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

其他扩展可参考之前的文章：

1、深入理解Spring IOC之扩展篇(一)、自定义xml标签

2、深入理解Spring IOC之扩展篇(二)、BeanFactoryPostProcessor和BeanPostProcessor

3、深入理解Spring IOC之扩展篇(三)、InitializingBean、@PostConstruct、SmartInitializingSingleton

4、深入理解Spring IOC之扩展篇(四)、Aware接口

本篇讲的是如何将我们自己的业务逻辑和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原本的这四个注解@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();
    }

完了可以看到控制台输出的内容如下：

此时还没完，因为别忘了，我们的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就不是了。