bugstack虫洞栈 | 沉淀、分享、成长，让自己和他人都能有所收获

《IntelliJ IDEA 插件开发》第一节：两种方式创建插件工程

Mon, 18 Oct 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：

一、前言

并不是所有的不会，都是真不会！

对于码农这一行业的编程学习生涯来说，会遇到很多的不会，不会搭建IDEA工程、不会写老师的案例、不会完成书中的效果、不会做项目的需求、不会实现复杂的逻辑、不会抽象工程的结构等等。但这些不会当中并不是所有的不会，都因为太复杂学不会，而是很大一部分内容因为找不到好的资料、没有清晰的文档、缺少完整的案例，导致不知道所以不会。

正好最近在折腾IDEA插件开发的时候，市面的资料确实不多，也没有成体系完整的开发指导手册，所以就遇到了很多不知道就不会的事情，需要一点点查询搜索源码、验证API接口，最终把各项功能实现，当然在这个过程中也确实踩了不少坑！

好！沉淀下来，接下来在这个专栏会把一些关于 IDEA 插件开发用到的各项知识做成案例输出出来，一方面可以让自己缕清所有的知识项，另一方面也可以帮助到更多的有需要的研发人员使用。

二、需求目的

可能你会想什么场景会需要用到插件开发，其实插件开发算是一种通用的解决方案，由服务平台定义标准让各自使用方进行自需的扩展。

这就像我们非常常用的 P3C 代码检查插件、代码审计插件、脚手架工程创建插件、自动化API提取插件、单元测试统计插件等等，这些都是在 IDEA 代码开发平台扩展出来的各项功能插件。

插件也可以说是一种解决方案，其实与你在代码编程时使用人家已经定义好的标准结构和功能下，扩展出自己的功能时是一样的。而这种方式也可以非常好的解决一些属于代码开发期间不易于放到代码提测后问题场景，并能及时提醒研发人员作出响应的修改处理。

三、环境说明

IntelliJ Platform Plugin JDK 不是自己安装的JDK1.8等，只有插件JDK才能开发插件
IntelliJ IDEA 2019.3.1 x64 如果你是其他版本，会涉及到插件工程创建后版本修改
gradle-5.2.1 与 2019 IDEA 版本下的插件开发匹配，如果遇到一些环境问题可以参考我们开篇介绍

在官方文档 https://plugins.jetbrains.com/docs/intellij/disposers.html 介绍开发 IDEA 插件的工程方式有两种，分别是模板方式和 Gradle 工程方式。这里我们分别演示下不同方式下工程的创建和所涉及到知识点内容的介绍，虽然两种方式都能创建 IDEA 插件工程，但更推荐使用 Gradle 方式。

四、模板方式创建

1. 创建引导

New -> Project -> IntelliJ Platform Plugin

2. 工程结构

guide-idea-plugin-create-project-by-platform
├── resources
│   └── META-INF
│       └── plugin.xml 
└── src
    └── cn.bugstack.guide.idea.plugin
        └── MyAction.java  

源码：https://github.com/fuzhengwei/guide-idea-plugin-create-project-by-platform

plugin.xml 插件配置：开发描述、版本信息、Action事件入口、扩展信息(数据存放等)
src 具体的事件、UI窗体、工程逻辑代码开发
另外类似 MyAction 的创建并不是直接创建普通类，而是通过 New -> Plugin DevKit -> Action 的方式进行创建，因为这样的创建方式可以再 plugin.xml 中自动添加 action 配置。当然如果你要是自己手动创建普通类那样创建 Action 类，则需要自己手动处理配置信息。

3. plugin.xml 配置

<idea-plugin>
  <id>cn.bugstack.guide.idea.plugin</id>
  <name>CreateProjectByPlatform</name>
  <version>1.0</version>
  <vendor email="184172133@qq.com" url="https://bugstack.cn">小傅哥</vendor>

  <description><![CDATA[
      基于IDEA插件模板方式创建测试工程<br>
      <em>1. 学习IDEA插件工程搭建</em>
      <em>2. 验证插件基础功能实现</em>
    ]]></description>

  <change-notes><![CDATA[
      插件开发学习功能点<br>
      <em>1. 工程搭建</em>
      <em>2. 菜单读取</em>
      <em>3. 获取配置</em>
      <em>4. 回显页面</em>
    ]]>
  </change-notes>

  <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
  <idea-version since-build="173.0"/>

  <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
       on how to target different products -->
  <depends>com.intellij.modules.platform</depends>

  <extensions defaultExtensionNs="com.intellij">
    <!-- Add your extensions here -->
  </extensions>

  <actions>
    <!-- Add your actions here -->
    <action id="MyAction" class="cn.bugstack.guide.idea.plugin.MyAction" text="MyAction" description="MyAction">
      <add-to-group group-id="FileMenu" anchor="first"/>
    </action>

  </actions>

</idea-plugin>

这里重点看 actions 其他上面的工程信息、版本描述、个人资料都按照自己的信息填写就行，不会影响插件运行。
actions 下是关于所有事件入口的配置，也就是你希望让你的 IDEA 插件在 IDEA 窗体中什么地方展示，以及配置快捷键等。这里的配置说明是在 FileMenu 下的第一个入口即为你的插件。

4. MyAction 事件入口

public class MyAction extends AnAction {

    @Override
    public void actionPerformed(AnActionEvent e) {
        Project project = e.getData(PlatformDataKeys.PROJECT);
        PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE);
        String classPath = psiFile.getVirtualFile().getPath();

        Messages.showMessageDialog(project, "guide-idea-plugin-create-project-by-platform: " + classPath, "Hi IDEA Plugin", Messages.getInformationIcon());
    }

}

在 MyAction 事件入口中获取 Project 工程信息、PsiFile 文件信息，以及对应的类路径。
最后在 Messages.showMessageDialog 下打印，这样把鼠标放到工程类下，在点这个按钮的时候就可以看到类的路径弹窗了。

5. 运行测试

运行过程

点击 Plugin 绿色箭头，和正常启动程序一样
这个时候它会打开一个新的 IDEA 工程，并在这个工程中默认安装你开发好的插件
在新打开的 IDEA 插件工程中，选中工程类后，点击 File -> MyAction

运行结果

通过测试运行效果可以看到，已经可以打出工程下类的路径信息了。你也可以尝试把Action的入口放到其他按钮下进行测试

五、Gradle 方式创建

1. 创建引导

New -> Project -> Gradle 选中 Java & IntelliJ Platform Plugin

2. 工程结构

guide-idea-plugin-create-project-by-gradle
├── .gradle
└── src
    ├── main
    │   └── java
    │   	└── cn.bugstack.guide.idea.plugin 
    │       	└── MyAction.java    
    ├── resources
    │   └── META-INF
    │       └── plugin.xml 
    ├── build.gradle  
    └── gradle.properties

源码：https://github.com/fuzhengwei/guide-idea-plugin-create-project-by-gradle

与模板方式创建 Gradle 主要差异在 build.gradle、gradle.properties 内容的配置，这两个文件主要是处理 Gradle 相关信息的，其中 gradle.properties 用于配置 JVM Xmx 参数的，避免下载耗费资源较大崩溃。
plugin.xml 配置插件入口等内容，MyAction 是事件入口。

3. build.gradle 配置

plugins {
    id 'java'
    id 'org.jetbrains.intellij' version '0.6.3'
}

group 'cn.bugstack.guide.idea.plugin'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

// See https://github.com/JetBrains/gradle-intellij-plugin/
intellij {
    version '2019.3.1'
}
patchPluginXml {
    changeNotes """
      <![CDATA[
      插件开发学习功能点<br>
      <em>1. 工程搭建</em>
      <em>2. 菜单读取</em>
      <em>3. 获取配置</em>
      <em>4. 回显页面</em>
    ]]>"""
}

gradle 与 maven 的使用配置上，还是可以相通的找到一些类似的地方的，如果没有使用过 gradle 也是可以使用的。
这里需要注意 plugins 中 id 'org.jetbrains.intellij' version '0.6.3' 默认创建工程的版本有点高，与 gradle 5.x 不匹配。不过你可以尝试调试合适版本进行使用

4. MyAction 事件入口

public class MyAction extends AnAction {

    @Override
    public void actionPerformed(AnActionEvent e) {
        Project project = e.getData(PlatformDataKeys.PROJECT);
        PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE);
        String classPath = psiFile.getVirtualFile().getPath();

        Messages.showMessageDialog(project, "guide-idea-plugin-create-project-by-gradle: " + classPath, "Hi IDEA Plugin", Messages.getInformationIcon());
    }

}

这里与模板方式创建的案例是一样的，为了区别两个插件测试，我们这里打印了工程的名称。当然你也可以使用 project.getName() 获取工程名称。

5. 运行测试

Gradle 测试运行相当于是运行 :runIde ,也是和普通的代码调试一样。

运行结果

通过测试运行效果可以看到，已经可以打出工程下类的路径信息了。

六、总结

整篇内容的学习还是蛮简单的，哪怕你之前没开发过 IDEA 插件，按照这样的套路往下折腾也是可以完成插件开发的。类似这样的知识内容只是平时常做业务开发所以接触的也不多，乍一听上去还是很陌生的，不过有这样的资料就可以上手了。
本章节初步介绍 IDEA 插件的方式和一个非常简单的基本功能，后续我们在 Gradle 创建插件的基础上，继续开发其他案例功能，逐步学习 IDEA 插件开发用到的各项技巧用于完成所需要解决的问题。
在学习的过程中可以自行尝试扩展一些其他组件入口，打印不同的工程信息。就像你使用的一些的插件一样，帮助你生成get、set，或者提取采集接口信息，也包括你写了多少行代码，思考它们是如何实现的。

七、系列推荐

12种 vo2dto 方法，就 BeanUtils.copyProperties 压测最拉胯！

Sun, 10 Oct 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/Xq7oQg7dYESMYxHVnxX8Dw

一、前言

为哈么，你的代码也就仅仅是能用而已？

没有技术深度、短缺知识储备、匮乏经验积累的前提下，怎么写代码？百度呀，遇到问题这搜一点，那查一块，不管它是什么原理还是适合哪种场景，先粘贴到自己的工程里，看，能跑了，能跑就行。那这样的代码也就仅仅是能用程度的交付，根本没有一定的质量保证，也更别提数据结构、算法逻辑和设计模式了，那看的编程资料刷的LeetCode，全歇菜了。

当你感觉看了很多资料又不会用的时候，会说什么，真卷，都学到这样了。但其实我并不觉对技术的深度挖掘、梳理全套的知识体系，一点点耕耘一点点收获是在卷。反而把看技术视频当成看电影一样轻松，不写案例就以为书看会了的爽，没有意义的缺少脑力思考机械式体力重复，才是卷，甚至很卷。

就像让你用一个属性拷贝工具，把vo转成dto，你用了哪呢，是 Apache 的还是 Spring 的，还是其他的什么，哪个效率最高？接下来我们来用数据验证下，并提供出各种案例的使用对比

二、性能测试对比

在 Java 系统工程开发过程中，都会有各个层之间的对象转换，比如 VO、DTO、PO、VO 等，而如果都是手动get、set又太浪费时间，还可能操作错误，所以选择一个自动化工具会更加方便。

目前我整理出，用于对象属性转换有12种，包括：普通的getset、json2Json、Apache属性拷贝、Spring属性拷贝、bean-mapping、bean-mapping-asm、BeanCopier、Orika、Dozer、ModelMapper、JMapper、MapStruct 接下来我们分别测试这11种属性转换操作分别在一百次、一千次、一万次、十万次、一百万次时候的性能时间对比。

BeanUtils.copyProperties 是大家代码里最常出现的工具类，但只要你不把它用错成 Apache 包下的，而是使用 Spring 提供的，就基本还不会对性能造成多大影响。
但如果说性能更好，可替代手动get、set的，还是 MapStruct 更好用，因为它本身就是在编译期生成get、set代码，和我们写get、set一样。
其他一些组件包主要基于 AOP、ASM、CGlib，的技术手段实现的，所以也会有相应的性能损耗。

三、12种转换案例

源码：https://github.com/fuzhengwei/guide-vo2dto

描述：在案例工程下创建 interfaces.assembler 包，定义 IAssembler<SOURCE, TARGET>#sourceToTarget(SOURCE var) 接口，提供不同方式的对象转换操作类实现，学习的过程中可以直接下载运行调试。

1. get\set

@Component
public class GetSetAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId(var.getUserId());
        userDTO.setUserNickName(var.getUserNickName());
        userDTO.setCreateTime(var.getCreateTime());
        return userDTO;
    }

}

推荐：★★★☆☆
性能：★★★★★
手段：手写
点评：其实这种方式也是日常使用的最多的，性能肯定是杠杠的，就是操作起来有点麻烦。尤其是一大堆属性的 VO 对象转换为 DTO 对象时候。但其实也有一些快捷的操作方式，比如你可以通过 Shift+Alt 选中所有属性，Shift+Tab 归并到一列，接下来在使用 Alt 选中这一列，批量操作粘贴 userDTO.set 以及快捷键大写属性首字母，最后切换到结尾补充括号和分号，最终格式化一下就搞定了。

2. json2Json

@Component
public class Json2JsonAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        String strJson = JSON.toJSONString(var);
        return JSON.parseObject(strJson, UserDTO.class);
    }

}

推荐：☆☆☆☆☆
性能：★☆☆☆☆
手段：把对象转JSON串，再把JSON转另外一个对象
点评：这么写多半有点烧！

3. Apache copyProperties

@Component
public class ApacheCopyPropertiesAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        UserDTO userDTO = new UserDTO();
        try {
            BeanUtils.copyProperties(userDTO, var);
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return userDTO;
    }

}

推荐：☆☆☆☆☆
性能：★☆☆☆☆
手段：Introspector 机制获取到类的属性来进行赋值操作
点评：有坑，兼容性交差，不建议使用

4. Spring copyProperties

@Component
public class SpringCopyPropertiesAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        UserDTO userDTO = new UserDTO();
        BeanUtils.copyProperties(var, userDTO);
        return userDTO;
    }

}

推荐：★★★☆☆
性能：★★★★☆
手段：Introspector机制获取到类的属性来进行赋值操作
点评：同样是反射的属性拷贝，Spring 提供的 copyProperties 要比 Apache 好用的多，只要你不用错，基本不会有啥问题。

5. Bean Mapping

@Component
public class BeanMappingAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        UserDTO userDTO = new UserDTO();
        BeanUtil.copyProperties(var, userDTO);
        return userDTO;
    }

}

推荐：★★☆☆☆
性能：★★★☆☆
手段：属性拷贝
点评：性能一般

6. Bean Mapping ASM

@Component
public class BeanMappingAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        UserDTO userDTO = new UserDTO();
        BeanUtil.copyProperties(var, userDTO);
        return userDTO;
    }

}

推荐：★★★☆☆
性能：★★★★☆
手段：基于ASM字节码框架实现
点评：与普通的 Bean Mapping 相比，性能有所提升，可以使用。

7. BeanCopier

@Component
public class BeanCopierAssembler implements IAssembler<UserVO, UserDTO> {

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        UserDTO userDTO = new UserDTO();
        BeanCopier beanCopier = BeanCopier.create(var.getClass(), userDTO.getClass(), false);
        beanCopier.copy(var, userDTO, null);
        return userDTO;
    }

}

推荐：★★★☆☆
性能：★★★★☆
手段：基于CGlib字节码操作生成get、set方法
点评：整体性能很不错，使用也不复杂，可以使用

8. Orika

@Component
public class OrikaAssembler implements IAssembler<UserVO, UserDTO> {

    /**
     * 构造一个MapperFactory
     */
    private static MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

    static {
        mapperFactory.classMap(UserDTO.class, UserVO.class)
                .field("userId", "userId")  // 字段不一致时可以指定
                .byDefault()
                .register();
    }

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        return mapperFactory.getMapperFacade().map(var, UserDTO.class);
    }

}

官网：https://orika-mapper.github.io/orika-docs/
推荐：★★☆☆☆
性能：★★★☆☆
手段：基于字节码生成映射对象
点评：测试性能不是太突出，如果使用的话需要把 MapperFactory 的构建优化成 Bean 对象

9. Dozer

@Component
public class DozerAssembler implements IAssembler<UserVO, UserDTO> {

    private static DozerBeanMapper mapper = new DozerBeanMapper();

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        return mapper.map(var, UserDTO.class);
    }

}

官网：http://dozer.sourceforge.net/documentation/gettingstarted.html
推荐：★☆☆☆☆
性能：★★☆☆☆
手段：属性映射框架，递归的方式复制对象
点评：性能有点差，不建议使用

10. ModelMapper

@Component
public class ModelMapperAssembler implements IAssembler<UserVO, UserDTO> {

    private static ModelMapper modelMapper = new ModelMapper();

    static {
        modelMapper.addMappings(new PropertyMap<UserVO, UserDTO>() {
            @Override
            protected void configure() {
                // 属性值不一样可以自己操作
                map().setUserId(source.getUserId());
            }
        });
    }

    @Override
    public UserDTO sourceToTarget(UserVO var) {
        return modelMapper.map(var, UserDTO.class);
    }

}

官网：http://modelmapper.org
推荐：★★★☆☆
性能：★★★☆☆
手段：基于ASM字节码实现
点评：转换对象数量较少时性能不错，如果同时大批量转换对象，性能有所下降

11. JMapper

JMapper<UserDTO, UserVO> jMapper = new JMapper<>(UserDTO.class, UserVO.class, new JMapperAPI()
        .add(JMapperAPI.mappedClass(UserDTO.class)
                .add(JMapperAPI.attribute("userId")
                        .value("userId"))
                .add(JMapperAPI.attribute("userNickName")
                        .value("userNickName"))
                .add(JMapperAPI.attribute("createTime")
                        .value("createTime"))
        ));

官网：https://github.com/jmapper-framework/jmapper-core/wiki
推荐：★★★★☆
性能：★★★★★
手段：Elegance, high performance and robustness all in one java bean mapper
点评：速度真心可以，不过结合 SpringBoot 感觉有的一点点麻烦，可能姿势不对

12. MapStruct

@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE, unmappedSourcePolicy = ReportingPolicy.IGNORE)
public interface UserDTOMapping extends IMapping<UserVO, UserDTO> {

    /** 用于测试的单例 */
    IMapping<UserVO, UserDTO> INSTANCE = Mappers.getMapper(UserDTOMapping.class);

    @Mapping(target = "userId", source = "userId")
    @Mapping(target = "createTime", dateFormat = "yyyy-MM-dd HH:mm:ss")
    @Override
    UserDTO sourceToTarget(UserVO var1);

    @Mapping(target = "userId", source = "userId")
    @Mapping(target = "createTime", dateFormat = "yyyy-MM-dd HH:mm:ss")
    @Override
    UserVO targetToSource(UserDTO var1);

}

官网：https://github.com/mapstruct/mapstruct
推荐：★★★★★
性能：★★★★★
手段：直接在编译期生成对应的get、set，像手写的代码一样
点评：速度很快，不需要到运行期处理，结合到框架中使用方便

四、总结

其实对象属性转换的操作无非是基于反射、AOP、CGlib、ASM、Javassist 在编译时和运行期进行处理，再有好的思路就是在编译前生成出对应的get、set，就像手写出来的一样。
所以我更推荐我喜欢的 MapStruct，这货用起来还是比较舒服的，一种是来自于功能上的拓展性，易用性和兼容性。
无论哪种使用，都要做一下完整的测试和验证，不要上来就复制粘贴，否则你可能早早的就把挖好坑了，当然不一定是哪个兄弟来填坑了。

五、系列推荐

p3c 插件，是怎么检查出你那屎山的代码？

Mon, 27 Sep 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/RwzprbY2AhdgslY8tbVL-A

一、前言

你会对你用到都技术，好奇吗？

虽然我们都被称为码农，也都是写着代码，但因为所处场景需求的不同，所以各类码农也都做着不一样都事情。

有些人统一规范、有些人开发组件、有些人编写业务、有些人倒腾验证，但越是工作内容简单如CRUD一样的码农，用到别人提供好的东西却是越多。一会安装个插件、一会引入个Jar包、一会调别人个接口，而自己的工作就像是装配工，东拼拼西凑凑，就把产品需求写完了。

坏了，这么干可能几年下来，也不会有什么技术上都突破。因为你对那些使用都技术不好奇，不想知道它们是怎么实现的。就像阿里的P3C插件，是怎么检查代码分析出来我写的拉胯的呢？

二、P3C 插件是什么

P3C 是阿里开源代码库的插件工程名称，它以阿里巴巴Java开发手册为标准，用于监测代码质量的 IDEA/Eclipse 插件。

源码：https://github.com/alibaba/p3c

插件安装完成后，就可以按照编程规约，静态分析代码中出现的代码：命名风格、常量定义、集合处理、并发处理、OOP、控制语句、注释、异常等各项潜在风险，同时会给出一些优化操作和实例。

在遵守开发手册标准并按照插件检查都情况下，还是可以非常好的统一编码标准和风格都，也能剔除掉一些潜在都风险。
如果你是新手编程用户或者想写出标准都代码，那么非常建议你按照这样都插件来辅助自己做代码开发。当然如果你所在的公司也有相应都标准手册和插件，也可以按照后遵守它都约定的。

三、P3C 插件源码

在最开始使用这类代码检查都插件的时候，就非常好奇它是怎么发现我的屎山代码的，用了什么样都技术原理呢，如果我能分析下是不是也可以把这样都技术手段用到其他地方。

在分析这样一个代码检查插件前，先思考要从 IDEA 插件都源码查起，看看它是什么个逻辑，之后分析具体是如何使用都。其实这与一些其他的框架性源码学习都是类似的，拿到官网都文档、GitHub 对应的源码，按照步骤进行构建、部署、测试、调试、分析，进而找到核心原理。

P3C 以 IDEA 插件开发为例，主要涉及到插件部分和规约部分，因为是把规约检查的能力与插件技术结合，所以会涉及到一些 IDEA 开发的技术。另外 P3C 插件涉及到都技术语言不只是 Java 还有一部分 kotlin 它是一种在 Java 虚拟机上运行的静态类型编程语言。

插件源码：https://github.com/alibaba/p3c/blob/master/idea-plugin
规约源码：https://github.com/alibaba/p3c/tree/master/p3c-pmd

1. 插件配置 p3c.xml

<action class="com.alibaba.p3c.idea.action.AliInspectionAction" id="AliP3CInspectionAction"
        popup="true" text="编码规约扫描" icon="P3cIcons.ANALYSIS_ACTION">
    <keyboard-shortcut keymap="$default"
                       first-keystroke="shift ctrl alt J"/>
    <add-to-group group-id="MainToolBar" anchor="last"/>
    <add-to-group group-id="ProjectViewPopupMenu" anchor="last"/>
    <add-to-group group-id="ChangesViewPopupMenu" anchor="last"/>
    <add-to-group group-id="EditorPopupMenu" anchor="last"/>
</action>

翻看源码最重要是要找到入口，这个入口通常也是你在使用插件、程序、接口等时候，最直接进入都那部分。
那么我们在使用 P3C 插件的时候，最明显的就是 编码规约扫描 通过源码中找到这个关键字，看它都涉及了哪个类都配置。
action 是 IDEA 插件中用于配置窗体事件入口都地方，以及把这个操作配置到哪个按钮下和对应都快捷键。

2. 编码规约扫描( AliInspectionAction)

class AliInspectionAction : AnAction() {

    override fun actionPerformed(e: AnActionEvent) {
        val project = e.project ?: return
        val analysisUIOptions = ServiceManager.getService(project, AnalysisUIOptions::class.java)!!
        analysisUIOptions.GROUP_BY_SEVERITY = true

        val managerEx = InspectionManager.getInstance(project) as InspectionManagerEx
        val toolWrappers = Inspections.aliInspections(project) {
            it.tool is AliBaseInspection
        }
        val psiElement = e.getData<PsiElement>(CommonDataKeys.PSI_ELEMENT)
        val psiFile = e.getData<PsiFile>(CommonDataKeys.PSI_FILE)
        val virtualFile = e.getData<VirtualFile>(CommonDataKeys.VIRTUAL_FILE)
        
		...
		
		createContext(
    	toolWrappers, managerEx, element,
    	projectDir, analysisScope
		).doInspections(analysisScope)
}		

这是一个基于 kotlin 语言开发的插件代码逻辑，它通过 actionPerformed 方法获取到工程信息、类信息等，接下来就可以执行代码检查了 doInspections

3. 规约 p3c-pmd

当我们再往下翻看阅读的时候，就看到了一个关于 pmd 的东西。PMD 是一款采用 BSD 协议发布的Java 程序静态代码检查工具，当使用PMD规则分析Java源码时，PMD首先利用JavaCC和EBNF文法产生了一个语法分析器，用来分析普通文本形式的Java代码，产生符合特定语法结构的语法，同时又在JavaCC的基础上添加了语义的概念即JJTree，通过JJTree的一次转换，这样就将Java代码转换成了一个AST，AST是Java符号流之上的语义层，PMD把AST处理成一个符号表。然后编写PMD规则，一个PMD规则可以看成是一个Visitor，通过遍历AST找出多个对象之间的一种特定模式，即代码所存在的问题。该软件功能强大，扫描效率高，是 Java 程序员 debug 的好帮手。

那么 p3c-pmd 是什么呢？

ViolationUtils.addViolationWithPrecisePosition(this, node, data,
    I18nResources.getMessage("java.naming.ClassNamingShouldBeCamelRule.violation.msg",
        node.getImage()));

p3c-pmd 插件是基于 PMD 实现的，更具体的来说是基于 pmd-java 的，因为 PMD 不仅支持 Java 代码分析，还支持其他多种语言。
具体自定义规则的方式，通过自定义Java类和XPATH规则实现。

四、规约监测案例

讲道理，说一千道一万，还得是拿出代码跑一下，才知道 PMD 具体是什么个样子。

1. 测试工程

guide-pmd
└── src
    ├── main
    │   ├── java
    │   │   └── cn.itedus.guide.pmd.rule
    │   │       ├── naming
    │   │       │   ├── ClassNamingShouldBeCamelRule.java
    │   │       │   ├── ConstantFieldShouldBeUpperCaseRule.java
    │   │       │   └── LowerCamelCaseVariableNamingRule.java
    │   │       ├── utils
    │   │       │   ├── StringAndCharConstants.java
    │   │       │   └── ViolationUtils.java    
    │   │       └── I18nResources
    │   └── resources
    │       ├── rule 
    │       │   └── ali-naming.xml  
    │       ├── messages.xml   
    │       └── namelist.properties  
    └── test
        └── java
            └── cn.itedus.demo.test
                ├── ApiTest.java
                └── TErrDto.java

源码：https://github.com/fuzhengwei/guide-pmd

这是一个类似 p3c-pmd 的测试工程，通过自行扩展重写代码监测规约的方式，来处理自己关于代码的审核标准处理。

naming 下的类是用于处理一些和名称相关的规则，类名、属性名、方法名等
resources 下 ali-naming.xml 是规约的配置文件

2. 驼峰命名规约

public class ClassNamingShouldBeCamelRule extends AbstractJavaRule {

    private static final Pattern PATTERN
            = Pattern.compile("^I?([A-Z][a-z0-9]+)+(([A-Z])|(DO|DTO|VO|DAO|BO|DAOImpl|YunOS|AO|PO))?$");

    @Override
    public Object visit(ASTClassOrInterfaceDeclaration node, Object data) {
        if (PATTERN.matcher(node.getImage()).matches()) {
            return super.visit(node, data);
        }
        
        ViolationUtils.addViolationWithPrecisePosition(this, node, data,
                I18nResources.getMessage("java.naming.ClassNamingShouldBeCamelRule.violation.msg",
                        node.getImage()));

        return super.visit(node, data);
    }
}

通过继承 PMD 提供的 AbstractJavaRule 抽象类，重写 visit 方法，使用正则的方式进行验证。
visit 方法都入参类型非常多，分别用于处理类、接口、方法、代码等各项内容的监测处理，只要重写需要的方法，在里面进行自己都处理就可以。
ClassNamingShouldBeCamelRule、ConstantFieldShouldBeUpperCaseRule、LowerCamelCaseVariableNamingRule 三个类都功能类似，这里就不一一展示了，可以直接参考源码。

3. ali-naming.xml 配置

<rule name="ClassNamingShouldBeCamelRule"
      language="java"
      since="1.6"
      message="java.naming.ClassNamingShouldBeCamelRule.rule.msg"
      class="cn.itedus.guide.pmd.rule.naming.ClassNamingShouldBeCamelRule">
    <priority>3</priority>
</rule>

在 ali-naming.xml 用于配置规约处理类、priority 级别、message 提醒文字。
同时还可以配置代码示例，使用 <example> 标签，在里面写好标准代码即可。

4. 测试验证规约

问题类示例

public class TErrDto {

    public static final Long max = 50000L;

    public void QueryUserInfo(){
        boolean baz = true;
        while (baz)
            baz = false;
    }

}

单元测试

@Test
public void test_naming(){
    String[] str = {
            "-d",
            "E:\\itstack\\git\\github.com\\guide-pmd\\src\\test\\java\\cn\\itedus\\demo\\test\\TErrDto.java",
            "-f",
            "text",
            "-R",
            "E:\\itstack\\git\\github.com\\guide-pmd\\src\\main\\resources\\rule\\ali-naming.xml"
            // "category/java/codestyle.xml"
    };
    PMD.main(str);
}

规约的测试验证可以直接使用 PMD.main 方法，在方法中提供字符串数组入参，这里的代码监测地址和规约配置需要是绝对路径。

测试结果

TErrDto.java:3:	【TErrDto】不符合UpperCamelCase命名风格
TErrDto.java:5:	常量【max】命名应全部大写并以下划线分隔
TErrDto.java:7:	方法名【QueryUserInfo】不符合lowerCamelCase命名风格

Process finished with exit code 4

从测试结果可以看到，我们写的三个代码规约分别监测出了代码的命名风格、常量大写、方法名不符合驼峰标识。
同时你还可以测试 category/java/codestyle.xml 这个是 PMD 自身提供好的规约监测。

五、扩展了解 Sonar

其实有了 PMD 静态代码检查规约，能做都事情就很多，不是只对正在写的代码进行检查，还可以对不同阶段的代码进行分析和风险提醒，比如：准备提测阶段、已经上线完成，都可以做相应的监测处理。

而 Sonar 就是一个这样都工具，它是一个Web系统，可以展现静态代码扫描的结果，结果是可以自定义的，支持多种语言的原理是它的扩展性。https://www.sonarqube.org/

不遵循代码标准：sonar可以通过PMD,CheckStyle,Findbugs等等代码规则检测工具规范代码编写。
潜在的缺陷：sonar可以通过PMD,CheckStyle,Findbugs等等代码规则检测工具检测出潜在的缺陷。
糟糕的复杂度分布：文件、类、方法等，如果复杂度过高将难以改变，这会使得开发人员难以理解它们, 且如果没有自动化的单元测试，对于程序中的任何组件的改变都将可能导致需要全面的回归测试。
重复：显然程序中包含大量复制粘贴的代码是质量低下的，sonar可以展示源码中重复严重的地方。
注释不足或者过多：没有注释将使代码可读性变差，特别是当不可避免地出现人员变动时，程序的可读性将大幅下降而过多的注释又会使得开发人员将精力过多地花费在阅读注释上，亦违背初衷。
缺乏单元测试：sonar可以很方便地统计并展示单元测试覆盖率。
糟糕的设计：通过sonar可以找出循环，展示包与包、类与类之间的相互依赖关系，可以检测自定义的架构规则通过sonar可以管理第三方的jar包，可以利用LCOM4检测单个任务规则的应用情况，检测耦合。
提高代码质量：了解自己在编码过程中犯过的错误，让自己的代码更具有可读性和维护性。

六、总结

PMD 是一款采用 BSD 协议的代码检查工具，你可以扩展实现为自己的标准和规范以及完善个性的提醒和修复操作。
另外基于 IDEA 插件实现的代码检查或者有审计要求的处理，也可以基于 IDEA 插件做更多的扩展，比如提醒修复、提供修复操作、自身业务逻辑的检查。例如momo开源库下的一款IDEA静态代码安全审计及漏洞一键修复插件 https://github.com/momosecurity/momo-code-sec-inspector-java
这里补充一点，kotlin 语言可以在 IDEA 中转换为 Java 语言，这样你在阅读类似这样的代码时候，如果不好看懂也可以转换一下在阅读。此外 IDEA 插件开发需要基于 Gradle 或者本身提供都模版进行创建，如果感兴趣也可以阅读我写的 IDEA 插件开发文章。

七、系列推荐

还重构？就你那代码只能铲了重写！

Wed, 15 Sep 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/4xzd6mC2wKhXldrX50uk2w

一、前言

我们不一样，就你没对象！ 对，你是面向过程编程的！

我说的，绝大多数码农没日没夜被需求憋着肝出来的代码，无论有多么的吭哧瘪肚，都不可能有重构，只有重新写。为什么？因为重新写所花的时间成本，远比重构一份已经烂成团的代码，要节省时间。但谁又不敢保证重写完的代码，就比之前能好多少，况且还要承担着重写后的代码事故风险和几乎体现不出来的业务价值！

虽然代码是给机器运行的，但同样也是给人看的，并且随着每次需求的迭代、变更、升级，都需要研发人员对同一份代码进行多次开发和上线，那么这里就会涉及到可维护、易扩展、好交接的特点。

而那些不合理分层实现代码逻辑、不写代码注释、不按规范提交、不做格式化、命名随意甚至把 queryBatch 写成 queryBitch 的，都会造成后续代码没法重构的问题。那么接下来我们就分别介绍下，开发好能重构的代码，都要怎么干！

二、代码优化

1. 约定规范

# 提交：主要 type
feat:     增加新功能
fix:      修复bug

# 提交：特殊 type
docs:     只改动了文档相关的内容
style:    不影响代码含义的改动，例如去掉空格、改变缩进、增删分号
build:    构造工具的或者外部依赖的改动，例如webpack，npm
refactor: 代码重构时使用
revert:   执行git revert打印的message

# 提交：暂不使用type
test:     添加测试或者修改现有测试
perf:     提高性能的改动
ci:       与CI（持续集成服务）有关的改动
chore:    不修改src或者test的其余修改，例如构建过程或辅助工具的变动

# 注释：类注释配置
/**
* @description: 
* @author: ${USER}
* @date: ${DATE}
*/

分支：开发前提前约定好拉分支的规范，比如日期_用户_用途，210905_xfg_updateRuleLogic
提交：作者，type: desc 如：小傅哥，fix：更新规则逻辑问题 参考Commit message 规范
注释：包括类注释、方法注释、属性注释，在 IDEA 中可以设置类注释的头信息 Editor -> File and Code Templates -> File Header 推荐下载安装 IDEA P3C 插件 Alibaba Java Coding Guidelines，统一标准化编码方式。

2. 接口标准

在编写 RPC 接口的时候，返回的结果中一定要包含明确的Code码和Info描述，否则使用方很难知道这个接口是否调用成功还是异常，以及是什么情况的异常。

定义 Result

public class Result implements java.io.Serializable {

    private static final long serialVersionUID = 752386055478765987L;

    /** 返回结果码 */
    private String code;

    /** 返回结果信息 */
    private String info;

    public Result() {
    }

    public Result(String code, String info) {
        this.code = code;
        this.info = info;
    }

    public static Result buildSuccessResult() {
        Result result = new Result();
        result.setCode(Constants.ResponseCode.SUCCESS.getCode());
        result.setInfo(Constants.ResponseCode.SUCCESS.getInfo());
        return result;
    }
    
    // ...get/set
}

返回结果包装：继承

public class RuleResult extends Result {

    private String ruleId;
    private String ruleDesc;

    public RuleResult(String code, String info) {
        super(code, info);
    }
	
	// ...get/set
}

// 使用
public RuleResult execRule(DecisionMatter request) {
    return new RuleResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo());
}

返回结果包装：泛型

public class ResultData<T> implements Serializable {

    private Result result;
    private T data;

    public ResultData(Result result, T data) {
        this.result = result;
        this.data = data;
    }   
	
	// ...get/set
}  

// 使用
public ResultData<Rule> execRule(DecisionMatter request) {
    return new ResultData<Rule>(Result.buildSuccessResult(), new Rule());
}

两种接口返回结果的包装定义，都可以规范返回结果。在这样的方式包装后，使用方就可以用统一的方式来判断Code码并做出相应的处理。

3. 库表设计

三范式：是数据库的规范化的内容，所谓的数据库三范式通俗的讲就是设计数据库表所应该遵守的一套规范，如果不遵守就会造成设计的数据库不规范，出现数据库字段冗余，数据的查询，插入等操作等问题。

数据库不仅仅只有三范式（1NF/2NF/3NF），还有BCNF、4NF、5NF…，不过在实际的数据库设计时，遵守前三个范式就足够了。再向下就会造成设计的数据库产生过多不必要的约束。

0NF

第零范式是指没有使用任何范式，数据存放冗余大量表字段，而且这样的表结构非常难以维护。

1NF

第一范式是在第零范式冗余字段上的改进，把重复字段抽离出来，设计成一个冗余数据较少便于存储和读取的表结构。
同时在第一范式中也指出，表中的所有字段都应该是原子的、不可再分割的，例如：你不能把公司雇员表的部门名称和职责存放到一个字段。需要确保每列保持原子性

2NF

满足1NF后，要求表中的列，都必须依赖主键，确保每个列都和主键列之间联系，而不能间接联系，也就是一个表只能描述一件事情。需要确保表中的每列都和主键相关。

3NF

不能存在依赖关系，学号、姓名，到院系，院系到宿舍，需要确保每列都和主键列直接相关,而不是间接相关。

反三范式

三大范式是设计数据库表结构的规则约束，但是在实际开发中允许局部变通：

有时候为了便于查询，会在如订单表冗余上当时用户的快照信息，比如用户下单时候的一些设置信息。
单列列表数据汇总到总表中一个数量值，便于查询的时候可以避免列表汇总操作。
可以在设计表的时候冗余一些字段，避免因业务发展情况多变，考虑不周导致该表繁琐的问题。

4. 算法逻辑

通常在我们实际的业务功能逻辑开发中，为了能满足一些高并发的场景，是不可能对数据库表上锁扣减库存、也不能直接for循环大量轮训操作的，通常需要考虑🤔在这样场景怎么去中心化以及降低时间复杂度。

秒杀：去中心化

背景：这个一个商品活动秒杀的实现方案，最开始的设计是基于一个活动号ID进行锁定，秒杀时锁定这个ID，用户购买完后就进行释放。但在大量用户抢购时，出现了秒杀分布式独占锁后的业务逻辑处理中发生异常，释放锁失败。导致所有的用户都不能再拿到锁，也就造成了有商品但不能下单的问题。
优化：优化独占竞态为分段静态，将活动ID+库存编号作为动态锁标识。当前秒杀的用户如果发生锁失败那么后面的用户可以继续秒杀不受影响。而失败的锁会有worker进行补偿恢复，那么最终会避免超卖以及不能售卖。

算法：反面教材

@Test
public void test_idx_hashMap() {
    Map<String, String> map = new HashMap<>(64);
    map.put("alderney", "未实现服务");
    map.put("luminance", "未实现服务");
    map.put("chorology", "未实现服务");
    map.put("carline", "未实现服务");
    map.put("fluorosis", "未实现服务");
    map.put("angora", "未实现服务");
    map.put("insititious", "未实现服务");
    map.put("insincere", "已实现服务");
    
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        map.get("insincere");
    }
    System.out.println("耗时(initialCapacity)：" + (System.currentTimeMillis() - startTime));
}

背景：HashMap 数据获取时间复杂度在 O(1) -> O(logn) -> O(n)，但经过特殊操作，可以把这个时间复杂度，拉到O(n)
操作：这是一个定义HashMap存放业务实现key，通过key调用服务的功能。但这里的key，只有insincere有用，其他的都是未实现服务。那你看到有啥问题了吗？
- 这点代码乍一看没什么问题，看明白了就是代码里下砒霜！它的目的就一个，要让所有的key成一个链表放到HashMap中，而且把有用的key放到链表的最后，增加get时的耗时！
- 首先，new HashMap<>(64);为啥默认初始化64个长度？因为默认长度是8，插入元素时，当链表长度为8时候会进行扩容和链表树化判断，此时就会把原有的key散列了，不能让所有key构成一个时间复杂度较高的链表。
- 其次，所有的 key 都是刻意选出来的，因为他们在 HashMap 计算下标时，下标值都为0，idx = (size - 1) & (key.hashCode() ^ (key.hashCode() >>> 16))，这样就能让所有 key 都散列到同一个位置进行碰撞。而且单词 insincere 的意思是；不诚恳的、不真诚的！
- 最后，前7个key其实都是废 key，不起任何作用，只有最后一个 key 有服务。那么这样就可以在HashMap中建出来很多这样耗时的碰撞链表，当然要满足0.75的负载因子，不要让HashMap扩容。

其实很多算法包括：散列、倒排、负载等，都是可以用到很多实际的业务场景中的，包括：人群过滤、抽奖逻辑、数据路由等等方面，这些功能的使用可以降低时间复杂度，提升系统的性能，降低接口响应时常。

5. 职责分离

为了可以让程序的逻辑实现更具有扩展性，通常我们都需要使用设计模式来处理各个场景的代码实现结构。而设计模式的使用在代码开发中的体现也主要为接口的定义、抽象类的包装和继承类的实现。通过这样的方式来隔离各个功能领域的开发，以此保障每次需求扩展时可以更加灵活的添加，而不至于让代码因需求迭代而变得更加混乱。

案例

public interface IRuleExec {

    void doRuleExec(String req);

}

public class RuleConfig {

    protected Map<String, String> configGroup = new ConcurrentHashMap<>();

    static {
        // ...
    }

}

public class RuleDataSupport extends RuleConfig{

    protected String queryRuleConfig(String ruleId){
        return "xxx";
    }

}

public abstract class AbstractRuleBase extends RuleDataSupport implements IRuleExec{

    @Override
    public void doRuleExec(String req) {
        // 1. 查询配置
        String ruleConfig = super.queryRuleConfig("10001");

        // 2. 校验信息
        checkRuleConfig(ruleConfig);

        // 3. 执行规则｛含业务逻辑，交给业务自己处理｝
        this.doLogic(configGroup.get(ruleConfig));
    }

    /**
     * 执行规则｛含业务逻辑，交给业务自己处理｝
     */
    protected abstract void doLogic(String req);

    private void checkRuleConfig(String ruleConfig) {
        // ... 校验配置
    }

}

public class RuleExec extends AbstractRuleBase {

    @Override
    protected void doLogic(String req) {
        // 封装自身业务逻辑
    }

}

类图

这是一种模版模式结构的定义，使用到了接口实现、抽象类继承，同时可以看到在 AbstractRuleBase 抽象类中，是负责完成整个逻辑调用的定义，并且这个抽象类把一些通用的配置和数据使用单独隔离出去，而公用的简单方法放到自身实现，最后是关于抽象方法的定义和调用，而业务类 RuleExec 就可以按需实现自己的逻辑功能了。

6. 逻辑缜密

你的代码出过线上事故吗？为什么出的事故，是树上有十只鸟开一枪还剩几只的问题吗？比如：枪是无声的吗、鸟聋吗、有怀孕的吗、有绑在树上的鸟吗、边上的树还有鸟吗、鸟害怕枪声吗、有残疾的鸟吗、打鸟的人眼睛花不花，… …

实际上你的线上事故基本回围绕在：数据库连接和慢查询、服务器负载和宕机、异常逻辑兜底、接口幂等性、数据防重性、MQ消费速度、RPC响应时常、工具类使用错误等等。

下面举个例子：用户积分多支付，造成批量客诉。

背景：这个产品功能的背景可能很大一部分研发都参与开发过，简单说就是满足用户使用积分抽奖的一个需求。上图左侧就是研发最开始设计的流程，通过RPC接口扣减用户积分，扣减成功后进行抽奖。但由于当天RPC服务不稳定，造成RPC实际调用成功，但返回超时失败。而调用RPC接口的uuid是每次自动生成的，不具备调用幂等性。所以造成了用户积分多支付现象。
处理：事故后修改抽奖流程，先生成待抽奖的抽奖单，由抽奖单ID调用RPC接口，保证接口幂等性。在RPC接口失败时由定时任务补偿的方式执行抽奖。流程整改后发现，补偿任务每周发生1~3次，那么也就是证明了RPC接口确实有可用率问题，同时也说明很久之前就有流程问题，但由于用户客诉较少，所以没有反馈。

7. 领域聚合

不够抽象、不能写死、不好扩展，是不是总是你的代码，每次都像一锤子买卖，完全是写死的、绑定的，根本没有一点缝隙让新的需求扩展进去。

为什么呢，因为很多研发写出来的代码都不具有领域聚合的特点，当然这并不一定非得是在DDD的结构下，哪怕是在MVC的分层里，也一样可以写出很多好的聚合逻辑，把功能实现和业务的调用分离开。

依靠领域驱动设计的设计思想，通过事件风暴建立领域模型，合理划分领域逻辑和物理边界，建立领域对象及服务矩阵和服务架构图，定义符合DDD分层架构思想的代码结构模型，保证业务模型与代码模型的一致性。通过上述设计思想、方法和过程，指导团队按照DDD设计思想完成微服务设计和开发。
- 拒绝泥球小单体、拒绝污染功能与服务、拒绝一加功能排期一个月
- 架构出高可用极易符合互联网高速迭代的应用服务
- 物料化、组装化、可编排的服务，提高人效

8. 服务分层

如果你想让你的系统工程代码可以支撑绝对多数的业务需求，并且能沉淀下来可以服用的功能，那么基本你就需要在做代码开发实现的时候，抽离出技术组件、功能领域和业务逻辑这样几个分层，不要把频繁变化的业务逻辑写入到各个功能领域中，应该让功能领域更具有独立性，可以被业务层串联、编排、组合实现不同业务需求。这样你的功能领域才能被逐步沉淀下来，也更易于每次需求都扩展。

这是一个简化的分层逻辑结构，有聚合的领域、SDK组件、中间件和代码编排，并提供一些通用共性凝练出的服务治理功能。通过这样的分层和各个层级的实现方式，就可以更加灵活的承接需求了。

9. 并发优化

在分布式场景开发系统，要尽可能运用上分布式的能力，从程序设计上尽可能的去避免一些集中的、分布式事物的、数据库加锁的，因为这些方式的使用都可能在某些极端情况下，造成系统的负载的超标，从而引发事故。

所以通常情况下更需要做去集中化处理，使用MQ消除峰，降低耦合，让数据可以最终一致性，也更要考虑在 Redis 下的使用，减少对数据库的大量锁处理。
合理的运用MQ、RPC、分布式任务、Redis、分库分表以及分布式事务只有这样的操作你才可能让自己的程序代码可以支撑起更大的业务体量。

10. 源码能力

你有了解过 HashMap 的拉链寻址数据结构吗、知道哈希散列和扰动函数吗、懂得怎么结合Spring动态切换数据源吗、AOP 是怎么实现以及使用的、MyBatis 是怎么和 Spring 结合交管Bean对象的，等等。看似都是些面试的八股文，但在实际的开发中其实是可以解决很多问题的。

@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 哈希桶数组 + 链表 + 红黑树的数据结构，通过扰动函数 (size - 1) & (key.hashCode() ^ (key.hashCode() >>> 16)); 解决数据碰撞严重的问题。
但其实这样的散列算法、寻址方式都可以运用到数据库路由的设计实现中，还有整个数组+链表的方式其实库+表的方式也有类似之处。
数据库路由简化的核心逻辑实现代码如上，首先我们提取了库表乘积的数量，把它当成 HashMap 一样的长度进行使用。
当 idx 计算完总长度上的一个索引位置后，还需要把这个位置折算到库表中，看看总体长度的索引因为落到哪个库哪个表。
最后是把这个计算的索引信息存放到 ThreadLocal 中，用于传递在方法调用过程中可以提取到索引信息。

三、总结

讲道理，你几乎不太可能把一堆已经烂的不行的代码，通过重构的方式把他处理干净。细了说，你要改变代码结构分层、属性对象整合、调用逻辑封装，但任何一步的操作都可能会对原有的接口定义和调用造成风险影响，而且外部现有调用你的接口还需要随着你的改动而升级，可能你会想着在包装一层，但这一层包装仍需要较大的时间成本和几乎没有价值的适配。
所以我们在实际开发中，如果能让这些代码具有重构的可能，几乎就是要实时重构，每当你在添加新的功能、新的逻辑、修复异常时，就要考虑是否可以通过代码结构、实现方式、设计模式等手段的使用，改变不合理的功能实现。每一次，一点的优化和改变，也不会有那么难。
当你在接需求的时候，认真思考承接这样的业务诉求，都需要建设怎样的数据结构、算法逻辑、设计模式、领域聚合、服务编排、系统架构等，才能更合理的搭建出良好的具有易维护、可扩展的系统服务。如果你对这些还没有什么感觉，可以阅读设计模式和手写Spring，这些内容可以帮助你提升不少的编程逻辑设计。

四、系列推荐

Hey there! 👋 2021版，开发者学习路线图分享！

Thu, 09 Sep 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/HyMzm9omIoIGz_bdKmL5Xg

一、介绍

Hey there! 👋 Roadmap to becoming a web developer in 2021

前端、后端、运维，如果你不清楚自己要从哪开始，下个阶段要学什么，到哪里算是结束，可以参考下 Kamran Ahmed 整理的 Web 开发者 2021 版最新的学习路线图。

以后端学习举例，这里包括你从接触互联网的基础内容开始，了解一部分如HTML、CSS的前端语言，之后学习操作系统的相关知识，并逐步转为后端语言学习，这包括你开始选择Java、C#、Go等，当一门基础语言掌握了以后，也就要逐步的开始提交你的代码，无论是工作需求还是个人积累代码，都会用到代码开发版本控制器的使用，以及你会发现GitHub这个神奇的网站。当你有了语言的编程能力，那么就要开始接触一系列用于存储数据库的技能学习，包括：关系型数据库和 NoSql 数据库已经缓存的应用，甚至可能你还会深入的研究如 Mysql 的内核和原理。接下来你的代码会经过测试、调试、验证、持续继承上线，以及验证它们是否安全可靠。此外你会慢慢的接触到真正的有价值的代码要在设计模式和系统架构的框架下进行开发，以及学习这西相关技巧，并且再也不只是单一的应用开发，还会用到分布式架构的相关技术，如：MQ、RPC、分布式任务、分库分表组件等，之后是对于这样大量应用的部署，可以运用容器化的能力，简化部署和提升弹性。可能一部分有特殊需求的研发还会涉及到学习图形数据库，WebSocket 等各项能力，在这个过程中也会涉及到一些运维知识，来侧面提升你的代码研发能力。

当然这还不是结束，甚至可能永远没有结束！

官网：https://roadmap.sh/
源码：https://github.com/kamranahmedse/developer-roadmap
资料：学习路线高清图和对应的学习资料已经放入网盘，可以关注公众号：bugstack虫洞栈 回复：网盘学习资料 获取

二、学习路线

1. 前端

2. 后端

3. 运维

三、学习资料

1. 技术内容

如果你对以上的学习路线有了较清楚的认识，但可能自己不好容易找到这些资料，那么可以参考我整理好的学习内容，包括对初学编程，大一、大二、大三、大四以及毕业了工作了几年后，都应该找什么样的资料学习的一个汇总。按照不同阶段的学习范围把资料分到不同的文件夹去，方便所处不同阶段的读者可以有一个相对准确的学习范围。

资料明细：大学四年到毕业工作5年的学习路线资源汇总
网盘链接：https://pan.baidu.com/s/4mmX7sDy - 资料较大，链接如果失效可以在公众号：bugstack虫洞栈回复：网盘学习资料

2. 实战内容

如果你已经跨过了初级阶段，需要做一些实践型的项目，可以关注下我的Github，如下：

内容：本代码库是作者小傅哥多年从事一线互联网Java开发的学习历程技术汇总，旨在为大家提供一个清晰详细的学习教程，侧重点更倾向编写Java核心内容。这部分资料也是我所写博客中实践项目的源码，在这里你可以学到Netty、字节码编程、设计模式、领域驱动设计、规则引擎、面试、架构以及职场经历的分享。
地址：https://github.com/fuzhengwei/CodeGuide/wiki

四、总结

其实我们都是在经历着这样的一个学习阶段，时不时的就会到达某个不好突破的瓶颈期，就像：

刚到公司理解不了项目插不进去手。
能写一些代码逻辑了，但总感觉写的不好。
设计模式慢慢用上了，但好像对整体架构又不太清楚。
能游刃有余的接项目了，又感觉自己好像就是一个CRUD工具人，没有技术深度。
想着要去扒开各种技术组件的源码看一看，但好像又有些看不懂，单个代码都懂，放一块不知道啥意思了。
撸了一些源码后，又没多久就忘记了，很难把这些技术内容结合到一块去。
开始尝试着做技术迁移，把在源码里学到的数据结构、算法逻辑，开始逐步用到自己的业务项目中了，感觉实现起来的逻辑有些深度了。但好像没有技术高度和全面的整合能力。
开始做整体的架构设计，把代码逻辑转换成图和文字，总感觉不知道从哪下手描述，描述出来的东西，讲完了听众都没有啥反应。
技术调研、经验积累、编写文章、提升影响力，一点点慢慢的平心静气的沉淀自己，是你接下来要完成的事情。
路还很长，要铺宽度，也要挖深度，要懂得沟通，也要协调人员，不只是研发视角，还要有业务思维、产品逻辑、运营能力。

所以，我们要不断的去铺设自己的技术栈，做有成体系和有深度的学习，并把这西学到的能力运用在项目开发中，也要记录笔记整理资料，慢慢的才会形成自己一套完整的抗打的技术广度和深度。

五、系列推荐

靠写文章，我在CSDN赚了1.27万！

Sun, 05 Sep 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/PIzReLEPzY-f2pqr2k5RPQ

一、嘿，赚了钱嘞

💥CSDN 5.1K下载量，可提现收入1.2W！

写了两年博客，用了两年的4个服务器，终于能回点本了，一年前还得靠薅羊毛填补服务器成本。讲道理真难，能坚持下来真难！晒个图，看看傅哥是怎么用 2.94、2.94、2.94 的赚到1万多块的。

1.3W 多不多？其实可能真的不多，这1.3W 的收入用了将近9个月，写了40万字和绘制了上百张PPT图稿，最后整理出 3 本在售的 PDF 资料。

一直以来我都希望在技术的方向上做有价值的内容，即使是用这样辛苦编写整理出来的资料赚点收入，也更希望是知识内容远大于付费成本。其实想到这些有时候感觉各类技术推文广告可以更实在的方式宣传，通过介绍课程的核心内容、适合人群、学到什么，也能很好的帮助一些编程路上持续学习成长的码农。但可能目前恰恰相反，广告的标题太吓人了，甚至有种只要学了这个课就能干翻这个码农世界升P7当架构的感觉，但学完了却被有些培训机构干的服服帖帖的。

写付费专栏可以、出PDF资料也行、弄知识星球也好，不太可能任何一个技术号主或者培训平台都用爱发电，因为我们从这些平台学到的知识也是用在工作、跳槽、晋升答辩上，来提升自己的福利待遇。只要做的知识不忽悠人、内容干净、确认学习内容有帮助，那么就这样的铺路人和走路人，都能一起走的长远。

恶意广告就像铺的烂路、白皮袄和窃权就像挖坑的，两者加一块，早早晚晚会掉坑里！

二、哎，挺不容易

做公众号，我可能选择最难的模式！

不转载、不接投稿、不发广告，2年多我似乎是拒绝了流量也拒绝了收入，那为什么呢？因为我想专心铺我的技术栈内容广度和深度，成体系的建设知识内容完善度，一者补全自己的漏洞提升写作能力、二者帮助也在这条路上奔走的技术同好共同成长。

而转载和投稿的技术文章，并不是我亲自写的内容，当有粉丝向我咨询文章中的学习内容时，我会很难解释这个内容不是我写的，我不清楚这样的话。总感觉这样是有那么一点点心里上的不舒服，也有那么一些不负责的感觉，再有就是这类文章可能已经铺天盖地的火热了，我就没必要再做同质化内容的凑热闹了。

在做技术公众号的这条路上，我选择的是长期原创文章和深耕内容，从几乎没有几个人的阅读量时保持初心的做到现在，也是希望可以把 沉淀、分享、成长，让自己和他人都能有所收获 坚持下来。

三、呐，画个路线

像我一样，有章法的学习起来！

现在我的技术栈内容已经慢慢铺设的挺完整了，有基础的核心内容、有提升的拓展文章、有实战的锻炼项目，其实这些也是我从初学编程阶段走来的学习方式，虽然，这样的是慢了些，但基础夯实的厚度够了以后再学其他的就不那么容易拉跨了🌶。

学习路线

在学会写代码到能把代码写好，是一个较有长度的时间过长，这个过程中需要把基础夯实，可能很大一部分研发伙伴不知道夯实的是什么，其实不单单把 Java 的 API 用熟练，而是能把 Java 中的一些核心源码设计学会，包括像HashMap、ArrayList、AQS、并发锁等所涉及到的数据结构和算法逻辑弄清楚，才是真正的夯实基础。

在夯实基础完成后接下来就不只是单单的用代码实现所需要完成的业务逻辑了，还要考虑到怎么能做到易维护、可扩展，这个时候你就需要了解设计模式了，在经过设计模式的学习以及到项目中的实战后，会开始陆续的考虑代码的功能实现，而不是大量的堆砌ifelse来完成需求开发。

如果能对设计模式有一定的了解后，后面就可以尝试学习下 Spring、Mybatis 这样的框架源码了，尤其是 Spring 它的结构设计和代码实现用了大量的设计模式，也对接口、抽象类、继承、封装有丰富的使用场景，当你学习完成这部分内容后就会对 Spring 把 Bean 对象解耦到可以扩展各类节点插入逻辑的设计，感觉到异常强大。其实所有的设计模式体现也就是对逻辑职责的分拆，让各个类包装处理各个业务内容，不至于被一个堆业务把一个类填充到炸裂。

当你有上面👆这些基础以后，但又没有一个可以让你操刀的项目时，那么就可以参与到 Lottery 抽奖系统 - DDD 实践 的项目中了，在此项目中你会学习到互联网公司关于C端项目开发时候用到的一些，技术、架构、规范等内容。由于项目为实战类编程项目，在学习的过程中需要上手操作，小傅哥会把系统的搭建拉不同的分支列为每一个章节进行设计和实现并记录到开发日记中，读者在学习的过程中可以结合这部分内容边看文章边写代码实践。技术：SpringBoot、Mybatis、Dubbo、MQ、Redis、Mysql、ELK、分库分表、Otter 架构：DDD 领域驱动设计、充血模型、设计模式 规范：分支提交规范、代码编写规范

资料介绍

小傅哥的《Java 面经手册》 ⭐⭐⭐⭐ 3.8k+ 下载量

小傅哥的《重学 Java 设计模式》 ⭐⭐⭐⭐

小傅哥的《手撸 Spring》 ⭐⭐⭐⭐⭐

Lottery 抽奖系统 - 基于领域驱动设计的四层架构实践 ⭐⭐⭐⭐

四、呀，不止码农

发现没，傅哥并不只是一个码农！

其实我们大部分码农在公司都只是像一个零件或者工具，不了解业务、不懂得产品、不知晓运营，也就是在开发、测试、上线这一环上有所储备。所以其实我们也很多时候都在站在自己的视角去说业务、喷产品、叼运营，但如果这些事放在自己干，会是什么样呢？

不知道从什么时候开始，我挺希望把自己的想法落地，有时候喜欢去讨论下产品、有时候喜欢去问问运营手段、甚至还对UI的设计感了兴趣。因为这些职责完完整整的加到一块，才是一个全面的 “产品”。

而有些时候我听到的这不能赋能业务、那不能帮助产品，虽然这些可能是大战略，但对于个人的学习成长来说，8小时以外是不能被OKR限制的，总得要落地些什么自己想做的。才有机会更全面的看懂这个 “产品” 的全貌。

学习运营

运营的过程是从流程、产品、用户、需求到心智的过程，也就是不断的筛选出目标用户。而我的目标用户就是那些可以一起学习成长的技术同好。
所以我目前在走的路线也是以这个过程在执行的，不只是关注最初的吸引流量，还包括完成开发产品，解决需求和培养心智的过程。像付费很低的技术价值较高的PDF资料，其实更属于一种流量产品。就像宝马1系一样，其实卖一辆就赔一辆，但它确实建设整个流量链条的通道。
当然，我还是不是运营大佬，至少算不上一个自媒体人，对流量的玩法的还比较青涩。也只能希望在坚持我的初心干净的技术人路上，不断的成长起来。别总是在自己小圈子里晃悠，抬抬眼看看整个全貌。

五、来，送点奖品

1. 礼品说明

一等奖[1名]：小霸王红白机
二等奖[9名]：game poke 怀旧款掌上小型游戏机，挺卡哇伊的

2. 得奖规则

对公众号此文章：https://mp.weixin.qq.com/s/PIzReLEPzY-f2pqr2k5RPQ 进行留言并转发朋友圈，找伙伴给你的留言点赞
以个人留言被读者点赞数量为排名，最高的前10名依次获得对应奖品，最低点赞数量 >= 10
仅有100个留言名额，超过数量不能被精选，参与活动

3. 活动说明

时间范围：2021-09-06 07:55:00 - 2020-09-08 07:59:59，共计2天计票
公布时间：2021-09-10，星期五
公布方式：小傅哥的朋友圈公布，记得添加小傅哥微信：fustack
领奖方式：看到小傅哥朋友圈后，主动联系小傅哥。提供；收获人、收获地址、手机号等必要信息。😄嘿…嘿，我会保密的你的信息！

六、好，总结一下

做公众号写文章，一路走来学到了很多，懂得了很多，也锻炼了不少。有几条很重要的建议可能对你也有帮助：

有自己的思考，不要人云亦云
坚持做好自己的事情，哪怕是慢一点
不违背自己的初心，也不要被诱惑
把时间放在可以积累长期价值的事上
生活和职业上都提早规划好自己的路，别被牵着走
有自己的个性，不要被既得利益者忽悠成螺丝钉
坚持阅读和写作输出，积累个人的影响力
坚持跑步锻炼身体，哪怕不是为了减肥
有些时候可能不是你做的不优秀，只是入场时间不对，可以换个场地
与同好同行，共同进步

加油：让我们既有底气、又有勇气，的往前冲！

七、呐，系列推荐！

技术调研，IDEA 插件怎么开发「脚手架、低代码可视化编排、接口生成测试」？

Fri, 27 Aug 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/ckbu4ej4P2fEA8D_5cNUpw

一、前言

不踩些坑，根本不是成熟的码农！

你觉得肯德基全家桶是什么？一家人一起吃的桶吗，就那么一点点？不是，肯德基全家桶说的是，鸡的全家桶！

听到这个故事就像有时候我因为需要解决某些问题去搜索、折腾、验证、排除的技术方案，因为方向不对，所以努力也就白费。只能一次次在众多的资料、文档、源码中一点点找到并组合出适合自己的问题场景的技术处理手段。

但这个过程有时候又是必须经历的，很少有时候能一次就找到正确的答案或者人，哪怕开始就找到了，也会再去排查下其他的资料，看看还有没有更好的。是不，这就是你吧？

二、抛出问题

我又要冲IDEA插件开发了！

在研究字节码插桩的相关技术后，🤔考虑着除了通常的用在代码上线后的非入侵式监控外，是不是也可以用于研发在开发阶段对系统接口的提取呢？

带着这个从脑袋中冒出的想法，想到如果要处理这个事情，最核心的问题就是开发一款IDEA插件+字节码插桩能力，在代码运行时对运行方法增强，提取相关的必要信息。别说案例还真做出来了，如下：

案例地址：基于IDEA插件开发和字节码插桩技术，实现研发交付质量自动分析
后续问题：其实实现到这里还只能算是一个案例，对于 IDEA 插件开发能力并没有完全弄透，比如这个 IDEA 插件需要做一些基础配置，那么在哪里打开呢？还有实时监控并产生的接口信息能在 IDEA 界面右侧展示出来或者支持导出吗？如果我再有一些集合 IDEA 插件开发的能力做的其他的功能引入咋办呢？这里用到了哪些技术呢？等等，这些问题都需要去一一解决掉，才能完完整整的开发一个可用的 IDEA 插件，为此，需要做更深入的资料整理和实践验证。

三、开发插件涉及的问题

问题汇总：开发一个 IDEA 插件基本要涉及到的问题过程如下：

开发方式：在官网的描述中，创建IDEA插件工程的方式有两种分别是，IntelliJ Platform Plugin 模版创建和 Gradle 构建方式。
框架入口：一个 IDEA 插件开发完，要考虑把它嵌入到哪，比如是从 IDEA 窗体的 Edit、Tools 等进入配置还是把窗体嵌入到左、右工具条还是IDEA窗体下的对话框。
UI：思考的是窗体需要用到什么语言开发，没错，用的就是 Swing、Awt 的技术能力。
API：在 IDEA 插件开发中，一般都是围绕工程进行的，那么基本要从通过 IDEA 插件 JDK 开发能力中获取到工程信息、类信息、文件信息等。
外部功能：这一个是用于把插件能力与外部系统结合，比如你是需要把拿到的接口上传到服务器，还是从远程下载文件等等。

四、开发插件的两种配置

官方文档：https://plugins.jetbrains.com/docs/intellij/disposers.html
官方案例：https://github.com/JetBrains/intellij-sdk-docs

1. 基础配置

IntelliJ IDEA 2019.3.1 x64
JDK 需要配置 IntelliJ Platform Plugin JDK，在 Project Setting 中设置，这样才可以正常开发 IDEA 插件
id ‘org.jetbrains.intellij’ version ‘0.6.3’
gradle-5.2.1 与 2019 IDEA 版本下的插件开发匹配
Settings -> Build, Execution,Deloyment -> Build Tools，配置 Gradle。Gradle user home = D:/Program Files (x86)/gradle/gradle-5.2.1/.gradle User Gradle from =gradle-wrapper.properties 或者 Specified location 具体如下图：

如果你是使用 IDEA New Project 默认的 IntelliJ Platform Plugin 方式，其实只关注1、2两步骤就可以了，但如果你需要 Gradle，那么需要注意3、4、5步骤的设置。当然通常也更推荐使用 Gradle 来搭建工程，这样你在需要一些额外的 Jar 包时候，只需要在 Gradle build.gradle 配置即可，而不是把需要的 Jar 包复制到工程的 lib 下。

2. 遇到问题

在使用 Gradle 构建项目后，你会遇到几个问题；

提前下载好 Gradle 5.2.1 版本并配置上，否则构建工程自动下载会比较慢 https://gradle.org/next-steps/?version=5.2.1&format=all
构建工程时候拉取相关内容，会比较慢，如果你有代理会好一些。
【麻烦的问题】基于 Gradle 的 IDEA 插件开发会在构建过程中，会下载一个匹配版本的 IDEA 软件用于启动测试开发插件，几百兆那种zip包 ideaIC-2019.3.1.zip。这个时候基本你会遇到一个崩溃的报错 ` Could not resolve all files for configuration ‘:detachedConfiguration1’. 咋办呢，如果你不嫌弃麻烦可以手动下载并SHA1加密后把下载的文件放到缓存文件夹中 .gradle\caches\modules-2\files-2.1` 具体操作如下：
- 打开系统盘下当前用户的.gradle目录，进入.gradle\caches\modules-2\files-2.1目录，即为缓存文件的目录。这个目录是你的报错构建过程中的报错地址，Could not get resource D:\Program Files (x86)\gradle\gradle-5.2.1\.gradle\caches\modules-2\files-2.1\com.jetbrains.intellij.idea\ideaIC\2019.3.1
- 加密文件夹2dae8e50d4b0508cad2e680b53414f657954f390目录名称(你的可能不是这样的)，我去，这个应该是加密过的，但是是什么加密呢？,经过了解知道了这个是SHA1加密，且是对文件进行SHA1的加密生成的唯一字符串，但是windows上没有这个命令，在线SHA1也太麻烦了，还要上传文件，于是想到了Java的API，还有就是通过git hash命令行来实现。把我们的文件ideaIC-2019.3.1.zip先临时拷贝到这个目录。运行sha1sum.exe ideaIC-2019.3.1.zip命令，生成唯一的唯一字符串（用来校验文件的完整性），这样就拿到这个2dae8e50d4b0508cad2e680b53414f657954f390目录名
- 接下来在2019.3.1目录下，新建目录2dae8e50d4b0508cad2e680b53414f657954f390，将ideaIC-2019.3.1.zip移动进去即可。
【堆栈溢出】在 Gradle 构建的过程中，消耗内存较大，可能会报错 Java heap space 所以也可以在IDEA项目根目录下，新建文件gradle.properties，添加如下内容，变更gradle Jvm参数 org.gradle.jvmargs=-Xmx2024m -XX:MaxPermSize=512m 别说还挺好用，竟然构建成功了。

五、写个测试案例

1. 工程结构

PluginGuide
├── .gradle
└── src
    ├── main
    │   └── java
    │       ├── HiClazz.java
    │       ├── MyDumbAwareAction.java
    │       ├── MySearchableConfigurable.java
    │       ├── MyToolWindowFactory.java    
    │       └── TestUI.java    
    └── resources
        ├── icons  
        └── META-INF
            └── plugin.xml 

HiClazz 是继承 AnAction 的实现类，用于附着到 IDEA 的窗体上，点击后打开对应页面
MyDumbAwareAction、MyToolWindowFactory，配合使用，用于在 IDEA 最下面的窗体设置，与你看见的控制台输出信息位置一样。
MySearchableConfigurable，可以用于 Settings 中配置窗体。
TestUI 是基于 Swing 开发的窗体，验证在 AnAction 实现类中打开。
plugin.xml 是整个 IDEA 咖啡的配置文件，你所有的窗体都会在这个配置文件里有所体现。

2. AnAction

public class HiClazz extends AnAction {

    @Override
    public void actionPerformed(AnActionEvent e) {
        Project project = e.getData(PlatformDataKeys.PROJECT);
        PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE);
        String classPath = psiFile.getVirtualFile().getPath();
        String title = "Hello World!";
        Messages.showMessageDialog(project, classPath, title, Messages.getInformationIcon());
    }

}

测试在 IDEA 中读取鼠标停留在类文件中的信息。我们可以把这个 AnAction 配置到各个 IDEA 菜单中。

3. MyToolWindowFactory

public class MyToolWindowFactory implements ToolWindowFactory {

    @Override
    public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {

        toolWindow.setToHideOnEmptyContent(true);

        class MyPanel extends SimpleToolWindowPanel {

            public MyPanel(boolean vertical) {
                super(vertical);

                DefaultActionGroup group = new DefaultActionGroup();
                group.add(new MyDumbAwareAction("Login1"));
                group.add(new MyDumbAwareAction("Login2"));
                group.add(new MyDumbAwareAction("Login3"));

                ActionToolbar toolbar = ActionManager.getInstance().createActionToolbar("ToolBar", group, false);
                setToolbar(toolbar.getComponent());
            }

        }

        // 添加一个页
        toolWindow.getContentManager().addContent(ContentFactory.SERVICE.getInstance().createContent(new MyPanel(false), "First", false), 0);

    }

}

在 IDEA 的最下面窗体中，如果想展示自己的窗体，则需要开发对应的 ToolWindowFactory 实现类，这样才可以展示你的内容。
这里的思想基本是 Swing 技术的开发方式，如果你不熟悉 Swing 最这块内容会比较陌生。

4. plugin.xml

<extensions defaultExtensionNs="com.intellij">
    <!-- Add your extensions here -->
    <toolWindow canCloseContents="true" anchor="bottom"
                id="SmartIM"
                factoryClass="MyToolWindowFactory">
    </toolWindow>
    
    <!-- 在Setting中添加自定义配置模版 -->
    <projectConfigurable groupId="Other Settings" displayName="My Config" id="thief.id"
                         instance="MySearchableConfigurable"/>
</extensions>

<actions>
    <!-- Add your actions here -->
    <action id="HiId_FileMenu" class="HiClazz" text="HiName">
        <add-to-group group-id="FileMenu" anchor="first"/>
        <add-to-group group-id="MainMenu" anchor="first"/>
        <add-to-group group-id="EditMenu" anchor="first"/>
        <add-to-group group-id="ViewMenu" anchor="first"/>
        <add-to-group group-id="CodeMenu" anchor="first"/>
        <add-to-group group-id="AnalyzeMenu" anchor="first"/>
        <add-to-group group-id="RefactoringMenu" anchor="first"/>
        <add-to-group group-id="BuildMenu" anchor="first"/>
        <add-to-group group-id="RunMenu" anchor="first"/>
        <add-to-group group-id="ToolsMenu" anchor="first"/>
        <add-to-group group-id="WindowMenu" anchor="first"/>
        <add-to-group group-id="HelpMenu" anchor="first"/>
    </action>
    <action id="HiId_EditorPopupMenu" class="HiClazz" text="HiName">
        <add-to-group group-id="EditorPopupMenu" anchor="first"/>
    </action>
    <action id="HiId_MainToolBar" class="HiClazz" text="HiName">
        <add-to-group group-id="MainToolBar" anchor="first"/>
    </action>
</actions>

在 plugin.xml 的配置中，主要是把各个功能实现窗体配置到对应的菜单下，比如 Tools 下、toolWindow 里等。

5. 测试结果

启动运行

IDEA 插件开发运行会基于 Plugin 或者 Gradle 下配置的 ::runIde

运行界面

在 IDEA 的各个菜单中都可以看到新增加的 HiName 插件，在你实际开发的时候选择需要的内容进行配置即可。

运行效果

当鼠标点到类的上，在点 HiName 就可以看到对应的工程类信息了。

六、插件开发能做啥都

在 GitHub 上搜索 IDEA 插件开发，一共有44页内容，https://github.com/search?p=41&q=idea%E6%8F%92%E4%BB%B6&type=Repositories 涉及到自动化测试、工程脚手架、API生成、生成数据库的DAO类、一些常用工具，当然还有一些比较有意思的，比如：摸鱼看书、听郭德纲相声、微信聊天、局域网聊天、英语翻译等等。这里我给大家列举几个，开阔开阔思路。

1. 快速生成 CRUD 工程代码

地址：https://github.com/mars05/crud-intellij-plugin
描述：一个增删改查的idea插件，可以根据数据库表结构，帮助您快速生成model、dao、service、controller等相关代码。同时支持MyBatis、JPA、MybatisPlus。

2. 在 IDEA 中摸鱼聊天

地址：https://github.com/Jamling/SmartIM4IntelliJ
描述：ntelliJ IDEA上的SmartIM(原SmartQQ)插件，可以在IDEA中使用QQ或微信聊天。安装成功后，会在底部栏出现一个SmartIM的tab（如果没有底部栏，则在菜单View中把ToolButtons勾选上）

3. 可视化流程编排

地址：https://github.com/alibaba/compileflow
描述：compileflow Process引擎是淘宝工作流TBBPM引擎之一，是专注于纯内存执行，无状态的流程引擎，通过将流程文件转换生成java代码编译执行，简洁高效。当前是阿里业务中台交易等多个核心系统的流程引擎。在阿里巴巴中台解决方案中广泛使用，支撑了导购、交易、履约、资金等多个业务场景。

七、总结

IDEA 开发技术涉及到了对 IDEA 插件开发 API 的熟悉以及UI界面的开发，所以如果想开发一款 IDEA 插件，基本离不开对 Swing 的编写，不过也不需要太复杂的页面，所有这部分技能还好。
IDEA 官网文档仅提供了两种构建 IDEA 插件工程的方法，但更推荐 Gradle 方式，这样可以满足你对后续其他功能组件的便捷引入，以及做其他内容的扩展。
IDEA 插件开发可以开发出很多用于提效研发编程的技术插件，例如一些监控、脚手架、接口API以及调试、流程化低代码编排等等，所以这部分内容的价值还是蛮大的。

八、系列推荐

带头撸项目，《DDD + RPC 开发分布式架构，抽奖系统》

Sun, 22 Aug 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn
原文：https://mp.weixin.qq.com/s/VthCUlT8oAJqKOoq5_NzSQ

一、咋，撸个项目？

总有粉丝伙伴问傅哥，有没有能上手练习技术的项目，现在学了这么多技术知识、看了这么多设计模式、搜了这么多架构设计，但这些内容都是怎么结合在一起使用的呢？互联网中的项目架构设计是什么样的呢？我该怎么开始学到什么样才能进大厂呢？

项目学习意见（收集结果）

项目学习意见（收集结果）.xlsx

咋neng呢，撸个项目吧！

在撸项目开始之前，做了一次项目学习意见调研，问了问大家：“想做个什么项目，如；积分商城、抽奖系统、活动系统、监控系统、技术组件，并且这些项目中用到了哪些技术栈。”

最后在大家的意见反馈中得到结果是，要先以开发互联网中C端类项目 抽奖系统 开始，这样一个项目可以让大家在系统的架构搭建、功能配置、服务开发中学习到关于一些关于解决高并发、高性能、高可用场景时的技术实践运用。放心，其他类的互联网项目，我们也会陆续的折腾起来！

So！基于DDD领域驱动设计的四层架构抽奖系统，开始啦！有座，这趟车的你跟上！

二、呀，都能学啥？

一个以真实场景实践技术栈整合开发实际需求的项目，势必会因为要完成需求而引入各项技术栈的使用，也会由于要解决互联网中C端场景中的三高问题，而使用相应的技术实现不同类别解决与方案，我们也可以把此类解决方案理解为DDD中的业务领域模型开发。在这个设计和开发的过程中会涉及到架构设计、技术应用、场景实现，每一块内容都会有非常多的实践知识，可以让读者学到东西。

三、嘿，让我看看！

1. 目录章节

一项代码实战派的傅哥，已经在两个周末的时间折腾出不少内容了，包括：从系统框架的搭建、广播模式Dubbo的配置、库表的设计以及部分功能的实现等，接下来在大家上车后，就可以对着已经完成的内容学习和跟进新内容的实现了。DDD四层系统架构测试案例如图：

当然完成的内容远不止上面截图的框架搭建，还包括下列章节：

提醒：文章需要代码库授权后可见，每周末和假期更新进度，以及不定期安排视频直播讲解共性学习问题。

2. 代码仓库

3. 工程结构

4. 运行结果

四、来，上傅哥车！

🚌 来吧，上车，还有座！

【小提醒】：这是一个付费项目，加入小傅哥的知识星球码农会锁，就可以参与到项目实战学习中了。当然，知识星球远不止这一个项目，后续还会有其他项目，另外你还会获得知识星球专属用户的一些特殊学习照顾。

【优惠券】：在公众号：bugstack虫洞栈，回复：加入星球，你会获得一张粉丝专属折扣券，冲！

代码授权：加入星球后，你会在星球里看到一个加入项目的🔝置顶消息，进入后按照步骤操作后，就可以被授权开通《抽奖系统的代码库》权限了。

学习说明：为了能让读者伙伴快速🔜进入项目学习，可以按照下面的步骤开始，在项目中会有更详细说明：

【入口】Lottery 仅代码授权后可访问 项目主入口中有一个 README.md 有关于项目的学习说明、开发规范、章节目录和问题交流提交issue说明以及群内交流，在学习的过程中可以参考使用。
【文章】每一个章节内容中都会包括；需求、实现、验证、细节，四块内容的介绍，以及当前章节中对应的代码分支可以切换学习。
【代码】在代码学习的过程中可以克隆工程进行开发练习，也可以给主工程小傅哥工程代码提交PR、ISSUE，我会去审核和合并以及不断的完善代码。

五、好，总结一下！

动手、动手、动手，一个实践类型的项目最需要的就是你动起手来，只有这样你才能发现各种问题细节的处理。更何况哪怕在别人电脑💻上运行的再顺畅的代码，在你那也可能拉跨，不过没关系因为所有拉跨的过程都将是你抓住学习的点！

我一直坚持很多事情要慢下来，希望你也不要过于的着急快，火急火燎不是学习的长久过程，而迟迟以恒才能让你的收获更加丰满。趁着时间还多正当年恰，坚持做好自己想做的事情吧！

基于Hash散列，数据库路由组件设计

Thu, 19 Aug 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn

一、前言

什么？Java 面试就像造火箭🚀

单纯了！ 以前我也一直想 Java 面试就好好面试呗，嘎哈么总考一些工作中也用不到的玩意，会用 Spring、MyBatis、Dubbo、MQ，把业务需求实现了不就行了！

但当工作几年后，需要提升自己(~~要加钱~~)的时候，竟然开始觉得自己只是一个调用 API 攒接口的工具人。没有知识宽度，没有技术纵深，也想不出来更没有意识，把日常开发的业务代码中通用的共性逻辑提炼出来，开发成公用的组件，更没有去思考日常使用的一些组件是用什么技术实现的。

所以有时候你说面试好像就是在造火箭，这些技术日常根本用不到，其实很多时候不是这个技术用不到，而是因为你没用(嗯，以前我也没用)。当你有这个想法想突破自己的薪资待遇瓶颈时，就需要去了解了解必备的数据结构、学习学习Java的算法逻辑、熟悉熟悉通用的设计模式、再结合像 Spring、ORM、RPC，这样的源码实现逻辑，把相应的技术方案赋能到自己的日常业务开发中，把共性的问题用聚焦和提炼的方式进行解决，这些才是你在 CRUD 之外的能力体现(~~加薪筹码~~)。

怎么？ 好像听上去有道理，那么举个栗子，来一场数据库路由的需求分析和逻辑实现！

二、需求分析

如果要做一个数据库路由，都需要做什么技术点？

首先我们要知道为什么要用分库分表，其实就是由于业务体量较大，数据增长较快，所以需要把用户数据拆分到不同的库表中去，减轻数据库压力。

分库分表操作主要有垂直拆分和水平拆分：

垂直拆分：指按照业务将表进行分类，分布到不同的数据库上，这样也就将数据的压力分担到不同的库上面。最终一个数据库由很多表的构成，每个表对应着不同的业务，也就是专库专用。
水平拆分：如果垂直拆分后遇到单机瓶颈，可以使用水平拆分。相对于垂直拆分的区别是：垂直拆分是把不同的表拆到不同的数据库中，而水平拆分是把同一个表拆到不同的数据库中。如：user_001、user_002

而本章节我们要实现的也是水平拆分的路由设计，如图 1-1

那么，这样的一个数据库路由设计要包括哪些技术知识点呢？

是关于 AOP 切面拦截的使用，这是因为需要给使用数据库路由的方法做上标记，便于处理分库分表逻辑。
数据源的切换操作，既然有分库那么就会涉及在多个数据源间进行链接切换，以便把数据分配给不同的数据库。
数据库表寻址操作，一条数据分配到哪个数据库，哪张表，都需要进行索引计算。在方法调用的过程中最终通过 ThreadLocal 记录。
为了能让数据均匀的分配到不同的库表中去，还需要考虑如何进行数据散列的操作，不能分库分表后，让数据都集中在某个库的某个表，这样就失去了分库分表的意义。

综上，可以看到在数据库和表的数据结构下完成数据存放，我需要用到的技术包括：AOP、数据源切换、散列算法、哈希寻址、ThreadLocal以及SpringBoot的Starter开发方式等技术。而像哈希散列、寻址、数据存放，其实这样的技术与 HashMap 有太多相似之处，那么学完源码造火箭的机会来了 如果你有过深入分析和学习过 HashMap 源码、Spring 源码、中间件开发，那么在设计这样的数据库路由组件时一定会有很多思路的出来。接下来我们一起尝试下从源码学习到造火箭！

三、技术调研

在 JDK 源码中，包含的数据结构设计有：数组、链表、队列、栈、红黑树，具体的实现有 ArrayList、LinkedList、Queue、Stack，而这些在数据存放都是顺序存储，并没有用到哈希索引的方式进行处理。而 HashMap、ThreadLocal，两个功能则用了哈希索引、散列算法以及在数据膨胀时候的拉链寻址和开放寻址，所以我们要分析和借鉴的也会集中在这两个功能上。

1. ThreadLocal

@Test
public void test_idx() {
    int hashCode = 0;
    for (int i = 0; i < 16; i++) {
        hashCode = i * 0x61c88647 + 0x61c88647;
        int idx = hashCode & 15;
        System.out.println("斐波那契散列：" + idx + " 普通散列：" + (String.valueOf(i).hashCode() & 15));
    }
} 

斐波那契散列：7 普通散列：0
斐波那契散列：14 普通散列：1
斐波那契散列：5 普通散列：2
斐波那契散列：12 普通散列：3
斐波那契散列：3 普通散列：4
斐波那契散列：10 普通散列：5
斐波那契散列：1 普通散列：6
斐波那契散列：8 普通散列：7
斐波那契散列：15 普通散列：8
斐波那契散列：6 普通散列：9
斐波那契散列：13 普通散列：15
斐波那契散列：4 普通散列：0
斐波那契散列：11 普通散列：1
斐波那契散列：2 普通散列：2
斐波那契散列：9 普通散列：3
斐波那契散列：0 普通散列：4

数据结构：散列表的数组结构
散列算法：斐波那契（Fibonacci）散列法
寻址方式：Fibonacci 散列法可以让数据更加分散，在发生数据碰撞时进行开放寻址，从碰撞节点向后寻找位置进行存放元素。公式：f(k) = ((k * 2654435769) >> X) << Y对于常见的32位整数而言，也就是 f(k) = (k * 2654435769) >> 28 ，黄金分割点：(√5 - 1) / 2 = 0.6180339887 1.618:1 == 1:0.618
学到什么：可以参考寻址方式和散列算法，但这种数据结构与要设计实现作用到数据库上的结构相差较大，不过 ThreadLocal 可以用于存放和传递数据索引信息。

2. HashMap

public static int disturbHashIdx(String key, int size) {
    return (size - 1) & (key.hashCode() ^ (key.hashCode() >>> 16));
}

数据结构：哈希桶数组 + 链表 + 红黑树
散列算法：扰动函数、哈希索引，可以让数据更加散列的分布
寻址方式：通过拉链寻址的方式解决数据碰撞，数据存放时会进行索引地址，遇到碰撞产生数据链表，在一定容量超过8个元素进行扩容或者树化。
学到什么：可以把散列算法、寻址方式都运用到数据库路由的设计实现中，还有整个数组+链表的方式其实库+表的方式也有类似之处。

四、设计实现

1. 定义路由注解

定义

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface DBRouter {

    String key() default "";

}

使用

@Mapper
public interface IUserDao {

     @DBRouter(key = "userId")
     User queryUserInfoByUserId(User req);

     @DBRouter(key = "userId")
     void insertUser(User req);

}

首先我们需要自定义一个注解，用于放置在需要被数据库路由的方法上。
它的使用方式是通过方法配置注解，就可以被我们指定的 AOP 切面进行拦截，拦截后进行相应的数据库路由计算和判断，并切换到相应的操作数据源上。

2. 解析路由配置

以上就是我们实现完数据库路由组件后的一个数据源配置，在分库分表下的数据源使用中，都需要支持多数据源的信息配置，这样才能满足不同需求的扩展。
对于这种自定义较大的信息配置，就需要使用到 org.springframework.context.EnvironmentAware 接口，来获取配置文件并提取需要的配置信息。

数据源配置提取

@Override
public void setEnvironment(Environment environment) {
    String prefix = "router.jdbc.datasource.";    

    dbCount = Integer.valueOf(environment.getProperty(prefix + "dbCount"));
    tbCount = Integer.valueOf(environment.getProperty(prefix + "tbCount"));    

    String dataSources = environment.getProperty(prefix + "list");
    for (String dbInfo : dataSources.split(",")) {
        Map<String, Object> dataSourceProps = PropertyUtil.handle(environment, prefix + dbInfo, Map.class);
        dataSourceMap.put(dbInfo, dataSourceProps);
    }
}

prefix，是数据源配置的开头信息，你可以自定义需要的开头内容。
dbCount、tbCount、dataSources、dataSourceProps，都是对配置信息的提取，并存放到 dataSourceMap 中便于后续使用。

3. 数据源切换

在结合 SpringBoot 开发的 Starter 中，需要提供一个 DataSource 的实例化对象，那么这个对象我们就放在 DataSourceAutoConfig 来实现，并且这里提供的数据源是可以动态变换的，也就是支持动态切换数据源。

创建数据源

@Bean
public DataSource dataSource() {
    // 创建数据源
    Map<Object, Object> targetDataSources = new HashMap<>();
    for (String dbInfo : dataSourceMap.keySet()) {
        Map<String, Object> 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 传递数据源，整体案例代码如下：

@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 中，用于传递在方法调用过程中可以提取到索引信息。

5. 测试验证

5.1 库表创建

create database `bugstack_01`;
DROP TABLE user_01;
CREATE TABLE user_01 ( id bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID', userId varchar(9) COMMENT '用户ID', userNickName varchar(32) COMMENT '用户昵称', userHead varchar(16) COMMENT '用户头像', userPassword varchar(64) COMMENT '用户密码', createTime datetime COMMENT '创建时间', updateTime datetime COMMENT '更新时间', PRIMARY KEY (id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
DROP TABLE user_02;
CREATE TABLE user_02 ( id bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID', userId varchar(9) COMMENT '用户ID', userNickName varchar(32) COMMENT '用户昵称', userHead varchar(16) COMMENT '用户头像', userPassword varchar(64) COMMENT '用户密码', createTime datetime COMMENT '创建时间', updateTime datetime COMMENT '更新时间', PRIMARY KEY (id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
DROP TABLE user_03;
CREATE TABLE user_03 ( id bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID', userId varchar(9) COMMENT '用户ID', userNickName varchar(32) COMMENT '用户昵称', userHead varchar(16) COMMENT '用户头像', userPassword varchar(64) COMMENT '用户密码', createTime datetime COMMENT '创建时间', updateTime datetime COMMENT '更新时间', PRIMARY KEY (id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
DROP TABLE user_04;
CREATE TABLE user_04 ( id bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID', userId varchar(9) COMMENT '用户ID', userNickName varchar(32) COMMENT '用户昵称', userHead varchar(16) COMMENT '用户头像', userPassword varchar(64) COMMENT '用户密码', createTime datetime COMMENT '创建时间', updateTime datetime COMMENT '更新时间', PRIMARY KEY (id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

创建相同表结构的多个库存信息，bugstack_01、bugstack_02

5.2 语句配置

<select id="queryUserInfoByUserId" parameterType="cn.bugstack.middleware.test.infrastructure.po.User"
        resultType="cn.bugstack.middleware.test.infrastructure.po.User">
    SELECT id, userId, userNickName, userHead, userPassword, createTime
    FROM user_${tbIdx}
    where userId = #{userId}
</select>               

<insert id="insertUser" parameterType="cn.bugstack.middleware.test.infrastructure.po.User">
    insert into user_${tbIdx} (id, userId, userNickName, userHead, userPassword,createTime, updateTime)
    values (#{id},#{userId},#{userNickName},#{userHead},#{userPassword},now(),now())
</insert>

在 MyBatis 的语句使用上，唯一变化的需要在表名后面添加一个占位符，${tbIdx} 用于写入当前的表ID。

5.3 注解配置

@DBRouter(key = "userId")
User queryUserInfoByUserId(User req);   

@DBRouter(key = "userId")
void insertUser(User req);

在需要使用分库分表的方法上添加注解，添加注解后这个方法就会被 AOP 切面管理。

5.4 单元测试

38:20.067  INFO 19900 --- [           main] c.b.m.db.router.DBRouterJoinPoint        : 数据库路由 method：queryUserInfoByUserId dbIdx：2 tbIdx：3
38:20.594  INFO 19900 --- [           main] cn.bugstack.middleware.test.ApiTest      : 测试结果：{"createTime":1615908803000,"id":2,"userHead":"01_50","userId":"980765512","userNickName":"小傅哥","userPassword":"123456"}
38:20.620  INFO 19900 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'1

以上就是我们使用自己的数据库路由组件执行时的一个日志信息，可以看到这里包含了路由操作，在2库3表：数据库路由 method：queryUserInfoByUserId dbIdx：2 tbIdx：3

五、总结

综上就是我们从 HashMap、ThreadLocal、Spring等源码学习中了解到技术内在原理，并把这样的技术用在一个数据库路由设计上。如果没有经历过这些总被说成造火箭的技术沉淀，那么几乎也不太可能顺利开发出一个这样一个中间件，所有很多时候根本不是技术没用，而是自己没用上没机会用而已。不要总惦记那一片片重复的 CRUD，看看还有哪些知识是真的可以提升个人能力的！参考资料：《SpringBoot 中间件设计和开发》

六、系列推荐

给学习加点实践，开发一个分布式IM(即时通信)系统！

Tue, 17 Aug 2021 00:00:00 +0800

作者：小傅哥
博客：https://bugstack.cn

一、前言

这知识学的，根本没有忘的快呀？！

是不是感觉很多资料，点收藏起来爽、看视频时候嗨、读文章当时会，只要过了那个劲，就完了，根本不记得这里面都讲了啥。时间浪费了，东西还没学到手，这是为啥？

其实因为学习也分为上策、中策和下策：

下策：眼睛看就行，坐着、窝着、躺着，都行，反正也不累，还能一边回复下吹水的微信群
中策：看完的资料做笔记整理归纳，长期积累资料
上策：实践、上手、应用、调试、归纳、整理资料，总结经验输出文档

综上，下策学起来很快感觉自己好像会了不少，中策有点要动手了懒不想动，上策就很耗时耗力了要自己对每一个知识点都能事必躬亲到亲力亲为。就这样你在学习的时候不自觉的就选择了下策，因此其实并没有学到什么。

学习能把知识学到手，讲究的是实践，在小傅哥编写的文章中，基本都是以实践代码验证结果为核心，讲述文章内容。😁从小我就喜欢动手，就以一个即时通信的项目为例，已经基于不同技术方案实现了5、6次，仅为了实践技术，截图如下：

有些是刚学完Socket和Swing的时候，想动手试试这些技术能不能写个QQ出来。
也有的是因为实习培训需要完成的项目，不过在有了一些基础后，一周时间就能写完全部功能。
虽然这些项目在现在看上去还是丑丑的界面，以及代码逻辑可能也不是那么完善。但放在学习阶段的每一次实现中，都能为自己带来很多技术上的成长。

那么，这次IM实践的机会给你，希望你能用的上！接下来我会给你介绍一个IM的系统架构、通信协议、单聊群聊、表情发送、UI事件驱动等各项内容，以及提供全套的源码让你可以上手学习。

二、演示

在开始学习之前，先给大家演示下这套仿照PC端微信界面的IM系统运行效果。

聊天页面

添加好友

视频演示

https://www.bilibili.com/video/BV1BZ4y1W7fC

三、系统设计

在这套IM中，服务端采用DDD领域驱动设计模式进行搭建。将 Netty 的功能交给 SpringBoot 进行启停控制，同时在服务端搭建控制台可以非常方便的操作通信系统，进行用户和通信管理。在客户端的建设上采用UI分离的方式进行搭建，以保证业务代码与UI展示分离，做到非常易于扩展的控制。

另外在功能实现上包括；完美仿照微信桌面版客户端、登录、搜索添加好友、用户通信、群组通信、表情发送等核心功能。如果有对于实际需要使用的功能，可以按照这套系统框架进行扩展。

UI开发：使用JavaFx与Maven搭建UI桌面工程，逐步讲解登录框体、聊天框体、对话框、好友栏等各项UI展示及操作事件。从而在这一章节中让Java 程序员学会开发桌面版应用。
架构设计：在这一章节中我们会使用DDD领域驱动设计的四层模型结构与Netty结合使用，架构出合理的分层框架。同时还有相应库表功能的设计。相信这些内容学习后，你一定也可以假设出更好的框架。
功能实现：这部分我们主要将通信中的各项功能逐步实现，包括；登录、添加好友、对话通知、消息发送、断线重连等各项功能。最终完成整个项目的开发，同时也可以让你从实践中学会技能。

四、UI开发

1. 整体结构定义、侧边栏

聊天窗体，相对于登陆窗体来说，聊天窗体的内容会比较多，同时也会相对复杂一些。因此我们会分章节的逐步来实现这些窗体以及事件和接口功能。在本篇文章中我们会主要讲解聊天框体的搭建以及侧边栏 UI 开发。

首先是我们整个聊天主窗体的定义，是一块空白面板，并去掉默认的边框按钮 (最小化、退出等)
之后是我们左侧边栏，我们称之为条形 Bar，功能区域的实现。
最后添加窗体事件，当点击按钮时变换 内容面板 中的填充信息。

2. 对话聊天框

对话框选中后的内容区域展现，也就是用户之间信息发送和展现。从整体上看这是一个联动的过程，点击左侧的对话框用户，右侧就有相应内容的填充。那么右侧被填充对话列表 ListView 需要与每一个对话用户关联，点击聊天用户的时候，是通过反复切换填充的过程。

点击左侧的每一个对话框体，右侧聊天框填充内容即随之变化。同时还有相应的对话名称也会也变化。
对话框中左侧展示好友发送的信息，右侧展示个人发送的信息。同时消息内容会随着内容的增多而增加高度和宽度。
最下面是文本输入框，在后面的实现里我们文本输入框采用公用的方式进行设计，当然你也可以设计为单独的个人使用。

3. 好友栏

大家都经常使用 PC 端的微信，可以知道在好友栏里是分了几段内容的，其中包含；新的朋友、公众号、群组和最下面的好友。

最上面的搜索框这部分内容不变，和前面的一样。我们目前使用的方式是 fxml 设计，例如这部分是通用功能，可以抽取出来放到代码中，设计成一个组件元素类。
经过我们的分析，在使用 JavaFx 组件开发为基础下，这部分是一种嵌套 ListView，也就是最底层的面板是一个 ListView，好友和群组有各是一个 ListView，这样处理后我们会很方便的进行数据填充。
另外这样的结构主要有利于在我们程序运行过程中，如果你添加了好友，那么我们需要将好友信息刷新到好友栏中，而在数据填充的时候，为了更加便捷高效，所以我们设计了嵌套的 ListView。如果还不是特别理解，可以从后续的代码中获得答案。

4. 事件定义

在桌面版 UI 开发中，为了能使 UI 与业务逻辑隔离，需要在我们把 UI 打包后提供出操作界面的展示效果的接口以及界面操作事件抽象类。那么可以按照下图理解；

序号	接口名	描述
1	void doShow()	打开窗口
2	void setUserInfo(String userId, String userNickName, String userHead)	设置登陆用户 ID、昵称、头像
3	void addTalkBox(int talkIdx, Integer talkType, String talkId, String talkName, String talkHead, String talkSketch, Date talkDate, Boolean selected)	填充对话框列表
4	void addTalkMsgUserLeft(String talkId, String msg, Date msgData, Boolean idxFirst, Boolean selected, Boolean isRemind)	填充对话框消息 - 好友 (别人的消息)

以上这些接口就是我们目前 UI 为外部提供的所有行为接口，这些接口的一个链路描述就是；打开窗口、搜索好友、添加好友、打开对话框、发送消息。

五、通信设计

1. 系统架构

在前面我们说到更适合的架构，才是符合你当下需要最好的架构。那么怎么设计这样架构呢，基本就是要找到符合点的目标。我们之所以这样设计是为什么，那么在这个系统里有如下几点；

我们系统在服务端要有 web 页面进行管理通信用户以及服务端的控制和监控。
数据库的对象类，不要被外部污染，要有隔离性。比如说；你的数据库类暴漏给外部做展示类使用了，那么现在需要增加一个字段，而这个字段又不是你数据库存在的属性。那么这个时候就已经把数据库类污染了。
因为目前我们都是在 Java 语言下实现 Netty 通信，那么服务端与客户端都会需要使用到通信过程中的协议定义和解析。那么我们需要抽离这一层对外提供 Jar 包。
接口、业务处理、底层服务、通信交互，要有明确的区分和实现，避免造成混乱难以维护。

结合我们上面这四点的目标，你头脑中有什么模型结构体现了呢？以及相应的技术栈选择上是否有计划了？接下来我们会介绍两种架构设计的模型，一种是你非常熟悉的 MVC，另外一种是你可能听说过的 DDD 领域驱动设计。

2. 通信协议

从图稿上来看，我们在传输对象的时候需要在传输包中添加一个 帧标识 以此来判断当前的业务对象是哪个对象，也就可以让我们的业务更加清晰，避免使用大量的 if 语句判断。

协议框架

agreement
└── src
    ├── main
    │   ├── java
    │   │   └── org.itstack.naive.chat
    │   │       ├── codec
    │   │       │    ├── ObjDecoder.java
    │   │       │    └── ObjEncoder.java
    │   │       ├── protocol
    │   │       │    ├── demo
    │   │       │    ├── Command.java
    │   │       │    └── Packet.java
    │   │       └── util
    │   │             └── SerializationUtil.java
    │   ├── resources    
    │   │   └── application.yml
    │   └── webapp
    │       └── chat
    │       └── res
    │       └── index.html
    └── test
         └── java
             └── org.itstack.demo.test
                 └── ApiTest.java

协议包

public abstract class Packet {

    private final static Map<Byte, Class<? extends Packet>> packetType = new ConcurrentHashMap<>();

    static {
        packetType.put(Command.LoginRequest, LoginRequest.class);
        packetType.put(Command.LoginResponse, LoginResponse.class);
        packetType.put(Command.MsgRequest, MsgRequest.class);
        packetType.put(Command.MsgResponse, MsgResponse.class);
        packetType.put(Command.TalkNoticeRequest, TalkNoticeRequest.class);
        packetType.put(Command.TalkNoticeResponse, TalkNoticeResponse.class);
        packetType.put(Command.SearchFriendRequest, SearchFriendRequest.class);
        packetType.put(Command.SearchFriendResponse, SearchFriendResponse.class);
        packetType.put(Command.AddFriendRequest, AddFriendRequest.class);
        packetType.put(Command.AddFriendResponse, AddFriendResponse.class);
        packetType.put(Command.DelTalkRequest, DelTalkRequest.class);
        packetType.put(Command.MsgGroupRequest, MsgGroupRequest.class);
        packetType.put(Command.MsgGroupResponse, MsgGroupResponse.class);
        packetType.put(Command.ReconnectRequest, ReconnectRequest.class);
    }

    public static Class<? extends Packet> get(Byte command) {
        return packetType.get(command);
    }

    /**
     * 获取协议指令
     *
     * @return 返回指令值
     */
    public abstract Byte getCommand();

}

3. 添加好友

从上面的流程中可以看到，这里包含了两部分内容；(1) 搜索好友，(2) 添加好友。当天就完成好友后，好友会出现到我们的好友栏中。
并且这里面我们采用的是单方面同意加好友，也就是你添加一个好友的时候，对方也同样有你的好友信息。
如果你的业务中是需要添加好友并同意的，那么可以在发起好友添加的时候，添加一条状态信息，请求加好友。对方同意后，两个用户才能成为好友并进行通信。

添加好友，案例代码

public class AddFriendHandler extends MyBizHandler<AddFriendRequest> {

    public AddFriendHandler(UserService userService) {
        super(userService);
    }

    @Override
    public void channelRead(Channel channel, AddFriendRequest msg) {
        // 1. 添加好友到数据库中[A->B B->A]
        List<UserFriend> userFriendList = new ArrayList<>();
        userFriendList.add(new UserFriend(msg.getUserId(), msg.getFriendId()));
        userFriendList.add(new UserFriend(msg.getFriendId(), msg.getUserId()));
        userService.addUserFriend(userFriendList);
        // 2. 推送好友添加完成 A
        UserInfo userInfo = userService.queryUserInfo(msg.getFriendId());
        channel.writeAndFlush(new AddFriendResponse(userInfo.getUserId(), userInfo.getUserNickName(), userInfo.getUserHead()));
        // 3. 推送好友添加完成 B
        Channel friendChannel = SocketChannelUtil.getChannel(msg.getFriendId());
        if (null == friendChannel) return;
        UserInfo friendInfo = userService.queryUserInfo(msg.getUserId());
        friendChannel.writeAndFlush(new AddFriendResponse(friendInfo.getUserId(), friendInfo.getUserNickName(), friendInfo.getUserHead()));
    }

}

4. 消息应答

从整体的流程可以看到，在用户发起好友、群组通信的时候，会触发一个事件行为，接下来客户端向服务端发送与好友的对话请求。
服务端收到对话请求后，如果是好友对话，那么需要保存与好友的通信信息到对话框中。同时通知好友，我与你要通信了。你在自己的对话框列表中，把我加进去。
那么如果是群组通信，是可以不用这样通知的，因为不可能把还没有在线的所有群组用户全部通知（人家还没登录呢），所以这部分只需要在用户上线收到信息后，创建出对话框到列表中即可。可以仔细理解下，同时也可以想想其他实现的方式。

消息应答，案例代码

public class MsgHandler extends MyBizHandler<MsgRequest> {

    public MsgHandler(UserService userService) {
        super(userService);
    }

    @Override
    public void channelRead(Channel channel, MsgRequest msg) {
        logger.info("消息信息处理：{}", JSON.toJSONString(msg));
        // 异步写库
        userService.asyncAppendChatRecord(new ChatRecordInfo(msg.getUserId(), msg.getFriendId(), msg.getMsgText(), msg.getMsgType(), msg.getMsgDate()));
        // 添加对话框[如果对方没有你的对话框则添加]
        userService.addTalkBoxInfo(msg.getFriendId(), msg.getUserId(), Constants.TalkType.Friend.getCode());
        // 获取好友通信管道
        Channel friendChannel = SocketChannelUtil.getChannel(msg.getFriendId());
        if (null == friendChannel) {
            logger.info("用户id：{}未登录！", msg.getFriendId());
            return;
        }
        // 发送消息
        friendChannel.writeAndFlush(new MsgResponse(msg.getUserId(), msg.getMsgText(), msg.getMsgType(), msg.getMsgDate()));
    }

}

5. 断线重连

从上述流程中我们看到，当网络连接断开以后，会像服务端发送重新链接的请求。那么在这个发起链接的过程，和系统的最开始链接有所区别。断线重连是需要将用户的 ID 信息一同- - 发送给服务端，好让服务端可以去更新用户与通信管道 Channel 的绑定关系。
同时还需要更新群组内的重连信息，把用户的重连加入群组映射中。此时就可以恢复用户与好友和群组的通信功能。

消息应答，案例代码

// Channel 状态定时巡检；3 秒后每 5 秒执行一次
scheduledExecutorService.scheduleAtFixedRate(() -> {while (!nettyClient.isActive()) {System.out.println("通信管道巡检：通信管道状态" + nettyClient.isActive());
        try {System.out.println("通信管道巡检：断线重连 [Begin]");
            Channel freshChannel = executorService.submit(nettyClient).get();
            if (null == CacheUtil.userId) continue;
            freshChannel.writeAndFlush(new ReconnectRequest(CacheUtil.userId));
        } catch (InterruptedException | ExecutionException e) {System.out.println("通信管道巡检：断线重连 [Error]");}
    }
}, 3, 5, TimeUnit.SECONDS);

6. 集群通信

跨服务之间案例采用redis的发布和订阅进行传递消息，如果你是大型服务可以使用zookeeper
用户A在发送消息给用户B时候，需要传递B的channeId，以用于服务端进行查找channeId所属是否自己的服务内
单台机器也可以启动多个Netty服务，程序内会自动寻找可用端口

六、源码下载

本项目是作者小傅哥使用JavaFx、Netty4.x、SpringBoot、Mysql等技术栈和偏向于DDD领域驱动设计方式，搭建的仿桌面版微信实现通信核心功能。

这套 IM 代码分为了三组模块；UI、客户端、服务端。之所以这样拆分，是为了将UI展示与业务逻辑隔离，使用事件和接口进行驱动，让代码层次更加干净整洁易于扩展和维护。

序号	工程	介绍
1	itstack-naive-chat-ui	使用JavaFx开发的UI端，在我们的UI端中提供了；登录框体、聊天框体，同时在聊天框体中有大量的行为交互界面以及接口和事件。最终我的UI端使用Maven打包的方式向外提供Jar包，以此来达到UI界面与业务行为流程分离。
2	itstack-naive-chat-client	客户端是我们的通信核心工程，主要使用Netty4.x作为我们的socket框架来完成通信交互。并且在此工程中负责引入UI的Jar包，完成UI定义的事件(登录验证、搜索添加好友、对话通知、发送信息等等)，以及需要使用我们在服务端工程定义的通信协议来完成信息的交互操作。
3	itstack-navie-chat-server	服务端同样使用Netty4.x作为socket的通信框架，同时在服务端使用Layui作为管理后台的页面，并且我们的服务端采用偏向于DDD领域驱动设计的方式与Netty集合，以此来达到我们的框架结构整洁干净易于扩展。
4	itstack.sql	系统工程数据库表结构以及初始化数据信息，共计6张核心表；用户表、群组表、用户群组关联表、好友表、对话表以及聊天记录表。用户在实际业务开发中可以自行拓展完善，目前库表结构只以核心功能为基础。

源码获取：关注公众号：bugstack虫洞栈，回复IM 亲，源码给我点个Star，不要白皮袄！！！
专栏小册：直接阅读原文即可

七、总结

此IM系统涉及到的技术栈内容较多，Netty4.x、SpringBoot、Mybatis、Mysql、JavaFx、layui等技术栈的使用，以及整个系统框架结构采用DDD四层架构+Socket模块的方式进行搭建，所有的UI都以前后端分离事件驱动方式进行设计，在这个过程中只要你能坚持学习下来，那么一定会收获非常多的内容。足够吹牛啦！🌶
任何一个新技术栈的学习过程都会包括这样一条路线；运行HelloWorld、熟练使用API、项目实践以及最后的深度源码挖掘。那么在听到这样一个需求时候，Java程序员肯定会想到一些列的技术知识点来填充我们项目中的各个模块，例如；界面用JavaFx、Swing等，通信用Socket或者知道Netty框架、服务端控制用MVC模型加上SpringBoot等。但是怎么将这些各个技术栈合理的架设出我们的系统确是学习、实践、成长过程中最重要的部分。