Intellij Idea下tomcat设置自动编译

*eclipse默认tomcat下是自动完成编译；而Intellij Idea默认tomcat下不是自动完成编译，从如下开始设置： 进入“settings”，如下图找到“compiler”，选中如图框选选项 勾选“Build project automatically”，保存即可。   from:https://www.cnblogs.com/zdb292034/p/8047267.html

龙生   19 May 2019
View Details

IntelliJ IDEA怎么设置自动编译

第一步在我们的电脑上打开IntelliJ IDEA，点击File->Settings，如下图所示：  第二步进去Settings之后，点击 Compiler，如下图所示：  第三步勾选“Build project automatically”，点击OK，如下图所示：  第四步按“ctrl+alt+shift+/”键，选择Registry ，如下图所示：  第五步勾选“compiler.automake.allow.when.app.running”，保存之后，进行重启IntelliJ IDEA就完成了，如下图所示： from:https://jingyan.baidu.com/article/ca2d939d5b0c05eb6d31ce77.html

龙生   19 May 2019
View Details

数据挖掘，机器学习，和人工智能的区别

数据挖掘 (data mining): 有目的地从现有大数据中提取数据的模式(pattern)和模型(model) 关键字：模式提取，大数据 数据挖掘是从现有的信息(existing information)中提取数据的模式(pattern)和模型(model)，即精选出最重要的信息，以用于未来机器学习和AI的数据使用。其核心目的是找到数据变量之间的关系。其发展出来的主要原因是大数据的发展，用传统的数据分析的方式已经无能处理那么多大量的看似不相关的数据的处理，因此需要数据挖掘技术去提取各种数据和变量之间的相互关系，从而精炼数据。 数据挖掘本质上像是机器学习和人工智能的基础，他的主要目的是从各种各样的数据来源中，提取出超集(superset)的信息，然后将这些信息合并让你发现你从来没有想到过的模式和内在关系。这就意味着，数据挖掘不是一种用来证明假说的方法，而是用来构建各种各样的假说的方法。数据挖掘不能告诉你这些问题的答案，他只能告诉你，A和B可能存在相关关系，但是它无法告诉你A和B存在什么相关关系。 当然，数据挖掘会使用大量机器学习的算法，但是其特定的环境和目的和机器学习不太一样。   机器学习(machine learning): 自动地从过往的经验中学习新的知识。 关键字: 自动化，自我优化，预测，需要training data，推荐系统 机器学习其实是人工智能很重要的一部分，因为目前，在实践过程中，大多数的人工智能处理的任务，其实是用机器学习的方式完成的。机器学习可以用程序和算法自动地学习，只要被设计好了，这个程序可以进行自我优化。同时，机器学习需要一定数量的训练数据集(training data set)，用于构建来自过往经验的“知识” 。 且机器学习目前在实践中最重要的功能便是预测结果。比如机器学习已经学习结束了，现在有一个新的数据集x，需要预测其分类，机器学习算法会根据这个新数据与学习后的“知识”相匹配(实际上，知识指的是学习后的数学模型)，然后将这个数据集x分类某类C去。再比较常见的机器学习，比如amazon的推荐系统。   人工智能(AI): 一个广泛的概念，本质是用数据和模型去为现有的问题(existing problems)提供解决方法(solutions). 关键字：和人一样处理问题，技术的合集 人工智能是一个与机器学习和数据挖掘相对不同的概念，人工智能的目的是为了去创造有智力的电脑(不知道怎么翻译好，可以假设其为机器人)。在实践中，我们希望这个电脑可以像有智力的人一样处理一个任务。因此，理论上人工智能几乎包括了所有和机器能做的内容，当然也包括了数据挖掘和机器学习的内容，同时还会有监视(monitor)和控制进程(process control)的内容。   from:https://blog.csdn.net/horacehe16/article/details/80202826

龙生   17 May 2019
View Details

C# RSA 无 长度限制 加密解密 示例

RSA 是一种非对称加密算法。由于算法特性，加密和解密过程用不同密钥，即公钥和私钥，而被广泛应用于数字证书的安全管理。 在具体应用中，公钥用加密而私钥用于解密，或 私钥用于数字签名而公钥用于签名验证。由于非对称加密算法比价复杂，耗时较长，所以一般在网络环境中RAS 被应用于 签名认证，或小数据传输，如 AES 对称密钥传输。 在.Net 框架中，默认提供的辅助类只能对密钥长度大小相同的数据进行加密解密。 此文提供C# RSA 算法示例一座优化，可以不限数据大小。此实例 仅供交流学习。 RSA 加密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public string RsaEncrypt(string rawInput, string publicKey)
{
    if (string.IsNullOrEmpty(rawInput))
    {
return string.Empty;
    }
 
    if(string.IsNullOrWhiteSpace(publicKey))
    {
throw new ArgumentException("Invalid Public Key");
    }
 
    using (var rsaProvider = new RSACryptoServiceProvider())
    {
var inputBytes = Encoding.UTF8.GetBytes(rawInput);//有含义的字符串转化为字节流
rsaProvider.FromXmlString(publicKey);//载入公钥
int bufferSize = (rsaProvider.KeySize / 8) - 11;//单块最大长度
var buffer = new byte[bufferSize];
using (MemoryStream inputStream = new MemoryStream(inputBytes),
     outputStream = new MemoryStream())
{
    while (true)
    { //分段加密
int readSize = inputStream.Read(buffer, 0, bufferSize);
if (readSize <= 0)
{
    break;
}
 
var temp = new byte[readSize];
Array.Copy(buffer, 0, temp, 0, readSize);
var encryptedBytes = rsaProvider.Encrypt(temp, false);
outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);
    }
    return Convert.ToBase64String(outputStream.ToArray());//转化为字节流方便传输
}
    }
}

RSA 解密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public string RsaDecrypt(string encryptedInput, string privateKey)
{
    if (string.IsNullOrEmpty(encryptedInput))
    {
return string.Empty;
    }
 
    if (string.IsNullOrWhiteSpace(privateKey))
    {
throw new ArgumentException("Invalid Private Key");
    }
 
    using (var rsaProvider = new RSACryptoServiceProvider())
    {
var inputBytes = Convert.FromBase64String(encryptedInput);
rsaProvider.FromXmlString(privateKey);
int bufferSize = rsaProvider.KeySize / 8;
var buffer = new byte[bufferSize];
using (MemoryStream inputStream = new MemoryStream(inputBytes),
     outputStream = new MemoryStream())
{
    while (true)
    {
int readSize = inputStream.Read(buffer, 0, bufferSize);
if (readSize <= 0)
{
    break;
}
 
var temp = new byte[readSize];
Array.Copy(buffer, 0, temp, 0, readSize);
var rawBytes = rsaProvider.Decrypt(temp, false);
outputStream.Write(rawBytes, 0, rawBytes.Length);
    }
    return Encoding.UTF8.GetString(outputStream.ToArray());
}
    }
}

  from:https://blog.csdn.net/hangzhi22/article/details/53089154

龙生   16 May 2019
View Details

RSA密钥之C#格式与Java格式转换

前言 最近由于项目需求，服务端由c#编写，客户端由java编写。通信数据使用RSA非对称加密。但是java和c#生成的密钥格式是不一样的，所以需要转换格式才可以正常使用。网上搜到使用java进行格式转换的代码（如：http://blog.csdn.net/road2010/article/details/40071881 ），本文将给出一种c#的实现方法。 密钥格式 java密钥格式如下： 私钥： MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAKSZSSEdPhv77O5ocnLNGXeQ21qJDArC1+yId+9/pY5bXkZk5vCB49EpfMwNukLv6AJqofThZPNOs1t015fdEYIUnkIc2QVxRwa0xTeFP6N8D4WQXRWs4fNG27JK5kP45s+9KlJtx5hs7G97aMczehIWpHaO6j9inOmjlU8l62KZAgMBAAECgYEAmK3TRtMwRJb33OGnn9OeFumYfy92qxi3X6Hq1o6qDBW2qkd4bImfv+ni6AinyOVuaadt2Y+lq4dKGcCVJzoZvPm1VKxD2y7xKa8/vEbPRiRTt0qnPq9T7UJkpDsiXf/zOMfWdjc3uA1bPnQ65RWHSJ7zAE+Gd7xnyCE5MEyijLECQQDVYqQWDqOVLZ5lJUuIfUIrhv26GvuoTX8v60+opCz4/Mdfh6JlefICVD6SAaYvufXBHVFY26JicNlR62ZOiBoNAkEAxXhsuEnNJNQcQHEVTPZoulbMbTV1VZIDQ1zjG8fvu8sv6IBYcR5+EsC8n3/6RkW8/iCJDzxE++VHzhoSQSoDvQJBAM6/63J/rpndAIrJ7vyJOPLJsc9/U3SH2gMJAT7KC9UXvuldlsixtf3xuEpplKbLjEUXbfklnZm586a+6XqPvoUCQDFotltOLARBBmihYuEE7qNhQHk63QbyJ9rdDP5Qgo2Mg4o7QuXa6VSr4QZPsUGQBX/YiDLFs8ULU3IgV9zyNEkCQADAYR8DctYzg0eBGdcOrDA5Szc62pYrS2wk89wUxyL4FyDL3omkVMKvtu5tccy7Xht2ikJZRqefZ3dS7ASm8/4= 公钥： MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkmUkhHT4b++zuaHJyzRl3kNtaiQwKwtfsiHfvf6WOW15GZObwgePRKXzMDbpC7+gCaqH04WTzTrNbdNeX3RGCFJ5CHNkFcUcGtMU3hT+jfA+FkF0VrOHzRtuySuZD+ObPvSpSbceYbOxve2jHM3oSFqR2juo/Ypzpo5VPJetimQIDAQAB   .NET密钥格式如下： 私钥：

1
2
3
4
5
6
7
8
9
10
<RSAKeyValue>
  <Modulus>pJlJIR0+G/vs7mhycs0Zd5DbWokMCsLX7Ih373+ljlteRmTm8IHj0Sl8zA26Qu/oAmqh9OFk806zW3TXl90RghSeQhzZBXFHBrTFN4U/o3wPhZBdFazh80bbskrmQ/jmz70qUm3HmGzsb3toxzN6Ehakdo7qP2Kc6aOVTyXrYpk=</Modulus>
  <Exponent>AQAB</Exponent>
  <P>1WKkFg6jlS2eZSVLiH1CK4b9uhr7qE1/L+tPqKQs+PzHX4eiZXnyAlQ+kgGmL7n1wR1RWNuiYnDZUetmTogaDQ==</P>
  <Q>xXhsuEnNJNQcQHEVTPZoulbMbTV1VZIDQ1zjG8fvu8sv6IBYcR5+EsC8n3/6RkW8/iCJDzxE++VHzhoSQSoDvQ==</Q>
  <DP>zr/rcn+umd0Aisnu/Ik48smxz39TdIfaAwkBPsoL1Re+6V2WyLG1/fG4SmmUpsuMRRdt+SWdmbnzpr7peo++hQ==</DP>
  <DQ>MWi2W04sBEEGaKFi4QTuo2FAeTrdBvIn2t0M/lCCjYyDijtC5drpVKvhBk+xQZAFf9iIMsWzxQtTciBX3PI0SQ==</DQ>
  <InverseQ>wGEfA3LWM4NHgRnXDqwwOUs3OtqWK0tsJPPcFMci+Bcgy96JpFTCr7bubXHMu14bdopCWUann2d3UuwEpvP+</InverseQ>
  <D>mK3TRtMwRJb33OGnn9OeFumYfy92qxi3X6Hq1o6qDBW2qkd4bImfv+ni6AinyOVuaadt2Y+lq4dKGcCVJzoZvPm1VKxD2y7xKa8/vEbPRiRTt0qnPq9T7UJkpDsiXf/zOMfWdjc3uA1bPnQ65RWHSJ7zAE+Gd7xnyCE5MEyijLE=</D>
</RSAKeyValue>

公钥：

1
2
3
4
<RSAKeyValue>
  <Modulus>pJlJIR0+G/vs7mhycs0Zd5DbWokMCsLX7Ih373+ljlteRmTm8IHj0Sl8zA26Qu/oAmqh9OFk806zW3TXl90RghSeQhzZBXFHBrTFN4U/o3wPhZBdFazh80bbskrmQ/jmz70qUm3HmGzsb3toxzN6Ehakdo7qP2Kc6aOVTyXrYpk=</Modulus>
  <Exponent>AQAB</Exponent>
</RSAKeyValue>

  转换实现代码（c#） 格式转换要用到一个开源加密库Bouncy Castle Crypto APIs，官网地址： http://www.bouncycastle.org/csharp/ 具体实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
using System;
using System.Xml;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.X509;
/// <summary>
/// RSA密钥格式转换
/// </summary>
public class RSAKeyConvert
{
    /// <summary>
    /// RSA私钥格式转换，java->.net
    /// </summary>
    /// <param name="privateKey">java生成的RSA私钥</param>
    /// <returns></returns>
    public static string RSAPrivateKeyJava2DotNet(string privateKey)
    {
        RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
        return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
            Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
    }
    /// <summary>
    /// RSA私钥格式转换，.net->java
    /// </summary>
    /// <param name="privateKey">.net生成的私钥</param>
    /// <returns></returns>
    public static string RSAPrivateKeyDotNet2Java(string privateKey)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(privateKey);
        BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
        BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
        BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
        BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
        BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
        BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
        BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
        BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
        RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
        PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
        byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
        return Convert.ToBase64String(serializedPrivateBytes);
    }
    /// <summary>
    /// RSA公钥格式转换，java->.net
    /// </summary>
    /// <param name="publicKey">java生成的公钥</param>
    /// <returns></returns>
    public static string RSAPublicKeyJava2DotNet(string publicKey)
    {
        RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
        return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
            Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
            Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
    }
    /// <summary>
    /// RSA公钥格式转换，.net->java
    /// </summary>
    /// <param name="publicKey">.net生成的公钥</param>
    /// <returns></returns>
    public static string RSAPublicKeyDotNet2Java(string publicKey)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(publicKey);
        BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
        BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
        RsaKeyParameters pub = new RsaKeyParameters(false, m, p);
        SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
        byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
        return Convert.ToBase64String(serializedPublicBytes);
    }
}

  from:https://www.cnblogs.com/datous/p/RSAKeyConvert.html

龙生   16 May 2019
View Details

Rsa加解密Java、C#、php通用代码 密钥转换工具

之前发了一篇"TripleDes的加解密Java、C#、php通用代码"，后面又有项目用到了Rsa加解密，还是在不同系统之间进行交互，Rsa在不同语言的密钥格式不一样，所以过程中主要还是密钥转换问题，为方便密钥转换，写了一个XML和PEM格式的密钥转换工具，文章后面会提供密钥转换工具的下载地址，通过搜索参考和研究终于搞定了在Java、C#和Php都可以通用的加解密代码，整理了Rsa的加解密代码做个记录，以后可以参考，大家应该都知道Rsa算法，这里就不说明了，直接看代码（代码主要是公钥加密私钥解密，密文统一进行base64编码，密钥长度为2048）： Java版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
package com.w3cnet.leetcode.utils;
 
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import org.apache.commons.codec.binary.Base64;
 
public class RsaUtil {
    /**
     * 加密算法
     */
    public static final String ALGORITHM = "RSA";
 
    /**
     * 填充方式
     */
    public static final String PADDING_FORMAT = "RSA/ECB/PKCS1Padding";
 
    /**
     * 明文块最大值
     */
    private static final int MAX_ENCRYPT_BLOCK = 245;
 
    /**
     * 密文块最大值
     */
    private static final int MAX_DECRYPT_BLOCK = 256;
 
    /**
     * 加密
     * @param text  明文
     * @param publicKey  公钥
     * @param charset 字符编码
     * @return  加密后的字符串（base64）
     * @throws Exception
     */
    public static String encrypt(String text, String publicKey, String charset)
            throws Exception {
 
        byte[] data = text.getBytes(charset);
        byte[] keyBytes = Base64.decodeBase64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
 
        // 对数据加密
        Cipher cipher = Cipher.getInstance(PADDING_FORMAT);
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int length = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
 
        // 对数据分段加密
        while (length - offSet > 0) {
            int len = length - offSet > MAX_ENCRYPT_BLOCK ? MAX_ENCRYPT_BLOCK : length - offSet;
            cache = cipher.doFinal(data, offSet, len);
            out.write(cache, 0, cache.length);
 
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
 
        byte[] cipherBytes = out.toByteArray();
        out.close();
 
        return Base64.encodeBase64String(cipherBytes);
    }
 
    /**
     * 私钥解密
     * @param ciphertext  密文（base64）
     * @param privateKey  私钥
     * @param charset  字符编码
     * @return
     * @throws Exception
     */
    public static String decrypt(String ciphertext, String privateKey, String charset)
            throws Exception {
 
        byte[] data = Base64.decodeBase64(ciphertext);
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
 
        Cipher cipher = Cipher.getInstance(PADDING_FORMAT);
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int length = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
 
        while (length - offSet > 0) {
            int len = length - offSet > MAX_DECRYPT_BLOCK ? MAX_DECRYPT_BLOCK : length - offSet;
            cache = cipher.doFinal(data, offSet, len);
            out.write(cache, 0, cache.length);
 
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
 
        byte[] textBytes = out.toByteArray();
        out.close();
 
        return new String(textBytes, charset);
    }
    
    /**
     * 从文件中加载密钥字符串
     * @return 是否成功
     * @throws Exception
     */
    public static String loadKeyString(String keyFile){
        String keyString="";
        InputStream in=null;
        BufferedReader br=null;
        try {
            in=RSACryptoUtil.class.getResourceAsStream("/"+keyFile);
            br= new BufferedReader(new InputStreamReader(in));
            String readLine= null;
            StringBuilder sb= new StringBuilder();
            while((readLine= br.readLine())!=null){
                if(readLine.charAt(0)=='-'){
                    continue;
                }else{
                    sb.append(readLine);
                    sb.append('\r');
                }
            }
            keyString=sb.toString();
        } catch (IOException e) {
        } catch (Exception e) {
 
        }finally{
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                }
            }
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                }
            }
        }
        return keyString;
    }
    
    /**
     * 从文件中加载密钥字符串  根据文件路径加载
     * @return 是否成功
     * @throws Exception
     */
    public static String loadKeyStringByPath(String keyFile){
        String keyString="";
        InputStream in=null;
        BufferedReader br=null;
        try {
            in = new FileInputStream(keyFile);
            br= new BufferedReader(new InputStreamReader(in));
            String readLine= null;
            StringBuilder sb= new StringBuilder();
            while((readLine= br.readLine())!=null){
                if(readLine.charAt(0)=='-'){
                    continue;
                }else{
                    sb.append(readLine);
                    sb.append('\r');
                }
            }
            keyString=sb.toString();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
 
        }finally{
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                }
            }
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                }
            }
        }
        return keyString;
    }
    
    public static void main(String[] args) throws Exception {
        String publicKey = RSAUtils.loadKeyStringByPath("D:/sso_public_key_test.pem");
        System.out.println(RSACryptoUtil.encrypt("123", publicKey, "utf-8"));
    }
}

  C#版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
    public class RsaUtil
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="text">明文</param>
        /// <param name="publicKey">公钥</param>
        /// <returns>密文</returns>
        public static string Encrypt(string text, string publicKey)
        {
            var bytes = Encoding.UTF8.GetBytes(text);
            var length = bytes.Length;
            // rsa实例
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(publicKey);
            var blockSize = (rsa.KeySize / 8) - 11;
            var offSet = 0; // 游标
            var i = 0;
            byte[] cache;
            var ms = new MemoryStream();
            while (length - offSet > 0)
            {
                var len = length - offSet > blockSize ? blockSize : length - offSet;
                var temp = new byte[len];
                Array.Copy(bytes, offSet, temp, 0, len);
                cache = rsa.Encrypt(temp, false);
                ms.Write(cache, 0, cache.Length);
                i++;
                offSet = i * blockSize;
            }
            var cipherBytes = ms.ToArray();
            return Convert.ToBase64String(cipherBytes);
        }
 
        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="ciphertext">密文</param>
        /// <param name="privateKey">私钥</param>
        /// <returns>明文</returns>
        public static string Decrypt(string ciphertext, string privateKey)
        {
            var blockSize = 256;
            var bytes = Convert.FromBase64String(ciphertext);
            var length = bytes.Length;
            // rsa实例
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(privateKey);
            var offSet = 0; // 游标
            var i = 0;
            byte[] cache;
            var ms = new MemoryStream();
            while (length - offSet > 0)
            {
                var len = length - offSet > blockSize ? blockSize : length - offSet;
                var temp = new byte[len];
                Array.Copy(bytes, offSet, temp, 0, len);
                cache = rsa.Decrypt(temp, false);
                ms.Write(cache, 0, cache.Length);
                i++;
                offSet = i * blockSize;
            }
            var cipherBytes = ms.ToArray();
            return Encoding.UTF8.GetString(cipherBytes);
        }
    }

  PHP版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?php
#私钥
$private_key = '-----BEGIN PRIVATE KEY-----
MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCocmvQIWD2L9TW
N1uKpLONwHcdy2oaKoW1CtI8PB+S+UjdEuLl3usWEuh3ZgLYloPyD9553SJFn7an
fOplHITBqASOIXt9pi0CkahUPgwCPj4Dke5cT3fsp2i243/FX3afzrcf7FfTrEv/
LT22wF3csqrGt/UhqMcmpWIpPaL8edoCwGRBhghzEWaRwPZ2x5RPg+9qTSy0M7QG
u+8EwYDnNkGGuuIwzNxklclic9Unp96eVp33vOP/LNvz90OcuqGQQcABh+e2ttv6
VzqlRcD1GRhxqkT3erXmgbQAVm6JQHArK1Up10No+lth1tri5TGcL0BEF7PetDIj
jYh+aCLpAgMBAAECggEAPjFI1yaLyzmrxo/Xz5+x36NxF2IUQabziP1+09iK+9Po
cB9aAO9GMvc2N2dFo7wm6Uesp6fa0IQAh2RakoxuA6ZKUEPSeXjSY4Ft+fSSsH1U
njLSI+j/aTQCOIxUj4YIoUZMXJABeVjDEmscvw3VWffpj8c5zXyoUv9696kXNUoa
uHOuphe1UNc3ghFIpWK+7ScxkPB6KtmAFwD4LSbT9OwhPozavBqouQvhLt1bXO8C
ycKq4f1Pzhtt3sq3BRsPwqGhWt1NK95upKQuDnk1kJHjNzScH1FZxhsBHLxwOJ6E
M7HP5Ywh78umusaNPVLMM6+YVWbENg+WZZcXd/XspQKBgQDRIhIukY7m7fRBH0CP
mHi20gUmn7HzXgLxlbcU5n2PMDHHOg8D+Nmz1MnYPRQNwqxJdH8HOk8YQDC2uA+h
BpyCpvPbp6y6SnZw8bhqiNfSHBjEftmg7lUU5xzBiBo6SyCyLkWD2xa/O8Vyh6ut
/G1mQpNNJWWt5b+g5c4i0/fIhwKBgQDOMjGcLS8zHnZ30ZsWUS39iZ5TZXPCldTl
Q9JB5PnB4CajYmQEdw3n9C6mOO42b+3M04mmqo1r0HiNyA9lZQQNsM3KqG+ngGvE
0DM1cAyuz3Fi3XTIhAbRyXXyVbqBp5Yh2/O2lvrsInusJrimDRgwglquu2GsdVrj
+++b2DFFDwKBgQCkfXLlk/FdK44xZn5mM1vHGBubDIJv0+Lm14Yf90aMyDBu7fh/
fEznSBfWb/wE8riGMg3zxmYNwfdO0Cji04torB4kB5cxE35jSYxupuFxzk2gx9Eu
5iafgUQ56G4QqaS24PQmSL10fnPHqHRdLa1ygCzRwfdettVpnTbsZ+J9owKBgQDF
o2Tb3o9sPxmsdVNiy8L6TstcAlU3wOfELQK+uFwQ0eoXFvrpMLg6iVmhZ9YkhZp4
hpZdEwLkwXib5ZOkS3PcL4jBZDtJYRVrG2jKIrF1aU60RbJnc+0ZbjHIaxWOqvSD
VdE/RW4TomXKN38rYke6T2feLatMY1wQRG6BgXKQTwKBgQDKfK9Xuqzx+WI4AohT
EwKrQEZUMD+6DTESHHG9As4zMJ9zU+6iPpM4Gw4CzfJZHhPP4dD+TC9NcvvR+GC9
UkwxmZrvP1+6KNFp0DZNk6M9wPZuYM/E63Vy0sFEA+/gFp4vQh8k7N8n/n7DhR3v
kLuPdicfsKcz0thxzyDjv6oR2g==
-----END PRIVATE KEY-----';
 
#公钥
$public_key = '-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqHJr0CFg9i/U1jdbiqSz
jcB3HctqGiqFtQrSPDwfkvlI3RLi5d7rFhLod2YC2JaD8g/eed0iRZ+2p3zqZRyE
wagEjiF7faYtApGoVD4MAj4+A5HuXE937KdotuN/xV92n863H+xX06xL/y09tsBd
3LKqxrf1IajHJqViKT2i/HnaAsBkQYYIcxFmkcD2dseUT4Pvak0stDO0BrvvBMGA
5zZBhrriMMzcZJXJYnPVJ6fenlad97zj/yzb8/dDnLqhkEHAAYfntrbb+lc6pUXA
9RkYcapE93q15oG0AFZuiUBwKytVKddDaPpbYdba4uUxnC9ARBez3rQyI42Ifmgi
6QIDAQAB
-----END PUBLIC KEY-----';
 
$pi_key = openssl_pkey_get_private($private_key);
$pu_key = openssl_pkey_get_public($public_key);
 
 
#公钥加密数据 rsa+base64
$data = "hello world!";
openssl_public_encrypt($data,$encrypted,$pu_key);
$base64_encrypted = base64_encode($encrypted);
echo $base64_encrypted."\n";
 
#私钥解密数据
openssl_private_decrypt(base64_decode($base64_encrypted),$decrypted_data,$pi_key);
 
echo $decrypted_data;
 
?>

Rsa加解密C#和Java、php使用的密钥格式不一样，这里提供一个密钥转换工具：Rsa密钥转换工具v2.0   参考 https://www.cnblogs.com/jaamy/p/6118814.html

龙生   16 May 2019
View Details

接口与抽象类的区别

一个类可以实现多个接口，但却只能继承最多一个抽象类。 抽象类可以包含具体的方法；接口的所有方法都是抽象的。 抽象类可以声明和使用字段；接口则不能，但可以创建静态的final常量。 抽象类中的方法可以是public、protected、private或者默认的pagckage；接口的方法都是public。 抽象类可以定义构造函数；接口不能。

龙生   10 May 2019
View Details

CSS3 @media 查询

1
2
3
4
5
@media screen and (max-width: 300px) {
    body {
        background-color:lightblue;
    }
}

定义和使用 使用 @media 查询，你可以针对不同的媒体类型定义不同的样式。 @media 可以针对不同的屏幕尺寸设置不同的样式，特别是如果你需要设置设计响应式的页面，@media 是非常有用的。 当你重置浏览器大小的过程中，页面也会根据浏览器的宽度和高度重新渲染页面。 浏览器支持 表格中的数字表示支持 @media 规则的第一个浏览器的版本号。 Rule Chrome IE FireFox Safari Opera @media 21 9 3.5 4.0 9 CSS 语法 @media mediatype and|not|only (media feature) { CSS-Code; } 你也可以针对不同的媒体使用不同 stylesheets : <link rel="stylesheet" media="mediatype and|not|only (media feature)" href="mystylesheet.css"> 媒体类型 值 描述 all 用于所有设备 aural 已废弃。用于语音和声音合成器 braille 已废弃。 应用于盲文触摸式反馈设备 embossed 已废弃。 用于打印的盲人印刷设备 handheld 已废弃。 用于掌上设备或更小的装置，如PDA和小型电话 print 用于打印机和打印预览 projection 已废弃。 用于投影设备 screen 用于电脑屏幕，平板电脑，智能手机等。 speech 应用于屏幕阅读器等发声设备 tty 已废弃。 用于固定的字符网格，如电报、终端设备和对字符有限制的便携设备 tv 已废弃。 用于电视和网络电视 媒体功能 值 描述 aspect-ratio 定义输出设备中的页面可见区域宽度与高度的比率 color 定义输出设备每一组彩色原件的个数。如果不是彩色设备，则值等于0 color-index 定义在输出设备的彩色查询表中的条目数。如果没有使用彩色查询表，则值等于0 device-aspect-ratio 定义输出设备的屏幕可见宽度与高度的比率。 device-height 定义输出设备的屏幕可见高度。 device-width 定义输出设备的屏幕可见宽度。 grid 用来查询输出设备是否使用栅格或点阵。 height 定义输出设备中的页面可见区域高度。 […]

龙生   10 May 2019
View Details

html禁止手机页面放大缩小

<meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=1.0,user-scalable=no" /> html手机页面 <meta name="viewport" content="width=device-width, initial-scale=1" /> js正则: /<ul.*(?=breadline)(.|\n)*?<\/ul>/gi； 匹配以ul开始 class="breadline"结束外加中间任意内容</ul> ——————— 作者：huang100qi 来源：CSDN 原文：https://blog.csdn.net/huang100qi/article/details/36186573 版权声明：本文为博主原创文章，转载请附上博文链接！

龙生   08 May 2019
View Details

谈谈微服务中的 API 网关（API Gateway）

前言 又是很久没写博客了，最近一段时间换了新工作，比较忙，所以没有抽出来太多的时间写给关注我的粉丝写一些干货了，就有人问我怎么最近没有更新博客了，在这里给大家抱歉。 那么，在本篇文章中，我们就一起来探讨一下 API 网关在整个微服务分布式架构中的一个作用。 背景 我们知道在微服务架构风格中，一个大应用被拆分成为了多个小的服务系统提供出来，这些小的系统他们可以自成体系，也就是说这些小系统可以拥有自己的数据库，框架甚至语言等，这些小系统通常以提供 Rest Api 风格的接口来被 H5, Android, IOS 以及第三方应用程序调用。 但是在UI上进行展示的时候，我们通常需要在一个界面上展示很多数据，这些数据可能来自于不同的微服务中，举个例子。 在一个电商系统中，查看一个商品详情页，这个商品详情页包含商品的标题，价格，库存，评论等，这些数据对于后端来说可能是位于不同的微服务系统之中，可能我后台的系统是这样来拆分我的服务的： 产品服务 – 负责提供商品的标题，描述，规格等。 价格服务 – 负责对产品进行定价，价格策略计算，促销价等。 库存服务 – 负责产品库存。 评价服务 – 负责用户对商品的评论，回复等。 现在，商品详情页需要从这些微服务中拉取相应的信息，问题来了？ 问题 由于我们使用的服务系统架构，所以没办法像传统单体应用一样依靠数据库的 join 查询来得到最终结果，那么如何才能访问各个服务呢？ 按照微服务设计的指导原则，我们的微服务可能存在下面的问题： 服务使用了多种协议，因为不同的协议有不同的应场景用，比如可能同时使用 HTTP, AMQP, gRPC 等。 服务的划分可能随着时间而变化。 服务的实例或者Host+端口可能会动态的变化。 那么，对于前端的UI需求也可能会有以下几种： 粗粒度的API，而微服务通常提供的细粒度的API，对于UI来说如果要调用细粒度的api可能需要调用很多次，这是个不小的问题。 不同的客户端设备可能需要不同的数据。Web,H5,APP 不同设备的网络性能，对于多个api来说，这个访问需要转移的服务端会快得多 以上，就是我们构建微服务的过程中可能会遇到的问题。那么如何解决呢？ 这种情况下，我们就需要一个今天要讲的这个东西， API 网关（API Gataway）。 API 网关 下面是百度上针对于 API 网关的介绍： API网关是一个服务器，是系统的唯一入口。从面向对象设计的角度看，它与外观模式类似。API网关封装了系统内部架构，为每个客户端提供一个定制的API。它可能还具有其它职责，如身份验证、监控、负载均衡、缓存、请求分片与管理、静态响应处理。 API网关方式的核心要点是，所有的客户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。通常，网关也是提供REST/HTTP的访问API。服务端通过API-GW注册和管理服务。 Chris Richardson 在他的博客中把 API 网关划分为以下两种： 单节点 API 网关 Backends for frontends 网关 单节点网关 单节点的 API网关为每个客户端提供不同的API，而不是提供一种万能风格的API。 这个网关和微软在 eShop 项目中推荐的网关是一致的。 更多详细信息我会在下文进行说明。 Backends for frontends 网关 这种模式是针对不同的客户端来实现一个不同的API网关。 落地方案 我一直在寻思一种最佳的 API 网关的落地方案，以上两种 API 网关有什么问题呢？ 通常情况下， […]

龙生   07 May 2019
View Details
1 … 158 159 160 … 412

Copyright © 2025 Longsheng All rights reserved