spring整合mybatis原理

深藏阁楼爱情的钟 2024-03-24 14:16 40阅读 0赞

## 1.MyBatis整合Spring实现 ##

我们先来实现MyBatis和Spring的整合操作。

![11e24d8eb5bb4e529c558473da1ba495.png][]

### 1.1什么事MyBatis？ ###

MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。

### 1.2添加相关的依赖 ###

<dependency>
    	<groupId>org.mybatis</groupId>
    	<artifactId>mybatis-spring</artifactId>
    	<version>2.0.4</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context</artifactId>
    	<version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-orm</artifactId>
    	<version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-test</artifactId>
    	<version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>

## 2.创建数据库 ##

use mydb;
    
    drop table if exists t_user;
    -- 创建表
    create table t_user(
    uid int primary key auto_increment,
    username varchar(20),
    password varchar(20),
    phone varchar(11),
    address varchar(50)
    );
    
    
    insert into t_user(username,password,phone,address) values('张三','666','18965423548','南阳');
    insert into t_user(username,password,phone,address) values('李四','333','18754263548','许昌');
    insert into t_user(username,password,phone,address) values('小美','123','18565234759','信阳');
    
    select * from t_user;

## 3.创建项目并导入所需jar包，并创建结构如下 ##

![9f50be4ebea84913a02cdd7ab46523ea.png][]

## 4.创建实体类 ##

package com.zhao.bean;
    
    public class User {
        private Integer uid;
        private String username;
        private String password;
        private String phone;
        private String address;
    
        public Integer getUid() {
            return uid;
        }
    
        public void setUid(Integer uid) {
            this.uid = uid;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "uid=" + uid +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", phone='" + phone + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

## 5.创建dao层的接口及其mapper映射文件 ##

**接口类**

package com.zhao.dao;
    
    import com.zhao.bean.User;
    
    import java.util.List;
    
    public interface UserDao {
        //全查
        List<User> selectAll();
    
    }

**mapper文件**

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.zhao.dao.UserDao">
        <select id="selectAll" resultType="user">
           select * from t_user;
        </select>
    </mapper>

## 5.1 **MapperDAO层开发规范** ##

1.  接口的全路径要和映射文件的namespace保持一致
2.  接口的方法名要和映射文件中的statementId保持一致
3.  接口方法的参数类型,返回类型要和映射文件中的parameterType,resultType保持一致 d
4.  接口和映射文件的名字最好保持一致 例如:UserMapper.java/UserMapper.xml
5.  接口和映射文件最好放到同一个目录

### 5.2 **Mybatis 动态 sql 是做什么的？都有哪些动态 sql？能简述一下动态 sql 的执行原理不？** ###

### 5.3 **\#\{\}和$\{\}的区别是什么？** ###

1.  \#\{\}是预编译处理，$\{\}是字符串替换。
2.  Mybatis 在处理\#\{\}时，会将 sql 中的\#\{\}替换为?号，调用 PreparedStatement 的 set 方法来赋值；
3.  Mybatis 在处理$\{\}时，就是把$\{\}替换成变量的值。
4.  使用\#\{\}可以有效的防止 SQL 注入，提高系统安全性。

## 6.创建service接口及其实现类 ##

**service接口**

package com.zhao.service;
    
    import com.zhao.bean.User;
    
    import java.util.List;
    
    public interface UserService {
        List<User> findAll();
    
    }

**service接口实现类**

package com.zhao.service.impl;
    
    import com.zhao.bean.User;
    import com.zhao.dao.UserDao;
    import com.zhao.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    @Service
    public class UserServiceImpl implements UserService {
        @Autowired
        UserDao userDao;
    
        @Override
        public List<User> findAll() {
            return userDao.selectAll();
        }
    }

## 7.创建mybatis配置文件 ##

> 由于整合时相关连接数据库 / 实体类起别名 / 扫描 mapper 文件等操作都在 spring 配置文件中定义， 所以此处只剩日志的配置

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <settings>
            <setting name="logImpl" value="log4j"/>
        </settings>
    </configuration>

## 8.创建Spring配置文件 ##

> 添加Spring的配置文件，并在该文件中实现和Spring的整合操作

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:component-scan base-package="com.zhao" />
        
        <bean id="dataSource"
              class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
            <property name="username" value="root"/>
            <property name="password" value="root"/>
        </bean>
        
        <bean id="factoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
            
            <property name="dataSource" ref="dataSource"/>
            
            <property name="typeAliasesPackage" value="com.zhao.bean" />
            
            <property name="configLocation" value="mybatis.xml" />
        </bean>
        
        <bean id="scanner"
              class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.zhao.dao"/>
        </bean>
    </beans>

### 8.1 整合Spring的原理 ###

把MyBatis集成到Spring里面，是为了进一步简化MyBatis的使用，所以只是对MyBatis做了一些封装，并没有替换MyBatis的核心对象。也就是说：MyBatis jar包中的SqlSessionFactory、SqlSession、MapperProxy这些类都会用到。mybatis-spring.jar里面的类只是做了一些包装或者桥梁的工作。

只要我们弄明白了这三个对象是怎么创建的，也就理解了Spring继承MyBatis的原理。我们把它分成三步：

*  SqlSessionFactory在哪创建的。
 *  SqlSession在哪创建的。
 *  代理类在哪创建的。

#### 8.1.1 SqlSessionFactory ####

首先我们来看下在MyBatis整合Spring中SqlSessionFactory的创建过程，查看这步的入口在Spring 的配置文件中配置整合的标签中

![5e207ffdefb447d9bf6d514cc9b30943.png][]

我们进入[SqlSessionFactoryBean][]中查看源码发现，其实现了InitializingBean 、FactoryBean、ApplicationListener 三个接口

![1de1a57098f347b3bcc22542e5508969.png][]

对于这三个接口，学过Spring生命周期的小伙伴应该清楚他们各自的作用

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>项目</td> 
   <td>Value</td> 
   <td>Value</td> 
  </tr> 
  <tr> 
   <td>接口</td> 
   <td>方法</td> 
   <td>作用</td> 
  </tr> 
  <tr> 
   <td>FactoryBean</td> 
   <td>getObject()</td> 
   <td>返回由FactoryBean创建的Bean实例</td> 
  </tr> 
  <tr> 
   <td>InitializingBean</td> 
   <td>afterPropertiesSet()</td> 
   <td>bean属性初始化完成后添加操作</td> 
  </tr> 
  <tr> 
   <td>ApplicationListener</td> 
   <td>onApplicationEvent()</td> 
   <td>对应用的事件进行监听</td> 
  </tr> 
 </tbody> 
</table>

**8.1.1.1 afterPropertiesSet**

我们首先来看下 afterPropertiesSet 方法中的逻辑

public SqlSessionFactory getObject() throws Exception {
            if (this.sqlSessionFactory == null) {
                this.afterPropertiesSet();
            }
            return this.sqlSessionFactory;
    }

可以发现在afterPropertiesSet中直接调用了buildSqlSessionFactory方法来实现 sqlSessionFactory对象的创建

![在这里插入图片描述][3f0558ad2b014114b34ed92a426ea543.png]

方法小结一下：通过定义一个实现了InitializingBean接口的SqlSessionFactoryBean类，里面有一个afterPropertiesSet()方法会在bean的属性值设置完的时候被调用。Spring在启动初始化这个Bean的时候，完成了解析和工厂类的创建工作。  
**8.1.1.2**  **getObject**

另外SqlSessionFactoryBean实现了FactoryBean接口。  
FactoryBean的作用是让用户可以自定义实例化Bean的逻辑。如果从BeanFactory中根据Bean的ID获取一个Bean，它获取的其实是FactoryBean的getObject()返回的对象。  
也就是说，我们获取SqlSessionFactoryBean的时候，就会调用它的getObject()方法。

public SqlSessionFactory getObject() throws Exception {
     if (this.sqlSessionFactory == null) {
    		this.afterPropertiesSet();
     }
     return this.sqlSessionFactory;

getObject方法中的逻辑就非常简单，返回SqlSessionFactory对象，如果SqlSessionFactory对象为 空的话就又调用一次afterPropertiesSet来解析和创建一次。

**8.1.1.3 onApplicationEvent**

实现[ApplicationListener][]接口让SqlSessionFactoryBean有能力监控应用发出的一些事件通知。比如 这里监听了ContextRefreshedEvent（上下文刷新事件），会在Spring容器加载完之后执行。这里做的 事情是检查ms是否加载完毕。

public void onApplicationEvent(ApplicationEvent event) {
    if (this.failFast && event instanceof ContextRefreshedEvent) { 
    	this.sqlSessionFactory.getConfiguration().getMappedStatementNames();
    	}
    }

#### 8.1.2 SqlSession ####

**8.1.2.1 DefaultSqlSession的问题**

在前面介绍MyBatis的使用的时候，通过SqlSessionFactory的open方法获取的是  
DefaultSqlSession，但是在Spring中我们不能直接使用DefaultSqlSession，因为DefaultSqlSession是 线程不安全的。所以直接使用会存在数据安全问题，针对这个问题的，在整合的MyBatis-Spring的插件包中给我们提供了一个对应的工具SqlSessionTemplate。

![6076d80f063a492ca7c080f18f866960.png][]

也就是在我们使用SqlSession的时候都需要使用try catch 块来处理

try (SqlSession session = sqlSessionFactory.openSession()) {
    	// 你的应用逻辑代码
    }
    	// 或者
    SqlSession session = null;
     try {
    	session = sqlSessionFactory.openSession();
    	// 你的应用逻辑代码
    }finally{
    	session.close();
    }

**8.1.2.2 SqlSessionTemplate**

在mybatis-spring的包中，提供了一个线程安全的SqlSession的包装类，用来替代SqlSession，这个类就是SqlSessionTemplate。因为它是线程安全的，所以可以在所有的DAO层共享一个实例（默认是单例的）。

![39344a632f2e44e39ad35f1aee04755a.png][]

总结一下：因为DefaultSqlSession自己做不到每次请求调用产生一个新的实例，我们干脆创建一个代理 类，也实现SqlSession，提供跟DefaultSqlSession一样的方法，在任何一个方法被调用的时候都先创建 一个DefaultSqlSession实例，再调用被代理对象的相应方法。  
MyBatis还自带了一个线程安全的SqlSession实现：SqlSessionManager，实现方式一样，如果不集成到Spring要保证线程安全，就用SqlSessionManager。

## 9.创建测试类 ##

package com.zhao.test;
    
    import com.zhao.bean.User;
    import com.zhao.service.UserService;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import java.util.List;
    
    public class UserDaoTest {
        UserService userService;
    
        @Test
        public void testSelectAll(){
            ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
            userService=context.getBean(UserService.class);
    
            List<User> userList = userService.findAll();
            for (User user:userList){
                System.out.println(user);
            }
        }
    }

**测试结果**

![3a8ae00b0ffc43088ddb38834af63674.png][]

**总结一下，Spring是怎么把MyBatis继承进去的？**

> 1.  提供了SqlSession的替代品SqlSessionTemplate，里面有一个实现了实现了InvocationHandler的内部SqlSessionInterceptor，本质是对SqlSession的代理。
> 2.  提供了获取SqlSessionTemplate的抽象类SqlSessionDaoSupport。
> 3.  扫描Mapper接口，注册到容器中的是MapperFactoryBean，它继承了SqlSessionDaoSupport，可 以获得SqlSessionTemplate。
> 4.  把Mapper注入使用的时候，调用的是getObject()方法，它实际上是调用了SqlSessionTemplate的getMapper()方法，注入了一个JDK动态代理对象。
> 5.  执行Mapper接口的任意方法，会走到触发管理类MapperProxy，进入SQL处理流程。

核心对象：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>对象</td> 
   <td>生命周期</td> 
  </tr> 
  <tr> 
   <td>SqlSessionTemplate</td> 
   <td>Spring中SqlSession的替代品，是线程安全的</td> 
  </tr> 
  <tr> 
   <td>SqlSessionDaoSupport</td> 
   <td>用于获取SqlSessionTemplate</td> 
  </tr> 
  <tr> 
   <td>SqlSessionInterceptor（内部类）</td> 
   <td>代理对象，用来代理DefaultSqlSession，在SqlSessionTemplate中使用</td> 
  </tr> 
  <tr> 
   <td>MapperFactoryBean</td> 
   <td>代理对象，继承了SqlSessionDaoSupport用来获取SqlSessionTemplate</td> 
  </tr> 
  <tr> 
   <td>SqlSessionHolder</td> 
   <td>控制SqlSession和事务</td> 
  </tr> 
 </tbody> 
</table>

设计模式总结：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:92px;">设计模式</td> 
   <td style="width:407px;">类</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">工厂模式</td> 
   <td style="width:407px;">SqlSessionFactory、ObjectFactory、MapperProxyFactory</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">建造者模式</td> 
   <td style="width:407px;">XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuidler</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">单例模式</td> 
   <td style="width:407px;">SqlSessionFactory、Configuration、ErrorContext</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">代理模式</td> 
   <td style="width:407px;">绑定：MapperProxy延迟加载：ProxyFactory 插件：PluginSpring集成MyBaits： SqlSessionTemplate的内部SqlSessionInterceptorMyBatis自带连接池：PooledConnection日志打印：ConnectionLogger、StatementLogger<br> &nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">适配器模式</td> 
   <td style="width:407px;">Log，对于Log4j、JDK logging这些没有直接实现slf4j接口的日志组件，需要适配器</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">模板方法</td> 
   <td style="width:407px;">BaseExecutor、SimpleExecutor、BatchExecutor、ReuseExecutor</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">装饰器模式</td> 
   <td style="width:407px;">LoggingCache、LruCache对PerpetualCacheCachingExecutor对其他Executor</td> 
  </tr> 
  <tr> 
   <td style="width:92px;">责任链模式</td> 
   <td style="width:407px;">Interceptor、InterceptorChain</td> 
  </tr> 
 </tbody> 
</table>

## **9.MyBatis 的好处是什么？** ##

1.  MyBatis 把 sql 语句从 Java 源程序中独立出来，放在单独的 XML 文件中编写，给程序的维护带来了很大便利。
2.  MyBatis 封装了底层 JDBC API 的调用细节，并能自动将结果集转换成 Java Bean 对象， 大大简化了 Java 数据库编程的重复工作。
3.  因为 MyBatis 需要程序员自己去编写 sql 语句，程序员可以结合数据库自身的特点灵活控制 sql 语句，因此能够实现比 Hibernate 等全自动 orm 框架更高的查询效率，能够完成复杂查询。

## 10.**接口绑定有几种实现方式,分别是怎么实现的?** ##

接口绑定有两种实现方式,一种是通过注解绑定,就是在接口的方法上面加上@Select@Update 等注解里面包含 Sql 语句来绑定,另外一种就是通过 xml 里面写 SQL 来绑定,在这种情况下,要指定 xml 映射文件里面的 namespace 必须为接口的全路径名.

## 11.**当实体类中的属性名和表中的字段名不一样，如果将查询的结果封装到指定 pojo？** ##

1.  通过在查询的 sql 语句中定义字段名的别名。
2.  通过<resultMap>来映射字段名和实体类属性名的一一对应的关系。

[11e24d8eb5bb4e529c558473da1ba495.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f8f38be5bc484c3ba87367275e7282a4.png
[9f50be4ebea84913a02cdd7ab46523ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/ffcfd0d649c847a797b39418e7ccdb7d.png
[5e207ffdefb447d9bf6d514cc9b30943.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/650cc3de7a5a47428dd6804c3a6d9b77.png
[SqlSessionFactoryBean]: https://so.csdn.net/so/search?q=SqlSessionFactoryBean&spm=1001.2101.3001.7020
[1de1a57098f347b3bcc22542e5508969.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5f12c078ccda42928e12b6502264a225.png
[3f0558ad2b014114b34ed92a426ea543.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3424f6ab93c1416b946774a7336bd0b6.png
[ApplicationListener]: https://so.csdn.net/so/search?q=ApplicationListener&spm=1001.2101.3001.7020
[6076d80f063a492ca7c080f18f866960.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/357a1c02d1284e13bc9e7e9071db3a27.png
[39344a632f2e44e39ad35f1aee04755a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3422a43e059c4ecf97f24e25f6f2ae60.png
[3a8ae00b0ffc43088ddb38834af63674.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2a15ad439e424ac8b2ad0e9176e750e4.png