如何将接口通过反向代理生成实例然后注册到Spring

需要组件：bean工厂，bean注册器，bean扫描器，接口定义
bean注册器其实是spring的bean定义后置处理器，将这个bean注册到spring的时候就会触发对应的方法。此时我们在postProcessBeanDefinitionRegistry这个方法中，使用bean扫描器扫描接口，并修改将接口的定义信息实现使用bean工厂构建bean的目的

1. bean工厂
   作用是根据接口创建代理实现

package com.dong.factory;

import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.FactoryBean;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.UUID;

/**
 * @Author dongzhihua
 * @Date 2021/1/4 22:40
 */
public class EntityBeanFactory<T> implements FactoryBean<T>, BeanClassLoaderAware {
    private Class<T> type;
    private ClassLoader classLoader;

    public EntityBeanFactory() {
        System.err.println("EntityBeanFactory");
    }

    public EntityBeanFactory(Class<T> type) {
        System.err.println("EntityBeanFactory type");
        this.type = type;
    }

    public T getObject() {
        InvocationHandler inv = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.err.printf("invoke %s#%s(%s)", proxy.getClass(), method.getName(), args);
                Class<?> returnType = method.getReturnType();
                if (returnType == Integer.class || returnType == int.class) {
                    return new Random().nextInt();
                }
                if (returnType == String.class) {
                    return UUID.randomUUID().toString();
                }
                if (returnType == List.class) {
                    return new ArrayList<Object>();
                }
                // 此处需要改进
                return returnType.newInstance();
            }
        };
        T res =  (T) Proxy.newProxyInstance(classLoader, new Class[]{type}, inv);
        return res;
    }

    public Class<?> getObjectType() {
        return type;
    }

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

2. bean注册器
   使用扫描器，将扫描到的类注册到spring容器中

package com.dong.registry;

import com.dong.config.MyBeanScanner;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;

/**
 * @Author dongzhihua
 * @Date 2021/1/4 21:57
 */
public class MyBeanRegistry implements BeanDefinitionRegistryPostProcessor {
    private String basePackage;

    public void setBasePackage(String basePackage) {
        this.basePackage = basePackage;
    }

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        ClassPathBeanDefinitionScanner scanner1 = new MyBeanScanner(registry);
        scanner1.scan(basePackage);
    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

3. bean扫描器
   根据包路径，扫描接口

package com.dong.config;

import com.dong.factory.EntityBeanFactory;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

import java.io.IOException;
import java.util.Set;

/**
 * @Author dongzhihua
 * @Date 2021/1/9 14:43
 */
public class MyBeanScanner extends ClassPathBeanDefinitionScanner {
    public MyBeanScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }

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

    public MyBeanScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {
        super(registry, useDefaultFilters, environment);
    }

    public MyBeanScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, ResourceLoader resourceLoader) {
        super(registry, useDefaultFilters, environment, resourceLoader);
    }

    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        addIncludeFilter(new TypeFilter() {
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
                return true;
            }
        });
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        for (BeanDefinitionHolder holder : beanDefinitionHolders) {
            GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
            definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());
            definition.setBeanClass(EntityBeanFactory.class);
        }
        return beanDefinitionHolders;
    }
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
    }
}

4. 接口
   定义业务接口

package com.dong.mapper;

import com.dong.entity.Product;

import java.util.List;

public interface ProductMapper {

    int save(Product product);

    List<Product> list();
}

5. 配置
   配置bean注册器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean class="com.dong.registry.MyBeanRegistry">
        <property name="basePackage" value="com.dong.mapper"/>
    </bean>
</beans>

6. 测试
   单元测试

package com.dong.scanner;

import com.dong.mapper.BlogMapper;
import com.dong.mapper.ProductMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-scan-test.xml")
public class MyBeanRegistryTest {
    @Resource
    ProductMapper product;
    
    @Test
    public void scan() {
        System.out.println(product.save(null));
        System.out.println(product.list());
        System.out.println("over...");
    }
}

EDN