2. 程式人生 > 實用技巧 >時間輪演算法在Netty和Kafka中的應用，為什麼不用Timer、延時執行緒池？

時間輪演算法在Netty和Kafka中的應用，為什麼不用Timer、延時執行緒池？

阿新 • • 發佈：2020-08-07

Mybatis-9.28

環境：

  • JDK1.8
  • Mysql 5.7
  • maven 3.6.1
  • IDEA

回顧：

  • JDBC
  • Mysql
  • Java基礎
  • Maven
  • Junit

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

1、簡介

1.1、什麼是Mybatis

  • MyBatis 是一款優秀的持久層框架
  • 它支援定製化 SQL、儲存過程以及高階對映。
  • MyBatis 避免了幾乎所有的 JDBC 程式碼和手動設定引數以及獲取結果集。
  • MyBatis 可以使用簡單的 XML 或註解來配置和對映原生型別、介面和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 物件）為資料庫中的記錄。
  • MyBatis 本是apache的一個開源專案iBatis, 2010年這個專案由apache software foundation 遷移到了google code，並且改名為MyBatis 。
  • 2013年11月遷移到Github。

如何獲得Mybatis？

1.2、持久化

資料持久化

  • 持久化就是將程式的資料在持久狀態和瞬時狀態轉化的過程
  • 記憶體：斷電即失
  • 資料庫(Jdbc)，io檔案持久化。
  • 生活：冷藏. 罐頭。

為什麼需要需要持久化？

  • 有一些物件，不能讓他丟掉。

  • 記憶體太貴了

1.3、持久層

Dao層，Service層，Controller層….

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

1.4 為什麼需要Mybatis？

  • 幫助程式猿將資料存入到資料庫中。
  • 方便
  • 傳統的JDBC程式碼太複雜了。簡化。框架。自動化。
  • 不用Mybatis也可以。更容易上手。 技術沒有高低之分
  • 優點：
    • 簡單易學
    • 靈活
    • sql和程式碼的分離，提高了可維護性。
    • 提供對映標籤，支援物件與資料庫的orm欄位關係對映
    • 提供物件關係對映標籤，支援物件關係組建維護
    • 提供xml標籤，支援編寫動態sql。

最重要的一點：使用的人多！

Spring SpringMVC SpringBoot

2、第一個Mybatis程式

思路：搭建環境-->匯入Mybatis-->編寫程式碼-->測試！

2.1、搭建環境

搭建資料庫

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user`(
  `id` INT(20) NOT NULL PRIMARY KEY,
  `name` VARCHAR(30) DEFAULT NULL,
  `pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES 
(1,'狂神','123456'),
(2,'張三','123456'),
(3,'李四','123890')

新建專案

  1. 新建一個普通的maven專案

  2. 刪除src目錄

  3. 匯入maven依賴

        <!--匯入依賴-->
    <dependencies>
        <!--mysql驅動-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

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="123456"/>
            </dataSource>
        </environment>
    </environments>

</configuration>

  • 編寫mybatis工具類

    //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 (IOException e) {
            e.printStackTrace();
        }

    }

    //既然有了 SqlSessionFactory，顧名思義，我們就可以從中獲得 SqlSession 的例項了。
    // SqlSession 完全包含了面向資料庫執行 SQL 命令所需的所有方法。
    public static SqlSession  getSqlSession(){
        return sqlSessionFactory.openSession();
    }

}

2.3、編寫程式碼

  • 實體類

    package com.kuang.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介面

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

  • 介面實現類由原來的UserDaoImpl轉變為一個 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.kuang.dao.UserDao">

<!--select查詢語句-->
   <select id="getUserList" resultType="com.kuang.pojo.User">
       select * from mybatis.user
   </select>

</mapper>

2.4、測試

注意點：

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

MapperRegistry是什麼？

核心配置檔案中註冊 mappers

  • junit測試

    @Test
public void test(){
    //第一步：獲得SqlSession物件
    SqlSession sqlSession = MybatisUtils.getSqlSession();


    //方式一：getMapper
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.getUserList();

    for (User user : userList) {
        System.out.println(user);
    }



    //關閉SqlSession
    sqlSession.close();
}

你們可以能會遇到的問題：

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

3、CRUD

1、namespace

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

2、select

選擇，查詢語句;

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

  1. 編寫介面

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

  2. 編寫對應的mapper中的sql語句

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

  3. 測試

        @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

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

4、update

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

5、Delete

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

注意點：

  • 增刪改需要提交事務！

6、分析錯誤

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

7、萬能Map

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

    //萬能的Map
    int addUser2(Map<String,Object> map);


    <!--物件中的屬性，可以直接取出來    傳遞map的key-->
    <insert id="addUser" parameterType="map">
        insert into mybatis.user (id, pwd) values (#{userid},#{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("passWord","2222333");

        mapper.addUser2(map);

        sqlSession.close();
    }

Map傳遞引數，直接在sql中取出key即可！ 【parameterType="map"】

物件傳遞引數，直接在sql中取物件的屬性即可！【parameterType="Object"】

只有一個基本型別引數的情況下，可以直接在sql中取到！

多個引數用Map，或者註解！

8、思考題

模糊查詢怎麼寫？

  1. Java程式碼執行的時候，傳遞萬用字元 % %

    List<User> userList = mapper.getUserLike("%李%");

  2. 在sql拼接中使用萬用字元！

    select * from mybatis.user where name like "%"#{value}"%"

4、配置解析

1、核心配置檔案

  • mybatis-config.xml

  • MyBatis 的配置檔案包含了會深深影響 MyBatis 行為的設定和屬性資訊。

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

2、環境配置（environments）

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

不過要記住：儘管可以配置多個環境，但每個 SqlSessionFactory 例項只能選擇一種環境。

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

Mybatis預設的事務管理器就是 JDBC ， 連線池 ： POOLED

3、屬性（properties）

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

這些屬性都是可外部配置且可動態替換的，既可以在典型的 Java 屬性檔案中配置，亦可通過 properties 元素的子元素來傳遞。【db.properties】

編寫一個配置檔案

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

在核心配置檔案中映入

    <!--引入外部配置檔案-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="pwd" value="11111"/>
    </properties>
  • 可以直接引入外部檔案
  • 可以在其中增加一些屬性配置
  • 如果兩個檔案有同一個欄位，優先使用外部配置檔案的！

4、類型別名（typeAliases）

  • 類型別名是為 Java 型別設定一個短的名字。‘
  • 存在的意義僅在於用來減少類完全限定名的冗餘。
    <!--可以給實體類起別名-->
    <typeAliases>
        <typeAlias type="com.kuang.pojo.User" alias="User"/>
    </typeAliases>

也可以指定一個包名，MyBatis 會在包名下面搜尋需要的 Java Bean，比如：

掃描實體類的包，它的預設別名就為這個類的 類名，首字母小寫！

<!--可以給實體類起別名-->
<typeAliases>
    <package name="com.kuang.pojo"/>
</typeAliases>

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

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

第一種可以DIY別名，第二種則·不行·，如果非要改，需要在實體上增加註解

@Alias("user")
public class User {}

5、設定

這是 MyBatis 中極為重要的調整設定，它們會改變 MyBatis 的執行時行為。

6、其他配置

7、對映器（mappers）

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

方式一： 【推薦使用】

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

方式二：使用class檔案繫結註冊

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

注意點：

  • 介面和他的Mapper配置檔案必須同名！
  • 介面和他的Mapper配置檔案必須在同一個包下！

方式三：使用掃描包進行注入繫結

<!--每一個Mapper.XML都需要在Mybatis核心配置檔案中註冊！-->
<mappers>
    <package name="com.kuang.dao"/>
</mappers>

注意點：

  • 介面和他的Mapper配置檔案必須同名！
  • 介面和他的Mapper配置檔案必須在同一個包下！

練習時間：

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

8、生命週期和作用域

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

SqlSessionFactoryBuilder：

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

SqlSessionFactory：

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

SqlSession

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

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

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

1、 問題

資料庫中的欄位

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

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

測試出現問題

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

解決方法：

  • 起別名

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

2、resultMap

結果集對映

id   name   pwd
id   name   password

<!--結果集對映-->
<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" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>
  • resultMap 元素是 MyBatis 中最重要最強大的元素
  • ResultMap 的設計思想是，對於簡單的語句根本不需要配置顯式的結果對映，而對於複雜一點的語句只需要描述它們的關係就行了。
  • ResultMap 最優秀的地方在於，雖然你已經對它相當瞭解了，但是根本就不需要顯式地用到他們。
  • 如果世界總是這麼簡單就好了。

6、日誌

6.1、日誌工廠

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

曾經：sout 、debug

現在：日誌工廠！

  • SLF4J

  • LOG4J 【掌握】

  • LOG4J2

  • JDK_LOGGING

  • COMMONS_LOGGING

  • STDOUT_LOGGING 【掌握】

  • NO_LOGGING

在Mybatis中具體使用那個一日誌實現，在設定中設定！

STDOUT_LOGGING標準日誌輸出

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

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

6.2、Log4j

什麼是Log4j？

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

  1. 先匯入log4j的包

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

  2. 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/kuang.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

  3. 配置log4j為日誌的實現

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

  4. Log4j的使用！，直接測試執行剛才的查詢

簡單使用

  1. 在要使用Log4j 的類中，匯入包 import org.apache.log4j.Logger;

  2. 日誌物件，引數為當前類的class

    static Logger logger = Logger.getLogger(UserDaoTest.class);

  3. 日誌級別

    logger.info("info:進入了testLog4j");
logger.debug("debug:進入了testLog4j");
logger.error("error:進入了testLog4j");

7、分頁

思考：為什麼要分頁？

  • 減少資料的處理量

7.1、使用Limit分頁

語法：SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 3;  #[0,n]

使用Mybatis實現分頁，核心SQL

  1. 介面

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

  2. Mapper.xml

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

  3. 測試

    @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",1);
    map.put("pageSize",2);

    List<User> userList =  mapper.getUserByLimit(map);
    for (User user : userList) {
    System.out.println(user);
    }

    sqlSession.close();
    }

7.2、RowBounds分頁

不再使用SQL實現分頁

  1. 介面

    //分頁2
List<User> getUserByRowBounds();

  2. mapper.xml

    <!--分頁2-->
<select id="getUserByRowBounds" resultMap="UserMap">
    select * from  mybatis.user
</select>

  3. 測試

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

//RowBounds實現
RowBounds rowBounds = new RowBounds(1, 2);

//通過Java程式碼層面實現分頁
List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds",null,rowBounds);

    for (User user : userList) {
    System.out.println(user);
    }

    sqlSession.close();
    }

7.3、分頁外掛

瞭解即可，萬一 以後公司的架構師，說要使用，你需要知道它是什麼東西！

8、使用註解開發

8.1、面向介面程式設計

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

關於介面的理解

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

三個面向區別

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

8.2、使用註解開發

  1. 註解在介面上實現

    @Select("select * from user")
List<User> getUsers();

  2. 需要再核心配置檔案中繫結介面！

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

  3. 測試

本質：反射機制實現

底層：動態代理！

Mybatis詳細的執行流程！

8.3、CRUD

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

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

編寫介面，增加註解

public interface UserMapper {

    @Select("select * from user")
    List<User> getUsers();

    // 方法存在多個引數，所有的引數前面必須加上 @Param("id")註解
    @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);
}

測試類

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

關於@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.
  • java library
  • plugs
  • build tools
  • with one annotation your class

使用步驟：

  1. 在IDEA中安裝Lombok外掛！

  2. 在專案中匯入lombok的jar包

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

  3. 在實體類上加註解即可！

    @Data
@AllArgsConstructor
@NoArgsConstructor

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger
@Data
@Builder
@Singular
@Delegate
@Value
@Accessors
@Wither
@SneakyThrows

說明：

@Data：無參構造，get、set、tostring、hashcode，equals
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@ToString
@Getter

10、多對一處理

多對一：

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

SQL：

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老師'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8


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');

測試環境搭建

  1. 匯入lombok
  2. 新建實體類 Teacher，Student
  3. 建立Mapper介面
  4. 建立Mapper.XML檔案
  5. 在核心配置檔案中繫結註冊我們的Mapper介面或者檔案！【方式很多，隨心選】
  6. 測試查詢是否能夠成功！

按照查詢巢狀處理

<!--
    思路:
        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>

按照結果巢狀處理

<!--按照結果巢狀處理-->
<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、一對多處理

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

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

環境搭建

  1. 環境搭建，和剛才一樣

實體類

@Data
public class Student {

    private int id;
    private String name;
    private int tid;

}


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

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

按照結果巢狀處理

    <!--按結果巢狀查詢-->
    <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>

按照查詢巢狀處理

<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from mybatis.teacher where id = #{tid}
</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 mybatis.student where tid = #{tid}
</select>

小結

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

注意點：

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

慢SQL 1s 1000s

面試高頻

  • Mysql引擎
  • InnoDB底層原理
  • 索引
  • 索引優化！

12、動態 SQL

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

利用動態 SQL 這一特性可以徹底擺脫這種痛苦。

動態 SQL 元素和 JSTL 或基於類似 XML 的文字處理器相似。在 MyBatis 之前的版本中，有很多元素需要花時間瞭解。MyBatis 3 大大精簡了元素種類，現在只需學習原來一半的元素便可。MyBatis 採用功能強大的基於 OGNL 的表示式來淘汰其它大部分元素。

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 CHARSET=utf8

建立一個基礎工程

  1. 導包

  2. 編寫配置檔案

  3. 編寫實體類

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

  4. 編寫實體類對應Mapper介面 和 Mapper.XML檔案

IF

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

choose (when, otherwise)

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

trim (where,set)

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

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

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

if

where ， set ， choose ，when

SQL片段

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

  1. 使用SQL標籤抽取公共的部分

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

  2. 在需要使用的地方使用Include標籤引用即可

    <select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <include refid="if-title-author"></include>
    </where>
</select>

注意事項：

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

Foreach

select * from user where 1=1 and 

  <foreach item="id" collection="ids"
      open="(" separator="or" close=")">
        #{id}
  </foreach>

(id=1 or id=2 or id=3)



<!--
        select * from mybatis.blog where 1=1 and (id=1 or id = 2 or id=3)

        我們現在傳遞一個萬能的map ， 這map中可以存在一個集合！
-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
    select * from mybatis.blog

    <where>
        <foreach collection="ids" item="id" open="and (" close=")" separator="or">
            id = #{id}
        </foreach>
    </where>

</select>

動態SQL就是在拼接SQL語句，我們只要保證SQL的正確性，按照SQL的格式，去排列組合就可以了

建議：

  • 現在Mysql中寫出完整的SQL,再對應的去修改成為我們的動態SQL實現通用即可！

13、快取 （瞭解）

13.1、簡介

查詢  ：  連線資料庫 ，耗資源！
	一次查詢的結果，給他暫存在一個可以直接取到的地方！--> 記憶體 ： 快取
	
我們再次查詢相同資料的時候，直接走快取，就不用走資料庫了

  1. 什麼是快取 [ Cache ]？

    • 存在記憶體中的臨時資料。
    • 將使用者經常查詢的資料放在快取（記憶體）中，使用者去查詢資料就不用從磁碟上(關係型資料庫資料檔案)查詢，從快取中查詢，從而提高查詢效率，解決了高併發系統的效能問題。

  2. 為什麼使用快取？

    • 減少和資料庫的互動次數，減少系統開銷，提高系統效率。

  3. 什麼樣的資料能使用快取？

    • 經常查詢並且不經常改變的資料。【可以使用快取】

13.2、Mybatis快取

  • MyBatis包含一個非常強大的查詢快取特性，它可以非常方便地定製和配置快取。快取可以極大的提升查詢效率。

  • MyBatis系統中預設定義了兩級快取：一級快取和二級快取

    • 預設情況下，只有一級快取開啟。（SqlSession級別的快取，也稱為本地快取）

    • 二級快取需要手動開啟和配置，他是基於namespace級別的快取。

    • 為了提高擴充套件性，MyBatis定義了快取介面Cache。我們可以通過實現Cache介面來自定義二級快取

13.3、一級快取

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

測試步驟：

  1. 開啟日誌！
  2. 測試在一個Sesion中查詢兩次相同記錄
  3. 檢視日誌輸出

快取失效的情況：

  1. 查詢不同的東西

  2. 增刪改操作，可能會改變原來的資料，所以必定會重新整理快取！

  3. 查詢不同的Mapper.xml

  4. 手動清理快取！

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

一級快取就是一個Map。

13.4、二級快取

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

步驟：

  1. 開啟全域性快取

    <!--顯示的開啟全域性快取-->
<setting name="cacheEnabled" value="true"/>

  2. 在要使用二級快取的Mapper中開啟

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

    也可以自定義引數

    <!--在當前Mapper.xml中使用二級快取-->
<cache  eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"/>

  3. 測試

    1. 問題:我們需要將實體類序列化！否則就會報錯！

      Caused by: java.io.NotSerializableException: 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.1.0</version>
</dependency>

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

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

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：為快取路徑，ehcache分為記憶體和磁碟兩級，此屬性定義磁碟的快取位置。引數解釋如下：
       user.home – 使用者主目錄
       user.dir  – 使用者當前工作目錄
       java.io.tmpdir – 預設臨時檔案路徑
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache：預設快取策略，當ehcache找不到定義的快取時，則使用這個快取策略。只能定義一個。
     -->
    <!--
      name:快取名稱。
      maxElementsInMemory:快取最大數目
      maxElementsOnDisk：硬碟最大快取個數。
      eternal:物件是否永久有效，一但設定了，timeout將不起作用。
      overflowToDisk:是否儲存到磁碟，當系統當機時
      timeToIdleSeconds:設定物件在失效前的允許閒置時間（單位：秒）。僅當eternal=false物件不是永久有效時使用，可選屬性，預設值是0，也就是可閒置時間無窮大。
      timeToLiveSeconds:設定物件在失效前允許存活時間（單位：秒）。最大時間介於建立時間和失效時間之間。僅當eternal=false物件不是永久有效時使用，預設是0.，也就是物件存活時間無窮大。
      diskPersistent：是否快取虛擬機器重啟期資料 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：這個引數設定DiskStore（磁碟快取）的快取區大小。預設是30MB。每個Cache都應該有自己的一個緩衝區。
      diskExpiryThreadIntervalSeconds：磁碟失效執行緒執行時間間隔，預設是120秒。
      memoryStoreEvictionPolicy：當達到maxElementsInMemory限制時，Ehcache將會根據指定的策略去清理記憶體。預設策略是LRU（最近最少使用）。你可以設定為FIFO（先進先出）或是LFU（較少使用）。
      clearOnFlush：記憶體數量最大時是否清除。
      memoryStoreEvictionPolicy:可選策略有：LRU（最近最少使用，預設策略）、FIFO（先進先出）、LFU（最少訪問次數）。
      FIFO，first in first out，這個是大家最熟的，先進先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一點就是講一直以來最少被使用的。如上面所講，快取的元素有一個hit屬性，hit值最小的將會被清出快取。
      LRU，Least Recently Used，最近最少使用的，快取的元素有一個時間戳，當快取容量滿了，而又需要騰出地方來快取新的元素的時候，那麼現有快取元素中時間戳離當前時間最遠的元素將被清出快取。
   -->

</ehcache>

Redis資料庫來做快取！ K-V

練習：29道練習題實戰！

相關推薦

時間輪演算法在Netty和Kafka中的應用，為什麼不用Timer、延時執行緒池？

大家好，我是yes。 最近看 Kafka 看到了時間輪演算法，記得以前看 Netty 也看到過這玩意，沒太過關注。今天就來看看時間輪到底是什麼東西。

時間輪原理及其在框架中的應用

一、時間輪簡介 1.1 為什麼要使用時間輪 在平時開發中，經常會與定時任務打交道。下面舉幾個定時任務處理的例子。

時間輪演算法 簡單學習

時間輪 參考： https://github.com/wolaiye1010/zdc-java-script/ 參考： https://www.cnblogs.com/zhongwencool/p/timing_wheel.html

教程：比較JSON文件並在USDB和MongoDB中應用補丁

節省比較JSON文件的時間，並在應用程式中構建協作功能 在本演示教程中，我們將展示如何應用diff和patch操作來監控TerminuDB模式、TerminuDB文件、JSON模式和其他文件資料庫（如MongoDB）中的更改。使用這個免費的開

執行緒池在爬蟲案例中的應用

import requests from lxml import etree import re from multiprocessing.dummy import Pool #需求：爬取梨視訊的視訊資料

應用案例——執行緒池中的任務佇列

執行緒池－由一個任務佇列和一組處理佇列的執行緒組成。一旦工作程序需要處理某個可能“阻塞”的操作，不用自己操作，將其作為一個任務放到執行緒池的佇列，接著會被某個空閒執行緒提取處理。

執行緒池提交執行任務中execute()方法和submit()的區別

技術標籤：java多執行緒java多執行緒 文章目錄 簡介方法來源不同接收的引數不同返回值不同異常的處理

go time時間偏移_Go 語言中的執行緒池（Thread Pooling in Go Programming）

技術標籤：go time時間偏移 用過一段時間的 Go 之後，我學會了如何使用一個不帶快取的 channel 去建立一個 goroutine 池。我喜歡這個實現，這個實現甚至比這篇博文描述的更好。雖然這樣說，這篇博文仍然對它

執行緒池中shutdown()和shutdownNow()方法的區別

一般情況下，當我們頻繁的使用執行緒的時候，為了節約資源快速響應需求，我們都會考慮使用執行緒池，執行緒池使用完畢都會想著關閉，關閉的時候一般情況下會用到shutdown和shutdownNow，這兩個函式都能夠用來關閉執行

05 netty的基本元件概述和EventLoop(執行緒池)的介紹

1 Netty的背景 Netty:非同步的事件驅動的網路應用框架，該框架用於快速開發可維護的高效能協議伺服器和客戶端。

【高併發】深度解析執行緒池中那些重要的頂層介面和抽象類

大家好，我是冰河~~ 在上一篇《【高併發】不得不說的執行緒池與ThreadPoolExecutor類淺析》一文中，從整體上介紹了Java的執行緒池。如果細細品味執行緒池的底層原始碼實現，你會發現整個執行緒池體系的設計是非常優雅

Java程式中常用的四種執行緒池示例

在Java中使用執行緒池，可以用ThreadPoolExecutor的建構函式直接創建出執行緒池例項，如何使用參見之前的文章Java執行緒池構造引數詳解。不過，在Executors類中，為我們提供了常用執行緒池的建立方法。接下來我們就來

執行緒池應用及實現原理剖析

為什麼要用執行緒池 執行緒是不是越多好？ 執行緒在Java中是一個物件， 更是作業系統的資源， 執行緒額建立和銷燬都需要時間，如果 建立時間+銷燬時間>執行任務時間 就很不合算

ThreadPoolExecutor執行緒池原始碼解讀keepAliveTime 空閒過期時間作用

keepAliveTime引數主要是把除了核心執行緒 其他執行緒當超過等待時間keepAliveTime 就會進行執行緒移除

關於SpringBoot中Redis執行緒池的有關探討

探討起因 最近在寫一個小專案，用redis過期來實現驗證碼的時間限制。因為SpringBoot預設採用

JDK執行緒池和Spring執行緒池的使用例項解析

這篇文章主要介紹了JDK執行緒池和Spring執行緒池的使用例項解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java執行緒池的應用例項分析

本文例項講述了Java執行緒池的應用。分享給大家供大家參考，具體如下： 一 使用Future與Callable來計算斐波那契數列

執行緒池中使用spring aop事務增強

這篇文章主要介紹了執行緒池中使用spring aop事務增強,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java 執行緒狀態和等待喚醒機制和執行緒池的實現

1.概念 執行緒一共有6中狀態，相互之間可以互相轉換。 等待喚醒案例（執行緒之間的通訊）

解決python ThreadPoolExecutor 執行緒池中的異常捕獲問題

問題 最近寫了涉及執行緒池及執行緒的 python 指令碼，執行過程中發現一個有趣的現象，執行緒池中的工作執行緒出現問題，引發了異常，但是主執行緒沒有捕獲異常，還在發現 BUG 之前一度以為執行緒池程式碼正常返回。