深入理解Spring IOC之扩展篇(五)、基于注解整合Spring框架

本篇讲的是如何将我们自己的业务逻辑和Spring框架整合起来,整合的方式主要采用的是注解,里面涉及到了多个知识点。 我们的目的是做出我们自己的注解,主要是标在接口上,当调用接口里相应的方法的时候,就会执行我们自己的逻辑。 对的,就是现在的MyBatis和Feign的整合方式,这种也是现在比较容易的,如果你业务里面xml用的多,你也可以结合xml来搞,拓展xml的文章我之前已经说过,你可以翻回去看看。 我们需要做很多步工作,我们把这些步骤拆开了一步一步来做

1、自定义注解:

首先当然是需要自定义出我们自己的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno {

}
我简单的说一下上面四个注解的意思哈,@Target表述注解可以被标注的地方,ElementType.TYPE表示只能被标注在类上。@Retention表示的是注解的生命周期,这里的RententionPolicy.Runtime表示它在被加载到jvm中之后还依然存在。@Documented表示这个注解会被javadoc工具所记录。@Inherited表示这个注解是会被继承的,其实也就是当A有我们这个@MyAnno的时候,B继承了A,B也会拥有这个注解而已。 画外音:我没有将@Target以及@Retention中所有的值都拿出来讲,因为那样的话我文章就写不完了,而且这也不是我们本章的重点,大家可以自行了解一下这个~ 我们有了自己的注解之后,还需要让Spring可以识别的来我们的注解,那么此时我们需要扩展我之前讲过的BeanDefinitionRegistryPostProcessor,代码如下:
@Component
public class MyAnnoConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {

    private String[] basePackages;

    public MyAnnoConfigurationPostProcessor1() {
        // 暂且写死扫描路径
        this.basePackages = new String[]{"com.example.demo.external5"};
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 1. new 一个ClassPathBeanDefinitionScanner对象,ClassPathBeanDefinitionScanner这个玩意是
        // Spring 默认的注解扫描器
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
        // 2.为上面呢创建好的scanner对象添加Filter,主要目的是让它能够认识我们的注解
        scanner.addIncludeFilter(new AnnotationTypeFilter(MyAnno.class));
        // 3.进行扫描
        scanner.scan(this.basePackages);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {}
}
其实你也可以使用ComonentScan的include属性,这样会来的更简单一些。但是我为了剧情的进一步发展,就先引出BeanDefinitionRegistryPostProcessor 然后我们把我们的注解找个类标上:
@MyAnno
public class Person {

}
复制代码
接着用这段代码测试下:
public class Test {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Config.class);
        Person p = annotationConfigApplicationContext.getBean(Person.class);
        System.out.println(p);
    }
}

// 配置类,实际作用就是上面的ComponentScan注解
@ComponentScan(basePackages = "com.example.demo.external5")
public class Config {
}
我们可以看到如下的测试结果:
深入理解Spring IOC之扩展篇(五)、基于注解整合Spring框架
此时我们便拥有了一个自己定义的注解,这个注解现在和Spring原本的这四个注解@Component、@Controller、@Repository、@Service的作用是一样的,并且,它现在还是对接口无效的,因为标在接口上的话,会被Spring的注解扫描器ClassPathBeanDefinitionScanner这玩意忽略掉,因此我们接下来需要自己定义我们自己的注解扫描器。

2、自定义注解扫描器

注意:我们自定义的注解扫描器需要有扫描接口的功能,我们先来简单的实现一下它
public class ClassPathAnnoScanner extends ClassPathBeanDefinitionScanner {

    // 必须有这样一个构造方法,不然报错,因为父类没有无参构造,这是由于java的继承机制导致的
    public ClassPathAnnoScanner(BeanDefinitionRegistry registry) {
        super(registry);
        // 在构造器中就加上filter,使它天生就可以认识我们的自定义注解
        this.addIncludeFilter(new AnnotationTypeFilter(MyAnno.class));
    }

    // 这个方法是使扫描器能够扫描注解的核心
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
    }

    @Override
    public Set<BeanDefinitionHolder> doScan(String... basePackages) {
        // 调用父类方法的扫描功能,返回BeanDefinition
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

        if (beanDefinitions.isEmpty()) {
            System.out.println("扫描到的 beanDefinitions 是空的,无法进行进一步操作!");
        }

        return beanDefinitions;
    }
}
然后在代码中结合BeanDefinitionRegistryPostProcessor去使用:
@Component
public class MyAnnoConfigurationPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {

    private String[] basePackages;

    public MyAnnoConfigurationPostProcessor() {
        // 暂且写死
        this.basePackages = new String[]{"com.example.demo.external5"};
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 1. 使用我们自己的扫描器
        ClassPathAnnoScanner scanner = new ClassPathAnnoScanner(registry);
        // 2.为上面呢创建好的scanner对象添加Filter,主要目的是让它能够认识我们的注解
        scanner.addIncludeFilter(new AnnotationTypeFilter(MyAnno.class));
        // 3.进行扫描
        scanner.scan(this.basePackages);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 空实现即可
    }
}
这时候我们便可以把我们的MyAnno注解标在接口上了,但是,如果你此时把它标在接口上面并且启动的话,那是会报错滴,原因也很简单哈,接口是没有构造方法的,所以无法初始化。我们如果想像MyBatis或者是Feign那样子在我们调用一个接口的方法之后可以执行相应的逻辑的话,需要在运行时期生成一个相应接口的代理,并且这个代理还需要借助FactoryBean来生成(末尾含FactoryBean面试题)。 但是具体是怎么做的呢?其实还是得继续改造我们的注解扫描器,我们来看看改造的代码:
public class ClassPathAnnoScanner extends ClassPathBeanDefinitionScanner {

    // 必须有这样一个构造方法,不然报错,因为父类没有无参构造,这是由于java的继承机制导致的
    public ClassPathAnnoScanner(BeanDefinitionRegistry registry) {
        super(registry);
        this.addIncludeFilter(new AnnotationTypeFilter(MyAnno.class));
    }

    // 这个方法是使扫描器能够扫描注解的核心
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
    }

    @Override
    public Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

        if (beanDefinitions.isEmpty()) {
            System.out.println("扫描到的 beanDefinitions 是空的,无法进行进一步操作!");
        } else {
            // 调用修改BeanDefinition的方法
            processBeanDefinitions(beanDefinitions);
        }

        return beanDefinitions;
    }

    // 相比上面,多了个这个修改BeanDefinition的方法
    // 需要在这里把interface的beanClass转为特定的beanClass
    private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitions) {
            BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();

            // 这个会使Spring优先选择对应的有参构造
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
            // 把扫描到的interface改为FactoryBean,这样便能以FactoryBean的方式初始化
            beanDefinition.setBeanClassName(MyFactoryBean.class.getName());
        }
    }
}
可以看到哈,相比之前的,我们还需要去修改扫描到的BeanDefinition,不然你让Spring给你初始化接口,Spring是会让你嗝屁的。

3、用FactoryBean创建代理

在用Factory创建代理之前,你首先要知道代理是怎么创建的,如果这都不知道的话麻烦自行百度jdk的动态代理。 首先我们先创建出我们的代理的处理器逻辑
// 这个是属于jdk动态代理的东西
public class MyServiceProxy implements InvocationHandler {
    
    private Class target;

    public MyServiceProxy(Class target) {
        this.target = target;
    }

    public Object getProxy() {
        // 创建代理的核心逻辑
        return Proxy.newProxyInstance(target.getClassLoader(), new Class[]{target}, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 每次被代理的接口的方法被调用就会走到这里来,在这里我们可以做很多事情
        // 我这里只是简单打印了方法的全路径名称而已
        // 你可以在这里根据每个方法的名称不同做不同的事情,甚至还可以根据方法参数里的method去拿方法的注解,获取注解的信息,进而做更多的事情
        System.out.println(method.getDeclaringClass().getName() + "." + method.getName());
        return null;
    }
}
然后再实现我们自己的FactoryBean:
public class MyFactoryBean<T> implements FactoryBean<T> {
    // 必须是接口的class
    private Class<T> clazz;

    public MyFactoryBean() {
    }

    public MyFactoryBean(Class<T> clazz) {
        this.clazz = clazz;
    }


    @Override
    public T getObject() throws Exception {
        // 创建代理
        return (T) new MyServiceProxy(clazz).getProxy();
    }

    @Override
    public Class<?> getObjectType() {
        return clazz;
    }

    public void setClass(Class<T> clazz){
        this.clazz = clazz;
    }
}
在这里,先说一下FactoryBean的机制。FactoryBean这个也是用于创建对象的,如果我们某个类比如A.java实现了FactoryBean的话,并且你给这个类标上了@Component这样的注解,那么,当调用getBean("a")的时候,我们获取到的是FactoryBean中getObject返回的对象。如果我们想要得到FactoryBean本身应该则应该调用在参数前加上"&",比如getBean("&a")这样去调用,或者getBean(A.class)这样传个Class对象进去也可以,具体的原因可以看我前面的文章。 此时我们可以尝试着把我们的@MyAnno注解加在接口上:
@MyAnno
public interface TestService {

    void eat();

}
接口很简单,也没有实现类。然后用如下测试代码进行测试
public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Config.class);
        TestService testService = (TestService) annotationConfigApplicationContext.getBean("testService");
        testService.eat();
    }
完了可以看到控制台输出的内容如下:
深入理解Spring IOC之扩展篇(五)、基于注解整合Spring框架
此时还没完,因为别忘了,我们的MyAnnoConfigurationPostProcessor里面的扫描路径是写死的。一般来说,我们会把扫描路径配合一个注解写到启动类上,方便统一管理,就像Mybatis的@MapperScan那样。明确目标后,然后我们来解决我们的问题

4、使用注解配置扫描路径

我们定义一下我们自己的Scanner:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(MyAnnoScannerRegistrar.class)
public @interface MyAnnoScanner {
    
    // value 为包扫描的路径
    String[] value() default {};
}
注意这个import注解引进来的这个class是重中之重,它是用来对我们这个MyAnnoScanner里面value值对应的包来进行扫描的,我们来看看代码:
// 必须实现ImportBeanDefinitionRegistrar
public class MyAnnoScannerRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 获取被Import注解所标着的类的元数据
        AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MyAnnoScanner.class.getName()));
        List<String> basePackages = new ArrayList();
        // 获取MyAnnoScanner里面的路径
        for (String pkg : annoAttrs.getStringArray("value")) {
            if (StringUtils.hasText(pkg)) {
                basePackages.add(pkg);
            }
        }
        ClassPathAnnoScanner scanner = new ClassPathAnnoScanner(registry);
        for (String basePackage : basePackages) {
            // 针对每个路径进行扫描
            scanner.doScan(basePackage);
        }
    }
}
最后我们在我们的Config.java上加上我们的注解:
@ComponentScan(basePackages = "com.example.demo.external5")
@MyAnnoScanner(value = "com.example.demo.external5")
public class Config {
}
注意哈,之前的MyAnnoConfigurationPostProcessor这个类我们就可以干掉了,因为它此时已经完全没什么用了。我们用和上面一样的测试代码,发现最后的输出了我们想要的东西,此时,完整的一个整合就结束了。 多说一下关于Import注解的东西,你只需要记住,当Import进来的类,没有实现ImportBeanDefinitionRegistrar这个接口的时候,这个类就会被放进Spring容器中, 你可以通过@Autowired的方式去自动注入它;反之如果实现了ImportBeanDefinitionRegistrar,那么这个类之后是不会放入Spring中,这个原因涉及到的代码在ConfigurationClassPostProcessor的方法postProcessBeanDefinitionRegistry中,具体是还是比较复杂的,我后边如果有时间也会专门再去写文章讲这些。

关于FactoryBean的面试题

相信不少人在面试中是遇到过这样一个面试题的:你能说说FactoryBean和BeanFactory的区别吗?我们可以说他们都是工厂,都是用来创建对象的,但是创建对象的场景是天差地别的,BeanFactory是可以用来创建各种各样的对象,但是FactoryBean是用来创建某一类的复杂对象的。并且BeanFactory人家的实现类都可以说是一个一个的容器,但是FactoryBean就不是了。
原文 :https://juejin.im/post/5ee58f0de51d45786e497ce3
正文到此结束
Loading...