博客

1、接口

创建一个用于测试的接口

/**
 * 用来模拟动态注入的测试接口
 * @author YKR
 * @Describe
 * @date 2021/7/16
 */
public interface MyMapper {

    public String sayHello();

}

2、使用jdk实现动态代理

/**
 * 使用jdk动态代理，这是代理类
 * @author YKR
 * @Describe
 * @date 2021/7/16
 */
public class MyProxy implements InvocationHandler{
    private Class<?> interfaceClass;
    
    //代理类工厂调用此方法返回代理类对象
    public Object bind(Class<?> clazz) {
        this.interfaceClass = clazz;
        return Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] {interfaceClass}, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return "hello world";
    }

}

3、创建一个代理类工厂

/**
 * 代理类的工厂，用来生成代理对象，需要实现spring的一个专门的接口
 * @author YKR
 * @Describe
 * @date 2021/7/16
 */
public class MyProxyFactory<T> implements FactoryBean<T> {

    //用来存放代理类代理的接口的字节码对象
    private Class<T> interfaceClass;
    
    //接口的字节码对象的getter和setter
    public Class<T> getInterfaceClass() {
        return interfaceClass;
    }
    public void setInterfaceClass(Class<T> interfaceClass) {
        this.interfaceClass = interfaceClass;
    }

    //该方法返回生成的代理对象
    @Override
    public T getObject() throws Exception {
        return (T) new MyProxy().bind(interfaceClass);
    }

    //该方法返回接口的字节码对象
    @Override
    public Class<?> getObjectType() {
        return interfaceClass;
    }

    @Override
    public boolean isSingleton() {
        // 单例模式,因为默认为true，所以也可以不重写
        return true;
    }

}

factorybean是一个泛型接口，实现它的实例可以通过id找到这个bean，但是它返回的是getObject()方法的对象

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
	
    /**
      *@Nullable注解可以标注在方法、字段、参数之上，表示对应的值可以为空
      *
      */
    @Nullable
    T getObject() throws Exception;//该方法返回生成的代理对象

    @Nullable
    Class<?> getObjectType();//该方法返回接口的字节码对象

    //默认采用单例模式,jdk1.8新特性，接口方法可以有默认值
    default boolean isSingleton() {
        return true;
    }
}

4、把我们的代理对象动态注入到IoC容器中

/**
 * @author YKR
 * @Describe
 * @date 2021/7/16
 */
@Component
public class MyRegistryBean implements ApplicationContextAware, BeanDefinitionRegistryPostProcessor {
    private ApplicationContext ctx;
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    }
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        // 需要被代理的接口
        Class<?> clazz = MyMapper.class;
        //使用BeanDefinitionBuilder.genericBeanDefinition(clazz)，我们可以动态的将代理类注册到spring容器中
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
        //spring初始化时，可以用GenericBeanDefinition存储用户自定义的Bean，在初始化Bean时，又会将其转换为RootBeanDefinition
        GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition();
        //给我们的bean设置属性，把interfaceClass作为bean的id，把我们接口的字节码对象作为value
        definition.getPropertyValues().add("interfaceClass", definition.getBeanClassName());
        //给我们的bean设置class，class应该是代理类工厂的class
        definition.setBeanClass(MyProxyFactory.class);
        //给我们的bean设置自动装配方式为按类型装配
        definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
        // 注册bean名,一般为类名首字母小写
        beanDefinitionRegistry.registerBeanDefinition("myMapper", definition);
    }
    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        this.ctx = ctx;
    }

}

这里我们实现了spring的两个接口，深入源码

先看ApplicationContextAware，看到—Aware就知道是干什么的了，就是属性注入的，但是这个ApplicationContextAware的不同地方在于，实现了这个接口的bean，当spring容器初始化的时候，会自动的将ApplicationContext注入进来，然后它的父接口Aware是个空接口，个人猜测是一个类似于回调方法的机制，来让注入的bean知道自己的ApplicationContext，如果有好的见解望告知！

public interface ApplicationContextAware extends Aware {
    void setApplicationContext(ApplicationContext var1) throws BeansException;
}

再看BeanDefinitionRegistryPostProcessor，首先在spring源码中有一个BeanDefinitionRegistry，它是注册bean定义的接口，而这个接口加了PostProcessor意为后处理，意思就是在第一次bean定义注册之后再处理的bean定义，从而实现动态注入

//动态的注册bean到spring容器中
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry var1) throws BeansException;
}

它继承了BeanFactoryPostProcessor

//允许对ApplicationContext进行自定义修改的接口，它可以调整ApplicationContext基础bean工厂中配置的bean的属性
@FunctionalInterface  //1.8新特性 函数式接口
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

5、写一个controller测试效果

/**
 * @author YKR
 * @Describe
 * @date 2021/7/16
 */
@RestController
public class TestController {
   
    @Autowired
    MyMapper myMapper;
   
    @RequestMapping("/test")
    public String test() {
       return myMapper.sayHello();
    }
}

最终结果，注入成功