Go元件:go中grom學習
技術標籤: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:
-
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.5</version> </dependency>
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&useUnicode=true&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&useUnicode=true&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&useUnicode=true&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 [[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. -
簡單使用
-
在要使用Log4j的類中,匯入包:import org.apache.log4j.Logger;
-
日誌物件載入引數為當前類的class:static Logger logger = Logger.getLogger(UserMapperTest.class);
-
日誌級別
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
- javaType用來指定實體類的型別
- 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"/>
-
問題:
-
我們需要將實體類序列化,否則就會報錯
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"/>