注解使用

Java 持久层框架
mybatis
发布日期:   2022-02-11

概述

使用步骤

  1. 配置SqlMapConfig.xml
    <configuration>
    <properties resource="jdbcConfig.properties"/>
   
    <mappers>
        <package name="cn.dy.mapper"/>
    </mappers>
</configuration>
  2. 在XxxMapper接口上添加正确的注解

增

注解:@Insert
使用方式:方法上
添加数据

public interface AccountMapper {
    /**
     * 添加账户
     * @param account
     * @return
     */
    @Insert("insert into account (UID,money) values (#{uId},#{money})")
    void save(Account account);
}

添加数据,并将自增的主键使用反射设置到当前对象中
方式一

// mapper接口
public interface AccountMapper {
    /**
     * 添加账户
     * @param account
     * @return
     */
    @Insert("insert into account (UID,money) values (#{uId},#{money})")
    @Options(useGeneratedKeys=true,keyColumn = "id",keyProperty = "id")
    void save(Account account);
}

方式二

// mapper接口
public interface AccountMapper {
    /**
     * 添加账户
     * @param account
     * @return
     */
    @Insert("insert into account (UID,money) values (#{uId},#{money})")
    @SelectKey(before = false,keyColumn = "id",keyProperty = "id",
            statement = "select last_insert_id()",resultType = Integer.class)
    void save(Account account);
}

测试类
``` Java
public class TestAccount {

    private InputStream inputStream;
    private SqlSession sqlSession;
    private AccountMapper accountMapper;
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() {
        try {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //  这里的事务默认不开启
        sqlSession = sqlSessionFactory.openSession();
        accountMapper = sqlSession.getMapper(AccountMapper.class);
    }

    @After
    public void destory() {
        //  这里提交事务
        sqlSession.commit();
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSession.close();
    }

    @Test
    public void testSave(){
        Account account = new Account(null,45,9999.0);
        //  自增后的主键会设置到当前对象中
        accountMapper.save(account);
        System.out.println(account);
    }
}

删

注解:@Delete
使用方式:方法上

public interface AccountMapper {
    /**
     * 删除账户
     * @param id
     * @return
     */
    @Delete("DELETE from account WHERE id = #{id}")
    //  返回值为执行结果:影响的行数
    int removeById(int id);
}

改

注解:@Update
使用方式:方法上

public interface AccountMapper {
  /**
    * 根据id修改用户信息
    * @param account
    * @return
    */
  @Update("UPDATE  account SET  UID=#{uId},money=#{money} WHERE id = #{id}")
  int editorById(Account account);
}

查

注解:@Select
使用方式:方法上
普通查询+起别名

public interface AccountMapper {
    /**
     * 根据id查询账户信息
     *
     * @param id
     * @return
     */

    @Select({"SELECT id,UID uId,money FROM account"})
    Account findById(int id);
}

查询个数

public interface AccountMapper {
    /**
     * 查询个数
     * @return
     */
    @Select("select count(1) from user")
     Integer findCount();
}

结果集(需与Select一起使用)

注解:@Results
使用方式:方法上
结果集映射查询
属性:

  • id 当前结果集起个别名,可复用 (注意:此id值不可重复)
  • value 结果集字段映射
    • 结果集字段映射使用@Result注解
      • column的值为数据库列名
      • property的值为实体类中的属性名
      • id=true表示该字段为主键,不写默认的值为false
        public interface AccountMapper {
    /**
     * 根据id查询账户信息
     *
     * @param id
     * @return
     */

    @Select({"SELECT id,UID,money FROM account"})
    @Results(id = "accountMap", value = {
            @Result(column = "id", property = "id", id = true),
            @Result(column = "UID", property = "uId"),
            @Result(column = "money", property = "money")
    })
    Account findById(int id);
}

使用结果集

注解:@ResultMap

public interface AccountMapper {
  /**
    * 查询所有账户信息
    *
    * @return
    */
  @Select("select id,UID uId,money from account")
  //  注意:使用ResultMap时,名为accountMap的结果集必须存在
  @ResultMap("accountMap")
  List<Account> findAll();
}

传参(暂未使用)

注解:@Param
使用方式:在方法参数前使用
例:

public interface AccountMapper {
    /**
     * 根据id查询账户信息
     *
     * @param id
     * @return
     */

    @Select({"SELECT id,UID,money FROM account WHERE id = #{id}"})
    // 在方法参数前使用
    Account findById(@Param("id") int id);
}

延迟加载(懒加载,按需加载)

需在SqlMapConfig中开启配置


<configuration>
    <properties resource="jdbcConfig.properties"/>
    <!--    配置项-->
    <settings>
        <!--开启懒加载(延迟加载)-->

        <!-- 将延迟加载 lazyLoadingEnable 的开关设置成 teue-->
        <setting name="lazyLoadingEnabled" value="true"/>

        <!-- 将积极加载修改为消极加载，将 aggressiveLazyLoading 改为 false-->
        <setting name="aggressiveLazyLoading" value="false"/>

        <!-- 指定对象的哪些方法触发一次延迟加载;默认值:equals,clone,hashCode,toString-->
        <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode"/>

    </settings>

</configuration>

pojo类
Account.java

public class Account implements Serializable {
    private Integer id;
    private Integer uId;
    private double money;

    private  User user;
}

User.java

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

    List<Account> accounts;
}

一对多或多对多
UserMapper.java

public interface UserMapper {
  /**
    * 查询所有用户信息
    * @return
    */
  @Select("select * from user")
  @Results(id = "userAccount",value = {
          @Result(id = true,property = "id",column = "id"),
          @Result(property = "username",column = "username"),
          @Result(property = "sex",column = "sex"),
          @Result(property = "address",column = "address"),
          //  配置延迟加载项:
            //  property延迟加载的对象属性名
            //  column传递给延迟加载对象的参数
            //  many延迟加载的类型为集合时使用
              //  select延迟加载对象的坐标:包名.类名.方法名
              //  fetchType延迟加载的时机:LAZY懒加载
          @Result(property = "accounts",column = "id",many = @Many(
                  select = "cn.dy.mapper.AccountMapper.findById",fetchType = FetchType.LAZY
          ))
  })
  List<User> findAll();
}

AccountMapper.java

public interface AccountMapper {
    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    @Select("SELECT * FROM account")
    Account findById(int id);
}

测试类TestUser.java

public class TestUser {
    private InputStream inputStream;
    private SqlSession sqlSession;
    private UserMapper userMapper;
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() {
        try {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //  这里的事务默认不开启
        sqlSession = sqlSessionFactory.openSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
    }

    @After
    public void destory() {
        //  这里提交事务
        sqlSession.commit();
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSession.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println(user);
            System.out.println(user.getAccounts());//  调用此方法时启用延迟加载
            System.out.println("-------------------------------------------------");
        }
    }
}

多对一或一对一
AccountMapper.java

public interface AccountMapper {

  /**
    * 查询所有账户信息
    * @return
    */
  @Select("select * from account")
  @Results(id = "accountUser",value = {
          @Result(id = true,property = "id",column = "id"),
          @Result(property = "uId",column = "UID"),
          @Result(property = "money",column = "money"),
          //  配置延迟加载项:
            //  property延迟加载的对象属性名
            //  column传递给延迟加载对象的参数
            //  one延迟加载的类型为对象时使用
              //  select延迟加载对象的坐标:包名.类名.方法名
              //  fetchType延迟加载的时机:LAZY懒加载
          @Result(property = "user",column = "id",one = @One(
                  select = "cn.dy.mapper.UserMapper.findById",fetchType = FetchType.LAZY
          ))
  })
  List<Account> findAll();
}

UserMapper.java

public interface UserMapper {
    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */
    @Select("SELECT * FROM user WHERE id=#{id}")
    User findById(int id);
}

测试类TestAccount.java

public class TestAccount {

    private InputStream inputStream;
    private SqlSession sqlSession;
    private AccountMapper accountMapper;
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() {
        try {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //  这里的事务默认不开启
        sqlSession = sqlSessionFactory.openSession();
        accountMapper = sqlSession.getMapper(AccountMapper.class);
    }

    @After
    public void destory() {
        //  这里提交事务
        sqlSession.commit();
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSession.close();
    }

    //  查询所有账户信息
    @Test
    public  void testFindAll(){
        List<Account> accounts = accountMapper.findAll();
        for (Account account : accounts) {
            System.out.println(account);
            System.out.println(account.getUser());//  调用此方法时启用延迟加载
            System.out.println("--------------------------------------------");
        }
    }
}

二级缓存

需要先在SqlMapConfig.xml中配置

<configuration>
    <properties resource="jdbcConfig.properties"/>
    <!--    配置项-->
    <settings>
        <!--开启全局二级缓存-->
        <setting name="cacheEnabled" value="true"/>

</configuration>

注解:@CacheNamespace(blocking = true)
使用:在mapper接口类上添加注解

//  开启注解支持二级缓存
@CacheNamespace(blocking = true)
public interface UserMapper {
    /**
     * 查询全部
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMapper",value = {
            @Result(id = true,property = "userId",column = "id"),
            @Result(property = "userName",column = "username"),
            @Result(property = "userSex",column = "sex"),
            @Result(property = "userAddress",column = "address")
    })
    public List<User> findAll();

    /**
     * 查询个数
     * @return
     */
    @Select("select count(1) from user")
    public Integer findCount();

    /**
     * 通过名字模糊查询
     * @param name
     * @return
     */
    @Select("select * from user where username like #{userName}")
    @ResultMap("userMapper")
//    @Select("select * from user where username like '%${value}%'")
    public List<User> findByName(String name);

    
}
文章作者: zrh
文章链接: https://zrh-main.github.io/2022/02/11/Java/Mybatis/11.%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 zrh !
Java 持久层框架
  目录