1. Mybatis多表查询

1.1 一对一查询

一对一查询的模型

用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户

一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户

orders	user
id:int	id:int
ordertime:varchar(255)	username:varchar(50)
total:double	password:varchar(50)
uid:int	birthday:varchar(50)

一对一查询的语句

对应的sql语句：select * from orders o,user u where o.uid=u.id

创建Order和User实体

public class Order {
    private int id;
    private Date ordertime;
    private double total;
    //代表当前订单从属于哪一个客户
    private User user;
}

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;
}

创建OrderMapper接口

1
2
3

public interface OrderMapper {
	List<Order> findAll();
}

配置OrderMapper.xml

<mapper namespace="cn.jyw.mapper.OrderMapper">
    <resultMap id="orderMap" type="cn.jyw.pojo.Order">
        <result column="uid" property="user.id"/>
        <result column="username" property="user.username"/>
        <result column="password" property="user.password"/>
        <result column="birthday" property="user.birthday"/>
    </resultMap>
    <select id="findAll" resultMap="orderMap">
        select * from orders o,user u where o.uid=u.id
    </select>
</mapper>

其中<resultMap>还可以配置如下

<resultMap id="orderMap" type="cn.jyw.pojo.Order">
    <result property="id" column="id"/>
    <result property="ordertime" column="ordertime"/>
    <result property="total" column="total"/>
    <association property="user" javaType="cn.jyw.pojo.User">
        <result column="uid" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="birthday" property="birthday"/>
    </association>
</resultMap>

测试结果

OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
List<Order> all = mapper.findAll();
for(Order order : all){
	System.out.println(order);
}

1.2 一对多查询

一对多查询的模型

用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户

一对多查询的需求：查询一个用户，与此同时查询出该用户具有的订单

一对多查询的语句

对应的sql语句：select * from user u left join orders o on u.id=o.uid;

修改User实体

public class Order {
    private int id;
    private Date ordertime;
    private double total;
    //代表当前订单从属于哪一个客户
    private User user;
}

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;
    //代表当前用户具备哪些订单
    private List<Order> orderList;
}

创建UserMapper接口

1
2
3

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

配置UserMapper.xml

<mapper namespace="cn.jyw.pojo.UserMapper">
    <resultMap id="userMap" type="cn.jyw.pojo.User">
        <result column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="birthday" property="birthday"/>
        <collection property="orderList" ofType="cn.jyw.pojo.Order">
            <result column="ordertime" property="ordertime"/>
            <result column="total" property="total"/>
        </collection>
    </resultMap>
    <select id="findAll" resultMap="userMap">
    	select * from user u left join orders o on u.id=o.uid
    </select>
</mapper>

测试结果

UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> all = mapper.findAll();
for(User user : all){
    System.out.println(user.getUsername());
    List<Order> orderList = user.getOrderList();
    for(Order order : orderList){
    	System.out.println(order);
    }
    System.out.println("----------------------------------");
}

1.3 多对多查询

多对多查询的模型

用户表和角色表的关系为，一个用户有多个角色

一个角色被多个用户使用

多对多查询的需求：查询用户同时查询出该用户的所有角色

user	user_role	role
id:int	user_id:int	id:int
username:varchar(50)	role_id:int	rolename:varchar(255)
password:varchar(50)
birthday:varchar(50)

多对多查询的语句

对应的sql语句：select u.* ,r.* ,r.id rid from user u left join user_role ur on u.id=ur.user_id inner join role r on ur.role_id=r.id

创建Role实体，修改User实体

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;
    //代表当前用户具备哪些订单
    private List<Order> orderList;
    //代表当前用户具备哪些角色
    private List<Role> roleList;
}

public class Role {
    private int id;
    private String rolename;
}

添加UserMapper接口方法

1	List<User> findAllUserAndRole();

配置UserMapper.xml

<resultMap id="userRoleMap" type="cn.jyw.pojo.User">
    <result column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="password" property="password"/>
    <result column="birthday" property="birthday"/>
    <collection property="roleList" ofType="cn.jyw.pojo.Role">
        <result column="rid" property="id"/>
        <result column="rolename" property="rolename"/>
    </collection>
</resultMap>
<select id="findAllUserAndRole" resultMap="userRoleMap">
    select u.*,r.*,r.id rid from user u left join user_role ur on 
u.id=ur.user_id
    inner join role r on ur.role_id=r.id
</select>

测试结果

UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> all = mapper.findAllUserAndRole();
for(User user : all){
    System.out.println(user.getUsername());
    List<Role> roleList = user.getRoleList();
    for(Role role : roleList){
    	System.out.println(role);
    }
    System.out.println("----------------------------------");
}

1.4 MyBatis多表配置方式小结

一对一配置：使用<resultMap>做配置
一对多配置：使用<resultMap>+<collection>做配置
多对多配置：使用<resultMap>+<collection>做配置

2. MyBatis注解开发

2.1 MyBatis的常用注解

@Insert：实现新增
@Update：实现更新
@Delete：实现删除
@Select：实现查询
@Result：实现结果集封装
@Results：可以与@Result 一起使用，封装多个结果集
@One：实现一对一结果集封装
@Many：实现一对多结果集封装

2.2 MyBatis的增删改查

@Insert("insert into user values(#{id},#{username},#{password},#{birthday})")
public void save(User user);

@Update("update user set username=#{username},password=#{password} where id=#{id}")
public void update(User user);

@Delete("delete from user where id=#{id}")
public void delete(int id);

@Select("select * from user where id=#{id}")
public User findById(int id);

@Select("select * from user")
public List<User> findAll();

修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可

<mappers>
    <!--扫描使用注解的类-->
    <mapper class="cn.jyw.mapper.UserMapper"></mapper>
</mappers>

或者指定扫描包含映射关系的接口所在的包也可以

<!--加载映射关系-->
<mappers>
    <!--指定接口所在的包-->
    <package name="cn.jyw.mapper"></package>
</mappers>

2.3 MyBatis的注解实现复杂映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置来实现

使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置

注解	说明
@Results	代替的是`<resultMap>`标签该注解中可以使用单个@Result注解，也可以使用@Result集合使用格式：@Results（{@Result（），@Result（）}）或@Results（@Result（））
@Resut	代替了`<id>`标签和`<result>`标签 @Result中属性介绍： column：数据库的列名 property：需要装配的属性名 one：需要使用的@One 注解（@Result（one=@One）（））） many：需要使用的@Many 注解（@Result（many=@many）（）））
@One （一对一）	代替了`<assocation>`标签，是多表查询的关键，在注解中用来指定子查询返回单一对象 @One注解属性介绍： select: 指定用来多表查询的 sqlmapper 使用格式：@Result(column=” “,property=””,one=@One(select=””))
@Many （多对一）	代替了`<collection>`标签, 是是多表查询的关键，在注解中用来指定子查询返回对象集合使用格式：@Result(property=””,column=””,many=@Many(select=””))

2.4 一对一查询

@Select("select *,o.id oid from orders o,user u where o.uid=u.id")
    @Results({
            @Result(column = "oid",property = "id"),
            @Result(column = "ordertime",property = "ordertime"),
            @Result(column = "total",property = "total"),
            @Result(column = "uid",property = "user.id"),
            @Result(column = "username",property = "user.username"),
            @Result(column = "password",property = "user.password")
    })
    public List<Order> findAll();

或者

@Select("select * from orders")
   @Results({
           @Result(column = "id",property = "id"),
           @Result(column = "ordertime",property = "ordertime"),
           @Result(column = "total",property = "total"),
           @Result(
                   property = "user", //要封装的属性名称
                   column = "uid", //根据那个字段去查询user表的数据
                   javaType = User.class, /a/要封装的实体类型
                   //select属性 代表查询那个接口的方法获得数据
                   one = @One(select = "cn.jyw.mapper.UserMapper.findById")
           )
   })
   public List<Order> findAll();

2.5 一对多查询

@Select("select * from user")
@Results({
        @Result(id=true ,column = "id",property = "id"),
        @Result(column = "username",property = "username"),
        @Result(column = "password",property = "password"),
        @Result(
                property = "orderList",
                column = "id",
                javaType = List.class,
                many = @Many(select = "cn.jyw.mapper.OrderMapper.findByUid")
        )
})
public List<User> findUserAndOrderAll();

public interface OrderMapper {
    @Select("select * from orders where uid=#{uid}")
    List<Order> findByUid(int uid);
}

2.6 多对多查询

@Select("SELECT * FROM USER")
   @Results({
           @Result(id = true,column = "id",property = "id"),
           @Result(column = "username",property = "username"),
           @Result(column = "password",property = "password"),
           @Result(
                   property = "roleList",
                   column = "id",
                   javaType = List.class,
                   many = @Many(select = "cn.jyw.mapper.RoleMapper.findByUid")
           )
   })
   public List<User> findUserAndRoleAll();

public interface RoleMapper {
    @Select("select * from role r,user_role ur where r.id=ur.role_id and ur.user_id=#{uid}")
    List<Role> findByUid(int uid);
}