`
nannan408
  • 浏览: 1783671 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

架构师之sha加密解密--------------------------私钥

 
阅读更多
１．前言．
　　如题．
２．代码． 
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * reference apache commons <a
 * href="http://commons.apache.org/codec/">http://commons.apache.org/codec/</a>
 *
 * support MD2/MD5/SHA/SHA256/SHA384/SHA512
 * @author Aub
 *
 */
public class DigestUtils {

 /**
  * 根据给定摘要算法创建一个消息摘要实例
  *
  * @param algorithm
  *            摘要算法名
  * @return 消息摘要实例
  * @see MessageDigest#getInstance(String)
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 static MessageDigest getDigest(String algorithm) {
  try {
   return MessageDigest.getInstance(algorithm);
  } catch (NoSuchAlgorithmException e) {
   throw new RuntimeException(e.getMessage());
  }
 }

 /**
  * 获取 MD5 消息摘要实例
  *
  * @return MD5 消息摘要实例
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 private static MessageDigest getMd5Digest() {
  return getDigest("MD5");
 }

 /**
  * 获取 SHA-1 消息摘要实例
  *
  * @return SHA-1 消息摘要实例
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 private static MessageDigest getShaDigest() {
  return getDigest("SHA");
 }

 /**
  * 获取 SHA-256 消息摘要实例
  *
  * @return SHA-256 消息摘要实例
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 private static MessageDigest getSha256Digest() {
  return getDigest("SHA-256");
 }

 /**
  * 获取 SHA-384 消息摘要实例
  *
  * @return SHA-384 消息摘要实例
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 private static MessageDigest getSha384Digest() {
  return getDigest("SHA-384");
 }

 /**
  * 获取 SHA-512 消息摘要实例
  *
  * @return SHA-512 消息摘要实例
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 private static MessageDigest getSha512Digest() {
  return getDigest("SHA-512");
 }

 /**
  * 使用MD5消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeMD5(byte[] data) {
  return getMd5Digest().digest(data);
 }

 /**
  * 使用MD5消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return 消息摘要（长度为32的十六进制字符串）
  */
 public static String encodeMD5Hex(byte[] data) {
  return Hex.encodeHexStr(encodeMD5(data));
 }

 /**
  * 使用SHA-1消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-1消息摘要（长度为20的字节数组）
  */
 public static byte[] encodeSHA(byte[] data) {
  return getShaDigest().digest(data);
 }

 /**
  * 使用SHA-1消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-1消息摘要（长度为40的十六进制字符串）
  */
 public static String encodeSHAHex(byte[] data) {
  return Hex.encodeHexStr(getShaDigest().digest(data));
 }

 /**
  * 使用SHA-256消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-256消息摘要（长度为32的字节数组）
  */
 public static byte[] encodeSHA256(byte[] data) {
  return getSha256Digest().digest(data);
 }

 /**
  * 使用SHA-256消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-256消息摘要（长度为64的十六进制字符串）
  */
 public static String encodeSHA256Hex(byte[] data) {
  return Hex.encodeHexStr(encodeSHA256(data));
 }

 /**
  * 使用SHA-384消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-384消息摘要（长度为43的字节数组）
  */
 public static byte[] encodeSHA384(byte[] data) {
  return getSha384Digest().digest(data);
 }

 /**
  * 使用SHA-384消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-384消息摘要（长度为86的十六进制字符串）
  */
 public static String encodeSHA384Hex(byte[] data) {
  return Hex.encodeHexStr(encodeSHA384(data));
 }

 /**
  * 使用SHA-512消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-512消息摘要（长度为64的字节数组）
  */
 public static byte[] encodeSHA512(byte[] data) {
  return getSha512Digest().digest(data);
 }

 /**
  * 使用SHA-512消息摘要算法计算消息摘要
  *
  * @param data
  *            做消息摘要的数据
  * @return SHA-512消息摘要（长度为128的十六进制字符串）
  */
 public static String encodeSHA512Hex(byte[] data) {
  return Hex.encodeHexStr(encodeSHA512(data));
 }

}

 

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;

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

/**
 * Hmac<br/>
 * algorithm HmacMD5/HmacSHA/HmacSHA256/HmacSHA384/HmacSHA512
 * @author Aub
 */
public class Hmac {
 
 /**
  * 根据给定密钥生成算法创建密钥
  *
  * @param algorithm
  *            密钥算法
  * @return 密钥
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 private static byte[] getHmacKey(String algorithm){
  //初始化KeyGenerator
  KeyGenerator keyGenerator = null;
  try {
   keyGenerator = KeyGenerator.getInstance(algorithm);
  } catch (NoSuchAlgorithmException e) {
   throw new RuntimeException(e.getMessage());
  }
  //产生密钥
  SecretKey secretKey = keyGenerator.generateKey();
  //获得密钥
  return secretKey.getEncoded();
 }
 
 /**
  * 获取 HmaMD5的密钥
  *
  * @return  HmaMD5的密钥
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 public static byte[] getHmaMD5key(){
  return getHmacKey("HmacMD5");
 }
 
 /**
  * 获取 HmaSHA的密钥
  *
  * @return  HmaSHA的密钥
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 public static byte[] getHmaSHAkey(){
  return getHmacKey("HmacSHA1");
 }
 
 /**
  * 获取 HmaSHA256的密钥
  *
  * @return  HmaSHA256的密钥
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 public static byte[] getHmaSHA256key(){
  return getHmacKey("HmacSHA256");
 }
 
 /**
  * 获取 HmaSHA384的密钥
  *
  * @return  HmaSHA384的密钥
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 public static byte[] getHmaSHA384key(){
  return getHmacKey("HmacSHA384");
 }
 
 /**
  * 获取 HmaSHA512的密钥
  *
  * @return  HmaSHA384的密钥
  * @throws RuntimeException
  *             当 {@link java.security.NoSuchAlgorithmException} 发生时
  */
 public static byte[] getHmaSHA512key(){
  return getHmacKey("HmacSHA512");
 }
 
 /**
  * 转换密钥
  *
  * @param key 二进制密钥
  * @param algorithm 密钥算法
  * @return 密钥
  */
 private static Key toKey(byte[] key,String algorithm){
  //生成密钥
  return new SecretKeySpec(key, algorithm);
 }
 
 /**
  * 使用HmacMD5消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacMD5(byte[] data, Key key){
  Mac mac = null;
  try {
   mac = Mac.getInstance("HmacMD5");
   mac.init(key);
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
   return new byte[0];
  }catch (InvalidKeyException e) {
   e.printStackTrace();
   return new byte[0];
  }
  return mac.doFinal(data);
 }
 
 /**
  * 使用HmacMD5消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacMD5(byte[] data, byte[] key){
  Key k = toKey(key, "HmacMD5");
  return encodeHmacMD5(data, k);
 }
 
 /**
  * 使用HmacSHA消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA(byte[] data, Key key){
  Mac mac = null;
  try {
   mac = Mac.getInstance("HmacSHA1");
   mac.init(key);
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
   return new byte[0];
  }catch (InvalidKeyException e) {
   e.printStackTrace();
   return new byte[0];
  }
  return mac.doFinal(data);
 }
 
 /**
  * 使用HmacSHA消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA(byte[] data, byte[] key){
  Key k = toKey(key, "HmacSHA1");
  return encodeHmacSHA(data, k);
 }
 
 /**
  * 使用HmacSHA256消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA256(byte[] data, Key key){
  Mac mac = null;
  try {
   mac = Mac.getInstance("HmacSHA256");
   mac.init(key);
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
   return new byte[0];
  }catch (InvalidKeyException e) {
   e.printStackTrace();
   return new byte[0];
  }
  return mac.doFinal(data);
 }
 
 /**
  * 使用HmacSHA256消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA256(byte[] data, byte[] key){
  Key k = toKey(key, "HmacSHA256");
  return encodeHmacSHA256(data, k);
 }
 
 
 /**
  * 使用HmacSHA384消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA384(byte[] data, Key key){
  Mac mac = null;
  try {
   mac = Mac.getInstance("HmacSHA384");
   mac.init(key);
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
   return new byte[0];
  }catch (InvalidKeyException e) {
   e.printStackTrace();
   return new byte[0];
  }
  return mac.doFinal(data);
 }
 
 /**
  * 使用HmacSHA384消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA384(byte[] data, byte[] key){
  Key k = toKey(key, "HmacSHA384");
  return encodeHmacSHA384(data, k);
 }
 
 
 
 /**
  * 使用HmacSHA512消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA512(byte[] data, Key key){
  Mac mac = null;
  try {
   mac = Mac.getInstance("HmacSHA512");
   mac.init(key);
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
   return new byte[0];
  }catch (InvalidKeyException e) {
   e.printStackTrace();
   return new byte[0];
  }
  return mac.doFinal(data);
 }
 
 /**
  * 使用HmacSHA512消息摘要算法计算消息摘要
  *
  * @param data 做消息摘要的数据
  * @param key 密钥
  * @return 消息摘要（长度为16的字节数组）
  */
 public static byte[] encodeHmacSHA512(byte[] data, byte[] key){
  Key k = toKey(key, "HmacSHA512");
  return encodeHmacSHA512(data, k);
 }
 
 
 private static String  showByteArray(byte[] data){
  if(null == data){
   return null;
  }
  StringBuilder sb = new StringBuilder("{");
  for(byte b:data){
   sb.append(b).append(",");
  }
  sb.deleteCharAt(sb.length()-1);
  sb.append("}");
  return sb.toString();
 }
 
 public static void main(String[] args) {
//  byte[] key = getHmaMD5key();
//  byte[] key = getHmaSHAkey();
//  byte[] key = getHmaSHA256key();
//  byte[] key = getHmaSHA384key();
  byte[] key = getHmaSHA512key();
  
  
  System.out.println("加密密钥: byte[]:"+showByteArray(key).length());
  
  String data = "Mac数据";
  System.out.println("加密前数据: string:"+data);
  System.out.println("加密前数据: byte[]:"+showByteArray(data.getBytes()));
  System.out.println();
//  byte[] encodeData = encodeHmacMD5(data.getBytes(), key);
//  byte[] encodeData = encodeHmacSHA(data.getBytes(), key);
//  byte[] encodeData = encodeHmacSHA256(data.getBytes(), key);
//  byte[] encodeData = encodeHmacSHA384(data.getBytes(), key);
  byte[] encodeData = encodeHmacSHA512(data.getBytes(), key);
  System.out.println("加密后数据: byte[]:"+showByteArray(encodeData).length());
  System.out.println("加密后数据: byte[]:"+encodeData.length);
  System.out.println("加密后数据: hexStr:"+Hex.encodeHexStr(encodeData));
  System.out.println();
 }
}

 

 

/**
 * reference apache commons <a
 * href="http://commons.apache.org/codec/">http://commons.apache.org/codec/</a>
 *
 * @author Aub
 *
 */
public class Hex {

 /**
  * 用于建立十六进制字符的输出的小写字符数组
  */
 private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5',
   '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

 /**
  * 用于建立十六进制字符的输出的大写字符数组
  */
 private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5',
   '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

 /**
  * 将字节数组转换为十六进制字符数组
  *
  * @param data
  *            byte[]
  * @return 十六进制char[]
  */
 public static char[] encodeHex(byte[] data) {
  return encodeHex(data, true);
 }

 /**
  * 将字节数组转换为十六进制字符数组
  *
  * @param data
  *            byte[]
  * @param toLowerCase
  *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  * @return 十六进制char[]
  */
 public static char[] encodeHex(byte[] data, boolean toLowerCase) {
  return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
 }

 /**
  * 将字节数组转换为十六进制字符数组
  *
  * @param data
  *            byte[]
  * @param toDigits
  *            用于控制输出的char[]
  * @return 十六进制char[]
  */
 protected static char[] encodeHex(byte[] data, char[] toDigits) {
  int l = data.length;
  char[] out = new char[l << 1];
  // two characters form the hex value.
  for (int i = 0, j = 0; i < l; i++) {
   out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
   out[j++] = toDigits[0x0F & data[i]];
  }
  return out;
 }

 /**
  * 将字节数组转换为十六进制字符串
  *
  * @param data
  *            byte[]
  * @return 十六进制String
  */
 public static String encodeHexStr(byte[] data) {
  return encodeHexStr(data, true);
 }

 /**
  * 将字节数组转换为十六进制字符串
  *
  * @param data
  *            byte[]
  * @param toLowerCase
  *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  * @return 十六进制String
  */
 public static String encodeHexStr(byte[] data, boolean toLowerCase) {
  return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
 }

 /**
  * 将字节数组转换为十六进制字符串
  *
  * @param data
  *            byte[]
  * @param toDigits
  *            用于控制输出的char[]
  * @return 十六进制String
  */
 protected static String encodeHexStr(byte[] data, char[] toDigits) {
  return new String(encodeHex(data, toDigits));
 }

 /**
  * 将十六进制字符数组转换为字节数组
  *
  * @param data
  *            十六进制char[]
  * @return byte[]
  * @throws RuntimeException
  *             如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
  */
 public static byte[] decodeHex(char[] data) {

  int len = data.length;

  if ((len & 0x01) != 0) {
   throw new RuntimeException("Odd number of characters.");
  }

  byte[] out = new byte[len >> 1];

  // two characters form the hex value.
  for (int i = 0, j = 0; j < len; i++) {
   int f = toDigit(data[j], j) << 4;
   j++;
   f = f | toDigit(data[j], j);
   j++;
   out[i] = (byte) (f & 0xFF);
  }

  return out;
 }

 /**
  * 将十六进制字符转换成一个整数
  *
  * @param ch
  *            十六进制char
  * @param index
  *            十六进制字符在字符数组中的位置
  * @return 一个整数
  * @throws RuntimeException
  *             当ch不是一个合法的十六进制字符时，抛出运行时异常
  */
 protected static int toDigit(char ch, int index) {
  int digit = Character.digit(ch, 16);
  if (digit == -1) {
   throw new RuntimeException("Illegal hexadecimal character " + ch
     + " at index " + index);
  }
  return digit;
 }

 public static void main(String[] args) {
  String srcStr = "待转换字符串";
  String encodeStr = encodeHexStr(srcStr.getBytes());
  String decodeStr = new String(decodeHex(encodeStr.toCharArray()));
  System.out.println("转换前：" + srcStr);
  System.out.println("转换后：" + encodeStr);
  System.out.println("还原后：" + decodeStr);
 }

}


转自：http://blog.163.com/yxhui_cool/blog/static/770197702012291433339/
分享到：
| 关于稳增长的一些不成熟的建议(二)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    20210328-RISC-V_K_扩展概述文档1

    K扩展中的AES加速指令（Zkne、Zknd）针对AES的加密和解密过程进行了优化。在AES的加密过程中，数据在4x4字节矩阵上进行操作，通过AddRoundKey、SubBytes、ShiftRows和MixColumns四个步骤完成。K扩展为RISC-V提供了...

    Java加密与解密的艺术配书源代码

    系统架构师将通过本书领悟构建安全企业级应用的要义；其他领域的安全工作者也能通过本书一窥加密与解密技术的精髓。 第一部分基础篇 第1章企业应用安全2 1.1 我们身边的安全问题2 1.2 拿什么来拯救你，我的应用3 1.3...

    通向架构师的道路（第十四天）Axis2 Web Service安全之rampart.docx

    通向架构师的道路（第十四天）Axis2 Web Service安全之rampart 本篇文章主要讲述了Axis2 Web Service安全之rampart的知识点，包括加密保护Web Service传输、基本概念、对称加密、非对称加密、数字签名等内容。 一...

    800-21 Guideline for implementing crytography in the federal government

    本指南的目标读者包括但不限于联邦政府的信息安全专业人员、系统管理员、网络安全架构师以及其他负责设计、实施或维护信息安全系统的相关人员。 **1.3 范围** 该指南覆盖了密码学的基本原理及其在联邦政府中的应用...

    Web接口示例文档.doc

    - **阅读对象**：明确了文档的受众，通常包括开发人员、测试人员、系统架构师等需要理解和实现接口的人员。 - **业务术语**：列出文档中涉及的专业词汇和业务概念，帮助读者理解文档内容。 - **接口地址**：提供...

    电信设备-一种集群节点间密码信息处理方法及系统.zip

    这份文档的详细阅读将为理解集群节点间的密码信息处理提供深入的见解，对于从事电信设备设计、网络架构师或者信息安全专业人员来说，具有很高的参考价值。通过学习和实施这些方法，可以显著提升电信网络的安全水平，...

    java开源包1

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包10

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    Applied Cryptography PART1

    这本书详细介绍了密码学在实际应用中的各个方面，旨在为软件开发者、系统架构师以及安全专业人员提供实用的加密技术指南。 首先，我们要了解密码学的基本概念。密码学是一门研究信息安全的科学，它涵盖了加密、解密...

    java开源包11

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包2

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包3

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包6

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包5

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包4

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

    java开源包8

    用来计算 MD5、SHA 哈希算法的 Java 类库，支持 "MD5", "SHA", "SHA-1", "SHA-256", "SHA-384", "SHA-512". 高性能RPC框架 nfs-rpc nfs-rpc是一个集成了各种知名通信框架的高性能RPC框架，目前其最好的性能为在采用...

Magicbox
Global site tag (gtag.js) - Google Analytics