【MyBatis】MyBatis 注解开发

时间：2023-03-09 20:17:59
【MyBatis】MyBatis 注解开发

MyBatis 注解开发

文章源码

环境搭建

Mybatis 也可以使用注解开发方式，这样就可以减少编写 Mapper 映射文件。

常用注解说明：

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

单表 CRUD

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

  • @Results 代替了 <id> 标签和 <result> 标签，属性介绍：

    • id 是否是主键字段
    • column 数据库的列名
    • property 需要装配的属性名
    • one 需要使用的 @One 注解 @Result(one=@One)()
    • many 需要使用的 @Many 注解（@Result(many=@Many)()

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

    • select 指定用来多表查询的 sqlmapper
    • fetchType 会覆盖全局的配置参数 lazyLoadingEnabled
    • 使用格式：@Result(column=" ", property="", one=@One(select=""))

  • @Many（多对一）代替了 <collection> 标签，是是多表查询的关键，在注解中用来指定子查询返回对象集合，

    • 使用格式：@Result(property="", column="", many=@Many(select=""))

  • 编写实体类

    public class User implements Serializable {
    
    private Integer id;
    
    private String username;
    
    private Date birthday;
    
    private String sex;
    
    private String address;
    
}

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

    package cn.parzulpan.dao;

import cn.parzulpan.domain.User;
    
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
    
* @Author : parzulpan
    
* @Time : 2020-12
    
* @Desc : 用户的持久层接口，使用注解开发
    
*/

public interface UserDAO {

    /**
    
    * 查询所有用户
    
    * @return
    
    */
    
    @Select("select * from user")
    
    @Results(id = "userMap",
    
            value = {
    
            @Result(id = true, column = "id", property = "userId"),
    
            @Result(column = "username", property = "userName"),
    
            @Result(column = "birthday", property = "userBirthday"),
    
            @Result(column = "sex", property = "userSex"),
    
            @Result(column = "address", property = "userAddress")
    
            })
    
    List<User> findAll();

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

    /**
    
    * 插入操作
    
    * @param user
    
    * @return
    
    */
    
    @Insert("insert into user(username, birthday, sex, address) values (#{userName}, #{userBirthday}, #{userSex}, #{userAddress})")
    
    @SelectKey(keyColumn = "id", keyProperty = "userId", resultType = Integer.class, before = false,
    
            statement = {"select last_insert_id()"})
    
    int saveUser(User user);

    /**
    
    * 更新操作
    
    * @param user
    
    * @return
    
    */
    
    @Update("update user set username = #{userName}, birthday = #{userBirthday}, sex = #{userSex}, " +
    
            "address = #{userAddress} where id = #{userId}")
    
    int updateUser(User user);

    /**
    
    * 删除操作
    
    * @param userId
    
    * @return
    
    */
    
    @Delete("delete from user where id = #{uid}")
    
    int deleteUser(Integer userId);

    /**
    
    * 使用聚合函数查询
    
    * @return
    
    */
    
    @Select("select count(*) from user")
    
    int findTotal();

    /**
    
    *
    
    * @param name
    
    * @return
    
    */
    
    @Select("select * from user where username like #{username}")
    
    @ResultMap(value = {"userMap"})
    
    List<User> findByName(String name);

}

  • 编写 SqlMapConfig 配置文件

    <?xml version="1.0" encoding="UTF-8" ?>
    
<!DOCTYPE configuration
    
        PUBLIC "-//mabatis.org//DTD Congfig 3.0//EN"
    
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    
    <!-- 配置 properties 文件的位置 -->
    
    <properties resource="JDBCConfig.properties"/>

    <!-- 配置别名 -->
    
    <typeAliases>
    
        <package name="cn.parzulpan.domain"/>
    
    </typeAliases>

    <!-- 配置 MySQL 环境 -->
    
    <environments default="mysql">
    
        <environment id="mysql">
    
            <transactionManager type="JDBC"/>
    
            <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>

    <!-- 配置映射信息 -->
    
    <mappers>
    
        <package name="cn.parzulpan.dao"/>
    
    </mappers>
    
</configuration>

  • 编写测试方法

    package cn.parzulpan;

import cn.parzulpan.dao.UserDAO;
    
import cn.parzulpan.domain.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.InputStream;
    
import java.util.Date;
    
import java.util.List;

/**
    
* @Author : parzulpan
    
* @Time : 2020-12
    
* @Desc :
    
*/

public class MyBatisAnnotationCRUDTest {
    
    private InputStream is;
    
    private SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    
    private SqlSessionFactory sqlSessionFactory;
    
    private SqlSession sqlSession;
    
    private UserDAO userDAO;

    @Before
    
    public void init() throws Exception {
    
        System.out.println("Before...");
    
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
    
        sqlSessionFactory = builder.build(is);
    
        sqlSession = sqlSessionFactory.openSession();
    
        userDAO = sqlSession.getMapper(UserDAO.class);
    
    }

    @After
    
    public void destroy() throws Exception {
    
        System.out.println("After...");
    
        sqlSession.commit();
    
        sqlSession.close();
    
        is.close();
    
    }

    @Test
    
    public void findAllTest() {
    
        List<User> users = userDAO.findAll();
    
        for (User user : users) {
    
            System.out.println(user);
    
        }
    
    }

    @Test
    
    public void findByIdTest() {
    
        User user = userDAO.findById(41);
    
        System.out.println(user);
    
    }

    @Test
    
    public void saveUserTest() {
    
        User user = new User(null, "annotation username", new Date(), "男", "Beijing");
    
        System.out.println("save before: " + user); // User{id=null, ...}
    
        int i = userDAO.saveUser(user);
    
        System.out.println(i);
    
        System.out.println("save after: " + user); // User{id=53, ...}
    
    }

    @Test
    
    public void updateUserTest() {
    
        User user = userDAO.findById(42);
    
        user.setUserName("Tom Tim Tom AA");
    
        user.setUserAddress("瑞典");
    
        int i = userDAO.updateUser(user);
    
        System.out.println(i);
    
    }

    @Test
    
    public void deleteUserTest() {
    
        int i = userDAO.deleteUser(53);
    
        System.out.println(i);
    
    }

    @Test
    
    public void findTotalTest() {
    
        int total = userDAO.findTotal();
    
        System.out.println(total);
    
    }

    @Test
    
    public void findByNameTest() {
    
        List<User> users = userDAO.findByName("%Tim%");
    
        for (User user : users) {
    
            System.out.println(user);
    
        }
    
    }
    
}

多表查询

一对一

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

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

    public class Account implements Serializable {
    
    private Integer id;
    
    private Integer uid;
    
    private Double money;

    private User user;  // 一对一
    
}

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

    package cn.parzulpan.dao;

import cn.parzulpan.domain.Account;
    
import org.apache.ibatis.annotations.One;
    
import org.apache.ibatis.annotations.Result;
    
import org.apache.ibatis.annotations.Results;
    
import org.apache.ibatis.annotations.Select;
    
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

/**
    
* @Author : parzulpan
    
* @Time : 2020-12
    
* @Desc :
    
*/

public interface AccountDAO {

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

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

    @Test
    
    public void findAllTest() {
    
        List<Account> accounts = accountDAO.findAll();
    
        for (Account account : accounts) {
    
            System.out.println();
    
            System.out.println(account);
    
            System.out.println(account.getUser());
    
        }
    
    }
    
``

一对多

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

  • 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 interface UserDAO {
    
    /**
    
    * 查询所有用户，包括账户列表
    
    * @return
    
    */
    
    @Select("select * from user")
    
    @Results(id = "userMapWithAccount",
    
            value = {
    
                    @Result(id = true, column = "id", property = "userId"),
    
                    @Result(column = "username", property = "userName"),
    
                    @Result(column = "birthday", property = "userBirthday"),
    
                    @Result(column = "sex", property = "userSex"),
    
                    @Result(column = "address", property = "userAddress"),
    
                    @Result(column = "id", property = "accounts", many = @Many(
    
                            select = "cn.parzulpan.dao.AccountDAO.findByUid",
    
                            fetchType = FetchType.LAZY
    
                    ))
    
            })
    
    List<User> findAllWithAccount();
    
}

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

    public interface AccountDAO {

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

  • 添加测试方法

    package cn.parzulpan;

import cn.parzulpan.dao.UserDAO;
    
import cn.parzulpan.domain.Account;
    
import cn.parzulpan.domain.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.InputStream;
    
import java.util.List;

/**
    
* @Author : parzulpan
    
* @Time : 2020-12
    
* @Desc :
    
*/

public class MyBatisAccountManyTest {
    
    private InputStream is;
    
    private SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    
    private SqlSessionFactory sqlSessionFactory;
    
    private SqlSession sqlSession;
    
    private UserDAO userDAO;

    @Before
    
    public void init() throws Exception {
    
        System.out.println("Before...");
    
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
    
        sqlSessionFactory = builder.build(is);
    
        sqlSession = sqlSessionFactory.openSession();
    
        userDAO = sqlSession.getMapper(UserDAO.class);
    
    }

    @After
    
    public void destroy() throws Exception {
    
        System.out.println("After...");
    
        sqlSession.commit();
    
        sqlSession.close();
    
        is.close();
    
    }

    @Test
    
    public void findAllWithAccountTest() {
    
        List<User> users = userDAO.findAllWithAccount();
    
        for (User user : users) {
    
            System.out.println();
    
            System.out.println(user);
    
            System.out.println(user.getAccounts());
    
        }
    
    }
    
}

缓存配置

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

    <?xml version="1.0" encoding="UTF-8" ?>
    
<!DOCTYPE configuration
    
        PUBLIC "-//mabatis.org//DTD Congfig 3.0//EN"
    
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

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

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

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

  • 测试

    @Test
    
public void findByIdHighCacheTest() {
    
    SqlSession sqlSession1 = sqlSessionFactory.openSession();
    
    UserDAO dao1 = sqlSession1.getMapper(UserDAO.class);
    
    User user1 = dao1.findById(41);
    
    System.out.println(user1.hashCode());   // 765284253
    
    sqlSession1.close();    // 一级缓存消失

    SqlSession sqlSession2 = sqlSessionFactory.openSession();
    
    UserDAO dao2 = sqlSession2.getMapper(UserDAO.class);
    
    User user2 = dao2.findById(41);
    
    System.out.println(user2.hashCode());   // 1043351526
    
    sqlSession1.close();    // 一级缓存消失

    System.out.println(user1 == user2); // false

}

练习和总结

相关文章