Java基础加密组件

import java.security.MessageDigest;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * 基础加密组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public abstract class CoderUtil {
    public static final String KEY_SHA = "SHA";
    public static final String KEY_MD5 = "MD5";

    /**
     * MAC算法可选以下多种算法
     * 
     * <pre>
     * HmacMD5 
     * HmacSHA1 
     * HmacSHA256 
     * HmacSHA384 
     * HmacSHA512
     * </pre>
     */
    public static final String KEY_MAC = "HmacMD5";

    /**
     * BASE64解密
     * 
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptBASE64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    /**
     * BASE64加密
     * 
     * @param key
     * @return
     * @throws Exception
     */
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    /**
     * MD5加密
     * 
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptMD5(byte[] data) throws Exception {

        MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
        md5.update(data);

        return md5.digest();

    }

    /**
     * SHA加密
     * 
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptSHA(byte[] data) throws Exception {

        MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
        sha.update(data);

        return sha.digest();

    }

    /**
     * 初始化HMAC密钥
     * 
     * @return
     * @throws Exception
     */
    public static String initMacKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

        SecretKey secretKey = keyGenerator.generateKey();
        return encryptBASE64(secretKey.getEncoded());
    }

    /**
     * HMAC加密
     * 
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

        SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);

        return mac.doFinal(data);

    }

    public static void main(String[] args) throws Exception {
        String inputStr = "简单加密";
        System.err.println("原文:\n" + inputStr);

        byte[] inputData = inputStr.getBytes();
        String code = CoderUtil.encryptBASE64(inputData);

        System.err.println("BASE64加密后:\n" + code);

        byte[] output = CoderUtil.decryptBASE64(code);

        String outputStr = new String(output);

        System.err.println("BASE64解密后:\n" + outputStr);

    }
}
 
 
 
对我有用[0]丢个板砖[0]引用举报管理TOP 


zygege


等　级：

 #623楼 得分：0回复于：2010-05-07 20:01:31Java codepackage org.wxws.common.tools;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;


public class CommonComparator implements Serializable, Comparator {
    
    /*************** 属性名及类型MAP对 *************/
    private Map fnameType;
    
    /*********** 对应的排序方式 true=顺序 false=倒序  ************/
    private boolean order;
    
    public boolean isOrder() {
        return order;
    }

    public void setOrder(boolean order) {
        this.order = order;
    }

    public Map getFnameType() {
        return fnameType;
    }

    public void setFnameType(Map fnameType) {
        this.fnameType = fnameType;
    }

    /**
     * 定义排序规则 如果按照不止一个属性进行排序 这按照属性的顺序进行排序,类是sql order by 即只要比较出同位置的属性就停止
     */ 
    public int compare(Object obj1, Object obj2) { 
        // 没有属性，则不排序
        if(fnameType == null || fnameType.isEmpty()) { 
            return 2;// 不比较
        }
        
        Iterator iterator = fnameType.entrySet().iterator();
        
        while(iterator.hasNext()) {     
            Map.Entry entry = (Map.Entry) iterator.next();
            String name = (String) entry.getKey();
            String type = (String) entry.getValue();
             
            if(compareField(obj1,obj2,name,type,order)) { 
                // 如果obj1的属性值大于obj2的属性值，则返回正数
                return 1; 
            } else { 
                // 小于返回负数
                return -1; 
            }
        }
        
        return 0;
    }
    
    /**
     * 方法描述: 比较对象的属性名
     *
     * fei    2010-4-14
     * @param o1            比较对象1
     * @param o2            比较对象2
     * @param fieldName        比较属性名称
     * @param type            比较属性类型
     * @param order            比较顺序 true=顺序 false=倒序
     * @return
     */
    private static boolean compareField(Object o1,Object o2,String fieldName, String type, boolean order) { 
        try {
            
            
            Object value1 = getFieldValueByName(fieldName,o1); 
            Object value2 = getFieldValueByName(fieldName,o2);
            
            if ("String".equals(type)) {
                String value1Str = value1.toString();
                String value2Str = value2.toString();
                if (order) {//顺序
                    if (value1Str.compareTo(value2Str) > 0) {
                        return true;
                    }
                } else {//倒序
                    if (value1Str.compareTo(value2Str) < 0) {
                        return true;
                    }
                }
            } else if ("Integer".equals(type)) {
                int value1I = Integer.parseInt(value1.toString());
                int value2I = Integer.parseInt(value2.toString());
                if (order) {//顺序
                    if (value1I < value2I) {
                        return true;
                    }
                } else {//倒序
                    if (value1I > value2I) {
                        return true;
                    }
                }
            } else if ("Long".equals(type)) {
                long value1L = Long.parseLong(value1.toString());
                long value2L = Long.parseLong(value2.toString());
                if (order) {//顺序
                    if (value1L < value2L) {
                        return true;
                    }
                } else {//倒序
                    if (value1L > value2L) {
                        return true;
                    }
                }
            } else if ("Float".equals(type)) {
                float value1F = Float.parseFloat(value1.toString());
                float value2F = Float.parseFloat(value2.toString());
                if (order) {//顺序
                    if (value1F < value2F) {
                        return true;
                    }
                } else {//倒序
                    if (value1F > value2F) {
                        return true;
                    }
                }
            } else if ("Double".equals(type)) {
                double value1D = Double.parseDouble(value1.toString());
                double value2D = Double.parseDouble(value2.toString());
                if (order) {//顺序
                    if (value1D < value2D) {
                        return true;
                    }
                } else {//倒序
                    if (value1D > value2D) {
                        return true;
                    }
                }
            } else if ("Date".equals(type)) {
                Date value1D = (Date)value1;
                Date value2D = (Date)value2;
                if (order) {//顺序
                    if (value1D.before(value2D)) {
                        return true;
                    }
                } else {//倒序
                    if (value1D.after(value2D)) {
                        return true;
                    }
                }
            }
        } catch (Exception e) { 
            System.out.println("-----------------------------------------------------------------------------"); 
            System.out.println("---------对象的该属性不存在或者不允许在此安全级别上反射该属性，详情请查阅JAVA DOC--------"); 
            System.out.println("-----------------------------------------------------------------------------"); 
            e.printStackTrace(); 
        } 
        return false; 
    }
    
    /**
     * @param fieldName 属性名 obj 对象 
     * 反射获得该属性的值
     */ 
    private static Object getFieldValueByName(String fieldName,Object obj) { 
        try { 
            String Letter = fieldName.substring(0,1).toUpperCase(); 
            String methodStr = "get"+Letter+fieldName.substring(1);
            Method method = obj.getClass().getMethod(methodStr, new Class[]{}); 
        
            Object value = method.invoke(obj, new Object[]{}); 
            return value; 
        }catch(Exception e) { 
            System.out.println("------------------------------------------------------"); 
            System.out.println("---------该"+fieldName+"属性不存在----------------------"); 
            System.out.println("------------------------------------------------------"); 
            return null; 
        } 
    }
    
    public static void main(String[] args) {

//        List arrayDemo = new ArrayList(); 
//
//        Person p1 = new Person(); 
//        p1.setName("张三"); 
//        p1.setAge(20); 
//        p1.setSalary(2000); 
//
//        Person p2 = new Person(); 
//        p2.setName("李四"); 
//        p2.setAge(22); 
//        p2.setSalary(1800); 
//
//        Person p3 = new Person(); 
//        p3.setName("王五"); 
//        p3.setAge(25); 
//        p3.setSalary(1900); 
//
//        Person p4 = new Person(); 
//        p4.setName("赵六"); 
//        p4.setAge(25); 
//        p4.setSalary(3000); 
//
//        Person p5 = new Person(); 
//        p5.setName("刘七"); 
//        p5.setAge(30); 
//        p5.setSalary(2000); 
//
//        arrayDemo.add(p1); 
//        arrayDemo.add(p2); 
//        arrayDemo.add(p3); 
//        arrayDemo.add(p4); 
//        arrayDemo.add(p5);
//        
//        //        *********开始比较********// 
//        CommonComparator comparator = new CommonComparator(); 
//
//        System.out.println("------1.按照月薪和年龄从低到高比较---------");
//        Map map = new HashMap<String, String>();
//        map.put("salary", "Integer");
//        map.put("age", "Integer");
//        comparator.setFnameType(map); 
//        comparator.setOrder(false);//倒顺
//        Collections.sort(arrayDemo, comparator); 
//        for(int i=0;i<arrayDemo.size();i++) { 
//            Person person = (Person)arrayDemo.get(i); 
//            System.out.println("用户名："+person.getName()+" 年龄："+person.getAge()+" 月薪："+person.getSalary()); 
//        }
    }
}