js中三個點用法、yiled*用法

阿新 • • 發佈：2020-12-23

技術標籤：Mybatis

MyBatis

環境：

JDK：1.8
MySQL：5.7
maven：3.6.1
IDEA

回顧：

JDBC
MySQL
Java基礎
Maven
Junit

1. 簡介

SSM框架：配置檔案。最好的方式：看官網

1.1 什麼是MyBatis

MyBatis 是一款優秀的持久層框架
它支援自定義 SQL、儲存過程以及高階對映。
MyBatis 免除了幾乎所有的 JDBC 程式碼以及設定引數和獲取結果集的工作。
MyBatis 可以通過簡單的 XML 或註解來配置和對映原始型別、介面和 Java POJO（Plain Old Java Objects，普通老式 Java 物件）為資料庫中的記錄。

MyBatis2013年11月遷移到Github

如何獲得MyBatis：

maven倉庫

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

Github
中文文件

1.2 持久化

資料持久化

持久化就是將程式的資料在持久狀態和瞬時狀態轉化的過程
記憶體：斷電即失
資料庫（JDBC），IO檔案持久化

為什麼需要持久化

有一些物件不能讓它丟掉
記憶體太貴了

1.3 持久層

Dao層、Service層、Controller層……

完成持久化工作的程式碼塊
層是界限十分明顯的

1.4 為什麼需要MyBatis

幫助程式猿將資料存入到資料庫中
方便
傳統的JDBC程式碼太複雜，簡化–>框架
不用MyBatis也可以。用了更容易上手，技術沒有高低之分
優點：
- 簡單易學：本身就很小且簡單。沒有任何第三方依賴，最簡單安裝只要兩個jar檔案+配置幾個sql對映檔案易於學習，易於使用，通過文件和原始碼，可以比較完全的掌握它的設計思路和實現。
- 靈活：mybatis不會對應用程式或者資料庫的現有設計強加任何影響。 sql寫在xml裡，便於統一管理和優化。通過sql語句可以滿足操作資料庫的所有需求。
- 解除sql與程式程式碼的耦合：通過提供DAO層，將業務邏輯和資料訪問邏輯分離，使系統的設計更清晰，更易維護，更易單元測試。sql和程式碼的分離，提高了可維護性。
- 提供對映標籤，支援物件與資料庫的orm欄位關係對映
- 提供物件關係對映標籤，支援物件關係組建維護
- 提供xml標籤，支援編寫動態sql。

2. 第一個MyBatis程式

思路：搭建環境–>匯入MyBatis–>編寫程式碼–>測試

2.1 搭建環境

搭建資料庫

(Navicat)

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user` (
`id` int( 20 ) NOT NULL AUTO_INCREMENT ,
`name` varchar( 30 ) default NULL ,
`pwd` varchar( 30 ) default NULL ,
PRIMARY KEY ( `id` )
) ENGINE = Innodb default CHARSET = gb2312

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'hxh','123456'),
(2,'張三','zhang'),
(3,'李四','li');

新建專案

新建一個普通的Maven專案
刪除src目錄（當成一個父工程）

匯入maven依賴

<?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.hxh</groupId>
    <artifactId>Mybatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--匯入依賴-->
    <dependencies>
        <!--mysql驅動-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>


</project>

2.2 建立一個模組

編寫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核心配置檔案-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSl=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="Qy=UyPk%z6m9"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

編寫MyBatis的工具類

package com.hxh.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;

//SqlSessionFactory-->SqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static{
        try {
            //使用MyBatis第一步：獲取SqlSessionFactory物件
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //既然有了 SqlSessionFactory，顧名思義，我們可以從中獲得 SqlSession 的例項。
    // SqlSession 提供了在資料庫執行 SQL 命令所需的所有方法。
    public static SqlSession getSqlSession(){
        //SqlSession sqlSession = sqlSessionFactory.openSession();
        //return sqlSession;上面兩句等同於下面，能簡化就簡化
        return sqlSessionFactory.openSession();
    }
}

2.3 編寫程式碼

資料庫相關，要寫實體類

根據資料庫設定實體類，有參無參構造，getter and setter，toString

package com.hxh.pojo;

//實體類
public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

操作實體類的實現類

Dao介面

package com.hxh.dao;

import com.hxh.pojo.User;

import java.util.List;

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

介面實現類由原來的Impl轉換為一個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：繫結一個對應的Dao或者Mapper介面-->
<mapper namespace="com.hxh.dao.UserDao">
    <!--select：查詢語句，id對應方法名字-->
    <select id="getUserList" resultType="com.hxh.pojo.User">
    select * from mybatis.user
  </select>
</mapper>

2.4 測試

注意點：

org.apache.ibatis.binding.BindingException: Type interface com.hxh.dao.UserDao is not known to the MapperRegistry.

MapperRegistry：核心配置檔案中註冊mapper

解決方法：在resources/mybatis-mapper.xml中配置

<!--每一個Mapper.xml都需要在Mybatis核心配置檔案中註冊-->
<mappers>
    <mapper resource="com/hxh/dao/UserMapper.xml"/>
</mappers>

junit測試

package com.hxh.dao;

import com.hxh.pojo.User;
import com.hxh.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //第一步：獲得SqlSession物件
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //執行SQL，方式一：getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
    	  //方式二：不推薦使用
        //List<User> userList = sqlSession.selectList("com.hxh.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //關閉SqlSession
        sqlSession.close();
    }
}

可能遇到的問題：

配置檔案沒有註冊
2. 繫結介面錯誤
3. 方法名不對
4. 返回型別不對
5. Maven匯出資源問題

   <!--在build中配置resources，來防止我們資源匯出失敗的問題
   org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration.
   Cause: java.io.IOException: Could not find resource com/hxh/dao/UserMapper.xml-->
   <build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.xml</include>
                   <include>**/*.properties</include>
               </includes>
               <filtering>true</filtering>
           </resource>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.xml</include>
                   <include>**/*.properties</include>
               </includes>
               <filtering>true</filtering>
           </resource>
       </resources>
   </build>

3. CRUD

1. namespace

namespace中的包名要和Dao/Mapper介面的包名一致

2. select

選擇，查詢語句：

id：就是對應的namespace中的方法名
resultType：SQL語句執行的返回值
parameterType：引數型別

編寫介面

//根據id查詢使用者
User getUserById(int id);

編寫對應的Mapper中的sql語句

<select id="getUserById" parameterType="int" resultType="com.hxh.pojo.User">
    select * from mybatis.user where id = #{id}
</select>

測試

@Test
public void getUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.getUserById(1);
    System.out.println(user);

    sqlSession.close();
}

3. Insert

4. Update

5. Delete

編寫介面

package com.hxh.dao;

import com.hxh.pojo.User;

import java.util.List;

public interface UserMapper {
    //查詢全部使用者
    List<User> getUserList();
    //根據id查詢使用者
    User getUserById(int id);
    //insert一個使用者
    int addUser(User user);
    //修改使用者
    int updateUser(User user);
    //刪除使用者
    int deleteUser(int id);
}

編寫對應的Mapper中的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">
<!--namespace：繫結一個對應的Dao或者Mapper介面-->
<mapper namespace="com.hxh.dao.UserMapper">
    <!--select：查詢語句，id對應方法名字-->
    <select id="getUserList" resultType="com.hxh.pojo.User" >
    select * from mybatis.user
  </select>

    <select id="getUserById" parameterType="int" resultType="com.hxh.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>

    <!--物件中的屬性可以直接取出來-->
    <insert id="addUser" parameterType="com.hxh.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>

    <update id="updateUser" parameterType="com.hxh.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id = #{id}
    </delete>
</mapper>

測試

package com.hxh.dao;

import com.hxh.pojo.User;
import com.hxh.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        //第一步：獲得SqlSession物件
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try {
            //執行SQL，方式一：getMapper
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<User> userList = userMapper.getUserList();
            for (User user : userList) {
                System.out.println(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //關閉SqlSession
            sqlSession.close();
        }
    }
    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);

        sqlSession.close();
    }

    //增刪改需要提交事務
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.addUser(new User(4, "哈哈", "123123"));
        if (result>0){
            System.out.println("插入成功");
        }
        //提交事務
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(4,"嘿","111111"));
        //提交事務
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(4);
        sqlSession.commit();
        sqlSession.close();
    }
}

注意點：

增刪改需要提交事務：sqlSession.commit();

6. 分析錯誤

標籤不要匹配錯
resource繫結mapper，需要使用路徑
程式配置檔案必須符合規範
NullPointerException：空指標異常，沒有註冊到資源
輸出的xml檔案中存在亂碼問題
maven資源沒有匯出

7. 萬能Map

假設我們的實體類或者資料庫中的類、欄位或者引數過多，我們應當考慮使用Map

//萬能的Map，不需要知道資料庫裡有什麼，只需要查對應的欄位
int addUser2(Map<String,Object> map);

<!--物件中的屬性可以直接取出來
傳遞Mapper的key-->
<insert id="addUser2" parameterType="map">
    insert into mybatis.user (id,name,pwd) values (#{userid},#{userName},#{password});
</insert>

@Test
public void addUser2(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("userid",5);
    map.put("userName","hello");
    map.put("password",121212);
    mapper.addUser2(map);
    sqlSession.close();
}

Map傳遞引數，直接在SQL中取出key即可（parameterType=“map”）

物件傳遞引數，直接在SQL中取物件的屬性即可（parameterType=“Object”）

只有一個基本型別引數的情況下，可以直接在SQL中取到（可以不寫）

多個引數用Map或者註解

8. 模糊查詢

Java程式碼執行的時候，傳遞萬用字元% %：List userLike = mapper.getUserLike("%李%")

List<User> getUserLike(String value);

<select id="getUserLike" resultType="com.hxh.pojo.User">
    select * from mybatis.user where name like #{value }
</select>

@Test
public void getUserLike(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userLike = mapper.getUserLike("%李%");
    for (User user : userLike) {
        System.out.println(user);
    }
    sqlSession.close();
}

在SQL拼接中使用萬用字元 select * from mybatis.user where name like “%”#{value}"%"

4. 配置解析

1. 核心配置檔案

mybatis-config.xml

configuration（配置）
properties（屬性）
settings（設定）
typeAliases（類型別名）
typeHandlers（型別處理器）
objectFactory（物件工廠）
plugins（外掛）
environments（環境配置）
environment（環境變數）
transactionManager（事務管理器）
dataSource（資料來源）
databaseIdProvider（資料庫廠商標識）
mappers（對映器）

2. 環境配置（environments）

MyBatis 可以配置成適應多種環境

儘管可以配置多個環境，但每個 SqlSessionFactory 例項只能選擇一種環境

學會使用配置多套環境執行

<environments default="test"> <!--通過default選擇環境，當前選擇的是test環境-->
    <environment id="development">
        <transactionManager type="JDBC"/>  <!--事務管理器-->
        <dataSource type="POOLED">  <!--資料來源-->
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSl=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="Qy=UyPk%z6m9"/>
        </dataSource>
    </environment>
    
    <environment id="test">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSl=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="Qy=UyPk%z6m9"/>
        </dataSource>
    </environment>
</environments>

MyBaits預設的事務管理器是JDBC，預設的連線池是POOLED

3. 屬性（properties）

我們可以通過propertier屬性來實現引用配置檔案

這些屬性可以在外部進行配置，並可以進行動態替換。你既可以在典型的 Java 屬性檔案中配置這些屬性，也可以在 properties 元素的子元素中設定【db.properties】

編寫一個配置檔案db.properties：

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSl=true&useUnicode=true&characterEncoding=UTF-8
username=root
pwd=Qy=UyPk%z6m9

在核心配置檔案中引入

在xml中所有的標籤都可以規定其順序：

properties、settings、typeAliases、typeHandlers、objectFactory、objectwrapperFactory、reflectorFactory、plugins、environments、databaseIdPrpvider、mappers

<configuration>
    <!--引入web配置檔案-->
    <properties resource="db.properties"/>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一個Mapper.xml都需要在Mybatis核心配置檔案中註冊-->
    <mappers>
        <mapper resource="com/hxh/dao/UserMapper.xml"/>
    </mappers>
</configuration>

<!--引入外部配置檔案-->
<properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="pwd" value="Qy=UyPk%z6m9"/>
</properties>

可以直接引用外部檔案
可以在其中增加一些屬性配置
如果兩個檔案有同一個欄位，優先使用外部配置檔案

如果一個屬性在不只一個地方進行了配置，那麼，MyBatis 將按照下面的順序來載入：

首先讀取在 properties 元素體內指定的屬性。
然後根據 properties 元素中的 resource 屬性讀取類路徑下屬性檔案，或根據 url 屬性指定的路徑讀取屬性檔案，並覆蓋之前讀取過的同名屬性。
最後讀取作為方法引數傳遞的屬性，並覆蓋之前讀取過的同名屬性。

因此，通過方法引數傳遞的屬性具有最高優先順序，resource/url 屬性中指定的配置檔案次之，最低優先順序的則是 properties 元素中指定的屬性。

4. 類型別名（typeAliases）

類型別名可為 Java 型別設定一個縮寫名字。
它僅用於 XML 配置，意在降低冗餘的全限定類名書寫。

<!--可以給實體類起別名-->
<typeAliases>
    <typeAlias type="com.hxh.pojo.User" alias="User"/>
</typeAliases>

<!--select：查詢語句，id對應方法名字-->
<select id="getUserList" resultType="User" >
  select * from mybatis.user
</select>

也可以指定一個包名，MyBatis 會在包名下面搜尋需要的 Java Bean
- 掃描實體類的包，它的預設別名就為這個類的類名，首字母小寫（若有註解，則別名為其註解值）

<typeAliases>
    <package name="com.hxh.pojo"/>
</typeAliases>

<select id="getUserList" resultType="user" >  <!--大小寫user都可以，建議使用小寫-->
  select * from mybatis.user
</select>

在實體類比較小的時候使用第一種方式

如果實體類十分多，建議使用第二種

第一種可以自定義別名，第二種不行，但第二種可以通過在實體類增加註解起別名

@Alias("hello")
public class User {
    private int id;
    private String name;
    private String pwd;
}

<select id="getUserList" resultType="hello" >
  select * from mybatis.user
</select>

5. 設定

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

6. 其他配置

typeHandlers（型別處理器）
objectFactory（物件工廠）
plugins（外掛）
- mybaits-generator-core
- mybatis-plus
- 通用mapper

7. 對映器（mappers）

MapperRegistry：註冊繫結我們的Mapper檔案

方式一：使用相對於類路徑的資源引用**（推薦使用）**

<!--每一個Mapper.xml都需要在Mybatis核心配置檔案中註冊-->
<mappers>
    <mapper resource="com/hxh/dao/UserMapper.xml"/>
</mappers>

方式二：使用對映器介面實現類的完全限定類名，使用class檔案繫結註冊
```
<mappers>
	<mapper class="com.hxh.dao.UserMapper"/>
</mappers>
```
注意點：
- 介面和它的Mapper配置檔案必須同名
- 介面和它的Mapper配置檔案必須在同一個包下
方式三：將包內的對映器介面實現全部註冊為對映器，使用掃描包進行注入繫結
```
<mappers>
	<package name="com.hxh.dao"/>
</mappers>
```
注意點：
- 介面和它的Mapper配置檔案必須同名
- 介面和它的Mapper配置檔案必須在同一個包下

練習時間：

將資料庫配置檔案外部引入
實體類別名
保證UserMapper介面和UserMapper.xml改為一致，並且防止同一個包下

8. 生命週期和作用域

生命週期和作用域別是至關重要的，因為錯誤的使用會導致非常嚴重的併發問題

SqlSessionFactoryBuilder：

一旦建立了SqlSessionFactory，就不再需要它了
區域性變數

SqlSessionFactory：

說白了就是可以想象為資料庫連線池
一旦被建立就應該在應用的執行期間一直存在，沒有任何理由丟棄它或者重新建立另一個例項
SqlSessionFactory 的最佳作用域是應用作用域
最簡單的就是使用單例模式或者靜態單例模式

SqlSession

連線到連線池的一個請求
SqlSession 的例項不是執行緒安全的，因此是不能被共享的，所以它的最佳的作用域是請求或方法作用域。
用完之後需要趕緊關閉，否則資源被佔用

這裡面的每個Mapper就代表一個具體的業務

5. 解決屬性名和欄位名不一致的問題

1. 問題

資料庫中的欄位

新建一個專案，拷貝之前的，測試實體類欄位不一致的情況

public class User {
    private int id;
    private String name;
    private String password;
}

測試出現問題：User{id=1, name=‘hxh’, password=‘null’}

分析SQL：

//select * from mybatis.user where id = #{id}
//型別處理器
//select id,name,pwd from mybatis.user where id = #{id}

解決方法：

起別名

<select id="getUserById" parameterType="int" resultType="com.hxh.pojo.User">
    select id,name,pwd as password from mybatis.user where id = #{id}
</select>

resultMap

2. resultMap

結果集對映

id  name  pwd

id  name  passeord

<?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：繫結一個對應的Dao或者Mapper介面-->
<mapper namespace="com.hxh.dao.UserMapper">

    <!--結果集對映-->
    <resultMap id="UserMap" type="user">
        <!--column資料庫中的欄位，property實體類中的屬性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>
    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from mybatis.user where id = #{id}
    </select>

</mapper>

resultMap元素是 MyBatis 中最重要最強大的元素。
ResultMap的設計思想是，對簡單的語句做到零配置，對於複雜一點的語句，只需要描述語句之間的關係就行了。
ResultMap的優秀之處：對它相當瞭解了，你完全可以不用顯式地配置它們

6. 日誌

6.1 日誌工廠

如果一個數據庫操作出現了異常，我們需要排錯。日誌就是最好的助手

曾經：sout、debug

現在：日誌工廠

設定名name	描述	有效值value	預設值
logImpl	指定 MyBatis 所用日誌的具體實現，未指定時將自動查詢。	SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	未設定

SLF4J
LOG4J【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING【掌握】
NO_LOGGING

在mybatis中具體使用哪一個日誌實現，在設定中設定

STDOUT_LOGGING 標準日誌輸出

在mybatis核心配置檔案中，配置我們的日誌

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

Opening JDBC Connection
Created connection 1932274274.
Setting autocommit to false on JDBC Connection [[email protected]]
> Preparing: select * from mybatis.user where id = ?
> Parameters: 1(Integer)
< Columns: id, name, pwd
< Row: 1, hxh, 123456
<== Total: 1
User{id=1, name=‘hxh’, password=‘123456’}
Resetting autocommit to true on JDBC Connection [com.mysql.cj[email protected]]
Closing JDBC Connection [[email protected]]
Returned connection 1932274274 to pool.

6.2 LOG4J

Log4j是Apache的一個開源專案，通過使用Log4j，我們可以控制日誌資訊輸送的目的地是控制檯、檔案、GUI元件
我們也可以控制每一條日誌的輸出格式
通過定義每一條日誌資訊的級別，我們能夠更加細緻地控制日誌的生成過程
通過一個配置檔案來靈活地進行配置，而不需要修改應用的程式碼。

先匯入log4j的包

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

Log4j.properties

#將等級為DEBUG的日誌資訊輸出到console和file這兩個目的地，console和file的定義在下面的程式碼
log4j.rootLogger=DEBUG,console,file

#控制檯輸出的相關設定
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#檔案輸出的相關設定
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/hxh.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}[%c]%m%n

#日誌輸出級別
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

配置log4j為日誌的實現

<settings>
    <setting name="logImpl" value="LOG4J"/>
</settings>

Log4j的使用，直接測試執行剛才的查詢
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1063980005.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [[email protected]]
[com.hxh.dao.UserMapper.getUserById]-> Preparing: select * from mybatis.user where id = ?
[com.hxh.dao.UserMapper.getUserById]-> Parameters: 1(Integer)
[com.hxh.dao.UserMapper.getUserById]-<== Total: 1
User{id=1, name=‘hxh’, password=‘123456’}
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [[email protected]]
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [[email protected]]
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 1063980005 to pool.
簡單使用
1. 在要使用Log4j的類中，匯入包：import org.apache.log4j.Logger;
2. 日誌物件載入引數為當前類的class：static Logger logger = Logger.getLogger(UserMapperTest.class);
3. 日誌級別
```
public void testLog4j(){
    logger.info("info:進入了testLog4j");
    logger.debug("debug:進入了testLog4j");
    logger.error("error:進入了testLog4j");
}
```

7. 分頁

為什麼要分頁：

減少資料的處理量

7.1 使用Limit分頁

語法：select * from user limit startIndex,pageSize;
#		 從startIndex開始，沒有顯示pageSize個
		 select * from user limit 3; #[0,n]

使用Mybatis實現分頁，核心是SQL

介面

package com.hxh.dao;

import com.hxh.pojo.User;

import java.util.List;
import java.util.Map;

public interface UserMapper {

    //根據id查詢使用者
    User getUserById(int id);

    //分頁
    List<User> getUserByLimit(Map<String,Integer> map);

}

Mapper.xml

<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from mybatis.user limit #{startIndex},#{pageSize}
</select>

測試

@Test
public void getUserByLimit(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("startIndex",0);
    map.put("pageSize",2);
    List<User> userList = mapper.getUserByLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }
  sqlSession.close();
}

7.2 RowBounds分頁

面向物件，不建議使用

不再使用SQL實現分頁

介面
```
List<User> getUserByRowBounds();
```

Mappper.xml

<select id="getUserByRowBounds" resultMap="UserMap">
    select * from mybatis.user
</select>

測試

@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //通過rowbounds實現分頁
    RowBounds rowBounds = new RowBounds(0, 2);
    //通過java程式碼層面實現分頁
    List<User> userList = sqlSession.selectList("com.hxh.dao.UserMapper.getUserByRowBounds",null,rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

7.3 分頁外掛

MyBatis分頁外掛PageHelper

8. 使用註解開發

8.1 面向介面程式設計

大家之前都學過面向物件程式設計，也學習過介面，但在真正的開發中，很多時候我們會選擇面向介面程式設計
根本原因：
- 解耦：可拓展，提高複用，分層開發中，上層不用管具體的實現，大家都遵守共同的標準，使得開發變得容易，規範性更好。
在一個面向物件的系統中，系統的各種功能是由許許多多的不同物件協作完成的，在這種情況下，各個物件內部是如何實現自己的，對系統設計人員來講就不那麼重要了
而哥哥物件之間的協作關係則成為系統設計的關鍵，小到不同類之間的通訊，大到各模組之間的互動，在系統設計之初都是要著重考慮的，這也是系統設計的主要工作內容。面向介面程式設計就是指按照這種思想來程式設計

關於介面的理解：

介面從更深層次的理解，應是定義（規範、約束）與實現（名實分離的原則）的分離
介面的本身反映系統設計人員對系統的抽象理解
介面應有兩類：
- 對一個個體的抽象，它可對應為一個抽象體（abstract class）
- 對一個個體某一方面的抽象，即形成一個抽象面（interface）
一個個體有可能有多個抽象面，抽象體和抽象面是由區別的

三個面向區別：

面向物件是指我們考慮問題時，以物件為單位，考慮它的屬性及方法
面向過程是指我們考慮問題時，以一個具體的流程（事務過程）為單位，考慮它的實現
介面設計與非介面設計是針對複用技術而言的，與面向物件（過程）不是一個問題，更多的體現就是對系統整體的架構

8.2 使用註解開發

使用註解來對映簡單語句會使程式碼顯得更加簡潔，但對於稍微複雜一點的語句，Java 註解不僅力不從心，還會讓你本就複雜的 SQL 語句更加混亂不堪。因此，如果你需要做一些很複雜的操作，最好用 XML 來對映語句。

註解在介面上實現

package com.hxh.dao;

import com.hxh.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Map;

public interface UserMapper {
    @Select("select * from user")
    List<User> getUsers();
}

需要在核心配置檔案中繫結介面 mybatis-config.xml

<!--繫結介面-->
<mappers>
    <mapper class="com.hxh.dao.UserMapper"/>
</mappers>

測試

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //底層主要應用反射
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

本質：反射機制實現

底層：動態代理

MyBatis詳細的執行流程：

Resources獲取載入全域性配置檔案➡️例項化SqlSessionFactoryBuilder構造器➡️解析配置檔案流XMLConfigBuilder➡️Configuration所有的配置資訊➡️例項化SqlSessionFactory➡️

transactional事務管理➡️建立executor執行器➡️建立sqlSession➡️實現CRUD➡️檢視是否執行成功➡️transactional事務管理

8.3 CRUD

我們可以在工具類建立的時候實現自動提交事務

public static SqlSession getSqlSession(){
    return sqlSessionFactory.openSession(true);
}

編寫介面，增加註解

package com.hxh.dao;

import com.hxh.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;
import java.util.Map;

public interface UserMapper {
    @Select("select * from user")
    List<User> getUsers();

    //方法存在多個引數，所有的引數前面必須加上@Param
    @Select("select * from user where id = #{id}")
    User getUserById(@Param("id") int id);

    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

    @Update("update user set name=#{name},pwd=#{password} where id = #{id}")
    int updateUser(User user);

    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
}

測試類

package com.hxh.dao;

import com.hxh.pojo.User;
import com.hxh.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //底層主要應用反射
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        /*
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
         */
        /*
        User userById = mapper.getUserById(1);
        System.out.println(userById);
         */
        /*
        mapper.addUser(new User(5,"hei","qwer"));
         */
        /*mapper.updateUser(new User(5,"AA","123qwe"));
         */
        mapper.deleteUser(5);
        sqlSession.close();
    }
}

【注意：我們必須要將介面註冊繫結到我們的核心配置檔案中】

關於@param()註解：

基本型別的引數或者String型別需要加上
引用型別不需要加
如果只有一個基本型別的話可以忽略，但是建議加上
我們在SQL中引用的就是我們這裡的@Param()中設定的屬性名

#{}：預編譯

${}：

能用#就用#

9. Lombok

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

使用步驟：

在IDEA中安裝Lombok外掛

在專案中匯入Lombok的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

在實體類上加註解即可

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
Lombok config system
Code inspections
Refactoring actions (lombok and delombok)

說明：

@Data：無參構造、get、set、tostring、hashcode、equal
@AllArgsConstructor：有參
@NoArgsConstructor：無參
@ToString
@EqualsAndHashCode
@Getter 放在類所有屬性生成getter方法，放在欄位上只是當前欄位生成
@Setter

10. 多對一處理

多對一：

多個學生對應一個老師
對於學生這邊而言，關聯：多個學生關聯一個老師【多對一】
對於老師而言，集合：一個老師有很多學生【一對多】

SQL：

CREATE TABLE `teacher`(
`id` int(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY ( `id` )
) ENGINE = Innodb default CHARSET = gb2312

INSERT INTO `teacher`(`id`,`name`)VALUES(1,'HTeacher');

CREATE TABLE `student`(
`id` int(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
KEY `fktid` ( `tid` ),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE = Innodb default CHARSET = gb2312

INSERT INTO `student`(`id`,`name`,`tid`)VALUES(1,'小明','1');
INSERT INTO `student`(`id`,`name`,`tid`)VALUES(2,'小紅','1');
INSERT INTO `student`(`id`,`name`,`tid`)VALUES(3,'小張','1');
INSERT INTO `student`(`id`,`name`,`tid`)VALUES(4,'小李','1');
INSERT INTO `student`(`id`,`name`,`tid`)VALUES(5,'小王','1');

測試環境搭建

匯入Lombok

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>

新建實體類Teacher、Student

package com.hxh.pojo;

import lombok.Data;

@Data
public class Student {
    private int id;
    private String name;
    //學生要關聯一個老師
    private Teacher teacher;
}

package com.hxh.pojo;

public class Teacher {
    private int id;
    private String name;
}

建立Mapper介面

package com.hxh.dao;

public interface StudentMapper {
}

package com.hxh.dao;

import com.hxh.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {
    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

建立Mapper.xml檔案

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置檔案-->
<mapper namespace="com.hxh.dao.StudentMapper">

</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置檔案-->
<mapper namespace="com.hxh.dao.TeacherMapper">

</mapper>

在核心配置檔案中繫結註冊我們的Mapper介面或者檔案【方式很多】

<mappers>
    <mapper class="com.hxh.dao.TeacherMapper"/>
    <mapper class="com.hxh.dao.StudentMapper"/>
</mappers>

測試查詢是否能夠成功

import com.hxh.dao.TeacherMapper;
import com.hxh.pojo.Teacher;
import com.hxh.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class MyTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
        sqlSession.close();
    }
}

按照查詢巢狀處理

方式一：子查詢

<mapper namespace="com.hxh.dao.StudentMapper">
  <!--
	思路：
		1. 查詢所有的學生功能資訊
		2. 根據查詢出來的學生的tid，尋找對應的老師   子查詢
	-->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    </select>

    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--複雜的屬性需要單獨處理,物件：association,集合：collection-->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>

    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{id}
    </select>
</mapper>

按照結果巢狀處理

方式二：關聯查詢

<select id="getStudent2" resultMap="StudentTeacher2">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid=t.id;
</select>
<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

回顧MySQL多對一查詢方式：

子查詢
聯表查詢

11. 一對多處理

比如：一個老師擁有多個學生

對於老師而言就是一對多的關係

環境搭建，匯入Lombok

實體類

package com.hxh.pojo;

import lombok.Data;

@Data
public class Student {
    private int id;
    private String name;
    //學生要關聯一個老師
    private int tid;
}

package com.hxh.pojo;

import lombok.Data;

import java.util.List;

@Data
public class Teacher {
    private int id;
    private String name;

    //一個老師擁有多個學生
    private List<Student> students;
}

TeacherMapper.java

package com.hxh.dao;

import com.hxh.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface TeacherMapper {
    //獲取老師
    List<Teacher> getTeacher();
    //獲取指定老師下的所有學生及老師的資訊
    Teacher getTeacher(@Param("tid") int id);

    Teacher getTeacher2(@Param("id") int id);
}

TeacherMapper.xml

按照結果巢狀處理

（推薦使用，SQl語句可以在localhost裡測試）

通過結果做對映

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置檔案-->
<mapper namespace="com.hxh.dao.TeacherMapper">
    <!--按結果巢狀查詢-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid, s.name sname, t.name tname, t.id tid
        from student s,teacher t
        where s.tid = t.id and t.id = #{tid}
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--複雜的屬性需要單獨處理,物件：association,集合：collection
        javaType：指定的屬性的型別
        集合中的泛型資訊，我們使用ofType獲取-->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

按照查詢巢狀處理

    <!--子查詢-->
    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from mybatis.teacher where id = #{id}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherID" column="id"/>
    </resultMap>
    <select id="getStudentByTeacherID" resultType="Student">
        select * from student where tid = #{tid}
    </select>
</mapper>

小結

關聯 association 【多對一】
集合 collection 【一對多】
javaType & ofType
1. javaType用來指定實體類的型別
2. ofType用來指定對映到List或者集合中的pojo型別，泛型中的約束型別

注意點

保證SQL的可讀性，儘量保證通俗易懂
注意一對多和多對一中屬姓名和欄位的問題
如果問題不好排查錯誤，可以使用日誌，建議使用log4j

面試高頻：

Mysql引擎
InnoDB底層遠離
索引
索引優化

12. 動態SQL

什麼是動態SQL：動態SQL就是指根據不同的條件生成不同的SQL語句

利用動態 SQL，可以徹底擺脫這種痛苦

如果你之前用過 JSTL 或任何基於類 XML 語言的文字處理器，你對動態 SQL 元素可能會感覺似曾相識。在 MyBatis 之前的版本中，需要花時間瞭解大量的元素。藉助功能強大的基於 OGNL 的表示式，MyBatis 3 替換了之前的大部分元素，大大精簡了元素種類，現在要學習的元素種類比原來的一半還要少。

if
choose (when, otherwise)
trim (where, set)
foreach

搭建環境

CREATE TABLE `blog`(
	`id` varchar(50) NOT NULL COMMENT '部落格id',
  `title` varchar(100) NOT NULL COMMENT '部落格標題',
  `author` varchar(30) NOT NULL COMMENT '部落格作者',
  `create_time` Datetime NOT NULL COMMENT '建立時間',
  `views` int(30) NOT NULL COMMENT '瀏覽量'
)ENGINE=INNODB DEFAULT CHARACTER SET=utf8;

建立一個基礎工程

導包 pom.xml

dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

編寫配置檔案

編寫實體類

package com.hxh.pojo;
import lombok.Data;
import java.util.Date;

@Data
public class blog {
    private int id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}

編寫實體類對應的Mapper介面和Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.hxh.dao.BlogMapper">
    <insert id="addBlog" parameterType="blog">
        insert into mybatis.blog (id, title, author, create_time, views)
        values (#{id},#{title},#{author},#{createTime},#{views});
    </insert>

</mapper>

if

BlogMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.hxh.dao.BlogMapper">
    <insert id="addBlog" parameterType="blog">
        insert into mybatis.blog (id, title, author, create_time, views)
        values (#{id},#{title},#{author},#{createTime},#{views});
    </insert>

    <select id="queryBlogIF" parameterType="map" resultType="blog">
        select * from mybatis.blog where 1=1
        <if test="title != null ">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>

</mapper>

where改成標籤：

<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <if test="title != null ">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
</select>

MyTest.java

import com.hxh.dao.BlogMapper;
import com.hxh.pojo.Blog;
import com.hxh.utils.IDUtils;
import com.hxh.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.Date;
import java.util.HashMap;
import java.util.List;

public class MyTest {
    @Test
    public void addInitBlog(){
        SqlSession session = MybatisUtils.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);

        Blog blog = new Blog();
        blog.setId(IDUtils.getId());
        blog.setTitle("Mybatis如此簡單");
        blog.setAuthor("HxH");
        blog.setCreateTime(new Date());
        blog.setViews(9999);
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("Java如此簡單");
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("Spring如此簡單");
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("微服務如此簡單");
        mapper.addBlog(blog);

        session.close();

    }

    @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        map.put("title","Java如此簡單");
        map.put("author","HxH");

        List<Blog> blogs = mapper.queryBlogIF(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
        sqlSession.close();
    }
}

trim、where、set

where

where 元素只會在子元素返回任何內容的情況下才插入 “WHERE” 子句。而且，若子句的開頭為 “AND” 或 “OR”，where 元素也會將它們去除。

<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <if test="title != null ">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
</select>

set

<update id="updateBlog" parameterType="map">
    update mybatis.blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author != null">
            author = #{author}
        </if>
    </set>
    where id = #{id}
</update>

set 元素會動態地在行首插入 SET 關鍵字，並會刪掉額外的逗號（這些逗號是在使用條件語句給列賦值時引入的）
set 元素可以用於動態包含需要更新的列，忽略其它不更新的列

trim

<trim prefix="" prefixOverrides="" suffix="" suffixOverrides="">
    
</trim>

choose、when、otherwise

choose

它有點像 Java 中的 switch 語句

BlogMapper.xml

<select id="queryBlogChoose" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                and author = #{author}
            </when>
            <otherwise>
                and views = #{views}
            </otherwise>
        </choose>
    </where>
</select>

title滿足後，後面的都不執行

MyTest.java

 @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        map.put("title","Java如此簡單");
        map.put("author","HxH");
        map.put("views",99999);

        List<Blog> blogs = mapper.queryBlogChoose(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
        sqlSession.close();
    }

所謂的動態SQL，本質還是SQL語句，只是我們可以在SQL層面去執行一個邏輯程式碼

foreach

遍歷迴圈

select * from user where 1=1 and (id=1 or id=2 or id=3)

SQL片段

有的時候，我們可能會將一些公共的部分抽取出來，方便複用。

使用SQL標籤抽取公共部分

<sql id="IfTitleAuthor">
    <if test="title != null ">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</sql>

在需要使用的部分使用include引用即可

<select id="selectRiverGeoDataList" parameterType="RiverGeoData" resultMap="RiverGeoDataResult">
    <include refid="selectRiverGeoDataVo"/>
    <where>  
        <if test="rgdBizCode != null  and rgdBizCode != ''"> and rgd_biz_code = #{rgdBizCode}</if>
        <if test="rgdBizId != null "> and rgd_biz_id = #{rgdBizId}</if>
    </where>
</select>

ref—指引用

SQL片段注意事項：

最好基於單表來定義SQL片段
不要存在where標籤

13. 快取

13.1 簡介

查詢：需要連線資料庫，耗資源，優化：

一次查詢的結果暫存在一個可以直接取到的地方——>記憶體：快取

我們再次查詢相同資料的時候直接走快取，就不用走資料庫了

什麼是快取
- 存在記憶體中的臨時資料
- 將使用者經常查詢的資料放在快取（記憶體）中，使用者去查詢資料就不用從磁碟上（關係型資料庫資料檔案）查詢，從快取中查詢，從而提高查詢效率，解決了高併發系統的效能問題。
為什麼使用快取
- 減少和資料庫的互動次數，減少系統開銷，提高系統效率。
什麼樣的資料能使用快取
- 經常查詢並且不經常改變的資料。【可以使用快取】

13.2 Mybatis快取

MyBatis包含一個非常強大的查詢快取特性，它可以非常方便地定製和配置快取，快取可以極大的提升查詢效率。
MyBatis系統中預設定義了兩種快取：一級快取和二級快取
- 預設情況下，只有一級快取開啟。（SqlSession級別的快取，也成為本地快取）
- 二級快取需要手動開啟和配置，它是基於namespace級別的快取
  - 一個mapper對應一個namespace，介面
- 為了提高擴充套件性，MyBatis定義了快取介面Cache，我們可以通過實現Cache介面來自定義二級快取

13.3 一級快取

一級快取也叫本地快取：SqlSession
- 與資料庫同義詞會話期間查詢到的資料會放在本地快取中
- 以後如果需要獲取相同的資料，直接從快取中拿，沒必要再去查詢資料庫

測試步驟：

開啟日誌

在mybatis核心配置檔案中，配置我們的日誌

<settings>
  <!--標準的日誌工廠實現-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

測試在一個Session中查詢兩次相同記錄
查詢日誌輸出

select語句查詢的結果會被快取，增刪改會重新整理快取

快取失效的情況：

查詢不同的東西
增刪改操作，可能會改變原來的資料，所以必定會重新整理快取
查詢不同的mapper.xml
手動清理快取
```
sqlSession.clearCaChe();
```

小結：

一級快取預設是開啟的，只在一次sqlSession中有效，也就是拿到連線到關閉連線這個區間段

一級快取就是（相當於）一個Map

13.4 二級快取

二級快取也叫全域性快取，一級快取作用域太低了，所以誕生了二級快取
基於namespace級別的快取，一個名稱空間，對應一個二級快取
工作機制
- 一個會話查詢一條資料，這個資料就會被放在當前會話的一級快取中
- 如果當前會話關閉了，這個會話對應的一級快取就沒了，但是我們想要的是，會話關閉了，一級快取中的資料被儲存到二級快取中
- 新的會話查詢資訊，就可以從二級快取中獲取內容
- 不同的mapper查出的資料會放在自己對應的快取（map）中

步驟：

在配置檔案中開啟全域性快取

<!--顯示的開啟全部快取-->
<setting name="cacheEnable" value="true"/>

在要使用二級快取的mapper.xml中開啟

<!--在當前Mapper.xml中使用二級快取-->
<cacahe/>

也可以自定義引數

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

問題：
1. 我們需要將實體類序列化，否則就會報錯
  
  cause by: java.io.NotSerializalbeException: com.kuang.pojo.User

小結：

只要開啟了二級快取，在同一個mapper下就有效
所有的資料都會先放在一級快取中，
只有當會話提交或者關閉的時候，才會提交到二級快取中

13.5 快取原理

13.6 自定義快取-Ehcache

Ehcache是一種廣泛使用的開源Java分散式快取。主要面向通用快取。

要在程式中使用Ehcache，先要導包

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>

在mapper中指定使用我們的ehcache快取實現

<!--在當前mapper.xml中使用二級快取-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

js中三個點用法、yiled*用法

MyBatis

1. 簡介

1.1 什麼是MyBatis

1.2 持久化

1.3 持久層

1.4 為什麼需要MyBatis

2. 第一個MyBatis程式

2.1 搭建環境

2.2 建立一個模組

2.3 編寫程式碼

2.4 測試

3. CRUD

1. namespace

2. select

3. Insert

4. Update

5. Delete

6. 分析錯誤

7. 萬能Map

8. 模糊查詢

4. 配置解析

1. 核心配置檔案

2. 環境配置（environments）

3. 屬性（properties）

4. 類型別名（typeAliases）

5. 設定

6. 其他配置

7. 對映器（mappers）

8. 生命週期和作用域

5. 解決屬性名和欄位名不一致的問題

1. 問題

2. resultMap

6. 日誌

6.1 日誌工廠

6.2 LOG4J

7. 分頁

7.1 使用Limit分頁

7.2 RowBounds分頁

7.3 分頁外掛

8. 使用註解開發

8.1 面向介面程式設計

8.2 使用註解開發

8.3 CRUD

9. Lombok

10. 多對一處理

測試環境搭建

按照查詢巢狀處理

按照結果巢狀處理

11. 一對多處理

按照結果巢狀處理

按照查詢巢狀處理

小結

注意點

12. 動態SQL

搭建環境

建立一個基礎工程

if

trim、where、set

where

set

trim

choose、when、otherwise

choose

foreach

SQL片段

13. 快取

13.1 簡介

13.2 Mybatis快取

13.3 一級快取

13.4 二級快取

13.5 快取原理

13.6 自定義快取-Ehcache

相關推薦