前言介绍
为什么会有路由层？因为在微服务架构设计中，往往并不会直接将服务暴漏给调用端，而是通过调用路由层进行业务隔离，以达到不同的业务调用对应的服务模块。
Spring Cloud Zuul
```
2. 使用Jquery把文章所在容器高度缩小，这样会把内容进行压缩
```js
// 文章所在容器的选择器
var articleSelector = 'article.post.container.need';
// 找到文章所在的容器
var $article = $(articleSelector);
// 文章的实际高度
var article = $article[0], height = article.clientHeight;
// 文章隐藏后的高度
var halfHeight = height * 0.4;
// 隐藏缩小
$article.css('height', halfHeight + 'px');
$article.addClass('lock');
```
3. 给文章加一点朦胧感，渐变隐藏
```css
.asb-post-01 {
position: absolute;
left: 0;
bottom: 0;
width: 100%;
display: none;
z-index: 10000;
margin-bottom: 0;
}
.asb-post-01 .mask {
height: 240px;
width: 100%;
background: -webkit-gradient(linear, 0 top, 0 bottom, from(rgba(255, 255, 255, 0)), to(#fff));
}
```
4. 从UM全局唯一ID中获取token
友盟作为网站数据采集服务，会生成一个针对用户的全局唯一值UM_distinctid，而我们需要就使用这个值部分截取后作为唯一token加锁钥匙
```other
UM_distinctid = 16e9cd64925334-0882eb883c9554-7711b3e-144000-16e9cd6492631c
```
```js
function getCookie(name) {
var value = "; " + document.cookie;
var parts = value.split("; " + name + "=");
if (parts.length == 2)
return parts.pop().split(";").shift();
}
function getToken() {
let value = getCookie('UM_distinctid');
if (!value) {
return getUUID().toUpperCase();
}
return value.substring(value.length - 6).toUpperCase();
}
```
5. 定时轮旋检查是否关注公众号并解锁，可以优化写入全局Jquery值或者记录在cookie，减少轮询检查次数
```js
// 查询后端的结果
var _detect = function() {
console.info(token);
$.ajax({
url : 'https://bugstack.cn/xx/xx/check',
type: "GET",
dataType: "text",
data : {
token : token
},
success : function(data) {
console.log(data);
if (data == 'refuse') {
_lock();
} else {
_unlock();
}
},
error : function(data) {
_unlock();
}
})
}
// 定时任务
_detect();
setInterval(function() {
_detect();
}, 5000);
```
6. 引导用户关注公众号
现在将token值回显到页面，提醒用户关注公众号回复口令解锁全部文章，以此来得到粉丝的关注。效果如下；
### 3.2 后端
1. 本地环境开发需要安装(免费)http://natapp.cn/，做网络穿透便于我们进行测试
2. 服务度三个主要接口；1同名称的get、post请求，分别用于公众号验验、接收用户行为与回复信息。2给博客提供验证是否解锁接口
3. 在微信公众号；开发->基础设置(服务器配置)，修改配置内容并开启服务，此时服务端会收到验证请求信息
4. Java服务度采用领域驱动设计微服务方式开发，DDD的开发模式会更加清晰以及易于后续功能的拓展
5. (提醒)个人微信号，部分接口权限是没有的，同时如果开启开发者功能配置后，自定义菜单和自定义回复都会失效。而自定义菜单又不开放给个人微信号，所以需要再次配置开启，但是不能修改
#### 开发环境
1. jdk 1.8、tomcat8、idea2018、Maven3
2. Spring Boot 2.1.2.RELEASE
3. mysql 5.6
4. natapp 网络穿透
#### 工程代码
>itstack-ark-wx & 领域驱动设计方式设计
```
/* Detailed source-code truncated for AI context efficiency. */
```
>itstack-ark-wx & 建表语句
```sql
CREATE TABLE
user_auth
(
id bigint NOT NULL AUTO_INCREMENT,
openId VARCHAR(64),
token VARCHAR(16) NOT NULL,
uuid VARCHAR(128),
createTime DATETIME,
updateTime DATETIME,
PRIMARY KEY (id, token),
CONSTRAINT idx_uuid UNIQUE (uuid)
)
ENGINE=InnoDB DEFAULT CHARSET=utf8
```
**讲解部分重点代码块，完整代码下载关注公众号；bugstack虫洞栈 & 回复：itstack-ark-wx**
**interfaces接口层**
>WxPortalController.java & 接收微信公众号验签与行为信息通知
- 微信公众号都是通过服务提供方的一个接口的get/post请求来执行操作的{这样设计真sao但真香}
- get接口主要是验证签名
- post接口会收到；关注、取消关注、用户的回复信息
```
/* Detailed source-code truncated for AI context efficiency. */
```
>BlogController.java & 博客验权接口，用于判断文章是否解锁
- 因为我们这个服务部署在二级域名下，因此需要设置跨域访问
- 由于我们网站是https加密，那么非https是不能被访问，需要下载安装证书到tomcat服务器
- 本接口只返回success和refuse，通过即可解锁
```java
/**
* 微信公众号：bugstack虫洞栈
* 纯洁版博客：https://bugstack.cn
* 沉淀、分享、成长，让自己和他人都能有所收获！
* Create by 付政委 on @2019
*/
@CrossOrigin("https://bugstack.cn")
@RestController
@RequestMapping("/api")
public class BlogController {
private Logger logger = LoggerFactory.getLogger(BlogController.class);
@Autowired
private UserLockAuthService userLockAuthService;
@GetMapping(value = "check", produces = "application/json;charset=utf-8")
public String check(@RequestParam String token) {
try {
logger.info("校验博客浏览用户授权状态{}开始", token);
boolean status = userLockAuthService.checkAuth(token);
logger.info("校验博客浏览用户授权状态{}完成", token, status);
return status ? "success" : "refuse";
} catch (Exception e) {
logger.error("校验博客浏览用户授权状态{}失败", token, e);
return "refuse";
}
}
}
```
**application应用层**
- 本层主要定义逻辑分层，属于非常薄的一层，在一些复杂设计中会有一些服务编排
- UserLockAuthService 用户权限验证
- WxReceiveService 接收用户行为消息
- WxValidateService 微信公众号验签
>UserLockAuthService.java & 定义后由领域层实现
```java
public interface UserLockAuthService {
boolean checkAuth(String token);
}
```
**domain领域层**
- 领域层完成了；权限验证、行为消息处理、公众号验签
- 这里最重要的各种行为消息处理，我们设计为决策树工厂模型，定义了逻辑功能和引擎服务，后续只需要按需扩展即可
>logic/LogicFilter.java & 定义逻辑模型，impl中有对应的一组的实现类
```java
public interface LogicFilter {
String filter(BehaviorMatter request);
}
```
>logic/impl/SubscribeFilter.java & 其中一个实现，关注时行为处理
```java
@Service("subscribe")
public class SubscribeFilter implements LogicFilter {
private final String content = "您好！\n" +
"\n" +
"非常感谢您关注，微信公众号：bugstack虫洞栈 | 也期待您分享给更多小伙伴！\n" +
"\n" +
"bugstack虫洞栈，专注于原创技术专题案例，以最易学习编程开发的方式分享技术知识，让萌新、小白、大牛都能有所收获。目前已经完成的专题有；《Netty4.x从入门到实战》、《手写RPC框架》、《用Java实现JVM》、《基于JavaAgent的全链路监控》、《DDD专题案例》，其他更多专题还在排兵布阵中。\n" +
"\n" +
"获取专题案例源码回复；netty案例、rpc案例、用Java实现jvm源码、基于JavaAgent的全链路监控案例、DDD落地。\n" +
"\n" +
"联系作者：付政委 | monkeycode";
@Override
public String filter(BehaviorMatter request) {
return content;
}
}
```
>engine/impl/MsgEngineHandle.java & 引擎路由调用
```java
@Service("msgEngineHandle")
public class MsgEngineHandle extends EngineBase {
@Value("${wx.config.originalid:你的Err默认值}")
private String originalId;
@Override
public String process(BehaviorMatter request) throws Exception {
LogicFilter router = super.router(request);
if (null == router) return null;
String resultStr = router.filter(request);
if (StringUtils.isBlank(resultStr)) return "";
//反馈信息[文本]，暂时只有文本后续按需拓展
MessageTextEntity res = new MessageTextEntity();
res.setToUserName(request.getOpenId());
res.setFromUserName(originalId);
res.setCreateTime(String.valueOf(System.currentTimeMillis() / 1000L));
res.setMsgType("text");
res.setContent(resultStr);
return XmlUtil.beanToXml(res);
}
}
```
**infrastructure基础层**
- 本层主要提供基础服务能力，包括数据库操作、缓存操作、工具包等
- 如果你的服务中由redis可以在本层来提供
- 在领域驱动设计中数据库不提倡共用，是单独分离，因为此设计中只有用户表还体现的不明显
>repository/UserAuthGrantRepository.java & 数据库实现
```java
@Repository("userAuthGrantRepository")
public class UserAuthGrantRepository implements IUserAuthGrantRepository {
@Autowired
private UserAuthDao userAuthDao;
@Override
public void grantAuth(String openId, String token) {
UserAuth userAuthReq = new UserAuth();
userAuthReq.setOpenId(openId);
userAuthReq.setToken(token);
userAuthReq.setUuid(openId + "_" + token);
userAuthDao.insert(userAuthReq);
}
@Override
public void revokeAuth(String openId) {
userAuthDao.delete(openId);
}
}
```
### 3.3 部署
#### 1. 工程打包
1. springboot配置打包部署成可运行war包
>pom.xml
```xml
war
```
>WxApplication.java
```java
@SpringBootApplication
public class WxApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(WxApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(WxApplication.class, args);
}
}
```
2. 修改配置application.yml，数据库配置、微信配置
```java
server:
port: 80
spring:
# datasource:
# username: root
# password: 123456
# url: jdbc:mysql://localhost:3306/itstack-ark-wx?useUnicode=true&characterEncoding=utf8
# driver-class-name: com.mysql.jdbc.Driver
mybatis:
mapper-locations: classpath:/mybatis/mapper/*.xml
config-location: classpath:/mybatis/config/mybatis-config.xml
# 微信公众号配置信息
# originalid：原始ID
# appid：个人AppID
# token：开通接口服务自定义设置
wx:
config:
originalid: xxxxxxx
appid: xxxxxxx
token: xxxxxxx
```
#### 2. 服务上线
1. 申请云服务器，目前提供方比较多，一般可以和域名选择一个服务商
2. 准备好Linux服务器jdk1.8、tomcat8
3. 看个人域名访问情况，酌情申请Https，配置RSA
4. 本地安装XShell、Xftp，方便部署和文件传输
5. 准备好个人微信公众号，用于配置服务
6. 启动服务
```
/* Detailed source-code truncated for AI context efficiency. */
```
#### 3. 功能验证
1. 验证连接；https://bugstack.cn/itstack-demo-ddd/2019/10/16/DDD%E4%B8%93%E9%A2%98%E6%A1%88%E4%BE%8B%E4%BA%8C-%E9%A2%86%E5%9F%9F%E5%B1%82%E5%86%B3%E7%AD%96%E8%A7%84%E5%88%99%E6%A0%91%E6%9C%8D%E5%8A%A1%E8%AE%BE%E8%AE%A1.html
2. 引导提示；
3. 文章解锁；
## 4. 综上总结
1. 还是很感激那些前途的探路人，为原创研发贡献力量
2. 我博客；https://bugstack.cn，可以尝试验证或者克隆对应的代码仓库
3. 利用了11月24日周六给自己加个通宵班完成所有代码的开发和服务申请到部署，从最开始拿到想法到最终实现还是经历了很多坎坎坷坷
4. 这里面还有很多可以优化的点以及一些拓展的功能，后续会陆续完善，如果由小伙伴有好的点子欢迎随时交流
5. 源码贡献给所有研发，微信公众号内回复；**itstack-ark-wx**，即可获得一份基于领域驱动设计开发的微信公众号与博客打通工程(Star&Frok)
6. 夜深人静咣咣敲代码我也会怀疑，我是谁，我在哪，我在干什么！哎，这就是；喜欢干一份工作，往往来自于干了一件喜欢的工作
---
### Md Devops 2020 03 28 GithubAndMyBlogAttacked (`docs/md/devops/2020-03-28-GithubAndMyBlogAttacked.md`)
---
layout: post
category: itstack-code-life
title: 20年3月27日，Github被攻击。我的GitPage博客也挂了，紧急修复之路，也教会你搭建 Jekyll 博客！
tagline: by 付政委
tag: [java,itstack-code-life]
excerpt: 万万没想到！`Github` 竟然受到攻击了！还能让我使用了 `GitPage` 的博客瘫痪了！整个网站一下不能访问了，还是有点慌的，毕竟在这之前没有考虑到还能有这事。
lock: need
---
# 20年3月27日，Github被攻击。我的GitPage博客也挂了，紧急修复之路，也教会你搭建 Jekyll 博客！
作者：小傅哥
博客：[https://bugstack.cn](https://bugstack.cn)
原文：[https://mp.weixin.qq.com/s/ISA7Nmow-boP1yWStGCuBw](https://mp.weixin.qq.com/s/ISA7Nmow-boP1yWStGCuBw)
## 一、前言
万万没想到！`Github` 竟然受到攻击了！还能让我使用了 `GitPage` 的博客瘫痪了！
整个网站一下不能访问了，还是有点慌的，毕竟在这之前没有考虑到还能有这事。但虽然没有一个准备好了的预案，但也还是可以使用自己技术把这事搞定，尽快恢复。为了可以尽快恢复博客的访问，我把网站迁移到了 `码云` 的Gitpage服务，并开启免费一个月使用（挺香）,并迅速搞定配置以及 ```HTTPS```。嗯！迁移过来速度还比之前快了。但是后来发现有些网络环境下竟然不能访问，这又让我感觉不爽了，否则我都快要交钱给 `码云` (一年90元)。到 `码云` 官网群问使用这个搭建博客，百度收录吗？也没有人回应。**如果不收录我没必要用了就，是吧。钱花了，事没办！** 不过也还好有 Gitee，否则网站不能那么快恢复，如果按照下面的方式搞，至少 `24` 小时才能完事。
接下来就是将网站迁移到我自己买的服务器上，虽然过程比较坎坷，但终究还是满足了我的需求。提升了网站速度、体验，也可以让网站被百度爬虫收录。如果也有小伙伴遇到这样问题或者想建博客，可以按照我下面的步骤，进行安装 `Jekyll` 部署博客。
## 二、版本
>Ruby，一种简单快捷的面向对象（面向对象程序设计）脚本语言，在20世纪90年代由日本人松本行弘(Yukihiro Matsumoto)开发，遵守GPL协议和Ruby License。它的灵感与特性来自于 Perl、Smalltalk、Eiffel、Ada以及 Lisp 语言。由 Ruby 语言本身还发展出了JRuby（Java平台）、IronRuby（.NET平台）等其他平台的 Ruby 语言替代品。Ruby的作者于1993年2月24日开始编写Ruby，直至1995年12月才正式公开发布于fj（新闻组）。因为Perl发音与6月诞生石pearl（珍珠）相同，因此Ruby以7月诞生石ruby（红宝石）命名。
| 序号 | 官网 | 描述 |
|:---:|:---|:---|
| 1 | [https://rubyinstaller.org/downloads/](https://rubyinstaller.org/downloads/) | Ruby官网下载 |
| 2 | [https://gems.ruby-china.com/](https://gems.ruby-china.com/)| 完整 RubyGems 镜像```China``` |
| 3 | [http://www.ruby-lang.org/zh_cn/documentation/](http://www.ruby-lang.org/zh_cn/documentation/)| Ruby 编程文档 |
| 4 | [http://jekyllthemes.org/](http://jekyllthemes.org/) | jekyll 模版 |
| 5 | [https://www.jekyll.com.cn/docs/](https://www.jekyll.com.cn/docs/)| 快速入门手册 |
Ruby 的版本比较多，安装方式也分为整体安装和分开安装(Ruby + devkit)，而这些也是最容易出错的地方。有时候安装完了和自己的不博客版本对不上，而导致报错不能编译。目前经过测试此版本**Ruby+Devkit 2.5.7-1 (x64)**比较适合 ```Jekyll``` 博客的编译部署。如果你在官网下载速度较慢，可以添加**公众号**：```bugstack虫洞栈```，回复邮箱。
## 三、安装
**Ruby+Devkit 2.5.7-1**，完整包的安装过程比较简单，但需要注意以下几点；
1. 安装路径不要有空格，中文等特殊符号
2. 安装中的选项内容按照下图执行
3. 安装完后需要更换数据源，这些内容会在下文具体执行总展示
### 1. 双击打开软件(rubyinstaller-devkit-2.5.7-1-x64)
### 2. 设置路径和选项
- 注意！千万不要把路径设置有空格、中文、特殊符号
- 注意！前两个是必选项，第三个可以不选
### 3. 继续执行直到完成
>点击下一步即可，不需要更改配置
>初步安装成功，点击 `Finsh`
**按照到这我们的软件就已经安装完成了，此时你已经可以执行命令查看版本了。**
```java
Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。
C:\Users\xiaofuge>ruby -v
ruby 2.5.7p206 (2019-10-01 revision 67816) [x64-mingw32]
```
## 四、配置
在安装完成之后还需要执行一系列配置，才能让软件正常工作。并且不注意英文提示的小伙伴，可能你的一个**回车**就把刚安装好的软件卸载了！
### 1. 更换源
>更新 `Gem`
```java
C:\Users\xiaofuge>gem update --system
Updating rubygems-update
Fetching: rubygems-update-2.7.7.gem (100%)
Successfully installed rubygems-update-2.7.7
...
```
>查看版本
```java
C:\Users\xiaofuge>gem -v
2.7.7
```
>替换源，否则你会下载的很慢
```java
C:\Users\xiaofuge>gem sources --add https://gems.ruby-china.com/ --remove http
s://rubygems.org/
source https://gems.ruby-china.com/ already present in the cache
source https://rubygems.org/ not present in cache
```
>查看新的源
```java
C:\Users\xiaofuge>gem sources -l
*** CURRENT SOURCES ***
https://gems.ruby-china.com
```
### 2. 基础的安装和配置
接下来的步骤就比较简单了，但整体的过程比较耗时，黑窗口会在我们执行命令后下载大约 `600M` 的软件。
>命令 1
>命令 2
>命令 3
好！当你顺利安装到此后，你的软件就已经安装完成，可以使用了！
## 五、安装Jekyll
```Ruby``` 软件已经安装完成，接下来就是我们的博客的相关内容的安装了。
>检查版本并安装
```java
E:\>gem -v
2.7.7
E:\>gem install jekyll
Fetching: public_suffix-4.0.3.gem (100%)
Successfully installed public_suffix-4.0.3
Fetching: addressable-2.7.0.gem (100%)
Successfully installed addressable-2.7.0
Fetching: colorator-1.1.0.gem (100%)
Successfully installed colorator-1.1.0
...
ass-converter, rb-fsevent, rb-inotify, listen, jekyll-watch, kramdown, kramdown-
parser-gfm, liquid, mercenary, forwardable-extended, pathutil, rouge, safe_yaml,
unicode-display_width, terminal-table, jekyll after 33 seconds
26 gems installed
```
>查看安装的Jekyll版本
```java
E:\>jekyll -v
jekyll 4.0.0
```
## 六、创建博客
Jekyll 给我们提供了创建博客的命令，你只需要选择好自己文件夹地址，进入执行即可。
### 1. 进入本地站点
```java
C:\Users\xiaofuge>E:
E:\>cd E:\itstack
```
### 2. 创建博客
```java
E:\>jekyll new myblog
Running bundle install in E:/myblog...
Bundler: Fetching source index from https://rubygems.org/
Bundler: Resolving dependencies.............
Bundler: Using public_suffix 4.0.3
Bundler: Using addressable 2.7.0
...
New jekyll site installed in E:/myblog.
E:\>cd myblog
```
### 3. 编译博客
这里执行的编译是默认本地编译，也就是编译后文中都是 ```localhost:4000``` 地址开头，不要把这回内容传到服务端。
```java
E:\myblog>jekyll build
Configuration file: E:/myblog/_config.yml
Source: E:/myblog
Destination: E:/myblog/_site
Incremental build: disabled. Enable with --incremental
Generating...
Jekyll Feed: Generating feed for posts
done in 1.184 seconds.
Auto-regeneration: disabled. Use --watch to enable.
```
- 编译好后看到一个 `_site` 的文件夹，这里就是我们的静态博客内容。
### 4. 运行预览
如果在本地我们没编译而是执行运行预览也是可以的，他会自动进行编译。
```java
E:\myblog>jekyll s
Configuration file: E:/myblog/_config.yml
Source: E:/myblog
Destination: E:/myblog/_site
Incremental build: disabled. Enable with --incremental
Generating...
Jekyll Feed: Generating feed for posts
done in 0.847 seconds.
Auto-regeneration: enabled for 'E:/myblog'
Server address: http://127.0.0.1:4000/
Server running... press ctrl-c to stop.
```
- 这里可以指定端口和IP，也可以控制后台运行，具体可以看到 `十、助记指令`
### 5. 运行效果
- 具体如何使用Jekyll编写博客，可以参考官网文档
>博客结构
```java
├── _config.yml
├── _includes
| ├── footer.html
| └── header.html
├── _layouts
| ├── default.html
| ├── post.html
| └── page.html
├── _posts
| └── 2020-03-28-welcome-to-jekyll.markdown
├── _sass
| ├── _base.scss
| ├── _layout.scss
| └── _syntax-highlighting.scss
├── about.md
├── css
| └── main.scss
├── feed.xml
└── index.html
```
## 七、克隆博客(使用模版)
好！接下来就是我们的**重点**内容了，虽然默认模版也不难看，但终究不是我们的博客。在这里我的目标是将个人博客进行本地编译运行。如果你有喜欢的模版或者是官网，或者是别人个Github，可以下载到自己本地。
### 1. 下载bundler
```java
E:\itstack\gitee.com\fuzhengwei.github.io>gem install bundler
Fetching: bundler-2.1.4.gem (100%)
bundler's executable "bundle" conflicts with D:/Ruby25-x64/bin/bundle
Overwrite the executable? [yN] n
ERROR: Error installing bundler:
"bundle" from bundler conflicts with D:/Ruby25-x64/bin/bundle
```
### 2. 安装环境
```java
E:\itstack\gitee.com\fuzhengwei.github.io>bundle install
Fetching gem metadata from http://gems.ruby-china.com/..........
Using rake 12.3.0
Fetching concurrent-ruby 1.0.5
Installing concurrent-ruby 1.0.5
Fetching i18n 0.9.1
Installing i18n 0.9.1
Using minitest 5.10.3
Using thread_safe 0.3.6
Fetching tzinfo 1.2.4
Installing tzinfo 1.2.4
Fetching activesupport 4.2.10
...
lockfile (nokogiri (~> 1.6)).
Either installing with `--full-index` or running `bundle update
```
### 3. 更新bundle(按需执行)
```java
E:\itstack\gitee.com\fuzhengwei.github.io>bundle update
Fetching gem metadata from http://gems.ruby-china.com/...........
Fetching gem metadata from http://gems.ruby-china.com/.
Resolving dependencies....
Fetching rake 13.0.1 (was 12.3.0)
...
```
### 4. 编译
```java
bundle exec jekyll build
```
### 5. 运行
```java
bundle exec jekyll s
```
>http://localhost:4000/
- 可以看到我们已经很顺利的运行并访问了博客，效果还不错。
- 这会虽然是本地运行，所以里面的链接都是 ```http://localhost:4000/``` ，不能用于服务端部署。
## 八、手动发布
如果部署到服务端，那么我们编译后里面的链接地址都肯定以我们的域名开始，例如；```https://bugstack.cn/```。接下来我们开始执行服务端部署的编译和使用。
### 1. 清空和重新构建
```java
Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。
C:\Users\fuzhengwei>E:
E:\>cd E:\itstack\gitee.com\fuzhengwei.github.io
E:\itstack\gitee.com\fuzhengwei.github.io>bundle exec jekyll clean
Configuration file: E:/itstack/gitee.com/fuzhengwei.github.io/_config.yml
Cleaner: Removing ./_site...
Cleaner: Nothing to do for ./.jekyll-metadata.
Cleaner: Removing ./.jekyll-cache...
Cleaner: Nothing to do for .sass-cache.
E:\itstack\gitee.com\fuzhengwei.github.io>bundle exec jekyll build
Configuration file: E:/itstack/gitee.com/fuzhengwei.github.io/_config.yml
Source: E:/itstack/gitee.com/fuzhengwei.github.io
Destination: E:/itstack/gitee.com/fuzhengwei.github.io/_site
Incremental build: disabled. Enable with --incremental
Generating...
GitHub Metadata: No GitHub API authentication could be found. Some fields may
be missing or have incorrect data.
done in 18.102 seconds.
Auto-regeneration: disabled. Use --watch to enable.
E:\itstack\gitee.com\fuzhengwei.github.io>
```
- 在以上我们分别执行了清空(```bundle exec jekyll clean```)和构建(```bundle exec jekyll build```)，接下来看以看到文件下的 ```_site``` 内容的生成。
### 2. 部署到远程服务器
远程服务器的部署主要依赖于大家个子使用的服务器类型，我的手里有一台云虚拟机，通过FTP的方式进行部署即可。如下；
- 部署以后我们在线网站就可以访问了；[https://bugstack.cn/](https://bugstack.cn/)
## 九、自动发布
如果每次都是这样去本地编译在部署到服务端，代码又得维护在 `GitHub` 还是比较麻烦的。可以使用；`Github -> Travis CI -> Docker-> VPS`。的方式进行部署，不过还得花点钱买服务器。
- 本地提交博客 Markdown 文件 到 Github 源文件 repository
- Github 触发 Travis CI 执行自动编译
- Travis CI 编译后 push 静态文件到 Github 静态文件 repository
- Travis CI 通知 Docker 重建镜像（预计 5 分钟）
- 服务器休眠 5 分钟后，Travis CI 通知服务器
- 服务器拉取最新镜像，然后停止并删除原容器，用最新镜像重建容器
*这种方式目前我还没有钱和时间去折腾，等后面我的博客访问量和内容更大了以后在投入经历去搞！*
## 十、助记指令
| 序号 | 指令 | 说明 |
|:---:|:---|:---|
| 1 | ruby -v | 查看Ruby版本 |
| 2 | gem update | 更新 |
| 3 | `gem -v` | 查看Gem版本 |
| 4 | gem install jekyll | 安装jekyll |
| 5 | gem install bundler | 下载bundler |
| 6 | `gem install jekyll-paginate` | 下载jeky-paginate |
| 7 | git clone git@github.com:xiaofuge/xiaofuge.github.io.git | 克隆主题(cd到xiaofuge.github.io，执行jekyll serve 可以在http://localhost:4000看到效果) |
| 8 | `gem sources --add https://gems.ruby-china.com/ --remove https://rubygems.org/` | 更换源[https://gems.ruby-china.com](https://gems.ruby-china.com/) |
| 9 | jekyll new myblog | 初始化默认博客 |
| 10 | bundle install | 进入博客文件夹执行初始化|
| 11 | jekyll build | 本地编译默认所有链接为http://localhost |
| 13 | `jekyll build --source
--destination ` | 编译指定的文件夹，同时可以设定到指定的地方|
| 12 | jekyll build --destination | 编译到指定地方 |
| 14 | jekyll build --watch | 编译后好自动监听文件变化 自动编译 |
| 15 | bundle exec jekyll build | 您只需构建您的站点(而不是在本地提供),然后您可以将生成的文件上传到您的服务器（这将生成与_config.yml中配置变量url的值的规范链接） |
| 16 | jekyll clean | 清空编译_site |
| 17 | jekyll serve | 本地启动服务 |
| 18 | jekyll serve --host 0.0.0.0 --port 80 | 指定ip和端口启动 |
| 19 | nohup jekyll serve & | 后台运行 |
| 20 | ps -axu | grep jekyll | 运行关闭 |
| 21 | kill -9 [pid] | 杀死进程 |
## 十一、总结
- 通过这次 `GitHub` 挂了，也彻底让我的博客又得花钱维护了。不花点钱是真不行！以前我忍受了；速度、收录、体验，但是突然的一挂，啥都拜拜了。所以只能挂到自己的服务器上，还好价格也不贵！毕竟是一个只能支持 PHP、ASP的虚拟机。
- 从没有那件事情是可以轻轻松松的，在 `天灾人祸` 来临的时候，能帮你抵挡的都是你日积月累的能力。就像；**是时候展示真正的技术了！**
- `Jekyll` 搭建的博客还是蛮好看的，也蛮容易维护的。技术人员还是要有自己的博客，通过不停的折腾从里面不断的获取各个技术点的突破。
---
### Md Devops 2020 04 25 《Netty+JavaFx实战：仿桌面版微信聊天》代码开源+上云部署+视频讲解 (`docs/md/devops/2020-04-25-《Netty+JavaFx实战：仿桌面版微信聊天》代码开源+上云部署+视频讲解.md`)
---
layout: post
category: itstack-demo-netty-3
title: 《Netty+JavaFx实战：仿桌面版微信聊天》代码开源、上云部署、视频讲解，只为让你给点个Star！
tagline: by 付政委
tag: [netty,itstack-demo-netty-3]
excerpt: https://github.com/fuzhengwei/NaiveChat 代码开源，通过视频讲解每一个服务模块的功能，快速入门后并深入学习实践。好！感谢那些默默支持小傅哥的伙伴们！
---
# 《Netty+JavaFx实战：仿桌面版微信聊天》代码开源、上云部署、视频讲解，只为让你给点个Star！
作者：小傅哥
';
echo print_r($output);
echo ' ';
```
- 如果你未对 `php.ini` 中的 `disable_functions = {exec、shell_exec}` 删掉，那么执行这个 php 文件的中脚本指令会报错。
**访问站点**
- 项目路径：`[0] => /www/wwwroot/39.96.73.167`
- 用户目录：`[1] => /home/www` - *www 就是这个用户目录，也就是我们需要为其创建 ssh 公钥的用户*
### 2. 生成和配置公钥
#### 2.1 开启 www 用户
- 命令：`vim /etc/passwd`
- 配置：把 `sbin/nologin` 为 `bin/bash`
#### 2.2 生成公钥
因为我们已经开始了 www 登录权限，那么在生成公钥之前，需要切换到 www 账户下，命令：`su www`
- 切换用户：`su www`
- 生成公钥：`ssh-keygen -t rsa -C "184172133@qq.com"` - 默认回车即可
- 查看公钥：`cat ~/.ssh/id_rsa.pub` - 其他账户下不可见，只有切换到 www 可见
#### 2.3 配置公钥(Github)
- 地址：https://github.com/settings/ssh/new
- 配置：把你通过 `cat ~/.ssh/id_rsa.pub` 查看到的公钥，配置到这里即可，如下：
- 有了这个公钥的配置，我们通过 webhooks.php 中的脚本指令就可以自动的拉取代码了。
## 五、webhooks 更新博客
### 1. 克隆我的代码
- 源码：[关注公众号：bugstack虫洞栈](#) - 回复：`guide-webhooks` 即可获得
- 使用：你可以把我的源码先fork到自己的Github，然后部署到你的站点中。在学习完成搞清楚原理后，再处理你自己的站点
### 2. 部署到站点
- 这里我们需要先在站点使用 `git clone ”你的网站代码git地址“`，把Github代码克隆到自己的博客中，其实也就是启动了部署做的作用。而这步操作，其实就是日常使用 Git 的方式，先克隆代码，在不断 git pull 更新。
- 命令：`[www@CodeGuide 39.96.73.167]$ git clone git@github.com:fuzhengwei/guide-webhooks.git` - 注意，你需要切换为自己的代码库地址，否则 webhooks 不能生效
### 3. 更改网站运行目录
- 因为我们已经在博客站点中，从 Github 克隆下来我们的博客运行代码，那么这里需要把网站的运行目录切换到这个文件夹下，这样就能正常访问到我们的博客代码了。
### 4. 配置 webhooks
**webhooks.php**
**回调脚本**
```php
&1"); // 当前为www用户
// 记录日志 ($content 返回的是一整个对象，可以按需获取里面的内容，写入日志)
$res_log = '------------------------->' . PHP_EOL;
$res_log .= '用户 ' . $content['pusher']['name'] . ' 于 ' . date('Y-m-d H:i:s') . ' 向项目【' . $content['repository']['name'] . '】分支【' . $content['ref'] . '】PUSH ' . $content['commits'][0]['message'] . PHP_EOL;
$res_log .= $res . PHP_EOL;
// 追加方式，写入日志文件
file_put_contents("git_webhook_log.txt", $res_log, FILE_APPEND);
}
echo 'done';
```
- 在我们从 Github 克隆下来的代码文件中，有一个名为 `webhooks.php` 的文件，它是用于处理 Github 回调时拉取 Github 对应博客代码库的脚本文件。
- 现在 http://39.96.73.167/webhooks.php 就可以配置到 Github 的 webhooks 下了，如图：
- 配置，URL、Content type、Secret、trigger，配置完成后确认即可，另外你可以把多个服务器实例都配置上 webhooks，这样就可以在推送代码到 Github 仓库时一起部署了。
## 六、部署验证
**目前**，访问博客是这样，如下：`接下来我们开始修改博客文件并提交，验证自动部署更新站点`
### 1. index.php 新增代码
- 你可以在 index.php 文件中修改任意内容，或者添加新的内容。
### 2. push 代码到 Github
- 推送新修改的内容，到代码库中，等待 Github webhooks 回调脚本
### 3. 验证博客更新
- 地址：[http://39.96.73.167/](http://39.96.73.167/)
- 效果：
- 通过访问博客地址，已经可以看到我们新加入的内容，已经自动部署更新到站点了！✌🏻
### 4. 查看脚本执行日志
在我们的 webhooks.php 中，执行 git pull 脚本的时候，还有一段日志记录，便于知晓谁对网站对了什么！
**git_webhook_log.txt**
- git_webhook_log.txt 是在 webhooks.php 中记录的日志文件，你可以自行扩展其他需要输出的内容。
### 5. 查看webhooks推送日志
- 每一次 webhooks 执行时，都会有对应的记录，来告诉你本次代码推送是否被回调成功。并且在日志中，你还可以看到 webhooks 向你推送的内容 JSON 文件内容，你可以从中获取需要的信息，比如这是谁推送的、在哪个分支推送的、推送的文件有哪些等等。
- 这里也截取了一段推送的 JSON，其余信息你可以在推送记录中自己查看了。
## 七、总结
- 本章节我们带着大家彻底的把 webhooks 的使用走了一遍，也让需要此技术的小伙伴可以让自己的站点部署变更的更加`聪明一些`。当然自己做记录也帮助了一些师弟和小姐姐！
- 那么现在如果你手里有服务器正在吃灰不知道怎么用起来，现在可以折腾起来了，因为傅哥给你录好了入门视频、写好了操作文章，那么不要等待了，上吧！年轻人！课程链接：[https://space.bilibili.com/15637440/channel/seriesdetail?sid=479958](https://space.bilibili.com/15637440/channel/seriesdetail?sid=479958)
- 最后，如果你还没有服务器，那么赶紧搞一个吧，趁着还有活动🔥 链接：[https://www.aliyun.com/minisite/goods?taskPkg=1111ydsrwb&pkgSid=11388&recordId=1033318&userCode=is4kfbdt](https://www.aliyun.com/minisite/goods?taskPkg=1111ydsrwb&pkgSid=11388&recordId=1033318&userCode=is4kfbdt)
---
### Md Devops 2022 03 04 教小白使用 Docsify，搭建一个贼简单的所见即所得博客！ (`docs/md/devops/2022-03-04-教小白使用 docsify，搭建一个贼简单的所见即所得博客！.md`)
---
title: 教小白使用 docsify，搭建一个贼简单的所见即所得博客！
lock: need
---
# 教小白使用 docsify，搭建一个贼简单的所见即所得博客！
作者：小傅哥
## 一、这是什么服务器？
国内我们知道有阿里云、腾讯云、华为云、百度云、京东云，而国外有亚马逊旗下的 AWS 云，并且重点来了，AWS 是有免费的云服务的，任何人都可以获得一台。`其实以前就听说有 AWS 免费云，但一直没当回事，现在才感觉真香！`
在 AWS 活动页，有一个免费套餐，这里有很多产品都可以免费使用，包括；云服务、数据库、函数计算、机器学习等。地址：[https://aws.amazon.com/cn/free](https://aws.amazon.com/cn/free)
这里小傅哥感兴趣的就是 Amazon EC2 云服务器，每个月免费750个小时。这一个月31天✖️24小时不也才744小时，所以这和免费有啥区别？🤔 **难道一天能加出来25个小时班？**
**另外这里有一些注意点**；
1. EC2 云服务器，只有1核1G，在安装 Docker、Portainer、以及一个 Java SpringBoot 应用程序后，运行正常&稳定。
2. 申请时需要用到银行卡，我自己有一个 VISA 的信用卡，直接注册的时候使用就可以。其他银行卡也OK。`有些营销文，为了卖服务器说乱扣费`，为此我专门去搜索了下关于 AWS 免费服务器会有坑不，以及自己验证了一段时间，检查账单以及服务器的运行程度，发现使用的很顺畅，不会有恶意扣费。
3. 使用到快到1年的时候，可以把服务停掉，并重新申请个账号就可以继续用1年了。
如果以上这些点你觉得没问题，那么就可以按照接下来的教程进行申请和使用了。因为 Amazon EC2 和国内的一些服务器使用风格略有差异，所以需要按照教程创建并使用实例。
## 二、怎么免费白皮袄？
### 1. 创建账号
地址：[https://portal.aws.amazon.com/billing/signup#/start/email](https://portal.aws.amazon.com/billing/signup#/start/email)
### 2. 登录账号
地址：[https://console.aws.amazon.com/console/home](https://console.aws.amazon.com/console/home)
### 3. 控制面板
地址：[https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-2#/home](https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-2#/home) - 搜索 IAM 并进入，就是控制面板了。
在创建 Amazon EC2 云服务器前，需要在控制面板中创建；用户组、用户、角色，这样在后面创建服务器的时候才能把用户信息给关联上。
#### 3.1 创建用户
- 地址：[https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-2#/users](https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-2#/users)
- 说明：首先你需要在IAM控制面板下的访问管理中的用户下，创建一个自己的用户。你可以创建用户名为 admin 或者其他。
#### 3.2 创建用户组
- 地址：[https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-2#/groups/create](https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-2#/groups/create)
- 说明：在用户组的创建中，写上组名、添加上刚才创建的用户admin，之后再搜索`AdministratorAccess`为这个组的用户进行授权。
### 4. 部署实例
#### 4.1 创建密钥对
这里需要先创建一个密钥对，之后再创建应用实例的时候把密钥对关联上去。同时密钥对也是用作本地 SSH 登录的一个重要凭证，否则不能登录。另外这里创建完密钥对，会自动下载到本地，你需要保存好。
地址：[https://us-east-2.console.aws.amazon.com/ec2/home?region=us-east-2#KeyPairs:](https://us-east-2.console.aws.amazon.com/ec2/home?region=us-east-2#KeyPairs:) - EC2 管理控制台。
- 创建完成后，会自动下载一个名为 `admin_key.pem` 的文件，保存好它，后面用。
#### 4.2 创建安装组
用于访问服务器的端口都需要在安全组中开通，比如 SSH 22、Portainer 9000、Docker 2375 所以需要自己创建一个安全组。
地址：[https://us-east-2.console.aws.amazon.com/ec2/home?region=us-east-2#SecurityGroups:](https://us-east-2.console.aws.amazon.com/ec2/home?region=us-east-2#SecurityGroups:)
- 以后你想控制各个端口的访问，就在安全组中操作就可以了。
#### 4.4 启动新实例
如果你比较粗鲁，刚一进来 AWS 就创建了实例，但发现用户也不对，权限也不对用不了。没关系可以把它终止掉，之后重新启动新实例。
地址：[https://us-east-2.console.aws.amazon.com/ec2/home?region=us-east-2#Instances:](https://us-east-2.console.aws.amazon.com/ec2/home?region=us-east-2#Instances:)
如果在使用中把自己的应用实例搞坏了，没关系。直接干掉它，重新启动新实例就可以了。
### 5. 连接实例
Amazon EC2 云服务器提供了 EC2 在线连接、会话管理器、SSH 客户端、EC2 串行管理器。我们这里主要用在线的和 SSH 客户端。
| **EC2 Instance Connect** | SSH 客户端 |
| ----------------------------------------------------- | ----------------------------------------------------- |
| | |
- EC2 在线连接，直接点上连接就可以了。SSH 客户端需要按照引导进行操作。
通过此方式就可以本地连接了，还是非常方便的。如果你有连接工具也可以配置到工具中操作。
## 三、部署应用耍起来！
### 1. 安装 Docker
```java
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum list docker --showduplicates | sort -r
sudo yum install docker
sudo systemctl start docker
systemctl enable docker
docker --version
```
### 2. 配置远程链接
```java
vim /usr/lib/systemd/system/docker.service
在ExecStart=/usr/bin/dockerd-current 后面加上 -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock \
# 重新加载配置文件
systemctl daemon-reload
# 重启启动
systemctl restart docker
```
### 3. 部署网页版 ChatGPT
| 方式 | 免费？ | 可靠性 | 质量 |
| ------------------------------------------------- | ------ | ---------- | -------- |
| `ChatGPTAPI(gpt-3.5-turbo-0301)` | 否 | 可靠 | 相对较笨 |
| [`ChatGPTUnofficialProxyAPI(网页 accessToken)`](https://chat.openai.com/api/auth/session) | 是 | 相对不可靠 | 聪明 |
**通过以下方式，你可以自己部署一个网页版的 ChatGPT，让自己使用。** 注意：OPENAI_API_KEY 需要申请
- 海外服务器；`docker run --name chatgpt-web -d -p 3002:3002 --env OPENAI_API_KEY=sk-6cPOiRgKmIcMA**** chenzhaoyu94/chatgpt-web`
- 海内服务器；`docker run --name chatgpt-web -d -p 3002:3002 --env OPENAI_API_KEY=sk-6cPOiRgKmIcMA**** --env OPENAI_API_BASE_URL=https://open2.aiproxy.xyz chenzhaoyu94/chatgpt-web` - 需要添加代理
**也可以不使用Key方式部署**，这个方式的好处是免费，都免费！
- docker run --name chatgpt-web -d -p 3002:3002 --env OPENAI_ACCESS_TOKEN=【从这里获取 https://chat.openai.com/api/auth/session】 chenzhaoyu94/chatgpt-web
- 开源项目：[https://github.com/Chanzhaoyu/chatgpt-web](https://github.com/Chanzhaoyu/chatgpt-web) - 点个 Star 支持作者
- 开源代理：[https://github.com/geekr-dev/openai-proxy](https://github.com/geekr-dev/openai-proxy) - 点个 Star 支持作者
### 4. 部署 ChatGPT 问答助手
- 地址：[https://github.com/fuzhengwei/chatbot-api](https://github.com/fuzhengwei/chatbot-api)
- 视频：[https://bugstack.cn/md/project/chatbot-api/chatbot-api.html](https://bugstack.cn/md/project/chatbot-api/chatbot-api.html)
- 注意：通过 IDEA 打开 chatbot-api 并在 IDEA 配置 Docker，这样就可以直接部署应用了。这些内容在视频里都有手把手操作。
---
### Md Devops 2023 04 18 Docker (`docs/md/devops/2023-04-18-docker.md`)
---
title: Docker
lock: need
---
# Docker 环境配置
作者：小傅哥
```
- 安装指定版本，例如：sudo yum install docker-ce-20.10.11.ce
### 7. 安装Docker-Compose
#### 7.1 正常安装
```shell
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
```
#### 7.2 离线安装
```shell
# 下载；docker-compose-`uname -s`-`uname -m` 查看版本；https://github.com/docker/compose/releases/tag/v2.18.1
# 重命名
mv docker-compose-Linux-x86_64 docker-compose
# 加入执行权限
sudo chmod +x /usr/local/bin/docker-compose
# 查看docker-compose版本
docker-compose -v
```
```java
[root@dev-ops bin]# sudo chmod +x /usr/local/bin/docker-compose
[root@dev-ops bin]# docker-compose -v
Docker Compose version v2.18.1
```
### 8. 启动Docker并添加开机自启动
```java
[root@CodeGuide ~]# sudo systemctl start docker
```
- 启动 Docker
```java
[root@CodeGuide ~]# systemctl enable docker
```
- 设置开机启动 Docker
### 9. 查看 Docker 版本
```java
[root@CodeGuide ~]# docker --version
Docker version 20.10.11, build dea9396
```
### 10. 卸载 Docker
```java
[root@CodeGuide ~]# sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine
```
### 11. Docker 常用命令
```java
[root@CodeGuide ~]# docker --help #Docker帮助
[root@CodeGuide ~]# docker --version #查看Docker版本
[root@CodeGuide ~]# docker search #搜索镜像文件，如：docker search mysql
[root@CodeGuide ~]# docker pull #拉取镜像文件， 如：docker pull mysql
[root@CodeGuide ~]# docker images #查看已经拉取下来的所以镜像文件
[root@CodeGuide ~]# docker rmi #删除指定镜像文件
[root@CodeGuide ~]# docker run --name -p 80:8080 -d #发布指定镜像文件
[root@CodeGuide ~]# docker ps #查看正在运行的所有镜像
[root@CodeGuide ~]# docker ps -a #查看所有发布的镜像
[root@CodeGuide ~]# docker rm #删除执行已发布的镜像
```
### 12. 设置国内源
阿里云提供了镜像源：[https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors](https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors) - 登录后你会获得一个专属的地址。
使用以下命令来设置 Docker 国内源：- 或者你可以通过 `vim /etc/docker/daemon.json` 进入修改添加 registry-mirrors 内容后重启 Docker
```
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://***替换为你的地址***.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
```
这个命令会创建一个 `/etc/docker/daemon.json` 文件，并将国内源的配置写入其中。然后你只需要重启 Docker 服务即可使配置生效，可以通过运行 `sudo systemctl restart docker` 命令来重启 Docker 服务。
---
### Md Devops 2023 04 18 Portainer (`docs/md/devops/2023-04-18-portainer.md`)
---
title: Portainer
lock: need
---
# Portainer 环境配置
作者：小傅哥
## 二、链接服务
地址：[http://180.76.119.142:9000/#!/wizard/endpoints/create?envType=dockerStandalone](http://180.76.119.142:9000/#!/wizard/endpoints/create?envType=dockerStandalone)
```shell script
docker run -d \
-p 9001:9001 \
--name portainer_agent \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /var/lib/docker/volumes:/var/lib/docker/volumes \
portainer/agent:2.16.2
```
---
### Md Devops 2023 04 18 Tool (`docs/md/devops/2023-04-18-tool.md`)
---
title: Tool
lock: need
---
# Tool 工具整理
作者：小傅哥
当这个男人👨🏻准备下手的时候，一切技术将变得简单、容易，好理解！
我把本次的分内容定义为简历博客，并已经做好了博客的框架（[vuepress](https://theme-hope.vuejs.press/zh/)）和内容案例，以及部署需要的Nginx配置。如果你需要部署到线上，那么需要准备一台云服务器（[2c2g 50元/1年](https://gaga.plus/yun.html)）。另外你还可以注册一个域名（ICP备案2周），这样就可以通过域名访问你的专属博客了。【要我说，每个程序员👨🏻💻都应该有一个自己的域名，有了它你才有了做一些事情的可能】。**接下来我会带着你搭建一个如图所示的个人简历博客**
那么，接下来小傅哥就带着你，完成下简历博客的搭建。
>文末提供了8个Java实战项目，嘎嘎提升简历竞争力。💐
## 一、搭建准备
- 简历博客项目：[https://gitcode.net/KnowledgePlanet/road-map/xfg-dev-tech-blog](https://gitcode.net/KnowledgePlanet/road-map/xfg-dev-tech-blog)
- 一台云服务器，2c2g 推荐 50元/1年 [https://gaga.plus/yun.html](https://gaga.plus/yun.html)
- 云服务器搭建 Docker、安装 Portainer 教程地址（包括学习视频）：[https://bugstack.cn/md/road-map/docker.html](https://bugstack.cn/md/road-map/docker.html)
- 域名和域名备案（ICP备案2周），未购买也可以完成本节课程的操作。
- SSL 申请，如果有域名了，可以申请免费的 SSL 让域名地址支持 HTTPS。申请地址：[https://yundun.console.aliyun.com/?p=cas#/certExtend/free/cn-hangzhou](https://yundun.console.aliyun.com/?p=cas#/certExtend/free/cn-hangzhou)
- Node.js 安装，地址：[https://nodejs.org/en/download](https://nodejs.org/en/download) - `选择自己机器适配的版本安装即可`
## 二、项目说明
这里小傅哥已经把博客框架、内容案例、部署博客的环境，都准备好了。你只需要下载到本地就可以使用。
本博客采用 [VuePress Theme Hope](https://theme-hope.vuejs.press/zh/) 模板进行搭建。当你能完成部署本博客后，还可以参考模板做一些其他的扩展以及各类喜欢插件的安装。
- src 目录下，为博客的框架模板和已经写好的案例。在 `package.json`中有一个 `docs:build` 用于构建，还有一个 `docs:dev`用于本地启动测试。
- dev-ops 提供的是博客的部署，这里的 docker-compose.yml 是 Docker 执行脚本安装 Nginx 环境。
- 小傅哥在 `src/.vuepress-> config.ts`文件中下配置了把项目 build 到 nginx/html 文件夹。这样可以更加方便我们部署。
## 三、部署项目
当你把 xfg-dev-tech-blog 项目检出到本地，使用 IntelliJ IDEA 或者 WebStrom 工具打开后。会提示你执行 npm install 安装环境。如果没有提示你也可以自己在项目 Terminal 下执行。执行完安装就可以做博客的部署了。
### 1. 构建项目
- 打开项目的 `package.json`里面有`构建`和`运行`命名。
- 构建的操作会把工程打包为 HTML 文件写入到 dev-ops/nginx/html 文件夹下。
- 运行的操作会直接本地启动服务，启动后你可以在本地预览。这样你在修改一些内容的时候也可以随时看到效果。
### 2. 构建结果
- 如步骤操作，完成构建。当你看到 `dev-ops/nginx/html` 下有对应的一堆文件了，说明构建成功了。
### 3. Nginx 配置
对于 Nginx 的配置提供了3种方式，分别包括；IP访问、HTTP域名访问、HTTPS域名访问。
#### 1. localhost.conf
这个配置方式为了方便，没有域名的伙伴们测试使用。也就是你部署后可以直接通过IP进行访问。
```shell
server {
listen 80;
listen [::]:80;
location / {
root /usr/share/nginx/html;
index index.html;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}
```
- 直接把 80 请求转发到本地的根目录地址的 html 文件上即可
#### 2. http.blog.conf
##### 2.1 配置域名解析
- 如果你有云服务器和域名，那么可以先如图，配置下域名解析地址。
##### 2.2 nginx 脚本
```shell
server {
listen 80;
listen [::]:80;
server_name blog.gaga.plus;
location / {
root /usr/share/nginx/html;
index index.html;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}
```
#### 3. https.blog.conf
如果你有域名那么还可以配置免费的ssl验证，配置完成后把 ssl key、pem 文件放到 dev-ops/nginx/ssl 文件夹下并上传到云服务器上。详细介绍：[https://bugstack.cn/md/devops/2023-04-18-nginx.html#_4-1-%E5%88%9B%E5%BB%BA%E8%AF%81%E4%B9%A6](https://bugstack.cn/md/devops/2023-04-18-nginx.html#_4-1-%E5%88%9B%E5%BB%BA%E8%AF%81%E4%B9%A6)
```shell
server {
listen 80;
listen [::]:80;
server_name blogs.gaga.plus;
rewrite ^(.*) https://$server_name$1 permanent;
}
server {
listen 443 ssl;
server_name api.gaga.plus;
ssl_certificate /etc/nginx/ssl/blogs.gaga.plus.pem;
ssl_certificate_key /etc/nginx/ssl/blogs.gaga.plus.key;
ssl_session_cache shared:SSL:1m;
ssl_session_timeout 5m;
ssl_ciphers HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers on;
location / {
root /usr/share/nginx/html;
index index.html;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}
```
- 这个方式就是配置 ssl 的方式。
### 4. 上传文件
- 小傅哥这里使用的是 [https://termius.com/](https://termius.com/) 连接云服务器的 SSH 工具，自带 SFTP 。`你也可以使用其他 SSH/FTP 工具`
- 通过这个工具，连接云服务器，并把我们在工程下创建的 `dev-ops` 上传到云服务器端。
### 5. 服务启动
接下来，你只需要在云服务器进入到 dev-ops 文件夹下，执行脚本 `docker-compose -f docker-compose.yml up -d` 即可完成部署。
- 在你初次部署的时候，会拉取 Nginx 镜像。拉取完成后则会自动部署。
- 部署完成后可以进入到 portainer 中查看 nginx 运行，以及进入到日志中查看运行情况。
### 6. 访问博客
- IP地址：[http://117.72.37.243/](http://117.72.37.243/)
- HTTP地址：[http://blog.gaga.plus/](http://blog.gaga.plus/)
- HTTPS地址：[https://blogs.gaga.plus/](https://blogs.gaga.plus/)
**全部完成撒花 💐** 现在你就可以在简历上挂一个自己的博客了，还可以在博客中秀出自己的技术肌肉💪🏻，赢得面试官的青睐！
>当然，有了简历博客，最好配有一套对应的高质量实战项目，撑起简历的技术度。那些CRUD/XXX管理系统，现在是越来越没竞争力了。早点学一些，每天积累一点，就能让自己有更多的选择。
## 四、实战项目
小傅哥工作10年+，深刻感受到在不同阶段(毕业~3年，3年~5年、5年+)都要有对应的能力，才能踏上换乘的列车。为了让自己的职业生涯走的更加稳妥，就不要只把自己当成满足工作需要的工具。早些积累、早些积累自己的技术栈体系闭环。这是非常重要的！！！
>小傅哥把工作中的技术经验，陆续的编写出对应的博客和实战项目，整整写了3年多。这些内容可以让一个研发小白成长为技术大牛！
**加入学习 https://gaga.plus**
>[🧧加入学习](https://bugstack.cn/md/zsxq/other/join.html)
**注意📢**，加入星球后你可以申请加入星球VIP群，获得高质量技术交流。此外星球的所有内容，都从星球的**课程入口**进入，里面做了非常细致的归档。
---
### Md Devops 2024 03 23 Yun (`docs/md/devops/2024-03-23-yun.md`)
---
title: 云服务器
lock: need
---
# 云服务器，2c2g 1年50、2c4g 1年126、4c16g 1月26.5
作者：小傅哥
那云服务器有很便宜，很实惠的吗？🤔
与过去云服务厂商不多的时候相比，现在的云服务器市场很卷，所以最实惠的也就是咱们这样的小用户。但凡自己或家里有几个没注册过的新用户，都能拿到这么便宜、实惠、好用的云服务器。
**💐 2c2g 1年 50元、2c4g 1年126元【推荐】、4c16g 3个月80元，2c4g 3年 558【推荐】、2c8g 3年998** —— 优惠链接：[https://618.gaga.plus/](https://618.gaga.plus/)
优惠链接：[https://yun.xfg.plus/](https://yun.xfg.plus/) - 我把最优惠的SKU做了汇总，你可以进入选择。点击后，还可以继续选配置。如果项目部署的较大，不要选2c2g。
>小傅哥，云服务器我有手✋🏻，我会买。那云服务器的使用教程有吗，能锻炼技能上云的项目有吗？🤔 —— 当然！有！你傅哥不就是卷这些的吗，管项目都卷了11万行代码给大家。
## 云服务器教程
- 关于云服务器的配置选择、环境安装、空间占用等各类实战的技巧，我都做了相关的视频，你只要跟着搞就可以。一次学习，永久收获！
- 注意：日常简单测试安装个轻量的环境，2c2g 会占用到 60%，长期使用推荐 2c4g。分布式所有环境（mysql、redis、nacos、elk、普罗米修斯、canal、前后端应用）需要 2c8g。
## 实战项目系列
小傅哥就是个实战派，1年、3年、2c2g、2c4g、2c8g 的服务器，我都有买，分别部署了不同的项目，自己可以锻炼，也让大家可以学习。地址：[https://gaga.plus](https://gaga.plus) - 进入后可以看到实战项目和部署演示。
在 `嘎嘎强 gaga.plus` 中有大量的实战项目，你都可以学习部署到云服务器上。而且会专门写好的教程和录制的手把手视频，教你从服务器选择、环境安装、应用构建、镜像部署、监控配置、应用压测，一步步带着你做。
## 嘎嘎实惠加入
小傅哥是一个大厂的架构师，经常会带着伙伴们，卷这些实际场景中非常有必要的技术。也会带着伙伴实战项目，这些项目也都是来自于互联网大厂中真实的业务场景，所有学习这样的项目无论是实习、校招、社招，都是有非常强的竞争力。别人还在玩玩具，而你已经涨能力！
>🧧在小傅哥星球「码农会锁」有8个实战项目，每个都是从0到1开发并提供简历模板和面试题，并且还在继续开发，后续还将有更多！价格嘎嘎实惠，早点加入，早点提升自己。项目地址：https://gaga.plus
---
### Md Other Guide To Reading (`docs/md/other/guide-to-reading.md`)
---
title: 编码指南
---
# bugstack虫洞栈 | 程序员的编码指南 🔥
>你好，我是小傅哥，[《重学Java设计模式》](https://item.jd.com/13218336.html)、[《手写MyBatis：渐进式源码实践》](https://item.jd.com/13811216.html) 图书作者，一线互联网 Java 工程师、架构师。
我是一个着迷于技术，又喜欢不断折腾的技术活跃者，从13年毕业到进入互联网，开发过交易、营销类项目，实现过运营、活动类项目，设计过中间件，组织过系统重构，发表过数十篇技术专利。不仅从事业务系统的开发工作，也经常做一些字节码插桩类的设计和实现，对架构的设计和落地有丰富的经验。在热衷于Java语言的同时，也喜欢研究中继器、I/O板卡、C#和PHP！
除此之外小傅哥并不只满足于CRUD搬砖，也关心业务、运营、产品、数据、测试、运维等各项知识体系的完善学习，就研发架构设计来讲，更全面的学习会更有利于做出更长远的架构设计。同时完善个人知识体系也更有利于个人成长。
所以你会看到小傅哥在工作之外的深夜、周末、假期会折腾于写文章、编小册、出书籍，并十分热情于对粉丝的交流、提问、解惑。并不深沉且少许逗比的我，希望我的沉淀，分享，也可以给你带来收获！
---
⏰ **提醒**：在接下来你对本博客的阅读中，如果遇到一些`内容`、`图稿`、`代码`等中的勘误都可以提交Issue或者PR的方式进行反馈，小傅哥会陆续进行完善，感谢您的支持；
- 贡献
- Issue：[https://github.com/fuzhengwei/CodeGuide/issues](https://github.com/fuzhengwei/CodeGuide/issues)
- PR：[https://github.com/fuzhengwei/CodeGuide/pulls](https://github.com/fuzhengwei/CodeGuide/pulls) - 你只需要在阅读文章的最下面找到`在 GitHub 上编辑此页`，即可完成克隆和提交PR
- 学习
- 博客 [小傅哥虫洞栈](https://bugstack.cn/) 具备丰富的企业级实战技能，可以综合提高自己的全方面架构、技术、项目、运维，方面知识积累。
- 项目 [星球「码农会锁」](https://bugstack.cn/md/zsxq/introduce.html) - 具有非常多的实战类业务项目、组件项目、开源项目等，☕️一顿饭钱的支持，突破技术瓶颈`！
- 演示 [嘎嘎强，嘎嘎哒学](https://gaga.plus/) - 应用级实战项目运行演示平台。用户可以体验项目运行效果，并学习每个功能的实现方案。
- 其他
- 考试：[100道八股题考试测验](https://bugstack.cn/md/zsxq/material/exam.html) —— 你可以尝试验证自己的能力，考题范围：数据结构、算法、源码、设计模式、系统架构、中间件、网络通信、实战项目、扩展问题
- 本站为公众号往期文章整理的小册，关注`公众号`：[bugstack虫洞栈](https://bugstack.cn/images/personal/qrcode.png) 可以知晓最新推文，避免错过最近正在更新的技术系列文章。
- 其他：如果你在学习本站内容遇到不能解决的问题，可以联系作者：`小傅哥`，微信：`fustack` - 交个朋友👬🏻，不要错过成为技术同好的机会。
## 一、本站知识阅览
我给自己在技术职业成长上，定位成一个能抗住`农夫三拳`的架构师，所以我在编写和输出的技术内容上，也是以数据结构、算法逻辑、设计模式、核心技术、系统架构、服务运维等方面的知识扩展技术广度和深度，并以实践验证的学习方式进行汇总内容编写文章。也希望这些成体系的技术系列内容能帮助你慢慢且踏实的成长起来。
而这几大块内容也是每一个较贵的 Java 程序员应该掌握的内容，可以包括：
- **编程路书**：开发一套[《Java简明学习路书》](https://bugstack.cn/md/road-map/road-map.html)，通过一个个小案例，为大家讲解这些技术栈的运用。帮助踏上这条路上的伙伴，以更简单明了的方式进入编程学习。最后再通过完整的项目实战，把这些技术栈串联起来运用。
- **Java&Spring**：以讲解Java、Spring核心知识为基础，用数学逻辑思维分析关于Java、Spring、Mybatis、Dubbo等核心源码技术内容。其中如[《Java 面经手册》](https://bugstack.cn/md/project/pdf/2021-01-26-Java%E9%9D%A2%E7%BB%8F%E6%89%8B%E5%86%8CPDF%E4%B8%8B%E8%BD%BD.html)是一本以面试题为入口讲解 Java 核心内容的技术书籍，书中内容极力的向你证实代码是对数学逻辑的具体实现。包括正在编写的[《手撸 Spring》](https://bugstack.cn/md/spring/develop-spring/2021-05-16-%E7%AC%AC1%E7%AB%A0%EF%BC%9A%E5%BC%80%E7%AF%87%E4%BB%8B%E7%BB%8D%EF%BC%8C%E6%89%8B%E5%86%99Spring%E8%83%BD%E7%BB%99%E4%BD%A0%E5%B8%A6%E6%9D%A5%E4%BB%80%E4%B9%88%EF%BC%9F.html)通过手写简化版 Spring 框架，了解 Spring 核心原理。在手写的过程中会简化 Spring 源码，摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能，例如：IOC、AOP、Bean生命周期、上下文、作用域、资源处理等内容实现。这些都程序员学习技术成长过程中非常重要的知识，如果能深入学习那么对以后的个人成长帮助非常大。
- **算法逻辑和数据结构**：这部分内容主要以Java源码为入手，讲解其中的数学知识，包括：扰动函数、负载因子、拉链寻址、开放寻址、斐波那契（Fibonacci）散列法还有黄金分割点的使用等等，这也正是[《Java 面经手册》](https://bugstack.cn/md/project/pdf/2021-01-26-Java%E9%9D%A2%E7%BB%8F%E6%89%8B%E5%86%8CPDF%E4%B8%8B%E8%BD%BD.html)的核心内容所在。
- **面向对象**：[《Java 设计模式》](https://item.jd.com/13218336.html)的知识是在Java基础铺平，数据结构、算法逻辑有了一定的了解后，在深入学习和使用的技术。同样是一个需求在学过设计模式后，也阅读了不少别人优秀的代码，那么在他实现需求的时候，会拆分出很多的接口和接口的继承、抽象类的职责隔离实现、具体业务模块的分层、功能服务组件的细化、具体实现过程中对设计模式的运用等等。这样的代码实现后会非常具有易扩展和可维护的特点，否则一篇的ifelse不是坑自己就是坑下一个人。
- **中间件**：可能很大一部分研发并不会接触到中间件，也不太可能有人告诉你可以使用中间件的方式解决一些实际遇到的问题。因为大部分时候你都会认为中间件只是公司专门部门的人写的，或者是技术大牛搞的，总之与你没关系。但其实代码知识对数学逻辑的具体实现，业务开发有业务开发的方式，[《Spring 中间件和开发》](https://bugstack.cn/md/project/springboot-middleware/2021-03-31-%E3%80%8ASpringBoot%20%E4%B8%AD%E9%97%B4%E4%BB%B6%E8%AE%BE%E8%AE%A1%E5%92%8C%E5%BC%80%E5%8F%91%E3%80%8B%E4%B8%93%E6%A0%8F%E5%B0%8F%E5%86%8C%E4%B8%8A%E7%BA%BF%E5%95%A6%EF%BC%81.html)也只是对Spring的关于容器中一些特定接口和类的使用，具体的还是普通的逻辑代码，比如暴露服务、采集日志、监控系统等。但如果你能早些学到这样技术的核心思想，那么对于升值、加薪、跳槽，都是非常有帮助的。
- **通信专题**：其实Netty是一项非常重要的技术，比如在RPC服务实现中的Dubbo、或者MQ、以及很多时候的通信里都是能用到的技术。就连小傅哥的第一次面试大厂也是靠着对Netty的学习，刷进来的！所以小傅哥编写了很多Netty从基础入门讲解到核心原理，告诉你如何处理半包、粘包，怎样定义消息协议，并开发了一个基于Netty的仿微信聊天项目，这些技术内容你都可以在我的博客学习到学习到。
- **字节码编程**：这项技术可能大多数研发，哪怕35岁的，可能也不一定接触到。但这样的技术你却基本都用过，比如你的IDEA是购买的吗，你怎么给让它能用的！你用过一些非入侵的全链路监控系统的，你通过字节码插桩搞过一些事情吗，那你用过Cglib吧，它的底层就是通过ASM字节码框架对字节码进行的一些列操作。
- **实战项目**：以实战项目的方式学习互联网大厂开发中应用到的技术，通过这样的实践方式把一些学习的技术应用起来，而不是单单的去背资料，但最终不知道该如何把这些技术内容综合起来使用。所以这里小傅哥以实战项目为主，推出：[大营销平台系统](https://bugstack.cn/md/project/big-market/big-market.html)、[OpenAi 大模型应用服务](https://bugstack.cn/md/project/chatgpt/chatgpt.html)、[Lottery 分布式抽奖系统](https://bugstack.cn/md/project/lottery/introduce/Lottery%E6%8A%BD%E5%A5%96%E7%B3%BB%E7%BB%9F.html)、[透视业务监控系统](https://bugstack.cn/md/zsxq/project/business-behavior-monitor.html)、[动态线程池组件](https://bugstack.cn/md/zsxq/project/dynamic-thread-pool.html)、[API网关](https://bugstack.cn/md/assembly/api-gateway/api-gateway.html)等众多项目。
- **关于**：除了技术学习以外，还有很多伙伴会经常问我一些关于学习、成长以及在职场中怎么活下去。所以我结合我自己在大厂互联网中的学习和成长经历，给读者伙伴写了不少此类的内容。如简历编写、招聘要求、技术资料、代码规范、评审晋升、薪资待遇、副业收入等等。这些内容可能很多会帮助你度过一个安定的职场生涯！
## 二、学习路线参考
可能有很大一部分处于开始成长阶段的码农伙伴，不太清楚自己要从哪里开始学习，哪怕手里有几个T的资料，也没有办法把这些内容吸收到大脑中。因此我把一些非常有必要学习的知识串连出一条学习路径，帮助处于不同阶段的伙伴找到学习方向，也可以把自己的技术水平和工资代码，都拉起来。🌶
- Java 面经手册：[https://download.csdn.net/download/Yao__Shun__Yu/14932325](https://download.csdn.net/download/Yao__Shun__Yu/14932325)
- 重学Java设计模式：[https://download.csdn.net/download/Yao__Shun__Yu/19265731](https://download.csdn.net/download/Yao__Shun__Yu/19265731)
- SpringBoot 中间件设计和开发：[https://juejin.cn/book/6940996508632219689](https://juejin.cn/book/6940996508632219689)
- 🔥Lottery Plus 大营销平台系 - DDD 分布式架构技术实践：[https://t.zsxq.com/199mpn9Lt](https://t.zsxq.com/199mpn9Lt)
- [更多项目](https://gaga.plus)
## 三、算法
- 地址：[Java 数据结构和算法](https://bugstack.cn/md/algorithm/data-structures/data-structures.html)
- 介绍：以Java源码为基础，结合使用场景，学习数据结构和算法。涵盖4类14种数据结构，包括：链表、数组、队列、堆栈、哈希表、堆、字典树、二分搜索树、平衡二叉树、2-3树、红黑树、并查集、图、布隆过滤器。
## 四、Java
### 1. Java 面经手册
- 地址：[Java 面经手册](https://bugstack.cn/md/java/interview/2020-07-28-%E9%9D%A2%E7%BB%8F%E6%89%8B%E5%86%8C%20%C2%B7%20%E5%BC%80%E7%AF%87%E3%80%8A%E9%9D%A2%E8%AF%95%E5%AE%98%E9%83%BD%E9%97%AE%E6%88%91%E5%95%A5%E3%80%8B.html)
- 介绍：全书共计5章29节，417页11.5万字，耗时4个月完成。涵盖数据结构、算法逻辑、并发编程、JVM以及简历和互联网大厂面试等内容。
[《Java 面经手册》](https://bugstack.cn/md/project/pdf/2021-01-26-Java%E9%9D%A2%E7%BB%8F%E6%89%8B%E5%86%8CPDF%E4%B8%8B%E8%BD%BD.html) 是一本以面试题为入口讲解 Java 核心技术的 PDF 书籍，书中内容也极力的向你证实`代码是对数学逻辑的具体实现`。*为什么这么说？* 当你仔细阅读书籍时，会发现这里有很多数学知识，包括：扰动函数、负载因子、拉链寻址、开放寻址、斐波那契（Fibonacci）散列法还有黄金分割点的使用等等。
编码只是在确定了研发设计后的具体实现，而设计的部分包括：数据结构、算法逻辑以及设计模式等，而这部分数据结构和算法逻辑在 Java 的核心 API 中体现的淋漓尽致。那么，也就解释了为什么这些内容成为了热点面试题，虽然可能我们都会觉得这样的面试像是造火箭。
### 2. 用Java实现JVM
- 地址：[用Java实现JVM](https://bugstack.cn/md/java/develop-jvm/2019-05-01-%E7%94%A8Java%E5%AE%9E%E7%8E%B0JVM%E7%AC%AC%E4%B8%80%E7%AB%A0%E3%80%8A%E5%91%BD%E4%BB%A4%E8%A1%8C%E5%B7%A5%E5%85%B7%E3%80%8B.html)
- 介绍：本专题按照《java虚拟机规范》、go语言版《自己动手写Java虚拟机》来实现自己的java版虚拟机。从而深入学习jvm的基础功能；搜索和解析class、字节码指令集、运行时数据区、虚拟机栈、栈桢、局部变量表、操作数栈、寄存器等是如何一步步将java代码运行起来的。
### 3. 基础技术
- 地址：[基础技术](https://bugstack.cn/md/java/core/2020-01-06-%5B%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%5D%E5%92%8B%E5%98%9E%EF%BC%9F%E4%BD%A0%E7%9A%84IDEA%E8%BF%87%E6%9C%9F%E4%BA%86%E5%90%A7%EF%BC%81%E5%8A%A0%E4%B8%AAJar%E5%8C%85%E5%B0%B1%E7%A0%B4%E8%A7%A3%E4%BA%86%EF%BC%8C%E4%B8%BA%E4%BB%80%E4%B9%88%EF%BC%9F.html)
- 介绍：讲解 JDK 新特性、JDK 和 CGLIB 反射、Byte 字节、技术扩展、常忽略的技术问题，帮研发同学更好的拉伸自己的技术栈学习。
## 五、Spring
### 1. Spring 手撸专栏
- 地址：[Spring 手撸专栏](https://bugstack.cn/md/spring/develop-spring/2021-05-16-%E7%AC%AC1%E7%AB%A0%EF%BC%9A%E5%BC%80%E7%AF%87%E4%BB%8B%E7%BB%8D%EF%BC%8C%E6%89%8B%E5%86%99Spring%E8%83%BD%E7%BB%99%E4%BD%A0%E5%B8%A6%E6%9D%A5%E4%BB%80%E4%B9%88%EF%BC%9F.html)
- 介绍：在写了部分关于 `Spring核心源码` 的面经内容后，我决定要去手撸一个Spring了。为啥这么干呢？因为所有我想写的内容，都希望它是以理科思维理解为目的方式学会，而不是靠着硬背记住。而编写面经的过程中涉及到的每一篇Spring源码内容分析，在即使去掉部分非主流逻辑后，依然会显得非常庞大。
- 此专栏是一本以开发简化版Spring学习其原理和内核的知识内容，不仅是代码编写实现也更注重内容上的需求分析和方案设计，所以在学习的过程要结合这些内容一起来实践，并调试对应的代码。粉丝伙伴在阅读的过程中，**千万不要害怕在学习的过程中遇到问题，这些都是正常的！** 希望你可以一直坚持把这些内容事必躬亲、亲历亲为的学完，加油！
### 2. Mybatis 手撸专栏
- 地址：[Mybatis 手撸专栏](https://bugstack.cn/md/spring/develop-mybatis/2022-03-20-%E7%AC%AC1%E7%AB%A0%EF%BC%9A%E5%BC%80%E7%AF%87%E4%BB%8B%E7%BB%8D%EF%BC%8C%E6%89%8B%E5%86%99Mybatis%E8%83%BD%E7%BB%99%E4%BD%A0%E5%B8%A6%E6%9D%A5%E4%BB%80%E4%B9%88%EF%BC%9F.html)
- 介绍：像我们之前完成[手写 Spring](https://mp.weixin.qq.com/s/g7YdIe_FSrk-WE8nQRO3TA)一样，拆解功能、简化流程、渐进实现，让读者能够更容易的学习到最有价值的知识。
在手写的过程中学习 Mybatis 从解析、绑定、反射、缓存，到会话和事务操作，以及如何与 Spring 进行关联注册 Bean 对象，完成整合部分功能逻辑。通过这些内容的拆解实现，读者伙伴就可以非常清楚的知道这些核心功能都是如何实现的了，以后再阅读 Mybatis 源码也就知道从哪开始到哪结束了。
### 3. Spring Cloud
- 地址：[Spring Cloud](https://bugstack.cn/md/spring/spring-cloud/2019-10-31-Spring%20Cloud%E9%9B%B6%E3%80%8A%E6%80%BB%E6%9C%89%E4%B8%80%E5%81%8F%E6%A6%82%E8%BF%B0%E5%91%8A%E8%AF%89%E4%BD%A0SpringCloud%E6%98%AF%E4%BB%80%E4%B9%88%E3%80%8B.html)
- 介绍：以案例实践的方式讲解 Spring Cloud 中常用的技术内容，包括：Eureka注册中心、熔断、降级、限流、动态刷新配置、消息总线、zuul 网关路由等
### 4. 源码分析
- 地址：[源码分析](https://bugstack.cn/md/spring/source-code/2019-12-25-%5B%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%5DMybatis%E6%8E%A5%E5%8F%A3%E6%B2%A1%E6%9C%89%E5%AE%9E%E7%8E%B0%E7%B1%BB%E4%B8%BA%E4%BB%80%E4%B9%88%E5%8F%AF%E4%BB%A5%E6%89%A7%E8%A1%8C%E5%A2%9E%E5%88%A0%E6%94%B9%E6%9F%A5.html)
- 介绍：拆解、分析、实践的方式进行源码学习，包括对 Mybatis 的分析和手写，这部分内容涵盖的非常广泛，可以让你非常清楚一个 ORM 框架是如何开发的以及怎么结合到 Spring 中，同时这部分内容还包括了 Quartz 定时任务全流程的分析，可以帮助你更好的理解任务的分层处理。
## 六、面向对象
### 1. 重学Java设计模式
- 地址：[重学Java设计模式](https://bugstack.cn/md/develop/design-pattern/2020-05-20-%E9%87%8D%E5%AD%A6Java%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E3%80%8A%E5%AE%9E%E6%88%98%E5%B7%A5%E5%8E%82%E6%96%B9%E6%B3%95%E6%A8%A1%E5%BC%8F%E3%80%8B.html)
- 视频：[https://www.bilibili.com/video/BV1D341177SV](https://www.bilibili.com/video/BV1D341177SV) - `与重学Java设计模式相对应，成体系录制`
- 介绍：本书是作者小傅哥，基于互联网真实案例编写的Java设计模式实践图书。全书以解决方案为核心，从实际开发业务中抽离出交易、营销、规则引擎、中间件、框架源码等22个真实场景，对设计模式进行全面、彻底的分析。帮助读者灵活地使用各种设计模式，从容应对复杂变化的业务需求，编写出易维护、可扩展的代码结构。
| 序号 | 类型 | 图稿 | 业务场景 | 实现要点 |
| ---- | ------------ | ------------------------------------------------------------ | ---------------------------------------------------- | ------------------------------------------------------------ |
| 1 | **工厂方法** | | 多种类型商品不同接口，统一发奖服务搭建场景 | 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 |
| 2 | **抽象工厂** | | 替换Redis双集群升级，代理类抽象场景 | 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 |
| 3 | **生成器** | | 各项装修物料组合套餐选配场景 | 将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 |
| 4 | **原型** | | 上机考试多套试，每人题目和答案乱序排列场景 | 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 |
| 5 | **单例** | | 7种单例模式案例，Effective Java 作者推荐枚举单例模式 | 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 |
- 图片引用：[https://refactoringguru.cn](https://refactoringguru.cn)
- 出版图书：[https://mp.weixin.qq.com/s/g9LYQEqzOeiYOpfG_5XFYg](https://mp.weixin.qq.com/s/g9LYQEqzOeiYOpfG_5XFYg)
### 2. DDD 专题
- 地址：[DDD 专题](https://bugstack.cn/md/develop/framework/ddd/2019-10-15-DDD%E4%B8%93%E9%A2%98%E6%A1%88%E4%BE%8B%E4%B8%80%E3%80%8A%E5%88%9D%E8%AF%86%E9%A2%86%E5%9F%9F%E9%A9%B1%E5%8A%A8%E8%AE%BE%E8%AE%A1DDD%E8%90%BD%E5%9C%B0%E3%80%8B.html)
- 介绍：领取驱动设计DDD{Domain-Driven Design}历史较长但随着微服务的兴起DDD又活跃到人们的视线，它提供的是一套架构设计思想，我们可以使用这套方法论将架构设计的尽可能做到高内聚、低耦合、可扩展性强的应用服务。本专题以DDD实战落地为根本，分章节设计不同的架构模型。学习并实战是奔入应用级最快的方法，Hi HelloWorld！我来了。
### 3. 工程框架
- 地址：[工程框架](https://bugstack.cn/md/develop/framework/frame/2019-12-22-%E6%9E%B6%E6%9E%84%E6%A1%86%E6%9E%B6%E6%90%AD%E5%BB%BA%E4%B8%80%E3%80%8A%E5%8D%95%E4%BD%93%E5%BA%94%E7%94%A8%E6%9C%8D%E5%8A%A1%E4%B9%8BSSM%E6%95%B4%E5%90%88%EF%BC%9ASpring4%20+%20SpringMvc%20+%20Mybatis%E3%80%8B.html)
- 介绍：讲解工程🏭框架的搭建，落地案例代码，方便有需要的研发伙伴以此为模板快速搭建自己需要的框架工程，也是一种入门的学习的最快方式。
### 4. 架构设计
- 地址：[架构设计](https://bugstack.cn/md/develop/framework/scheme/2021-02-04-%E5%9F%BA%E4%BA%8EIDEA%E6%8F%92%E4%BB%B6%E5%BC%80%E5%8F%91%E5%92%8C%E5%AD%97%E8%8A%82%E7%A0%81%E6%8F%92%E6%A1%A9%E6%8A%80%E6%9C%AF%EF%BC%8C%E5%AE%9E%E7%8E%B0%E7%A0%94%E5%8F%91%E4%BA%A4%E4%BB%98%E8%B4%A8%E9%87%8F%E8%87%AA%E5%8A%A8%E5%88%86%E6%9E%90.html)
- 介绍：讲解互联网大厂中一些场景的复杂场景，该如何设计和落地，包括：IDEA 插件、低代码、脚手架、DDD、中台、非入侵的全链路监控、字节码插庒等场景问题。
## 七、中间件
### 1. Spring Boot 中间件开发
- 地址：[Spring Boot 中间件开发](https://bugstack.cn/md/assembly/middleware/2019-12-02-SpringBoot%E6%9C%8D%E5%8A%A1%E6%B2%BB%E7%90%86%E4%B8%AD%E9%97%B4%E4%BB%B6%E4%B9%8B%E7%BB%9F%E4%B8%80%E7%99%BD%E5%90%8D%E5%8D%95%E9%AA%8C%E8%AF%81.html)
- 介绍：讲解基础的 Spring Boot Starter 开发流程，以及如何设计实现的，并且该怎么把这样的插件发布到中心仓库中。如果对此感兴趣也可以阅读：[SpringBoot 中间件设计和开发](https://bugstack.cn/md/project/springboot-middleware/2021-03-31-%E3%80%8ASpringBoot%20%E4%B8%AD%E9%97%B4%E4%BB%B6%E8%AE%BE%E8%AE%A1%E5%92%8C%E5%BC%80%E5%8F%91%E3%80%8B%E4%B8%93%E6%A0%8F%E5%B0%8F%E5%86%8C%E4%B8%8A%E7%BA%BF%E5%95%A6%EF%BC%81.html) - `这里有更完整的中间件开发学习，包括：服务治理、ORM框架、分布式组件、字节码应用`
### 2. IDEA Plugin 开发
- 地址：[IDEA Plugin 开发](https://bugstack.cn/md/assembly/idea-plugin/2021-08-27-%E6%8A%80%E6%9C%AF%E8%B0%83%E7%A0%94%EF%BC%8CIDEA%20%E6%8F%92%E4%BB%B6%E6%80%8E%E4%B9%88%E5%BC%80%E5%8F%91%EF%BC%9F.html)
- 介绍：IDEA 插件开发可以帮助研发人员提升能效，解决一些实际场景中的共性问题。但最近在折腾IDEA插件开发的时候，市面的资料确实不多，也没有成体系完整的开发指导手册，所以就遇到了很多不知道就不会的事情，需要一点点查询搜索源码、验证API接口，最终把各项功能实现，当然在这个过程中也确实踩了不少坑！接下来在这个专栏会把一些关于 IDEA 插件开发用到的各项知识做成案例输出出来，帮助有需要的研发伙伴，一起建设 IDEA Plugin
- **开发方式**：在官网的描述中，创建IDEA插件工程的方式有两种分别是，IntelliJ Platform Plugin 模版创建和 Gradle 构建方式。
- **框架入口**：一个 IDEA 插件开发完，要考虑把它嵌入到哪，比如是从 IDEA 窗体的 Edit、Tools 等进入配置还是把窗体嵌入到左、右工具条还是IDEA窗体下的对话框。
- **UI**：思考的是窗体需要用到什么语言开发，没错，用的就是 Swing、Awt 的技术能力。
- **API**：在 IDEA 插件开发中，一般都是围绕工程进行的，那么基本要从通过 IDEA 插件 JDK 开发能力中获取到工程信息、类信息、文件信息等。
- **外部功能**：这一个是用于把插件能力与外部系统结合，比如你是需要把拿到的接口上传到服务器，还是从远程下载文件等等。
### 3. API网关：中间件设计和实践
- 地址：[API网关：中间件设计和实践](https://bugstack.cn/md/assembly/api-gateway/2022-08-12-%E5%BC%80%E7%AF%87%EF%BC%9A%E5%A6%82%E6%9E%9C%E8%AE%A9%E6%88%91%E8%AE%BE%E8%AE%A1%E4%B8%80%E5%A5%97%EF%BC%8CTPS%E7%99%BE%E4%B8%87%E7%BA%A7API%E7%BD%91%E5%85%B3.html)
- 介绍：API网关，是所有互联网大厂都有的一个核心服务，承接着来自用户的滴滴打车、美团外卖、京东购物、微信支付，更是大促期间千万级访问量的核心系统。
## 八、Netty 4.x
- 地址：[Netty 4.x](https://bugstack.cn/md/netty/base/2019-07-30-netty%E6%A1%88%E4%BE%8B%EF%BC%8Cnetty4.1%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8%E7%AF%87%E9%9B%B6%E3%80%8A%E5%88%9D%E5%85%A5JavaIO%E4%B9%8B%E9%97%A8BIO%E3%80%81NIO%E3%80%81AIO%E5%AE%9E%E6%88%98%E7%BB%83%E4%B9%A0%E3%80%8B.html)
- 介绍：跟着案例学Netty，Netty4.x案例从简单入门到应用实战，全篇37章节优秀案例+实战源码[基础篇(13)、中级篇(13)、高级篇(3章+)、源码分析篇]，以上章节全部完成并不断持续更新中。
## 九、字节码编程(ASM、Javassist、Byte-Buddy)
- 地址：[字节码编程(ASM、Javassist、Byte-Buddy)](https://bugstack.cn/md/bytecode/asm/2020-03-25-%5BASM%E5%AD%97%E8%8A%82%E7%A0%81%E7%BC%96%E7%A8%8B%5D%E5%A6%82%E6%9E%9C%E4%BD%A0%E5%8F%AA%E5%86%99CRUD%EF%BC%8C%E9%82%A3%E8%BF%99%E7%A7%8D%E6%8A%80%E6%9C%AF%E4%BD%A0%E6%B0%B8%E8%BF%9C%E7%A2%B0%E4%B8%8D%E5%88%B0.html)
- 介绍：但全书共计107页，11万7千字，20个章节涵盖三个字节码框架和JavaAgent使用并附带整套案例源码！讲道理，市面上以及网络搜索中都基本很少有成体系的关于字节码编程的知识，这主要由于大部分开发人员其实很少接触这部分内容，包括；ASM、Javassist、Byte-buddy以及JavaAgent，没有很大的市场也就没有很多的资料。但大家其实已经从其他的框架或者中间件中使用到，就像你用到的；Cglib、混沌工程、非入侵的全链路监控以及你是否使用过jetbrains-agent.jar做了某项实验？
## 十、实战项目
### 1. 业务类型
#### 1.1 大营销平台系统
项目：[https://bugstack.cn/md/project/big-market/big-market.html](https://bugstack.cn/md/project/big-market/big-market.html)
这个新项目，结合小傅哥已经带着大家完成的 OpenAi 大模型应用业务场景，做上层的营销活动。这就像互联网公司中有了电商、外卖、出行等场景一样，在场景之上做营销活动。所以我们的新项目是 **《大营销平台系统》**！因为小傅哥的星球之前做过了一个抽奖，那么这个项目会用新的DDD架构，对抽奖系统进行重构，并扩展出`营销账户`、`用户返利`、`积分兑换`等服务，完成一整套的营销平台功能。💥
#### 1.2 OpenAi 大模型应用服务体系构建 - API-SDK、鉴权、公众号、企业微信、支付服务
项目：[https://bugstack.cn/md/project/chatgpt/chatgpt.html](https://bugstack.cn/md/project/chatgpt/chatgpt.html)
此项目以围绕类似 ChatGPT 生成式服务，构建微服务应用架构体系组件。包括；用户鉴权、公众号、多方支付、企业微信等对接方式，满足不同诉求的使用。并以模块化设计，积木式构建应用，让不同的场景诉求都可以配置化对接。
#### 1.3 Lottery 抽奖系统 - 基于领域驱动设计的四层架构实践
- 地址：[Lottery 抽奖系统 - 基于领域驱动设计的四层架构实践](https://bugstack.cn/md/project/lottery/introduce/Lottery%E6%8A%BD%E5%A5%96%E7%B3%BB%E7%BB%9F.html)
- 介绍：`Lottery 抽奖系统` 项目是一款互联网面向C端人群营销活动类的抽奖系统，可以提供抽奖活动玩法策略的创建、参与、记账、发奖等逻辑功能。在使用的过程中运营人员通过创建概率类奖品的抽奖玩法，对用户进行拉新、促活、留存，通常这样的系统会用在电商、外卖、出行、公众号运营等各类场景中。
在此项目中你会学习到互联网公司关于C端项目开发时候用到的一些，技术、架构、规范等内容。由于项目为实战类编程项目，在学习的过程中需要上手操作，小傅哥会把系统的搭建拉不同的分支列为每一个章节进行设计和实现并记录到开发日记中，读者在学习的过程中可以结合这部分内容边看文章边写代码实践。
- 技术：SpringBoot、Mybatis、Dubbo、MQ、Redis、Mysql、ELK、分库分表、Otter
- 架构：DDD 领域驱动设计、充血模型、设计模式
- 规范：分支提交规范、代码编写规范
#### 1.4 IM Netty 仿PC端微信
- 地址：[IM Netty 仿PC端微信](https://bugstack.cn/md/project/im/2020-03-04-%E3%80%8ANetty+JavaFx%E5%AE%9E%E6%88%98%EF%BC%9A%E4%BB%BF%E6%A1%8C%E9%9D%A2%E7%89%88%E5%BE%AE%E4%BF%A1%E8%81%8A%E5%A4%A9%E3%80%8B.html)
- 介绍：🎭 本项目是作者小傅哥使用JavaFx、Netty4.x、SpringBoot、Mysql等技术栈和偏向于DDD领域驱动设计方式，搭建的仿桌面版微信实现通信核心功能。课程文章已发布到GitChat专栏，欢迎购买。
**第一章节**：**UI开发**。使用`JavaFx`与`Maven`搭建UI桌面工程，逐步讲解登录框体、聊天框体、对话框、好友栏等各项UI展示及操作事件。从而在这一章节中让Java 程序员学会开发桌面版应用。
**第二章节**：**架构设计**。在这一章节中我们会使用DDD领域驱动设计的四层模型结构与Netty结合使用，架构出合理的分层框架。同时还有相应库表功能的设计。相信这些内容学习后，你一定也可以假设出更好的框架。
**第三章节**：**功能实现**。这部分我们主要将通信中的各项功能逐步实现，包括；登录、添加好友、对话通知、消息发送、断线重连等各项功能。最终完成整个项目的开发，同时也可以让你从实践中学会技能。
### 2. 组件类型
#### 2.1 透视业务流程 - 监控系统
项目：[https://bugstack.cn/md/zsxq/project/business-behavior-monitor.html](https://bugstack.cn/md/zsxq/project/business-behavior-monitor.html)
本次项目会采用基于扩展 logback 日志上报数据进行 ognl 配置节点公式的方式进行采集、计算和可视化渲染。在这套项`小而美，小而精`的组件项目中，你可以学习到非常多的实战技能。
这套`透视业务流程的监控系统`，与 `Prometheus + Grafana`、`Skywalking` 有较大的差异。这两款监控都是系统健康度监控，而小傅哥带着大家做的是业务流程监控。*很多中大厂，也都有同类的业务系统*
#### 2.2 动态线程池组件实现
项目：[https://bugstack.cn/md/zsxq/project/dynamic-thread-pool.html](https://bugstack.cn/md/zsxq/project/dynamic-thread-pool.html)
本次带着大家做的这款动态线程池组件项目，也是各个中大厂中都非常常见的组件能力。通过这样的学习，以中大厂的经验补充自身的技术积累，让自己的简历和职业生涯都有东西可讲。
我们知道，线程池（Thread Pool），是一种基于池化思想管理线程的工具，用于降低资源消耗、提高响应速度、提高线程的管理性。池化技术的引入，可以有效的减少线程频繁申请/销毁和调度所带来的额外开销。对于池化思想，我们还能看到；内存池、连接池、化粪池。
#### 2.3 支付SDK设计和开发
项目：[https://bugstack.cn/md/zsxq/project/ltzf-sdk-java.html](https://bugstack.cn/md/zsxq/project/ltzf-sdk-java.html)
在面试中详细了解得知，不少伙伴压根是没有做支付的。而是一个假的模拟支付，修改数据库状态，当做支付而已。这样做有个很大的问题就是没法全面的了解支付流程，包括在`掉单`、`幂等`、`透传`、`回调`等方面的业务是很难清晰的理解的。所以在面试过程中也就压根不知道支付这一块。但不写支付，又觉得整个项目不完整，并且很多公司面试都会问一些支付的内容。那怎么办😰呢？
小傅哥在带着大家做的项目和小场景中，有做过微信支付，支付宝沙箱支付，但想做真实的支付一般是需要个体户或者公司主体的。不过好在市面还有一些专门提供给个人使用的支付，比如；蓝兔、虎皮椒、PayJS。这些支付中，小傅哥测试验证了蓝兔支付，为它提供了一款SDK，让大家像使用微信支付一样简单的使用蓝兔支付。
#### 2.4 《SpringBoot 中间件设计和开发》
- 地址：[《SpringBoot 中间件设计和开发》](https://bugstack.cn/md/project/springboot-middleware/2021-03-31-%E3%80%8ASpringBoot%20%E4%B8%AD%E9%97%B4%E4%BB%B6%E8%AE%BE%E8%AE%A1%E5%92%8C%E5%BC%80%E5%8F%91%E3%80%8B%E4%B8%93%E6%A0%8F%E5%B0%8F%E5%86%8C%E4%B8%8A%E7%BA%BF%E5%95%A6%EF%BC%81.html)
- 介绍：说到底，为什么要扒开CRUD的表面，深入到核心源码实践学一些中间件开发技能，还不是希望自己对技术栈学习有一定的深度，免得面试时被人忽悠压薪资。就像人家问你：类的代理、反射调用是在什么场景用到的？ 自定义注解是怎么和切面一起获取到信息使用的？你需要的yml配置信息是如何被SpringBoot加载并初始化的？Bean 是如何被注入到 Spring 容器，提供服务的？综上，等等这些技术点可能很多时候你所学到的只能称作为背答案、记结果，因为没有实操所以过后就忘而且也扛不住面试官的接连发问。
- **技术框架**：包括 Spring、SpringBoot 配置加载、自定义注解、扫描注册Bean等，以及 ORM 框架设计原理和实现。这部分技术主要是把开发的中间件与框架结合，开发相应的组件或者包装为各类 SpringBoot Starter 的能力学习。
- **数据服务**：Mysql、Redis、Elasticsearch，都是数据服务，通常需要开发各类组件对数据服务的使用进行封装，Mysql 我们知道有 JDBC，Redis 我们知道有 Jedis，但 Elasticsearch 有 x-pack 你是否了解。
- **数据组件**：这类组件的开发就是为了简化对数据服务的使用，Mysql+JDBC+ORM，可以非常方便的使用数据库服务，那么 Elasticsearch 是否也可以做相应的组件研发，让它的查询也能像使用 MyBatis 一样呢？二折页的技术能力就需要对 MyBatis 等 ORM 框架的实现原理熟悉，同时需要了解 JDBC 的概念。
- **分布式技术**：RPC 框架、注册中心、分布式任务，都是现有互联网分布式架构中非常重要的技术，而对于如何实现一个 RPC 框架，也技术是研发人员要掌握的重点，同时如何使用注册中心、怎么下发分布式调度任务，等等，这些技术的学习能让对现有的框架使用有更深入的认识。
- **服务治理**：熔断、降级、限流、切量、黑白名单以及对现有方法的非入侵式扩展增强等，都可以成为是服务治理类组件，原本这类技术在早期是与业务逻辑代码融合的，后来逐步被拆解出来，开发成对应的组件。所以我们可以学习到，关于这类组件的包装、集成是如何做的。
- **字节码&插件**：在互联网的系统应用运维过程中，你一定会接触到各类的监控系统，而很多监控系统是非入侵的全链路监控，那么这些是如何实现的呢？其实它们是基于字节码插桩，对系统方法的增强，采集相应的运行时信息，进行监控的。再到扩展 JVMTI、IDEA 插件开发，都是为了整个研发过程的可持续交付和上线提高交付质量和降低人效的。
#### 2.5 API网关
项目：[https://bugstack.cn/md/assembly/api-gateway/api-gateway.html](https://bugstack.cn/md/assembly/api-gateway/api-gateway.html)
API网关系统用于统一管理RPC（Dubbo）通信接口，通过协议解析和泛化调用统一对外提供HTTP服务的系统。这套系统是微服务架构设计，分为核心通信、启动引擎、注册中心、管理平台以及上报接口服务。这套API网关也是随着对公司传统庞大的单体应用（All in one）拆分为众多的微服务（Microservice）以后，所引入的统一通信管理系统。用于运行在外部HTTP请求与内部RPC服务之间的一个流量入口，实现对外部请求的协议转换、参数校验、鉴权、切量、熔断、限流、监控、风控等各类共性的通用服务。
这是一整套API网关的核心通信模型结构图，以API网关算力的多套服务注册到网关中心开始，拉取RPC应用接口并完成映射HTTP调用操作。最终允许用户通过 Nginx 访问和路径重写的负载均衡管理，调用到具体的网关算力中执行协议解析和RPC接口的泛化调用并最终返回结果数据。
**综上**，这些贯穿整个互联网系统架构中的各类典型中间件，都会在后续章节中陆续讲解出来，它们是如何设计和实现的，一点点带你解开中间件的神秘面纱，让你的技术栈知识也增加一些有深度的并且是可以亲自操作的内容。
## 📚PDF 下载
- Java 面经手册：[https://download.csdn.net/download/Yao__Shun__Yu/14932325](https://download.csdn.net/download/Yao__Shun__Yu/14932325)
- 重学Java设计模式：[https://download.csdn.net/download/Yao__Shun__Yu/19265731](https://download.csdn.net/download/Yao__Shun__Yu/19265731)
- 字节码编程：[https://download.csdn.net/download/Yao__Shun__Yu/12505051](https://download.csdn.net/download/Yao__Shun__Yu/12505051)
- IDEA Plugin 开发手册：[https://download.csdn.net/download/Yao__Shun__Yu/77484299](https://download.csdn.net/download/Yao__Shun__Yu/77484299)
## 关于
关于自己、关于学习、关于职场，👉 如果你是刚入行、在外包、跨语言学习、想跳槽大厂、缺少学习动力等，可以阅读小傅哥的成长故事，这个系列包括了我的个人在外包到大厂的成长、跳槽的过程、互联网的学习经历，那么可以阅读一下。Go -> [https://bugstack.cn/md/about/me/about-me.html](https://bugstack.cn/md/about/me/about-me.html)
---
### Md Other Road Map (`docs/md/other/road-map.md`)
---
title: 编程路书
---
# bugstack虫洞栈 | 编程路书 v1.0 👣 - Java 程序员的简明教程 👨🏻💻 @小傅哥
作者：小傅哥
---
### Md Road Map 13scan Jdumpspider (`docs/md/road-map/13scan-jdumpspider.md`)
---
title: w13scan-jdumpspider 安全漏洞扫描
lock: need
---
# 安全漏洞扫描，他怎么拿到了我的数据库密码？
作者：小傅哥
**那这是怎么被发现暴漏的呢？🤔**
做安全的有一套应用漏洞检查扫描的软件，它通过启动被动流量扫描服务，通过代理的方式，挂载到自身的浏览器。日常的访问一些网站时，所有的流量节点都会进入到被动扫描代理服务中，之后消耗这些流量节点，依次检测每个地址下可能发生的；XSS、jsonp信息泄露、sql注入、http smuggling 走私攻击，以及可以根据各类组件提供的漏洞问题做扫描补偿。这样就可以拿到你的网站都有哪些安全漏洞问题了。
这里有一个最典型的就是 SpringBoot Actuator 安全点暴漏，这东西是可以拿到你的 heapdump，之后再通过 JDumpSpider 扫描，也就可以拿到你应用中的数据源、配置文件、Redis配置、ShiroKey等信息。此时如果你的数据库恰好没有配置IP访问限制，那么直接远程连接登录进去，一顿操作了。
那么整个这样一个流程怎么玩一下呢？这东西只有亲自上下手，才会感受到它的恐怖。接下来，小傅哥就教你做被动安全扫描操作和 heapdump 下载分析提取数据库密码。
## 一、流程介绍
关于被动扫描系统安全漏洞的服务系统有很多，包括 w13scan 免费开源的，也有 xray 付费的，还有的是公司或者个人独立开发的。本节我们主要使用 w13scan 作为安全漏洞扫描的案例。
- 首先， w13scan 的流程是这样，你需要先启动一个这样的被动扫描服务，之后再你的浏览器中配置网页请求代理地址。这个代理地址就是 w13scan 服务。
- 那么，这个时候你所有在浏览器发起的请求，都会经过 w13scan 走一圈。这样，就可以把请求的网址进行一系列安全扫描检查，查看是什么样的漏洞。
- 另外，w13scan 不只是可以被动扫描还可以主动配置路径扫描一个固定的网站地址检测。
- 最后，w13scan 会把扫描到的安全漏洞以html方式展示出来，我们可以在这个网页上查看漏洞检测结果。也就可以在进一步对存在的漏洞进行挖局，如拿到 heapdump 在解析它的信息了。
## 二、案例工程
这里小傅哥为你提供了完整的案例测试工程，你可以直接完整体验。`你需要有 docker 环境或者 Python 3.6+`
地址：[https://github.com/fuzhengwei/xfg-dev-tech-w13scan-jdumpspider](https://github.com/fuzhengwei/xfg-dev-tech-w13scan-jdumpspider)
- 首先，你需要下载这个工程到本地电脑，便于安装环境和测试。
- 如图，已经为你描述了案例的功能。
## 三、被动扫描
**源码**：[https://github.com/fuzhengwei/w13scan](https://github.com/fuzhengwei/w13scan) - 小傅哥 fork 的 w13scan 并做了镜像打包。源码文档里提供了安装和使用说明。
### 1. 组件安装 - docker 方式
```java
# docker-compose -f docker-compose.yml up -d
version: '3.8'
services:
w13scan:
image: fuzhengwei/w13scan:1.0
container_name: w13scan
ports:
- "7778:7778"
volumes:
- ./output:/w13scan/W13SCAN/output
entrypoint: ["python3", "w13scan.py", "-s", "0.0.0.0:7778", "--html"]
tty: true
```
- 你可以通过脚本 `docker-compose -f docker-compose.yml up -d` 脚本执行 w13scan 的服务安装。
- 另外，如果你不能执行 docker-compose 还可以通过提供的 `docker run -d --name w13scan -p 7778:7778 -v ./output:/w13scan/w13scan/output fuzhengwei/w13scan:1.0 python3 w13scan.py -s 127.0.0.1:7778 --html`
### 2. 组件安装 - Python 方式
这个方式就把代码拉到自己本地，进行构建和启动。
```java
git clone https://github.com/fuzhengwei/w13scan.git
cd w13scan # 进入git目录
pip3 install -r requirements.txt
cd W13SCAN # 进入源码目录
python3 w13scan.py -h
```
```java
python3 w13scan.py -s 127.0.0.1:7778 --html # 端口可省略，默认为7778,开启--html即实时生成html报告
```
- 安装完成后启动，也可以看到一个 ` HTTPServer is running at address('0.0.0.0','7778')......` 日志。
### 3. 代理配置
无论使用那种方式部署，启动完成后，都需要给浏览器配置代理。其实也就是你的电脑的网络哪里配置下代理。
- 给你的网络配置代理服务，我这里是 mac 电脑点网络wifi那里进入的配置。你可以找到你的位置进行添加。
### 4. 下载证书
下载：[http://w13scan.ca/](http://w13scan.ca/)
一定是你服务启动成功，代理配置成功。那么你在点击下载后，才能下载一个 `download.crt` 文件。之后双击点开信任即可。
### 5. 开始使用
一切配置成功后，你可以在浏览器访问你想检查漏洞的网址，一段时间后就可以看到被动扫描组件检测的数据信息了。之后进入到 `w13scan/W13SCAN/output` 查看检测文件了。这些 html 文件直接用浏览器打开和刷新即可。
- 现在你就看到一些展示的系统安全漏洞了，再根据这些漏洞进行**友好的访问**
## 四、heapdump 下载
测试前你可以先启动 xfg-dev-tech-w13scan-jdumpspider 应用。这样就可以做后面的流程以及获取 heapdump 日志了。
### 1. 问题背景
测试工程中的 yml 配置。这个配置为了配合普罗米修斯做监控使用的，但要注意如果只是这样配置，是很有风险的。
```java
# 监控
management:
endpoints:
web:
exposure:
include: "*"
endpoint:
health:
show-details: always
metrics:
export:
prometheus:
enabled: true
prometheus:
enabled: true
```
- 如果你的 SpringBoot 系统配置了这样的监控，并且没有配置相关的安全校验，Spring Security 那么现在你就暴漏了自己的端点。
### 2. 端点访问
地址：[http://127.0.0.1:8091/actuator/env](http://127.0.0.1:8091/actuator/env)
- 这个地址，就可以由被动扫描检测出来。不过不同的被动扫描组件检测点不同，有些是没有的。
### 3. 下载 dump
地址：[http://127.0.0.1:8091/actuator/heapdump](http://127.0.0.1:8091/actuator/heapdump)
- 把工程的 heapdump 文件下载下来。下载后可以放到案例工程 docs 里 JDumpSpider-1.1-SNAPSHOT-full.jar 的同层路径下。
## 五、heapdump 解析
以前小傅哥带着大家做一篇[《Eclipse MAT 分析 Java heap space dump 日志》](https://bugstack.cn/md/road-map/dump-mat.html) 这个也能分析 dump 日志查看系统中的核心数据。不过这里我们选择个更针对性的 JDumpSpider 做日志分析，直接提取核心配置。
源码：[https://github.com/whwlsfb/JDumpSpider](https://github.com/whwlsfb/JDumpSpider) - 有相关的使用说明。
命令：`java -jar JDumpSpider-1.1-SNAPSHOT-full.jar heapdump`
```java
/bin/zsh /xiaofuge/develop/github/xfg-dev-tech-w13scan-jdumpspider/docs/jdumpspider.sh
(base) xiaofuge@ZBMac-GV47H1GXD docs % /bin/zsh /Users/xiaofuge/Documents/develop/github/xfg-dev-tech-w13scan-jdumpspider/docs/jdumpspider.sh
===========================================
SpringDataSourceProperties
-------------
password = 123456
driverClassName = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://127.0.0.1:13306/road_map?useUnicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&serverTimezone=UTC&useSSL=true
username = root
===========================================
WeblogicDataSourceConnectionPoolConfig
-------------
not found!
===========================================
MongoClient
-------------
not found!
===========================================
AliDruidDataSourceWrapper
-------------
not found!
===========================================
HikariDataSource
-------------
not found!
```
- 命令执行后可以看到你的工程中连接数据库的配置，密码也会直接暴漏出来。其他的配置如果你有添加，也会一并给你拿出来。**底裤给你扒掉**
## 六、安全建议
- 对于自己上线的应用，尤其独立开发者，一定多进行安全扫描。
- 不要无密码暴漏自己的应用，包括任何监控、数据采集、以及第三方组件。
- 数据库、缓存、文件等连接，在云服务器要配置上可访问IP限制。这样就算底裤拔掉了，也还有一个玻璃罩。只能看，不能连。
---
### Md Road Map 1panel (`docs/md/road-map/1panel.md`)
---
title: 1Panel 运维面板
lock: need
---
# 1Panel 云服务器运维面板 | 操作云服务器，这套东西还适合小白的！
作者：小傅哥
**那云服务器操作有Easy工具吗？🤔**
小傅哥，在最早使用云服务器的时候，为了快速简单的搭建博客对外使用，选择过宝塔面板。这个东西虽然不大，但对于最开始云服务器操作能力和对编程的理解都比较偏弱的伙伴还是非常好用的。
但当大家开始使用 Linux + Docker，对一些列分布式环境继续安装和项目构建部署时，有些小白就会遇到一些各类小问题了。只有写好了 docker compose 和对应的文档，才能让小白快速完成安装。但有一些小白用到的新的服务安装时，自己不会写 docker compose 就会遇到新问题了。所以，今天我们来体验下一个新的云服务器运维面板，非常好用。
## 一、面板介绍
1Panel 是新一代的 Linux 服务器运维管理面板，它可以帮助你非常方便管理云服务器上的软件操作。`也不需要再配置 docker 代理了。`
- 用户可以通过 Web 图形界面轻松管理 Linux 服务器，实现主机监控、文件管理、数据库管理、容器管理等功能。
- 深度集成开源建站软件 WordPress 和 Halo，域名绑定、SSL 证书配置等一键搞定。
- 精选上架各类高质量的开源工具和应用软件，协助用户轻松安装并升级。
- 基于容器管理并部署应用，实现最小的漏洞暴露面，同时提供病毒防护、防火墙和日志审计等功能。
- 支持一键备份和恢复，用户可以将数据备份到各类云端存储介质，永不丢失。
> 好啦，介绍的还挺🐂皮的，咱们来体验下！
## 二、安装软件
### 1. 安装脚本
```java
curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start.sh && sh quick_start.sh
```
- Centos 一键安装脚本，复制到云服务器直接执行即可。
- 其他的云服务器系统安装脚本：https://1panel.cn/docs/installation/online_installation/
- 2c2g 云服务器，活动价，一年26元 [https://618.gaga.plus](https://618.gaga.plus)
### 2. 安装效果
- 安装过程中你可以顺序点回车即可，注意是否配置镜像加速，因为我配置过，所以没有配置。你可以选 Y 统一配置镜像加速。
- 安装完成后，会得到一个外网地址，端口是默认的 19166，同时给会你用户和密码。注意，需要在云服务器开放端口（安全组/防火墙）19166 另外账号密码可以在登录后修改。
## 三、软件功能
### 1. 查看容器
- 你的 Linux 安装 Docker 会直接被 1Panel 接管。在 1Panel 会看到你安装过的软件。
- 同时可以看到每个软件占用的 CPU、内存，这个还是非常好用的。
### 2. 安装软件
- 在 1Panel 的应用商店里，可以按照你需要的各类软件（它的覆盖度还是非常全的），包括常用的：Nginx、MySQL、MQ、Nacos、PHPAdmin等等，都是有的。
- 如图，是个 OneAPI 它是用于访问兼容访问各类其他 OpenAI 的软件的。比如，文心一言、通义千问、讯飞星火、智谱 ChatGLM、腾讯混元，都可以按照 ChatGPT 的格式进行使用啦。
>好啦，你可以美滋滋的去体验下啦！🌶
---
### Md Road Map A2a (`docs/md/road-map/a2a.md`)
---
title: a2a
lock: need
---
# A2A，实际跑起来是什么样？
作者：小傅哥
针对这些 LLM 大模型的相关知识，小傅哥也分别提供了相关实战类项目，包括；**AI 问答助手（23年）**、**OpenAi(ChatGPT/ChatGLM) 微服务应用体系构（23年）**、**OpenAI 代码自动评审组件（24年）**、**AI Agent 智能体 - 拖拉拽（25年）**、**AI MCP Gateway 网关服务系统（25年）**、**AI Agent 脚手架 + 场景应用（26年）**，通过这些实战项目，实践各类标准协议和技术组件（spring ai、google adk...）的使用，以及提供非常出色的解决方案。
因为后续的 ai agent 智能体项目，还会涉及到 a2a 协议，所以先给大家做个相关技术的使用方便大家快速实践理解。
>🧧 文末提供了20个实战项目（6个AI、5个业务、8个组件、1套源码），以及各类编程技术小册等。欢迎一起加入学习。
## 一、A2A 是什么？
A2A (Agent2Agent) 协议是 Google于2025年4月推出、并由 Linux基金会托管的开源开放标准。它作为AI智能体之间的“通用语言”，旨在实现不同框架、不同厂商构建的智能体（Agent）间跨平台发现、通信与协作。
随后25年底，Google 发布了 [a2a adk](https://central.sonatype.com/artifact/com.google.adk/google-adk-a2a/0.4.0) 组件（迭代速度很快）。之后借助代理开发工具包 (Google ADK)，我们可以构建复杂的多代理系统，其中不同的代理需要使用代理对代理 (A2A) 协议进行协作和交互！本节提供了一个全面的指南，指导您构建强大的多代理系统，使代理能够安全高效地进行通信和协作。
框架：[https://google.github.io/adk-docs/a2a/](https://google.github.io/adk-docs/a2a/)
源码：[https://github.com/google/adk-java](https://github.com/google/adk-java)
资料：[https://www.ibm.com/cn-zh/think/topics/agent2agent-protocol](https://www.ibm.com/cn-zh/think/topics/agent2agent-protocol)
文档：[https://a2aprotocol.ai/docs/](https://a2aprotocol.ai/docs/)
---
如图，整套智能体架构（含A2A）；
- 左侧，是 LLM 模型智能体构建，基于 Spring AI 框架实现。这部分包括，AiApi 使用、RAG、MCP、Skills 的组合构建。
- 右侧，是 AI Agent 智能体编排，基于 Google ADK 框架实现。这套框架，提供了智能体工作流组装，插件回调钩子等各项基于 Google 发布的协议进行构建的。
- 之后，右上方，是 Google ADK 26年基于 A2A 协议实现的框架组件，方便我们设计出远程的 A2A 服务对接，把远程服务，转换为本地功能组件，编排进智能体中。因此 A2A 协议的作用，就是让一个远程的智能体，可以像构建本地智能体一样，连接起来进行使用。
> 基于 a2a 的协议，也有很多三方框架，但我们需要的是一个整体的解决方案，单一一个功能，还不能解决所有问题。所以这里优先选择 google adk 框架。
## 二、实践案例
### 1. 编程环境
- jdk 17
- google adk 0.8
- spring ai 1.1.0-M3
>相关的版本包，已经在测试工程中的 pom 里引入了。可以打开工程查看。
### 2. 工程结构
- 工程：[https://github.com/fuzhengwei/xfg-dev-tech-google-adk-a2a-server](https://github.com/fuzhengwei/xfg-dev-tech-google-adk-a2a-server)
- 说明：基于 Google ADK 框架，构建 A2A 服务端和客户端。注意，服务端的启动方式为 `quarkus.sh` 方式启动服务，之后使用客户端连接。
- 注意：这部分还有一些关于关于 Spring AI + Google ADK 的基础使用知识，是在 ApiTest 中有案例。也可以学习项目 [《AI Agent 脚手架 + 场景应用》](https://bugstack.cn/md/project/ai-agent-scaffold/ai-agent-scaffold.html)
### 3. 测试案例
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 这是一个 Spring AI + Google ADK 构建的简单智能体，由 LlmAgent 构建时候，创建模型 `new SpringAI(chatModel)` 关联到 Spring AI 框架。
- 之后，由 Google ADK 构建的智能体，使用内存记忆，创建会话之后进行测试。也可以学习项目 [《AI Agent 脚手架 + 场景应用》](https://bugstack.cn/md/project/ai-agent-scaffold/ai-agent-scaffold.html) 锻炼使用相关内容。
### 4. A2A 测试
#### 4.1 服务端
这部分内容的学习，可以打开案例代码，方便对比。
##### 4.1.1 服务提供
```java
@ApplicationScoped
public class AgentExecutorProducer {
@ConfigProperty(name = "my.adk.app.name", defaultValue = "default-app")
String appName;
@Produces
public AgentExecutor agentExecutor() {
return new com.google.adk.a2a.executor.AgentExecutor.Builder()
.agent(Agent.ROOT_AGENT)
.appName(appName)
.sessionService(new InMemorySessionService())
.artifactService(new InMemoryArtifactService())
.agentExecutorConfig(AgentExecutorConfig.builder().build())
.build();
}
}
```
- 这部分是把智能体提供出去，通过 google adk 框架，创建 AgentExecutor 实例。
- 之后 Agent.ROOT_AGENT 类似于上面的测试案例，智能体构建的部分。你可以创建任何之后通过 AgentExecutor 发布出去。
##### 4.1.2 卡片提供
```java
@ApplicationScoped
public class AgentCardProducer {
@Produces
@PublicAgentCard
public AgentCard agentCard() {
try (InputStream is = getClass().getResourceAsStream("/agent/agent.json")) {
if (is == null) {
throw new RuntimeException("agent.json not found in resources");
}
// Read the JSON file content
String json = new String(is.readAllBytes(), StandardCharsets.UTF_8);
// Use the SDK's built-in mapper to convert JSON string to AgentCard record
return Utils.OBJECT_MAPPER.readValue(json, AgentCard.class);
} catch (Exception e) {
throw new RuntimeException("Failed to load AgentCard from JSON", e);
}
}
}
```
**/agent/agent.json**
```java
{
"capabilities": {"streaming": true},
"defaultInputModes": ["text/plain"],
"defaultOutputModes": ["application/json"],
"description": "一个专门检查数字是否为素数的智能体。它可以高效地确定单个数字或数字列表的素性。",
"name": "check_prime_agent",
"skills": [
{
"id": "prime_checking",
"name": "Prime Number Checking",
"description": "使用高效的数学算法检查列表中的数字是否为素数",
"tags": ["mathematical", "computation", "prime", "numbers"]
}
],
"preferredTransport": "JSONRPC",
"url": "http://localhost:9090",
"version": "1.0.0"
}
```
- 这里要构建一个智能体卡，A2A 的协议中，把服务包装成一个卡片的概念。
- agent.json 配置的是 `Agent.ROOT_AGENT` 智能体的信息。
- 如果你之前学习过小傅哥的 AI MCP 网关项目，会对 JSONRPC 有印象， MCP 协议和 A2A 协议，都是走到 JSONRPC 标准进行的通信。
#### 4.2 客户端
##### 4.2.1 构建端
```
/* Detailed source-code truncated for AI context efficiency. */
```
- createRootAgent 是构建入口，一个是创建 createRemoteAgent 远程智能体，一个是 `LlmAgent.builder()` 构建本地智能体。之后在构建本地智能体的时候，通过 subAgents 把远程智能体填充到本地的智能体里去了。这个编排的方式有多种多样的。
- createRemoteAgent 远程构建，这是固定协议路径 `/.well-known/agent-card.json`拿到智能体卡片以后（一个卡片上有各类的信息），之后通过 a2aClient 创建客户端，在通过 RemoteA2AAgent 完成本地智能体的转换。
##### 4.2.2 使用端
```java
public final class A2AAgentRun {
private final String userId;
private final String sessionId;
private final Runner runner;
public A2AAgentRun(BaseAgent agent) {
this.userId = "test_user";
String appName = "A2AAgentApp";
this.sessionId = UUID.randomUUID().toString();
InMemoryArtifactService artifactService = new InMemoryArtifactService();
InMemorySessionService sessionService = new InMemorySessionService();
this.runner =
new Runner(agent, appName, artifactService, sessionService, /* memoryService= */ null);
ConcurrentMap initialState = new ConcurrentHashMap<>();
var unused =
sessionService.createSession(appName, userId, initialState, sessionId).blockingGet();
}
// ... 省略部分
public static void main(String[] args) throws InterruptedException {
BaseAgent agent = A2AAgent.createRootAgent("http://localhost:9090");
A2AAgentRun a2aRun = new A2AAgentRun(agent);
List events =
a2aRun.run("掷一个6面的骰子。").toList().timeout(90, TimeUnit.SECONDS).blockingGet();
events.forEach(A2AAgentRun::printOutEvent);
events =
a2aRun.run("这是素数吗？").toList().timeout(90, TimeUnit.SECONDS).blockingGet();
events.forEach(A2AAgentRun::printOutEvent);
}
}
```
- A2AAgentRun 测试入口，连接远程的智能体，之后做相关的调用验证。
## 三、测试验证
### 1. 前置准备
1. IntelliJ IDEA 右侧的 maven 点击执行 clean -> install 构建
2. 通过命令启动服务，`mvn quarkus:dev -pl xfg-dev-tech-app`
### 2. 访问服务
#### 2.1 服务首页
- 地址：[http://localhost:9090/q/dev-ui/welcome](http://localhost:9090/q/dev-ui/welcome)
- 说明：访问首页，localhost:9090 会看到上面的地址信息，这个是 a2a 协议的入口。
#### 2.2 服务协议
- 地址：[http://localhost:9090/.well-known/agent-card.json](http://localhost:9090/.well-known/agent-card.json)
- 说明：点击 agent-card.json 可以看到具体的服务协议信息。
### 3. 调用验证
- 点击运行，你可以看到它在进行多个智能体的调用（可能模型原因不准，但核心点在于多个智能体的调用）。
- 好啦，到这关于 A2A 整个内容就演示完了，可以时刻关注 google adk a2a 协议的迭代，这部分内容后续还会有一些调整。
---
### Md Road Map Agent Skill (`docs/md/road-map/agent-skill.md`)
---
title: agent-skills
lock: need
---
# Agent Skill，你记一下，我做如下部署调整！
作者：小傅哥
随着 LLM 大模型能力的不断提升，并与 RAG、MCP、Skill 的结合，使得 Agent 智能体与完整的计算机环境（Computer/Phone）交互成为可能。这个过程中，一方面不断产生新的技术方案，一方面又不断的优化设计。就像 Skill 的出现，它不是替代 MCP，而是更准确的使用 MCP 能力。
接下来，小傅哥就带着大家使用一波 skill，让小伙伴们可以在 opencode、trae.ai，以及基于 Spring AI 也可以使用上 skill 能力。
## 一、skill 和 prompt + mcp
如图，演示了一段 skill 的编写案例；
- 场景：案例中体现的是，对电脑性能检测后，用一段下达命令的方式，告知用户如何优化电脑性能。
- 重点：如果不使用 skill，则需要描述一大段话术，让 ai 自己完成对用户场景诉求的分析，并按照步骤来调用对应的各个 mcp 服务（没有 skill 则需要把各类内容，都包装为 mcp 服务）。这个过程是比较消耗 token 的，也可能有不小的幻觉。现在有了 skill，我们可以适当的完整的写一段诉求文档，文档里嵌入可执行的脚本/mcp服务，让执行更可靠。
- 用途：那都有哪些场景可以写 skill 技能书呢？🤔 如；互联网公司里的系统巡检，在接收到报警日志后，拿到一个报警的系统和接口信息，之后用 skill 技能书，分别采集出对应的系统配置、上线日志、数据库/缓存情况、运营操作记录、全链路监控上的接口耗时情况等。之后在根据我们日常排查问题的时候经验，编写过程步骤，这样会更加准确。
> 所以，不是 skill、mcp 谁替代谁，而是 skill 对 mcp 进行增强，让 ai 执行时更加可靠。
## 二、配置使用
首先，像是市面上的 claude code、opencode 这些软件，都是支持了 skill 技能书配置使用的，如果遇到一些软件暂时还不支持 skill，或者自己使用 spring ai、langchain4j、google adk 构建的智能体时候需要使用 skil 技能，则可以通过 skillport-mcp 来使用 skill 配置。
这里小傅哥分别演示下 opencode、trae.ai + mcp、spring ai + google adk + mcp 的方式使用 skill；
### 1. 测试工程(skill)
- 地址：[https://github.com/fuzhengwei/xfg-dev-tech-agent-skills](https://github.com/fuzhengwei/xfg-dev-tech-agent-skills)
- 说明：
- 工程里 `docs/skills` 下面就是一个个技能书，battle-plan、pdf，每一个技能书下都必须有一个 SKILL.md 文件，作为入口。这个文件，可以描述 prompt 提示词，以及在提示词中明确给出可执行的脚本(py\shell\js)和可参考的文档。
- 此外，在 xfg-dev-tech-app 下，test 里编码的是 SpringAiToolTest 测试技能书案例。
### 2. opencode 使用
- 文档：[https://opencode.ai/docs/skills/](https://opencode.ai/docs/skills/)
- 安装：[https://bugstack.cn/md/road-map/ai-ssh-opencode.html](https://bugstack.cn/md/road-map/ai-ssh-opencode.html) - `做好了安装脚本，方便小白伙伴使用`
#### 2.1 配置skill
```java
fuzhengwei@fuzhengweideMacBook-Pro-2 skill % ls
battle-plan
fuzhengwei@fuzhengweideMacBook-Pro-2 skill % pwd
/Users/fuzhengwei/.opencode/skill
fuzhengwei@fuzhengweideMacBook-Pro-2 skill % cd battle-plan
fuzhengwei@fuzhengweideMacBook-Pro-2 battle-plan % ls
reference.md scripts SKILL.md
fuzhengwei@fuzhengweideMacBook-Pro-2 battle-plan %
```
进入到 opencode 配置文件下，如果是 linux 一般会放到 `/root/.config/opencode/` 下。首先你要进入到这个 opencode 配置文件夹，之后在这个文件夹添加一个 skill，再之后就在 skill 下创建你的具体的技能书了。现在你可以把 xfg-dev-tech-agent-skills 案例工程的技能书，battle-plan 放到 skill 里。
#### 2.2 开启skill
```java
fuzhengwei@fuzhengweideMacBook-Pro-2 ~ % cd /Users/fuzhengwei/.opencode
fuzhengwei@fuzhengweideMacBook-Pro-2 .opencode % ls
bin node_modules package.json
bun.lock opencode.json skill
fuzhengwei@fuzhengweideMacBook-Pro-2 .opencode % cat opencode.json
{
"permission": {
"skill": {
"pr-review": "allow",
"internal-*": "deny",
"experimental-*": "ask",
"*": "allow"
}
},
"$schema": "https://opencode.ai/config.json"
}% fuzhengwei@fuzhengweideMacBook-Pro-2 .opencode %
```
- 注意 `opencode.json` 需要配置下 `"*": "allow"`
#### 2.3 使用skill
- 提问：`基于 skill 解答，电脑性能优化`
- 说明：这里的`电脑性能优化`就是 skill 工具名称的描述。
### 3. trae.ai + mcp + skill
#### 3.1 工具说明
工具：[https://github.com/gotalab/skillport](https://github.com/gotalab/skillport)
目前还有不少 AI Agent 智能体，在底层设计上，还不支持直接使用 skill，也包括一些 ai 组件框架，也都没有 skill 的直接支持。那么这里要引入一个 skillport-mcp 服务来解决。借助 mcp 能力，使用 skill。
#### 3.2 工具安装
```java
# 需要安装 python3
pip3 config set global.index-url http://mirrors.aliyun.com/pypi/simple/
pip3 install uvx
```
- 安装 skillport 前，要确保本地安装了 pyhton/python3 环境。之后有 uvx 的安装。
```java
pip3 install skillport
# or: uv tool install skillport
```
- 如果安装过程中遇到一些失败的问题，可以用 trae.ai 里面执行安装，之后把报错拖进去提问。
#### 3.3 mcp 配置
```java
{
"mcpServers": {
"skillport": {
"command": "uvx",
"args": ["skillport-mcp"],
"env": { "SKILLPORT_SKILLS_DIR": "~/.skillport/skills" }
}
}
}
```
- 这里你要配置下自己 skill mcp 服务，到你的 trae.ai 中。确保一定安装好了 python 环境，可以执行 `pip3 install skillport` 安装。
#### 3.4 工具使用
当你选择 Builder with MCP（涵盖了skillport-mcp），之后提问 `基于 skill 解答，电脑性能优化` 那么就可以得到上面的命令了。
### 4. spring ai + skill
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 在 Spring AI 程序中，添加 `skillport-mcp` 服务，之后在 ChatModel 模型里，使用 mcp 服务。
- 如果你正在开发一些 AI Agent，那么也可以把 `skillport-mcp` 配置进去使用。如小傅哥带着做 [AI Agent 智能体项目](https://bugstack.cn/md/project/ai-knowledge/ai-knowledge.html) 你现在可以加进去更多的扩展操作了。
---
### Md Road Map Ai Ssh Opencode (`docs/md/road-map/ai-ssh-opencode.md`)
---
title: ai ssh opencode
lock: need
---
# ai ssh opencode 命令行工具
作者：小傅哥
**ai 正在改变产品设计！**
2025年，是 ai agent 智能体爆发的一年，它所提效的接入方式可以分三层来看；
先是中间这一层，是 ai agent 接入服务和软件，像是大家使用的 trae.ai 或者小傅哥分享过的 [draw.io + ai](https://bugstack.cn/md/road-map/draw.io.html)，以及各个互联网公司用 ai 提效做的一些场景客服，系统巡检，日志分析等。
之后上面这一层，是从用户视角，模拟用户行为使用软件，而不是直接接入到软件api上。它使用的方式是 AutoGLM-Phone-9B 手机模型，以 ADB 或者无障碍模式，让手机可以接收用户指令，完成操作。如；`打开京东，搜索东北老式麻辣烫，加入购物车，以默认地址，进行支付购买。下单支付完成后，微信发给xxx告诉，她预计送达时间。` 如果感兴趣，可以基于这篇文章进行实践。[《手机 + agent，这是要掀桌子！》](https://bugstack.cn/md/algorithm/model/autoglm-phone-agent.html)
然后底下这一层，是从系统层面，不再依赖于直接对接某个软件，某个api，而是以系统层面直接操作软件，或者完成整个行为动作。如，在云服务器/本地，配置好 jdk、maven、docker 环境，之后帮我拉取 git clone xxx 仓库代码，本地完成 maven 构建和启动。以及在遇到问题时候，让 ai 直接检索并处理都是非常可以的。
好，那接下来，小傅哥给大家分享下，如何安装一个 ai ssh 工具（没有这个教程，很多人是安装不上的！）。
>🧧 文末提供了小傅哥所有编程实战项目获取方式，一次加入即可获得19个已完结的实战项目，也有非常多的 AI 类项目，一定要补充学习！
## 一、工具介绍
ai ssh 是命令行工具，可以安装到 Mac、Windows、Linux 上，以通过 terminal（终端）直接操作系统进行使用。它的场景也包括你打开的 IntelliJ IDEA 下面的 terminal 终端中使用，这样就天然的嵌入到了 IntelliJ IDEA 中了，非常方便。
目前这类的 ai ssh 命令行工具软件也非常多，包括；[opencode.ai](https://opencode.ai/)、[claude](https://claude.com/product/claude-code)、[openai codex](https://github.com/openai/codex)、[阿里千问 - qianwen code](https://github.com/QwenLM/qwen-code)，都出了对应的软件。
在整体体验后，效果还是都不错的，这里是 opencode 的终端使用截图；
- opencode 默认提供了一些免费模型，可以输入 `/models` 进行选择。
- 另外还可以通过配置文件，添加其他模型，如 claude 模型、openai 模型、小米模型等。
## 二、软件安装
以下软件安装，会需要用到 gcc、nodejs 20+ 版本，建议安装 Ubuntu 24 版本，可以不需要折腾系统环境。
### 1. 脚本说明
这软件好用是挺好用，但它的源都在 Github 上，很多伙伴在执行官网脚本 `curl -fsSL https://opencode.ai/install | bash` 是安装不上的。所以，小傅哥做了一个对应的脚本，方便大家更加简化的安装使用。
- 脚本（gitcode）：[https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install](https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install)
- 脚本（github）：[https://github.com/fuzhengwei/xfg-dev-tech-docker-install](https://github.com/fuzhengwei/xfg-dev-tech-docker-install)
### 2. 脚本下载
```java
git clone https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install.git
```
- 你可以通过命令的方式把脚本拉取到本地电脑或者云服务器上。
### 3. 脚本授权
```java
find . -name "*.sh" -type f -exec chmod +x {} \;
```
- 全部授权
```java
chmod +x terminal.sh
```
- 指定授权
### 4. 执行安装
```java
./terminal.sh
```
- 执行安装时，选择1，opencode code，这个是比较推荐的。
- 无论是 Windows、Mac、Linux 都可以使用这个脚本进行安装，我已经做好了对应的脚本。
- 安装完成后，需要输入 `opencode` 之后 Enter（回车）进入到系统中。如果提示 opencode 不是有效的命令，可以检查是否安装过程中有个提示 `source .../bashrc` 可以自行执行刷新。
## 三、软件配置
### 1. 命令使用
- `/init` - 创建/更新 Agents.md"
- `/review` - 检查变化"
- `/new` - 创建新的会话"
- `/models` - 选择模型"
- `/agents` - 智能体方式"
- `/session` - 会话列表"
- `/status` - 查看状态"
- `/mcp` - 选择mcp服务"
- `/theme` - 选择主题"
- `/editor` - 编辑"
- `/connect` - 链接模型提供者"
- `/help` - 帮助"
- `/commands` - 命令"
- `/exit` - 调试模式"
> 这些可能会随着版本更新而调整，你可以依次尝试下。
### 2. 配置模型（自定义 - 可选）
```java
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"my-model-openai": {
"npm": "@ai-sdk/openai-compatible",
"name": "OpenAPI",
"options": {
"apiKey": "你的apikey",
"baseURL": "https://你的baseURL/v1"
},
"models": {
"gpt-4.1": {
"name": "gpt-4.1"
}
}
},
"my-model-glm": {
"npm": "@ai-sdk/openai-compatible",
"name": "GLMAPI",
"options": {
"apiKey": "你的apikey",
"baseURL": "https://open.bigmodel.cn/api/paas/v4"
},
"models": {
"glm-4.7": {
"name": "glm-4.7"
}
}
}
},
"model": "my-model-openai/gpt-4.1"
}
```
- 如果你想自己更换下模型，比如使用 openai 的或则 claude 的，那么需要你在脚本下的 terminal/opencode.json 进行更换，之后执行 `./opencode.json.sh` 进行创建。
- 如果先执行了 ``./opencode.json.sh`` 之后想更换配置的模型，则可以通过 vim 命令，编辑 `/root/.config/opencode/opencode.json`
- 其他的还有一些像是 mcp 的配置，可以参考官网（避免调整了配置错），[https://opencode.ai/docs/mcp-servers/](https://opencode.ai/docs/mcp-servers/)
## 三、软件使用
### 1. Linux
#### 1.1 构建项目
#### 1.2 安装软件
#### 1.3 巡检系统
#### 1.4 编写文件
>通过命令操作云服务器是非常便捷的，尤其是很多小白伙伴，有了这个可以说是如小白虎添翼！打开思路，你可以在更多地方使用上，尤其哪些环境安装都困难的伙伴。
### 2. Mac/Windows + IntelliJ IDEA
- 在本地电脑，除了可以像 Linux 举例那种安装和检查各类软件，也可以直接在 IntelliJ IDEA 开启，之后管理你的项目。
- 尤其是很多伙伴，拿到一个项目，不知道里面都是什么，也不清楚脚本能干啥，那你都可以使用 opencode 帮你解决。
### 3. IPad Pro
虽然 IPad Pro 没啥开发类软件，但如果你使用的是云服务器、Nas等，这些软件里安装 opencode，那么你也可以在 IPad Pro 安装 [termius.com](https://termius.com/) SSH 工具，通过 SSH 工具操作部署了 opencode 的 Linux 系统。
现在日常出门，带着 IPad Pro 也是可以处理一些小的开发的维护的，非常方便。IPad Pro + Nas 嘎嘎舒服！
---
### Md Road Map Aigc (`docs/md/road-map/aigc.md`)
---
title: AiGC
lock: need
---
# 入局AiGC，分币没赚！咋整滴？
作者：小傅哥
最近一段时间受不少 AiGC 类广告的影响，`文生图`、`文生视频`、`故事成片`，在家动动手就能赚钱。一个视频都几千、几万的点赞。
听起来做这个也挺简单，让 DeepSeek 生成口播故事，把故事放到 AiGC 软件（现在一堆），选择故事成片，在把视频上传到抖音、快手、头条，完活！**就是不赚钱！**
>本文会分享 AiGC 视频制作的过程和注意点。另外作为技术人员，我们可以自己部署一个文生视频的软件服务，以及了解相关的 API 技术，也为后续自己开发 AiGC 做积累。
## 选择一个赛道！下场！
首先，你可以想好一个创作的主题，如果有多个主题，可以分别投放到不同的软件平台，尽量先垂直一个系列更新，如果一直没有流量，后面可以干掉重新换主题来。
主题可以包括；`婆媳关系`、`中老年相亲`、`农村故事`、`鬼故事`、`好看的景色+音乐`、`儿童诗歌`，也就是你尽量要找一些高频有大量客群的场景，只要推荐到这样的人群标签下，视频的播放量还是很高的。
但不要想着这样就能赚钱，如果只是试试水，基于 DeepSeek 生成关键信息的故事（主题、背景、人物、故事线），再把故事放到文生视频完成后上传即可。**但这样做好，基本属于徒劳！**
在我尝试推了几个鬼故事后，没有看到什么流量，这时候有个哥们加我，说我这样推没用的。我也好奇的去加了下关注，他是专门做鬼故事系列的，每个内容都很精良，而且属于 TM 鬼故事 + 擦边！还备注上（收徒）！
所以，从这块开始，我发现要想让一个内容有较不错的流量，需要以下几点；
1. 故事主体框架是明确、不能纯用 DeepSeek 来写。故事可以基于一些比较火的小说来制造。看过越多小说的，做这方面越有优势。
2. 故事内容太干净了也没有人看，在 DeepSeek + 文生视频允许的范围内，你都可以“肆意”创作。
3. 如果你时间更多，也更想做好，那么要对生成的视频，逐帧剪辑，也可能要多生成几次来使用。并制造好吸引人的封面！
3. 长期主义，1~3，你可以都不用考虑。而是真的一点点来结合 AI 来写长期有意义的故事。
**不过，就算以上这样你都做了，也可能一点流量都没有！**😂
## AiGC 软件工具
在有了内容以后，就是 AI 生成视频了。AI 生成视频的软件有很多，基本也都是付费的。😂 所以说，你不一定赚不赚钱，但 AI 创作课程和 AI 软件是赚钱。
我体验了，可灵 AI、录咖 AI，还有抖音剪映自带的 AI 生成类工具。可灵 AI 适合文生图片、数字人口播，剪映 AI 适合文生视频。因为我本身就需要日常剪辑视频，开了剪映会员，所以可以直接使用。可灵 AI 是少量付费体验了下。
- 剪映 APP 有个 AI 图片成片，进入后选择 AI 故事成片。
- 你可以把 DeepSeek/AI 生成口播故事（2000字 - 3000字），放进来转换即可。完成后，把视频下载下来，上传到你的各个平台。
## 我以为一分钱也赚不到的时候！
**在我折腾了快一周，以为分币赚不到的时候，来活了！**
有个“粉丝”，关注了我。给我讲，接活不。我问啥活，她说，关注这个没事主播，点赞视频和收藏，完成后给6块钱。我没想到，她真给！
o(╥﹏╥)o 这是我做 AIGC 的第一笔收入！虽然，它看起来不正常！
晚上，这个粉丝小姐姐，问我还做不。我说行，她说你要大量做，要下载一个软件“魅信”。我去TM的，我是一个程序员，能信你这！不是“魅信”可怕，是你给我来个自动录屏，整走我点信息不完犊子了。
所以，我给这假粉丝讲！我是一个程序员，我对这个不放心，我不做了！没过多久，我就看XXX视频平台给这个假粉丝账号封了，没法查看完整聊天。以至于我只能截图这一丢丢，给大家看。
- 因为它的账号被封了，已经看不到内容了。只能通过录制视频，在截取一下。不过截取不全了。
- 所以，如果你遇到这种的，赚个6块就跑吧🏃🏻！
## 回到本质，仍然是技术！
说到底，其实做各类东西都需要大量的时间精力投入，也有努力 + 运气，才可能有机会做成。想随随便便加个“副业社群”，不一定都能赚到什么钱。
就像你自己，如果用了大量的核心知识储备，那么你所用的这些产品就是工具，反之他们就不是工具，而是收割你的工具。
所以，作为研发人员，我们储备多的是技术知识，可以依赖于技术底层的积累，增强对工具的实现技术了解。看看这样的 AIGC 工具是如何实现的，能部署一个深入了解不，看看API接口从哪调用的，以后我们自己搞下是不更好。
### 1. 软件部署
有这么一个开源软件「利用AI大模型，一键生成高清短视频 Generate short videos with one click using AI LLM.」，可以通过 Docker 部署体现。
代码：[https://github.com/harry0703/MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo)
**docker-compose.yml**
```java
services:
webui:
image: registry.cn-hangzhou.aliyuncs.com/xfg-studio/moneyprinterturbo:latest
container_name: MPTwebui
ports:
- "8501:8501"
restart: unless-stopped
logging:
driver: "json-file"
options:
max-size: "2m"
command: >
streamlit run /MoneyPrinterTurbo/webui/Main.py
--browser.serverAddress=127.0.0.1
--server.enableCORS=True
--browser.gatherUsageStats=False
api:
image: registry.cn-hangzhou.aliyuncs.com/xfg-studio/moneyprinterturbo:latest
container_name: MPTapi
ports:
- "8080:8080"
restart: unless-stopped
logging:
options:
max-size: "2m"
command: python3 /MoneyPrinterTurbo/main.py
```
- 通过 Docker Compose 脚本，执行软件安装。`docker-compose -f docker-compose.yml up -d` 来执行安装。
- 安装后访问 ip:8501
### 2. 访问服务
- 首先，需要点开设置。配置你的 openai 地址服务，之后配置 [Pexels API Key](https://www.pexels.com/api/key/)
- 之后，填写文案，文案也可以由 AI 工具生成复制进来。之后点击生成视频（其他选型也可以尝试更换）。
- 最后，生成完视频，就可以扔了。这个效果基本就是体验，与剪映那个差太多了。
### 3. 访问API
AIGC 相当于根据你的文案，检索/生成对应图片，好的AI产品会设置分镜头不同视角的检索。在结合这些图片、视频资源合成你最后要生成的视频效果。
如：[https://www.pexels.com/](https://www.pexels.com/) 就是一个图片视频资源库，你可以免费申请一个 API，之后使用它来生成图片。它的官网有对应的文档描述使用。举例如下；
```java
curl -H "Authorization: 8aHBe0CyGtMZVMji32RVEvgzIRNx38rrkHlbp9HK*****申请你的" \
"https://api.pexels.com/v1/search?query=美女&per_page=1"
```
- 调用接口返回的 JSON 可以查看图片信息，基本你要的内容还是可以大部分时候准确获取的。
- 如果感兴趣，还可以深入体验下它的 API。
---
### Md Road Map Aliyun Workbench (`docs/md/road-map/aliyun-workbench.md`)
---
title: Docker 镜像构建 - Aliyun
lock: need
---
# Docker 镜像构建 - Aliyun
作者：小傅哥
**大厂更多的都是给程序员👨🏻💻配Mac！**
其实到也不是 Windows 不好，只是在编程开发中的环境配置，要有太多的额外的兼容问题。因为 Windows 是一个系统，这个系统被各个厂商使用，安装到自己家的电脑上。因此一个软件安装后，不同的机器，都可能在一些细节功能上，有自己的差异化处理方案。就像 Docker 安装，Mac 电脑直接安装即可，Windows 不是安装虚拟机，就是搞个 wsl2，不少小白基本就在这崩溃了。
相对说，Mac 电脑就好的多，因为人家的系统只给自己家的电脑使用。所以各类软件的安装和使用也不会有那么多的适配问题了。另外 Mac 电脑也等同于是在 Linux 上做开发，你的所有编程中使用的命令，几乎就是无差别的可以在云环境 Linux 执行。因此，Mac 电脑除了不省钱，其他的都省；省时、省心、省力。
不过，Windows 电脑也不能推沟里呀！所以，我们要想点办法，让一些如 Docker 的环境安装和镜像构建，让外部系统解决。不就可以了噻！
>接下来，小傅哥就教大家搞一下这个事情。—— 学到手的全是技术！
## 一、DevOps 流水线
DevOps 流水线，是一种可持续集成交付的手段。用户可以使用流水线自定义编排项目发布过程中所涉及的代码打包、单元测试、自动部署等各项阶段。 通过一系列自动化任务的组合解决日常开发工作中繁琐而重复的任务。
官网（JD）：[https://docs.jdcloud.com/cn/devops/application-scenarios](https://docs.jdcloud.com/cn/devops/application-scenarios)
---
市面上也有很多的免费的可持续交付工具，方便我们自己部署项目使用。如 [Github Actions](https://bugstack.cn/md/road-map/github-actions-workflows.html)、[buddy.works](https://bugstack.cn/md/road-map/buddy.html)、[Jenkins](https://bugstack.cn/md/road-map/jenkins.html)，这些已经在 [bugstack.cn](https://bugstack.cn/) 编程路书（发布部署）中分享。今天小傅哥再分享一个阿里云的 DevOps 流水线操作，实际使用体验效果还不错。
## 二、云效工作台介绍
本次案例会涉及到使用阿里云效平台的 `代码管理`、`流水线配置`、`容器镜像`
### 1. 代码&流水线
- 地址：[https://devops.aliyun.com/workbench](https://devops.aliyun.com/workbench)
- 说明：用于管理工程代码和配置流水线。你可以提交本地代码，也可以把其他仓库的代码导入到`代码管理`中，如；Github、Gitee、Gitlab，其他的也可以通过 url 导入。
### 2. 容器镜像服务
#### 2.1 容器申请
- 地址：[https://cr.console.aliyun.com/cn-hangzhou/instance/dashboard](https://cr.console.aliyun.com/cn-hangzhou/instance/dashboard)
- 说明：容器镜像，相当于代理的 [Docker Hub](https://hub.docker.com/) 可以把我们通过流水线构建的项目（SpringBoot/React/...）构建的镜像，放到容器镜像服务中。之后就可以在其他云环境或者本地环境拉取使用了。
#### 2.2 新建服务
- 这里要新建一个镜像名称，`xfg-dev-tech-aliyun-workbench` 的镜像。这个镜像为后续的流水线构建使用。
- 创建的时候，要选择对应的仓库。可以是 Codeup 的阿里云代码库，也可以是 Github 关联地址的仓库。
> 再往下开始平台，你需要注册一个云校平台和容器镜像服务。
## 三、上传代码库
这部分会涉及一些 Git 的操作，这里小傅哥准备好了教程可以使用 [https://bugstack.cn/md/road-map/git.html](https://bugstack.cn/md/road-map/git.html)
### 1. 案例工程
```java
# 基础镜像 openjdk:8-jre-slim 代理地址；registry.cn-hangzhou.aliyuncs.com/xfg-studio/openjdk:8-jre-slim
FROM registry.cn-hangzhou.aliyuncs.com/xfg-studio/openjdk:8-jre-slim
# 作者
MAINTAINER xiaofuge
# 配置
ENV PARAMS=""
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 在容器内创建目录/home/project 用于存放应用程序和相关文件
RUN mkdir -p /home/project
# 设置工作目录为/home/project，即后续的命令都在这个工作目录下执行。
WORKDIR /home/project
# 添加应用
ADD xfg-dev-tech-app/target/xfg-dev-tech-app.jar /home/project/xfg-dev-tech-app.jar
## 在镜像运行为容器后执行的命令
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /home/project/xfg-dev-tech-app.jar $PARAMS"]
```
- 地址：[https://github.com/fuzhengwei/xfg-dev-tech-aliyun-workbench](https://github.com/fuzhengwei/xfg-dev-tech-aliyun-workbench)
- 说明：这里小傅哥给你准备好了一个测试工程，你可以使用验证阿里云效流水线操作。
- 脚本：注意配置的脚本信息，如果你是新的其他的工程，可以参考配置。
### 2. 上传项目
把案例代码上传到阿里云代码库的方式有很多，可以从 Github 导入，也可以先把代码拉取到本地，在从本地上传到阿里云代码库。但两个方式都建议把代码拉取到本地代码一份，方便进行修改。
#### 2.1 导入代码
- 首先，进入案例工程地址（Github），点击 Fork 克隆到自己的仓库中。
- 之后，在阿里云效点击导入仓库，这里可以选择从 Github 导入。导入的时候，需要填写 Access Token。创建地址：[https://github.com/settings/tokens](https://github.com/settings/tokens)
- 最后，在确认后会展示你的 Github 仓库列表，选择要导入的工程即可。
#### 2.2 上传代码
- 首先，开始操作之前，你要把提供的案例代码拉取到本地。
- 之后，在云效代码库，新建一个代码库。新建后可以获得一个 https 提交代码库的地址。另外，要注意你还要在云效仓库个人设置里，创建一个，个人访问令牌（地址：[https://account-devops.aliyun.com/settings/profile](https://account-devops.aliyun.com/settings/profile)）。
- 最后，在自己 Intellij IDEA 菜单栏上，点击 Git 选择 Manage Remotes 添加阿里云效仓库地址，之后就可以把代码提交到阿里云效了。
### 3. 添加流水线
#### 3.1 构建操作
- 如图，配置构建信息。注意，☑️ 制品中包含打包路径的目录。
#### 3.2 添加步骤；Docker镜像构建
- 添加新的步骤，选择构建并推送至ACR（个人版）注意配置路径正确。
#### 3.3 添加步骤；邮件通知
- 添加一个邮件通知的插件，构建后会接收到邮件。
### 4. 构建镜像
#### 4.1 执行构建
- 点击运行，之后就可以构建镜像了。如果哪个节点失败了，可以点日志查看失败原因。
#### 4.2 构建结果
##### 4.2.1 邮件通知
- 你会收到一个来自云效构建的通知邮件。代表着构建的结果。
##### 4.2.2 查看镜像
- 构建完成镜像后，可以进入`容器镜像服务`中找到镜像。地址：[https://cr.console.aliyun.com/cn-hangzhou/instance/repositories](https://cr.console.aliyun.com/cn-hangzhou/instance/repositories)
- 之后还可以通过公网地址拉取镜像，命令：`docker pull registry.cn-hangzhou.aliyuncs.com/fuzhengwei/xfg-dev-tech-aliyun-workbench:1.0.0`
##### 4.2.3 拉取镜像
```java
[root@hcss-ecs-decd ~]# docker pull registry.cn-hangzhou.aliyuncs.com/fuzhengwei/xfg-dev-tech-aliyun-workbench:1.0.0
1.0.0: Pulling from fuzhengwei/xfg-dev-tech-aliyun-workbench
1efc276f4ff9: Already exists
a2f2f93da482: Already exists
1a2de4cc9431: Already exists
d2421c7a4bbf: Already exists
64e0330ea35f: Pull complete
4da07e374896: Pull complete
4f4fb700ef54: Pull complete
eb9d0e194679: Pull complete
Digest: sha256:a7af08fff4ea0b76184a2fad7e7ca639ab4a9ad16573480b526eda672ed8a483
Status: Downloaded newer image for registry.cn-hangzhou.aliyuncs.com/fuzhengwei/xfg-dev-tech-aliyun-workbench:1.0.0
registry.cn-hangzhou.aliyuncs.com/fuzhengwei/xfg-dev-tech-aliyun-workbench:1.0.0
[root@hcss-ecs-decd ~]# docker tag registry.cn-hangzhou.aliyuncs.com/fuzhengwei/xfg-dev-tech-aliyun-workbench:1.0.0 fuzhengwei/xfg-dev-tech-aliyun-workbench:1.0.0
[root@hcss-ecs-decd ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
fuzhengwei/xfg-dev-tech-aliyun-workbench 1.0.0 df740ba425bb 24 minutes ago 221MB
```
- 镜像构建完成后，就可以在云服务器上拉取镜像了。
- 好啦，到这你就可以愉快的完善了，前端构建镜像也是一样的操作。
---
### Md Road Map Apisix (`docs/md/road-map/apisix.md`)
---
title: apisix
lock: need
---
# Apisix 云原生架构的开源 API 网关
作者：小傅哥
为什么选择 Apache APISIX?
- 简单易用的 Dashboard：Apache APISIX Dashboard 可以让用户尽可能直观、便捷地通过可视化界面操作 Apache APISIX。作为 Apache 软件基金会中持续迭代的开源项目，欢迎你随时提出新的想法。
- 友好的用户体验：Apache APISIX Dashboard 极大地满足了用户需求，不仅提供了清晰的组织架构以适配二次开发，而且可以借助插件编排能力释放想象力！
- 可视化配置：拒绝重复造轮子。借助 Apache APISIX 内置插件，可以在极短时间内创建灵活、可靠、高性能的网关。无需编写代码，只需在编辑器中拖拽插件、配置条件，便可通过可视化的方式打造专属的 API 管理系统。
- 极致的性能体验：Apache APISIX 基于 Radixtree Route 和 etcd 提供路由极速匹配与配置快速同步的能力。从路由到插件，所有的设计和实现都是为了极速性能和超低延迟。
- 阻拦恶意程序：Apache APISIX 提供了多款身份认证与接口验证的插件，我们将稳定、安全放在首位。
## 二、环境部署
- 云服务器：2c2g 最低，我是用的 2c8g 体验的。[https://yun.xfg.plus](https://yun.xfg.plus/) - 价格实惠。
- 基础环境：Docker、Portainer、Git 【在小傅哥的 bugstack.cn 路书中都有讲解安装和使用】
### 1. 脚本配置
官网中提供了 docker 的安装脚本，但不能直接使用，需要如图做下复制操作。小傅哥已经把这部分复制的内容，到`脚本`工程里了。
- 你可以知道有这么一个地方，将来如果版本更新了，也可以做下配置操作。
### 2. 可用脚本 - 准备好的
- 这个是小傅哥帮你准备好的脚本，可以直接安装使用。
- 这里涉及了 docker、portainer 的使用，在《[bugstack.cn](https://bugstack.cn) 路书》中，已经完整配置提供，可以查看。
## 三、网关配置
- 网关的登录密码是在 dev-ops/apisix-dashboard/conf.yaml 中配置的。默认的是 `admin/admin`
- 另外注意 conf.yml 中 etcd:2379 的配置，这里从 127.0.0.1 调整为 etch 应用名称。这样能保证在同一个 docker 配置的网络下，可以直接连接使用。如果是分布式部署，则要改为具体的IP。
- 这套按照学习脚本中提供了 web1、web2 两个 nginx 的配置，可以测试使用。
### 1. 访问网关
地址：[http://127.0.0.1:9093/](http://127.0.0.1:9093/)
- 访问后就可以看到左侧的目录，可以配置；服务、上游、路由，以及插件等功能。
- 路由是入口，从路由可以访问到配置的服务，服务是每个应用的访问地址，可以配置权重轮训和一致性哈希。插件主要是提供的是；身份验证、安全防护、流量控制、无服务架构、可观测性功能。
### 2. 服务配置
- 配置后，一直点击就可以了。
### 3. 配置路由
### 4. 插件配置
- 你可以按需测试各种插件，还可以通过编排让各个要执行的插件串联起使用。
## 四、服务验证
地址：[http://192.168.1.105:9080/api](http://192.168.1.105:9080/api)
- 刷新网关接口，不停的刷新，会看到接口访问值的变化。
---
### Md Road Map Arex Test (`docs/md/road-map/arex-test.md`)
---
title: AREX - 流量录制&回放
lock: need
---
# AREX - 流量录制&回放
作者：小傅哥
**如何保证系统的可靠性？**
互联网大厂toc场景，非常重视交付的可靠性，甚至大于交付的效率性。所以，在整个研发声明周期过程中，要有 PRD 评审、研发设计代码、代码评审、代码分支合并评审，以及在这个过程中还有测试人员进行全流程的验证。
但即使这样，面对经历了数十年迭代的系统，单工程甚至几十万行代码，极其复杂的业务系统流程，测试也是可能会出现疏漏。这种疏漏如，虽然非本次需求迭代的场景，但是其他业务场景因当前系统的一个枚举，一个参数的变动，都会影响到数十条业务。哪怕不是代码变动，仅仅是重构了小部分代码块，调整了前后顺序，当前业务无影响，但确影响了某次其他任务的跑批结果！
一次事故，可能是扣绩效和年终奖，也可能是影响晋升提名，还可能是直接毕业🎓啦！所以，在互联网大厂班组🧱搬砖，会学到很多高级技巧，来保证系统的可靠性。
>关注小傅哥 [bugstack.cn](https://bugstack.c) 博客，编程路书，可以学习到非常多的互联网企业使用技能，补全自己的短板！如；系统架构、开发环境、开发技术、授权框架、常用类库、工程测试、质量监控、发布部署等。
## 一、说说概念
其实简单来讲，流量录制，核心的本质就是把线上运行的应用，在有流量请求到服务接口后，把请求接口的入参和执行的结果，都保存下来。之后流量回放，则是把这些保存下来的入参信息，在开发环境/测试环境/预发环境，进行请求，之后验证请求后的结果是否与线上录制的流量结果一致。整个的这个过程，就是流量的录制和回放。
但实际的操作场景要比这个过程复杂，如；录制流量的操作，要无侵入代码的，要把整个调用链路，全部录制下来，而不是单个接口。同时录制的不只是对接口的操作，还有缓存、rpc、数据库（MyBatis）、es，等各类组件兼容，都能确保可正确录制到完整数据，以便在流量回放时，可以mock掉数据接口，以此只验证功能逻辑。
说到，逻辑和数据，这里想到了DDD架构的领域层和基础设施层，领域层（domain）专门业务功能逻辑的，而基础设置层（infrastructure）则是提供数据的。这样有了业务功能和数据获取的分离，不让核心业务逻辑又掺杂外部接口的调用，其实维护和迭代起来，是会更加容易的。
## 二、讲讲原理
为了可以无侵入式的完成系统的流量录制和流量回放，这里引入了一个 Java Agent 字节码增强技术，通过在程序启动阶段，对工程代码的方法进行埋点。这个埋点，就等同于动态的通过 class 文件写入新的代码，新的代码可以采集到方法的出入参信息，并把这些信息发送到流量录制存储方，或者执行时进行mock接口请求结果处理。
这部分技术方案，小傅哥于19-20年，编写了先关的技术资料。其中包括了用于处理字节码增强技术的，asm、javassist、byte-buddy 三种框架。
文档：[https://bugstack.cn/md/bytecode/asm/2020-04-05-%5BASM%E5%AD%97%E8%8A%82%E7%A0%81%E7%BC%96%E7%A8%8B%5DJavaAgent+ASM%E5%AD%97%E8%8A%82%E7%A0%81%E6%8F%92%E6%A1%A9%E9%87%87%E9%9B%86%E6%96%B9%E6%B3%95%E5%90%8D%E7%A7%B0%E4%BB%A5%E5%8F%8A%E5%85%A5%E5%8F%82%E5%92%8C%E5%87%BA%E5%8F%82%E7%BB%93%E6%9E%9C%E5%B9%B6%E8%AE%B0%E5%BD%95%E6%96%B9%E6%B3%95%E8%80%97%E6%97%B6.html](https://bugstack.cn/md/bytecode/asm/2020-04-05-%5BASM%E5%AD%97%E8%8A%82%E7%A0%81%E7%BC%96%E7%A8%8B%5DJavaAgent+ASM%E5%AD%97%E8%8A%82%E7%A0%81%E6%8F%92%E6%A1%A9%E9%87%87%E9%9B%86%E6%96%B9%E6%B3%95%E5%90%8D%E7%A7%B0%E4%BB%A5%E5%8F%8A%E5%85%A5%E5%8F%82%E5%92%8C%E5%87%BA%E5%8F%82%E7%BB%93%E6%9E%9C%E5%B9%B6%E8%AE%B0%E5%BD%95%E6%96%B9%E6%B3%95%E8%80%97%E6%97%B6.html)
### 1. 增强代码
```java
mv.visitVarInsn(LLOAD, startTimeIdentifier);
mv.visitLdcInsn(methodId);
if (parameterTypeList.isEmpty()) {
mv.visitMethodInsn(INVOKESTATIC, Type.getInternalName(ProfilingAspect.class), "point", "(JI)V", false);
} else {
mv.visitVarInsn(ALOAD, parameterIdentifier); // 5
mv.visitVarInsn(ALOAD, localCount); // 6
mv.visitMethodInsn(INVOKESTATIC, Type.getInternalName(ProfilingAspect.class), "point", "(JI[Ljava/lang/Object;Ljava/lang/Object;)V", false);
}
```
### 2. 拦截信息
```java
ASM类输出路径：/Users/xiaofuge/itstack/git/github.com/SQM/target/test-classes/org/itstack/test/ApiTest$1SQM.class
监控 - Begin
类名：org.itstack.test.ApiTest
方法：queryUserInfo
入参类型：["I","I"]
入数[值]：[111,17]
出参类型：Ljava/lang/String;
出参[值]："你好，bugstack虫洞栈 | 精神小伙！"
耗时：95(s)
监控 - End
测试结果：你好，bugstack虫洞栈 | 精神小伙！
```
- 以上为简要的案例代码，通过ASM字节码增强框架来对方法修改，增加日志打印信息，在执行方法时，获取出入参。
- 字节码增强技术应用的方面非常多，如；MapStruct、非入侵的全链路监控、Lombok，甚至你用过的 IntelliJ IDEA 破解也是字节码增强技术。
## 三、工具介绍
关于流量录制和流量回放的工具是蛮多的，其中包括；[jvm-sandbox-repeater](https://github.com/alibaba/jvm-sandbox-repeater)、[MoonBox](https://github.com/vivo/MoonBox)、[arextest](https://arextest.com/) 等。
- jvm-sandbox-repeater，是一个基于 JVM-Sandbox 采用Java来实现的流量录制回放工具，或者可以理解为它是一个基于Java虚拟机的插件，可以直接运行中JVM中，无需对目标应用程序进行任何修改。
- Moonbox（月光宝盒），是一个无侵入的线上流量录制 和流量回放平台，沿用了jvm-sandbox-repeater的SPI设计，并提供了大量的常用插件，同时也提供数据统计和存储能力。通过Moonbox可以实现自动化测试、线上问题追踪、和业务监控等能力
- arextest，AREX 通过将真实的在线流量复制到测试环境进行自动化 API 测试来解决自动化测试的挑战。**作为本文分享场景工具使用。**
**名词解释**
- **录制**：把一次请求的入参、出参、**下游RPC、DB、缓存**等序列化并存储的过程
- **回放**：把录制数据还原，重新发起一次或N次请求，对特定的下游节点进行MOCK的过程
- **入口调用**：入口调用一般是应用的**流量来源**，比如http/dubbo，在调用过程中录制调用入参，返回值。回放时作为流量发起和执行结果对比依据
- **子调用**：区别于入口调用，子调用是调用执行过程中某次方法调用。子调用在录制时会记录该方法的入参、返回值；回放时用该返回值进行MOCK
- **MOCK**：在回放时，被拦截的子调用**不会发生真实调用**，利用字节码动态干预能力，将录制时的返回值直接返回
- **降噪**：在回放时，部分回放子调用入参或者回放流量响应结果和原始流量对比不一致字段，对这些非必要字段进行排除对比过程
## 四、工具使用
### 1. 案例工程
- 地址：[https://github.com/fuzhengwei/xfg-dev-tech-traffic-agent](https://github.com/fuzhengwei/xfg-dev-tech-traffic-agent)
- 如图：1~6点，说明了各个模块的用途。
- 提示：建议使用云服务器部署流量录制&回放服务，非常方便。
### 2. 安装插件
地址：[https://chromewebstore.google.com/detail/arex-chrome-extension/jmmficadjneeekafmnheppeoehlgjdjj](https://chromewebstore.google.com/detail/arex-chrome-extension/jmmficadjneeekafmnheppeoehlgjdjj)
- 安装插件是为了有权限访问接口。
### 3. 服务部署（arex）
**前置条件**，2c4g云服务器，完成初始化Docker环境。这里有一键安装脚本，[https://bugstack.cn/md/road-map/docker-install.html](https://bugstack.cn/md/road-map/docker-install.html)
```java
[root@iv-jdyun ~]# cd /
[root@iv-jdyun ~]# mkdir dev-ops
[root@iv-jdyun ~]# cd dev-ops
[root@iv-jdyun ~]# sudo yum install git
[root@iv-jdyun ~]# git clone --depth 1 https://github.com/arextest/deployments.git
[root@iv-jdyun ~]# cd deployments
[root@iv-jdyun ~]# docker-compose up -d
```
- 执行脚本安装完成后，在云服务器安全组开放端口号（出/入规则）。
- 之后访问：http://ip:8088 首次访问会慢一些，进入后会让设置你的登录账号。
### 4. 启动项目 - 录制流量
- 首先，需要给项目工程加入一个 agent，来录制和回放。arex 的 agent jar，下载后方到工程下，lib 中。目前工程中已经下载了，如果将来有更新，可以重新下载最新的。地址：[https://github.com/arextest/arex-agent-java/releases](https://github.com/arextest/arex-agent-java/releases)
- 之后，本地项目测试验证的时候，可以先 **install**，成功之后使用 `run_application_2_agent.sh` 启动项目，这个操作会把 agent 加载到程序启动中。
#### 4.1 本地测试
```java
#!/bin/bash
# AREX Agent 启动脚本
# 用于在不同环境下启动应用并加载 AREX Agent
# 设置 AREX Agent 相关参数
AREX_AGENT_PATH="./lib/arex-agent.jar"
AREX_SERVICE_NAME="xfg-dev-tech-app"
AREX_STORAGE_HOST="115.190.107.206:8093"
# 应用 JAR 包路径（相对于项目根目录）
APP_JAR="../../xfg-dev-tech-app/target/xfg-dev-tech-app.jar"
# JVM 参数
JVM_OPTS="-Xms512m -Xmx1024m"
# 检查 AREX Agent 文件是否存在
if [ ! -f "$AREX_AGENT_PATH" ]; then
echo "错误: AREX Agent 文件不存在: $AREX_AGENT_PATH"
echo "请确保 arex-agent.jar 文件已放置在正确位置"
exit 1
fi
# 检查应用 JAR 包是否存在
if [ ! -f "$APP_JAR" ]; then
echo "错误: 应用 JAR 包不存在: $APP_JAR"
echo "请先执行 mvn clean package 构建应用"
exit 1
fi
echo "正在启动应用..."
echo "AREX Agent: $AREX_AGENT_PATH"
echo "Service Name: $AREX_SERVICE_NAME"
echo "Storage Host: $AREX_STORAGE_HOST"
echo "Application: $APP_JAR"
echo ""
echo "执行配置："$JVM_OPTS \
-javaagent:"$AREX_AGENT_PATH" \
-Darex.service.name="$AREX_SERVICE_NAME" \
-Darex.storage.service.host="$AREX_STORAGE_HOST" \
-jar "$APP_JAR"
# 启动应用
java $JVM_OPTS \
-javaagent:"$AREX_AGENT_PATH" \
-Darex.service.name="$AREX_SERVICE_NAME" \
-Darex.storage.service.host="$AREX_STORAGE_HOST" \
-jar "$APP_JAR"
```
#### 4.2 docker 镜像
##### 4.2.1 dockerfile
```java
# 基础镜像
FROM openjdk:8-jre-slim
# 作者
MAINTAINER xiaofuge
# 配置
ENV PARAMS=""
# AREX Agent 配置
ENV AREX_SERVICE_NAME="xfg-dev-tech-app"
ENV AREX_STORAGE_HOST="115.190.107.206:8093"
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 添加 AREX Agent
ARG AREX_AGENT_PATH=docs/dev-ops/lib/arex-agent.jar
ADD ${AREX_AGENT_PATH} /arex-agent.jar
# 添加应用
ADD target/xfg-dev-tech-app.jar /xfg-dev-tech-app.jar
ENTRYPOINT ["sh","-c","java $JAVA_OPTS -javaagent:/arex-agent.jar -Darex.service.name=$AREX_SERVICE_NAME -Darex.storage.service.host=$AREX_STORAGE_HOST -jar /xfg-dev-tech-app.jar $PARAMS"]
```
##### 4.2.2 docker-compose
```java
version: '3.8'
services:
xfg-dev-tech-app:
image: fuzhengwei/xfg-dev-tech-app:traffic-agent-v1
container_name: xfg-dev-tech-app
ports:
- "8091:8091"
environment:
# AREX Agent 配置
- AREX_SERVICE_NAME=xfg-dev-tech-app
- AREX_STORAGE_HOST=115.190.107.206:8093
# JVM 配置
- JAVA_OPTS=-Xms512m -Xmx1024m
volumes:
# 日志目录挂载（可选）
- ./data/logs:/var/log/app
networks:
- app-network
restart: unless-stopped
networks:
app-network:
driver: bridge
volumes:
app-logs:
driver: local
```
- 此方式适用于项目部署上线。
### 5. 启动程序
```java
./bin/bash /xfg-dev-tech-traffic-agent/docs/dev-ops/run_application_2_agent.sh
```
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 启动程序，会看到 arex-agent.jar 的加载，这代表是正确✅的，可以上报服务信息。
### 6. 流量录制
```java
@Slf4j
@RestController
@RequestMapping("/api/traffic")
public class TrafficController {
@GetMapping("/query_user_age")
public Integer queryUserAge(@RequestParam("userId") String userId) {
log.info("请求参数:{}", userId);
// return getCache();
return getDB();
}
// 模拟从缓存获取数据
public Integer getCache() {
return 20;
}
// 模拟从数据库获取数据
public Integer getDB() {
return 21;
}
}
```
- 你可以使用工程下，test-api-curl.sh 脚本访问接口，也可以其他方式请求接口。
- 当你请求完成接口后，就可以去arex控制台检查上报的信息和流量录制的数据了。
### 7. 流量回放
#### 7.1 内网穿透
流量回放是从云服务器调用本地，但本地没有对外的公网IP，所以需要内网穿透，让云服务器可以调用。这里的内网穿透工具很多，可以选择；[natapp](https://natapp.cn/)、[cpolar.com](https://www.cpolar.com/) 等。
```java
Powered By NATAPP Please visit https://natapp.cn (Ctrl+C to Quit)
Tunnel Status Online
Version 2.3.9 (New Version 2.4.0)
Forwarding http://xfg-studio.natapp1.cc -> 127.0.0.1:8091
Web Interface Disabled
Total Connections 0
```
- 启动后，会把本地的服务:端口，暴漏出去，通过 http 域名地址访问。
- 注意，在natapp配置你的应用端口，如 8091，如果是其他就修改下。
#### 7.2 回放配置 - 正确回放
- 如图，填写回放配置信息。
- 这次我们是正确回放，也就是本地程序没有任何变更。配置后点OK。
- 点击后，可以在我们本地服务看到回调的日志，但还要稍微等待一会 arex 平台，他要比对回放结果。完成后，Passed 表示回放通过。
#### 7.2 回放配置 - 异常回放
首先，我们要修改下代码。
```java
@RestController
@RequestMapping("/api/traffic")
public class TrafficController {
@GetMapping("/query_user_age")
public Integer queryUserAge(@RequestParam("userId") String userId) {
log.info("请求参数:{}", userId);
// return getCache();
return getDB();
}
// 模拟从缓存获取数据
public Integer getCache() {
return 20;
}
// 模拟从数据库获取数据
public Integer getDB() {
return 21;
}
}
```
- 这个接口方法，如果录制流量是用的 getCache()，那么这会就修改为 getDB()，让两次结果不一样。
- 之后，要重新 install 并重新执行 `run_application_2_agent.sh` 启动项目。关闭执行 Ctrl/Command + C
配置，流量回放操作。
- 之后，再来一遍回放。这样就是错误的结果了。
### 8. 接口请求（Debug）
- arex 工具，还支持线上请求本地接口操作。
- 也就是说，你从线上录制的流量，可以直接拿流量，调试本地接口。有了这样一个操作，哪些线上请求参数非常复杂的结构，就可以直接一键对本地进行验证了。
---
### Md Road Map Arthas (`docs/md/road-map/arthas.md`)
---
title: arthas
lock: need
---
# 面试官：“程序内存溢出，你怎么找出大对虾(像)”？ —— arthas 使用教程
作者：小傅哥
**那有什么手段给 Java 代码号脉吗？🤔**
还真有这么一个工具，也是大多数老司机程序员👨🏻💻非常喜欢用的一款组件，很多时候不好排查的 Bug 都用这个工具进行分析。它可以知道哪个对象创建的过多、方法的出入参、系统运行时候JVM的参数等等，让你随时可以知道系统运行的细节状态。
它就是 Arthas，但很多伙伴还没有使用过，这篇文章为大家分享下，如何使用这样一款组件。以及怎么使用这个组件监控部署到 Docker 中的 Java 应用。
## 一、组件介绍
官网：[https://arthas.aliyun.com/doc/](https://arthas.aliyun.com/doc/)
Arthas 是一款线上监控诊断产品，通过全局视角实时查看应用 load、内存、gc、线程的状态信息，并能在不修改应用代码的情况下，对业务问题进行诊断，包括查看方法调用的出入参、异常，监测方法执行耗时，类加载信息等，大大提升线上问题排查效率。
当你遇到以下类似问题而束手无策时，Arthas可以帮助你解决：
1. 这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？
2. 我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？
3. 遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？
4. 线上遇到某个用户的数据处理有问题，但线上同样无法 debug，线下无法重现！
5. 是否有一个全局视角来查看系统的运行状况？
6. 有什么办法可以监控到 JVM 的实时运行状态？
7. 怎么快速定位应用的热点，生成火焰图？
8. 怎样直接从 JVM 内查找某个类的实例？
## 二、快速入门
在 Arthas 官网有一个简单🔜快速入门的案例，它提供了2个程序，一个是 Java 的随机数分解的程序代码，另外一个是 arthas-boot.jar 监控组件。这个套代码可以在任何安装了 Java 环境的服务器上使用，包括你本地、云服务器都可以运行。
### 1. 步骤1，案例程序
```java
curl -O https://arthas.aliyun.com/math-game.jar
java -jar math-game.jar
```
### 2. 步骤2，监控程序
```java
curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar
```
- 启动后会出来一个 math-game.jar 之后再敲下回车，就进入了 Arthas 的监控程序了。之后你可以使用监控程序提供的各种命令进行使用。
- 命令列表：[https://arthas.aliyun.com/doc/commands.html](https://arthas.aliyun.com/doc/commands.html)
## 三、应用使用
### 1. 环境准备
为了方便大家进行学习验证，小傅哥这里准备好了一个测试工程和相关的环境安装。你可以如下文的说明进行使用和验证。
- 工程：[https://github.com/fuzhengwei/xfg-dev-tech-arthas](https://github.com/fuzhengwei/xfg-dev-tech-arthas)
- 说明：`dev-ops` 下提供了部署测试工程的 docker compose 脚本，以及 arthas-boot 启动程序的脚本。另外工程提供了一个接口，每次访问都会创建对象。接口在 Application 中，简单实现。地址：[http://localhost:8091/api/exec](http://localhost:8091/api/exec) - 接口内容可详见代码。
- 前置：如果你需要云服务器部署操作，可以在 [bugstack.cn](https://bugstack.cn) <路书> 中有云服务器操作，可以学习使用。
### 2. 应用安装
**操作过程预览**
>如图所示，接下来我们会进行部署操作。
#### 2.1 构建脚本
```java
# 基础镜像 openjdk:8-jre-slim openjdk:8-jdk-alpine 8-jdk-alpine
FROM openjdk:8-jdk
# 作者
MAINTAINER xiaofuge
# 配置
ENV PARAMS=""
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 添加应用
ADD target/xfg-dev-tech-app.jar /xfg-dev-tech-app.jar
# arthas https://hub.docker.com/r/hengyunabc/arthas
COPY --from=hengyunabc/arthas:latest /opt/arthas /opt/arthas
## 在镜像运行为容器后执行的命令
ENTRYPOINT ["sh","-c","java -Djava.security.egd=file:/dev/./urandom -jar $JAVA_OPTS /xfg-dev-tech-app.jar $PARAMS"]
# 暴露容器的端口
EXPOSE 8989
```
- `FROM openjdk:8-jdk`：因为 arthas 需要 jps 的相关命令，所以需要指定安装 jdk 版本。`openjdk:8-jre-slim` 是没有这些脚本的。
- `hengyunabc/arthas:latest`：把 arthas 的镜像打包到程序中，这样我们可以直接在程序中使用 arthas 组件。
- 构建过程：无论是本地还是云服务器 Docker 启动后，先执行 `maven install` 程序、后执行 `build.sh` 构建应用镜像。[云服务器操作视频](https://bugstack.cn/md/road-map/linux.html)
#### 2.2 部署项目
```java
version: '3.8'
# docker-compose -f docker-compose-app.yml up -d
# 你需要修改system为你自身系统的仓库名
services:
xfg-dev-tech:
image: xiaofuge/xfg-dev-tech-app:1.0
container_name: xfg-dev-tech
restart: on-failure
ports:
- "8091:8091"
environment:
- TZ=PRC
- SERVER_PORT=8091
# 2c4g 配置，4c8g 翻倍，-Xms4096m -Xmx4096m | -Xmx –Xms：指定java堆最大值（默认值是物理内存的1/4(<1GB)）和初始java堆最小值（默认值是物理内存的1/64(<1GB))
- JAVA_OPTS=-Xms2048m -Xmx2048m -XX:MaxMetaspaceSize=128m -XX:MetaspaceSize=128m -XX:+HeapDumpOnOutOfMemoryError -XX:+PrintGCDateStamps
volumes:
- ./log:/data/log
- ./arthas/profiler:/arthas-output
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
networks:
- my-network
networks:
my-network:
driver: bridge
```
- 脚本说明；脚本提供了 docker compose 安装的配置参数，包括端口、jvm、日志和arthas的映射路径等。
- 执行脚本；`docker-compose -f docker-compose-app.yml up -d`这样会帮助你启动项目。
- Mac 电脑 + Docker 可以直接在 IntelliJ IDEA 中点击启动。
### 3. 监控部署
```java
docker exec -it xfg-dev-tech /bin/sh -c "java -jar /opt/arthas/arthas-boot.jar"
```
- 在案例工程下有一个 dev-ops/arthas-boot.sh 你可以执行启动 arthas
- 启动后有一个 arthas 的控制台，这个控制台可以输入各种 arthas 提供的命令来监控程序。**非常强大**
### 4. 访问接口
在案例工程中提供了一个用于创建对象的程序，方便进行测试。
```java
@Slf4j
@SpringBootApplication
@RestController()
@RequestMapping("/api/")
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
// 创建线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
// 用于存储内存占用对象的列表
private static final List memoryHolder = new ArrayList<>();
/**
* http://localhost:8091/api/exec
*/
@RequestMapping(value = "/exec", method = RequestMethod.GET)
public String exec() {
executorService.submit(() -> {
try {
// 创建一个大对象
// byte[] largeObject = new byte[10 * 1024 * 1024]; // 10MB
byte[] largeObject = new byte[10 * 1024]; // 10MB
// 将其加入内存占用列表中，防止被gc
synchronized (memoryHolder) {
memoryHolder.add(largeObject);
}
log.info("模拟填充大对象");
// 模拟一些工作
Thread.sleep(1000);
} catch (OutOfMemoryError e) {
System.err.println("Out of memory! Halting further allocation.");
// 如果出现OOM，暂停分配以防止程序崩溃
executorService.shutdown();
} catch (InterruptedException e) {
// 捕获并处理睡眠中断
Thread.currentThread().interrupt();
System.err.println("Task interrupted");
}
});
return "ok";
}
}
```
- 请求地址：[http://localhost:8091/api/exec](http://localhost:8091/api/exec)
- 请求脚本：提供了请求1次和循环多次的脚本，方便测试。
## 四、命令使用
使用监控命令前，可以先执行上图中的 curl-one.sh 调用程序接口。你还可以在使用命令的过程中调用测试。
命令：[https://arthas.aliyun.com/doc/commands.html](https://arthas.aliyun.com/doc/commands.html)
### 4.1 dashboard - 当前系统的实时数据面板
> [arthas@7]$ dashboard
- 运行脚本后，可以查看到当前服务的运行数据信息。另外这里还有一些 JVM 基础知识，补充给大家。
#### 4.1.1 jvm 内存空间都有啥
在 Java 运行环境中，JVM（Java Virtual Machine, Java 虚拟机）是执行 Java 程序的引擎，而内存管理是 JVM 非常重要的一部分。JDK 1.8 中的 JVM 内存空间主要分为以下几个区域，每个区域都有其特定的用途：
1. 堆（Heap）：
- 用途：堆是 JVM 中内存最大的一块，用于存储所有的对象实例和数组。几乎所有对象都在此分配内存，垃圾收集器也在这里执行。
- 分代垃圾收集机制：堆内存被进一步划分为新生代和老年代。
- 新生代（Young Generation）：用于存放新创建的对象。其中又分为伊甸园区（Eden Space）和两个幸存者区（Survivor Spaces，通常称为 S0 和 S1）。
- 老年代（Old Generation）：用于存放生命周期较长的对象。
2. 方法区（Method Area）（在 JDK 1.8 中已被细化为元空间 Metaspace）：
- 用途：存储已被加载的类元数据、常量、静态变量等。在 JDK 1.8 中，用于取代永久代（PermGen）。
- 元空间（Metaspace）：与永久代不同，元空间用的是本地内存而不是堆内存，这避免了 Java 中永久代容量不足导致的内存问题。
3. 栈（Stack）：
- 用途：每个线程创建时会分配一个栈，它用来存储局部变量表、操作数栈、动态链接、方法出口等。栈内存会自动随着方法的进出而分配和释放。
- 特性：栈是线程私有的，每个线程都有自己的栈。
4. 程序计数器（Program Counter Register）：
- 用途：是一个较小的内存空间，用于指示当前线程所执行的字节码的行号。
- 特性：它是唯一一个在 Java 虚拟机规范中没有规定任何 OutOfMemoryError 情况的区。
5. 本地方法栈（Native Method Stack）：
- 用途：与 Java 栈类似，但它主要用于处理本地方法（Native Method）的执行。
- 特性：也是线程私有的，负责本地方法的调度和执行。
这些内存区的设计是为了支持 Java 的垃圾收集机制和多线程并发运行，确保 Java 应用程序能够高效和稳定地执行。了解这些内存区的功能和作用，可以帮助开发者优化 Java 应用的性能，并有效管理内存使用。
#### 4.1.2 垃圾回收算法
GC 核心在于通过不同的算法来高效管理内存资源。常用的 GC 算法包括：
1. 标记-清除算法（Mark and Sweep）：
- 标记阶段：遍历所有的对象引用，标记活动的对象。
- 清除阶段：清理掉未被标记的对象。
- 缺点：容易造成内存碎片，因为清除后内存是不连续的。
2. 复制算法（Copying）：
- 将活动的对象从一块内存（From space）复制到另一块（To space），然后清理整块 From space。
- 优点：内存分配简单，不会产生碎片。
- 缺点：需要预留多余的内存空间实行复制。
3. 标记-整理算法（Mark-Compact）：
- 标记阶段：和标记-清除相似。
- 整理阶段：将所有活动对象移到一端，处理剩余的空间为可用。
- 减少了碎片化问题，但相比复制算法更复杂。
4. 分代收集算法：
- 根据对象的生命周期不同，将堆分为新生代和老年代。
- 新生代使用复制算法，老年代使用标记-清除 或 标记-整理。
- 优点：优化了大多数对象短命这一特性带来的效率。垃圾回收算法。
#### 4.1.3 垃圾收集器
Java 提供了多种垃圾收集器，适用于不同应用场景：
1. Serial GC：
- 单线程收集器，非常适合单线程环境和小型应用。
- 效率高但可能造成长时间的停顿。
2. Parallel GC (Throughput Collector)：
- 多线程收集器，用于最大化 CPU 吞吐量。
- 适合后台处理任务和高效利用系统资源的场景。
3. CMS GC (Concurrent Mark-Sweep Collector)：
- 重点在于缩短停顿时间，适合响应时间敏感的应用。
- 较轻量级的 GC，但处理老年代垃圾时效率不如 Parallel。
4. G1 GC (Garbage-First Collector)：
- 设计用于大堆，提供可预测的停顿时间。
- 将堆划分为不同的区域（Region），针对不同老化级别进行回收。
5. ZGC / Shenandoah GC：
- 尝试实现低延迟垃圾回收，几乎不会造成任何长时间的停顿。
#### 4.1.4 code_cache (代码缓存区)、compressed_class_space (压缩类空间)、metaspace (元空间)，他们的用途是什么，有什么要注意的。
在 Java 虚拟机（JVM）中，非堆内存部分包括多个区域，每个区域负责存储不同种类的数据，这里重点介绍 Code Cache（代码缓存区）、Compressed Class Space（压缩类空间）和 Metaspace（元空间）的用途及注意事项。
##### 1. Code Cache（代码缓存区）
用途：
- JIT 编译代码：Java 虚拟机的即时编译器（Just-In-Time Compiler，JIT）会将频繁使用的字节码编译成本地机器码，以提高运行性能。编译后的本地代码存储在代码缓存区中。
- 性能提升：通过存储这些编译后的代码，JVM 可以避免对同一代码片段重复进行解释，从而提升执行速度。
注意事项：
- 内存限制：代码缓存区有固定的最大值（可通过 `-XX:ReservedCodeCacheSize` 参数配置），需要注意在长时间运行的应用程序中这个区不会被耗尽，否则可能导致性能退化。
- 清理与优化：JVM 在启动时和运行过程中可能会执行代码缓存的清理和优化，这个过程会对性能有一定影响。
##### 2. Compressed Class Space（压缩类空间）
用途：
- 存储类元数据：在开启类指针压缩的情况下（默认开启），这个空间用于存储类元数据的压缩指针，以节省内存空间。
- 支持元空间：压缩类空间是元空间的一部分，专门用来优化类加载器的内存消耗。
注意事项：
- 有固定最大限制：虽然是元空间的一部分，但压缩类空间有自己的最大内存限制（默认为 1GB），可以通过 `-XX:CompressedClassSpaceSize` 参数调整。
- 适配性告诉：32 位 JVM 不使用压缩类空间功能，64 位 JVM 在默认情况下是开启的，因其节省的内存对大型应用尤其重要。
##### 3. Metaspace（元空间）
用途：
- 替换永久代：Java 8 开始，用元空间替代了永久代，用于存储类的元数据（类的结构信息、方法、字段等）。
- 动态调整大小：与永久代不同，元空间作为物理内存的一部分，不断增长（直到达到物理内存上限），默认不设置上限，灵活性更高。
注意事项：
- 内存泄漏风险：尽管更灵活，但如果不加限制，糟糕的类加载策略可能导致元空间内存泄漏。在开发环境中尤其要防止过度类加载。
- 调整与监控：可以通过 `-XX:MetaspaceSize` 和 `-XX:MaxMetaspaceSize` 进行调节，适当限制，在实际使用中密切监控。
- 自动释放：JVM 在内存不足时会尝试回收未使用的类加载的内存，虽然一般无需手动干预，了解这方面的配置有助于优化内存使用。
这些部分的配置和监控是调优 JVM 的重要组成部分，适当的配置可以防止内存泄漏、排查性能瓶颈，并为应用程序的稳定性提供保障。
### 4.2 火焰图
#### 4.2.1 生成脚本
profiler 命令支持生成应用热点的火焰图。本质上是通过不断的采样，然后把收集到的采样结果生成火焰图。火焰图可以清楚的看到程序运行中对象的创建，这样你就可以发现那些大对虾(像)从哪来的？
操作过程，开启采集 `profiler start --event alloc` 等待程序执行，关闭采集 `profiler stop --format html`
我们操作中，开启采集后，可以先执行多次的 curl-one.sh 调用接口，多产生点对象。
```java
profiler start --event alloc
profiler getSamples
profiler status
profiler stop --format html
```
- 执行完成后，你会得到一个火焰图的 html 文件。之后就可以打开了。
#### 4.2.2 查看图表
1. 这里的x轴代表采样总量（也就是此刻所有执行的耗时cpu的方法）。这是注意的是x 轴并不代表时间，而是所有的调用方法合并后，按字母顺序排列。
2. Y轴代表方法的调用栈深度，每一层都是一个方法。顶部是正在执行的方法。当然调用栈越深，火焰就越高。
3. 鼠标可以点击的选中的每个框就代表了一个栈里的函数，其宽度可以直接理解为CPU时间占比（其实是采样的数量以及与采样总量的占比）。
4. 那么，也就是说占比比较宽的框就表示：a.该函数运行时间较长（单次时间长）b.被调用次数较多.（调用频率高）进而被采样的次数比较多，占用的CPU时间多。
4. 这样你就知道了是哪里在创建大对像。比如一些数据库对象，缓存对象等，特别大，又耗时，一下就监控出来了。
> Arthas 提供的功能还有很多，不过咱们要换个更加舒服的方式使用了。如下。
## 五、IDEA Plugin Arthas
### 1. 安装插件
### 2. 使用插件
这些命令你都可以通过 Arthas IDEA Plugin 插件复制出来使用。
- [monitor](https://arthas.aliyun.com/doc/monitor.html) - 方法执行监控
- [stack](https://arthas.aliyun.com/doc/stack.html) - 输出当前方法被调用的调用路径
- [trace](https://arthas.aliyun.com/doc/trace.html) - 方法内部调用路径，并输出方法路径上的每个节点上耗时
- [tt](https://arthas.aliyun.com/doc/tt.html) - 方法执行数据的时空隧道，记录下指定方法每次调用的入参和返回信息，并能对这些不同的时间下调用进行观测
- [watch](https://arthas.aliyun.com/doc/watch.html) - 方法执行数据观测
更多命令 [https://arthas.aliyun.com/doc/commands.html](https://arthas.aliyun.com/doc/commands.html)
#### 2.1 复制命令
#### 2.2 使用命令
- 如图你就可以监控到方法的运行信息了。
### 3. 其他命令
#### 3.1 查看代码
- 线上运行的代码，不确定是否是最新的，那么这样就可以一步获取到并对比。
#### 3.2 接口参数
- 有时候预发验证服务，因为不会打印所有的服务接口出入参信息，但遇到问题不好排查。
- 那么使用 Arthas 插件，就可以直接获取到接口的出入参了，方便排查问题。
> 其他更多命令可以通过官网的命令提示和插件一起使用验证了。
---
### Md Road Map Buddy (`docs/md/road-map/buddy.md`)
---
title: Docker 镜像构建 - Buddy
lock: need
---
# Docker 镜像构建 - Buddy
作者：小傅哥
org.elasticsearch.plugin
x-pack-sql-jdbc
7.17.14
```
## 三、工程配置
本节涉及到了简明教程中所讲解的 [Sharding 分库分表](https://bugstack.cn/md/road-map/sharding-jdbc.html)的使用，因为我们需要把分库分表的数据通过 canal 同步到 Elasticsearch。（也可以使用其他分库分表组件）
在工程中配置一套 Sharding 分库分表映射的 MyBatis MyBatis，在配置一套 Elasticsearch x-pack-sql-jdbc 数据源映射的 MyBatis Mapper。这样可以读写分别走自己设定好的 Mapper 对象了。
### 1. 创建数据源
```
/* Detailed source-code truncated for AI context efficiency. */
```
- ElasticsearchMyBatisConfig 使用 EsDataSource 创建数据源和映射 MyBatis Mapper 文件。
- MysqlMyBatisConfig 使用 DataSourceBuilder 创建 Sharding 提供的数据源和映射 MyBatis Mapper 文件。
### 2. Mapper 映射
```xml
select _user_id, _user_name, _order_id, _sku_name
from "xfg_dev_tech.user_order"
order by _update_time
limit 10
```
这个是 Elasticsearch 映射的 Mapper 文件，映射的字段就是前面安装环境的时候设置的索引和字段。现在你使用 Elasticsearch 就不用在工程中硬编码查询语句了，变得非常方便。
## 四、工程测试
### 1. 写入数据
```java
@Test
public void test_insert() throws InterruptedException {
for (int i = 0; i < 3; i++) {
UserOrderPO userOrderPO = UserOrderPO.builder()
.userName("小傅哥")
.userId("xfg_" + RandomStringUtils.randomAlphabetic(6))
.userMobile("+86 13521408***")
.sku("13811216")
.skuName("《手写MyBatis：渐进式源码实践》")
.orderId(RandomStringUtils.randomNumeric(11))
.quantity(1)
.unitPrice(BigDecimal.valueOf(128))
.discountAmount(BigDecimal.valueOf(50))
.tax(BigDecimal.ZERO)
.totalAmount(BigDecimal.valueOf(78))
.orderDate(new Date())
.orderStatus(0)
.isDelete(0)
.uuid(UUID.randomUUID().toString().replace("-", ""))
.ipv4("127.0.0.1")
.ipv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334".getBytes())
.extData("{\"device\": {\"machine\": \"IPhone 14 Pro\", \"location\": \"shanghai\"}}")
.build();
userOrderDao.insert(userOrderPO);
Thread.sleep(100);
}
}
```
- 循环插入3条数据，按需你可以设置更多条数据。
- 这里的用户编号 userId 是随机的，也是切分键的 ID，所以会在不同的库表写入数据。
### 2. 数据验证
- MySQL：[http://127.0.0.1:8899/](http://127.0.0.1:8899/) docker compose 配置的管理后台，可以 root/123456 登录
- Kibana：[http://127.0.0.1:5601/app/discover](http://127.0.0.1:5601/app/discover) 查询写入的数据。
### 3. 查询数据
```java
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserOrderDaoTest {
@Resource
private IElasticsearchUserOrderDao userOrderDao;
@Test
public void test() {
List userOrderPOS = userOrderDao.selectByUserId();
log.info("测试结果：{}", JSON.toJSONString(userOrderPOS));
}
}
```
- 通过 Elasticsearch 走 x-pack-sql-jdbc 的方式再把数据查询出来。
---
### Md Road Map Cloud Server (`docs/md/road-map/cloud-server.md`)
---
title: CloudServer 云服务器是什么？
lock: need
---
# CloudServer 云服务器是什么？
作者：小傅哥
**你是否对云服务器比较陌生？**
其实不少伙伴没怎么使用过云服务器，一方面是因为没有意识到项目最终是在云服务器部署（也没有主动虚席），另一方面是因为云服务器基本是使用 Linux 系统，不像是 Windows/Mac 电脑一样，基本是没有图形化界面的，所以对于云服务器的使用就有了一道**障碍**。
不过，鉴于云服务器的技能这么重要。所以，小傅哥准备做一套基础的**免费教程**，来教会小白伙伴上手云服务器使用。这套教程，通过在线网站提供图形化界面 + 模拟体验的方式，教会小白伙伴上手云服务器。
> 📢 本套课程，是小傅哥多年的沉淀的经验，转化最易接受和上手学习的方式，让小白伙伴可以轻松的掌握全套关于云服务器的知识和实践运用。
## 一、课程地址
**地址**：[https://gaga.plus/](https://gaga.plus/)
> 如图，教程地址，会陆续更新在线课程。可以收藏地址，关注后续课程更新（更新内容会在公众号「bugstack虫洞栈」发布通知）。
## 二、我能学到什么？
通过这套教程，你可以完成的理解云服务器的用途，掌握云服务器的操作技能。从零基础到熟练运用云服务器 + 本地环境完成项目的开发、测试和部署的全流程。教程采用在线演示体验，互动式学习方式，以及一键安装的脚本，让复杂的云服务器操作，变得简单和易于理解。
- 🏗️理解云服务器的概念、选择、配置、管理，以及通过 shell 脚本，完成自动化的初始化环境操作。
- ☕ 在云服务器部署 Git、Java、Maven 环境，可以通过云服务器完成项目的构建。
- 🐳 Docker 容器化技术，完成项目的构建镜像、操作部署等。
- 🔐 远程连接与安全，学习 SSH 链接云服务器和 Linux 命令操作云服务器。
- 🌿 版本控制与协作，可以在云服务器通过 Git 检出项目进行维护使用。
- 🚀 部署与运维，以代码开发、Git Push、Git Pull、mvn clean install、docker，一些列命令，完成项目的打包和上线。
这套教程的特色在于完全可视化学习，注重理论与实践，不仅让您了解云服务器的基本概念，更重要的是通过交互式演示和自动化脚本，让您能够快速上手并在实际项目中应用这些技术。无论您是初学者还是有一定经验的开发者，都能从中获得有价值的知识和技能提升。
## 三、小傅哥为你准备了什么？
小傅哥，今天为你准备了第一套在线教程**《第1节：云服务器，是什么？》**
在这套教程，你可以直接直观的理解到云服务器相对于本地电脑，其实就等同于你的另外一个电脑而已。并且，小傅哥这里做了模拟的链接，**你可以在线体验通过 SSH 连接云服务器，并执行 Linux 脚本运行**。关于这些写脚本，已经写好了相关的执行动作和说明，很适合小白伙伴学习使用。
### 1. 云服务器链接
- 首先，云服务器，就是你在互联网上的另一台电脑，随时随地访问使用，任意安装和卸载软件。尤其对软件学习来说，可以避免windows电脑的兼容问题。
- 之后，你可以点击建立 SSH 链接，这个时候会弹出 SSH 链接操作。让你真的的体验到如何通过 SSH 链接云服务器。
### 2. Linux 命令模拟
#### 2.1 建立链接（SSH）
- 如图，IP、用户名、密码、端口号，就是你在获得一个云服务器后，可以拿到的连接信息。在你真实使用云服务器时，也是需要获得这些信息进行连接操作。
- 之后，通过点击建立SSH连接，模拟登录云服务器。**没有云服务器的伙伴，也能随时体验云服务器操作**
#### 2.2 体验登录
- 我知道很多小伙伴，不太熟悉 Linux 命令。所以，小傅哥这里做了模拟操作，你可以点击命令，之后就可以看到执行结果，以及告诉你命令的用途。此外还有 Git、Maven、Docker 常见命令的学习。
- 通过这套东西的学习，对于云服务器的使用，基本就可以有一个操作的使用认知了。后续在看到要执行命令，也都能理解，是怎么的一个操作过程。
#### 2.3 常用命令
**如下，这些命令都已经加入到体验区 👨🏻💻**
- 你可以点击各个命令，学习对应的场景用途。
- 如果，小伙伴还有其他命令想学习，也可以留言。我会进行补充。
> 后续，还有更炸裂的在线模拟学习课，让你身临其境的学习云服务器的操作。我们下一节再见👋🏻
---
### Md Road Map Connection Pool (`docs/md/road-map/connection-pool.md`)
---
title: ConnectionPool
lock: need
---
# MySQL 连接池 c3p0、dbcp、druid、hikari
作者：小傅哥
- 在 IntelliJ IDEA 打开 xfg-dev-tech-connection-pool 分别点开 mysql-docker-compose、apachebench-docker-compose，之后点击安装即可。
- 执行完脚本，你可以得到一份安装好的 MySQL 8.0 并安装了数据库表。另外一份是用于压测使用的 [ApacheBench](https://httpd.apache.org/docs/2.4/programs/ab.html)
- 连接 MySQL 的工具，推荐使用开源免费的 [Sequel Ace](https://apps.apple.com/us/app/sequel-ace/id1518036000?ls=1)
## 三、工程说明
在 xfg-dev-tech-connection-pool 工程中提供了不同连接池的配置和一些非常常用的 SQL 操作，以及提供了对应的接口进行压测使用；
| 序号 | 接口 | 说明 |
| ---- | ------------------------------------------------------------ | -------------------------------------------------- |
| 1 | http://127.0.0.1:8091/api/mysql/cacheData | 用于缓存数据的接口，拿缓存好的数据压测更新、查询 |
| 2 | http://127.0.0.1:8091/api/mysql/insert | 插入数据接口 |
| 3 | http://127.0.0.1:8091/api/mysql/updateOrderStatusByUserId | 使用索引字段 userId 更新订单状态 |
| 4 | http://127.0.0.1:8091/api/mysql/updateOrderStatusByUserMobile | 使用无索引字段 userMobile 更新订单状态 |
| 5 | http://127.0.0.1:8091/api/mysql/updateOrderStatusByOrderId | 使用索引字段 orderId 更新订单状态 |
| 6 | http://127.0.0.1:8091/api/mysql/selectByUserId | 使用索引字段 userId 查询订单 |
| 7 | http://127.0.0.1:8091/api/mysql/selectByUserMobile | 使用无索引字段 userMobile 查询订单，测试中添加索引 |
| 8 | http://127.0.0.1:8091/api/mysql/selectByOrderId | 使用有索引字段 orderId 查询订单 |
| 9 | http://127.0.0.1:8091/api/mysql/selectByOrderIdAndUserId | 区分度高的索引字段在前，区分度低的索引字段在后 |
| 10 | http://127.0.0.1:8091/api/mysql/selectByUserIdAndOrderId | 区分度低的索引字段在前，区分度高的索引字段在后 |
- 具体代码实现可以直接对照工程来看，以及按需添加SQL语句进行性能压测验证。
## 四、库表语句
SQL：`xfg-dev-tech-connection-pool/docs/sql/road_map_8.0.sql`
- 这是本节所需要测试的一个订单表和测试前所建的索引字段。以及初始化了100万数据，占用350M空间。
- 接下来，我们就可以做测试验证了。
## 五、压测指令
ApacheBench 官网教程：[https://httpd.apache.org/docs/2.4/programs/ab.html](https://httpd.apache.org/docs/2.4/programs/ab.html)
常用的如：`ab -c 20 -n 1000 http://127.0.0.1:8091/hi` - 20个并发1000次
## 六、压测验证
首先在测试前，正式测试前，你大概需要花费几十分钟来初始化100万数据。执行脚本；`ab -c 20 -n 1000000 http://127.0.0.1:8091/api/mysql/insert` - 如果你在工程中配置了 no-pool 大概要花费几个小时才能跑完，这就使用和不使用连接池的差距。
### 1. 连接池比对
**条件**；
1. 插入1万条数据
2. 连接池配置 initialPoolSize=5、minPoolSize=5、maxPoolSize=20
2. 此时数据库已经有100万数据，分别用几个链接方式插入数据。hikari 放到最后，它是 SpringBoot 的默认连接池。
2. 脚本；`ab -c 20 -n 10000 http://127.0.0.1:8091/api/mysql/insert`
| | no-pool | c3p0 | dbcp | druid | hikari |
| :--: | :------------: | :------------: | :------------: | :------------: | :------------: |
| 耗时 | 88.990 seconds | 24.228 seconds | 33.656 seconds | 25.971 seconds | 25.002 seconds |
| 50% | 155ms | 39ms | 60ms | 45ms | 43ms |
| 80% | 223ms | 61ms | 86ms | 64ms | 64ms |
| 90% | 291ms | 75ms | 103ms | 75ms | 76ms |
- 通过对比可以发现，如果不使用连接池，会比使用连接池，要占用更多的时间连接数据库使用数据库。
- c3p0、hikari 的性能还是非常不错的，dbcp 相对是弱一些的。所以这可以给你在使用连接池时有一个参考。也可以结合你的机器再次进行压测验证。
### 2. 更新对比
**条件**；
1. 使用接口，向内存加入600条数据。每个测试方式，分别消耗200条。`ab -c 10 -n 600 http://127.0.0.1:8091/api/mysql/cacheData`
2. 之后使用无索引字段、有索引但区分度不高的字段以及使用有索引区分度非常好的字段来更新。
3. 脚本；
1. `ab -c 20 -n 200 http://127.0.0.1:8091/api/mysql/updateOrderStatusByUserMobile`
2. `ab -c 20 -n 200 http://127.0.0.1:8091/api/mysql/updateOrderStatusByUserId`
3. `ab -c 20 -n 200 http://127.0.0.1:8091/api/mysql/updateOrderStatusByOrderId`
| | 无索引 | 有索引-区分度不高 | 有索引-区分度很高 |
| :--: | :-----: | :---------------: | :---------------: |
| 耗时 | 24小时+ | 24小时+ | 0.432 seconds |
| 50% | 24小时+ | 24小时+ | 35ms |
| 80% | 24小时+ | 24小时+ | 48ms |
| 90% | 24小时+ | 24小时+ | 67ms |
- 无索引的时候；会把整个表的这个记录，全部锁上。那么越执行越慢，最后拖垮数据库。甚至可能1天都执行不完。
- 有索引-区分度不高；几乎是一样的，如果你批量的对一个用户的所有数据都更新，也会锁很多记录。
- 有索引-区分度很高；只要你锁的是自己的一条记录，就与别人没有影响。效率也会非常高。
### 3. 查询对比
**条件**；
1. 查询100万加的数据库表记录，每次缓存记录5000条数据id；`ab -c 10 -n 5000 http://127.0.0.1:8091/api/mysql/cacheData`
2. userId 有索引、orderId 有索引、userMobie 无索引。
2. 每次查询的时候，都要关闭服务重启，避免有缓存干扰结果。
3. 脚本：
1. `ab -c 20 -n 5000 http://127.0.0.1:8091/api/mysql/selectByUserMobile`
2. `ab -c 20 -n 5000 http://127.0.0.1:8091/api/mysql/selectByUserId`
3. `ab -c 20 -n 5000 http://127.0.0.1:8091/api/mysql/selectByOrderId`
4. `ab -c 20 -n 5000 http://127.0.0.1:8091/api/mysql/selectByOrderIdAndUserId`
5. `ab -c 20 -n 5000 http://127.0.0.1:8091/api/mysql/selectByUserIdAndOrderId`
| | 无索引 | 有索引-区分度不高 | 有索引区分度高 | 高在前 | 低在前 |
| ---- | :----: | :---------------: | :------------: | :-----------: | :-----------: |
| 耗时 | 6小时+ | 8.343 seconds | 2.051 seconds | 2.168 seconds | 3.279 seconds |
| 50% | 7s | 13ms | 7ms | 7ms | 11ms |
| 80% | 9s | 20ms | 10ms | 11ms | 17ms |
| 90% | 15s | 26ms | 13ms | 13ms | 22ms |
- 无索引，还是查询字段的。非常危险。
- 不要在一些区分度不高的字段建索引。当然本案例中，userId 最多也就1000来个用户所产生的1百万数据，这样的情况更适合分库分表。
- 区分度很高的字段，查询效率会非常好。
- 把高区分度的索引字段放在前面，更有利于查询。—— 注意不要测试完上一个，直接测试下一个。有缓存的情况下，会影响对比结果。
---
这就是整个数据库表的压测过程了。如果你有使用的诉求，需要做技术调研，那么一定要做一些这样的压测处理。这样有真实数据才好讲道理。另外需要面试的伙伴，你不是总没有数据吗，来吧，按照这个压一压！
---
### Md Road Map Db Router (`docs/md/road-map/db-router.md`)
---
title: db-router
lock: need
---
# 数据库分库分表路由组件
作者：小傅哥
dataSourceProps = PropertyUtil.handle(environment, prefix + dbInfo, Map.class);
dataSourceMap.put(dbInfo, dataSourceProps);
}
}
```
- prefix，是数据源配置的开头信息，你可以自定义需要的开头内容。
- dbCount、tbCount、dataSources、dataSourceProps，都是对配置信息的提取，并存放到 dataSourceMap 中便于后续使用。
### 3. 数据源切换
在结合 SpringBoot 开发的 Starter 中，需要提供一个 DataSource 的实例化对象，那么这个对象我们就放在 DataSourceAutoConfig 来实现，并且这里提供的数据源是可以动态变换的，也就是支持动态切换数据源。
**创建数据源**
```java
@Bean
public DataSource dataSource() {
// 创建数据源
Map targetDataSources = new HashMap<>();
for (String dbInfo : dataSourceMap.keySet()) {
Map objMap = dataSourceMap.get(dbInfo);
targetDataSources.put(dbInfo, new DriverManagerDataSource(objMap.get("url").toString(), objMap.get("username").toString(), objMap.get("password").toString()));
}
// 设置数据源
DynamicDataSource dynamicDataSource = new DynamicDataSource();
dynamicDataSource.setTargetDataSources(targetDataSources);
return dynamicDataSource;
}
```
- 这里是一个简化的创建案例，把基于从配置信息中读取到的数据源信息，进行实例化创建。
- 数据源创建完成后存放到 `DynamicDataSource` 中，它是一个继承了 AbstractRoutingDataSource 的实现类，这个类里可以存放和读取相应的具体调用的数据源信息。
### 4. 切面拦截
在 AOP 的切面拦截中需要完成；数据库路由计算、扰动函数加强散列、计算库表索引、设置到 ThreadLocal 传递数据源，整体案例代码如下：
```java
@Around("aopPoint() && @annotation(dbRouter)")
public Object doRouter(ProceedingJoinPoint jp, DBRouter dbRouter) throws Throwable {
String dbKey = dbRouter.key();
if (StringUtils.isBlank(dbKey)) throw new RuntimeException("annotation DBRouter key is null！");
// 计算路由
String dbKeyAttr = getAttrValue(dbKey, jp.getArgs());
int size = dbRouterConfig.getDbCount() * dbRouterConfig.getTbCount();
// 扰动函数
int idx = (size - 1) & (dbKeyAttr.hashCode() ^ (dbKeyAttr.hashCode() >>> 16));
// 库表索引
int dbIdx = idx / dbRouterConfig.getTbCount() + 1;
int tbIdx = idx - dbRouterConfig.getTbCount() * (dbIdx - 1);
// 设置到 ThreadLocal
DBContextHolder.setDBKey(String.format("%02d", dbIdx));
DBContextHolder.setTBKey(String.format("%02d", tbIdx));
logger.info("数据库路由 method：{} dbIdx：{} tbIdx：{}", getMethod(jp).getName(), dbIdx, tbIdx);
// 返回结果
try {
return jp.proceed();
} finally {
DBContextHolder.clearDBKey();
DBContextHolder.clearTBKey();
}
}
```
- 简化的核心逻辑实现代码如上，首先我们提取了库表乘积的数量，把它当成 HashMap 一样的长度进行使用。
- 接下来使用和 HashMap 一样的扰动函数逻辑，让数据分散的更加散列。
- 当计算完总长度上的一个索引位置后，还需要把这个位置折算到库表中，看看总体长度的索引因为落到哪个库哪个表。
- 最后是把这个计算的索引信息存放到 ThreadLocal 中，用于传递在方法调用过程中可以提取到索引信息。
## 四. 测试验证
### 1. 库表创建
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 创建相同表结构的多个库存信息，bugstack_01、bugstack_02
### 2. 语句配置
```java
SELECT id, userId, userNickName, userHead, userPassword, createTime
FROM user_${tbIdx}
where userId = #{userId}
insert into user_${tbIdx} (id, userId, userNickName, userHead, userPassword,createTime, updateTime)
values (#{id},#{userId},#{userNickName},#{userHead},#{userPassword},now(),now())
```
- 在 MyBatis 的语句使用上，唯一变化的需要在表名后面添加一个占位符，`${tbIdx}` 用于写入当前的表ID。
### 3. 注解配置
```java
@DBRouter(key = "userId")
User queryUserInfoByUserId(User req);
@DBRouter(key = "userId")
void insertUser(User req);
```
- 在需要使用分库分表的方法上添加注解，添加注解后这个方法就会被 AOP 切面管理。
### 4. 单元测试
```java
22:38:20.067 INFO 19900 --- [ main] c.b.m.db.router.DBRouterJoinPoint : 数据库路由 method：queryUserInfoByUserId dbIdx：2 tbIdx：3
22:38:20.594 INFO 19900 --- [ main] cn.bugstack.middleware.test.ApiTest : 测试结果：{"createTime":1615908803000,"id":2,"userHead":"01_50","userId":"980765512","userNickName":"小傅哥","userPassword":"123456"}
22:38:20.620 INFO 19900 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor : Shutting down ExecutorService 'applicationTaskExecutor'1
```
- 以上就是我们使用自己的数据库路由组件执行时的一个日志信息，可以看到这里包含了路由操作，在2库3表：`数据库路由 method：queryUserInfoByUserId dbIdx：2 tbIdx：3`
---
### Md Road Map Ddd Archetype Maven (`docs/md/road-map/ddd-archetype-maven.md`)
---
title: DDD 脚手架【Maven 在线版】
lock: need
---
# 我把DDD脚手架，发布到了Maven仓库，大家都能用了！
作者：小傅哥
dev
true
dev
test
test
prod
prod
```
- 定义环境；开发、测试、上线。
**源码**：`xfg-frame-app/application.yml`
```java
spring:
config:
name: xfg-frame
profiles:
active: dev # dev、test、prod
```
- 除了 pom 的配置，还需要在 application.yml 中指定环境。这样就可以对应的加载到；`application-dev.yml`、`application-prod.yml`、`application-test.yml` 这样就可以很方便的加载对应的配置信息了。尤其是各个场景中切换会更加方便。
### 5. 切面
一个工程开发中，有时候可能会有很多的统一切面和启动配置的处理，这些内容都可以在 xfg-frame-app 完成。
**源码**：`cn.bugstack.xfg.frame.aop.RateLimiterAop`
```java
@Slf4j
@Aspect
public class RateLimiterAop {
private final long timeout;
private final double permitsPerSecond;
private final RateLimiter limiter;
public RateLimiterAop(double permitsPerSecond, long timeout) {
this.permitsPerSecond = permitsPerSecond;
this.timeout = timeout;
this.limiter = RateLimiter.create(permitsPerSecond);
}
@Pointcut("execution(* cn.bugstack.xfg.frame.trigger..*.*(..))")
public void pointCut() {
}
@Around(value = "pointCut()", argNames = "jp")
public Object around(ProceedingJoinPoint jp) throws Throwable {
boolean tryAcquire = limiter.tryAcquire(timeout, TimeUnit.MILLISECONDS);
if (!tryAcquire) {
Method method = getMethod(jp);
log.warn("方法 {}.{} 请求已被限流，超过限流配置[{}/秒]", method.getDeclaringClass().getCanonicalName(), method.getName(), permitsPerSecond);
return Response.builder()
.code(Constants.ResponseCode.RATE_LIMITER.getCode())
.info(Constants.ResponseCode.RATE_LIMITER.getInfo())
.build();
}
return jp.proceed();
}
private Method getMethod(JoinPoint jp) throws NoSuchMethodException {
Signature sig = jp.getSignature();
MethodSignature methodSignature = (MethodSignature) sig;
return jp.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
}
}
```
**使用**
```java
# 限流配置
rate-limiter:
permits-per-second: 1
timeout: 5
```
- 这样你所有的通用配置，又和业务没有太大的关系的，就可以直接写到这里了。—— 具体可以参考代码。
## 六、工程测试验证
- 首先；整个工程由 SpringBoot 驱动，提供了 road-map.sql 测试 SQL 库表语句。你可以在自己的本地mysql上进行执行。它会创建库表。
- 之后；在 application.yml 配置数据库链接信息。
- 之后就可以打开 ApiTest 进行测试了。你可以点击 Application 类的绿色箭头启动工程，使用触发器里的接口调用测试，或者单元测试RPC接口，小傅哥也提供了泛化调用的方式。
- 如果你正常获取了这样的结果信息，那么说明你已经启动成功。接下来就可以对照着DDD的结构进行学习，以及使用这样的工程结构开发自己的项目。
---
### Md Road Map Ddd Model (`docs/md/road-map/ddd-model.md`)
---
title: DDD 建模案例
lock: need
---
# 架构的本质之 DDD 四色建模
作者：小傅哥
dev
true
dev
test
test
prod
prod
```
- 定义环境；开发、测试、上线。
**源码**：`xfg-frame-app/application.yml`
```java
spring:
config:
name: xfg-frame
profiles:
active: dev # dev、test、prod
```
- 除了 pom 的配置，还需要在 application.yml 中指定环境。这样就可以对应的加载到；`application-dev.yml`、`application-prod.yml`、`application-test.yml` 这样就可以很方便的加载对应的配置信息了。尤其是各个场景中切换会更加方便。
### 5. 切面
一个工程开发中，有时候可能会有很多的统一切面和启动配置的处理，这些内容都可以在 xfg-frame-app 完成。
**源码**：`cn.bugstack.xfg.frame.aop.RateLimiterAop`
```java
@Slf4j
@Aspect
public class RateLimiterAop {
private final long timeout;
private final double permitsPerSecond;
private final RateLimiter limiter;
public RateLimiterAop(double permitsPerSecond, long timeout) {
this.permitsPerSecond = permitsPerSecond;
this.timeout = timeout;
this.limiter = RateLimiter.create(permitsPerSecond);
}
@Pointcut("execution(* cn.bugstack.xfg.frame.trigger..*.*(..))")
public void pointCut() {
}
@Around(value = "pointCut()", argNames = "jp")
public Object around(ProceedingJoinPoint jp) throws Throwable {
boolean tryAcquire = limiter.tryAcquire(timeout, TimeUnit.MILLISECONDS);
if (!tryAcquire) {
Method method = getMethod(jp);
log.warn("方法 {}.{} 请求已被限流，超过限流配置[{}/秒]", method.getDeclaringClass().getCanonicalName(), method.getName(), permitsPerSecond);
return Response.builder()
.code(Constants.ResponseCode.RATE_LIMITER.getCode())
.info(Constants.ResponseCode.RATE_LIMITER.getInfo())
.build();
}
return jp.proceed();
}
private Method getMethod(JoinPoint jp) throws NoSuchMethodException {
Signature sig = jp.getSignature();
MethodSignature methodSignature = (MethodSignature) sig;
return jp.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
}
}
```
**使用**
```java
# 限流配置
rate-limiter:
permits-per-second: 1
timeout: 5
```
- 这样你所有的通用配置，又和业务没有太大的关系的，就可以直接写到这里了。—— 具体可以参考代码。
## 六、测试验证
- 首先；整个工程由 SpringBoot 驱动，提供了 road-map.sql 测试 SQL 库表语句。你可以在自己的本地mysql上进行执行。它会创建库表。
- 之后；在 application.yml 配置数据库链接信息。
- 之后就可以打开 ApiTest 进行测试了。你可以点击 Application 类的绿色箭头启动工程，使用触发器里的接口调用测试，或者单元测试RPC接口，小傅哥也提供了泛化调用的方式。
- 如果你正常获取了这样的结果信息，那么说明你已经启动成功。接下来就可以对照着DDD的结构进行学习，以及使用这样的工程结构开发自己的项目。
---
### Md Road Map Disruptor (`docs/md/road-map/disruptor.md`)
---
title: Disruptor
lock: need
---
# Disruptor 高性能环形消息队列应用，Log4j 2 也用到了这套技术。
作者：小傅哥
com.lmax
disruptor
3.4.4
```
- 引入 disruptor pom 包。
### 3. 监听消息
```java
@Slf4j
public class XxxEventHandler implements EventHandler {
@Override
public void onEvent(Message longEvent, long l, boolean b) throws Exception {
log.info("接收消息：{}", longEvent.getValue());
}
@Data
public static class Message {
private String value;
}
}
```
- 在 trigger 下 event 包内，加一个实现了 disruptor EventHandler 的监听实现类，消息体类型我们定义到 XxxEventHandler 中，也就是 Message。具体生产使用的时候，按需调整。
- 这个接收消息的过程和使用 MQ 的方式是一样的。
### 4. 实例化监听
```java
@Configuration
public class DisruptorConfig {
private final ExecutorService executor = Executors.newCachedThreadPool();
@Bean("xxxEventDisruptor")
public Disruptor disruptor() {
// 环形队列的大小，注意要是2的幂
int bufferSize = 1024;
// 创建Disruptor
Disruptor disruptor = new Disruptor<>(XxxEventHandler.Message::new, bufferSize, executor);
// 连接事件处理器
disruptor.handleEventsWith(new XxxEventHandler());
// 开始Disruptor
disruptor.start();
return disruptor;
}
}
```
- 在 App 模块下，有一个 config 专门的配置类，在这里配置下消息监听。这个过程和我们之前使用的 Redis 发布订阅是一样的。
### 5. 推送消息(Test)
```java
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class DisruptorTest {
@Resource
private Disruptor xxxEventDisruptor;
@Test
public void test_publishEvent() throws InterruptedException {
for (int i = 0; i < 10; i++) {
xxxEventDisruptor.publishEvent((event, sequence) -> event.setValue("你好，我是 Disruptor Message"));
}
// 暂停 - 测试完手动关闭程序
new CountDownLatch(1).await();
}
}
```
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 提供一个单测来测试消息推送，这样你就可以监听到消息了。
## 三、总结
在美团、京东、阿里，等各个大厂中都有很多这样的组件使用，在美团发布过的文章中[《高性能队列——Disruptor》](https://tech.meituan.com/2016/11/18/disruptor.html) 还有一个对应的压测数据。CPU:Intel Core i7-2720QM，JVM:Java 1.6.0_25 64-bit，OS:Ubuntu 11.04
| - | ABQ | Disruptor |
| :----------------- | :-------- | :--------- |
| Unicast: 1P – 1C | 4,057,453 | 22,381,378 |
| Pipeline: 1P – 3C | 2,006,903 | 15,857,913 |
| Sequencer: 3P – 1C | 2,056,118 | 14,540,519 |
| Multicast: 1P – 3C | 260,733 | 10,860,121 |
| Diamond: 1P – 3C | 2,082,725 | 15,295,197 |
- 依据并发竞争的激烈程度的不同，Disruptor比ArrayBlockingQueue吞吐量快4~7倍。
---
另外，Log4j 2 采用了 Disruptor（一种无锁的线程间通信库），提高吞吐量降低延迟。在生产使用中，大并发的系统注意 Log4j 版本。官网说明：[https://logging.apache.org/log4j/2.12.x/manual/async.html](https://logging.apache.org/log4j/2.12.x/manual/async.html)
- **异步 Logger**是 Log4j 2 中的新增功能。其目的是尽快从对 Logger.log 的调用返回到应用程序。您可以选择使所有 Logger 异步，或使用同步和异步 Logger 的混合。使所有 Logger 异步将提供最佳性能，而混合使用则可为您提供更大的灵活性。
- **LMAX Disruptor 技术**。异步记录器内部使用 [Disruptor（](https://logging.apache.org/log4j/2.12.x/manual/async.html#UnderTheHood)一种无锁的线程间通信库）而不是队列，从而实现更高的吞吐量和更低的延迟。
- 作为异步日志记录器工作的一部分，**异步附加器**已得到增强，可以在批处理结束时（当队列为空时）刷新到磁盘。这会产生与配置“immediateFlush=true”相同的结果，即所有收到的日志事件始终在磁盘上可用，但效率更高，因为它不需要在每个日志事件上都接触磁盘。（异步附加器在内部使用 ArrayBlockingQueue，不需要类路径上的 Disruptor jar。）
---
### Md Road Map Docker Deploy Project (`docs/md/road-map/docker-deploy-project.md`)
---
title: Docker 部署项目
lock: need
---
# Docker 部署项目
作者：小傅哥
**看看是不你也遇到了这些问题**
云服务器选什么系统、云服务器怎么安装环境、Intellij IDEA 怎么连接云服务器、云服务器安装了 Docker 本地电脑还用安装吗、SpringBoot 项目怎么部署到云服务器、构建的镜像推送不到 Docker Hub 怎么办？
等等，一些列的问题，把小白拦截在云服务器的门外。不过，没关系，今天小傅哥就帮你把这接腿🦵🏻的事办啦，让你以后畅通无阻。
>文末提供了，5个AI项目、5个业务项目、8个组件项目、1套源码项目，还有非常多的学习资料，你可以全部获取学习，积累来自互联网大厂的经验。
## 零、所需资源
- [购买云服务器 2c4g](http://618.gaga.plus/)
- [工程案例代码 xfg-dev-tech-docker-deploy](https://github.com/fuzhengwei/xfg-dev-tech-docker-deploy)
- [云服务器安装脚本](https://gaga.plus/app/dev-ops/index.html)
- [云服务器连接工具](https://origin.bugstack.cn/md/road-map/tool.html)
- [阿里云docker镜像仓库](https://cr.console.aliyun.com/cn-hangzhou/instance/repositories)
## 一、云服务器是什么？
在使用云服务器之前，我们先来理解下云服务器是什么，把定位搞清楚，后面的事才好办。如图；
- 云服务器，你可以理解为是你的书桌上摆着的2台电脑。你可以通过其中一台电脑，以 SSH 方式连接另外一台电脑，并在另外一台电脑安装 MySQL、Redis、Ollama 等，以减轻当前这台电脑的压力。让手里的这台电脑只负责代码开发，需要什么资源就连接另外一台电脑的上软件即可。
- 现在为了方便的让每个人都可以拥有自己的另外一台电脑，有一些公司就把电脑集中起来搭建成了服务器机房，在通过提供公网IP让你在购买云服务器后，可以用你的电脑连接上云服务器电脑，进行软件的部署和程序对软件的连接。
## 二、云服务器咋操作（命令）
当然，云服务器的操作也需要一点 Linux 命令的知识，它不是那种`点点点`的方式使用电脑，而是通过命令行。比如，`ls` 查看文件列表、`mkdir` 创建文件夹、`chmod +x` 给文件授予执行权限，当然也有些死鬼告诉你执行 `rm -rf /*` 今天一天都不用干活！
为了，让小伙伴们，先不需要看非常的多的资料，就能快速的使用起这些命令。这里小傅哥做了个模拟 Linux 服务器，进行命令练习的网页，你可以通过页面的模拟建立 SSH 连接，之后学习这些命令。
地址：[https://gaga.plus/app/dev-ops/tutorials/what-is-a-cloud-server.html](https://gaga.plus/app/dev-ops/tutorials/what-is-a-cloud-server.html)
说明：你每点击一个右侧的命令，他就会在左侧进行输入，之后提示命令的用途和效果。这些命令包括了常用的文件、目录、系统、用户的操作，也给大家增加了 Git、Docker、Maven 的命令（右侧往下翻即可）
## 三、云系统环境安装
### 1. 环境选择
在你首次购买和设置云服务器的时候，它会让你选择需要安装的系统（也可以重置重新安装），安装完成后你就可以通过命令操作，部署 Docker 以及安装软件了。
这里比较推荐 Centos 7.6、7.9 或则 Ubuntu 24+，这两个系统，我已经做好了一键安装脚本，可以让你非常方便的把 Docker 以及一些常用的软件，全部安装完成。
### 2. 安装脚本
#### 2.1 Git 安装
**Centos**
```java
sudo yum install git
```
**Ubuntu**
```java
# sudo apt update
# sudo apt install nodejs npm
# node -v
# npm -v
```
```java
apt-get install git
```
#### 2.2 Docker + Portainer
```java
root@iv-ydw2iok0lcbw80bxaha0:~# ls
root@iv-ydw2iok0lcbw80bxaha0:~# cd /
root@iv-ydw2iok0lcbw80bxaha0:/# mkdir dev-ops
root@iv-ydw2iok0lcbw80bxaha0:/# ls
bin cdrom etc lib64 media proc sbin sys var
bin.usr-is-merged dev home lib.usr-is-merged mnt root sbin.usr-is-merged tmp
boot dev-ops lib lost+found opt run srv usr
root@iv-ydw2iok0lcbw80bxaha0:/# cd dev-ops/
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops# ls
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops# git clone https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install.git
Cloning into 'xfg-dev-tech-docker-install'...
remote: Enumerating objects: 181, done.
remote: Counting objects: 100% (35/35), done.
remote: Compressing objects: 100% (21/21), done.
remote: Total 181 (delta 20), reused 25 (delta 14), pack-reused 146 (from 1)
Receiving objects: 100% (181/181), 12.51 MiB | 1.26 MiB/s, done.
Resolving deltas: 100% (75/75), done.
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops# ls
xfg-dev-tech-docker-install
```
- 推荐；git clone https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install.git
- 备用；git clone https://github.com/fuzhengwei/xfg-dev-tech-docker-install.git
- 在 Linux 系统的根目录，通过命令创建一个空文件夹，进入文件夹，通过 git clone 检出代码。
- 这里有2个地址，如果 github.com 检出很慢，可以使用 gitcode.com 地址检出。
```java
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install# chmod +x ubuntu_run_install_docker_local.sh
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install# ./ubuntu_run_install_docker_local.sh
[INFO] 使用本地Docker安装脚本: ubuntu_install_docker.sh
[INFO] 设置可执行权限...
[INFO] 开始执行Docker安装脚本...
[INFO] 注意：安装过程可能需要root权限，如果需要会自动请求
-----------------------------------------------------------
[INFO] docker 环境安装脚本 By xiaofuge，建议使用 https://618.gaga.plus 优惠购买服务器，安装 Ubuntu 24.04 LTS 系统。
[INFO] 开始安装 Docker 环境...
[INFO] 检查系统信息...
内核版本: 6.8.0-55-generic
操作系统: Ubuntu 24.04 LTS
[INFO] 检测网络连接状态...
[INFO] 网络连接正常，可以访问: https://www.baidu.com
[INFO] 网络连接检测通过
...
Status: Downloaded newer image for registry.cn-hangzhou.aliyuncs.com/xfg-studio/portainer:latest
1c2d6211944ced359ebec2e5d28b9cf30eec55bc781b386838c54abc944ed1f3
[INFO] Portainer安装成功！
[WARNING] 重要提示：请确保您的云服务器已开放9000端口！
-----------------------------------------------------------
Portainer访问方式：
1. 通过公网访问：http://您的服务器公网IP:9000
2. 首次访问需要设置管理员账号和密码
3. 登录后即可通过Web界面管理Docker容器
-----------------------------------------------------------
[INFO] 您可以使用Portainer来方便地管理Docker容器、镜像、网络和卷等资源
```
- Centos 执行 `chmod +x centos_run_install_docker_local.sh` `./centos_run_install_docker_local.sh`
- Ubuntu 执行 `chmod +x ubuntu_run_install_docker_local.sh` `./ubuntu_run_install_docker_local.sh`
执行的中间，他会有一些提示你的操作，你可以按照提示输入之后继续运行就好。安装到最后，Docker + Portainer 就安装完成了。注意，云服务器的访问，需要开放对应的端口在云服务器的安全组中找到出入站配置（也可以在云服务器官网搜，他都会提供文档）。
#### 2.3 软件安装（JDK、Maven）可选
在 xfg-dev-tech-docker-install 一键安装脚本中，还有提供 JDK、Maven 的安装。这个软件安全是为了在云服务器直接构建 Java 项目，如果你不需要，是完全可以不用安装的。
**Centos 安装**
```
/* Detailed source-code truncated for AI context efficiency. */
```
```java
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment# ls
jdk maven
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment# cd maven/
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment/maven# ls
apache-maven-3.8.8.zip install-maven.sh remove-maven.sh
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment/maven# chmod +x install-maven.sh
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment/maven# ./install-maven.sh
[INFO] 开始Maven安装程序...
[INFO] 检测到系统: Ubuntu 24.04
[INFO] 检测到Java版本: 1.8.0_472
[INFO] 检查并安装依赖包...
[SUCCESS] Maven包验证通过
[INFO] 开始安装Maven 3.8.8 到: /usr/local/maven
[INFO] 解压Maven包...
[SUCCESS] Maven解压完成
[INFO] 配置环境变量...
[SUCCESS] 环境变量配置完成
[INFO] 环境变量已在当前会话中生效
[INFO] 验证安装...
[SUCCESS] Maven安装成功!
```
**Ubuntu 安装**
```java
sudo apt update
sudo apt install openjdk-8-jdk
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment# java -version
openjdk version "1.8.0_472"
OpenJDK Runtime Environment (build 1.8.0_472-8u472-ga-1~24.04-b08)
OpenJDK 64-Bit Server VM (build 25.472-b08, mixed mode)
```
```java
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment/maven# apt install maven
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following packages were automatically in
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment/maven# mvn --version
Apache Maven 3.8.7
Maven home: /usr/share/maven
...
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-install/environment/maven# cd /usr/share/maven
root@iv-ydw2iok0lcbw80bxaha0:/usr/share/maven# ls
bin boot conf lib man
root@iv-ydw2iok0lcbw80bxaha0:/usr/share/maven# cd conf
root@iv-ydw2iok0lcbw80bxaha0:/usr/share/maven/conf# ls
logging m2.conf settings.xml toolchains.xml
```
Ubuntu 基本通过 apt 就可以完整这些软件的安装了。注意进入 conf 替换 settings.xml 文件带有阿里云 maven 镜像的地址。
地址：[https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install/blob/main/environment/maven/apache-maven-3.8.8/conf/settings.xml](https://gitcode.com/Yao__Shun__Yu/xfg-dev-tech-docker-install/blob/main/environment/maven/apache-maven-3.8.8/conf/settings.xml)
#### 2.4 软件安装（MySQL、Redis）
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 执行提供好的脚本，即可完成各项软件的安装。其他的软件，也可以搜索教程安装。
### 3. 应用配置
- 云服务器环境 Docker + Portainer（管理docker的软件） 以及软件安装完成后，你就可以在你的 IntelliJ IDEA 的程序里配置对应的连接信息了。这样你的本地就可以连接到云服务器上的 Docker 里安装的 MySQL 了。
- Docker 是非常常用的软件，也是非常好用的软件，对于开发学习部署和卸载各类软件都非常方便，不会破坏本地环境。
## 四、项目部署
Docker 部署项目需要的是程序的镜像，镜像的目的是把一个程序运行所需的各类环境都给打包进行，等运行部署的时候直接执行即可。
所以，这里我们会通过各种方式来完成镜像的构建和部署，包括；
| 方案 | 复杂度 |
| ------------------------------------------------------------ | ------ |
| 本地打包Jar + 云上构建镜像。 | ⭐️⭐️ |
| 云上打包Jar + 云上构建镜像。 | ⭐️⭐️⭐️ |
| 本地打包Jar + 本地构建镜像 + 上传到阿里云 Docker 镜像仓库 + 云上拉取构建 | ⭐️⭐️⭐️⭐️ |
### 1. 文件配置
#### 1.1 dockerfile
```java
# 基础镜像 openjdk:8-jre-slim
FROM registry.cn-hangzhou.aliyuncs.com/xfg-studio/openjdk:8-jre-slim
# 作者
MAINTAINER xiaofuge
# 配置
ENV PARAMS=""
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 添加应用
ADD target/xfg-dev-tech-docker-deploy-app.jar /xfg-dev-tech-docker-deploy-app.jar
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /xfg-dev-tech-docker-deploy-app.jar $PARAMS"]
```
- 这里配置了构建镜像的地址信息。
#### 1.2 build.sh
```java
# 普通镜像构建，随系统版本构建 amd/arm
docker build -t system/xfg-dev-tech-docker-deploy-app:1.0-SNAPSHOT -f ./Dockerfile .
# 兼容 amd、arm 构建镜像
# docker buildx build --load --platform liunx/amd64,linux/arm64 -t xiaofuge/xfg-frame-archetype-app:1.0 -f ./Dockerfile . --push
```
- 配置了构建镜像的名称。
### 2. 构建镜像
#### 2.1 本地打包Jar + 云上构建镜像
##### 2.1.1 打包jar
- 在本地 install 构建项目 jar，target 目录下可以只保留项目的 jar 其他的删掉就可以。
##### 2.1.2 上传jar
- 把本地构建的jar，通过 sftp 把整个 xfg-dev-tech-deploy-app 上传到云服务器。
##### 2.1.3 构建镜像
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 通过这样的方式就把整个镜像构建出来，`docker images` 可以查看镜像列表，system/xfg-dev-tech-docker-deploy-app:1.0-SNAPSHOT 就是咱们构建的镜像。
#### 2.2 云上打包Jar + 云上构建镜像
##### 2.2.1 拉取项目
```java
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-deploy# ls
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-deploy# git clone https://github.com/fuzhengwei/xfg-dev-tech-docker-deploy.git
Cloning into 'xfg-dev-tech-docker-deploy'...
remote: Enumerating objects: 176, done.
remote: Counting objects: 100% (176/176), done.
remote: Compressing objects: 100% (87/87), done.
remote: Total 176 (delta 23), reused 175 (delta 22), pack-reused 0 (from 0)
Receiving objects: 100% (176/176), 75.84 KiB | 40.00 KiB/s, done.
Resolving deltas: 100% (23/23), done.
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-deploy# ls
xfg-dev-tech-docker-deploy
```
- 通过 git clone 命令，拉取项目。
##### 2.2.2 打包jar
```java
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-deploy/xfg-dev-tech-docker-deploy# ls
docs pom.xml README.md xfg-dev-tech-docker-deploy-app
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-deploy/xfg-dev-tech-docker-deploy# mvn clean install
[INFO] Scanning for projects...
Downloading from central: https://repo.maven.apache.org/maven2/org/springframework/boot/spring-boot-starter-parent/2.7.12/spring-boot-starter-parent-2.7.12.pom
...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary for xfg-dev-tech-docker-deploy 1.0-SNAPSHOT:
[INFO]
[INFO] xfg-dev-tech-docker-deploy ......................... SUCCESS [ 0.219 s]
[INFO] xfg-dev-tech-docker-deploy-app ..................... SUCCESS [05:29 min]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 05:29 min
[INFO] Finished at: 2025-12-21T10:56:57+08:00
[INFO] ------------------------------------------------------------------------
root@iv-ydw2iok0lcbw80bxaha0:/dev-ops/xfg-dev-tech-docker-deploy/xfg-dev-tech-docker-deploy# ls
docs pom.xml README.md xfg-dev-tech-docker-deploy-app
```
- 进入到项目，通过 `mvn clean install` 打包项目 jar
##### 2.2.3 构建镜像
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 这样，就在云服务器把项目镜像构建出来了。
#### 2.3 阿里云 DockerHub
##### 2.3.1 账号申请
官网：[https://cr.console.aliyun.com/cn-hangzhou/instance/dashboard](https://cr.console.aliyun.com/cn-hangzhou/instance/dashboard)
- 如图所示，申请账号，创建个人的命名空间。步骤3、4可选。
- 之后你这里可以手动操作上传镜像，也可以走下面的流程自动操作。
##### 2.3.2 上传镜像
- 在项目下，有一个 push.sh 文件，可以把镜像推送到阿里云 DockerHub 镜像库。这样操作的目的是有个统一地方来维护镜像，各个云服务器都可以拉取部署了。
- 推送后，可以到仓库查看镜像 [https://cr.console.aliyun.com/cn-hangzhou/instance/repositories](https://cr.console.aliyun.com/cn-hangzhou/instance/repositories)
### 3. 项目部署
#### 3.1 脚本说明
- 这里的镜像名称，要修改成你的镜像名称。
#### 3.2 上传脚本
- 上传项目下的部署脚本到云服务器，dev-ops 创建个文件夹。
#### 3.3 执行部署
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 部署后，就可以访问服务看最终的效果了！**
---
### Md Road Map Docker Idea (`docs/md/road-map/docker-idea.md`)
---
title: Docker IntelliJ IDEA
lock: need
---
# Docker WEB IntelliJ IDEA —— 随时随地打开浏览器就能写代码！
作者：小傅哥
**死鬼，我就知道你有很多办法！**
嘿嘿，是的，小傅哥又给你带来一个新方法：”在 Linux 安装一个 IntelliJ IDEA！“ 并且可以在线执行代码、构建项目、打包程序。这不美滋滋，尤其是对有学习项目诉求的伙伴，不就可以随时随地学习自己的项目了吗！
>好啦，接下来小傅哥就带着你安装下。文末提供了本次安装的相关脚本。
## 一、前置说明
- 一台云服务器，最低 2c4g [https://618.gaga.plus](https://618.gaga.plus ) —— 价格比较实惠。
- 安装 Docker、Docker Compose 教程：[https://bugstack.cn/md/road-map/docker.html](https://bugstack.cn/md/road-map/docker.html)
```java
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://dc.j8.work", "https://docker.1panel.live"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
```
- 如果拉取镜像失败，可以配置下以上地址。
## 二、安装脚本
- 地址：[https://gitcode.net/KnowledgePlanet/xfg-dev-tech-docker-idea](https://gitcode.net/KnowledgePlanet/xfg-dev-tech-docker-idea)
- 说明：小傅哥这里为你提供了搭建 Docker IDEA 的操作脚本，并配有 JDK、Maven，这样可以更加方便我们构建项目。
## 三、执行安装
### 1. 上传脚本
- 下载项目后，把本地的配置文件传到云服务器端。注意是 root 目录下。也就是 `~` 这里。
### 2. 解压文件
#### 2.1 jdk
```java
[root@lavm-aqhgp9nber java]# tar -zxvf jdk-8u202-linux-x64.tar.gz
```
- 这个解压后是为了映射到 Docker IntelliJ IDEA 下的。
#### 2.2 maven
```java
[root@lavm-aqhgp9nber maven]# unzip apache-maven-3.8.8.zip
```
- 可选不非得加压，因为我们可以直接把 `maven .m2` 下的 `settings.xml` 映射到 Docker IntelliJ IDEA 下。
```java
[root@lavm-aqhgp9nber maven]# ls -a
. .. apache-maven-3.8.8.zip install-maven.sh .m2 remove-maven.sh
```
### 3. 授权文件
```java
chmod -R 777 projector-user/
```
- 给整个文件夹包括文件夹下的其他文件一起授权。
- 授权后检查当前文件夹 `projector-user` 和文件夹以下的 java、maven 文件夹。
### 4. 执行安装
```java
# 命令执行 docker-compose -f docker-compose.yml up -d
# 以下这些都可以做 WEB IDEA 安装。在下面替换就可以。
# docker pull registry.jetbrains.team/p/prj/containers/projector-clion
# docker pull registry.jetbrains.team/p/prj/containers/projector-datagrip
# docker pull registry.jetbrains.team/p/prj/containers/projector-goland
# docker pull registry.jetbrains.team/p/prj/containers/projector-idea-c
# docker pull registry.jetbrains.team/p/prj/containers/projector-idea-u
# docker pull registry.jetbrains.team/p/prj/containers/projector-phpstorm
# docker pull registry.jetbrains.team/p/prj/containers/projector-pycharm-c
# docker pull registry.jetbrains.team/p/prj/containers/projector-pycharm-p
version: '3.9'
services:
intellij-idea:
image: registry.jetbrains.team/p/prj/containers/projector-idea-c
container_name: intellij-idea
ports:
- "8887:8887"
volumes:
- ~/projector-user:/home/projector-user
- ~/projector-user/maven/.m2/settings.xml:/home/projector-user/.m2/settings.xml
tty: true
stdin_open: true
restart: unless-stopped # 这将确保容器在失败时自动重启
```
- 执行脚本 `docker-compose -f docker-compose.yml up -d`
- 安装完成后记得在云服务器开放端口 `8887`
### 5. 测试项目
- 通过 `git clone` 检出项目地址 github/gitee/gitcode ，这样在projector-user 下就可以看到你的项目了。
- 这个是用于 WEB IDEA 打开的项目，当然也可以在 WEB IDEA 创建信息项目。
## 四、访问测试
地址：[http://117.72.37.243:8887/](http://117.72.37.243:8887/)
- 接下来你就可以在网页端，操作自己的项目了，想怎么玩就怎么玩，和本地效果是一样的。
- 这对于新人伙伴学习编程太有用了，直接在云服务器都能打包部署了。
---
### Md Road Map Docker Install (`docs/md/road-map/docker-install.md`)
---
title: Docker 环境配置（一键安装）
lock: need
---
# Docker 环境配置（一键安装）
作者：小傅哥
**啥是云服务器？**
云服务器，就等同于自己的另外一个电脑💻，在另外一台电脑部署 redis、mysql、mq等，本地电脑连接过去使用。尤其是 Windows 电脑用户，真心建议搞个云服务器，否则你会浪费非常多的时间这套 Windows 适配问题。
这样有了云服务器，就可以不用嚯嚯本地电脑了，安装了卸，卸了安装，把自己本机电脑环境弄的乱码起糟，全是费时费力的事。有这精力，不如用一台云服务器部署环境，开发完成项目后，再上线云服务器。既节省本地电脑资源，又锻炼了云服务器操作，起步一举两得！
不过，放心！别担心你不会用云服务器，因为小傅哥已经给你准备了一件安装云服务器环境的脚本，和各类部署环境和构建项目的视频。**即使是小卡拉米，也能跟着学习下来。**
> 🧧小傅哥还提供了非常多的编程实战项目，包括；业务的、组件的、AI的、源码的、轮子的，可以关注公众号「bugstack虫洞栈」回复「星球」加入。
## 一、优惠云服务器地址
- 购买地址：[https://618.gaga.plus](https://618.gaga.plus)
- 购买地址：[https://618.gaga.plus](https://618.gaga.plus)
- 购买地址：[https://618.gaga.plus](https://618.gaga.plus)
**我适合买哪个服务器？**
- 2c2g 1年，28￥，可部署一套 docker、mysql、redis、SpringBoot 单体项目，用于替代本地电脑的环境部署。
- 2c4g 1年（非常推荐3年），109￥，可部署一套 docker、mysql、redis、rabbitmq、xxl-job、SpringBoot 分布式微服务项目。
- 2c8g 1年，328￥，适合部署小傅哥星球社群[大部分项目](https://bugstack.cn/md/zsxq/material/student-learn-advanced.html)，可以完成多个微服务项目部署。
注意📢：购买选择系统时，推荐系统镜像，**centos 7.9**
>如果自己账号不是新人身份，可以自己注册个新账号，用家里人JD扫码认证一下即可。
🎁 礼物赠送，购买2c4g 3年的，赠送Joy公仔，邮寄到家！购买后，联系小傅哥（微信：fustack）
## 二、一键部署脚本
小傅哥，这里为你准备一键安装 Docker 环境的脚本文件，你可以非常省心的完成 Docker 部署。使用方式如下。
- **地址**：
- **地址**：
本文档介绍如何执行项目中的各个脚本，包括权限设置和执行步骤。
### 1. 上传脚本&设置权限
- ssh 工具，推荐 termius。[https://bugstack.cn/md/road-map/tool.html](https://bugstack.cn/md/road-map/tool.html) 免费的就够用，带有 sftp 工具。
- 左侧是云服务器空间 root 下，右侧是本地环境。可以把整个文件夹全部拖到云服务器。
- 另外，也可以在云服务器执行 `sudo yum install git` 安装 Git，通过 git clone 拉取脚本。
在执行任何脚本之前，需要先为脚本文件添加可执行权限：
```
# 为所有脚本添加可执行权限
chmod +x environment/jdk/install-java.sh
chmod +x environment/jdk/remove-java.sh
chmod +x run_install_docker_local.sh
chmod +x run_install_software.sh
chmod +x install-maven.sh
chmod +x remove-maven.sh
```
或者一次性为所有脚本添加权限：
```
find . -name "*.sh" -type f -exec chmod +x {} \;
```
### 2. JDK 安装脚本
#### 2.1 安装 JDK
脚本位置： environment/jdk/install-java.sh
功能： 支持安装 JDK 8 和 JDK 17
执行方式：
```
# 交互式安装（推荐）
sudo ./environment/jdk/install-java.sh
# 指定版本安装
sudo ./environment/jdk/install-java.sh -v 8 # 安装 JDK 8
sudo ./environment/jdk/install-java.sh -v 17 # 安装 JDK 17
# 强制安装（覆盖已有安装）
sudo ./environment/jdk/install-java.sh -f -v 8
# 静默安装
sudo ./environment/jdk/install-java.sh -q -v 8
# 自定义安装目录
sudo ./environment/jdk/install-java.sh -d /opt/java -v 8
```
注意事项：
- 需要 root 权限执行
- 脚本会提示手动下载 JDK 包到 /dev-ops/java 目录
- 支持的版本：JDK 8 (1.8.0_202) 和 JDK 17 (17.0.14)
- 安装完成后环境变量会自动配置
#### 2.2 卸载 JDK
脚本位置： environment/jdk/remove-java.sh
功能： 彻底清理 JDK 安装和环境配置
执行方式：
```
# 交互式删除（推荐）
sudo ./environment/jdk/remove-java.sh
# 强制删除
sudo ./environment/jdk/remove-java.sh -f
# 静默删除
sudo ./environment/jdk/remove-java.sh -f -q
# 指定安装目录删除
sudo ./environment/jdk/remove-java.sh -d /opt/java
# 删除时不备份配置文件
sudo ./environment/jdk/remove-java.sh --no-backup
```
注意事项：
- 需要 root 权限执行
- 会自动备份配置文件（除非使用 --no-backup）
- 清理系统和用户级环境变量配置
### 2.3 Maven 安装脚本
#### 2.3.1 安装 Maven
脚本位置：`environment/maven/install-maven.sh`
功能：自动安装 Apache Maven 3.8.8
执行方式：
```bash
# 交互式安装（推荐）
sudo ./environment/maven/install-maven.sh
# 自定义安装目录
sudo ./environment/maven/install-maven.sh -d /opt/maven
# 使用本地Maven包
sudo ./environment/maven/install-maven.sh -p /path/to/apache-maven-3.8.8.zip
# 强制安装（覆盖已有安装）
sudo ./environment/maven/install-maven.sh -f
# 静默安装
sudo ./environment/maven/install-maven.sh -q
# 强制静默安装
sudo ./environment/maven/install-maven.sh -f -q
```
### 3. Docker 安装脚本
脚本位置： run_install_docker_local.sh
功能： 使用本地的 install_docker.sh 脚本安装 Docker
执行方式：
```
# 执行 Docker 安装
./run_install_docker_local.sh
```
注意事项：
- 脚本会自动检查 install_docker.sh 文件是否存在
- 如果需要 root 权限会自动请求
- 安装完成后会询问是否安装 Portainer 容器管理界面
- Portainer 访问地址： http://服务器IP:9000
### 4. 软件安装脚本
脚本位置： run_install_software.sh
功能： 使用 Docker Compose 安装各种开发软件
执行方式：
```
# 执行软件安装
sudo ./run_install_software.sh
```
支持的软件：
- nacos - 服务注册与发现
- mysql - 数据库
- phpmyadmin - MySQL 管理界面
- redis - 缓存数据库
- redis-admin - Redis 管理界面
- rabbitmq - 消息队列
- elasticsearch - 搜索引擎
- logstash - 日志处理
- kibana - 日志分析界面
- xxl-job-admin - 任务调度
- prometheus - 监控系统
- grafana - 监控面板
- ollama - AI 模型服务
- pgvector - 向量数据库
- pgvector-admin - 向量数据库管理界面
注意事项：
- 需要 root 权限执行
- 需要先安装 Docker 和 docker-compose
- 脚本会检查磁盘空间并显示预计占用
- 支持选择原始配置或阿里云镜像配置
- 可以多选软件进行批量安装
### 5. 常见问题
#### 5.1 权限问题
如果遇到权限拒绝错误：
```
# 确保脚本有执行权限
ls -la *.sh
# 如果没有 x 权限，重新添加
chmod +x script_name.sh
```
#### 5.2 环境变量生效
JDK 安装后，环境变量在当前会话中已生效，新开终端需要：
```
# 重新加载配置
source /etc/profile
# 或者重新登录
```
#### 5.3 Docker 相关
确保 Docker 服务正在运行：
```
# 检查 Docker 状态
sudo systemctl status docker
# 启动 Docker 服务
sudo systemctl start docker
```
### 6. 执行顺序建议
1. 首先安装 JDK （如果需要）：
```
sudo ./environment/jdk/install-java.sh -v 8
```
2. 然后安装 Docker ：
```
./run_install_docker_local.sh
```
3. 然后安装 Docker ：
```
./install-maven.sh
```
4. 最后安装开发软件 ：
```
sudo ./run_install_software.sh
```
按照以上步骤，您就可以成功执行所有脚本并搭建完整的开发环境。
### 7. 安装演示
#### 7.1 docker 安装
```java
[root@xiaofuge ~]# ls
run_install_docker_local.sh
[root@xiaofuge ~]# chmod +x run_install_docker_local.sh
[root@xiaofuge ~]# ./run_install_docker_local.sh
```
- 执行完 `./run_install_docker_local.sh ` 全程会自动化安装，如果已经过 docker 会提示是否卸载。使用起来非常方便。
#### 7.2 软件安装
```java
[root@xiaofuge dev-ops]# ls
install_docker.sh README.md run_install_docker_local.sh run_install_docker.sh run_install_software.sh software
[root@xiaofuge dev-ops]# chmod +x run_install_software.sh
[root@xiaofuge dev-ops]# ls
install_docker.sh README.md run_install_docker_local.sh run_install_docker.sh run_install_software.sh software
```
- 安装时候可以选择需要安装的软件，重复安装也会提示卸载。
---
### Md Road Map Docker What (`docs/md/road-map/docker-what.md`)
---
title: Docker 是什么？
lock: need
---
# Docker 是什么？
作者：小傅哥
**那 Docker 是什么呢？**
Docker 是什么，其实来自于 Docker 的图标已经说明。Docker 的图标是一条鲸鱼 🐳一样的大船，上面摆放了很多集装箱。你可以把这些集装箱当做是一个个不同的应用程序，虽然不同但可以统一用一套集装箱（脚本命令）承载，并承放在统一一条大船上（环境上）。而且这些集装箱都有自己的编号ID（有自己的IP）互相隔离，不受影响。
Docker 是一个用于开发、发布和运行应用程序的开放平台。Docker 可让您将应用程序与基础架构分离，以便快速交付软件。借助 Docker，您可以像管理应用程序一样管理基础架构。通过利用 Docker 的发布、测试和部署代码方法，您可以显著减少编写代码和在生产中运行代码之间的延迟。
官网：[https://www.docker.com/](https://www.docker.com/)
文档：[https://docs.docker.com/get-started/docker-overview/](https://docs.docker.com/get-started/docker-overview/)
## 一、Docker 安装在哪
Docker 可以安装在 Windows + wsl2、Mac、Linux，支持 ARM、AMD 架构。它可以通过软件下载安装和执行脚本命令安装，也可以通过云服务器提供的镜像直接购买云服务器时选择使用。我们可以看下 Docker 和虚拟机安装在操作系统上的关系来了解 Docker 的安装位置。
与虚拟机的安装使用相比，Docker 会把应用所需的依赖、函数库、甚至其他的软件应用可以一起打包成一个镜像，这样在应用程序运行时，就可以直接调用本地函数库，然后和 Linux 内核进行通信。有了这样的设计，你也就不需要关心每一个应用所需的环境都是啥了，也不用为每一个应用安装各类环境到 Linux 或者虚拟机了。也就做到了跨系统的运行。这有点类似于 Java 的 JVM 虚拟机。
- 本地安装：[https://www.docker.com/](https://www.docker.com/) - 下载 Mac、Windows 你需要的版本进行安装。
- 云服务器：[https://bugstack.cn/md/road-map/docker.html](https://bugstack.cn/md/road-map/docker.html) - centos 7.9 其他的也都类似操作即可。
>安装完成后都可以通过命令操作，安装、部署、卸载软件。文末提供了教程链接。
## 二、Docker 怎么工作
Docker 为了屏蔽软件使用差异，会统一对这些软件进行镜像打包，把一个软件所需的各类环境都打包到镜像中。我们在使用的时候，就是使用各类平台提供好的软件镜像，进行服务部署。同样的我们也可以作为镜像提供方，把我们的应用程序 SpringBoot、React、VUE 等，打包成镜像，让我们在其他地方，如云服务器进行部署。或者提供给全网的人员，进行部署使用。
如图，这是一整套的，本地拉取镜像、部署环境、开发代码、发布镜像，再到云服务器拉取镜像、部署项目和环境的过程。在这个过程中，我们也可以借助于如 Github Action 完成镜像的构建和发布，还可以在云服务器上直接构建镜像，减少了拉取拉取的过程。
> 你可以理解为，Docker 就是一个中心和一个客户端，中心管理镜像，客户端拉取使用或者构建发布镜像。
## 三、Docker 命令说明
Docker 的操作是通过脚本命令配置和执行完成使用，不过不用害怕命令😱，命令是最简单、直接、可靠的方式。当你习惯命令以后，你会很喜欢它，并且知道只要执行这个命令就一定会有结果，而不像被软件包装后，不确定是软件的问题还是命令的问题。
Docker 安装软件分为直接使用和通过 Docker Compose 脚本。直接使用如；`docker run -d --restart=always --name portainer -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer` 这条命令会自动拉取和执行脚本。不过对于更大的项目部署，Docker Compose 脚本更好用。
- 如图，是整个 Docker Compose 在配置一套执行脚本后，各个脚本的核心用途。当然 Docker Compose 还有不少的命令，比如容量的限制、端口的处理、默认的命令等，都是可以操作的，凡是你想的合理的，它都可以支持。
- 特别注意，安装到云服务器的docker部署的应用，外部访问需要走公网IP:Port端口，之后这个端口要在安全组打开。这样就类似于你再本地自己的电脑发，访问另外一台电脑上的服务了。
- 如果在使用中遇到其他命令不理解的，可以让 [openai](https://openai.itedus.cn) 解释。
## 四、Docker 实操教程
此外，为了大家更好的使用 Docker 搭建各类环境，小傅哥为大家准备好了文档和视频。可以放心食用。
- 文档：[https://bugstack.cn/md/road-map/docker.html](https://bugstack.cn/md/road-map/docker.html) - 这是一个系列，你可以从左侧目录选择阅读。
- 视频：[https://www.bilibili.com/video/BV1xw411W7xf](https://www.bilibili.com/video/BV1xw411W7xf) - 对应一整套的视频，手把手操作。
---
### Md Road Map Docker (`docs/md/road-map/docker.md`)
---
title: Docker 环境配置（手动安装）
lock: need
---
# Docker 环境配置（手动安装）
作者：小傅哥
```
- 安装指定版本，例如：`yum install -y docker-ce-25.0.5 docker-ce-cli-25.0.5 containerd.io`
### 7. 安装Docker-Compose
#### 7.1 正常安装
**官网地址**
```shell
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
```
**镜像地址**
```shell
# 指定路径【推荐】
sudo curl -L https://gitee.com/fustack/docker-compose/releases/download/v2.24.1/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
# 设置权限
sudo chmod +x /usr/local/bin/docker-compose
```
#### 7.2 离线安装
```shell
# 下载；docker-compose-`uname -s`-`uname -m` 查看版本；https://github.com/docker/compose/releases/tag/v2.18.1
# 重命名
mv docker-compose-linux-x86_64 docker-compose
# 加入执行权限
sudo chmod +x /usr/local/bin/docker-compose
# 查看docker-compose版本
docker-compose -v
```
```java
sudo chmod +x /usr/local/bin/docker-compose
docker-compose -v
Docker Compose version v2.18.1
```
- 安装后就可以使用 compose 命令了；`docker-compose -f environment-docker-compose.yml up -d`
### 8. 启动Docker并添加开机自启动
```java
[root@CodeGuide ~]# sudo systemctl start docker
```
- 启动 Docker
```java
[root@CodeGuide ~]# systemctl enable docker
```
- 设置开机启动 Docker
```java
sudo systemctl restart docker
```
- 重启 Docker 命令
### 9. 查看 Docker 版本
```java
[root@CodeGuide ~]# docker --version
Docker version 20.10.11, build dea9396
```
### 10. 卸载 Docker
```java
[root@CodeGuide ~]# sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine
```
### 11. Docker 常用命令
```java
[root@CodeGuide ~]# docker --help #Docker帮助
[root@CodeGuide ~]# docker --version #查看Docker版本
[root@CodeGuide ~]# docker search #搜索镜像文件，如：docker search mysql
[root@CodeGuide ~]# docker pull #拉取镜像文件， 如：docker pull mysql
[root@CodeGuide ~]# docker images #查看已经拉取下来的所以镜像文件
[root@CodeGuide ~]# docker rmi #删除指定镜像文件
[root@CodeGuide ~]# docker run --name -p 80:8080 -d #发布指定镜像文件
[root@CodeGuide ~]# docker ps #查看正在运行的所有镜像
[root@CodeGuide ~]# docker ps -a #查看所有发布的镜像
[root@CodeGuide ~]# docker rm #删除执行已发布的镜像
```
### 12. 设置国内源
1. 【推荐】1panel 提供了镜像源 [https://status.1panel.top/status/docker](https://status.1panel.top/status/docker) - `直接进去就可以找到最新的镜像源`
2. 阿里云提供了镜像源：[https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors](https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors) - 登录后你会获得一个专属的地址。
使用以下命令来设置 Docker 国内源：- 或者你可以通过 `vim /etc/docker/daemon.json` 进入修改添加 registry-mirrors 内容后重启 Docker
```yaml
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://***替换为你的地址***.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
```
可用镜像检测：[https://status.1panel.top/status/docker](https://status.1panel.top/status/docker)
#### 12.1 本地Docker软件配置
```yaml
{ "registry-mirrors" : [
"https://docker.1panel.live",
"https://dc.j8.work",
"https://docker.m.daocloud.io"
],
"builder": {
"gc": {
"enabled": true,
"defaultKeepStorage": "20GB"
}
},
"experimental": false,
"features": {
"buildkit": true
}
}
```
这个命令会创建一个 `/etc/docker/daemon.json` 文件，并将国内源的配置写入其中。然后你只需要重启 Docker 服务即可使配置生效，可以通过运行 `sudo systemctl restart docker` 命令来重启 Docker 服务。
**解决目前Docker Hub国内无法访问方法**
自从2023年5月中旬，著名Docker 容器平台：`hub.docker.com` “不知” 何种原因国内均无法正常访问了。
这样对国内服务器拉取Docker仓库影响比较大。不过得亏国内有Docker Hub镜像平台。有付费的，有免费的！
#### 12.2 Linux 配置 Docker 镜像
```yaml
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": [
"https://docker.1panel.live",
"https://dc.j8.work",
"https://docker.m.daocloud.io",
"https://dockerproxy.com",
"https://docker.mirrors.ustc.edu.cn",
"https://docker.nju.edu.cn"
]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
```
- 参考链接：https://cloud.tencent.com/developer/article/2301228
### 13. 远程连接 - 不推荐
```shell script
vim /lib/systemd/system/docker.service
```
```shell script
[Unit]Description=Docker Application Container Engine
Documentation=http://docs.docker.com
After=network.target
Wants=docker-storage-setup.service
Requires=docker-cleanup.timer
[Service]
Type=notify
NotifyAccess=main
EnvironmentFile=-/run/containers/registries.conf
EnvironmentFile=-/etc/sysconfig/docker
EnvironmentFile=-/etc/sysconfig/docker-storage
EnvironmentFile=-/etc/sysconfig/docker-network
Environment=GOTRACEBACK=crash
Environment=DOCKER_HTTP_HOST_COMPAT=1
Environment=PATH=/usr/libexec/docker:/usr/bin:/usr/sbin
ExecStart=/usr/bin/dockerd-current \
--add-runtime docker-runc=/usr/libexec/docker/docker-runc-current \
--default-runtime=docker-runc \
--exec-opt native.cgroupdriver=systemd \
--userland-proxy-path=/usr/libexec/docker/docker-proxy-current \
--init-path=/usr/libexec/docker/docker-init-current \
--seccomp-profile=/etc/docker/seccomp.json \
-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock \
$OPTIONS \
$DOCKER_STORAGE_OPTIONS \
$DOCKER_NETWORK_OPTIONS \
$ADD_REGISTRY \
$BLOCK_REGISTRY \
$INSECURE_REGISTRY \
$REGISTRIES
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity
TimeoutStartSec=0
Restart=on-abnormal
KillMode=process
[Install]
WantedBy=multi-user.target
```
- 添加：`-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock \`
```shell script
# 加载
systemctl daemon-reload
# 重启
systemctl restart docker
# 测试
curl http://127.0.0.1:2375/info
```
- 之后你就可以打开 IDEA 的 Services 配置 Docker 了；`tcp://180.76.138.**:2375` 验证连接后就可以使用了。
### 14. 卸载Docker
```shell
/Applications/Docker.app/Contents/MacOS/Docker --uninstall
```
---
### Md Road Map Draw.Io (`docs/md/road-map/draw.io.md`)
---
title: draw.io + ai agent
lock: need
---
# draw.io + ai Agent，确实打开新思路
作者：小傅哥
**Ai Agent 会结合到各个场景！**
可以想象，将来我们使用的各种工具，都会很方便的以标准的协议方式结合到 AI Agent 智能体。这就像小傅哥，25年，年初开始做 Ai Agent 时，对一个智能体的执行过程，是需要自己进行分析，设计，实现的（`那时候我就在讲，Agent 也会出标准框架`）。到了年中的时候 Google ADK 除了 0.1.0 最初的版本，年尾发布了 0.4.0，这个框架提供了构建智能体的最基本框架，可以整合 Spring AI、Langchain4j 快速构建智能体。
>Spring AI、Langchain4j 提供的是 AI 封装能力，Google ADK 提供的是 Agent 执行能力（并行、循环、串行）的组装和使用。
未来（甚至不会太久），各个软件与 Ai Agent 的对接会变得非常容易，你手里用到的各项软件，都可以很方便的添加上智能体的能力。就像，我们现在用到的 `trae.ai`、`Cursor`，在以后 Ai Agent 基础能力成熟后，在结合 `Visual Studio Code` 给出软件对接标准协议，那么任何一个人都可以快速的搭建出一个智能体编码工具。除此之外，其他的软件也都会逐步提供出这样的能力。
扩展的思路分析完毕，小傅哥这次先带着大家了解下，draw.io 是怎么与 Ai 结合使用的。
>🧧 文末提供了小傅哥所有编程实战项目获取方式，一次加入即可获得19个已完结的和本次新开展的。
## 一、关于 draw.io
draw.io 是一个用于绘制通用图表的 JavaScript 客户端编辑器。
官网：[https://www.drawio.com/](https://www.drawio.com/)
代码：[https://github.com/jgraph/drawio](https://github.com/jgraph/drawio)
我所有的这类的绘图，都来自于使用 draw.io 完成（[bugstack.cn](https://bugstack.cn) 还有很多绘图）。它可以下载到本地使用，也可以在网页使用。如果你是开发人员，还可以使用它的开发组件引入到自己的程序中进行使用。也正因如此，有了 Ai Agent 能力的结合，一种是通过 MCP，另外一种是直接通过扩展功能，直接在 draw.io 二开上完成。接下来小傅哥会分别介绍这两种方式以及使用。
## 二、MCP 方式对接
MCP（Model Context Protocol）是用于解决 AI 与服务接口通信的标准模型上下文协议，该协议通过标准化通信方式，使AI应用程序能够访问和使用实时数据、执行操作，从而克服了模型训练数据的局限性。 你可以将MCP想象成AI应用程序的“USB-C接口”，它提供了一个标准化的方法，让AI模型能够连接各种外部资源。
**Draw.io Model Context Protocol (MCP) Server**，就是基于此协议实现的对接 Draw.io 的 MCP 服务。我们可以使用这样一套服务，把 AI 与 Draw.io 建立起使用链接。
源码：[https://github.com/lgazo/drawio-mcp-server](https://github.com/lgazo/drawio-mcp-server)
### 1. 插件安装
- 谷歌浏览器：[https://chromewebstore.google.com/detail/drawio-mcp-extension/okdbbjbbccdhhfaefmcmekalmmdjjide](https://chromewebstore.google.com/detail/drawio-mcp-extension/okdbbjbbccdhhfaefmcmekalmmdjjide)
- 火狐浏览器：[https://addons.mozilla.org/en-US/firefox/addon/drawio-mcp-extension/](https://addons.mozilla.org/en-US/firefox/addon/drawio-mcp-extension/)
安装完成后，可以看到这样一个小插件（右侧插件文件里可以点击让常驻浏览器），之后后面可以等着使用（继续下面的步骤）。
### 2. 配置服务
```java
{
"mcpServers": {
"drawio": {
"command": "npx",
"args": [
"-y",
"drawio-mcp-server"
]
}
}
}
```
#### 2.1 trae.ai - 也可以其他的
#### 2.2 spring ai
### 3. 使用服务
首先打开：[https://app.diagrams.net/#](https://app.diagrams.net/)
- 对接上之后，你就可以在右侧提问了。之后他就可以实时的出设计图。`受限于MCP服务对接，它不是在 Draw.io 上扩展，会缺少一些交互和判断，画图有时候会有重叠。`
- 不过，这个方式的好处是，你可以结合自己的代码，拖进去，让它直接出架构图、流程图、模型图等。之后在自己做一些调整。
## 三、软件方式使用
现在 Github 上有很多基于 Draw.io 的二次开发，结合了 Ai 的能力，这里小傅哥找到一个做这块功能比较早的，next-ai-draw-io 来演示给大家。感兴趣的伙伴，还可以结合代码做二次开发。
这是一个基于 Next.js 的 Web 应用程序，它将 AI 功能与 draw.io 图表集成在一起。该应用程序允许您通过自然语言命令和 AI 辅助可视化来创建、修改和增强图表。
### 1. 代码下载
代码：[https://github.com/DayuanJiang/next-ai-draw-io](https://github.com/DayuanJiang/next-ai-draw-io)
```java
git clone https://github.com/DayuanJiang/next-ai-draw-io.git
```
下载代码后，注意修改配置文件。
### 2. 启动工程
- 进入 package.json 点击绿色箭头执行启动。
### 3. 访问项目
- 访问 http://localhost:6002 这样你就可以提问来让它绘制图了。这个效果还不错。
---
### Md Road Map Dubbo (`docs/md/road-map/dubbo.md`)
---
title: Dubbo
lock: need
---
# Dubbo 使用教程和原理分析
作者：小傅哥
- 关于通信，就引入了 RPC 框架，而 Dubbo 就是其中的一个实现方式。
- 那为啥用 Dubbo 呢？其实核心问题就一个，为了提高通信效率。因为 Dubbo 的底层通信是 Socket 而不是 HTTP 所以通信的性能会更好。同时 Dubbo 又有分布式的高可用设计，在一组部署了交易服务的实例宕机后，会被从注册中心摘除，之后流量会打到其他服务上。
## 二、要怎么使用
Dubbo 的使用分为2方，一个是接口的提供方，另外一个是接口的调用方。接口的提供方需要提供出被调用方使用接口的描述性信息。这个信息包括：接口名称、接口入参、接口出参，只有让调用方拿到这些信息以后，它才能依托于这样的接口信息做一个代理操作，并在代理类中使用 Socket 完成双方的信息交互。
所以你看上去调用 RPC 接口好像和使用 HTTP 也没啥区别，无非就是引入了 POM 配置，之后再配置了注解就可以使用了。但其实，它是把你的 Jar 当做代理的必要参数使用了。**本文也会介绍，具体是怎么代理的**
## 三、使用的案例
对于编程的学习来说，其实最开始的那一下，不是搞明白所有原理，而是先让自己可以看到运行出来的效果。哎，之后就去分析原理，这样会舒服的多。
所以小傅哥这里提供了一套简单的 Dubbo 使用案例，只要你满足最基本的配置条件，就可以运行出效果；
1. JDK 1.8
1. Maven 3.x - jdk1.8支持的就可以
2. Dubbo 3.1.4 - POM 中已经配置，与2.x最大的使用上的区别就是一些注解的使用
3. Zookeeper 3.4.x - 如果你只是按照本文中的直连模式测试，那么不安装 Zookeeper 也可以
### 1. 接口提供方
工程案例创建结构，采用的是 DDD 结构。但和 DDD 一点关系没有。如果你对工程创建有疑惑，可以参考 [《Java 简明教程》之 DDD 架构](https://bugstack.cn/md/road-map/ddd.html)
#### 1.1 接口定义
**源码**：`cn.bugstack.dev.tech.dubbo.api.IUserService`
```java
public interface IUserService {
Response queryUserInfo(UserReqDTO reqDTO);
}
```
- 接口定义平平无奇，但第1个坑暗藏玄机！
- 也就是，所有的 Dubbo 接口，出入参，默认都需要继承 Serializable 接口。也就是 UserReqDTO、UserResDTO、Response 这3个类，都得继承 Serializable 序列化接口。
#### 1.2 接口实现
**源码**：`cn.bugstack.dev.tech.dubbo.trigger.rpc.UserService`
```java
@Slf4j
@DubboService(version = "1.0.0")
public class UserService implements IUserService {
@Override
public Response queryUserInfo(UserReqDTO reqDTO) {
log.info("查询用户信息 userId: {} reqStr: {}", reqDTO.getUserId(), JSON.toJSONString(reqDTO));
try {
// 1. 模拟查询【你可以从数据库或者Redis缓存获取数据】
UserResDTO resDTO = UserResDTO.builder()
.userId(reqDTO.getUserId())
.userName("小傅哥")
.userAge(20)
.build();
// 2. 返回结果
return Response.builder()
.code(Constants.ResponseCode.SUCCESS.getCode())
.info(Constants.ResponseCode.SUCCESS.getInfo())
.data(resDTO).build();
} catch (Exception e) {
log.error("查询用户信息失败 userId: {} reqStr: {}", reqDTO.getUserId(), JSON.toJSONString(reqDTO), e);
return Response.builder()
.code(Constants.ResponseCode.UN_ERROR.getCode())
.info(Constants.ResponseCode.UN_ERROR.getInfo())
.build();
}
}
}
```
- 接口实现平平无奇，但第2个坑暗藏玄机！
- Dubbo 的实现接口，需要被 Dubbo 自己管理。所以 Dubbo 提供了 @DubboService 注解。有些小卡拉米，使用的是不是 Spring 的 @Service 呀？尤其是以前的 Dubbo 版本 `2.7.*` 它的注解也是 @Service 也不留神就用成了 Spring 的 @Service。一个小bug，又调了一上午。
#### 1.3 工程配置
**application.yml**
```java
dubbo:
application:
name: xfg-dev-tech-dubbo
version: 1.0.0
registry:
address: zookeeper://127.0.0.1:2181 # N/A - 无zookeeper可配置 N/A 走直连模式测试
protocol:
name: dubbo
port: 20881
scan:
base-packages: cn.bugstack.dev.tech.dubbo.api
```
- 配置信息平平无奇，但第3个坑暗藏玄机！
- base-packages 扫描的是哪里配置了 Dubbo 的 API 入口，给它入口就行，它会自己找到实现类。但！你要知道 Java 的 Spring 应用能扫描到，能被 Spring 管理，那么 pom 要**直接或者间接**的引导到定义了 Dubbo 的模块。
- 再有一个问题，Spring 应用开发，讲究约定大于配置。你 Application 应用的包名，应该是可以覆盖到其他包名的。比如 Application 都配置到 `cn.bugstack.dev.tech.dubbo.a.b.c.d.*` 去了，它默认就扫不到 `cn.bugstack.dev.tech.dubbo.api` 了。一个小bug，一下午又过去了。
- 注意：address：如果配置的是 N/A 就是不走任何注册中心，就是个直连，主要用于本地验证的。如果你配置了 zookeeper://127.0.0.1:2181 就需要先安装一个 zookeeper 另外，即使你配置了注册中心的方式，也可以直连测试。
#### 1.4 应用构建
以上信息都准备了，一群小卡拉米开始掉到第4个坑里了！
你有2个应用，一个Dubbo接口提供方、一个Dubbo接口使用方。那么你在给你另外一个应用使用接口的时候，你在 InelliJ IDEA 的 Maven 中执行 Install 了吗？
Install 是干啥的？它是为了让你使用了同一个本地 Maven 配置的应用，可以引入到对方提供的 Jar 包。你 Install 以后，这个 Jar 包就会进入到本地 Maven 仓库了。如果是公司里开发，会有专门的自己家部署的，私有Maven中心仓库，就可以通过 deploy 把本地 Jar 发布上去，那么公司里的伙伴，也就都可以引用了。
- 你要先点击 root 下的 install 操作，这样就会自动构建了。
- 如果你电脑配置有点低，也会出现一些`气人怪相`，比如就刷不进去，install 了也引用不了。记得要 clean 清空下，也可以直接到 maven 文件夹去清空。
### 2. 接口使用方
有些小卡拉米觉得前面的坑都扫干净了，就完事了。没有接下来还有坑，让你一搞搞一天，半夜也睡不好。
#### 2.1 POM 引入
```xml
cn.bugstack
xfg-dev-tech-dubbo-api
1.0-SNAPSHOT
```
- POM 的配置，就是把 Jar 包给引用进来。因为 Dubbo 需要根据这个接口，做一个代理操作。**不引入，你代码就爆红啦！爆红啦！🌶**
#### 2.2 消费配置
**源码**：`application.yml`
```java
dubbo:
application:
name: xfg-dev-tech-dubbo
version: 1.0.0
registry:
address: zookeeper://127.0.0.1:2181
# address: N/A
protocol:
name: dubbo
port: 20881
```
- 配置了 zookeeper 你就用第一个，代码中对应 `@DubboReference(interfaceClass = IUserService.class, version = "1.0.0")`
- 配置了 N/A 你就用第二个，代码中必须指定直连。`@DubboReference(interfaceClass = IUserService.class, url = "dubbo://127.0.0.1:20881", version = "1.0.0")`
#### 2.3 代码配置
**源码**：`cn.bugstack.dev.tech.dubbo.consumer.test.ApiTest`
```java
// 直连模式；@DubboReference(interfaceClass = IUserService.class, url = "dubbo://127.0.0.1:20881", version = "1.0.0")
@DubboReference(interfaceClass = IUserService.class, version = "1.0.0")
private IUserService userService;
@Test
public void test_userService() {
UserReqDTO reqDTO = UserReqDTO.builder().userId("10001").build();
Response resDTO = userService.queryUserInfo(reqDTO);
log.info("测试结果 req: {} res: {}", JSON.toJSONString(reqDTO), JSON.toJSONString(resDTO));
}
```
**测试结果**
```java
2023-07-08 15:37:22.291 INFO 62481 --- [ main] c.b.d.tech.dubbo.consumer.test.ApiTest : 测试结果 req: {"userId":"10001"} res: {"code":"0000","data":{"userAge":20,"userId":"10001","userName":"小傅哥"},"info":"成功"}
2023-07-08 15:37:22.324 INFO 62481 --- [tor-Framework-0] o.a.c.f.imps.CuratorFrameworkImpl : backgroundOperationsLoop exiting
```
- 如果不出啥意外，到这你就可以直接启动运行了。并看到测试结果。
- 但别忘记了，你启动的时候，需要先启动 xfg-dev-tech-dubbo 让接口提供方跑起来。
## 四、原理的分析
都说 Jar 是提供可描述性信息的，对方才能代理调用。那么这个过程是怎么干的呢，总不能一问这个，就让小卡拉米们去手写 Dubbo 呀！所以小傅哥会通过最简单模型结构，让你了解这个 Dubbo 通信的原理，方便小卡拉米们上手。
- 如果所示，接口使用方，对接口进行代理。什么是代理呢，代理就是用一个包装的结构，代替原有的操作。在这个包装的结构里，你可以自己扩展出任意的方法。
- 那么，这里的代理。就是根据接口的信息，创建出一个代理对象，在代理对象中，提供 Socket 请求。当调用这个接口的时候，就可以对接口提供方的，发起 Socket 请求了。
- 而 Socket 接收方，也就是接口提供方。他收到信息以后，根据接口的描述性内容，进行一个反射调用。这下就把信息给请求出来，之后再通过 Socket 返回回去就可以了。
好，核心的原理就这么点。接下来，我们从代码中看看。
### 1. 接口反射 - 提供方
**源码**：`cn.bugstack.dev.tech.dubbo.trigger.socket.RpcServerSocket`
```
/* Detailed source-code truncated for AI context efficiency. */
```
这段代码主要提供的功能包括：
1. Netty Socket 启动一个服务端。
2. 注入 ApplicationContext applicationContext 用于在接收到请求接口信息后，获取对应的 Bean 对象。
3. 根据请求来的 Bean 对象，以及参数的必要信息。进行接口的反射调用。
4. 最后一步，就是把接口反射请求的信息，再通过 Socket 返回回去。
### 2. 接口代理 - 调用方
打开工程：[xfg-dev-tech-dubbo-test](https://gitcode.net/KnowledgePlanet/road-map/xfg-dev-tech-dubbo-test)
**源码**：`cn.bugstack.dev.tech.dubbo.consumer.config.RPCProxyBeanFactory`
```
/* Detailed source-code truncated for AI context efficiency. */
```
这段代码主要提供的功能包括：
1. 实现 `FactoryBean` 为的是把这样一个代理对象，交给 Spring 容器管理。
2. 实现 Runnable 接口，并在接口中，创建 Netty 的 Socket 客户端。客户端中接收来自服务端的消息，并临时存放到缓存中。**注意 Dubbo 中这块的处理会复杂一些，以及请求同步响应通信，这样才能把各个接口的调动记录下来**
3. `getObject()` 对象中，提供代理操作。代理里，就可以自己想咋搞咋搞了。而 Dubbo 也是在代理里，提供了如此的操作，对接口提供方发送请求消息，并在超时时间内返回接口信息。因为反射调用，需要你`提供类`、`方法`、`入参类型`、`入参内容`，所以我们要把这些信息传递给接口提供方。
### 3. 服务测试 - 消费验证
- 启动 xfg-dev-tech-dubbo
- 测试 xfg-dev-tech-dubbo-test
```java
@Resource(name = "rpcProxyBeanFactory")
private IUserService proxyUserService;
@Test
public void test_proxyUserService(){
UserReqDTO reqDTO = UserReqDTO.builder().userId("10001").build();
Response resDTO = proxyUserService.queryUserInfo(reqDTO);
log.info("测试结果 req: {} res: {}", JSON.toJSONString(reqDTO), JSON.toJSONString(resDTO));
}
```
**测试结果**
```java
2023-07-08 16:14:51.322 INFO 74498 --- [ main] c.b.d.tech.dubbo.consumer.test.ApiTest : 测试结果 req: {"userId":"10001"} res: {"code":"0000","data":{"userAge":20,"userId":"10001","userName":"小傅哥"},"info":"成功"}
```
- 这里我们给 IUserService 注入一个自己代理好的对象，之后就可以调用验证了。
- 好啦，到这我们就把关于 Dubbo 的事交代明白了，以上内容较多。小卡拉米需要细细的品味吸收！
---
### Md Road Map Dump Mat (`docs/md/road-map/dump-mat.md`)
---
title: dump eclipse mat
lock: need
---
# Eclipse MAT 分析 Java heap space dump 日志
作者：小傅哥
-vm
/Library/Java/JavaVirtualMachines/jdk1.8.0_341.jdk/Contents/Home/bin
-keyring
~/.eclipse_keyring
```
- 如果遇到 `The JVM shared library "/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/bin/../lib/server/libjvm.dylib" does not contain the JNI_CreateJavaVM symbol.` 可以打开 Info.plist 添加 -vm 和 jdk 路径。
## 三、产生 dump 案例
首先你需要为你要运行的方法添加 VM Options 当你运行一个方法后，添加 JVM 配置，这样才能到处 dump
- `-Xms128M -Xmx128M -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=../xfg-dev-tech-dump/docs/dump`
- HeapDumpPath 为你的工程完成路径，到出到 dump 文件夹下。
- 运行方法后，就可以在 docs/dump 就可以看到产生的日志了。
### 1. 数据库查询
```java
SELECT * FROM user_order
limit 0, 2500000
@Test
public void test_java_heap_space_sql() throws InterruptedException {
while (true){
userOrderDao.queryPage();
}
}
```
### 2. 线程池过大
```java
@Test
public void test_thread_pool_java_heap_space() {
// 创建一个固定大小的线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
try {
// 不断提交占用大量内存的任务
for (int i = 0; i < Integer.MAX_VALUE; i++) {
executorService.submit(new MemoryHogTask());
}
} catch (OutOfMemoryError e) {
System.out.println("Caught OutOfMemoryError: " + e.getMessage());
} finally {
// 关闭线程池
executorService.shutdown();
}
}
static class MemoryHogTask implements Runnable {
@Override
public void run() {
try {
// 分配一个大数组来占用内存
int[] memoryHog = new int[1000000]; // 大约占用 4MB 内存
// 模拟一些计算以避免 JIT 优化掉内存分配
for (int i = 0; i < memoryHog.length; i++) {
memoryHog[i] = i;
}
// 保持任务在一定时间内占用内存
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
```
### 3. list 添加过多数据
```java
@Test
public void test_java_heap_space_list() throws InterruptedException {
List list = new ArrayList<>();
while (true) {
byte[] bytes = new byte[1024 * 1024 * 1024];
list.add(bytes);
TimeUnit.SECONDS.sleep(1);
}
}
```
- 这类场景是比较多的，比如我们做营销活动，要把很多的活动数据预热到缓存，如果 JVM 配置的比较低，是可能会出现 `Java heap space` 的。
## 四、Eclipse MAT 分析
### 1. 导入 dump 文件
### 2. 查看统计树
### 3. 排序对象
### 4. 引用关系
- 点击查看，被谁引用了。
### 5. 逐层分析 - 进入对象详情
- 看看这个 Object 值装的是什么。
### 6. 发现问题
- 看到了在检索数据库数据。其实前面就已经定义到哪里的方法导致，这里可以具体看到细节。
### 7. 其他分析
- 我们本案例采用的是 MySql 8.x 如果你使用其他线程池工具，还可能会返回具体的 SQL 语句一起打印出来。方便分析。
好啦，有了这样一个分析过程，你也可以尝试熟悉下工具，分析分析其他的 Java heap space 场景。几次玩下来也就熟悉这个工具了。
---
其他工具；[https://visualvm.github.io/](https://visualvm.github.io/)
---
### Md Road Map Dump Visualvm (`docs/md/road-map/dump-visualvm.md`)
---
title: dump VisualVM
lock: need
---
# VisualVM 分析 Java heap space dump 日志
作者：小傅哥
net.logstash.logback
logstash-logback-encoder
7.3
```
这个Jar是为了上报应用日志用的。工程的根目录下引入是定义版本，在 xfg-dev-tech-app 模块下引入是具体的引入。
#### 3.2 logback 采集
```yml
# logstash部署的服务器IP
logstash:
host: 127.0.0.1
```
```xml
${LOG_STASH_HOST}:4560
```
- LOG_STASH_HOST 通过占位符可以使用 yml 配置，这样方便后期动态调整。
## 四、应用测试
### 1. 启动应用&检测上报
```java
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
/**
* curl http://localhost:8091/api/ratelimiter/login?fingerprint=uljpplllll01009&uId=1000&token=8790
*/
@RequestMapping(value = "login", method = RequestMethod.GET)
public String login(String fingerprint, String uId, String token) {
log.info("模拟登录 login fingerprint:{}", fingerprint);
return "模拟登录：登录成功 " + uId;
}
}
```
- 地址：[http://0.0.0.0:5601/app/dev_tools#/console](http://0.0.0.0:5601/app/dev_tools#/console)
- 命令：`GET _cat/indices` - 通过命令检测日志上报
### 2. 配置日志
地址：[http://0.0.0.0:5601/app/discover](http://0.0.0.0:5601/app/discover)
#### 2.1 创建索引
- 当你的应用启动后，会上报数据。这个时候在点击 Discover 会提示你有可用的数据。
- 如图创建索引即可。
#### 2.2 回到监控
创建索引后，回到 Discover 即可查看监控日志。在这个阶段，你可以访问应用程序接口，查看上报日志信息；[http://localhost:8091/api/ratelimiter/login?fingerprint=uljpplllll01009&uId=1000&token=8790](http://localhost:8091/api/ratelimiter/login?fingerprint=uljpplllll01009&uId=1000&token=8790)
- 当你不断的访问接口，就可以看到上报的日志数据信息了。
---
### Md Road Map Fastjson (`docs/md/road-map/fastjson.md`)
---
title: fastjson
lock: need
---
# fastjson 使用
作者：小傅哥
map = new HashMap<>();
map.put("key1", "xfg");
map.put("key2", 123);
map.put("key3", false);
log.info(JSON.toJSONString(map));
}
@Test
public void test_json2map() {
String jsonString = "{\"key1\":\"xfg\",\"key2\":123,\"key3\":false}";
Map map = JSON.parseObject(jsonString, Map.class);
for (Map.Entry entry : map.entrySet()) {
log.info("{} : {}", entry.getKey(), entry.getValue());
}
}
```
- 有些时候我们接收的对象就是个 Map 那么你可以使用 fastjson 来对对象进行 map 的转换或者序列化
### 5. toString 处理
```java
@Test
public void testToString2Bean() throws Exception {
UserEntity userEntity = UserEntity.builder()
.amount(100D)
.userName("xfg")
.password("abc000")
.createTime(new Date())
.build();
log.info(userEntity.toString());
log.info(JSON.toJSONString(ToString2Bean.toObject(userEntity.toString(), UserEntity.class)));
}
public static T toObject(String str, Class clazz) throws Exception {
// 创建一个新的对象
T obj = clazz.getDeclaredConstructor().newInstance();
// 获取类对象
Class objClass = obj.getClass();
// 解析字符串
String[] fields = str.substring(str.indexOf("{") + 1, str.indexOf("}")).split(", ");
// 遍历成员变量
for (String field : fields) {
// 获取成员变量名和值
String[] parts = field.split("=");
// 获取成员变量对象
Field objField = objClass.getDeclaredField(parts[0].trim());
// 设置成员变量可以访问
objField.setAccessible(true);
// 设置成员变量的值
objField.set(obj, convertValue(objField.getType(), parts[1].trim()));
// 设置成员变量不可访问
objField.setAccessible(false);
}
return obj;
}
```
```java
06:03:46.302 [main] INFO cn.bugstack.xfg.dev.tech.test.ApiTest - UserEntity{userName='xfg', password='abc000', amount=100.0, createTime=2023-09-21 20:03:46}
06:03:46.670 [main] INFO cn.bugstack.xfg.dev.tech.test.ApiTest - {"password":"'abc000'","userName":"'xfg'","createTime":"21/09/2023"}
Process finished with exit code 0
```
- 有一些在方法入参的时候需要用日志打印入参信息。大部分时候都是直接用 json 打印对象，但对于一些较大对象就比较耗时。所以阿里的开发手册是建议这个场景使用 toString 操作。
- 但是 toString 操作后的日志不太便于，在本地进行测试验证。因为不好转对象。所以这里我们写个 toString2Bean 对象的方法。
---
### Md Road Map Frp (`docs/md/road-map/frp.md`)
---
title: Frp 内网穿透
lock: need
---
# Frp 内网穿透，用云服务器IP，教你搭一套内网穿透服务！
作者：小傅哥
**FRP 内网穿透是什么？**
内网穿透是一种技术手段，用于访问位于防火墙或路由器后面的本地网络（内网）中的设备或服务。通常情况下，内网中的设备无法直接通过公网（互联网）进行访问，从而实现隐私保护和安全性。内网穿透技术的目标是突破这一限制，使外部用户能够通过互联网访问内网中的服务或设备。
虽然市面也有一些内网穿透的服务，包括； `natapp`、`coplar`、`花生壳`等，如果你不想折腾，也可以直接使用。但折腾一下，往往会省钱！
## 1. 搭建脚本
这里小傅哥使用了 `fatedier/frp` 0.60 版本进行搭建，提供了相关的运行脚本。
- 地址：[https://gitcode.net/KnowledgePlanet/road-map/xfg-dev-tech-frp](https://gitcode.net/KnowledgePlanet/road-map/xfg-dev-tech-frp)
- 官网：[https://github.com/fatedier/frp](https://github.com/fatedier/frp)
### 1.1 frps - 服务端
```java
# https://github.com/fatedier/frp/blob/dev/conf/frps_full_example.toml
[common]
# 监听端口
bind_port = 7000
# 面板端口
dashboard_port = 7500
# 登录面板的账号密码（修改成自己的）
dashboard_user = admin
dashboard_pwd = admin
# token =
```
- token 如果设定了，需要保持客户端和服务端一致。
```java
# 命令执行 docker-compose -f docker-compose.yml up -d
version: '3.9'
services:
frps:
image: fatedier/frps:v0.60.0
hostname: frps
container_name: frps
volumes:
- "./config/frps.toml:/frps.toml"
command:
- "-c"
- "/frps.toml"
network_mode: "host"
```
- docker compose 按照脚本，走的是 `network_mode: "host"` 不需要额外指定端口。
- 你需要在云服务器开放 7000、7500 以及需要映射出去的端口。比如客户端配置了 8080、9001 也需要在云服务器开放端口，这样才能访问进来。
- 官网配置：[https://github.com/fatedier/frp/blob/dev/conf/frps_full_example.toml](https://github.com/fatedier/frp/blob/dev/conf/frps_full_example.toml) - 这里有很全的配置可以参考。
### 1.2 frpc - 客户端
```java
# 服务端地址 https://github.com/fatedier/frp/blob/dev/conf/frpc_full_example.toml
serverAddr = "117.72.37.243"
# 服务端配置的bindPort
serverPort = 7000
# token =
[[proxies]]
# 代理应用名称，根据自己需要进行配置
name = "xfg-dev-tech-01"
# 代理类型 有tcp\udp\stcp\p2p
type = "tcp"
# 客户端代理应用IP
localIP = "127.0.0.1"
# 客户端代理应用端口
localPort = 8080
# 服务端反向代理端口；提供给外部访问
remotePort = 8080
[[proxies]]
# 代理应用名称，根据自己需要进行配置
name = "xfg-dev-tech-02"
# 代理类型 有tcp\udp\stcp\p2p
type = "tcp"
# 客户端代理应用IP
localIP = "127.0.0.1"
# 客户端代理应用端口
localPort = 9001
# 服务端反向代理端口；提供给外部访问
remotePort = 9001
```
- `localPort = 8080` 是本地应用的端口。
- `remotePort = 8080` 是远程服务器要暴漏出去的端口，这个端口你可以按需调整。
```java
# 命令执行 docker-compose -f docker-compose.yml up -d
version: '3.9'
services:
frpc:
image: fatedier/frpc:v0.60.0
hostname: frpc
container_name: frpc
volumes:
- "./config/frpc.toml:/frpc.toml"
command:
- "-c"
- "/frpc.toml"
network_mode: "host"
```
- docker compose 安装，同样需要指定 `network_mode: "host"`
## 2. 执行安装
搭建FRP内网穿透需要一台云服务器，其实主要用的就是它的公网IP。不过现在的云服务器都非常便宜，36元就可以购买1年，还能抽取京豆。折算下来也就26元1年了！
- 专属价：[http://618.gaga.plus/](http://618.gaga.plus/)
- 云服务器使用：[https://bugstack.cn/md/road-map/docker.html](https://bugstack.cn/md/road-map/docker.html) - 已录制了相关 Docker、Portainer 环境安装，你可以直接对照操作。
### 2.1 frps - 云服务器安装
#### 2.1.1 上传文件
#### 2.1.2 执行脚本
```java
[root@lavm-aqhgp9nber frps]# docker-compose -f docker-compose.yml up -d
[+] Running 1/1
✔ Container frps Started
```
你可以进入📃查看启动日志；
```java
WARNING: ini format is deprecated and the support will be removed in the future, please use yaml/json/toml format instead!
2024-09-08 09:51:50.581 [I] [frps/root.go:105] frps uses config file: /frps.toml
2024-09-08 09:51:50.674 [I] [server/service.go:237] frps tcp listen on 0.0.0.0:7000
2024-09-08 09:51:50.674 [I] [frps/root.go:114] frps started successfully
2024-09-08 09:51:50.674 [I] [server/service.go:351] dashboard listen on 0.0.0.0:7500
2024-09-08 09:51:52.429 [I] [server/service.go:576] [cd9f610f66475f3a] client login info: ip [223.72.84.77:10816] version [0.60.0] hostname [] os [linux] arch [amd64]
2024-09-08 09:51:52.447 [I] [proxy/tcp.go:82] [cd9f610f66475f3a] [xfg-dev-tech-02] tcp proxy listen port [9001]
2024-09-08 09:51:52.448 [I] [server/control.go:399] [cd9f610f66475f3a] new proxy [xfg-dev-tech-02] type [tcp] success
2024-09-08 09:51:52.448 [I] [proxy/tcp.go:82] [cd9f610f66475f3a] [xfg-dev-tech-01] tcp proxy listen port [8080]
2024-09-08 09:51:52.448 [I] [server/control.go:399] [cd9f610f66475f3a] new proxy [xfg-dev-tech-01] type [tcp] success
```
#### 2.1.3 开放端口
- 进入云服务器防火墙，开放访问端口。
### 2.2 frpc - 本地安装客户端
#### 2.2.1 执行脚本
- 注意 frpc.toml 是配置服务器的ip和本机应用的ip信息。你需要修改 serverAddr 的 IP 地址，为你的服务器公网 IP 地址。
- 如果你的 IntelliJ IDEA 带有绿色箭头，且本机也安装了 Docker 那么可以直接安装 frpc 客户端。
#### 2.2.2 客户端日志
```java
2024-09-08 10:00:16.472 [I] [sub/root.go:142] start frpc service for config file [/frpc.toml]
2024-09-08 10:00:16.473 [I] [client/service.go:295] try to connect to server...
2024-09-08 10:00:16.533 [I] [client/service.go:287] [adab2679b41d410f] login to server success, get run id [adab2679b41d410f]
2024-09-08 10:00:16.534 [I] [proxy/proxy_manager.go:173] [adab2679b41d410f] proxy added: [xfg-dev-tech-01 xfg-dev-tech-02]
2024-09-08 10:00:16.550 [I] [client/control.go:168] [adab2679b41d410f] [xfg-dev-tech-01] start proxy success
2024-09-08 10:00:16.550 [I] [client/control.go:168] [adab2679b41d410f] [xfg-dev-tech-02] start proxy success
```
#### 2.2.3 服务端日志
- 客户端启动后，你可以进入到服务端 frps 查看日志，这个时候会注册进来客户端信息。
**你还可以进入 frp 管理后台查看**
地址：[http://117.72.37.243:7500/static/#/](http://117.72.37.243:7500/static/#/) - 修改为你的服务器ip进行访问。
- 这里也可以看到你注册上来的各项信息。
## 3. 测试验证
### 3.1 部署应用
在工程中提供了 xfg-dev-tech-app 的应用，你可以本地执行 docker 脚本进行镜像构建和部署。
- 如图，执行1、2、3步骤，打包、构建和部署应用。
### 3.2 访问验证
#### 3.2.1 本地访问
地址：[http://127.0.0.1:8080/api/test](http://127.0.0.1:8080/api/test)
#### 3.2.2 穿透访问
地址：[http://117.72.37.243:8080/api/test](http://117.72.37.243:8080/api/test)
## 4. 同类产品
- [EasyTier 一个简单、安全、去中心化的内网穿透 VPN 组网方案](https://www.easytier.top/)
---
### Md Road Map Git (`docs/md/road-map/git.md`)
---
title: Git
lock: need
---
# Git 使用说明和配置
作者：小傅哥
**Git的作用是什么？**
你可以想象下，当你有10个小伙伴都需要在一个 txt 文档里，写一份老师👩🏻🏫上课的笔记📒，把信息进行汇总、互相完善、用于课后学习。那么怎么保证大家做的课堂内容都能顺利的写在一份 txt 呢，而且不要互相删除，也不要丢失谁的信息呢？
这个就是 Git 的用途。Git 是一种分布式版本控制系统，用于高效地管理和跟踪源代码和文件的历史记录，支持多人协作开发及分支管理，提供可靠的版本回退和合并机制，从而提高开发效率和代码质量。
## 1. Git 起源故事
讲到 Git 就不得不提一下 Linux，因为如果没有 Linux 也就没有 Git 的诞生，这里是有一段 **10天** 写出 Git 的故事！
众所周知，Linus 于 1991年 创建了开源的 Linux，从此 Linux 系统不断发展壮大。但 Linux 的壮大是靠全世界热心的开发者参与的，不过这么多人在世界各地为 Linux 编写代码，那代码是如何管理的呢？事实是，2002 之前，合并代码的操作都是 Linux 老爷子自己手动合并的！
但 2000 年的时候，不是已经 [SVN](https://zh.wikipedia.org/wiki/Subversion) 可以使用了吗？但 Linus 坚决反对 CVS、SVN 这些集中式的管理工具，不仅速度差还得联网操作。虽然有商用版的功能好一些，但这与 Linux 开源精神不符。所以 Linus 就不用，看人家这开源精神！
不过到了 2002年，Linux 都发展10年了，在这么手动的合并代码，让社区的兄弟也苦不堪言，强烈反对。为此，林纳斯·托瓦兹（Linus Torvalds）决定使用 BitKeeper 作为 Linux 内核主要的版本控制系统用以维护代码。BitKeeper 的东家 BitMover 公司，看 Linux 开源的不容易，授权 Linux 社区免费使用这个版本控制系统。
哈哈哈，但好景不长！2005年，安德鲁·垂鸠（Andrew Tridgell）写了一个简单程序，可以连接 BitKeeper 的仓库，BitKeeper 著作权拥有者拉里·麦沃伊认为安德鲁·垂鸠对 BitKeeper 内部使用的协议进行逆向工程，决定收回无偿使用 BitKeeper 的许可。Linux 内核开发团队与 BitMover 公司进行磋商，但无法解决他们之间的歧见。林纳斯·托瓦兹决定自行开发版本控制系统替代 BitKeeper ，以10天的时间编写出 git 第一个版本！—— 牛皮！
有了 Git 以后，GitHub 平台也于2007年10月1日开始开发。网站于2008年2月以beta版本开始上线，4月份正式上线。GitHub 里面的项目可以通过标准的 Git 命令进行访问和操作。—— 这就是 Linux、Git、Github 的故事。
## 2. 软件安装
Git 是一个软件工具，在使用前需要进行安装。
- 地址：[https://git-scm.com/downloads](https://git-scm.com/downloads) - `选择需要的版本下载` 网盘资源：[https://www.alipan.com/s/LqwsNfHRx54](https://www.alipan.com/s/LqwsNfHRx54) - `也提供了 Git 软件，在 dev-ops -> 环境 -> git 下`
- 演示：[https://learngitbranching.js.org/](https://learngitbranching.js.org/) - `可直接查看动画效果，引导式学习Git命令操作。`
**配置代理**
```java
git config --global http.proxy ip:port
git config --global https.proxy ip:port
```
- 如果你有代理地址可以配置
### 2.1 Mac
```java
# 如果你没有 brew 命令，则需要先安装下；https://brew.sh/index_zh-cn
brew install git
```
### 2.2 Windows
- [32-bit Git for Windows Setup](https://github.com/git-for-windows/git/releases/download/v2.41.0.windows.1/Git-2.41.0-32-bit.exe)
- [64-bit Git for Windows Setup](https://github.com/git-for-windows/git/releases/download/v2.41.0.windows.1/Git-2.41.0-64-bit.exe)
### 2.3 Linux
#### Debian/Ubuntu
获取适用于您的 Debian/Ubuntu 版本的最新稳定版本
**如果没有安装npm可以安装**
```
# sudo apt update
# sudo apt install nodejs npm
# node -v
# npm -v
```
**安装git**
```
# apt-get install git
```
对于 Ubuntu，此 PPA 提供最新的稳定上游 Git 版本
```
# add-apt-repository ppa:git-core/ppa
# apt update; apt install git
```
#### Centos
```java
sudo yum install git
```
## 3. 配置账户
当你拿到一个Git的仓库（Github、Gitcode、Gitee、GitLab），让你克隆（git clone）代码的时候，不要`虾呵呵`的上去就点个zip下载。
- zip 下载的代码，只是当前分支的，下载后用 IntelliJ IDEA 打开也没有 Git 标识，不能进行仓库的pull、push、checkout等操作。
- 另外对于一些工程内容比较大的项目，直接 zip 下载还可能会失败。
>你要做都是配置账户 ssh 秘钥，或者下载的时候输入 git 仓库账号密码（目前很多仓库为了安全，不在支持账号密码方式下载代码了。）
**注意**：gitcode.com、github.com 都需要创建访问令牌当做账号密码的密码使用。而不是直接使用账号里你设置的那个密码。
如 [https://gitcode.com/setting/token-classic](https://gitcode.com/setting/token-classic)
### 1. 配置git账户
```java
[root@lavm-aqhgp9nber ~]# git config --global user.name "fuzhengwei"
[root@lavm-aqhgp9nber ~]# git config --global user.email "184172133@qq.com"
```
- 用户名和邮箱，更换为你的代码库注册使用的名称和邮箱📮。
### 2. 创建ssh秘钥
```java
[root@lavm-aqhgp9nber ~]# ssh-keygen -t rsa -C "184172133@qq.com"
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:lgf+3a1srOvDD0znv+/jiR3iwMaZtxW94k9FI1HzJAk 184172133@qq.com
The key's randomart image is:
+---[RSA 2048]----+
| Eoo+.|
| ooo|
| . . .o|
| . o ..o|
| S . . ..o|
| . oo+o+ .+|
| .O+=o=.|
| . Bo@+o|
| .+@*BB|
+----[SHA256]-----+
```
- 命令：`ssh-keygen -t rsa -C "184172133@qq.com"`
- 操作：一路敲回车同意就可以了。
### 3. 获取ssh秘钥
```java
[root@lavm-aqhgp9nber ~]# cat /root/.ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC7eYQiDe46Jq5CJ6vXtIiM0hxUKKgCoSFIkSQucsZoLjhW53guxmZ0aR+gUZb/M8Xgrk9WMxc32KqQasFy0xPo86Hxagd40fPz+XdwOyokEJC5He6F1********CkATF2YgEdtcRW2RPICjtLr*******DWkS8ez 184172133@qq.com
```
- 命令：`ssh-keygen -t rsa -C "184172133@qq.com"`
- 操作：`Your public key has been saved in /root/.ssh/id_rsa.pub.` 按照提示地址，获取 pub 公钥。如果是linux就通过 cat 获取。如果是本机电脑就按照路径打开。如，我的地址（你要更换为你的）：`cat /Users/fuzhengwei/.ssh/id_rsa.pub`
- 注意：`.ssh` 点开头的文件夹是隐藏文件，Windows/Mac 都可以设置查看隐藏文件。Windows 是设置里配置，Mac 是通过 `Shift + Command + .` 开启和关闭查看隐藏文件。
### 4. 配置ssh秘钥
#### 4.1 gitcode.net
- 秘钥配置地址：[https://gitcode.net/-/profile/keys](https://gitcode.net/-/profile/keys)
#### 4.2 github.com
- 秘钥配置地址：[https://github.com/settings/keys](https://github.com/settings/keys)
---
其他的各个代码库平台也都类似，找到配置 ssh 秘钥的地方，把 id_rsa.pub 内容填充进去即可。
## 4. 检出代码 - 命令
通过在公司工作，大家会说检出代码，不会说下载。因为检出对应的是 git clone 命令，而下载是 http 直接点击链接。在我们使用一些图形化的 git 界面操作代码检出的时候，走的也是 git clone 命令。
### 4.1 检出地址
- 地址：选择工程的 ssh 地址，这个是你配置 ssh 秘钥后的检出方式。
### 4.2 检出命令
#### 4.2.1 默认检出（master）
```java
git clone git@github.com:fuzhengwei/openai-code-review.git
```
- 你可以复制你需要的工程地址进行检出。
#### 4.2.2 指定分支
```java
git clone -b 240720-xfg-init-project git@github.com:fuzhengwei/openai-code-review.git
```
- 添加 `-b 分支名`，可以指定分支名称检出。
#### 4.2.3 其他命令
- git branch：查看当前工程分支
- git branch -r：查看远程分支列表
- git pull：拉取分支最新代码
- git push：推送本地变更的代码。【这样的操作有图形化界面，更方便】
- git fetch：获取远程仓库最新分支变动，这个很有用。在你想操作分支创建新或者看其他人的分支时候，先操作下 git fetch 看下最新的分支变动。
- git merge origin/master：将远程分支的 master 代码合并到本地分支 master 上。【类似这样的操作有图形化界面，点击即可】
## 5. 检出代码 - IntelliJ IDEA
IntelliJ IDEA 本身就提供了 Git 的图形化操作，也是最简单最常用的方式。只要你的代码是通过 Git 检出的，那么通过配置 Git 的 IntelliJ IDEA 打开工程，就会自动的被 Git 管理。
### 5.1 配置 Git
- 像是 Mac 电脑会自动默认的配置好 IntelliJ IDEA Git 直接使用即可，如果你的电脑在 IntelliJ IDEA 打开工程后，提示没有 Git 则可进入设置手动配置。
- 配置后，点击 Test 可以测试出 Git 的版本。
### 5.2 检出代码
#### 5.2.1 方式1；打开工程前
#### 5.2.2 方式2；打开工程后
- 打开工程后，也可以通过菜单栏中的 Git 进行检出操作。
### 5.3 图形界面
#### 5.3.1 分支使用
#### 5.3.2 提交代码
#### 5.3.3 查看记录
#### 5.3.4 查看对比
- 这个代码对比非常适合代码评审，也可以用于自己学习代码。可以知道任意两个分支的代码差异，也就知道了代码上一次是什么样，这一次是做了什么开发。
#### 5.3.5 合并分支
在公司中很多时候是大家一起在一个工程开发代码，那么这个时候就会涉及合并代码的。如果有多人共同开发一个接口方法，就会在合并的时候产生冲突。所以要特别注意。
注意，📢在Git中，`merge`和`rebase`是两种用于合并分支变更的方法。每种方法都有其特定的用途和行为：
Merge
- **概念**: `merge`命令用于将一个分支的更改合并到当前分支，通常会生成一次新的合并提交（commit），从而保留分支历史。
- **历史记录**: 使用`merge`会保留所有开发历史记录，包括分支点，这使得历史记录图呈现出一个分叉和合并的树状结构。
- **使用场景**:
- 当你想保留完整的历史记录，了解如何以及何时进行了分支。
- 通常用于将分支合并到主分支(如`main`或`master`)时，以保留分支的历史上下文。
- **命令**:
```bash
git checkout main
git merge feature-branch
```
Rebase
- **概念**: `rebase`命令用于重新定位一系列的提交，可以将分支上的更改申请到另一分支的顶端，因而能得到更线性的历史。
- **历史记录**: Rebase重新写了提交历史（改变了提交的父提交），这会导致更线性的提交历史，从而更清晰，但会丢失分支合并信息。
- **使用场景**:
- 当你希望提交历史更加简洁和线性。
- 合并特性分支到主分支前用以避免杂乱的分支合并历史。
- 需要小心在共享分支上使用，因为重写的提交历史会影响他人。
- **命令**:
```bash
git checkout feature-branch
git rebase main
```
选择何时使用
- **Merge**适合用于保持完整的提交历史，不改变现有提交的哈希。
- **Rebase**适合用于清理提交历史，通常在提交尚未推送至共享存储库时使用。
一般情况下，对于已对外分享的分支，尤其是共享存储库中的`main`或`master`分支，尽量避免使用`rebase`。而对于个人开发的特性分支，`rebase`可以帮助维护一个清晰的提交历史。
**普通合并**
- 在实际的开发中，大家承接新的需求，会从master拉一个新的分支。拉取后，开始编写代码，完成开发后提交。
- 之后切换到master分支，通过把自己的开发的分支合并回master分支进行提交。
- 注意：如果多人开发，同时修改一个类，可能会引起合并冲突，这个审核要点开类，查看冲突进行合并，不要把自己和他人的代码合并丢失。
**冲突合并**
1. 选择，你要从哪个分支合并到 test 分支。右键选择 Merge into test
2. 如果你合并到test分支的代码，有其他人也在同一行做了改变或者格式化了代码，就会弹出一个合并冲突。这个时候你需要点 Merge 进行合并。
3. 在点击 Merge 后，你会看到具体冲突的代码是什么，你可以有选择的从左右合并到中，最后点击 Apply。这个时候要注意不要把让别人的代码合并丢喽。
4. 合并完的代码，不要直接 push，你要先本地 install 看是否可以打包。以及如果可以运行的话，可以本地先跑一下。 最后 push 提交合并代码即可。
#### 5.3.6 回滚分支
回滚提交和回滚push
如果出现了合并代码冲突后，丢失了代码，那么这个时候一般要进行回滚操作，重新合并。
虽然 Git 提供了回滚代码的功能，但一定要谨慎使用。怎么谨慎？第一个谨慎就是 push 的代码一定确保可以构建和运行，否则不要 push！第二个谨慎是要回滚代码，需要和团队中对应的伙伴打招呼，避免影响别人测试或者上线。
1. 先选择要在哪个分支的哪次提交上进行回滚。这里选择的是 test 分支上的提交进行回滚。
2. 这里选择 Hard 回滚。因为我们所有的都是合并到 test 分支，所以 test 分支丢失也没问题。可以重新合并。但要和同组伙伴提前说明。
3. 回滚后，你会看到代码只剩下从回滚往下的提交内容了。
4. 回滚后，你不能直接 push 提交了，这个之后会报错；`fast-forward` 因为此时本地分支落后于远程分支。
5. 所以要通过 `git push origin HEAD --force` 进行强制提交。或者你可以把 test 的远程分支删掉，之后在提交。
## 6. 提交工程 - IntelliJ IDEA
那么首次创建的工程怎么提交到代码库呢？🤔
### 6.1 创建本地仓库
- Create Git repository 创建一个本地的暂存库。你可以把开发的内容暂时提交到本地仓库中。
### 6.3 提交本地代码
- 把本地仓库提交到本地代码库待提交列表中。
- 后续你在创建的代码，会默认自动加入进来。*如果你是通过打开文件夹复制进去的，不会被添加，需要手动 +Add*
- 添加后就可以参考 5.3 中的操作提交代码了。
### 6.4 创建远程仓库
你可以选择 GitHub/GitCode/Gitee/GitLab 任意地方创建自己的工程库。教程；
- [https://bugstack.cn/md/road-map/github.html](https://bugstack.cn/md/road-map/github.html)
- [https://bugstack.cn/md/road-map/gitcode.html](https://bugstack.cn/md/road-map/gitcode.html)
- [https://bugstack.cn/md/road-map/gitee.html](https://bugstack.cn/md/road-map/gitee.html)
### 6.5 推送本地工程
- 最后推送完成就可以看到自己的代码进入仓库中了！
## 7. 操作界面 - git-gui
Git 附带了用于提交 ( [git-gui](https://git-scm.com/docs/git-gui) ) 和浏览 ( [gitk](https://git-scm.com/docs/gitk) ) 的内置 GUI 工具，但也有一些第三方工具可供用户寻求特定于平台的体验。
- Git 提供了操作的客户端界面，你可以按需下载使用。
- 地址：[https://git-scm.com/docs/git-gui](https://git-scm.com/docs/git-gui)
## 8. 分支命名
不同公司中对Git的使用分支命名规范也略有差异，不过整体都会分为；`上线`、`预发`、`开发`、`测试`，这样几个分支。如图是一种比较简单使用的拉取分支方式。
- master/main 作为主分支，不可直接修改代码代码，只能从分支合并到主分支进行进行提交。同时，master 分支的合并需要进行审批，审批后才能合并。
- 开发前，先从 master 分支，拉一个开发分支。`2024/10/11/xfg-xxx` 使用带有斜线的分支命名会自动创建文件夹，对于多人开发的项目，可以直接归档。
- 后开发，也就是研发已经完成了本地的验证。进行测试时，可以把研发的开发分支合并到 test 分支，提交、部署、测试。遇到测试bug，需要回到可发分支修改代码，之后合并到 test 分支部署验证。
- pre/release 预发分支，用于测试完成后，把研发的开发分支合并到预发分支进行预发上线，上线后测试人员进行验证。最终完成验证后，把开发分支合并到 master 分支，并需要由架构师对合并代码审批通过。最后进行上线开量验证。
- 如果是修复bug的，可以添加一个 `fix-用户名缩写-具体功能`
## 9. 提交规范
保持一个标准的统一的规范提交代码，在后续的评审、检查、合并，都会非常容易处理。
**提交规范**：`type:【需求名】desc #id` 如：`feat:【抽奖算法】O1、Ologn 时间复杂度算法实现 #需求id（github pr/行云等会有自动关联）` *参考Commit message 规范*
```java
# 主要type
feat: 增加新功能
fix: 修复bug
# 特殊type
docs: 只改动了文档相关的内容
style: 不影响代码含义的改动，例如去掉空格、改变缩进、增删分号
build: 构造工具的或者外部依赖的改动，例如webpack，npm
refactor: 代码重构时使用
revert: 执行git revert打印的message
# 暂不使用type
test: 添加测试或者修改现有测试
perf: 提高性能的改动
ci: 与CI（持续集成服务）有关的改动
chore: 不修改src或者test的其余修改，例如构建过程或辅助工具的变动
```
> 前提通知，谨慎回滚。如果是回滚 Master 更要特别小心，别把工作回滚丢了。
## 10. 操作手册
- 文档：[https://git-scm.com/book/zh/v2](https://git-scm.com/book/zh/v2) - `可以直接对照着操作，练习命令`
- PDF：[https://github.com/progit/progit2-zh/releases/download/2.1.62/progit.pdf](https://github.com/progit/progit2-zh/releases/download/2.1.62/progit.pdf)
- 演示：[https://learngitbranching.js.org/](https://learngitbranching.js.org/) - `可直接查看动画效果，引导式学习Git命令操作。`
---
- 中文PDF，直接深度学习Git操作！下载：**微信公众号「bugstack虫洞栈」回复「gitbook」**
---
### Md Road Map Gitcode (`docs/md/road-map/gitcode.md`)
---
title: Gitcode
lock: need
---
# Gitcode 使用
作者：小傅哥
- 它的注册方式直接使用会跳转到 CSDN 直接使用即可。
- 注册后你就会有一个自己的 Gitee，如：[https://gitcode.com/fuzhengwei](https://gitcode.com/fuzhengwei)
## 二、仓库创建
### 1. 创建类型
- 创建仓库，操作步骤与 Github 基本一致。
- 在新建项目的时候，同样也可以从其他仓库导入项目。
### 2. 创建操作
#### 2.1 创建项目
**创建选项**
- 项目名称；也就是你最后的项目名称
- URL&标识：选择把项目创建到你的那个组织下，以及路径。一般路径和仓库名称最好保持一致。
- 项目介绍：描述这个项目的。
- 创建类型：你可以选择私有和公开。
**创建完成**
- 示例：[https://gitcode.net/fuzhengwei/xfg-frame-ddd](https://gitcode.net/fuzhengwei/xfg-frame-ddd)
#### 2.2 创建组织
- 组织相当于是一个额外的空间，而你是这个组织的管理者。它必须全局唯一。
- 之后你可以在创建项目的时候，选择到组织空间，这样项目就会创建到组织里了。
## 三、代码提交
代码提交到仓库，核心在于把本地代码和远程仓库关联起来。如果你是直接从远程仓库地址，检出到本地的，那么就不需要再次关联了。本场景适用于，你本地有代码库，需要首次提交到远程仓库中。
### 1. 创建本地仓库
- 首先你需要打开 IntelliJ IDEA 工程，选择 VCS 创建一个本地仓库的Git仓库。Create Git Repository
### 2. 关联远程仓库
- 打开你的 Gitee 仓库对应的项目，复制项目 HTTPS 地址，粘贴到 IntelliJ IDEA 项目的远程仓库配置中，点击 OK 即可。
- Manage Remotes 可以设置多个仓库，在push代码的时候，选择对应的地址提交即可。
### 3. 项目代码提交
#### 3.1 添加
- 在工程上右键，把你需要提交的文件，选择 +Add 注意不要把一些不需要提交的文件，也提交上去。
- 你可以先创建一个 `Add to .gitignore` 它可以屏蔽掉一些不要的文件。—— 在 Github 创建工程的时候也有此文件。你也可以先更新 pull 拉取下来。
#### 3.2 提交
- 提交代码快捷键：`Ctrl + K` - 提交到本地仓库
#### 3.3 推送
- 推送代码快捷辑：`Ctrl + Shift + K` —— 提交到远程仓库
## 四、提交规范
**分支命名**：`日期_姓名首字母缩写_功能单词`，如：`230708_xfg_buildFramework`
**提交规范**：`作者，type: desc` 如：`小傅哥，fix：修复查询用户信息逻辑问题` *参考Commit message 规范*
```
# 主要type
feat: 增加新功能
fix: 修复bug
# 特殊type
docs: 只改动了文档相关的内容
style: 不影响代码含义的改动，例如去掉空格、改变缩进、增删分号
build: 构造工具的或者外部依赖的改动，例如webpack，npm
refactor: 代码重构时使用
revert: 执行git revert打印的message
# 暂不使用type
test: 添加测试或者修改现有测试
perf: 提高性能的改动
ci: 与CI（持续集成服务）有关的改动
chore: 不修改src或者test的其余修改，例如构建过程或辅助工具的变动
```
---
**此外**，Github 是一个大宝藏，你可以通过检索，找到特别多的优质项目、代码、设计。如：[https://gitcode.net/fuzhengwei](https://gitcode.net/fuzhengwei)
---
### Md Road Map Gitee (`docs/md/road-map/gitee.md`)
---
title: Gitee
lock: need
---
# Gitee 使用
作者：小傅哥
- 你可以按照Gitee的注册提示，一步一步的填写信息就可以完成账号注册了。
- 注册后你就会有一个自己的 Gitee，如：[https://gitee.com/fustack](https://gitee.com/fustack)
## 二、仓库创建
### 1. 创建类型
- 创建仓库，操作步骤与 Github 基本一致。
- 从 Github/GitLab 导入仓库，这个功能非常好用。如果你拿到了一个 Github 的地址，但访问不了。这个时候你可以通过这个功能，把项目导入到 Gitee 就可以访问了。
### 2. 创建操作
#### 2.1 创建项目
**创建选项**
- 仓库名称；也就是你最后的项目名称
- 归属&路径：选择把项目创建到你的那个组织下，以及路径。一般路径和仓库名称最好保持一致。
- 仓库介绍：描述这个项目的。
- 创建类型：默认情况下你只能创建一个私有项目，在审核后，在修改为公开。
- 其他设置；你可以选择一些默认的信息初始化仓库，如；gitignore、开源许可协议、模板、分支等。
**创建完成**
- 示例：[https://gitee.com/fustack/xfg-frame-ddd](https://gitee.com/fustack/xfg-frame-ddd)
#### 2.2 创建组织
- 组织相当于是一个额外的空间，而你是这个组织的管理者。它必须全局唯一。
- 之后你可以在创建项目的时候，选择到组织空间，这样项目就会创建到组织里了。
## 三、代码提交
代码提交到仓库，核心在于把本地代码和远程仓库关联起来。如果你是直接从远程仓库地址，检出到本地的，那么就不需要再次关联了。本场景适用于，你本地有代码库，需要首次提交到远程仓库中。
### 1. 创建本地仓库
- 首先你需要打开 IntelliJ IDEA 工程，选择 VCS 创建一个本地仓库的Git仓库。Create Git Repository
### 2. 关联远程仓库
- 打开你的 Gitee 仓库对应的项目，复制项目 HTTPS 地址，粘贴到 IntelliJ IDEA 项目的远程仓库配置中，点击 OK 即可。
- Manage Remotes 可以设置多个仓库，在push代码的时候，选择对应的地址提交即可。
### 3. 项目代码提交
#### 3.1 添加
- 在工程上右键，把你需要提交的文件，选择 +Add 注意不要把一些不需要提交的文件，也提交上去。
- 你可以先创建一个 `Add to .gitignore` 它可以屏蔽掉一些不要的文件。—— 在 Github 创建工程的时候也有此文件。你也可以先更新 pull 拉取下来。
#### 3.2 提交
- 提交代码快捷键：`Ctrl + K` - 提交到本地仓库
#### 3.3 推送
- 推送代码快捷辑：`Ctrl + Shift + K` —— 提交到远程仓库
## 四、提交规范
**分支命名**：`日期_姓名首字母缩写_功能单词`，如：`230708_xfg_buildFramework`
**提交规范**：`作者，type: desc` 如：`小傅哥，fix：修复查询用户信息逻辑问题` *参考Commit message 规范*
```
# 主要type
feat: 增加新功能
fix: 修复bug
# 特殊type
docs: 只改动了文档相关的内容
style: 不影响代码含义的改动，例如去掉空格、改变缩进、增删分号
build: 构造工具的或者外部依赖的改动，例如webpack，npm
refactor: 代码重构时使用
revert: 执行git revert打印的message
# 暂不使用type
test: 添加测试或者修改现有测试
perf: 提高性能的改动
ci: 与CI（持续集成服务）有关的改动
chore: 不修改src或者test的其余修改，例如构建过程或辅助工具的变动
```
---
**此外**，Github 是一个大宝藏，你可以通过检索，找到特别多的优质项目、代码、设计。如：[https://github.com/fuzhengwei](https://github.com/fuzhengwei)
---
### Md Road Map Github Actions Workflows (`docs/md/road-map/github-actions-workflows.md`)
---
title: Docker 镜像构建 - Github Action
lock: need
---
# Docker 镜像构建 - Github Action
作者：小傅哥
**小白基础很差，每次收获都很大！**
很多我们自己不能直接访问的服务，在很多互联网公司中都是可以直接访问的，包括；GitHub、谷歌，因为这些公司都是有专门备案的可信的专线网络。这也就是为什么很多机智的伙伴，有 github 地址，但访问很慢的时候，会直接在 gitee 仓库，通过导入 github 地址的方式进行访问。因为 gitee 是有对应的网络专线的，他们可以来拉取代码（并做安全审核），让我们可以放心使用。
嘿嘿，那么就有办法了。同样的访问不了 DockerHub，拉取不了进项。但阿里云有镜像仓库呀。阿里云可以访问 GitHub，GitHub 也可以访问阿里云。那么简单了，我们可以基于 GitHub 的 Actions 服务，执行构建和推送镜像的脚本，把需要的镜像推送到阿里云 Docker 镜像仓库，这不就可以满足自己使用了吗！
>接下来，小傅哥就教大家搞一下这个事情。—— 学到手的全是技术！
## 一、GitHub Actions 是什么
我把 GitHub Actions 当成一种免费的云服务器，我估计不少程序员也都这么理解！因为它可以执行出非常多的骚操作！
**正经的！** GitHub Actions 是 GitHub 提供的一项持续集成和持续交付（CI/CD）服务。它允许开发者在代码库中自动化各种任务，例如构建、测试和部署代码。通过定义工作流（workflow），开发者可以在特定事件（如代码推送、拉取请求等）发生时自动触发这些任务。
嘿嘿，你看，其实还是一台可以执行任意脚本的云服务器！除了说的 CI/CD 持续交付，也包括它可以定时的执行的任意脚本，比如；定时执行 Java 的 Main 函数，调用下 openai 接口，给自己的公众号每天推送一个最新的技术信息。或者是各类签到就送东西的平台，定时+随机时间签到获取金币/京豆/积分。
## 二、GitHub Actions 的使用
小傅哥不只是一个后端Java工程师，同时也能开发点前端，再搞点实施运维的事情。这就让我对很多问题，都有了很多的解决方案。
所以在小傅哥星球「码农会锁」带着大家实战的大营销平台项目，就提供了多种的 Docker 部署方式。如；本地构建再推送镜像到 DockerHub，鉴于不少伙d伴本地安装 Docker 费劲，又提供了直接把一台云服务器配置成开发机器，在云服务器直接 Maven 编译和构建镜像，这样就满足了大部分伙伴的开发部署诉求。
当为了让伙伴得到更全面的学习，小傅哥最近又开始提供了 GitHub Actions CI/CD 持续交付的部署方式。只要你提交代码，即可自动进行构建和完成镜像的推送，并且是同时把镜像推送到 DockerHub 和 阿里云的 Docker 镜像中。接下来小傅哥就告诉大家是怎么操作的。
### 1. 阿里云镜像仓库配置
#### 1.1 创建个人实例
- 地址：[https://cr.console.aliyun.com/cn-hangzhou/instances](https://cr.console.aliyun.com/cn-hangzhou/instances)
#### 1.2 查看连接凭证
- 地址：[https://cr.console.aliyun.com/cn-hangzhou/instance/credentials](https://cr.console.aliyun.com/cn-hangzhou/instance/credentials)
#### 1.3 镜像使用说明 - 推送后即可使用
- 地址：[https://cr.console.aliyun.com/repository/cn-hangzhou/fuzhengwei/big-market-app/details](https://cr.console.aliyun.com/repository/cn-hangzhou/fuzhengwei/big-market-app/details) - `修改为你的地址进行登录`
- 使用：`docker pull registry.cn-hangzhou.aliyuncs.com/xfg-studio/big-market-app:3.0`
### 2. GitHub 仓库 Actions CI/CD 配置
- 首先，点开你的 GitHub 中需要使用 Actions 的项目，点击 Settings 设置。
- 之后，添加阿里云镜像仓库配置，包括用户名和密码。[https://cr.console.aliyun.com/cn-hangzhou/instance/credentials](https://cr.console.aliyun.com/cn-hangzhou/instance/credentials)
- 最后，配置 DockerHub 用户名和 `New Access Token`。[https://hub.docker.com/settings/security](https://hub.docker.com/settings/security)
### 3. 工程脚本配置
#### 3.1 工程目录
- 新增加了一个 ActionDockerfile 方便管理路径。
#### 3.2 Dockerfile
```java
# 基础镜像
FROM openjdk:8-jre-slim
# 作者
MAINTAINER xiaofuge
# 配置
ENV PARAMS=""
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 添加应用
ADD ./big-market-app/target/big-market-app.jar /big-market-app.jar
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /big-market-app.jar $PARAMS"]
```
#### 3.3 workflows
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 这里就是 GitHub 的 Actions 执行脚本，包括；监听 master 分支、拉取代码、设置环境、Maven 打包、构建镜像、推送镜像分别到 DockerHub 和 阿里云镜像仓库。
- 这样我们每次需要新的打包镜像时，可以直接在这里修改下版本号，提交即可。
### 4. 启动运行
GitHub 的 Actions 是自动执行的，只要监听到 Master 分支有变化，即可自动执行并推送镜像到仓库中。
> 运行到这里，你就可以在 DockerHub、阿里云仓库同时看到自己的镜像文件了。想咋用就咋用。
## 三、GitHub Actions 其他玩法
### 1. 同步镜像文件
- 地址：[https://github.com/fuzhengwei/docker-image-pusher](https://github.com/fuzhengwei/docker-image-pusher)
```
mysql:8.0.32
phpmyadmin:5.2.1
redis:6.2
spryker/redis-commander:0.8.0
rabbitmq:3.12.9
```
1. 在 `images.txt` 添加你需要的镜像（PR方式提交），你可以从 https://hub.docker.com/ 搜索需要的镜像后添加。
2. 新添加镜像，需要等待1分钟同步。之后通过命令 `docker pull registry.cn-hangzhou.aliyuncs.com/xfg-studio/mysql` 拉取你需要的镜像，如果有版本号，可以添加。如；`mysql:8.0.32`
### 2. 自动部署博客
- 地址：[https://github.com/fuzhengwei/xfg-dev-tech-blog](https://github.com/fuzhengwei/xfg-dev-tech-blog)
- 视频：[https://www.bilibili.com/video/BV1ri421a7Aj/](https://www.bilibili.com/video/BV1ri421a7Aj/)
---
### Md Road Map Github Models (`docs/md/road-map/github-models.md`)
---
title: Github Models
lock: need
---
# Github Models（AI接口），申请使用教程
作者：小傅哥
这些免费的不错的大模型（LLM），也都是有对应的频次和最大出入/输出token的限制。虽然不会让咱们玩命的调用测试。但在程序开发初期，对于单个功能的验证还是非常方便的。接下来，小傅哥就给大家演示下，关于 Github 免费提供的大模型如何配置使用。
## 一、模型说明
### 1. 官网地址
官网：[https://github.com/marketplace?type=models](https://github.com/marketplace?type=models)
在 Github marketplace 下提供了非常多的免费的 LLM 使用，gpt-5、gpt-4.1 都是有的，具备完整的测试功能。有时候还会新增加其他模型。
### 2. 频次限制
地址：[https://docs.github.com/en/github-models/use-github-models/prototyping-with-ai-models#rate-limits](https://docs.github.com/en/github-models/use-github-models/prototyping-with-ai-models#rate-limits)
- 每日150次、每分钟15次，每次token，8000进、4000出。对于单个模型的验证是没问题的，不过对于复杂的 ai agent 智能体是跑不动的。所以，这块测试的话，要分开验证。之后对于全流程的，在购买 api 进行测试即可。
- 如果小伙伴还觉得，每分钟15次，有点不够干的，那你可以弄10个账号，通过 nginx 负载下，这样基本每分钟150次，一天1500次还是很够用的。
## 二、模型使用
### 1. 测试工程
- 地址：[https://github.com/fuzhengwei/xfg-dev-tech-github-models](https://github.com/fuzhengwei/xfg-dev-tech-github-models)
- 说明：这里小傅哥准备了一套基于 Spring AI 的测试工程，来验证 Github LLM 的使用。你可以下载后，替换 token/apikey 即可调用验证。
- 环境：jdk 17、maven 3.8.x、spring ai 1.1.0
### 2. 对接申请
#### 2.1 申请token
地址：https://github.com/settings/tokens/new
- 在 Tokens 下，添加 Note 描述和过期时间，完事后不用加任何其他权限，拉到最后设置点击 `Generate token` 生成令牌即可。
- 生成后复制你的 Token，复制后关闭就看不见了。只有删除和创建新的。
#### 2.2 查看curl（api）
地址：[https://github.com/marketplace/models/azure-openai/gpt-4-1/playground](https://github.com/marketplace/models/azure-openai/gpt-4-1/playground)
在左侧你可以选择需要使用的模型，之后进行对话验证。之后，在右侧有一个 `Use this model` 这里可以获得模型 API 请求信息。
你现在单独验证 api，在整个程序测试前，要确保你的 api 是可用的。
### 3. 测试验证
```java
public class ApiTest {
public static void main(String[] args) throws Exception {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
Resource resource = new ClassPathResource("dog.png", classLoader);
OpenAiApi openAiApi = OpenAiApi.builder()
.baseUrl("https://models.github.ai/inference")
// apikey 要替换为你的，在 https://github.com/settings/tokens 创建即可。
.apiKey("ghp_FfiwBkVunYDQyhIwaQSccVw******")
.completionsPath("/chat/completions")
.embeddingsPath("/embeddings")
.build();
ChatModel chatModel = OpenAiChatModel.builder()
.openAiApi(openAiApi)
.defaultOptions(OpenAiChatOptions.builder()
.model("openai/gpt-4.1")
.build())
.build();
// 模型测试，没问题可以识别图片
ChatResponse response = chatModel.call(new Prompt(
UserMessage.builder()
.text("请描述这张图片的主要内容，并说明图中物品的可能用途。")
.media(Media.builder()
.mimeType(MimeType.valueOf(MimeTypeUtils.IMAGE_PNG_VALUE))
.data(resource)
.build())
.build()));
System.out.println("测试结果" + JSON.toJSONString(response));
}
}
```
```java
测试结果{"metadata":{"empty":false,"id":"chatcmpl-CzHhVYaXPv3HjJ3oKE4YKPamPQRQB","model":"gpt-4.1-2025-04-14","rateLimit":{"requestsLimit":1000,"requestsRemaining":996,"tokensLimit":1000000,"tokensRemaining":980423},"usage":{"completionTokens":0,"nativeUsage":{},"promptTokens":0,"totalTokens":0}},"result":{"metadata":{"contentFilters":[],"empty":true,"finishReason":"STOP"},"output":{"media":[],"messageType":"ASSISTANT","metadata":{"role":"ASSISTANT","messageType":"ASSISTANT","finishReason":"STOP","refusal":"","index":0,"annotations":[{"$ref":"$.metadata.rateLimit.usage.nativeUsage"}],"id":"chatcmpl-CzHhVYaXPv3HjJ3oKE4YKPamPQRQB"},"text":"这张图片的主要内容是一只卡通风格的小狗。小狗是棕色的，脸部较大，眼睛圆而突出，表情看起来有些疑惑或惊讶，嘴巴微微张开，尾巴翘起。整个形象简洁可爱，线条和颜色运用都比较简单。\n\n**物品的可能用途：**\n1. **图标或表情包**：这种卡通形象常用于聊天软件中的表情包或头像，传达惊讶、困惑等情感。\n2. **儿童绘本或动画角色**：可以作为儿童图书或动画中的形象角色，吸引小朋友的注意力。\n3. **宠物相关宣传设计**：可用于宠物店、宠物产品的宣传海报、包装或logo，增加亲和力。\n4. **教育材料**：在教学课件或教育类APP中，用于引导、示范或者增加趣味性。\n\n整体而言，这是一种很常见且可爱的卡通动物形象，主要用于与宠物、儿童或者情感表达相关的领域。","toolCalls":[]}},"results":[{"$ref":"$.metadata.rateLimit.usage.nativeUsage.result"}]}
```
- 这是一段基于 Spring AI 配置 github llm api的使用方式，尤其注意，baseUrl、apiKey、completionsPath、embeddingsPath、openai/gpt-4.1，这些配置信息和你直接使用管的 gpt 配置是有差异的。
- 本案例，是识别图片的用途，你也可以验证其他功能。这样的项目在小傅哥的 [《AI Agent 智能体》](https://bugstack.cn/md/project/ai-knowledge/ai-knowledge.html) 都有讲解。
## 三、使用拓展
### 1. 部署脚本
- 这是一套 nginx 转发脚本。你需要有自己的域名（各个云服务器厂商都可以购买）以及申请 ssl 后才可以配置使用。
- ssl 可以从 [httpok](https://bugstack.cn/md/road-map/ssl-httpsok.html) 申请使用。地址：[https://bugstack.cn/md/road-map/ssl-httpsok.html](https://bugstack.cn/md/road-map/ssl-httpsok.html)
### 2. 转发说明（nginx）
如果你希望在使用的过程中，让模型是以你之前使用 openai 一样的方式，那么可以配置一套 Nginx 转发；
```java
server {
listen 80;
listen [::]:80;
server_name 需要配置域名（api.xxx.cn）;
rewrite ^(.*) https://$server_name$1 permanent;
}
server {
listen 443 ssl;
server_name 需要配置域名（api.xxx.cn）;
ssl_certificate /etc/nginx/ssl/_.itedus.cn.pem;
ssl_certificate_key /etc/nginx/ssl/_.itedus.cn.key;
ssl_session_cache shared:SSL:1m;
ssl_session_timeout 5m;
ssl_ciphers HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers on;
location / {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
root /usr/share/nginx/html;
index index.html index.htm;
}
location /v1/ {
# 去掉路径中的/v1前缀
rewrite ^/v1/(.*) /$1 break;
proxy_pass https://models.inference.ai.azure.com;
proxy_http_version 1.1;
chunked_transfer_encoding off;
proxy_buffering off;
proxy_cache off;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}
```
- nginx 的方式是，当访问有 v1/ 路径的时候，在进行路径重写 `rewrite ^/v1/(.*) /$1 break;` 之后转发到 `https://models.inference.ai.azure.com` - `这个也是 gpt 里的一种模型对接地址`
- 转发后，你就可以直接使用模型服务了。
### 3. curl 验证
- 配置转发后，就可以使用 curl_nginx.sh 脚本进行验证了。
好啦，本文到这，你就可以初步使用免费的 LLM 进行一些一些初始功能验证。2025年，ai agent 开始崛起，2026年，必然是 ai agent 爆发的时候。一定要多学习这类实战项目，企业里 spring 是大盘，所以结合 spring ai 做的项目也必然会非常多。
---
### Md Road Map Github (`docs/md/road-map/github.md`)
---
title: Github
lock: need
---
# Github 使用
作者：小傅哥
- 你可以按照Github的注册提示，一步一步的填写信息就可以完成账号注册了。
- 注册后你就会有一个自己的 Github，如：[https://github.com/fuzhengwei](https://github.com/fuzhengwei)
## 二、仓库创建
### 1. 创建类型
- New repository 创建仓库
- Import repository 导入仓库
- New organization 创建组织，一个组织下可以创建多个项目。
### 2. 创建操作
#### 2.1 创建项目
**创建选项**
- 项目名称：不重复即可，一般是小写的项目名称和中划线。
- 项目介绍：介绍写核心信息。
- 项目类型：公开的和私有的，私有的别人不能被搜索到，也看不到。
- 详细介绍：README 是用于写详细介绍的，你可以把它当成是项目本身的简历。
- .gitignore：是一个模板，哪里不被 Java 项目提交到仓库。
- License：协议，比如 Apache License 协议。
**创建完成**
- 示例：[https://github.com/fuzhengwei/xfg-frame-ddd](https://github.com/fuzhengwei/xfg-frame-ddd)
#### 2.2 创建组织
- 组织相当于是一个额外的空间，而你是这个组织的管理者。它必须全局唯一。
- 之后你可以在创建项目的时候，选择到组织空间，这样项目就会创建到组织里了。
## 三、代码提交
代码提交到仓库，核心在于把本地代码和远程仓库关联起来。如果你是直接从远程仓库地址，检出到本地的，那么就不需要再次关联了。本场景适用于，你本地有代码库，需要首次提交到远程仓库中。
### 1. 创建本地仓库
- 首先你需要打开 IntelliJ IDEA 工程，选择 VCS 创建一个本地仓库的Git仓库。Create Git Repository
- 这里还有一个分享到仓库，Share Project On GitHub 你也可以选择使用，直接把本地代码分享创建到远程仓库。
### 2. 关联远程仓库
- 打开你的Github 仓库对应的项目，复制项目 HTTPS 地址，粘贴到 IntelliJ IDEA 项目的远程仓库配置中，点击 OK 即可。
### 3. 项目代码提交
#### 3.1 添加
- 在工程上右键，把你需要提交的文件，选择 +Add 注意不要把一些不需要提交的文件，也提交上去。
- 你可以先创建一个 `Add to .gitignore` 它可以屏蔽掉一些不要的文件。—— 在 Github 创建工程的时候也有此文件。你也可以先更新 pull 拉取下来。
#### 3.2 提交
- 提交代码快捷键：`Ctrl + K` - 提交到本地仓库
#### 3.3 推送
- 推送代码快捷辑：`Ctrl + Shift + K` —— 提交到远程仓库
## 四、提交规范
**分支命名**：`日期_姓名首字母缩写_功能单词`，如：`230708_xfg_buildFramework`
**提交规范**：`作者，type: desc` 如：`小傅哥，fix：修复查询用户信息逻辑问题` *参考Commit message 规范*
```
# 主要type
feat: 增加新功能
fix: 修复bug
# 特殊type
docs: 只改动了文档相关的内容
style: 不影响代码含义的改动，例如去掉空格、改变缩进、增删分号
build: 构造工具的或者外部依赖的改动，例如webpack，npm
refactor: 代码重构时使用
revert: 执行git revert打印的message
# 暂不使用type
test: 添加测试或者修改现有测试
perf: 提高性能的改动
ci: 与CI（持续集成服务）有关的改动
chore: 不修改src或者test的其余修改，例如构建过程或辅助工具的变动
```
---
**此外**，Github 是一个大宝藏，你可以通过检索，找到特别多的优质项目、代码、设计。如：[https://github.com/fuzhengwei](https://github.com/fuzhengwei)
---
### Md Road Map Google Adk (`docs/md/road-map/google-adk.md`)
---
title: google adk
lock: need
---
# Google Agent ADK，20分钟，帮你搭建一个简单智能体
作者：小傅哥
- ADK 以轻便化构建 Ai Agent 智能体，解决智能体开发的复杂流程而设计。目前支持 Python、Java、Go 3种语言对应的技术框架。
- 整个文档完整的描述了，智能体的创建和运行、工具的调用（tools、function、mcp）、可观测性以及 A2A 协议等。
- Agent Development Kit (ADK) is designed to empower developers to quickly build, manage, evaluate and deploy AI-powered agents. These quick start guides get you set up and running a simple agent in less than **20 minutes**.
## 二、工程实践
### 1. 前置说明
本次的 Ai Agent 实践，是以 Google ADK 框架为基础，配和 Github [system-prompts-and-models-of-ai-tools](https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools) 开源提示词项目中的 claude-code-system-prompt 作为必要描述。来实验，ELK 系统日志智能分析场景。
- API Key：[https://ai.google.dev/gemini-api](https://ai.google.dev/gemini-api) 需要申请开发 API 秘钥，是免费的。
- Docker 环境，本项目部署了一套 ELK 日志服务，基于 Docker 部署，之后对 ELK 模拟写入日志，让 Ai Agent 智能体进行分析。`如果暂时配置不了，可以在测试的时候去掉这部分 mcp 服务`
- `JDK 17+`、`Maven 3.8.x`
### 2. 工程说明
- 工程地址：[https://github.com/fuzhengwei/xfg-dev-tech-google-adk](https://github.com/fuzhengwei/xfg-dev-tech-google-adk)
- 这是一套引入了 Google ADK 0.1.0 版本的 Agent 最基础智能体测试。如果需要扩展，还要额外增加很多东西，可以参考 [《Ai Agent 智能体项目》](https://bugstack.cn/md/project/ai-knowledge/ai-knowledge.html)
#### 2.1 YML 配置
```java
server:
port: 8901
# 可申请API秘钥；https://ai.google.dev/gemini-api
google:
api:
base-url: https://generativelanguage.googleapis.com
key: AIzaSyDF6JnvFx7xWEsARS*******可以自己申请免费的
cloud:
project: xfg-google-adk
logging:
level:
root: info
config: classpath:logback-spring.xml
```
- 在 `application-dev.yml` 修改你的参数配置，配置你的 Google api key
#### 2.2 ADK 单测
```
/* Detailed source-code truncated for AI context efficiency. */
```
```java
Agent > Hi there! Yes, I'm here to help. To best assist you, could you tell me what you need help with? The more information you give me, the better I can understand your request and provide a useful response.
```
- 这是一套最基础的 Ai Agent 智能体 ADK 的测试使用代码。其实它的配置和调用与 Spring AI 框架是有类似之处的，基本上这类框架也都是这样的使用模式。
- LlmAgent 提供了一整套构建智能体的方式，可以设置客户端（Gemini），并设置相关的 baseUrl、apiKey 参数，以及模型和超时时间等。
- InMemoryRunner 的用途是把 Agent 放入一个记忆执行里，让一整个 Session 会话下的执行都被记录下，这样才能记录上下文。
- 之后就是放到响应框架进行之后和拿到最后结果啦。
#### 2.3 Agent 智能体测试
```
/* Detailed source-code truncated for AI context efficiency. */
```
- AutoAgentTest 智能体，配置了两个 mcp，mcp_elk、mcp_filesystem 服务。其实 AI Agent 智能体，都少不了 MCP 服务的加持，这样才能让这个大脑有手脚可以行动起来。
- init 初始化阶段，instruction 配置了对应的智能体提示词，这部分很重要，有点像智能体的神经。[https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Claude%20Code/claude-code-system-prompt.txt](https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Claude%20Code/claude-code-system-prompt.txt) - 可以选择这里的提示词配置到智能体进行测试。
- 这部分也可以运行测试，之后会你可以进行提问。注意，如果你没有配置 elk，那么可以删掉 `mcpTools.addAll(mcp_elk());` 代码。
- mcp_filesystem() 配置了，`/Users/fuzhengwei/Desktop` 你需要修改为你的本地的有权限访问的地址。
#### 2.4 Agent 智能体服务
有了前面的案例测试基础，就可以把服务配置成对应的接口，以及开发个简单的页面进行对接验证了。
##### 2.4.1 服务接口
```java
@Slf4j
@RestController
@RequestMapping("/trigger")
@CrossOrigin(origins = "*")
public class AgentController {
private final AgentService agentService;
public AgentController(AgentService agentService) {
this.agentService = agentService;
}
@PostMapping(path = "/session", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
public CreateSessionResponse createSession(@RequestBody CreateSessionRequest req) {
String sessionId = agentService.createOrGetSession(req.getUserId());
log.info("创建会话ID:{}", sessionId);
return new CreateSessionResponse(sessionId);
}
@PostMapping(path = "/chat", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
public ChatResponse chat(@RequestBody ChatRequest req) {
String sessionId = req.getSessionId();
if (sessionId == null || sessionId.isEmpty()) {
sessionId = agentService.createOrGetSession(req.getUserId());
}
log.info("使用会话ID:{}", sessionId);
List outputs = agentService.chat(req.getUserId(), sessionId, req.getMessage());
return new ChatResponse(sessionId, String.join("\n", outputs));
}
}
```
- 这里就是把单测的服务，包装成接口。详细的部分可以直接看工程代码。
##### 2.4.2 页面对接
- 把服务端的接口对接到页面。
## 三、功能测试
### 1. 部署 elk 日志服务
- 整个 Ai Agent 案例，配置了 ELK 作为日志分析的基础，所以最好配置下。
- 这里也有云服务器的部署操作，也可以参考教程来部署。教程：[https://bugstack.cn/md/road-map/docker-install.html](https://bugstack.cn/md/road-map/docker-install.html)
- 注意配置完成后，要执行 `elk-blacklist-data.sh` 模拟的写入进去一些日志，这样才能用于分析使用。
### 2. 启动服务访问页面
- 以上演示了，使用 Ai Agent 进行 ELK 日志分析，通过对话可以看到，最终我们可以拿到系统的日志数据。
- 你还可以尝试配置其他的 MCP 服务，之后验证各种场景功能。担任如果你希望更细化的做 Ai Agent，还是要看下 [《Ai Agent 智能体项目》](https://bugstack.cn/md/project/ai-knowledge/ai-knowledge.html) 这样可以更细腻的做出这样的系统，以及对应的可视化编排操作。
---
### Md Road Map Grafana (`docs/md/road-map/grafana.md`)
---
title: Grafana 可视化监控面板
lock: need
---
# Prometheus + Grafana 监控，验证 Hystrix 超时熔断
作者：小傅哥
com.netflix.hystrix
hystrix-javanica
1.5.18
```
- 这个熔断的组件，不需要引入 SpringCloud 一堆的东西，使用起来更加容易。
```java
@Configuration
public class HystrixConfig {
@Bean
public HystrixCommandAspect hystrixCommandAspect() {
return new HystrixCommandAspect();
}
}
```
- 引入 POM 后，添加 HystrixConfig 熔断配置。
### 2. 接口配置
这里小傅哥提供了2个接口，一个普通的查询数据接口，一个是 OpenAi 中服务的给前端异步响应结果的接口。尤其是 OpenAi 异步接口，我们在实际使用的时候，也总会有超时熔断，所以这里给大家添加上。
#### 2.1 普通接口
```java
/**
* curl http://localhost:8091/api/hystrix/query_order_info
*/
@HystrixCommand(commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "50")
}, fallbackMethod = "queryOrderInfo_error"
)
@RequestMapping(value = "query_order_info", method = RequestMethod.GET)
public String queryOrderInfo() throws InterruptedException {
new CountDownLatch(1).await();
return "您的订单信息查询完毕";
}
private String queryOrderInfo_error() throws InterruptedException {
return "Fallback Hello";
}
```
- 测试过程中，超时熔断时间，可以设置的较大一些，也可以先不添加超时熔断的注解。
#### 2.2 异步接口
```java
/**
* curl http://localhost:8091/api/hystrix/stream
*/
@HystrixCommand(commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "150")
}, fallbackMethod = "stream_error"
)
@RequestMapping(value = "/stream", method = RequestMethod.GET)
public ResponseBodyEmitter stream(HttpServletResponse response) throws Exception {
response.setContentType("text/event-stream");
response.setCharacterEncoding("UTF-8");
response.setHeader("Cache-Control", "no-cache");
ResponseBodyEmitter emitter = new ResponseBodyEmitter();
emitter.send("异步响应");
new Thread(() -> {
for (int i = 0; i < 200; i++) {
try {
emitter.send("hi xfg-dev-tech-grafana\r\n" + i);
Thread.sleep(250);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
emitter.complete();
}).start();
return emitter;
}
public ResponseBodyEmitter stream_error(HttpServletResponse response) throws IOException {
response.setContentType("text/event-stream");
response.setCharacterEncoding("UTF-8");
response.setHeader("Cache-Control", "no-cache");
ResponseBodyEmitter emitter = new ResponseBodyEmitter();
emitter.send("Err");
emitter.complete();
return emitter;
}
```
- 另外一个是一步响应接口，如果响应时间较长，则进入超时熔断方法中。
## 四、服务压测验证
### 1. 配置信息
**application.yml**
```yml
server:
port: 8091
# 1核2G内存，可默认配置 200；4核8G内存【accept-count=1000、max-threads=800、max-connections=10000】，线程数经验值800。线程池过大，cpu调度会消耗大量时间
tomcat:
mbeanregistry:
enabled: true
max-connections: 20 # 最大连接数
threads:
max: 20 # 设定处理客户请求的线程的最大数目，决定了服务器可以同时响应客户请求的数,默认200
min-spare: 10 # 初始化线程数,最小空闲线程数,默认是10
accept-count: 10 # 等待队列长度
```
- 我们在 YML 文件中指定了 tomcat 的连接数配置为 20 个，处理线程最多也是20个。
- 同时还添加了监控空你暴露为true，这样 Grafana 才能监控到。
### 2. 压测工具
压测工具有很多，包括；[JMeter、ApacheBench、Siege](https://bugstack.cn/md/road-map/jmeter.html) 小傅哥已经在前面写过文章，也可以去参考使用。
不过这里为了让大家更加简单的压测下，小傅哥使用了 ApiPost 工具自带的压测，这样不需要自己再安装其他工具就可以简单压测下了。
- 你只要把2个接口配置到 ApiPost 就可以用一键压测工具进行压测。
### 3. 压测观察
- 这里小傅哥压测了下接口 `http://localhost:8091/api/hystrix/stream` 接口。因为这个接口设置了超时，可以看见，快速的就把连接数给占满了。
- 所以如果你的应用配置的 Tomcat 连接数不合理，之后接口又容易超时，超时后又没有熔断，那么很容易就会把你的服务拖垮。很多新人在做一些对外的应用时，如果没有注意到这些，那么也是很容易宕机的。
---
### Md Road Map Guava (`docs/md/road-map/guava.md`)
---
title: guava
lock: need
---
# Guava 使用
作者：小傅哥
cache = CacheBuilder.newBuilder()
// 最大存储条数，缓存将尝试逐出最近或不经常使用的条目
.maximumSize(10000)
// 可以设定删除时候的权重判断
.weigher((Weigher) (x, y) -> x.length() - y.length())
// 有效时间
.expireAfterWrite(3, TimeUnit.SECONDS)
// 记录次数
.recordStats()
.build();
cache.put("xfg", "bugstack.cn");
log.info("测试结果：{}", cache.getIfPresent("xfg"));
cache.invalidate("xfg"); // cache.invalidateAll(); 也可以全部删除
log.info("测试结果：{}", cache.getIfPresent("xfg"));
log.info("测试结果：{}", cache.stats());
}
```
- 你可以自己设定有时效性的缓存对象，还可以记录次数、权重和最大条数。
- 如果你的项目不大，也不想自己实现有过期时间的缓存，那么 Guava 非常适合使用。
### 2. 事件总线
```java
@Test
public void test_eventbus() {
EventBus eventBus = new EventBus();
eventBus.register(new Listener());
// 可以由其他服务推送消息，之后就可以在监听中收到了
eventBus.post("消息总线，订单号：100001");
}
static class Listener {
@Subscribe
public void handleEvent(String orderId) {
log.info("测试结果：{}", orderId);
}
}
```
- 事件总线和MQ消息实现的效果是一致的，都是为了解耦功能流程。但 Guava 的这个组件，非常适合在自己的小项目中使用，接入成本非常低。
### 3. 并发回调
```java
@Test
public void test_ListenableFuture() throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(1);
ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
ListenableFuture explosion = executorService.submit(() -> "finished");
ExecutorService callBackService = Executors.newFixedThreadPool(1);
Futures.addCallback(explosion, new FutureCallback() {
public void onSuccess(String explosion) {
System.out.println("onSuccess");
countDownLatch.countDown();
}
public void onFailure(Throwable thrown) {
System.out.println("onFailure");
countDownLatch.countDown();
}
}, callBackService);
countDownLatch.await();
}
```
### 4. 布隆过滤器
```java
@Test
public void test_BloomFilter() {
BloomFilter bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()),
1000,
0.01);
// 向布隆过滤器中添加元素
bloomFilter.put("apple");
bloomFilter.put("banana");
bloomFilter.put("orange");
// 检查元素是否存在于布隆过滤器中
System.out.println(bloomFilter.mightContain("apple")); // true
System.out.println(bloomFilter.mightContain("banana")); // true
System.out.println(bloomFilter.mightContain("orange")); // true
System.out.println(bloomFilter.mightContain("grape")); // false
// 输出布隆过滤器的统计信息
System.out.println("Expected FPP: " + bloomFilter.expectedFpp());
System.out.println("Number of Inserted Elements: " + bloomFilter.approximateElementCount());
}
```
### 5. 反射工具包
```java
@Test
public void test_Invokable() throws NoSuchMethodException {
Method method = UserEntity.class.getMethod("getUserName");
Invokable invokable = Invokable.from(method);
log.info("测试结果 - 方法名称：{}", invokable.getName());
log.info("测试结果 - 参数类型：{}", JSON.toJSONString(invokable.getTypeParameters()));
log.info("测试结果 - 静态判断：{}", invokable.isStatic());
// !(Modifier.isFinal(method.getModifiers()) || Modifiers.isPrivate(method.getModifiers()) || Modifiers.isStatic(method.getModifiers()) || Modifiers.isFinal(method.getDeclaringClass().getModifiers()))
log.info("测试结果 - isOverridable：{}", invokable.isOverridable());
}
```
- 如果你开发一些组件，有不少的操作都是需要判断方法的权限范围、包的权限范围等，使用 Guava 的插件也会非常方便。
---
其他更多的操作可以参考仓库代码和官网文档学习，基本都是非常完整的案例。
---
### Md Road Map Higress Ai (`docs/md/road-map/higress-ai.md`)
---
title: Higress-Ai
lock: need
---
# AI(+MCP)网关，快速集成（LLM API/HTTP/RPC/Nacos）
作者：小傅哥
org.springdoc
springdoc-openapi-starter-webmvc-ui
2.5.0
org.springdoc
springdoc-openapi-starter-webmvc-api
2.5.0
```
- 官网：[https://swagger.io/](https://swagger.io/)
- 添加 swagger api pom，项目启动后可以访问；[http://localhost:8091/swagger-ui/index.html](http://localhost:8091/swagger-ui/index.html) - 就可以看到项目的 http 接口信息了。
#### 2.2 接口开发
```java
@RestController
@CrossOrigin("*")
@RequestMapping("/api/v1/")
@Tag(name = "测试服务", description = "示例接口")
public class TestServiceController {
private static final Logger logger = LoggerFactory.getLogger(TestServiceController.class);
/**
* API文档；swagger API测试；http://127.0.0.1:8091/api/v1/to_upper_case?word=xiaofuge
*/
@GetMapping("to_upper_case")
@Operation(summary = "字符串转大写", description = "将传入 word 转换为大写")
public String toUpperCase(@RequestParam String word) {
logger.info("接收信息:{}", word);
return word.toUpperCase();
}
}
```
- 在接口上增加描述信息，这些信息可以用作于 mcp 协议结构中方法和字段上的介绍。如下就是 mcp 接口的 @Tool 工具配置。
```java
@Tool(description = "获取公司雇员信息")
public XxxResponse getCompanyEmployee(XxxRequest01 xxxRequest01, XxxRequest02 xxxRequest02) {
log.info("根据公司和雇员，查询工资和工作工时。{} {}",xxxRequest01.getCompany(), xxxRequest02.getEmployeeName());
// 这部分可以实际调用你需要的接口，比如调用http接口获取个数据或者做一些操作等。
XxxResponse xxxResponse = new XxxResponse();
xxxResponse.setSalary(new Random().longs(10000).toString());
xxxResponse.setDayManHour(String.valueOf(new Random().nextInt(24)));
return xxxResponse;
}
```
- 所以，即使是我们自己开发 AI MCP 网关，也是在找这样的衔接点。怎么把 http 接口，借住什么标准的桥梁，转换为 mcp 协议，让用户使用起来更加简单。而 swagger api 就是中间的标准 open api 桥梁。
### 3. 网关部署
#### 3.1 脚本说明
```java
# 命令执行 docker-compose -f docker-compose-environment-aliyun.yml up -d
# docker 代理和使用文档；https://bugstack.cn/md/road-map/docker.html
version: '3.9'
services:
# https://github.com/alibaba/higress
# docker run -d --rm --name higress-ai -v ${PWD}:/data \
# -p 8001:8001 -p 8080:8080 -p 8443:8443 \
# higress-registry.cn-hangzhou.cr.aliyuncs.com/higress/all-in-one:latest
higress-ai:
image: higress-registry.cn-hangzhou.cr.aliyuncs.com/higress/all-in-one:latest
container_name: higress-ai
hostname: higress-ai
ports:
- 8001:8001
- 8080:8080
- 8443:8443
volumes:
- ./higress-ai/data:/data
networks:
- my-network
# Redis
redis:
image: redis:6.2
container_name: redis
restart: always
hostname: redis
privileged: true
ports:
- 16379:6379
volumes:
- ./redis/redis.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf
networks:
- my-network
healthcheck:
test: [ "CMD", "redis-cli", "ping" ]
interval: 10s
timeout: 5s
retries: 3
networks:
my-network:
driver: bridge
```
- 这里把 higress-ai 通过 docker-compose 脚本进行部署，因为部署后还需要配置 Redis 环境，基于 Redis 的 pub/sub 发布订阅能力，让网关具备分布式部署能力，所以在 docker-compose 脚本里，提供了 higress-ai、redis 的部署。
- 部署；`docker-compose -f docker-compose-environment-aliyun.yml up -d`
#### 3.2 部署网关
##### 3.2.1 部署脚本
- 如图说明，进行部署。Mac 电脑本地测试即可。如果 Windows 电脑有兼容问题，可以考虑 Linux 云服务器。[https:618.gaga.plus](https:618.gaga.plus)
##### 3.2.2 部署结果
- 部署后，访问 portainer（这个是 docker 的管理后台）
##### 3.2.3 访问网关
- 地址：[http://127.0.0.1:8001/](http://127.0.0.1:8001/)
- 说明：首次登录需要设置下登录账号和密码，设置后登录即可。
### 4. 获取接口
#### 4.1 启动服务（springboot）
- 测试：[http://127.0.0.1:8091/api/v1/to_upper_case?word=xiaofuge](http://127.0.0.1:8091/api/v1/to_upper_case?word=xiaofuge) - `把小写的xiaofuge转换为大写`
- 接口：[http://localhost:8091/swagger-ui/index.html#/%E6%B5%8B%E8%AF%95%E6%9C%8D%E5%8A%A1/toUpperCase](http://localhost:8091/swagger-ui/index.html#/%E6%B5%8B%E8%AF%95%E6%9C%8D%E5%8A%A1/toUpperCase)
#### 4.2 获取接口
- 地址：[http://localhost:8091/swagger-ui/index.html](http://localhost:8091/swagger-ui/index.html)
- 说明：启动服务后，访问 swagger 地址，你就可以拿到接口文档了。这里主要需要的就是这份json结构。
### 5. 网关配置
#### 5.1 开启网关（mcp）
- 注意，在系统设置里，需要开启 mcp 网关服务。enable = true
- 另外，redis 地址，需要配置上。默认本文给的案例，是支持直接使用 redis 别名链接的，如果 redis 不是本案例安装的，则可以用 ip:port 连接。如果有密码，记得填写密码。
#### 5.2 服务来源
- 可以在网关页，配置服务来源。这里的服务来源支持多种类型，Nacos、Eureka、Zookeeper，以及我们图中这种固定地址的案例，都是可以的。
- 注意下面配置的服务协议，这里选择的是 HTTP，也支持 HTTPS，GRPC 的格式。
#### 5.3 创建服务（MCP）
在 AI网关管理下，MCP 管理中，添加一个 MCP 服务。这里的用途是建一个 MCP 网关和后端服务建立起连接。
#### 5.4 添加工具（协议转换）
- 接下来，还需要添加下工具。也就是 http 接口的具体能力。这里可以把 Swagger 的 json 文件复制过来，添加进去即可。
#### 5.5 验证接口（sse）
在添加接口的地方，你会看到一个网关服务的地址。也就是 SSE 接入点，用于配置到 AI 客户端里。访问地址；http://127.0.0.1:8080/mcp-servers/toUpperCase/sse
**好了，到这你的 AI MCP 网关就配置成功了，你可以把各类服务端的接口转换为 MCP 协议结构进行使用。**
### 6. 接口转发（AI）
AI 网关管理里，还提供了关于 AI 接口的配置。它可以进行统一管理，适合项目的接入使用。做 AI 类的项目，可以把 AI 请求，统一用这样一套东西管理起来。
## 三、调用测试
```java
13:55:19.581 [main] INFO cn.bugstack.xfg.dev.tech.test.ApiTest -- 测试结果:字符串 "xiaofuge" 转换为大写后是 "XIAOFUGE"。
```
- 调用后可以看到把小写的字符串 `xiaofuge` 转换为大写的 `XIAOFUGE`
- 你也可以进入到 TestServiceController 看到调用的日志。
## 四、深入学习
目前，小傅哥也正在带着粉丝伙伴学习 AI 项目，[《AI MCP 网关》](https://origin.bugstack.cn/md/project/ai-mcp-gateway/ai-mcp-gateway.html)，就是目前在持续更新的一个实战类项目。
该项目是 AI Agent 智能体，关于 MCP 协议对接的通用网关服务项目，以解决各类业务接口便捷转换为 MCP 协议而设计实现。通过这样的配置，可以大大的简化从普通http、rpc接口到 MCP 协议的转换操作。这样的项目，也是每个互联网公司在做 AI Agent 智能体时，必备的基础设施项目。
### 1. 项目架构
### 2. 工程模块
### 3. 协议转换
在此项目中，小傅哥一遍带着你分析调试 Spring AI MCP 上下文源码，一边带着你写 AI MCP 网关代码。让你全面的厘清系统设计，又能亲手实现出一套 AI MCP 网关。
---
### Md Road Map Higress (`docs/md/road-map/higress.md`)
---
title: Higress
lock: need
---
# 体验下，大厂在使用功能的API网关！
作者：小傅哥
org.apache.ignite
ignite-core
2.15.0
org.apache.ignite
ignite-spring
2.15.0
```
- 注意引入 ignite 的 pom 配置
#### 2.1 Ignite
**源码**：`cn.bugstack.xfg.dev.tech.config.DataSourceConfig#IgniteMyBatisConfig`
```
/* Detailed source-code truncated for AI context efficiency. */
```
- 创建 Ignite 的数据源，以及对应的 igniteSqlSessionFactory 工厂。这样就把 MyBatis 给关联起来了。
#### 2.2 MySQL
**源码**：`cn.bugstack.xfg.dev.tech.config.DataSourceConfig#MysqlMyBatisConfig`
```java
@Configuration
@MapperScan(basePackages = "cn.bugstack.xfg.dev.tech.infrastructure.mysql.dao", sqlSessionFactoryRef = "mysqlSqlSessionFactory")
static class MysqlMyBatisConfig {
@Bean("mysqlDataSource")
@ConfigurationProperties(prefix = "spring.mysql.datasource")
public DataSource mysqlDataSource(Environment environment) {
return DataSourceBuilder.create()
.url(environment.getProperty("spring.mysql.datasource.url"))
.driverClassName(environment.getProperty("spring.mysql.datasource.driver-class-name"))
.build();
}
@Bean("mysqlSqlSessionFactory")
public SqlSessionFactory mysqlSqlSessionFactory(DataSource mysqlDataSource) throws Exception {
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
factoryBean.setDataSource(mysqlDataSource);
factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mybatis/mapper/mysql/*.xml"));
return factoryBean.getObject();
}
}
```
- 同样，创建 MySQL 的数据源以及 MyBatis 的关联操作。
## 五、性能测试
小傅哥提供了 IgniteController、MySQLController 两个 HTTP 访问类，分别提供了两个数据库的压测操作。
- 这里提供了 Ignite、MySQL 的 HTTP 访问接口，分别进行压测。
### 1. Ignite 压测
- 初始化ID值：`ab -c 1 -n 1 http://127.0.0.1:8091/api/ignite/start`
- 写入数据：`ab -c 20 -n 50000 http://127.0.0.1:8091/api/ignite/insert`
- 随机加载内存1000条数据：`ab -c 20 -n 1000 http://127.0.0.1:8091/api/ignite/cacheData`
- 根据加载到内存的数据查询Ignite：`ab -c 20 -n 1000 http://127.0.0.1:8091/api/ignite/selectByOrderId` - 记得给 OrderId 加索引
### 2. MySQL 压测
- 初始化ID值：`ab -c 1 -n 1 http://127.0.0.1:8091/api/ignite/start`
- 写入数据：`ab -c 20 -n 50000 http://127.0.0.1:8091/api/ignite/insert`
- 随机加载内存1000条数据：`ab -c 20 -n 1000 http://127.0.0.1:8091/api/ignite/cacheData`
- 根据加载到内存的数据查询MySQL：`ab -c 20 -n 1000 http://127.0.0.1:8091/api/ignite/selectByOrderId` - 记得给 OrderId 加索引
---
**综上**，Ignite 略胜一筹，确实纯内存的数据库会更快一些。也适合在一些需要内存计算的场景中，并且不改变MySQL表结构的情况下，做一些优化的是使用。
---
### Md Road Map Intellij Idea Remote Jvm Debug (`docs/md/road-map/intellij-idea-remote-jvm-debug.md`)
---
title: IntelliJ IDEA Remote JVM Debug
lock: need
---
# IntelliJ IDEA Remote JVM Debug - 本地远程调试服务器运行代码
作者：小傅哥
127.0.0.1 `
## 四、压测验证
### 1. 本地压测
- 开启服务：xfg-dev-tech-jmeter
- 启动压测：JMeter
### 2. 脚本压测
压测命令：`jmeter -n -t one.jmx -l one.jtl`
## 五、其他工具
- [ApacheBench](https://httpd.apache.org/docs/2.4/programs/ab.html)：一个轻量级的HTTP性能测试工具，可以模拟多种类型的负载，并提供详细的测试报告。脚本：`ab -n 10 -c 2 http://localhost:8091/api/jmeter/query_order_info?orderId=100001`
- [Siege](#)：是常用的HTTP性能测试工具，可以模拟多个并发用户发送请求。脚本：`siege -c10 -r1 -p http://localhost:8091/api/jmeter/query_order_info?orderId=100001`
- [ApiPost](https://www.apipost.cn/)：自带接口简单压测模拟，安装更加简单，适合初步压测验证。
---
--- METRICS ---
- Files Extracted: 99
- Estimated Token Budget: ~201682 tokens
- Canonical Reference: https://codewiki.google/github.com/fuzhengwei/CodeGuide
- **公众号(bugstack虫洞栈)** - 沉淀、分享、成长，专注于原创专题案例，以最易学习编程的方式分享知识，让自己和他人都能有所收获。
