Java中使用OpenSSL生成的RSA公私钥进行数据加解密

当前使用的是Linux系统，已经按装使用OpenSSL软件包，

一、使用OpenSSL来生成私钥和公钥

1、执行命令openssl version -a 验证机器上已经安装openssl

openssl version -a

运行结果：

2、生成私钥：这条命令让openssl随机生成了一份私钥，加密长度是1024位。加密长度是指理论上最大允许”被加密的信息“长度的限制，也就是明文的长度限制。随着这个参数的增大（比方说2048），允许的明文长度也会增加，但同时也会造成计算复杂度的极速增长。一般推荐的长度就是2048位

openssl genrsa -out rsa_private_key.pem 2048

运行结果：

生产私钥文件：rsa_private_key.pem，内容都是标准的ASCII字符，开头一行和结尾一行有明显的标记，真正的私钥数据是中间的不规则字符

3、根据私钥生产公钥：rsa_public_key.pem

openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout

运行结果：

公钥内容：

注意：此时的私钥还不能直接被使用，需要进行PKCS#8编码：

4、PKCS#8编码：指明输入私钥文件为rsa_private_key.pem，输出私钥文件为pkcs8_rsa_private_key.pem，不采用任何二次加密（-nocrypt）

openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt

至此：可用的密钥对已经生成好了，私钥使用pkcs8_rsa_private_key.pem，公钥采用rsa_public_key.pem

至此，可用的密钥对已经生成好了，私钥使用pkcs8_rsa_private_key.pem，公钥采用rsa_public_key.pem。

最近又遇到RSA加密的需求了，而且对方要求只能使用第一步生成的未经过PKCS#8编码的私钥文件。后来查看相关文献得知第一步生成的私钥文件编码是PKCS#1格式，这种格式Java其实是支持的，只不过多写两行代码而已：

RSAPrivateKeyStructure asn1PrivKey = new RSAPrivateKeyStructure((ASN1Sequence) ASN1Sequence.fromByteArray(priKeyData));  
RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());  
KeyFactory keyFactory= KeyFactory.getInstance("RSA");  
PrivateKey priKey= keyFactory.generatePrivate(rsaPrivKeySpec);

首先将PKCS#1的私钥文件读取出来（注意去掉减号开头的注释内容），然后使用Base64解码读出的字符串，便得到priKeyData，也就是第一行代码中的参数。最后一行得到了私钥。接下来的用法就没什么区别了。

二、编写Java代码实际测试

RSA加密解密类：

  1 import java.io.BufferedReader;2 import java.io.BufferedWriter;3 import java.io.FileReader;4 import java.io.FileWriter;5 import java.io.IOException;6 import java.security.InvalidKeyException;7 import java.security.KeyFactory;8 import java.security.KeyPair;9 import java.security.KeyPairGenerator;10 import java.security.NoSuchAlgorithmException;11 import java.security.SecureRandom;12 13 import java.security.interfaces.RSAPrivateKey;14 import java.security.interfaces.RSAPublicKey;15 import java.security.spec.InvalidKeySpecException;16 import java.security.spec.PKCS8EncodedKeySpec;17 import java.security.spec.X509EncodedKeySpec;18 19 import javax.crypto.BadPaddingException;20 import javax.crypto.Cipher;21 import javax.crypto.IllegalBlockSizeException;22 import javax.crypto.NoSuchPaddingException;23 24 import org.apache.commons.codec.binary.Base64;25 26 public class RSAEncrypt {27     /**28      * 字节数据转字符串专用集合29      */30     private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',31             '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };32 33     /**34      * 随机生成密钥对35      */36     public static void genKeyPair(String filePath) {37         // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象38         KeyPairGenerator keyPairGen = null;39         try {40             keyPairGen = KeyPairGenerator.getInstance("RSA");41         } catch (NoSuchAlgorithmException e) {42             e.printStackTrace();43         }44         // 初始化密钥对生成器，密钥大小为96-1024位45         keyPairGen.initialize(1024,new SecureRandom());46         // 生成一个密钥对，保存在keyPair中47         KeyPair keyPair = keyPairGen.generateKeyPair();48         // 得到私钥49         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();50         // 得到公钥51         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();52         try {53             // 得到公钥字符串54             Base64 base64 = new Base64();55             String publicKeyString = new String(base64.encode(publicKey.getEncoded()));56             // 得到私钥字符串57             String privateKeyString = new String(base64.encode(privateKey.getEncoded()));58             // 将密钥对写入到文件59             FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");60             FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");61             BufferedWriter pubbw = new BufferedWriter(pubfw);62             BufferedWriter pribw = new BufferedWriter(prifw);63             pubbw.write(publicKeyString);64             pribw.write(privateKeyString);65             pubbw.flush();66             pubbw.close();67             pubfw.close();68             pribw.flush();69             pribw.close();70             prifw.close();71         } catch (Exception e) {72             e.printStackTrace();73         }74     }75 76     /**77      * 从文件中输入流中加载公钥78      * 79      * @param in80      *            公钥输入流81      * @throws Exception82      *             加载公钥时产生的异常83      */84     public static String loadPublicKeyByFile(String path) throws Exception {85         try {86             BufferedReader br = new BufferedReader(new FileReader(path87                     + "/publicKey.keystore"));88             String readLine = null;89             StringBuilder sb = new StringBuilder();90             while ((readLine = br.readLine()) != null) {91                 sb.append(readLine);92             }93             br.close();94             return sb.toString();95         } catch (IOException e) {96             throw new Exception("公钥数据流读取错误");97         } catch (NullPointerException e) {98             throw new Exception("公钥输入流为空");99         }
100     }
101 
102     /**
103      * 从字符串中加载公钥
104      * 
105      * @param publicKeyStr
106      *            公钥数据字符串
107      * @throws Exception
108      *             加载公钥时产生的异常
109      */
110     public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
111             throws Exception {
112         try {
113             Base64 base64 = new Base64();
114             byte[] buffer = base64.decode(publicKeyStr);
115             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
116             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
117             return (RSAPublicKey) keyFactory.generatePublic(keySpec);
118         } catch (NoSuchAlgorithmException e) {
119             throw new Exception("无此算法");
120         } catch (InvalidKeySpecException e) {
121             throw new Exception("公钥非法");
122         } catch (NullPointerException e) {
123             throw new Exception("公钥数据为空");
124         }
125     }
126 
127     /**
128      * 从文件中加载私钥
129      * 
130      * @param keyFileName
131      *            私钥文件名
132      * @return 是否成功
133      * @throws Exception
134      */
135     public static String loadPrivateKeyByFile(String path) throws Exception {
136         try {
137             BufferedReader br = new BufferedReader(new FileReader(path
138                     + "/privateKey.keystore"));
139             String readLine = null;
140             StringBuilder sb = new StringBuilder();
141             while ((readLine = br.readLine()) != null) {
142                 sb.append(readLine);
143             }
144             br.close();
145             return sb.toString();
146         } catch (IOException e) {
147             throw new Exception("私钥数据读取错误");
148         } catch (NullPointerException e) {
149             throw new Exception("私钥输入流为空");
150         }
151     }
152 
153     public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
154             throws Exception {
155         try {
156             Base64 base64 = new Base64();
157             byte[] buffer = base64.decode(privateKeyStr);
158             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
159             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
160             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
161         } catch (NoSuchAlgorithmException e) {
162             throw new Exception("无此算法");
163         } catch (InvalidKeySpecException e) {
164             throw new Exception("私钥非法");
165         } catch (NullPointerException e) {
166             throw new Exception("私钥数据为空");
167         }
168     }
169 
170     /**
171      * 公钥加密过程
172      * 
173      * @param publicKey
174      *            公钥
175      * @param plainTextData
176      *            明文数据
177      * @return
178      * @throws Exception
179      *             加密过程中的异常信息
180      */
181     public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
182             throws Exception {
183         if (publicKey == null) {
184             throw new Exception("加密公钥为空, 请设置");
185         }
186         Cipher cipher = null;
187         try {
188             // 使用默认RSA
189             cipher = Cipher.getInstance("RSA");
190             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
191             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
192             byte[] output = cipher.doFinal(plainTextData);
193             return output;
194         } catch (NoSuchAlgorithmException e) {
195             throw new Exception("无此加密算法");
196         } catch (NoSuchPaddingException e) {
197             e.printStackTrace();
198             return null;
199         } catch (InvalidKeyException e) {
200             throw new Exception("加密公钥非法,请检查");
201         } catch (IllegalBlockSizeException e) {
202             throw new Exception("明文长度非法");
203         } catch (BadPaddingException e) {
204             throw new Exception("明文数据已损坏");
205         }
206     }
207 
208     /**
209      * 私钥加密过程
210      * 
211      * @param privateKey
212      *            私钥
213      * @param plainTextData
214      *            明文数据
215      * @return
216      * @throws Exception
217      *             加密过程中的异常信息
218      */
219     public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
220             throws Exception {
221         if (privateKey == null) {
222             throw new Exception("加密私钥为空, 请设置");
223         }
224         Cipher cipher = null;
225         try {
226             // 使用默认RSA
227             cipher = Cipher.getInstance("RSA");
228             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
229             byte[] output = cipher.doFinal(plainTextData);
230             return output;
231         } catch (NoSuchAlgorithmException e) {
232             throw new Exception("无此加密算法");
233         } catch (NoSuchPaddingException e) {
234             e.printStackTrace();
235             return null;
236         } catch (InvalidKeyException e) {
237             throw new Exception("加密私钥非法,请检查");
238         } catch (IllegalBlockSizeException e) {
239             throw new Exception("明文长度非法");
240         } catch (BadPaddingException e) {
241             throw new Exception("明文数据已损坏");
242         }
243     }
244 
245     /**
246      * 私钥解密过程
247      * 
248      * @param privateKey
249      *            私钥
250      * @param cipherData
251      *            密文数据
252      * @return 明文
253      * @throws Exception
254      *             解密过程中的异常信息
255      */
256     public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
257             throws Exception {
258         if (privateKey == null) {
259             throw new Exception("解密私钥为空, 请设置");
260         }
261         Cipher cipher = null;
262         try {
263             // 使用默认RSA
264             cipher = Cipher.getInstance("RSA");
265             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
266             cipher.init(Cipher.DECRYPT_MODE, privateKey);
267             byte[] output = cipher.doFinal(cipherData);
268             return output;
269         } catch (NoSuchAlgorithmException e) {
270             throw new Exception("无此解密算法");
271         } catch (NoSuchPaddingException e) {
272             e.printStackTrace();
273             return null;
274         } catch (InvalidKeyException e) {
275             throw new Exception("解密私钥非法,请检查");
276         } catch (IllegalBlockSizeException e) {
277             throw new Exception("密文长度非法");
278         } catch (BadPaddingException e) {
279             throw new Exception("密文数据已损坏");
280         }
281     }
282 
283     /**
284      * 公钥解密过程
285      * 
286      * @param publicKey
287      *            公钥
288      * @param cipherData
289      *            密文数据
290      * @return 明文
291      * @throws Exception
292      *             解密过程中的异常信息
293      */
294     public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
295             throws Exception {
296         if (publicKey == null) {
297             throw new Exception("解密公钥为空, 请设置");
298         }
299         Cipher cipher = null;
300         try {
301             // 使用默认RSA
302             cipher = Cipher.getInstance("RSA");
303             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
304             cipher.init(Cipher.DECRYPT_MODE, publicKey);
305             byte[] output = cipher.doFinal(cipherData);
306             return output;
307         } catch (NoSuchAlgorithmException e) {
308             throw new Exception("无此解密算法");
309         } catch (NoSuchPaddingException e) {
310             e.printStackTrace();
311             return null;
312         } catch (InvalidKeyException e) {
313             throw new Exception("解密公钥非法,请检查");
314         } catch (IllegalBlockSizeException e) {
315             throw new Exception("密文长度非法");
316         } catch (BadPaddingException e) {
317             throw new Exception("密文数据已损坏");
318         }
319     }
320 
321     /**
322      * 字节数据转十六进制字符串
323      * 
324      * @param data
325      *            输入数据
326      * @return 十六进制内容
327      */
328     public static String byteArrayToString(byte[] data) {
329         StringBuilder stringBuilder = new StringBuilder();
330         for (int i = 0; i < data.length; i++) {
331             // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
332             stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
333             // 取出字节的低四位 作为索引得到相应的十六进制标识符
334             stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
335             if (i < data.length - 1) {
336                 stringBuilder.append(' ');
337             }
338         }
339         return stringBuilder.toString();
340     }
341 }

签名及校验类：

  1 import java.security.KeyFactory;2 import java.security.PrivateKey;3 import java.security.PublicKey;4 import java.security.spec.PKCS8EncodedKeySpec;5 import java.security.spec.X509EncodedKeySpec;6 7 import org.apache.commons.codec.binary.Base64;8 9 /**10  * RSA签名验签类11  */12 public class RSASignature {13 14     /**15      * 签名算法16      */17     public static final String SIGN_ALGORITHMS = "SHA1WithRSA";18 19     /**20      * RSA签名21      * 22      * @param content23      *            待签名数据24      * @param privateKey25      *            商户私钥26      * @param encode27      *            字符集编码28      * @return 签名值29      */30     public static String sign(String content, String privateKey, String encode) {31         try {32             Base64 base64 = new Base64();33             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(base64.decode(privateKey));34 35             KeyFactory keyf = KeyFactory.getInstance("RSA");36             PrivateKey priKey = keyf.generatePrivate(priPKCS8);37 38             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);39 40             signature.initSign(priKey);41             signature.update(content.getBytes(encode));42 43             byte[] signed = signature.sign();44 45             return new String(base64.encode(signed));46         } catch (Exception e) {47             e.printStackTrace();48         }49 50         return null;51     }52 53     public static String sign(String content, String privateKey) {54         try {55             Base64 base64 = new Base64();56             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(base64.decode(privateKey));57             KeyFactory keyf = KeyFactory.getInstance("RSA");58             PrivateKey priKey = keyf.generatePrivate(priPKCS8);59             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);60             signature.initSign(priKey);61             signature.update(content.getBytes());62             byte[] signed = signature.sign();63             return new String(base64.encode(signed));64         } catch (Exception e) {65             e.printStackTrace();66         }67         return null;68     }69 70     /**71      * RSA验签名检查72      * 73      * @param content74      *            待签名数据75      * @param sign76      *            签名值77      * @param publicKey78      *            分配给开发商公钥79      * @param encode80      *            字符集编码81      * @return 布尔值82      */83     public static boolean doCheck(String content, String sign, String publicKey, String encode) {84         try {85             KeyFactory keyFactory = KeyFactory.getInstance("RSA");86             Base64 base64 = new Base64();87             byte[] encodedKey = base64.decode(publicKey);88             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));89 90             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);91 92             signature.initVerify(pubKey);93             signature.update(content.getBytes(encode));94 95             boolean bverify = signature.verify(base64.decode(sign));96             return bverify;97 98         } catch (Exception e) {99             e.printStackTrace();
100         }
101 
102         return false;
103     }
104 
105     public static boolean doCheck(String content, String sign, String publicKey) {
106         try {
107             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
108             Base64 base64 = new Base64();
109             byte[] encodedKey = base64.decode(publicKey);
110             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
111 
112             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
113 
114             signature.initVerify(pubKey);
115             signature.update(content.getBytes());
116 
117             boolean bverify = signature.verify(base64.decode(sign));
118             return bverify;
119 
120         } catch (Exception e) {
121             e.printStackTrace();
122         }
123 
124         return false;
125     }
126 
127 }

最后是一个MainTest：

 1 import org.apache.commons.codec.binary.Base64;2 3 public class MainTest {4 5     public static void main(String[] args) throws Exception {6         String filepath = "G:/tmp/";7 8         // RSAEncrypt.genKeyPair(filepath);9 
10         Base64 base64 = new Base64();
11 
12         System.out.println("--------------公钥加密私钥解密过程-------------------");
13         String plainText = "ihep_公钥加密私钥解密";
14         // 公钥加密过程
15         byte[] cipherData = RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),
16                 plainText.getBytes());
17         String cipher = new String(base64.encode(cipherData));
18         // 私钥解密过程
19         byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),
20                 base64.decode(cipher));
21         String restr = new String(res);
22         System.out.println("原文：" + plainText);
23         System.out.println("加密：" + cipher);
24         System.out.println("解密：" + restr);
25         System.out.println();
26 
27         System.out.println("--------------私钥加密公钥解密过程-------------------");
28         plainText = "ihep_私钥加密公钥解密";
29         // 私钥加密过程
30         cipherData = RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),
31                 plainText.getBytes());
32         cipher = new String(base64.encode(cipherData));
33         // 公钥解密过程
34         res = RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),
35                 base64.decode(cipher));
36         restr = new String(res);
37         System.out.println("原文：" + plainText);
38         System.out.println("加密：" + cipher);
39         System.out.println("解密：" + restr);
40         System.out.println();
41 
42         System.out.println("---------------私钥签名过程------------------");
43         String content = "ihep_这是用于签名的原始数据";
44         String signstr = RSASignature.sign(content, RSAEncrypt.loadPrivateKeyByFile(filepath));
45         System.out.println("签名原串：" + content);
46         System.out.println("签名串：" + signstr);
47         System.out.println();
48 
49         System.out.println("---------------公钥校验签名------------------");
50         System.out.println("签名原串：" + content);
51         System.out.println("签名串：" + signstr);
52 
53         System.out.println("验签结果：" + RSASignature.doCheck(content, signstr, RSAEncrypt.loadPublicKeyByFile(filepath)));
54         System.out.println();
55 
56     }
57 }

参考：

http://blog.csdn.net/chaijunkun/article/details/7275632

http://blog.csdn.net/wangqiuyun/article/details/42143957

转载于:https://www.cnblogs.com/yaowen/p/9226566.html

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

五分钟学会 Kotlin 语法
为什么使用Kotlin 项目一期在收尾了终于有时间折腾了，一个多月以来Kotlin从入门到现在，坚持用来开发的切身感受。因为语法与Java的区别挺大的一开始很想放弃，如果不是因为项目在使用，想必很少人会尝试这样一门小众语言，但是习惯后会发现这些年究竟浪费多少时间在写无用的J…...
2024/4/21 23:17:15
如何让总是显示在最上层，而不致于被其他遮挡
若有多个div层，某个层一直在最上面可以在最上面的层加上样式：：position:absoulte;z-index:5555; 把它的位子给设置一下就可以了！ flash图层置于最上面：自己：将<param name="wmode" value="Opaque">这一句放在flash中即可实现DIV在外层(即FLASH…...
2024/4/16 23:08:06
LeetCode第 21 题：合并两个有序链表(C++)
leetcode链接第一种方法（借助其他标准库容器）遍历两个链表将元素均存入容器中（例如vector,或者multiset会更好吗？），调用泛型算法sort进行元素排序，最后在新建链表将排序好的元素导过去： class Solution { public:ListNode* mergeTwoLists(ListNode* l1, ListNode* l2…...
2024/5/6 8:39:57
AngularJS开发实战（1）
从接触angularjs到现在已经有1年多的时间期间已经用这个框架开发了大大小小的好几个项目，参考了其他一些项目的结构模版和自己摸索尝试，从一开始项目结构错乱复杂到现在我自认为是比较良好的结构划分，现在整理成一个系列留作团队培训内容和分享，如果有更好的方案欢迎一起研…...
2024/4/20 7:17:36
psql 数据库备份与恢复
1/备份数据库（整库） pg_dump -h 112.***.***.*** -p 4321 -U carnot -f M2_cc.0914.sql carnot 2/ 压缩文件tar zcvf M2_cc.0914.sql.tar M2_cc.0914.sqlxz -9 M2_cc.0914.sql.tar3/ 上传下载rz 上传sz 下载4/解压缩文件xz -d M2_cc.0914.sql.tar.xztar xf M2_cc.0914.sql.ta…...
2024/4/16 23:08:00
豆瓣top250
文章目录1. 保存excel2. 保存mysql 1. 保存excelimport requests import pandas from lxml import etreeclass Spider(object):def __init__(self):# self.url = https://movie.douban.com/top250?start=0&filter=self.headers = {User-Agent: Mozilla/5.0 (Windows NT 6.…...
2024/4/20 6:27:25
Kotlin学习之路--Kotlin简述
Kotlin是什么？Kotlin是由jetBrains开发的一门现代多平台应用的静态编程语言，Kotlin代码即可以编译成Java字节码，又可以编译成JavaScript,Kotlin是开源的，源码在这为什么要学习Kotlin？在2017年5月18日的Google开发者大会上，Google宣布将Kotlin作为Android官方语言，作为一…...
2024/4/18 20:56:03
RSA加解密和签名验签
常用的加解密算法分三大类：非对称密钥加密算法、对称密钥加密算法、Hash加密算法非对称密钥加密算法常见算法：RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。非对称加密算法需要两个密…...
2024/4/20 8:22:30
vs code比较不错的插件
code runner 安装好node环境后可以直接在vscode上执行js文件，快捷键：ctrl+alt+n 、直接按右上角执行按钮Bracket Pair Colorizer对应括号着色，便于区分ESLint代码错误检查veturvue代码提示，高亮Path Intellisense路径自动填充Beautify格式化HTML、css，js，json代码vue-bea…...
2024/4/16 23:07:48
传统方式部署Java web项目到Linux服务器
传统方式部署Java web项目到Linux服务器搭建环境JDK安装Tomcat安装部署项目其他操作搭建环境这里仅采用JDK+Tomcat作为运行环境，暂时不考虑负载均衡等问题。 JDK安装通常在本地下好对应版本的jdk，然后通过xftp，将压缩包拷贝到服务器上。也可以在Linux上通过命令直接下载…...
2024/4/20 13:16:41
使用片段嵌入进行文档搜索
作者|Ajit Rajasekharan 编译|VK 来源|Towards Data Science从文档中获取的句子片段的嵌入可以作为该文档的提取摘要方面，并可能加速搜索，特别是当用户输入是一个句子片段时。这些片段嵌入不仅比传统的文本匹配系统产生更高质量的结果,也是问题的内在驱动的搜索方法。现代向量…...
2024/4/16 23:08:18
Kotlin 官方参考文档翻译完毕
本也发在我的个人博客上：https://hltj.me/kotlin/2017/05/15/kotlin-reference-translated.html 。非常高兴跟大家宣布：Kotlin 官方文档的参考部分已翻译校对完毕、且与官网同步，这也是目前唯一完整且最新的官方参考文档翻译。打开 Kotlin 语言中文站，点学习即是，或者直接…...
2024/4/16 23:07:48
ER图之资源管理系统
该系统主要分为课程管理系统，考试系统，资源管理系统，留言系统，新闻公告系统。资料管理系统ER图如下：...
2024/4/16 23:09:12
datagrip 导出数据库备份到本地
1.建立自己的数据库 2.如图3,结果转载于:https://www.cnblogs.com/0909/p/9956904.html...
2024/4/20 6:45:36
影视广告专业术语中英文对照(整理中）
ADArt Director 美术总监、艺术总监AEAccount Executive 客户总管Audience 观众、听众BS 卫星电视CMCommercial Message 电视广播广告CFCommercial Film 用电影胶片拍摄的电视广告VCMVideo Commercial Message 录像电视广告CM Planner 电视广播广告策划者CM Song 广告歌曲CCCor…...
2024/4/16 23:07:54
openssl在java端的加解密和签名验证
一、前言很大程度上参考：http://blog.csdn.net/chaijunkun/article/details/7275632 在此基础上添加了签名和验证方法。为了完整性，把其前面的内容也搬过来了。二、openssl下载windows版本下载地址：http://slproweb.com/products/Win32OpenSSL.html 绿色版下载地址：http://…...
2024/4/23 11:52:14
用kotlin说Hello World
1.创建项目并配置创建一个空的Android项目（1）在Project的gradle添加kotlin的版本号（2）在Project的gradle添加路径buildscript {ext.kotlin_version = 1.1.2-4repositories {jcenter()}dependencies {classpath com.android.tools.build:gradle:2.2.3classpath "or…...
2024/4/16 23:07:12
sqlserver数据库备份与还原语句
--创建备份设备 USE [master] GO EXEC master.dbo.sp_addumpdevice @devtype = Ndisk, @logicalname = Nbeifen, @physicalname = ND:\beifen.bak GO --完整备份到备份设备中 BACKUP DATABASE [student] TO [beifen] WITH NOFORMAT, NOINIT, NAME = Nstudent-完整数据库备…...
2024/4/16 23:06:53
NetBeans 7.0 ML使用印象
看到新闻《NetBeans7.0M1 发布》[url]http://www.iteye.com/news/4573-netbeans-70m1-released[/url]，急不可耐地下了一个尝尝鲜：给我最深印象的是: NetBeans 7.0对老的plugins的支持，NetBeans 6.5所有支持的Plugins只有124。而7.01，除了自带的71个插件之外，可以安装185个…...
2024/4/16 23:08:12
Java编程：比对两个文本文件，标记相同和不同之处
使用需求：文件1里面是需要比较的内容，文件2是被比较的文本，现在需要找到在文件1中每一行的文本在文件2中是否存在并相等，如果相等，就在一份结果文件中输出，文件1的哪一行与文件2的哪一行相同，反之不相同就输出文件1的哪一行不相同或不存在。Java代码如下，输出的是resul…...
2024/4/16 23:09:18

Java中使用OpenSSL生成的RSA公私钥进行数据加解密

相关文章

最新文章