关于java:从1开始实现一个中间件

他人都写从 0 开始实现 xxx，我先从 - 1 开始就显得更牛逼一些。

明天，先开个头，来教大家怎么实现一个中间件。

新建我的项目

首先，咱们新建一个多 module 的我的项目用于测试。

我的项目蕴含两个模块，test-infra用户中间件模块的开发，demo用于测试。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.aixiaoxian.infra</groupId>
    <artifactId>aixiaoxian-infra</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <name>aixiaoxian-infra</name>
    <description>aixiaoxian-infra</description>
    <packaging>pom</packaging>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <modules>
        <module>demo</module>
        <module>test-infra</module>
    </modules>

    <dependencies>

    </dependencies>

    <build>
        <plugins>
            <!-- Source -->
            <plugin>
                <artifactId>maven-source-plugin</artifactId>
                <inherited>true</inherited>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

开发中间件

我的项目创立 OK 了，接着开始开发一个最最最简略的中间件。

在 resources 目录下创立 META-INFA/spring.factories 文件，用于主动拆卸，别问我啥是主动拆卸，而后配置一个主动拆卸类。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.aixiaoxian.testInfra.config.TestConfiguration

实现 TestConfiguration，最简略的形式，间接应用 @Bean 注解申明一个 Bean 交给 Spring 治理。

@Configuration
public class TestConfiguration implements BeanDefinitionRegistryPostProcessor, EnvironmentAware {
    private Environment environment;

    @Bean
    public TestManager getTestManager() {return new TestManager();
    }
  
   @Override
    public void setEnvironment(Environment environment) {this.environment = environment;}

}

而后实现真正的中间件逻辑的解决局部TestManager。

@Slf4j
public class TestManager {public TestManager() {init();
    }

    public void init(){log.info("TestManager start");
    }
}

这样的话，一个最简略的中间件就开发好了，间接把他增加到 demo 模块中，启动测试即可。

 <dependency>
   <groupId>com.aixiaoxian.infra</groupId>
   <artifactId>test-infra</artifactId>
   <version>0.0.1-SNAPSHOT</version>
 </dependency>

换个姿态

咱们换个姿态去创立 Bean，应用BeanDefinitionRegistryPostProcessor，让 TestConfiguration 去实现它，重写postProcessBeanDefinitionRegistry，注册一个新的 Bean aiManager，这样也是 OK 的，写法很多，不再赘述。

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(AiManager.class);
    beanDefinitionBuilder.addConstructorArgValue(this.environment);
    beanDefinitionRegistry.registerBeanDefinition("aiManager", beanDefinitionBuilder.getBeanDefinition());
}

@Slf4j
public class AiManager {
    private Environment environment;

    public AiManager(Environment environment) {
        this.environment = environment;

        init();}

    public void init(){log.info("AiManager start");
    }
}

再换个姿态

对于主动拆卸创立 Bean 有了根本的理解，那如果我想申明一个注解给他人用该怎么做？

首先创立一个注解，留神我应用了 @Import 注解，TestImportSelector 实现 TestImportSelector 接口。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import({TestImportSelector.class})
@Documented
public @interface TestAnnotation {
}

public class TestImportSelector implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {return new String[]{AnnotationConfiguration.class.getName()};
    }
}

AnnotationConfiguration 写法也很简略了，这样也实现了主动拆卸，当然了你要是用下面的写法也能达到一样的成果，然而倡议这样写，别问，问就是这样。

public class AnnotationConfiguration implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(AnnotationManager.class);
        beanDefinitionRegistry.registerBeanDefinition("annotationManager", beanDefinitionBuilder.getBeanDefinition());
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {}}

@Slf4j
public class AnnotationManager {public AnnotationManager() {init();
    }

    public void init(){log.info("AnnotationManager start");
    }
}

最初在 demo 启动类上打上咱们这个注解。

@SpringBootApplication
@TestAnnotation
public class DemoApplication {public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args);
    }
}

最初咱们能够看到输入：

2022-06-21 19:05:07.433  INFO 4598 --- [main] c.a.testInfra.manager.TestManager        : TestManager start
2022-06-21 19:05:07.456  INFO 4598 --- [main] c.a.testInfra.manager.AiManager          : AiManager start
2022-06-21 19:05:07.456  INFO 4598 --- [main] c.a.testInfra.manager.AnnotationManager  : AnnotationManager start

好了，就这样，我猜，没人须要这个源码吧？为了前面的文章，先写个这个铺垫一下，完结。