MyBatis进阶——高级使用2

第二节：动态sql

通过mybatis提供的各种标签方法实现动态拼接sql。
需求：根据性别和名字查询用户
查询sql：

SELECT id, username, birthday, sex, address FROM user WHERE sex = 1 AND username LIKE '%张%';

2.1. If标签

2.1.1. Mapper.xml文件

UserMapper.xml配置sql，如下：

<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`
	WHERE sex = #{sex} AND username LIKE '%${username}%'
select>

2.1.2. Mapper接口

public interface UserMapper{
    List<User> queryUserByWhere(User user);
}

2.1.3. 测试方法

在UserMapperTest添加测试方法，如下：

@Test
public void testQueryUserByWhere() {
	SqlSession sqlSession = MyBatisUtils.openSession();
	
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User user = new User();
	user.setSex("1");
	user.setUsername("张");

	List<User> list = userMapper.queryUserByWhere(user);

	for (User u : list) {
		System.out.println(u);
	}
	sqlSession.close();
}

测试查看结果
如果注释掉user.setSex(1)
再次测试发现问题。
按照之前所学的，要解决这个问题，需要编写多个sql，查询条件越多，需要编写的sql就更多了，显然这样是不靠谱的。
解决方案，使用动态sql的if标签

2.1.5. 使用if标签

改造UserMapper.xml，如下：

<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`
	WHERE 1=1
	<if test="sex != null and sex != ''">
		AND sex = #{sex}
	if>
	<if test="username != null and username != ''">
		AND username LIKE '%${username}%'
	if>
select>

注意字符串类型的数据需要做不等于空字符串校验。

再次测试没有问题。

2.2.Where标签

上面的sql还有where 1=1 这样的语句，很麻烦

可以使用where标签进行改造

改造UserMapper.xml，如下

<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`

	<where>
		<if test="sex != null">
			AND sex = #{sex}
		if>
		<if test="username != null and username != ''">
			AND username LIKE
			'%${username}%'
		if>
	where>
select>

2.3.Sql片段

Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。

把上面例子中的id, username, birthday, sex, address提取出来，作为sql片段，如下：

<select id="queryUserByWhere" parameterType="user" resultType="user">
	
	
	SELECT <include refid="userFields" /> FROM `user`
	
	<where>
		<if test="sex != null">
			AND sex = #{sex}
		if>
		<if test="username != null and username != ''">
			AND username LIKE
			'%${username}%'
		if>
	where>
select>


<sql id="userFields">
	id, username, birthday, sex, address
sql>

2.4. foreach标签

向sql传递数组或List，mybatis使用foreach解析，如下：
根据多个id查询用户信息
查询sql：

SELECT * FROM user WHERE id IN (1,10,24)

2.4.1.改造QueryVo

在QueryVo中定义list属性ids存储多个用户id，并添加getter/setter方法

public class QueryVo {
   private User user;
   private List<Integer> ids;
}

2.4.2. Mapper.xml文件

UserMapper.xml添加sql，如下：

<select id="queryUserByIds" parameterType="queryVo" resultType="user">
	SELECT * FROM `user`
	<where>
		
		
		
		
		
		
		<foreach collection="ids" item="item" open="id IN (" close=")"
			separator=",">
			#{item}
		foreach>
	where>
select>

测试方法

@Test
public void testQueryUserByIds() {
	// MyBatis和spring整合，整合之后，交给spring管理
	SqlSession sqlSession = this.sqlSessionFactory.openSession();
	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	// 使用userMapper执行根据条件查询用户
	QueryVo queryVo = new QueryVo();
	List<Integer> ids = new ArrayList<>();
	ids.add(1);
	ids.add(10);
	ids.add(24);
	queryVo.setIds(ids);

	List<User> list = userMapper.queryUserByIds(queryVo);

	for (User u : list) {
		System.out.println(u);
	}

	// MyBatis和spring整合，整合之后，交给spring管理
	sqlSession.close();
}

第三节：关联查询

表之前的关系包括：一对一、一对多、多对多。

3.1. 一对一查询

需求：查询所有订单信息，关联查询订单用户信息。
注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。
使用sql语句：

SELECT o.id,o.user_id userId, o.number,o.createtime,o.note,u.username,u.address FROM
orders o LEFT JOIN user u 
ON o.user_id = u.id

方法一：使用resultType

使用resultType，改造订单pojo类，此pojo类中包括了订单信息和用户信息

这样返回对象的时候，mybatis自动把用户信息也注入进来了

OrderUser类继承Order类后OrderUser类包括了Order类的所有字段，只需要定义用户的信息字段即可，如下

public class OrderUser extends Order {
    private String username;
    private String addrss;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddrss() {
        return addrss;
    }

    public void setAddrss(String addrss) {
        this.addrss = addrss;
    }
}

在UserMapper.xml添加sql，如下

<select id="queryOrderUser" resultType="orderUser">
	SELECT
	o.id,
	o.user_id
	userId,
	o.number,
	o.createtime,
	o.note,
	u.username,
	u.address
	FROM
	`order` o
	LEFT JOIN `user` u ON o.user_id = u.id
select>

在UserMapper接口添加方法，如下：

public interface UserMapper {
	List<OrderUser> queryOrderUser();
}

在UserMapperTest添加测试方法，如下：

@Test
public void testQueryOrderUser() {
	
	SqlSession sqlSession = MyBatisUtils.openSession();
	
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	List<OrderUser> list = userMapper.queryOrderUser();

	for (OrderUser ou : list) {
		System.out.println(ou);
	}
	sqlSession.close();
}

定义专门的pojo类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单。

方法二：使用resultMap

使用resultMap，定义专门的resultMap用于映射一对一查询结果。

改造pojo类

在Order类中加入User属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。
改造Order如下：

 	// 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;
    // 用户
    private User user;

Mapper.xml
这里resultMap指定orderUserResultMap，如下：

<resultMap type="order" id="orderUserResultMap">
	<id property="id" column="id" />
	<result property="userId" column="user_id" />
	<result property="number" column="number" />
	<result property="createtime" column="createtime" />
	<result property="note" column="note" />

	
	
	
	<association property="user" javaType="user">
		
		<id property="id" column="user_id" />
		<result property="username" column="username" />
		<result property="address" column="address" />
	association>

resultMap>


<select id="queryOrderUserResultMap" resultMap="orderUserResultMap">
	SELECT
	o.id,
	o.user_id,
	o.number,
	o.createtime,
	o.note,
	u.username,
	u.address
	FROM
	`order` o
	LEFT JOIN `user` u ON o.user_id = u.id
select>

Mapper接口

编写UserMapper如下：

List<Order> queryOrderUserResultMap();

在UserMapperTest增加测试方法，如下：

@Test
public void testQueryOrderUserResultMap() {
	
	SqlSession sqlSession = MyBatisUtils.openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<Order> list = userMapper.queryOrderUserResultMap();
	for (Order o : list) {
		System.out.println(o);
	}
	sqlSession.close();
}

3.2. 一对多查询

案例：查询所有用户信息及用户关联的订单信息。

用户信息和订单信息为一对多关系。

sql语句：
SELECT
 u.id,
 u.username,
 u.birthday,
 u.sex,
 u.address,
 o.id oid,
 o.number,
 o.createtime,
 o.note
FROM
user u
LEFT JOIN order o ON u.id = o.user_id

1.修改pojo类

在User类中加入Listorders属性,如下图：

public class User {   
	private Integer id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
    private List<Order> orders;//订单
}

2.Mapper.xml

在UserMapper.xml添加sql，如下：

<resultMap type="user" id="userOrderResultMap">
	<id property="id" column="id" />
	<result property="username" column="username" />
	<result property="birthday" column="birthday" />
	<result property="sex" column="sex" />
	<result property="address" column="address" />

	
	<collection property="orders" javaType="list" ofType="order">
		
		<id property="id" column="oid" />
		<result property="number" column="number" />
		<result property="createtime" column="createtime" />
		<result property="note" column="note" />
	collection>
resultMap>


<select id="queryUserOrder" resultMap="userOrderResultMap">
	SELECT
	u.id,
	u.username,
	u.birthday,
	u.sex,
	u.address,
	o.id oid,
	o.number,
	o.createtime,
	o.note
	FROM
	`user` u
	LEFT JOIN `order` o ON u.id = o.user_id
select>

3.Mapper接口

编写UserMapper接口，如下图：

public class UserMapper{
  	List<User> queryUserOrder();
}

4. 测试方法

在UserMapperTest增加测试方法，如下

@Test
public void testQueryUserOrder() {
	SqlSession sqlSession = MyBatisUtils.openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<User> list = userMapper.queryUserOrder();

	for (User u : list) {
		System.out.println(u);
	}
	sqlSession.close();
}