Mybatis注解开发(基本使用、一对一、一对多、多对多)

这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了。

一、简介

1.1 常用注解

先简单认识下Mybatis的常用注解，如下：

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

1.2 核心配置文件

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

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

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

<mappers>    
	<!--扫描使用注解的类所在的包-->    
	<package name="com.happy.mapper"></package>
</mappers>

1.3 复杂映射

实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置

二、基本使用

2.1 创建UserMapper接口

创建UserMapper接口，提供增删改查方法，如下：

@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();

2.2 加载映射关系

根据上文介绍，在sqlMapConfig.xml中加载映射关系，如下：

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

2.3 测试

编写单元测试，如下：

private UserMapper mapper;

@Before
public void before() throws IOException {
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    mapper = sqlSession.getMapper(UserMapper.class);
}


@Test
public void testSave(){
    User user = new User();
    user.setUsername("tom");
    user.setPassword("abc");
    mapper.save(user);
}

@Test
public void testUpdate(){
    User user = new User();
    user.setId(18);
    user.setUsername("lucy");
    user.setPassword("123");
    mapper.update(user);
}

@Test
public void testDelete(){
    mapper.delete(18);
}

@Test
public void testFindById(){
    User user = mapper.findById(2);
    System.out.println(user);
}

@Test
public void testFindAll(){
    List<User> all = mapper.findAll();
    for (User user : all) {
        System.out.println(user);
    }
}

三、一对一查询

3.1 模型

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

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

3.2 语句

对应的sql语句：
select * from orders;
select * from user where id=查询出订单的uid;

查询的结果如下：

3.3 创建Order和User实体类

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

public class User {        
	private int id;    
	private String username;    
	private String password;    
	private Date birthday;
	// 省略get set方法
}

3.4 创建OrderMapper接口

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

3.5 使用注解配置Mapper

创建UserMapper接口，提供findById方法，如下：

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

在OrderMapper中通过注解获取数据：

@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, //要封装的实体类型
                //select属性 代表查询那个接口的方法获得数据
                one = @One(select = "com.happy.mapper.UserMapper.findById")
        )
})
public List<Order> findAll();

这里使用到了@one注解，表明是一对一关系，关系图如下：

3.6 测试

执行如下测试代码：

private OrderMapper mapper;

@Before
public void before() throws IOException {
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    mapper = sqlSession.getMapper(OrderMapper.class);
}


@Test
public void testSave(){
    List<Order> all = mapper.findAll();
    for (Order order : all) {
        System.out.println(order);
    }
}

输出结果为：

四、一对多

4.1 模型

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

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

4.2 语句

对应的sql语句：
select * from user;
select * from orders where uid=查询出用户的id;

查询的结果如下：

4.3 创建User和Order实体类

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

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

4.4 创建UserMapper接口

List<User> findAllUserAndOrder();

4.5 使用注解配置Mapper

创建OrderMapper接口，提供findByUid接口，如下：

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

UserMapper中findUserAndOrderAll方法配置如下：

@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 = "com.happy.mapper.OrderMapper.findByUid")
        )
})
public List<User> findUserAndOrderAll();

此处使用@Many注解，表明是一对多关系，关系图如下：

4.6 测试

执行如下测试代码：

List<User> all = userMapper.findAllUserAndOrder();
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("-----------------------------");}

结果如下：

五、多对多查询

5.1 模型

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

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

5.2 语句

对应的sql语句：
select * from user;
select * from role r,user_role ur where r.id=ur.role_id and ur.user_id=用户的id

查询的结果如下

5.3 创建Role实体类，修改User实体类

public class Role {    
	private int id;    
	private String rolename;
	// 省略get set方法
}

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

5.4 UserMapper添加方法

List<User> findAllUserAndRole();

5.5 使用注解配置Mapper

创建RoleMapper，提供findByUid方法，如下：

public interface RoleMapper {
    @Select("SELECT * FROM sys_user_role ur,sys_role r WHERE ur.roleId=r.id AND ur.userId=#{uid}")
    public List<Role> findByUid(int uid);
}

UserMapper中findUserAndRoleAll配置如下：

@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 = "com.happy.mapper.RoleMapper.findByUid")
        )
})
public List<User> findUserAndRoleAll();

此处使用了@Many，表明是多对多，关系图如下：

5.6 测试

执行测试代码，如下：

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("----------------------------------");}

输出结果为：

六、小结

• 认识Mybatis常用注解
• 通过注解完成CRUD基本操作
• 通过注解完成一对一、y