[Java知识库]05-spring整合mybatis

Spring集成mybatis的分析

整合的目的：把mybatis框架和spring集成在一起，像一个框架一样使用。
用的技术：ioc
为什么是ioc：能把mybatis和spring集成在一起，像一个框架，是因为ioc能创建对象。可以把mybatis框架中的对象交给spring统一创建，开发人员从spring中获取对象。开发人员就不用同时面对两个或多个框架了，就面对一个spring

mybatis使用步骤分析

1. 定义dao接口，StudentDao
2. 定义mapper文件 StudentDao.xml
3. 定义mybatis的主配置文件 mybatis.xml
4. 创建dao的代理对象，StudentDao dao=SqlSession.getMapper(StudentDao.class);

要使用dao对象，需要使用getMapper()方法
怎么能使用getMapper()方法，需要哪些条件

1. 获取SqlSession对象，需要使用SqlSessionFactory的openSession()方法
2. 创建SqlSessionFactory对象，通过读取mybatis的主配置文件，能创建SqlSessionFactory对象
   需要SqlSessionFactory对象，使用Factory能获取SqlSession，有了SqlSession就能有dao，目的就是获取dao对象，SqlSessionFactory创建需要读取配置文件

我们会使用独立的连接池替换mybatis默认自带的，把连接池类也交给spring创建
主配置文件：
1.数据库信息

 <environment id="mydev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--数据库的驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--连接数据库的url字符串-->
                <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
                <!--访问数据库的用户名-->
                <property name="username" value="root"/>
                <!--密码-->
                <property name="password" value="123456"/>
            </dataSource>
  <enviroment>

2. mapper文件的位置

  <mappers>
        <mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
        <!--<mapper resource="com/bjpowernode/dao/SchoolDao.xml" />-->
    </mappers>

==============================================================
通过以上的说明，我们需要让spring创建以下对象
1.独立的连接池类对象，使用ali的druid连接池
2.SqlSessionFactory对象
3.创建出dao对象

整合演示

整合步骤：
1.新建maven项目
2.加入maven的依赖
1、spring依赖
2、mybatis依赖
3、mysql驱动
4、spring的事务的依赖
5、mybatis和spring集成的依赖：mybatis官方提供的，用来在spring项目中创建mybatis的
SqlSessionFactory，dao对象的
3.创建实体类
4.创建dao接口和mapper文件
5.创建mybatis主配置文件
6.创建Service接口和实现类，属性是dao

以上步骤都是mybatis的流程

7.创建spring的配置文件：声明mybatis的对象交给spring创建
1.数据源(使用德鲁伊连接池)
2.SqlSessionFactory
3.Dao对象
4.声明自定义的service
8.创建测试类，获取service对象，通过service调用dao完成数据库的访问

1.新建maven项目：ch08-springconvergemybatis
2.加入maven的依赖如下是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.yongbin</groupId>
  <artifactId>ch08-springconvergemybatis</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>ch08-springconvergemybatis</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>

    <dependency>

      <!--单元测试-->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--spring核心ioc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
  </dependency>

    <!--做spring事务用到的，下面两个-->
    <dependency>
    <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
     </dependency>

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

    <!--mybatis的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
  </dependency>

    <!--mybatis和spring集成的依赖，mybatis官方提供-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
  </dependency>

    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
  </dependency>

    <!--数据库连接池：阿里提供，用来替代mybatis自带的连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
  </dependency>

  </dependencies>

  <!--插件-->
  <build>
    <!--目的是把src/main/java目录中的xml包含到输出结果中。输出到target-》classess下-->
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <!--filtering 选项 false 不启用过滤器， *.property 已经起到过滤的作用了 -->
        <filtering>false</filtering>
      </resource>
    </resources>

    <!--指定jdk的版本，前面指定过了，这里也可以不指定-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>

  </build>
</project>

3.创建实体类，包结构如下图：

在domain下新建Student的实体类，如下：

public class Student {
    //定义属性，目前要求属性名和列名一样
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Student() {
    }

    public Student(Integer id, String name, String email, Integer age) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" +
                email + '\'' +
                ", age=" + age +
                '}';
    }

    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 Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }


}

4.创建dao接口和mapper文件
dao接口的声明如下：

public interface StudentDao {

    //查询所有学生
    List<Student> selectAllStudents();

    //插入学生
    int addStudent(Student student);
}

StudentDao.xml(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">

<!--这时，namespace就必须是接口的全限定名称
    id：必须是接口中的方法名
-->
<mapper namespace="com.yongbin.dao.StudentDao">


    <select id="selectAllStudents" resultType="com.yongbin.domain.Student">
        select * from student
    </select>

    <insert id="addStudent"  >
        insert into student VALUE (#{id},#{name},#{email},#{age})
    </insert>
</mapper>

5.在src/main/java/resources下面，创建mybatis主配置文件注意的是environments标签不再配置了

<?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文件的位置，从类路径根开始找,一般放在src/main/resources/下面和mybatis.xml在同一个文件下-->
    <properties resource="jdbc.properties"></properties>

    <!--settings：控制mybatis全局行为，还有其他设置去课件中找-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--定义别名-->
    <typeAliases>
        <!--
         第一种方式
             示例： <typeAlias type="com.yongbin.domain.Student" alias="stu"></typeAlias>
             可以指定一个类型，一个自定义的别名
                type：自定义类型的全限定名称
                alias：别名（短小，容易记忆）
        第二种方式 
              <package> name是包名，这个包中的所有类，类名就是别名（类名不区分大小写）
       -->
        <package name="com.yongbin.domain"></package>

    </typeAliases>
    
    <!--环境不再配置-->

    <!--sql mapper（sql映射文件）的位置-->
    <mappers>
        <!--
            第一种方式
            <!-<mapper resource="com/yongbin/dao/StudentDao.xml"/>
            第二种方式：使用包名
                name：xml文件（mapper文件）所在的包名，这个包中的所有xml文件，一次都能加载给mybatis。
                使用package的要求：
                1.mapper文件名称需要和接口名称一样
                2.mapper文件和dao接口需要在同一目录
        -->
        <package name="com.yongbin.dao"/>

    </mappers>
</configuration>

6.创建service接口和实现类，里面有一个dao属性

public interface StudentService {

    //添加student
    int addStudent(Student student);

    //查询方法
    List<Student> queryStudents();
}

以上步骤都是mybatis的流程，唯一的改变是mybatis的主配置文件mybatis.xml中去掉了environments标签

7.创建spring的配置文件：声明mybatis的对象交给spring创建
1）数据源（使用德鲁伊连接池）
2）SqlSessionFactory
3）dao对象
4）声明自定义的service对象

在src/main/java/resources下面创建jdbc.properties和applicationContext.xml（spring配置文件）
jdbc.properties的内容如下：

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.userName=root
jdbc.password=123456

applicationContext.xml（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">

    <!--引入外部属性文件，jdbc.properties
        想要使用该标签，得引入上面的context名称空间
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置连接池 -->
    <!-- DruidDataSource dataSource = new DruidDataSource(); -->
    <!--这个类不是你定义的，所以用注解-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            set方法注入，给druidDataSource提供连接数据库
        -->
        <!-- 获取properties文件内容,即jdbc.properties文件中数据库配置的内容
             根据key获取，使用spring表达式获取
             下面的名字都不是随便的，而是人家连接池中set方法的一部分
             驱动可以不写，只要是常见的数据库，druid会自动识别
        -->
        <property name="driverClassName" value="${jdbc.driverClass}"></property><!--对应着setDriverClassName-->
        <property name="url" value="${jdbc.url}"></property> <!--对应着setUrl-->
        <property name="username" value="${jdbc.userName}"></property><!--对应着setUsername-->
        <property name="password" value="${jdbc.password}"></property><!--对应着setPassword-->
        <property name="maxActive" value="20"></property><!--对应着setMaxActive-->
    </bean>


    <!--声明mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
        通过第一个属性dataSource来确定数据源（替代mybatis.xml中environment标签内容），
        通过configlocation来找到mybatis主文件位置
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池赋给了dataSource属性-->
        <property name="dataSource" ref="myDataSource"></property>
        <!--
            mybatis主配置文件的位置
            configLocation属性是Resource类型，读取配置文件
            它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml"></property>
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper(Student.class)
        MapperScannerConfigure：内部调用getMapper()生成每个dao接口的代理对象，这个bean没有id
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定sqlSessionFactory的id
            把上面的id拿过来赋给value就行
                关于使用set注入方式给属性赋值时，什么时候用ref，什么时候用vale？
                    ref：用在引用数据类型
                    value：int、float等包括String被spring认为是基本类型
                    怎样查看类型，如下main的，在打sqlSessionFactoryBeanName字母时，后面会给出提示，显示类型
        -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        <!--指定包名，包名是dao接口所在的包名
            1、MapperScannerConfigure会扫描这个包中的所有接口，把每个接口都执行
            一次getMapper()方法，得到每个接口的dao对象
            创建好的dao对象放入到spring的容器中(这个dao对象的名称是接口名的首字母小写)

            2、多个包的话：在value后面继续写
                示例：value="com.yongbin.dao,com.yongbin.dao1..."
        -->
        <property name="basePackage" value="com.yongbin.dao"></property>
    </bean>

    <!--声明service-->
    <bean id="studentService" class="com.yongbin.service.impl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"></property>
    </bean>

</beans>

至此，整合完毕了，下面测试。
在src/test/java/下面新建一个TestSprintConvergeMybatis的类，声明一个查看容器中所有对象的方法，如下：

 //获取容器中所有对象
    @Test
    public void test01(){
        String config="applicationContext.xml";
        //开始加载配置文件，当加载配置文件的时候对象就创建了
        ApplicationContext context=new ClassPathXmlApplicationContext(config);
        String[] names = context.getBeanDefinitionNames();
        //查看容器中所有的对象
        for (int i = 0; i < names.length; i++) {
            System.out.println("容器中对象的名称"+names[i]+":"+context.getBean(names[i]));
        }
    }

运行如下：

下面创建StudentServiceImpl来实现StudentService接口，内容如下：

public class StudentServiceImpl implements StudentService {

    //引用类型
    private StudentDao studentDao;

    //创建set方法，目的是使用set注入
    public void setStudentDao(StudentDao studentDao){
        this.studentDao=studentDao;
    }

    @Override
    public int addStudent(Student student) {
        int nums = studentDao.addStudent(student);
        return nums;
    }

    @Override
    public List<Student> queryStudents() {
        List<Student> stuList = studentDao.selectAllStudents();
        return stuList;
    }
}

由于我们在spring的配置文件里已经使用bean标签创建了service对象，且通过set方式注入了dao对象，所以下面是通过service来测试方法。
测试查询操作和插入操作的代码如下，代码都能够正常运行。

public class StudentServiceImpl implements StudentService {

    //引用类型
    private StudentDao studentDao;

    //创建set方法，目的是使用set注入
    public void setStudentDao(StudentDao studentDao){
        this.studentDao=studentDao;
    }

    @Override
    public int addStudent(Student student) {
        int nums = studentDao.addStudent(student);
        return nums;
    }

    @Override
    public List<Student> queryStudents() {
        List<Student> stuList = studentDao.selectAllStudents();
        return stuList;
    }
}

使用idea保存spring集成mybatis的applicationContext配置文件

通过配置模板保存一下applicationContext文件，可以供自己下次使用，下次在使用的时候改改就行。