Spring集成MyBatis

目錄

• 一、建立資料庫及新表
• 二、maven依賴pom.xml
• 三、創建物體類
• 四、創建dao介面
• 五、定義映射檔案mapper
• 六、創建mybatis主組態檔
• 七、創建Service介面和實作類，屬性是dao
• 八、創建spring的組態檔
• 九、創建測驗類
• 十、總結

實作 Spring 與 MyBatis 的整合常用的方式：掃描的 Mapper 動態代理

一、建立資料庫及新表

二、maven依賴pom.xml

• spring依賴
• mybatis依賴
• mysql驅動
• spring的事務依賴
• mybatis和spring集成的依賴

完整的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.md</groupId>
  <artifactId>06-spring-mybatis</artifactId>
  <version>1.0-SNAPSHOT</version>


  <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核心-->
    <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集成的-->
    <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>

	<!--德魯伊，資料庫連接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>


  </dependencies>

  <build>

    <!--目的是把src/main/java目錄中的xml檔案包含到輸出結果中，也就是輸出到classes目錄中-->
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目錄-->
        <includes><!--包括目錄下的.properties,.xml 檔案都會掃描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>

  </build>

</project>

三、創建物體類

package com.md.domain;

/**
 * @author MD
 * @create 2020-08-09 20:02
 */
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 +
                '}';
    }
}

四、創建dao介面

package com.md.dao;

import com.md.domain.Student;

import java.util.List;

/**
 * @author MD
 * @create 2020-08-09 20:04
 */
public interface StudentDao {
    int insertStudent(Student student);

    List<Student> selectStudents();
}

五、定義映射檔案mapper

和dao在同一目錄下，名字和dao介面的一樣，StudentDao.xml

mapper 中的 namespace 取值也為 Dao 介面的全限定性名

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


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


    <select id="selectStudents" resultType="com.md.domain.Student">

        select id,name,email,age from student

    </select>

</mapper>

六、創建mybatis主組態檔

在 src /main/resources下定義 MyBatis 的主組態檔，命名為 mybatis.xml

注意：

1. 主組態檔中不再需要資料源的配置了，因為資料源要交給 Spring 容器來管理了
2. 這里對 mapper 映射檔案的注冊，使用<package/>標簽，即只需給出 mapper 映射檔案所在的包即可，因為 mapper 的名稱與 Dao 介面名相同，可以使用這種簡單注冊方式，這種方式的好處是，若有多個映射檔案，這里的配置也是不用改變的，當然，也可使用原來的<resource/>標簽方式

<?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=https://www.cnblogs.com/mengd/p/"STDOUT_LOGGING"/>
    


    
    
        
        

    



    
    

        
        
    

七、創建Service介面和實作類，屬性是dao

package com.md.service;

import com.md.domain.Student;

import java.util.List;

/**
 * @author MD
 * @create 2020-08-09 20:25
 */
public interface StudentService {

    int addStudent(Student student);

    List<Student> queryStudent();

}

//-------------------------------------
package com.md.service.impl;

import com.md.dao.StudentDao;
import com.md.domain.Student;
import com.md.service.StudentService;

import java.util.List;

/**
 * @author MD
 * @create 2020-08-09 20:27
 */
public class StudentServiceImpl implements StudentService {

    // 參考型別
    private StudentDao studentDao;

    // 為了使用set注入來賦值
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

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



    @Override
    public List<Student> queryStudent() {
        List<Student> studentList = studentDao.selectStudents();

        return studentList;
    }
}

八、創建spring的組態檔

在 src /main/resources下定義 Spring的主組態檔，命名為 applicationContext.xml

宣告mybatis的物件交給spring創建

1. 資料源DateSource

使用 JDBC 模板，首先需要配置好資料源，資料源直接以 Bean 的形式配置在 Spring 組態檔中，根據資料源的不同，其配置方式不同：

這里使用的Druid，Druid 是阿里的開源資料庫連接池，是 Java 語言中最好的資料庫連接池，Druid 能
夠提供強大的監控和擴展功能

https://github.com/alibaba/druid

首先在pom.xml中加入依賴，上面添加過了

然后是在spring的組態檔中

<!--宣告資料源DataSource，作用是連接資料庫-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">

        <!--set注入提供連接資料庫資訊-->
        <property name="url" value=https://www.cnblogs.com/mengd/p/"${jdbc.url}" />
        
        
        

    

為了維護方法方便，還可以使用屬性檔案

在在 src /main/resources下定義jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=123456
jdbc.maxActive=20

然后再spring的組態檔中

 <!--
        把資料庫的配置資訊寫在一個獨立的檔案中，編譯修改資料庫的配置內容
        讓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">
 <!--    使用屬性組態檔中的資料，語法 ${key} -->
        <property name="url" value=https://www.cnblogs.com/mengd/p/"${jdbc.url}" />
        
        
        


    

這樣就可以了

2. 注冊SqlSessionFactoryBean

 <!--SqlSessionFactory-->
    <!--宣告的是mybatis中提供的SqlSessionFactoryBean類，這個類內部創建SqlSessionFactory-->
    <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

        <!--set注入，把資料庫連接池付給dataSource屬性-->
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis主組態檔的位置
            configLocation屬性是Resource型別，讀取組態檔
            它的賦值使用的是value ， 指定檔案的路徑，使用的是classpath：表示檔案的位置
        -->
        <property name="configLocation" value=https://www.cnblogs.com/mengd/p/"classpath:mybatis.xml"/>
    

3. 定義 Mapper 掃描配置器 MapperScannerConfigurer

也就是創建dao物件

    <!--創建 dao物件
        使用SqlSession的getMapper(StudentDao.class)
        MapperScannerConfigurer在內部呼叫getMapper()生成每個dao介面的代理物件
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定的是SqlSessionFactory物件的id-->
        <property name="sqlSessionFactoryBeanName" value=https://www.cnblogs.com/mengd/p/"SqlSessionFactory"/>

        


        

        
        

    

4. 向 Service 注入介面名

 <!--宣告service-->
    <bean id="studentService" class="com.md.service.impl.StudentServiceImpl">

        <!--就是上面通過創建的dao物件-->
        <property name="studentDao" ref="studentDao"/>
    </bean>

總：

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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        把資料庫的配置資訊寫在一個獨立的檔案中，編譯修改資料庫的配置內容
        讓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注入提供連接資料庫資訊-->
        <!--<property name="url" value=https://www.cnblogs.com/mengd/p/"jdbc:mysql://localhost:3306/ssm" />-->
        
        
        

        
        
        
        

    



    
    
    

        
        
        
        
    



    
    
        
        

        


        

        
        


    


    




    



    
    

        
        
    

九、創建測驗類

 @Test
    public void test03(){
        ApplicationContext c = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 獲取到了spring容器中的物件
        StudentService studentService = (StudentService) c.getBean("studentService");
        studentService.addStudent(new Student(1008,"馮寶寶","[email protected]",20));

        // spring和mybatis整合在一起使用，事務是自動提交的

        List<Student> studentList = studentService.queryStudent();
        studentList.forEach(stu-> System.out.println(stu));

    }

整體目錄結構

十、總結

1. 新建maven專案
2. 加入maven依賴
   • spring依賴
   • mybatis依賴
   • mysql驅動
   • spring的事務依賴
   • mybatis和spring集成的依賴
   • 德魯伊，資料庫連接池的依賴
3. 創建物體類
4. 創建dao介面和mapper檔案
5. 創建mybatis主組態檔
6. 創建Service介面和實作類，屬性是dao
7. 創建spring的組態檔：宣告mybatis的物件交給spring創建
   • 資料源DateSource
   • SqlSessionFactory
   • Dao物件
   • 宣告自定義的service
8. 創建測驗類，獲取Service物件，通過service呼叫dao完成資料庫的訪問

標籤：Java

上一篇：Java自學-圖形界面 面板

下一篇：關于Mybatis使用原生介面開發的心得以及示例代碼