Spring整合Mybatis和Junit

环境准备
- 步骤1：准备数据库
- 步骤2：创建项目导入jar包
- 步骤3：根据数据库的表创建模型类
- 步骤4：创建Dao接口
- 步骤5：创建Service接口和实现类
- 步骤6：添加jdbc.properties文件
- 步骤7：添加Mybatis核心配置文件
- 步骤8：编写应用程序
- 步骤9：运行程序
Spring整合Mybatis
- 整合Mybatis思路
- 步骤1：项目中导入整合需要的jar包
- 步骤2：创建Spring的主配置类
- 步骤3：创建Jdbc数据源的配置类
- 步骤4: 主配置类中读properties并引入数据源配置类
- 步骤5: 创建Mybatis配置类并配置SqlSessionFactory（整合时的关键模板，再整合的时候可以直接进行引用）
- 步骤6: 主配置类中引入Mybatis配置类
- 步骤7:编写运行类并运行
Sprin整合Junit
- 步骤1：引入Junit依赖
- 步骤2：编写测试类

环境准备

步骤1：准备数据库

Mybatis是来操作数据库表，所以先创建一个数据库及表

create database spring_db character set utf8;
use spring_db;
create table tbl_account(
    id int primary key auto_increment,
    name varchar(35),
    money double
);

insert into tbl_account(name, money) values('lsm', 123.4),('yxy', 123.4);

select * from tbl_account;

步骤2：创建项目导入jar包

<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>
</dependencies>

步骤3：根据数据库的表创建模型类

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;

    public Account() {
    }

    public Account(Integer id, String name, Double money) {
        this.id = id;
        this.name = name;
        this.money = 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 +
                '}';
    }
}

步骤4：创建Dao接口

import com.itheima.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface AccountDao {
    /**
     * 插入数据到account表中
     * @param account
     */
    @Insert("insert into tbl_account(name, money) values(#{name}, #{money})")
    void save(Account account);

    /**
     * 根据id删除数据
     * @param id
     */
    @Delete("delete from tbl_account where id = #{id}}")
    void delete(Integer id);

    /**
     * 根据id更新数据
     * @param account
     */
    @Update("update tbl_account set name = #{name}, money = #{money} where id = #{id}")
    void update(Account account);

    /**
     * 查找表中的所有数据
     * @return
     */
    @Select("select * from tbl_account")
    List<Account> findAll();

    /**
     * 根据id查找数据
     * @param id
     * @return
     */
    @Select("select * from tbl_account where id = #{id}")
    Account findById(Integer id);
}

步骤5：创建Service接口和实现类

service接口

package com.itheima.service;
import com.itheima.domain.Account;
import java.util.List;


public interface AccountService {

    /**
     * 插入数据到account表中
     * @param account
     */
    void save(Account account);

    /**
     * 根据id删除数据
     * @param id
     */
    void delete(Integer id);

    /**
     * 根据id更新数据
     * @param account
     */
    void update(Account account);

    /**
     * 查找表中的所有数据
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id查找数据
     * @param id
     * @return
     */
    Account findById(Integer id);
}

service接口的实现类

package com.itheima.service.impl;

import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

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

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

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

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

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

步骤6：添加jdbc.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
jdbc.username=root
jdbc.password=1234

步骤7：添加Mybatis核心配置文件

<?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>

步骤8：编写应用程序

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

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

        Account account1 = new Account();
        account1.setName("lsxy");
        account1.setMoney(110.0);
        accountDao.save(account1);

        List<Account> all = accountDao.findAll();
        System.out.println(all);
    }
}

步骤9：运行程序

在这里插入图片描述

Spring整合Mybatis

整合Mybatis思路

Mybatis程序核心对象分析，从下图可知，真正需要交给Spring管理的是SqlSessionFactory

在这里插入图片描述

整合Mybatis，就是将Mybatis用到的内容交给Spring管理，分析下配置文件

说明:

第一行读取外部properties配置文件，Spring有提供具体的解决方案@PropertySource,需要交给Spring
第二行起别名包扫描，为SqlSessionFactory服务的，需要交给Spring
第三行主要用于做连接池，Spring之前我们已经整合了Druid连接池，这块也需要交给Spring
前面三行一起都是为了创建SqlSession对象用的，那么用Spring管理SqlSession对象吗?回忆下SqlSession是由SqlSessionFactory创建出来的，所以只需要将SqlSessionFactory交给Spring管理即可。
第四行是Mapper接口和映射文件[如果使用注解就没有该映射文件]，这个是在获取到SqlSession以后执行具体操作的时候用，所以它和SqlSessionFactory创建的时机都不在同一个时间，可能需要单独管理

步骤1：项目中导入整合需要的jar包

<dependency>
    <!--Spring操作数据库需要该jar包-->
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<dependency>
    <!--
		Spring与Mybatis整合的jar包
		这个jar包mybatis在前面，是Mybatis提供的
	-->
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

步骤2：创建Spring的主配置类

// 配置类注解
@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}

步骤3：创建Jdbc数据源的配置类

在配置类中完成数据源的创建

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;

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

    @Bean
    public DataSource getDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(diverName);
        druidDataSource.setUrl(url);
        druidDataSource.setPassword(password);
        druidDataSource.setUsername(username);
        return druidDataSource;
    }
}

步骤4: 主配置类中读properties并引入数据源配置类

@Configuration  // 配置类注解
@ComponentScan("com.itheima")  // 包扫描，主要扫描的是醒目中的AccountServiceImpl类
@Import({JdbcConfig.class})
//@PropertySource({"jdbc.properties"})
@PropertySource("jdbc.properties")
public class SpringConfig {
}

步骤5: 创建Mybatis配置类并配置SqlSessionFactory（整合时的关键模板，再整合的时候可以直接进行引用）

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;


// 对应SqlMapConfig.xml文件
public class MybatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        /**
         * 对应
         *  <typeAliases>
         *         <package name="com.itheima.domain"/>
         *  </typeAliases>
         */
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        /**
         * 对应
         *  <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>
         */
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

说明:

使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息
- SqlSessionFactoryBean是前面我们讲解FactoryBean的一个子类，在该类中将SqlSessionFactory的创建进行了封装，简化对象的创建，我们只需要将其需要的内容设置即可。
- 方法中有一个参数为dataSource,当前Spring容器中已经创建了Druid数据源，类型刚好是DataSource类型，此时在初始化SqlSessionFactoryBean这个对象的时候，发现需要使用DataSource对象，而容器中刚好有这么一个对象，就自动加载了DruidDataSource对象。
使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IOC容器中
- 这个MapperScannerConfigurer对象也是MyBatis提供的专用于整合的jar包中的类，用来处理原始配置文件中的mappers相关配置，加载数据层的Mapper接口类
- MapperScannerConfigurer有一个核心属性basePackage，就是用来设置所扫描的包路径

步骤6: 主配置类中引入Mybatis配置类

@Configuration  // 配置类注解
@ComponentScan("com.itheima")  // 包扫描，主要扫描的是醒目中的AccountServiceImpl类
@Import({JdbcConfig.class, MybatisConfig.class})
//@PropertySource({"jdbc.properties"})
@PropertySource("jdbc.properties")
public class SpringConfig {
}

步骤7:编写运行类并运行

public class App2 {
    public static void main(String[] args) {
        ApplicationContext act = new AnnotationConfigApplicationContext(SpringConfig.class);
        AccountServiceImpl accountService = act.getBean(AccountServiceImpl.class);
        List<Account> accountList = accountService.findAll();
        System.out.println(accountList);
    }
}

在这里插入图片描述

Sprin整合Junit

在上述环境的基础上，我们来对Junit进行整合。

步骤1：引入Junit依赖

 <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

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

步骤2：编写测试类

//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = {SpringConfig.class}) //加载配置类
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));

    }
    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

注意:

单元测试，如果测试的是注解配置类，则使用@ContextConfiguration(classes = 配置类.class)
单元测试，如果测试的是配置文件，则使用@ContextConfiguration(locations={配置文件名,...})
Junit运行后是基于Spring环境运行的，所以Spring提供了一个专用的类运行器，这个务必要设置，这个类运行器就在Spring的测试专用包中提供的，导入的坐标就是这个东西SpringJUnit4ClassRunner
上面两个配置都是固定格式，当需要测试哪个bean时，使用自动装配加载对应的对象，下面的工作就和以前做Junit单元测试完全一样了