Spring框架入门68-79：spring整合mybatis

开始时间：2022-01-10
课程链接：动力节点Spring框架教程

MyBatis和Spring的结合

将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory 对象交由 Spring
来管理。

用的技术是：ioc 。
因为ioc能创建对象能把mybatis和spring集成在一起，像一个框架。
可以把mybatis框架中的对象交给spring统一创建， 开发人员从spring中获取对象。

mybatis使用步骤，可复习MyBatis
1.定义dao接口 ，StudentDao
2.定义mapper文件 StudentDao.xml
3.定义mybatis的主配置文件 mybatis.xml
4.创建dao的代理对象，

StudentDao dao = SqlSession.getMapper(StudentDao.class);
List<Student> students  = dao.selectStudents();

要使用dao对象，需要使用get Mapper()方法，
使用getMapper()方法，需要哪些条件？
1.获取SqlSession对象， 需要使用SqlSessionFactory的openSession()方法。
2.创建SqlSessionFactory对象。 通过读取mybatis的主配置文件，能创建SqlSessionFactory对象

需要SqlSessionFactory对象， 使用Factory能获取SqlSession ，有了SqlSession就能有dao ， 目的就是获取dao对象

Factory创建需要读取主配置文件

注意：我们会使用独立的连接池类替换mybatis默认自己带的， 把连接池类也交给spring创建。
主配置文件一般是以下内容
1.数据库信息(这里实际不用，用druid）

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

2.mapper文件的位置

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

通过以上的说明，我们需要让spring创建以下对象

• 独立的连接池类的对象， 使用阿里的druid连接池
• SqlSessionFactory对象
• 创建出dao对象

需要学习就是上面三个对象的创建语法，使用xml的bean标签。

步骤如下

ch07-spring-mybatis：spring和mybatis的集成

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。
7.创建spring的配置文件：声明mybatis的对象交给spring创建
1）数据源DataSource
2）SqlSessionFactory
3) Dao对象
4）声明自定义的service

8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问

1.新建maven项目

正常的套用模板maven中选quickstart就行

2.加入maven的依赖

  1）spring依赖
  2）mybatis依赖
  3）mysql驱动
  4）spring的事务的依赖
  5）mybatis和spring集成的依赖： mybatis官方提供的，用来在spring项目中创建mybatis
     的SqlSessionFactory，dao对象的

<?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>BUPT</groupId>
    <artifactId>ch07-Spring-MyBatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>ch07-Spring-MyBatis</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>15</maven.compiler.source>
        <maven.compiler.target>15</maven.compiler.target>
    </properties>

    <dependencies>
        <!--Test-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <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>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>

        <!--连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
    </dependencies>


    <build>
        <!--把xml文件包含到输出结果中，输出到class目录中-->
        <resources>
            <resource>
                <directory>src/main/java</directory><!--所在的目录-->
                <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>15</source>
                    <target>15</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.创建实体类

package BUPT.entity;

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;
    }

    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 String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {`在这里插入代码片`
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

4.创建dao接口和mapper文件

package BUPT.dao;

import BUPT.entity.Student;

import java.util.List;

public interface StudentDao {
    int insertStudent(Student student);

    List<Student> selectStudents();
}

注意不要写错SQL语句，我把逗号写成了点号，找了半天才解决报错

<?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="BUPT.dao.StudentDao">

    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>

    <select id="selectStudent" resultType="BUPT.entity.Student">
        select id,name,email,age from student order by id
    </select>
</mapper>     

5.创建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>

    <!--settings：控制mybatis全局行为-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--环境配置： 数据库的连接信息
        default:必须和某个environment的id值一样。
        告诉mybatis使用哪个数据库的连接信息。也就是访问哪个数据库
    -->
    <typeAliases>
        <!--name:实体类的别名-->
        <package name="BUPT.entity"/>
    </typeAliases>

    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--一个mapper标签指定一个文件的位置。
           从类路径开始的路径信息。  target/clasess(类路径)
           package配一个包
        -->
        <package name="BUPT.dao"/>
    </mappers>
</configuration>
        <!--
           mybatis的主配置文件： 主要定义了数据库的配置信息， sql映射文件的位置

           1. 约束文件
           <!DOCTYPE configuration
                PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-config.dtd">

            mybatis-3-config.dtd：约束文件的名称

          2. configuration 根标签。
        -->

6.创建Service接口和实现类，属性是dao。
实现类

package BUPT.service.impl;

import ...;

public class StudentServiceImpl implements StudentService {

    //引用类型
    private StudentDao studentDao;

    //使用set注入，赋值
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

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

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

接口

package BUPT.service;

import BUPT.entity.Student;

import java.util.List;

public interface StudentService {
    int addStudent(Student student);
    List<Student> queryStudents();
}

7.创建spring的配置文件：声明mybatis的对象交给spring创建
1）数据源DataSource
2）SqlSessionFactory
3) Dao对象
4）声明自定义的service

<?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/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--声明数据源DataSource, 作用是连接数据库的-->

    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库信息 -->
        <!--    使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="jdbc:mysql://localhost:3306/springdb?serverTimezone=UTC"/><!--setUrl()-->
        <property name="username" value="root"/>
        <property name="password" value="333"/>
        <property name="maxActive" value="20"/>
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
        SqlSessionFactory  sqlSessionFactory = new ..
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis主配置文件的位置
           configLocation属性是Resource类型，读取配置文件
           它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>
	
	 <!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
    MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。
	注意这里是用的value不是ref，名称要和上面一个bean id一致
-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名， 包名是dao接口所在的包名。-->
        <property name="basePackage" value="BUPT.dao"/>
    </bean>
</beans>

MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
一次getMapper()方法，得到每个接口的dao对象。
创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写

8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问

可以拿到所有对象名

package BUPT;

import static ...;
public class AppTest 
{
   @Test
    public void myTest(){
       String config = "applicationContext.xml";
       ApplicationContext AC = new ClassPathXmlApplicationContext(config);
       //从目标容器中获取目标对象
       String[] names=AC.getBeanDefinitionNames();
       for(String name:names){
           System.out.println("容器中对象名称:" +name);
       }
   }
}

容器中对象名称:myDataSource
容器中对象名称:sqlSessionFactory
容器中对象名称:org.mybatis.spring.mapper.MapperScannerConfigurer#0
容器中对象名称:studentDao
容器中对象名称:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
容器中对象名称:org.springframework.context.annotation.internalAutowiredAnnotationProcessor
容器中对象名称:org.springframework.context.event.internalEventListenerProcessor
容器中对象名称:org.springframework.context.event.internalEventListenerFactory

那我们再看几个Test类
实现对象的添加

    @Test
    public void testServiceInsert(){

        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //获取spring容器中的dao对象
        StudentService service = (StudentService) ctx.getBean("studentService");
        Student student  = new Student();
        student.setId(1015);
        student.setName("李胜利");
        student.setEmail("zhoufeng@qq.com");
        student.setAge(26);
        int nums = service.addStudent(student);
        //spring和mybatis整合在一起使用，事务是自动提交的。 无需执行SqlSession.commit();
        System.out.println("nums="+nums);
    }

实现对象的查询

  @Test
    public void testServiceSelect(){

        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //获取spring容器中的dao对象
        StudentService service = (StudentService) ctx.getBean("studentService");

        List<Student> students = service.queryStudents();
        for (Student stu:students){
            System.out.println(stu);
        }
    }

再加一个jdbc.properties作为配置文件

jdbc.url=jdbc:mysql://localhost:3306/springdb?serverTimezone=UTC
jdbc.username=root
jdbc.password=333
jdbc.max=30

同步修改applicationContext
补充其位置

    <!--
       把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
       spring知道jdbc.properties文件的位置
    -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--声明数据源DataSource, 作用是连接数据库的-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库信息 -->
        <!--    使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="${jdbc.url}" /><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="${jdbc.max}" />

    </bean>

结束时间：2022-01-12