五、mybaitis学习 ——代理方式面向注解编程(mybatis三种编程方式之一)

最新推荐文章于 2023-12-05 13:32:39 发布
最新推荐文章于 2023-12-05 13:32:39 发布
阅读量215 收藏
点赞数
分类专栏： 1mybaitis学习 文章标签： java mybatis 注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/houysx/article/details/79916490
版权

五、mybaitis学习 ——代理方式面向注解编程(mybatis三种编程方式之一)

一、常用注解

   @Select：查询
   @Update：修改
   @Insert：添加
   @Delete：删除
   @Options：可用于设置封装自增长主键
   @Results：用法类是配置文件的ResultMap 
   @Result：用于配置表字段和javaBean字段的的关联关系
   @many:用于封装关联对象为集合
   @one:：用于封装关联对象为javaBean实体

二、注解的属性

   1.   select update insert delete 注解中的value
    该值用于保存sql语句
    说明：对于增删改三个注解之间在mybatis中其实可以混用，这个主要取决于mybatis底层的工作机制，在执行增删改的操作时最终统一调用的都是update方法
   2.Options ：主要介绍有2个属性
   1）useGeneratedKeys = true：设置添加完成后封装自增长主键
   2）keyProperty = "id"：设置封装的字段名为id
   说明：这两个属性必须同时使用才有效，用法同xml配置类似
  3.@Results：此注解相当于配置文件的ResultMap ，主要介绍一个属性value 
         value:属性的值为一个注解集合,用于设置表和实体的关联关系   
  4.@Result  
   1）column  值为表字段名
   2)  property 值为JavaBean实体字段名
   3)  many  值固定为@many注解，用于配置一对多关联关系，及引用的是封装了javaBean的集合
   4)  one  值固定为@one注解，用于配置一对一关联关系，及引用的是一个javaBean实体
   5.@many:  @one: 均有两个属性
   1）select：引用的从表sql语句
   2）fetchType：主要介绍一个值FetchType
        其中FetchType又有三个值（类型为枚举），这里只介绍两个
                 a.EAGER 不使用延迟加载（one可以使用）
                 b.LAZY 使用延迟加载（many推荐使用）
  说明：注解的多表查询使用的是延迟加载的模式，主要依赖于@many @one两个注解

三、实例说明1.简单的增删改查

1、javaBean实体

账户:
public class Account implements Serializable{
    private Integer aid;
    private Integer userId;
    private Double userMoney;
    private User user;

    public Account() {
    }

    public Account(Integer aid, Integer userId, Double userMoney, User user) {
        this.aid = aid;
        this.userId = userId;
        this.userMoney = userMoney;
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getAid() {
        return aid;
    }

    public void setAid(Integer aid) {
        this.aid = aid;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public Double getUserMoney() {
        return userMoney;
    }

    public void setUserMoney(Double userMoney) {
        this.userMoney = userMoney;
    }

    @Override
    public String toString() {
        return "Account [aid=" + aid + ", userId=" + userId + ", userMoney=" + userMoney + ", user=" + user + "]";
    }

}






用户：
public class User implements Serializable{

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<Account> accounts;

    public User() {
    }

    public User(Integer id, String username, Date birthday, String sex, String address, List<Account> accounts) {
        this.id = id;
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
        this.accounts = accounts;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address="
                + address + ", accounts=" + accounts + "]";
    }
}

2简单的增删该查

用户dao：
public interface UserDao {

    /**
     *根据id查询用户
     *@Select：用于查询的注解 
     */
    @Select("select * from user where id =#{uid}")
    User getUserByUid(Integer uid);

    /**
     *模糊查询用户
     * ${value}：基于statement的字符拼接
     */
    @Select("select * from user where username like '%${value}%'")
    List<User> fuzzyQueryUserByUname(String username);

    /**
     *添加用户
     *@Insert：用于添加的注解 
     *@Options：可以设置封装自增长主键，用法类似基于配置文件编程方式
     *useGeneratedKeys = true：设置添加完成后封装自增长主键
     *keyProperty = "id"：设置封装的字段名为id
     *
     */
    @Insert("insert into user (username,sex,birthday,address) values(#{username},#{sex},#{birthday},#{address})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insertUser(User user);

    /**
     *修改用户，通过用户id
     *@Update：用于修改的注解 
     */
    @Update("update user set username = #{username} where id =#{id}")
    int update(User user);

    /**
     *删除用户，通过用户id
     *@Update：用于删除的注解 
     */
    @Delete("delete from user where id =#{id}")
    int delete(Integer i);
}

3一对多

用户dao：
public interface UserDao {

    /**
     *根据查询所有用户，并且封装关联对象accounts账户
     *@Select：用于查询的注解 
     *@Results:用法类是配置文件的ResultMap 
     *@Result：用于配置表字段和javaBean字段的的关联关系
     *column：1表字段，
     *        2在进行关联对象配置时，则代表用于查询分表的关联字段，相当于Xml中的ofType,javaType
     *property：javaBean
     *many:1当封装的关联对象为集合是，可以用many进行关联配置，相当于XML配置文件collection标签的作用
     *     2值固定为注解@many
     *one:1当封装的关联对象为javaBean实体时，可以用one进行关联配置，相当于XML配置文件association标签的作用
     *    2值固定为注解@one
     *select:@many或者@one注解中的select代表的关联字段sql语句的引用(包全限定名+方法名)，
     * fetchType=FetchType.LAZY 使用延迟加载（一对多建议使用言辞加载）
     * FetchType 主要使用的有两个值 LAZY(延迟加载) EAGER(及时加载)
     */

    @Results(value = {
             @Result(column="id",property="id"),
             @Result(column="username",property="username"),
             @Result(column="sex",property="sex"),
             @Result(column="birthday",property="birthday"),
             @Result(column="address",property="address"),
             @Result(
                property="accounts",
                column="id",
                many=@Many(

                        select="cn.itcast.demo.dao.AccountDao.getAccountByUid",
                        fetchType=FetchType.EAGER)),
    })
    @Select("select * from user")
    List<User> getAll();
}

账户dao:
public interface AccountDao  {

    /**
     *根据id查询账户
     *@Select：用于查询的注解
     *当javaBean和表字段名称不同时：
     *     1可以通过起别名的方式进行封装，
     *     2也可以通过Results进行关联配置 
     */
    @Select("select id aid ,uid userId ,money userMoney from account where uid = #{uid}")
    List<Account> getAccountByUid(Integer uid);
}

4一对一

账户dao：
public interface AccountDao  {

    List<Account> findAll(Account ac);
    /**
     *根据查询所有用户，并且封装关联对象accounts账户
     *@Select：用于查询的注解 
     *@Results:用法类是配置文件的ResultMap 
     *@Result：用于配置表字段和javaBean字段的的关联关系
     *column：1表字段，
     *        2在进行关联对象配置时，则代表用于查询分表的关联字段，相当于Xml中的ofType,javaType
     *property：javaBean
     *many:1当封装的关联对象为集合是，可以用many进行关联配置，相当于XML配置文件collection标签的作用
     *     2值固定为注解@many
     *one:1当封装的关联对象为javaBean实体时，可以用one进行关联配置，相当于XML配置文件association标签的作用
     *    2值固定为注解@one
     *select:@many或者@one注解中的select代表的关联字段sql语句的引用(包全限定名+方法名)，
     * fetchType=FetchType.EAGER 不使用延迟加载（一对一可以不使用延迟加载）
     * FetchType 主要使用的有两个值 LAZY(延迟加载) EAGER(及时加载)
     */
    @Results({
        @Result(column="id",property="aid"),
        @Result(column="uid",property="userId"),
        @Result(column="money",property="userMoney"),
        @Result(
                column="uid",
                property="user",
                one=@One(select="cn.itcast.demo.dao.UserDao.getUserByUid",
                         fetchType=FetchType.EAGER)),


    })
    @Select("select * from account")
    List<Account> getAll();

}

用户dao：

public interface UserDao {

    /**
     *根据id查询用户
     *@Select：用于查询的注解 
     */
    @Select("select * from user where id =#{uid}")
    User getUserByUid(Integer uid);

}

5.user测试类

public class testUser {

    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void befor() throws Exception {
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

    }
    @Test
    public void testgetAll() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.getAll();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void testfuzzyQueryUserByUname() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.fuzzyQueryUserByUname("王");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void testInsert() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = new User();
        user.setUsername("cting");
        user.setBirthday(new Date());
        user.setSex("女");
        int row = userDao.insertUser(user);
        System.out.println(user);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void testUpdate() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = new User();
        user.setUsername("徐");
        user.setId(91);
        int row = userDao.update(user);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void testDel() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        int row = userDao.delete(56);
        sqlSession.commit();
        sqlSession.close();
    }



}

6.account测试类


public class testAccount {

    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void befor() throws Exception {
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

    }

    @Test
    public void testgetAll() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
        List<Account> accounts = accountDao.getAll();
        for (Account account : accounts) {
            System.out.println(account);
        }
        sqlSession.close();
    }

    @Test
    public void testgetbyuid() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
        List<Account> accounts = accountDao.getAccountByUid(41);
        for (Account account : accounts) {
            System.out.println(account.getUserMoney());

        }
        sqlSession.commit();
        sqlSession.close();

        System.out.println("========================================");
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        AccountDao accountDao1 = sqlSession1.getMapper(AccountDao.class);
        List<Account> accounts1 = accountDao1.getAccountByUid(41);
        for (Account account1 : accounts1) {
            System.out.println(account1.getUserMoney());
        }
        sqlSession1.close();

    }

}
houysx
关注
专栏目录
MyBatis注解开发之一对多查询
流楚丶格念的博客
07-04 2398
实现复杂关系映射之前我们可以在映射文件中通过配置来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置 一对多查询的需求：查询一个课程，与此同时查询出该该课程对应的学生信息 对应的sql语句： 1.3 创建StudentMapper接口 1.4 使用注解配置Mapper 1.5 测试类 运行结果如下：...
使用注解开发（重点）
qq_46423017的博客
08-25 242
面向接口编程、使用注解开发、CRUD
手撕Java注解，从此面向注解编程！
Ahahaha0303的专栏
04-05 835
注解概念 Java 注解（Annotation），是 JDK5.0 引入的一种注释机制。Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。注解可以被看作是对 一个 类/方法 的一个扩展的模版，按照注解类中的规则，处理不同的逻辑。 注解的作用： 编写文档：通过代码里标识的注解生成文档 编译检查：通过代码里标识的注解让...
Java面向对象编程（注解）
chars_lana的博客
12-08 258
注解 描述： 1) 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。 2) 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。 3) 在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等。 三个基本的 Annotation: .
面向注解编程—Spring 注解看这一篇就够了
最新发布
克克克克业业的学习记录
12-05 717
Spring的一个核心功能是IOC，就是将Bean初始化加载到容器中，调用的时候直接注入即可，使用注解可以大大提高了开发效率！。Bean英文意为 豆子 理解起来就是豆荚里的豌豆，豆荚就是Spring 容器。
Room的使用（对sqlite的封装，面向注解编程）
xiyangyang8110的博客
07-13 341
1允许使用androidx gradle.properties android.useAndroidX=true android.enableJetifier= true 2build.gradle 引入room依赖 // Room的支持 def room_version = "2.2.0-alpha01" implementation "androidx.room:room-runtime:$room_version" // Room 的 APi支持 annotationPro
【MyBatis学习笔记五】——MyBatis注解的简单使用.zip
05-30
【MyBatis学习笔记五】——MyBatis注解的简单使用.zip 博客地址：https://blog.csdn.net/weixin_43817709/article/details/117407621
mybatis学习笔记之mybatis注解配置详解
08-28
MyBatis 的注解配置提供了一种简单的方式来实现简单映射语句，而不会引入大量的开销。常用的 MyBatis 注解包括： * `@CacheNamespace`：定义在该命名空间内允许使用内置缓存 * `@CacheNamespaceRef`：定义缓存引用 ...
SpringMvc+Spring+Mybatis+Maven+注解方式=整合
08-22
"SpringMvc+Spring+Mybatis+Maven+注解方式"是一个经典的Java后端技术栈，它整合了四个关键组件，为开发人员提供了强大的工具和框架支持。下面将详细讲解这四个组件及其整合方式。 1. **Spring Framework**： ...
【MyBatis学习笔记一】——MyBatis入门demo.zip
05-28
【MyBatis学习笔记一】——MyBatis入门demo.zip 博客地址：https://blog.csdn.net/weixin_43817709/article/details/117370755
面向注解开发
面对疾风吧
12-23 431
面向注解开发，案例、测试
Spring开发中常用的注解（面向注解开发）
weixin_51493673的博客
07-02 1192
Spring的常用注解大全
自定义注解和aop面向切面编程
weixin_51969378的博客
04-13 170
【代码】自定义注解和aop面向切面编程。
自定义注解+AOP实现面向切面编程
mollen的博客
12-18 381
一、自定义注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface AroundInterceptor { String value() default ""; } 二、切面方法 @RestController public class MyContr...
Mybatis 代理dao的开发 基于注解
amazing_Code的博客
09-13 256
代理Dao的开发需要遵守的规范： A:将映射文件和接口放在同一个包中并文件的主文件名相同 B:映射文件的命名空间必须是接口的完整包名+接口名，即接口地址 C:映射文件中的mappedstatementId的值必须和接口的方法名相同 D:输入映射参数的类型必须和接口中方法的形参的数据类型相同 E:输出映射参数的类型必须和接口中方法返回值的数据类型相同(如果返回单个对象类型必须相同，如果返回...
面向切面编程spring AoP（自定义注解）
刘金金777的成神之路
09-22 1372
spring AoP自定义注解
Spring学习笔记【十五】注解编程
weixin_46100927的博客
02-12 1116
《Spring》学习笔记
深入探究注解的原理与实现
xiaoliangtx的博客
06-02 182
注解这个东西自从SpringBoot以来一直是Java开发者们必备的生存技巧呀，我们平时几乎大部分时间都是面向注解编程，通过注解我们可以节约大量的时间。用过了这么多的注解，那么我们否有关注过注解的实现原理呢？所以本篇文章主要是讲述注解的有关操作，自己实现一个注解来体会注解的实现原理，注解也不是特别高深的东西，掌握了自然就明白了。 注解的基本原理 注解本来的意思就是用来做标注用：可以在类、字段变量、方法、接口等位置进行一个特殊的标记，为后续做一些诸如: 代码生成、数据校验、资源整合等工作做铺垫。所以注解就是做
java注解
竞仔今天也要努力码一千字
09-29 296
@Retention 注解的生命周期 @Target 注解范围 @Document 注解是否生成在javadoc文档中 @Inherited 子类可以继承父类中的该注解 @interface 声明自定义注解 在内部定义的属性是参数 @Target({ElementType.METHOD,ElementType.ANNOTATION_TYPE}) public @interface Test { //当只有一个参数且名字叫value时可以不写value= String value() ; //
Mybatis注解方式实现SQL语句生成示例
在Mybatis中，注解形式的SQL语句生成提供了一种简洁的方式来映射Java对象与数据库表之间的关系，简化了XML配置文件的编写。本文介绍的实例主要关注如何通过自定义注解实现这一功能。 首先，@Column注解用来标记实体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值