【MyBatis】基础篇(十四) MyBatis基于注解开发

最新推荐文章于 2024-04-16 11:22:23 发布
最新推荐文章于 2024-04-16 11:22:23 发布
阅读量1.7k 收藏 9
点赞数 1
分类专栏： # ★ MyBatis·基础篇 ※开源框架专题※ 文章标签： MyBatis 注解开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41744145/article/details/99735305
版权

MyBatis·基础篇(十四) MyBatis基于注解开发

1. mybatis 的常用注解说明

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

MyBatis中使用注解开发方式，可以减少编写 Mapper 映射文件

2. 使用 Mybatis 注解实现单表操作

2.1 编写实体类

/**
 * @author: LzCc
 * @create: 2019-08-16 17:48
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description: User实体类
 */
public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    //getter、setter...
    //toString...
}

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

/**
 * @author: LzCc
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description: 基于注解开发的持久层接口
 */
public interface UserMapper {
    /**
     * 查询所有用户
     *
     * @return
     */
    @Select("select * from user")
    List<User> findAll();
    /**
     * 根据 id 查询一个用户
     *
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{uid}")
    User findById(Integer userId);
    /**
     * 保存操作
     *
     * @param user
     * @return
     */
    @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);
    /**
     * 更新操作
     *
     * @param user
     * @return
     */
    @Update("update user set username=#{username}, address=#{address}, sex=#{sex}, birthday=#{birthday} where id = #{id}")
    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}")
    List<User> findByName(String name);
}

@Insert：增加，可以理解为映射文件中的 <insert> 标签
@Select：查询，可以理解为映射文件中的 <select> 标签
@Update：更新，可以理解为映射文件中的 <update> 标签
@Delete：删除，可以理解为映射文件中的 <delete> 标签
@SelectKey：查询逐渐，可以理解为映射文件中的 <selectKey> 标签
* statement ：里面写查询主键的 SQL语句
类名：对应了映射文件中的 namespace
方法返回值类型：对应了映射文件中的 resultType

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

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>
    <!-- 配置别名的注册 -->
    <typeAliases>
        <package name="top.lzchao.mybatisquickstart.entity"/>
    </typeAliases>
    <!-- 配置 mybatis 的环境 -->
    <environments default="mysql">
        <!-- 配置 mysql 的环境 -->
        <environment id="mysql">
            <!-- 配置事务的类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置连接数据库的信息：用的是数据源(连接池) -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 配置映射信息 -->
    <mappers>
        <!-- 配置 dao 接口的位置，它有两种方式
            第一种：使用 mapper 标签配置 class 属性
            第二种：使用 package 标签，直接指定 dao 接口所在的包
            -->
        <package name="top.lzchao.mybatisquickstart.mapper"/>
    </mappers>
</configuration>

2.4 编写测试类，测试方法

/**
 * @author: LzCc
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description: MyBatis注解方式测试
 */
public class MybatisAnnotationTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private UserMapper userMapper;
    @Before
    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.创建代理对象
        userMapper = session.getMapper(UserMapper.class);
    }
    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll() {
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
    /**
     * 测试查询一个
     */
    @Test
    public void testFindById() {
        User user = userMapper.findById(1);
        System.out.println(user);
    }
    /**
     * 测试保存
     */
    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("mybatis annotation");
        user.setSex("男");
        user.setAddress("俄亥俄克利夫兰");
        user.setBirthday(new Date());
        int res = userMapper.saveUser(user);
        System.out.println("影响数据库记录的行数：" + res);
        System.out.println("插入的主键值：" + user.getId());
    }
    /**
     * 测试更新
     */
    @Test
    public void testUpdate() {
        User user = userMapper.findById(5);
        user.setBirthday(new Date());
        user.setSex("女");
        int res = userMapper.updateUser(user);
        System.out.println(res);
    }
    /**
     * 测试删除
     */
    @Test
    public void testDelete() {
        int res = userMapper.deleteUser(5);
        System.out.println(res);
    }
    /**
     * 测试查询使用聚合函数
     */
    @Test
    public void testFindTotal() {
        int res = userMapper.findTotal();
        System.out.println(res);
    }
    /**
     * 测试模糊查询
     */
    @Test
    public void testFindByName() {
        List<User> users = userMapper.findByName("%杰%");
        for (User user : users) {
            System.out.println(user);
        }
    }
    @After
    public void destroy() throws Exception {
        //提交事务
        session.commit();
        //释放资源
        session.close();
        //关闭流
        in.close();
    }
}

使用注解开发后，基本的CRUD操作变得非常的简单了！

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

当类中的属性名和查询出来的列名不一致时，当我们要实现复杂关系映射时，我们再映射文件通过 <resultMap> 标签来实现，那么注解开发呢？

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 注解（一对一）

代替了标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。

@One 注解属性介绍：

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

代替了标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。

  • 注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义；
  • 使用格式：
    • @Result(property="",column="",many=@Many(select=""))

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

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

添加 User 实体类及 Account 实体类
/**
 * @author: LzCc
 * @create: 2019-08-16 17:48
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description: User实体类
 */
public class User implements Serializable {
	private Integer userId;
	private String userName;
	private Date userBirthday;
	private String userSex;
	private String userAddress;
	//getter、setter
	//toString
}
/**
 * @author: LzCc
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description: Account实体类
 */
public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //多对一关系映射：从表方应该包含一个主表方的对象引用
    private User user;
	//getter、setter
	//toString...
}

注意:User实体类故意将属性名写出与列名不对应

添加账户的持久层接口并使用注解配置
/**
 * @author: LzCc
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description: 账户持久层接口
 */
public interface AccountMapper {
    /**
     * 查询所有账户，采用延迟加载的方式查询账户的所属用户
     * @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 = "top.lzchao.mapper.UserMapper.findById", fetchType = FetchType.LAZY)
                    )
            })
    List<Account> findAll();
}

fetchType ：

  • lazy ：懒加载
  • eager ：立即加载
    指定属性后，将在映射中忽略全局配置参数 lazyLoadingEnabled，使用属性的值。
添加用户的持久层接口并使用注解配置
/**
 * @author: LzCc
 * @blog: https://blog.youkuaiyun.com/qq_41744145
 * @description:
 */
public interface UserMapper {
    /**
     * 查询所有用户
     * @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 查询一个用户
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{uid} ")
    @ResultMap("userMap")
    User findById(Integer userId);
}
测试一对一关联及延迟加载
@Test
 public void testAccountFindAll() {
     AccountMapper accountMapper = session.getMapper(AccountMapper.class);
     List<Account> accounts = accountMapper.findAll();
     // for(Account account : accounts) {
     // System.out.println(account);
     // System.out.println(account.getUser());
     // }
 }

控制台输出：
在这里插入图片描述
延迟加载已打开

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

需求：

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

分析：

  • 一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。
User 实体类加入 List
private List<Account> accounts;
public List<Account> getAccounts() {
    return accounts;
}
public void setAccounts(List<Account> accounts) {
    this.accounts = accounts;
}
编写用户的持久层接口并使用注解配置

/**
 * 查询所有用户
 * @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"),
                @Result(column = "id", property = "accounts",
                        many = @Many(
                                select = "top.lzchao.mybatisquickstart.mapper.AccountMapper.findByUid",
                                fetchType = FetchType.LAZY
                        )
                )
        })
List<User> findAll();
  • @Many: 相当于 <collection> 的配置
    * select 属性：代表将要执行的 sql 语句
    • fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值
编写账户的持久层接口并使用注解配置
 /**
  * 根据用户 id 查询用户下的所有账户
  *
  * @param userId
  * @return
  */
@Select("select * from account where uid = #{uid}")
List<Account> findByUid(Integer userId);
添加测试方法
/**
 * 测试查询所有
 */
@Test
public void testFindAll() {
    UserMapper userMapper = session.getMapper(UserMapper.class);
    List<User> users = userMapper.findAll();
    // for(User user : users) {
        // System.out.println("-----每个用户的内容-----");
        // System.out.println(user);
        // System.out.println(user.getAccounts());
    // }
}

控制台输出：
在这里插入图片描述
正常输出

4. MyBatis 基于注解的二级缓存

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

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

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

@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface UserMapper {}
Mybatis面试题（基础篇）
qq_38196449的博客
06-09 1426
（1）mybatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。（2）mybatis避免了几乎所有的JDBC代码（说明了mybatis底层用的就是JDBC，只不过是封装了）和手动设置参数以及获取结果集。（3）mybatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的pojo映射成数据库中的记录。
Springboot整合mybatis（注解-基础篇）最通俗易懂的文章
m0_45311187的博客
03-16 2328
最好的Springboot整合mybatis入门。手把手全流程教学。有问题可以评论区讨论。
MyBatis基于注解简单案例
07-28
简单的MyBatis开发案例，内含增加，删除，修改，列表查询，数量查询等等，有改进的地方，请多指正。
mybatis基于注解
qq_36976201的博客
09-26 169
@Insert@Delete@Update@Select 要使用注解的方式可以直接在接口上使用，这样就不用xml配置文件了 @Insert public interface StudentDao { @Insert("insert into student values(#{id},#{name},#{email},#{age})") public int insertStudent(Student student); } @Delete public interface Student.
boot-mybatis基于注解
面朝大海，春暖花开
09-26 225
spring boot mybatis 基于注解 基于spring boot 2.0.5.RELEASE 基础的CRUD注解 @Select @Insert @Update @Delete 对象映射注解 @Results 返回多个字段映射. @Result 单个字段映射. @ResultMap 相当于&amp;lt;resultMap&amp;gt;标签 动态sql注解 @SelectProvider ...
【MyBatis】基于注解开发
锦瑟流年
12-23 204
MyBatis基于注解开发的步骤： 1、编写SqlMapConfig，其中包括数据库连接池的信息和映射文件的路径。 2、在持久层接口的方法上进行对应的注解。 1.编写SqlMapConfig配置文件 <!-- 在resources目录下的db.properitis配置文件 --> jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/eesy jdbc.username=root jdbc.passwor
MyBatis基于注解的使用
别念茶茶
12-10 313
Mybtis注解 增加接口CategoryMapper ，并在接口中声明的方法上，加上注解 增加对CategoryMapper 的映射： &lt;mappers&gt; //com.shop.mapper包下的CategoryMapper接口         &lt;mapper class="com.shop.mapper.CategoryMapper"/&gt;  &lt;/mappers&...
mybatis快速入门基础篇-mybatis使用-mybatis工具类封装
weixin_44201223的博客
04-16 352
mybatis快速入门，搭建
全网最简单、通俗易理解SpringBoot教程，基础篇10-SpringBoot整合MyBatis
最新发布
05-14
全网最简单、通俗易理解SpringBoot教程，快速完成项目，一切为项目而生
Mybatis 入门到理解篇
12-18
Mybatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。 知识点如下： 1. Mybatis的发展历史：Mybatis最初是apache的一个开源...
基于注解的mybatis使用
weixin_46132241的博客
07-22 167
domain： public class User implements Serializable { private Integer id; private String username; private String address; private String sex; public String getSex() { return sex; } public void setSex(String sex) { .
Mybatis-基于注解开发基础介绍
WJY
08-26 206
注解开发 注解和XML标签对应关系 注解 注解属性 XML标签 XML标签属性 CURD 一对以 一对多
mybatis基于注解开发【三】
qq_38777614的博客
08-20 406
Mybatis的常用注解 @Insert，@Delete，@Update，@Select，@Results，@Result，@One，@Many 使用注解的好处，不用写映射文件了。什么参数类型，返回值类型等。 mybatis基于注解开发 1.1：一对一（丈夫和妻子） 1、创建表 create table wife( wid int primary key auto_increment, wname varchar(20) ); insert into wife values(null,'西施');..
mybatis基于注解的环境搭建
陌意随影的博客
07-24 216
1.创建maven工程，然后创建相应的目录如图： 2.在pom.xml文件中导入项目依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache
Mybatis相关：基于注解的Mybatis开发
zitian246的博客
10-25 542
1.Mybatis常用注解 @Insert:实现新增 @Update:实现更新 @Delete:实现删除 @Select:实现查询 @Result:实现结果集封装 @Results:可以与@Result 一起使用，封装多个结果集 @ResultMap:实现引用@Results 定义的封装 @One:实现一对一结果集封装 @Many:实现一对多结果集封装 @SelectProvider: 实现动态 SQL 映射 @CacheNamespace:实现注解二级缓存的使用 2.基于注解的增删改查
mybatis使用注解开发
SuperstarSteven的博客
08-18 395
1.Pet.jaa package com.annotation.entity; import java.util.Date; /** * 创建实体类Pet * @author Steven * */ public class Pet { private int id;//宠物id private String name;//名称 private String owner;...
Mybatis基础总结-基于注解开发
lw的博客
07-09 840
注解可以简化开发操作，省略映射配置文件的编写。常用注解@Select(“查询的 SQL 语句”)：执行查询操作注解@Insert(“查询的 SQL 语句”)：执行新增操作注解@Update(“查询的 SQL 语句”)：执行修改操作注解@Delete(“查询的 SQL 语句”)：执行删除操作注解配置映射关系< mappers > < package name = " 接口所在包 " />
Mybatis的注解开发
qq_56751933的博客
05-24 1810
一、Mybatis的注解开发 1.1 MyBatis的常用注解 这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。 @Insert：实现新增 @Update：实现更新 @Delete：实现删除 @Select：实现查询 @Result：实现结果集封装 @Results：可以与@Result 一起使用，封装多个结果集 @One：实现一对一结果集封装 @Many：实现一对多结果集封装 1.
Mybatis01—基于注解的Mybatis开发
weixin_43514899的博客
07-31 199
我们只需要编写Dao接口并且按照mybatis要求编写两个配置文件（IUserDao.xml和SqlMapConfig.xml），就可以实现Mybatis的开发。这远比用jdbc编写来实现功能方便多了。 （我们使用注解之后，将变得更为简单，只需要编写一个mybatis配置文件就够了。） 所以本文我们来讲解基于注解的Mybatis开发 移除xml的映射配置（IUserDao.xml） 在持久层接口中添加注解 public interface IUserDao { @Select("select *
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值