mybatis框架学习-注解方式的crud，缓存，一对一，一对多

最新推荐文章于 2022-09-27 15:15:57 发布
最新推荐文章于 2022-09-27 15:15:57 发布
阅读量87 收藏
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/ccoonngg/p/11385183.html
版权

前期mysql准备

create database rainbow;
use rainbow;
CREATE TABLE `user` (
  `uid` int(11) NOT NULL auto_increment,
  `name` varchar(32) NOT NULL COMMENT '用户名称',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`uid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `account` (
  `aid` int(11) NOT NULL auto_increment,
  `uid` int(11) default NULL COMMENT '用户编号',
  `money` double default NULL COMMENT '金额',
  PRIMARY KEY  (`aid`),
  KEY `FK_Reference_8` (`uid`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`uid`) REFERENCES `user` (`uid`)

1.创建maven项目，导入依赖

<?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.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cong</groupId>
    <artifactId>mybatis_annotation</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId></groupId>
            <artifactId></artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

2.创建实体类

package com.cong.pojo;

import java.io.Serializable;

public class Account implements Serializable{
    private int id;
    private int uid;
    private double money;
    //多对一(Mybatis中称为一对一)的映射，一个account只能属于一个user
    private User user;
    public User getUser() {
        return user;
    }

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

    public int getId() {
        return id;
    }

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

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}




package com.cong.pojo;

import java.io.Serializable;
import java.util.List;

public class User implements Serializable{
    private int id;
    private String username;
    private char sex;
    private String addr;
    private List<Account> accounts;
    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 + '\'' +
                ", sex=" + sex +
                ", addr='" + addr + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public char getSex() {
        return sex;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }
}

3.创建mapper代理接口，因为是注解方式，crud全部在这里配置的

accountMpper接口

package com.cong.mapper;
/**
 * 这里演示一对一的查询
 * 以及基于注解的二级缓存配置
 */

import com.cong.pojo.Account;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;
@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface AccountMapper {
    //查询所有
    @Select("select * from account")
    @Results(id = "accountMap",value = {
            @Result(id = true, property = "id", column = "aid")
    })
    List<Account> findAll();
    //根据uid查询account
    @ResultMap(value = "accountMap")
    @Select("select * from account where uid = #{uid}")
    List<Account> findByUid(int i);
    //根据aid查询account
    @ResultMap(value = "accountMap")
    @Select("select * from account where aid = #{aid}")
    Account findById(int id);
    /**
     * 多对一(Mybatis中称为一对一)的映射，一个account只能属于一个user
     * @return
     */
    @Select("select * from account")
    @Results(id = "accountUserMap",value = {
            @Result(id = true,property = "id",column = "aid"),
            @Result(property = "money",column = "money"),
            @Result(property = "uid",column = "uid"),
            @Result(property = "user",column = "uid",
                    one = @One(select = "com.cong.mapper.UserMapper.findById",fetchType = FetchType.EAGER)
            ),
    })
    List<Account> findAcountAndUser();
}

usermapper接口

package com.cong.mapper;

import com.cong.pojo.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

/**
 * 这里演示crud的注解配置
 * 以及一对多的查询配置
 */
public interface UserMapper {
    /**
     注解@Results中提供了id属性这就跟xml文件中的id作用一样，下面引用的话可以用@ResultMap来引用。
     首先说明一下@Results各个属性的含义，
     id为当前结果集声明唯一标识，value值为结果集映射关系，
     @Result代表一个字段的映射关系，
     column指定数据库字段的名称，property指定实体类属性的名称，
     jdbcType数据库字段类型，@Result里的id值为true表明主键，默认false；
     使用@ResultMap来引用映射结果集，其中value可省略。
     */
    //查询所有
    @Results(id = "userMap",value = {
            @Result(property = "id", column = "uid",id = true),
            @Result(property = "username", column = "name")
    })
    @Select("select * from user")
    List<User> findAll();
    //根据id查询
    @Select("select * from user where uid = #{id}")
    @ResultMap(value = "userMap")
    User findById(int id);
    //根据名字模糊查询
    @Select("select * from user where name like #{name}")
    @ResultMap(value = "userMap")
    List<User> findByName(String name);
    //查询数量
    @Select("select count(*) from user")
    int findTotal();
    //插入
    @Insert("insert into user(name,sex,addr) values(#{username},#{sex},#{addr})")
    @Options(useGeneratedKeys = true,keyColumn = "uid",keyProperty = "id")//返回自增字段的id
    void saveUser(User user);
    //更新，在这name=#{username}，name是数据库的字段，username是实体类的属性
    @Update("update user set name=#{username},sex = #{sex},addr = #{addr} where uid  = #{id}")
    void updateUser(User user);
    //删除
    @Delete("delete from user where uid = #{uid}")
    void deleteUser(int id);
    /**
     * 以上单表操作
     * ----------------分界线-----------------
     * 以下多表操作
     */
    @Select("select * from user")
    @Results(id = "userAccountMap",value = {
            @Result(id = true,property = "id",column = "uid"),
            @Result(property = "username",column = "name"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "addr",column = "addr"),
            @Result(property = "accounts",column = "uid",
                    many = @Many(select = "com.cong.mapper.AccountMapper.findByUid",fetchType = FetchType.LAZY))

    })
    List<User> findUserAndAccount();
}

4.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>
    <settings>
        <!-- 开启二级缓存的支持,默认是开启的 -->
        <setting name="cacheEnabled" value="true"/>
    </settings>
    <typeAliases>
        <package name="com.cong.pojo"></package>
    </typeAliases>
    <environments default="mysql">
        <environment id="mysql">
            <!-- 使用JDBC事物管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
                <property name="url" value="jdbc:mysql://localhost:3306/rainbow?useUnicode=true&amp;characterEncoding=UTF-8"></property>
                <property name="username" value="root"></property>
                <property name="password" value="123456"></property>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定映射配置文件的位置，映射配置文件指的是每个mapper独立的配置文件
     如果是用注解来配置的话，此处应该使用class属性指定被注解的mapper全限定类名-->
    <mappers>
        <package name="com.cong.mapper"></package>
    </mappers>
</configuration>

5.测试类

TestAccount

import com.cong.mapper.AccountMapper;
import com.cong.pojo.Account;
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 TestAccount {
    private InputStream inputStream;
    private SqlSession sqlSession;
    private AccountMapper accountMapper;
    @Test
    public void findAllAccount(){
        List<Account> accounts = accountMapper.findAll();
        for (Account account : accounts) {
            System.out.println(account.toString());
        }
    }
    @Test
    public void findAccountAndUser(){
        List<Account> accounts = accountMapper.findAcountAndUser();
        for (Account account : accounts) {
            System.out.println("----------------------------------");
            System.out.println(account.toString());
            System.out.println(account.getUser().toString());
        }
    }
    @Test
    public void findAccountByUid(){
        List<Account> accounts = accountMapper.findByUid(1);
        for (Account account : accounts) {
            System.out.println(account.toString());
        }
    }

    @Before
    public void init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = factory.openSession();
        accountMapper = sqlSession.getMapper(AccountMapper.class);
    }
    @After
    public void destroy() throws Exception{
        sqlSession.commit();
        sqlSession.close();
        inputStream.close();
    }
}

TestUser

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

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

public class TestUser {
    private InputStream inputStream;
    private SqlSession sqlSession;
    private UserMapper userMapper;
    @Test
    public void findAllUser(){
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println(user.toString());
        }
    }
    @Test
    public void findById(){
        User user = userMapper.findById(1);
        System.out.println(user.toString());
    }
    @Test
    public void findByName(){
        List<User> users = userMapper.findByName("%RAIN%");
        for (User user : users) {
            System.out.println(user.toString());
        }
    }
    @Test
    public void findTotal(){
        int total = userMapper.findTotal();
        System.out.println("total: " + total);
    }
    @Test
    public void saveUser(){
        User rain = new User();
        rain.setUsername("rain");
        rain.setSex('女');
        rain.setAddr("25号");
        userMapper.saveUser(rain);
        System.out.println(rain.toString());
    }
    @Test
    public void updateUser(){
        //User rainbow = userMapper.findById(5);
        User rainbow = new User();
        rainbow.setId(12);
        rainbow.setUsername("菜菜");
        rainbow.setSex('女');
        rainbow.setAddr("北街25号");
        userMapper.updateUser(rainbow);
    }
    @Test
    public void deleteUser(){
        userMapper.deleteUser(6);
    }

    @Test
    public void findAllUserAndAccount(){
        List<User> users = userMapper.findUserAndAccount();
        for (User user : users) {
            System.out.println(user.toString());
            if(!user.getAccounts().isEmpty()){
                for (Account account : user.getAccounts()) {
                    System.out.println("\t"+account.toString());
                }
            }
        }
    }
    @Before
    public void init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = factory.openSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
    }
    @After
    public void destroy() throws Exception{
        sqlSession.commit();
        sqlSession.close();
        inputStream.close();
    }
}

TestCache

import com.cong.mapper.AccountMapper;
import com.cong.pojo.Account;
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;

public class TestCache {
    private InputStream inputStream;
    //private SqlSession sqlSession;
    //private AccountMapper mapper;
    private SqlSessionFactory factory;
    @Test
    public void testFirstLevelCache(){
        SqlSession sqlSession = factory.openSession();
        AccountMapper mapper = sqlSession.getMapper(AccountMapper.class);
        Account account = mapper.findById(1);
        Account account1 = mapper.findById(1);
        System.out.println(account == account1);//true
    }
    @Test
    public void testSecondLevelCache(){
        SqlSession sqlSession = factory.openSession();
        AccountMapper mapper = sqlSession.getMapper(AccountMapper.class);
        Account account = mapper.findById(1);
        sqlSession.close();//一级缓存消失
        SqlSession sqlSession1 = factory.openSession();
        AccountMapper mapper1 = sqlSession1.getMapper(AccountMapper.class);
        Account account1 = mapper1.findById(1);
        System.out.println(account);
        System.out.println(account1);
        System.out.println(account == account1);//false
    }
    @Before
    public void init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(inputStream);
//        sqlSession = factory.openSession();
//        mapper = sqlSession.getMapper(AccountMapper.class);
    }
    @After
    public void destroy() throws Exception{
//        sqlSession.commit();
//        sqlSession.commit();
        inputStream.close();
    }
}

 

转载于:https://www.cnblogs.com/ccoonngg/p/11385183.html

weixin_38170065
关注
Mybatis注解实现一对一，
1234567
08-17 1739
来源：黑马程序员 账户： 用户： 目标实现查找所有账户的同时找到对应的用户信息，立即加载 User属性： private Integer id; private String username; private String address; private String sex; private Date birthday; Account属性： private Integer id; private Integer .
mybatis第三天及整理（注解形式实现一对一，一对多）
最难理解的博客
01-12 194
延迟加载，一二级缓存，注解开发完善，以及用注解开发实现延迟加载，一对多，一对一，一二级缓存
【MyBatis】03.接口开发 动态代理方式的CRUD
ZhengD的博客
12-28 155
一、创建mapper文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" &gt; &lt;mapper namespace=&q
mybatis黑马：注解开发 单表CRUD操作（代理Dao方式）
JH灰色的博客
02-18 218
注解开发需要删除IUserDao.xml文件(即mappers文件)。 以下是注解的形式： 省略User.java IUserDao.java CRUD一共有四个注解 @Select @Insert @Update @Delete package com.jh.dao; import com.jh.domain.User; import org.apache.ibatis.annotatio...
Mybatis入门笔记(12)——基于注解方式的代理Dao的CRUD操作
weixin_30439131的博客
07-20 85
创建步骤： 创建maven工程，什么都不选就ok,并导入坐标； <packaging>jar</packaging> <dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>my...
SpringBoot项目框架+Mybatis+Mybatis-Plus+JOOQ
05-30
Mybatis通过XML或注解的方式将SQL语句与Java代码分离，既保持了SQL的灵活性，又避免了硬编码带来的问题。 Mybatis-Plus是在Mybatis的基础上进行了进一步的封装，提供了更便捷的操作API，如插入、更新、删除、查询等...
MyBatis-Simplified-Chinese.rar_ mybatis-3_Mybatis-spring_mybatis
09-20
可以使用 XML 或注解方式编写映射，包括 CRUD 操作和其他复杂的 SQL 查询。 五、动态 SQL MyBatis 的动态 SQL 功能非常强大，允许在 SQL 映射文件中使用 if、choose、when、otherwise、where、foreach 等元素，实现...
spring-boot-starter-mybatis-spring-boot-2.0.0.tar.gz
04-19
Spring Boot 2.0是一个重要的里程碑，引入了大量新特性和改进，例如更好的错误处理、新的WebFlux框架、对Java 9的支持等。选择这个版本意味着可以享受到Spring Boot 2.x系列的诸多优化。 3. **集成步骤** - 添加...
spring-boot-starter-mybatis-spring-boot-1.3.2.zip
04-19
Spring Boot以其简化配置、快速启动的优势，深受开发者喜爱，而MyBatis作为一个轻量级的持久层框架，以其灵活的SQL映射功能，解决了ORM框架的一些繁琐问题。当这两者结合时，可以构建出高效且易于维护的Web应用。...
MyBatis-CRUD-Annotation.zip
04-16
在"MyBatis-CRUD-Annotation.zip"这个压缩包中，很显然，它包含了一个关于如何使用MyBatis的注解进行CRUD（创建、读取、更新、删除）操作的示例或教程。以下是对MyBatis中注解使用及相关知识点的详细解释： 1. **...
【Mybatis】注解方式实现一对一查询
m0_55336071的博客
04-15 1305
使用注解方式实现一对一的多表查询，和使用配置文件实现一样也有两种方式。 第一种：首先创建两个类User 以及 Order package com.leoham.domain; import java.util.Date; public class User { private int id; private String username; private String password; private Date birthday; public int
MyBatis注解——一对一
xingcsdnboke的博客
09-27 407
1、订单对应用户：一对一 ，数据库。3、maper 接口。
mybatis注解方式实现一对一的连表查询的方法二
独孤一剑
06-27 674
需求：查询所有的账户并且显示账户所对应的用户的信息 准备实体类： Account的实体类上代码： package com.test.domain; /** * @author:shi jiaojie * @date:2019/6/26 20:15 * @description: */ public class Account { private Integer id ; ...
spring整合mybatis完整案例(注解配置方法)
编号0347
08-31 1924
一.项目整体结构二.详细内容0.导入jar包1.domian(1)User实体类2. dao(1)IUserDaoUserDao层接口，定义crud接口方法 (2)IUserDao.xml注解方式配置不需要实现dao接口，会自动实现并创建对象 只需要配置实体类对应的SQL映射<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUB
Mybatis@注解方式实现一对一，一对多的关联查询
鲸鱼姐的专栏
12-18 2145
1. 创建User.java，一个User里有一个Address地址，有多个book。 public class User { private int userId; private String userName; private String userPassword; private Address userAddress; private List<Book> ...
mybatis注解方式实现一对一的连表查询的方法一
独孤一剑
06-27 3124
需求：查出所有的账户并且显示账户下的对应的用户信息 先准备实体类上代码： Account实体类： package com.test.domain; /** * @author:shi jiaojie * @date:2019/6/26 20:15 * @description: */ public class Account { private Integer id ; ...
mybatis基于注解（一对一，一对多，多对多）
AinUser的博客
08-17 1133
原文链接：https://blog.csdn.net/caoxuekun/article/details/76944001
Mybatis之注解方式配置一对一和一对多
qq_41458842的博客
07-25 555
一：1对1--在从表实体类中建立主表实体类的对象引用。 二：一对多--主表实体类应该包含从表实体类的集合引用
Mybatis配置，包括注解和XML配置
热门推荐
hq.zheng的博客
01-12 1万+
1.项目结构 2. 主配置文件 mybatis-config.xml <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> -->
mybatis-plus-join 一对一使用教程
最新发布
07-24
对于一对多、多对一等关联查询场景非常有用。 ### mybatis-plus-join 一对一使用教程 #### 1. 引入依赖 首先需要在项目中引入 MyBatis-Plus 和相关的 ORM 包如 MyBatis 或 Spring Data JPA 的依赖。通常在 Maven ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值