Mybatis03

 

一，输入映射和输出映射

输入类型有，简单类型，pojo对象，（参考MyBatis一）

使用POJO包装对象

开发中通过可以使用POJI传递查询条件。查询条件可能是综合的查询条件，不仅包括用户查询条件还包括其他的查询条件。包装对象：Pojo类中的一个属性是另一个的POJO

需求：根据用户名模糊查询用户信息，查询条件放在QueryVo的user属性中。

1.编写QueryVo

public class QueryVo {

    // 包含其他的pojo

    private User user;

    public User getUser() {

       return user;

    }

    public void setUser(User user) {

       this.user = user;

    }

}

 

2.在UserMapper.xml中配置sql

<!-- 使用包装类型查询用户 -->
<select id="queryUserByQueryVo" parameterType="QueryVo" resultType="user">
select * from user where username like
'%${user.username}%'
</select>

3.在UserMapper接口中添加方法：

public List<User> queryUserByQueryVo(QueryVo vo);

4.测试

@Test
public void testQueryUserByQueryVo() {
    // mybatis和spring整合，整合之后，交给spring管理
    SqlSession sqlSession = this.sqlSessionFactory.openSession();
    // 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    // 使用userMapper执行查询，使用包装对象
    QueryVo queryVo = new QueryVo();
    // 设置user条件
    User user = new User();
    user.setUsername("张");
    // 设置到包装对象中
    queryVo.setUser(user);
    // 执行查询
    List<User> list = userMapper.queryUserByQueryVo(queryVo);
    for (User u : list) {
       System.out.println(u);
    }
    // mybatis和spring整合，整合之后，交给spring管理
    sqlSession.close();
}

效果：

 

resultMap

resultMap可以指定将查询结果映射为POJO，但需要po'j'o的属性名和sql查询的列名一致方可映射成功。

如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系，resultMap实质上还需要将查询结果映射到pojo对象中。

resultMap可以实现将查询结果映射为复杂类型的pojo,比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询

1.声明POJO对象

public class Order {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;
get/set。。。
}

2.创建orderMapper.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">
<!-- 写Sql语句   -->
<mapper namespace="com.itheima.mybatis.mapper.OrderMapper">
<!-- 查询所有的订单数据 -->
<select id="queryOrderAll" resultType="Order">
select id,user_id,number,createtime,
note from orders
</select>
</mapper>

3.编写Mapper接口

public interface OrderMapper {
//查询所有订单
public List<Order> queryOrderAll();
}

4.编写测试方法

public class MybatisOrderTest {
private SqlSessionFactory factory;
@Before
public void init() throws Exception{
InputStream s = Resources.getResourceAsStream("sqlMapConfig.xml");
this.factory = new SqlSessionFactoryBuilder().build(s);
}

@Test
public void Test1(){
//获取sqlSession
SqlSession session = this.factory.openSession();
//获取orderMapper
OrderMapper mapper = session.getMapper(OrderMapper.class);

//执行查询
List<Order> queryOrderAll = mapper.queryOrderAll();
for (Order order : queryOrderAll) {
System.out.println(order);
　　　　}
　　}
}

效果：

发现结果是空的，

解决方案1：使用resultMap

解决方案2；造成null原因是Pojo的属性名字，和数据库中的不一致，可以修改成一致的。

使用resultMap

由于上边的mapper.xml中sql查询列(user_id)和Order类属性(userId)不一致，所以查询结果不能映射到pojo中。需要定义resultMap，把orderResultMap将sql查询列(user_id)和Order类属性(userId)对应起来。

改造OrderMapper.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">

<!-- 写Sql语句   -->

<mapper namespace="com.itheima.mybatis.mapper.OrderMapper">

<!-- resultMap最后是将结果映射到POJO上，type就是指映射到哪一个pojo

　　id:设置ResultMap的id

17　　 定义主键 ,非常重要。如果是多个字段,则定义多个id

19　　 property：主键在pojo中的属性名

21　　 column：主键在数据库中的列名

-->

<resultMap type="Order" id="orderResultMap">

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

</resultMap>

<!-- 查询所有的订单数据 -->

<select id="queryOrderAll" resultType="Order" resultMap="orderResultMap">

select id,user_id,number,createtime,

note from orders

</select>

</mapper>

 

效果：

 

 

 

动态sql

通过mybatis提供的各种标签方法实现动态标签拼接sql

根据性别和名字查询名字

sql:

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

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>

 

编写Mapper接口：

//根据条件查询用户

public List<User> queryUserByWhere(User u);

 

测试：

public class MybatisUserTest {

private SqlSessionFactory factory;

@Before

public void init() throws IOException{

InputStream s = Resources.getResourceAsStream("sqlMapConfig.xml");

this.factory = new SqlSessionFactoryBuilder().build(s);

       }

@Test

public void TestqueryUserByWhere(){

SqlSession sqlsession = this.factory.openSession();

UserMapper mapper = sqlsession.getMapper(UserMapper.class);

//执行查询

User u = new User();

u.setUsername("张");

u.setSex("1");

List<User> list = mapper.queryUserByWhere(u);

for (User user : list) {

System.out.println(user);

        }

    }

}    

 

效果：

 

 

如果注释掉user.setSex("1"),测试结果入下图：

 

 

测试结果二很显然不合理。按照之前所学，要解决这个问题，需要编写多个sql,查询条件越多，需要编写的sql就更多了，显然这样是不靠谱的。

解决方法，使用动态sql的if标签

<!-- 根据性别和名字查询用户 -->
<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>

 

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

 

上面的sql还有where 1=1 这样的语句，很麻烦。还可以使用where标签来进行改造

<!-- 根据性别和名字查询用户 -->

<!-- 根据性别和名字查询用户 -->
<select id="queryUserByWhere" parameterType="User" resultType="User">
SELECT id, username, birthday, sex, address FROM user
<where>
<if test="sex !=null and sex !=''">
AND sex = #{sex}
</if>
<if test="username !=null and username !=''">
AND username LIKE '%${username}%'
</if>
</where>
</select>

效果：

 

 

Sql片段

sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql复用的目的。把上面例子中的id,username,birthday,sex,address提取出来，作为sql片段，如下：

<!-- 根据性别和名字查询用户 -->

<select id="queryUserByWhere" parameterType="User" resultType="User">

SELECT <include refid="userFields"></include> FROM user

<where>

<if test="sex !=null and sex !=''">

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>

 

如果要使用别的Mapper.xml配置的sql片段，可以在refid前面加上对应的Mapper.xml的namespace

例如：

 

 

foreach标签

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

查询sql:select * from user where id in(1,10,24)

改造QueryVo

1.在pojo中定义list属性ids 存储多个用户id,并添加get/set

 

 

2.在UserMapper.xml中添加:

<!-- 查询多个用户 -->

<select id="queryUserByIds" parameterType="QueryVo" resultType="User">

select * from user

<where>

<foreach collection="ids" item="id" open="id IN(" close=")" separator=",">

#{id}

</foreach>

</where>

</select>

 

3.在UserMapper接口中添加

//查询多个用户

public List<User> queryUserByIds(QueryVo vo);

4.测试：

@Test

public void TestqueryUserByIds(){

SqlSession sqlSession = this.factory.openSession();

UserMapper mapper = sqlSession.getMapper(UserMapper.class);

QueryVo vo = new QueryVo();

List<Integer> ids = new ArrayList<Integer>();

ids.add(1);

ids.add(10);

ids.add(24);

vo.setIds(ids);

List<User> queryUserByIds = mapper.queryUserByIds(vo);

for (User user : queryUserByIds) {

System.out.println(user);

}

}

 

效果：

 

 

 

 

关联查询

商品订单数据模型

 

 

1.一对一查询

需求：查询所有订单信息，关联查询下单用户信息。

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

方法一：使用resultType

使用resultType,改造订单POJO类，此pojo类中包括了订单信息和用户信息，这样返回对象的时候，mybatis自动把用户信息也注入进来了。

1.改造pojo类

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

public class OrderUser extends Order{

private String username;

private String address;

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

}

 

2.在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
orders o
LEFT JOIN USER u ON o.user_id = u.id
</select>

 

3.在UserMappring接口中添加对应方法

/*
* 一对一关联，查询订单同时包含用户信息
*/
public List<OrderUser> queryOrderUser();

 

4.测试

@Test
public void testQueryOrderUser(){
SqlSession sqlsession = this.factory.openSession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
List<OrderUser> queryOrderUser = mapper.queryOrderUser();
for (OrderUser orderUser : queryOrderUser) {
System.out.println(orderUser);
}
}

 

5.效果：

 

 

 

方法二：使用resultMap

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

1.改造pojo类

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

private User user;

 

2.在Mapper.xml中添加：

<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:order里面的user属性名 -->

<!-- javaType：属性类型 -->

<association property="user" javaType="User">

<!-- id：声明主键，表示user_id是关联查询对象的唯一标识 -->

<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

orders o

LEFT JOIN user u ON o.user_id = u.id

</select>

 

3.在UserMapper编写接口

/*

* 一对一关联，查询订单同时包含用户信息

*/

public List<OrderUser> queryOrderUser();

 

4.测试

@Test

public void TestqueryOrderUserResultMap(){

//获取sqlSession

SqlSession sqlsession = this.factory.openSession();

//获取mapper

OrderMapper mapper = sqlsession.getMapper(OrderMapper.class);

 

List<Order> list = mapper.queryOrderUserResultMap();

for (Order order : list) {

System.out.println(order);

}

}

效果：