Mybatis工作原理浅析

最新推荐文章于 2024-06-13 11:40:44 发布

hedongxu1111

最新推荐文章于 2024-06-13 11:40:44 发布

阅读量169

点赞数

文章标签： mybatis mybatis和spring整合原理 mybatis原理

本文链接：https://blog.csdn.net/u014018804/article/details/103304489

版权

Mybatis官方网址

https://mybatis.org/spring/（mybatis-spring）
https://mybatis.org/mybatis-3/（mybatis）

Mybatis最核心的两点

要学习Mybatis的工作原理，可以从搞清楚以下两个问题入手：

一、Mybatis是怎么实现的返回Mapper接口的对象完成对数据库的增删改查操作（Mapper是咱们自己定义的接口，里面定义了一些对数据库增删改查的方法）

public interface UserMapper {
    @Select("select user_name,email from icm_user")
    public List<Map<String,String>> query();
}
SqlSession session = sqlSessionFactory.openSession()) {
UserMapper userMapper = session.getMapper(UserMapper .class);
List<Map<String,String>>  list = mapper.query();

二、第一点并不难，应该是返回的动态代理的对象，Mybatis底层源码这块也是利用的JDK动态代理技术返回的Mapper代理对象，但是这个动态代理的对象是怎么交给Spring容器管理的哪？把一个【类】交给spring容器和把一个【对象】交给spring容器是有区别的，一个【类】交给spring管理可以在类上面加一个@Component注解，这样的话对象的产生过程就交给spring来管理了。
如何把一个对象怎么放到spring容器中那？就是对象的产生过程自己可以控制，有一下两种方式：
（1）@Bean注解
（2）实现FactoryBean接口，在getObject()方法里面返回对象，这样的话这个对象也是被spring容器管理的，实现了FactoryBean接口的Bean，根据该Bean的Id从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，可以在id前面加一个&符号来获取。
（3）调用AnnotationConfigApplicationContext对象的getBeanFactory().registerSingleton()方法（不常用）

在Mybatis的启动类上加一个@MapperScan(“com.xx.xx.mapper”)或者在xml配置文件中配置要扫描的Mapper，指定一下要扫描的包，就可以把UserMapper通过@Autowired注解自动注入了其他业务类作为属性，这个UserMapper是动态代理对象肯定是没有疑问的了，但是这个动态代理对象是动态产生的，Mybatis又是怎么做到的把这个动态代理对象放到spring容器中的，下面用代码来简单模拟一下这个过程的原理。

（1）AppConfig 类，在main方法中初始化spring容器，调用容器getBean方法拿到UserMapper代理类对象，调用query方法完成查询数据库的操作，其中MyScan是自己定义的注解（类似mybatis的MapperScan注解的作用），还把SqlSessionFactoryBean 、DataSource 加到了spring容器中
（2）自定义MyMapperFactoryBean（类似mybatis的MapperFactoryBean）实现FactoryBean接口（利用了spring的扩展点），在getObject方法里面通过jdk动态代理返回代理对象，其中属性1、SqlSessionFactory sqlSessionFactory，可以从spring容器中拿到，2、Class mapperInterface可以通过构造方法传入
（3）MyInvocationHandler，实现了InvocationHandler接口，重写invoke方法，里面完成真正的查询数据库的逻辑
（4）MyImportBeanDefinitionRegister ，实现了ImportBeanDefinitionRegistrar 接口（利用了spring的扩展点），在这个类中可以拿到MyMapperFactoryBean的BeanDefinition（如果不知道什么是BeanDefinition，可以先看一下这篇文章），进而调用构造方法给属性赋值，就是把要代理的接口传过去beanDefinition.getConstructorArgumentValues().addGenericArgumentValue（）
根据MyScan（自己定义的注解）上要扫描的包，获取该包下的所有类，拿到类的名字，第一个字符转成小写作为bean的名字
（5）MyScan 注解中用@import导入MyImportBeanDefinitionRegister

到此就模拟mybatis，完成了把动态代理对象加到spring容器中，就是利用了jdk动态代理技术和spring提供的扩展点FactoryBean和ImportBeanDefinitionRegistrar。

AppConfig 类

@Configuration
@MyScan("com.mi.asop.demo.mapper")
public class AppConfig {
public static void main(String[] args) {
    AnnotationConfigApplicationContext ac = new
            AnnotationConfigApplicationContext(AppConfig.class);
    UserMapper userMapper = (UserMapper)ac.getBean("userMapper");
    List<Map<String,String>> resultList = userMapper.query();
    resultList.forEach((map->{
        System.out.println(map.get("user_name"));
        System.out.println(map.get("user_account"));
    }));
}
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(dataSource);
    return sqlSessionFactoryBean;
}
@Bean
public DataSource dataSource(){
    DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
    driverManagerDataSource.setDriverClassName("com.mysql.jdbc.Driver");
    driverManagerDataSource.setUsername("xxxx");
    driverManagerDataSource.setPassword("xxxxx");
    driverManagerDataSource.setUrl("jdbc:mysql://xxxx:3308/xxxx?   useUnicode=true&characterEncoding=utf8&useSSL=false");
    return driverManagerDataSource;
}
}

UserMapper接口类

public interface UserMapper {
    @Select("select user_name,user_account from user_info")
    public List<Map<String,String>> query();
}

MyMapperFactoryBean 类

public class MyMapperFactoryBean implements FactoryBean {
@Autowired
SqlSessionFactory sqlSessionFactory;
Class mapperInterface;
public MyMapperFactoryBean(Class mapperInterface){
    this.mapperInterface = mapperInterface;
}
@Override
public Object getObject() throws Exception {
    Class[] clazz = new Class[]{mapperInterface};
    Object mapper = Proxy.newProxyInstance(MyMapperFactoryBean.class.getClassLoader(),clazz,new MyInvocationHandler(sqlSessionFactory));
    return mapper;
}
@Override
public Class<?> getObjectType() {
    return mapperInterface;
}
}

MyInvocationHandler

public class MyInvocationHandler implements InvocationHandler {
private SqlSessionFactory sqlSessionFactory;
public MyInvocationHandler(SqlSessionFactory sqlSessionFactory){
    this.sqlSessionFactory = sqlSessionFactory;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String sql = method.getAnnotation(Select.class).value()[0];
    System.out.println("获取要执行的sql语句："+sql);
    Connection connection = null;
    Statement statement = null;
    SqlSession sqlSession = null;
    List<Map<String,String>> resultList = new ArrayList<>();

    try{
        sqlSession = sqlSessionFactory.openSession();
        connection = sqlSession.getConnection();
        statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery(sql);
        while(resultSet.next()){
            Map<String,String> map = new HashMap<>();
            map.put("user_name",resultSet.getString("user_name"));
            map.put("user_account",resultSet.getString("user_account"));
            resultList.add(map);
        }
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        if(statement!=null){
            statement.close();
        }
        if(connection!=null){
            connection.close();
        }
        if(sqlSession!=null){
            sqlSession.close();
        }
    }
    return resultList;
}

}

MyScan 注解类

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Import(MyImportBeanDefinitionRegister.class)
public @interface MyScan {
    String[] value() default {};

}

MyImportBeanDefinitionRegister 类

public class MyImportBeanDefinitionRegister implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry)     {
    Map<String, Object> annotationAttributes = annotationMetadata.getAnnotationAttributes(MyScan.class.getName());

    String[] basePackages = ( String[])annotationAttributes.get("value");
    /**
     * 拿到注解上的扫描的包的名称
     * com.mi.asop.demo.mapper
     */
    String packageName =  basePackages[0];
    /**
     * 得到包下面所有的类
     */
    String packagePath = "";
    String[] names = packageName.split("\\.");
    for(String name:names){
        packagePath+=name+"/";
    }

    String classPath = this.getClass().getResource("/").getPath()+packagePath;
    File file = new File(classPath);
    String[] list = file.list();
    for(String fileName:list){
        //com.mi.asop.demo.mapper.userMapper
        fileName = fileName.substring(0,fileName.lastIndexOf("."));
        String first = fileName.substring(0, 1);
        String after = fileName.substring(1);
        first = first.toLowerCase();
        String beanName = first+after;
          BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MyMapperFactoryBean.class);
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(packageName+"."+fileName);
        beanDefinitionRegistry.registerBeanDefinition(beanName,beanDefinition);
    }
}
}