- 定义一个EnableMapperScan注解
@Import(MapperProxyHandlerRegister.class) 标注将MapperProxyHandlerRegister导入到容器中。
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import(MapperProxyHandlerRegister.class)
public @interface EnableMapperScan {
String baskPackages();
}
- MapperProxyHandlerRegister
ImportBeanDefinitionRegistrar 是一个特殊组件，实现了这个接口的组件registry会动态给容器中批量注册组件，这里的关键就是获取到baskPackages 指定的路径，然后批量扫描classpath下的所有的接口，然后定义BeanDefinition，注册到容器中。
注意：AnnotationMetadata metadata封装的是标注了@Import注解的那个类。这样就可以拿到最终因哪个类扫描的这个配置类。
/**
* Mapper组件注册器
*/
public class MapperProxyHandlerRegister implements ImportBeanDefinitionRegistrar {
/**
* @param metadata 注意：metadata是Spring解析@Import注解标注的那个类的元信息，而不是导入的配置类的元信息
* @param registry BeanDefinition注册器
* @param generator BeanName生成器
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry,
BeanNameGenerator generator) {
//这里的这个metadata封装的是标注了@Import注解的那个类，如果标注@Import注解因其他类似@Enablexxx注解进一步解析到的
//那这里的metadata封装的就是解析@Enablexxx那个类的元数据信息，
//总之，metadata封装的就是Spring原始解析类上关联的@Import注解的类
Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(EnableMapperScan.class.getName());
String baskPackages = annotationAttributes.get("baskPackages").toString();
//获取此包下所有的类
try {
Set<Class<?>> scan = scan(baskPackages);
if (CollUtil.isNotEmpty(scan)){
//遍历接口
for (Class<?> mapperClass : scan) {
//注册到容器
RootBeanDefinition definition = new RootBeanDefinition();
definition.setBeanClass(MapperFactoryBean.class);
//设置构造方法参数值
ConstructorArgumentValues constructorArgumentValues = new ConstructorArgumentValues();
constructorArgumentValues.addIndexedArgumentValue(0,mapperClass);
definition.setConstructorArgumentValues(constructorArgumentValues);
//definition.setFactoryMethodName("getObject");
//注册Bean
registry.registerBeanDefinition(mapperClass.getName(),definition);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/*
1. 创建A --> 依赖B --> 创建B（依赖A） -> 为A创建代理对象 ，并从缓存中拿，后注入A的是一个代理对象。
* */
public static Set<Class<?>> scan(String basePackage) throws IOException, ClassNotFoundException {
// 创建一个扫描器
//ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
// 可以添加过滤器来筛选特定类型的类，这里先不添加任何过滤器，获取所有类
// 例如，如果只想获取带有特定注解的类，可以添加如下代码
// scanner.addIncludeFilter(new AnnotationTypeFilter(YourAnnotation.class));
// 如果只想获取特定接口的实现类，可以添加如下代码
// scanner.addIncludeFilter(new AssignableTypeFilter(YourInterface.class));
// 构建要扫描的资源路径模式
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + "/**/*.class";
Resource[] resources = resolver.getResources(packageSearchPath);
MetadataReaderFactory metadataReaderFactory = new SimpleMetadataReaderFactory();
Set<Class<?>> classes = new HashSet<>();
for (Resource resource : resources) {
MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
String sourceClassName = metadataReader.getClassMetadata().getClassName();
if (metadataReader.getClassMetadata().isInterface()){
//只扫描mapper接口
classes.add(Class.forName(sourceClassName));
}
//System.out.println("sourceClassName = " + sourceClassName);
// 排除接口和抽象类，只获取具体类
//if (!metadataReader.getClassMetadata().isInterface() &&!metadataReader.getClassMetadata().isAbstract()) {
// String className = metadataReader.getClassMetadata().getClassName();
// classes.add(Class.forName(className));
//}
}
return classes;
}
private static String resolveBasePackage(String basePackage) {
return basePackage.replace('.', '/');
}
- MapperProxy
这个类封装了代理对象的核心方法，主要就是获取mapper接口上标注了@Select @Update @Delete注解的方法，解析sql参数，获取sqlsessionfactory，然后执行sql。这里简单模拟输出获取到的sql。
/**
mapper组件动态代理方法拦截实现
*/
public class MapperProxy implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getDeclaringClass() == Object.class){
return method.invoke(this,args);
}
String name = method.getDeclaringClass().getName();
String methodName = method.getName();
System.out.println("mapperProxy 执行方法,被代理对象拦截 ===》 " + name + "." +methodName + "()");
Select select = method.getAnnotation(Select.class);
if (select != null){
String[] value = select.value();
//拦截方法
System.out.println("拦截到的SQL：===> " + Arrays.toString(value));
}
Class<?> returnType = method.getReturnType();
if (Number.class.isAssignableFrom(returnType) || returnType.isPrimitive()){
return 1;
}
return null;
}
}
- MapperFactoryBean
这个类实现了FactoryBean 接口，实现了这个接口的类Spring会进一步调用getObject方法创建Bean对象，这个Bean对象的类型是getObjectType返回的数据类型，由此，这个类型就是真正的Mapper接口类型，可以实现基于Mapper接口的自动装配。
public class MapperFactoryBean implements FactoryBean {
private Class mapperInterFaceClazz;
public MapperFactoryBean(Class mapperInterFaceClazz){
this.mapperInterFaceClazz = mapperInterFaceClazz;
}
@Override
public Object getObject() throws Exception {
/**
在创建代理对象时，传入需要实现的接口mapperInterFaceClazz
如果这个接口还继承了其他接口，在基于实现类调方法时，父接口的方法也会被代理对象拦截。
原理很简单，面向对象三大特征之一： 继承，子类继承父类，就把父类所有的内容全都继承
JVM在判断时，如果满足继承结构以及安全检查
*/
return Proxy.newProxyInstance(mapperInterFaceClazz.getClassLoader(),new Class[]{mapperInterFaceClazz},new MapperProxy());
}
@Override
public Class<?> getObjectType() {
return mapperInterFaceClazz;
}
}
- MainApp
@SpringBootApplication
@EnableMapperScan(baskPackages = "com.example.ssm3.mapper")
