mybatis学习—— mybatis 注解开发

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

mybatis 的常用注解说明

@Insert:实现新增

@Update:实现更新

@Delete:实现删除

@Select:实现查询

@Result:实现结果集封装

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

@ResultMap:实现引用@Results 定义的封装

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

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

@SelectProvider: 实现动态 SQL 映射

@CacheNamespace:实现注解二级缓存的使用

使用 Mybatis 注解实现基本 CRUD

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

1 编写实体类

public class User implements Serializable { 
 
    private Integer userId; 
    private String userName; 
    private Date userBirthday;  
    private String userSex;  
    private String userAddress;  
    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 Date getUserBirthday() {   
        return userBirthday;  
    }  
    public void setUserBirthday(Date userBirthday) {   
        this.userBirthday = userBirthday;  
    }  
    public String getUserSex() {   
        return userSex;  
    }  
    public void setUserSex(String userSex) {   
        this.userSex = userSex;  
    }
    public String getUserAddress() {  
        return userAddress;  
    } 
    public void setUserAddress(String userAddress) {   
        this.userAddress = userAddress;  
    }  
    @Override  
    public String toString() {   
        return "User [userId=" + userId + ", userName=" + userName + ", userBirthday=" + userBirthday + ", userSex="+ userSex + ", userAddress=" + userAddress + "]";  
    } 
}

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

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

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="sex",property="userSex"),     
　　　　　　　　　　　　　　　　@Result(column="address",property="userAddress"),     
　　　　　　　　　　　　　　　　@Result(column="birthday",property="userBirthday")    }
　　　　　　　　)  
    List<User> findAll();    
    /**
    * 根据 id 查询一个用户     
    */  
    @Select("select * from user where id = #{uid} ")  
    @ResultMap("userMap")  
    User findById(Integer userId);    
    /** 
      * 保存操作   
     */  
    @Insert("insert into user(username,sex,birthday,address)values(#{username},#{sex},#{birthday},#{address} )")              
　　 @SelectKey(keyColumn="id",keyProperty="id",resultType=Integer.class,before = false, statement = { "select last_insert_id()" })  
    int saveUser(User user);    
    /** 
      * 更新操作 
     */  
    @Update("update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id =#{id} ") 
    int updateUser(User user);    
    /** 
      * 删除用户    
    */  
    @Delete("delete from user where id = #{uid} ") 
     int deleteUser(Integer userId);    
    /** 
      * 查询使用聚合函数   
     */  
    @Select("select count(*) from user ") 
    int findTotal(); 
    /** 
      * 模糊查询   
     */  
　　@Select("select * from user where username like #{username} ")              
　　List<User> findByName(String name); 
} 

通过注解方式，我们就不需要再去编写 UserDao.xml 映射文件了。

3 编写 SqlMapConfig 配置文件

 

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Confi3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <properties resource="jdbcConfig.properties"></properties>

    <!--使用typeAliases配置别名，它只能配置domain中类的别名 -->
    <typeAliases>
        <!-- 用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写-->
        <package name="com.churujianghudezai.domain"></package>
    </typeAliases>

    <!--配置mybatis的环境-->
    <environments default="mysql">
        <!--配置mybatis的环境-->
        <environment id="mysql">
            <!--配置事务类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接数据库的信息，用的是数据源（连接池）-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--告知mybatis映射配置的位置-->
    <mappers>
        <package name="com.churujianghudezai.dao"/>
    </mappers>

</configuration>

 4 编写测试方法

public class MybatisAnnotationCRUDTest {

    /**
     * 测试查询所有
     * */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
        for(User user : users) {
            System.out.println(user);
        }
    }
    /**
     * 测试查询一个
     * */
    @Test
    public void testFindById() {
        User user = userDao.findById(41);
        System.out.println(user);
    }
    /**
     * 测试保存
     * */
    @Test
    public void testSave() {
        User user = new User();
        user.setUserName("mybatis annotation");
        user.setUserSex("男");
        user.setUserAddress("北京市顺义区");
        user.setUserBirthday(new Date());
        int res = userDao.saveUser(user);
        System.out.println("影响数据库记录的行数："+res);
        System.out.println("插入的主键值："+user.getUserId());
    }
    /**
     * 测试更新
     * */
    @Test
    public void testUpdate() {
        User user = userDao.findById(63);
        user.setUserBirthday(new Date());
        user.setUserSex("女");
        int res = userDao.updateUser(user);
        System.out.println(res);
    }
    /**
     * 测试删除
     * */
    @Test
    public void testDelete() {
        int res = userDao.deleteUser(63);
        System.out.println(res);
    }
    /**
     * 测试查询使用聚合函数
     * */
    @Test
    public void testFindTotal() {
        int res = userDao.findTotal();
        System.out.println(res);
    }
    /**
     * 测试模糊查询
     * */
    @Test
    public void testFindByName() {
        List<User> users = userDao.findByName("%m%");
        for(User user : users) {
            System.out.println(user);
        }
    }
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;

    @Before//junit 的注解
    public void init()throws Exception{
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.创建 session
        session = factory.openSession();
        //4.创建代理对象
        userDao = session.getMapper(IUserDao.class);
    }
    @After//junit 的注解
    public void destroy()throws Exception {
        //提交事务
        session.commit();
        //释放资源
        session.close();
        //关闭流
        in.close();
    }
}

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

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

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=""))

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

需求： 

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

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

public class User implements Serializable {

    private Integer userId;
    private String userName;
    private Date userBirthday;
    private String userSex;
    private String userAddress;
    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 Date getUserBirthday() {
        return userBirthday;
    }
    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }
    public String getUserSex() {
        return userSex;
    }
    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }
    public String getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + ", userBirthday=" + userBirthday + ", userSex=" + userSex + ", userAddress=" + userAddress + "]";
    }
}

-----------------------------------------------------------

public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;
    //多对一关系映射：从表方应该包含一个主表方的对象引用
    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 + "]";
    }
}

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

public interface IAccountDao {
    /**
    * 查询所有账户，采用延迟加载的方式查询账户的所属用户
    * */
    @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(column="uid",property="user",one=@One(select="com.itheima.dao.IUserDao.findById",fetchType=FetchType.LAZY))
    })
    List<Account> findAll();
}

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

public interface IUserDao {
    /**
    * 查询所有用户
     * */
    @Select("select * from user")
    @Results(id="userMap",value= {
                @Result(id=true,column="id",property="userId"),
                @Result(column="username",property="userName"),
                @Result(column="sex",property="userSex"),
                @Result(column="address",property="userAddress"),
                @Result(column="birthday",property="userBirthday")
    })
    List<User> findAll();
    /**
    * 根据 id 查询一个用户
     * */
    @Select("select * from user where id = #{uid} ")
    @ResultMap("userMap")
    User findById(Integer userId);
}

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

public class AccountTest {
    @Test
    public void testFindAll() {
        List<Account> accounts = accountDao.findAll();
        //  for(Account account : accounts) {
        //   System.out.println(account);
        //   System.out.println(account.getUser());
        //  }
    }
}

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

需求： 

　　查询用户信息时，也要查询他的账户列表。使用注解方式实现。

分析： 

　　一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。

3.1 User 实体类加入 List<Account>

public class User implements Serializable {

    private Integer userId;
    private String userName;
    private Date userBirthday;
    private String userSex;
    private String userAddress;
    //一对多关系映射：主表方法应该包含一个从表方的集合引用
    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 Date getUserBirthday() {
        return userBirthday;
    }
    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }
    public String getUserSex() {
        return userSex;
    }
    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }
    public String getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + ", userBirthday=" + userBirthday + ", userSex=" + userSex + ", userAddress=" + userAddress + "]";
    }
}

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

public interface IUserDao {    
    /**
    * 查询所有用户 
     * */  
    @Select("select * from user")  
    @Results(id="userMap",value= {     
                @Result(id=true,column="id",property="userId"),     
                @Result(column="username",property="userName"),     
                @Result(column="sex",property="userSex"),     
                @Result(column="address",property="userAddress"),     
                @Result(column="birthday",property="userBirthday"),     
                @Result(column="id",property="accounts",many=@Many(select="com.itheima.dao.IAccountDao.findByUid",fetchType=FetchType.LAZY ))    
    })  
    List<User> findAll();  
} 

@Many: 相当于<collection>的配置 

select 属性：代表将要执行的 sql 语句 

fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值

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

public interface IAccountDao {
    /**
    * 根据用户 id 查询用户下的所有账户
    * */
    @Select("select * from account where uid = #{uid} ")
    List<Account> findByUid(Integer userId);
}

3.4 添加测试方法

public class UserTest {
    /**
     * 测试查询所有
     * */
    @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());
    //  }
    }
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;
        @Before//junit 的注解
        public void init()throws Exception{
            //1.读取配置文件
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            factory = builder.build(in);
            //3.创建 session
            session = factory.openSession();
            //4.创建代理对象
            userDao = session.getMapper(IUserDao.class);
        }
        @After//junit 的注解
        public void destroy()throws Exception {
            //提交事务
            session.commit();
            //释放资源
            session.close();
            //关闭流
            in.close();
        }
}

mybatis 基于注解的二级缓存

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

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

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

@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存 
public interface IUserDao {}