Java加密技术（七）

最新推荐文章于 2024-09-08 12:41:07 发布
最新推荐文章于 2024-09-08 12:41:07 发布
阅读量484 收藏
点赞数
分类专栏： JAVA之加密解密 文章标签： 加密 java exception 解密 byte string

关键字: ecc, 椭圆曲线加密, 非对称加密

ECC
ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。
    当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的资料，无论是官方还是非官方的解释，最终只有一种答案——ECC算法在jdk1.5后加入支持，目前仅仅只能完成密钥的生成与解析。
    尽管如此，我照旧提供相应的Java实现代码，以供大家参考。

通过java代码实现如下： Coder类见 Java加密技术（一）
Java代码 复制代码
  1. import java.math.BigInteger;   
  2. import java.security.Key;   
  3. import java.security.KeyFactory;   
  4. import java.security.interfaces.ECPrivateKey;   
  5. import java.security.interfaces.ECPublicKey;   
  6. import java.security.spec.ECFieldF2m;   
  7. import java.security.spec.ECParameterSpec;   
  8. import java.security.spec.ECPoint;   
  9. import java.security.spec.ECPrivateKeySpec;   
  10. import java.security.spec.ECPublicKeySpec;   
  11. import java.security.spec.EllipticCurve;   
  12. import java.security.spec.PKCS8EncodedKeySpec;   
  13. import java.security.spec.X509EncodedKeySpec;   
  14. import java.util.HashMap;   
  15. import java.util.Map;   
  16.   
  17. import javax.crypto.Cipher;   
  18. import javax.crypto.NullCipher;   
  19.   
  20. import sun.security.ec.ECKeyFactory;   
  21. import sun.security.ec.ECPrivateKeyImpl;   
  22. import sun.security.ec.ECPublicKeyImpl;   
  23.   
  24. /**  
  25.  * ECC安全编码组件  
  26.  *   
  27.  * @author 梁栋  
  28.  * @version 1.0  
  29.  * @since 1.0  
  30.  */  
  31. public abstract class ECCCoder extends Coder {   
  32.   
  33.     public static final String ALGORITHM = "EC";   
  34.     private static final String PUBLIC_KEY = "ECCPublicKey";   
  35.     private static final String PRIVATE_KEY = "ECCPrivateKey";   
  36.   
  37.     /**  
  38.      * 解密<br>  
  39.      * 用私钥解密  
  40.      *   
  41.      * @param data  
  42.      * @param key  
  43.      * @return  
  44.      * @throws Exception  
  45.      */  
  46.     public static byte[] decrypt(byte[] data, String key) throws Exception {   
  47.         // 对密钥解密   
  48.         byte[] keyBytes = decryptBASE64(key);   
  49.   
  50.         // 取得私钥   
  51.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
  52.         KeyFactory keyFactory = ECKeyFactory.INSTANCE;   
  53.   
  54.         ECPrivateKey priKey = (ECPrivateKey) keyFactory   
  55.                 .generatePrivate(pkcs8KeySpec);   
  56.   
  57.         ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),   
  58.                 priKey.getParams());   
  59.   
  60.         // 对数据解密   
  61.         // TODO Chipher不支持EC算法 未能实现   
  62.         Cipher cipher = new NullCipher();   
  63.         // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());   
  64.         cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());   
  65.   
  66.         return cipher.doFinal(data);   
  67.     }   
  68.   
  69.     /**  
  70.      * 加密<br>  
  71.      * 用公钥加密  
  72.      *   
  73.      * @param data  
  74.      * @param privateKey  
  75.      * @return  
  76.      * @throws Exception  
  77.      */  
  78.     public static byte[] encrypt(byte[] data, String privateKey)   
  79.             throws Exception {   
  80.         // 对公钥解密   
  81.         byte[] keyBytes = decryptBASE64(privateKey);   
  82.   
  83.         // 取得公钥   
  84.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
  85.         KeyFactory keyFactory = ECKeyFactory.INSTANCE;   
  86.   
  87.         ECPublicKey pubKey = (ECPublicKey) keyFactory   
  88.                 .generatePublic(x509KeySpec);   
  89.   
  90.         ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),   
  91.                 pubKey.getParams());   
  92.   
  93.         // 对数据加密   
  94.         // TODO Chipher不支持EC算法 未能实现   
  95.         Cipher cipher = new NullCipher();   
  96.         // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());   
  97.         cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());   
  98.   
  99.         return cipher.doFinal(data);   
  100.     }   
  101.   
  102.     /**  
  103.      * 取得私钥  
  104.      *   
  105.      * @param keyMap  
  106.      * @return  
  107.      * @throws Exception  
  108.      */  
  109.     public static String getPrivateKey(Map<String, Object> keyMap)   
  110.             throws Exception {   
  111.         Key key = (Key) keyMap.get(PRIVATE_KEY);   
  112.   
  113.         return encryptBASE64(key.getEncoded());   
  114.     }   
  115.   
  116.     /**  
  117.      * 取得公钥  
  118.      *   
  119.      * @param keyMap  
  120.      * @return  
  121.      * @throws Exception  
  122.      */  
  123.     public static String getPublicKey(Map<String, Object> keyMap)   
  124.             throws Exception {   
  125.         Key key = (Key) keyMap.get(PUBLIC_KEY);   
  126.   
  127.         return encryptBASE64(key.getEncoded());   
  128.     }   
  129.   
  130.     /**  
  131.      * 初始化密钥  
  132.      *   
  133.      * @return  
  134.      * @throws Exception  
  135.      */  
  136.     public static Map<String, Object> initKey() throws Exception {   
  137.         BigInteger x1 = new BigInteger(   
  138.                 "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);   
  139.         BigInteger x2 = new BigInteger(   
  140.                 "289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);   
  141.   
  142.         ECPoint g = new ECPoint(x1, x2);   
  143.   
  144.         // the order of generator   
  145.         BigInteger n = new BigInteger(   
  146.                 "5846006549323611672814741753598448348329118574063", 10);   
  147.         // the cofactor   
  148.         int h = 2;   
  149.         int m = 163;   
  150.         int[] ks = { 7, 6, 3 };   
  151.         ECFieldF2m ecField = new ECFieldF2m(m, ks);   
  152.         // y^2+xy=x^3+x^2+1   
  153.         BigInteger a = new BigInteger("1", 2);   
  154.         BigInteger b = new BigInteger("1", 2);   
  155.   
  156.         EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);   
  157.   
  158.         ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,   
  159.                 n, h);   
  160.         // 公钥   
  161.         ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);   
  162.   
  163.         BigInteger s = new BigInteger(   
  164.                 "1234006549323611672814741753598448348329118574063", 10);   
  165.         // 私钥   
  166.         ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);   
  167.   
  168.         Map<String, Object> keyMap = new HashMap<String, Object>(2);   
  169.   
  170.         keyMap.put(PUBLIC_KEY, publicKey);   
  171.         keyMap.put(PRIVATE_KEY, privateKey);   
  172.   
  173.         return keyMap;   
  174.     }   
  175.   
  176. }  
import java.math.BigInteger;
import java.security.Key;
import java.security.KeyFactory;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECFieldF2m;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.ECPrivateKeySpec;
import java.security.spec.ECPublicKeySpec;
import java.security.spec.EllipticCurve;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;
import javax.crypto.NullCipher;

import sun.security.ec.ECKeyFactory;
import sun.security.ec.ECPrivateKeyImpl;
import sun.security.ec.ECPublicKeyImpl;

/**
 * ECC安全编码组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public abstract class ECCCoder extends Coder {

	public static final String ALGORITHM = "EC";
	private static final String PUBLIC_KEY = "ECCPublicKey";
	private static final String PRIVATE_KEY = "ECCPrivateKey";

	/**
	 * 解密<br>
	 * 用私钥解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decrypt(byte[] data, String key) throws Exception {
		// 对密钥解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = ECKeyFactory.INSTANCE;

		ECPrivateKey priKey = (ECPrivateKey) keyFactory
				.generatePrivate(pkcs8KeySpec);

		ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),
				priKey.getParams());

		// 对数据解密
		// TODO Chipher不支持EC算法 未能实现
		Cipher cipher = new NullCipher();
		// Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
		cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());

		return cipher.doFinal(data);
	}

	/**
	 * 加密<br>
	 * 用公钥加密
	 * 
	 * @param data
	 * @param privateKey
	 * @return
	 * @throws Exception
	 */
	public static byte[] encrypt(byte[] data, String privateKey)
			throws Exception {
		// 对公钥解密
		byte[] keyBytes = decryptBASE64(privateKey);

		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = ECKeyFactory.INSTANCE;

		ECPublicKey pubKey = (ECPublicKey) keyFactory
				.generatePublic(x509KeySpec);

		ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),
				pubKey.getParams());

		// 对数据加密
		// TODO Chipher不支持EC算法 未能实现
		Cipher cipher = new NullCipher();
		// Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
		cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());

		return cipher.doFinal(data);
	}

	/**
	 * 取得私钥
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PRIVATE_KEY);

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 取得公钥
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPublicKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PUBLIC_KEY);

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 初始化密钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		BigInteger x1 = new BigInteger(
				"2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);
		BigInteger x2 = new BigInteger(
				"289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);

		ECPoint g = new ECPoint(x1, x2);

		// the order of generator
		BigInteger n = new BigInteger(
				"5846006549323611672814741753598448348329118574063", 10);
		// the cofactor
		int h = 2;
		int m = 163;
		int[] ks = { 7, 6, 3 };
		ECFieldF2m ecField = new ECFieldF2m(m, ks);
		// y^2+xy=x^3+x^2+1
		BigInteger a = new BigInteger("1", 2);
		BigInteger b = new BigInteger("1", 2);

		EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);

		ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,
				n, h);
		// 公钥
		ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);

		BigInteger s = new BigInteger(
				"1234006549323611672814741753598448348329118574063", 10);
		// 私钥
		ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);

		Map<String, Object> keyMap = new HashMap<String, Object>(2);

		keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put(PRIVATE_KEY, privateKey);

		return keyMap;
	}

}


    请注意上述代码中的 TODO内容，再次提醒注意， Chipher不支持EC算法 ，以上代码仅供参考。 Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey均不支持EC算法。为了确保程序能够正常执行，我们使用了NullCipher类，验证程序。

照旧提供一个测试类：
Java代码 复制代码
  1.   
  2. import static org.junit.Assert.*;   
  3.   
  4. import java.math.BigInteger;   
  5. import java.security.spec.ECFieldF2m;   
  6. import java.security.spec.ECParameterSpec;   
  7. import java.security.spec.ECPoint;   
  8. import java.security.spec.ECPrivateKeySpec;   
  9. import java.security.spec.ECPublicKeySpec;   
  10. import java.security.spec.EllipticCurve;   
  11. import java.util.Map;   
  12.   
  13. import org.junit.Test;   
  14.   
  15. /**  
  16.  *   
  17.  * @author 梁栋  
  18.  * @version 1.0  
  19.  * @since 1.0  
  20.  */  
  21. public class ECCCoderTest {   
  22.   
  23.     @Test  
  24.     public void test() throws Exception {   
  25.         String inputStr = "abc";   
  26.         byte[] data = inputStr.getBytes();   
  27.   
  28.         Map<String, Object> keyMap = ECCCoder.initKey();   
  29.   
  30.         String publicKey = ECCCoder.getPublicKey(keyMap);   
  31.         String privateKey = ECCCoder.getPrivateKey(keyMap);   
  32.         System.err.println("公钥: /n" + publicKey);   
  33.         System.err.println("私钥： /n" + privateKey);   
  34.   
  35.         byte[] encodedData = ECCCoder.encrypt(data, publicKey);   
  36.   
  37.         byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);   
  38.   
  39.         String outputStr = new String(decodedData);   
  40.         System.err.println("加密前: " + inputStr + "/n/r" + "解密后: " + outputStr);   
  41.         assertEquals(inputStr, outputStr);   
  42.     }   
  43. }  
import static org.junit.Assert.*;

import java.math.BigInteger;
import java.security.spec.ECFieldF2m;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.ECPrivateKeySpec;
import java.security.spec.ECPublicKeySpec;
import java.security.spec.EllipticCurve;
import java.util.Map;

import org.junit.Test;

/**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public class ECCCoderTest {

	@Test
	public void test() throws Exception {
		String inputStr = "abc";
		byte[] data = inputStr.getBytes();

		Map<String, Object> keyMap = ECCCoder.initKey();

		String publicKey = ECCCoder.getPublicKey(keyMap);
		String privateKey = ECCCoder.getPrivateKey(keyMap);
		System.err.println("公钥: /n" + publicKey);
		System.err.println("私钥： /n" + privateKey);

		byte[] encodedData = ECCCoder.encrypt(data, publicKey);

		byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);

		String outputStr = new String(decodedData);
		System.err.println("加密前: " + inputStr + "/n/r" + "解密后: " + outputStr);
		assertEquals(inputStr, outputStr);
	}
}


控制台输出：
Console代码 复制代码
  1. 公钥:    
  2. MEAwEAYHKoZIzj0CAQYFK4EEAAEDLAAEAv4TwFN7vBGsqgfXk95ObV5clO7oAokHD7BdOP9YMh8u   
  3. gAU21TjM2qPZ   
  4.   
  5. 私钥：    
  6. MDICAQAwEAYHKoZIzj0CAQYFK4EEAAEEGzAZAgEBBBTYJsR3BN7TFw7JHcAHFkwNmfil7w==   
  7.   
  8. 加密前: abc   
  9.   
  10. 解密后: abc  


相关链接：
Java加密技术（一）
Java加密技术（二）
Java加密技术（三）
Java加密技术（四）
Java加密技术（五）
Java加密技术（六）
Java加密技术（七）
Java加密技术（八）
Java加密技术（九）
Java加密技术（十）
yzhjisji
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java加密技术
08-31
Java加密技术是Java编程语言中用于保障数据安全的一系列加密方法和技术，它包括了单向加密算法、对称加密算法、非对称加密算法以及加密算法的高级应用如数字签名和数字证书等。本文将详细介绍这些加密技术，并结合...
centos6.5 openjdk https/ssl兼容性错误ECKeyPairGenerator.generateKeyPair
Zeal Vampire真诚的吸血鬼
09-08 4860
阿里云centos6.5下使用新版openjdk7(OpenJDK 64-Bit Server VM (build 24.85-b03, mixed mode)) 会碰到一个比较无奈的问题, trust all https get请求在本地oracle jdk 或低些版本的openjdk都没问题,  放到阿里云就可能会报一下错, 本人案例是在微信OAUTH交换采访令牌环时报错. Caused
极光java sdk_极光使用服务端使用java sdk 出现异常 日志如下
weixin_42138545的博客
02-16 654
服务器已经开启了443端口 ，并且开通了ip 白名单， 但是 使用java jpush sdk 报错```cn.jiguang.common.resp.APIConnectionException: Connection IO error.Can not connect to JPush Server. Please ensure your internet connection is o...
java.security.key_java.security.KeyException异常解决
weixin_39638647的博客
03-07 700
Caused by: java.security.ProviderException: java.security.KeyException at sun.security.ec.ECKeyPairGenerator.generateKeyPair(ECKeyPairGenerator.java:146) at java.security.KeyPairGenerator$Delega...
Java创建EC密钥对并使用其进行加解密&签名验签
振宇要低调
12-24 6551
以下代码示例中 1）先使用java.security包生成EC密钥对（包括R1、K1） 2）之后将该密钥对转换为字符串格式（转换为字符串之后就可以存储到数据库中了） 3）将字符串类型的密钥对数据，反转回密钥对的对象（模拟从数据库取出并转换为对象） 4）使用密钥对中的私钥，对某个数据进行签名 5）使用密钥对中的公钥，对签名后的数据进行验签 6）使用密钥对中的公钥，对数据进行加密 7）使用密钥对中的私钥，对数据进行解密 main函数中包含了整个流程，废话不多说，上代码 自定义的一个密钥对类
Java加密技术
08-23
Java加密技术
JAVA加密技术.docx
11-20
在Java编程中，加密技术是确保信息安全的关键组成部分。本文将探讨几种常见的加密算法，包括单向加密和对称及非对称加密算法。首先，我们来看基础的单向加密算法，如BASE64、MD5、SHA和HMAC。 **BASE64** 是一种...
各种Java加密算法
number_chc的专栏
09-01 9406
所有分类 > 开发语言与工具 > Java开发 各种Java加密算法 您的评价:           如基本的单向加密算法：  BASE64 严格地说，属于编码格式，而非加密算法 MD5(Message Digest algorithm 5，信息摘要算法) SHA(Secure Hash Algorithm，安全散列算法
非对称算法 ECC ：java 加解密实现
xiaoliuliu2050的专栏
07-23 7839
ECC  ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。      当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的资料，无论是官方还是非...
谈谈Java加密技术（七）
站在搜素引擎上的巨人
06-12 3346
ECC     ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。     当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的资料，无论是官
java ECC 加密 解密算法
照母山挖洋芋
12-18 8513
公司最近需要使用非对称加密算法进行数据加密，本来打算采用RSA的，但是CTO强制使用ECC加密算法；没办法，硬着头皮整吧！ 网上的千篇一律，写法都差不多，但是有一个问题，公钥和私钥永远不会发生变法，这就比较尴尬了，而且数学学的又不是特比好，真的是很尴尬。 不过后面还是搞出来了，这里直接上代码吧！ ECC定义的常量，方便调用 package com.ktnw.utils.ecc; pub...
spring事务详细讲解-深入浅出
小电玩
09-08 314
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1159
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：值传递和址传递
最新发布
weixin_53755148的博客
09-08 944
方法调用时，传递的实参是一个基本类型的数据形参改变，实参不变又称为地址传递，或引用传递方法调用时，传递的实参是一个引用类型的数据基本类型的数据，比较简单，可以直接存储在变量中引用类型的数据比较复杂，包含了一堆子数据，不能直接存储在变量中，存储在堆区，会为其分配一个内存地址我们在使用引用类型数据时，都是通过地址间接引用类型的数据所谓的地址传递，就是在方法调用时，传递的是引用类型的地址。形参（内容）改变，实参（内容）改变类似于值传递的址传递。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 677
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1299
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1042
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
Java ECC加密技术探索与实现
"Java加密技术第四部分，主要探讨了椭圆曲线加密算法(ECC)在Java中的应用。ECC是一种高效的公钥加密体制，尤其在软件注册保护和生成序列号等方面有广泛应用。虽然Java从1.5版本开始支持ECC，但其加密/解密操作通常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值