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

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了mybatis框架学习-注解方式的crud，缓存，一对一，一对多，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13437字，纯文字阅读大概需要20分钟。

内容图文

前期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` doubledefault 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;
    }

    publicint getId() {
        return id;
    }

    publicvoid setId(int id) {
        this.id = id;
    }

    publicint getUid() {
        return uid;
    }

    publicvoid setUid(int uid) {
        this.uid = uid;
    }

    publicdouble getMoney() {
        return money;
    }

    publicvoid 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;

publicclass User implements Serializable{
    privateint id;
    private String username;
    privatechar sex;
    private String addr;
    private List<Account> accounts;
    public List<Account> getAccounts() {
        return accounts;
    }

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

    @Override
    public String toString() {
        return"User{" +
                "id=" + id +
                ", username=‘" + username + ‘\‘‘ +
                ", sex=" + sex +
                ", addr=‘" + addr + ‘\‘‘ +
                ‘}‘;
    }

    publicint getId() {
        return id;
    }

    publicvoid setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    publicvoid setUsername(String username) {
        this.username = username;
    }

    publicchar getSex() {
        return sex;
    }

    publicvoid setSex(char sex) {
        this.sex = sex;
    }

    public String getAddr() {
        return addr;
    }

    publicvoid 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 基于注解方式实现配置二级缓存publicinterface 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的注解配置
 * 以及一对多的查询配置
 */publicinterface 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")//返回自增字段的idvoid 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
    publicvoid 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
    publicvoid findAccountByUid(){
        List<Account> accounts = accountMapper.findByUid(1);
        for (Account account : accounts) {
            System.out.println(account.toString());
        }
    }

    @Before
    publicvoid init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = factory.openSession();
        accountMapper = sqlSession.getMapper(AccountMapper.class);
    }
    @After
    publicvoid 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
    publicvoid findById(){
        User user = userMapper.findById(1);
        System.out.println(user.toString());
    }
    @Test
    publicvoid findByName(){
        List<User> users = userMapper.findByName("%RAIN%");
        for (User user : users) {
            System.out.println(user.toString());
        }
    }
    @Test
    publicvoid findTotal(){
        int total = userMapper.findTotal();
        System.out.println("total: " + total);
    }
    @Test
    publicvoid saveUser(){
        User rain = new User();
        rain.setUsername("rain");
        rain.setSex(‘女‘);
        rain.setAddr("25号");
        userMapper.saveUser(rain);
        System.out.println(rain.toString());
    }
    @Test
    publicvoid updateUser(){
        //User rainbow = userMapper.findById(5);
        User rainbow = new User();
        rainbow.setId(12);
        rainbow.setUsername("菜菜");
        rainbow.setSex(‘女‘);
        rainbow.setAddr("北街25号");
        userMapper.updateUser(rainbow);
    }
    @Test
    publicvoid deleteUser(){
        userMapper.deleteUser(6);
    }

    @Test
    publicvoid 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
    publicvoid init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = factory.openSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
    }
    @After
    publicvoid 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
    publicvoid 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
    publicvoid init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(inputStream);
//        sqlSession = factory.openSession();
//        mapper = sqlSession.getMapper(AccountMapper.class);    }
    @After
    publicvoid destroy() throws Exception{
//        sqlSession.commit();
//        sqlSession.commit();        inputStream.close();
    }
}

原文：https://www.cnblogs.com/ccoonngg/p/11385183.html

内容总结

以上是互联网集市为您收集整理的mybatis框架学习-注解方式的crud，缓存，一对一，一对多全部内容，希望文章能够帮你解决mybatis框架学习-注解方式的crud，缓存，一对一，一对多所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1125279.html

来源：【匿名】

【上一篇】CPU的高速缓存存储器知识整理【下一篇】屏蔽浏览器缓存另类方法

更多 ►

【mybatis框架学习-注解方式的crud，缓存，一对一，一对多】教程文章相关的互联网学习教程文章

【maven】代码生成器 SpringMVC_mybatis or hibernate+ehcache二级缓存_shiro_druid_bootstrap

原文：http://fg-27400201.iteye.com/blog/2203090

java权限框架 SpringMVC_mybatis or hibernate+ ehcache二级缓存 +shiro+druid+bootstrap+HTML

原文：http://baidu-27167647.iteye.com/blog/2200060

23、mybatis学习——mybatis的二级缓存【代码】【图】

MyBatis 一级缓存最大的共享范围就是一个SqlSession内部，那么如果多个 SqlSession 需要共享缓存，则需要开启二级缓存，开启二级缓存后，会使用 CachingExecutor 装饰 Executor，进入一级缓存的查询流程前，先在CachingExecutor 进行二级缓存的查询，具体的工作流程如下所示当二级缓存开启后，同一个命名空间(namespace) 所有的操作语句，都影响着一个共同的 cache，也就是二级缓存被多个 SqlSession 共享，是一个全局的变量。当...

集成代码生成器 SpringMVC mybatis shiro druid bootstrap HTML5 兼容PC 平板手机 ehcache二级缓存【图】

获取【下载地址】? ?QQ: 313596790? ?【免费支持更新】A 代码生成器(开发利器);? ? B 阿里巴巴数据库连接池druid;??数据库连接池??阿里巴巴的 druid。Druid在监控、可扩展性、稳定性和性能方面都有明显的优势C 安全权限框架shiro ;??D ehcache 自定义二级缓存;E 微信接口开发（后续会加入Activiti5 工作流）免费升级----------------------------------------------------------------------------------------------------------...

mybatis-分页和缓存

1.分页1.1在dao接口中配置分页参数：package com.java1234.mappers;import java.util.List;import java.util.Map;import org.apache.ibatis.session.RowBounds;import com.java1234.model.Student;public interface StudentMapper { public List<Student> searchStudents(Map<String,Object> map); public List<Student> searchStudents2(Map<String,Object> map); public List<Student> searchStudents3(Map<String,Object> map);...

Mybatis缓存【代码】

资料来自一级缓存和二级缓存一级缓存和二级缓存注解mapper一级缓存一级缓存，是指SqlSession级别的缓存。一级缓存是一直开启的，在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的public void TestCache01() throws IOException {SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();SqlSession openSession =...

java权限框架 SpringMVC_mybatis or hibernate+ ehcache二级缓存 +shiro+druid+bootstrap+HTML

原文：http://hg6863.iteye.com/blog/2202420

【企业框架源码】 SpringMVC mybatis or hibernate ehcache二级缓存maven非和maven版本【websocket即时通讯】【图】

mybatis探究之延迟加载和缓存【代码】【图】

mybatis探究之延迟加载和缓存一、什么是延迟加载1.延迟加载的概念在mybatis进行多表查询时，并非所有的查询都需要立即进行。例如在查询带有账户信息的用户信息时，我们们并不需要总是在加载用户信息时就一定要加载他的账户信息。这时就要用到延迟加载，所谓延迟加载就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。2.延迟加载的好处和坏处好处：先从单表查询，需要时再从关联表去关联查询，大...

mybatis缓存（上）---一级缓存【代码】【图】

什么是一级缓存在日常开发过程中，经常会有相同的sql执行多次查询的情况，mybatis提供了一级缓存来优化这些查询，避免多次请求数据库。一级缓存在mybatis中默认是开启的并且是session级别，它的作用域为一次sqlSession会话。什么是二级缓存相对于一级缓存，二级缓存的作用域更广泛，它不止局限于一个sqlSession，可以在多个sqlSession之间共享，事实上，它的作用域是namespace。 mybatis的...

Mybatis中的缓存简介【图】

01 Mybatis中的缓存简介缓存的好处：只是查询才有缓存（增删改没有缓存的），可以增块访问的速度 sqlsession级缓存（一级缓存）默认开启的所有的操作是公用同一个SQLsession对象并且执行的是同一条SQL语句的时候才会走缓存02缓存的缺点可能存在数据的脏读执行修改、删除、添加默认的把缓存中数据全部清空03问题不同的用户访问的时候创建了不同的sqlsession对象，这个时候我们缓存的数据没有办法实现共享04sqlsess...

MyBatis一级缓存和二级缓存【代码】

public class MyBatisTest {public SqlSessionFactory getSqlSessionFactory() throws IOException {String resource = "mybatis-config.xml";InputStream inputStream = Resources.getResourceAsStream(resource);return new SqlSessionFactoryBuilder().build(inputStream);}/*** 两级缓存：* 一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直开启的；SqlSession级别的一个Map* 与数据库同一次会话期间查询到的数...

【MyBatis】缓存示例【代码】

DAO和Bean参见下面相应章节【MyBatis】映射文件示例当执行一条SQL语句时，在缓存开启的情况下，会先查询二级缓存、再查询一级缓存，如果都没有才会使用JDBC查询数据库。映射文件映射文件中指定了使用ehcache缓存，使用cache或者cache-ref标签。 EmployeeMapper.xml 下面只是缓存相关的部分,其他部分代码与【MyBatis】映射文件示例相同<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper...