单例Bean，单例模式，单例池之间的联系与底层原理
单例Bean：不是指在Spring容器中只有一个userService类型的对象，可以有多个此类型的对象。Spring找到对应的对象是先 byType 再 byName。
通过@Bean标签就可以看出来Spring中的单例Bean并不是指只有一个此类型的对象。
单例模式：单例类只能有一个实例，单例类必须自己创建自己的唯一实例，单例类必须给所有类提供这一实例。
单例池：是用来是实现单例Bean的，单例池就是一个Map Bean对象的名字就是它的键，bean对象就是值。
FactoryBean的作用和底层
public class UserService {
@Autowired
UserMapper userMapper;
public void test(){
System.out.println(userMapper.get());
}
}
对于这个userMapper它就是MyBatils框架创建的代理对象，是由MyBatils创建的代理对象赋值给这个userMapper。
Spring想要使用这个MyBatils所产生的对象，就要把他放入到Spring容器中成为一个Bean，那么他是怎么让这个对象成为这个Bean的呢？
Spring事务的实现：
1 申明式：@Transan
2 编程式：使用TransaMananger类
如何定义一个Bean；
1 申明式：@Bean @Service <bean>....
2 编程式：使用BeanDefinition
package com.test.pojo;
public class User {
}
package com.test;
import com.test.pojo.User;
import com.test.service.UserService;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan("com.test")
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);
context.refresh();
System.out.println(context.getBean("user"));
// UserService userService = context.getBean("userService", UserService.class);
// userService.test();
}
}
Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'user' available
我们这样式得不到这个User对象的，因为我们只是扫描了这个类，但是并没有将他放到我们Spring容器中，所以我们还需要一步。
@ComponentScan("com.test")
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("user",beanDefinition);
context.refresh();
System.out.println(context.getBean("user"));}}
com.test.pojo.User@6dde5c8c
这就是我们的编程式得到Bean对象，那么我们的这些@Bean @Component....注解的底层肯定跟这个beanDefintion有很大的关系。也就是说式BeanDefinition实现的注解。
那么我们将User.class 换成UserService.class就可以得UserService对象嘛？
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(UserMapper.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("user",beanDefinition);
context.refresh();
System.out.println(context.getBean("user"));
org.springframework.context.support.AbstractApplicationContext refresh
答案式否定的，并不能得到UserService对象，下面我们就引出FactoryBean。
FactoryBean中有三个方法，你想去实现一个接口你就得实现他的方法，但是这里有默认实现，你就可以不用实现，也可以实现接口。（java8才可以，java7无法实现）
public class LuoGeBeanFactory implements FactoryBean {
public Object getObject() throws Exception {
return new User();
}
public Class<?> getObjectType() {
return User.class;
}
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//此时的LuoGeBeanFactory对应了两个对象
beanDefinition.setBeanClass(LuoGeBeanFactory.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("user",beanDefinition);
context.refresh();
System.out.println(context.getBean("user"));
System.out.println(context.getBean("&user"));
com.test.pojo.User@35a50a4c
com.mybatils.spring.LuoGeBeanFactory@1f021e6c
我们可以看到确实得到了LuoGeBeanFactory和User两个对象。那么现在我们就知道怎么才能得到这个MyBatils对象了，这也就是怎么注入MyBatils对象到Spring中。
@Component
public class UserService {
@Autowired
UserMapper userMapper;
public void test(){
System.out.println(userMapper.get());
}
}
public class LuoGeBeanFactory implements FactoryBean {
public Object getObject() throws Exception {
// 想要使用UserMapper对象， 我们就需要进行代理,这样我们就得到了这个代理对象。
Object o = Proxy.newProxyInstance(UserMapper.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName());
return null;
}
});
return o;
}
public Class<?> getObjectType() {
return UserMapper.class;
}
}
@ComponentScan("com.test")
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(LuoGeBeanFactory.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("xxx",beanDefinition);
context.refresh();
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
get
null
这里的get就是我们调用的那个方法，这个null是这个方法返回的null;
这里的null其实是userService对象，但是我们输出这个对象需要调用对象的toString方法。
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
这个jar包里面其实也就是在做我们刚才FactoryBean的事，但是我们发现了这个方法里面的UserService.class是定死了的Proxy.newProxyInstance(UserMapper.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() 问题又出现了，难道我们只能用这一个类吗？
public interface PeopleMapper {
User set();
}
public class LuoImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
List<Class> list = new ArrayList<Class>();
list.add(PeopleMapper.class);
list.add(UserMapper.class);
for (Class aClass : list) {
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(LuoGeBeanFactory.class);
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(aClass);
//将user对象注入到这个beanDefintion中。
registry.registerBeanDefinition(aClass.getName(),beanDefinition);
}
}
}
}
@ComponentScan("com.test")
@Import(LuoImportBeanDefinitionRegistrar.class)
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
context.refresh();
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
null;
我们有了第二个Mapper的时候，我们就不能再把其中的类写死了，我们将它写成一个变量，再调用有参构造来注入它，当然我们再把除了启动Spring的代码移出去，移到ImportBeanDefinitionRegistrar类上，这也是我们启动前执行的类，将它通过@Imput注解将它注入到主要执行的代码中，他就可以实现不同的Mapper对象注入了。当然我们把所有需要的Mapper类都放到List集合中进行遍历就可以实现伪自动注入了。现在我么又引出一个问题，怎么才能扫描储所有的Mapper对象？
就是通过beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(aClass)方法把对应的类名传给LuoGeBeanFactory的有参构造进行赋值，但是因为我们在LuoGeBeanFactory存的就是mapper，再把beanDefinition的BeanClassName设置为原来的就可以了。
package com.mybatils.spring;
import com.test.mapper.PeopleMapper;
import com.test.mapper.UserMapper;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
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.ArrayList;
import java.util.List;
public class LuoImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 1 扫描 2 扫描路径
String path = "com.test.mapper";
//扫描注册表
LuoMapperScanner luoMapperScanner = new LuoMapperScanner(registry);
luoMapperScanner.addIncludeFilter(new TypeFilter() {
//由于这个scan扫描默认会排除一些东西，return true相当于不排除的意思，支持所有
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
return true;
}
});
int sacn = luoMapperScanner.scan(path);// 2个mapper
System.out.println(sacn);
}
}
package com.mybatils.spring;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import java.util.Set;
public class LuoMapperScanner extends ClassPathBeanDefinitionScanner {
//Spring 的扫描器
public LuoMapperScanner(BeanDefinitionRegistry registry) {
super(registry);
}
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
// 这里得到beanDefinitionHolders就是扫描了Mapper
Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
//我们得到的还是Mapper的接口，并不能得到对象 我们已经得到BeanFinition 并把他注入进去了
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
//设置LuoGeBeanFactory类构造方法的参数值，将类名传入进行代理，得到代理对象
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
//遍历出来的BeanClass是不对的 是个接口 我们修改它成为它所对应的class名因为我们一开始就是需要beanClass名称才能得到对应的接口类
beanDefinition.setBeanClassName(LuoGeBeanFactory.class.getName());
}
return beanDefinitionHolders;
}
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
//我们只需要找到属于接口的类跟Spring恰恰相反，Spring需要的是可以实现的类。
return beanDefinition.getMetadata().isInterface();
}
}
package com.mybatils.spring;
import com.sun.org.apache.regexp.internal.RE;
import com.test.mapper.UserMapper;
import com.test.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class LuoGeBeanFactory implements FactoryBean {
private Class mapperClass;
private SqlSession sqlSession;
public LuoGeBeanFactory(Class mapperClass) {
this.mapperClass = mapperClass;
}
@Autowired
public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
this.sqlSession = sqlSessionFactory.openSession();
}
public Object getObject() throws Exception {
// //想要使用UserMapper对象， 我们就需要进行代理,这样我们就得到了这个代理对象。
// Object o = Proxy.newProxyInstance(UserMapper.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// System.out.println(method.getName());
// return null;
// }
// });
// return o;
//直接通过sqlSession得到mapper
return sqlSession.getMapper(mapperClass);
}
public Class<?> getObjectType() {
return mapperClass;
}
}
package com.test;
import com.mybatils.spring.LuoGeBeanFactory;
import com.mybatils.spring.LuoImportBeanDefinitionRegistrar;
import com.test.mapper.UserMapper;
import com.test.pojo.User;
import com.test.service.UserService;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
import java.io.IOException;
import java.io.InputStream;
@ComponentScan("com.test")
@Import(LuoImportBeanDefinitionRegistrar.class)
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
@Bean
public SqlSessionFactory sqlSessionFactory() throws IOException {
//只需要的到一个sqlSessionFactory 文件可以随便写
InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
return sqlSessionFactory;
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
context.refrJ();
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
2
people
people
通过LuoMapperScanner调用scan底层就是doScan方法进行对这个包的扫描的到我们想要的Mapper对象，再dosacn方法中我们我们取出本来就存入了beanDefinition的BeanClass名字（），再将它设置为原来的名字设置为beanDefinitionHolders（这里得到beanDefinitionHolders就是扫描了Mapper），这里我们就得到了mapper层的所有接口类了，所以scan的值是2，这里我们再通过方法的到SqlSessionFactory对象，SqlSessionFactory就可以直接getMapper了，这就是我们的Spring Mybatis的整合基本原理。
————————————————
版权声明：本文为CSDN博主「本来写bug却写成了程序」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_57560984/article/details/120442474
#Java源码##学习路径#
通过@Bean标签就可以看出来Spring中的单例Bean并不是指只有一个此类型的对象。
单例模式：单例类只能有一个实例，单例类必须自己创建自己的唯一实例，单例类必须给所有类提供这一实例。
单例池：是用来是实现单例Bean的，单例池就是一个Map Bean对象的名字就是它的键，bean对象就是值。
FactoryBean的作用和底层
public class UserService {
@Autowired
UserMapper userMapper;
public void test(){
System.out.println(userMapper.get());
}
}
对于这个userMapper它就是MyBatils框架创建的代理对象，是由MyBatils创建的代理对象赋值给这个userMapper。
Spring想要使用这个MyBatils所产生的对象，就要把他放入到Spring容器中成为一个Bean，那么他是怎么让这个对象成为这个Bean的呢？
Spring事务的实现：
1 申明式：@Transan
2 编程式：使用TransaMananger类
如何定义一个Bean；
1 申明式：@Bean @Service <bean>....
2 编程式：使用BeanDefinition
package com.test.pojo;
public class User {
}
package com.test;
import com.test.pojo.User;
import com.test.service.UserService;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan("com.test")
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);
context.refresh();
System.out.println(context.getBean("user"));
// UserService userService = context.getBean("userService", UserService.class);
// userService.test();
}
}
Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'user' available
我们这样式得不到这个User对象的，因为我们只是扫描了这个类，但是并没有将他放到我们Spring容器中，所以我们还需要一步。
@ComponentScan("com.test")
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("user",beanDefinition);
context.refresh();
System.out.println(context.getBean("user"));}}
com.test.pojo.User@6dde5c8c
这就是我们的编程式得到Bean对象，那么我们的这些@Bean @Component....注解的底层肯定跟这个beanDefintion有很大的关系。也就是说式BeanDefinition实现的注解。
那么我们将User.class 换成UserService.class就可以得UserService对象嘛？
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(UserMapper.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("user",beanDefinition);
context.refresh();
System.out.println(context.getBean("user"));
org.springframework.context.support.AbstractApplicationContext refresh
答案式否定的，并不能得到UserService对象，下面我们就引出FactoryBean。
FactoryBean中有三个方法，你想去实现一个接口你就得实现他的方法，但是这里有默认实现，你就可以不用实现，也可以实现接口。（java8才可以，java7无法实现）
public class LuoGeBeanFactory implements FactoryBean {
public Object getObject() throws Exception {
return new User();
}
public Class<?> getObjectType() {
return User.class;
}
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//此时的LuoGeBeanFactory对应了两个对象
beanDefinition.setBeanClass(LuoGeBeanFactory.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("user",beanDefinition);
context.refresh();
System.out.println(context.getBean("user"));
System.out.println(context.getBean("&user"));
com.test.pojo.User@35a50a4c
com.mybatils.spring.LuoGeBeanFactory@1f021e6c
我们可以看到确实得到了LuoGeBeanFactory和User两个对象。那么现在我们就知道怎么才能得到这个MyBatils对象了，这也就是怎么注入MyBatils对象到Spring中。
@Component
public class UserService {
@Autowired
UserMapper userMapper;
public void test(){
System.out.println(userMapper.get());
}
}
public class LuoGeBeanFactory implements FactoryBean {
public Object getObject() throws Exception {
// 想要使用UserMapper对象， 我们就需要进行代理,这样我们就得到了这个代理对象。
Object o = Proxy.newProxyInstance(UserMapper.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName());
return null;
}
});
return o;
}
public Class<?> getObjectType() {
return UserMapper.class;
}
}
@ComponentScan("com.test")
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(LuoGeBeanFactory.class);
//将user对象注入到这个beanDefintion中。
context.registerBeanDefinition("xxx",beanDefinition);
context.refresh();
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
get
null
这里的get就是我们调用的那个方法，这个null是这个方法返回的null;
这里的null其实是userService对象，但是我们输出这个对象需要调用对象的toString方法。
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
这个jar包里面其实也就是在做我们刚才FactoryBean的事，但是我们发现了这个方法里面的UserService.class是定死了的Proxy.newProxyInstance(UserMapper.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() 问题又出现了，难道我们只能用这一个类吗？
public interface PeopleMapper {
User set();
}
public class LuoImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
List<Class> list = new ArrayList<Class>();
list.add(PeopleMapper.class);
list.add(UserMapper.class);
for (Class aClass : list) {
//表示用来定义bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(LuoGeBeanFactory.class);
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(aClass);
//将user对象注入到这个beanDefintion中。
registry.registerBeanDefinition(aClass.getName(),beanDefinition);
}
}
}
}
@ComponentScan("com.test")
@Import(LuoImportBeanDefinitionRegistrar.class)
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
context.refresh();
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
null;
我们有了第二个Mapper的时候，我们就不能再把其中的类写死了，我们将它写成一个变量，再调用有参构造来注入它，当然我们再把除了启动Spring的代码移出去，移到ImportBeanDefinitionRegistrar类上，这也是我们启动前执行的类，将它通过@Imput注解将它注入到主要执行的代码中，他就可以实现不同的Mapper对象注入了。当然我们把所有需要的Mapper类都放到List集合中进行遍历就可以实现伪自动注入了。现在我么又引出一个问题，怎么才能扫描储所有的Mapper对象？
就是通过beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(aClass)方法把对应的类名传给LuoGeBeanFactory的有参构造进行赋值，但是因为我们在LuoGeBeanFactory存的就是mapper，再把beanDefinition的BeanClassName设置为原来的就可以了。
package com.mybatils.spring;
import com.test.mapper.PeopleMapper;
import com.test.mapper.UserMapper;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
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.ArrayList;
import java.util.List;
public class LuoImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 1 扫描 2 扫描路径
String path = "com.test.mapper";
//扫描注册表
LuoMapperScanner luoMapperScanner = new LuoMapperScanner(registry);
luoMapperScanner.addIncludeFilter(new TypeFilter() {
//由于这个scan扫描默认会排除一些东西，return true相当于不排除的意思，支持所有
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
return true;
}
});
int sacn = luoMapperScanner.scan(path);// 2个mapper
System.out.println(sacn);
}
}
package com.mybatils.spring;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import java.util.Set;
public class LuoMapperScanner extends ClassPathBeanDefinitionScanner {
//Spring 的扫描器
public LuoMapperScanner(BeanDefinitionRegistry registry) {
super(registry);
}
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
// 这里得到beanDefinitionHolders就是扫描了Mapper
Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
//我们得到的还是Mapper的接口，并不能得到对象 我们已经得到BeanFinition 并把他注入进去了
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
//设置LuoGeBeanFactory类构造方法的参数值，将类名传入进行代理，得到代理对象
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
//遍历出来的BeanClass是不对的 是个接口 我们修改它成为它所对应的class名因为我们一开始就是需要beanClass名称才能得到对应的接口类
beanDefinition.setBeanClassName(LuoGeBeanFactory.class.getName());
}
return beanDefinitionHolders;
}
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
//我们只需要找到属于接口的类跟Spring恰恰相反，Spring需要的是可以实现的类。
return beanDefinition.getMetadata().isInterface();
}
}
package com.mybatils.spring;
import com.sun.org.apache.regexp.internal.RE;
import com.test.mapper.UserMapper;
import com.test.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class LuoGeBeanFactory implements FactoryBean {
private Class mapperClass;
private SqlSession sqlSession;
public LuoGeBeanFactory(Class mapperClass) {
this.mapperClass = mapperClass;
}
@Autowired
public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
this.sqlSession = sqlSessionFactory.openSession();
}
public Object getObject() throws Exception {
// //想要使用UserMapper对象， 我们就需要进行代理,这样我们就得到了这个代理对象。
// Object o = Proxy.newProxyInstance(UserMapper.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// System.out.println(method.getName());
// return null;
// }
// });
// return o;
//直接通过sqlSession得到mapper
return sqlSession.getMapper(mapperClass);
}
public Class<?> getObjectType() {
return mapperClass;
}
}
package com.test;
import com.mybatils.spring.LuoGeBeanFactory;
import com.mybatils.spring.LuoImportBeanDefinitionRegistrar;
import com.test.mapper.UserMapper;
import com.test.pojo.User;
import com.test.service.UserService;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
import java.io.IOException;
import java.io.InputStream;
@ComponentScan("com.test")
@Import(LuoImportBeanDefinitionRegistrar.class)
public class LuoGeApplaction implements InstantiationAwareBeanPostProcessor {
@Bean
public SqlSessionFactory sqlSessionFactory() throws IOException {
//只需要的到一个sqlSessionFactory 文件可以随便写
InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
return sqlSessionFactory;
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(LuoGeApplaction.cla***Spring
context.refrJ();
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
2
people
people
通过LuoMapperScanner调用scan底层就是doScan方法进行对这个包的扫描的到我们想要的Mapper对象，再dosacn方法中我们我们取出本来就存入了beanDefinition的BeanClass名字（），再将它设置为原来的名字设置为beanDefinitionHolders（这里得到beanDefinitionHolders就是扫描了Mapper），这里我们就得到了mapper层的所有接口类了，所以scan的值是2，这里我们再通过方法的到SqlSessionFactory对象，SqlSessionFactory就可以直接getMapper了，这就是我们的Spring Mybatis的整合基本原理。
————————————————
版权声明：本文为CSDN博主「本来写bug却写成了程序」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_57560984/article/details/120442474
#Java源码##学习路径#
