PHP是用来做网站的 Java从不做网站

Jessica     本站原创     Java, PHP

read more

C#加密.Java解密(DES 返回非base64 可以url传递)

Jessica     Java     C#, DES, Java

工作需要 需要C#给一个字符串加密 然后通过url传递给Java Java进行解密.

网上这种例子好多 但是C#返回的都是base64..但是base64编码在URL中传递又不太合适.

所以我自己把算法修改了一下 已经测试可以使用..:)

为了和C#统一 所以我在Java中的向量直接用的是key 你也可以换一下 两者统一即可.

最后又打包下载.

C#代码

using System;  
using System.Security;  
using System.Security.Cryptography;  
using System.IO;  
using System.Text;  
using System.Threading;  
namespace DES  
{  
    /// <summary>  
    /// DES 加密  
    /// </summary>  
    public class DES  
    {  
        public DES()  
        {  
        }  
        //密钥  
        private const string sKey = "ABCDEFGH";  
 
        public static string Encrypt(string pToEncrypt)  
        {  
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())  
            {  
                byte[] inputByteArray = Encoding.UTF8.GetBytes(pToEncrypt);  
                des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);  
                des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);  
                System.IO.MemoryStream ms = new System.IO.MemoryStream();  
                using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))  
                {  
                    cs.Write(inputByteArray, 0, inputByteArray.Length);  
                    cs.FlushFinalBlock();  
                    cs.Close();  
                }  
                string str = HexStringFromByteArray(ms.ToArray());  
                ms.Close();  
                return str;  
            }  
        }  
        public static string HexStringFromByteArray(byte[] bytes)  
        {  
            string s = "";  
 
            foreach (byte b in bytes)  
            {  
                s += string.Format("{0:X2}", b);  
            }  
 
            return s;  
        }  
 
        public static void Main(string[] args)  
        {  
            //  
            // TODO: Add code to start application here 
 
            //  
 
            Console.WriteLine (DES.Encrypt("500200088"));  
        }  
 
    }  
} 

Java代码

import javax.crypto.Cipher;  
import javax.crypto.SecretKey;  
import javax.crypto.SecretKeyFactory;  
import javax.crypto.spec.DESKeySpec;  
import javax.crypto.spec.IvParameterSpec;  
 
public class DES {  
    /** 加密、解密key. */    
    private static final String PASSWORD_CRYPT_KEY = "ABCDEFGH";     
    
    /** 加密算法 */    
    private final static String ALGORITHM = "DES/CBC/PKCS5Padding";     
         
    /**     
     * 对数据进行DES加密.    
     * @param data 待进行DES加密的数据    
     * @return 返回经过DES加密后的数据    
     * @throws Exception    
     */    
    public final static String decrypt(String data) throws Exception {     
        return new String(decrypt(hex2byte(data.getBytes()),     
                PASSWORD_CRYPT_KEY.getBytes()));     
    }     
    
    /**     
     * 对用DES加密过的数据进行解密.    
     * @param data DES加密数据    
     * @return 返回解密后的数据    
     * @throws Exception    
     */    
    public final static String encrypt(String data) throws Exception  {     
        return byte2hex(encrypt(data.getBytes(), PASSWORD_CRYPT_KEY     
                .getBytes()));     
    }     
         
    /**     
     * 用指定的key对数据进行DES加密.    
     * @param data 待加密的数据    
     * @param key DES加密的key    
     * @return 返回DES加密后的数据    
     * @throws Exception    
     */    
    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {      
        // 从原始密匙数据创建DESKeySpec对象     
        DESKeySpec dks = new DESKeySpec(key);     
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成     
        // 一个SecretKey对象     
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");     
        SecretKey securekey = keyFactory.generateSecret(dks);  
        //向量  
        IvParameterSpec iv = new IvParameterSpec(key);  

        // Cipher对象实际完成加密操作     
        Cipher cipher = Cipher.getInstance(ALGORITHM);     
        // 用密匙初始化Cipher对象     
        cipher.init(Cipher.ENCRYPT_MODE, securekey, iv);     
        // 现在，获取数据并加密     
        // 正式执行加密操作     
        return cipher.doFinal(data);     
    }  
    
    /** *//**    
     * 用指定的key对数据进行DES解密.    
     * @param data 待解密的数据    
     * @param key DES解密的key    
    * @return 返回DES解密后的数据    
     * @throws Exception    
     */    
    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {     
        // 从原始密匙数据创建一个DESKeySpec对象     
        DESKeySpec dks = new DESKeySpec(key);     
        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成     
        // 一个SecretKey对象     
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");     
        SecretKey securekey = keyFactory.generateSecret(dks);  
        //向量  
        IvParameterSpec iv = new IvParameterSpec(key);  
        // Cipher对象实际完成解密操作     
        Cipher cipher = Cipher.getInstance(ALGORITHM);     
        // 用密匙初始化Cipher对象     
        cipher.init(Cipher.DECRYPT_MODE, securekey, iv);     
        // 现在，获取数据并解密     
        // 正式执行解密操作     
        return cipher.doFinal(data);     
    }  
      
    public static byte[] hex2byte(byte[] b) {     
        if ((b.length % 2) != 0)     
            throw new IllegalArgumentException("长度不是偶数");     
        byte[] b2 = new byte[b.length / 2];     
        for (int n = 0; n < b.length; n += 2) {     
            String item = new String(b, n, 2);     
            b2[n / 2] = (byte) Integer.parseInt(item, 16);     
        }     
        return b2;     
    }     
    

    public static String byte2hex(byte[] b) {     
        String hs = "";     
        String stmp = "";     
    
        for (int n = 0; n < b.length; n++) {     
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));     
            if (stmp.length() == 1)     
                hs = hs + "0" + stmp;     
            else    
                hs = hs + stmp;     
        }     
        return hs.toUpperCase();     
    }  
}  

read more

Java中double类型计算不精确的解决办法(BigDecimal)

Jessica     Java     BigDecimal, Java

首先我们先用一般的情况进行下double类型的计算。

System.out.println(1.0-0.41); 

得到的值是0.5900000000000001，这个是不精确的。
为了解决这个问题，Java为我们提供了一个叫BigDecimal的类。
所以我们用下面的方法计算。

BigDecimal bd1 = new BigDecimal(1.0);  
BigDecimal bd2 = new BigDecimal(0.41);  
System.out.println(  
  bd1.subtract(bd2).doubleValue()); 

我们又看到，这个值和上面得到的是一样的。也是不精确的，也许这就是Java的一个BUG吧。
但是我们换一种另外的方法解决。注意看注释。

read more