【Spring（九）】带你了解Spring整合MyBatis的详细过程

前言

  前面我们已经学习完了Spring的注解开发，接下来我们来学习Spring整合MyBatis💪💪。

Spring整合mybatis思路分析

  整合其实我们在核心容器中已经完成了一个东西了:DruidDataSource,我们现在要学习Spring最重要的一个东西了,Spring整合MyBatis,在开始学它之前我们需要回忆一下MyBatis程序独立开发是怎么做的👇👇。

  操作的数据库表：tbl_account👇👇。

  到我们程序中domain与它相对应，是封装数据的👇👇。

public class Account implements Serializable {

    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

  然后对应数据层操作接口AccountDao👇👇。

public interface AccountDao {

    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);

    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List<Account> findAll();

    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

  可以发现一点：是用注解的方式配的映射关系。看到这我们就知道了，回头在我们配置文件中就没有那个.xml文件了，有实现类吗？没有，那就告诉我们这一边是用自动代理做的。

  再来看一下我们的核心配置：SqlMapConfig.xml👇👇。

<?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>
    <properties resource="jdbc.properties"></properties>
    <typeAliases>
        <package name="com.itheima.domain"/>
    </typeAliases>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.itheima.dao"></package>
    </mappers>
</configuration>

  加载jdbc的连接数据在这:jdbc.properties👇👇

  应用程序👇👇。

public class App {
    public static void main(String[] args) throws IOException {
        // 1. 创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 2. 加载SqlMapConfig.xml配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 3. 创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        // 4. 获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 5. 执行SqlSession对象执行查询，获取结果User
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);

        Account ac = accountDao.findById(2);
        System.out.println(ac);

        // 6. 释放资源
        sqlSession.close();
    }
}

  运行结果👇👇。

  mybatis的原始开发我们就说到这，现在我们就从它的运行程序出发，分析一下既然Spring是用来管理bean的，那mybatis里有哪些bean是应该交给你管，或者说是值得让你去管的👇👇。

  在上面这段程序中，我们可以把它分成如上四个部分，上面有SqlSessionFactory、SqlSession两个核心对象，我们来思考这两个哪个是最核心的呢，SqlSession对象是由工厂造出来的，有点像我们之前学的连接池，所以在这里其实是对象早就造好了，你拿过来用就行了，根本不是让你在这造这个对象，因此最核心的对象是SqlSessionFactory,有了它，SqlSession对象也就有了，下面的接口对象也就有了，所有的操作也就能做了，那SqlSessionFactory这个东西怎么来的呢？要说第二个东西了，我们的配置👇👇。

  我们的所有的配置都是围绕着SqlSessionFactory对象的，在它的核心配置中，我们可以分为如上四个部分，我们来观察前三个部分，首先加载数据库对应的外部配置信息，这个和mybatis没什么关系，相当于这个数据你不在这写在其他地方写，可以忽略掉，第二部分我们的mybatis操作完以后得到的数据封装成什么样，也就是那个 <typeAliases> </typeAliases>那个别名，再往下看,dataSource 里边是干什么的，是连接哪个数据库，配它的dataSource的，我们就想一点，我们的SqlSessionFactory要是都不知道我们操作哪个数据库，我们怎么连，我们是不是都连不成，所以说，我们看到这个地方就已经确认一个信息，这一定是为我们SqlSessionFactory服务的，那上面呢transactionManager是事务管理，用的jdbc的事务，还是为这个东西服务的，为啥，我们SqlSessionFactory造的SqlSession是操作数据库的，所以以上东西都是为SqlSessionFactory服务的，最下边的初始化映射配置也是吗，当然不是，我们把SqlSessionFactory造出来以后，再去根据不同的配置加载以后，可以得到不同的mapper，然后去操作不同的库表，也就是说前边的那一套实际上是做大的连接管理，而我们的下边的这一部分是我们的业务操作，换句话说如果我们的业务操作假如一点没有的话，那mybatis也应该是成立的，它可能没有用，但是它是成立的，所以最底下这一块是伴随着我们的业务在进行变化的，核心对象其实是在这之前上边的部分,而这部分信息就是给我们的SqlSessionFactory初始化的，这里我们应该得出一个结论：mybatis应该管SqlSessionFactory对象🎉🎉。

Spring整合MyBatis

  我们接下来开始Spring整合MyBatis，从哪里下手呢，第一步，我们先导入一些专用的坐标,这些坐标是Spring和MyBatis需要用到的东西，我们在pom.xml文件中进行导入👇👇。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>spring_15_spring_mybatis</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

  </dependencies>
</project>

  其中倒数第二个是Spring操作jdbc对应的坐标，倒数第一个是MyBatis与Spring整合要用的坐标，是隶属于MyBatis的坐标，做完这个以后我们就要开发这套东西了。

   在这里我们学的是注解的方式,既然是用注解的那我们先把Spring的注解开发的格式给它挂上👇👇。

AccountService

public interface AccountService {

    void save(Account account);

    void delete(Integer id);

    void update(Account account);

    List<Account> findAll();

    Account findById(Integer id);

}

AccountServiceImpl

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account){
        accountDao.update(account);
    }

    public void delete(Integer id) {
        accountDao.delete(id);
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public List<Account> findAll() {
        return accountDao.findAll();
    }
}

JdbcConfig

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

MyBatisConfig

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

SpringConfig

@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

   我们来分析MyBatisConfig,SqlSessionFactoryBean 是Spring提供的快速造SqlSeesionFactory的类，里边该怎么做呢，先创建SqlSessionFactoryBean的对象，然后我们将它返回回去就行了，理论上是这样的，但是我们原来在造SqlSessionFactory的时候，我们的那些配置一个都不能少啊，如果我们现在不给这个SqlSessionFactoryBean的对象指定这些配置，它肯定是不能造出来的，所以我们用对应的set方法往里设置东西，框架的好处是里边的大部分东西采用默认就行了，我们就只设置需要设置的，第二个bean相当于帮我们扫描那个配置，使用自动代理的方式帮我们造dao的实现类的💪💪。

主程序

public class App2 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        AccountService accountService = ctx.getBean(AccountService.class);

        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

运行结果

总结

   其实Spring整合MyBatis最终总结到一个类：MyBatisConfig,我们在使用的时候，只需要改掉里边的包的路径就可以了，以上就是我们Spring整合MyBatis的全部内容,最后，如果有什么错误的话，大家可以私信我📬📬，希望大家多多关注+点赞+收藏 ^_ ^🙏🙏，你们的鼓励是我不断前进的动力💪💪！！！