MyBatis框架的簡單使用

一、MyBatis框架的簡介

MyBatis 是一款優秀的持久層框架，它支持自定義 SQL、存儲過程以及高級映射。MyBatis 免除了幾乎所有的 JDBC 代碼以及設置參數和獲取結果集的工作。MyBatis 可以通過簡單的 XML 或註解來配置和映射原始類型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 對象）爲數據庫中的記錄。

中文官網：https://mybatis.org/mybatis-3/zh/index.html

MyBatis的特點：

• 屬於持久層的ORM框架
  • 持久層：將內存中的對象數據儲存到數據庫持久保存
  • ORM：Object Relational Mapping 通過使用描述對象和數據庫之間映射的元數據，將面嚮對象語言程序中的對象自動持久化到關係數據庫中。本質上就是將數據從一種形式轉換到另外一種形式。
• 半自動化
  • 需要手動設計表
  • 提供sql語句
  • 依賴於數據庫平臺

MyBatis的優缺點：

• 優點：
  • 簡單易學
  • 靈活
  • 解除sql語句與程序代碼的耦合
  • 提供映射標籤，支持對象與數據庫的ORM關係映射
  • 提供對象關係映射標籤，支持對象關係組件維護
  • 系統XML標籤，支持編寫動態SQL
• 缺點：
  • 編寫SQL語句時工作量大。
  • SQL語句依賴於數據庫，導致數據庫移植性差，不能更換數據庫

---

二、環境搭建

使用MyBatis，需要使用到MyBatis的jar包，將jar包添加到項目中即可。

Jar包地址：https://github.com/mybatis/mybatis-3/releases

1、創建文件

創建一個新的Java項目，在項目的src文件夾下創建一個名叫mybatis的xml文件，用來配置MyBatis的全局配置文件。

創建一個mappers包，在包內創建一個mapper.xml文件，用來配置要使用的SQL命令和對應結果集的實體類。

創建一個pojo包，在包內創建SQL結果集的對應的實體類(實體類的屬性類型和名字要和數據庫中的字段名字和類型一致)。

2、配置MyBatis的核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- XML約束 -->
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  
<!-- MyBatis 全局配置文件 -->  
<configuration>
		<!-- 開發環境配置 -->
	<environments default="dev">
		<!-- 環境標識 -->
		<environment id="dev">
			<!-- 
				事務管理器
					type:採用什麼方式進行事務管理
					JDBC:採用JDBC的事務管理
			-->
			<transactionManager type="JDBC"></transactionManager>
			<!-- 
				配置連接池和連接參數
					type:設置否是採用連接池技術
					pooled:採用連接池技術
			-->
			<dataSource type="pooled">
				<!-- 驅動包名 -->
				<property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
				<!-- 數據庫連接地址 -->
				<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
				<!-- 數據庫用戶 -->
				<property name="username" value="SCOTT"/>
				<!-- 數據庫密碼 -->
				<property name="password" value="TIGER"/>
			</dataSource>
		</environment>
	</environments>
	
	<!-- SQL映射 -->
	<mappers>
		<!-- 
			SQLXML文件的路徑(包名+文件名)	，這裏的包名不在使用.而是使用/
		 -->
		<mapper resource="cn/yanghuisen/mappers/UserMapper.xml"/>
	</mappers>
</configuration>

• configuration：核心配置文件的根元素，所有其它的元素都要在這個元素裏面
• environments：用於管理所有環境，可以default指定默認使用哪個環境
• environment：配置環境，id用來唯一標識環境
• transactionManager：用戶配置事務管理器，type用來指定事務管理方式
  • JDBC：表示採用和原生JDBC一致的事務管理方式
• dataSource：用於配置數據庫連接信息，type用來指定是否使用連接池技術，pooled表示使用連接池技術
  • driver：數據庫驅動
  • url：數據庫鏈接地址
  • username：用戶實列|用戶賬號
  • password：用戶密碼
• mappers：配置SQL掃描映射文件（可以配置多個SQL掃描映射文件）
  • mapper：SQL映射文件的路徑，resource指定路徑

3、配置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">
 
 <!-- 
 	命名空間,全局唯一
 		可以隨意填寫，不重複就行，但是爲了便於後期維護，建議寫爲包名+文件名
 -->
<mapper namespace="cn.yanghuisen.mappers.UserMapper">
	<!-- 
		查詢標籤
			id:當前文件內唯一標識，不能重複
			resultType:結果集對應的實體類(包名+類名)
	 -->
	<select id="queryAll" resultType="cn.yanghuisen.pojo.User">
		<!-- 查詢語句 -->
		select * from u_user
	</select>
</mapper>

• mapper：SQL映射配置文件的根元素，namespace指定該文件的命名空間，全局唯一
  • select：查詢標籤
  • resultType：要返回的數據類型

select也可改變爲：insert、update、delete…

4、創建實體類

實體類的屬性名和類型要和數據庫中的字段名和類型一致

package cn.yanghuisen.pojo;

import java.util.Date;

public class User {
	private Integer u_id;
	private String u_name;
	private String u_pwd;
	private Date u_date;
	public User() {
		super();
	}
	
	
	
	public User(String u_name, String u_pwd) {
		super();
		this.u_name = u_name;
		this.u_pwd = u_pwd;
	}



	public User(Integer u_id, String u_name, String u_pwd) {
		super();
		this.u_id = u_id;
		this.u_name = u_name;
		this.u_pwd = u_pwd;
	}



	public User(String u_name, String u_pwd, Date u_date) {
		super();
		this.u_name = u_name;
		this.u_pwd = u_pwd;
		this.u_date = u_date;
	}



	public User(Integer u_id, String u_name, String u_pwd, Date u_date) {
		super();
		this.u_id = u_id;
		this.u_name = u_name;
		this.u_pwd = u_pwd;
		this.u_date = u_date;
	}
	@Override
	public String toString() {
		return "User [u_id=" + u_id + ", u_name=" + u_name + ", u_pwd=" + u_pwd + ", u_date=" + u_date + "]";
	}
}

環境到此配置完成，後續只需要編寫Java代碼就行。

三、配置文件優化

上面的配置文件中有的地方是可以優化配置的。

1、properties標籤

可以使用properties標籤加載外部properties文件，解決硬編碼問題

db.properties

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:xe
name=SCOTT
pwd=TIGER

<?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>
	<!-- 加載外部properties文件 -->
	<properties resource="db.properties"/>
	<environments default="dev">
		<environment id="dev">
			<transactionManager type="JDBC"/>
			<dataSource type="POOLED">
											<!-- 引用外部properties文件的數據 -->
				<property name="driver" value="${driver}"/>
				<property name="url" value="${url}"/>
				<property name="username" value="${name}"/>
				<property name="password" value="${pwd}"/>
			</dataSource>
		</environment>
	</environments>
	
	<mappers>
		<mapper resource="cn/yanghuisen/mappers/UserMapper.xml"/>
	</mappers>

</configuration>

2、typeAliases標籤

可以使用typeAliases標籤對SQL映射文件的返回數據類型設置別名，typeAliases有三種使用方式

1、指定別名

核心配置文件

<?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>
	<!-- 加載外部properties文件 -->
	<properties resource="db.properties"/>
	
	<!-- 設置別名 -->
	<typeAliases>
			<!-- 指定 cn.yanghuisen.pojo.User的別名爲u-->
		<typeAlias type="cn.yanghuisen.pojo.User" alias="u"/>
	</typeAliases>
	<environments default="dev">
		<environment id="dev">
			<transactionManager type="JDBC"/>
			<dataSource type="POOLED">
											<!-- 引用外部properties文件的數據 -->
				<property name="driver" value="${driver}"/>
				<property name="url" value="${url}"/>
				<property name="username" value="${name}"/>
				<property name="password" value="${pwd}"/>
			</dataSource>
		</environment>
	</environments>
	
	<mappers>
		<mapper resource="cn/yanghuisen/mappers/UserMapper.xml"/>
	</mappers>

</configuration>

SQL映射文件

<select id="queryAll" resultType="u">
    select * from u_user
</select>

2、省略alias屬性

可以省略alias屬性，系統默認設置類名爲別名，並且不區分大小寫

核心配置文件

<!-- 設置別名 -->
<typeAliases>
    <!-- 省略alias屬性 -->
    <typeAlias type="cn.yanghuisen.pojo.User"/>
</typeAliases>

SQL映射文件

<select id="queryAll" resultType="user">
    select * from u_user
</select>

3、對整個包下面的類設置別名

就算是第二種省略alias屬性，一旦類多了想要配置也很麻煩，所以可以對一個包下面的所有類設置別名

<typeAliases>
    <!-- 對一個包下面的所有類設置別名 -->
    <package name="cn.yanghuisen.pojo"/>
</typeAliases>

對cn.yanghuisen.pojo這個包下面的所有屬性設置別名

還有一些是內建別名，在MyBatis中文官網有詳細介紹：https://mybatis.org/mybatis-3/zh/configuration.html#typeAliases

下面是一些爲常見的 Java 類型內建的類型別名。它們都是不區分大小寫的，注意，爲了應對原始類型的命名重複，採取了特殊的命名風格。

別名	映射的類型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

3、sql標籤

sql標籤可以對sql語句進行優化封裝，比如某幾個字段使用頻率非常高，就可以使用sql標籤進行封裝，後續使用只需要調用就行。

<mapper namespace="cn.yanghuisen.mappers.UserMapper">
	<sql id="user_all_field">
		u_id,u_name,u_pwd,u_date
	</sql>

	<!-- 查找全部數據 -->
	<select id="queryAll" resultType="user">
		select <include refid="user_all_field"/> from u_user
	</select>
</mapper>

可以封裝指定字段，也可以封裝一條完整語句，需要時使用include調用就行

三、查詢

查詢，增刪改查中最長用的一個

1、查詢全部數據

package cn.yanghuisen.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

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 org.junit.jupiter.api.Test;

import cn.yanghuisen.pojo.User;
import cn.yanghuisen.utils.MyBatisUtil;

public class Test1 {
	
	// 查找數據-查找全部數據
	@Test
	public void test1() {
		InputStream is = null;
		SqlSession session = null;
		try {
			// 載入mybatis配置文件，返回一個InputStream流
			is = Resources.getResourceAsStream("mybatis-config.xml");
			// 構建SqlSessionFactory工廠
			SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
			// 構建SqlSession對象
			session = MyBatisUtil.getSqlSession();
			// 執行SQL語句
			List<User> list = session.selectList("cn.yanghuisen.mappers.UserMapper.queryAll");
			list.forEach(System.out::println);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
}

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=4, u_name=mazi, u_pwd=1314520, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]

• selectList：查詢了表中的全部數據，返回的是一個List集合。

• cn.yanghuisen.mappers.UserMapper.queryAll：是sql映射文件的namespace屬性值+sql語句的ID

載入配置文件，構建工廠，構建對象每次都要使用，所以也可以再次封裝，製作一個工具類。

MyBatisUtil工具

package cn.yanghuisen.utils;

import java.io.IOException;

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

public class MyBatisUtil {
	private static SqlSessionFactory factory;
	
	static {
		try {
			factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static SqlSession getSqlSession() {
		SqlSession session = null;
		if(factory!=null) {
			session = factory.openSession();
		}
		return session;
	}
}

封裝工具後的掉用

@Test
public void test0() {
    SqlSession session = MyBatisUtil.getSqlSession();
    Map<String, User> map = session.selectMap("cn.yanghuisen.mappers.UserMapper.queryAll","u_name");
    Set<Entry<String, User>> set = map.entrySet();
    set.forEach(System.out::println);
    session.close();
}

• selectMap：返回一個Map集合
  • 第一個參數爲Sql映射文件
  • 第二個參數爲返回的map的key。用數據庫中的u_name字段的值設置爲key

運行結果

mazi=User [u_id=4, u_name=mazi, u_pwd=1314520, u_date=Sun Mar 15 18:41:45 CST 2020]
lisi=User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
zhaoliu=User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]
zhangsan=User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
wangwu=User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
wanger=User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]

2、查詢指定條件數據

查詢指定條件數據就需要指定篩選條件，所以還涉及一個傳參的問題。

2.1、傳參-基本數據類型-一個參數

查詢之前要先創建相應的SQL語句

<!-- 根據指定ID查找數據 -->
<select id="queryByID" resultType="user" parameterType="int">
    select <include refid="user_all_field"/> from u_user where u_id = #{id}
</select>

• parameterType：傳入參數類型，這裏使用的是int類型
• #{id}：獲取傳入的參數，如果只有一個參數的話，id可以隨便寫

java程序

// 查找數據-一個參數的查詢
// 根據指定ID查找數據
// 傳入一個基本數據類型參數
@Test
public void test2() {
    SqlSession session = MyBatisUtil.getSqlSession();
    // 2：要傳入的參數
    User user = session.selectOne("cn.yanghuisen.mappers.UserMapper.queryByID",2);
    System.out.println(user);
    session.close();
}

運行結果

User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]

• selectOne：查詢一條數據

2.2、傳參-String類型-一個參數

參數不一樣，sql語句也要相應的改變

<!-- 根據指定name查找數據 -->
<select id="queryByName" resultType="user" parameterType="string">
    select <include refid="user_all_field"/> from u_user where u_name = #{str}
</select>

java程序

// 查找數據-一個參數的查詢
// 根據指定name查找數據
// 傳入一個String型參數
@Test
public void test3() {
    SqlSession session = MyBatisUtil.getSqlSession();
    // wanger：要傳入的參數
    User user = session.selectOne("cn.yanghuisen.mappers.UserMapper.queryByName","wanger");
    System.out.println(user);
    session.close();
}

運行結果

User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]

2.3、傳參-數組|List集合-多個參數

MyBatis的查詢方法中，不能填寫多個參數，所以如果要傳入多個參數就要使用別的辦法。例如數組或者List集合

同樣，參數不一樣，SQL語配置要改變

<!-- 查找id爲2或3的數據 -->
<select id="queryByArray" resultType="user">
    select <include refid="user_all_field"/> from u_user where u_id in(
    <foreach collection="array"  item="arr" separator=",">#{arr}</foreach>
    )
</select>

• foreach：遍歷數組或者List集合
• collection：傳入的數據類型，數組就是array，list集合就是list
• item：臨時儲存數組或List集合中的一個數據，就和java中的foreach一樣
• separator：指定分隔符
• 如果是傳入的是數組或者List集合，不用定義parameterType屬性

// 查找數據-多個參數的查詢
// 根據多個id查找數據數據
// 傳入一個數組或者List集合
@Test
public void test4() {
    SqlSession session = MyBatisUtil.getSqlSession();
    int[] arr = {2,3};
    List<User> list = session.selectList("cn.yanghuisen.mappers.UserMapper.queryByArray",arr);
    list.forEach(System.out::println);
    session.close();
}

運行結果

User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]

2.4、傳參-javaBean對象-多個參數

也可以使用JavaBean傳參，但是並不是在所有的情況下都可以使用，例如如果要根據ID查找多條記錄，就需要傳入多個ID值，但是JavaBean中只能有一個ID。

<!-- 根據傳進來的name和pwd查找數據 -->
<select id="queryByNamePwd" resultType="user" parameterType="user">
    select <include refid="user_all_field"/> from u_user where u_name = #{u_name} and u_pwd = #{u_pwd}
</select>

• parameterType：設置傳入數據的類型，可以和resultType一樣使用別名
• #{u_name}：傳入的user類型數據的屬性名
• #{u_pwd}：傳入的user類型數據的屬性名

java程序

// 查找數據-多個參數的查詢
// 根據多個name和pwd查找數據數據
// 傳入一個JavaBean對象
@Test
public void test5() {
    SqlSession session = MyBatisUtil.getSqlSession();
    User user = new User("zhangsan","123456");
    user = session.selectOne("cn.yanghuisen.mappers.UserMapper.queryByNamePwd",user);
    System.out.println(user);
    session.close();
}

2.5、傳參-Map集合-多個參數

也可以使用Map集合傳遞參數，key爲參數名字，value爲參數值

<!-- 根據傳進來的name和pwd查找數據 -->
<select id="queryByMapNamePwd" resultType="user" parameterType="map">
    select <include refid="user_all_field"/> from u_user where u_name = #{name} and u_pwd = #{pwd}
</select>

• parameterType：設置傳入參數類型爲map
• #{name}：對應的key的鍵
• #{pwd}：對應的key的鍵

java程序

// 查找數據-多個參數的查詢
// 根據多個name和pwd查找數據數據
// 傳入一個Map集合
@Test
public void test6() {
    SqlSession session = MyBatisUtil.getSqlSession();
    Map<String, Object> map = new HashMap<String, Object> ();
    map.put("name", "wanger");
    map.put("pwd", "112233");
    User user = session.selectOne("cn.yanghuisen.mappers.UserMapper.queryByMapNamePwd",map);
    System.out.println(user);
    session.close();
}

運行結果

User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]

3、查詢數據的結果類型

傳入參數有多種方式，結果的類型也有多種

3.1、Date類型

返回Date類型時間

<!-- 獲取全部的數據的時間 -->
<select id="queryAllByDate" resultType="date">
    select u_date from u_user
</select>

• resultType：返回date類型數據

java程序：

// 查找數據
// 獲取多條數據的時間，返回Date類型時間
@Test
public void test7() {
    SqlSession session = MyBatisUtil.getSqlSession();
    List<Date> list = session.selectList("cn.yanghuisen.mappers.UserMapper.queryAllByDate");
    list.forEach(System.out::println);
    session.close();
}

運行結果

Sun Mar 15 18:41:45 CST 2020
Sun Mar 15 18:41:45 CST 2020
Sun Mar 15 18:41:45 CST 2020
Sun Mar 15 18:41:45 CST 2020
Sun Mar 15 18:41:45 CST 2020
Sun Mar 15 18:41:45 CST 2020

3.2、List集合

返回List集合

<!-- 查找全部數據 -->
<select id="queryAll" resultType="user">
    select <include refid="user_all_field"/> from u_user
</select>

• resultType：因爲List集合需要指定泛型，所有List集合中裝的是User類型的，所以爲User

java程序

// 查找數據
// 獲取多條數據，返回List類型
@Test
public void test8() {
    SqlSession session = MyBatisUtil.getSqlSession();
    List<User> list = session.selectList("cn.yanghuisen.mappers.UserMapper.queryAll");
    list.forEach(System.out::println);
    session.close();
}

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=4, u_name=mazi, u_pwd=1314520, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]

3.3、Map集合

返回Map集合，字段爲Key，值爲Value

<!-- 獲取ID爲4的數據 -->
<select id="queryMapById" resultType="map" parameterType="int">
    select <include refid="user_all_field"/> from u_user where u_id = #{id}
</select>

java程序

// 查找數據
// 獲取ID爲4的數據
// 返回Map集合
@Test
public void test9() {
    SqlSession session = MyBatisUtil.getSqlSession();
    Map<String, Object> map = session.selectOne("cn.yanghuisen.mappers.UserMapper.queryMapById",4);
    System.out.println(map);
    session.close();
}

運行結果

{U_PWD=1314520, U_ID=4, U_NAME=mazi, U_DATE=2020-03-15 18:41:45.0}

返回Map有一個弊端，那就是隻能返回一條數據。如果想要返回多個Map可以使用List-Map。

3.4、List-Map

Map只能返回一條數據，所以可以使用List-Map達到返回多條Map的xiaog。就是List集合中裝Map。

<!-- 獲取所有數據 -->
<select id="queryALLToListMap" resultType="map">
    select <include refid="user_all_field"/> from u_user
</select>

• resultType：因爲是list中裝map所以最底下還是map

java程序

// 查找數據
// 獲所有數據
// 返回List-Map集合
@Test
public void test10() {
    SqlSession session = MyBatisUtil.getSqlSession();
    List<Map<String, Object>> list = session.selectList("cn.yanghuisen.mappers.UserMapper.queryALLToListMap");
    list.forEach(System.out::println);
    session.close();
}

運行結果

{U_PWD=123456, U_ID=1, U_NAME=zhangsan, U_DATE=2020-03-15 18:41:45.0}
{U_PWD=123123, U_ID=2, U_NAME=lisi, U_DATE=2020-03-15 18:41:45.0}
{U_PWD=112233, U_ID=3, U_NAME=wanger, U_DATE=2020-03-15 18:41:45.0}
{U_PWD=1314520, U_ID=4, U_NAME=mazi, U_DATE=2020-03-15 18:41:45.0}
{U_PWD=666666, U_ID=5, U_NAME=wangwu, U_DATE=2020-03-15 18:41:45.0}
{U_PWD=88888888, U_ID=6, U_NAME=zhaoliu, U_DATE=2020-03-15 18:41:45.0}

四、插入、修改、刪除

1、插入

插入數據傳遞參數的方法和查詢數據時傳遞參數的方法一致

<!-- 插入數據 -->
<insert id="addUser" parameterType="user">
    insert into u_user values(sq_u_user.nextval,#{u_name},#{u_pwd},#{u_date})
</insert>

java程序

// 插入數據
@Test
public void test11() {
    SqlSession session = MyBatisUtil.getSqlSession();
    User user = new User("ahh","123123",new Date());
    int len = session.insert("cn.yanghuisen.mappers.UserMapper.addUser",user);
    if(len>0) {
        System.out.println("數據添加成功");
        // 手動事務提交
        session.commit();
    }else {
        System.out.println("數據添加失敗");
        // 事務回滾
        session.rollback();
    }
    session.close();
}

運行結果

數據添加成功

在MyBatis中默認是手動事務提交，如果要設置爲自動需要在工具類中修改一個數據。

public static SqlSession getSqlSession() {
    SqlSession session = null;
    if(factory!=null) {
        // true:自動提交事務，默認手動
        session = factory.openSession(true);
    }
    return session;
}

自動提交事務

// 插入數據
@Test
public void test11() {
    SqlSession session = MyBatisUtil.getSqlSession();
    User user = new User("abcd","123123",new Date());
    int len = session.insert("cn.yanghuisen.mappers.UserMapper.addUser",user);
    System.out.println(len>0?"添加成功":"添加失敗");
    session.close();
}

2、修改

修改數據的參數傳遞和查詢數據的參數傳遞一樣

<!-- 修改數據 -->
<update id="updateUserPwd" parameterType="map">
    update u_user set u_pwd = #{pwd} where u_id = #{id}
</update>

java程序

// 修改數據
@Test
public void test12() {
    SqlSession session = MyBatisUtil.getSqlSession();
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("pwd", "778899");
    map.put("id", 8);
    int len = session.update("cn.yanghuisen.mappers.UserMapper.updateUserPwd",map);
    System.out.println(len>0?"修改成功":"修改失敗");
    session.close();
}

運行結果

修改成功

3、刪除

同樣刪除數據的參數傳遞和查詢一樣

<!-- 刪除數據 -->
<delete id="deleteUser" parameterType="int">
    delete from u_user where u_id = #{id}
</delete>

java程序

// 刪除數據
@Test
public void test13() {
    SqlSession session = MyBatisUtil.getSqlSession();
    int len = session.update("cn.yanghuisen.mappers.UserMapper.deleteUser",8);
    System.out.println(len>0?"刪除成功":"刪除失敗");
    session.close();
}

運行結果

刪除成功

五、接口綁定方案

上面的方式還是不夠簡單，所以MyBatis又提供了一條接口綁定方案，程序員可以提供一個接口，然後提供一個接口所對應的Mapper.xml文件。MyBatis會自動將接口與XML文件進行綁定。實際上就是MyBatis根據接口和對應的XML文件創建一個接口的實現類，得到一個接口的子類對象，後續只需要調用方法就行。

1、定義接口

package cn.yanghuisen.mappers;

import java.util.List;

import cn.yanghuisen.pojo.User;

public interface UserMapper {
	// 查詢所有數據
	public List<User> queryAll();
}

2、修改全局配置文件

全局配置文件的SQL映射也需要修改

<mappers>
    <!-- 配置一個接口，class必須是接口所在的包名+接口類名 -->
    <mapper class="cn.yanghuisen.mappers.UserMapper"/>
</mappers>

接口如果很少還好，如果有很多接口，一個個配置也太麻煩了，所有還可以進行簡化配置

<mappers>
    <!-- 系統自動掃描cn.yanghuisen.mappers包下的所有接口 -->
    <package name="cn.yanghuisen.mappers"/>

</mappers>

3、配置SQL映射文件

要求：

• 接口和XML文件要在一個包內
• XML文件要和接口文件名一致
• namespace屬性值必須是接口的包名+類名
• XML文件的ID必須接口中的抽象方法的名字一致
• XML文件的返回值和參數類型必須和抽象方法的返回值和參數類型一致

XML配置和原先沒有多大區別

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

<mapper namespace="cn.yanghuisen.mappers.UserMapper">
	<sql id="user_all_field">
		u_id,u_name,u_pwd,u_date
	</sql>

	<!-- 查找全部數據 -->
	<select id="queryAll" resultType="user">
		select <include refid="user_all_field"/> from u_user
	</select>	
</mapper>

4、使用-查詢全部數據-無參數

查找全部數據

// 查找全部數據
@Test
public void test1() {
    SqlSession session = MyBatisUtil.getSqlSession();
    // 獲取接口的實現類
    UserMapper um = session.getMapper(UserMapper.class);
    // 多態調用方法
    List<User> list = um.queryAll();
    list.forEach(System.out::println);
}

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=4, u_name=mazi, u_pwd=1314520, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=7, u_name=ahh, u_pwd=123123, u_date=Sun Mar 15 22:09:03 CST 2020]

5、使用-查找指定數據-多個參數

查找根據name和密碼查找數據

配置XML文件

<!-- 查找根據name和密碼查找數據 -->
<select id="queryByNamePwd" resultType="user">
    select <include refid="user_all_field"/> from u_user where u_name = #{param1} and u_pwd =#{param2} 
</select>

• 傳入參數不需要聲明類型，只需要定義返回類型

接口中抽象方法

// 根據name和pwd查找數據
public User queryByNamePwd(String name,String pwd);

• param1+：默認爲死格式，第一個參數就是param1，第二個參數就是param2…
• 如果要修改需要在抽象方法中定義

public User queryByNamePwd(@Param("name")String name,@Param("pwd")String pwd);

<!-- 查找根據name和密碼查找數據 -->
<select id="queryByNamePwd" resultType="user">
    select <include refid="user_all_field"/> from u_user where u_name = #{name} and u_pwd =#{pwd} 
</select>

java程序

// 根據Name和Pwd查找數據
@Test
public void test2() {
    SqlSession session = MyBatisUtil.getSqlSession();
    UserMapper um = session.getMapper(UserMapper.class);
    User user = um.queryByNamePwd("zhangsan", "123456");
    System.out.println(user);
}

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]

6、使用-插入數據-多個參數

<!-- 插入數據 -->
<insert id="addUser">
    insert into u_user values(sq_u_user.nextval,#{param1},#{param2},#{param3})
</insrt>

// 插入數據
public int addUser(String name,String pwd,Date date);

// 插入數據
@Test
public void test3() {
    SqlSession session = MyBatisUtil.getSqlSession();
    UserMapper um = session.getMapper(UserMapper.class);
    int len = um.addUser("wanggoudan", "123123", new Date());
    System.out.println(len>0?"插入成功":"插入失敗");
}

運行結果

插入成功

7、使用-修改數據-多個參數

根據ID修改pwd

<!-- 根據ID修改pwd -->
<update id="updatePwdById">
    update u_user set u_pwd = #{param1} where u_id = #{param2}
</update>

// 根據id修改pwd
public int updatePwdById(String pwd,int id);

// 根據id修改pwd
@Test
public void test4() {
    SqlSession session = MyBatisUtil.getSqlSession();
    UserMapper um = session.getMapper(UserMapper.class);
    int len = um.updatePwdById("123456", 4);
    System.out.println(len>0?"修改成功":"修改失敗");
}

運行結果

修改成功

8、使用-刪除數據-一個參數

根據ID刪除數據

<!-- 根據ID刪除數據 -->
<delete id="deleteById">
    delete from u_user where u_id = #{param1}
</delete>

// 根據id刪除數據
public int deleteById(int id);

// 根據id刪除數據
@Test
public void test5() {
    SqlSession session = MyBatisUtil.getSqlSession();
    UserMapper um = session.getMapper(UserMapper.class);
    int len = um.deleteById(9);
    System.out.println(len>0?"刪除成功":"刪除失敗");
}

運行結果

刪除成功

六、動態SQL

動態SQL就是根據不同的條件，SQL語句可以隨之變化。可以實現一條SQL查詢多種結果。

1、if標籤

可以對傳入的參數進行判斷

<!-- if標籤 根據id或name或pwd查找數據 -->
<select id="queryUserByIDNamePwd" resultType="user">
    select * from u_user where 1=1
    <if test="id!=null">
        and u_id = #{id}
    </if>
    <if test="name!=null and name!=''">
        and u_name = #{name}
    </if>
    <if test="pwd!=null and pwd!=''">
        and u_pwd = #{pwd}
    </if>
</select>

• test：判斷條件
• 1=1：爲了所有的if都不成立，出現select * from u_user where

java程序：根據ID查找數據

List<User> list = mapper.queryUserByIDNamePwd(2, null, null);

運行結果

User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]

java程序：根據Name查找數據

List<User> list = mapper.queryUserByIDNamePwd(null, "kl", null);

運行結果

User [u_id=55, u_name=kl, u_pwd=221133, u_date=Mon Mar 16 19:09:11 CST 2020]

java程序：根據Pwd查找數據

List<User> list = mapper.queryUserByIDNamePwd(null, null, "123456");

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:03:03 CST 2020]

java程序：查找全部數據

List<User> list = mapper.queryUserByIDNamePwd(null, null, null);

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=4, u_name=mazi, u_pwd=123456789, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=20, u_name=#{item.u_name), u_pwd=#{item.u_pwd}, u_date=Mon Mar 16 10:49:46 CST 2020]
User [u_id=7, u_name=ahh, u_pwd=123123, u_date=Sun Mar 15 22:09:03 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=54, u_name=whh, u_pwd=11223344, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=55, u_name=kl, u_pwd=221133, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:03:03 CST 2020]

2、where標籤

where就是爲了解決上面的1=1問題

<!-- where標籤 -->
<!-- 如果沒有滿足條件則不會添加where關鍵字，否則相反-->
<!-- 如果第一個滿足條件的語句中有and,則自動去除 -->
<select id="queryUserByIDNamePwd1" resultType="User">
    select * from u_user
    <where>
        <if test="id!=null">
            and u_id = #{id}
        </if>
        <if test="name!=null and name!=''">
            and u_name = #{name}
        </if>
        <if test="pwd!=null and pwd!=''">
            and u_pwd = #{pwd}
        </if>
    </where>
</select>

• 如果沒有滿足條件則不會添加where關鍵字，否則相反
• 如果第一個滿足條件的語句中有and,則自動去除

java程序：

List<User> list = mapper.queryUserByIDNamePwd1(null, null, "123456");

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:03:03 CST 2020]

3、choose when otherwise、標籤

類似於java中的switch

<!-- choose when otherwise -->
<!-- 類似於Java中的switch -->
<!-- 如果第一個when滿足則不在執行第二個 -->
<select id="queryUserByIDNamePwd2" resultType="User">
    select * from u_user
    <where>
        <choose>
            <when test="name!=null and name!=''">
                and u_name = #{name}
            </when>
            <when test="pwd!=null and pwd!=''">
                and u_pwd = #{pwd}
            </when>
            <otherwise>
                1=1
            </otherwise>
        </choose>
    </where>
</select>

• when：相當於java中的case
• otherwise：相當於java中的default

java程序：查找全部數據

List<User> list = mapper.queryUserByIDNamePwd2(null, null);

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=4, u_name=mazi, u_pwd=123456789, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=20, u_name=#{item.u_name), u_pwd=#{item.u_pwd}, u_date=Mon Mar 16 10:49:46 CST 2020]
User [u_id=7, u_name=ahh, u_pwd=123123, u_date=Sun Mar 15 22:09:03 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=54, u_name=whh, u_pwd=11223344, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=55, u_name=kl, u_pwd=221133, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:03:03 CST 2020]

java程序：根據Name查找

List<User> list = mapper.queryUserByIDNamePwd2("kl", null);

運行結果

User [u_id=55, u_name=kl, u_pwd=221133, u_date=Mon Mar 16 19:09:11 CST 2020]

java程序：根據Pwd查找

List<User> list = mapper.queryUserByIDNamePwd2(null, "123456");

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:03:03 CST 2020]

4、set標籤

維護Update語句中的set子句

<!-- set標籤 -->
<!-- 如果不滿足條件則不會生成set關鍵字，反之 -->
<!-- 會自動去除最後的一個, -->
<update id="updateUserNamePwdDateByID">
    update u_user
    <set>
        <!-- 爲了必滿全部都不滿足，出現錯誤的update u_user語句 -->
        u_id = #{u_id},
        <if test="u_name!=null and u_name!=''">
            u_name = #{u_name},
        </if>
        <if test="u_pwd!=null and u_pwd!=''">
            u_pwd = #{u_pwd},
        </if>
        <if test="u_date!=null">
            u_date = #{u_date},
        </if>
    </set>
    where u_id = #{u_id}
</update>

• 如果不滿足條件則不會生成set關鍵字，反之
• 自動去除最後一個,

java程序：根據ID修改name

int len = mapper.updateUserNamePwdDateByID(new User(56,"sanjianke",null,null));

運行結果

1

java程序：根據ID修改Name和Pwd

int len = mapper.updateUserNamePwdDateByID(new User(56,"sanjianke","123456"));

運行結果

1

java程序：根據ID修改Name和Pwd和Date

int len = mapper.updateUserNamePwdDateByID(new User(56,"sanjianke","123456",new Date()));

運行結果

1

5、trim標籤

如果對where和set的刪除某些內容不不滿意，可以自己定義

<!-- trim標籤 -->
<!-- 如果對where和set的刪除某些內容不不滿意，可以自己定義 -->
<!-- prefix:在前面添加的內容 -->
<!-- prefixOverrides：刪除第一個結果的指定內容 -->
<select id="queryByNamePwd1" resultType="User">
    select * from u_user
    <trim prefix="where" prefixOverrides="and | or">
        <if test="name!=null and name!=''">
            and u_name = #{name}
        </if>
        <if test="pwd!=null and pwd!=''">
            and u_pwd = #{pwd}
        </if>
    </trim>
</select>

• prefix：在前面添加的內容
  • suffix：在最後添加內容
• prefixOverrides：刪除第一個結果的內容
  • suffixOverrides：刪除最後的內容

java程序：根據Name或者Pwd查找數據

// 根據Name或者Pwd查找數據-trim標籤
@Test
public void test7() {
    SqlSession session = MyBatisUtil.getSqlSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    List<User> list = mapper.queryByNamePwd1("","123456");
    list.forEach(System.out::println);
    session.close();
}

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:41:51 CST 2020]

6、bind標籤

對傳入的數據在加工

<!-- 根據Name模糊查找 bind標籤 -->
<select id="queryByNameLike" resultType="User">
    select * from u_user
    <where>
        <if test="name!=null and name!=''">
            <bind name="name" value="'%'+name+'%'"/>
            u_name like #{name}
        </if>
    </where>
</select>

• name：加工後的值的名字
• value：加工（字符串拼接）

java程序：傳入一個空字符串，查找全部內容

List<User> list = mapper.queryByNameLike("");

運行結果

User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=2, u_name=lisi, u_pwd=123123, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=3, u_name=wanger, u_pwd=112233, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=4, u_name=mazi, u_pwd=123456789, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=5, u_name=wangwu, u_pwd=666666, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=20, u_name=#{item.u_name), u_pwd=#{item.u_pwd}, u_date=Mon Mar 16 10:49:46 CST 2020]
User [u_id=7, u_name=ahh, u_pwd=123123, u_date=Sun Mar 15 22:09:03 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=54, u_name=whh, u_pwd=11223344, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=55, u_name=kl, u_pwd=221133, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=56, u_name=sanjianke, u_pwd=123456, u_date=Mon Mar 16 22:41:51 CST 2020]

java程序：查找Name中帶h的

List<User> list = mapper.queryByNameLike("h");

運行結果

User [u_id=7, u_name=ahh, u_pwd=123123, u_date=Sun Mar 15 22:09:03 CST 2020]
User [u_id=80, u_name=baisushan, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=60, u_name=shaungwaiwai, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=30, u_name=wahaah, u_pwd=123456, u_date=Mon Mar 16 11:41:07 CST 2020]
User [u_id=54, u_name=whh, u_pwd=11223344, u_date=Mon Mar 16 19:09:11 CST 2020]
User [u_id=1, u_name=zhangsan, u_pwd=123456, u_date=Sun Mar 15 18:41:45 CST 2020]
User [u_id=6, u_name=zhaoliu, u_pwd=88888888, u_date=Sun Mar 15 18:41:45 CST 2020]

7、foreach標籤

遍歷傳入的list集合或者數組

<!-- 批量修改數據 -->
<update id="updateSomeUser">
    <foreach collection="list" item="item" open="begin" close=";end;" separator=";">
        update u_user set u_name = #{item.u_name},u_pwd = #{item.u_pwd} where u_id = #{item.u_id}	
    </foreach>
</update>

• collection：傳入的數據類型，list集合就是list，數組就是array
• item：遍歷過程中每條數據的臨時儲存
• open：頭部添加內容
• close：結尾添加內容
• separator：每次遍歷完畢添加內容

@Test
public void test2() {
    SqlSession session = MyBatisUtil.getSqlSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    int len = mapper.updateSomeUser(Arrays.asList(new User(54,"whh","11223344",new Date()),
                                                  new User(56,"sww","789456",new Date()),new User(55,"kl","221133",new Date())));
    System.out.println(len);
    session.close();
}

運行結果

-1

Tips：-1是對結果，原因不清楚。

8、Sql Include標籤

引用SQL語句

SQL

<sql id="user_all_field">
    u_id,u_name,u_pwd,u_date
</sql>

Include

<select id="queryAll" resultType="user">
    select <include refid="user_all_field"/> from u_user
</select>

七、自動映射

自動映射：MyBatis自動把數據庫中查出來的數據按照字段名字和JavaBean對象的屬性進行匹配。

1、自動映射

如果數據庫字段名和類的屬性名一致，將會自動映射

2、設置別名的方式

如果數據庫中的字段名和類的屬性的屬性名不一致，可以在Sql中設置別名。然後繼續使用自動映射

<select id="queryAll1" resultType="Student">
    select u_id t_id,u_name t_naem,u_pwd t_pwd,u_date t_date from u_user
</select>

2、resultMap

用於自定義映射關係，一旦使用resultMap將不在採用自動映射機制。

<resultMap type="Student" id="s1">
    <!-- id用來映射主鍵 -->
    <id column="u_id" property="t_id"/>
    <!-- result映射非主鍵 -->
    <result column="u_name" property="t_name"/>
    <result column="u_pwd" property="t_pwd"/>
    <result column="u_date" property="t_date"/>
</resultMap>

<select id="queryAll2" resultMap="s1">
    select * from u_user
</select>

java程序

@Test
public void test2() {
    SqlSession session = MyBatisUtil.getSqlSession();
    StudentMapper mapper =  session.getMapper(StudentMapper.class);
    List<Student> list = mapper.queryAll1();
    list.forEach(System.out::println);
    session.close();
}

運行結果

Student [t_id=1, t_name=null, t_pwd=123456, t_date=Sun Mar 15 18:41:45 CST 2020]
Student [t_id=2, t_name=null, t_pwd=123123, t_date=Sun Mar 15 18:41:45 CST 2020]
Student [t_id=3, t_name=null, t_pwd=112233, t_date=Sun Mar 15 18:41:45 CST 2020]
Student [t_id=4, t_name=null, t_pwd=123456789, t_date=Sun Mar 15 18:41:45 CST 2020]
Student [t_id=5, t_name=null, t_pwd=666666, t_date=Sun Mar 15 18:41:45 CST 2020]
Student [t_id=6, t_name=null, t_pwd=88888888, t_date=Sun Mar 15 18:41:45 CST 2020]
Student [t_id=20, t_name=null, t_pwd=#{item.u_pwd}, t_date=Mon Mar 16 10:49:46 CST 2020]
Student [t_id=7, t_name=null, t_pwd=123123, t_date=Sun Mar 15 22:09:03 CST 2020]
Student [t_id=30, t_name=null, t_pwd=123456, t_date=Mon Mar 16 11:41:07 CST 2020]
Student [t_id=60, t_name=null, t_pwd=123456, t_date=Mon Mar 16 11:41:07 CST 2020]
Student [t_id=80, t_name=null, t_pwd=123456, t_date=Mon Mar 16 11:41:07 CST 2020]
Student [t_id=54, t_name=null, t_pwd=11223344, t_date=Mon Mar 16 19:09:11 CST 2020]
Student [t_id=55, t_name=null, t_pwd=221133, t_date=Mon Mar 16 19:09:11 CST 2020]
Student [t_id=56, t_name=null, t_pwd=789456, t_date=Mon Mar 16 22:41:51 CST 2020]