跨境互联网
Revin
2023-07-23
目录

Mybatis注解开发

# 6.1 MyBatis的常用注解

这几年来注解开发越来越流行,Mybatis也可以使用注解开发方式,这样我们就可以减少编写Mapper映射文件了。我们先围绕一些基本的CRUD来学习,再学习复杂映射多表操作。

@Insert:实现新增

@Update:实现更新

@Delete:实现删除

@Select:实现查询

@Result:实现结果集封装

@Results:可以与@Result 一起使用,封装多个结果集

@One:实现一对一结果集封装

@Many:实现一对多结果集封装

# 6.2 MyBatis的增删改查

我们完成简单的user表的增删改查的操作

private UserMapper userMapper;


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


@Test
public void testAdd() {
   User user = new User();
   user.setUsername("测试数据");
   user.setPassword("123");
   user.setBirthday(new Date());
   userMapper.add(user);
}


@Test
public void testUpdate() throws IOException {
   User user = new User();
   user.setId(16);
   user.setUsername("测试数据修改");
   user.setPassword("abc");
   user.setBirthday(new Date());
   userMapper.update(user);
}


@Test
public void testDelete() throws IOException {
   userMapper.delete(16);
}


@Test
public void testFindById() throws IOException {
   User user = userMapper.findById(1);
   System.out.println(user);
}


@Test
public void testFindAll() throws IOException {
   List<User> all = userMapper.findAll();
   for(User user : all){
       System.out.println(user);
 
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

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

<mappers>
   <!--扫描使用注解的类-->
   <mapper class="com.lagou.mapper.UserMapper"></mapper>
</mappers>
1
2
3
4

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

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

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

实现复杂关系映射之前我们可以在映射文件中通过配置来实现,使用注解开发后,我们可以使用

@Results注解,@Result注解,@One注解,@Many注解组合完成复杂关系的配置

Mybatis_Page35_001

Mybatis_Page35_002

# 6.4 一对一查询

# 6.4.1 一对一查询的模型

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

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

Mybatis_Page35_003

# 6.4.2 一对一查询的语句

对应的sql语句:

select * from orders;


select * from user where id=查询出订单的uid;
1
2
3
4

查询的结果如下:

Mybatis_Page35_004

# 6.4.3 创建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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 6.4.4 创建OrderMapper接口

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

# 6.4.5 使用注解配置Mapper

public interface OrderMapper {
   @Select("select * from orders")
   @Results({
           @Result(id=true,property = "id",column = "id"),
           @Result(property = "ordertime",column = "ordertime"),
           @Result(property = "total",column = "total"),
           @Result(property = "user",column = "uid",
                   javaType = User.class,
                   one = @One(select = "com.lagou.mapper.UserMapper.findById"))
 
  })
   List<Order> findAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public interface UserMapper {
   @Select("select * from user where id=#{id}")
   User findById(int id);
   
}
1
2
3
4
5

# 6.4.6 测试结果

@Test
public void testSelectOrderAndUser() {
   List<Order> all = orderMapper.findAll();
   for(Order order : all){
       System.out.println(order);
 
  }
}
1
2
3
4
5
6
7
8

Mybatis_Page37_001

# 6.5 一对多查询

# 6.5.1 一对多查询的模型

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

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

Mybatis_Page37_002

# 6.5.2 一对多查询的语句

对应的sql语句:

select * from user;
select * from orders where uid=查询出用户的id;
1
2

查询的结果如下:

Mybatis_Page37_003

# 6.5.3 修改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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 6.5.4 创建UserMapper接口

List<User> findAllUserAndOrder();
1

# 6.5.5 使用注解配置Mapper

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


public interface OrderMapper {
   @Select("select * from orders where uid=#{uid}")
   List<Order> findByUid(int uid);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 6.5.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("-----------------------------");
}
1
2
3
4
5
6
7
8
9

Mybatis_Page39_001

# 6.6 多对多查询

# 6.6.1 多对多查询的模型

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

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

Mybatis_Page39_002

# 6.6.2 多对多查询的语句

对应的sql语句:

select * from user;


select * from role r,user_role ur where r.id=ur.role_id and ur.user_id=用户的id
1
2
3
4

查询的结果如下:

Mybatis_Page39_003

# 6.6.3 创建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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 6.6.4 添加UserMapper接口方法

List<User> findAllUserAndRole();
1

# 6.6.5 使用注解配置Mapper

public interface UserMapper {
   @Select("select * from user")
   @Results({
       @Result(id = true,property = "id",column = "id"),
       @Result(property = "username",column = "username"),
       @Result(property = "password",column = "password"),
       @Result(property = "birthday",column = "birthday"),
       @Result(property = "roleList",column = "id",
               javaType = List.class,
               many = @Many(select = "com.lagou.mapper.RoleMapper.findByUid"))
})
List<User> findAllUserAndRole();}
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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 6.6.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("----------------------------------");
}
1
2
3
4
5
6
7
8
9
10
11

Mybatis_Page41_001

上次更新: 2025/04/03, 11:07:08
Mybatis复杂映射开发
Mybatis缓存

← Mybatis缓存→

最近更新
01
tailwindcss
03-26
02
PaddleSpeech
02-18
03
whisper
02-18
更多文章>
Theme by Vdoing | Copyright © 2019-2025 跨境互联网 | 豫ICP备14016603号-5 | 豫公网安备41090002410995号