Mybatis的注解方式开发

系统管理员 2023-05-22 22:25 3阅读 0赞

### 目录 ###

*  一、环境搭建与测试
 *  二、注解方式的单表CRUD
 *  三、注解方式的复杂关系映射
 *   *  属性与列的对应关系
     *  多表查询
     *   *  一对一
         *  一对多
 *  四、注解方式使用二级缓存

前面的文章使用的都是XML配置的方式进行开发，当然，Mybatis也可以使用注解的方式进行开发，这样可以不用配置Mapper映射文件（主配置文件还是不能省的）。

# 一、环境搭建与测试 #

数据库中的user表：  
![在这里插入图片描述][20200418163457134.png]  
目录结构：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70]  
User实体类：

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;
        }
    }

使用注解方式开发DAO接口：

/** * <p> * 用户的持久层接口 */
    public interface IUserDao { 
        /** * 查询所有用户，同时获取到用户所属的所有角色信息 * @return */
        @Select("select * from user")
        List<User> findAll();
    }

主配置文件：

<?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.zhu.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>
            <package name="com.zhu.dao"></package>
        </mappers>
    </configuration>

测试类:

/** * 注解开发测试类 */
    public class MybatisAnnoTest { 
    
        /** * 测试基于注解的mybatis使用 * @param args */
        public static void main(String[] args) throws  Exception{ 
            //1.获取字节输入流
            InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.根据字节输入流构建SqlSessionFactory
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
            //3.根据SqlSessionFactory生产一个SqlSession
            SqlSession session = factory.openSession();
            //4.使用SqlSession获取Dao的代理对象
            IUserDao userDao = session.getMapper(IUserDao.class);
            //5.执行Dao的方法
            List<User> users = userDao.findAll();
            for(User user : users){ 
                System.out.println(user);
            }
            //6.释放资源
            session.close();
            in.close();
        }
    }

测试结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70 1]

# 二、注解方式的单表CRUD #

[\----->项目源码][-----]  
在mybatis中针对CRUD一共有四个注解  
@Insert:实现新增  
@Update:实现更新  
@Delete:实现删除  
@Select:实现查询

上文已经使用了@Select，接下来补充其他几种来进行单表的CRUD。  
在DAO接口中添加各个方法：

/** * <p> * 用户的持久层接口 */
    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 '%${value}%' ")
        List<User> findUserByName(String username);
    
        /** * 查询总用户数量 * @return */
        @Select("select count(*) from user ")
        int findTotalUser();
    }

测试类：

/** * 注解方式CRUD的测试 */
    public class AnnotationCRUDTest { 
        private InputStream in;
        private SqlSessionFactory factory;
        private SqlSession session;
        private IUserDao userDao;
    
        @Before
        public  void init()throws Exception{ 
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            factory = new SqlSessionFactoryBuilder().build(in);
            session = factory.openSession();
            userDao = session.getMapper(IUserDao.class);
        }
    
        @After
        public  void destroy()throws  Exception{ 
            session.commit();
            session.close();
            in.close();
        }
    
    
        @Test
        public void testSave(){ 
            User user = new User();
            user.setUsername("梅西");
            user.setAddress("西班牙");
    
            userDao.saveUser(user);
        }
    
        @Test
        public void testUpdate(){ 
            User user = new User();
            user.setId(7);
            user.setUsername("梅老板");
            user.setAddress("西班牙马德里");
            user.setSex("男");
            user.setBirthday(new Date());
    
            userDao.updateUser(user);
        }
    
    
        @Test
        public void testDelete(){ 
            userDao.deleteUser(7);
        }
    
        @Test
        public void testFindOne(){ 
            User user = userDao.findById(6);
            System.out.println(user);
        }
    
    
        @Test
        public  void testFindByName(){ 
            List<User> users = userDao.findUserByName("林");
            for(User user : users){ 
                System.out.println(user);
            }
        }
    
        @Test
        public  void testFindTotal(){ 
            int total = userDao.findTotalUser();
            System.out.println(total);
        }
    }

测试结果略…

# 三、注解方式的复杂关系映射 #

使用**XML方式**开发时，实现复杂关系映射可在映射文件中通过配置<resultMap>来实现， 在使用**注解**开发时，对应地，我们需要使用@Results 注解， @Result 注解， @One 注解， @Many 注解 。

## 属性与列的对应关系 ##

当实体类的属性与数据库中表的列名不一致时，需要通过@Results 注解来建立它们之间的对应关系。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70 2]  
在IUserDao的相应方法上添加@Results注解：

> @Results 注解代替的是标签<resultMap>  
> 该注解中可以使用单个@Result 注解，也可以使用@Result 集合  
> @Results（\{@Result（）， @Result（） \}）或@Results（@Result（））

/** * 查询所有用户，同时获取到用户所属的所有角色信息 * @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")
        })
        List<User> findAll();

> @Result中的属性：  
> id 是否是主键字段  
> column 数据库的列名  
> property 需要装配的属性名

如此，测试findAll（）方法就能进行正常的封装，但是别的查询方法（如findById）依然不能封装。  
其实 @Results注解是可复用的，使用@ResultMap即可：

/** * 根据id查询用户 * @param userId * @return */
        @Select("select * from user where id=#{id} ")
        @ResultMap(value = { "userMap"})
        User findById(Integer userId);

简写为 @ResultMap(“userMap”)。

## 多表查询 ##

[\----->项目源码][----- 1]

### 一对一 ###

除了用户，还有用户的钱包！  
现在的需求是：查询钱包时，同时查询出对应用户的信息，这是多对一关系，在mybatis中为一对一关系。  
参考[Mybatis的多表查询实例][Mybatis]，再建立一张（钱包）表与对应的实体类：  
Wallet表：  
![在这里插入图片描述][20200419142648372.png]  
实体类：

public class Wallet 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 "Wallet{" +
                    "id=" + id +
                    ", uid=" + uid +
                    ", money=" + money +
                    '}';
        }
    }

接着新建IWalletDao并添加查询方法：

public interface IWalletDao { 
    
        /** * 查询所有钱包，同时还要获取到当前钱包的所属用户信息 * @return */
        @Select("select * from wallet")
        @Results(id="walletMap",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.zhu.dao.IUserDao.findById",fetchType= FetchType.EAGER))
        })
        List<Wallet> findAll();
    }

@One 注解 （一对一）代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。  
使用格式：

@Result(column=" ",property="",one=@One(select=""))

@One 注解属性介绍：  
select 指定用来多表查询的 sqlmapper  
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled，有三种属性：  
![在这里插入图片描述][20200419150412111.png]  
分别为懒加载、立即加载和默认。

最后测试钱包的findAll方法：  
![在这里插入图片描述][20200419150511490.png]

### 一对多 ###

需求：查询用户时，还要把用户名下的所有钱包信息查询出来。  
那么需要在实体类中体现一对多关系，就得包含对方对象的集合引用：  
User.java:

public class User implements Serializable { 
    
        private Integer id;
        private String username;
        private String address;
        private String sex;
        private Date birthday;
    
        //一对多关系映射：主表实体应该包含从表实体的集合引用
        private List<Wallet> wallets;
    
        public List<Wallet> getWallets() { 
            return wallets;
        }

编写IUserDao：

/** * 查询所有用户，同时获取到用户下所有账户的信息 * @return */
        @Select("select * from user")
        @Results(id="userMap",value={ 
                @Result(property = "wallets",column = "id",
                        many = @Many(select = "com.zhu.dao.IWalletDao.findWalletByUid",
                                fetchType = FetchType.LAZY))
        })
        List<User> findAll();

@Many 注解代替了<Collection>标签,是是多表查询的关键，在注解中用来指定子查询返回的对象集合。  
格式：

@Result(property="",column="",many=@Many(select=""))

同时要在IWalletDao 中添加findWalletByUid方法:

/** * 根据用户id查询钱包信息 * @return */
        @Select("select * from wallet where uid = #{Uid}")
        List<WalletUser> findWalletByUid();

测试User的fingAll()：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70 3]

# 四、注解方式使用二级缓存 #

与xml方式一样，先得在主配置中开启二级缓存支持：

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

接着需要在DAO接口中使用注解来配置二级缓存：

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

[20200418163457134.png]: /images/20230521/43bacc46e94f4510838b12bdd75d1ebb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70]: /images/20230521/a7d09a978e934e08b9dcc8015a29fb51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70 1]: /images/20230521/3cfb2cc645894378befd2302662337d9.png
[-----]: https://github.com/MagicalPiggy/Mybatis-learning-example/tree/master/mybatis_learning/mybatis_11_annotation
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70 2]: /images/20230521/7240ecf9964146cc8101a1e5fe417324.png
[----- 1]: https://github.com/MagicalPiggy/Mybatis-learning-example/tree/master/mybatis_learning/mybatis_12_1toX
[Mybatis]: https://blog.csdn.net/z714405489/article/details/105545924
[20200419142648372.png]: /images/20230521/370c645bd4e94f308bd3bf647130f3ed.png
[20200419150412111.png]: /images/20230521/a44b165265ae4440bd56979449d3b9fb.png
[20200419150511490.png]: /images/20230521/fe289172234c496ea547140aec05faaa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o3MTQ0MDU0ODk_size_16_color_FFFFFF_t_70 3]: /images/20230521/7a6c81379f89470180914c7607b5dccc.png