javacoo
javacoo

事件处理工具组件

event-spring-boot-starter是一个基于springboot starter机制，结合SPI 接口设计思想实现的事件处理工具组件，旨在提供简单的事件处理编程模型，让基于事件的开发更简单灵活，内部实现基于guava EventBus 实现，扩展方便，集成使用简单。

背景介绍

业务背景

1、我们在日常开发过程中经常遇到一些特殊业务场景(非分布式环境下,分布式环境的不在此次讨论范围)，需要异步处理，常见的处理方式是基于事件机制来完成任务，我们可以基于java的事件处理机制自己实现，也可以基于Spring事件机制实现，还可以使用guava EventBus 实现，或者基于MQ中间件来实现等等，可选方案很多，大家可以任意发挥，但同时对于项目来说也带来了一些问题：技术不统一，维护成本提高等，所以需要一个统一的事件处理编程模型。

需求分析

1、提供统一的事件处理编程模型。

2、尽量少改或者不改造已有功能：少侵入或者0侵入式开发。

3、扩展方便，集成简单，开发速率高，使用简单。

设计思路

事件处理只需要2步：发布事件，处理事件。就这么简单:)

组件整体基于springboot starter机制，结合SPI 接口设计思想实现，内部集成默认实现：guava EventBus，EventBus使用相对简单，但是需要我们手动注册监听者对象有点繁琐,鉴于此，我想到了两种方式实现自动注册监听者对象，1：基于ASM动态修改字节码实现，2：基于插入式注解处理器在编译期直接操作抽象语法树实现。最终选用 第2种方式实现

  • 新建 springboot starter工程：event-spring-boot-starter

  • 基于SPI思想设计扩展接口(EventHelper)：提供事件发布，监听对象注册

  • 定义事件订阅注解(MySubscribe)：基于ASM动态修改字节码实现

    1. 实现ApplicationContextAware 接口，获取ApplicationContext 应用上下文。
    2. 查找所有包含org.springframework.stereotype.Service注解并且方法上有MySubscribe注解的对象，利用AopUtils工具类获取其class对象，以及相关信息，并封装为EventMetaData对象(目标类对象，包含MySubscribe注解的方法集合等)，供下一步使用。
    3. 根据获取的EventMetaData集合，依次处理，利用AsmUtil工具类，给目标class对象中目标方法添加Subscribe注解，并得到新的class对象。
    4. 根据EventMetaData中记录的目标对象beanBean,利用GenericBeanDefinition在ApplicationContext 应用上下文中找到该实例对象，重新设置beanClass为新生成的class对象。
    5. 最后利用DefaultListableBeanFactory 重新注册该对象。

  • 定义事件处理器注解(EventHandler)：基于插入式注解处理器在编译期直接操作抽象语法树实现

    1. 继承AbstractProcessor 重写process方法。
    2. 在process方法方法中，首先找到方法上有EventHandler注解的方法，如果注解属性threadSafe是true则在该方法上添加AllowConcurrentEvents，再在该方法上添加Subscribe注解，并记录该类。
    3. 判断该类是否已经被Spring容器管理，如果没有则为此类添加org.springframework.stereotype.Component注解。
    4. 然后为此类添加事件监听注册初始化方法。
    5. 利用ApplicationListener监听ContextRefreshedEvent事件，在Spring容器初始化完毕后，注册事件监听对象。

  • 内部实现guava EventBus

  • 扩展接口(EventHelper)：

    方法名称 参数 说明
    post (Object eventObject) 发布同步事件
    eventObject：事件对象，可以为任意对象
    postAsync (Object eventObject) 发布异步事件
    eventObject：事件对象，可以为任意对象
    postDelay (Object eventObject, long delayTime) 发布延迟事件
    eventObject：事件对象，可以为任意对象
    delayTime：延迟时间,单位:毫秒
    register (Object listenerObject) 注册监听对象
    listenerObject：监听对象，可以为任意对象
    unRegister (Object listenerObject) 注销监听对象
    listenerObject：监听对象

具体实现见 实施步骤 一节，由于实施步骤较多，故放在后面章节，我们先来看看如何集成,使用及扩展。

集成，使用及扩展

源码

https://gitee.com/javacoo/event-spring-boot-starter

集成

   com.javacoo
   event-spring-boot-starter
   1.0.0
使用

  • 配置文件接入事件处理器（此步骤可省略,默认可用）

    主要配置说明，详见 EventConfig限流配置

config.png

  • 发布事件：任意对象可作为事件对象发布

        @Override
  public Optional getExampleInfo(String id) {
      AbstractAssert.isNotBlank(id, ErrorCodeConstants.SERVICE_GET_EXAMPLE_INFO_ID);
        ExampleDto exampleDto = new ExampleDto();
        exampleDto.setData("这是测试数据");
        exampleDto.setId("1");
        //发布延迟事件
        EventHolder.getEventHelper().get().postDelay(exampleDto,1000);
        //发布同步事件
        String str = "我是事件内容";
        EventHolder.getEventHelper().get().post(str);
        //发布异步事件
        Integer integer = 1;
        EventHolder.getEventHelper().get().postAsync(integer);
        return Optional.ofNullable(exampleDto);
  }

  • 处理事件：

        //@MySubscribe
  public void tesSubscribe(ExampleDto exampleDto){
      log.info("事件处理:{}", JSON.toJSONString(exampleDto));
    }
    //@MySubscribe
    public void tesIntegerSubscribe(Integer integer){
        log.info("IntegerSubscribe事件处理:{}", integer);
    }
    //@MySubscribe
    public void tesStringSubscribe(String str){
        log.info("StringSubscribe事件处理:{}", str);
    }
    @EventHandler
    public void testEventHandler(ExampleDto exampleDto){
        log.info("事件处理:{}", JSON.toJSONString(exampleDto));
    }
    @EventHandler
  public void testIntegerEventHandler(Integer integer){
        log.info("IntegerEventHandler事件处理:{}", integer);
  }
    @EventHandler
    public void testStringEventHandler(String str){
        log.info("StringEventHandler事件处理:{}", str);
    }

    事件处理器注解@EventHandler效果

entlog.png

事件订阅注解@MySubscribe效果

scrlog.png
扩展

基于xkernel 提供的SPI机制，扩展非常方便，大致步骤如下：

  1. 实现事件帮助类接口：如 com.xxxx.xxxx.MyEventHelper

  2. 配置事件帮助类接口：

    • 在项目resource目录新建包->META-INF->services

    • 创建com.javacoo.event.client.api.EventHelper文件，文件内容：实现类的全局限定名，如：

      myEventHelper=com.xxxx.xxxx.MyEventHelper

    • 修改配置文件，添加如下内容:

    #event实现，默认内部实现
event.impl = myEventHelper

注意：**@MySubscribe，@EventHandler不能共存，推荐使用@EventHandler注解。

至此组件安装，使用及扩展介绍完毕，接下来将进入预备知识环节。

预备知识

1，ASM

  1. 简介

    • ASM 是一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class 文件里，这些类文件拥有足够的元数据来解析类中的所有元素：类名称、方法、属性以及 Java 字节码（指令）。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。

    • 在ASM的理解和应用，之前需要我们掌握class字节码，JVM基于栈的设计模式,JVM指令

      class字节码

      我们编写的java文件，会通过javac命令编译为class文件，JVM最终会执行该类型文件来运行程序。下图所示为class文件结构（图片来源网络）。

      img

      下面我们通过一个简单的实例来进行说明。下面是我们编写的一个简单的java文件，只是简单的函数调用.

      public class Test {
    private int num1 = 1;
    public static int NUM1 = 100;
    public int func(int a,int b){
        return add(a,b);
    }
    public int add(int a,int b) {
        return a+b+num1;
    }
    public int sub(int a, int b) {
        return a-b-NUM1;
    }
}

      使用javac -g Test.java编译为class文件，然后通过 javap -verbose Test.class 命令查看class文件格式。

      public class com.wuba.asmdemo.Test
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#26         // java/lang/Object."":()V
   #2 = Fieldref           #5.#27         // com/wuba/asmdemo/Test.num1:I
   #3 = Methodref          #5.#28         // com/wuba/asmdemo/Test.add:(II)I
   #4 = Fieldref           #5.#29         // com/wuba/asmdemo/Test.NUM1:I
   #5 = Class              #30            // com/wuba/asmdemo/Test
   #6 = Class              #31            // java/lang/Object
   #7 = Utf8               num1
   #8 = Utf8               I
   #9 = Utf8               NUM1
  #10 = Utf8               
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               LocalVariableTable
  #15 = Utf8               this
  #16 = Utf8               Lcom/wuba/asmdemo/Test;
  #17 = Utf8               func
  #18 = Utf8               (II)I
  #19 = Utf8               a
  #20 = Utf8               b
  #21 = Utf8               add
  #22 = Utf8               sub
  #23 = Utf8               
  #24 = Utf8               SourceFile
  #25 = Utf8               Test.java
  #26 = NameAndType        #10:#11        // "":()V
  #27 = NameAndType        #7:#8          // num1:I
  #28 = NameAndType        #21:#18        // add:(II)I
  #29 = NameAndType        #9:#8          // NUM1:I
  #30 = Utf8               com/wuba/asmdemo/Test
  #31 = Utf8               java/lang/Object
{
  public static int NUM1;
    descriptor: I
    flags: ACC_PUBLIC, ACC_STATIC

  public com.wuba.asmdemo.Test();     //构造函数
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field num1:I
         9: return
      LineNumberTable:
        line 3: 0
        line 5: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  this   Lcom/wuba/asmdemo/Test;

  public int func(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=3
         0: aload_0
         1: iload_1
         2: iload_2
         3: invokevirtual #3                  // Method add:(II)I
         6: ireturn
      LineNumberTable:
        line 10: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0  this   Lcom/wuba/asmdemo/Test;
            0       7     1     a   I
            0       7     2     b   I

  public int add(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=3
         0: iload_1
         1: iload_2
         2: iadd
         3: aload_0
         4: getfield      #2                  // Field num1:I
         7: iadd
         8: ireturn
      LineNumberTable:
        line 14: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcom/wuba/asmdemo/Test;
            0       9     1     a   I
            0       9     2     b   I

  public int sub(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=3
         0: iload_1
         1: iload_2
         2: isub
         3: getstatic     #4                  // Field NUM1:I
         6: isub
         7: ireturn
      LineNumberTable:
        line 18: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       8     0  this   Lcom/wuba/asmdemo/Test;
            0       8     1     a   I
            0       8     2     b   I

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: bipush        100
         2: putstatic     #4                  // Field NUM1:I
         5: return
      LineNumberTable:
        line 7: 0
}
SourceFile: "Test.java"

      可以看出在编译为class文件后，字段名称，方法名称，类型名称等均在常量池中存在的。从而做到减小文件的目的。同时方法定义也转变为了jvm指令。下面我们需要对jvm指令加深一下了解。在了解之前需要我们理解JVM基于栈的设计模式

      JVM基于栈的设计模式

      JVM的指令集是基于栈而不是寄存器，基于栈可以具备很好的跨平台性。在线程中执行一个方法时，我们会创建一个栈帧入栈并执行，如果该方法又调用另一个方法时会再次创建新的栈帧然后入栈，方法返回之际，原栈帧会返回方法的执行结果给之前的栈帧，随后虚拟机将会丢弃此栈帧。

      img
      局部变量表

      局部变量表(Local Variable Table)是一组变量值存储空间，用于存放方法参数和方法内定义的局部变量。虚拟机通过索引定位的方法查找相应的局部变量。举个例子。以上述的代码为例

       public int sub(int a, int b) {
        return a-b-NUM1;
    }

      这个方法大家可以猜测一下局部变量有哪些? 答案是3个，不应该只有a,b吗？还有this,对应实例对象方法编译器都会追加一个this参数。如果该方法为静态方法则为2个了。

      public int sub(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=3
         0: iload_1
         1: iload_2
         2: isub
         3: getstatic     #4                  // Field NUM1:I
         6: isub
         7: ireturn
      LineNumberTable:
        line 18: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       8     0  this   Lcom/wuba/asmdemo/Test;
            0       8     1     a   I
            0       8     2     b   I

      所以局部变量表第0个元素为this, 第一个为a,第二个为b

      操作数栈

      通过局部变量表我们有了要操作和待更新的数据，我们如果对局部变量这些数据进行操作呢？通过操作数栈。当一个方法刚刚开始执行时，其操作数栈是空的，随着方法执行和字节码指令的执行，会从局部变量表或对象实例的字段中复制常量或变量写入到操作数栈，再随着计算的进行将栈中元素出栈到局部变量表或者返回给方法调用者，也就是出栈/入栈操作。一个完整的方法执行期间往往包含多个这样出栈/入栈的过程。

      JVM指令
      • load 命令：用于将局部变量表的指定位置的相应类型变量加载到操作数栈顶；
      • store命令：用于将操作数栈顶的相应类型数据保入局部变量表的指定位置；
      • invokevirtual:调用实例方法
      • ireturn: 当前方法返回int

      在举个例子

      a = b + c 的字节码执行过程中操作数栈以及局部变量表的变化如下图所示

      img
      img
      ASM操作

      通过上面的介绍，我们对字节码和JVM指令有了进一步的了解，下面我们看一下ASM是如果编辑class字节码的。

      ASM API

      ASM API基于访问者模式，为我们提供了ClassVisitor，MethodVisitor，FieldVisitor API接口，每当ASM扫描到类字段是会回调visitField方法，扫描到类方法是会回调MethodVisitor，下面我们看一下API接口

      ClassVisitor方法解析

      public abstract class ClassVisitor {
        ......
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces);
    //访问类字段时回调
    public FieldVisitor visitField(int access, String name, String desc, String signature, Object value);
    //访问类方法是回调
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions);
    public void visitEnd();
}
      MethodVisitor方法解析
      public abstract class MethodVisitor {
        ......
    public void visitParameter(String name, int access);
    //访问本地变量类型指令 操作码可以是LOAD,STORE，RET中一种；
    public void visitIntInsn(int opcode, int operand);
    //域操作指令，用来加载或者存储对象的Field
    public void visitFieldInsn(int opcode, String owner, String name, String descriptor);
    //访问方法操作指令
    public void visitMethodInsn(int opcode, String owner, String name, String descriptor);
    public void visitEnd();
}

  2. 实战

    利用ASM替换自定义注解MySubscribe,代码如下

    自定义注解MySubscribe

    @Documented
@Inherited
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MySubscribe {
}

    事件注册基类

    @Slf4j
public class BaseEventRegister {
    /**
     * 获取所有注解 类
     * 
    说明:
    
     * 
  3. 在所有注解 org.springframework.stereotype.Service 类中查找方法包含指定注解
    4. 
     * @author [email protected]
     * @param annClass 类注解class
     * @param mAnnClass 方法注解class
     * @date 2021/10/20 22:02
     * @retuen Set
     */
    protected Set getEventMetaDatas(Class annClass,Class mAnnClass){
        //查找Service
        Map serviceMap = ApplicationContextProvider.getApplicationContext().getBeansWithAnnotation(annClass);
        log.info("事件注册数量:{},对象:{}",serviceMap.size(),serviceMap);
        Set eventMetaDatas = new HashSet<>();
        for (Map.Entry entry : serviceMap.entrySet()) {
            Class entryClass = AopUtils.getTargetClass(entry.getValue());
            //获取注解所在方法 public方法
            List methods = Arrays.stream(entryClass.getDeclaredMethods())
                    .filter(method -> Modifier.isPublic(method.getModifiers()))//获取本类 public方法
                    .filter(method->method.isAnnotationPresent(mAnnClass))//找到注解所在方法
                    .collect(Collectors.toList());
            if(methods.isEmpty()){
                continue;
            }
            eventMetaDatas.add(EventMetaData.builder().beanName(entry.getKey()).targetMethods(methods).targetClass(entryClass).build());
        }
        return eventMetaDatas;
    }
}

    ASM实现事件注册

    @Slf4j
@Configuration
public class AsmEventRegister extends BaseEventRegister implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //设置applicationContext
        ApplicationContextProvider.setApplicationContext(applicationContext);
        //查找Service
        Set eventMetaDatas = getEventMetaDatas(Service.class, MySubscribe.class);

        if(EventHolder.getEventHelper().isPresent() & !eventMetaDatas.isEmpty()){
            eventMetaDatas.forEach(eventMetaData -> {
                List methodNames = eventMetaData.getTargetMethods().stream().map(method -> method.getName()).collect(
                    Collectors.toList());
                Class newCalss = AsmUtil.getInstance().addAnntation(methodNames, "Lcom/google/common/eventbus/Subscribe;", eventMetaData.getTargetClass());
                if(newCalss != null){
                    log.info("事件元数据:{}",eventMetaData);
                    ApplicationContextProvider.registerBean(eventMetaData.getBeanName(),newCalss);
                    Object newObject =ApplicationContextProvider.getBean(eventMetaData.getBeanName());
                    if(newObject != null){
                        log.info("注册监听对象:{}",newObject);
                        EventHolder.getEventHelper().get().register(newObject);
                    }
                }
            });
        }
    }
}

    ASM工具类

    /**
 * Asm工具类
 * 
  4. 
 *
 * @author: [email protected]
 * @since: 2021/10/18 11:23
 */
@Slf4j
public class AsmUtil extends ClassLoader{
    public static AsmUtil getInstance() {
        return AsmUtilHolder.instance;
    }
    private static class AsmUtilHolder {
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static AsmUtil
            instance = new AsmUtil();
    }
    /**
     * 添加注解
     * 
  5. 
     * @author [email protected]
     * @date 2021/10/18 11:34
     * @param methods:目标方法
     * @param annotation:注解名称
     * @param clazz:当前类
     * @return: java.lang.Class 添加注解后的class
     */
    public Class addAnntation(List methods,String annotation,Class clazz){
        try {
            String className = clazz.getName();
            log.info("添加注解className:{}",className);
            ClassReader cr = new ClassReader(className);
            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            log.info("添加注解annotation:{}",annotation);
            AsmMethodVisitor mv = new AsmMethodVisitor(Opcodes.ASM4,cw,methods,annotation);
            log.info("添加注解mv:{}",mv);
            cr.accept(mv, 0);
            byte[] code = cw.toByteArray();
            return defineClass(null, code, 0, code.length);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("类:{} 的方法:{},添加注解:{}失败,msg:{}",clazz,methods,annotation,e.getMessage());
        }
        return null;
    }

    class AsmMethodVisitor extends ClassVisitor implements Opcodes {

        private List methods;
        private String annotation;

        public AsmMethodVisitor(int api, ClassVisitor cv,List methods,String annotation) {
            super(api, cv);
            this.methods = methods;
            this.annotation = annotation;
        }

        @Override
        public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
            MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
            if(methods.contains(name)){
                AnnotationVisitor av1 = mv.visitAnnotation(annotation, true);
                av1.visitEnd();
            }
            return mv;
        }
    }
}

2，AST

  1. 简介

    • 抽象语法树（Abstract Syntax Tree, AST）是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的结构，树的每个节点ASTNode都表示源码中的一个结构。抽象语法树就像是java文件的dom模型，比如dom4j通过标签解析出xml文件。AST把java中的各种元素比如类、属性、方法、代码块、注解、注释等等定义成相应的对象，在编译器编译代码的过程中，语法分析器首先通过AST将源码分析成一个语法树，然后再转换成二进制文件。

    • Java的编译过程可以分成三个阶段：

      javac flow
      1. 所有源文件会被解析成语法树。
      2. 调用注解处理器。如果注解处理器产生了新的源文件，新文件也要进行编译。
      3. 最后，语法树会被分析并转化成类文件。

    • 例如：下面一段java代的抽象语法树大概长这样：

      ast.jpg
  • 上图即为语法树，左边树的节点对应右边相同颜色覆盖的代码块。
![ast-seq.png](https://upload-images.jianshu.io/upload_images/23568343-88299a598fe29f01.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

  • 编辑器对代码处理的流程大概是：JavaTXT->词语法分析-> 生成AST ->语义分析 -> 编译字节码

    AST Workflow

  • 通过操作AST，可以达到修改源代码的功能，相比AOP三剑客，他的时机更为提前：

aop.jpg
  • AST操作推荐类库:Rewrite JavaParser

  1. 实战

    生成@Getter @Setter

    首先需要注解类,标明作用的范围和作用的时期，两个类分别对应Lombok的Getter、Setter

    @Target({ElementType.TYPE}) //加在类上的注解
@Retention(RetentionPolicy.SOURCE) //作用于编译期
public @interface Getter {
}
@Target({ElementType.TYPE}) //加在类上的注解
@Retention(RetentionPolicy.SOURCE) //作用于编译期
public @interface Setter {
}

    新建抽象注解处理器需要继承AbstractProcessor，这里使用模板方法模式

    public abstract class MyAbstractProcessor extends AbstractProcessor {
    //语法树
    protected JavacTrees trees;
 
    //构建语法树节点
    protected TreeMaker treeMaker;
 
    //创建标识符的对象
    protected Names names;
 
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.trees = JavacTrees.instance(processingEnv);
        Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
        this.treeMaker = TreeMaker.instance(context);
        this.names = Names.instance(context);
    }
 
    @Override
    public boolean process(Set annotations, RoundEnvironment roundEnv) {
        //获取注解标识的类
        Set set = roundEnv.getElementsAnnotatedWith(getAnnotation());
        //拿到语法树
        set.stream().map(element -> trees.getTree(element)).forEach(jcTree -> jcTree.accept(new TreeTranslator() {
            //拿到类定义
            @Override
            public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                List jcVariableDeclList = List.nil();
                //拿到所有成员变量
                for (JCTree tree : jcClassDecl.defs) {
                    if (tree.getKind().equals(Tree.Kind.VARIABLE)) {
                        JCTree.JCVariableDecl jcVariableDecl = (JCTree.JCVariableDecl) tree;
                        jcVariableDeclList = jcVariableDeclList.append(jcVariableDecl);
                    }
                }
 
                jcVariableDeclList.forEach(jcVariableDecl -> {
                    jcClassDecl.defs = jcClassDecl.defs.prepend(makeMethodDecl(jcVariableDecl));
                });
                super.visitClassDef(jcClassDecl);
            }
        }));
        return true;
    }
 
    /**
     * 创建方法
     * @param jcVariableDecl
     * @return
     */
    public abstract JCTree.JCMethodDecl makeMethodDecl(JCTree.JCVariableDecl jcVariableDecl);
 
    /**
     * 获取何种注解
     * @return
     */
    public abstract Class getAnnotation();
}

    用于处理Setter注解 继承MyAbstractProcessor

    @SupportedAnnotationTypes("com.javacoo.processor.Setter") //注解处理器作用于哪个注解 也可以重写getSupportedAnnotationTypes
@SupportedSourceVersion(SourceVersion.RELEASE_8) //可以处理什么版本 也可以重写getSupportedSourceVersion
public class SetterProcessor extends MyAbstractProcessor {
 
    @Override
    public JCTree.JCMethodDecl makeMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {
        ListBuffer statements = new ListBuffer<>();
        //生成函数体 this.name = name;
        statements.append(treeMaker.Exec(treeMaker.Assign(treeMaker.Select(treeMaker.Ident(names.fromString("this")), jcVariableDecl.getName()),treeMaker.Ident(jcVariableDecl.getName()))));
        JCTree.JCBlock body = treeMaker.Block(0, statements.toList());
        //生成方法
        return treeMaker.MethodDef(
                treeMaker.Modifiers(Flags.PUBLIC), //访问标志
                getNewMethodName(jcVariableDecl.getName()), //名字
                treeMaker.TypeIdent(TypeTag.VOID), //返回类型
                List.nil(), //泛型形参列表
                List.of(getParameters(jcVariableDecl)), //参数列表
                List.nil(), //异常列表
                body, //方法体
                null //默认方法（可能是interface中的那个default）
        );
    }
 
    @Override
    public Class getAnnotation() {
        return Setter.class;
    }
 
    private Name getNewMethodName(Name name) {
        String fieldName = name.toString();
        return names.fromString("set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, name.length()));
    }
 
    private JCTree.JCVariableDecl getParameters(JCTree.JCVariableDecl prototypeJCVariable) {
        return treeMaker.VarDef(
                treeMaker.Modifiers(Flags.PARAMETER), //访问标志
                prototypeJCVariable.name, //名字
                prototypeJCVariable.vartype, //类型
                null //初始化语句
        );
    }
}

    用于处理Getter注解 继承MyAbstractProcessor

    @SupportedAnnotationTypes("com.javacoo.processor.Getter") //注解处理器作用于哪个注解 也可以重写getSupportedAnnotationTypes
@SupportedSourceVersion(SourceVersion.RELEASE_8) //可以处理什么版本 也可以重写getSupportedSourceVersion
public class GetterProcessor extends MyAbstractProcessor {
 
    @Override
    public JCTree.JCMethodDecl makeMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {
        ListBuffer statements = new ListBuffer<>();
        //生成函数体 return this.字段名
        statements.append(treeMaker.Return(treeMaker.Select(treeMaker.Ident(names.fromString("this")), jcVariableDecl.getName())));
        JCTree.JCBlock body = treeMaker.Block(0, statements.toList());
        //生成方法
        return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC), getNewMethodName(jcVariableDecl.getName()), jcVariableDecl.vartype, List.nil(), List.nil(), List.nil(), body, null);
    }
 
    @Override
    public Class getAnnotation() {
        return Getter.class;
    }
 
    private Name getNewMethodName(Name name) {
        String fieldName = name.toString();
        return names.fromString("get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, name.length()));
    }
}

    编译现有类

    javac -cp $JAVA_HOME/lib/tools.jar *.java -d .

    新建一个测试类 IDEA中由于找不到get set方法会报错，可以忽略

    @Getter
@Setter
public class UserInfo {
    private String userId;
 
    private String userName;
 
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId("001");
        userInfo.setUserName("得物");
        System.out.println("id = "+userInfo.getUserId()+" name = "+userInfo.getUserName());
    }
}

    接着编译,多个处理器用逗号分隔

    javac -processor com.ingxx.processor.GetterProcessor,com.ingxx.processor.SetterProcessor UserInfo.java -d .

3，编译期注解处理器

  1. 简介

    • Java编译期注解处理器，Annotation Processing Tool，简称APT，是Java提供给开发者的用于在编译期对注解进行处理的一系列API，这类API的使用被广泛的用于各种框架，如dubbo,lombok等。
    • Java的注解处理一般分为2种，最常见也是最显式化的就是Spring以及Spring Boot的注解实现了，在运行期容器启动时，根据注解扫描类，并加载到Spring容器中。而另一种就是本文主要介绍的注解处理，即编译期注解处理器，用于在编译期通过JDK提供的API，对Java文件编译前生成的Java语法树进行处理，实现想要的功能。

  2. 实战
    使用基本流程

    • 定义编译期的注解

      @Target({ElementType.METHOD})//加在方法上的注解
@Retention(RetentionPolicy.SOURCE)//作用于编译期
public @interface EventHandler {
}

  • 利用JSR269 api(Pluggable Annotation Processing API )创建编译期的注解处理器

    @AutoService(Processor.class)//利用google AutoService自动在META-INF/services/生成接口的类名
@SupportedSourceVersion(SourceVersion.RELEASE_8)//可以处理什么版本 也可以重写getSupportedSourceVersion
@SupportedAnnotationTypes("com.javacoo.event.client.annotation.EventHandler")//注解处理器作用于哪个注解 也可以重写getSupportedAnnotationTypes
public class EventHandlerProcessor extends AbstractProcessor {
    .....
}

  • 利用tools.jar的javac api处理AST(抽象语法树)

    处理过程

![ast-pro.png](https://upload-images.jianshu.io/upload_images/23568343-08963e136c18b86a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


 处理前

 ![ast-before.png](https://upload-images.jianshu.io/upload_images/23568343-df513199d8a4001a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


 处理后
ast-after.png
  • 将功能注册进jar包

4，SPI

  • SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。
  • https://www.jianshu.com/p/cc1f08c8aed6

实施步骤

1，新建limit-spring-boot-starter工程
  • 工程结构
pj.png
  • 类结构图
EventAutoConfiguration.png

  • 项目结构

    event-spring-boot-starter
 └── src
    ├── main  
    │ ├── java  
    │ │   └── com.javacoo
    │ │   ├────── event
    │ │   │         ├──────client
    │   │   │         │         ├── api
    │   │   │         │         │    └── EventHelper 事件帮助类接口
    │   │   │         │         ├── annotation
    │   │   │         │         │    └── EventHandler 事件处理器注解
    │   │   │         │         │    └── MySubscribe 事件订阅注解
    │   │   │         │         ├── config
    │   │   │         │         │    └── EventConfig 事件参数配置
    │   │   │         │         ├── context
    │   │   │         │         │    └── EventContext 事件上下文
    │   │   │         │         ├── exception
    │   │   │         │         │    └── LimitException 限流异常
    │   │   │         │         ├── util
    │   │   │         │         │    └── AsmUtil Asm工具类
    │   │   │         │         ├── support
    │   │   │         │         │    ├── ApplicationContextProvider 抽象限流处理器
    │   │   │         │         │    ├── BaseEventRegister 限流注解处理器
    │   │   │         │         │    ├── EventMetaData 限流配置处理器
    │   │   │         │         └──  ├── asm
    │   │   │         │              │    └── AsmEventRegister ASM实现事件注册
    │   │   │         │              └── ast
    │   │   │         │                   ├── EventHandlerProcessor EventHandler注解处理器
    │   │   │         │                   └── AstEventRegister AST实现事件注册
    │   │   │         │         └── internal 接口内部实现
    │   │   │         │              └── guava
    │   │   │         │                   └── EventBusEventHelper EventHelper接口实现类
    │ │   │         └──────starter
    │   │   │                   ├── EventAutoConfiguration 自动配置类
    │   │   │                   └── EventHolder 事件处理器对象持有者
    │ └── resource  
    │     ├── META-INF
    │             ├── spring.factories
    │             └── ext
    │                └── internal
    │                        └── com.javacoo.event.client.api.EventHelper
    └── test  测试
2，基于SPI思想设计扩展接口

  • 事件帮助类接口->com.javacoo.event.client.api.EventHelper

    /**
 * 事件帮助类接口
 * 
  • 
 *
 * @author: [email protected]
 * @since: 2021/10/15 11:16
 */
@Spi(EventConfig.DEFAULT_IMPL)
public interface EventHelper {
    /**
     * 发布同步事件
     * 
  • 
     * @author [email protected]
     * @date 2021/10/15 11:18
     * @param eventObject: 事件对象
     * @return: void
     */
    void post(Object eventObject);
    /**
     * 发布异步事件
     * 
  • 
     * @author [email protected]
     * @date 2021/10/15 11:19
     * @param eventObject:事件对象
     * @return: void
     */
    void postAsync(Object eventObject);
    /**
     * 发布延迟时间
     * 
  • 
     * @author [email protected]
     * @date 2021/10/15 11:20
     * @param eventObject: 事件对象
     * @param time: 延迟时间,单位:毫秒
     * @return: void
     */
    void postDelay(Object eventObject, long time);

    /**
     * 注册监听对象
     * 
    说明:
    
     * 
  • 
     * @param listenerObject: 监听对象
     * @author [email protected]
     * @date 2021/10/15 18:01
     */
    void register(Object listenerObject);
    /**
     * 注销监听对象
     * 
    说明:
    
     * 
  • 
     * @param listenerObject: 监听对象
     * @author [email protected]
     * @date 2021/10/15 18:02
     */
    void unRegister(Object listenerObject);
}
3，注解

  • 事件处理器注解：com.javacoo.event.client.annotation.EventHandler

    /**
 * 事件处理器注解
 * 
  • 
 *
 * @author: [email protected]
 * @since: 2021/10/19 10:40
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.SOURCE)
public @interface EventHandler {
  /**
   * 当前监听方法是否线程安全
   * 
  • 如果是线程安全的,则不会同步订阅者对象
    • 
   * @author [email protected]
   * @date 2021/11/1 10:35
   * @return: boolean 默认false
   */
  boolean threadSafe() default false;
}

  • 事件订阅注解：com.javacoo.event.client.annotation.MySubscribe

    /**
 * 事件订阅注解
 * 
  • 
 * @author [email protected]
 * @date 2021/10/15 22:39
 */
@Documented
@Inherited
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MySubscribe {
}
4，配置

  • 事件参数配置：com.javacoo.event.client.config.EventConfig

    /**
 * 事件参数配置
 * 
    说明:
    
 * @author duanyong
 * @date 2021/3/4 15:15
 */
@ConfigurationProperties(prefix = EventConfig.PREFIX)
public class EventConfig {
    /** 前缀 */
    public static final String PREFIX = "event";
    /** lock是否可用,默认值*/
    public static final String ENABLED = "enabled";
    /** 默认实现:,默认值*/
    public static final String DEFAULT_IMPL= "default";
    /** event是否可用*/
    private String enabled = ENABLED;
    /**实现*/
    private String impl = DEFAULT_IMPL;

    public String getEnabled() {
        return enabled;
    }

    public void setEnabled(String enabled) {
        this.enabled = enabled;
    }

    public String getImpl() {
        return impl;
    }

    public void setImpl(String impl) {
        this.impl = impl;
    }
}
5，上下文

  • 事件上下文：com.javacoo.event.client.context.EventContext

    /**
 * 事件上下文
 * 
  • 
 *
 * @author: [email protected]
 * @since: 2021/10/21 8:58
 */
public class EventContext {
    /**
     * 事件监听对象对象集合
     */
    private Set listeningObjects = new HashSet<>();

    public Set getListeningObjects() {
        return listeningObjects;
    }

    public void addListeningObject(Object listeningObject){
        listeningObjects.add(listeningObject);
    }

}
 


    6，内部实现
    

      

    •  
      EventHelper接口实现：
       
      /**
 * EventHelper接口实现类
 * 
      说明:
      
 * 
    • 基于google eventbus
      • 
 * @author [email protected]
 * @date 2021/10/15 17:38
 */
@Slf4j
public class EventBusEventHelper implements EventHelper {
    /**
     * EventBus
     */
    private static EventBus eventBus = null;
    /**
     * AsyncEventBus
     */
    private static AsyncEventBus asyncEventBus = null;
    /**
     * DelayQueue
     */
    private static DelayQueue delayQueue = null;
    /**
     * 延迟时间执行器
     */
    private static TaskExecutor delayTaskExecutor = null;

    public EventBusEventHelper() {
        delayTaskExecutor = new TaskExecutor() {
            ExecutorService executorService = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors(),
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(), Executors.defaultThreadFactory());
            @Override
            public void execute(Runnable task) {
                executorService.execute(task);
            }
        };
        eventBus = new EventBus();
        asyncEventBus = new AsyncEventBus(delayTaskExecutor);
        delayQueue = new DelayQueue<>();

       
      • 

    

    //注册DeadEvent监听
     eventBus.register(new Object() {
     @Subscribe
     public void lister(DeadEvent event) {
     log.error("{}发布的{}事件未找到监听对象", event.getSource().getClass(), event.getEvent());
     }
     });
     asyncEventBus.register(new Object() {
     @Subscribe
     public void lister(DeadEvent event) {
     log.error("{}发布的{}事件未找到监听对象", event.getSource().getClass(), event.getEvent());
     }
     });
     }
     /**
     * 发布同步事件
     * 

  •  *
     * @param eventObject : 事件对象
     * @author [email protected]
     * @date 2021/10/15 11:18
     * @return: void
     */
     @Override
     public void post(Object eventObject) {
     log.info("发布同步事件:{}",eventObject);
     eventBus.post(eventObject);
     }
    

      /**
   * 发布异步事件
   * 
  • 
   *
   * @param eventObject :事件对象
   * @author [email protected]
   * @date 2021/10/15 11:19
   * @return: void
   */
  @Override
  public void postAsync(Object eventObject) {
      log.info("发布异步事件:{}",eventObject);
      asyncEventBus.post(eventObject);
  }

  /**
   * 发布延迟时间
   * 
  • 
   *
   * @param eventObject : 事件对象
   * @param time        : 延迟时间,单位:毫秒
   * @author [email protected]
   * @date 2021/10/15 11:20
   * @return: void
   */
  @Override
  public void postDelay(Object eventObject, long time) {
      log.info("延迟执行事件->入延迟队列:{}",eventObject);
      //入延迟队列
      delayQueue.put(new EventBusEventHelper.EventItem(eventObject, time));
      //执行
      delayTaskExecutor.execute(()->execute());
  }

  /**
   * 注册监听对象
   * 
    说明:
    
   * 
  • 
   *
   * @param listenerObject : 监听对象
   * @author [email protected]
   * @date 2021/10/15 18:01
   */
  @Override
  public void register(Object listenerObject) {
      log.info("注册监听对象:{}",listenerObject);
      asyncEventBus.register(listenerObject);
      eventBus.register(listenerObject);
  }

  /**
   * 注销监听对象
   * 
    说明:
    
   * 
  • 
   *
   * @param listenerObject : 事件元数据
   * @author [email protected]
   * @date 2021/10/15 18:02
   */
  @Override
  public void unRegister(Object listenerObject) {
      log.info("注销监听对象:{}",listenerObject.toString());
      asyncEventBus.unregister(listenerObject);
      eventBus.unregister(listenerObject);
  }

  /**
   * 异步执行
   * 
  • 
   * @author [email protected]
   * @date 2021/7/8 10:08
   * @return: void
   */
  private void execute(){
      try {
          // 使用DelayQueue的take方法获取当前队列里的元素(take方法是阻塞方法，如果队列里有值则取出，否则一直阻塞)
          asyncEventBus.post(delayQueue.take().getEventObject());
          log.info("延迟执行事件");
      }catch (InterruptedException interruptedException){
          log.info("延迟执行事件异常:",interruptedException);
      }
  }

  /**
   * 事件项
   * 
  • 
   * @author [email protected]
   * @date 2021/7/8 9:06
   */
  class EventItem implements Delayed {
      /** 触发时间:单位 毫秒 */
      private long time;
      /** 事件对象 */
      private T eventObject;

      public EventItem(T eventObject, long time) {
          super();
          // 将传入的时间转换为超时的时刻
          this.time = TimeUnit.NANOSECONDS.convert(time, TimeUnit.MILLISECONDS)
                  + System.nanoTime();
          this.eventObject = eventObject;
      }

      public long getTime() {
          return time;
      }

      public T getEventObject() {
          return eventObject;
      }

      @Override
      public long getDelay(TimeUnit unit) {
          // 剩余时间= 到期时间-当前系统时间，系统一般是纳秒级的，所以这里做一次转换
          return unit.convert(time- System.nanoTime(), TimeUnit.NANOSECONDS);
      }

      @Override
      public int compareTo(Delayed o) {
          // 剩余时间-当前传入的时间= 实际剩余时间（单位纳秒）
          long d = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
          // 根据剩余时间判断等于0 返回1 不等于0
          // 有可能大于0 有可能小于0  大于0返回1  小于返回-1
          return (d == 0) ? 0 : ((d > 0) ? 1 : -1);
      }

      @Override
      public String toString() {
          return "EventItem{" +
                  "time=" + time +
                  ", eventObject='" + eventObject + '\'' +
                  '}';
      }
  }

    

    }
    

    
##### 7，支持类

- ApplicationContextProvider

```java
/**
 * 获取applicationContext
 * 
    说明:
    
 * 
  • 
 * @author [email protected]
 * @date 2021/10/16 9:28
 */
@Slf4j
public class ApplicationContextProvider {
    private static ApplicationContext ctx = null;  
    public static void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        log.info("获取applicationContext:{}",applicationContext);
        ctx = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return ctx;
    }

    public static  T getBean(Class type) {
        try {
            return Optional.ofNullable(ctx).orElseThrow(() -> new IllegalStateException("non in spring application context.")).getBean(type);
        } catch (Exception e) {
            return null;
        }
    }
    public static Object getBean(String beanName) {
        try {
            return Optional.ofNullable(ctx).orElseThrow(() -> new IllegalStateException("non in spring application context.")).getBean(beanName);
        } catch (Exception e) {
            return null;
        }
    }
    public static void registerBean(String beanName,Class beanClass){
        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) ctx;
        GenericBeanDefinition beanDefinition = (GenericBeanDefinition)configurableApplicationContext.getBeanFactory().getBeanDefinition(beanName);
        log.info("注册bean,getBeanClassName:{}",beanDefinition.getBeanClassName());
        beanDefinition.setBeanClass(beanClass);
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
        beanFactory.registerBeanDefinition(beanName,beanDefinition);
        log.info("注册bean:{}",beanName);
    }
    public  static void removeBean(String beanName){
        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) ctx;
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
        beanFactory.removeBeanDefinition(beanName);
        log.info("删除bean:{}",beanName);
    }

}


    

      

    •  
      事件注册基类
       
      /**
 * 事件注册基类
 * 
      说明:
      
 * 
    • 
 *
 * @author [email protected]
 * @date 2021/10/20 22:02
 */
@Slf4j
public class BaseEventRegister {
    /**
     * 获取所有注解 类
     * 
      说明:
      
     * 
    • 在所有注解 org.springframework.stereotype.Service 类中查找方法包含指定注解
      • 
     * @author [email protected]
     * @param annClass 类注解class
     * @param mAnnClass 方法注解class
     * @date 2021/10/20 22:02
     * @retuen Set
     */
    protected Set getEventMetaDatas(Class annClass,Class mAnnClass){
        //查找Service
        Map serviceMap = ApplicationContextProvider.getApplicationContext().getBeansWithAnnotation(annClass);
        log.info("事件注册数量:{},对象:{}",serviceMap.size(),serviceMap);
        Set eventMetaDatas = new HashSet<>();
        for (Map.Entry entry : serviceMap.entrySet()) {
            Class entryClass = AopUtils.getTargetClass(entry.getValue());
            //获取注解所在方法 public方法
            List methods = Arrays.stream(entryClass.getDeclaredMethods())
                    .filter(method -> Modifier.isPublic(method.getModifiers()))//获取本类 public方法
                    .filter(method->method.isAnnotationPresent(mAnnClass))//找到注解所在方法
                    .collect(Collectors.toList());
            if(methods.isEmpty()){
                continue;
            }
            eventMetaDatas.add(EventMetaData.builder().beanName(entry.getKey()).targetMethods(methods).targetClass(entryClass).build());
        }
        return eventMetaDatas;
    }
}


       
      • 

    •  
      事件元数据
       
      /**
 * 事件元数据
 * 
    • 
 *
 * @author: [email protected]
 * @since: 2021/10/18 11:42
 */
@Data
@Builder
public class EventMetaData {
    /**
     * 目标监听对象名称
     */
    private String beanName;
    /**
     * 目标监听对象class
     */
    private Class targetClass;
    /**
     * 目标方法
     */
    private List targetMethods;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EventMetaData that = (EventMetaData) o;
        return Objects.equals(beanName, that.beanName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(beanName);
    }
}

       
      • 

    •  
      ASM实现事件注册
       
      /**
 * ASM实现事件注册
 * 
      说明:Asm实现
      
 * 
    • 
 *
 * @author [email protected]
 * @date 2021/10/16 7:50
 */
@Slf4j
@Configuration
public class AsmEventRegister extends BaseEventRegister implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //设置applicationContext
        ApplicationContextProvider.setApplicationContext(applicationContext);
        //查找Service
        Set eventMetaDatas = getEventMetaDatas(Service.class, MySubscribe.class);

        if(EventHolder.getEventHelper().isPresent() & !eventMetaDatas.isEmpty()){
            eventMetaDatas.forEach(eventMetaData -> {
                List methodNames = eventMetaData.getTargetMethods().stream().map(method -> method.getName()).collect(
                    Collectors.toList());
                Class newCalss = AsmUtil.getInstance().addAnntation(methodNames, "Lcom/google/common/eventbus/Subscribe;", eventMetaData.getTargetClass());
                if(newCalss != null){
                    log.info("事件元数据:{}",eventMetaData);
                    ApplicationContextProvider.registerBean(eventMetaData.getBeanName(),newCalss);
                    Object newObject =ApplicationContextProvider.getBean(eventMetaData.getBeanName());
                    if(newObject != null){
                        log.info("注册监听对象:{}",newObject);
                        EventHolder.getEventHelper().get().register(newObject);
                    }
                }
            });
        }
    }
}

       
      • 

    •  
      AST实现事件注册
       
      /**
 * AST实现事件注册
 * 
      说明:AST
      
 * 
    • 
 *
 * @author [email protected]
 * @date 2021/10/16 7:50
 */
@Slf4j
@Component
public class AstEventRegister extends BaseEventRegister implements ApplicationListener {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) {
            //设置applicationContext
            ApplicationContextProvider.setApplicationContext(event.getApplicationContext());
            //注册事件监听对象
            EventHolder.getEventContext().getListeningObjects().forEach(o -> EventHolder.getEventHelper().get().register(o));
        }
    }
}


       
      • 

    • EventHandler注解处理器
      • 

    

     /**
 * EventHandler注解处理器
 * 
  • 
 *
 * @author: [email protected]
 * @since: 2021/10/19 10:42
 */
@Slf4j
@AutoService(Processor.class)
@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes("com.javacoo.event.client.annotation.EventHandler")
public class EventHandlerProcessor extends AbstractProcessor {
    /**
     * spring注解包
     */
    private static final String SPRING_ANNONATION_PACKAGE = "org.springframework.stereotype";
    /**
     * 打印log
     */
    private Messager messager;
    /**
     * 抽象语法树
     */
    private JavacTrees trees;
    /**
     * 封装了创建AST节点的一些方法
     */
    private TreeMaker treeMaker;
    /**
     * 提供了创建标识符的一些方法
     */
    private Names names;
    private JavacElements elementUtils;
    // 初始化方法
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.messager = processingEnv.getMessager();
        this.trees = JavacTrees.instance(processingEnv);
        Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
        this.treeMaker = TreeMaker.instance(context);
        this.names = Names.instance(context);
        this.elementUtils = (JavacElements) processingEnv.getElementUtils();
    }

    // 真正处理注解的方法
    @Override
    public synchronized boolean process(Set annotations, RoundEnvironment roundEnv) {
        printLog("获取所有注解:{}",annotations.toString());
        //包含注解的类集合
        Set classElements = new HashSet<>();
        // 获取所有包含EventHandler注解的Element
        Set set = roundEnv.getElementsAnnotatedWith(EventHandler.class);
        //处理所有包含EventHandler注解的Element,添加注解并导入包
        set.forEach(element -> {
          JCTree.JCMethodDecl jcMethodDecl = (JCTree.JCMethodDecl) elementUtils.getTree(element);
            //获取注解
            EventHandler eventHandler = element.getAnnotation(EventHandler.class);
            //如果是线程安全的 则添加AllowConcurrentEvents注解
            if(eventHandler != null && eventHandler.threadSafe()){
                //添加AllowConcurrentEvents注解
                addMethodAnnotation(jcMethodDecl,"com.google.common.eventbus.AllowConcurrentEvents");
                //导入包
                addConsumerImport(element,"com.google.common.eventbus","AllowConcurrentEvents");
            }
            //添加Subscribe注解
            addMethodAnnotation(jcMethodDecl,"com.google.common.eventbus.Subscribe");
            //导入包
            addConsumerImport(element,"com.google.common.eventbus", "Subscribe");
            //记录注解所在类
            classElements.add(element.getEnclosingElement());
            printLog("包含注解所在类:{}",element.getEnclosingElement().getSimpleName());
        });
        //处理注解所在类添加初始化方法
        classElements.forEach(element -> {
            addClassAnnotation(element,"org.springframework.stereotype.Component");
            //导入包
            addConsumerImport(element,"com.javacoo.event.client.starter","EventHolder");
            //构建方法
            JCTree.JCMethodDecl jcMethodDecl = makeEventListeningRegisterMethodDecl();
            //添加注解
            addMethodAnnotation(jcMethodDecl,"javax.annotation.PostConstruct");
            //添加类方法
            addClassMethod(element,jcMethodDecl);
        });
        return true;
    }
    /**
     * 添加类方法
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 11:36
     * @param element: 类element对象
     * @param jcMethodDecl: 方法
     * @return: void
     */
    private void addClassMethod(Element element,JCTree.JCMethodDecl jcMethodDecl) {
        printLog("添加类方法:{}",jcMethodDecl.name);
        JCTree jcTree = trees.getTree(element);
        //获取源注解的参数
        jcTree.accept(new TreeTranslator(){
            @Override
            public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                jcClassDecl.defs=jcClassDecl.defs.append(jcMethodDecl);
                super.visitClassDef(jcClassDecl);
            }
        });
    }
    /**
     * 添加方法注解
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 11:38
     * @param jcMethodDecl: 方法
     * @param annotaionName: 注解名称
     * @return: void
     */
    private void addMethodAnnotation(JCTree.JCMethodDecl jcMethodDecl,String annotaionName){
        printLog("添加方法注解:{}",annotaionName);
        JCTree.JCAnnotation jcAnnotation = makeAnnotation(annotaionName, List.nil());
        jcMethodDecl.mods.annotations = jcMethodDecl.mods.annotations.append(jcAnnotation);
    }
    /**
     * 添加类注解
     * 
    说明:
    
     * 
  • 
     * @author [email protected]
     * @date 2021/10/27 22:05
     */
    private void addClassAnnotation(Element element,String annotaionName) {
        JCTree jcTree = trees.getTree(element);
        //获取源注解的参数
        jcTree.accept(new TreeTranslator(){
            @Override
            public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                //是否包含spring注解
                boolean incAnno = jcClassDecl.mods.annotations.stream().anyMatch(annotation ->annotation.type.toString().contains(SPRING_ANNONATION_PACKAGE));
                //boolean incAnno = jcClassDecl.mods.annotations.stream().anyMatch(annotation ->annotation.type.toString().equals(jcAnnotation.annotationType.toString()));
                printLog("是否包含待添加注解:{}",incAnno);
                if(incAnno){
                   return;
                }
                JCTree.JCAnnotation jcAnnotation = makeAnnotation(annotaionName, List.nil());
                printLog("类添加注解:{}",jcAnnotation.toString());
                jcClassDecl.mods.annotations = jcClassDecl.mods.annotations.append(jcAnnotation);
                jcClassDecl.mods.annotations.forEach(e -> {
                    printLog("当前类包含注解:{}",e.toString());
                });
                super.visitClassDef(jcClassDecl);
            }
        });
    }

    /**
     * 日志打印
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 11:38
     * @param ss: 信息
     * @param args: 参数
     * @return: void
     */
    private void printLog(String ss,Object... args){
        if(args.length>0) {
            ss = ss.replace("{}", "%s");
            String logs = String.format(ss, args);
            messager.printMessage(Diagnostic.Kind.NOTE, logs);
        }else{
            messager.printMessage(Diagnostic.Kind.NOTE, ss);
        }
    }
    /**
     * 构建事件监听对象注册方法
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 9:19
     * @return: com.sun.tools.javac.tree.JCTree.JCMethodDecl
     */
    private JCTree.JCMethodDecl makeEventListeningRegisterMethodDecl() {
        printLog("构建事件监听对象注册方法");
        ListBuffer statements = new ListBuffer<>();
        statements.append(treeMaker.Exec(
                    treeMaker.Apply(
                        List.nil(),
                        treeMaker.Select(
                            treeMaker.Ident(
                                elementUtils.getName("EventHolder")
                            ),
                            elementUtils.getName("register")
                        ),
                        List.of(
                            treeMaker.Ident(names.fromString("this"))
                        )
                    )
                ));
        JCTree.JCBlock body = treeMaker.Block(0, statements.toList());
        return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC), names.fromString("eventListeningRegister"), treeMaker.Type(new Type.JCVoidType()), List.nil(), List.nil(), List.nil(), body, null);
    }
    /**
     * 构建注解对象
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 11:39
     * @param annotaionName:注解名称
     * @param args: 注解参数
     * @return: com.sun.tools.javac.tree.JCTree.JCAnnotation
     */
    private JCTree.JCAnnotation makeAnnotation(String annotaionName, List args) {
        JCTree.JCExpression expression = chainDots(annotaionName.split("\\."));
        JCTree.JCAnnotation jcAnnotation=treeMaker.Annotation(expression, args);
        return jcAnnotation;
    }
    /**
     * 构建依赖包导入
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 11:40
     * @param packageName:
     * @param className:
     * @return: com.sun.tools.javac.tree.JCTree.JCImport
     */
    private JCTree.JCImport buildImport(String packageName, String className) {
        JCTree.JCIdent ident = treeMaker.Ident(names.fromString(packageName));
        JCTree.JCImport jcImport = treeMaker.Import(treeMaker.Select(ident, names.fromString(className)), false);
        printLog("构建依赖包导入:{}",jcImport.toString());
        return jcImport;
    }
    /**
     * 导入依赖包
     * 
  • 
     * @author [email protected]
     * @date 2021/10/21 11:40
     * @param element: 类element对象
     * @return: void
     */
    private void addConsumerImport(Element element,String packageName, String className) {
        TreePath treePath = trees.getPath(element);
        JCTree.JCCompilationUnit jccu = (JCTree.JCCompilationUnit) treePath.getCompilationUnit();
        java.util.List trees = new ArrayList<>();
        trees.addAll(jccu.defs);
        JCTree.JCImport custImport = buildImport(packageName, className);
        if (!trees.contains(custImport)) {
            trees.add(0,custImport);
        }
        jccu.defs=List.from(trees);
    }
    private JCTree.JCExpression chainDots(String... elems) {
        assert elems != null;
        JCTree.JCExpression e = null;
        for (int i = 0 ; i < elems.length ; i++) {
            e = e == null ? treeMaker.Ident(names.fromString(elems[i])) : treeMaker.Select(e, names.fromString(elems[i]));
        }
        assert e != null;
        return e;
    }
}
  

    

    9，自动配置
    

      

    •  
      自动配置类
       
      /**
 * 自动配置类
 * 
    • 
 * @author duanyong
 * @date 2021/10/15 22:50
 */
@Slf4j
@Configuration                                                                                                                              
@EnableConfigurationProperties(value = EventConfig.class)
@ConditionalOnClass(EventConfig.class)
@ConditionalOnProperty(prefix = EventConfig.PREFIX, value = EventConfig.ENABLED, matchIfMissing = true)
public class EventAutoConfiguration {
  @Autowired
    private EventConfig eventConfig;
  @Bean
  @ConditionalOnMissingBean(EventHelper.class)
  public EventHelper createEventHelper() {
        log.info("初始化事件处理器,实现类名称:{}",eventConfig.getImpl());
        EventHolder.eventHelper = ExtensionLoader.getExtensionLoader(EventHelper.class).getExtension(eventConfig.getImpl());
        log.info("初始化事件处理器成功,实现类:{}",EventHolder.eventHelper);
       return EventHolder.eventHelper;
  }
}


       
      • 

    •  
      事件对象持有者
       
      /**
 * 事件对象持有者
 * 
    • 
 *
 * @author: duanyong
 * @since: 2021/10/15 22:56
 */
@Slf4j
public class EventHolder {
    /** 事件上下文*/
    static EventContext eventContext = new EventContext();
    /** 事件帮助类接口对象*/
    static EventHelper eventHelper;
    /**
     * 获取EventHelper
     * 
    • 
     * @author [email protected]
     * @date 2021/10/21 9:03
     * @return: java.util.Optional
     */
    public static Optional getEventHelper() {
        return Optional.ofNullable(eventHelper);
    }
    /**
     * 注册事件监听对象
     * 
    • 这里只是将监听对象存入上下文,待组件初始化完成才注册
      • 
     * @author [email protected]
     * @date 2021/10/21 9:05
     * @param listeningObject:
     * @return: void
     */
    public static void register(Object listeningObject){
        log.info("注册事件监听对象:{}",listeningObject);
        eventContext.addListeningObject(listeningObject);
    }
    /**
     * 获取EventContext
     * 
    • 
     * @author [email protected]
     * @date 2021/10/21 11:31
     * @return: com.javacoo.event.client.context.EventContext
     */
    public static EventContext getEventContext(){
        return eventContext;
    }

}

       
      • 

    

    8，资源文件
    

      

    •  
      spring.factories
       
      org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.javacoo.event.client.support.asm.AsmEventRegister,\
  com.javacoo.event.client.support.ast.AstEventRegister,\
  com.javacoo.event.client.starter.EventAutoConfiguration


       
      • 

    •  
      com.javacoo.event.client.api.EventHelper
       
      default=com.javacoo.event.client.internal.guava.EventBusEventHelper

       
      • 

    

    问题及局限性
    

    问题
    

      

    •  
      ASM方式实现时遇到cglib代理会出现异常情况。
       
      局限性
       
      • 

    • 不支持事件持久化。
      • 

    • 不支持发布异步顺序事件。
      • 

    • 该组件未经过生产验证，仅供学习参考，如需用于生产，请谨慎，并多测试。
      • 

    

    一些信息
    

    路漫漫其修远兮,吾将上下而求索
码云：https://gitee.com/javacoo
QQ：164863067
作者/微信：javacoo
邮箱：[email protected]

    






    



    


    


    




    

    你可能感兴趣的:(事件处理工具组件)
    

    

    

      

    • QQ群采集助手，精准引流必备神器
2401_87347160
其他经验分享

      功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
      

      • 

    • element实现动态路由+面包屑
软件技术NINI
vue案例vue.js前端

      el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
      

      • 

    • 理解Gunicorn：Python WSGI服务器的基石
范范0825
ipythonlinux运维

      理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
      

      • 

    • Google earth studio 简介
陟彼高冈yu
旅游

      GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
      

      • 

    • 直返最高等级与直返APP：无需邀请码的返利新体验
古楼

      随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
      

      • 

    • 2020-04-12每天三百字之连接与替代
冷眼看潮

      不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
      

      • 

    • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
nseejrukjhad
langchaineasyui前端python

      #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
      

      • 

    • 利用Requests Toolkit轻松完成HTTP请求
nseejrukjhad
http网络协议网络python

      RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
      

      • 

    • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
nseejrukjhad
数据库python

      深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
      

      • 

    • 利用LangChain的StackExchange组件实现智能问答系统
nseejrukjhad
langchainmicrosoft数据库python

      利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
      

      • 

    • 在一台Ubuntu计算机上构建Hyperledger Fabric网络
落叶无声9
区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric

      在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
      

      • 

    • GitHub上克隆项目
bigbig猩猩
github

      从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
      

      • 

    • 【目标检测数据集】卡车数据集1073张VOC+YOLO格式
熬夜写代码的平头哥∰
目标检测YOLO人工智能

      数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：1073标注数量(xml文件个数)：1073标注数量(txt文件个数)：1073标注类别数：1标注类别名称:["truck"]每个类别标注的框数：truck框数=1120总框数：1120使用标注工具：labelImg标注
      

      • 

    • 人工智能时代，程序员如何保持核心竞争力？
jmoych
人工智能

      随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
      

      • 

    • pyecharts——绘制柱形图折线图
2224070247
信息可视化pythonjava数据可视化

      一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
      

      • 

    • 钢筋长度超限检测检数据集VOC+YOLO格式215张1类别
futureflsl
数据集YOLO深度学习机器学习

      数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：215标注数量(xml文件个数)：215标注数量(txt文件个数)：215标注类别数：1标注类别名称:["iron"]每个类别标注的框数：iron框数=215总框数：215使用标注工具：labelImg标注规则：对类别进
      

      • 

    • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片
诚芯微科技
社交电子

      CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
      

      • 

    • Python 实现图片裁剪（附代码） | Python工具
剑客阿良_ALiang

      前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
      

      • 

    • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
算法大师
华为od面试python算法前端

      华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
      

      • 

    • Python爬虫解析工具之xpath使用详解
eqa11
python爬虫开发语言

      文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
      

      • 

    • mac电脑命令行获取电量
小米人er
我的博客macos命令行

      在macOS上，有几个命令行工具可以用来获取电量信息，最常用的是pmset命令。你可以通过以下方式来查看电池状态和电量信息：查看电池状态：pmset-gbatt这个命令会返回类似下面的输出：Nowdrawingfrom'BatteryPower'-InternalBattery-0(id=1234567)95%;discharging;4:02remainingpresent:true输出中包括电
      

      • 

    • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
算法大师
华为od面试python

      华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
      

      • 

    • 摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发
诚芯微科技
社交电子

      长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
      

      • 

    • 如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析
北京云巴巴信息技术有限公司
产品经理需求分析

      在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
      

      • 

    • Python开发常用的三方模块如下：
换个网名有点难
python开发语言

      Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
      

      • 

    • ES聚合分析原理与代码实例讲解
光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由

      ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
      

      • 

    • Python实现简单的机器学习算法
master_chenchengg
pythonpython办公效率python开发IT

      Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
      

      • 

    • JVM、JRE和 JDK：理解Java开发的三大核心组件
Y雨何时停T
Javajava

      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      

      • 

    • 一次冒险
追梦少年_4509

      每个人应该都会经历很多冒险，这样你才能变得坚强起来，变得勇敢起来，冒险就是用来磨练自己，勇气的工具，接下来就给大家说说，我经历过的最吓人的冒险。2016年的夏天我和大爷大娘一起去北地捉知了我们边走边找，我负责拿着罐子大娘拿了一个电灯四处照，大爷就拿着一个棍子负责把知了，弄下来我们边走边捉，一会儿罐子就满了，就在我四处看分神的时候看见了一个知了接着我叫大爷大娘来拿知了我一看旁边没有人，我的心里十分害
      

      • 

    • 视频号买1000个粉多少钱?视频号可以购买粉丝吗？开橱窗需要多少粉？
爱吃菠萝的鱼

      在视频号的发展初期，很多人都认为，视频号可以通过购买粉丝来提升用户质量。而这个说法，在我们使用视频号的过程中，发现了它是可以购买粉丝的。但是我们要知道，视频号的本质，是一款社交工具。而不是一个私域流量池。而很多人在做私域流量池的时候，就想着怎么通过购买粉丝来提升用户质量。但我觉得你真的是想多了。视频号涨粉咨询号码：1776206920517753965895视频号粉丝1000有什么好处1、视频号粉
      

      • 

    • java封装继承多态等
麦田的设计者
javaeclipsejvmcencapsulatopn

             最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。
    1、final关键字
      译为：最终的
       &
      

      • 

    • F5与集群的区别
bijian1013
weblogic集群F5

              http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。
        F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
      

      • 

    • LeetCode[Math] - #7 Reverse Integer
Cwind
java题解MathLeetCodeAlgorithm

      原题链接：#7 Reverse Integer
 
要求：
按位反转输入的数字
例1： 输入 x = 123, 返回 321
例2： 输入 x = -123, 返回 -321
 
难度：简单
 
分析：
对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
      

      • 

    • BufferedOutputStream
周凡杨

           首先说一下这个大批量，是指有上千万的数据量。
     例子：
     有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！
     select t.msisd
      

      • 

    • linux下模拟按键输入和鼠标
被触发
linux

      查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices
设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。
linux/in
      

      • 

    • ContentProvider初体验
肆无忌惮_
ContentProvider

      ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。
在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。
如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
      

      • 

    • 关于Spring MVC项目（maven）中通过fileupload上传文件
843977358
mybatisspring mvc修改头像上传文件upload

      Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。
 
1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar
因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定）
<!-- 文件上传 start by zhangyd-c --&g
      

      • 

    • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作
aigo
svnkit

       原文：http://blog.csdn.net/hardwin/article/details/7963318
 
import java.io.File;
import org.apache.log4j.Logger;
import org.tmatesoft.svn.core.SVNCommitInfo;
import org.tmateso
      

      • 

    • 对比浏览器，casperjs，httpclient的Header信息
alleni123
爬虫crawlerheader

       @Override
protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
{
String type=req.getParameter("type");
Enumeration es=re
      

      • 

    • java.io操作 DataInputStream和DataOutputStream基本数据流
百合不是茶
java流

      1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到
 
 
2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
      

      • 

    • 车辆保险理赔案例
bijian1013
车险

      理赔案例：
一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。
赔付建议和方案：
客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”；
如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
      

      • 

    • 学习Spring必学的Java基础知识(5)—注解
bijian1013
javaspring

              文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。
 
        有必要对
      

      • 

    • 【Struts2一】Struts2 Hello World
bit1129
Hello world

      Struts2 Hello World应用的基本步骤
创建Struts2的Hello World应用，包括如下几步：
1.配置web.xml
2.创建Action
3.创建struts.xml，配置Action
4.启动web server，通过浏览器访问
  配置web.xml
<?xml version="1.0" encoding="
      

      • 

    • 【Avro二】Avro RPC框架
bit1129
rpc

      1. Avro RPC简介 1.1. RPC
RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包
从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
      

      • 

    • lua　set get cookie
ronin47
lua cookie

      lua:
local access_token = ngx.var.cookie_SGAccessToken
if access_token then
ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000"
end
      

      • 

    • java-打印不大于N的质数
bylijinnan
java

      
public class PrimeNumber {
/**
* 寻找不大于N的质数
*/
public static void main(String[] args) {
int n=100;
PrimeNumber pn=new PrimeNumber();
pn.printPrimeNumber(n);
System.out.print
      

      • 

    • Spring源码学习-PropertyPlaceholderHelper
bylijinnan
javaspring

      今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug
当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复：
详见：
http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug

      

      • 

    • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么?
comsci
拓扑

      
   如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢?
   是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
      

      • 

    • ITEYE 都换百度推广了
cuisuqiang
GoogleAdSense百度推广广告外快

      以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。
 
为什么个人博客设置里面还是Google AdSense呢？
 
都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。
 
什么时候能从ITEYE上来点外快，哪怕少点
      

      • 

    • 新浪微博技术架构分析
dalan_123
新浪微博架构

      新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
      

      • 

    • 玩转ARP攻击
dcj3sjt126com
r

      我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
      

      • 

    • PHP编码规范
dcj3sjt126com
编码规范

      一、文件格式
1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
      

      • 

    • linux 脱机管理（nohup）
eksliang
linux nohupnohup

      脱机管理 nohup
转载请出自出处：http://eksliang.iteye.com/blog/2166699
nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下
nohup [命令与参数] --在终端机前台工作
nohup [命令与参数] & --在终端机后台工作
 
但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
      

      • 

    • BusinessObjects Enterprise Java SDK
greemranqq
javaBOSAPCrystal Reports

      最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。
 
首先，我是尝试用JAVA JSP 去访问的。
 
官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
      

      • 

    • 系统负载剧变下的管控策略
iamzhongyong
高并发

      假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。
1、水平扩展
这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。
2、系统分组
假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
      

      • 

    • BitTorrent DHT 协议中文翻译
justjavac
bit

      前言
做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。
BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
      

      • 

    • Ubuntu下Java环境的搭建
macroli
java工作ubuntu

      配置命令：
　　$sudo apt-get install ubuntu-restricted-extras
　　再运行如下命令：
　　$sudo apt-get install sun-java6-jdk
　　待安装完毕后选择默认Java.
　　$sudo update- alternatives --config java
　　安装过程提示选择，输入“2”即可，然后按回车键确定。 
      

      • 

    • js字符串转日期（兼容IE所有版本）
qiaolevip
TODateStringIE

       /**
* 字符串转时间（yyyy-MM-dd HH:mm:ss）
* result （分钟）
*/
stringToDate : function(fDate){
var fullDate = fDate.split(" ")[0].split("-");
var fullTime = fDate.split("
      

      • 

    • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析
superlxw1234
sql数据挖掘关联规则

      关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。
关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。
例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%] 支持度3%：意味3%顾客同时购买牛奶和面包。 置信度40%：意味购买牛奶的顾客40%也购买面包。 规则的支持度和置信度是两个规则兴
      

      • 

    • Spring 5.0 的系统需求，期待你的反馈
wiselyman
spring

             
       Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。
 
       Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。
 
      

      •