MyBatis框架高級應用詳解-有解無憂

專案已托管到GitHub，大家可以去GitHub查看下載！并搜索關注微信公眾號碼出Offer 領取各種學習資料！

一、ORM概述

物件關系映射（Object Relational Mapping，簡稱ORM）是通過使用描述物件和資料庫之間映射的元資料，將面向物件語言程式中的物件自動持久化到關系資料庫中，本質上就是將資料從一種形式轉換到另外一種形式，

二、ORM映射

2.1 MyBatis自動ORM失效

MyBatis只能自動維護庫表“列名”與“屬性名”相同時的一一對應關系，二者不同時，無法自動ORM，

自動ORM失效
007

2.2 解決方式一：列的別名

在SQL中使用 as 為查詢欄位添加列別名，以匹配屬性名，

<mapper namespace="com.mylifes1110.dao.ManagerDao">
    <select id="selectManagerByIdAndPwd" resultType="com.mylifes1110.bean.Manager">
        SELECT mgr_id AS id , mgr_name AS username , mgr_pwd AS password
        FROM t_managers
        WHERE mgr_id = #{id} AND mgr_pwd = #{pwd}
    </select>
</mapper>

2.3 解決方式二：結果映射

使用<resultMap id="別名" type="物體類物件名" >標簽來映射，匹配列名與屬性名，

注意： property設定屬性，column設定別名

<mapper namespace="com.mylifes1110.dao.ManagerDao">

    <!--定義resultMap標簽-->
    <resultMap id="managerResultMap" type="com.mylifes1110.bean.Manager">
          <!--關聯主鍵與列名-->
        <id property="id" column="mgr_id" />

          <!--關聯屬性與列名-->
        <result property="username" column="mgr_name" />
        <result property="password" column="mgr_pwd" />
    </resultMap>

     <!--使用resultMap作為ORM映射依據-->
    <select id="selectAllManagers" resultMap="managerResultMap">
        SELECT mgr_id , mgr_name , mgr_pwd
        FROM t_managers
    </select>
</mapper>

三、MyBatis處理關聯關系

3.1 映射關系

物體間的關系： 關聯關系（擁有 has、屬于 belong）

OneToOne： 一對一關系（Passenger--- Passport）

OneToMany： 一對多關系（Employee --- Department）

ManyToMany： 多對多關系（Student --- Subject）

3.2 映射表分析

Table建立外鍵關系
008

Entity添加關系屬性
009_2

Mapper中將屬性與列名對應
010

3.3 映射關系應用

3.3.1 標簽說明

結果映射標簽： <resultMap id="結果映射別名" type="物體類物件">

雙方均可建立關系屬性，建立關系屬性后，對應的Mapper檔案中需使用<ResultMap >完成多表映射

id映射標簽： <id property="ID名" column="ID別名" />

屬性映射標簽： <result property="屬性名" column="別名" />

映射單一物件標簽： <association property="物件屬性名" javaType="物體類包含的單一物件">

持有物件關系屬性使用<association>標簽來完成映射，此標簽是寫在<resultMap>標簽內

映射集合物件標簽： <collection property="集合屬性名" ofType="集合泛型內單一物件">

持有集合關系屬性，使用<collection>標簽來完成映射，此標簽是寫在<resultMap>標簽內

查詢標簽： <select id="介面方法名" resultMap="結果映射別名">

查詢標簽中resultMap屬性內填入的是結果映射別名

3.3.2 一對一關系應用

在一對一關系中，如果物體類中包含需要查詢的物件，則需要在<resultMap>標簽內添加<association>標簽來映射物體類中的單一物件

創建表

// 旅客表
create table passenger
(
    id       int auto_increment
        primary key,
    name     varchar(50) null,
    sex      tinyint     null,
    birthday date        null
);

// 護照表
create table passport
(
    id           int auto_increment
        primary key,
    nationlity   varchar(100) null,
    expire       date         null,
    passenger_id int          null
);

創建物體類物件

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Passport {
    private int id;
    private String nationlity;
    private Date expire;
    private int passengerId;
    private Passenger passenger;

    public Passport(String nationlity, Date expire, int passengerId) {
        this.nationlity = nationlity;
        this.expire = expire;
        this.passengerId = passengerId;
    }
}

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Passenger {
    private int id;
    private String name;
    private boolean sex;
    private Date birthday;
    private Passport passport;

    public Passenger(String name, boolean sex, Date birthday) {
        this.name = name;
        this.sex = sex;
        this.birthday = birthday;
    }
}

創建介面

package com.mylifes1110.dao;

import com.mylifes1110.bean.Passenger;
import org.apache.ibatis.annotations.Param;

public interface PassengerDao {
    Passenger selectPassengerById(@Param("id") int id);
}

創建Mapper.xml

<?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：所需實作的介面全限定名-->
<mapper namespace="com.mylifes1110.dao.PassengerDao">
    <!--封裝結果映射-->
    <resultMap id="passenger_passport" type="com.mylifes1110.bean.Passenger">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <result column="sex" property="sex"></result>
        <result column="birthday" property="birthday"></result>
        <!--封裝類中物件-->
        <association property="passport" javaType="com.mylifes1110.bean.Passport">
            <id column="id" property="id"></id>
            <result column="nationlity" property="nationlity"></result>
            <result column="expire" property="expire"></result>
        </association>
    </resultMap>

<!--查詢-->
<select id="selectPassengerById" resultMap="passenger_passport">
    select passenger.id,
       passenger.name,
       passenger.sex,
       passenger.birthday,
       passport.id pid,
       passport.nationlity,
       passport.expire,
       passport.passenger_id
from passenger
         join passport on passenger.id = passport.passenger_id
where passenger.id = #{id}
</select>
</mapper>

注冊Mapper

<!--Mapper注冊-->
<mappers>
    <mapper resource="mappers/PassengerMapper.xml"/>
<mappers>

測驗類

@Test
public void selectPassengerById() {
    PassengerDao passengerDao = MyBatisUtils.getMapper(PassengerDao.class);
    System.out.println(passengerDao.selectPassengerById(1));
}

3.3.3 一對多關系應用

在一對多關系中，可能會出現查詢一個物件（物體）的資訊，還有可能會出現查詢好多物件（物體集合）的資訊，那么我們可以判斷在查詢一個物件的資訊是可以使用<association>標簽，而查詢集合物件的資訊可以使用<collection>標簽

創建表

// 部門
create table department
(
    id       int auto_increment
        primary key,
    name     varchar(100) null,
    location varchar(200) null
);

// 員工
create table employee
(
    id      int auto_increment
        primary key,
    name    varchar(100) null,
    salary  double       null,
    dept_id int          null
);

物體類

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private int id;
    private String name;
    private double salary;
    private int deptId;
    private List<Department> departments;
}

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Department {
    private int id;
    private String name;
    private String location;
    private Employee employee;
}

Dao層介面

package com.mylifes1110.dao;

import com.mylifes1110.bean.Employee;

import java.util.List;

public interface EmployeeDao {
    List<Employee> selectAllEmployee();
}

Mapper.xml

<?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：所需實作的介面全限定名-->
<mapper namespace="com.mylifes1110.dao.EmployeeDao">
    <resultMap id="selectEmployeeAll" type="com.mylifes1110.bean.Employee">
        <id property="id" column="eid"></id>
        <result property="name" column="ename"></result>
        <result property="salary" column="salary"></result>
        <collection property="departments" ofType="com.mylifes1110.bean.Department">
            <id property="id" column="id"></id>
            <result property="name" column="name"></result>
            <result property="location" column="location"></result>
        </collection>
    </resultMap>
<select id="selectAllEmployee" resultMap="selectEmployeeAll">
    select department.id, department.name, department.location, employee.id eid, employee.name ename, employee.salary
from department
         join employee on department.id = employee.dept_id;
</select>
</mapper>

測驗類

@Test
public void selectAllEmployee() {
    EmployeeDao employeeDao = MyBatisUtils.getMapper(EmployeeDao.class);
    System.out.println(employeeDao.selectAllEmployee());
}

3.3.4 多對多關系應用

關于多對多在映射中還算是有挑戰性的，接下來是一個三表聯查來實作多對多映射

創建表

// 科目表
create table subject(
   id int primary key auto_increment,
   name varchar(100),
   grade int
)default charset =utf8;

// 學生表
create table student(
    id int primary key  auto_increment,
    name varchar(50),
    sex tinyint
)default charset =utf8;

// 學生和科目的中間管理表
create table student_subject(
  student_id int references student(id),
  subject_id int references subject(id),
  primary key (student_id,subject_id)
)default charset =utf8;

建立第三張關系表
011_2

物體類

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private int id;
    private String name;
    private boolean sex;
    private List<Subject> subjects;
}

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Subject {
    private int id;
    private String name;
    private int grade;
    private List<Student> students;
}

Dao層介面

package com.mylifes1110.dao;

import com.mylifes1110.bean.Subject;

import java.util.List;

public interface StudentDao {
    List<Subject> selectAllStudent();
}

Mapper.xml

<?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 = 所需實作的介面全限定名-->
<mapper namespace="com.mylifes1110.dao.StudentDao">
<resultMap id="subject_student" type="com.mylifes1110.bean.Subject">
    <id property="id" column="id"></id>
    <result property="name" column="name"></result>
    <result property="grade" column="grade"></result>
<collection property="students" ofType="com.mylifes1110.bean.Student">
    <id property="id" column="stuid"></id>
    <result property="name" column="stuname"></result>
    <result property="sex" column="sex"></result>
</collection>
</resultMap>
<select id="selectAllStudent" resultMap="subject_student">
select student.id stuid, student.name stuname, student.sex, subject.id, subject.name, subject.grade
from student
         join student_subject on student.id = student_subject.student_id
         join subject
              on student_subject.subject_id = subject.id;
</select>
</mapper>

測驗類

@Test
public void selectAllStudent() {
    StudentDao studentDao = MyBatisUtils.getMapper(StudentDao.class);
    System.out.println(studentDao.selectAllStudent());
}

四、動態SQL

4.1 動態SQL概述

MyBatis的映射檔案中支持在基礎SQL上添加一些邏輯操作，并動態拼接成完整的SQL之后再執行，以達到SQL復用、簡化編程的效果

4.2 sql標簽

關于<sql>標簽是用來抽取多個相同重復sql片段的標簽，抽取后并書寫此標簽內，隨后再為<sql id="別名">標簽內取一個別名，當需要引入重復sql片段時，使用<include refid="sql標簽別名">標簽來完成

<sql id="selectSql">
    select id, username, password, gender, birth
</sql>
<!--sql標簽使用-->
<select id="selectUserById1" resultType="com.mylifes1110.bean.User">
    <include refid="selectSql"></include>
    from tb_user where id = #{id}
</select>

4.3 if標簽

關于<if>標簽，它適用于是一個場景，我們的以前的增刪改查一旦寫了條件就寫死了，導致很不靈活，比如：在select查詢陳述句中定義了多個查詢條件，而這個當查詢的時候必須寫入這幾個查詢條件，缺一個都不行，當專案需求改了時怎么辦呢？只能需要修改代碼來實作，而<if>標簽能夠動態的來解除多條件的限制，當我們考慮好這幾個條件是可以實作動態條件查詢的時候，就可以使用<if>標簽來分配

// 如果username不為空并且不為空字串則username的值改為新值

<update id="updateUserById1"> 
    update tb_user set
    <if test="username != null and username != ''">username = #{username}</if>
    <if test="password != null">password = #{password}</if>
    <if test="gender != null">gender = #{gender}</if>
    <if test="birth != null">birth = #{birth}</if>
    where id = #{id}
</update>

該段代碼的意思就是我指定<if>標簽包裹的哪一個屬性都可以修改，而不是寫死的只要修改就必須所有的值都傳，那我們看一下測驗類，使用<if>標簽是怎么動態傳值的

@Test
public void updateUserById1() {
    User user = new User(1, "Z", null, null, null);
    UserDao userDao = MyBatisUtils.getMapper(UserDao.class);
    System.out.println(userDao.updateUserById1(user));
}

測驗類反映如果我們想改的值就可以直接傳入新值修改，不修改的值就只需要傳放入null即可

4.4 where標簽

<where>標簽用于補充Sql中使用的where關鍵，并且可以自動忽略前綴，比如：and和or前綴

<select id="selectBookByCondition" resultType="com.mylifes1110.bean.Book">
    SELECT id , name , author , publish , sort
    FROM t_books
    <where> 
        <if test="id != null">
            id = #{id}
        </if>

        <if test="name != null">
            and name = #{name}
        </if>

        <if test="author != null">
            and author = #{author}
        </if>

        <if test="publish != null">
            and publish = #{publish}
        </if>

        <if test="sort != null">
            and sort = #{sort}
        </if>
    </where>
</select>

該代碼有一種問題場景存在，我們查詢的時候不查詢id，把id傳入null，下一個name前面會多出一個and來干擾我們的查詢，普通的情況下使用就會報錯，而使用<where>標簽來包裹查詢條件，既補充了where關鍵字，又忽略了這種情況下而多出的and關鍵字，or關鍵字亦是如此！

4.5 set標簽

<set>標簽用于補充Sql陳述句中使用的set關鍵字，并且可以自動忽略后綴，比如：,（逗號）

<update id="updateBookByCondition">
    UPDATE t_books
    <set>
        <if test="name != null">
            name = #{name} ,
        </if>

        <if test="author != null">
            author = #{author} ,
        </if>

        <if test="publish != null">
            publish = #{publish} ,
        </if>

        <if test="sort != null">
            sort = #{sort} ,
        </if>
    </set>
    WHERE id = #{id}
</update>

同樣的思想，該代碼也會有一種問題場景存在，我們在修改的時候，修改的值正常都是所有值都傳入的，即使不修改的值，也是需要傳值的，這樣就導致了一種寫死的狀態，不能動態的修改自己所需要的值，當我們引入<set>標簽時，它可以補充set關鍵字并實作了動態修改自己想要的值，但是第一個值修改時，第二個值不修改的時候，后面就會多出來一個逗號來干擾修改，其<set>標簽就解決了此問題，忽略了后綴 , （逗號）

4.6 trim標簽

<trim prefix="" suffix="" prefixOverrides="" suffixOverrides="">是一個重量級標簽，它代替<where> 和<set>（前綴、后綴、前綴覆寫、后綴覆寫），并具有它們的所有功能

替換<where>標簽

<select id="selectBookByCondition" resultType="com.mylifes1110.bean.Book">
        SELECT id,name,author,publish,sort
    FROM t_books
    <!-- 增加WHERE前綴,自動忽略前綴 AND 或 OR -->
    <trim prefix="WHERE" prefixOverrides="AND |OR "> 
        <if test="id != null">
            and id = #{id}
        </if>

        <if test="name != null">
            and name = #{name}
        </if>

        <if test="author != null">
            and author = #{author}
        </if>

        <if test="publish != null">
            and publish = #{publish}
        </if>

        <if test="sort != null">
            and sort = #{sort}
        </if>
    </trim>
</select>

替換<set>標簽

<update id="updateBookByCondition">
    UPDATE t_books
    <!-- 增加SET前綴,自動忽略最后的 逗號 -->
    <trim prefix="SET" suffixOverrides=","> 
        <if test="name != null">
            name = #{name} ,
        </if>

        <if test="author != null">
            author = #{author} ,
        </if>

        <if test="publish != null">
            publish = #{publish} ,
        </if>

        <if test="sort != null">
            sort = #{sort}
        </if>
    </trim>
    WHERE id = #{id}
</update>

4.7 foreach標簽

<foreach>標簽可以用來實作批量插入資料和查詢資料

引數	描述	取值
collection	容器型別	list、array、map
open	起始符	(
close	結束符	)
separator	分隔符	,
index	下標號	從0開始，依次遞增
item	當前項	任意名稱（回圈中通過 #{任意名稱} 運算式訪問）

批量查詢

// 物體類
package com.mylifes1110.bean;

import java.io.Serializable;
import java.util.Date;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private Integer id;
    private String username;
    private String password;
    private String gender;
    private Date birth;
}

// Dao層介面
List<User> selectUsersBatch(List<Integer> ids);

// Mapper.xml
<select id="selectUsersBatch" resultType="com.mylifes1110.bean.User">
    <include refid="selectUser"></include>
    where id in
    <foreach collection="list" item="id" open="(" close=")" separator=",">
        (#{id})
    </foreach>
</select>

// 測驗類
@Test
public void selectUsersBatch() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    UserDao mapper = MyBatisUtil.getMapper(UserDao.class);
    List<User> users = mapper.selectUsersBatch(list);
    for (User user : users) {
        System.out.println(user);
    }
}

批量插入

// Dao層介面
int insertUserBatch(List<User> users);

// Mapper.xml
<insert id="insertUserBatch">
    insert into tb_user(username, password, gender, birth)
    values
    <foreach collection="list" item="user" open="" close="" separator=",">
        (#{user.username}, #{user.password}, #{user.gender}, #{user.birth})
    </foreach>
</insert>

// 測驗類
@Test
public void insertUserBatch() {
    List<User> list = new ArrayList<>();
    for (int i = 0; i <= 100; i++) {
        User user = new User(null, "MM", "GGGGGG", "f", new Date());
        list.add(user);
    }
    UserDao mapper = MyBatisUtil.getMapper(UserDao.class);
    System.out.println(mapper.insertUserBatch(list));
}

五、快取

5.1 快取的重要性

記憶體中的一塊存盤空間，服務于某個應用程式，旨在將頻繁讀取的資料臨時保存在記憶體中，便于二次快速訪問

無快取：用戶在訪問相同資料時，需要發起多次對資料庫的直接訪問，導致產生大量IO、讀寫硬碟的操作，效率低下
012

有快取：首次訪問時，查詢資料庫，將資料存盤到快取中；再次訪問時，直接訪問快取，減少IO、硬碟讀寫次數、提高效率
013

5.2 一級快取

SqlSession級別的快取，同一個SqlSession的發起多次同構查詢，會將資料保存在一級快取中

注意： 無需任何配置，默認開啟一級快取

測驗一級快取

@Test
public void testMapperCache1(){
      SqlSession sqlSession1 = MyBatisUtils.getSession();

      BookDao bookDao1 = sqlSession1.getMapper(BookDao.class);
    //第一次查詢，從資料庫獲取，并將查詢結果存入一級快取
      bookDao1.selectBookByCondition(new Book(1));
    //第二次查詢，從一級快取獲取
    bookDao1.selectBookByCondition(new Book(1));

      sqlSession1.close(); 
}

測驗后，你查看MyBatis日志，會發現結果第一次查詢觸發了查詢，而第二次的結果是從快取中拿出來的，并沒有觸發再次查詢

5.3 二級快取

SqlSessionFactory級別的快取，同一個SqlSessionFactory構建的SqlSession發起的多次同構查詢，會將資料保存在二級快取中

注意： 二級快取設定后，在sqlSession.commit()或者sqlSession.close()之后生效并且JavaBean必須實作序列化，三者缺一不可！

5.4 開啟全域快取

<settings>是MyBatis中極為重要的調整設定，他們會改變MyBatis的運行行為，而該標簽是放在<properties>標簽之后，別名標簽之前的

注意： mybaits-config.xml中開啟全域快取（默認開啟）

<configuration>
    <properties .../>

      <!-- 注意書寫位置 -->
    <settings>
        <setting name="cacheEnabled" value=https://www.cnblogs.com/ziph/p/"true"/>
    </settings>

      <typeAliases></typeAliases>
</configuration>

5.5 指定Mapper快取

我們可以通過一個簡單的<cache />標簽來指定某一個Mapper開啟快取

Mapper.xml

<mapper namespace="com.mylifes1110.dao.UserDao">
    <!-- 指定當前Mapper快取 -->
    <cache /> 

    <select id="selectUserById" resultType="com.mylifes1110.bean.User">
        SELECT * FROM t_user
    </select>
</mapper>

測驗類

@Test
public void testMapperCache(){
      SqlSession sqlSession1 = MyBatisUtils.getSession();
      BookDao bookDao1 = sqlSession1.getMapper(BookDao.class);
      bookDao1.selectBookByCondition(new Book());
    //必須關閉SqlSession才可快取資料
      sqlSession1.close(); 

      SqlSession sqlSession2 = MyBatisUtils.getSession();
      BookDao bookDao2 = sqlSession2.getMapper(BookDao.class);
      bookDao2.selectBookByCondition(new Book());
      sqlSession2.close(); //快取擊中
}

如果你使用了MyBatis日志依賴，可以查看到這么一條資訊，這條日志反映了從該資料被快取后，被拉取該快取的幾率為百分之50，也就是一共查詢了兩次，快取中查出來了一次

快取擊中
image-20200711203246412

5.6 快取清空并重新快取

快取清空： 從資料被快取，隨后資料被增刪改操作后快取即為清空

重新快取： 增刪改操作過后，當重新被查詢該資料后，此時快取未擊中便重新快取

@Test
public void testMapperCache2(){
      SqlSession sqlSession1 = MyBatisUtils.getSession();
      UserDao UserDao1 = sqlSession1.getMapper(UserDao.class);
      UserDao1.selectUserByUser(new User());
      sqlSession1.close(); //必須關閉SqlSession才可快取資料

    SqlSession sqlSession3 = MyBatisUtils.getSession();
    UserDao bookDao3 = sqlSession3.getMapper(UserDao.class);
    UserDao3.deleteUserById(102);
    sqlSession3.commit(); //DML成功，資料發生變化，快取清空
    sqlSession3.close();

      SqlSession sqlSession2 = MyBatisUtils.getSession();
      UserDao userDao2 = sqlSession2.getMapper(UserDao.class);
      UserDao2.selectUserByUser(new User());
      sqlSession2.close(); //快取未擊中，重新查詢資料庫、重新快取
}

六、Durid連接池

6.1 Durid連接池概述

Druid 是阿里巴巴開源平臺上的一個專案，整個專案由資料庫連接池、插件框架和 SQL 決議器組成，該專案主要是為了擴展 JDBC 的一些限制，可以讓程式員實作一些特殊的需求，比如向密鑰服務請求憑證、統計 SQL 資訊、SQL 性能收集、SQL 注入檢查、SQL 翻譯等，程式員可以通過定制來實作自己需要的功能，

6.2 不同連接池對比

測驗執行申請歸還連接 1,000,000（一百萬）次總耗時性能對比，

6.2.1 測驗環境

環境	版本
OS	OS X 10.8.2
CPU	Intel i7 2GHz 4 Core
JVM	Java Version 1.7.0_05

6.2.2 基準測驗結果對比

JDBC-Conn Pool	1 Thread	2 threads	5 threads	10 threads	20 threads	50 threads
Druid	898	1,191	1,324	1,362	1,325	1,459
tomcat-jdbc	1,269	1,378	2,029	2,103	1,879	2,025
DBCP	2,324	5,055	5,446	5,471	5,524	5,415
BoneCP	3,738	3,150	3,194	5,681	11,018	23,125
jboss-datasource	4,377	2,988	3,680	3,980	32,708	37,742
C3P0	10,841	13,637	10,682	11,055	14,497	20,351
Proxool	16,337	16,187	18,310(Ex)	25,945	33,706(Ex)	39,501 (Ex)

6.2.3 測驗結論

Druid 是性能最好的資料庫連接池，tomcat-jdbc 和 druid 性能接近，
Proxool 在激烈并發時會拋例外，不適用，
C3P0 和 Proxool 都相當慢，影響 sql 執行效率，
BoneCP 性能并不優越，采用 LinkedTransferQueue 并沒有能夠獲得性能提升，
除了 bonecp，其他的在 JDK 7 上跑得比 JDK 6 上快，
jboss-datasource 雖然穩定，但性能很糟糕，

6.3 Durid連接的開發步驟

6.3.1 引入依賴

在Maven專案中的pom.xml檔案中引入阿里巴巴的Durid連接池

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

6.3.2 替換MyBatis中的默認資料源

MyBatis中是有默認資料源的，如果我們想用其他連接池，需要替換默認資料源

操作： MyDruidDataSourceFactory并繼承PooledDataSourceFactory，并替換資料源

package com.mylifes1110.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory;

public class MyDruidDataSource extends PooledDataSourceFactory {

    public MyDruidDataSource() {
        this.dataSource = new DruidDataSource();
    }
}

6.3.3 配置mybatis-config.xml

修改mybatis-config.xml檔案中連接池相關配置

注意： < property name="屬性名" />屬性名必須與com.alibaba.druid.pool.DruidAbstractDataSource中一致

<!--連接池-->
<dataSource type="com.mylifes1110.utils.MyDruidDataSourceFactory"><!--資料源工廠-->
    <property name="driverClass" value=https://www.cnblogs.com/ziph/p/"${driver}"/>
    <property name="jdbcUrl" value=https://www.cnblogs.com/ziph/p/"${url}"/>
    <property name="username" value=https://www.cnblogs.com/ziph/p/"${username}"/>
    <property name="password" value=https://www.cnblogs.com/ziph/p/"${password}"/> 
</dataSource>

七、分頁插件（PageHelper）

7.1 PageHelper概述

PageHelper是一個適用于MyBatis框架的一個分頁插件，使用方式極為便捷，支持任何復雜的單表、多表分頁查詢操作

7.2 官網

官方網站：https://pagehelper.github.io/

下載地址：https://github.com/pagehelper/Mybatis-PageHelper

7.3 PageHelper開發步驟

7.3.1 引入依賴

在Maven專案中的pom.xml檔案中引入PageHelper依賴

<dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>5.1.10</version>
</dependency>

7.3.2 配置mybatis-config.xml

在核心組態檔中的別名標簽<typeAliases>和<environments>內添加<plugins>標簽并引入PageHelper配置

<configuration>
      <typeAliases></typeAliases>

    <plugins>
        <!-- com.github.pagehelper為PageHelper類所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

      <environments>...</environments>
</configuration>

7.4 PageInfo物件

PageInfo物件是PageHelper插件中的一個類，里面包含了如下頁面中所需要的所有相關資料

PageInfo結構圖
image-20200116145234073

7.5 注意事項

只有在PageHelper.startPage()方法之后的第一個查詢會有執行分頁

分頁插件不支持帶有“for update” 的查詢陳述句

分頁插件不支持“嵌套查詢”，由于嵌套結果方式會導致結果集被折疊，所以無法保證分頁結果數量正確

7.6 分頁查詢

7.6.1 創建表

create table tb_user
(
    id       int auto_increment
        primary key,
    username varchar(30) null,
    password varchar(30) null,
    gender   char        null,
    birth    date        null
);

7.6.2 物體類

package com.mylifes1110.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private int id;
    private String username;
    private String password;
    private boolean gender;
    private Date birth;
}

7.6.3 Dao層

package com.mylifes1110.dao;

import com.mylifes1110.bean.User;

import java.util.List;

public interface UserDao {
    List<User> selectUserByPage();
}

7.6.4 datasource

package com.mylifes1110.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory;

public class MyDruidDataSource extends PooledDataSourceFactory {

    public MyDruidDataSource(){
        this.dataSource = new DruidDataSource();
    }
}

7.6.5 Service層

// 介面
package com.mylifes1110.service;

import com.github.pagehelper.PageInfo;
import com.mylifes1110.bean.User;

public interface UserService {
    PageInfo<User> selectUserByPage(int pageNum, int pageSize);
}

package com.mylifes1110.service.impl;


// 實作類
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mylifes1110.bean.User;
import com.mylifes1110.dao.UserDao;
import com.mylifes1110.service.UserService;
import com.mylifes1110.utils.MyBatisUtil;

import java.util.List;

public class UserServiceImpl implements UserService {

    @Override
    public PageInfo<User> selectUserByPage(int pageNum, int pageSize) {
        UserDao userDao = MyBatisUtil.getMapper(UserDao.class);
        PageHelper.startPage(pageNum, pageSize);
        List<User> userList = userDao.selectUserByPage();
        MyBatisUtil.closeSession();
        return new PageInfo<User>(userList);
    }
}

7.6.6 工具類

package com.mylifes1110.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class MyBatisUtil {
    //獲得SqlSession工廠
    private static SqlSessionFactory factory;

    //創建ThreadLocal系結當前執行緒中的SqlSession物件
    private static final ThreadLocal<SqlSession> tl = new ThreadLocal<SqlSession>();

    static {
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            factory = new SqlSessionFactoryBuilder().build(is);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //獲得連接（從tl中獲得當前執行緒SqlSession）
    private static SqlSession openSession(){
        SqlSession session = tl.get();
        if(session == null){
            session = factory.openSession();
            tl.set(session);
        }
        return session;
    }

    // 每次回傳一個新創建的sqlSession
    public static SqlSession getSession(){
        return factory.openSession();
    }

    //釋放連接（釋放當前執行緒中的SqlSession）
    public static void closeSession(){
        SqlSession session = tl.get();
        session.close();
        tl.remove();
    }

    //提交事務（提交當前執行緒中的SqlSession所管理的事務）
    public static void commit(){
        SqlSession session = openSession();
        session.commit();
        closeSession();
    }

    //回滾事務（回滾當前執行緒中的SqlSession所管理的事務）
    public static void rollback(){
        SqlSession session = openSession();
        session.rollback();
        closeSession();
    }

    //獲得介面實作類物件
    public static <T extends Object> T getMapper(Class<T> clazz){
        SqlSession session = openSession();
        return session.getMapper(clazz);
    }
}

7.6.7 controller

package com.mylifes1110.controller;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.github.pagehelper.PageInfo;

import com.mylifes1110.bean.User;
import com.mylifes1110.service.UserService;
import com.mylifes1110.service.impl.UserServiceImpl;

@WebServlet(
    name  = "UserServlet",
    value = "/user/page"
)
public class UserServlet extends HttpServlet {
    private UserService userService = new UserServiceImpl();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        int    pageNum     = 1;
        int    pageSize    = 5;
        String pageNumStr  = request.getParameter("pageNum");
        String pageSizeStr = request.getParameter("pageSize");

        if (pageNumStr != null) {
            pageNum = Integer.parseInt(pageNumStr);
        }

        if (pageSizeStr != null) {
            pageSize = Integer.parseInt(pageSizeStr);
        }

        PageInfo<User> pageInfo = userService.selectUserByPage(pageNum, pageSize);

        request.setAttribute("pageInfo", pageInfo);
        request.getRequestDispatcher("/index.jsp").forward(request, response);
    }
}

7.6.8 Mapper.xml

<?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 = 所需實作的介面全限定名-->
<mapper namespace="com.mylifes1110.dao.UserDao">
    <select id="selectUserByPage" resultType="com.mylifes1110.bean.User">
        select id, username, password, gender, birth from tb_user
    </select>
</mapper>

7.6.9 index.jsp

<%--
  Created by IntelliJ IDEA.
  User: Ziph
  Date: 2020/7/8
  Time: 17:59
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<script src="${pageContext.request.contextPath}/js/jquery-2.1.0.js"></script>
<!-- 最新版本的 Bootstrap 核心 CSS 檔案 -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
      integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
<!-- 最新的 Bootstrap 核心 JavaScript 檔案 -->
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.min.js"
        integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa"
        crossorigin="anonymous"></script>
<html>
<head>
    <title>index</title>
</head>
<body>
<table class="table table-striped table-bordered table-hover">
    <tr>
        <th>ID</th>
        <th>用戶名</th>
        <th>密碼</th>
        <th>性別</th>
        <th>出生日期</th>
    </tr>
    <c:forEach items="${pageInfo.list}" var="user">
        <tr>
            <td>${user.id}</td>
            <td>${user.username}</td>
            <td>${user.password}</td>
            <td>${user.gender}</td>
            <td>
                <fmt:formatDate value="${user.birth}" pattern="yyyy/MM/dd"/>
            </td>
        </tr>
    </c:forEach>
</table>
<div align="center">
    <nav aria-label="Page navigation">
        <ul class="pagination">
            <c:if test="${pageInfo.hasPreviousPage}">
                <li>
                    <a href="${pageContext.request.contextPath}/user/page?pageNum=${pageInfo.prePage}"
                       aria-label="Previous">
                        <span aria-hidden="true">&laquo;</span>
                    </a>
                </li>
            </c:if>
            <c:forEach begin="1" end="${pageInfo.pages}" var="i">
                <c:if test="${pageInfo.pageNum == i}">
                    <li class="active"><a href="${pageContext.request.contextPath}/user/page?pageNum=${i}">${i}</a>
                    </li>
                </c:if>
                <c:if test="${pageInfo.pageNum != i}">
                    <li><a href="${pageContext.request.contextPath}/user/page?pageNum=${i}">${i}</a></li>
                </c:if>
            </c:forEach>
            <c:if test="${pageInfo.hasNextPage}">
                <li>
                    <a href="${pageContext.request.contextPath}/user/page?pageNum=${pageInfo.nextPage}"
                       aria-label="Next">
                        <span aria-hidden="true">&raquo;</span>
                    </a>
                </li>
            </c:if>
        </ul>
    </nav>
</div>
</body>
</html>

7.6.10 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>org.example</groupId>
    <artifactId>paging</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <!--MySql驅動依賴-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <!-- jstl 支持 -->
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <!-- servlet編譯環境 -->
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <!-- jsp編譯環境 -->
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

7.6.11 各種組態檔

jdbc.properties

#jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db2004?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

log4j.properties

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.com.qf.mybatis.part1.basic=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

mybatis-config.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">

<!--MyBatis配置-->
<configuration>
    <properties resource="jdbc.properties"/>
    <!-- mybaits-config.xml中開啟全域快取（默認開啟） -->
    <settings>
        <setting name="cacheEnabled" value=https://www.cnblogs.com/ziph/p/"true"/>
    </settings>

    <!-- 定義物體的別名 -->
    <typeAliases>
        <!--<typeAlias type="com.qianfeng.entity.User" alias="User" />-->
        <package name="com.mylifes1110.bean"/>
    </typeAliases>
    <!--分頁插件-->
    <plugins>
        <!-- com.github.pagehelper為PageHelper類所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
    <!--JDBC環境配置、選中默認環境-->
    <environments default="MySqlDB">
        <!--MySql資料庫環境配置-->
        <environment id="MySqlDB">
            <!--事務管理-->
            <transactionManager type="JDBC"/>
            <!--連接池-->
            <dataSource type="com.mylifes1110.datasource.MyDruidDataSource">
                <property name="driverClass" value=https://www.cnblogs.com/ziph/p/"${jdbc.driver}"/>
                <!-- &轉義&amp; -->
                <property name="jdbcUrl" value=https://www.cnblogs.com/ziph/p/"${jdbc.url}"/>
                <property name="username" value=https://www.cnblogs.com/ziph/p/"${jdbc.username}"/>
                <property name="password" value=https://www.cnblogs.com/ziph/p/"${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--Mapper注冊-->
    <mappers>
        <!--注冊Mapper檔案的所在位置-->
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

八、MyBatis補充

8.1 MyBatis注解開發

在MyBaits中是可以通過注解來完成CRUD的

注意： 介面注解定義完畢后，需將介面全限定名注冊到mybatis-config.xml的< mappers >中

經驗： 注解模式屬于硬編碼到.java檔案中，失去了使用組態檔外部修改的優勢，可結合需求選用

<mappers>
    <!-- class：介面全限定名 -->
    <mapper class="com.mylifes1110.dao.UserMapper" />
</mappers>

8.1.1 查詢

public interface UserMapper {
    @Select("SELECT * FROM t_users WHERE id = #{id}")
    public User selectUserById(Integer id);

    @Select("SELECT * FROM t_users WHERE id = #{id} AND password = #{pwd}")
    public User selectUserByIdAndPwd_annotation(@Param("id") Integer id, @Param("pwd") String password);
}

8.1.2 洗掉

@Delete(value = "DELETE FROM t_users WHERE id = #{id}")
public int deleteUser(Integer id);

8.1.3 修改

@Update("UPDATE t_users SET name = #{name} , password = #{password} , salary = #{salary} , birthday = #{birthday} WHERE id = #{id}")
public int updateUser(User user);

8.1.4 插入

@Insert("INSERT INTO t_users VALUES(#{id},#{name},#{password},#{salary},#{birthday},null)")
public int insertUser(User user);

@Options(useGeneratedKeys = true , keyProperty = "id") // 自增key，主鍵為id
@Insert("INSERT INTO t_users VALUES(#{id},#{name},#{password},#{salary},#{birthday},null)")
public int insertUserGeneratedKeys(User user);

8.2 $符號的應用場景

${attribute} 屬于字串拼接SQL，而非預編譯占位符，會有注入攻擊問題，不建議在常規SQL中使用，常用于可解決動態生降序問題

8.2.1 $符號引數系結

不能識別此Latex公式:
符號可用于拼接Sql陳述句，可以解決#符號傳值解決不了的問題，如下是使用
符號引數系結實作同一按鈕升降序功能

注意： 在使用$符號時，必須使用@Param注解來傳遞引數，我們必須手動的指定傳入升降序規則

Dao層介面

List<User> selectUsersByUsername(@Param("username") String username, @Param("rule") String rule);

Mapper.xml

<select id="selectUsersByUsername" resultType="com.mylifes1110.bean.User">
    <include refid="selectUser"></include>
    where username like concat('%', #{username}, '%')
    order by id ${rule}
</select>

測驗類

@Test
public void selectUsersByUsername() {
    UserDao mapper = MyBatisUtil.getMapper(UserDao.class);
    // 降序
    System.out.println(mapper.selectUsersByUsername("M", "desc"));
    // 升序
    System.out.println(mapper.selectUsersByUsername("M", "asc"));
}

8.2.2 $符號注入攻擊

<select id="selectUsersByKeyword" resultType="User">
    <!-- 會存在注入攻擊  比如傳入引數是 【String name = "tom' or '1'='1";】-->
    SELECT * FROM t_user
      WHERE name = '${name}' 
</select>

注入攻擊，拼接的內容，改變了原sql語意，被攻擊！
注入

8.2.3 避免使用$符號注入攻擊

在使用$符號時，避免直接的接受處理表單引數，接收表單引數后在Service層做一系列傳入引數處理，這樣傳入的引數不是直接的向資料庫做一系列操作，而是以類似別名的形式訪問操作資料庫，

這樣以來即使被注入，該資料也不能直接的操作資料庫，所以這樣的做法是安全的

9.3 MyBatis處理關聯關系-嵌套查詢（了解）

思路： 查詢部門資訊時，及聯查詢所屬的員工資訊

DepartmentDao介面中定義selectDepartmentById，并實作Mapper

EmployeeDao介面中定義selectEmployeesByDeptId，并實作Mapper

當selectDepartmentById被執行時，通過< collection >呼叫selectEmployeesByDeptId方法，并傳入條件引數

9.3.1 主表查詢

定義selectEmployeesByDeptId，并書寫Mapper，實作根據部門ID查詢員工資訊

Dao層介面

public interface EmployeeDao {
    public List<Employee> selectEmployeeByDeptId(@Param("did") String did);
}

Mapper.xml

<mapper namespace="com.mylifes1110.dao.EmployeeDao">
    <!-- 根據部門編號查詢所有員工 -->
    <select id="selectEmployeeById" resultType="Employee" >
        SELECT id,name,salary,dept_id 
          FROM t_employees 
          WHERE dept_id = #{did}
    </select>
</mapper>

9.3.2 級聯呼叫

定義selectDepartmentById，并書寫Mapper，實作根據部門ID查詢部門資訊，并及聯查詢該部門員工資訊

Dao層介面

public interface DepartmentDao {
    public Department selectDepartmentById(@Param("id") String id);
}

Mapper.xml

<mapper namespace="com.mylifes1110.dao.DepartmentDao">
    <resultMap id="departmentResultMap" type="department">
        <id property="id" column="id" />
        <result property="name" column="name" />
        <result property="location" column="location" />
         <!-- column="傳入目標方法的條件引數"  select="及聯呼叫的查詢目標"-->
        <collection property="emps" ofType="Employee" column="id" 
                    select="com.mylifes1110.dao.EmployeeDao.selectEmployeeByDeptId" />
    </resultMap>
    <select id="selectAllDepartments" resultMap="departmentResultMap">
        SELECT id , name , location
        FROM t_departments
        WHERE id = #{id}
    </select>
</mapper>

9.3.3 延遲加載

mybatis-config.xml中開啟延遲加載

注意： 開啟延遲加載后，如果不使用及聯資料，則不會觸發及聯查詢操作，有利于加快查詢速度、節省記憶體資源

<settings>
    <!-- 開啟延遲加載（默認false） -->
    <setting name="lazyLoadingEnabled" value="true"/> 
</settings>

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/145707.html

標籤：Java

上一篇：## Java基礎(一)：八種資料型別

下一篇：Java例外