All posts by 龙生

【ES报错】Unable to parse response body for Response{requestLine=PUT /index/_doc…HTTP/1.1 201 Created}

这里告诉大家一个非常关键的经验：往往遇到奇奇怪怪的问题时通常是包冲突或者是中间件版本冲突引起的。

因为这些报错不是我们自己写代码引起的，它们肯定来自于我们引入的代码，所以我们才会觉得没见过或者奇奇怪怪，那引入的代码好好的又不可能会随便报错，那就只可能是他们所依赖的其它包的版本发生了变化或者是所依赖的中间件的版本发生了变化。

这里便不再赘述了。本次问题主要是中间件版本冲突引起的。

龙生   29 Sep 2024
View Details

es版本与java api版本对照一览

大家好，我是老坛。 在我们使用java api操作es时，常常会遇到因为版本不一致所引起的问题，因此保证版本一致性尤为重要。这里列出了版本对照表： 该对照表是spring官方给出的版本，原链接：https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/ 但是该表格并没有列出es在8.x时对应的spring data版本，这是因为目前spirng data只支持7.x及其以下的es版本，当es达到了8.x时我们应当使用相应的第三方包： 更多优质文章资源请关注同名公众号：老坛聊开发

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>co.elastic.clients</groupId>
    <artifactId>elasticsearch-java</artifactId>
    <version>8.1.1</version>
</dependency>
<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>2.0.1</version>
</dependency>

需要将二者同时引入，否则可能会报丢失jakarta相关文件的错误。   from:https://blog.csdn.net/qq_34263207/article/details/127790216

龙生   29 Sep 2024
View Details

ScheduledExecutorService 处理定时和周期性任务的强大工具

ScheduledExecutorService是Java中处理定时和周期性任务的强大工具，它简化了线程管理，自动分配线程资源，避免了手动创建线程的繁琐，它提供了定时和周期性任务调度功能，能满足多数场景，此外，ScheduledExecutorService还支持任务取消和线程池关闭，对线程管理提供了更好的控制手段。

龙生   23 Sep 2024
View Details

记一次mybatis的NullPointerException异常

mybatis处理不了关键字：point

龙生   30 Aug 2024
View Details

nvm 安装node失败问题记录（Get “https://nodejs.org/dist/latest/SHASUMS256.txt“: dial tcp 104.20.23.46:443: i/）

在使用 NVM（Node Version Manager）安装 Node.js 时，您可能会遇到类似如下的错误提示： 这个问题通常是由于网络连接不畅或访问 nodejs.org 的服务器时出现超时所导致的。当 NVM 尝试从 nodejs.org 下载 Node.js 版本文件时，网络阻塞可能会引发这个问题，尤其是在国内网络环境下。 解决方案 为了绕过这一问题，可以通过设置镜像源来加速下载。具体步骤如下： 设置 npm 镜像源： 使用 NVM 时，可以通过以下命令将 npm 的镜像源设置为国内的 npm 镜像源：

1
nvm npm_mirror https://npmmirror.com/mirrors/npm/

  这个命令将会指向 npm 镜像源，确保在安装 npm 相关的包时可以顺利下载。 设置 Node.js 镜像源： 同样地，我们可以将 Node.js 的镜像源设置为国内的 Node.js 镜像源：

1
nvm node_mirror https://npmmirror.com/mirrors/node/

  这个命令将 Node.js 下载源指向 npmmirror 的镜像服务器，避免访问 nodejs.org 时出现超时的问题。 设置好镜像源之后，您可以正常安装 Node.js 了。例如：

1
nvm install 20.0.0

这将从国内的镜像源下载并安装指定版本的 Node.js。 总结 通过设置 npm 和 Node.js 的镜像源，可以有效解决由于网络问题导致的 NVM 安装 Node.js 失败的问题。这种方法特别适用于在国内环境中开发时遇到的网络连接问题。 希望这个解决方案能够帮助您顺利安装并使用 Node.js。如果您在其他方面遇到问题或有进一步的疑   from:https://blog.csdn.net/qq_67572731/article/details/141465938

龙生   25 Aug 2024
View Details

Java RsaUtil

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
215
216
217
218
219
220
221
import com.alibaba.fastjson.JSONObject;
import com.ucmed.unified.dto.ResultBean;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang.StringUtils;
 
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
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;
 
/**
* RSA Helper
*
*/
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 = 117;
 
    /**
     * 密文块最大值
     */
    private static final int MAX_DECRYPT_BLOCK = 128;
 
    /**
     * 生成密钥对
     */
    public static Map<String, String> generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(1024);
 
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 
        Map<String, String> keyMap = new HashMap<>(2);
        keyMap.put("RSAPublicKey", Base64.encodeBase64String(publicKey.getEncoded()));
        keyMap.put("RSAPrivateKey", Base64.encodeBase64String(privateKey.getEncoded()));
 
        return keyMap;
    }
 
    /**
     * 公钥加密
     *
     * @param text      明文
     * @param publicKey 公钥
     * @param charset   字符编码
     * @return 加密后的字符串（base64）
     */
    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 key = keyFactory.generatePublic(x509KeySpec);
 
        // 对数据加密
        Cipher cipher = Cipher.getInstance(PADDING_FORMAT);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        int length = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
 
        // 对数据分段加密
        while (length - offSet > 0) {
            int len = Math.min(length - offSet, MAX_ENCRYPT_BLOCK);
            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    字符编码
     */
    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 key = keyFactory.generatePrivate(pkcs8KeySpec);
 
        Cipher cipher = Cipher.getInstance(PADDING_FORMAT);
        cipher.init(Cipher.DECRYPT_MODE, key);
        int length = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
 
        while (length - offSet > 0) {
            int len = Math.min(length - offSet, MAX_DECRYPT_BLOCK);
            cache = cipher.doFinal(data, offSet, len);
            out.write(cache, 0, cache.length);
 
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
 
        out.close();
 
        return out.toString(charset);
    }
 
    /**
     * 私钥加密
     *
     * @param text       明文
     * @param privateKey 私钥
     * @param charset    字符编码
     * @return 加密后的字符串（base64）
     */
    public static String encryptWithPrivateKey(String text, String privateKey, String charset)
            throws Exception {
 
        byte[] data = text.getBytes(charset);
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        Key key = keyFactory.generatePrivate(pkcs8KeySpec);
 
        // 对数据加密
        Cipher cipher = Cipher.getInstance(PADDING_FORMAT);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        int length = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
 
        // 对数据分段加密
        while (length - offSet > 0) {
            int len = Math.min(length - offSet, MAX_ENCRYPT_BLOCK);
            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 publicKey  私钥
     * @param charset    字符编码
     */
    public static String decryptWithPublicKey(String ciphertext, String publicKey, String charset)
            throws Exception {
 
        byte[] data = Base64.decodeBase64(ciphertext);
        byte[] keyBytes = Base64.decodeBase64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        Key key = keyFactory.generatePublic(x509KeySpec);
 
        Cipher cipher = Cipher.getInstance(PADDING_FORMAT);
        cipher.init(Cipher.DECRYPT_MODE, key);
        int length = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
 
        while (length - offSet > 0) {
            int len = Math.min(length - offSet, MAX_DECRYPT_BLOCK);
            cache = cipher.doFinal(data, offSet, len);
            out.write(cache, 0, cache.length);
 
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
 
        out.close();
 
        return out.toString(charset);
    }
}

 

龙生   20 Aug 2024
View Details

第9天：Python tupple（元组）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号()，列表使用方括号[]。

龙生   17 Aug 2024
View Details

第8天：Python list

Python 中的数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字、字符、甚至可以是其他数据结构 在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从 0 开始，以此类推……

龙生   16 Aug 2024
View Details

第7天：Python 数据结构--序列

Python 中的数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字、字符、甚至可以是其他数据结构 在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从 0 开始，以此类推…… 本文着重介绍 Python 的序列及其实际应用。

龙生   16 Aug 2024
View Details

第6天：Python 模块和包

模块(module)其实就是 py 文件，里面定义了一些函数、类、变量等
包(package)是多个模块的聚合体形成的文件夹，里面可以是多个 py 文件，也可以嵌套文件夹
库是参考其他编程语言的说法，是指完成一定功能的代码集合，在 Python 中的形式就是模块和包

龙生   16 Aug 2024
View Details
1 … 4 5 6 … 401