Mybatis 注解开发

朱雀 2021-06-10 20:37 632阅读 0赞

这几年来注解开发越来越流行，Mybatis 也可以使用注解开发方式，这样我们就可以减少编写 Mapper 映射 文件了。本次我们先围绕一些基本的 CRUD 来学习，再学习复杂映射关系及延迟加载。

3.1 mybatis 的常用注解说明

  1. @Insert:实现新增 
  2. @Update:实现更新 
  3. @Delete:实现删除 
  4. @Select:实现查询 
  5. @Result:实现结果集封装 
  6. @Results:可以与@Result 一起使用，封装多个结果集 
  7. @ResultMap:实现引用@Results 定义的封装 
  8. @One:实现一对一结果集封装 
  9. @Many:实现一对多结果集封装 
  10. @SelectProvider: 实现动态 SQL 映射 
  11. @CacheNamespace:实现注解二级缓存的使用

3.2 使用 Mybatis 注解实现基本 CRUD

单表的 CRUD 操作是最基本的操作，前面我们的学习都是基于 Mybaits 的映射文件来实现的。

3.2.1 编写实体类

  1. package com.itheima.domain;
  3. import java.io.Serializable;
  4. import java.util.Date;
  6. /**
  7.  * @author 黑马程序员
  8.  * @Company http://www.ithiema.com
  9.  */
  10. public class User implements Serializable{
  12.     private Integer id;
  13.     private String username;
  14.     private String address;
  15.     private String sex;
  16.     private Date birthday;
  18.     public Integer getId() {
  19.         return id;
  20.     }
  22.     public void setId(Integer id) {
  23.         this.id = id;
  24.     }
  26.     public String getUsername() {
  27.         return username;
  28.     }
  30.     public void setUsername(String username) {
  31.         this.username = username;
  32.     }
  34.     public String getAddress() {
  35.         return address;
  36.     }
  38.     public void setAddress(String address) {
  39.         this.address = address;
  40.     }
  42.     public String getSex() {
  43.         return sex;
  44.     }
  46.     public void setSex(String sex) {
  47.         this.sex = sex;
  48.     }
  50.     public Date getBirthday() {
  51.         return birthday;
  52.     }
  54.     public void setBirthday(Date birthday) {
  55.         this.birthday = birthday;
  56.     }
  58.     @Override
  59.     public String toString() {
  60.         return "User{" +
  61.                 "id=" + id +
  62.                 ", username='" + username + '\'' +
  63.                 ", address='" + address + '\'' +
  64.                 ", sex='" + sex + '\'' +
  65.                 ", birthday=" + birthday +
  66.                 '}';
  67.     }
  68. }

注意： 此处我们故意和数据库表的列名不一致。

3.2.2 使用注解方式开发持久层接口

3.2.2 使用注解方式开发持久层接口

format_png

完整的DAO类

  1. public interface IUserDao {
  3.     /**
  4.      * 查询所有用户
  5.      * @return
  6.      */
  7.     @Select("select * from user")
  8.     List<User> findAll();
  10.     /**
  11.      * 保存用户
  12.      * @param user
  13.      */
  14.     @Insert("insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})")
  15.     void saveUser(User user);
  17.     /**
  18.      * 更新用户
  19.      * @param user
  20.      */
  21.     @Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
  22.     void updateUser(User user);
  24.     /**
  25.      * 删除用户
  26.      * @param userId
  27.      */
  28.     @Delete("delete from user where id=#{id} ")
  29.     void deleteUser(Integer userId);
  31.     /**
  32.      * 根据id查询用户
  33.      * @param userId
  34.      * @return
  35.      */
  36.     @Select("select * from user  where id=#{id} ")
  37.     User findById(Integer userId);
  39.     /**
  40.      * 根据用户名称模糊查询
  41.      * @param username
  42.      * @return
  43.      */
  44. //    @Select("select * from user where username like #{username} ")
  45.     @Select("select * from user where username like '%${value}%' ")
  46.     List<User> findUserByName(String username);
  48.     /**
  49.      * 查询总用户数量
  50.      * @return
  51.      */
  52.     @Select("select count(*) from user ")
  53.     int findTotalUser();
  54. }

3.2.3 编写 SqlMapConfig 配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <!-- 引入外部配置文件-->
  7.     <properties resource="jdbcConfig.properties"></properties>
  8.     <!--配置别名-->
  9.     <typeAliases>
  10.         <package name="com.itheima.domain"></package>
  11.     </typeAliases>
  12.     <!-- 配置环境-->
  13.     <environments default="mysql">
  14.         <environment id="mysql">
  15.             <transactionManager type="JDBC"></transactionManager>
  16.             <dataSource type="POOLED">
  17.                 <property name="driver" value="${jdbc.driver}"></property>
  18.                 <property name="url" value="${jdbc.url}"></property>
  19.                 <property name="username" value="${jdbc.username}"></property>
  20.                 <property name="password" value="${jdbc.password}"></property>
  21.             </dataSource>
  22.         </environment>
  23.     </environments>
  24.     <!-- 指定带有注解的dao接口所在位置 -->
  25.     <mappers>
  26.         <mapper class="com.itheima.dao.IUserDao"></mapper>
  27.     </mappers>
  28. </configuration>

format_png 1

3.2.4 编写测试方法

  1. @Test
  2.     public void testSave(){
  3.         User user = new User();
  4.         user.setUsername("mybatis annotation");
  5.         user.setAddress("北京市昌平区");
  7.         userDao.saveUser(user);
  8.     }
  10.     @Test
  11.     public void testUpdate(){
  12.         User user = new User();
  13.         user.setId(57);
  14.         user.setUsername("mybatis annotation update");
  15.         user.setAddress("北京市海淀区");
  16.         user.setSex("男");
  17.         user.setBirthday(new Date());
  19.         userDao.updateUser(user);
  20.     }
  23.     @Test
  24.     public void testDelete(){
  25.         userDao.deleteUser(51);
  26.     }
  28.     @Test
  29.     public void testFindOne(){
  30.         User user = userDao.findById(57);
  31.         System.out.println(user);
  32.     }
  35.     @Test
  36.     public  void testFindByName(){
  37. //        List<User> users = userDao.findUserByName("%mybatis%");
  38.         List<User> users = userDao.findUserByName("mybatis");
  39.         for(User user : users){
  40.             System.out.println(user);
  41.         }
  42.     }
  44.     @Test
  45.     public  void testFindTotal(){
  46.         int total = userDao.findTotalUser();
  47.         System.out.println(total);
  48.     }

3.3 使用注解实现复杂关系映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置来实现，在使用注解开发时我们需要借 助@Results 注解，@Result 注解，@One 注解，@Many 注解。

3.3.1 复杂关系映射的注解说明

  1. @Results 注解 代替的是标签<resultMap>  该注解中可以使用单个@Result 注解，也可以使用@Result 集合 @Results（{@Result（），@Result（）}）或@Results（@Result（）） 
  3. @Resutl 注解 代替了 <id>标签和<result>标签  
  4. @Result 中 属性介绍：  
  5.  id 是否是主键字段  column 数据库的列名  property 需要装配的属性名  one  需要使用的@One 注解（@Result（one=@One）（）））  many  需要使用的@Many 注解（@Result（many=@many）（））） 
  7. @One 注解（一对一）  代替了<assocation>标签，是多表查询的关键，
  8. 在注解中用来指定子查询返回单一对象。 
  9. @One 注解属性介绍：  select  指定用来多表查询的 sqlmapper  fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。。 使用格式：  @Result(column=" ",property="",one=@One(select="")) 
  11. @Many 注解（多对一）       代替了<Collection>标签,是是多表查询的关键，
  12. 在注解中用来指定子查询返回对象集合。  
  13. 注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，
  14. 属性的 javaType （一般为 ArrayList）但是注解中可以不定义；  
  15. 使用格式：   @Result(property="",column="",many=@Many(select=""))

3.3.2 使用注解实现一对一复杂关系映射及延迟加载

需求： 加载账户信息时并且加载该账户的用户信息，根据情况可实现延迟加载。（注解方式实现）

3.3.2.1 添加 User 实体类及 Account 实体类

  1. public class User implements Serializable{
  3.     private Integer userId;
  4.     private String userName;
  5.     private String userAddress;
  6.     private String userSex;
  7.     private Date userBirthday;
  9.     //一对多关系映射：一个用户对应多个账户
  10.     private List<Account> accounts;
  12.     public List<Account> getAccounts() {
  13.         return accounts;
  14.     }
  16.     public void setAccounts(List<Account> accounts) {
  17.         this.accounts = accounts;
  18.     }
  20.     public Integer getUserId() {
  21.         return userId;
  22.     }
  24.     public void setUserId(Integer userId) {
  25.         this.userId = userId;
  26.     }
  28.     public String getUserName() {
  29.         return userName;
  30.     }
  32.     public void setUserName(String userName) {
  33.         this.userName = userName;
  34.     }
  36.     public String getUserAddress() {
  37.         return userAddress;
  38.     }
  40.     public void setUserAddress(String userAddress) {
  41.         this.userAddress = userAddress;
  42.     }
  44.     public String getUserSex() {
  45.         return userSex;
  46.     }
  48.     public void setUserSex(String userSex) {
  49.         this.userSex = userSex;
  50.     }
  52.     public Date getUserBirthday() {
  53.         return userBirthday;
  54.     }
  56.     public void setUserBirthday(Date userBirthday) {
  57.         this.userBirthday = userBirthday;
  58.     }
  60.     @Override
  61.     public String toString() {
  62.         return "User{" +
  63.                 "userId=" + userId +
  64.                 ", userName='" + userName + '\'' +
  65.                 ", userAddress='" + userAddress + '\'' +
  66.                 ", userSex='" + userSex + '\'' +
  67.                 ", userBirthday=" + userBirthday +
  68.                 '}';
  69.     }
  70. }
  74. public class Account implements Serializable {
  76.     private Integer id;
  77.     private Integer uid;
  78.     private Double money;
  80.     //多对一（mybatis中称之为一对一）的映射：一个账户只能属于一个用户
  81.     private User user;
  83.     public User getUser() {
  84.         return user;
  85.     }
  87.     public void setUser(User user) {
  88.         this.user = user;
  89.     }
  91.     public Integer getId() {
  92.         return id;
  93.     }
  95.     public void setId(Integer id) {
  96.         this.id = id;
  97.     }
  99.     public Integer getUid() {
  100.         return uid;
  101.     }
  103.     public void setUid(Integer uid) {
  104.         this.uid = uid;
  105.     }
  107.     public Double getMoney() {
  108.         return money;
  109.     }
  111.     public void setMoney(Double money) {
  112.         this.money = money;
  113.     }
  115.     @Override
  116.     public String toString() {
  117.         return "Account{" +
  118.                 "id=" + id +
  119.                 ", uid=" + uid +
  120.                 ", money=" + money +
  121.                 '}';
  122.     }
  123. }

3.3.2.2 添加账户的持久层接口并使用注解配置

  1. public interface IAccountDao {
  3.     /**
  4.      * 查询所有账户，并且获取每个账户所属的用户信息
  5.      * @return
  6.      */
  7.     @Select("select * from account")
  8.     @Results(id="accountMap",value = {
  9.             @Result(id=true,column = "id",property = "id"),
  10.             @Result(column = "uid",property = "uid"),
  11.             @Result(column = "money",property = "money"),
  12.             @Result(property = "user",column = "uid",one=@One(select="com.itheima.dao.IUserDao.findById",fetchType= FetchType.EAGER))
  13.     })
  14.     List<Account> findAll();
  16.     /**
  17.      * 根据用户id查询账户信息
  18.      * @param userId
  19.      * @return
  20.      */
  21.     @Select("select * from account where uid = #{userId}")
  22.     List<Account> findAccountByUid(Integer userId);
  23. }

3.3.2.3 添加用户的持久层接口并使用注解配置

  1. @CacheNamespace(blocking = true)
  2. public interface IUserDao {
  4.     /**
  5.      * 查询所有用户
  6.      * @return
  7.      */
  8.     @Select("select * from user")
  9.     @Results(id="userMap",value={
  10.             @Result(id=true,column = "id",property = "userId"),
  11.             @Result(column = "username",property = "userName"),
  12.             @Result(column = "address",property = "userAddress"),
  13.             @Result(column = "sex",property = "userSex"),
  14.             @Result(column = "birthday",property = "userBirthday"),
  15.             @Result(property = "accounts",column = "id",
  16.                     many = @Many(select = "com.itheima.dao.IAccountDao.findAccountByUid",
  17.                                 fetchType = FetchType.LAZY))
  18.     })
  19.     List<User> findAll();
  21.     /**
  22.      * 根据id查询用户
  23.      * @param userId
  24.      * @return
  25.      */
  26.     @Select("select * from user  where id=#{id} ")
  27.     @ResultMap("userMap")
  28.     User findById(Integer userId);
  30.     /**
  31.      * 根据用户名称模糊查询
  32.      * @param username
  33.      * @return
  34.      */
  35.     @Select("select * from user where username like #{username} ")
  36.     @ResultMap("userMap")
  37.     List<User> findUserByName(String username);
  40. }

3.3.2.4 测试一对一关联及延迟加载

  1. @Test
  2. public  void  testFindAll(){
  3.     List<Account> accounts = accountDao.findAll();
  4. /*
  5.     for(Account account : accounts){
  6.         System.out.println("----每个账户的信息-----");
  7.         System.out.println(account);
  8.         System.out.println(account.getUser());
  9.     }
  10. */
  11. }

3.3.3 使用注解实现一对多复杂关系映射

需求： 查询用户信息时，也要查询他的账户列表。使用注解方式实现。 分析： 一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。

3.3.3.1 User 实体类加入 List

  1. //一对多关系映射：一个用户对应多个账户
  2.     private List<Account> accounts;
  4.     public List<Account> getAccounts() {
  5.         return accounts;
  6.     }
  8.     public void setAccounts(List<Account> accounts) {
  9.         this.accounts = accounts;
  10.     }

3.3.3.2 编写用户的持久层接口并使用注解配置

  1. @CacheNamespace(blocking = true)
  2. public interface IUserDao {
  4.     /**
  5.      * 查询所有用户
  6.      * @return
  7.      */
  8.     @Select("select * from user")
  9.     @Results(id="userMap",value={
  10.             @Result(id=true,column = "id",property = "userId"),
  11.             @Result(column = "username",property = "userName"),
  12.             @Result(column = "address",property = "userAddress"),
  13.             @Result(column = "sex",property = "userSex"),
  14.             @Result(column = "birthday",property = "userBirthday"),
  15.             @Result(property = "accounts",column = "id",
  16.                     many = @Many(select = "com.itheima.dao.IAccountDao.findAccountByUid",
  17.                                 fetchType = FetchType.LAZY))
  18.     })
  19.     List<User> findAll();
  21.     /**
  22.      * 根据id查询用户
  23.      * @param userId
  24.      * @return
  25.      */
  26.     @Select("select * from user  where id=#{id} ")
  27.     @ResultMap("userMap")
  28.     User findById(Integer userId);
  30.     /**
  31.      * 根据用户名称模糊查询
  32.      * @param username
  33.      * @return
  34.      */
  35.     @Select("select * from user where username like #{username} ")
  36.     @ResultMap("userMap")
  37.     List<User> findUserByName(String username);
  40. }
  44. @Many: 
  45.  相当于<collection>的配置  select 属性：代表将要执行的 sql 语句  
  46. fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值

3.3.3.3 编写账户的持久层接口并使用注解配置

  1. /**
  2.      * 根据用户id查询账户信息
  3.      * @param userId
  4.      * @return
  5.      */
  6.     @Select("select * from account where uid = #{userId}")
  7.     List<Account> findAccountByUid(Integer userId);

3.3.3.4 添加测试方法

  1. /** 
  2.   * 测试查询所有   */  
  3. @Test  public void testFindAll() {   
  4. List<User> users = userDao.findAll(); // 
  5.  for(User user : users) { 
  6.    System.out.println("-----每个用户的内容-----"); 
  7.    System.out.println(user); //   
  8. System.out.println(user.getAccounts()); //  }  
  9. }

3.4 mybatis 基于注解的二级缓存

3.4.1 在 SqlMapConfig 中开启二级缓存支持

  1. <!-- 配置二级缓存 --> 
  2. <settings> 
  3.  <!-- 开启二级缓存的支持 --> 
  4.  <setting name="cacheEnabled" value="true"/> 
  5. </settings>

3.4.2 在持久层接口中使用注解配置二级缓存

format_png 2

发表评论

表情：
评论列表 （有 0 条评论，632人围观）

还没有评论，来说两句吧...

相关阅读

    相关 MyBatis之注解开发

    除了XML映射方式，MyBatis还支持注解方式实现POJO对象和数据表之间的关联映射，使用注解的方式一般将SQL语句直接写到接口上。与XML的映射方式相比，基于注解的映射方式

    ゝ一纸荒年。ゝ一纸荒年。/ 0 赞/ 132 阅读

    相关 Mybatis 注解开发

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

    朱雀朱雀/ 0 赞/ 633 阅读