2025-06-14 的今天参与了腾讯云架构师北京技术同盟的线下活动，今天的主题是 **「AI 时代下的架构设计」**，很有幸成为架构师同盟的一员，我将总结分享下今天的内容。


![image.png](https://blog.liushigong.cn/static/img/6ab44cbd6a100ba6aa2825b489762ce1.image.webp)




## 「AI 时代下的架构设计」

今天分享的主要有4个主题，确实收货满满

![image.png](https://blog.liushigong.cn/static/img/7bd1b034041671254b20f47a0f0204b1.image.webp)

### AI 时代下的数据治理

这一篇主题是我比较感兴趣的，之前了解 AI 的时候，就思考过 AI 在大数据处理中的应用，如何通过 AI 来实现业务中各种的数据统计与分析，此处老师分享的是数据治理。

在一些企业中，创建了数据湖仓，对应的数据来源可能从不同的子公司或者其他途径获取，其中不同子公司的数据字典词义相同，但是其语义不同，造成了数据湖仓中的数据分析的紊乱。

当出现此类情况时就需要我们的数据治理，如果数据字典数据量少的情况下，人工处理也是可以的，但是往往真实情况中数据字典量会非常庞大，这个时候我们就需要用到 AI 来治理我们的数据。

#### 数据治理实现思路

数据治理需要制定数据标准，数据规范，可通过 AI 由以下几种方式进行实现

- 智能对话/业务咨询
- 业务术语、业务描述的生成
- 智能识别、智能匹配

在治理的过程中，可以结合「需求文档、设计文档、产品原型、培训文档」等资料训练模式，结合 SQL 给出业务语义，从而实现统一标准规范

![image.png](https://blog.liushigong.cn/static/img/c32f8e2e6c65b43d41db6cc4b1269bb6.image.webp)


![image.png](https://blog.liushigong.cn/static/img/07c90344b902dc7798fe61f7b93cd891.image.webp)


#### AI 数据分级分类的实现思路：向量词

需要专业可靠的词库，否则专业词会被拆分，将会影响最终匹配结果，所以我们要继续完善词库信息


![image.png](https://blog.liushigong.cn/static/img/e756d8b8d6469e882491d025d918b511.image.webp)


![image.png](https://blog.liushigong.cn/static/img/20eb56be55cdc94309e7391c9cc2c5ab.image.webp)


#### 要点回顾

![image.png](https://blog.liushigong.cn/static/img/a39e86c1ee4112114913dd388242a854.image.webp)

#### 总结

![image.png](https://blog.liushigong.cn/static/img/16c0ee63e806ce404d1eff2a4260944e.image.webp)

以上为我在会议中的手画图，整体的数据治理流程就是通过将业务数据导入与采集，然后结合 AI 进行数据治理，统一规范标准后入数据湖仓，接下来通过数据分析与统计，回写到业务数据中进行展示，由此形成闭环。




### AI 时代智能数据存储与处理解决之道

嗯~这一篇在讲结合 AI 的云存储的底层实现，感觉像是在介绍腾讯云产品，直接跳过吧

### AI 驱动下的社交电商架构升级

这一篇是由闫国旗闫老师讲述的电商业务，围绕社交电商的核心业务场景，深入剖析 AI 技术如何针对这些场景的业务痛点，提供智能化解决方案。同时，阐述为实现这些 AI 应用，社交电商架构在数据层、应用层、基础设施层的升级路径，展现 AI 驱动下社交电商架构从理论到实践的完整升级过程。

开始讲述的电商的发展历程，从电商到社交，在到现在的短视频（忘记名词了），再到电商中 AI 的落地实现

- 以业务问题为导向
- 轻量级起步 + 快速验证
- 利用已有平台能力（无需从零训练模型）

接下来讲述基于电商的实际业务中的 AI 实现，其中包含

- 商品搜索
- 商品转链 - 文字染色，推广文案，文案敏感词检测（风控）
- 内容种草 - 数据洞察，内容创作
- 私域投放 - 流量引入

![image.png](https://blog.liushigong.cn/static/img/48def3e4da1c5892263552626174636d.image.webp)

![image.png](https://blog.liushigong.cn/static/img/594936b22c29604f77dc94beabb44a7f.image.webp)

#### 一些 AI 经验

**深度释放模型CoT能力**

业务问题结构化拆解，将复杂场景转化为“问题链”再通过CoT分步处理。使用提示词模板固定推理框架。

**精准划定AI能力输出边界**
 
利用传统技术在内容安全、数据隐私、业务合规等方面做兜底方案。特别是在线业业务，通过输出审计便于后期追溯和选代。
 
**以点带线提升业务短板**

采用高ROI场景切入策略，在问题边界明确、数据的可获得性，收益价值可量化三个方面进行筛选。要考虑能力的复用与价值链的延伸与技术资产沉淀。

#### 目标

AI大模型通过打造基于消费场景的专业化助理、深化用户消费意图的多维度心智解析，以及将商品文案、营销素材等内容生成能力进行标准化封装输出，实现社交电商导购从需求捕捉到内容服务的全链路智能化升级，为商家降低运营成本的同时提升用户消费体验。

**基于消费场景的AI助理**

从“通用服务”到“场景专家。以线带面，基于用户场景，实现用户、商品与服务的连接。

**用户消费意图理解**

借助大模型的理解能力和情感分析能力，实现对用户消费意图的深度洞察。

**内容生成能力优化**

从“零散输出”到“标准化能力”，完成内容从“量”到“质”转变，拒绝制造“内容垃圾”。

#### 总结

闫老师宣讲的内容更多的偏向于业务上的 AI 应用，更多的是让我们有一种产品思维去考虑在电商中如何应用 AI。

### AI 技术赋能从产品设计到交付的效率

这位老师想从自己创业产品作为切入点，结果大多数是个人介绍的经理，唯一干货就是通过 cursor 生成项目代码，要保证代码可控，可以结合原型、UI自主生成代码，等有机会玩一玩，到时候出一篇文章来讲讲，唯一的缺点就是收费，差点意思。

腾讯云架构师城市沙龙 - 「AI 时代下的架构设计」

对于 Nacos 的动态配置大家都很熟悉，在此我提出个疑问❓ **如何在 Nacos 配置中定义 Bean 信息且实现动态的添加删除 Bean 呢？** 本文是结合工作中的实践，来讲下在 **动态的可插拔式插件设计** 的实现思路，可结合业务场景动态切换告警信息、短信服务商、动态线程池等等



## Nacos 配置中 Bean 的定义

既然要动态的配置 Bean，那么首先需要在配置中定义好 Bean 的结构，需要哪些属性。接下来我将以班级、学生与学生做的事来讲述代码思路

首先定义班级的属性，其中班级下有一群学生，对应的属性为 `students`，每个学生都会做同一件事，接下来我们会将学生做一些事转换为动态的，可通过Nacos配置进行 **增删改**

```java
@Data
@ConfigurationProperties(prefix = ClassProperties.PREFIX)
public class ClassProperties {

 /**
 * 配置属性的前缀
 */
 public static final String PREFIX = "class";

 /**
 * 属性名
 */
 public static final String STU_PROPERTY_NAME = "class.students";

 /**
 * BeanName Template Name
 */
 public static final String BEANNAME_TEMPLATE = "class.students[%s]";

 /**
 * 班级名称
 */
 private String className;

 /**
 * 年级
 */
 private String gradeName;

 /**
 * 班级学生
 * 
 * key:学号，value:学生信息
 * 
 */
 private Map<String, Student> students;

}
```

学生对象的属性

```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
 private String name;
 private Integer age;
 private String sex;
}
```

声明学生所做的事情，本质上来说，这就是我们真实要处理业务场景的逻辑，可自行调整

```java
public interface StudentHandler {
 String doSomething();
}

@Data
public class StudentDoSomethingHandler implements StudentHandler {

 private String key;

 private Student student;

 public StudentDoSomethingHandler(String key, Student student) {
 this.key = key;
 this.student = student;
 }

 @Override
 public String doSomething() {
 // do something
 return "【" + key + "】学生【" + student.getName() + "】，今年【" + student.getAge() + "岁】，性别【" + student.getSex() + "】,开始做点什么了...";
 }
}
````

对象定义完了，来描述下Nacos中的属性, `2025140001` 即为 `Map<String, Student> students` 的key，此为 **唯一标识**，用来进行学生的查找，同时也是 `StudentDoSomethingHandler` 中的属性 `key`，而其下的学生信息对应着对象 `student`。

```yaml
class:
 className: 十四班
 gradeName: 初一
 students:
 2025140001:
 name: 张三
 age: 18
 sex: 男
 2025140002:
 name: 紫馨
 age: 20
 sex: 女
 2025140003:
 name: 狗五松溪
 age: 13
 sex: 男
 2025140004:
 name: 构思
 age: 10
 sex: 未知
```


## 动态的注册Bean对象

定义好属性后，我们需要将配置的Bean信息在项目启动时，注入到Spring容器中，交由Spring容器管理。

核心逻辑为：将定义的 `Map<String, Student> students` 转换成 `StudentDoSomethingHandler` 对象，注入到Spring容器中，其中 BeanName 使用模板 `class.students[%s]` 声明，将 `key` 替换到占位符中，最终定义为 `class.students[2025140001]`,此方式便于随时查找Bean对象，整体实现代码如下

```java
@Component
public class StudentBeanDefinitionRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

 /**
 * 班级的属性配置
 */
 private ClassProperties classProperties;


 /**
 * Register bean definitions as necessary based on the given annotation metadata of
 * the importing {@code @Configuration} class.
 * Note that {@link BeanDefinitionRegistryPostProcessor} types may not be
 * registered here, due to lifecycle constraints related to {@code @Configuration}
 * class processing.
 * The default implementation is empty.
 *
 * @param importingClassMetadata annotation metadata of the importing class
 * @param registry current bean definition registry
 */
 @Override
 public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
 // 配置的学生信息
 Map<String, Student> students = classProperties.getStudents();
 if (!CollectionUtils.isEmpty(students)) {
 // 将配置对象转换成Bean，注册到Spring容器中
 students.forEach((key, student) -> {
 // key:beanName, value:beanDefinition
 registry.registerBeanDefinition(buildBeanName(key), buildBeanDefinition(StudentDoSomethingHandler.class, key, student));
 });
 }
 }

 /**
 * 根据 Environment 中的属性名进行构建
 *
 * 
 * 示例：class.students[...]
 * 
 */
 public String buildBeanName(String key) {
 return String.format(ClassProperties.BEANNAME_TEMPLATE, key);
 }

 /**
 * 构建 BeanDefinition
 *
 * @param clazz 构建 Bean 对象的类型
 * @param constructorArguments Bean 的构造参数
 * @param <T> -
 * @return BeanDefinition
 */
 public static <T> BeanDefinition buildBeanDefinition(Class<T> clazz, Object... constructorArguments) {
 // 定义 BeanDefinition
 BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(clazz).getBeanDefinition();
 ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();

 // 构建参数
 for (int i = 0; i < constructorArguments.length; i++) {
 constructorArgumentValues.addIndexedArgumentValue(i, constructorArguments[i]);
 }
 return beanDefinition;
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 // 绑定属性
 classProperties = PropertiesBinder.bindProperties(ClassProperties.PREFIX, environment, ClassProperties.class);
 }
}
```


:::tip{title="BeanName 的生成"}
BeanName 的生成各种各样，并没有什么规则，但是有一点需要注意，那就是 **保证唯一性**，上述规则中就是根据 key 进行的生成，即保证了唯一性，同时在后续 **删改** 的过程中,可根据调整的 Nacos 配置属性随时定位到修改前的 Bean 对象进行处理。
:::


:::danger{title="依赖关系破坏"}

若实现过程中，其他的 Bean 引用了被移除的 Bean（简称 `引用 Bean`），可能导致 `NoSuchBeanDefinitionException` 或空指针，我们应该避免此类情况。

如果无法避免的情况下，如果是 **属性变更** 导致的移除，只需要将引用过 **被移除 Bean** 的对象进行缓存，在移除 Bean 的同时，构建新的 Bean，在将引用 Bean 中的属性进行覆盖，或者移除引用 Bean，进行重新添加

如果是纯移除 Bean，其他引用到此移除 Bean 导致产生异常的，那只能通过调整代码来解决了
:::


提供一个 `Environment` 环境属性中转换对象的工具类
```java
public class PropertiesBinder {

 @SneakyThrows
 public static <T> T bindProperties(String prefix, Environment environment, Class<T> clazz) {
 // 构建对象
 T t = clazz.getDeclaredConstructor().newInstance();
 Binder binder = Binder.get(environment);
 Bindable<?> target = Bindable.of(ResolvableType.forClass(clazz)).withExistingValue(t);
 binder.bind(prefix, target);
 return t;
 }
}
```

## Nacos配置修改Bean信息

实现了项目启动时，配置中 Bean 对象的初始化以后，我们接下来实现对配置中 Bean 对象的 **增删改**，来保证Spring容器中构建的对象为最新调整的属性

### Nacos 配置的变更

首先，当Nacos 平台上对配置进行变更时，我们需要做出扩展，触发Bean的动态刷新操作。从源码中可以得知，当配置变更时，客户端的 `RefreshEventListener` 监听器，会监听到 `RefreshEvent` 事件，执行 `ContextRefresher #refresh()` 方法，此方法中调用了内部方法 `refreshEnvironment()`，而这个内部方法将会变更本地的配置，同时将变更的属性提取出来，并且发布了 `EnvironmentChangeEvent` 事件，那我们只需要监听这个事件即可

![image.png](/static/img/04823db0535fb27da66c2d5d3b9e6205.image.webp)

上述逻辑中提取的变更属性有3种操作情况，分别是

1. 修改属性：会记录到变更的属性中，修改哪个属性，则记录哪个，例如修改了某个学生的年龄，则会存在一条变更的属性 `class.students[2025140001].age`
2. 删除属性：同修改属性一样，删除了哪些属性，也会记录哪些属性是变更的属性，例如删除了某个key以及对应的学生，则会将学生的对象都会记录上 `class.students[2025140001].name`、`class.students[2025140001].age`、`class.students[2025140001].sex`
3. 新增属性，同修改删除一样，但凡新增的都会记录到变更的属性中

### Bean 的增删改

监听到Nacos配置的变更后，我们需要从变更的属性中，只需要找出 `ClassProperties #students` 的属性变更，其中配置变更的操作也是3种，分别对应上述的配置变更的3种情况

1. 修改属性：确认对象是否在Spring容器中存在，存在则可能为更新或删除属性，接下来确认变更的属性是否还在 `Environment` 中，如果还在，则为更新
2. 删除属性：如果变更的属性不在`Environment` 中，则视为删除属性
3. 新增属性：Spring容器中不存在此变更的属性对象，则为新增属性

结合上述思路，代码实现如下

```java
@Component
public class StudentConfigChangeListener implements EnvironmentAware, BeanFactoryAware, ApplicationListener<EnvironmentChangeEvent> {

 private DefaultListableBeanFactory beanFactory;

 private Environment environment;

 /**
 * Handle an application event.
 *
 * @param event the event to respond to
 */
 @Override
 public void onApplicationEvent(EnvironmentChangeEvent event) {
 // 将当前符合的信息进行变更，其他变更过滤
 parseBeanName(event.getKeys()).forEach(beanName -> {
 // Environment 中是否还存在 Bean 的属性信息
 boolean isExist = false;
 Field[] fields = Student.class.getDeclaredFields();
 for (int i = 0; i < fields.length && !isExist; i++) {
 if (environment.containsProperty(beanName + "." + fields[i].getName())) {
 isExist = true;
 }
 }

 // 添加 Bean
 if (isExist) {
 registerBean(beanName);
 }
 // 删除 Bean
 else {
 removeBean(beanName);
 }
 });
 }

 /**
 * 从变更的属性中解析出自定义的 BeanName
 */
 public Set<String> parseBeanName(Set<String> keys) {
 return keys.stream().filter(key -> key.startsWith(ClassProperties.STU_PROPERTY_NAME)).map(key -> key.substring(0, key.indexOf("]") + 1)).collect(Collectors.toSet());
 }

 /**
 * 删除 Bean
 */
 public void removeBean(String beanName) {
 try {
 StudentFactory.LOCK.writeLock().lock();
 // 删除 BeanDefinition
 if (beanFactory.containsBeanDefinition(beanName)) {
 beanFactory.removeBeanDefinition(beanName);
 }

 // 销毁单例实例
 if (beanFactory.containsSingleton(beanName)) {
 beanFactory.destroySingleton(beanName);
 }

 // 删除缓存
 StudentFactory.STUDETN_HANDLER.remove(beanName);
 } finally {
 StudentFactory.LOCK.writeLock().unlock();
 }
 }

 /**
 * 添加 Bean
 */
 public void registerBean(String beanName) {
 try {
 StudentFactory.LOCK.writeLock().lock();
 // 当前 Bean存在，则先删除 Bean
 if (beanFactory.containsSingleton(beanName)) {
 removeBean(beanName);
 }

 // 注册 BeanDefinition
 String key = beanName.substring(beanName.indexOf("[") + 1, beanName.indexOf("]"));
 Student student = PropertiesBinder.bindProperties(beanName, environment, Student.class);
 beanFactory.registerBeanDefinition(beanName, StudentBeanDefinitionRegister.buildBeanDefinition(StudentDoSomethingHandler.class, key, student));

 // 添加缓存
 StudentFactory.STUDETN_HANDLER.put(beanName, beanFactory.getBean(beanName, StudentHandler.class));
 } finally {
 StudentFactory.LOCK.writeLock().unlock();
 }
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 this.environment = environment;
 }

 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 this.beanFactory = (DefaultListableBeanFactory) beanFactory;
 }
}
```

:::warning{title="插件设计"}
需要注意的一点，以上的代码为插件的设计，尤其是Spring项目启动时自动注册Bean信息实现的 `ImportBeanDefinitionRegistrar` 接口，只会在自动装配中生效，2.7版本以前需要添加到 `META-INF/spring.factories`, 2.7版本以后添加到 `META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports` ，具体实现可以查看 [SpringBoot 自动装配原理的满分解读](/post/16)
:::

:::warning{title="单例 Bean 的生命周期"}
单例 Bean 的实例会被容器缓存，移除定义后需手动销毁实例，可查看 `StudentConfigChangeListener #removeBean` 方法中的代码实现
:::

### 门面调用

构建一个门面方法 `doPlan`,根据指定的学生key（也就是nacos配置中的学号 `2025140001`）来执行一些事情的方法

```java
public class StudentFactory {

 /**
 * 读写锁，保证动态Bean信息的线程安全
 */
 public static final ReadWriteLock LOCK = new ReentrantReadWriteLock();

 /**
 * 每个学生对应的处理器缓存，可用来做一些事情
 *
 * 
 * key -> beanName, 对应的格式为: class.students[...]
 * value -> StudentHandler, 学生对应的处理器对象
 * 
 */
 public static Map<String, StudentHandler> STUDETN_HANDLER = new ConcurrentHashMap<>();

 /**
 * 执行学生的计划
 *
 * @param key 学生的key
 * @return 学生的做一些事的结果
 */
 public static String doPlan(String key) {
 try {
 LOCK.readLock().lock();
 StudentHandler studentHandler = STUDETN_HANDLER.get(String.format(ClassProperties.BEANNAME_TEMPLATE, key));
 Assert.notNull(studentHandler, "StudentHandler is null!");
 return studentHandler.doSomething();
 } finally {
 LOCK.readLock().unlock();
 }
 }
}
```


:::danger{title="并发问题"}
动态修改容器可能引发安全问题，通过可重入读写锁 `ReentrantReadWriteLock` 来确保操作原子性，在添加或删除Bean时使用写锁，在读取动态Bean时使用读锁，依赖读写互斥的特性，来解决并发问题。
:::

### 测试示例

在项目中添加接口进行测试

```java
@RestController
public class TestController {

 /**
 * 获取所有学生
 */
 @GetMapping("/get")
 public Object get() {
 Map<String, StudentHandler> beansOfType = SpringUtil.getBeansOfType(StudentHandler.class);
 return JSON.toJSON(beansOfType);
 }
 
 /**
 * 让某个学生做一些事，例如让百度服务商发短信，或其他服务商发短信
 */
 @GetMapping("/getStudent")
 public String getStudent(String key) {
 return StudentFactory.doPlan(key);
 }
}
```

调整 Nacos 平台上的配置后，以上的Bean对象中也会跟着动态调整，访问 `/get` 接口查看，在更新配置后，刷新接口看内容是否发生变更

![image.png](/static/img/756ac01040b769029da914e380efa759.image.webp)

访问 `/getStudent` 接口，可让不同学生执行某些事情

![image.png](/static/img/69a6a1dcd364e1c6976dedeb0ed356ab.image.webp)


## 插件设计的场景

在工作中，我是以此思路实现了 **告警组件**，结合el表达式，可动态调整告警信息。通过某次技术分享后，同事借鉴此思路实现了动态切换短信服务商，可结合实际的业务场景，自行实现动态的插件

插件设计 - 基于 Nacos 配置实现动态 Bean 的注入

运维部署 - 快速模拟线上环境进行开发

在项目上线时，你是否还在手动打包上传服务器，执行命令进行部署项目呢？这种方式一旦操作失误，就会降低线上环境的可靠性。今天给大家分享一下如何基于 Jenkins + Docker 从 GIT 上自动获取代码进行自动化构建部署 SpringBoot 项目。




## Jenkins 简介

Jenkins是一个开源的自动化服务器，由Java编写，主要用于持续集成（CI）和持续交付/部署（CD）的自动化工作流。它通过插件生态系统扩展功能，支持与各种工具集成，如版本控制系统（Git、SVN）、构建工具（Maven、Gradle）、测试框架（JUnit、TestNG）和部署工具（Docker、Kubernetes）等。Jenkins旨在通过自动化构建、测试和部署流程，提高开发效率，减少人为错误，缩短交付周期。


## Jenkins 安装

这里采用 Docker 的形式来安装，拉取镜像的命令如下：

```sh
docker pull jenkins/jenkins:lts
```

![image.png](https://blog.liushigong.cn/static/img/6a87d7066f9da72a8937327259e7d4d3.image.webp)

镜像拉取完成后，创建容器运行，其默认端口是8080，容易与其他端口冲突，所以映射为 8880

```sh
docker run -p 8880:8080 -p 5000:5000 --name jenkins \
 -u root \
 -v /opt/docker/jenkins:/var/jenkins_home \
 -d jenkins/jenkins:lts
```

![image.png](https://blog.liushigong.cn/static/img/2d22976400cb0d8d26f4019b34b685fb.image.webp)

到此 jenkins 容器已启动完成

![image.png](https://blog.liushigong.cn/static/img/75c38dbd9e195153e52ef31a3d997e0e.image.webp)


## Jenkins 初始化

接下来我们将访问 Jenkins 界面，访问地址是 http://IP:8880/ ,初次登录需要输入管理员密码才可以使用

![image.png](https://blog.liushigong.cn/static/img/5300854355e6c0a3b35f11d50d07e870.image.webp)

通过 `docker logs jenkins` 查看启动日志，密码会在控制台输出

![image.png](https://blog.liushigong.cn/static/img/ae189ac3b6156e9002bebef919dc74a3.image.webp)

当密码验证成功后，跳转到插件安装的页面，这里选择 `安装推荐的插件`

![image.png](https://blog.liushigong.cn/static/img/6557139c40654d294228a383145e9021.image.webp)

创建第一个管理员账户

![image.png](https://blog.liushigong.cn/static/img/4f101d14cdd60b1e908ff6eb14452f5f.image.webp)



![image.png](https://blog.liushigong.cn/static/img/0fb7dcc19af4c1ea0925ac8ec16268cf.image.webp)



![image.png](https://blog.liushigong.cn/static/img/3f135e87aa0f11de26dfe29cb1e5646b.image.webp)

## Jenkins 配置

### 插件安装

点击右上角的系统管理，选择插件管理，开始进行插件的安装

![image.png](https://blog.liushigong.cn/static/img/9ebc5447bb9a054d2a5c3cb9a0096fdc.image.webp)

安装 `Publish Over SSH` 插件，用于访问远程主机并执行命令。

![image.png](https://blog.liushigong.cn/static/img/40893bb22051b73ab6cdf0f9c617a63c.image.webp)

### SSH 配置

找到 系统管理 -> 系统配置

![image.png](https://blog.liushigong.cn/static/img/10e844c7ed913666747dcadea2a7d4d9.image.webp)

找到 SSH Servers 部分，填写要部署连接的服务器信息，需要注意的是必须装上 `Publish Over SSH` 插件才会有此功能项

![image.png](https://blog.liushigong.cn/static/img/21f3a3cc6b48273a13db3cda6bd49efa.image.webp)

点击高级，勾选上 `Use password authentication, or use a different key` 后，配置服务器的密码，配置完成后，点击下方 `Test Configuration` 测试连接是否成功

![image.png](https://blog.liushigong.cn/static/img/9d081c106cf6ff30d05dddf0657cd0b6.image.webp)

### Maven 配置

找到 系统管理 -> 全局工具配置

![image.png](https://blog.liushigong.cn/static/img/426b7a7dae1db084fe10b996e2316a5f.image.webp)

首先配置 Maven，滑动到最下方，找到 Maven 安装，新增 Maven，填写个名字，点击保存

![image.png](https://blog.liushigong.cn/static/img/ee2ee914661a117c1b9c88c0ff0f3e26.image.webp)

到这 Jenkins 就算配置完成了，接下来我们看下如何自动化部署 SpringBoot 项目。

## 一键部署 SpringBoot 项目

### 编写 Dcokerfile

在项目的根目录下，创建 docker 文件夹，编写 Dockerfile，内容如下，根据实际服务配置编写即可

```sh
FROM openjdk:17-jdk

RUN rm -rf /etc/localtime &&\
 ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime &&\
 echo "Asia/Shanghai" > /etc/timezone

COPY *.jar /data/

EXPOSE 9527

WORKDIR /data

ENV JAVA_OPTS="-Xms128m -Xmx128m"
ENV JAR_PATH="/data"
ENV EXAM_ENV="prod"
ENV LOGGING_PATH="/data/logs"

ENTRYPOINT java ${JAVA_OPTS} \
 -Dlogging.path=${LOGGING_PATH} \
 -DSpring.profiles.active=${EXAM_ENV} \
 -Dfile.encoding=UTF-8 \
 -XX:NativeMemoryTracking=detail \
 -jar ${JAR_PATH}/*.jar
```

### 新建任务

接下来我们通过 Jenkins 来创建任务实现 SpringBoot 项目的自动化部署，回到首页，点击新建任务

![image.png](https://blog.liushigong.cn/static/img/9f6e81f795064a8bdd4974cbce10d030.image.webp)

填写任务的名称，一般就是服务名称，选择 `构建一个自由风格的软件项目`，点击确定

![image.png](https://blog.liushigong.cn/static/img/47544984083c737d517e549b80a8ce1a.image.webp)

#### 配置选项参数

通过选项参数，可以让脚本动态获取到选项参数的值，让脚本变得更加通用，此处配置2个选项参数

- var_project_name 项目名称
- var_app_docker_path 软件工作目录

![image.png](https://blog.liushigong.cn/static/img/52a3d1757aec33100f492bff8c87055f.image.webp)

#### 配置GIT仓库

紧接着在源码管理中，配置 Git 仓库地址，注意仓库地址必须是公共的

![image.png](https://blog.liushigong.cn/static/img/612482aed0a702203e3bdd6d15e847a1.image.webp)

#### 添加Maven构建

点击 `Build Steps` -> `增加构建步骤` -> `调用顶层 Maven 目标`

![image.png](https://blog.liushigong.cn/static/img/03f97ff8200ef7d79e8f2c75d9bd88cd.image.webp)

选择之前配置的 `Maven 3.9.11`，添加目标也就是构建命令 `clean install`，点击高级，配置上 POM 文件目录 `${workspace}/pom.xml` 

再次添加构建步骤，目标 `clean package`，POM 目录为 `${WORKSPACE}/pom.xml`，点击 Save 保存

![image.png](https://blog.liushigong.cn/static/img/8e744a402d4643cfb67e50bce5f6539d.image.webp)


:::warning{title="注意"}
此处我得目录结构为

- echo-im
- echo-im-web
- echo-im-common
- echo-im-framework
- echop-im-websocket

echo-im 即为根目录，是pom类型，当执行 `clean install` 时，其子模块会自动构建，需要根据实际目录地址选择 pom.xml 文件

:::

#### 选择服务器与部署目录

此处选择之前插件中配置的服务器别名，点击高级，勾选 `Verbose output in console`，构建开始后会在控制台输出详细的日志

接下来开始添加需要上传的文件

- Source files 要上传的源文件
- Remove prefix 删除源文件中的目录前缀，相当于只保留源文件目录中，如果不配置，则会跟源文件目录一起上传
- Remote directory 上传源文件存放在服务器中的目录

此处选择根目录下 docker/Dockerfile 文件进行上传，在 build 时会用到

:::warning{title="注意"}
此处的项目路径是内置 Mavan 编译路径，实际为 `/var/jenkins_home/workspace/echo-im`，可通过相对路径获取 echo-im 项目下的编译内容
:::

![image.png](https://blog.liushigong.cn/static/img/243ae88b701deaf590ea6bbe307cebbb.image.webp)

配置要上传的jar包，同时也要去除下路径前缀，只保留jar包上传即可

![image.png](https://blog.liushigong.cn/static/img/121b3c35a9e6953374d05a11536375fa.image.webp)

动态的执行脚本如下，根据不同的项目路径会自动进行构建运行，还有一种方式可以将脚本放到 docker 目录下，例如是 run.sh ，与 Dockerfile 一起上传，当上传jar包后执行 `sh run.sh`

```sh
#!/bin/bash
echo "=================================================================="
echo " 开始部署流程"
echo "=================================================================="
echo "当前时间: $(date)"
echo "部署名称: ${var_project_name}"

#获得变量
var_images_id=`docker images|grep -i ${var_project_name}|awk '{print $3}'`
var_ps_id=`docker ps -a|grep -i ${var_project_name}|awk '{print $1}'`
echo "${var_project_name} docker images ID:${var_images_id}"
echo "${var_project_name} docker ps ID:${var_ps_id}"

#结束镜像任务
if [ -n "$var_ps_id" ]; then
 docker rm -f ${var_ps_id}
 echo "结束镜像:${var_project_name},ID:${var_images_id}"
fi

#删除历史镜像
if [ -n "$var_images_id" ]; then
 docker rmi -f ${var_images_id}
 echo "删除镜像:${var_project_name} ID:${var_images_id}"
fi

#切换工作目录
cd /${var_app_docker_path}/${var_project_name}
echo "当前目录:$(cd "$(dirname "$0")";pwd)"

# 添加权限
chmod 721 Dockerfile
echo "Dockerfile 添加权限"

#开始构件镜像
docker build -t ${var_project_name} .
echo "构建镜像:${var_project_name}"

#执行镜像
docker run -it -d -p 9527:9527 -p 8101:8101 --name ${var_project_name} --link redis:7.2.4 -e TZ="Asia/Shanghai" -v /opt/docker/${var_project_name}/logs:/data/logs -v /opt/docker/nginx/html:/data/upload ${var_project_name}
echo "${var_project_name} is running!"
echo "=================================================================="
echo " 部署流程结束"
echo "=================================================================="
```

到此，任务构建的准备工作就完成了，服务中的整体效果如下

![image.png](https://blog.liushigong.cn/static/img/d09cac56a6f952d200d3ee697c001698.image.webp)


### 开始部署

开始构建，确认填写的选项参数，点击 build

![image.png](https://blog.liushigong.cn/static/img/04648c32a27c153997215f136a574d15.image.webp)


查看控制台输出，如果运行的过程中存在问题根据控制台的输出信息进行调试即可

![image.png](https://blog.liushigong.cn/static/img/dd30cb3b8b6666fe3ea3260854368047.image.webp)

运维部署 - 基于 Jenkins + Docker 一键打包部署 SpringBoot 项目 

数据库 - 深度探索 Mysql 的 binlog、redo log、undo log

baidu-site-verification

本人自己的博客，对工作与学习过程中的总结、一些场景设计的实现方案、遇到过的疑难问题与解决、以及面试总结等。