手打RPC-动态注入服务_rpc 动态接入

作者：盐析白兔 | 2024-04-14 23:10:05

踩

rpc 动态接入

继续上篇内容,本篇讲解服务启动时，动态注入相关的实例。

一.自定义注解

自定义的注解分为三部分:

容器启动时，自动注入配置的注解
服务端注入服务提供者的注解
消费端启动引用服务提供者的注解

@EnableRainRpc 自动扫包，引入一些默认配置，以及注入RainRpcComponentScanRegistrar，使注解了@RainProvider， @RainConsumer 的类生效。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({RainRpcComponentScanRegistrar.class, RainRpcConfig.class,RainRpcAutoConfiguration.class })
public @interface EnableRainRpc {

    /**
     * 指定扫描包路径
     */
    String[] value() default {};


    /**
     * 指定扫描类
     */
    Class<?>[] basePackageClasses() default {};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@RainProvider 用于标识服务提供者的具体实现类

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Inherited
public @interface RainProvider {


}
1
2
3
4
5
6
7
8

@RainConsumer标识服务提供者的接口，用于消费者引用

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Inherited
public @interface RainConsumer {

    /**
     * 应用名称
     */
    String name() default "";

    /**
     * 服务集群名称
     */
    String cluster() default "rpc";

    /**
     * 降级处理
     */
    String degradation() default "";

    /**
     * 请求等待
     */
    long timeout() default 10;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

二.定制beanDefinition后置处理器

RainRpcComponentScanRegistrar 实现了spring的ImportBeanDefinitionRegistrar 接口，可以动态注册
beanDefinition。容器启动时，会执行registerBeanDefinitions方法。

public class RainRpcComponentScanRegistrar  implements ImportBeanDefinitionRegistrar , ResourceLoaderAware
        , EnvironmentAware, BeanClassLoaderAware {

    protected final Log logger = LogFactory.getLog(getClass());

    private ResourceLoader resourceLoader;

    private Environment environment;

    private ClassLoader classLoader;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    	// 获取要扫包的路径
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
		// 处理@RainProvider
        registerProviderBeanPostProcessor(packagesToScan, registry);
		// 处理@RainConsumer 
        registerConsumerBeanPostProcessor(packagesToScan,registry);
    }

    /**
     * 注册RainProvider注解处理器
     * @author wu
     * @param packagesToScan
     * @param registry
     * @return
     */
    public void registerProviderBeanPostProcessor(Set<String> packagesToScan,BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder builder = rootBeanDefinition(RainProviderBeanPostProcessor.class);
        builder.addConstructorArgValue(packagesToScan);
        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
    }


    /**
     * 注册RainConsumer注册处理器
     * @author wu
     * @param registry
     * @return
     */
    public void registerConsumerBeanPostProcessor(Set<String> packagesToScan,BeanDefinitionRegistry registry) {
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(this.resourceLoader);
        scanner.addIncludeFilter(new AnnotationTypeFilter(RainConsumer.class));
        for (String basePackage : packagesToScan) {
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    if (!annotationMetadata.isInterface()) {
                        logger.info("@RainConsumer can only be specified on an interface");
                        continue;
                    }
                    registerClient(beanDefinition, registry);
                }
            }

        }
    }

    private void registerClient(AnnotatedBeanDefinition beanDefinition, BeanDefinitionRegistry registry) {

        Class<?> beanClass = resolveClass(beanDefinition);

        RainConsumer service = findAnnotation(beanClass, RainConsumer.class);

        AbstractBeanDefinition serviceBeanDefinition =
                buildServiceBeanDefinition(service, beanClass);

        registry.registerBeanDefinition(beanClass.getName(), serviceBeanDefinition);
    }

    private AbstractBeanDefinition buildServiceBeanDefinition(RainConsumer service, Class<?> interfaceClass) {

        BeanDefinitionBuilder builder = rootBeanDefinition(ConsumerBean.class);

        builder.addPropertyValue("interfaceClass", interfaceClass.getName());

        builder.addPropertyValue("annotation", service);

        builder.setPrimary(Boolean.TRUE);

        return builder.getBeanDefinition();

    }


    private Class<?> resolveClass(AnnotatedBeanDefinition beanDefinition) {
        String beanClassName = beanDefinition.getBeanClassName();
        return resolveClassName(beanClassName, classLoader);
    }



    /**
     * 获取扫描包路径
     * @author wu
     * @param metadata
     * @return {@link Set< String>}
     */
    private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                metadata.getAnnotationAttributes(EnableRainRpc.class.getName()));
        Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
        String[] value = attributes.getStringArray("value");
        // Appends value array attributes
        Set<String> packagesToScan = new LinkedHashSet<String>(Arrays.asList(value));
        for (Class<?> basePackageClass : basePackageClasses) {
            packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
        }
        if (packagesToScan.isEmpty()) {
            return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
        }
        return packagesToScan;
    }

    protected ClassPathScanningCandidateComponentProvider getScanner() {
        return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
            @Override
            protected boolean isCandidateComponent(
                    AnnotatedBeanDefinition beanDefinition) {
                boolean isCandidate = false;
                if (beanDefinition.getMetadata().isIndependent()) {
                    if (!beanDefinition.getMetadata().isAnnotation()) {
                        isCandidate = true;
                    }
                }
                return isCandidate;
            }
        };
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

1. 处理@RainProvider的bean

registerProviderBeanPostProcessor方法主要是向bean注册器中注册RainProviderBeanPostProcessor后置处理器。
RainProviderBeanPostProcessor处理流程:

获取扫包路基，路径来源注解@EnableRainRpc启动类路径或@EnableRainRpc自定义的路径
扫描标注@RainProvider注解的beanDefinition
根据beanDefinition构造ProviderBean
将ProviderBean注册到bean注册器中

public class RainProviderBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware
        , BeanClassLoaderAware {

    protected final Log logger = LogFactory.getLog(getClass());

    private final Set<String> packagesToScan;

    private Environment environment;

    private ClassLoader classLoader;

    public RainProviderBeanPostProcessor(Collection<String> packagesToScan) {
        this(new LinkedHashSet<>(packagesToScan));
    }

    public RainProviderBeanPostProcessor(Set<String> packagesToScan) {
        this.packagesToScan = packagesToScan;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

        Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);

        if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
            registerServiceBeans(resolvedPackagesToScan, registry);
        }
    }


    private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false);

        BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);

        scanner.setBeanNameGenerator(beanNameGenerator);

        scanner.addIncludeFilter(new AnnotationTypeFilter(RainProvider.class));

        // 扫描包，注册beanDefinition
        for (String packageToScan : packagesToScan) {
            scanner.scan(packageToScan);

            Set<BeanDefinitionHolder> beanDefinitionHolders =
                    findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);

            if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    registerServiceBean(beanDefinitionHolder, registry);
                }

            }
        }

    }


    private BeanNameGenerator resolveBeanNameGenerator(BeanDefinitionRegistry registry) {

        BeanNameGenerator beanNameGenerator = null;

        if (registry instanceof SingletonBeanRegistry) {
            SingletonBeanRegistry singletonBeanRegistry = SingletonBeanRegistry.class.cast(registry);
            beanNameGenerator = (BeanNameGenerator) singletonBeanRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
        }

        if (beanNameGenerator == null) {

            if (logger.isInfoEnabled()) {

                logger.info("BeanNameGenerator bean can't be found in BeanFactory with name ["
                        + CONFIGURATION_BEAN_NAME_GENERATOR + "]");
                logger.info("BeanNameGenerator will be a instance of " +
                        AnnotationBeanNameGenerator.class.getName() +
                        " , it maybe a potential problem on bean name generation.");
            }

            beanNameGenerator = new AnnotationBeanNameGenerator();

        }

        return beanNameGenerator;

    }

    private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(
            ClassPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry,
            BeanNameGenerator beanNameGenerator) {

        Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);

        Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());

        for (BeanDefinition beanDefinition : beanDefinitions) {

            String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
            BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
            beanDefinitionHolders.add(beanDefinitionHolder);

        }

        return beanDefinitionHolders;

    }


    private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry) {

        Class<?> beanClass = resolveClass(beanDefinitionHolder);

        RainProvider service = findAnnotation(beanClass, RainProvider.class);
        // 接口类
        Class<?> interfaceClass = beanClass.getInterfaces()[0];
        // 实现类名
        String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();

        AbstractBeanDefinition serviceBeanDefinition =
                buildServiceBeanDefinition(service, interfaceClass, annotatedServiceBeanName);

        registry.registerBeanDefinition( interfaceClass.getName(), serviceBeanDefinition);
    }


    private Class<?> resolveClass(BeanDefinitionHolder beanDefinitionHolder) {

        BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
        String beanClassName = beanDefinition.getBeanClassName();

        return resolveClassName(beanClassName, classLoader);
    }



    private Set<String> resolvePackagesToScan(Set<String> packagesToScan) {
        Set<String> resolvedPackagesToScan = new LinkedHashSet<String>(packagesToScan.size());
        for (String packageToScan : packagesToScan) {
            if (StringUtils.hasText(packageToScan)) {
                String resolvedPackageToScan = environment.resolvePlaceholders(packageToScan.trim());
                resolvedPackagesToScan.add(resolvedPackageToScan);
            }
        }
        return resolvedPackagesToScan;
    }

    private AbstractBeanDefinition buildServiceBeanDefinition(RainProvider service, Class<?> interfaceClass,
                                                              String annotatedServiceBeanName) {

        BeanDefinitionBuilder builder = rootBeanDefinition(ProviderBean.class);

        // 引用具体实现类
        addPropertyReference(builder, "ref", annotatedServiceBeanName);

        builder.addPropertyValue("interfaceClass", interfaceClass.getName());

        builder.addPropertyValue("methodList", interfaceClass.getDeclaredMethods());

        return builder.getBeanDefinition();

    }


    private void addPropertyReference(BeanDefinitionBuilder builder, String propertyName, String beanName) {
        String resolvedBeanName = environment.resolvePlaceholders(beanName);
        builder.addPropertyReference(propertyName, resolvedBeanName);
    }


    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

2. 处理@RainConsumer的bean

区别于@RainProvider的处理方式，@RainConsumer的处理换了一种方式,为啥会这样呢?
@RainConsumer注解对象都是接口，直接使用ClassPathBeanDefinitionScanner扫描器，不会将接口类转换为beanDefinition，故而不能使用beanDefinition后置处理器处理。
既然现成的扫描器实现不了目标，那就自定义一个扫描器，重写判断条件。
代码如下:

    protected ClassPathScanningCandidateComponentProvider getScanner() {
        return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
            @Override
            protected boolean isCandidateComponent(
                    AnnotatedBeanDefinition beanDefinition) {
                boolean isCandidate = false;
                if (beanDefinition.getMetadata().isIndependent()) {
                    if (!beanDefinition.getMetadata().isAnnotation()) {
                        isCandidate = true;
                    }
                }
                return isCandidate;
            }
        };
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

有了扫描器之后，操作方式就跟@RainProvider类似:

扫描对应路径下的注解了@RainConsumer类获取BeanDefinition
根据beanDefinition构造一个ConsumerBean
将ConsumerBean注册到bean注册器中

这里ConsumerBean是一个FactoryBean,用于连接服务,生成代理服务类。

三.自动配置

RainRpcAutoConfiguration 向容器中注入ProviderContextStart。ProviderContextStart用于向注册中心注册服务。

@Configuration
public class RainRpcAutoConfiguration {


    @Bean
    public ProviderContextStart providerContextStart() {
        return new ProviderContextStart();
    }




}
1
2
3
4
5
6
7
8
9
10
11
12
13

项目详细代码参考

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/424582