Posts on YuanEr'Blog

Disruptor高性能分析

Mon, 06 Jan 2025 00:00:00 +0000

Disruptor高性能分析

Disruptor是高性能的无锁有界内存队列。日志框架Log4j2也正是利用Disruptor带来的极大的性能提升。

1.内存分配

使用RingBuffer数据结构，本质还是数组，数组元素在初始化的时候一次性创建，提高缓存命中率；对象循环利用，避免频繁垃圾回收。

因为数组元素是初始化一次性创建，所以数组元素分配的内存大概率也是连续内存。很好的利用了局部性原理，充分利用CPU缓存。

 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


 RingBufferFields(
 EventFactory<E> eventFactory,
 Sequencer sequencer)
 {
 this.sequencer = sequencer;
 this.bufferSize = sequencer.getBufferSize();

 if (bufferSize < 1)
 {
 throw new IllegalArgumentException("bufferSize must not be less than 1");
 }
 if (Integer.bitCount(bufferSize) != 1)
 {
 throw new IllegalArgumentException("bufferSize must be a power of 2");
 }

 this.indexMask = bufferSize - 1;
 this.entries = new Object[sequencer.getBufferSize() + 2 * BUFFER_PAD];
 fill(eventFactory);
 }

 private void fill(EventFactory<E> eventFactory)
 {
 for (int i = 0; i < bufferSize; i++)
 {
 entries[BUFFER_PAD + i] = eventFactory.newInstance();
 }
 }

RingBufferFields是RingBuffer的抽象父类，RingBuffer的构造方法是直接调用父类的构造方法。

可以在源码中发现RingBufferFields在初始化的时候就已经对数组的每一个元素都填充了Event，这里的Event对象并不是一个事件new一个Event对象，而是新事件直接替换Event的属性值。Event类是需要自定义实现的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


 public class Event {
 /**
 * 事件
 */
 private E event;

 // 设置事件的值
 public void setValue(E event) {
 this.event = event;
 }
 // 重写 toString 方法，用于调试时打印事件信息
 @Override
 public String toString() {
 return "Event{" + "event=" + event + '}';
 }
 }

连续内存，这里就能很好的利用空间局部性原理：某一块内存一旦被访问，不久之后这块内存附近的内存也很有可能被访问，而CPU的缓存在设计的时候也正是利用了局部性原理。同时消费者在消费的时候，也会按照这种连续的顺序去消费事件，那么如果这些连续的事件的内存空间也是连续的，就能够充分利用到空间局部性原理，消费的时候大概率能直接从缓冲中读取到，而不用再从内存中去加载。

缓存的的读写速率比内存高很多倍，CPU缓存设计的初衷就是解决处理器与内存之间的速度差异所带来的性能瓶颈

2.避免伪共享

伪共享问题：

伪共享（False Sharing）是一种与多线程编程和CPU缓存相关的性能问题。它指的是多个线程同时访问不同但位于同一缓存行（Cache Line）的数据，导致频繁的缓存失效和数据同步操作，从而降低了程序的性能。

CPU缓存以缓存行为单位进行读取和写入操作，一般缓存行的大小为64字节（在大多数情况下）。当多个线程同时访问不同的变量，但这些变量位于同一个缓存行时，由于缓存一致性协议的限制，每次一个线程更新缓存行中的某个变量时，会导致该缓存行的所有数据都失效，其他线程访问缓存行中的其他变量时，需要重新从主内存加载数据，造成额外的缓存失效和数据同步开销。

伪共享问题可能导致程序性能显著下降，特别是在多核处理器上运行多线程程序时，由于多个线程之间的竞争和数据同步带来的开销。

Disruptor解决伪共享问题：

通过特殊的结构，很好的避免的伪共享问题。提升缓存的命中率。

可已在Sequence的源码中发现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class LhsPadding
{
 protected long p1, p2, p3, p4, p5, p6, p7;
}

class Value extends LhsPadding
{
 protected volatile long value;
}

class RhsPadding extends Value
{
 protected long p9, p10, p11, p12, p13, p14, p15;
}

public class Sequence extends RhsPadding{
 //`````
}

Sequence的value属性值可以看到原本8个字节的value，在前后都嵌入了7个long类型，value前面56字节，后面也是56个字节。因为缓存是按照缓存行进行缓存的读取和移除的，大部分处理器的缓存行都是按照64字节为一个缓存行，这样的设计就能保证value必定能够独享一个缓存行，也就避免的伪共享问题。但是可以看到这种方式内存浪费是很严重的。

3.无锁算法

通过无锁算法，避免了频繁的加锁解锁带来的性能开销。

核心就是CAS,和无限循环。

参考资料：

https://ifeve.com/disruptor-cacheline-padding/

API接口调用鉴权~思考

Mon, 12 Aug 2024 00:00:00 +0000

API接口调用鉴权~思考

1.AK/SK(aksk)鉴权

1.1 概述

统一签名认证（ak+sk+时间戳+随机字符串+防重放+防篡改） AK：Access Key Id，用于标示用户。 SK：Secret Access Key，是用户用于加密认证字符串和用来验证认证字符串的密钥，其中SK必须保密。

适用场景：对指定的客户提供接口服务。需要有配套的密钥生成分发系统。客户需要找密钥系统注册提供一些身份信息，用以和生成的密钥做信息绑定（也能方便后期统计接口调用相关信息）。AK当做客户的唯一标识（类似账号），对其他有用参数（包括真正参数，以及时间戳，请求唯一标识等）进行拼接再混合SK，最后进行某种不可逆的摘要算法计算得出一个字符串，作为签名参数一同传递。

1.2 大致流程

客户获取AK/SK

客户在配套的系统中注册。申请创建AK/SK，系统生成AK（后期将作为标识，建议使用UUID或其他能确保唯一性的值）以及SK（这个虽然不要求唯一性，但是也是需要有一定复杂度，防止被暴力破解），通过安全的方式传递给客户。同时我们的系统也将存储配套的AK/SK。

客户构建请求

客户现在需要调用我们的接口。假设现在和请求业务相关的参数有name=lihua;age=12,构建的请求实际所需要的参数有如下

1
2
3
4
5
6


name=v1
age=v2
access-key=v3
timestamp=v4
random=v5
signature=v6

前两个是业务参数，第三个参数是申请的AK，第三个参数是时间戳，第四个是随机字符串，第6个参数是签名字符串。

之后就是进行签名，计算signature的值v6，一般来说需要对上面有用的参数都需要进行签名。

首先是根据参数名（除了signature签名）进行排序（当然也有其他的排序方式，但是需要提前和服务端沟通，确保验证的时候能同样使用这种方式）

排序之后进行拼接

1

TMP=access-key=v3age=v2name=v1random=v5timestamp=v4

这时候就需要用到我们同时得到的SK了。也拼接在后面，再进行不可逆摘要算法计算

v6=MD5(TMP+SK)

就得到了signature签名的值

然后就将上面那些参数构建成相应的请求发送给服务端

服务端验证请求

首先需要做的就是验证时间戳，通过时间戳判断是否是合法的时间发送的请求，这里需要做的就是比较服务端当前时间和请求中的时间戳是否时间差距过大（这个时间差需要根据情况来设定）。时间戳超时的请求直接返回异常。

然后根据access-key到系统数据库中去找对应的SK，如果不能正常找到，那么就是非法请求，直接异常。能找到的话，服务器就再次根据请求的相关参数进行构建signature，构建出来后和请求中的signature一致就是合法请求，继续业务流程。不一致就是非法请求，直接异常。

1.3 为什么能防止篡改

因为signature的构建是根据请求中的实际参数进行计算得到。同时融入了SK（这个必须要保证保密性，不可外露），所以一旦请求的参数被中途篡改了，签名就会失效，那么就会导致服务端计算的signature和请求中的不一致，会被判定成非法请求。

1.4 为什么能防止重放

参数携带时间戳，请求具有时效性，过期请求会变成非法请求。

同时还有一个 random随机字符串参数，这个在服务端处理的时候，把random放进一个集合中，同时设置一定的过期时间，在验证请求的时候，如果random已经存在，说明已经响应过这个请求，这是就可以直接异常，或者将上一次的缓存的响应结果直接返回。

Java代码实现

1

后续补充

2. appID+appKey+appSecret实现权限分配

2.1概述

appID用于标识某个大型应用，appKey+appSecret是成对分配的，一个appID下可以分配多套appKey+appSecret

这里通过appID用于标识应用，下面的可以申请多个appKey，同时对这些不同的appKey配置不同的权限，（某些appKey只能调用GET查询请求，只有高级一点的才能调用其他类型的敏感请求等，具体如何分配权限，根据具体情况设计）

2.2 大致流程

大致流程和上面1AK/SK(aksk)鉴权差不多，只是多了个用于接口验证的参数

获取Spring中所有web请求接口的path和method

Mon, 29 Jul 2024 00:00:00 +0000

获取Spring中所有web请求接口的path和method

1.概述

最近在开发一个项目的过程中，遇到一个需求，需要去汇总拿到系统中所有的请求接口，然后集中进行一些处理。我这里大概有两种思路：

众所周知，接口都是定义在Controller层的，我们通过Spring容器拿到那些Controller层的Bean的class，然后通过反射拿到所有的该类方法，然后依次获取每个方法的注解（主要是获取那几个和RequestMapping相关注解），这种方案我写到一半，觉得太过于繁琐了，这里需要考虑的情况有很多，
1. 可以使用@RestController()和@Controller标注控制层。
2. Controller类上面也可以有@RequestMapping注解，
3. @RequestMapping注解的变形又还有5种，GetMapping, PostMapping, PutMapping, DeleteMapping, PatchMapping
4. Mapping注解又有两个属性可用于定义path，默认值value和path,而且均是数组的形式。
5. 路径参数上/的兼容也很难处理，有些开发者开头不写/,有些又要写这玩意儿。
我写着写着，代码越来越复杂，有点像屎山了。就想到了另外一种方案。
使用spring开发web应用的时候，要能够处理请求映射关系是肯定会提前收集好对应的路径和handler之间的映射关系的，然后我就从DispatcherServlet的doDispatch方法开始调试代码，很明显会在里面的 mappedHandler = getHandler(processedRequest);方法调用中获取到handler。调试进入，

可以看到就是在遍历handlerMappings

去查了一下这几个handlerMapping的资料。

RequestMappingHandlerMapping：
- 这是Spring MVC中用于处理基于注解的请求映射的核心组件。
- 它主要处理带有 @RequestMapping、@GetMapping、@PostMapping 等注解的方法。
- 通过这些注解，你可以将HTTP请求映射到特定的方法上，从而处理不同的请求。
BeanNameUrlHandlerMapping：
- 这是一个简单的URL到处理器映射策略，它将URL路径映射到Bean的名称。
- 通常不推荐使用，因为它依赖于Bean的名称，而不是更灵活的路径表达式或注解。
RouterFunctionMapping：
- 这是Spring WebFlux的一部分，用于处理基于函数式编程的路由。
- 它允许你使用函数式编程风格来定义路由，而不是传统的Controller方法。
- 这种方式更适用于响应式编程模型，例如使用 RouterFunctions 定义路由。
SimpleUrlHandlerMapping：
- 这是一个简单的URL到处理器映射器，它允许你通过代码配置URL到处理器的映射。
- 它不依赖于注解，而是通过在Spring配置中显式定义URL和处理器的映射关系。
WelcomePageHandlerMapping：
- 这个映射器用于处理欢迎页面的请求。
- 当一个目录请求被发送到服务器时（例如访问根目录 /），它会被映射到欢迎页面。
- 通常用于定义默认页面或目录索引页面。

不难看出来，满足我们需求的就是RequestMappingHandlerMapping，调试的时候仔细看了一下，确实找到了路径到handler的映射

之后就是从spring容器中获取这个bean，然后进行各种路径收集等操作。

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


package com.ruayou.client.manager;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @Author：ruayou
 * @Date：2024/7/18 0:22
 * @Filename：RequestPathFinder
 */
public class RequestPathFinder implements ApplicationContextAware {

 ApplicationContext applicationContext;
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 this.applicationContext = applicationContext;
 }

 public Set<String> getAllRequestPath() {
 HashSet<String> set = new HashSet<>();
 RequestMappingHandlerMapping mapping = applicationContext.getBean(RequestMappingHandlerMapping.class);
 for (Map.Entry<RequestMappingInfo, HandlerMethod> requestMappingInfoHandlerMethodEntry : mapping.getHandlerMethods().entrySet()) {
 RequestMappingInfo key = requestMappingInfoHandlerMethodEntry.getKey();
 Set<String> patternValues = key.getPatternValues();
 RequestMethodsRequestCondition methods = key.getMethodsCondition();
 patternValues.forEach((pa)->{
 if (!methods.isEmpty()) {
 methods.getMethods().forEach((m)->{
 set.add(m.name()+" "+pa);
 });
 }
 });
 }
 set.forEach(s -> System.out.println(s)
 );
 return set;
 }
}

方法的运行结果如上图，可以正确获取到自己定义的接口（必须是通过注解定义的才能获取到！）

关于SpringBoot打Jar包

Mon, 10 Jun 2024 00:00:00 +0000

关于SpringBoot打Jar包

1.概述

之前开发spring-boot项目一般都是直接制作一个可执行的jar包（当时只会这种方式😀），这种方式制作出来的jar十分庞大，往往都是几十上百兆的文件大小，有时候对项目只是简单的修改，重新打包，然后去部署的时候，往往需要传一个庞大的jar包上去，还是挺不友好的。后面就花时间了解了一下关于打Jar包相关的类容。还有一种是打成war包。

主要讲述两种常见的打包方式，一种是通过spring-boot-maven-plugin插件制作完整的包含依赖的可执行jar，另外一种是maven-jar-plugin打包出来的依赖分离的方式。

2.spring-boot-maven-plugin制作可执行jar包

在pom.xml中build配置

 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


<build>
 <plugins>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.8.1</version>
 <configuration>
 <source>1.8</source>
 <target>1.8</target>
 <encoding>UTF-8</encoding>
 </configuration>
 </plugin>

 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 <version>${spring-boot.version}</version>
 <configuration>
 <mainClass>com.ruayou.springspitest.SpringSpiTestApplication</mainClass>
 <skip>false</skip>
 </configuration>
 <executions>
 <execution>
 <id>repackage</id>
 <goals>
 <goal>repackage</goal>
 </goals>
 </execution>
 </executions>
 </plugin>
 </plugins>
 </build>

使用上述的插件打包之后的jar包结构是这样的，只是一个很简易的项目，依赖并不多，但是jar包文件大小来到了8.5m

在Java项目中，Manifest.MF文件是JAR文件的清单文件，它包含了JAR包的元数据信息,所以这里重点关注一下\META-INF\MANIFEST.MF文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven 3.8.6
Built-By: yuaner
Build-Jdk: 17.0.9
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.ruayou.springspitest.SpringSpiTestApplication
Spring-Boot-Version: 2.6.13
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Spring-Boot-Layers-Index: BOOT-INF/layers.idx

这里发现一个问题，我们实际在pom.xml文件中配置的mainClass是

<mainClass>com.ruayou.springspitest.SpringSpiTestApplication</mainClass>

但是清单文件中的Main-Class: org.springframework.boot.loader.JarLauncher，

我们自己配置的是Start-Class: com.ruayou.springspitest.SpringSpiTestApplication

我们确实能在jar包中根据这个包路径找到这个JarLauncher

用idea打开这个字节码文件，可以实现反编译。(

后面发现更好的方式😀

1
2
3
4


<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-loader</artifactId>
</dependency>

在项目依赖中引入，就可以直接利用idea下载源码查看啦。这个依赖是引入了springboot打包插件的时候打包自动集成到jar包的。引入之后可以直接在项目中搜索需要查看到的类

)

我们可以看到这个字节码文件的大致代码是

 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


public class JarLauncher extends ExecutableArchiveLauncher {
 private static final String DEFAULT_CLASSPATH_INDEX_LOCATION = "BOOT-INF/classpath.idx";
 static final Archive.EntryFilter NESTED_ARCHIVE_ENTRY_FILTER = (entry) -> {
 return entry.isDirectory() ? entry.getName().equals("BOOT-INF/classes/") : entry.getName().startsWith("BOOT-INF/lib/");
 };

 public JarLauncher() {
 }

 protected JarLauncher(Archive archive) {
 super(archive);
 }

 protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
 if (archive instanceof ExplodedArchive) {
 String location = this.getClassPathIndexFileLocation(archive);
 return ClassPathIndexFile.loadIfPossible(archive.getUrl(), location);
 } else {
 return super.getClassPathIndex(archive);
 }
 }

 private String getClassPathIndexFileLocation(Archive archive) throws IOException {
 Manifest manifest = archive.getManifest();
 Attributes attributes = manifest != null ? manifest.getMainAttributes() : null;
 String location = attributes != null ? attributes.getValue("Spring-Boot-Classpath-Index") : null;
 return location != null ? location : "BOOT-INF/classpath.idx";
 }

 protected boolean isPostProcessingClassPathArchives() {
 return false;
 }

 protected boolean isSearchCandidate(Archive.Entry entry) {
 return entry.getName().startsWith("BOOT-INF/");
 }

 protected boolean isNestedArchive(Archive.Entry entry) {
 return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
 }

 public static void main(String[] args) throws Exception {
 (new JarLauncher()).launch(args);
 }
}

确实存在一个main方法，其实不难看出这里执行的就是加载"BOOT-INF/classpath.idx"文件和"BOOT-INF/lib/"下的文件。

索引文件实际就是列举了项目中依赖的jar路径，也就是我们制作的这个巨大的jar包是包含了项目的所有依赖的。

我们继续细看main方法执行的launch方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


protected void launch(String[] args) throws Exception {
 if (!this.isExploded()) {
 JarFile.registerUrlProtocolHandler();
 }

 ClassLoader classLoader = this.createClassLoader(this.getClassPathArchivesIterator());
 String jarMode = System.getProperty("jarmode");

 String launchClass = jarMode != null && !jarMode.isEmpty() ? "org.springframework.boot.loader.jarmode.JarModeLauncher" : this.getMainClass();
 this.launch(args, launchClass, classLoader);
}

可以看到就是创建了一个类加载器去加载什么东西？具体怎么加载，是一个方法调用，下面会跟进。

在创建类加载器的时候this.getClassPathArchivesIterator()

 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


@Override
protected Iterator<Archive> getClassPathArchivesIterator() throws Exception {
 Archive.EntryFilter searchFilter = this::isSearchCandidate;
 Iterator<Archive> archives = this.archive.getNestedArchives(searchFilter,
 (entry) -> isNestedArchive(entry) && !isEntryIndexed(entry));
 //上述isNestedArchive判断逻辑在JarLauncher中实现的，isEntryIndexed在ExecutableArchiveLauncher实现
 if (isPostProcessingClassPathArchives()) {
 archives = applyClassPathArchivePostProcessing(archives);
 }
 return archives;
}
//JarLauncher中的实现
@Override
 protected boolean isNestedArchive(Archive.Entry entry) {
 return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
 }

//只加载下面两个目录文件
 static final EntryFilter NESTED_ARCHIVE_ENTRY_FILTER = (entry) -> {
 if (entry.isDirectory()) {
 //我们自己写的代码的字节码文件
 return entry.getName().equals("BOOT-INF/classes/");
 }
 //依赖的jar包
 return entry.getName().startsWith("BOOT-INF/lib/");
 };

//判断jar包是否在索引文件
 private boolean isEntryIndexed(Archive.Entry entry) {
 if (this.classPathIndex != null) {
 return this.classPathIndex.containsEntry(entry.getName());
 }
 return false;
 }

总的来说就是拿到 jar 包（当前应用）找到的所有 JarFileArchive

// 返回 jar 包（当前应用）找到的所有 JarFileArchive
// `BOOT-INF/classes/` 目录对应一个 JarFileArchive（因为就是我们自己写的应用中的内容）
// `BOOT-INF/lib/` 目录下的每个 jar 包对应一个 JarFileArchive

这个注意到getMainClass()在子类的实现是这样的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 protected String getMainClass() throws Exception {
 Manifest manifest = this.archive.getManifest();
 String mainClass = null;
 if (manifest != null) {
 mainClass = manifest.getMainAttributes().getValue("Start-Class");
 }

 if (mainClass == null) {
 throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this);
 } else {
 return mainClass;
 }
 }

这拿到的Start-Class全类名不就是清单中我们自己指定的那个自己写的主类吗😄

继续看launch方法

1
2
3
4


 protected void launch(String[] args, String launchClass, ClassLoader classLoader) throws Exception {
 Thread.currentThread().setContextClassLoader(classLoader);
 this.createMainMethodRunner(launchClass, args, classLoader).run();
 }

run方法

1
2
3
4
5
6


 public void run() throws Exception {
 Class<?> mainClass = Class.forName(this.mainClassName, false, Thread.currentThread().getContextClassLoader());
 Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
 mainMethod.setAccessible(true);
 mainMethod.invoke((Object)null, this.args);
 }

可以看出来就是加载了我们的主类之后，通过反射的方式调用我们自己写的启动类main方法，同时实现了参数的传递。

不得不说确实巧妙🚀

3.maven-jar-plugin制作依赖分离的jar包

在pom.xml中build配置

 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


 <build>
 <plugins>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.8.1</version>
 <configuration>
 <source>1.8</source>
 <target>1.8</target>
 <encoding>UTF-8</encoding>
 </configuration>
 </plugin>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-dependency-plugin</artifactId>
 <executions>
 <execution>
 <!-- 绑定生命周期 -->
 <phase>package</phase>
 <goals>
 <goal>copy-dependencies</goal>
 </goals>
 <!-- 设置依赖的存放路径 -->
 <configuration>
 <outputDirectory>app/lib</outputDirectory>
 </configuration>
 </execution>
 </executions>
 </plugin>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-jar-plugin</artifactId>
 <version>3.1.2</version>
 <!-- 对插件进行个性化配置 -->
 <configuration>
 <archive>
 <manifest>
 <!-- 将入口类添加到 MANIFEST.MF 中 -->
 <mainClass>com.ruayou.springspitest.SpringSpiTestApplication</mainClass>
 <addClasspath>true</addClasspath>
 <!-- 将依赖的存放位置添加到 MANIFEST.MF 中-->
 <classpathPrefix>./lib/</classpathPrefix>
 </manifest>
 </archive>
 <outputDirectory>app</outputDirectory>
 </configuration>
 </plugin>
 </plugins>
 </build>

上述操作还利用了maven-dependency-plugin进行依赖jar包的复制。然后在maven-jar-plugin中也指定了classpathPrefix前缀，也就是我们提取的lib文件夹的相对路径，我这里打包之后的目录结构是

之后迁移到服务器运行的时候也必须是这样的结构，lib文件夹和生成的jar同一级目录。 jar包的结构如下

com目录下就是我们自己编写的代码字节码文件,重点关注的是MANIFEST.MF文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


Manifest-Version: 1.0
Created-By: Maven Archiver 3.4.0
Build-Jdk-Spec: 17
Class-Path: ./lib/spring-boot-starter-2.6.13.jar ./lib/spring-boot-2.6.1
 3.jar ./lib/spring-context-5.3.23.jar ./lib/spring-aop-5.3.23.jar ./lib
 /spring-beans-5.3.23.jar ./lib/spring-expression-5.3.23.jar ./lib/sprin
 g-boot-autoconfigure-2.6.13.jar ./lib/spring-boot-starter-logging-2.6.1
 3.jar ./lib/logback-classic-1.2.11.jar ./lib/logback-core-1.2.11.jar ./
 lib/log4j-to-slf4j-2.17.2.jar ./lib/log4j-api-2.17.2.jar ./lib/jul-to-s
 lf4j-1.7.36.jar ./lib/jakarta.annotation-api-1.3.5.jar ./lib/spring-cor
 e-5.3.23.jar ./lib/spring-jcl-5.3.23.jar ./lib/snakeyaml-1.29.jar ./lib
 /slf4j-api-1.7.36.jar ./lib/Spring-Spi-EnableAutoConfiguration-0.0.1-SN
 APSHOT.jar ./lib/Spring-Spi-Import-0.0.1-SNAPSHOT.jar
Main-Class: com.ruayou.springspitest.SpringSpiTestApplication

Class-Path里面的每一项都有我们buid时候设置的前缀./lib，所以是能够找到我们依赖的jar包的。

Main-Class也是直接启动我们自己定义的那个启动类。这算是比较传统的一种jar包启动方式。

Markdown学习

Thu, 09 May 2024 00:00:00 +0000

Markdown学习

标题：

三级标题

四级标题

五级标题

1
2
3
4
5


### 三级标题

#### 四级题

##### 五级标题

字体

Hello，World！

Hello，World！

Hello，World！

Hello，World！

~~Hello，World!~~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12



## 字体

Hello，World！

**Hello，World！**

*Hello，World！*

***Hello，World！***

~~Hello，World!~~

引用

Yuaner ha ha ha

1

> Yuaner ha ha ha

分割线

1
2
3


---

***

图片

1

![截图1](https://image.cdn.582021.xyz/yuaner-image/YuanErya/pictures/raw/img/img/202508161726277.png)

超链接

点击跳转

1

[点击跳转](https:www.baidu.com)

列表

1
2
3
4
5
6
7
8


1. A
2. B
3. C
4. D

- A
- B
- C

表格

1
2
3
4
5


| | | |
| ---- | ---- | ---- |
| | | |
| | | |
| | | |

代码

1
2
3
4
5


public class Main {
 public static void main(String[] args) {
 System.out.println("Hello,Wrold!");
 }
}

1
2
3
4
5
6
7


```java
public class Main {
 public static void main(String[] args) {
 System.out.println("Hello,Wrold!");
 }
}
```

Spring MVC扩展点——控制层参数的解析映射

Mon, 08 Apr 2024 00:00:00 +0000

Spring MVC扩展点——控制层参数的解析映射HandlerMethodArgumentResolver

HandlerMethodArgumentResolver是SpringMVC中非常重要的一个角色，负责将请求中的信息转换成处理器方法所需的参数类型。

最近做的一个项目是需要对某个参数进行解密操作，我不像在每个方法中单独对参数进行解析。原本打算在AOP中实现，将参数解析之后放ThreadLocal中，在方法完成后释放ThreadLocal。但是后来了解到这个扩展点，觉得这个扩展点来实现这个参数的解析过程更好。

允许开发者将请求参数直接映射到处理器方法的参数上，而无需手动解析请求。也就是是允许在请求进入控制层的方法之前，对一些参数进行修改，可以实现对某些数据的加解密操作等，这样统一处理就能够，不用在后面的流程中再进行数据的处理。同时配合自定义的参数注解，可以实现按需设置是否开启参数的解析。

接口源码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public interface HandlerMethodArgumentResolver {

 //判断该参数是否支持用该自定义解析器进行解析
 boolean supportsParameter(MethodParameter parameter);

 @Nullable
 Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
 NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;

}

使用示例：

自定义注解：

1
2
3
4
5


@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Addr {

}

HandlerMethodArgumentResolver：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public class AddrResolver implements HandlerMethodArgumentResolver {
//只有含有上述注解的参数才会执行下面参数解析
 @Override
 public boolean supportsParameter(MethodParameter parameter) {
 return parameter.hasParameterAnnotation(Addr.class);
 }

 @Override
 public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
 HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
 String remoteHost = request.getRemoteHost();
 int remotePort = request.getRemotePort();
 String re=remoteHost+":"+remotePort;
 return re;
 }
}

上述代码的参数解析只是简单模拟了从请求中获取到请求地址和端口封装成一个字符串，Controller层的方法参数address将会获得解析处理后的结果。

将自定义的参数注册到Spring容器中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


@Configuration
@EnableWebMvc
public class WebMvcConfig implements WebMvcConfigurer {
 @Bean
 public AddrResolver currUserArgumentResolver(){
 return new AddrResolver();
 }

 @Override
 public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
 argumentResolvers.add(currUserArgumentResolver());
 }
}

使用示例

1
2
3
4


@GetMapping("/getAddr")
public String getAddr(@Addr() String address ) {
 return address;
}

实验结果:

TCP&TLS握手抓包分析

Thu, 21 Mar 2024 00:00:00 +0000

1.TCP抓包分析

下面的请求是访问 www.baidu.com 的抓包信息，截图的部分是TCL建立连接时候的三次握手的请求。图中是分别在客户端的53608和53609建立了两条连接。

接下来着重分析一条连接的建立，以53608端口建立的连接为例进行分析。

筛选出53608端口相关的网络数据包

客户端发出的第一个包详细如下：

标志位SYN为1表示希望建立连接，并且会设置初始序列号。可以看到第一次握手客户端发出的数据包是有随机生成的序列号238847144

下面是第二次握手的报文，可以看到标志位SYN同样为1也表示希望建立连接，也会初始化出一个序列号238847145，同时ACK标志位也设置为1，确认号为第一次握手的数据包的序列号seq+1

第三次握手数据包：

seq=第二次握手的ack（ack就是期待下一次收到数据包的序号），ack=第二次握手的seq+1;

2.TLS握手抓包分析

TCP连接建立后就能够进行TLS握手

客户端发起第一次握手：

客户端发送Client Hello，确定TLS版本，并且携带生成的随机数和支持的密码套件，密码套件的命名规则「密钥交换算法 + 签名算法 + 对称加密算法 + 摘要算法」

第二次握手：

服务端发送Server Hello ,服务端确认的版本号，服务端生成的随机数，选择的密码套件。

这里有点疑惑？Server Hello 后并没有把证书发给客户端？

重新抓了一次包，这次正常了。上面可能抓包没抓全？

第一次握手：

第二次握手：

随后服务端立即发送了证书：

第三次握手：

第四次握手

frp配置项说明

Wed, 03 Jan 2024 00:00:00 +0000

更新于2024-1-3日

frps.toml说明

 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


\# 必须包含 IPv6 的文字地址或主机名
\# 在方括号中，如”[::1]:80″、”[ipv6-host]:http”或”[ipv6-host%zone]:80″
\# 对于单个”bind_addr”字段，不需要方括号，如”bind_addr = ::”。
bindAddr = “0.0.0.0”
bindPort = 7000

\# 用于 kcp 协议的 udp 端口，可以与 ‘bind_port’ 相同。
\# 如果未设置，kcp 在 frps 中被禁用。
kcpBindPort = 7000

\# 用于 quic 协议的 udp 端口。
\# 如果没有设置，quic 在 frps 中被禁用。
\# quicBindPort = 7002

\# 指定代理监听哪个地址，默认值与bind_addr相同
\# proxy_bind_addr = “127.0.0.1”

\# quic协议选项
\# transport.quic.keepalivePeriod = 10
\# transport.quic.maxIdleTimeout = 30
\# transport.quic.maxIncomingStreams = 100000

\# 心跳配置，不建议修改默认值
\# heartbeat_timeout 默认值为 90。设置负值即可禁用。
\# transport.heartbeatTimeout = 90

\# 每个代理中的池计数将不超过 maxPoolCount。
transport.maxPoolCount = 5

\# 如果使用tcp流复用，默认为true
\# transport.tcpMux = true

\# 指定 tcp mux 的保持活动间隔。
\# 仅当 tcpMux 为 true 时才有效。
\# transport.tcpMuxKeepaliveInterval = 60

\# tcpKeepalive 指定 frpc 和 frps 之间活动网络连接的 keep-alive 探测之间的时间间隔。
\# 如果为负，则禁用保持活动探测。
\# transport.tcpKeepalive = 7200

\# Transport.tls.force 指定是否只接受 TLS 加密的连接。 默认情况下，该值为 false。
tls.force = false

\# transport.tls.certFile = “server.crt”
\# transport.tls.keyFile = “server.key”
\# transport.tls.trustedCaFile = “ca.crt”

\# 如果要支持虚拟主机，必须设置监听的http端口（可选）
\# 注意：http端口和https端口可以与bind_port相同
vhostHTTPPort = 80
vhostHTTPSPort = 443

\# vhost http服务器的响应头超时（秒），默认为60秒
\# vhostHTTPTimeout = 60

\# tcpmuxHTTPConnectPort 指定服务器监听 TCP 的端口
\# HTTP CONNECT 请求。 如果值为0，服务器不会复用TCP
\# 单个端口上的请求。 如果不是 – 它将监听这个值
\# HTTP CONNECT 请求。 默认情况下，该值为 0。
\# tcpmuxHTTPConnectPort = 1337

\# 如果 tcpmux_passthrough 为 true，frps 不会对流量进行任何更新。
\# tcpmuxPassthrough = false

\# 配置Web服务器以启用frps的仪表板。
\# 仅当设置了 webServer.port 时，仪表板才可用。
webServer.addr = “127.0.0.1”
webServer.port = 7500
webServer.user = “admin”
webServer.password = “admin”
\# webServer.tls.certFile = “server.crt”
\# webServer.tls.keyFile = “server.key”
\# dashboard assets directory(only for debug mode)
\# webServer.assetsDir = “./static”

\# 在仪表板监听器中启用 golang pprof 处理程序。
\# 必须首先设置仪表板端口
\# webServer.pprofEnable = false

\#enablePrometheus 将在 /metrics api 中导出 webServer 上的 prometheus 指标。
\# enablePrometheus = true

\# 控制台或真实日志文件路径，如 ./frps.log
log.to = “./frps.log”
\# trace, debug, info, warn, error
log.level = “info”
log.maxDays = 3
\# 当 log.to 为控制台时禁用日志颜色，默认为 false
log.disablePrintColor = false

\#DetailedErrorsToClient 定义是否将特定错误（带有调试信息）发送到 frpc。 默认情况下，该值为 true。
detailedErrorsToClient = true

\# auth.method 指定使用什么身份验证方法对 frpc 和 frps 进行身份验证。
\# 如果指定了”token” – 令牌将被读入登录消息。
\# 如果指定”oidc” – 将使用 OIDC 设置颁发 OIDC（开放 ID 连接）令牌。 默认情况下，该值为”token”。
auth.method = “token”

\# auth.additionalScopes 指定包含身份验证信息的附加范围。
\# 可选值为 HeartBeats、NewWorkConns。
\# auth.additionalScopes = [“HeartBeats”, “NewWorkConns”]

\# auth token
auth.token =”123456″

\# oidc 发行者指定验证 OIDC 令牌的发行者。
\# auth.oidc.issuer = “”
\# oidcaudience 指定验证时 OIDC 令牌应包含的受众。
\# auth.oidc.audience = “”
\# oidc SkipExpiryCheck 指定是否在 OIDC 令牌过期时跳过检查。
\# auth.oidc.skipExpiryCheck = false
\# oidc skipIssuerCheck 指定是否跳过检查 OIDC 令牌的颁发者声明是否与 OidcIssuer 中指定的颁发者匹配。
\# auth.oidc.skipIssuerCheck = false

\# userConnTimeout 指定等待工作连接的最长时间。
\# userConnTimeout = 10

\# 只允许 frpc 绑定您列出的端口。 默认情况下，不会有任何限制。
\# allowPorts = [
\# { start = 2000, end = 3000 },
\# { single = 3001 },
\# { single = 3003 },
\# { start = 4000, end = 50000 }
\# ]

\# 每个客户端可以使用的最大端口数，默认值为0表示无限制
maxPortsPerClient = 0

\# 如果subDomainHost不为空，则可以在frpc的配置文件中设置type为http或https时的子域名
\# subDomainHost = “frps.com”
\# subdomain为test时，路由使用的host为test.frps.com

\# subDomainHost = “*.proxy.frps.com”
\# subdomain为test时，路由使用的host为test.proxy.frps.com

\# HTTP 请求的自定义 404 页面
\# custom404Page = “/path/to/404.html”

\# 指定udp数据包大小，单位为字节。 如果未设置，则默认值为 1500。
\# 这个参数在客户端和服务器之间应该是相同的。
\# 它影响 udp 和 sudp 代理。
udpPacketSize = 1500

\# NAT打洞策略数据的保留时间。
natholeAnalysisDataReserveHours = 168

\# [[http插件]]
\# name = “user-manager”
\# addr = “127.0.0.1:9000”
\# path = “/handler”
\# ops = [“Login”]

\# [[http插件]]
\# name = “port-manager”
\# addr = “127.0.0.1:9001”
\# path = “/handler”
\# ops = [“NewProxy”]
配置使用之前记得验证一下，是否正常

./frps verify -c frps.toml

frpc.toml说明

 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
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358


\# 您的代理名称将更改为 {user}.{proxy}
user = “your_name”

\# 必须包含 IPv6 的文字地址或主机名
\# 在方括号中，如”[::1]:80″、”[ipv6-host]:http”或”[ipv6-host%zone]:80″
\# 对于单个 serverAddr 字段，不需要方括号，如 serverAddr = “::”。
serverAddr = “0.0.0.0”
serverPort = 7000

\# STUN 服务器帮助穿透 NAT 漏洞。
\# natHoleStunServer = “stun.easyvoip.com:3478”

\# 决定首次登录失败是否退出程序，否则不断重新登录frps
\# 默认为真
loginFailExit = true

\# 控制台或真实日志文件路径，如 ./frpc.log
log.to = “./frpc.log”
\# trace, debug, info, warn, error
log.level = “info”
log.maxDays = 3
\# 当 log.to 为控制台时禁用日志颜色，默认为 false
log.disablePrintColor = false

auth.method = “token”
\# auth.additionalScopes 指定包含身份验证信息的附加范围。
\# 可选值为 HeartBeats、NewWorkConns。
\# auth.additionalScopes = [“HeartBeats”, “NewWorkConns”]

\# 授权令牌
auth.token = “12345678”

\# oidc.clientID 指定用于在 OIDC 身份验证中获取令牌的客户端 ID。
\# auth.oidc.clientID = “”
\# oidc.clientSecret 指定用于在 OIDC 身份验证中获取令牌的客户端密钥。
\# auth.oidc.clientSecret = “”
\# oidc.audience 指定 OIDC 认证中令牌的受众。
\# auth.oidc.audience = “”
\# oidc_scope 指定 OIDC 身份验证中令牌的权限，如果 AuthenticationMethod == “oidc”。 默认情况下，该值为””。
\# auth.oidc.scope = “”
\# oidc.tokenEndpointURL 指定实现 OIDC 令牌端点的 URL。
\# 它将用于获取 OIDC 令牌。
\# auth.oidc.tokenEndpointURL = “”

\# oidc.additionalEndpointParams 指定要发送到 OIDC 令牌端点的附加参数。
\# 例如，如果要指定”audience”参数，可以如下设置。
\# frp 会将”audience=”、”var1=”添加到附加参数中。
\# auth.oidc.additionalEndpointParams.audience = “https://dev.auth.com/api/v2/”
\# auth.oidc.additionalEndpointParams.var1 = “foobar”

\# 设置管理地址，用于通过http api控制frpc的动作，如reload
webServer.addr = “127.0.0.1”
webServer.port = 7400
webServer.user = “admin”
webServer.password = “admin”
\# 管理资产目录。 默认情况下，这些资源与 frpc 捆绑在一起。
\# webServer.assetsDir = “./static”

\# 在管理监听器中启用 golang pprof 处理程序。
webServer.pprofEnable = false

\# 拨号到服务器等待连接完成的最长时间。 默认值为 10 秒。
\# transport.dialServerTimeout = 10

\# dialServerKeepalive 指定 frpc 和 frps 之间活动网络连接的 keep-alive 探测之间的时间间隔。
\# 如果为负，则禁用保持活动探测。
\# transport.dialServerKeepalive = 7200

\# 连接将提前建立，默认值为零
transport.poolCount = 5

\# 如果使用tcp流复用，默认为true，必须与frps相同
\# transport.tcpMux = true

\# 指定 tcp mux 的保持活动间隔。
\# 仅当 tcpMux 启用时才有效。
\# transport.tcpMuxKeepaliveInterval = 60

\# 用于连接服务器的通信协议
\# 现在支持 tcp、kcp、quic、websocket 和 wss，默认为 tcp
transport.protocol = “tcp”

\# 设置客户端连接服务器时绑定的ip，默认为空。
\# 仅当protocol = tcp或websocket时，才会使用该值。
transport.connectServerLocalIP = “0.0.0.0”

\# 如果你想通过http代理或者socks5代理或者ntlm代理连接frps，可以在这里或者全局环境变量中设置proxyURL
\# 仅当协议为 tcp 时才有效
\# transport.proxyURL = “http://user:passwd@192.168.1.128:8080”
\# transport.proxyURL = “socks5://user:passwd@192.168.1.128:1080”
\# transport.proxyURL = “ntlm://user:passwd@192.168.1.128:2080”

\# quic协议选项
\# transport.quic.keepalivePeriod = 10
\# transport.quic.maxIdleTimeout = 30
\# transport.quic.maxIncomingStreams = 100000

\# 如果tls.enable为true，frpc将通过tls连接frps。
\# 从v0.50.0开始，默认值改为true，并且默认启用tls。
transport.tls.enable = true

\# transport.tls.certFile = “client.crt”
\# transport.tls.keyFile = “client.key”
\# transport.tls.trustedCaFile = “ca.crt”
\# transport.tls.serverName = “example.com”

\# 如果disableCustomTLSFirstByte设置为false，frpc将使用以下方式与frps建立连接
\# 启用 tls 时的第一个自定义字节。
\# 从v0.50.0开始，默认值改为true，并且默认禁用第一个自定义字节。
\# transport.tls.disableCustomTLSFirstByte = true

\# 心跳配置，不建议修改默认值。
\# heartbeat_interval默认值为10，heartbeat_timeout默认为90。设置负值禁用它。
\# transport.heartbeatInterval = 30
\# transport.heartbeatTimeout = 90

\# 指定一个dns服务器，这样frpc将使用它而不是默认的
\# dnsServer = “8.8.8.8”

\# 您要启动的代理名称。
\# 默认为空，表示所有代理。
\# start = [“ssh”, “dns”]

\# 指定udp数据包大小，单位为字节。 如果未设置，则默认值为 1500。
\# 这个参数在客户端和服务器之间应该是相同的。
\# 它影响 udp 和 sudp 代理。
udpPacketSize = 1500

\# 客户端的附加元数据。
metadatas.var1 = “abc”
metadatas.var2 = “123”

\# 包含代理的其他配置文件。
\# includes = [“./confd/*.ini”]

[[proxies]]
\# ‘ssh’ 是唯一的代理名称
\# 如果全局用户不为空，则改为{user}.{proxy} 如’your_name.ssh’
name = “ssh”
type = “tcp”
localIP = “127.0.0.1”
localPort = 22
\# 限制该代理的带宽，单位是KB和MB
transport.bandwidthLimit = “1MB”
\# 限制带宽的地方，可以是’client’或’server’，默认是’client’
transport.bandwidthLimitMode = “client”
\# 如果为 true，则该代理的流量将被加密，默认为 false
transport.useEncryption = false
\# 如果为 true，流量将被压缩
transport.useCompression = false
\# 通过frps监听远程端口
remotePort = 6001
\# frps 将为同一组中的代理负载平衡连接
loadBalancer.group = “test_group”
\# 组应该有相同的组密钥
loadBalancer.groupKey = “123456”
\# 为后端服务启用健康检查，现在支持’tcp’和’http’。
\# frpc 将连接本地服务的端口来检测其健康状态
healthCheck.type = “tcp”
\# 健康检查连接超时
healthCheck.timeoutSeconds = 3
\# 如果连续3次失败，代理将从frps中移除
healthCheck.maxFailed = 3
\# 每10秒会进行一次健康检查
healthCheck.intervalSeconds = 10
\# 每个代理的附加元信息
metadatas.var1 = “abc”
metadatas.var2 = “123”

[[proxies]]
name = “ssh_random”
type = “tcp”
localIP = “192.168.31.100”
localPort = 22
\# 如果remote_port为0，frps会为你分配一个随机端口
remotePort = 0

[[proxies]]
name = “dns”
type = “udp”
localIP = “114.114.114.114”
localPort = 53
remotePort = 6002

\# 将您的域名解析为 [server_addr]，以便您可以使用 http://web01.yourdomain.com 浏览 web01，使用 http://web02.yourdomain.com 浏览 web02
[[proxies]]
name = “web01”
type = “http”
localIP = “127.0.0.1”
localPort = 80
\# http用户名和密码是http协议的安全认证
\# 如果不设置，无需认证即可访问此custom_domains
httpUser = “admin”
httpPassword = “admin”
\# 如果frps的域名是frps.com，那么您可以通过URL http://web01.frps.com访问[web01]代理
subdomain = “web01”
customDomains = [“web01.yourdomain.com”]
\# 位置仅适用于 http 类型
locations = [“/”, “/pic”]
\# 如果 http 基本自动用户是 abc，则将请求路由到此服务
\# route_by_http_user = abc
hostHeaderRewrite = “example.com”
\# 带有前缀”header_”的参数将用于更新http请求头
requestHeaders.set.x-from-where = “frp”
healthCheck.type = “http”
\# frpc 将向本地 http 服务发送 GET http 请求 ‘/status’
\# 当 http 服务返回 2xx http 响应代码时，它就处于活动状态
healthCheck.path = “/status”
healthCheck.intervalSeconds = 10
healthCheck.maxFailed = 3
healthCheck.timeoutSeconds = 3

[[proxies]]
name = “web02”
type = “https”
localIP = “127.0.0.1”
localPort = 8000
subdomain = “web02”
customDomains = [“web02.yourdomain.com”]
\# 如果不为空，frpc将使用代理协议将连接信息传输到您的本地服务
\# v1 或 v2 或空
transport.proxyProtocolVersion = “v2”

[[proxies]]
name = “tcpmuxhttpconnect”
type = “tcpmux”
multiplexer = “httpconnect”
localIP = “127.0.0.1”
localPort = 10701
customDomains = [“tunnel1”]
\# routeByHTTPUser = “user1”

[[proxies]]
name = “plugin_unix_domain_socket”
type = “tcp”
remotePort = 6003
\# 如果定义了plugin，local_ip和local_port就没用了
\# 插件将处理从 frps 获得的连接
[proxies.plugin]
type = “unix_domain_socket”
unixPath = “/var/run/docker.sock”

[[proxies]]
name = “plugin_http_proxy”
type = “tcp”
remotePort = 6004
[proxies.plugin]
type = “http_proxy”
httpUser = “abc”
httpPassword = “abc”

[[proxies]]
name = “plugin_socks5”
type = “tcp”
remotePort = 6005
[proxies.plugin]
type = “socks5”
username = “abc”
password = “abc”

[[proxies]]
name = “plugin_static_file”
type = “tcp”
remotePort = 6006
[proxies.plugin]
type = “static_file”
localPath = “/var/www/blog”
stripPrefix = “static”
httpUser = “abc”
httpPassword = “abc”

[[proxies]]
name = “plugin_https2http”
type = “https”
customDomains = [“test.yourdomain.com”]
[proxies.plugin]
type = “https2http”
localAddr = “127.0.0.1:80”
crtPath = “./server.crt”
keyPath = “./server.key”
hostHeaderRewrite = “127.0.0.1”
requestHeaders.set.x-from-where = “frp”

[[proxies]]
name = “plugin_https2https”
type = “https”
customDomains = [“test.yourdomain.com”]
[proxies.plugin]
type = “https2https”
localAddr = “127.0.0.1:443”
crtPath = “./server.crt”
keyPath = “./server.key”
hostHeaderRewrite = “127.0.0.1”
requestHeaders.set.x-from-where = “frp”

[[proxies]]
name = “plugin_http2https”
type = “http”
customDomains = [“test.yourdomain.com”]
[proxies.plugin]
type = “http2https”
localAddr = “127.0.0.1:443”
hostHeaderRewrite = “127.0.0.1”
requestHeaders.set.x-from-where = “frp”

[[proxies]]
name = “secret_tcp”
\# 如果类型是secret tcp，则remote_port没有用
\# 如果想要连接本地端口，需要部署另一个带有stcp代理的frpc，角色是visitor
type = “stcp”
\# secretKey is used for authentication for visitors
secretKey = “abcdefg”
localIP = “127.0.0.1”
localPort = 22
\# 如果不为空，则只有指定用户的访问者可以连接。
\# 否则，来自同一用户的访问者可以连接。 ‘*’ 表示允许所有用户。
allowUsers = [“*”]

[[proxies]]
name = “p2p_tcp”
type = “xtcp”
secretKey = “abcdefg”
localIP = “127.0.0.1”
localPort = 22
\# 如果不为空，则只有指定用户的访问者可以连接。
\# 否则，来自同一用户的访问者可以连接。 ‘*’ 表示允许所有用户。
allowUsers = [“user1”, “user2”]

\# frpc 角色访问者 -> frps -> frpc 角色服务器
[[visitors]]
name = “secret_tcp_visitor”
type = “stcp”
\# 您要访问的服务器名称
serverName = “secret_tcp”
secretKey = “abcdefg”
\#将此地址连接到访客stcp服务器
bindAddr = “127.0.0.1”
\#bindPort可以小于0，表示不绑定端口，只接收重定向的连接
\# 其他访客。 （目前SUDP不支持）
bindPort = 9000

[[visitors]]
name = “p2p_tcp_visitor”
type = “xtcp”
\# 如果不设置服务器用户，则默认为当前用户
serverUser = “user1”
serverName = “p2p_tcp”
secretKey = “abcdefg”
bindAddr = “127.0.0.1”
\#bindPort可以小于0，表示不绑定端口，只接收重定向的连接其他访客。 （目前SUDP不支持）
bindPort = 9001
\# 当需要自动隧道持久化时，设置为true
keepTunnelOpen = false
\# keep_tunnel_open设置为true时有效，每小时尝试打通的次数
maxRetriesAnHour = 8
minRetryInterval = 90
\# fallbackTo = “stcp_visitor”
\# fallbackTimeoutMs = 500

完

IK分词器实现热更新

Mon, 25 Sep 2023 00:00:00 +0000

定制IK分词器实现热更新

最近在写一个项目的时候有用到es做搜索引擎，选择了用ik分词器来分词。拿来直接用的时候，很多现在新产生的一些新词都只能一个一个字的拆分，效果不是很理想。只能手动添加扩展词库来增强分词效果。下面是加了一个扩展词库以后，手动添加了几个热词的分词效果。

但是还是存在一些停用词的问题，很多无用的词语被分出来了。现在经常都会有很多的新词产生，如果一有新词产生就去手动添加扩展词库还是很麻烦的。所以就想到了修改ik分词器的词库加载逻辑。对ik分词器进行定制化，加入mysql驱动，通过查询数据库实现热跟新。后期只需要在数据库进行添加新词，很快就能直接加载到分词器里面，同时也更容易通过编码实现词库的更新。本次项目使用的是elasticsearch 7.17.7版本。ik分词器也要对应的版本。把对应版本的ik分词器的源码下载解压出来，用idea打开，加载maven项目。

添加maven坐标导入mysql驱动

1
2
3
4
5


 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>8.0.29</version>
 </dependency>

这里看项目的结构：

和字典相关的代码都在org.wltea.analyzer.dic包下面。可以看到Monitor类是用来监控远程词库是否变更的一个类。

我们可以模仿这个写一个用于监控数据库词库是否变更的监视器。

大致逻辑就是从数据库读取到词库数据，为了避免读取到大量数据，增加系统负担，检索之后要保存检索时间，下一次检索就只检索修改时间在次之后的数据。由于是根据时间来检索的数据，可以给时间加上非唯一索引，加快检索速率。

监视器代码如下：

 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


public class JdbcMinitor implements Runnable {
 static {
 try {
 Class.forName("com.mysql.cj.jdbc.Driver");
 } catch (Exception e) {
 e.getStackTrace();
 }
 }

 /**
 * jdbc配置
 */
 private JdbcConfig jdbcConfig;
 /**
 * 主词汇上次更新时间
 */
 private Timestamp mainLastModitime = Timestamp.valueOf("2022-01-01 00:00:00");
 /**
 * 停用词上次更新时间
 */
 private Timestamp stopLastModitime = Timestamp.valueOf("2022-01-01 00:00:00");

 private static final Logger logger = ESPluginLoggerFactory.getLogger(JdbcMinitor.class.getName());

 public JdbcMinitor(JdbcConfig jdbcConfig) {
 this.jdbcConfig = jdbcConfig;
 }

 @Override
 public void run() {
 SpecialPermission.check();
 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 this.runUnprivileged();
 return null;
 });
 }

 /**
 * 加载词汇和停用词
 */
 public void runUnprivileged() {
 //Dictionary.getSingleton().reLoadMainDict();
 loadWords();
 }

 private void loadWords() {
 List<String> mainWords = new ArrayList<>();
 List<String> delMainWords = new ArrayList<>();
 List<String> stopWords = new ArrayList<>();
 List<String> delStopWords = new ArrayList<>();
 setAllWordList(mainWords, delMainWords, stopWords, delStopWords);
 mainWords.forEach(w -> Dictionary.getSingleton().fillSegmentMain(w));
 delMainWords.forEach(w -> Dictionary.getSingleton().disableSegmentMain(w));
 stopWords.forEach(w -> Dictionary.getSingleton().fillSegmentStop(w));
 delStopWords.forEach(w -> Dictionary.getSingleton().disableSegmentStop(w));
 logger.info("ik dic refresh from db. mainLastModitime: {} stopLastModitime: {}", mainLastModitime, stopLastModitime);
 }

 /**
 * 获取主词汇和停用词
 * @param mainWords
 * @param delMainWords
 * @param stopWords
 * @param delStopWords
 */
 private void setAllWordList(List<String> mainWords, List<String> delMainWords, List<String> stopWords, List<String> delStopWords) {
 Connection connection = null;
 try {
 connection = DriverManager.getConnection(jdbcConfig.getUrl(), jdbcConfig.getUsername(), jdbcConfig.getPassword());
 setWordList(connection, jdbcConfig.getMainWordSql(), mainLastModitime, mainWords, delMainWords);
 setWordList(connection, jdbcConfig.getStopWordSql(), stopLastModitime, stopWords, delStopWords);
 } catch (SQLException throwables) {
 logger.error("jdbc load words failed: mainLastModitime-{} stopLostMOditime-{}", mainLastModitime, stopLastModitime);
 logger.error(throwables.getStackTrace());
 } finally {
 if (connection != null) {
 try {
 connection.close();
 } catch (SQLException throwables) {
 logger.error("failed to close connection");
 logger.error(throwables.getMessage());
 }
 }
 }
 }
 /**
 * 连接数据库获取词汇
 * @param connection
 * @param sql
 * @param lastModitime
 * @param words
 * @param delWords
 */
 private void setWordList(Connection connection, String sql, Timestamp lastModitime, List<String> words, List<String> delWords) {
 PreparedStatement prepareStatement = null;
 ResultSet result = null;

 try {
 prepareStatement = connection.prepareStatement(sql);
 prepareStatement.setTimestamp(1, lastModitime);
 result = prepareStatement.executeQuery();

 while (result.next()) {
 String word = result.getString("word");
 Timestamp moditime = result.getTimestamp("moditime");
 String ifdel = result.getString("ifdel");

 if ("1".equals(ifdel)) {
 delWords.add(word);
 } else {
 words.add(word);
 }

 // 取最大的时间
 if (moditime.after(lastModitime)) {
 lastModitime.setTime(moditime.getTime());
 }
 }
 } catch (SQLException throwables) {
 logger.error("jdbc load words failed: {}", lastModitime);
 logger.error(throwables.getMessage());
 } finally {
 if (result != null) {
 try {
 result.close();
 } catch (SQLException throwables) {
 logger.error("failed to close prepareStatement");
 logger.error(throwables.getMessage());
 }
 }

 if (prepareStatement != null) {
 try {
 prepareStatement.close();
 } catch (SQLException throwables) {
 logger.error("failed to close prepareStatement");
 logger.error(throwables.getMessage());
 }
 }
 }
 }
}

停用词库表

1
2
3
4
5
6
7
8


CREATE TABLE `es_dic_stop` (
 `id` int NOT NULL AUTO_INCREMENT,
 `word` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '停用词',
 `moditime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
 `ifdel` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '0',
 PRIMARY KEY (`id`) USING BTREE,
 INDEX `time`(`moditime`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2434 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '停用词' ROW_FORMAT = Dynamic;

分词词库表

1
2
3
4
5
6
7
8


CREATE TABLE `es_dic_main` (
 `id` int NOT NULL AUTO_INCREMENT,
 `word` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '词汇',
 `moditime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
 `ifdel` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '0',
 PRIMARY KEY (`id`) USING BTREE,
 INDEX `time`(`moditime`) USING BTREE COMMENT 'time'
) ENGINE = InnoDB AUTO_INCREMENT = 5593806 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '主词汇' ROW_FORMAT = Dynamic;

两个词库大同小异，ifdel是标记屏蔽这个词

添加需要使用的配置类放org.wltea.analyzer.cfg包下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class JdbcConfig {
 private String url;

 private String username;

 private String password;

 private String mainWordSql;

 private String stopWordSql;

 private Integer interval;

 public JdbcConfig(String url, String username, String password, String mainWordSql, String stopWordSql, Integer interval) {
 this.url = url;
 this.username = username;
 this.password = password;
 this.mainWordSql = mainWordSql;
 this.stopWordSql = stopWordSql;
 this.interval = interval;
 }
}

上面代码还需要补充各个属性对应的 getter setter 方法

对应的配置文件如下：jdbc.properties

1
2
3
4
5
6
7


jdbc.url=jdbc:mysql://127.0.0.1:3306/ik?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=1111111
main.word.sql=SELECT * FROM es_dic_main WHERE moditime >= ?
stop.word.sql=SELECT * FROM es_dic_stop WHERE moditime >= ?
# ????(?)
interval=10

上面数据库连接相关替换成真实连接信息即可。配置文件放最外层的config目录下

现在需要字典管理器构造处修改代码加载jdbc配置文件org.wltea.analyzer.dic.Dictionary 构造方法最后一行添加读取配置文件的逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


 private void setJdbcConfig() {
 Path file = PathUtils.get(getDictRoot(), Dictionary.PATH_JDBC_CONFIG);
 Properties properties = null;
 try {
 properties = new Properties();
 properties.load(new FileInputStream(file.toFile()));
 } catch (Exception e) {
 logger.error("load jdbc.properties failed");
 logger.error(e.getMessage());
 }
 jdbcConfig = new JdbcConfig(
 properties.getProperty("jdbc.url"),
 properties.getProperty("jdbc.username"),
 properties.getProperty("jdbc.password"),
 properties.getProperty("main.word.sql"),
 properties.getProperty("stop.word.sql"),
 Integer.valueOf(properties.getProperty("interval"))
 );
 }

然后修改权限，resources/plugin-security.policy文件

1
2
3
4
5


grant {
 // needed because of the hot reload functionality
 permission java.net.SocketPermission "*", "connect,resolve";
 permission java.lang.RuntimePermission "setContextClassLoader";
};

之后就可以打包插件了。放进 Elasticsearch 插件目录下加载。

ElasticSearch部署用户组问题

Mon, 18 Sep 2023 00:00:00 +0000

前文疑惑ElasticSearch容器部署用户组问题

前文：YuanErBlog|原尔

本文是在解决之前在支付宝小程序云部署ElasticSearch一直运行不起来的疑惑。

这一切的根源问题还是因为ElasticSearch的限制，不能用root用户来运行ElasticSearch。

技术人员给出的解决方案是：

在dockerfile中添加两条指令重新构建镜像。

1
2


chown -R elasticsearch:root /usr/share/elasticsearch
chown elasticsearch:root /usr/local/bin/docker-entrypoint.sh

并且将挂载的持久卷的用户组设置为1000:0

即用户为1000，用户组为0（root)

可以看到这里的1000也正好对应了下面容器中1000 elasticsearch用户。

至于为什么能确定是1000，我的猜测的原因是：~~在许多Linux发行版中，用户1000可能是第一个创建的非特权用户账户。例如，在Ubuntu系统中，第一个通过安装过程创建的用户通常会被赋予UID 1000。~~

上述问题在elasticsearch构建镜像的dockerfile中找到了答案。

该文件地址：elasticsearch/distribution/docker/src/docker/Dockerfile at main · elastic/elasticsearch (github.com)

可以看到是手动指定的创建的elasticsearch用户，并且uid=1000

下图是容器中的运行es用户的详细id

构建镜像增加的两条命令：就是在变更文件的所属用户和用户组，由于使用elasticsearch用户来访问这些文件，所以，必须将这些文件改为elasticsearch所属，才能确保es的正确运行。

第二条指令是在修改docker启动脚本的所属用户。

注意：

由于docker容器是直接使用的宿主机的内核，而uid 和 gid 由 Linux 内核负责管理。内核控制的 uid 和 gid 只有一套；容器内使用的和容器外使用的是同一套，虽然用户名可能并不一样。

详细可参考文章：

理解 docker 容器中的 uid 和 gid - sparkdev - 博客园 (cnblogs.com)

定制elasticsearch镜像

Sat, 09 Sep 2023 00:00:00 +0000

定制elasticsearch镜像

项目是部署在支付宝小程序云上面的，只有云托管的功能，只能通过docker部署服务。还是不如自己使用云服务器来得方便，不能直接把es的插件目录和数据目录挂载出来在外部操作。所以要添加插件只能提前定制自己的完整的包含插件的镜像。我之前使用docker也都只是简单的拉取运行，java项目也都是一直使用最开始写的那个dockerfile缝缝补补在使用。所以我对dockerfile其实并不是很了解。这次定制镜像算是又系统的学了下dockerfile。但是在制作过程中还是遇到了很多的问题，特别是用户权限方面的问题。es的启动必须使用elasticsearch这个用户。最开始使用云托管部署es官方的镜像，如果挂载数据卷的话就一直部署不上，也是因为这个用户权限的问题。就找了支付宝官方人员的援助，当时可能是快21:00才去找的人工客服（官网是写的工作时间是到21:00）。经过客服的一些指导还是没能够解决。最后大概在23:00的时候，就添加了官方人员进项目里面，协助部署。官方人员部署的历程也挺抽象的hhhh,当时添加之后，他大概折腾了半个小时，还是都是部署失败。然后就没动静了，等到凌晨2点突然又开始部署了，当然他折腾一个小时的样子还是没成功。就给我发消息说是什么云硬盘的权限问题。

然后第二天官方人员又折腾了一上午加一下午，终于在第二天下午17点的样子给出了解决方案哈哈哈。不得不说确实敬业，凌晨2点都在折腾。快下班才去找人工，我都觉得自己有点🐕了😊，但是当时确实是没注意到他们下班时间。经过官方人员20+上线测试最终排查出来问题还是出在了用户组上。

在dockerfile中添加两条指令重新构建镜像。

1
2


chown -R elasticsearch:root /usr/share/elasticsearch
chown elasticsearch:root /usr/local/bin/docker-entrypoint.sh

解决了上面的问题以后。就可以开始定制镜像了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


FROM elasticsearch:7.17.7

ENV LANG C.UTF-8
ENV TZ=Asia/Shanghai

COPY analysis-pinyin-7.17.7 /usr/share/elasticsearch/plugins/py
COPY elasticsearch-analysis-ik-7.17.7 /usr/share/elasticsearch/plugins/ik

RUN chown -R elasticsearch:root /usr/share/elasticsearch
RUN chown elasticsearch:root /usr/local/bin/docker-entrypoint.sh

我的目的就是将我需要的插件打包进镜像里面，当然这些插件都是经过我自己定制化过的。ik分词器实现了连接数据库热更新。但是这个镜像还是很奇怪，只能在支付宝的云托管里面才能正常启动。我自己服务器上不能正常启动，还是存在权限相关问题。即便是我手动指定了用户组还是不能正常启动。这个问题有空再来解决。先把项目搞完再说！

Crontab+Rclone服务器数据备份

Sat, 18 Jun 2022 00:00:00 +0000

Crontab+Rclone服务器数据备份

主要利用Rclone强大的远程同步能力，实现数据的上传云端。

Crontab编写定时任务执行备份脚本，实现数据压缩加密，同步至云端一气呵成！

1.Rclone

1.1 安装以及环境配置

官方下载地址：Rclone downloads 我这里将通过Debian系统进行演示，下载之后会得到一个压缩包，解压之后会得到一下文件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


root@10-9-3-62:/my/rclone# wget https://downloads.rclone.org/v1.66.0/rclone-v1.66.0-linux-amd64.zip
--2024-05-24 11:24:59-- https://downloads.rclone.org/v1.66.0/rclone-v1.66.0-linux-amd64.zip
Resolving downloads.rclone.org (downloads.rclone.org)... 95.217.6.16, 2a01:4f9:c012:7154::1
Connecting to downloads.rclone.org (downloads.rclone.org)|95.217.6.16|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 21137057 (20M) [application/zip]
Saving to: ‘rclone-v1.66.0-linux-amd64.zip’

rclone-v1.66.0-linux-amd64.zip 100%[===================================================================================================>] 20.16M 6.49MB/s in 3.1s

2024-05-24 11:25:03 (6.49 MB/s) - ‘rclone-v1.66.0-linux-amd64.zip’ saved [21137057/21137057]

root@10-9-3-62:/my/rclone# unzip rclone-v1.66.0-linux-amd64.zip
Archive: rclone-v1.66.0-linux-amd64.zip
 creating: rclone-v1.66.0-linux-amd64/
 inflating: rclone-v1.66.0-linux-amd64/README.html
 inflating: rclone-v1.66.0-linux-amd64/README.txt
 inflating: rclone-v1.66.0-linux-amd64/rclone
 inflating: rclone-v1.66.0-linux-amd64/git-log.txt
 inflating: rclone-v1.66.0-linux-amd64/rclone.1
root@10-9-3-62:/my/rclone# cd rclone-v1.66.0-linux-amd64/
root@10-9-3-62:/my/rclone/rclone-v1.66.0-linux-amd64# ls
README.html README.txt git-log.txt rclone rclone.1

之后添加环境变量方便后期使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 vim /etc/profile
 #在文件最末尾添加下面内容，后面的路径根据自己的解压路径填写
export PATH=$PATH:/my/rclone/rclone-v1.66.0-linux-amd64
#使得修改之后的内容生效
source /etc/profile

echo $PATH
#输出下面内容就是生效了
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/my/rclone/rclone-v1.66.0-linux-amd64
#然后查看rclone是否配置成功，在任意目录
rclone version
#能看见输出的版本号就配置成功了

1.2 远程云端信息配置

我这里是使用Alist的WebDAV协议。我已经提前部署好了Alist,并且在Alist挂载阿里云盘，所以我现在可以使用rclone同步至阿里云盘。

1
2
3


rclone config
#之后会开启一个可交互的状态，根据提示完成相关远程的配置
#不同服务商配置内容不太一样，不做演示，自行搜索。

2.Crontab

2.1 定时任务编写

Crontab是 Linux 系统中用于设置周期性被执行的指令的命令。

1
2


#编辑当前用户的定时任务表
crontab -e

一条crontab命令格式：时间指令

时间：分时天月周

1
2
3
4


* 取值范围内的所有数字
/ 每过多少个数字
- 从X到Z
，散列数字

1
2
3
4
5
6
7
8


* * * * *
- - - - -
| | | | |
| | | | +----- 星期中星期几 (0 - 6) (星期天 为0)
| | | +---------- 月份 (1 - 12)
| | +--------------- 一个月中的第几天 (1 - 31)
| +-------------------- 小时 (0 - 23)
+------------------------- 分钟 (0 - 59)

详细时间的编写可参考菜鸟教程

参考文章：Linux Crontab 定时任务 | 菜鸟教程 (runoob.com)

2.2 压缩文件并设置密码

定时任务一般是用于执行一个脚本，现在就是编写一个备份脚本，用于定时任务的执行。

压缩文件：

使用zip进行文件的压缩。

1

zip -r -P password xxx.zip redis

自己替换实际压缩包密码，xxx.zip 是生成的压缩包名，我这里是以打包redis的数据目录作为演示

会在/my/1panel/1panel/apps/redis/redis.zip生成压缩包文件。

2.3 编写执行脚本脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#redisbackup.sh
# 获取当前日期和时间，格式为 YYYYMMDD-HHMM
timestamp=$(date +%Y%m%d-%H%M)

# 使用变量来构建zip文件名
zip_filename="/my/1panel/1panel/apps/redis/redis-${timestamp}.zip"

# 使用变量来创建zip文件，压缩密码myredis
zip -r -P myredis "${zip_filename}" /my/apps/redis/redis
#将rclone产生的日志输出到指定日志文件
rclone sync -v "${zip_filename}" alist:/tianyi/redis >> /my/apps/redis/rclone.log 2>&1

尝试执行脚本./redisbackup.sh,功能正常，建议提前把备份文件夹在云端创建好，有时候会莫名奇妙找不到路径。

2.4 添加定时任务

编写定时任务，先测试每分钟运行一次

1
2
3
4


#编写当前用户的定时任务
crontab -e
#然后输入
* * * * * /my/apps/redis/redisbackup.sh

等待一分钟，是否正常执行。

en… 脚本执行有点异常

环境变量在定时任务中没有生效貌似，把二进制文件rclone 改成全路径。

脚本最后一行替换为

1

/my/rclone/rclone-v1.66.0-linux-amd64/rclone sync -v "${zip_filename}" alist:/tianyi/redis >> /my/apps/redis/rclone.log 2>&1

成功达成目的！

成功备份至Alist

ACM模式的输入和输出

Fri, 08 Apr 2022 00:00:00 +0000

ACM模式的输入和输出

导包

1

import java.util.*;

示例题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


链接：https://ac.nowcoder.com/acm/contest/5657/G
来源：牛客网

输入数据有多组, 每行表示一组输入数据。每组数据输出求和的结果
每行不定有n个整数，空格隔开。(1 <= n <= 100)。
参考示例：
输入:
1 2 3
4 5
0 0 0 0 0
输出：
6
9
0

比较常见的写法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 // 注意 hasNext 和 hasNextLine 的区别
 // 一次读一行
 while(sc.hasNextLine()){
 String[] num = sc.nextLine().split(" ");
 int sum=0;
 for(int i=0;i<num.length;i++)
 { sum += Integer.parseInt(num[i]);
 }
 System.out.println(sum);
 }
 }
}

如果是像这种按行读取还有一种性能更好的方式，但是需要注意要抛出异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


import java.util.*;
import java.io.*;

public class Main{
 public static int ret = 0;
 public static String line;
 public static String[] pair;

 public static void main(String[] args) throws IOException{
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 while((line = in.readLine())!=null){
 pair = line.split(" ");
 ret =0;
 for(int i=0;i<pair.length;i++){
 ret+= Integer.valueOf(pair[i]);
 }
 out.println(ret);
 }
 out.flush();
 }
}

利用带缓冲区的io替代原来的输入输出方案。能一定程度上降低运行时间。但是Scanner也有一定的优势，能够按照类型进行读取。

但是输入流再用StreamTokenizer进行包装也能达到一样的效果。

示例题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

输入例子：
4 1 2 3 4
5 1 2 3 4 5
输出例子：
10
15

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


 public static void main(String[] args) throws Exception{
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 StreamTokenizer in = new StreamTokenizer(br);
 PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

 while(in.nextToken() != StreamTokenizer.TT_EOF){
 int N = (int)in.nval;
 int res = 0;
 for(int i = 0; i < N; i++){
 in.nextToken();
 res += (int)in.nval;
 }
 out.println(res);
 out.flush();
 }
 }