Spring和Mybatis主流框架的部分源码分析

最新推荐文章于 2020-11-20 22:40:56 发布

L# S@

最新推荐文章于 2020-11-20 22:40:56 发布

阅读量283

点赞数 1

分类专栏： Spring源码分析

本文链接：https://blog.csdn.net/weixin_43790623/article/details/105837676

版权

Spring源码分析专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

Mybatis的简单查询

首先我们按照官方文档新建一个查询
配置数据源

@SpringBootApplication
@MapperScan("com.springmybatisexample.demo.Dao")
public class test implements ApplicationRunner {
    @Autowired
    UserService userService;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource source = new DriverManagerDataSource();
        source.setDriverClassName("com.mysql.cj.jdbc.Driver");
        source.setUrl("jdbc:mysql://localhost:3306/test?serverTimezone=UTC");//一定要加上时区
        source.setUsername("root");
        source.setPassword("123456");
        return source;
    }

    @Bean
    @Autowired
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean;
    }

    public static void main(String[] args) {
        SpringApplication.run(test.class, args);

    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        userService.list();
    }
}

写一个mapper

@Mapper
public interface UserDao {
    @Select("select * from test1")
    public List<Map<String,String>> FindUser();
}

实现mapper的一个service

@Service
public class UserService {

    @Autowired
    UserDao userDao;

    public void list(){
        List<Map<String, String>> users = userDao.FindUser();
        System.out.println(users);
    }

}

一个简单的通过mybaits查询数据库的方法就写完了

接下来执行操作

在这里插入图片描述

mybaits的核心功能

在我们的UserService类中注入的 userDao 这个userDao一定是个对象不然调用不了方法但是我们发现这个 userDao 是一个接口如果说 userDao 是个对象的话它一定是实现了userDao的某个类的对象所以我们就发现了一个问题 mapper类的实现是哪里来的？
通过官方文档 mybaits的流程大致如下：

 DataSource dataSource=null;//数据源
        Environment environment=null;//环境参数
        Configuration configuration = new Configuration(null);//配置类
        configuration.addMapper(UserDao.class);
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(configuration);
        //以上为初始化 SqlSessionFactory

        SqlSession sqlSession = build.openSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);//通过动态代理  我们返回了一个我们需要的对象
        mapper.FindUser();

我们看getMapper（）方法中动态代理的具体实现：
使用 ctrl+alt+b 查看这个接口的实现类在 DefaultSqlSession 类中进行的实现最后我们找到这个

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
        if (mapperProxyFactory == null) {
            throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        } else {
            try {
                return mapperProxyFactory.newInstance(sqlSession);
            } catch (Exception var5) {
                throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
            }
        }
    }

我们可以看到它有一个返回值 return mapperProxyFactory.newInstance(sqlSession);
所以这一行代码的意义 UserDao mapper = sqlSession.getMapper(UserDao.class)
就是返回了一个代理对象底层是通过jdk包下的类实现的

 protected T newInstance(MapperProxy<T> mapperProxy) {
        return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
    }

最终我们可以得到一个大概的结论：mybaits的核心功能就是通过JDK的动态代理来产生了一个代理对象代理对象实现了我们的dao/mapper

模拟mybatis的核心功能

因为我们可以看到 spring的动态代理使用的是sqlSession.getMapper实现的所以我们也写一个
叫 EnjoySessions
需要注意的是我们在这个地方产生的类是没有对象的它的对象在内存中大概长这个样子

public class EnjoySessions  {
    public static Object GetMapper(Class clazz){

        Class[] classes =new Class[] {clazz};//这个对象 需要实现的接口
        Object o=Proxy.newProxyInstance(EnjoySessions.class.getClassLoader(),classes,new EnjoyHandler());//mybatis中的方法
                //第一个参数 类加载器 基本上 就是这个类的类加载器  
                //第三个参数 也就是说  当我们调用mapper.FindUser(); 这个方法的时候 会执行到handler中的invoke中
        return null;
    }
}

public class A implements UserDao {


    @Override
    public List<Map<String, String>> FindUser() {
        //去调用这个接口对象的invoke()方法;
        //invoke();
        return null;
    }
}

特别是第三个参数其意义是当我们调用FindUser方法的时候它会去调用EnjoyHandler中的invoke方法进行数据库的连接查询

public class EnjoyHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("conn");//数据库的连接
        String s = method.getAnnotation(Select.class).value()[0];//读取到selec上写的SQL语句 多个select的话 用循环处理
        System.out.println(s);
        return null;
    }
}

结果如下：
在这里插入图片描述

将模拟出的Mybatis和Spring配合工作

需求：将我们产生的对象放到spring的容器当中

如何把一个对象交给spring管理？
1、xml配置？<bean>?
2、注解方式 @Controller?
3、@bean 方式？
4、通过spring ApplicationContext的api方式？
5、扩展spring动态加入BeanDefinition方式？
6、通过FactoryBean的方式？

把一个对象交个给pring管理只有3和6可以
其他的方法都是将类交给spring管理

他们的区别
把类交给spring管理在spring扫描到它之后会对它进行实例化
把对象交给spring管理我们可以自己控制对象的产生过程

比如说我们之前使用的newProxyInstance 它是存在于mybatis中的方法 spring中不存在

使用@bean

public class test implements ApplicationRunner {
  
    @Autowired
    UserDao dao;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource source = new DriverManagerDataSource();
        source.setDriverClassName("com.mysql.cj.jdbc.Driver");
        source.setUrl("jdbc:mysql://localhost:3306/test?serverTimezone=UTC");//一定要加上时区
        source.setUsername("root");
        source.setPassword("123456");
        return source;
    }

    @Bean
    @Autowired
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean;
    }

    @Bean
    public UserDao userDao(){
        UserDao o = (UserDao) EnjoySessions.GetMapper(UserDao.class);
        return o;

    }

    public static void main(String[] args) {
        SpringApplication.run(test.class, args);

    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
      
        dao.FindUser();

       
    }
}

在这里插入图片描述

使用FactoryBean
因为我们不可能每一个bean都去自己写所以 mybatis使用的是这个方法

@Component
public class EnjoyFactoryBean implements FactoryBean {
    //FactoryBean  自己是一个bean  里面的getObject返回的对象也是个bean   只能返回一个mapper
 
    @Override
    public Object getObject() throws Exception {
        UserDao o = (UserDao) EnjoySessions.GetMapper(UserDao.class);
        return o;
    }

    @Override
    //告诉上面 返回对象的类型
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

运行的时候把UserDao的注释去掉
在这里插入图片描述
当然这种处理还是很简陋的无法处理多个bean 所以为了处理多个bean 进行改进：

@Component
public class EnjoyFactoryBean implements FactoryBean {
    //FactoryBean  自己是一个bean  里面的getObject返回的对象也是个bean   只能返回一个mapper
    Class mapperInterface;


    public void setMapperInterface(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    @Override
    public Object getObject() throws Exception {
        Object o = EnjoySessions.GetMapper(mapperInterface);
        return o;
    }

    @Override
    //告诉上面 返回对象的类型
    public Class<?> getObjectType() {
        return mapperInterface;
    }
}

每次调方法的时候传入 class即可

当然在bean创建生成之后一般来说会保存在一个全局变量list中是不能修改的

bean生成的具体流程
首先通过类加载器将被注解的类和为注解的类通过 javac 变成 .class文件
run 之后当 spring容器扫描到被注解的类之后将这个类变成BeanDefinition对象
伪代码：

  Map map=null;//spring的全局变量
        List<Class> list = null;//保存的被扫描出来的信息
        for (Class aClass : list) {
            GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
            //通过这个对象 将扫描出来的类的信息 保存到这个对象里面
            genericBeanDefinition.setBeanClass(aClass);//设置bean的名字
            genericBeanDefinition.setScope("pro");//设置作用域
            genericBeanDefinition.setAutowireMode(1);//设置类的注入模型  是通过byname还是bytype 还是通过构造方法
            genericBeanDefinition.setLazyInit(true);//是否懒加载
            ...
            ...
            map.put("x",genericBeanDefinition);//将信息对象放到map中
        }
        map.forEach(
                //取出里面的信息 然后new出来
        );

我们程序员通过写的实现BeanFactoryPostProcessor接口的方法
即通过我们写的这个方法对于list 进行操作
比如说我们现在有A B 两个类一个有注解一个无注解我们可以通过这个方法取出名为x的bean 然后将y注入

例子

@Component
public class X {
}

public class Y {
    public void test(){
        System.out.println("aaa");
    }
}

@Component
public class EnjoyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory BeanFactory) throws BeansException {
        GenericBeanDefinition x = (GenericBeanDefinition) BeanFactory.getBeanDefinition("x");//通过全局变量map 去取出我们需要的信息对象 不过 这个map我们只有间接权限
        x.setBeanClass(Y.class);

    }
}

@SpringBootApplication
//@MapperScan("com.springmybatisexample.demo.Dao")
public class test implements ApplicationRunner {
    //@Autowired
    //UserService userService;

    //@Autowired
    //UserDao dao;

    @Autowired
    Y y;

    public static void main(String[] args) {
        SpringApplication.run(test.class, args);

    }
    @Override
    public void run(ApplicationArguments args) throws Exception {
        y.test();
    }
    }

在这里插入图片描述
这个时候我们取x 是取不到的
由此可知在spring中一个bean的产生与提供的类关系不大因为中间有可能被篡改只有和其对应的BeanDefinition 有关系
即我们创建一个bean 可以不通过扫描直接通过创建相应的 BeanDefinition 加入到Map中就行
这个接口只通供了我们对map的访问权限

如果要对这个mapper进行操作我们就需要实现 ImportBeanDefinitionRegistrar 接口
这个方法 spring自己会回调在spring容器扫描完了之后放到这个map之后就会调用程序员提供的这个类

public class EnjoyBeanDefinitionRegistart implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //这个方法 spring自己会回调 在spring容器扫描完了之后 放到这个map之后 就会调用 程序员提供的这个类
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(EnjoyFactoryBean.class);
        //通过BeanDefinitionBuilder的genericBeanDefinition方法 创建一个 BeanDefinitionBuilder 并取出它的beanDefinition
        AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
        beanDefinition.getPropertyValues().add("mapperInterface", UserDao.class);
        //这个一个集合
        registry.registerBeanDefinition(String.valueOf(EnjoyFactoryBean.class),beanDefinition );//bean的名字 BeanDefinition
    }
}

在这里插入图片描述
输出正常

当然目前是写死的我们需要对他进行一个循环操作

    List<Class> list=null;//保存 需要装配的bean
        for(class clazz : list){
            //这个方法 spring自己会回调 在spring容器扫描完了之后 放到这个map之后 就会调用 程序员提供的这个类
            BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(EnjoyFactoryBean.class);
            //通过BeanDefinitionBuilder的genericBeanDefinition方法 创建一个 BeanDefinitionBuilder 并取出它的beanDefinition
            AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
            beanDefinition.getPropertyValues().add("mapperInterface", UserDao.class);
            //这个一个集合
            registry.registerBeanDefinition(String.valueOf(EnjoyFactoryBean.class), beanDefinition);//bean的名字 BeanDefinition
        }

importingClassMetadata 这个是传进来的包名通过这个包名将其下的所有dao扫描出来

同样 @MapperScan(“com.springmybatisexample.demo.Dao”) 等价于
我们自己建的 @HuiScan(“com.springmybatisexample.demo.Dao”)

@Retention(RetentionPolicy.RUNTIME)
@Import(EnjoyBeanDefinitionRegistart.class)
public @interface HuiScan {
}

总结

说来说去我们也就用了Spring中的3个扩展点分别为：

FactoryBean
将多个dao 初始化为bean 通过GetMapper( )方法这里面又通过了Proxy.newProxyInstance(EnjoySessions.class.getClassLoader(), classes, new EnjoyHandler());
这个jdk的方法其中的 EnjoyHandler( ) 是我们调对象方法的时候会掉这个对象中的 invoke( )方法，在里面实现了数据库的连接 jdbc的实现返回我们需要的数据
当然多个bean的话要使用 ImportBeanDefinitionRegistrar 进行辅助

BeanFactoryPostProcessor
可以将全局变量map中创建出的bean 根据名字取出来然后放新的class

ImportBeanDefinitionRegistrar
可以对于全局变量map 继续增加操作通过注解将importingClassMetadata（需要扫描的包名）下的所有类通过循环使用mapperInterface注入进去完成扫描
这个方法 spring自己会回调在spring容器扫描完了之后放到这个map之后就会调用程序员提供的这个类

L# S@

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring和Mybatis主流框架的部分源码分析

Mybatis的简单查询首先我们按照官方文档新建一个查询配置数据源@SpringBootApplication@MapperScan("com.springmybatisexample.demo.Dao")public class test implements ApplicationRunner { @Autowired UserService userServic...
复制链接

扫一扫

专栏目录