Mybatis笔记

冷不防 2022-05-31 13:30 113阅读 0赞

## Mybatis ##

MyBatis 是支持定制化 SQL、存储过程以及高级映射的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

1.使用mysql数据库（MySQLWorkbench）：  
建库建表，填充数据。  
![这里写图片描述][format_png]  
![这里写图片描述][format_png 1]

2.创建实体类Category

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

3.配置文件mybatis-config.xml（src目录下创建）  
下面可以配置多个元素节点，而每个节点可以配置两个东西，一个是事务管理器配置，另一个是数据源配置。

<?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>
    	<typeAliases>
    		<package name="com.bean" />
    	</typeAliases>
    	
    	<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?characterEncoding=UTF-8" />
    					
    				<property name="username" value="root" />
    				<property name="password" value="123456" />
    			</dataSource>
    		</environment>
    	</environments>
    	<mappers>
    		<mapper resource="com/bean/Category.xml" />
    	</mappers>
    
    
    </configuration>

4.配置Category.xml（com.bean目录）

<?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="com.bean">
    	<select id="listCategory" resultType="Category">
    		select * from category_
    	</select>
    </mapper>

5.测试类TestMybatis

public class TestMybatis {
    	public static void main(String[] args) throws IOException {
    		String resource = "mybatis-config.xml";
    		InputStream inputStream = Resources.getResourceAsStream(resource);
    		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    		// 通过配置文件"mybatis-config.xml"得到SQLSessionFactory(创建SqlSession对象的工厂)
    		SqlSession session = sqlSessionFactory.openSession();
    		// 通过SQLSessionFactory得到Session
    		List<Category> cs = session.selectList("listCategory");
    		// 通过session的selectList方法，调用sql语句listCategory。
    		for (Category c : cs) {
    			System.out.println(c.getName());
    		}
    	}
    }

**原理：**  
1. 应用程序找mybatis要数据  
2. mybatis从数据库中请求数据

- 通过mybatis-config.xml 定位数据库
    	 - 通过Category.xml执行对应的select语句
    	 - 基于Catgory.xml把返回的数据库记录封装在Category对象中
    	 - 把多个Category对象装在一个Category集合中

1.  返回一个Category集合  
    ![这里写图片描述][format_png 2]  
    **基本的增删改查:**  
    实体类（映射数据库表）–>Mybatis-config.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="com.bean">
    	<insert id="addCategory" parameterType="Category">
    		insert into category_(name) values (#{ name})
    	</insert>
    
    	<delete id="deleteCategory" parameterType="Category">
    		delete from category_ where id= #{ id}
    	</delete>
    
    	<select id="getCategory" parameterType="_int" resultType="Category">
    		select * from category_ where id=#{ id}
    	</select>
    
    	<update id="updateCategory" parameterType="Category">
    		update category_ set name=#{ name} where id=#{ id}
    	</update>
    
    	<select id="listCategory" resultType="Category">
    		select * from category_
    	</select>
    </mapper>

**parameterType的用法：**

1.基本数据类型，如输入参数只有一个，其数据类型可以是基本的数据类型，也可以是自己定的类类型。包括int,String,Integer,Date,如下：

（1）根据id进行相应的删除：

（2）添加员工：

2.复杂数据类型：包含java实体类，map。  
另外MyBatis还提供了一个使用注解来参与多个参数的方式。这种方式需要在接口的参数上添加@Param注解此处要注意的是，由于该方法需要传入多个参数，在进行MyBatis配置时，没有办法同时配置多个参数，另外MyBatis还提供了一个使用注解来参数多个参数的方式。这种方式需要在接口的参数上添加@Param注解注意，以下两种写法是完全相同的。  
但使用的时候要使用第一种类型  
Userlogin（@Param（value =“name”）Stringname，  
@Param（value =“password”）String password）; //用户登录（String name，String password）;  
配置如下：

<select id =“login”resultType =“com.pojo.User”>  
select \* from us where name =＃\{name\} and password =＃ \{密码\}  
</ select>  
<选择ID = “getWinLogByEventId”参数类型= “java.lang.Long中” >结果映射= “BaseResultMap”> > 选择<包括REFID = “基础\_列\_列表”/>从取胜\_登录其中EVENTID =＃ \{ \_ parameter，jdbcType = BIGINT\} </ select >  
3.获取参数中的值：  
1.基本数据类型：＃\{参数\}获取参数中的值 2.复杂数据类型：＃\{属性名\}， map中则是＃\{key\}  
**测试类：**

public class TestMybatis {  
    	public static void main（String [] args）throws IOException {  
    		String resource =“mybatis -config.xml“;
    		InputStream inputStream = Resources.getResourceAsStream(resource);
    		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    		// 通过配置文件"mybatis-config.xml"得到SQLSessionFactory(创建SqlSession对象的工厂)
    		SqlSession session = sqlSessionFactory.openSession();
    		// 通过SQLSessionFactory得到Session
    		Category c = new Category();
    		// 增加
    		c.setName("addCategory");
    		session.insert("addCategory", c);
    		// 删除
    		c.setId(6);
    		session.delete("deleteCategory", c);
    		// 查询
    		c = session.selectOne("getCategory", 3);
    		System.out.println(c.getName());
    		// 更改
    		c = session.selectOne("getCategory", 4);
    		c.setName("修改了姓名");
    		session.update("updateCategory", c);
    
    		// 遍历
    		listAll(session);
    
    		session.commit();
    		session.close();
    
    	}
    
    	private static void listAll(SqlSession session) { 
    		// TODO Auto-generated method stub
    		List<Category> cs = session.selectList("listCategory");
    		// 通过session的selectList方法，调用sql语句listCategory。
    		for (Category c : cs) { 
    			System.out.println(c.getName());
    		}
    
    	}
    
    }

**模糊查询：**  
实体类配置文件：

<select id="listCategoryByName" parameterType="String"
    		resultType="Category">
    		select * from category_ where name like concat('%',#{ 0},'%')
    		<！ - 如果是oracle，写法是 - > 
    		<！ -  select * from category_ where'name'like '％'||＃{ 0} ||'％' - > 
    	</ select>

测试代码：

List <Category> cs = session.selectList（“listCategoryByName”，“cat”）; 
    		for（Category c1：cs）{  
    			System.out.println（c1.getName（））; 
    		}

\*\*多条件查询：\*\*结合前面的模糊查询，多一个id多少的条件1。

<select id="listCategoryByIdAndName"  parameterType="map" resultType="Category">
        select * from   category_  where id> #{ id}  and name like concat('%',#{ name},'%')
    </select>

因为是多个参数，而selectList方法又只接受一个参数对象，所以需要把多个参数放在Map里面，然后把这个Map对象作为参数传递进去

Map <String，Object> params = new HashMap < >（）; 
    		params.put（“id”，0）; 
    		params.put（“name”，“cat”）;
    		List <Category> cs = session.selectList（“listCategoryByIdAndName”，params）; 
    		for（Category c1：cs）{ 
    		System.out.println（c1.getName（））;
    		}

**1.一对多**：（分类–产品）  
1、数据库建表，填数据。  
![这里写图片描述][format_png 3]  
2、新建一个普通的一个pojo Product实体类

public class Product {
    	private int id;
    	private String name;
    	private float price;
    	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 float getPrice() {
    		return price;
    	}
    	public void setPrice(float price) {
    		this.price = price;
    	}
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		return "Product [id=" + id + ",name=" + name + ",price=" + price;
    	}
    }

3.修改Category实体类

在Category类中增加：
    List<Product> products;
    
    	public List<Product> getProducts() {
    		return products;
    	}
    
    	public void setProducts(List<Product> products) {
    		this.products = products;
    	}

4.修改Category.xml  
通过left join关联查询，对Category和Product表进行关联查询。  
与前面学习的有所区别，这里不是用的resultType, 而是resultMap，通过resultMap把数据取出来放在对应的 对象属性里  
注： Category的id 字段 和Product的id字段同名，Mybatis不知道谁是谁的，所以需要通过取别名cid,pid来区分。  
name字段同理。

<mapper namespace="com.bean">
    <resultMap type="Category" id="categoryBean"> <id column="cid" property="id" 
    		/> <result column="cname" property="name" />
    	
    	
    <collection property="products" ofType="Product"> 
    <id column="pid" property="id" />
    		 <result column="pname" property="name" />
    		 <result column="price" property="price" />
    		 </collection>
    		 </resultMap>
    	
    <select id="listCategory" resultMap="categoryBean"> 
    select c.*,p.*,c.id 'cid',p.id 'pid',c.name 'cname',p.name 'pname' from category_ c left join product_ p on c.id=p.cid </select>
    </mapper>

5、测试

// 一对多关系
    	public static void listCategory(SqlSession session) {
    		List<Category> cs = session.selectList("listCategory");
    		for (Category category : cs) {
    			System.out.println(category);
    			List<Product> ps = category.getProducts();
    			for (Product product : ps) {
    				System.out.println("/t" + product);
    			}
    		}
    
    	}

**2.多对一关系**（产品–>分类）  
1.修改实体类为Product增加category属性

private Category category;
    	public Category getCategory() {
    		return category;
    	}
    	public void setCategory(Category category) {
    		this.category = category;
    	}

2.新建Product.xml  
提供Product.xml，通过listProduct配置关联查询的sql语句。  
然后通过resultMap ，进行字段和属性的对应。  
使用association（关联） 进行多对一关系关联，指定表字段名称与对象属性名称的一一对应关系  
注： Category的id 字段 和Product的id字段同名，Mybatis不知道谁是谁的，所以需要通过取别名cid,pid来区分。  
name字段同理。

3.在mybatis-config.xml中增加对于Product.xml的映射

4.测试

// 多对一关系
    	public static void listProduct(SqlSession session) {
    		List<Product> ps = session.selectList("listProduct");
    		for (Product product : ps) {
    			System.out.println(product + "\t对应的分类是\t" + product.getCategory());
    		}
    	}

**3.多对多关系**  
以订单Order和产品Product为例：  
***一张订单\*\*\*里可以包含\*\*\*多种产品***  
***一种产品*** 可以出现在\*\*\*多张订单\*\*\*里  
这就是多对多关系，为了维系多对多关系，必须要一个中间表。 在这里我们使用订单项(OrderItem)表来作为中间表。

1.  查询多对多关系
2.  建立多对多关系
3.  删除多对多关系

1.数据库建表填充数据。  
![这里写图片描述][format_png 4]新建order\_表，同理新建order\_item\_表  
填充数据:  
![这里写图片描述][format_png 5]

2.新建实体类Order和OrderItem  
自动生成getset方法。

public class Order {
    	private int id;
    	private String code;
    	
    	List<OrderItem> orderItems;
    }

public class OrderItem {
    	private int id;
    	private int number;
    	private Order order;
    	private Product product;
    }

3.配置映射文件Product、Order、OrderItem。  
Product.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="com.bean">
    	<resultMap type="Product" id="productBean">
    		<id column="pid" property="id" />
    		<result column="pname" property="name" />
    		<result column="price" property="price" />
    		
    		
    		<association property="category" javaType="Category">
    			<id column="cid" property="id" />
    			<result column="cname" property="name" />
    		</association>
    
    	</resultMap>
    
    	<select id="listProduct" resultMap="productBean">
    		select c.*,p.*,c.id
    		'cid',p.id 'pid' ,c.name 'cname',p.name 'pname' from
    		category_ c left
    		join product_ p on c.id=p.cid
    	</select>
    	<select id="getProduct" resultMap="productBean">
    		select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname'
    		from category_ c
    		left join product_ p on c.id = p.cid
    		where p.id = #{id}
    	</select>
    
    </mapper>

Order.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="com.bean">
    	<resultMap type="Order" id="orderBean">
    		<id column="oid" property="id" />
    		<result column="code" property="code" />
    		<collection property="orderItems" ofType="orderItem">
    			<id column=" oiid" property="id" />
    			<result column="number" property="number" />
    			<association property="product" javaType="Product">
    				<id column="pid" property="id" />
    				<result column="pname" property="name" />
    				<result column="price" property="price" />
    			</association>
    		</collection>
    
    	</resultMap>
    
    	<select id="listOrder" resultMap="orderBean">
    		select o.*,p.*,oi.*, o.id
    		'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
    		from order_ o
    		left join
    		order_item_ oi on o.id =oi.oid
    		left join product_ p on p.id = oi.pid
    	</select>
    	<select id="getOrder" resultMap="orderBean">
    		select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
    		from order_ o
    		left join order_item_ oi on o.id =oi.oid
    		left join product_ p on p.id = oi.pid
    		where o.id = #{id}
    	</select>
    
    </mapper>

OrderItem.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="com.bean">
    	<insert id="addOrderItem" parameterType="OrderItem">
    		insert into order_item_
    		values(null,#{order.id},#{product.id},#{number})
    	</insert>
    	<insert id="deleteOrderItem" parameterType="OrderItem">
    		delete from order_item_
    		where oid = #{order.id} and pid = #{product.id}
    	</insert>
    </mapper>

修改mybatis-config.xml  
增加映射文件

4.建立关系  
(1).查询

Test

private static void listOrder(SqlSession session) {
    		List<Order> orders = session.selectList("listOrder");
    		for (Order order : orders) {
    			System.out.println(order.getCode());
    			List<OrderItem> oItems = order.getOrderItems();
    			for (OrderItem orderItem : oItems) {
    				System.out.format("\t%s\t%f\t%d%n", orderItem.getProduct().getName(), orderItem.getProduct().getPrice(),
    						orderItem.getNumber());
    			}
    		}
    	}

(2).增加关系

// 建立关系(插入数据)
    	// 首先通过id分别获取Order和Product对象，接着就新建一个OrderItem对象，set order和product
    	// 还有数量，最后用"addOrderItem"对应的sql语句插入.
    	private static void addOrderItem(SqlSession session) {
    		Order order = session.selectOne("getOrder", 1);
    		Product product = session.selectOne("getProduct", 2);
    		OrderItem orderItem = new OrderItem();
    		orderItem.setProduct(product);
    		orderItem.setOrder(order);
    		orderItem.setNumber(200);
    		session.insert("addOrderItem", orderItem);
    	}

(3).删除关系

// 删除关系(就是删掉OrderItem记录)
    	// 同上通过对应的Order和Product的id进行删除
    	private static void deleteOrderItem(SqlSession session) {
    		Order order = session.selectOne("getOrder", 1);
    		Product product = session.selectOne("getProduct", 2);
    		OrderItem orderItem = new OrderItem();
    		orderItem.setProduct(product);
    		orderItem.setOrder(order);
    		session.delete("deleteOrderItem", orderItem);
    
    	}

(4).修改  
多对多不存在修改关系的做法，就是删除旧的，然后新增一条即达到修改的效果。

**动态sql------if标签**  
以查询Product表为例：  
1.Product.xml配置文件  
使用模糊查询的时候可能会用到不同的字段，如果查询一次使用一条sql语句，会变得难以维护，就能使用Mybatis的动态sql----if标签  
；如果没有传入参数那么就是查询所有，这样就可以一条语句应付多种情况。

<mapper namespace="com.bean">
    	<select id="listProductByName" resultType="Product">
    		select * from product_
    		<if test="name!=null">
    			where name like concat('%',#{name},'%')
    		</if>
    	</select>
    </mapper>

2.test

// 查询Product使用模糊查询
    	private static void listProductByName(SqlSession session) {
    		Map<String, Object> params = new HashMap<>();
    		params.put("name", "b");//"b"通过动态输入灵活查询
    		List<Product> ps = session.selectList("listProductByName", params);
    		for (Product product : ps) {
    			System.out.println(product);
    		}
    
    	}

**动态sql------where标签**  
1.修改Product.xml配置文件  
当出现多条件查询的时候不能愉快的直接使用  
select \* from product\_ where name like concat(’%’,\#\{name\},’%’) and price > \#\{price\}会出现name为空price不为空的语句错误；这时候就使用where标签。  
如果任何条件都不成立，那么就在sql语句里就不会出现where关键字  
如果有任何条件成立，会自动去掉多出来的 and 或者 or。

<select id="listProductByName" resultType="Product">
    		select * from product_
    		<where>
    			<if test="name!=null">
    				and name like concat('%',#{name},'%')
    			</if>
    			<if test="price!=null and price!=0">
    				and price > #{price}
    			</if>
    		</where>
    	</select>

2.test

// 多条件查询
    	private static void listProductByNameAndPrice(SqlSession session) {
    		Map<String, Object> params = new HashMap<>();
    		params.put("name", "b");// 这时params值为不为空都可以正常运行
    		params.put("price", "2");
    		List<Product> ps = session.selectList("listProductByName", params);
    		for (Product product : ps) {
    			System.out.println(product);
    		}
    	}

**动态sql------set标签**  
1.修改Product.xml配置文件  
与where标签类似的，在update语句里也会碰到多个字段相关的问题。 在这种情况下，就可以使用set标签：

<update id="updateProduct" parameterType="Product">
    		update product_
    		<set>
    			<if test="name!=null">name=#{name},</if>
    			<if test="price!=null">price=#{price}</if>
    		</set>
    		where id=#{id}
    	</update>

2.test

// 修改Product
    	private static void updateProductById(SqlSession session) {
    		Product p=new Product(5,"product zz",9.99f);
    		session.update("updateProduct", p);
    	}

**动态sql------trim标签**  
trim 用来定制想要的功能，比如where标签就可以用

替换  
set标签就可以用

替换。

<select id="listProductByName" resultType="Product">
    		select * from product_
    		<trim prefix="WHERE" prefixOverrides="AND|OR">
    			<if test="name!=null">
    				and name like concat('%',#{name},'%')
    			</if>
    			<if test="price!=null and price!=0">
    				and price > #{price}
    			</if>
    		</trim>
    	</select>
    	<update id="updateProduct" parameterType="Product">
    		update product_
    		<trim prefix="SET" suffixOverrides=",">
    			<if test="name!=null">name=#{name},</if>
    			<if test="price!=null">price=#{price}</if>
    		</trim>
    		where id=#{id}
    	</update>

效果和where和set一样。

**动态sql------choose标签**  
1.修改Product.xml配置文件

<select id="productList" resultType="Product">
    		select * from product_
    		<where>
    			<choose>
    				<when test="name!=null">and name like concat('%',#{name},'%')</when>
    				<when test="price!=null and price!=0">and price > #{price}</when>
    				<otherwise>
    					and id>1
    				</otherwise>
    				
    			</choose>
    		</where>
    	</select>

2.test

private static void productList(SqlSession session) {
    		Map<String, Object> params = new HashMap<>();
    		List<Product> ps = session.selectList("productList", params);
    		for (Product product : ps) {
    			System.out.println(product);
    		}
    	}

**动态sql------foreach标签**  
1.修改Product.xml配置文件

<select id="listProductForeach" resultType="Product">
    		SELECT * FROM product_
    		WHERE ID in
    		<foreach item="item" index="index" collection="list" open="("
    			separator="," close=")">
    			#{item}
    		</foreach>
    	</select>

2.test

private static void productListForeach(SqlSession session) {
    		List<Integer> ids = new ArrayList<>();
    		ids.add(1);
    		ids.add(2);
    		ids.add(3);
    		List<Product> ps = session.selectList("listProductForeach", ids);
    		for (Product product : ps) {
    			System.out.println(product);
    		}
    	}

**动态sql------bind标签**  
1.修改Product.xml配置文件

<select id="listProductBind" resultType="Product">
    		<bind name="likename" value="'%'+name+'%'" />
    		select * from product_ where name like #{likename}
    	</select>

2.test

private static void listProductBind(SqlSession session) {
    		Map<String, String> params = new HashMap<>();
    		params.put("name", "product");
    		List<Product> ps = session.selectList("listProductBind", params);
    		for (Product product : ps) {
    			System.out.println(product);
    		}
    	}

[format_png]: /images/20220531/39a9716d32bf4b7c96c318d25ca09f55.png
[format_png 1]: /images/20220531/7d806f586f6e4faf8c901b22efa1a9e5.png
[format_png 2]: /images/20220531/6d49896a142649a1b918c78e8be0b9b2.png
[format_png 3]: /images/20220531/ae0287427371429c91ac54c0f7a43513.png
[format_png 4]: /images/20220531/0fd5cdd2378f4f40a236b0e6f9ee65b0.png
[format_png 5]: /images/20220531/086b86c8af414155a84d863ac69344c5.png