发表于   |   更新于 | 分类于 >
字数统计: 3.9k字 | 阅读时长 ≈ 15分钟

作为码农平时搜集一些小知识点个人认为是个不错的习惯，书上说

好记性不如烂笔头

我想即使是以前忽略或者新get的很简单的东西，自己动手记下来不管如何印象也会更深刻。

ZipOutputStream打包文件成一个zip，自定义写入文件夹和文件

Java实现将文件(包括压缩包)、文件夹压缩成zip，并且压缩包里面保留文件夹结构
参考链接、参考链接 、参考链接

Get请求且用?号形式传参，那么list参数必须加@RequestParam主键否则会报错

参考链接

Java7文件复制方法

Java源码中有Files.copy(source, target, options)方法，options可以不传值。
例如：D:/a.txt文件要复制到E:/xx/b.txt中，先要得到得到两文件的path。
Ps：这里要求目标文件b.txt文件不存在(存在会报错)，而且目标文件的路径必须要有，源代码方法中没有创建dir的方法。
参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
//要确认拷贝的路径存在
File destDir = new File("E:/xx");
if(!(destDir.exists()&& destDir.isDirectory())) {
	destDir.mkdirs();
}
File source = new File("D:/a.txt");
File dest = new File("E:/xx/b.txt");
try{
	Files.copy(source.toPath(), dest.toPath());
} catch (IOException e){
	// TODO Auto-generated catch block
	 e.printStackTrace();
}

linux查看进程占用端口的方法

方法一：
1、netstat -lntp
找到端口对应的应用的ID
2、ps -ef |grep 进程ID
方法二：
lsof -i:端口号
输出的列表的pid就是进程号

在Java的switch中使用枚举判断

在Java的switch中使用枚举的code或者name会报错，必须使用枚举类。
需要在枚举类中加入一个根据编码获取枚举类的方法。
参考代码如下：

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
/**
 * 审核状态枚举（预审页面）
 *
 * @author Chuenhung
 * @date 2021/10/12
 */
public enum PreApprovalStatusEnum {

	TO_APPROVAL("2", "待审核"),
	REJECT("3", "已退回"),
	AGREE("4", "审核通过");

	private final String code;
	private final String name;

	PreApprovalStatusEnum(String code, String name) {
		this.code = code;
		this.name = name;
	}

	public String getCode() {
		return code;
	}

	public String getName() {
		return name;
	}

	/**
	 * 根据编码获取枚举
	 *
	 * @param: code
	 * @return PreApprovalStatusEnum
	 * @author Chuenhung
	 * @date 2022/6/13
	 */
	public static PreApprovalStatusEnum getEnumByCode(String code) {
		if (StringUtil.isNotEmpty(code)) {
			for (PreApprovalStatusEnum enu : PreApprovalStatusEnum.values()) {
				if (code.equals(enu.getCode())) {
					return enu;
				}
			}
		}
		return null;
	}
}

// switch case示例代码
switch (PreApprovalStatusEnum.getEnumByCode(status)){
		case TO_APPROVAL:
			break;
		case REJECT:
			break;
		case AGREE:
			break;
		default:
	}

Ps: case后面的枚举不能带类名，否则会报"An enum switch case label must be the unqualified name of an enumeration constant"错误。
参考链接

MySQL创建的临时表会全表扫描，很影响性能

Nginx配置学习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
location /portal {
	proxy_pass http://10.12.7.182:7001;
	proxy_set_header Host $http_host;
	proxy_set_header X-Real-IP $remote_addr;
	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	proxy_set_header Cookie $http_cookie;
	client_max_body_size 1000m;
	fastcgi_buffers 8 256k;
	fastcgi_buffer_size 64k;
	gzip on;
	gzip_min_length 50k;
	gzip_comp_level 5;
	gzip_vary on;
}

该配置(portal、proxy_pass后面无/)举例：
原始请求链接：http://10.12.7.182:5001/portal/carousel/getList
实际请求链接：http://10.12.7.182:7001/portal/carousel/getList

1
2
3
4
5
6
7
8
9
10
11
12
13
14
location /portal/ {
	proxy_pass http://10.12.7.182:7001/;
	proxy_set_header Host $http_host;
	proxy_set_header X-Real-IP $remote_addr;
	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	proxy_set_header Cookie $http_cookie;
	client_max_body_size 1000m;
	fastcgi_buffers 8 256k;
	fastcgi_buffer_size 64k;
	gzip on;
	gzip_min_length 50k;
	gzip_comp_level 5;
	gzip_vary on;
  }

该配置(portal、proxy_pass后面有/)举例：
原始请求链接：http://10.12.7.182:5001/portal/carousel/getList
实际请求链接：http://10.12.7.182:7001/carousel/getList

Nginx配置返回文本或者JSON

参考代码如下：

1
2
3
4
5
6
7
8
9
location /proxy_reward/web/login/findemployeebyphone {
    default_type application/json;
	add_header Content-Type 'text/html; charset=utf-8';
    add_header Access-Control-Allow-Credentials true;
    add_header Access-Control-Allow-Origin *;
    add_header Cache-Control public;
    add_header Cache-Control max-age=300;
    return 200 '{"status":"200","data":{"companyId":"1781","name":"张三","mobile":"12345678901","email":"123@163.com"}}';
}

参考链接

Nginx负载均衡配置

参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
upstream test{
	server 192.168.0.1;
	server 192.168.0.2;
}

server{
	listen 80;
	server_name test.com;
	charset utf-8;

location /nacos {
	proxy_pass http://test/;
  }
}

参考链接

validation相关注解速查

参考链接

Git修改.gitignore文件修改后刷新

  • 刷新命令

    1
    2
    git rm -r --cached .
    git add .

  • 提交代码命令

    1
    2
    git commit -m "update .gitignore"
    git push origin

ApplicationContext发布事件和处理事件示例代码

要发布的事件：

1
2
3
4
5
6
7
@Getter
public class TransformDocEvent extends ApplicationEvent {

    public TransformDocEvent(Object source) {
        super(source);
    }
}

发布事件：

1
applicationContext.publishEvent(new TransformDocEvent(doc));

处理事件：

1
2
3
4
5
6
7
8
9
10
@Component
@Slf4j
public class TransformDocListener {

    @Async("MyThreadPool")
    @EventListener
    public void transform(TransformDocEvent event) {
       
    }
}

FastStone Capture有两种滚动截屏方式

1、按住CTRL键选取截取范围，再点击滚动条下面的向下箭头
2、点击鼠标左键即可自动捕捉窗口全部页面(适用于页面禁用滚动条的时候)

RestTemplate学习

1、RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。
2、调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。
3、ClientHttpRequestFactory接口主要提供了两种实现方式

  • 一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式）创建底层的Http请求连接。
  • 另一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。

RestTemplate的getForObject完成get请求、postForObject完成post请求、put对应的完成put请求、delete完成delete请求；还有execute可以执行任何请求的方法，需要你设置RequestMethod来指定当前请求类型。

参考链接

使用RestTemplate发送post请求

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// RestTemplate也可以通过@Autowired注入到Spring容器。 
RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers = new HttpHeaders();
MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
headers.setContentType(type);
headers.add("Accept", MediaType.APPLICATION_JSON.toString());

// 请求参数
Map<String, Object> map = new HashMap<>();
map.put("typeId",9);
map.put("dontQueryEmpty",true);
JSONObject jsonObj = new JSONObject(map);
HttpEntity<String> formEntity = new HttpEntity<String>(jsonObj.toString(), headers);

String url = "http://10.12.7.124:18081/manage/awards/querysecondclasslist";
String result = restTemplate.postForObject(url, formEntity, String.class);

如果直接使用在postForObject中把对象传入很容易出现no suitable HttpMessageConverter found for request type的错误，建议直接先转成字符串，见jsonObj.otString()。
使用RestTemplate调用接口确实非常优雅，几行代码就解决了。

Swagger常用注解

参考链接

使用IDEA合并远程其他分支到本地

  • 鼠标放到项目目录上右击
  • 点击Git
  • 点击Repository
  • 点击pull
  • 在Branchs to merge中选择远程分支

建议合并前把本地分支的代码先提交到远程仓库，方便解决冲突

@Transactional与@Async同时使用事务会失效

@Transactional与@Async同时使用事务会失效，在Transactional注解中的多线程也会导致事物失效
参考链接

事务失效问题解决：
方法一：@Async与@Transactional不使用在同一个方法上
方法二：手动提交事务及回滚事务
参考链接

方法三：将需要事务的方法放到另一个类中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Component
public class A {

    @Resource
    private B b;

    @Async
    public void test(){
        b.dd();
    }
}
@Component
public class B {

    @Transactional
    public void dd(){

    }
}

参考链接

经过测试，直接在service实现类的方法同时加两个注解，事务和多线程都不会失效。

1
2
3
4
5
6
7
8
achievementRepetitionService.checkAchievementRepetition();

@Override
@Transactional(rollbackFor = Exception.class)
@Async("RepetitionThreadPool")
public void checkAchievementRepetition() {

}

经过测试，service实现类的非异步方法调用异步方法，多线程失效，事务不会失效。

1
2
3
4
5
6
7
8
@Override
public void checkAchievementRepetition() {
	insert();
}
@Async("RepetitionThreadPool")
public void insert(){

}

几种常见限流算法(方式)

限流算法

  • 固定窗口算法
    固定窗口算法又叫计数器算法，是一种简单方便的限流算法。主要通过一个支持原子操作的计数器来累计 1 秒内的请求次数，当 1 秒内计数达到限流阈值时触发拒绝策略。每过 1 秒，计数器重置为 0 开始重新计数。
  • 滑动窗口算法
    固定窗口算法假如 QPS为2，但是当遇到时间窗口的临界突变时，如 1s 中的后 500 ms 和第 2s 的前 500ms 时，虽然是加起来是 1s 时间，却可以被请求 4 次。
    滑动窗口算法是对固定窗口算法的改进，可以每 500ms 滑动一次窗口，可以发现窗口滑动的间隔越短，时间窗口的临界突变问题发生的概率也就越小，不过只要有时间窗口的存在，还是有可能发生时间窗口的临界突变问题。
  • 滑动日志算法
    滑动日志算法是实现限流的另一种方法，这种方法比较简单。基本逻辑就是记录下所有的请求时间点，新请求到来时先判断最近指定时间范围内的请求数量是否超过指定阈值，由此来确定是否达到限流，这种方式没有了时间窗口突变的问题，限流比较准确，但是因为要记录下每次请求的时间点，所以占用的内存较多。
  • 漏桶算法
    漏桶算法中的漏桶是一个形象的比喻，这里可以用生产者消费者模式进行说明，请求是一个生产者，每一个请求都如一滴水，请求到来后放到一个队列（漏桶）中，而桶底有一个孔，不断的漏出水滴，就如消费者不断的在消费队列中的内容，消费的速率（漏出的速度）等于限流阈值。即假如 QPS 为 2，则每 1s / 2= 500ms 消费一次。漏桶的桶有大小，就如队列的容量，当请求堆积超过指定容量时，会触发拒绝策略。
  • 令牌桶算法
    令牌桶算法同样是实现限流是一种常见的思路，最为常用的 Google 的 Java 开发工具包 Guava 中的限流工具类 RateLimiter 就是令牌桶的一个实现。令牌桶的实现思路类似于生产者和消费之间的关系。
    系统服务作为生产者，按照指定频率向桶（容器）中添加令牌，如 QPS 为 2，每 500ms 向桶中添加一个令牌，如果桶中令牌数量达到阈值，则不再添加。
    请求执行作为消费者，每个请求都需要去桶中拿取一个令牌，取到令牌则继续执行；如果桶中无令牌可取，就触发拒绝策略，可以是超时等待，也可以是直接拒绝本次请求，由此达到限流目的。
  • Redis分布式限流
    Redis 是一个开源的内存数据库，可以用来作为数据库、缓存、消息中间件等。Redis 是单线程的，IO多路复用，又在内存中操作，所以速度极快，得益于 Redis 的各种特性，所以使用 Redis 实现一个限流工具是十分方便的。

总结

  • 窗口算法实现简单，逻辑清晰，可以很直观的得到当前的 QPS 情况，但是会有时间窗口的临界突变问题，而且不像桶一样有队列可以缓冲。
  • 桶算法虽然稍微复杂，不好统计 QPS 情况，但是桶算法也有优势所在。
    漏桶模式消费速率恒定，可以很好的保护自身系统，可以对流量进行整形，但是面对突发流量不能快速响应。
    令牌桶模式可以面对突发流量，但是启动时会有缓慢加速的过程，不过常见的开源工具中已经对此优化。

参考链接

SpringBoot使用Redis教程(共五步)

参考链接

用RestTemplate调用对方接口一直报400 Bad Request，但是用PostMan没问题

MediaType type = MediaType.parseMediaType(“application/json; charset=UTF-8”);
把charset=utf-8去掉就可以了，对方接口解析请求头有问题

EasyExcel大数据导入导出

思路：分批次查询(分页查询)+循环写入Excel，及时清理查询的list，防止OOM
1、查询出此次要导出的数据量count，根据count和自定义的每次查询数量size（我是10000）来计算出一共要查询n次。（防止一次查询数据量过大导致OOM）
2、循环n次，每次查询size大小的数据。然后导出到同一个sheet的excel中。注意，每次循环完clear掉list数据，防止占用内存
3、循环中会有一个问题，就是你在循环过程中别人新插入了数据怎么办，我的做法是最开始查询count的时候根据创建时间排序，获取最新的创建时间，然后后面的循环都使用这个创建时间作为搜索条件。这样就只会查询到和count相符合的数据了。
注意：导出数据超过6w条的时候excel格式要用xlsx。
参考链接、参考链接(含代码)、参考链接

EasyExcel大数据导入

思路：分批次写入数据库，及时清理读取的list，防止OOM
参考链接(含代码)

Windows查看CPU核数和线程数

方法一：
第一步：开始菜单->运行->cmd->输入 wmic
第二步(方法一)：
分别输入下面的命令：

1
2
3
4
5
6
wmic:root\cli>cpu get NumberOfCores
NumberOfCores
6
wmic:root\cli>cpu get NumberOfLogicalProcessors
NumberOfLogicalProcessors
12

第二步(方法二)

  • 输入 cpu get *
  • 底部滑动条往右拖
  • NumberOfCores为核数 NumberOfLogicalProcessors为逻辑cpu数(线程数)

方法二：
在任务管理器中的性能页面中查看，如下图所示：
在这里插入图片描述
方法三：
运行dxdiag命令

Linux查看物理CPU个数、CPU核心数、逻辑CPU的个数(线程数)、型号、内核信息

1、物理CPU数
实际机器中插槽上的CPU个数，查询命令如下：

1
2
[award_dev@localhost ~]$ cat /proc/cpuinfo |grep "physical id"|sort |uniq|wc -l
16

2、CPU核心数
一块物理CPU上能处理数据的芯片组数量。也就是说一个物理CPU上可能会有多个核心，日常中说的双核、四核就是指的CPU核心。查询命令如下：

1
2
[award_dev@localhost ~]$ cat /proc/cpuinfo |grep "cores"|uniq
cpu cores: 1

3、逻辑CPU的个数(线程数)
逻辑CPU数量=物理cpu数量 x CPU核心数 x 2(如果支持并开启ht)。
查询命令如下所示：

1
2
[award_dev@localhost ~]$ cat /proc/cpuinfo |grep "processor"|wc -l
16

从结果可以看出，我的机器不支持(或不开启)ht。
一般情况，我们认为一颗cpu可以有多核，加上intel的超线程技术(HT),可以在逻辑上再分一倍数量的cpu core出来；所以逻辑CPU的值理论上是可以超过100%的。

​
4、CPU数量及型号

1
2
[award_dev@localhost ~]$ cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
     16  Intel(R) Xeon(R) Gold 5118 CPU @ 2.30GHz

​
5、查看当前操作系统内核信息

1
2
[award_dev@localhost ~]$ uname -a
Linux localhost.localdomain 3.10.0-1160.el7.x86_64 #1 SMP Mon Oct 19 16:18:59 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

Ps：Linux下top查看的CPU也是逻辑CPU个数

参考链接、参考链接

超线程

一个CPU核可以执行一个线程，由英特尔开发超线程技术可以把一个线程模拟出两个线程来使用，使得单个核心用起来像两个核心一样，以充分发挥CPU的性能。
通常：逻辑CPU数量=物理cpu数量 x CPU核心数，若不相等则表示CPU支持超线程技术。

发表于 | 分类于 >
字数统计: 541字 | 阅读时长 ≈ 2分钟

1、SpringBoot的总体读取顺序优先级包外大于包内,properties大于yml。
2、 SpringBoot的总体读取顺序如下所示：

  • config/application.properties（项目同级目录中config目录下）
  • config/application.yml
  • application.properties（项目同级目录下）
  • application.yml
  • resources/config/application.properties（项目resources目录中config目录下）
  • resources/config/application.yml
  • resources/application.properties（项目的resources目录下）
  • resources/application.yml

项目同级目录，相当于生产环境中的JAR包。

阅读全文 »

发表于 | 分类于 >
字数统计: 1.6k字 | 阅读时长 ≈ 8分钟

需求概述

支持按勾选的成果申请记录批量下载附件。按"年份"+“成果名称"将对应的成果附件放入文件夹，最后将所有文件夹打包成一个压缩包，名称未"成果附件”+“下载时间(精确到秒)”。例如：
在这里插入图片描述
在这里插入图片描述

工具类

在网上找了个Zip压缩工具类，基本满足了我的需求，代码如下：

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
/**
 * Zip压缩工具类：支持压缩文件列表(包括压缩包)和文件夹
 *
 * @author chuenhung
 * @createTime 2022/06/08
 */
public class ZipUtil {

    private static final int BUFFER_SIZE = 2 * 1024;

    /**
     * @param srcFiles 需要压缩的文件列表
     * @param out 输出流
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void toZip(List<File> srcFiles ,OutputStream out) throws RuntimeException, FileNotFoundException {
        ZipOutputStream zos = null;
        try {
            zos = new ZipOutputStream(out);
            for (File srcFile : srcFiles) {
                byte[] buf = new byte[BUFFER_SIZE];
                zos.putNextEntry(new ZipEntry(srcFile.getName()));
                int len;
                FileInputStream in = new FileInputStream(srcFile);
                while ((len = in.read(buf)) != -1){
                    zos.write(buf, 0, len);
                }
                zos.closeEntry();
                in.close();
            }
        } catch (Exception e) {
            throw new RuntimeException("zip error from ZipUtil",e);
        }finally{
            if(zos != null){
                try {
                    zos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * @param srcFiles 需要压缩的文件列表
     * @param outDir 输出文件目录
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void toZip(List<File> srcFiles ,String outDir) throws RuntimeException, FileNotFoundException {
        OutputStream out = new FileOutputStream(new File(outDir));
        ZipOutputStream zos = null;
        try {
            zos = new ZipOutputStream(out);
            for (File srcFile : srcFiles) {
                byte[] buf = new byte[BUFFER_SIZE];
                zos.putNextEntry(new ZipEntry(srcFile.getName()));
                int len;
                FileInputStream in = new FileInputStream(srcFile);
                while ((len = in.read(buf)) != -1){
                    zos.write(buf, 0, len);
                }
                zos.closeEntry();
                in.close();
            }
        } catch (Exception e) {
            throw new RuntimeException("zip error from ZipUtil",e);
        }finally{
            if(zos != null){
                try {
                    zos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * @param outDirList 压缩文件夹路径
     * @param KeepDirStructure 是否保留原来的目录结构,
     * 			true:保留目录结构;
     *			false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void toZip(List<String> outDirList, OutputStream out,
                             boolean KeepDirStructure) throws RuntimeException, Exception {

        ZipOutputStream zos = null;
        try {
            zos = new ZipOutputStream(out);
            List<File> sourceFileList = new ArrayList<>();
            for (String dir : outDirList) {
                File sourceFile = new File(dir);
                sourceFileList.add(sourceFile);
            }
            compress(sourceFileList, zos, KeepDirStructure);
        } catch (Exception e) {
            throw new RuntimeException("zip error from ZipUtil", e);
        } finally {
            if (zos != null) {
                try {
                    zos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * 递归压缩方法
     * @param sourceFile 源文件
     * @param zos zip输出流
     * @param name 压缩后的名称
     * @param KeepDirStructure 是否保留原来的目录结构,
     * 			true:保留目录结构;
     *			false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     * @throws Exception
     */
    private static void compress(File sourceFile, ZipOutputStream zos,
                                 String name, boolean KeepDirStructure) throws Exception {
        byte[] buf = new byte[BUFFER_SIZE];
        if (sourceFile.isFile()) {
            zos.putNextEntry(new ZipEntry(name));
            int len;
            FileInputStream in = new FileInputStream(sourceFile);
            while ((len = in.read(buf)) != -1) {
                zos.write(buf, 0, len);
            }
            // Complete the entry
            zos.closeEntry();
            in.close();
        } else {
            File[] listFiles = sourceFile.listFiles();
            if (listFiles == null || listFiles.length == 0) {
                if (KeepDirStructure) {
                    zos.putNextEntry(new ZipEntry(name + "/"));
                    zos.closeEntry();
                }

            } else {
                for (File file : listFiles) {
                    if (KeepDirStructure) {
                        compress(file, zos, name + "/" + file.getName(),
                                KeepDirStructure);
                    } else {
                        compress(file, zos, file.getName(), KeepDirStructure);
                    }

                }
            }
        }
    }

    private static void compress(List<File> sourceFileList,
                                 ZipOutputStream zos, boolean KeepDirStructure) throws Exception {
        byte[] buf = new byte[BUFFER_SIZE];
        for (File sourceFile : sourceFileList) {
            String name = sourceFile.getName();
            if (sourceFile.isFile()) {
                zos.putNextEntry(new ZipEntry(name));
                int len;
                FileInputStream in = new FileInputStream(sourceFile);
                while ((len = in.read(buf)) != -1) {
                    zos.write(buf, 0, len);
                }
                zos.closeEntry();
                in.close();
            } else {
                File[] listFiles = sourceFile.listFiles();
                if (listFiles == null || listFiles.length == 0) {
                    if (KeepDirStructure) {
                        zos.putNextEntry(new ZipEntry(name + "/"));
                        zos.closeEntry();
                    }

                } else {
                    for (File file : listFiles) {
                        if (KeepDirStructure) {
                            compress(file, zos, name + "/" + file.getName(),
                                    KeepDirStructure);
                        } else {
                            compress(file, zos, file.getName(),
                                    KeepDirStructure);
                        }
                    }
                }
            }
        }
    }
}

业务中需要删除临时文件夹以及下面的所有文件，用到的工具类代码如下所示：

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
/**
 * 文件工具类
 * @author chuenhung
 * @createTime 2022/06/09
 */
public class FileUtils {

    /**
     * 删除文件或文件夹
     *
     * @param: file 如果是文件删除该文件，如果是文件夹删除该文件夹以及下面的所有文件
     * @return void
     * @author chuenhung
     * @date 2022/6/9/
     */
    public static void deleteFile(File file) {
        if (file.isFile()) {
            file.delete();
        } else {
            String[] childFilePaths = file.list();
            for (String childFilePath : childFilePaths) {
                File childFile = new File(file.getAbsolutePath() + "/" + childFilePath);
                deleteFile(childFile);
            }
            file.delete();
        }
    }
}

参考链接1、参考链接2

业务代码

核心逻辑就是要把每个成果申请的所有文件放入到成果申请临时文件夹中，成果申请临时文件夹名：“年份”+“成果名称”，然后对每个成果申请文件夹压缩，最后删除临时文件夹。我在代码中也有详细地写注释，业务代码如下所示：

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
@Override
public void batchDownload(HttpServletResponse response, HttpServletRequest request, List<Long> idList) throws Exception {
	// 1、参数校验
	if(CollectionUtil.isEmpty(idList)){
		throw new CommonsException(MessageCode.PARAM_NULL);
	}
	// 2、设置response相关内容(包括文件名)
	StringBuilder builder = new StringBuilder();
	builder.append("成果附件");
	builder.append(DateUtil.getNowDate("yyyyMMddHHmmss"));
	builder.append(".zip");
	String fileName =  HttpHelper.createDownloadFileName(builder.toString());
	response.setCharacterEncoding("UTF-8");
	response.setContentType("application/force-download");
	response.setHeader("Content-Disposition", "attachment; filename="+fileName);
	// 3、根据成果主键批量查询成果信息
	Map<String,Object> map = new HashMap<>();
	map.put("idList",idList);
	List<AchievementApplication> applicationList = achievementApplicationMapper.queryAchievementApplicationList(map);
	if(CollectionUtil.isEmpty(applicationList)){
		throw new CommonsException(MessageCode.DATA_NOT_FOUND);
	}
	// 4、把每个成果申请的所有文件放入到成果申请临时文件夹中，成果申请临时文件夹名：年份+成果名称
	// 每一个压缩的成果附件路径
	List<String> outDirList = new ArrayList<>();
	for(AchievementApplication application: applicationList){
		if(StringUtil.isNotEmpty(application.getAttachment())){
			List<AttachmentFileBo> attachmentFileBoList = attachmentService.listFormalAttachmentFile(application.getAttachment());
			if(CollectionUtil.isNotEmpty(attachmentFileBoList)){
				// 成果申请临时文件夹名：年份+成果名称
				builder.delete(0,builder.length());
				builder.append(application.getYear());
				builder.append("-");
				builder.append(application.getName());
				// 循环对每个成果申请的所有文件压缩
				List<String> fileNameList = new ArrayList<>();
				// 每个成果的临时复制后存放的文件夹，之后对这个文件夹压缩
				String outDir = attachementUploadUrl+builder.toString();
				File outDirFile = new File(outDir);
				outDirFile.mkdirs();
				for(AttachmentFileBo fileBo: attachmentFileBoList){
					// 每个成果如有重复附件名则不处理
					if(!fileNameList.contains(fileBo.getFileName())){
						File sourceFile = new File(attachementUploadUrl+fileBo.getFileSaveName());
						if (!sourceFile.exists()) {
							log.error("AchievementApplicationServiceImpl.batchDownload附件{}丢失",fileBo.getFileName());
							throw new CommonsException(MessageCode.ATTACHMENT_LOST, "附件：" + fileBo.getFileName() + "丢失");
						}
						// 复制到临时文件夹
						File destinctFile = new File(outDir+"/"+fileBo.getFileName());
						Files.copy(sourceFile.toPath(), destinctFile.toPath());
					}
					fileNameList.add(fileBo.getFileName());
				}
				outDirList.add(outDir);
			}
		}
	}
	// 4、对成果申请文件夹压缩
	if(CollectionUtil.isNotEmpty(outDirList)){
		ZipUtil.toZip(outDirList, response.getOutputStream(),true);
	}
	// 5、删除临时文件夹
	for(String outDir: outDirList){
		File file = new File(outDir);
		FileUtils.deleteFile(file);
	}
}

发表于   |   更新于 | 分类于 >
字数统计: 1.9k字 | 阅读时长 ≈ 8分钟

作为码农平时搜集一些小知识点个人认为是个不错的习惯，书上说

好记性不如烂笔头

我想即使是以前忽略或者新get的很简单的东西，自己动手记下来不管如何印象也会更深刻。

mybatis的配置打印的是info级别日志 线上环境建议去除

1
2
3
4
5
6
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  configuration:
    #打印sql
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    call-setters-on-nulls: true

MySQL的GROUP_CONCAT给值加上单引号后再拼接

语法：

1
SELECT GROUP_CONCAT(DISTINCT '''',待拼接字段,'''') FROM 表名

示例代码：

1
2
select GROUP_CONCAT(DISTINCT '''',company,'''')  from t_awards_detail WHERE company_type='1';
UPDATE t_awards_detail SET company_type='3'

返回数据：
‘上海产业研究院’,‘上海公司’,‘上海曦智科技有限公司’

Linux查询某个进程JVM占用情况

语法：

1
jstat -gc 进程号  刷新时间

示例代码：

1
2
-- 查询进程6126的JVM占用情况 每隔3秒刷新一次
jstat -gc 6126 3000

Linux查询某个进程CPU、内存占用情况

1
top -H -p 进程id

MySQL的concat()、concat_ws()和group_concat()的用法

group_concat()对多字段拼接操作示例代码：

1
group_concat(column1,'拼接字符串'column2 SEPARATOR '分割字符串')

例如，筛选不同状态的数量、部门和用户拼接数据sql如下：

1
2
3
SELECT STATUS,COUNT(id),GROUP_CONCAT(reply_department,'-',reply_user SEPARATOR '、') 
FROM t_sub_order WHERE main_order_id='1'
GROUP BY status

查询结果如下所示：
在这里插入图片描述
参考链接

Java导出大批量数据的优化过程

  • 使用EasyExcel生成导出文件流
  • 异步把文件流上传到服务器，成功后更新文件上传状态
  • 用户去页面下载
    10W+ 的数据从生成Excel文件流到上传只要8秒，原来约要8分钟。
    参考链接

request.getParameter(“ticket”)方法

  • 接口传参为form表单格式提交，即Content-Type为application/x-www-form-urlencoded类型
  • /web/auth/v1/login/getUserRight?ticket=1234567。
    只有这两种格式可以取到参数,取不到JSON格式的参数。

MySQL按中文拼音字母排序

如果表字段使用的GBK编码的话，我们可以直接order by value ，因为GBK本身就是按照拼音字母排序ABCDEFGHIGK…，当第一位相同的时候会比较第二位，以此类推。 如果表字段使用的UTF-8编码的话，通常我们都会的编码，这样我们可以使用MySQL的convert方法开转换gbk进行排序。
举例:

1
SELECT * FROM TEST ORDER BY CONVERT(value USING GBK) ASC/DESC

自定义排序

自定义排序是根据自己想要的特定字符串（数字）顺序进行排序。
主要是使用函数 FIELD(str,str1,str2,str3,…)
MySQL的自定义排序，str与str1、str2、str3…进行比较，并按照str1,str2,str3…的顺序输出，如果遇到str为null或者不存在str1,str2,str3…中的情况的则序列为0，
例1:

1
SELECT * FROM TEST ORDER BY FIELD(value,'test1','test2','test3','test4') ASC/DESC

例2:

1
SELECT * FROM TEST WHERE VALUE IN('test1','test2','test3','test4') ORDER BY FIELD(value,'test1','test2','test3','test4') ASC/DESC

自定义排序(详细)

  • case when 转换实现自定义排序
  • mysql排序函数filed 实现自定义排序（推荐）
  • 函数locate 实现自定义排序
  • 函数lnstr 实现自定义排序
  • 利用数据字典实现自定义排序

参考链接

Linux将一个服务器上的文件或者文件夹复制到另一个服务器上

scp命令

命令语法：

1
2
3
4
5
6
7
8
9
10
11
// 从本地主机传输文件到远程主机
scp [本地文件路径] [用户名]@[远程主机IP地址]:[目标路径]

// 从远程主机传输文件到本地主机
scp [用户名]@[远程主机IP地址]:[远程文件路径] [本地目标路径]

// 传输整个目录
scp -r [本地目录路径] [用户名]@[远程主机IP地址]:[目标路径]

// 指定端口
scp -P [端口号] [本地文件路径] [用户名]@[远程主机IP地址]:[目标路径]

示例：

1
[award_dev@localhost ~]$ scp -r /opt/aspire/product/award_dev/testMove award_dev@10.12.7.182:/home/award_dev/
1
2
3
4
5
6
7
The authenticity of host '10.12.7.182 (10.12.7.182)' can't be established.
ED25519 key fingerprint is SHA256:2wVRM0wwyLswkz2qgc/osZnRRvMlLRYrOSrHqTUVqVA.
This host key is known by the following other names/addresses:
    ~/.ssh/known_hosts:1: 10.12.7.124
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '10.12.7.182' (ED25519) to the list of known hosts.
award_dev@10.12.7.182's password:

密码输入成功就可以迁移过去，不过存在中文文件名的会有问题(文件名改为了数字且内容为空)。

解决中文文件名迁移问题：
1、现在本地机器给待迁移文件夹打压缩包
命令： tar -zcvf filename.tar.gz dir/file
2、scp命令迁移到新服务器
3、在新服务器中解压
命令： tar -zxvf tarname.tar.gz -C 指定解压后文件存放地址
参考链接1、参考链接2

如果远程服务器是sftp服务器，用scp命令可能会不成功，这时候需要使用sftp命令传输。

sftp命令

命令语法:

1
sftp -oPort=[端口号] [用户名]@[ip地址]

使用示例:
先进入本机待传文件的目录 -> 用命令连接上远程sftp服务器 -> 进入远程待接收文件的目录 -> put 文件名

1
2
3
4
5
6
7
8
9
10
[award_server@localhost jlwz-innovation]$ sftp -oPort=55521 package@10.217.247.13
Authorized only. All activity will be monitored and reported
package@10.217.247.13's password:
Connected to 10.217.247.13.

sftp> cd /upload/jlwz/testsftp/
sftp> put reward-innovation-1.0.0.1-SNAPSHOT.jar
Uploading reward-innovation-1.0.0.1-SNAPSHOT.jar to /upload/jlwz/testsftp/reward-innovation-1.0.0.1                       -SNAPSHOT.jar
reward-innovation-1.0.0.1-SNAPSHOT.jar                                                  100%  221MB   1.8MB/s   02:02    s
sftp>

spring占位符打印日志

1
2
3
4
5
try{
	int zero = 2/0;
}catch (Exception e){
	log.error("测试占位符打印日志,{},{}",null,b,e);
}

1、前面的参数必须和占位符一一对应。
2、最后面参数是异常信息可以打印，非异常信息不会打印。
3、占位符的值可以为null。

Linux复制文件夹下面的所有文件到另一个文件夹

1
cp -r 当前路径/* 目标路径

注意：目标路径必须先存在。
例如：

1
cp -r /home/award_dev/nginx-1.20.2/conf/* /usr/local/nginx/conf

Nginx指定安装位置

默认位置是/usr/local/nginx，需要进入nginx-1.20.2目录后执行下面的命令
./configure --prefix=/home/award_dev/nginx
参考链接

Nginx安装步骤

参考链接

Linux查看端口

1
netstat -anp | grep 8888

SpringBoot+Vue.js前后端分离实现大文件分块上传

参考链接

Java 8 Predicate

参考链接

SpringCloud读取配置中心配置

需要引入下面的依赖

1
2
3
4
5
6
7
8
9
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<!-- bootstrap依赖，加载bootstrap.yml-->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

客户端添加spring-cloud-starter-config依赖后 会默认最高优先级读取(即使bootstrap.yml不配置)localhost:8888链接下的application.yml配置。
具体可以通过http://10.12.7.182:8888/应用名(对应bootstrap引导文件中的config.name配置)/profile 访问查看读取的配置 例如：http://10.12.7.182:8888/webbas32-gateway-v1/dev
或者直接访问文件 http://10.12.7.182:8888/webbas32-application-gateway-v1-dev.yml
spring-cloud-starter-bootstrap依赖非必须
参考链接

SpringBoot的jasypt加解密

StringEncryptor类中有加解密方法
配置文件配置ENC(“密文”)后，@Value注解可以自动解密
参考链接1、参考链接2