MyBatis(8) MyBatis 基于注解开发

最新推荐文章于 2024-04-13 02:38:21 发布
最新推荐文章于 2024-04-13 02:38:21 发布
阅读量194 收藏 1
点赞数 1
分类专栏： MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41049126/article/details/106243295
版权

MyBatis 注解开发

MyBatis的常用注解

  • @Insert：实现新增
  • @Update：实现更新
  • @Delete：实现删除
  • @Select：实现查询
  • @Result：实现结果集封装
  • @Results：可以与@Result 一起用，封装多个结果集
  • @One：实现一对一结果集封装
  • @Many：实现一对多结果集封装

MyBatis基于注解的增删改查

使用注解开发的好处就是：可以直接在Mapper接口写sql语句，无需编写mapper.xml文件，在业务简单的情况下，方便快速开发

  • 新建UserMapper类：

    package com.demo.mapper;

import com.demo.pojo.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.io.IOException;
import java.util.List;

public interface UserMapper {

    /**
     * 添加用户
     */
    @Insert("insert into user values (#{id},#{username})")
    void addUser(User user);

    /**
     * 更新用户
     */
    @Update("update user set username = #{username} where id = #{id}")
    void updateUser(User user);

    /**
     * 删除用户
     */
    @Delete("delete from user where id = #{id}")
    void deleteUser(Integer id);

    /**
     * 查询全部
     */
    @Select("select * from user")
    List<User> selectAll();

}

  • 新建测试类

    package com.demo.test;

import com.demo.mapper.UserMapper;
import com.demo.pojo.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.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class AnnotationTest {

    private UserMapper userMapper;

    @Before
    public void before() throws IOException {
        // 1.Resources工具类，配置文件的加载，把配置文件加载成字节输入流
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 2.解析了配置文件，并创建了sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        // 3.生成sqlSession （默认开启一个事务，但是该事务不会自动提交， 参数为true为自动提交）
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        userMapper = sqlSession.getMapper(UserMapper.class);
    }

    @Test
    public void testSelect(){
        List<User> users = userMapper.selectAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void testInsert(){
        User user = new User();
        user.setId(6);
        user.setUsername("测试数据");
        userMapper.addUser(user);
        testSelect();
    }

    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(6);
        user.setUsername("修改测试数据");
        userMapper.updateUser(user);
        testSelect();
    }

    @Test
    public void testDelete(){
        userMapper.deleteUser(6);
        testSelect();
    }
}

  • 使用注解开发时，sqlMapConfig.xml无需引入mapper.xml文件，但是仍需要引入Mapper接口类，

    <!-- 直接使用package扫描mapper接口 -->
<mappers>
    <package name="com.demo.mapper"/>
</mappers>

或者

<!-- 直接使引入指定的mapper接口 -->
<mappers>
    <mapper name="com.demo.mapper.UserMapper"/>
</mappers>

MyBatis基于注解实现复杂映射开发

实现复杂关系映射之前我们可以在映射文件通过配置resultMap实现，使用注解开发后，我们可以使用@Results、@Result、@One、@Many 注解组合完成复杂关系的配置

注解说明
@Results代替的标签是，该注解中可以使用单个@Result注解，也可以使用@Result集合。使用格式：@Results({@Result( ), @Result( ) }) 或者@Results(@Result() )
@Result代替了标签和标签
@Result中属性介绍
column：数据库中的列名
property ：实体类中的属性名
one：需要使用的@One注解 (@Result (one = @One) ())
many：需要使用的@Many注解 (@Result (many = @Many) ())

一对一查询

查询需求：查询订单，并同时把订单所属的用户一起查出来

对应的SQL语句：

select * from orders;
select * from user where id=查询出的订单uid;

原先用mapper.xml写的resultMap与sql语句

<!-- 手动配置实体属性与表字段的映射关系 -->
<resultMap id="orderAndUser" type="com.demo.pojo.Order">
    <result property="id" column="id"/>
    <result property="orderTime" column="order_time"/>
    <result property="total" column="total"/>
    <association property="user" javaType="com.demo.pojo.User">
        <result property="id" column="uid"/>
        <result property="username" column="username"/>
    </association>
</resultMap>

<select id="findAll" resultMap="orderAndUser">
    select * from `order`,user where `order`.uid=user.id
</select>

现在在mapper接口使用注解：

public interface OrderMapper {

    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "orderTime", column = "order_time"),
            @Result(property = "total", column = "total"),
            @Result(property = "user", column = "uid", javaType = User.class, one = @One(select = "com.demo.mapper.UserMapper.findById")),
    })
    @Select("select * from `order`")
    List<Order> findOrderAndUser();
}

对应的UserMapper：

public interface UserMapper {

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

}

这里执行的sql语句如下：

==>  Preparing: select * from `order` 
==> Parameters: 
<==    Columns: id, order_time, total, uid
<==        Row: 1, 2019-12-12, 3000, 1
====>  Preparing: select * from user where id = ? 
====> Parameters: 1(Integer)
<====    Columns: id, username
<====        Row: 1, 张三
<====      Total: 1
<==        Row: 2, 2019-12-12, 4000, 1
<==        Row: 3, 2019-12-12, 5000, 2
====>  Preparing: select * from user where id = ? 
====> Parameters: 2(Integer)
<====    Columns: id, username
<====        Row: 2, coco
<====      Total: 1
<==      Total: 3
Order{id=1, orderTime='2019-12-12', total=3000.0, uid=null, user=User{id=1, username='张三', orderList=[]}}
Order{id=2, orderTime='2019-12-12', total=4000.0, uid=null, user=User{id=1, username='张三', orderList=[]}}
Order{id=3, orderTime='2019-12-12', total=5000.0, uid=null, user=User{id=2, username='coco', orderList=[]}}

MyBatis底层是先把所有订单查出来，再用订单的uid，使用@One 调用 com.demo.mapper.UserMapper.findById 接口。

一对多

查询需求：查询用户，并同时把用户的所有订单一起查出来

对应的SQL语句：

select * from user; 
select * from orders where uid=查询出用户的id;

原先用mapper.xml写的resultMap与sql语句

<resultMap id="userMap" type="com.demo.pojo.User">
    <result property="id" column="id"/>
    <result property="username" column="username"/>
    <collection property="orderList" ofType="com.demo.pojo.Order">
        <result property="id" column="id(1)"/>
        <result property="orderTime" column="order_time"/>
        <result property="total" column="total"/>
    </collection>
</resultMap>

<select id="findUserOrders" resultMap="userMap">
    select * from user u left join `order` o on u.id=o.uid
</select>

现在在mapper接口使用注解：

public interface UserMapper {

    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "username", column = "username"),
            @Result(property = "orderList", column = "id", javaType = List.class,
                    many = @Many(select = "com.demo.mapper.OrderMapper.findOrderByUserId"))
    })
    @Select("select * from user")
    List<User> findUserOrderList();
}

对应的UserMapper：

public interface UserMapper {

    /**
     * 根据uid查订单
     * @param id 用户id
     * @return
     */
    @Select("select * from `order` where uid = #{uid}")
    List<Order> findOrderByUserId(Integer uid);

}

这里执行的sql语句如下：

==>  Preparing: select * from user 
==> Parameters: 
<==    Columns: id, username
<==        Row: 1, 张三
====>  Preparing: select * from `order` where uid = ? 
====> Parameters: 1(Integer)
<====    Columns: id, order_time, total, uid
<====        Row: 1, 2019-12-12, 3000, 1
<====        Row: 2, 2019-12-12, 4000, 1
<====      Total: 2
<==        Row: 2, coco
====>  Preparing: select * from `order` where uid = ? 
====> Parameters: 2(Integer)
<====    Columns: id, order_time, total, uid
<====        Row: 3, 2019-12-12, 5000, 2
<====      Total: 1
<==        Row: 3, kk
====>  Preparing: select * from `order` where uid = ? 
====> Parameters: 3(Integer)
<====      Total: 0
<==        Row: 4, ccham
====>  Preparing: select * from `order` where uid = ? 
====> Parameters: 4(Integer)
<====      Total: 0
<==        Row: 5, zz
====>  Preparing: select * from `order` where uid = ? 
====> Parameters: 5(Integer)
<====      Total: 0
<==      Total: 5
User{id=1, username='张三', orderList=[Order{id=1, orderTime='null', total=3000.0, uid=1, user=null}, Order{id=2, orderTime='null', total=4000.0, uid=1, user=null}]}
User{id=2, username='coco', orderList=[Order{id=3, orderTime='null', total=5000.0, uid=2, user=null}]}
User{id=3, username='kk', orderList=[]}
User{id=4, username='ccham', orderList=[]}
User{id=5, username='zz', orderList=[]}

MyBatis底层是先把所有用户查出来，再用用户的id，使用@Many 调用 com.demo.mapper.OrderMapper.findOrderByUserId 接口。

多对多查询

以用户和角色为例，一个用户可以有多个角色，一个角色被授权给多个用户。

多对多查询需求：查询所有的用户，同时查询出该用户的所有角色

对应的sql语句：

select * from user;
select * from role r,user_role ur where r.id=ur.role_id and ur.user_id=用户id;

期望查询结果：
在这里插入图片描述
mapper接口使用注解：

public interface UserMapper {

    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "username", column = "username"),
            @Result(property = "roleList", column = "id", javaType = List.class,
                    many = @Many(select = "com.demo.mapper.RoleMapper.findRoleByUid")),
    })
    @Select("select * from user")
    List<User> findUserAndRole();
}

对应的RoleMapper：

public interface RoleMapper {

    /**
     * 根据用户ID查询拥有的角色
     * @param uid
     * @return
     */
    @Select("select * from role r,user_role ur where r.id=ur.role_id and user_id=#{uid}")
    List<Role> findRoleByUid(Integer uid);
}

这里执行的sql语句如下：

==>  Preparing: select * from user 
==> Parameters: 
<==    Columns: id, username
<==        Row: 1, 张三
====>  Preparing: select * from role r,user_role ur where r.id=ur.role_id and user_id=? 
====> Parameters: 1(Integer)
<====    Columns: id, role_name, user_id, role_id
<====        Row: 1, admin, 1, 1
<====        Row: 2, root, 1, 2
<====      Total: 2
<==        Row: 2, coco
====>  Preparing: select * from role r,user_role ur where r.id=ur.role_id and user_id=? 
====> Parameters: 2(Integer)
<====    Columns: id, role_name, user_id, role_id
<====        Row: 3, CEO, 2, 3
<====        Row: 4, CTO, 2, 4
<====      Total: 2
<==        Row: 3, kk
====>  Preparing: select * from role r,user_role ur where r.id=ur.role_id and user_id=? 
====> Parameters: 3(Integer)
<====      Total: 0
<==        Row: 4, ccham
====>  Preparing: select * from role r,user_role ur where r.id=ur.role_id and user_id=? 
====> Parameters: 4(Integer)
<====    Columns: id, role_name, user_id, role_id
<====        Row: 4, CTO, 4, 4
<====      Total: 1
<==        Row: 5, zz
====>  Preparing: select * from role r,user_role ur where r.id=ur.role_id and user_id=? 
====> Parameters: 5(Integer)
<====      Total: 0
<==      Total: 5
User{id=1, username='张三', orderList=[], roleList=[Role{id=1, roleName='null'}, Role{id=2, roleName='null'}]}
User{id=2, username='coco', orderList=[], roleList=[Role{id=3, roleName='null'}, Role{id=4, roleName='null'}]}
User{id=3, username='kk', orderList=[], roleList=[]}
User{id=4, username='ccham', orderList=[], roleList=[Role{id=4, roleName='null'}]}
User{id=5, username='zz', orderList=[], roleList=[]}

MyBatis底层是先把所有用户查出来，再用用户的id，使用@Many 调用 com.demo.mapper.RoleMapper.findRoleByUid 接口。

章全蛋
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis（三、注解开发）
xmp
08-07 940
实现复杂关系映射之前我们可以在映射文件中通过配置来实现，使用注解开发后，我们可以使用@Results注解 ，@Result注解，@One注解，@Many注解组合完成复杂关系的配置。​ 修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可。这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。.........
MyBatis注解开发详解
weixin_61034310的博客
03-12 802
MyBatis可以使用简单的XML或注解来配置和映射原始类型、接口和Java POJO（Plain Old Java Objects，普通的Java对象）为数据库中的记录。当然，注解方式并不完全替代XML配置方式，两者可以混合使用，根据项目的实际情况选择最适合的配置方式。Spring Boot提供了自动配置的功能，你只需要添加相应的依赖和配置，Spring Boot就会为你自动配置好MyBatis。在MyBatis中，注解提供了一种更加简洁和直观的方式来配置SQL语句，而无需编写大量的XML配置文件。
Mybatis基础总结-基于注解开发
lw的博客
07-09 304
注解可以简化开发操作，省略映射配置文件的编写。常用注解@Select(“查询的 SQL 语句”)：执行查询操作注解@Insert(“查询的 SQL 语句”)：执行新增操作注解@Update(“查询的 SQL 语句”)：执行修改操作注解@Delete(“查询的 SQL 语句”)：执行删除操作注解配置映射关系< mappers > < package name = " 接口所在包 " />
Mybatis注解开发（超详细）
最新发布
2401_84152126的博客
04-13 1012
后记总结一下这三次面试下来我的经验是：一定不要死记硬背，要理解原理，否则面试官一深入就会露馅！代码能力一定要注重，尤其是很多原理性的代码（之前两次让我写过Node中间件，Promise.all，双向绑定原理，被虐的怀疑人生）！尽量从面试官的问题中表现自己知识的深度与广度，让面试官发现你的闪光点！多刷面经！
mybatis基于注解的开发方式
qq_41699954的博客
08-24 226
一、基本步骤 创建主配置文件SqlMapConfig.xml <?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"> <!-- mybatis的住配置文件 --> <configur
【MyBatis】基础篇(十四) MyBatis基于注解开发
不想当架构师的程序员不是好程序员
08-19 1656
MyBatis·基础篇(十四) MyBatis基于注解开发 1. mybatis 的常用注解说明 常见注解 作用 @Insert 实现新增 @Update 实现更新 @Delete 实现删除 @Select 实现查询 @Result 实现结果集封装 @Results 可以与@Result 一起使用，封装多个结果集 @ResultMap 实现引用@Resu...
Mybatis基于注解实现多表查询功能
08-25
Mybatis基于注解实现多表查询功能可以简化配置，提高开发效率。使用Mybatis框架中的注解可以灵活地配置多表查询，满足不同的业务需求。本文介绍了Mybatis基于注解实现多表查询功能的基本概念、优点、步骤和示例代码...
Java 8 开发的 Mybatis 注解代码生成工具
08-25
MybatisAnnotationTools 是基于 Java8 开发的一款可以用于自动化生成 MyBatis 注解类的工具，支持配置数据源、类路径，表名去前缀、指定类名前后缀等功能.这篇文章主要介绍了Java 8 开发的 Mybatis 注解代码生成工具...
MyBatis基于注解简单案例
07-28
在这个基于注解的简单案例中，我们将深入探讨如何使用MyBatis进行基本的数据操作：增加、删除、修改和查询。 首先，我们需要在项目中引入MyBatis的依赖库。通常，这可以通过Maven或Gradle的配置来完成。在Maven的...
Spring与Mybatis基于注解整合Redis的方法
09-01
在Java开发中，Spring和Mybatis是两个非常流行的框架，用于管理和操作数据库。Redis则是一个高性能的键值存储系统，常用于缓存数据以提高应用性能。本文将详细讲解如何在Spring和Mybatis项目中使用注解来整合Redis，...
Mybatis基于注解形式的sql语句生成实例代码
08-29
Mybatis基于注解形式的sql语句生成实例代码是指使用Mybatis框架提供的注解形式来生成sql语句，以提高开发效率和代码可读性。 在Mybatis中，使用注解形式可以将sql语句与java代码紧密耦合，实现了sql语句的动态生成...
mybatis 注解+配置文件方式完整例子
02-26
mybatis 注解+配置文件方式完整例子 包含数据库的sql文件. 所有方法都有注解, 很明了.不知道为啥这个所需积分竟然逐步增长了，描述文字也50起步了。。
mybatis之基于注解开发
a207551的博客
08-21 270
ssm
Mybatis-基于注解开发基础介绍
WJY
08-26 171
注解开发 注解和XML标签对应关系 注解 注解属性 XML标签 XML标签属性 CURD 一对以 一对多
@mapper注解的使用_SpringBoot-Mybatis通用mapper使用
weixin_39540315的博客
11-27 342
mybatis是一个很好用的工具，但是编写mapper是一件很麻烦的事，自mybatis 3.0开始可以使用注解的方式，极大的简化了xml的编写量，本地想看看mybatis源码，自己扩展写一个工具，在阅读源码过程中发现一个通用mapper的工具包，感觉不用重复造轮子了，简要记录一下spring boot整合通用mapper的使用。 确保可以正常使用mybatis pom引入依赖包，starte...
Spring整合MyBatis、全注解开发
qq_40843987的博客
07-10 1073
小插曲： 连接数据库报错Can’t connect to local MySQL server through socket /tmp/mysql.sock，看了很多解决方法都跟自身情况不符，结果点了一下 系统偏好设置——下面MySQL服务——Initialize DataBase——Use Legacy Password——设置新密码——OK，就好了。。 准备 项目目录： dao层接口4个抽象方法： service层接口抽象方法同dao层。 service层实现类，声明dao对象，定义
基于注解应用MyBatis 自用解析
cq724165616的博客
03-22 122
基于注解 一:mybatis常用注解说明 @Insert:实现新增 @Update:实现更新 @Delete:实现删除 @Select:实现查询 @Result:实现结果集封装 @Results:可以与@Result 一起使用，封装多个结果集 @ResultMap:实现引用@Results 定义的封装 @One:实现一对一结果集封装 @Many:实现一对多结果集封装 @SelectProvi...
MyBatis_通用mapper注解开发
qq_44509920的博客
07-26 1534
文章目录9. 通用mapper注解开发9.1. 通过mapper入门案例9.1.1. 添加mapper依赖9.1.2. 相关配置文件- jdbc.properties- mybatis-config.xml- log4j.properties9.13. 集成通用mapper9.1.4. 添加表和类品牌表brands实体类Brands9.1.5. 接口继承通用mapper9.1.6. 测试9.2. ORM9.2.1. @Table (JPA)9.2.2. @Id (JPA)9.2.3. 主键策略9.2.4.
注解开发mybatis
08-22
在使用注解开发MyBatis时，首先需要在Mapper接口的方法上添加对应的注解来映射SQL语句。常用的注解包括： 1. @Select：用于查询操作，可以指定SQL语句或调用已定义的SQL语句。 2. @Insert：用于插入操作，可以指定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值