Mybatis 注解开发

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

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

**3.1 mybatis 的常用注解说明**

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

**3.2 使用 Mybatis 注解实现基本 CRUD**

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

**3.2.1 编写实体类**

package com.itheima.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    
    /**
     * @author 黑马程序员
     * @Company http://www.ithiema.com
     */
    public class User implements Serializable{
    
        private Integer id;
        private String username;
        private String address;
        private String sex;
        private Date birthday;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", address='" + address + '\'' +
                    ", sex='" + sex + '\'' +
                    ", birthday=" + birthday +
                    '}';
        }
    }

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

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

![format_png][]

完整的DAO类

public interface IUserDao {
    
        /**
         * 查询所有用户
         * @return
         */
        @Select("select * from user")
        List<User> findAll();
    
        /**
         * 保存用户
         * @param user
         */
        @Insert("insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})")
        void saveUser(User user);
    
        /**
         * 更新用户
         * @param user
         */
        @Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
        void updateUser(User user);
    
        /**
         * 删除用户
         * @param userId
         */
        @Delete("delete from user where id=#{id} ")
        void deleteUser(Integer userId);
    
        /**
         * 根据id查询用户
         * @param userId
         * @return
         */
        @Select("select * from user  where id=#{id} ")
        User findById(Integer userId);
    
        /**
         * 根据用户名称模糊查询
         * @param username
         * @return
         */
    //    @Select("select * from user where username like #{username} ")
        @Select("select * from user where username like '%${value}%' ")
        List<User> findUserByName(String username);
    
        /**
         * 查询总用户数量
         * @return
         */
        @Select("select count(*) from user ")
        int findTotalUser();
    }

**3.2.3 编写 SqlMapConfig 配置文件**

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <properties resource="jdbcConfig.properties"></properties>
        
        <typeAliases>
            <package name="com.itheima.domain"></package>
        </typeAliases>
        
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"></property>
                    <property name="url" value="${jdbc.url}"></property>
                    <property name="username" value="${jdbc.username}"></property>
                    <property name="password" value="${jdbc.password}"></property>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
            <mapper class="com.itheima.dao.IUserDao"></mapper>
        </mappers>
    </configuration>

![format_png 1][]

**3.2.4 编写测试方法**

@Test
        public void testSave(){
            User user = new User();
            user.setUsername("mybatis annotation");
            user.setAddress("北京市昌平区");
    
            userDao.saveUser(user);
        }
    
        @Test
        public void testUpdate(){
            User user = new User();
            user.setId(57);
            user.setUsername("mybatis annotation update");
            user.setAddress("北京市海淀区");
            user.setSex("男");
            user.setBirthday(new Date());
    
            userDao.updateUser(user);
        }
    
    
        @Test
        public void testDelete(){
            userDao.deleteUser(51);
        }
    
        @Test
        public void testFindOne(){
            User user = userDao.findById(57);
            System.out.println(user);
        }
    
    
        @Test
        public  void testFindByName(){
    //        List<User> users = userDao.findUserByName("%mybatis%");
            List<User> users = userDao.findUserByName("mybatis");
            for(User user : users){
                System.out.println(user);
            }
        }
    
        @Test
        public  void testFindTotal(){
            int total = userDao.findTotalUser();
            System.out.println(total);
        }

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

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

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

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

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

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

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

public class User implements Serializable{
    
        private Integer userId;
        private String userName;
        private String userAddress;
        private String userSex;
        private Date userBirthday;
    
        //一对多关系映射：一个用户对应多个账户
        private List<Account> accounts;
    
        public List<Account> getAccounts() {
            return accounts;
        }
    
        public void setAccounts(List<Account> accounts) {
            this.accounts = accounts;
        }
    
        public Integer getUserId() {
            return userId;
        }
    
        public void setUserId(Integer userId) {
            this.userId = userId;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getUserAddress() {
            return userAddress;
        }
    
        public void setUserAddress(String userAddress) {
            this.userAddress = userAddress;
        }
    
        public String getUserSex() {
            return userSex;
        }
    
        public void setUserSex(String userSex) {
            this.userSex = userSex;
        }
    
        public Date getUserBirthday() {
            return userBirthday;
        }
    
        public void setUserBirthday(Date userBirthday) {
            this.userBirthday = userBirthday;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "userId=" + userId +
                    ", userName='" + userName + '\'' +
                    ", userAddress='" + userAddress + '\'' +
                    ", userSex='" + userSex + '\'' +
                    ", userBirthday=" + userBirthday +
                    '}';
        }
    }

public class Account implements Serializable {
    
        private Integer id;
        private Integer uid;
        private Double money;
    
        //多对一（mybatis中称之为一对一）的映射：一个账户只能属于一个用户
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public Integer getUid() {
            return uid;
        }
    
        public void setUid(Integer uid) {
            this.uid = uid;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", uid=" + uid +
                    ", money=" + money +
                    '}';
        }
    }

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

public interface IAccountDao {
    
        /**
         * 查询所有账户，并且获取每个账户所属的用户信息
         * @return
         */
        @Select("select * from account")
        @Results(id="accountMap",value = {
                @Result(id=true,column = "id",property = "id"),
                @Result(column = "uid",property = "uid"),
                @Result(column = "money",property = "money"),
                @Result(property = "user",column = "uid",one=@One(select="com.itheima.dao.IUserDao.findById",fetchType= FetchType.EAGER))
        })
        List<Account> findAll();
    
        /**
         * 根据用户id查询账户信息
         * @param userId
         * @return
         */
        @Select("select * from account where uid = #{userId}")
        List<Account> findAccountByUid(Integer userId);
    }

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

@CacheNamespace(blocking = true)
    public interface IUserDao {
    
        /**
         * 查询所有用户
         * @return
         */
        @Select("select * from user")
        @Results(id="userMap",value={
                @Result(id=true,column = "id",property = "userId"),
                @Result(column = "username",property = "userName"),
                @Result(column = "address",property = "userAddress"),
                @Result(column = "sex",property = "userSex"),
                @Result(column = "birthday",property = "userBirthday"),
                @Result(property = "accounts",column = "id",
                        many = @Many(select = "com.itheima.dao.IAccountDao.findAccountByUid",
                                    fetchType = FetchType.LAZY))
        })
        List<User> findAll();
    
        /**
         * 根据id查询用户
         * @param userId
         * @return
         */
        @Select("select * from user  where id=#{id} ")
        @ResultMap("userMap")
        User findById(Integer userId);
    
        /**
         * 根据用户名称模糊查询
         * @param username
         * @return
         */
        @Select("select * from user where username like #{username} ")
        @ResultMap("userMap")
        List<User> findUserByName(String username);
    
    
    }

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

@Test
    public  void  testFindAll(){
        List<Account> accounts = accountDao.findAll();
    /*
        for(Account account : accounts){
            System.out.println("----每个账户的信息-----");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    */
    }

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

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

**3.3.3.1 User 实体类加入 List<Account>**

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

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

@Many: 
     相当于<collection>的配置  select 属性：代表将要执行的 sql 语句  
    fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值

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

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

**3.3.3.4 添加测试方法**

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

**3.4 mybatis 基于注解的二级缓存**

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

<settings> 
      
     <setting name="cacheEnabled" value="true"/> 
    </settings>

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

![format_png 2][]

[format_png]: /images/20210527/e3d4aee13cad4df3a976c079969179d5.png
[format_png 1]: /images/20210527/e42bb6d51842424d8835866a9ef00201.png
[format_png 2]: /images/20210527/80c6a161e93f4635ae97a114ef23906e.png