背景

最近更换了 windows系统的电脑， git clone 项目的时候会连接超时的错误，不管我怎么把环境变量放到终端里尝试走代理都无果，于是开始了排查

以下命令是基于 git bash 终端使用的

检测问题

通过 ssh -T git@github.com 命令查看，会报如下错误：

ssh: connect to host github.com port 22: : Connection timed out

思索了一下，难道是端口的问题吗， 于是从 overflow 上找到回答：

修改 ~/.ssh/config 路径下的内容，增加如下

Host github.com

 Hostname ssh.github.com

 Port 443

这段配置实际上是让 github.com 走 443 端口去执行，评论上有些说 22端口被占用，某些路由器或者其他程序会占用它，想了一下有道理，于是使用 vim ~/.ssh/config 编辑加上，结果...

ssh: connect to host github.com port 443: : Connection timed out

正当我苦苦思索，为什么 ping github.com 超时的时候，脑子里突然回忆起那道久违的八股文面试题： “url输入网址到浏览器上会发生什么"，突然顿悟：是不是DNS解析出了问题，找不到服务器地址？

网上学到一行命令，可以在终端里看DNS服务器的域名解析

nslookup baidu.com

先执行一下 baidu.com 的，得到如下：

Server:		119.6.6.6

Address:	119.6.6.6#53



Non-authoritative answer:

Name:	baidu.com

Address: 110.242.68.66

Name:	baidu.com

Address: 39.156.66.10

再执行一下 nslookup github.com ，果然发现不对劲了：

Name:	github.com

Address: 127.0.0.1

返回了 127.0.0.1，这不对啊，笔者可是读过书的，这是本地的 IP 地址啊，原来是这一步出了问题..

解决问题

大部分同学应该都改过本地的 DNS 域名映射文件，这也是上面那道八股文题中回答的知识点之一，我们打开资源管理器输入一下路径改一下：

C:\Windows\System32\drivers\etc\hosts

MacOs的同学可以在终端使用 sudo vi /etc/hosts 命令修改

在下面加上下面这一行， 其中 140.82.113.4 是 github 的服务器地址，添加后就可以走本地的域名映射了

140.82.113.4 github.com

保存之后，就可以不使用代理，快乐访问 github.com 了，笔者顺利的完成了梦想第一步： git clone

结语

我是饮东，欢迎点赞关注，我们江湖再会

大家好，我是G探险者。

项目里，因为我使用了Lombok插件，然后代码走查的时候被领导点名了。

我心想，这么好用的插件，为啥不推广呢，整天写那些烦人的setter，getter方法就不嫌烦么？

领导既然不让用，自然有他的道理。

于是我查了一番关于lombok的一些绯闻。就有了这篇文章。

首先呢，Lombok 是一个在 Java 项目中广泛使用的库，旨在通过注解自动生成代码，如 getter 和 setter 方法，以减少重复代码并提高开发效率。然而，Lombok 的使用也带来了一些挑战和争议，特别是关于代码的可读性和与 Java Bean 规范的兼容性。

Lombok 基本使用

示例代码

不使用 Lombok:

public class User {

    private String name;

    private int age;



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    // 其他 getter 和 setter

}

使用 Lombok:

import lombok.Data;



@Data

public class User {

    private String name;

    private int age;

    // 无需显式编写 getter 和 setter

}

Lombok 的争议

下面我就列举一个例子进行说明。

属性命名的例子

假设有这么一个属性，aName;

标准 Java Bean 规范下：

• 属性 aName 的setter getter 方法应为 setaName() getaName()。


• 但是 Lombok 可能生成 getAName()。

这是因为Lombok 在生成getter和setter方法时，将属性名的首字母也大写，即使它是小写的。所以对于aName属性，Lombok生成的方法可能是getAName()和setAName()。

在处理JSON到Java对象的映射时，JSON解析库（如Jackson或Gson）会尝试根据Java Bean规范匹配JSON键和Java对象的属性。它通常期望属性名的首字母在getter和setter方法中是小写的。因此，如果JSON键为"aName"，解析库会寻找setaName()方法。

所以，当你使用Lombok的@Data注解，且Lombok生成的setter方法为setAName()时，JSON解析库可能找不到匹配的方法来设置aName属性，因为它寻找的是setaName()。

这种差异可能在 JSON 到 Java 对象的映射中引起问题。

Java Bean 命名规范

根据 Java Bean 规范，属性名应遵循驼峰式命名法：

• 单个单词的属性名应全部小写。


• 多个单词组成的属性名每个单词的首字母通常大写。

结论

Lombok 是一个有用的工具，可以提高编码效率并减少冗余代码。但是，在使用它时，团队需要考虑其对代码可读性、维护性和与 Java Bean 规范的兼容性。在决定是否使用 Lombok 时，项目的具体需求和团队的偏好应该是主要的考虑因素。

使用JWT进行用户认证和授权，而Session在一定程度上起到了辅助作用。
让我们详细讨论JWT和Session在这种结合模式中的各自作用以及为什么需要Session。

JWT的作用

Session的作用

为什么需要创建Session

尽管JWT可以在无状态环境中使用，但Session的引入带来了以下好处：

结合JWT和Session的优势

结合使用JWT和Session，可以同时利用两者的优点，实现安全性和扩展性的平衡：

代码示例

以下是一个简化的代码示例，展示了如何在用户登录时创建JWT和Session：

java

Copy code

public LoginResponse login(String username, String password) throws AuthException {

    // 验证用户名和密码

    User user = userService.authenticate(username, password);

    if (user == null) {

        throw new AuthException("Invalid username or password");

    }

    

    // 生成JWT Token

    String token = createJwt(user.getId(), user.getRoles());

    

    // 创建会话

    sessionManagerApi.createSession(token, user);

    

    // 返回Token

    return new LoginResponse(token);

}



public void createSession(String token, User user) {

    LoginUser loginUser = new LoginUser();

    loginUser.setToken(token);

    loginUser.setUserId(user.getId());

    loginUser.setRoles(user.getRoles());

    

    sessionManagerApi.saveSession(token, loginUser);

}

在请求验证时，首先验证JWT的有效性，然后检查Session中是否存在对应的会话：

java

Copy code

@Override

public DefaultJwtPayload validateToken(String token) throws AuthException {

    try {

        // 1. 先校验jwt token本身是否有问题

        JwtContext.me().validateTokenWithException(token);



        // 2. 获取jwt的payload

        DefaultJwtPayload defaultPayload = JwtContext.me().getDefaultPayload(token);



        // 3. 如果是7天免登陆，则不校验session过期

        if (defaultPayload.getRememberMe()) {

            return defaultPayload;

        }



        // 4. 判断session里是否有这个token

        LoginUser session = sessionManagerApi.getSession(token);

        if (session == null) {

            throw new AuthException(AUTH_EXPIRED_ERROR);

        }



        return defaultPayload;

    } catch (JwtException jwtException) {

        if (JwtExceptionEnum.JWT_EXPIRED_ERROR.getErrorCode().equals(jwtException.getErrorCode())) {

            throw new AuthException(AUTH_EXPIRED_ERROR);

        } else {

            throw new AuthException(TOKEN_PARSE_ERROR);

        }

    } catch (io.jsonwebtoken.JwtException jwtSelfException) {

        throw new AuthException(TOKEN_PARSE_ERROR);

    }

}

总结

在这个场景中，JWT用于无状态的用户认证，提供便捷和扩展性；Session作为辅助，提供额外的安全性和状态管理。通过这种结合，可以充分利用两者的优点，确保系统既具备高扩展性，又能提供细致的安全控制。

之前与同事讨论接口性能问题时听他介绍了一种缓存设计思路，觉得不错，做个记录供以后参考。

场景

假设有个以下格式的接口：

GET /api?keys={key1,key2,key3,...}&types={1,2,3,...}

其中 keys 是业务主键列表，types 是想要取到的信息的类型。

请求该接口需要返回业务主键列表对应的业务对象列表，对象里需要包含指定类型的信息。

业务主键可能的取值较多，千万量级，type 取值范围为 1-10，可以任意组合，每种 type 对应到数据库是 1-N 张表，示意：

现在设想这个接口遇到了性能瓶颈，打算添加 Redis 缓存来改善响应速度，应该如何设计？

设计思路

方案一：

最简单粗暴的方法是直接使用请求的所有参数作为缓存 key，请求的返回内容为 value。

方案二：

如果稍做一下思考，可能就会想到文首我提到的觉得不错的思路了：

小结

在以上两种方案之间做评估和选择，考虑几个方面：

• 缓存命中率；


• 缓存数量、占用空间大小；


• 刷新缓存是否方便；

稍作思考和计算，就会发现此场景下方案二的优势。

另外，就是需要根据实际业务场景，如业务对象复杂度、读写次数比等，来评估合适的缓存数据的粒度和层次，是对应到某一级组合后的业务对象（缓存值对应存储 + 部分逻辑），还是最基本的数据库表/字段（存储的归存储，逻辑的归逻辑）。

• 💂 个人网站: IT知识小屋


• 🤟 版权: 本文由【IT学习日记】原创、需要转载请联系博主


• 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦

写在前面

大家好，这里是IT学习日记。今日推荐项目：tianai-captcha行为验证码工具。

1000+优质开源项目推荐进度：6/1000。如需更多类型优质项目推荐，请在文章后留言。

工具简介

tianai-captcha行为验证码工具：分为 Go 和 Java 两个版本。支持多种验证方式，包括随机验证、曲线匹配、滑块验证、增强版滑块验证、旋转验证、滑动还原、角度验证、刮刮乐、文字点选、图标点选及语序点选等。

该系统能够快速集成到个人项目或系统中，显著提高开发效率。

功能展示

• 随机型验证码

• 曲线匹配验证码

• 滑动验证增强版验证码

• 滑块验证码

• 旋转验证码

• 滑动还原验证码

• 角度验验证码

• 刮刮乐验验证码

• 文字点选验证码

• 图标验证码

架构设计

tianai-captcha 验证码整体分为 生成器(ImageCaptchaGenerator)、校验器(ImageCaptchaValidator)、资源管理器(ImageCaptchaResourceManager) 其中生成器、校验器、资源管理器等都是基于接口模式实现可插拔的，可以替换为自定义实现，灵活度高

• 生成器 (ImageCaptchaGenerator)
  
  主要负责生成行为验证码所需的图片。


• 校验器 (ImageCaptchaValidator)
  
  主要负责校验用户滑动的行为轨迹是否合规。


• 资源管理器 (ImageCaptchaResourceManager)
  
  主要负责读取验证码背景图片和模板图片等。
  
  
  
  
  • 资源存储 (ResourceStore)
    
    负责存储背景图和模板图。
  
  
  • 资源提供者 (ResourceProvider)
    
    负责将资源存储器中对应的资源转换为文件流。一般资源存储器中存储的是图片的 URL 地址或 ID，资源提供者则负责将 URL 或其他 ID 转换为真正的图片文件。
  
  
  
  


• 图片转换器 (ImageTransform)
  
  主要负责将图片文件流转换成字符串类型，可以是 Base64 格式、URL 或其他加密格式，默认实现为 Base64 格式。

工具集成

引入依赖

<!-- maven 导入 -->

<dependency>

    <groupId>cloud.tianai.captcha</groupId>

    <artifactId>tianai-captcha</artifactId>

    <version>1.4.1</version>

</dependency>

• 使用 ImageCaptchaGenerator生成器生成验证码

public class Test {

    public static void main(String[] args) throws InterruptedException {

        ImageCaptchaResourceManager imageCaptchaResourceManager = new DefaultImageCaptchaResourceManager();

        ImageTransform imageTransform = new Base64ImageTransform();

        ImageCaptchaGenerator imageCaptchaGenerator = new MultiImageCaptchaGenerator(imageCaptchaResourceManager,imageTransform).init(true);

        /*

                生成滑块验证码图片, 可选项

                SLIDER (滑块验证码)

                ROTATE (旋转验证码)

                CONCAT (滑动还原验证码)

                WORD_IMAGE_CLICK (文字点选验证码)



                更多验证码支持 详见 cloud.tianai.captcha.common.constant.CaptchaTypeConstant

         */

        ImageCaptchaInfo imageCaptchaInfo = imageCaptchaGenerator.generateCaptchaImage(CaptchaTypeConstant.SLIDER);

        System.out.println(imageCaptchaInfo);



        // 负责计算一些数据存到缓存中，用于校验使用

        // ImageCaptchaValidator负责校验用户滑动滑块是否正确和生成滑块的一些校验数据; 比如滑块到凹槽的百分比值

        ImageCaptchaValidator imageCaptchaValidator = new BasicCaptchaTrackValidator();

        // 这个map数据应该存到缓存中，校验的时候需要用到该数据

        Map<String, Object> map = imageCaptchaValidator.generateImageCaptchaValidData(imageCaptchaInfo);

    }

}

• 使用ImageCaptchaValidator校验器 验证

public class Test2 {

    public static void main(String[] args) {

        BasicCaptchaTrackValidator sliderCaptchaValidator = new BasicCaptchaTrackValidator();



        ImageCaptchaTrack imageCaptchaTrack = null;

        Map<String, Object> map = null;

        Float percentage = null;

        // 用户传来的行为轨迹和进行校验

        // - imageCaptchaTrack为前端传来的滑动轨迹数据

        // - map 为生成验证码时缓存的map数据

        boolean check = sliderCaptchaValidator.valid(imageCaptchaTrack, map).isSuccess();

//        // 如果只想校验用户是否滑到指定凹槽即可，也可以使用

//        // - 参数1 用户传来的百分比数据

//        // - 参数2 生成滑块是真实的百分比数据

        check = sliderCaptchaValidator.checkPercentage(0.2f, percentage);

    }

}

工具获取

工具下载：gitee.com/dromara/tia…

在线体验：captcha.tianai.cloud/

如果这篇文章对您有帮助，请**“彦祖们”**一定帮我点个 “关注” 和 “点赞”,这对我非常重要。我将会继续推荐更多优质项目和新闻。

爬虫学得好，牢饭吃得饱！！！切记！！！

相信大家多少都会接触过爬虫相关的需求吧，爬虫在绝大多数场景下，能够帮助客户自动的完成部分工作，极大的减少人工操作。目前更多的实现方案可能都是以python为实现基础，但是作为java程序员，咱们需要知道的是，以java 的方式，仍然可以很方便、快捷的实现爬虫。下面将会给大家介绍两种以java为基础的爬虫方案，同时提供案例供大家参考。

一、两种方案

传统的java实现爬虫方案，都是通过jsoup的方式，本文将采用一款封装好的框架【webmagic】进行实现。同时针对一些特殊的爬虫需求，将会采用【selenium-java】的进行实现，下面针对两种实现方案进行简单介绍和演示配置方式。

1.1 webmagic

官方文档：webmagic.io/

1.1.1 简介

使用webmagic开发爬虫，能够非常快速的实现简单且逻辑清晰的爬虫程序。

四大组件

• Downloader：下载页面


• PageProcessor：解析页面


• Scheduler：负责管理待抓取的URL，以及一些去重的工作。通常不需要自己定制。


• Pipeline：获取页面解析结果，数持久化。

Spider

• 启动爬虫，整合四大组件

1.1.2 整合springboot

webmagic分为核心包和扩展包两个部分，所以我们需要引入如下两个依赖：

<properties>

    <webmagic.version>0.7.5</webmagic.version>

</properties>



<!--WebMagic-->

<dependency>

    <groupId>us.codecraft</groupId>

    <artifactId>webmagic-core</artifactId>

    <version>${webmagic.version}</version>

</dependency>

<dependency>

    <groupId>us.codecraft</groupId>

    <artifactId>webmagic-extension</artifactId>

    <version>${webmagic.version}</version>

</dependency>

到此为止，我们就成功的将webmagic引入进来了，具体使用，将在后面的案例中详细介绍。

1.2 selenium-java

官网地址：http://www.selenium.dev/

1.2.1 简介

selenium是一款浏览器自动化工具，它能够模拟用户操作浏览器的交互。但前提是，我们需要在使用他的机器（windows/linux等）安装上它需要的配置。相比于webmigc的安装，它要繁琐的多了，但使用它的原因，就是为了解决一些webmagic做不到的事情。

支持多种语言：java、python、ruby、javascript等。其使用代码非常简单，以java为例如下：

package dev.selenium.hello;



import org.openqa.selenium.WebDriver;

import org.openqa.selenium.chrome.ChromeDriver;



public class HelloSelenium {

    public static void main(String[] args) {

        WebDriver driver = new ChromeDriver();



        driver.get("https://selenium.dev");



        driver.quit();

    }

}

1.2.2 安装

无论是在windows还是linux上使用selenium，都需要两个必要的组件：

• 浏览器（chrome）


• 浏览器驱动 （chromeDriver）

需要注意的是，要确保上述两者的版本保持一致。

下载地址

chromeDriver：chromedriver.storage.googleapis.com/index.html

windows

windows的安装相对简单一些，将chromeDriver.exe下载至电脑，chrome浏览器直接官网下载相应安装包即可。严格保证两者版本一致，否则会报错。

在后面的演示程序当中，只需要通过代码指定chromeDriver的路径即可。

linux

linux安装才是我们真正的使用场景，java程序通常是要部署在linux环境的。所以我们需要linux的环境下安装chrome和chromeDriver才能实现想要的功能。

首先要做的是判断我们的linux环境属于哪种系统，是ubuntu、centos还是其他的种类，相应的shell脚本都是不同的。

我们采用云原生的环境，所有的服务均以容器的方式部署，所以要在每一个服务端容器内部安装chrome和chromeDiver。我们使用的是Alpine Linux，一个轻量级linux发行版，非常适合用来做Docker镜像。

我们可以通过apk --help去查看相应的命令，我直接给出安装命令：

# Install Chrome for Selenium

RUN apk add gconf

RUN apk add chromium

RUN apk add chromium-chromedriver

上面的内容，可以放在DockerFile文件中，在部署的时候，会直接将相应组件安装在容器当中。

需要注意的是，在Alpine Linux中自带的浏览器是chromium和chromium-chromedriver，且版本相应较低，但是足够我们的需求所使用了。

/ # apk search chromium

chromium-68.0.3440.75-r0

chromium-chromedriver-68.0.3440.75-r0

1.2.3 整合springboot

我们只需要在爬虫模块引入依赖就好了：

<dependency>

    <groupId>org.seleniumhq.selenium</groupId>

    <artifactId>selenium-java</artifactId>

</dependency>

二、三个案例

下面通过三个简单的案例，给大家实际展示使用效果。

2.1 爬取省份街道

使用webmagic进行省份到街道的数据爬取。注意，本文只提供思路，不提供具体爬取网站信息，请同学们自己根据使用选择。

接下来搭建webmagic的架子，其中有几个关键点：

• 创建页面解析类，实现PageProcessor。

import us.codecraft.webmagic.Page;

import us.codecraft.webmagic.Site;

import us.codecraft.webmagic.processor.PageProcessor;



/**

 * 页面解析

 *

 * @author wjbgn

 * @date 2023/8/15 17:25

 **/

public class TestPageProcessor implements PageProcessor {

    @Override

    public void process(Page page) {



    }



    @Override

    public Site getSite() {

        return site;

    }

    

    /**

     * 初始化Site配置

     */

    private Site site = Site.me()

            // 重试次数

            .setRetryTimes(3)

            //编码

            .setCharset(StandardCharsets.UTF_8.name())

            // 超时时间

            .setTimeOut(10000)

            // 休眠时间

            .setSleepTime(1000);

    }

• 实现PageProcessor后，要重写其方法process(Page page)，此方法是我们实现爬取的核心（页面解析）。通常省市区代码分为6级，所以常见的网站均是按照层级区分，我们是从省份开始爬取，即从第三层开始爬取。
  
  
  
  
  • 初始化变量
  
  
  
  

  @Override
  
  public void process(Page page) {
  
      // 市级别
  
      Integer type = 3;
  
      // 初始化结果明细
  
      RegionCodeDTO regionCodeDTO = new RegionCodeDTO();
  
      // 带有父子关系的结果集合
  
      List<Map<String, Object>> list = new ArrayList();
  
      // 页面所有元素集合
  
      List<String> all = new ArrayList<>();
  
      // 页面中子页面的链接地址
  
      List<String> urlList = new ArrayList<>();
  
  }
  
  

  
  
  
  
  • 根据不同级别，获取相应页面不同的元素
  
  
  
  

  if (CollectionUtil.isEmpty(all)) {
  
      // 爬取所有的市,编号，名称
  
      all = page.getHtml().css("table.citytable").css("tr").css("a", "text").all();
  
      // 爬取所有的城市下级地址
  
      urlList = page.getHtml().css("table.citytable").css("tr").css("a", "href").all()
  
              .stream().distinct().collect(Collectors.toList());
  
      if (CollectionUtil.isEmpty(all)) {
  
          // 区县级别
  
          type = 4;
  
          all = page.getHtml().css("table.countytable").css("tr.countytr").css("td", "text").all();
  
          // 获取区
  
          all.addAll(page.getHtml().css("table.countytable").css("tr.countytr").css("a", "text").all());
  
  
  
          urlList = page.getHtml().css("table.countytable").css("tr").css("a", "href").all()
  
                  .stream().distinct().collect(Collectors.toList());
  
          if (CollectionUtil.isEmpty(all)) {
  
              // 街道级别
  
              type = 5;
  
              all = page.getHtml().css("table.towntable").css("tr").css("a", "text").all();
  
              urlList = page.getHtml().css("table.towntable").css("tr").css("a", "href").all()
  
                      .stream().distinct().collect(Collectors.toList());
  
              if (CollectionUtil.isEmpty(all)) {
  
                  // 村，委员会
  
                  type = 6;
  
                  List<String> village = new ArrayList<>();
  
                  all = page.getHtml().css("table").css("tr.villagetr").css("td", "text").all();
  
                  for (int i = 0; i < all.size(); i++) {
  
                      if (i % 3 != 1) {
  
                          village.add(all.get(i));
  
                      }
  
                  }
  
                  all = village;
  
              }
  
          }
  
      }
  
  }
  
  

  
  
  
  
  • 定义一个实体类RegionCodeDTO，用来存放临时获取的code，url以及父子关系等内容：
  
  
  
  

  public class RegionCodeDTO {
  
  
  
      private String code;
  
  
  
      private String parentCode;
  
  
  
      private String name;
  
  
  
      private Integer type;
  
  
  
      private String url;
  
  
  
      private List<RegionCodeDTO> regionCodeDTOS;
  
  }
  
  

  
  
  
  
  • 接下来对页面获取的内容（code、name、type）进行组装和临时存储，添加到children中：
  
  
  
  

  // 初始化子集
  
  List<RegionCodeDTO> children = new ArrayList<>();
  
  // 初始化临时节点数据
  
  RegionCodeDTO region = new RegionCodeDTO();
  
  // 解析页面结果集all当中的数据，组装到region 和 children当中
  
  for (int i = 0; i < all.size(); i++) {
  
      if (i % 2 == 0) {
  
          region.setCode(all.get(i));
  
      } else {
  
          region.setName(all.get(i));
  
      }
  
      if (StringUtils.isNotEmpty(region.getCode()) && StringUtils.isNotEmpty(region.getName())) {
  
          region.setType(type);
  
          // 添加子集到集合当中
  
          children.add(region);
  
          // 重新初始化
  
          region = new RegionCodeDTO();
  
      }
  
  }
  
  

  
  
  
  
  • 组装页面链接，并将页面链接组装到children当中。
  
  
  
  

  // 循环遍历页面元素获取的子页面链接
  
  for (int i = 0; i < urlList.size(); i++) {
  
      String url = null;
  
      if (StringUtils.isEmpty(urlList.get(0))) {
  
          continue;
  
      }
  
      // 拼接链接，页面的子链接是相对路径，需要手动拼接
  
      if (urlList.get(i).contains(provinceEnum.getCode() + "/")) {
  
          url = provinceEnum.getUrlPrefixNoCode();
  
      } else {
  
          url = provinceEnum.getUrlPrefix();
  
      }
  
      // 将链接放到临时数据子集对象中
  
      if (urlList.get(i).substring(urlList.get(i).lastIndexOf("/") + 1, urlList.get(i).indexOf(".html")).length() == 9) {
  
          children.get(i).setUrl(url + page.getUrl().toString().substring(page.getUrl().toString().indexOf(provinceEnum.getCode() + "/") + 3
  
                  , page.getUrl().toString().lastIndexOf("/")) + "/" + urlList.get(i));
  
      } else {
  
          children.get(i).setUrl(url + urlList.get(i));
  
      }
  
  }
  
  

  
  
  
  
  • 将children添加到结果对象当中
  
  
  
  

  // 将子集放到集合当中
  
  regionCodeDTO.setRegionCodeDTOS(children);
  
  

  
  
  
  
  • 在下面的代码当中将进行两件事儿：
    
    
    
    
    • 处理下一页，通过page的addTargetRequests方法，可以进行下一页的跳转，此方法参数可以是listString和String，即支持多个页面跳转和单个页面的跳转。
    
    
    • 将数据传递到Pipeline，用于数据的存储，Pipeline的实现将在后面具体说明。
    
    
    
    
  
  
  
  

  // 定义下一页集合
  
  List<String> nextPage = new ArrayList<>();
  
  // 遍历上面的结果子集内容
  
  regionCodeDTO.getRegionCodeDTOS().forEach(regionCodeDTO1 -> {
  
      // 组装下一页集合
  
      nextPage.add(regionCodeDTO1.getUrl());
  
      // 定义并组装结果数据
  
      Map<String, Object> map = new HashMap<>();
  
      map.put("regionCode", regionCodeDTO1.getCode());
  
      map.put("regionName", regionCodeDTO1.getName());
  
      map.put("regionType", regionCodeDTO1.getType());
  
      map.put("regionFullName", regionCodeDTO1.getName());
  
      map.put("regionLevel", regionCodeDTO1.getType());
  
      list.add(map);
  
      // 推送数据到pipeline
  
      page.putField("list", list);
  
  });
  
  // 添加下一页集合到page
  
  page.addTargetRequests(nextPage);
  
  

  
  


• 当本次process方法执行完后，将会根据传递过来的链接地址，再次执行process方法，根据前面定义的读取页面元素流程的代码，将不符合type=3的内容，所以将会进入到下一级4的爬取过程，5、6级别原理相同。
  
  

  



• 创建Pipeline，用于编写数据持久化过程。经过上面的逻辑，已经将所需内容全部获取到，接下来将通过pipline进行数据存储。首先定义pipeline，并实现其process方法，获取结果内容，具体存储数据的代码就不展示了，需要注意的是，此处pipeline没有通过spring容器托管，需要调用业务service需要使用SpringUtils进行获取：
  
  

  public class RegionDataPipeline implements Pipeline{
  
  
  
  
  
  @Override
  
  public void process(ResultItems resultItems, Task task) {
  
  // 获取service
  
  IXXXXXXXXXService service = SpringUtils.getBean(IXXXXXXXXXService.class);
  
  // 获取内容
  
  List<Map<String, String>> list = (List<Map<String, String>>) resultItems.getAll().get("list");
  
  // 解析数据，转换为对应实体类
  
  // service.saveBatch
  
  }
  
  

  
  


• 启动爬虫
  
  

  //启动爬虫
  
  Spider.create(new RegionCodePageProcessor(provinceEnum))
  
          .addUrl(provinceEnum.getUrl())
  
          .addPipeline(new RegionDataPipeline())
  
          //此处不能小于2
  
          .thread(2).start()
  
  

  
  

2.2 爬取网站静态图片

爬取图片是最常见的需求，我们通常爬取的网站都是静态的网站，即爬取的内容都在网页上面渲染完成的，我们可以直接通过获取页面元素进行抓取。

可以参考下面的文章，直接拉取网站上的图片：juejin.cn/post/705138…

针对获取到的图片网络地址，直接使用如下方式进行下载即可：

url = new URL(imageUrl);

//打开连接

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

//设置请求方式为"GET"

conn.setRequestMethod("GET");

//超时响应时间为10秒

conn.setConnectTimeout(10 * 1000);

//通过输入流获取图片数据

InputStream is = conn.getInputStream();

2.3 爬取网站动态图片

在2.2中我们可以很快地爬取到对应的图片，但是在另外两种场景下，我们获取图片将会不适用上面的方式：

• 需要拼图，且多层的gis相关图片，此种图片将会在后期进行复杂的图片处理（按位置拼接瓦片，多层png图层叠加），才能获取到我们想要的效果。


• 动态js加载的图片，直接无法通过css、xpath获取。

所以在这种情况下我们可以使用开篇介绍的selenium-java来解决，本文使用的仅仅是截图的功能，来达到我们需要的效果。具体街区全屏代码如下所示：

public File getItems() {

    // 获取当前操作系统

    String os = System.getProperty("os.name");

    String path;

    if (os.toLowerCase().startsWith("win")) {

        //windows系统

        path = "driver/chromedriver.exe";

    } else {

        //linux系统

        path = "/usr/bin/chromedriver";

    }

    WebDriver driver = null;

    // 通过判断 title 内容等待搜索页面加载完毕，间隔秒

    try {

        System.setProperty("webdriver.chrome.driver", path);

        ChromeOptions chromeOptions = new ChromeOptions();

        chromeOptions.addArguments("--headless");

        chromeOptions.addArguments("--no-sandbox");

        chromeOptions.addArguments("--disable-gpu");

        chromeOptions.addArguments("--window-size=940,820");

        driver = new ChromeDriver(chromeOptions);

        // 截图网站地址

        driver.get(UsaRiverConstant.OBSERVATION_POINT_URL);

        // 休眠用于网站加载

        Thread.sleep(15000);

        // 截取全屏

        File screenshotAs = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);

        return screenshotAs;

    } catch (Exception e) {

        throw new RuntimeException(e);

    } finally {

        driver.quit();

    }

}

如上所示，我们获取的是整个页面的图片，还需要对截取的图片进行相应的剪裁，保留我们需要的区域，如下所示：

public static void cutImg(InputStream inputStream, int x, int y, int width, int height, OutputStream outputStream) {//图片路径，截取位置坐标,输出新突破路径

    InputStream fis = inputStream;

    try {

        BufferedImage image = ImageIO.read(fis);

        //切割图片

        BufferedImage subImage = image.getSubimage(x, y, width, height);

        Graphics2D graphics2D = subImage.createGraphics();

        graphics2D.drawImage(subImage, 0, 0, null);

        graphics2D.dispose();

        //输出图片

        ImageIO.write(subImage, "png", outputStream);

    } catch (IOException e) {

        e.printStackTrace();

    } finally {

        try {

            fis.close();

        } catch (IOException e) {

            throw new RuntimeException(e);

        }

    }

}

三、小结

通过如上两个组件的简单介绍，足够应付在java领域的大多数爬取场景。从页面数据、到静态网站图片，在到动态网站的图片截取。本文以提供思路为主，原理请参考相应的官方文档。

爬虫学得好，牢饭吃得饱！！！切记！！！

前言

Hi 你好，我是东东拿铁，一个正在探索个人IP&副业的后端程序员。

今天我想和大家聊一段我自己毕业初期的一段经历，当领导给你安排了无从下手的任务，难以解决的技术问题时，该怎么办？

本文会从我的一段经历出发，分析在初入职场、刚刚成为一个程序的时候，遇到自己无解决的问题，和自己的一些解决问题的思考。

如果你工作不满三年，一定要往下看，相信一定会对你有帮助。但如果你已经工作3年以上，那么你应该不会遇到下面的问题啦，但也欢迎你往下看，也许会有不同的收获。

先讲故事

每个人都有自己的职场新人期，这个阶段你会敏感、迷茫。

记得在毕业的2个月后，我的组长给我布置了一个任务，实现服务的热部署。

热部署是什么？

热部署是一种技术，它允许在应用程序运行时不中断地更新或替换软件组件，如代码或配置。这种技术主要应用于Web应用程序和分布式系统中，旨在减少停机时间，提高开发效率，并增强应用程序的可用性。

那时候我们的服务器是单实例，每次升级，一定要先停掉服务，替换war包，然后重启tomcat。想升级，必须要在半夜客户下班的时候升级。

作为一个职场小白，技术小白，第一次接到这种任务的时候，我整个人是一脸懵逼的。

那时候报错的堆栈信息我都看不懂，还得请教组里的同事，CRUD还没整明白呢。就要去解决这个架构问题，可想而知我那时候有多崩溃。

其实选择让我一个毕业2个月的应届生来做，能发现两个基本的背景

• 公司没有标准化的解决方案，没有人知道你的解决方案是否对错。


• 包括我的组长、组内老同事在内，也没有人了解如何在生产环境实现热部署，没人可以提供帮助。

因此在这件事的起步阶段，非常的困难。最重要的是，我还不会调研行业的标准方案是什么，刚毕业的我只能埋头苦干，不断试错。

持续的没有进展，也让我内心非常焦虑。多次周会上被问及这件事情，也完全不知道如何汇报进展，因为我自己也不知道，到底什么时候能解决。

记得那时候上厕所、接水的时候，我都是低头不语，装作看不见，生怕他问我一句：“那件事情的进度怎么样了？”

现在想起自己那时候的无助和不安，我都会微微一笑。

很庆幸是在计算机行业，即使是用百度，也能够搜到大把的信息，那段时间也了解到了像Nginx、Redis这样的中间件，最终也是用Nginx，实现了最基本的目标，可以在保证客户使用的情况下，正常的升级我们的系统了。

是的，毕业后的第一家公司的负载均衡和不停机服务发布，是由一个小小毕业生来做的，前期内心有多煎熬，上线的那一刻就有多自豪。

故事讲完了，我相信很多职场人，都会面临这样的场景吧，或许是一个功能不知道怎么去实现，又或者一个方案不知道如何去设计，不敢面对，不敢说出来。

为什么会这样

在职场中，我们大概可以用四个阶段概括

上面我自己的一小段经历，遇到了新人期中最容易面临的问题，技能上的迷茫，和职场上的迷茫。

技能上的迷茫

我们可能发现自己有好多东西不会，什么都要学，却不知道自己该如何入手。

在大厂里，周围人看起来都是大牛，可以看着他们侃侃而谈，虽然自己只能茫然四顾，但起码有着标杆和榜样。

而在普通传统行业，身边连个会的人都没有，自己的摸索更像是盲人摸象。

职场上的迷茫

不知道事情该办成什么样，领导会不会不满意，对我的考核会不会有影响。

又或者主动说了有困难，领导会不会觉得我能力不足？

面对多重困难，我该如何汇报自己的进度？没有进度怎么办。

思考、建立正确的认知

界定问题，比问题本身要重要

技术日新月异，新技术是学不完的，解决问题的方式更是多种多样的。所有成熟的方案，都不是一蹴而就的，而是通过发现问题、解决问题一步步优化完善来的。

所以我们有一个清晰的认知，我们很难得到最优的解决方案，而是把注意力放在问题本身，看看我们到底要解决什么问题。

例如我一开始不知道热部署的含义，但我知道的是，公司想解决服务的不停机升级问题。那么我最终引入了Nginx，通过反向代理，部署多个服务就好了。提供的解决方案，完成了预期，我认为对于一个新人来讲就是合格的。

PS：事实上我在使用了Nginx完成了负载均衡后，我的组长曾和我说，你这个方案感觉不太行，不是领导想要的效果。但点到为止了，也没有什么指导，或者改进措施，最终也用这个方案在生产去部署。

注重当下

职场规则是明确的，可以在员工手册、职级要求中看到。但职场中的潜规则是不明确的，你无法摸清领导最真实的想法。

为什么这么说呢？

• 领导可能就是想历练你，给你有挑战的事情，想看看你做到什么程度，你的能力边界在哪里


• 领导对你的预期就是能够解决，也不需要他的指导

不同的想法，对你的要求截然不同。

历练你的时候，即使事情没有结果，领导也不会多说什么，或许这就是一个当下受限于公司运维、资源而难以做到的事情。

但领导相信你能够解决问题的时候，你必须要尽量完成，不然确实会影响到对你的一些看法。

对于职场新手期，你短时间内是无法建立一个良好的向上沟通渠道的（如何建立向上沟通渠道，我们后面再说）。所以对你而言，与其揣摩想法， 不如界定好问题，然后注重当下，解决好遇到的每一个困难。

两个方法

目标拆分

有一个关于程序员的经典段子：这个工作已经做完了80%，剩下的**20%**还要用和前面的一样时间。

遇到无从下手，不知如何去解决的问题，是怎么给出一个可执行的分解。

重点来了，拆分的，一定要可执行。每个人对于可执行的区分，是有很大不同的。不同的地方在于可执行的定义，你是否能清楚地知道这个问题该如何解决。

比如文章开头的故事，如果时间回到那一刻，我会这么列出计划

学会借力

手里有把锤子,看见什么都是钉子。

我们更倾向于用我们手里的某种工具，去解决所有问题。

在遇到问题时，我们的大脑会根据以往经验做出预判，从而形成思维定势，使得我们倾向于使用熟悉的工具或方法来解决问题。然而，并不是所有问题都是钉子，一旦碰到超出我们经验边界的事情，我们可能会束手无策。

还是分享一段经历：

在字节的时候，我遇到过一个问题场景，就是如何保证集群服务器的本地缓存，保持一致。

直白来讲，我要开一个500人的会议，我准备了500份资料，那么在资料可能会修改的情况下，如何保证大家手里资料，都是最新的？

加载、更新，我能想到的就是用消息队列广播，系统收到消息的时候，每一台服务器都走一遍加载逻辑。

但有一个问题我解决不了，几百台服务器同时请求，如何解决突发的压力问题呢？如果500个人同时去找会议组织人打印，排队不说了，打印机得忙冒烟。

我给身边的一个技术大拿说了我的问题，他说，你可以用公司的一个中间件啊，数据只需要一次加载，然后服务器去下载就好了。是哈，用一个超级打印机打印出500份，分发下去就好了，不用每个人亲自来取呀。

就是几句点拨，同步给我了这一个信息，我了解了一下这个中间件，完美解决了我的问题。

因此，学会借力。找到公司大佬，找到网上的大佬，买杯咖啡、发个红包，直接了当的说出你的问题，咨询解决方案，从更高层次，降维打击你的问题。

当然，一定要在自己思考完、没有结果的情况下，再去请教，能够自己研究明白的，比如使用相关的，不要去麻烦别人。

说在最后

文章到这里就要结束啦，很感谢你能看到最后。

职场初期遇到无从下手的任务时，我们应该建立正确的认知，界定问题，并注重当下。

也分享给你了两个行之有效的方法，目标拆分和学会借力，当然，这一切都离不开你的行动和坚持，这不是方法，而是一个技术人最基本的素质，所以就不多说啦。

不知道你在职场中初期遇到无从下手的问题时，你是怎么处理的呢，欢迎你在评论区和我分享，也希望你点赞、评论、收藏，让我知道对你有所收获，这对我来说很重要。也欢迎你加我的wx：Ldhrlhy10，让我做你的垫脚石，帮你解决你遇到的问题呀，欢迎一起交流～

本文介绍了美团到家/站外投放团队在多场景建模技术方向上的探索与实践。基于外部投放的业务背景，本文提出了一种自适应的场景知识迁移和场景聚合技术，解决了在投放中面临外部海量流量带来的场景数量丰富、场景间差异大的问题，取得了明显的效果提升。希望能给大家带来一些启发或帮助。

1 引言

美团到家Demand-Side Platform（下文简称DSP）平台，主要负责在美团外部媒体上进行商品或者物料的推荐和投放，并不断优化转化效果。随着业务的不断发展与扩大，DSP对接的外部渠道越来越丰富、展示形式越来越多样，物料展示场景的差异性愈发明显（如开屏、插屏、信息流、弹窗等）。

例如，用户在午餐时间更容易点击【某推荐渠道下】【某App】【开屏展示位】的快餐类商家的物料而不是【信息流展示位】的啤酒烧烤类商家物料。场景间差异的背后本质上是用户意图和需求的差异，因此模型需要对越来越多的场景进行定制化建设，以适配不同场景下用户的个性化需求。

业界经典的Mixture-of-Experts架构（MoE，如MMoE、PLE、STAR^[1]等）能一定程度上适配不同场景下用户的个性化需求。这种架构将多个Experts的输出结果通过一个门控网络进行权重分配和组合，以得到最终的预测结果。早期，我们基于MoE架构提出了使用物料推荐渠道进行场景划分的多场景建模方案。然而，随着业务的不断壮大，场景间的差异越来越大、场景数量也越来越丰富，这版模型难以适应业务发展，不能很好地解决DSP背景下存在的以下两个问题：

在面对此类建模任务时，业界现有的方法是在不同场景间进行知识迁移。例如，SAML^[2]模型采用辅助网络来学习场景的共享知识并迁移至各场景的独有网络；ADIN^[3]和SASS^[4]模型使用门控单元以一种细粒度的方式来选择和融合全局信息到单场景信息中。然而，在DSP背景中复杂多变的流量背景下，场景差异性导致了场景数量的急剧增长，现有方法无法在巨量稀疏场景下有效。

因此，在本文中我们提出了DSP背景下的自适应场景建模方案（AdaScene, Adaptive Scenario Model），同时从知识迁移和场景聚合两个角度进行建模。AdaScene通过控制知识迁移的程度来最大化不同场景共性信息的利用，并使用稀疏专家聚合的方式利用门控网络自动选择专家组成场景表征，缓解了负迁移现象；同时，我们利用损失函数梯度指导场景聚合，将巨大的推荐场景空间约束到有限范围内，缓解了数据稀疏问题，并实现了自适应场景建模方案。

2 自适应场景建模

在本节开始前，我们先介绍多场景模型的建模方式。多场景模型采用输入层 Embedding + 混合专家（Mixture-of-Experts, MoE）的建模范式，其中输入信息包括了用户侧、商家侧以及场景上下文特征。多场景模型的损失由各场景的损失聚合而成，其损失函数形式如下：

其中，$K$为场景数量，$α_i$为各场景的损失权重值。

我们提出的AdaScene自适应场景模型主要包含以下2个部分：场景知识迁移（Knowledge Transfer）模块以及场景聚合（Scene Aggregation）模块，其模型结构如下图2所示。场景知识迁移模块自适应地控制不同场景间的知识共享程度，并通过稀疏专家网络自动选择 K 个专家构成自适应场景表征。场景聚合模块通过离线预先自动化衡量所有场景间损失函数梯度的相似度，继而通过最大化场景相似度来指导场景的聚合。

该模型结构的整体损失函数如以下公式所示：

其中，$\alpha_{k}$为每个场景组的损失函数所对应的系数，$G_k$为第$k$个场景组下的的场景数量，$G$为某种场景组的划分方式。

下面，我们分别介绍自适应场景知识迁移和场景聚合的建模方案。

2.1 自适应场景知识迁移

在多场景建模中，场景定义方式决定了场景专家的学习样本，很大程度上影响着模型对场景的拟合能力，但无论采用哪种场景定义方式，不同场景间用户分布都存在重叠，用户行为模式也会有相似性。

为提升不同场景间共性的捕捉能力，我们从场景特征和场景专家两个维度探索场景知识迁移的方法，在以物料推荐渠道×App×展示形态作为多场景建模Base模型的基础上，构建了如下图3所示的自适应场景知识迁移模型（Adaptive Knowledge Transfer Network, AKTN）。该模型建立了场景共享参数与私有参数的知识迁移桥梁，能够自适应地控制知识迁移的程度、缓解负迁移现象。

• 场景特征适配：通过Squeeze-and-Excitation Network^[5]构建场景适应层（Scene Adaption Layer），其结构可表示为$F_{SE}= FC( ReLU( FC(x)))$，其中$FC$表示全连接层，$ReLU$为激活函数。由于不同场景对原始特征的关注程度存在较大差异，该层能够根据不同场景的信息生成原始特征的权重，并利用这些权重对输入特征进行相应的变换，实现场景特定的个性化输入表征，提高模型的场景信息捕捉能力。


• 场景知识迁移：使用GRU门控单元构建场景知识迁移层（Scene Transfer Layer）。GRU门控单元通过场景上下文信息对来自全局场景专家和当前场景专家的信息流动进行控制，筛选出符合当前场景的有用信息；并且，该结构能以层级方式进行堆叠，不断对场景输出进行修正。

场景特征适配在输入层根据场景信息对不同特征进行权重适配，筛选出当前场景下模型最关注的特征；场景知识迁移在隐层专家网络中进行知识迁移，控制共享专家中共性信息向场景独有信息的流动，使得场景共性信息得以传递。

这两种知识迁移方式互为补充、相辅相成，共同提升多场景模型的预估能力。我们对比了不同模块的实验效果，具体结果如下表1所示。可以看出，引入场景知识迁移和特征权重优化在头部、尾部渠道都能带来一定提升，其中尾部小流量场景上（见下表1子场景2、3）有更为明显的提升，可见场景知识迁移缓解了场景之间的负迁移现象。

相关研究和实践表明^[6][7][8]，稀疏专家网络对于提高计算效率和增强模型效果非常有用。因此，我们在AKTN模型的基础上，在专家层进一步优化多场景模型。具体的，我们将场景知识迁移层替换为自动化稀疏专家选择方法，通过门控网络从大规模专家中选取与当前场景最相关的$K$个构成自适应场景表征，其选择过程如下图4所示：

在实践中，我们通过使用可微门控网络对专家进行有效组合，以避免不相关任务之间的负迁移现象。同时大规模专家网络的引入扩大了多场景模型的选择空间，更好地支持了门控网络的选择。考虑到多场景下的海量流量和复杂场景特征，在业界调研的基础上对稀疏专家门控网络进行了探索。

具体而言，我们对以下稀疏门控方法进行了实践：

• 方法一：通过$KL$散度衡量子场景与各专家之间的相似度，以此选择与当前场景最匹配的$k$个专家。在实现方式上，使用场景*专家的二维矩阵计算相似性，并通过$KL$散度选择出最适合的$k$个专家。


• 方法二：每个子场景配备一个专家选择门控网络，$m$个场景则有$m$个门控网络。对于每个场景的门控网络，配备$k$个单专家选择器^[9]，每个单专家选择器负责从$n$个专家中选择一个作为当前场景的专家（$n$为Experts个数）。在实践中，为提高训练效率，我们对单专家选择器中权重较小的值进行截断，保证每个单专家选择器仅选择一个专家。

在离线实验中，我们以物料推荐渠道 * 展示形态作为场景定义，对上述稀疏门控方法进行了尝试，离线效果如下表2所示：

可以看出，基于软共享机制的专家聚合方法能够更好地通过所激活的相同专家网络对各场景之间的知识进行共享。相较于常见的以截断方式为主的门控网络，使用二进制编码的方式使得其在不损失其他专家网络信息的同时，能够更好地收敛到目标专家数量，同时其可微性使得其在以梯度为基础的优化算法中训练更加稳定。

同时，为了验证稀疏门控网络能否有效区分不同场景并捕捉到场景间差异性，我们使用$n$=16个专家中选择$K$=7个的例子，对验证集中不同场景下各专家的利用率、选择专家的平均权重进行了可视化分析（如图5-图7所示），实验结果表明该方法能够有效地选择出不同的专家对场景进行表达。

例如，图6中KP_1更多地选择第5个专家，而KP_2更倾向于选择第15个专家。并且，不同场景对各专家的使用率以及选择专家的平均权重也有着明显的差异性，表明该方法能够捕捉到细分场景下流量的差异性并进行差异化的表达。

实验证明，在通过大规模专家网络对每个场景进行建模的同时，基于软共享机制的专家聚合方法能够更好地通过所激活的相同专家网络对各场景之间的知识进行共享。 同时，为了进一步探索Experts个数对模型性能的影响，我们在方法二的基础上通过调整专家个数和topK比例设计了多组对比实验，实验结果如下表3所示：

从实验数据可以看出，大规模的Experts结构会带来正向的离线收益；并且随着选取专家个数比例的增加（表3横轴），模型整体的表现效果也有上升的趋势。

2.2 自适应场景聚合

理想情况下，一条请求（流量）可以看作一个独立的场景。但如引言所述，随着DSP业务持续发展，不同的物料展示渠道、形式、位置等持续增加，每个场景的数据十分稀疏，我们无法对每个细分场景进行有效训练。因此，我们需要对各个推荐场景进行聚类、合并。我们使用场景聚合的方法对此问题进行求解，通过衡量所有场景间的相似度，并最大化该相似度来指导场景的聚合，解决了数据稀疏导致难以收敛的问题。具体的，我们将该问题表示为：

其中$G$表示某种分组方式，$f_{s_i}$为场景$s_i$在分组$G_k$内与其他场景的总体相似度。在将$N$个场景聚合成$K$个场景组的过程中，我们需要找到使得场景间整体相似度最大的分组方式$G^{\ast}$。

因此，我们在2.1节场景知识迁移模型的基础上，增加了场景聚合部分，提出了基于Two-Stage策略进行训练的场景聚合模型：

• Stage 1：基于相似度衡量方法对各场景的相似度进行归纳，并以最大化分组场景的相似度为目标找到各场景的最优聚合方式（如Scene1与Scene 4可聚合为场景组合Scene Gr0up SGA）；


• Stage 2：基于Stage 1得到的场景聚合方式，以交叉熵损失为目标函数最小化各场景下的交叉熵损失。

其中，Stage 2与2.1节中所述一致，本节主要针对Stage 1进行阐述。我们认为，一个有效的场景聚合方法应该能自适应地应对流量变化的趋势，能够发现场景之间的内在联系并依据当前流量特点自动适配聚合方法。我们首先想到的是从规则出发，将人工先验知识作为场景聚合的依据，按照推荐渠道、展示形式以及两者叉乘的方式进行了相应迭代。然而这类场景聚合方式需要可靠的人工经验来支撑，且在应对海量流量时不能迅速捕捉到其中的变化。

因此，我们对场景之间关系的建模方法进行了相关的探索。首先，我们通过离线训练时场景之间的表征迁移和组合训练来评估场景之间的影响，但这种方式存在组合空间巨大、训练耗时较长的问题，效率较低。

在多任务的相关研究中^{[10][11][12][13]}，使用梯度信息对任务之间的关系进行建模是一种有效的方法。类似的在多场景模型中，能够根据各场景损失函数的梯度信息对场景间的相似度进行建模，因此我们采用多专家网络并基于梯度信息自动化地对场景之间的相似度进行求解，模型示意如下图8所示：

基于上述思路，我们对场景之间的关系建模方法进行了以下尝试：

1. Gradient Regulation

基于梯度信息能够对场景信息进行潜在表示这一认知，我们在损失函数中加入各场景损失函数关于专家层梯度距离的正则项，整体的损失函数如下所示，该正则项的系数$\lambda_{s_i,s_j}$表示场景之间的相似度，$dist$为常见的评估梯度之间距离的方法，比如$l_1$，$l_2$距离。

2. Lookahead Strategy

3. Meta Weights

Lookahead Strategy该方法对场景间的关系进行了显式建模，但是这种根据损失函数的变化计算场景相关系数的策略存在着训练不稳定、波动较大的现象，无法像Gradient Regulation这一方法对场景相似度进行求解。

因此，我们引入了场景间的相关性系数矩阵（meta weights），结合前两种方法对该问题进行如下建模，通过场景$s_i$的数据对其与其他场景的相关性系数$\lambda_{s_i \to s_j}$进行更新，同时基于该参数对全局的参数模型$W$进行优化。针对这种典型的两层优化问题，我们基于MAML^[14]方法进行求解，并将meta weights作为场景间的相似度。

我们以推荐渠道和展示形式（是否开屏）的多场景模型作为Base，对上述3种方法做了探索。为了提高训练效率，我们在设计 Stage 1 模型时做了以下优化：

我们对每个方法的GAUC进行了比较，实验效果如下表4所示。相较于人工规则，基于梯度的场景聚合方法都能带来效果的明显提升，表明损失函数梯度能在一定程度上表示场景之间的相似性，并指导多场景进行聚合。

为了更全面的展现场景聚合对于模型预估效果的影响，我们选取Meta Weights进行分组数量的调优实验，具体的实验结果如下表5所示。可以发现：随着分组数的增大，GAUC提升也越大，此时各场景间的负迁移效应减弱；但分组超过一定数量时，场景间总体的相似度减小，GAUC呈下降趋势。

此外，我们对Meta Weigts方法中部分场景间的关系进行了可视化分析，分析结果如下图9所示。以场景作为坐标轴，图中的每个方格表示各场景间的相似度，颜色的深浅表示渠道间的相似程度大小。

从图中可以发现，以渠道和展示形式为粒度的细分场景下，该方法能够学习到不同场景间的相关性，例如A渠道下的信息流(s16)与其他场景的相关性较低，会将其作为独立的场景进行预估，而B渠道下的开屏展示（s9）与C渠道开屏展示（s8）相关性较高，会将其聚合为一个场景进行预估，同时该相似度矩阵不是对称的，这也说明各场景间相互的影响存在着差异。

3 总结与展望

通过多场景学习的探索和实践，我们深入挖掘了推荐模型在不同场景下的建模能力，并分别从场景知识迁移、场景聚合方向进行了尝试和优化，这些尝试提供了更好的理解和解释推荐模型对不同类型流量和场景的应对能力。然而，这只是多场景学习研究的开始，后续我们会探索并迭代以下方向：

• 更好的场景划分方式：当前多场景的划分主要还是依据渠道（渠道*展示形态）作为流量的划分方式，未来会在媒体、展示位、媒体*时间等维度上进行更详细地探索；


• 端到端的流量聚合方式：在进行流量聚合时，使用了Two-Stage的策略进行聚合。然而，这种方式不能充分地利用流量数据中相关的信息。因此，需要探索端到端的流量场景聚合方案将更直接和有效地提高推荐模型的能力。

结合多场景学习，在未来的研究中将不断探索新的方法和技术，以提高推荐模型对不同场景和流量类型的建模能力，创造更好的用户体验以及商业价值。

4 作者简介

王驰、森杰、树立、文帅、尹华、肖雄等，均来自美团到家事业群/到家研发平台。

5 参考文献

• [1] STAR：Sheng, Xiang-Rong, et al. "One model to serve all: Star topology adaptive recommender for multi-domain ctr prediction." Proceedings of the 30th ACM International Conference on Information & Knowledge Management. 2021.


• [2] SAML：Chen, Yuting, et al. "Scenario-aware and Mutual-based approach for Multi-scenario Recommendation in E-Commerce." 2020 International Conference on Data Mining Workshops (ICDMW). IEEE, 2020.


• [3] ADIN：Jiang, Yuchen, et al. "Adaptive Domain Interest Network for Multi-domain Recommendation." Proceedings of the 31st ACM International Conference on Information & Knowledge Management. 2022.


• [4]SASS：Zhang, Yuanliang, et al. "Scenario-Adaptive and Self-Supervised Model for Multi-Scenario Personalized Recommendation." Proceedings of the 31st ACM International Conference on Information & Knowledge Management. 2022.


• [5] Squeeze-and-Excitation：Hu, Jie, Li Shen, and Gang Sun. "Squeeze-and-excitation networks." Proceedings of the IEEE conference on computer vision and pattern recognition. 2018.


• [6] 美团外卖推荐情境化智能流量分发的实践与探索


• [7] PaLM：ai.googleblog.com/2022/04/pat…


• [8] GLaM：proceedings.mlr.press/v162/du22c.…


• [9] 单专家选择器：arxiv.org/abs/2106.03…


• [10] HOA：proceedings.mlr.press/v119/standl…


• [11] Gradient Affinity：proceedings.neurips.cc/paper/2021/…


• [12] SRDML：dl.acm.org/doi/abs/10.…


• [13] Auto-Lambda：arxiv.org/abs/2202.03…


• [14] MAML：arxiv.org/abs/1703.03…

背景：

充血模型是DDD分层架构中实体设计的一种方案，可以使关注点聚焦于业务实现，可有效提升开发效率、提升可维护性；

1、DDD项目落地整体调用关系

调用关系图中的Entity为实体，从进入领域服务（Domin）时开始使用，直到最后返回。

2、实体设计

充血模型是实体设计的一种方法，简单来说，就是一种带有具体行为方法和聚合关联关系的特殊实体；

关于实体设计，需要明白的关键词为：领域服务->聚合->聚合根->实体->贫血模型->充血模型

聚合与聚合根:

聚合是一种关联关系，而聚合根就是这个关系成立的基础，没有聚合根，这个聚合关系就无法成立；

举个例子，存在3个实体：用户、用户组、用户组关联关系，这3个实体形成的关联关系就是聚合，而用户实体就是这个聚合中的聚合根；

实体：

定义在领域层，是领域层的重要元素，从领域划分到工程实践落地，都应该围绕实体进行，DDD中的实体和数据库表不只是1对1关系，可能是1对多或者仅为内存中的对象；

贫血模型：

实体不带有任何行为方法，也不带有聚合关联关系，作用基本相当于值对象（ValueObject），仅作为值传递的对象，和传统三层项目架构中的实体具有相同作用，不建议使用。补充说明：一般我们使用的DTO就可以被当做是值对象

充血模型：

实体中带有具有行为方法和聚合关联关系，行为方法是说create、save、delete等封装了一类可以指代行为的方法，比如在用户实体对象中具有用户组实体的引用，这样当我们需要操作用户组时，只通过用户实体进行操作就可以。

工程实践中，建议采用充血模型，好处是隐藏胶水代码，提升代码可读性，使关注点聚焦于业务实现。

充血模型在实践中的问题：

行为代码量过多，导致实体内部臃肿膨胀，难以阅读，难以维护，对于这种问题，我们需要根据实体行为的代码量多少来采取不同的解决方案。

解决方案：

场景1：行为不会导致实体臃肿的情况下，在实体中完成行为定义

public CooperateServicePackageConfig save() {    

    // 直接调用基础设施层进行保存

    cooperateServicePackageConfigRepository.save(this);    

    return this;

}

场景2：行为导致实体臃肿的情况下，采用外部定义行为的方式，核心思想是借助其他类实现行为代码定义，将臃肿代码外移，保留干净的实体行为：

1）创建工具类，将某个实体中的行为定义其中，实体负责调用该工具类

public CooperateServicePackageConfig save() {    

    // 将处理过程放在工具类中

    ServicePackageSaveUtils.save(this);   

    return this;

 }

2）创建新实体，将该实体的使用场景明确至某个细分行为，比如一个聚合根（ExampleEntity）的保存可能涉及到5个实体的保存，那么我们定义一个ExampleSaveEntity实体，专门用来处理该聚合下的保存行为

实践经验：

1、关于spring bean注入：充血模型在实体中使用静态注入方法实现。例：

private LabelInfoRepository labelInfoRepository = ApplicationContextUtils.getBean(LabelInfoRepository.class);

2、充血模型的实体序列化，排除非必要属性，在一些redis对象缓存时可能会用到。例：

// 使用注解排除序列化属性

@Getter(AccessLevel.NONE)

private LabelInfoRepository labelInfoRepository = ApplicationContextUtils.getBean(LabelInfoRepository.class);

// 使用注解排除序列化属性

@JSONField(serialize = false)

private ServicePackageConfig servicePackageConfig;

// 使用注解排除序列化 get 方法

@Transient

@JSONField(serialize = false)

public static CooperateServicePackageRepositoryQuery getAllCodeQuery(Long contractId) {    

    CooperateServicePackageRepositoryQuery repositoryQuery = new CooperateServicePackageRepositoryQuery();    

    repositoryQuery.setContractIds(com.google.common.collect.Lists.newArrayList(contractId));    

    repositoryQuery.setCode(RightsPlatformConstants.CODE_ALL);   

     return repositoryQuery;

}

3、利用Set方法建立聚合绑定关系。例：

public void setServiceSkuInfos(List<ServiceSkuInfo> serviceSkuInfos) {    

    if (CollectionUtils.isEmpty(serviceSkuInfos)) 

    {        

        return;    

    }    

    this.serviceSkuInfos = serviceSkuInfos;    

    List<String> allSkuNoSet = serviceSkuInfos

                                .stream()

                                .map(one -> one.getSkuNo())

                                .collect(Collectors.toList());   

     String skuJoinStr = Joiner.on(GlobalConstant.SPLIT_CHAR).join(allSkuNoSet);    

     this.setSkuNoSet(skuJoinStr);}

作者：京东健康 张君毅

来源：京东云开发者社区

大家好，我是冰河~~

一般家庭网络的公网IP都是不固定的，而我又想通过域名来访问自己服务器上的应用，也就是说：需要通过将域名绑定到动态IP上来实现这个需求。于是乎，我开始探索实现的技术方案。

通过在网上查阅一系列的资料后，发现阿里云可以做到实现动态域名解析DDNS。于是乎，一顿操作下来，我实现了域名绑定动态IP。这里，我们以Python为例实现。

小伙伴们注意啦：Java版源码已提交到：github.com/binghe001/m…

好了，说干就干，我们开始吧，走起~~

阿里云DDNS前置条件

• 域名是在阿里云购买的


• 地址必须是公网地址，不然加了解析也没有用

通过阿里云提供的SDK，然后自己编写程序新增或者修改域名的解析，达到动态解析域名的目的；主要应用于pppoe拨号的环境，比如家里设置了服务器，但是外网地址经常变化的场景；再比如公司的pppoe网关，需要建立vpn的场景。

安装阿里云SDK

需要安装两个SDK库，一个是阿里云核心SDK库，一个是阿里云域名SDK库；

阿里云核心SDK库

pip install aliyun-python-sdk-core

阿里云域名SDK库

pip install aliyun-python-sdk-domain

阿里云DNSSDK库

pip install aliyun-python-sdk-alidns

设计思路

• 获取阿里云的accessKeyId和accessSecret


• 获取外网ip


• 判断外网ip是否与之前一致


• 外网ip不一致时，新增或者更新域名解析记录

实现方案

这里，我直接给出完整的Python代码，小伙伴们自行替换AccessKey和AccessSecret。

#!/usr/bin/env python

#coding=utf-8



# 加载核心SDK

from aliyunsdkcore.client import AcsClient

from aliyunsdkcore.acs_exception.exceptions import ClientException

from aliyunsdkcore.acs_exception.exceptions import ServerException



# 加载获取 、 新增、 更新、 删除接口

from aliyunsdkalidns.request.v20150109 import DescribeSubDomainRecordsRequest, AddDomainRecordRequest, UpdateDomainRecordRequest, DeleteDomainRecordRequest



# 加载内置模块

import json,urllib



# AccessKey 和 Secret  建议使用 RAM 子账户的 KEY 和 SECRET 增加安全性

ID = 'xxxxxxx'

SECRET = 'xxxxxx'



# 地区节点 可选地区取决于你的阿里云帐号等级，普通用户只有四个，分别是杭州、上海、深圳、河北，具体参考官网API

regionId = 'cn-hangzhou'



# 配置认证信息

client = AcsClient(ID, SECRET, regionId)



# 设置主域名

DomainName = 'binghe.com'



# 子域名列表  列表参数可根据实际需求增加或减少值

SubDomainList = ['a', 'b', 'c']



# 获取外网IP   三个地址返回的ip地址格式各不相同，3322 的是最纯净的格式， 备选1为 json格式  备选2 为curl方式获取  两个备选地址都需要对获取值作进一步处理才能使用

def getIp():

    # 备选地址：1， http://pv.sohu.com/cityjson?ie=utf-8    2，curl -L tool.lu/ip

    with urllib.request.urlopen('http://www.3322.org/dyndns/getip') as response:

        html = response.read()

        ip = str(html, encoding='utf-8').replace("\n", "")

    return ip



# 查询记录

def getDomainInfo(SubDomain):

    request = DescribeSubDomainRecordsRequest.DescribeSubDomainRecordsRequest()

    request.set_accept_format('json')



    # 设置要查询的记录类型为 A记录   官网支持A / CNAME / MX / AAAA / TXT / NS / SRV / CAA / URL隐性（显性）转发  如果有需要可将该值配置为参数传入

    request.set_Type("A")



    # 指定查记的域名 格式为 'test.binghe.com'

    request.set_SubDomain(SubDomain)



    response = client.do_action_with_exception(request)

    response = str(response, encoding='utf-8')



    # 将获取到的记录转换成json对象并返回

    return json.loads(response)



# 新增记录 (默认都设置为A记录，通过配置set_Type可设置为其他记录)

def addDomainRecord(client,value,rr,domainname):

    request = AddDomainRecordRequest.AddDomainRecordRequest()

    request.set_accept_format('json')



    # request.set_Priority('1')  # MX 记录时的必选参数

    request.set_TTL('600')       # 可选值的范围取决于你的阿里云账户等级，免费版为 600 - 86400 单位为秒 

    request.set_Value(value)     # 新增的 ip 地址

    request.set_Type('A')        # 记录类型

    request.set_RR(rr)           # 子域名名称  

    request.set_DomainName(domainname) #主域名



    # 获取记录信息，返回信息中包含 TotalCount 字段，表示获取到的记录条数 0 表示没有记录， 其他数字为多少表示有多少条相同记录，正常有记录的值应该为1，如果值大于1则应该检查是不是重复添加了相同的记录

    response = client.do_action_with_exception(request)

    response = str(response, encoding='utf-8')

    relsult = json.loads(response)

    return relsult



# 更新记录

def updateDomainRecord(client,value,rr,record_id):

    request = UpdateDomainRecordRequest.UpdateDomainRecordRequest()

    request.set_accept_format('json')



    # request.set_Priority('1')

    request.set_TTL('600')

    request.set_Value(value) # 新的ip地址

    request.set_Type('A')

    request.set_RR(rr)

    request.set_RecordId(record_id)  # 更新记录需要指定 record_id ，该字段为记录的唯一标识，可以在获取方法的返回信息中得到该字段的值



    response = client.do_action_with_exception(request)

    response = str(response, encoding='utf-8')

    return response



# 删除记录

def delDomainRecord(client,subdomain):

    info = getDomainInfo(subdomain)

    if info['TotalCount'] == 0:

        print('没有相关的记录信息，删除失败！')

    elif info["TotalCount"] == 1:

        print('准备删除记录')

        request = DeleteDomainRecordRequest.DeleteDomainRecordRequest()

        request.set_accept_format('json')



        record_id = info["DomainRecords"]["Record"][0]["RecordId"]

        request.set_RecordId(record_id) # 删除记录需要指定 record_id ，该字段为记录的唯一标识，可以在获取方法的返回信息中得到该字段的值

        result = client.do_action_with_exception(request)

        print('删除成功，返回信息：')

        print(result)

    else:

        # 正常不应该有多条相同的记录，如果存在这种情况，应该手动去网站检查核实是否有操作失误

        print("存在多个相同子域名解析记录值，请核查后再操作！")



# 有记录则更新，没有记录则新增

def setDomainRecord(client,value,rr,domainname):

    info = getDomainInfo(rr + '.' + domainname)

    if info['TotalCount'] == 0:

        print('准备添加新记录')

        add_result = addDomainRecord(client,value,rr,domainname)

        print(add_result)

    elif info["TotalCount"] == 1:

        print('准备更新已有记录')

        record_id = info["DomainRecords"]["Record"][0]["RecordId"]

        cur_ip = getIp()

        old_ip = info["DomainRecords"]["Record"][0]["Value"]

        if cur_ip == old_ip:

            print ("新ip与原ip相同，不更新！")

        else:

            update_result = updateDomainRecord(client,value,rr,record_id)

            print('更新成功，返回信息：')

            print(update_result)

    else:

        # 正常不应该有多条相同的记录，如果存在这种情况，应该手动去网站检查核实是否有操作失误

        print("存在多个相同子域名解析记录值，请核查删除后再操作！")





IP = getIp()



# 循环子域名列表进行批量操作

for x in SubDomainList:

    setDomainRecord(client,IP,x,DomainName)



# 删除记录测试

# delDomainRecord(client,'b.jsoner.com')



# 新增或更新记录测试

# setDomainRecord(client,'192.168.3.222','a',DomainName)



# 获取记录测试

# print (getDomainInfo(DomainName, 'y'))



# 批量获取记录测试

# for x in SubDomainList:

#     print (getDomainInfo(DomainName, x))



# 获取外网ip地址测试

# print ('(' + getIp() + ')')

Python脚本的功能如下：

• 获取外网ip地址。


• 获取域名解析记录。


• 新增域名解析记录。


• 更新域名解析记录。


• 删除域名解析记录 （并不建议将该功能添加在实际脚本中）。


• 批量操作，如果记录不存在则添加记录，存在则更新记录。

另外，有几点需要特别说明：

• 建议不要将删除记录添加进实际使用的脚本当中。


• 相同记录是同一个子域名的多条记录，比如 test.binghe.com。


• 脚本并没有验证记录类型，所以同一子域名下的不同类型的记录也会认为是相同记录，比如：有两条记录分别是 test.binghe.com 的 A 记录 和 test.binghe.com 的 AAAA 记录，会被认为是两条相同的 test.binghe.com 记录.如果需要判定为不同的记录，小伙伴们可以根据上述Python脚本自行实现。


• 可以通过判断获取记录返回的 record_id 来实现精确匹配记录。

最后，可以将以上脚本保存为文件之后，通过定时任务，来实现定期自动更新ip地址。

在业务开发的时候，经常会遇到某一个接口不能对外暴露，只能内网服务间调用的实际需求。

面对这样的情况，我们该如何实现呢？

1. 内外网接口微服务隔离

将对外暴露的接口和对内暴露的接口分别放到两个微服务上，一个服务里所有的接口均对外暴露，另一个服务的接口只能内网服务间调用。

该方案需要额外编写一个只对内部暴露接口的微服务，将所有只能对内暴露的业务接口聚合到这个微服务里，通过这个聚合的微服务，分别去各个业务侧获取资源。

该方案，新增一个微服务做请求转发，增加了系统的复杂性，增大了调用耗时以及后期的维护成本。

2. 网关 + redis 实现白名单机制

在 redis 里维护一套接口白名单列表，外部请求到达网关时，从 redis 获取接口白名单，在白名单内的接口放行，反之拒绝掉。

该方案的好处是，对业务代码零侵入，只需要维护好白名单列表即可；

不足之处在于，白名单的维护是一个持续性投入的工作，在很多公司，业务开发无法直接触及到 redis，只能提工单申请，增加了开发成本；

另外，每次请求进来，都需要判断白名单，增加了系统响应耗时，考虑到正常情况下外部进来的请求大部分都是在白名单内的，只有极少数恶意请求才会被白名单机制所拦截，所以该方案的性价比很低。

3. 方案三 网关 + AOP

相比于方案二对接口进行白名单判断而言，方案三是对请求来源进行判断，并将该判断下沉到业务侧。避免了网关侧的逻辑判断，从而提升系统响应速度。

我们知道，外部进来的请求一定会经过网关再被分发到具体的业务侧，内部服务间的调用是不用走外部网关的（走 k8s 的 service）。

根据这个特点，我们可以对所有经过网关的请求的header里添加一个字段，业务侧接口收到请求后，判断header里是否有该字段，如果有，则说明该请求来自外部，没有，则属于内部服务的调用，再根据该接口是否属于内部接口来决定是否放行该请求。

该方案将内外网访问权限的处理分布到各个业务侧进行，消除了由网关来处理的系统性瓶颈；

同时，开发者可以在业务侧直接确定接口的内外网访问权限，提升开发效率的同时，增加了代码的可读性。

当然该方案会对业务代码有一定的侵入性，不过可以通过注解的形式，最大限度的降低这种侵入性。

具体实操

下面就方案三，进行具体的代码演示。

首先在网关侧，需要对进来的请求header添加外网标识符: from=public

@Component

public class AuthFilter implements GlobalFilter, Ordered {

    @Override

    public Mono < Void > filter ( ServerWebExchange exchange, GatewayFilterChain chain ) {

         return chain.filter(

         exchange.mutate().request(

         exchange.getRequest().mutate().header('id', '').header('from', 'public').build())

         .build()

         )；

    }



    @Override

    public int getOrder () {

        return 0;

    }

 }

接着，编写内外网访问权限判断的AOP和注解

@Aspect

@Component

@Slf4j

public class OnlyIntranetAccessAspect {

 @Pointcut ( '@within(org.openmmlab.platform.common.annotation.OnlyIntranetAccess)' )

 public void onlyIntranetAccessOnClass () {}

 @Pointcut ( '@annotation(org.openmmlab.platform.common.annotation.OnlyIntranetAccess)' )

 public void onlyIntranetAccessOnMethed () {

 }



 @Before ( value = 'onlyIntranetAccessOnMethed() || onlyIntranetAccessOnClass()' )

 public void before () {

     HttpServletRequest hsr = (( ServletRequestAttributes ) RequestContextHolder.getRequestAttributes()) .getRequest ();

     String from = hsr.getHeader ( 'from' );

     if ( !StringUtils.isEmpty( from ) && 'public'.equals ( from )) {

        log.error ( 'This api is only allowed invoked by intranet source' );

        throw new MMException ( ReturnEnum.C_NETWORK_INTERNET_ACCESS_NOT_ALLOWED_ERROR);

            }

     }

 }



@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface OnlyIntranetAccess {

}

最后，在只能内网访问的接口上加上@OnlyIntranetAccess注解即可

@GetMapping ( '/role/add' )

@OnlyIntranetAccess

public String onlyIntranetAccess() {

    return '该接口只允许内部服务调用';

}

 4. 网关路径匹配 



在DailyMart项目中我采用的是第四种：即在网关中进行路径匹配。









该方案中我们将内网访问的接口全部以前缀/pv开头，然后在网关过滤器中根据路径找到具体校验器，如果是/pv访问的路径则直接提示禁止外部访问。















使用网关路径匹配方案不仅可以应对内网接口的问题，还可以扩展到其他校验机制上。

譬如，有的接口需要通过access_token进行校验，有的接口需要校验api_key 和 api_secret，为了应对这种不同的校验场景，只需要再实现一个校验类即可，由不同的子类实现不同的校验逻辑，扩展非常方便。

1.什么是pf4j?

一个插件框架，用于实现插件的动态加载，支持的插件格式（zip、jar）。

核心组件

• **Plugin：**是所有插件类型的基类。每个插件都被加载到一个单独的类加载器中以避免冲突。


• **PluginManager：**用于插件管理的所有方面（加载、启动、停止）。您可以使用内置实现作为JarPluginManager, ZipPluginManager, DefaultPluginManager（它是一个JarPluginManager+ ZipPluginManager），或者您可以从AbstractPluginManager（仅实现工厂方法）开始实现自定义插件管理器。


• **PluginLoader：**加载插件所需的所有信息（类）。


• **ExtensionPoint：**是应用程序中可以调用自定义代码的点。这是一个java接口标记。任何 java 接口或抽象类都可以标记为扩展点（实现ExtensionPoint接口）。


• **Extension：**是扩展点的实现。它是一个类上的 Java 注释

场景

有一个spring-boot实现的web应用，在某一个业务功能上提供扩展点，用户可以基于SDK实现功能扩展，要求可以管理插件，并且能够在业务功能扩展点处动态加载功能。

2.代码工程

实验目的

实现插件动态加载，调用 卸载

Demo整体架构

• pf4j-api：定义可扩展接口。


• pf4j-plugins-01：插件项目，可以包含多个插件，需要实现 plugin-api 中定义的接口。所有的插件jar包，放到统一的文件夹中，方便管理，后续只需要加载文件目录路径即可启动插件。


• pf4j-app：主程序，需要依赖 pf4j-api ，加载并执行 pf4j-plugins-01 。

pf4j-api

导入依赖

<dependency>

    <groupId>org.pf4j</groupId>

    <artifactId>pf4j</artifactId>

    <version>3.0.1</version>

</dependency>

自定义扩展接口，集成 ExtensionPoint ，标记为扩展点

package com.et.pf4j;



import org.pf4j.ExtensionPoint;



public interface Greeting extends ExtensionPoint {



    String getGreeting();



}

打包给其他项目引用

pf4j-plugins-01

如果你想要能够控制插件的生命周期，你可以自定义类集成 plugin 重新里面的方法

/*

 * Copyright (C) 2012-present the original author or authors.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.pf4j.demo.welcome;



import com.et.pf4j.Greeting;

import org.apache.commons.lang.StringUtils;



import org.pf4j.Extension;

import org.pf4j.Plugin;

import org.pf4j.PluginWrapper;

import org.pf4j.RuntimeMode;



/**

 * @author Decebal Suiu

 */

public class WelcomePlugin extends Plugin {



    public WelcomePlugin(PluginWrapper wrapper) {

        super(wrapper);

    }



    @Override

    public void start() {

        System.out.println("WelcomePlugin.start()");

        // for testing the development mode

        if (RuntimeMode.DEVELOPMENT.equals(wrapper.getRuntimeMode())) {

            System.out.println(StringUtils.upperCase("WelcomePlugin"));

        }

    }



    @Override

    public void stop() {

        System.out.println("WelcomePlugin.stop()");

    }



    @Extension

    public static class WelcomeGreeting implements Greeting {



        @Override

        public String getGreeting() {

            return "Welcome ,my name is pf4j-plugin-01";

        }



    }



}

打成jar或者zip包，方便主程序加载

pf4j-app

加载插件包

package com.et.pf4j;



import org.pf4j.JarPluginManager;

import org.pf4j.PluginManager;

import org.springframework.boot.autoconfigure.SpringBootApplication;



import java.nio.file.Paths;

import java.util.List;



@SpringBootApplication

public class DemoApplication {



/* public static void main(String[] args) {

      SpringApplication.run(DemoApplication.class, args);

   }*/

   public static void main(String[] args) {





      // create the plugin manager

      PluginManager pluginManager = new JarPluginManager(); // or "new ZipPluginManager() / new DefaultPluginManager()"



      // start and load all plugins of application

      //pluginManager.loadPlugins();



      pluginManager.loadPlugin(Paths.get("D:\\IdeaProjects\\ETFramework\\pf4j\\pf4j-plugin-01\\target\\pf4j-plugin-01-1.0-SNAPSHOT.jar"));

      pluginManager.startPlugins();

      /*

        // retrieves manually the extensions for the Greeting.class extension point

        List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);

        System.out.println("greetings.size() = " + greetings.size());

        */

      // retrieve all extensions for "Greeting" extension point

      List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);

      for (Greeting greeting : greetings) {

         System.out.println(">>> " + greeting.getGreeting());

      }



      // stop and unload all plugins

      pluginManager.stopPlugins();

      //pluginManager.unloadPlugins();





   }

}

3.测试

运行DemoApplication.java 里面的mian函数，可以看到插件加载，调用以及卸载情况

4.引用

• pf4j.org/


• github.com/pf4j/pf4j-s…

我真的不想再用mybatis和其衍生框架了选择自研亦是一种解脱

文档地址 xuejm.gitee.io/easy-query-…

GITHUB地址 github.com/xuejmnet/ea…

GITEE地址 gitee.com/xuejm/easy-…

为什么要用orm

众所邹知orm的出现让本来以sql实现的复杂繁琐功能大大简化,对于大部分程序员而言一个框架的出现是为了生产力的提升.。dbc定义了交互数据库的规范,任何数据库的操作都是只需要满足jdbc规范即可,而orm就是为了将jdbc的操作进行简化。我个人“有幸”体验过.net和java的两个大orm，只能说差距很大,当然语言上的一些特性也让java在实现orm上有着比较慢的进度,譬如泛型的出现，lambda的出现。

一个好的orm我觉得需要满足以下几点

• 强类型,如果不支持强类型那么和手写sql没有区别


• 能实现80%的纯手写sql的功能,好的orm需要覆盖业务常用功能


• 支持泛型,“如果一个orm连泛型都不支持那么就没有必要存在”这是一句现实但是又很残酷的结论,但是泛型会大大的减少开发人员的编写错误率


• 不应该依赖过多的组件,当然这并不是orm特有的,任何一个库其实依赖越少越不易出bug

其实说了这么多总结一下就是一个好的orm应该有ide的提示外加泛型约束帮助开发可以非常顺滑的把代码写下去,并且错误部分可以完全的在编译期间提现出来,运行时错误应该尽可能少的去避免。

为什么放弃mybatis

首先如果你用过其他语言的orm那么再用java的mybatis就像你用惯了java的stream然后去自行处理数据过滤，就像你习惯了kotlin的语法再回到java语法,很难受。这种难受不是自动挡到手动挡的差距,而且自动挡到手推车的差距。

xml配置sql也不知道是哪个“小天才”想出来的,先不说写代码的时候java代码和xml代码跳来跳去,而且xml下>,<必须要配合CDATA不然xml解析就失败,别说转义,我写那玩意在加转义你确定让我后续看得眼睛不要累死吗?美名其曰xml和代码分离方便维护,但是你再怎么方便修改了代码一样需要重启,并且因为代码写在xml里面导致动态条件得能力相对很弱。并且我也不知道mybatis为什么天生不支持分页,需要分页插件来支持,难道一个3202年的orm了还需要这样吗,很难搞懂mybatis的作者难道不写crud代码的吗？有些时候简洁并不是偷懒的原因,当然也有可能是架构的问题导致的。

逻辑删除的功能我觉得稍微正常一点的企业一定都会有这个功能,但是因为使用了myabtis,因为手写sql,所以常常会忘记往sql中添加逻辑删除字段,从而导致一些奇奇怪怪的bug需要排查,因为这些都是编译器无法体现的错误,因为他是字符串,因为mybatis把这个问题的原因指向了用户,这一点他很聪明,这个是用户的错误而不是框架的,但是框架要做的就是尽可能的将一些重复工作进行封装隐藏起来自动完成。

可能又会有一些用户会说所见即所得这样我才能知道他怎么执行了,但是现在哪个orm没有sql打印功能,哪个orm框架执行的sql和打印的sql是不一样的,不是所见即所得。总体而言我觉得mybatis充其量算是sqltemlate,比sqlhelper好的地方就是他是参数化防止sql注入。当然最主要的呀一点事难道java程序员不需要修改表,不需要动表结构,不需要后期维护的吗还是说java程序员写一个项目就换一个地方跳槽,还是说java程序员每个方法都有单元测试。我在转java后理解了一点,原来这就是你们经常说的java加班严重,用这种框架加班不严重就有鬼了。

为什么放弃mybatis衍生框架

有幸在201几年再网上看到了mybatis-plus框架,这块框架一出现就吸引了我,因为他在处理sql的方式上和.net的orm很相似,起码都是强类型,起码不需要java文件和xml文件跳来跳去,平常50%的代码也是可以通过框架的lambda表达式来实现,我个人比较排斥他的字符串模式的querywrapper,因为一门强类型语言缺少了强类型提示，在编写代码的时候会非常的奇怪。包括后期的重构,当然如果你的代码后续不需要你维护那么我觉得你用哪种方式都是ok的反正是一次性的,能出来结果就好了。

继续说mybatis-plus，因为工作的需要再2020年左右针对内部框架进行改造,并且让mybatis-plus支持强类型gr0up by,sum,min,max,any等api。

这个时候其实大部分情况下已经可以应对了,就这样用了1年左右这个框架,包括后续的update的increment,decrement

update table set column=column-1 where id=xxx and column>1

全部使用lambda强类型语法,可以应对多数情况,但是针对join始终没有一个很好地方法。直到我遇到了mpj也就是mybatis-plus-join,但是这个框架也有问题,就是这个逻辑删除在join的子表上不生效，需要手动处理,如果生效那么在where上面,不知道现在怎么样了,当时我也是自行实现了让其出现在join的on后面,但是因为实现是需要实现某个接口的,所以并没有pr代码.
首先定义一个接口

public interface ISoftDelete {

    Boolean getDeleted();

}



//其中join mapper是我自己的实现,主要还是`WrapperFunction`的那段定义

  @Override

    public Scf4jBaseJoinLinq<T1,TR> on(WrapperFunction<MPJAbstractLambdaWrapper<T1, ?>> onFunction) {

        WrapperFunction<MPJAbstractLambdaWrapper<T1, ?>> join=  on->{

            MPJAbstractLambdaWrapper<T1, ?> apply = onFunction.apply(on);

            if(ISoftDelete.class.isAssignableFrom(joinClass)){

                SFunction deleted = LambdaHelper.getFunctionField(joinClass, "deleted", Boolean.class);

                apply.eq(deleted,false);

            }

            return apply;

        };

        joinMapper.setJoinOnFunction(query->{

            query.innerJoin(joinClass,join);

        });

        return joinMapper;

    }

虽然实现了join但是还是有很多问题出现和bug。

• 比如不支持vo对象的返回,只能返回数据库对象自定义返回列,不然就是查询所有列


• 再比如如果你希望你的对象update的时候填充null到数据库,那么只能在entity字段上添加,这样就导致这个字段要么全部生效要么全部不生效.


• 批量插入不支持默认居然是foreach一个一个加,当然这也没关系,但是你真的想实现批处理需要自己编写很复杂的代码并且需要支持全字段。而不是null列不填充


• MetaObjectHandler,支持entity的insert和update但是不支持lambdaUpdateWrapper,有时候当前更新人和更新时间都是需要的,你也可以说数据库可以设置最后更新时间,但是最后修改人呢?


• 非常复杂的动态表名,拜托大哥我只是想改一下表名,目前的解决方案就是try-finally每次用完都需要清理一下当前线程,因为tomcat会复用线程,通过threadlocal来实现,话说pagehelper应该也是这种方式实现的吧
  当然其他还有很多问题导致最终我没办法忍受,选择了自研框架,当然我的框架自研是参考了一部分的freesql和sqlsuagr的api,并且还有java的beetsql的实现和部分方法。毕竟站在巨人的肩膀上才能看的更远，不要问我为什么不参考mybatis的,我觉得mybatis已经把简单问题复杂化了,如果需要看懂他的代码是一件很得不偿失的事情,最终我发现我的选择是正确的,我通过参考beetsql的源码很快的清楚了java这边应该需要做的事情,为我编写后续框架节约了太多时间,这边也给beetsql打个广告 https://gitee.com/xiandafu/beetlsql

自研orm有哪些特点

easy-query一款无任何依赖的java全新高性能orm支持 单表 多表 子查询 逻辑删除 多租户 差异更新 联级一对一 一对多 多对一 多对多 分库分表(支持跨表查询分页等) 动态表名 数据库列高效加解密支持like crud拦截器 原子更新 vo对象直接返回

文档地址 xuejm.gitee.io/easy-query-…

GITHUB地址 github.com/xuejmnet/ea…

GITEE地址 gitee.com/xuejm/easy-…

• 强类型,可以帮助团队在构建和查询数据的时候拥有id提示,并且易于后期维护。


• 泛型可以控制我们编写代码时候的一些低级错误,比如我只查询一张表,但是where语句里面可以使用不存在上下文的表作为条件,进一步限制和加强表达式


• easy-query提供了三种模式分别是lambda,property,apt proxy其中lambda表达式方便重构维护,property只是性能最好,apt proxy方便维护,但是重构需要一起重构apt文件

单表查询

//根据条件查询表中的第一条记录

List<Topic> topics = easyQuery

                .queryable(Topic.class)

                .limit(1)

                .toList();

==> Preparing: SELECT t.`id`,t.`stars`,t.`title`,t.`create_time` FROM t_topic t LIMIT 1

<== Total: 1



//根据条件查询id为3的集合

List<Topic> topics = easyQuery

                .queryable(Topic.class)

                .where(o->o.eq(Topic::getId,"3").eq(Topic::geName,"4")

                .toList();



==> Preparing: SELECT t.`id`,t.`stars`,t.`title`,t.`create_time` FROM t_topic t WHERE t.`id` = ? AND t.`name` = ?

==> Parameters: 3(String),4(String)

<== Total: 1

多表

 Topic topic = easyQuery

                .queryable(Topic.class)

                //join 后面是双参数委托，参数顺序表示join表顺序，可以通过then函数切换

                .leftJoin(BlogEntity.class, (t, t1) -> t.eq(t1, Topic::getId, BlogEntity::getId))

                .where(o -> o.eq(Topic::getId, "3"))

                .firstOrNull();



==> Preparing: SELECT t.`id`,t.`stars`,t.`title`,t.`create_time` FROM t_topic t LEFT JOIN t_blog t1 ON t.`id` = t1.`id` WHERE t.`id` = ? LIMIT 1

==> Parameters: 3(String)

<== Total: 1



List<BlogEntity> blogEntities = easyQuery

                .queryable(Topic.class)

                //join 后面是双参数委托，参数顺序表示join表顺序，可以通过then函数切换

                .innerJoin(BlogEntity.class, (t, t1) -> t.eq(t1, Topic::getId, BlogEntity::getId))

                .where((t, t1) -> t1.isNotNull(BlogEntity::getTitle).then(t).eq(Topic::getId, "3"))

                //join查询select必须要带对应的返回结果,可以是自定义dto也可以是实体对象,如果不带对象则返回t表主表数据

                .select(BlogEntity.class, (t, t1) -> t1.columnAll())

                .toList();



==> Preparing: SELECT t1.`id`,t1.`create_time`,t1.`update_time`,t1.`create_by`,t1.`update_by`,t1.`deleted`,t1.`title`,t1.`content`,t1.`url`,t1.`star`,t1.`publish_time`,t1.`score`,t1.`status`,t1.`order`,t1.`is_top`,t1.`top` FROM t_topic t INNER JOIN t_blog t1 ON t.`id` = t1.`id` WHERE t1.`title` IS NOT NULL AND t.`id` = ?

==> Parameters: 3(String)

<== Total: 1

子查询

```java

//SELECT * FROM `t_blog` t1 WHERE t1.`deleted` = ? AND t1.`id` = ?

 Queryable<BlogEntity> subQueryable = easyQuery.queryable(BlogEntity.class)

                .where(o -> o.eq(BlogEntity::getId, "1"));





List<Topic> x = easyQuery

        .queryable(Topic.class).where(o -> o.exists(subQueryable.where(q -> q.eq(o, BlogEntity::getId, Topic::getId)))).toList();





==> Preparing: SELECT t.`id`,t.`stars`,t.`title`,t.`create_time` FROM `t_topic` t WHERE EXISTS (SELECT 1 FROM `t_blog` t1 WHERE t1.`deleted` = ? AND t1.`id` = ? AND t1.`id` = t.`id`)

==> Parameters: false(Boolean),1(String)

<== Time Elapsed: 3(ms)

<== Total: 1





//SELECT t1.`id` FROM `t_blog` t1 WHERE t1.`deleted` = ? AND t1.`id` = ?

Queryable<String> idQueryable = easyQuery.queryable(BlogEntity.class)

            .where(o -> o.eq(BlogEntity::getId, "123"))

            .select(String.class, o -> o.column(BlogEntity::getId));//如果子查询in string那么就需要select string，如果integer那么select要integer 两边需要一致

List<Topic> list = easyQuery

        .queryable(Topic.class).where(o -> o.in(Topic::getId, idQueryable)).toList();





==> Preparing: SELECT t.`id`,t.`stars`,t.`title`,t.`create_time` FROM `t_topic` t WHERE t.`id` IN (SELECT t1.`id` FROM `t_blog` t1 WHERE t1.`deleted` = ? AND t1.`id` = ?)

==> Parameters: false(Boolean),123(String)

<== Time Elapsed: 2(ms)

<== Total: 0

自定义逻辑删除

//@Component //如果是spring

public class MyLogicDelStrategy extends AbstractLogicDeleteStrategy {

    /**

     * 允许datetime类型的属性

     */

    private final Set<Class<?>> allowTypes=new HashSet<>(Arrays.asList(LocalDateTime.class));

    @Override

    protected SQLExpression1<WherePredicate<Object>> getPredicateFilterExpression(LogicDeleteBuilder builder,String propertyName) {

        return o->o.isNull(propertyName);

    }



    @Override

    protected SQLExpression1<ColumnSetter<Object>> getDeletedSQLExpression(LogicDeleteBuilder builder, String propertyName) {

//        LocalDateTime now = LocalDateTime.now();

//        return o->o.set(propertyName,now);

        //上面的是错误用法,将now值获取后那么这个now就是个固定值而不是动态值

        return o->o.set(propertyName,LocalDateTime.now())

                .set("deletedUser",CurrentUserHelper.getUserId());

    }



    @Override

    public String getStrategy() {

        return "MyLogicDelStrategy";

    }



    @Override

    public Set<Class<?>> allowedPropertyTypes() {

        return allowTypes;

    }

}



//为了测试防止数据被删掉,这边采用不存在的id

logicDelTopic.setId("11xx");

//测试当前人员

CurrentUserHelper.setUserId("easy-query");

long l = easyQuery.deletable(logicDelTopic).executeRows();



==> Preparing: UPDATE t_logic_del_topic_custom SET `deleted_at` = ?,`deleted_user` = ? WHERE `deleted_at` IS NULL AND `id` = ?

==> Parameters: 2023-04-01T23:15:13.944(LocalDateTime),easy-query(String),11xx(String)

<== Total: 0

差异更新

• 要注意是否开启了追踪spring-boot下用@EasyQueryTrack注解即可开启


• 是否将当前对象添加到了追踪上下文 查询添加asTracking或者 手动将查询出来的对象进行easyQuery.addTracking(Object entity)

TrackManager trackManager = easyQuery.getRuntimeContext().getTrackManager();

try{

        trackManager.begin();

        Topic topic = easyQuery.queryable(Topic.class)

                .where(o -> o.eq(Topic::getId, "7")).asTracking().firstNotNull("未找到对应的数据");

        String newTitle = "test123" + new Random().nextInt(100);

        topic.setTitle(newTitle);

        long l = easyQuery.updatable(topic).executeRows();

}finally {



        trackManager.release();

}

==> Preparing: UPDATE t_topic SET `title` = ? WHERE `id` = ?

==> Parameters: test1239(String),7(String)

<== Total: 1

关联查询

一对一

学生和学生地址

//数据库对像查询

           List<SchoolStudent> list1 = easyQuery.queryable(SchoolStudent.class)

                        .include(o -> o.one(SchoolStudent::getSchoolStudentAddress).asTracking().disableLogicDelete())

                        .toList();

//vo自定义列映射返回

List<SchoolStudentVO> list1 = easyQuery.queryable(SchoolStudent.class)

                        .include(o -> o.one(SchoolStudent::getSchoolStudentAddress).asTracking().disableLogicDelete())

                        .select(SchoolStudentVO.class,o->o.columnAll()

                                .columnInclude(SchoolStudent::getSchoolStudentAddress,SchoolStudentVO::getSchoolStudentAddress))

                        .toList();

多对一

学生和班级

//数据库对像查询

 List<SchoolStudent> list1 = easyQuery.queryable(SchoolStudent.class)

                        .include(o -> o.one(SchoolStudent::getSchoolClass))

                        .toList();

//自定义列

 List<SchoolStudentVO> list1 = easyQuery.queryable(SchoolStudent.class)

                        .include(o -> o.one(SchoolStudent::getSchoolClass))

                        .select(SchoolStudentVO.class,o->o

                                .columnAll()

                                .columnInclude(SchoolStudent::getSchoolClass,SchoolStudentVO::getSchoolClass,s->s.column(SchoolClassVO::getId))

                        )

                        .toList();



//vo自定义列映射返回

   List<SchoolStudentVO> list1 = easyQuery.queryable(SchoolStudent.class)

                        .include(o -> o.one(SchoolStudent::getSchoolClass))

                        .select(SchoolStudentVO.class,o->o

                                .columnAll()

                                .columnInclude(SchoolStudent::getSchoolClass,SchoolStudentVO::getSchoolClass)

                        )

                        .toList();

一对多

班级和学生

//数据库对像查询

 List<SchoolClass> list1 = easyQuery.queryable(SchoolClass.class)

                        .include(o -> o.many(SchoolClass::getSchoolStudents))

                        .toList();

//vo自定义列映射返回

       List<SchoolClassVO> list1 = easyQuery.queryable(SchoolClass.class)

                        .include(o -> o.many(SchoolClass::getSchoolStudents))

                        .select(SchoolClassVO.class,o->o.columnAll()

                                .columnIncludeMany(SchoolClass::getSchoolStudents,SchoolClassVO::getSchoolStudents))

                        .toList();

多对多

班级和老师

      List<SchoolClass> list2 = easyQuery.queryable(SchoolClass.class)

                .include(o -> o.many(SchoolClass::getSchoolTeachers,1))

                .toList();

  List<SchoolClassVO> list2 = easyQuery.queryable(SchoolClass.class)

                    .include(o -> o.many(SchoolClass::getSchoolTeachers))

                    .select(SchoolClassVO.class,o->o.columnAll()

                            .columnIncludeMany(SchoolClass::getSchoolTeachers,SchoolClassVO::getSchoolTeachers))

                    .toList();

动态报名

List<BlogEntity> blogEntities = easyQuery.queryable(BlogEntity.class)

                .asTable(a -> "aa_bb_cc")

                .where(o -> o.eq(BlogEntity::getId, "123")).toList();





==> Preparing: SELECT t.`id`,t.`create_time`,t.`update_time`,t.`create_by`,t.`update_by`,t.`deleted`,t.`title`,t.`content`,t.`url`,t.`star`,t.`publish_time`,t.`score`,t.`status`,t.`order`,t.`is_top`,t.`top` FROM aa_bb_cc t WHERE t.`deleted` = ? AND t.`id` = ?

==> Parameters: false(Boolean),123(String)

<== Total: 0







List<BlogEntity> blogEntities = easyQuery.queryable(BlogEntity.class)

                .asTable(a->{

                    if("t_blog".equals(a)){

                        return "aa_bb_cc1";

                    }

                    return "xxx";

                })

                .where(o -> o.eq(BlogEntity::getId, "123")).toList();





==> Preparing: SELECT t.`id`,t.`create_time`,t.`update_time`,t.`create_by`,t.`update_by`,t.`deleted`,t.`title`,t.`content`,t.`url`,t.`star`,t.`publish_time`,t.`score`,t.`status`,t.`order`,t.`is_top`,t.`top` FROM aa_bb_cc1 t WHERE t.`deleted` = ? AND t.`id` = ?

==> Parameters: false(Boolean),123(String)

<== Total: 0









List<BlogEntity> x_t_blog = easyQuery

                .queryable(Topic.class)

                .asTable(o -> "t_topic_123")

                .innerJoin(BlogEntity.class, (t, t1) -> t.eq(t1, Topic::getId, BlogEntity::getId))

                .asTable("x_t_blog")

                .where((t, t1) -> t1.isNotNull(BlogEntity::getTitle).then(t).eq(Topic::getId, "3"))

                .select(BlogEntity.class, (t, t1) -> t1.columnAll()).toList();



==> Preparing: SELECT t1.`id`,t1.`create_time`,t1.`update_time`,t1.`create_by`,t1.`update_by`,t1.`deleted`,t1.`title`,t1.`content`,t1.`url`,t1.`star`,t1.`publish_time`,t1.`score`,t1.`status`,t1.`order`,t1.`is_top`,t1.`top` FROM t_topic_123 t INNER JOIN x_t_blog t1 ON t1.`deleted` = ? AND t.`id` = t1.`id` WHERE t1.`title` IS NOT NULL AND t.`id` = ?

==> Parameters: false(Boolean),3(String)

<== Total: 0

最后

感谢各位看到最后,希望以后我的开源框架可以帮助到您,如果您觉得有用可以点点star,这将对我是极大的鼓励

更多文档信息可以参考git地址或者文档

文档地址 xuejm.gitee.io/easy-query-…

GITHUB地址 github.com/xuejmnet/ea…

GITEE地址 gitee.com/xuejm/easy-…

一、什么是压缩炸弹，会有什么危害

1.1 什么是压缩炸弹

压缩炸弹(ZIP)：一个压缩包只有几十KB，但是解压缩后有几十GB，甚至可以去到几百TB，直接撑爆硬盘，或者是在解压过程中CPU飙到100%造成服务器宕机。虽然系统功能没有自动解压，但是假如开发人员在不细心观察的情况下进行一键解压(不看压缩包里面的文件大小)，可导致压缩炸弹爆炸。又或者压缩炸弹藏在比较深的目录下，不经意的解压缩，也可导致压缩炸弹爆炸。

以下是安全测试几种经典的压缩炸弹

graph LR

A(安全测试的经典压缩炸弹)

B(zip文件42KB)

C(zip文件10MB)

D(zip文件46MB)

E(解压后5.5G)

F(解压后281TB)

G(解压后4.5PB)



A ---> B --解压--> E

A ---> C --解压--> F

A ---> D --解压--> G



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style F fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style G fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

压缩炸弹（也称为压缩文件炸弹、炸弹文件）是一种特殊的文件，它在解压缩时会迅速膨胀成极其庞大的文件，可能导致系统资源耗尽、崩溃或磁盘空间耗尽。

压缩炸弹的原理是利用文件压缩算法中的重复模式和递归压缩的特性。它通常是一个非常小的压缩文件，但在解压缩时会生成大量的重复数据，导致文件大小迅速增长。这种文件的设计意图是迫使系统进行大量的解压缩操作，以消耗系统资源或填满磁盘空间。

压缩炸弹可能对系统造成严重的影响，包括系统崩溃、资源耗尽、拒绝服务攻击等。因此，它被视为一种恶意的计算机攻击工具，常常被用于恶意目的或作为安全测试中的一种工具。

1.2 压缩炸弹会有什么危害

graph LR

A(压缩炸弹的危害)

B(资源耗尽)

C(磁盘空间耗尽)

D(系统崩溃)

E(拒绝服务攻击)

F(数据丢失)



A ---> B

A ---> C

A ---> D

A ---> E

A ---> F



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

压缩炸弹可能对计算机系统造成以下具体的破坏：

重要提示：压缩炸弹可能对计算机系统造成不可逆的损害，请不要尝试创建、传播或使用压缩炸弹，以保护计算机和网络的安全。

二、怎么检测和处理压缩炸弹，Java怎么防止压缩炸弹

2.1 个人有没有方法可以检测压缩炸弹？

有一些方法可以识别和处理潜在的压缩炸弹，以防止对系统造成破坏。以下是一些常见的方法：

graph LR

A(个人检测压缩炸弹)

B(安全软件和防病毒工具)

C(文件大小限制)

D(文件类型过滤)



A ---> B --> E(推荐)

A ---> C --> F(太大的放个心眼)

A ---> D --> G(注意不认识的文件类型)



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style F fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style G fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

2.2 Java怎么防止压缩炸弹

在java中实际防止压缩炸弹的方法挺多的，可以采取以下措施来防止压缩炸弹：

graph LR

A(Java防止压缩炸弹)

B(解压缩算法的限制)

C(设置解压缩操作的资源限制)

D(使用安全的解压缩库)

E(文件类型验证和过滤)

F(异步解压缩操作)

G(安全策略和权限控制)



A ---> B

A ---> C

A ---> D

A ---> E

A ---> F

A ---> G



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px

style G fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

2.2.1 使用解压算法的限制来实现防止压缩炸弹

在前面我们说了Java防止压缩炸弹的一些策略，下面我将代码实现通过解压缩算法的限制来实现防止压缩炸弹。

先来看看我们实现的思路：

graph TD

    A(开始) --> B[创建 ZipFile 对象]

    B --> C[打开要解压缩的 ZIP 文件]

    C --> D[初始化 zipFileSize 变量为 0]

    D --> E{是否有更多的条目}

    E -- 是 --> F[获取 ZIP 文件的下一个条目]

    F --> G[获取当前条目的未压缩大小]

    G --> H[将解压大小累加到 zipFileSize 变量]

    H --> I{zipFileSize 是否超过指定的大小}

    I -- 是 --> J[调用 deleteDir方法删除已解压的文件夹]

    J --> K[抛出 IllegalArgumentException 异常]

    K --> L(结束)

    I -- 否 --> M(保存解压文件) --> E

    E -- 否 --> L

 

style A fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px

style G fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

style H fill:#E6E6FA,stroke:#E6E6FA,stroke-width:2px

style I fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px

style J fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

style K fill:#E6E6FA,stroke:#E6E6FA,stroke-width:2px

style L fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style M fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px

实现流程说明如下：

实现代码工具类：

import java.io.File;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;



/**

 * 文件炸弹工具类

 *

 * @author bamboo panda

 * @version 1.0

 * @date 2023/10

 */

public class FileBombUtil {



    /**

     * 限制文件大小 1M（限制单位：B）[1M=1024KB 1KB=1024B]

     */

    public static final Long FILE_LIMIT_SIZE = 1024 * 1024 * 1L;



    /**

     * 文件超限提示

     */

    public static final String FILE_LIMIT_SIZE_MSG = "The file size exceeds the limit";



    /**

     * 解压文件（带限制解压文件大小策略）

     *

     * @param file         压缩文件

     * @param outputfolder 解压后的文件目录

     * @param size         限制解压之后的文件大小（单位：B），示例 3M：1024 * 1024 * 3L （FileBombUtil.FILE_LIMIT_SIZE * 3）

     * @throws Exception IllegalArgumentException 超限抛出的异常

     *                   注意：业务层必须抓取IllegalArgumentException异常，如果msg等于FILE_LIMIT_SIZE_MSG

     *                   要考虑后面的逻辑，比如告警

     */

    public static void unzip(File file, File outputfolder, Long size) throws Exception {

        ZipFile zipFile = new ZipFile(file);

        FileOutputStream fos = null;

        try {

            Enumeration<? extends ZipEntry> zipEntries = zipFile.entries();

            long zipFileSize = 0L;

            ZipEntry entry;

            while (zipEntries.hasMoreElements()) {

                // 获取 ZIP 文件的下一个条目

                entry = zipEntries.nextElement();

                // 将解缩大小累加到 zipFileSize 变量

                zipFileSize += entry.getSize();

                // 判断解压文件累计大小是否超过指定的大小

                if (zipFileSize > size) {

                    deleteDir(outputfolder);

                    throw new IllegalArgumentException(FILE_LIMIT_SIZE_MSG);

                }

                File unzipped = new File(outputfolder, entry.getName());

                if (entry.isDirectory() && !unzipped.exists()) {

                    unzipped.mkdirs();

                    continue;

                } else if (!unzipped.getParentFile().exists()) {

                    unzipped.getParentFile().mkdirs();

                }



                fos = new FileOutputStream(unzipped);

                InputStream in = zipFile.getInputStream(entry);



                byte[] buffer = new byte[4096];

                int count;

                while ((count = in.read(buffer, 0, buffer.length)) != -1) {

                    fos.write(buffer, 0, count);

                }

            }

        } finally {

            if (null != fos) {

                fos.close();

            }

            if (null != zipFile) {

                zipFile.close();

            }

        }



    }



    /**

     * 递归删除目录文件

     *

     * @param dir 目录

     */

    private static boolean deleteDir(File dir) {

        if (dir.isDirectory()) {

            String[] children = dir.list();

            //递归删除目录中的子目录下

            for (int i = 0; i < children.length; i++) {

                boolean success = deleteDir(new File(dir, children[i]));

                if (!success) {

                    return false;

                }

            }

        }

        // 目录此时为空，可以删除

        return dir.delete();

    }



}

测试类：

import java.io.File;



/**

 * 文件炸弹测试类

 *

 * @author bamboo panda

 * @version 1.0

 * @date 2023/10

 */

public class Test {



    public static void main(String[] args) {

        File bomb = new File("D:\temp\3\zbsm.zip");

        File tempFile = new File("D:\temp\3\4");

        try {

            FileBombUtil.unzip(bomb, tempFile, FileBombUtil.FILE_LIMIT_SIZE * 60);

        } catch (IllegalArgumentException e) {

            if (FileBombUtil.FILE_LIMIT_SIZE_MSG.equalsIgnoreCase(e.getMessage())) {

                FileBombUtil.deleteDir(tempFile);

                System.out.println("原始文件太大");

            } else {

                System.out.println("错误的压缩文件格式");

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }



}

三、总结

文件炸弹是一种恶意的计算机程序或文件，旨在利用压缩算法和递归结构来创建一个巨大且无限增长的文件或文件集
合。它的目的是消耗目标系统的资源，如磁盘空间、内存和处理能力，导致系统崩溃或无法正常运行。文件炸弹可能是有意制造的攻击工具，用于拒绝服务（DoS）攻击或滥用资源的目的。

文件炸弹带来的危害极大，作为开发人员，我们必须深刻认识到文件炸弹的危害性，并始终保持高度警惕，以防止这种潜在漏洞给恐怖分子以可乘之机。

总而言之，我们作为开发人员，要深刻认识到文件炸弹的危害性，严防死守，不给恐怖分子任何可乘之机。通过使用安全工具、限制文件大小、及时更新软件、定期备份数据以及加强安全意识，我们可以有效地防止文件炸弹和其他恶意活动对系统造成损害。

在中国，网络安全和计算机犯罪问题受到相关法律法规的管理和监管。以下是一些中国关于网络安全和计算机犯罪方面的法律文献，其中也涉及到文件炸弹的相关规定：

1. 《中华人民共和国刑法》- 该法律规定了各种计算机犯罪行为的法律责任，包括非法控制计算机信息系统、破坏计算机信息系统功能、非法获取计算机信息系统数据等行为，这些行为可能涉及到使用文件炸弹进行攻击。


2. 《中华人民共和国网络安全法》- 该法律是中国的基本法律，旨在保障网络安全和维护国家网络空间主权。它规定了网络安全的基本要求和责任，包括禁止制作、传播软件病毒、恶意程序和文件炸弹等危害网络安全的行为。


3. 《中华人民共和国计算机信息系统安全保护条例》- 这是一项行政法规，详细规定了计算机信息系统安全的保护措施和管理要求。其中包含了对恶意程序、计算机病毒和文件炸弹等威胁的防范要求。

在现代软件架构中，不同类型的类扮演着不同的角色，共同构成了一个清晰、模块化和可维护的系统。以下是对实体类（Entity）、数据传输对象（DTO）、领域对象（Domain Object）、持久化对象（Persistent Object）、业务对象（Business Object）、应用对象（Application Object）、数据访问对象（Data Access Object, DAO）、服务层（Service Layer）和控制器层（Controller Layer）的总体介绍：

不同领域作用

POJO (Plain Old Java Object)

• 定义：POJO 是一个简单的Java对象，它不继承任何特定的类或实现任何特定的接口，除了可能实现 java.io.Serializable 接口。它通常用于表示数据，不包含业务逻辑。


• 案例的体现：
  
  
  
  
  • UserEntity 类可以看作是一个POJO，因为它主要包含数据字段和标准的构造函数、getter和setter方法。
  
  
  • UserDTO 类也是一个POJO，它用于传输数据，不包含业务逻辑。
  
  
  
  

VO (Value Object)

• 定义：VO 是一个代表某个具体值或概念的对象，通常用于表示传输数据的结构，不涉及复杂的业务逻辑。

VO（View Object）的特点：

• 展示逻辑：VO通常包含用于展示的逻辑，例如格式化的日期或货币值。


• 用户界面相关：VO设计时会考虑用户界面的需求，可能包含特定于视图的属性。


• 可读性：VO可能包含额外的描述性信息，以提高用户界面的可读性。

实体类（Entity）

• 作用：代表数据库中的一个表，是数据模型的实现，通常与数据库表直接映射。


• 使用场景：当需要将应用程序的数据持久化到数据库时使用。

数据传输对象（DTO）

• 作用：用于在应用程序的不同层之间传输数据，特别是当需要将数据从服务层传输到表示层或客户端时。


• 使用场景：进行数据传输，尤其是在远程调用或不同服务间的数据交换时。

领域对象（Domain Object）

• 作用：代表业务领域的一个实体或概念，通常包含业务逻辑和业务状态。


• 使用场景：在业务逻辑层处理复杂的业务规则时使用。

持久化对象（Persistent Object）

• 作用：与数据存储直接交互的对象，通常包含数据访问逻辑。


• 使用场景：执行数据库操作，如CRUD（创建、读取、更新、删除）操作。

业务对象（Business Object）

• 作用：封装业务逻辑和业务数据，通常与领域对象交互。


• 使用场景：在业务逻辑层实现业务需求时使用。

应用对象（Application Object）

• 作用：封装应用程序的运行时配置和状态，通常不直接与业务逻辑相关。


• 使用场景：在应用程序启动或运行时配置时使用。

数据访问对象（Data Access Object, DAO）

• 作用：提供数据访问的抽象接口，定义了与数据存储交互的方法。


• 使用场景：需要进行数据持久化操作时，作为数据访问层的一部分。

服务层（Service Layer）

• 作用：包含业务逻辑和业务规则，协调应用程序中的不同组件。


• 使用场景：处理业务逻辑，执行业务用例。

控制器层（Controller Layer）

• 作用：处理用户的输入，调用服务层的方法，并返回响应结果。


• 使用场景：处理HTTP请求和响应，作为Web应用程序的前端和后端之间的中介。

案例介绍

案例代码

视图对象（VO）

一个订单系统，我们需要在用户界面展示订单详情：

// OrderDTO - 数据传输对象

public class OrderDTO {

    private Long id;

    private String customerName;

    private BigDecimal totalAmount;

    // Constructors, getters and setters

}



// OrderVO - 视图对象

public class OrderVO {

    private Long id;

    private String customerFullName; // 格式化后的顾客姓名

    private String formattedTotal; // 格式化后的总金额，如"$1,234.56"

    private String orderDate; // 格式化后的订单日期



    // Constructors, getters and setters



    public OrderVO(OrderDTO dto) {

        this.id = dto.getId();

        this.customerFullName = formatName(dto.getCustomerName());

        this.formattedTotal = formatCurrency(dto.getTotalAmount());

        this.orderDate = formatDateTime(dto.getOrderDate());

    }



    private String formatName(String name) {

        // 实现姓名格式化逻辑

        return name;

    }



    private String formatCurrency(BigDecimal amount) {

        // 实现货币格式化逻辑

        return "$" + amount.toString();

    }



    private String formatDateTime(Date date) {

        // 实现日期时间格式化逻辑

        return new SimpleDateFormat("yyyy-MM-dd").format(date);

    }

}

实体类（Entity）

package com.example.model;



import javax.persistence.*;



@Entity

@Table(name = "users")

public class UserEntity {

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Long id;



    @Column(nullable = false, unique = true)

    private String username;



    @Column(nullable = false)

    private String password;



    // Constructors, getters and setters

    public UserEntity() {}



    public UserEntity(String username, String password) {

        this.username = username;

        this.password = password;

    }



    public Long getId() {

        return id;

    }



    public void setId(Long id) {

        this.id = id;

    }



    public String getUsername() {

        return username;

    }



    public void setUsername(String username) {

        this.username = username;

    }



    public String getPassword() {

        return password;

    }



    public void setPassword(String password) {

        this.password = password;

    }

}

数据传输对象（DTO）

package com.example.dto;



public class UserDTO {

    private Long id;

    private String username;



    // Constructors, getters and setters

    public UserDTO() {}



    public UserDTO(Long id, String username) {

        this.id = id;

        this.username = username;

    }



    public Long getId() {

        return id;

    }



    public void setId(Long id) {

        this.id = id;

    }



    public String getUsername() {

        return username;

    }



    public void setUsername(String username) {

        this.username = username;

    }

}

领域对象（Domain Object）

package com.example.domain;



public class UserDomain {

    private Long id;

    private String username;



    // Business logic methods

    public UserDomain() {}



    public UserDomain(Long id, String username) {

        this.id = id;

        this.username = username;

    }



    public Long getId() {

        return id;

    }



    public void setId(Long id) {

        this.id = id;

    }



    public String getUsername() {

        return username;

    }



    public void setUsername(String username) {

        this.username = username;

    }



    // Additional domain-specific methods

}

领域对象通常包含业务领域内的概念和逻辑。在订单系统中，这可能包括订单状态、订单项、总价等。

package com.example.domain;



import java.util.List;



public class OrderDomain {

    private String orderId;

    private List items; // 订单项列表

    private double totalAmount;

    private OrderStatus status; // 订单状态



    // Constructors, getters and setters



    public OrderDomain(String orderId, List items) {

        this.orderId = orderId;

        this.items = items;

        this.totalAmount = calculateTotalAmount();

        this.status = OrderStatus.PENDING; // 默认状态为待处理

    }



    private double calculateTotalAmount() {

        double total = 0;

        for (OrderItemDomain item : items) {

            total += item.getPrice() * item.getQuantity();

        }

        return total;

    }



    // 业务逻辑方法，例如更新订单状态

    public void processPayment() {

        // 处理支付逻辑

        if (/* 支付成功条件 */) {

            this.status = OrderStatus.PAYMENT_COMPLETED;

        }

    }



    // 更多业务逻辑方法...

}

持久化对象（Persistent Object）

package com.example.model;



public class UserPersistent extends UserEntity {

    // Methods to interact with persistence layer, extending UserEntity

}

业务对象（Business Object）

package com.example.service;



public class UserBO {

    private UserDomain userDomain;



    public UserBO(UserDomain userDomain) {

        this.userDomain = userDomain;

    }



    // Business logic methods

    public void performBusinessLogic() {

        // Implement business logic

    }

}

 OrderBO 业务对象通常封装业务逻辑，可能包含领域对象，并提供业务操作的方法。

package com.example.service;



import com.example.domain.OrderDomain;



public class OrderBO {

    private OrderDomain orderDomain;



    public OrderBO(OrderDomain orderDomain) {

        this.orderDomain = orderDomain;

    }



    // 执行订单处理的业务逻辑

    public void performOrderProcessing() {

        // 例如，处理订单支付

        orderDomain.processPayment();

        // 其他业务逻辑...

    }



    // 更多业务逻辑方法...

}

应用对象（Application Object）

package com.example.config;



public class AppConfig {

    private String environment;

    private String configFilePath;



    public AppConfig() {

        // Initialize with default values or environment-specific settings

    }



    // Methods to handle application configuration

    public void loadConfiguration() {

        // Load configuration from files, environment variables, etc.

    }



    // Getters and setters

}

数据访问对象（Data Access Object）

package com.example.dao;



import com.example.model.UserEntity;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;



@Repository

public interface UserDAO extends JpaRepository {

    // Custom data access methods if needed

    UserEntity findByUsername(String username);

}

- OrderDAO DAO 提供数据访问的抽象接口，定义了与数据存储交互的方法。在Spring Data JPA中，可以继承JpaRepository并添加自定义的数据访问方法。

package com.example.dao;



import com.example.domain.OrderDomain;

import org.springframework.data.jpa.repository.JpaRepository;



public interface OrderDAO extends JpaRepository { // 主键类型为String

    // 自定义数据访问方法，例如根据订单状态查询订单

    List findByStatus(OrderStatus status);

}

服务层（Service Layer）

package com.example.service;



import com.example.dao.UserDAO;

import com.example.dto.UserDTO;

import com.example.model.UserEntity;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;



@Service

public class UserService {

    private final UserDAO userDAO;



    @Autowired

    public UserService(UserDAO userDAO) {

        this.userDAO = userDAO;

    }



    public UserDTO getUserById(Long id) {

        UserEntity userEntity = userDAO.findById(id).orElseThrow(() -> new RuntimeException("User not found"));

        return convertToDTO(userEntity);

    }



    private UserDTO convertToDTO(UserEntity entity) {

        UserDTO dto = new UserDTO();

        dto.setId(entity.getId());

        dto.setUsername(entity.getUsername());

        return dto;

    }



    // Additional service methods

}

 OrderService服务层协调用户输入、业务逻辑和数据访问。它使用DAO进行数据操作，并可能使用业务对象来执行业务逻辑。

package com.example.service;



import com.example.dao.OrderDAO;

import com.example.domain.OrderDomain;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;



import java.util.List;



@Service

public class OrderService {

    private final OrderDAO orderDAO;



    @Autowired

    public OrderService(OrderDAO orderDAO) {

        this.orderDAO = orderDAO;

    }



    public List findAllOrders() {

        return orderDAO.findAll();

    }



    public OrderDomain getOrderById(String orderId) {

        return orderDAO.findById(orderId).orElseThrow(() -> new RuntimeException("Order not found"));

    }



    public void processOrderPayment(String orderId) {

        OrderDomain order = getOrderById(orderId);

        OrderBO orderBO = new OrderBO(order);

        orderBO.performOrderProcessing();

        // 更新订单状态等逻辑...

    }



    // 更多服务层方法...

}

控制器层（Controller Layer）

package com.example.controller;



import com.example.dto.UserDTO;

import com.example.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;



@RestController

@RequestMapping("/users")

public class UserController {

    private final UserService userService;



    @Autowired

    public UserController(UserService userService) {

        this.userService = userService;

    }



    @GetMapping("/{id}")

    public UserDTO getUser(@PathVariable Long id) {

        return userService.getUserById(id);

    }



    // Additional controller endpoints

}

总结

这些不同类型的类和层共同构成了一个分层的软件架构，每一层都有其特定的职责和功能。这种分层方法有助于降低系统的复杂性，提高代码的可维护性和可扩展性。通过将业务逻辑、数据访问和用户界面分离，开发人员可以独立地更新和测试每个部分，从而提高开发效率和应用程序的稳定性。

历史热点文章

• 命令模式（Command Pattern）:网络爬虫任务队列实战案例分析


• 迭代器模式（Iterator Pattern）：电商平台商品分类浏览实战案例分析


• 中介者模式（Mediator Pattern）:即时通讯软件实战案例分析


• 备忘录模式（Memento Pattern）:游戏存档系统实战案例分析


• 状态模式（State Pattern）:电商平台订单状态管理实战案例分析


• 责任链模式（Chain of Responsibility Pattern）：电商平台的订单审批流程实战案例分析


• 访问者模式（Visitor Pattern）:电商平台商品访问统计实战案例分析


• 工厂方法模式（Factory Method Pattern）: 电商多种支付实战案例分析


• 抽象工厂模式（Abstract Factory Pattern）：多风格桌面应用实战案例分析


• 建造者模式（Builder Pattern）： 在线订单系统实战案例分析


• 原型模式（Prototype Pattern）: 云服务环境配置实战案例分析


• 适配器模式（Adapter Pattern）:第三方支付集成实战案例分析


• 装饰器模式（Decorator Pattern）:电商平台商品价格策略实战案例分析


• 单例模式（Singleton Pattern）：购物车实战案例分析