自定义spring boot-starter,实现自动配置,自定义注解扫描注入(类似dubbo-starter)

最新推荐文章于 2024-05-12 23:38:31 发布

喵喵爱西瓜

最新推荐文章于 2024-05-12 23:38:31 发布

阅读量6k

点赞数 3

分类专栏： springboot JAVA rpc 文章标签： spring boot spring boot starter rpc mybatis

本文链接：https://blog.csdn.net/u010928589/article/details/90293703

版权

JAVA 同时被 3 个专栏收录

10 篇文章 0 订阅

订阅专栏

springboot

8 篇文章 2 订阅

订阅专栏

rpc

2 篇文章 0 订阅

订阅专栏

1. 简介

本文,自定义starter是为了扩展之前自己写的一个RPC框架,所以本文的案列就是在这个RPC框架之上,实现自动配置

传送门 : github | gitee

博主现在想把这个 RPC框架封装成一个 starter,实现以下功能

1 . 在maven 引入对应starter 实现自动配置,yaml文件的参数自定义

2 . 在项目启动时,扫描打了自定义注解 @ChyRPCRegist 的类,把他注册进 PRC 注册中心,同时使用 spring 提供的单例对象,进行反射调用

3 . 扫描自定义注解 @ChyRPCServiceFind 的接口(这里是接口,不是实现类,默认spring 的 @service是不扫描进容器的),然后偷龙换风,把代理对象扔给spring管理, 可以用 @Autowired,@Resource 注解注入后使用 , 类似 mybatis 的 starter;

最后一个比较麻烦,博主都是看着 mybatis starter 的源码一步步摸过来.

==================================分割线==========================================================

老规矩,先扔 github,这个项目依赖了,上一篇手写RPC框架 ,要先下载对应的PRC框架,然后 maven 安装后才能正常使用

https://github.com/cao2068959/rpc-starter

2 . starter 基本配置

(1 . 新建一个spring boot项目引入maven

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>


       <!--博主自己手写的RPC框架-->
        <dependency>
            <groupId>chy.frame.rpc</groupId>
            <artifactId>chyrpc2.0</artifactId>
            <version>2.0</version>
        </dependency>


    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

(2 .创建一个 Properties 用来映射 yaml上的配置文件

//在yaml文件中的前缀
@ConfigurationProperties(prefix="chyrpc")
public class RpcProperties {
    private String zookeepeer = "127.0.0.1:2181";
    private int port = 10086;
    private String ip = "127.0.0.1";

    public String getZookeepeer() {
        return zookeepeer;
    }

    public void setZookeepeer(String zookeepeer) {
        this.zookeepeer = zookeepeer;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }
}

(3 创建自动配置类

@Configuration
//必须要引入了 我手写的 rpc框架才能生效
@ConditionalOnClass(ChyRpcApplication.class)
//能够读取我自定义的配置文件
@EnableConfigurationProperties(RpcProperties.class)
public class ChyRpcAutoConfigure {

    @Autowired
    RpcProperties rpcProperties;

    @Bean
    //如果用户自定义了一个 ChyRpcApplication 就不创建,如果没有就在spring 容器中加入一个默认配置的rpc容器,ChyRpcApplication也是我RPC的核心类,类似 sessionFactory
    @ConditionalOnMissingBean(ChyRpcApplication.class)
    public ChyRpcApplication initChyRpcApplication(){
        ChyRpcApplication chyRpcApplication = new ChyRpcApplication(rpcProperties.getZookeepeer());
        chyRpcApplication.setPort(rpcProperties.getPort());
        chyRpcApplication.setIp(rpcProperties.getIp());
        return chyRpcApplication;
    }



}

(4 在项目下创建spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
chy.frame.spring.starter.rpc.autoConfigure.ChyRpcAutoConfigure

加入,要自动配置的配置类.这样当spring boot 引入该 starter后就会自动加载该类,然后根据那几个条件注解去加载对应方法

(5 测试

当以上配完之后,打包,然后新建一个 spring boot 项目,引入

  <dependency>
        <groupId>chy.frame.spring.starter</groupId>
        <artifactId>chyrpc-spring-boot-starter</artifactId>
        <version>1.0</version>
    </dependency>

这时候,在yaml文件中就能输入我们添加的参数

输入端口为 7992, 启动项目后,看到控制台

看来spring已经帮我们把 ChyRpcApplication 放入 spring 容器了.

这时候,启动2个服务,一个注册服务,一个调用服务.

@RestController
public class Mycontroller {

    @Autowired
    public MyService myService;

    @Autowired
    public ChyRpcApplication chyRpcApplication;


    @GetMapping("/regist")
    public String regist() throws Exception {
        chyRpcApplication.register("nameSB",myService);
        return "注册成功";
    }

    @GetMapping("/test2")
    public String test2() throws Exception {
        ServiceApi serviceApi = chyRpcApplication.getService("nameSB",ServiceApi.class);
        return serviceApi.test();
    }



}

能看到,浏览器上显示,远程服务器的方法调用后,最基本的 starter 就搭建完了

================================分割线总结一波============================================

不过缺点也很明显,如果上千个服务要注册,能写到崩溃,而且这么调用.spring 不能管理到代理对象.每次都是一个新的代理.

2 . 实现自动注册服务

这里我自定义了一个注解

@ChyRPCRegist

凡是被这个注解盯上的类,会在自动配置的时候,注册进RPC框架.


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

//有一个默认参数,将会指定 RPC服务的名称,如果不写,将会用这个类的接口的名称注册
    String name() default "";
}

因为, RPC注册的时候,需要服务类的实例对象(总不能每次调用都去new一个) ,同时spring 已经帮我们管理好了,我们直接用 spring 管理的 bean 对象就行.

所以思路就是,我们需要在 spring 把所有的 bean都创建好了,再去注册我们的服务.

spring 有各种监听接口,这里我们使用 ApplicationListener<ContextRefreshedEvent> 这个接口,注意泛型才是关键

这个接口会在 bean全部创建完了才会调用.

那事情是很好办了,创建一个类

实现思路, 在监听触发后,拿到 spring 容器中所有的bean对象.然后扫描所有bean.看谁打了注解 @ChyRPCRegist ,打了的就注册进RPC容器中.

public class ChyRpcRegistService implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private ChyRpcApplication chyRpcApplication;

    /**
     * 扫描自定义的注解,并注册到RPC容器中
     * @param contextRefreshedEvent
     */
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {

        //拿到spring容器
        ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
        //拿到所有打了注解 ChyRPCRegist 的bean
        Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(ChyRPCRegist.class);

        boolean isStart = false;

        for (String serviceName : beansWithAnnotation.keySet()) {

            Object serviceObject = beansWithAnnotation.get(serviceName);
            Class<?> serviceImpClass = serviceObject.getClass();
            //拿到注解
            ChyRPCRegist chyRPCRegist = serviceImpClass.getAnnotation(ChyRPCRegist.class);

            String registName = chyRPCRegist.name();
            //如果在注解中没指定名称,就用 接口的名称,
            if("".equals(registName)){
                Class<?>[] interfaces = serviceImpClass.getInterfaces();
                if(interfaces!=null && interfaces.length >0){
                    registName = interfaces[0].getName();
                }
            }

            if(registName == null || "".equals(registName)){
                System.err.println(serviceObject.getClass().getName()+ " ---> 注册失败");
                continue;
            }
            try {
                chyRpcApplication.register(registName,serviceObject);
                isStart = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


        if(isStart){
            System.out.println("RPC 服务提供者 开启 ---- > 端口 "+ chyRpcApplication.getPort());
        }

    }


}

但是这个类现在还没进入 spring 容器中,自然监听也不会生效

在之前我们配置的 ChyRpcAutoConfigure 类中加上

  /**
     * 扫描所有打过注解的类,把他注册进rpc服务
     */
    @ConditionalOnBean(ChyRpcApplication.class)
    @Bean
    public ChyRpcRegistService registAllService(){
        return new ChyRpcRegistService();
    }

测试 :

//因为bean对象 还是要交给 spring管理,我们的注解是在 spring扫描完 对象后才处理,没有管理bean的能力,所以必须要加上 @Service @Controller 等注解
@Service
@ChyRPCRegist
public class MyService implements ServiceApi {

    public String test(){
        return "调用了 8082的服务哦";
    }

}

启动服务后,查看 zookeeper,发现已经注册进了 RPC容器.

3 实现扫描接口上的自定义注解

接下来,我们要实现了类似 fegin ,mybaits 在接口上打个注解,然后把代理对象塞进去的骚操作.

. 首先,一个空接口上,如果打了 @Service 这些注解,spring 容器在扫描的时候,也不会生成对应的 bean,所以上面那种自动注册的做法就完全 pass了.

既然 @servcie 注解不理会接口,那我们就自己现实一个,mybaits 也是类似,所以他用了 @Mapper注解


@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ChyRPCServiceFind {
//服务的名称,用来RPC的时候调用指定名称的 服务
    String serviceName() default "";
//还记得 service注解中也要指定一个名字吗,使用@Resource的时候 注入对应名字的对象
    String beanName() default "";
}

既然这个注解要有扫描 bean的作用.那么我肯定要指定扫描的包路径,是不是很熟悉 ,mybatis 中有个 @MapperScan注解来指定扫描的路径,那么我们也来一个@RpcScan


@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
//spring中的注解,加载对应的类
@Import(FindServiceScan.class)
@Documented
public @interface RpcScan {

    String[] basePackage() default {};
}

是不是看到了一个 @Import(FindServiceScan.class)

没错,他就是我们正真的扫描入口

这个类实现了 ImportBeanDefinitionRegistrar 接口, 看名字就知道,他现在拥有的注册 bean的能力


public class FindServiceScan implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {


    ResourceLoader resourceLoader;

  

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {

        this.resourceLoader = resourceLoader;
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(annotationMetadata.getAnnotationAttributes(RpcScan.class.getName()));

        String[] basePackages = annoAttrs.getStringArray("basePackage");
        //没有设置 扫描路径,就扫描对应
        if(basePackages.length == 0){
            basePackages = new String[]{((StandardAnnotationMetadata) annotationMetadata).getIntrospectedClass().getPackage().getName()};
        }

        //自定义的 包扫描器
        FindServiceClassPathScanHandle scanHandle = new FindServiceClassPathScanHandle(beanDefinitionRegistry,false);

        if(resourceLoader != null){
            scanHandle.setResourceLoader(resourceLoader);
        }

        scanHandle.setBeanNameGenerator(new RpcBeanNameGenerator());
        //扫描指定路径下的接口
        Set<BeanDefinitionHolder> beanDefinitionHolders = scanHandle.doScan(basePackages);
    }
}

同时还继承 ResourceLoaderAware 接口这是为了,拿到resourceLoader 对象,用于传入扫描管理器中.

重点在 ImportBeanDefinitionRegistrar 的实现方法 registerBeanDefinitions 中

在这里面,我读取前面 @RpcScan 里指定要扫描的包路径,如果没指定,就扫描 main 方法下所在包的所有类,然后 new了一个 FindServiceClassPathScanHandle 对象开始扫描. FindServiceClassPathScanHandle是继承了 ClassPathBeanDefinitionScanner 而ClassPathBeanDefinitionScanner这是 spring 默认提供给我们的扫描器.这样我们就能站在巨人的肩膀上扩展一下.(你问我为什么知道,因为mybatis就是这么写的,我这不算抄袭...)

然后重点就是 FindServiceClassPathScanHandle这个类

public class FindServiceClassPathScanHandle extends ClassPathBeanDefinitionScanner {

    public FindServiceClassPathScanHandle(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
        super(registry, useDefaultFilters);
    }


    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        //添加过滤条件
         addIncludeFilter(new AnnotationTypeFilter(ChyRPCServiceFind.class));
        //调用spring的扫描
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        if(beanDefinitionHolders.size() != 0){
            //给扫描出来的接口添加上代理对象
            processBeanDefinitions(beanDefinitionHolders);
        }
        return beanDefinitionHolders;
    }


    /**
     * 给扫描出来的接口添加上代理对象
     * @param beanDefinitions
     */
    private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
        GenericBeanDefinition definition;
        for (BeanDefinitionHolder holder : beanDefinitions) {
            definition = (GenericBeanDefinition) holder.getBeanDefinition();
            //拿到接口的全路径名称
            String beanClassName = definition.getBeanClassName();
            //把接口的全路径放入ProxyFactoryBean 的构造器中,在构造器中会自动转成 class类型
            definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
            //把扫描出来的接口里面改成一个 生成代理类的工程方法,这个类实现了 factoryBean spring容器在实例化的时候会调用 里面的getObject 方法
            definition.setBeanClass(ProxyFactoryBean.class);
            definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

        }
    }

    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
    }

}

大概流程是 :

重写 doScan 方法,在原来的基础上加了一个过滤条件,只扫描打了 ChyRPCServiceFind 注解的类.(如果看 spring 源码也和这个类似,只是注解变成了 service controller 等注解). 然后调用父类的默认扫描方法.

然后拿到所有打了注解的接口的 bean描述文件(这时候,还没实例化对象,spring 会用描述文件去生成对应的实例),交给processBeanDefinitions 去修改描述文件,这样到真正生成实例的时候,就偷梁换柱

注意 :

要重写isCandidateComponent 方法,如果不重写,用父类的 isCandidateComponent ,就会把接口给过滤掉.导致doScan的时候拿不到接口(我在debug里面绕了好久才发现,mybatis 也重写了,抄的时候居然把关键点忘记了)

processBeanDefinitions做的就是,修改bean描述文件, 把描述文件中 bean的类的类型(原来是我们扫描到的接口),改成了ProxyFactoryBean ,这个类会帮我们生成代理类

public class ProxyFactoryBean<T> implements FactoryBean<T> {


    private Class<T> rpcInterface;


    @Autowired
    private ChyRpcApplication chyRpcApplication;


    public ProxyFactoryBean(Class<T> rpcInterface) {
        this.rpcInterface = rpcInterface;
    }

    /**
     * 用描述文件,生成真正对象的时候,会调用这个方法
     * 调用的时候生成代理对象
     * @return
     * @throws Exception
     */
    @Override
    public T getObject() throws Exception {
        ChyRPCServiceFind serviceFind = rpcInterface.getAnnotation(ChyRPCServiceFind.class);
        String serviceName = serviceFind.serviceName();
        if(serviceName == null || "".equals(serviceName)){
            serviceName = rpcInterface.getName();
        }
        return chyRpcApplication.getService(serviceName,rpcInterface);
    }

    /**
     * 假装我的类型还是 原来的接口类型,不是代理对象
     * 这样 自动注入的时候,类型才能匹配上
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return rpcInterface;
    }


    @Override
    public boolean isSingleton() {
        return true;
    }

    public Class<T> getRpcInterface() {
        return rpcInterface;
    }

    public void setRpcInterface(Class<T> rpcInterface) {
        this.rpcInterface = rpcInterface;
    }


    public ChyRpcApplication getChyRpcApplication() {
        return chyRpcApplication;
    }

    public void setChyRpcApplication(ChyRpcApplication chyRpcApplication) {
        this.chyRpcApplication = chyRpcApplication;
    }
}

到这里就基本实现了.

测试

调用者类

启动类

提供者

最后输入浏览器访问能成功看到

这样基本效果就完成了

4 按照名称注入对象

最后嗯,还有一个BUG.就是这个注入,只能根据接口的类型注入.那如果我想像 @Service("hell")注解这样在里面指定一个名称,在注入的时候 @Resource(name = "hell")来指定注入对象,怎么办嗯

在创建自定义扫描器的时候,是不是看到了这玩意,他就是用了给你的扫描类取名字的,我们重写这个类.

public class RpcBeanNameGenerator extends AnnotationBeanNameGenerator {

    @Override
    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {

        //从自定义注解中拿name
        String name = getNameByServiceFindAnntation(definition,registry);
        if(name != null && !"".equals(name)){
            return name;
        }
        //走原来的方法
        return super.generateBeanName(definition, registry);
    }

    private String getNameByServiceFindAnntation(BeanDefinition definition, BeanDefinitionRegistry registry) {
        String beanClassName = definition.getBeanClassName();
        try {
            Class<?> aClass = Class.forName(beanClassName);
            ChyRPCServiceFind annotation = aClass.getAnnotation(ChyRPCServiceFind.class);
            if(annotation == null){
                return null;
            }
            return annotation.beanName();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }



}

OK.最后测试

虽然IDEA没有识别出来,但是启动正常

喵喵爱西瓜

关注

3
点赞
踩
14

收藏

觉得还不错? 一键收藏
3
评论
自定义spring boot-starter,实现自动配置,自定义注解扫描注入(类似dubbo-starter)

1. 简介本文,自定义starter是为了扩展之前自己写的一个RPC框架,所以本文的案列就是在这个RPC框架之上,实现自动配置传送门 :手写RPC框架博主现在想把这个 RPC框架封装成一个 starter,实现以下功能1 . 在maven 引入对应starter 实现自动配置,yaml文件的参数自定义2 . 在项目启动时,扫描打了自定义注解@Chy...
复制链接

扫一扫

专栏目录