mybatis-注解

最新推荐文章于 2025-07-09 12:43:49 发布
最新推荐文章于 2025-07-09 12:43:49 发布
阅读量354 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： # mybatis 文章标签： java mybatis
原文链接：https://editor.csdn.net/md?not_checkout=1&articleId=120240360

mybatis-注解

一. mybatis的常用注解整理

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

二. 注解实现基本的CRUD

crud是指在做计算处理时的增加(Create)、检索(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写

1. 实体类User

package com.domain;
import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
   // get set 省略
}

2. 持久层接口 IUserDao

package com.dao;

import com.domain.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.util.List;

/**
 * mybatis中针对CRUD一共有四个注解
 * @Select @Insert @Update @Delete
   通过注解查询的方式, 可以省去编写 IUserDao.xml
   注: #{xxx}  为占位符, 实现预编译, 防止sql 注入漏洞 ,  ${xxx}  仅仅字符串拼接 , 有sql注入风险 
   
 */ 
public interface IUserDao {

    /**
     * 查询所有用户
     */
    @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
     */
    @Select("select * from user where id=#{id}")
    User findById(Integer userId);

    /**
     * 根据用户名称模糊查询
     * @param username
     */
    //@Select("select * from user where username like #{username}") //占位符
    @Select("select * from user where username like '%${value}%'")  //字符串拼接
    List<User> findByName(String username);

    /**
     * 查询总数量
     */
    @Select("select count(*) from user")
    int findTotal();
}

3. 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">
<configuration>
    <!--引入外部配置文件-->
    <properties resource="jdbcConfig.properties"></properties>
    <!--配置别名-->
    <typeAliases>
        <package name="com.keafmd.domain"/>
    </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>
    <!--指定带有注解的dao接口所在位置-->
    <mappers>
        <package name="com.dao"></package>
    </mappers>
</configuration>

4. 测试

package com.test;
import com.dao.IUserDao;
import com.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;

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 destory() throws Exception{
        session.commit();
        session.close();
        in.close();
    }

    @Test
    public void testSave(){
        User user = new User();
        user.setUsername("mybatis annotation");
        user.setAddress("北京");

        userDao.saveUser(user);
    }

    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(55);
        user.setUsername("mybatis annotation");
        user.setAddress("阿富汗");
        user.setSex("男");
        user.setBirthday(new Date());

        userDao.updateUser(user);
    }

    @Test
    public void testDelete(){
        userDao.deleteUser(54);
    }

    @Test
    public void testFindOne(){
        User user = userDao.findById(55);
        System.out.println(user);
    }

    @Test
    public void testFindByName(){
        //List<User> users = userDao.findByName("%sadami%");
        List<User> users = userDao.findByName("sadami");
        for (User user : users) {
            System.out.println(user);
        }
    }

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

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

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

1. 复杂关系映射的注解说明

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

  2. @Resutl 注解
    代替了 标签和标签
    @Result 中的属性介绍：

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

  1. @One 注解（一对一）
    代替了标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。
    @One 注解属性介绍：
    select 指定用来多表查询的 sqlmapper
    fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。
    使用格式：@Result(column=" “,property=”",one=@One(select=""))

  2. @Many 注解（多对一）
    代替了标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。
    注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义。
    使用格式：@Result(property="",column="",many=@Many(select=""))

2. 一对一 示例

使用注解实现一对一复杂关系映射及立即加载
需求：加载账户信息时并且加载该账户的用户信息，根据情况可实现立即加载。（注解方式实现）

1. 添加 User 实体类及 Account 实体类

用户类 User:

package com.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {
    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;
    // get set  省略
}

账户实体类 Account:

package com.domain;

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //多对一（mybatis中称之为一对一）的映射，一个账户只能属于一个用户 *
    private User user;
    // get set  省略...
}

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

IAccountDao：

package com.dao;
import com.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;

public interface IAccountDao {
    /**
     * 查询所有账户，并且获取每个账户下的用户信息,一对一
       fetchType= FetchType.EAGER   立即加载
     */
    @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(property = "user",column = "uid",one=@One(select="com.dao.IUserDao.findById",fetchType= FetchType.EAGER))
    })
    List<Account> findAll();
}

3. 测试一对一关联及立即加载

package com.test;

import com.dao.IAccountDao;
import com.dao.IUserDao;
import com.domain.Account;
import com.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;

public class AccountTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IAccountDao accountDao;

    @Before
    public void init() throws Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        accountDao = session.getMapper(IAccountDao.class);
    }

    @After
    public void destory() throws Exception{
        session.commit();
        session.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for (Account account : accounts) {
            System.out.println("-----每个账户信息-----");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

}

3. 一对多示例

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

需求：查询用户信息时，也要查询他的账户列表。使用注解方式实现。
分析：一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。

1. 修改 User 实体类加入 List

package com.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {
    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;
    //一对多关系映射：一个用户对应多个账户
    private List<Account> accounts;

    // 省略 get  set  ....
}

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

package com.dao;
import com.domain.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;

// 一对多示例
//  fetchType = FetchType.LAZY  懒加载
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id="userMap",value={
            @Result(id = true,column = "id",property = "userId"),
            @Result(column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "sex",property = "userSex"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(property = "accounts" ,column = "id",
                    many = @Many(select = "com.dao.IAccountDao.findAccountByUid",
                            fetchType = FetchType.LAZY))
    })
    List<User> findAll();

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

    /**
     * 根据用户名称模糊查询
     * @param username
     */
    @Select("select * from user where username like #{username}") //占位符
    @ResultMap("userMap")
    List<User> findByName(String username);
}

3. 一对多测试

package com.test;
import com.dao.IUserDao;
import com.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;

public class UserTest {
    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 destory() throws Exception{
        session.commit();
        session.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("-----每个用户的信息");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }
}
Mybatis 之九：MyBatis 注解
zp8126的专栏
03-16 2029
在 MyBatis 框架中，注解可以用于替代或补充 XML 映射文件来实现 SQL 语句的映射。使用注解可以使代码更简洁，减少配置文件的工作量，特别适用于简单场景和快速开发。使用@Results() 注解时，通过id属性来唯一标识结果映射，其他的方法可以通过 @ResultMap()直接引用。所以需要修改对应的 IEmpDao 和 IDeptDao 两个接口，那这样就需要在配置文件中同时配置两个dao的。修改员工持久接口 IEmpDao，新增通过部门编号查询员工列表的方法。修改 IDeptDao 接口。
Mybatis注解
m0_50744075的博客
08-21 542
Mybatis注解
SpringBoot系列—MyBatis（注解使用）
最新发布
sniper_fandc的博客
07-09 985
由于使用aliyun创建的项目是该依赖，因此在MyBatis中就没有办法在多个参数的SQL中使用方法参数名=#{参数名}的方式传入参数了。这里所做的就是把方法参数id和deleteFlag分别赋值给@Param("id")和@Param("deleteFlag")中的参数，此时MyBatis使用@Select注解就可以识别#{}中填写的参数名了，注意：@Param(参数名)必须和#{参数名}对应。使用#{}表示要传递的参数，其中要填的值在单个参数的情况下，不用和方法的参数名称一样，也不会出错。
mybatis-generator实体类带注释
11-17
mybatis逆向工程兼容oracle实体生产注释。
mybatis实体类注解_SpringBoot2.x系列教程43--整合使用Mybatis
weixin_39524425的博客
12-18 836
SpringBoot2.x系列教程43--整合使用Mybatis作者：一一哥在上一节中，我带大家学习了Spring Boot中整合JPA，那接下来这一章节中，我继续带领大家学习如何在Spring Boot中整合Mybatis。一. Mybatis简介1. MyBatis概述MyBatis是一款优秀的持久层框架，它本来是apache的一个开源项目iBatis。在2010年的时候，这个项目由apach...
mybatis利用注解解决实体类与数据库列名不一致问题
qq_39682037的博客
06-05 2998
mybatis利用注解解决实体类与数据库列名不一致问题 数据库设计 SET FOREIGN_KEY_CHECKS=0; -- ---------------------------- -- Table structure for user -- ---------------------------- DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username`
mybatis-3-config.dtd mybatis-3-mapper.dtd
10-13
MyBatis是一个流行的Java持久层框架，它简化了数据库操作，通过XML或注解的方式将SQL与Java代码绑定，提供了一种灵活的映射机制。在MyBatis中，`mybatis-3-config.dtd` 和 `mybatis-3-mapper.dtd` 是两个至关重要的...
mybatis-plus-join-SQL资源
06-23
mybatis-plus-join-SQL资源是一个强大的工具包，它通过提供扩展、适配器和注解等方式，为mybatis-plus增添了多表连接查询的能力。开发者可以利用这些工具来简化复杂SQL语句的编写，优化数据库操作，从而提升整体的...
mybatis-plus-annotation-3.5.3.jar
04-11
mybatis-plus-annotation.jar MP 注解 jar 包 mybatis-plus 的注解 jar 包，包含了 mybatis-plus 注解功能 各个版本
Mybatis代码生成工具(附带实体类中文注释)
06-13
重写mybatis-generator-core-1.3.2.jar包,生成底层实体（含中文注释）,生成的代码实体类有数据库的中文注解
MyBatis（三、注解开发）
xmp
08-07 1188
实现复杂关系映射之前我们可以在映射文件中通过配置来实现，使用注解开发后，我们可以使用@Results注解 ，@Result注解，@One注解，@Many注解组合完成复杂关系的配置。​ 修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可。这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。.........
mybatis自动生成实体(带中文注释)
08-09
mybatis自动生成实体类，实体属性带中文注释(数据库字段的注释),mapper和对应的xml
Mybatis插件，生成domain，mapper，xml，功能增强
u010698072的博客
11-01 741
Mybatis反向生成工具，插件增强 使用mybatis官方开发的插件包，便捷的进行数据库文件反向生成，为了更好更便捷的使用它， 自己对插件包做了一些功能增强，做了封装，简化配置和使用 1、增强功能介绍： 1、增加插件，控制生成domain类是否生成get和set方法，不生成get和set方法时，可以生成lombok简洁模式 2、增加插件，控制生成ExtMapper接口文件和对应的xml文件，可...
MyBatis：注解操作
子夜的个人博客
03-21 1780
MyBatis：注解操作
Mybatis教程 | 第八篇：Mybatis的注解配置
好记性不如烂笔头
03-02 4644
Mybatis为用户提供了快速的开发方式，因为有时候大量的XML配置文件的编写时非常繁琐的，因此Mybatis也提供了更加简便的基于注解(Annnotation)的配置方式。 Mybatis的注解位于org.apache.ibatis.annotations包下，常用的注解如下: 注解 说明 @Select 映射查询的SQL语句 @Insert 映射插入的SQL语句 ...
MyBatis中的注解
suwu150
10-25 9849
MyBatis中的注解 之前我们都是在映射器MapperXML配置文件中配置映射语句的。除此之外MyBatis也支持使用注解来配置映射语句。当我们使用基于注解的映射器接口时，我们不再需要在XML配置文件中配置了。如果你愿意，你也可以同时使用基于XML和基于注解的映射语句。 使用Person进行测试 drop table person; create table person( id number primary key, name varchar2(15), age number );public cl
MyBatis整理(注解方式)
weixin_44860598的博客
03-07 267
注解方式和xml配置方式不同处 不需要配置映射文件 在dao接口中完成注解 核心配置文件 <mappers> <mapper class="home.sise.cn.dao.IUserDao"></mapper> </mappers> 小注意，如果同时存在规范路径下的映射文件和注解，解析的会混乱 常用增删改操作 select...
Mybatis 注解
zzqtty的博客
08-03 565
 注解＠Component Spri ng IoC 会把这个类扫描生成 Bean 实例，而其中的 value 属性代表这个类在 pring 中的 ，这就相当于 XML 方式定义的 Bean id ，也可 以简写成＠Component（” role ”）， 甚至直接写成＠Component ，对于不写的， Spring IoC 容器就默认类名，但是以首字母小写的形式作为 id ，为其生成对象，配...
MyBatis-Plus注解3.1.0中文API文档完整版
- **Mybatis-Plus Annotation**: 这部分指的是Mybatis-Plus框架中的注解模块，它允许开发者使用Java注解来配置Mybatis，这种方式更为简洁明了，可以减少XML配置文件的编写。 - **API文档中文版**: API文档是开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值