Mybatis是一个优秀的ORM框架，它支持定制化 SQL、存储过程以及高级映射，对Mybatis不熟悉的可以查看我的这篇文章：Mybatis原理，在使用中，我们往往会很惊讶，为啥我只定义了一个接口，就可以进行依赖注入，而且还能对数据库进行操作，这其实是基于代理模式来实现的，对动态代理不了解的可以查看这篇文章：Java代理模式
本文将介绍如何实现和Mybatis一样，在SpringBoot启动的时候自动为所有接口创建代理实现类
一、创建核心包
这个包主要提供注册代理实现类的一些核心类
1、pom文件如下
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.gjing</groupId>
<artifactId>proxy-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>common</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>common</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<!--Compiler-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>2、定义一个基础接口
/**
* @author Gjing
**/
public interface BaseService {
void ok();
}3、定义基础接口的实现类
/**
* @author Gjing
**/
class DefaultService implements BaseService {
@Override
public void ok() {
System.out.println("ok");
}
}4、定义一个代理类
/**
* @author Gjing
**/
class ServiceProxy<T> implements InvocationHandler {
private Class<T> interfaces;
ServiceProxy(Class<T> interfaces) {
this.interfaces = interfaces;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getDeclaringClass().equals(interfaces)) {
System.out.println("执行您的方法：" + method.getName());
return method.getName();
} else {
return method.invoke(new DefaultService(), args);
}
}
}
5、定义代理类实现工厂
/**
* @author Gjing
**/
class ServiceProxyFactoryBean<T> implements FactoryBean<T> {
private Class<T> interfaces;
public ServiceProxyFactoryBean(Class<T> interfaces) {
this.interfaces = interfaces;
}
@Override
@SuppressWarnings("unchecked")
public T getObject() throws Exception {
return (T) Proxy.newProxyInstance(interfaces.getClassLoader(), new Class[]{interfaces},
new ServiceProxy<>(interfaces));
}
@Override
public Class<?> getObjectType() {
return interfaces;
}
@Override
public boolean isSingleton() {
return true;
}
}6、定义接口扫描类
/**
* @author Gjing
**/
class ServiceInterfacesScanner extends ClassPathBeanDefinitionScanner {
ServiceInterfacesScanner(BeanDefinitionRegistry registry) {
//false表示不使用ClassPathBeanDefinitionScanner默认的TypeFilter
super(registry, false);
}
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
this.addFilter();
Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
if (beanDefinitionHolders.isEmpty()) {
throw new NullPointerException("No interfaces");
}
this.createBeanDefinition(beanDefinitionHolders);
return beanDefinitionHolders;
}
/**
* 只扫描顶级接口
* @param beanDefinition bean定义
* @return boolean
*/
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
AnnotationMetadata metadata = beanDefinition.getMetadata();
String[] interfaceNames = metadata.getInterfaceNames();
return metadata.isInterface() && metadata.isIndependent()&& Arrays.asList(interfaceNames).contains(BaseService.class.getName());
}
/**
* 扫描所有类
*/
private void addFilter() {
addIncludeFilter((metadataReader, metadataReaderFactory) -> true);
}
/**
* 为扫描到的接口创建代理对象
*
* @param beanDefinitionHolders beanDefinitionHolders
*/
private void createBeanDefinition(Set<BeanDefinitionHolder> beanDefinitionHolders) {
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
GenericBeanDefinition beanDefinition = ((GenericBeanDefinition) beanDefinitionHolder.getBeanDefinition());
//将bean的真实类型改变为FactoryBean
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
beanDefinition.setBeanClass(ServiceProxyFactoryBean.class);
beanDefinition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
}
}
}7、定义注册类
/**
* @author Gjing
**/
public class ProxyRegister implements BeanDefinitionRegistryPostProcessor {
private String basePackage;
public ProxyRegister(String basePackage) {
this.basePackage = basePackage;
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
if (ParamUtil.isEmpty(basePackage)) {
return;
}
ServiceInterfacesScanner scanner = new ServiceInterfacesScanner(registry);
scanner.doScan(basePackage);
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
}整个核心包就完成了，接下来定义一个普通项目并使用它
二、创建普通项目
1、引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--引入刚刚定义的核心类-->
<dependency>
<groupId>com.gjing</groupId>
<artifactId>common</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>2、定义一个接口
/**
* @author Gjing
*/
public interface UserService extends BaseService {
String getMethodName();
}3、定义一个controller
/**
* @author Gjing
**/
@RestController
public class TestController {
@Resource
private UserService userService;
@GetMapping("/test")
public void test() {
userService.ok();
userService.getMethodName();
}
}4、配置接口扫描路径
/**
* @author Gjing
**/
@Configuration
public class DemoConfiguration {
@Bean
public ProxyRegister proxyRegister() {
return new ProxyRegister("com.example.demo.service");
}
}5、启动
可以看到，我们注入的对象是我们定义的代理类
控制台输出
本文到此就结束啦，如果文章中有任何错误或者疑问，可以在评论区留言，我会及时回复，本文源代码地址：proxy-demo
