一、Mybatis 常用注解
这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了
- @Insert：实现新增
- @Update：实现更新
- @Delete：实现删除
- @Select：实现查询
- @Result：实现结果集封装
- @Results：可以与@Result ⼀起使用，封装多个结果集
- @One：实现⼀对⼀结果集封装
- @Many：实现⼀对多结果集封装
二、MyBatis 基于注解方式的增删改查
- mapper 接口编写
public interface UserMapper {
List<User> findAll();
@Insert("insert into user values(#{id},#{username})")
void insert(User user);
@Update("update user set username = #{username} where id = #{id}")
void update(User user);
@Select("select * from user")
List<User> selectList();
@Delete("delete from user where id = #{id}")
void deleteById(Integer id);
}
- 测试类编写
package com.wujun.test;
import com.wujun.mapper.UserMapper;
import com.wujun.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MybatisTest {
private UserMapper userMapper;
private SqlSession sqlSession;
@Before
public void before() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
sqlSession = sqlSessionFactory.openSession();
userMapper = sqlSession.getMapper(UserMapper.class);
}
@After
public void after() {
sqlSession.close();
}
@Test
public void insert() throws IOException {
User insert = new User();
insert.setId(99);
insert.setUsername("吴俊99");
userMapper.insert(insert);
sqlSession.commit();
System.out.println("新增之后=======");
List<User> users = userMapper.selectList();
for (User user : users) {
System.out.println(user);
}
}
@Test
public void update() {
User update = new User();
update.setId(99);
update.setUsername("吴俊00");
userMapper.update(update);
sqlSession.commit();
System.out.println("更新之后=======");
List<User> users2 = userMapper.selectList();
for (User user : users2) {
System.out.println(user);
}
}
@Test
public void delete() {
userMapper.deleteById(99);
sqlSession.commit();
System.out.println("删除之后========");
List<User> users3 = userMapper.selectList();
for (User user : users3) {
System.out.println(user);
}
}
}
- 测试结果
删除之后========
User(id=1, username=吴俊1, roles=null)
User(id=2, username=吴俊2, roles=null)
User(id=3, username=吴俊3, roles=null)
新增之后=======
User(id=1, username=吴俊1, roles=null)
User(id=2, username=吴俊2, roles=null)
User(id=3, username=吴俊3, roles=null)
User(id=99, username=吴俊99, roles=null)
更新之后=======
User(id=1, username=吴俊1, roles=null)
User(id=2, username=吴俊2, roles=null)
User(id=3, username=吴俊3, roles=null)
User(id=99, username=吴俊00, roles=null)
三、Mybatis 基于注解实现复杂映射开发
| 注解 | 说明 |
|---|---|
| @Results | 代替的是标签<resultMap> 该注解中可以使用单个@Result注解，也可以使用@Result集合 使用格式：@Results ( { @Result(), @Result() } ) 或者 @Results (@Result()) |
| @Result | 代替了<id>标签和<result>标签 @Result中的属性介绍 column：数据库的列名 property：需要装配的属性名 one：需要使用@One注解 (@Result (one = @One) （）) many：需要使用@Many注解（@Result（many = @Many）（）） |
| @One（一对一） | 代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象 @One注解属性介绍 select：指定用来多表查询的sqlmapper 使用格式：@Result（property= "", column="", one=@One（select=""）） |
| @Many（多对一） | 代替了<collection>标签，是多表查询的关键，在注解中用来指定子查询返回的对象集合 使用格式：@Result（property="", column="", many=@Many（select=""）） |
1. 一对一查询
- javaBean：订单里面有一个User对象，对订单来说，一笔订单只可能有一个用户
@Data
public class User {
private Integer id;
private String username;
}
@Data
public class Order {
private Integer id;
private String orderName;
private User user;
}
- mapper接口
public interface OrderMapper {
@Select("select * from `order`") // 查询所有的订单
@Results({
@Result(id = true, property = "id", column = "id"), // 封装订单对象里面的id
@Result(property = "orderName", column = "order_name"), // 封装订单对象里面的orderName
// 以订单对象中的 user_id 为条件，执行com.wujun.mapper.UserMapper中的findById方法，传参就是user_id，
// 将返回结果封装到订单对象的user属性中
@Result(property = "user", column = "user_id", javaType = User.class,
one = @One(select = "com.wujun.mapper.UserMapper.findById"))
})
List<Order> findAll();
}
public interface UserMapper {
List<User> findAll();
@Insert("insert into user values(#{id},#{username})")
void insert(User user);
@Update("update user set username = #{username} where id = #{id}")
void update(User user);
@Select("select * from user")
List<User> selectList();
@Delete("delete from user where id = #{id}")
void deleteById(Integer id);
@Select("select * from `user` where id = #{id}")
User findById(Integer id);
}
- 测试类
@Test
public void findAllOrder() {
List<Order> all = orderMapper.findAll();
for (Order order : all) {
System.out.println(order);
}
}
- 测试结果
Order(id=1, orderName=订单1, user=User(id=1, username=吴俊1))
Order(id=2, orderName=订单2, user=User(id=2, username=吴俊2))
Order(id=3, orderName=订单3, user=User(id=1, username=吴俊1))
2. 一对多查询
- JavaBean：一个用户对应多张订单的场景
@Data
public class User {
private Integer id;
private String username;
private List<Order> orders;
}
@Data
public class Order {
private Integer id;
private String orderName;
}
- mapper 接口编写
public interface UserMapper {
@Select("select * from `user`")
@Results({
@Result(property = "id", column = "id"),
@Result(property = "username", column = "username"),
@Result(property = "orders", column = "id", javaType = List.class, many = @Many(select = "com.wujun.mapper.OrderMapper.findByUserId"))
})
List<User> findAll();
}
public interface OrderMapper {
@Select("select * from `order` where user_id = #{userId}")
@Results({
@Result(property = "id", column = "id"),
@Result(property = "orderName", column = "order_name")
})
List<Order> findByUserId(Integer userId);
}
- 测试类编写
@Test
public void oneToMany() {
List<User> all = userMapper.findAll();
for (User user : all) {
System.out.println(user);
}
}
- 测试结果
User(id=1, username=吴俊1, orders=[Order(id=1, orderName=订单1), Order(id=3, orderName=订单3)])
User(id=2, username=吴俊2, orders=[Order(id=2, orderName=订单2)])
User(id=3, username=吴俊3, orders=[])
User(id=99, username=吴俊00, orders=[])
