MyBatis 入门学习3

已于 2023-11-01 15:35:13 修改
阅读量146 收藏 1
点赞数
分类专栏： MyBatis 文章标签： mybatis mysql java
于 2021-01-18 20:31:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39376487/article/details/112794071
版权

MyBatis 学习3

延迟加载

在一对多关系中，1个人可以有100个账号，

立即加载就是当查询个人信息时，不管你需不需要看账号信息也立刻把个人对应的账号信息也查询出来，这样可能会消耗很多内存。

延迟加载就是当你只需要看个人信息时就只查了个人信息没有查账号信息，当你需要账号信息时再查给你。

一对多，多对多：通常用延迟加载。

多对一，一对一：通常用立即加载。(MyBatis 把多对一也看作一对一)

一对一延迟加载演示：

为了观看效果引入了日志依赖

<!--日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

Account 类

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    private User user;
    //省略getter、setter、toString方法
    }

MyBatis 配置文件 SqlMapConfig.xml 开启延迟加载

<settings>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- aggressiveLazyLoading 当开启时，任何方法的调用都会加载该对象的所有属性。
        否则，每个属性会按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

IAccountDao.xml

<resultMap id="accountUserLazyMap" type="Account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一关系映射，封装 user 的内容
        select属性：查询用户的唯一标识
        column属性：根据id查询时，所需要的值
        -->
        <association property="user" column="uid" javaType="user" select="com.rgb3.dao.IUserDao.findById"></association>
    </resultMap>
<!--一对一延迟查询全部-->
    <select id="lazyFindAll" resultMap="accountUserLazyMap">
        select * from t_account;
    </select>

<association> 里面

select属性：查询用户的唯一标识，这里指定了 IUserDao.xml 里的findById 方法

column属性：根据id查询时，所需要的值

IUserDao.xml

<resultMap id="userMap" type="user">
        <!--主键字段的对应-->
        <id property="userId" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userName" column="username"></result>
        <result property="userBirthday" column="birthday"></result>
        <result property="userAddress" column="address"></result>
    </resultMap>
<!--根据id查询-->
    <select id="findById" parameterType="int" resultMap="userMap">
        select * from t_user where id=#{id}
    </select>

数据表 t_account

在这里插入图片描述

t_user

在这里插入图片描述

IAccountDao 接口添加测试方法

//延迟查询
    List<Account> lazyFindAll();

测试方法

@Test
    public void lazyFindAll(){
        List<Account> all = accountDao.lazyFindAll();
        /*for (Account account:all){
            System.out.println(account);
            System.out.println(account.getUser());
        }*/
    }

这里只是查询所有账号数据

在这里插入图片描述

把测试方法的注释解开

@Test
    public void lazyFindAll(){
        List<Account> all = accountDao.lazyFindAll();
        for (Account account:all){
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

在这里插入图片描述

这里因为代码中用到了个人 user 对象的属性，即打印 user 数据，所以 MyBatis 就把 user 的数据查询了。

实现了延迟查询，用到才查，用不到就不查。

一对多延迟加载演示：

1个人有多个账号的情况。

User 类

public class User implements Serializable {

    private int userId;
    private String userName;
    private Date userBirthday;
    private String userAddress;
    private List<Account> accounts;
    //省略getter、setter、toString方法
    }

Account 类

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //省略getter、setter、toString方法
    }

IUserDao 接口添加方法

//一对多延迟查询
    List<User> lazyFindUserAll();

IAccountDao.xml

<!--根据uid查询账号-->
    <select id="findByUid"  resultType="account">
        select * from t_account where uid = #{uid};
    </select>

IUserDao.xml

<!--一对多结果映射,延迟加载-->
    <resultMap id="userAccountLazyMap" type="user">
        <id property="userId" column="id"></id>
        <result property="userName" column="username"></result>
        <result property="userBirthday" column="birthday"></result>
        <result property="userAddress" column="address"></result>
        <!--配置 user 对象的 accounts 集合映射-->
        <collection property="accounts" ofType="account" select="com.rgb3.dao.IAccountDao.findByUid" column="id"></collection>
    </resultMap>

这里<collection>里的 column 属性填id，因为 t_user 表里是 id 字段。

数据表 t_account

在这里插入图片描述

数据表 t_user

在这里插入图片描述

UserAccountTest 类测试方法

//一对多查询，延迟加载
    @Test
    public void lazyFindAccountAll(){
        List<User> all = userDao.lazyFindUserAll();
        /*for (User user : all){
            System.out.println(user);
            System.out.println(user.getAccounts());
            System.out.println("------------------------");
        }*/
    }

在这里插入图片描述

这里没有用到 account 对象的数据，所以只查询了个人信息

现在把测试方法的注释解开

//一对多查询，延迟加载
    @Test
    public void lazyFindAccountAll(){
        List<User> all = userDao.lazyFindUserAll();
        for (User user : all){
            System.out.println(user);
            System.out.println(user.getAccounts());
            System.out.println("------------------------");
        }
    }

在这里插入图片描述

这里用到account 对象的数据，所以查询个人信息后也查询了账号信息，实现了延迟加载。

MyBatis 的缓存

使用缓存可以减少和数据库交互的次数，提高执行效率。

  • 适合用缓存的数据：经常要查询且不常改变的，数据的正确与否对最终结果影响不大的。

  • 不合适用缓存的数据：经常改变的数据，数据的正确与否对最终结果影响大的（商品的库存等）。

MyBatis 中有一级缓存和二级缓存

在这里插入图片描述

一级缓存

指 MyBatis 中 SqlSession 对象的缓存，当我们执行查询后，查询结果会同时存入 SqlSession 的一块区域中，这个区域结构是 Map。当我们再次查询同样的数据时 MyBatis 会先去 SqlSession 中查询有没有，有就直接拿来用，就不用再去数据库查询了。

当 SqlSession 对象消失时，它的一级缓存也会消失。

t_user 表

在这里插入图片描述

User 类

public class User implements Serializable {

    private int userId;
    private String userName;
    private Date userBirthday;
    private String userAddress;
    //省略getter、setter方法
    //为了演示效果就不重写 toString 方法了
    }

IUserDao.xml

<resultMap id="userMap" type="user">
        <!--主键字段的对应-->
        <id property="userId" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userName" column="username"></result>
        <result property="userBirthday" column="birthday"></result>
        <result property="userAddress" column="address"></result>
    </resultMap>

MyBatisTest 测试类添加测试方法：

//测试一级缓存，根据id查询
    @Test
    public void firstCache(){
        User user1 = userDao.findById(33);
        System.out.println(user1);
        User user2= userDao.findById(33);
        System.out.println(user2);
    }

在这里插入图片描述

可以看到在代码里让它查询2次，但实际上，通过控制台可以看出它只从数据库查询了1次，第二的结果就是用了缓存里面的，所以是同一个 User 对象。

试试清空缓存

    @Test
    public void firstCache(){
        User user1 = userDao.findById(33);
        System.out.println(user1);
        session.clearCache();   //清除缓存
       User user2= userDao.findById(33);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }
}

在这里插入图片描述

清空缓存后，第二次查询就需要再次去数据库里面查了。

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加、删除、commit()、close() 等方法，就会清空一级缓存。

IUserDao.xml

<!--修改用户-->
    <update id="updateUser" parameterType="com.rgb3.domain.User">
        update t_user set username=#{userName},birthday=#{userBirthday} where id=#{userId};
    </update>

测试方法：

@Test
    public void firstCache(){
        User user1 = userDao.findById(33);
        System.out.println(user1);
        //session.clearCache();   //清除缓存

        user1.setUserName("mily");
        userDao.updateUser(user1);

        User user2= userDao.findById(33);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }

t_user 表

在这里插入图片描述

在这里插入图片描述

可以看到，在更新数据后，缓存里的数据也没了需要再次去数据库里面查，使查出来的数据是最新，而不是之前存在缓存里旧的数据。

二级缓存

SecondCacheTest 类

public class SecondCacheTest {
    private InputStream in ;
    private SqlSessionFactory factory;

    @Before//测试方式运行前运行
    public  void init() throws Exception {
        //读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory工厂
        factory = new SqlSessionFactoryBuilder().build(in);
    }

    @After//测试方法运行后运行
    public void destroy() throws Exception{
        in.close();
    }

    //测试二级缓存
    @Test
    public void secondCache(){
        //用工厂生产SqlSession对象
        SqlSession sqlSession1 = factory.openSession();
        //用SqlSession创建Dao接口的代理对象
        IUserDao userDao1 = sqlSession1.getMapper(IUserDao.class);
        User user1 = userDao1.findById(33);
        sqlSession1.close();    //清空一级缓存
        System.out.println(user1);

        SqlSession sqlSession2 = factory.openSession();

        IUserDao userDao2 = sqlSession2.getMapper(IUserDao.class);
        User user2 = userDao2.findById(33);
        sqlSession2.close();    //清空一级缓存
        System.out.println(user2);

        System.out.println(user1 == user2);

    }
}

在这里插入图片描述

这里分别用2个 SqlSession 对象进行查询，可以看到它查询1次后，再次查询它还是会再次去数据库里面查询，即默认二级缓存是关闭的

开启二级缓存：

  • 在 MyBatis 配置文件 SqlMapConfig.xml 中开启二级缓存的支持

    <settings>
        <!--开启二级缓存的支持，这里默认是true的，不写也行-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

    在相关的 dao.xml 映射配置文件里开启二级缓存的支持，这里是 IUserDao.xml

    <!--开启二级缓存的支持-->
    <cache/>

  • 配置 statement 上面的 useCache 属性，这里是 IUserDao.xml 里的<select> 标签

    <!--根据id查询-->
    <select id="findById" parameterType="int" resultMap="userMap" useCache="true">
        select * from t_user where id=#{id}
    </select>

    再次启动测试方法

在这里插入图片描述

可以看到有2个查询结果，但是它只向数据库查询了1次，所以第二次就是从缓存里面取出。

提示：当我们在使用二级缓存时，所缓存的类一定要实现序列化接口，如这里的 User 类

public class User implements Serializable {
    //...
}

MyBatis 注解方式

之前一直都是用 xml 配置文件的形式使用 MyBatis，MyBatis 也支持注解形式使用。

注意，MyBatis 的主配置文件还是要以 xml 配置文件的形式存在，之前像 IUserDao.xml 这些映射文件就可以不写了。

  • @Insert:实现新增

  • @Update:实现更新

  • @Delete:实现删除

  • @Select:实现查询

  • @Result:实现结果集封装

  • @Results:可以与@Result 一起使用，封装多个结果集

  • @ResultMap:实现引用@Results 定义的封装

  • @One:实现一对一结果集封装

  • @Many:实现一对多结果集封装

  • @SelectProvider: 实现动态 SQL 映射

  • @CacheNamespace:实现注解二级缓存的使用

单表演示：

查询全部

User 类

public class User implements Serializable {

    private int id;
    private String username;
    private Date birthday;
    private String address;
    //省略 getter setter toString方法
    }

IUserDao 接口

public interface IUserDao {
    //查询所有
    @Select("select * from t_user")
    List<User> findAll();
}

MyBatis 主配置文件 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主配置文件-->
<configuration>
    <properties resource="jdbcConfig.properties"></properties>

    <!--配置别名，只能配置 domain 中类的别名-->
    <typeAliases>
        <!--指定要配置别名的包，该包下的实体类都会注册别名，它的类名就是别名，不区分大小写-->
        <package name="com.rgb3.domain"></package>
    </typeAliases>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库-->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

   
    <mappers>
        <!-- package 指定有注解的 dao接口所在包，可以代替<mapper>-->
        <package name="com.rgb3.dao"></package>
    </mappers>
</configuration>

//测试注解类
public class MyBatisTest2 {
    private InputStream in ;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;

    @Before//测试方式运行前运行
    public  void init() throws Exception {
        //读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory工厂
        factory = new SqlSessionFactoryBuilder().build(in);
        //用工厂生产SqlSession对象
        session = factory.openSession();
        //用SqlSession创建Dao接口的代理对象
        userDao = session.getMapper(IUserDao.class);
    }

    @After//测试方法运行后运行
    public void destroy() throws Exception{
        //提交事务
        session.commit();   //保存、修改、删除操作时，如果你没这步提交事务，数据是不能成功写入数据库的
        in.close();
        session.close();
    }

    
    @Test
    public void findAll(){
        List<User> all = userDao.findAll();
        for (User user:all){
            System.out.println(user);
        }
    }
}

数据表t_user

在这里插入图片描述

在这里插入图片描述

插入数据

IUserDao 接口 添加方法

@Insert("insert into t_user(username,birthday,address) values(#{username},#{birthday},#{address})")
    void saveUser(User user);

测试方法

@Test
    public void saveUser(){
        User user = new User();
        user.setUsername("Bob");
        user.setBirthday(new Date());
        user.setAddress("北京");
        userDao.saveUser(user);
    }

在这里插入图片描述

修改数据

IUserDao 接口添加方法

//修改数据
    @Update("update t_user set username=#{username},birthday=#{birthday},address=#{address} where id =#{id}")
    void updateUser(User user);

测试方法

//修改数据
    @Test
    public void updateUser(){
        User user = new User();
        user.setId(42);
        user.setUsername("Bob2");
        user.setBirthday(new Date());
        user.setAddress("上海");
        userDao.updateUser(user);
    }

在这里插入图片描述

IUserDao 接口添加方法

//根据id查询
    @Select("select * from t_user where id = #{id}")
    User findById(Integer id);

测试方法

//根据id查询
    @Test
    public void findById(){
        User user = userDao.findById(39);
        System.out.println(user);
    }

在这里插入图片描述

删除

IUserDao 接口添加方法

//删除数据
    @Delete("delete from t_user where id = #{id}")
    void deleteUser(Integer id);

测试方法

//删除数据
    @Test
    public void deleteUser(){
        userDao.deleteUser(42);
    }

在这里插入图片描述

模糊查询

IUserDao 接口添加方法

//根据名字模糊查询
    @Select("select * from t_user where username like #{username}")
    List<User> findByName(String username);

测试方法

//根据名字模糊查询
    @Test
    public void findByUserName(){
        List<User> list = userDao.findByName("%t%");//注意这里要自己加百分号%
        for (User user:list){
            System.out.println(user);
        }
    }

在这里插入图片描述

这里的 SQL 语句用的是占位符的形式，还有一种是字符串拼接的方式

@Select("select * from t_user where username like '%${value}%'")

这样在 Java 中使用就不用自己加百分号

 List<User> list = userDao.findByName("t");

聚合函数查询总数

IUserDao 接口添加方法

//聚合函数查询总数
    @Select("select count(*) from t_user")
    int findTotal();

测试方法

//查询总数
    @Test
    public void findTotal(){
        int total = userDao.findTotal();
        System.out.println(total);
    }

在这里插入图片描述

数据库字段名与 Java 变量名不一致时的注解配置

User 类

public class User implements Serializable {

    private int userId;
    private String userName;
    private Date userBirthday;
    private String userAddress;
    //省略 getter、setter、toString 方法
    }

数据表字段

在这里插入图片描述

IUserDao 接口

//查询所有
    @Select("select * from t_user")
    @Results(id="userMap",value = {
            @Result(id = true,column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(column = "address",property = "userAddress")
    })
    List<User> findAll();

//根据id查询
    @Select("select * from t_user where id = #{id}")
    @ResultMap("userMap")
    User findById(Integer id);

@Result( id = true )表示这一字段对应的是 id 字段，类似 XML 配置方式里的 <id> 的作用。column 属性 表示数据表里的字段名，property 属性表示 Java 类里面的属性名。

@Results( id = “userMap”) 这里的 id 属性值表示给这个结果映射加一个唯一标识，这样在其他方法上要使用的时候用 @ResultMap() 引用一下就可以了。

@ResultMap("userMap")

多对一查询

多对一查询在 MyBatis 里即 一对一查询。

Account 类

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;

    //注解多对一，即一对一的查询，1个账号只属于1个人
    private User user;
    //省略 getter、setter、toString 方法
    }

IAccountDao 接口

public interface IAccountDao {

    @Select("select * from t_account")
    @Results(id = "accountMap",value = {
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "uid",property = "uid"),
            @Result(column = "money",property = "money"),
            @Result(column = "uid",property = "user",one = @One(select = "com.rgb3.dao.IUserDao.findById",fetchType = FetchType.EAGER))
    })
    List<Account> findAll();
}

@Result(column = "uid",property = "user",one = @One(select = "com.rgb3.dao.IUserDao.findById",fetchType = FetchType.EAGER)

这里@Result 的 column 属性 表示根据 uid 去查 账号对应的 user 。

@One 里面的 select 属性表示去哪个接口的哪个方法查 user，注意是要全限定类名，fetchType = FetchType.EAGER 表示积极的查询（即立即加载，因为现实中，一般情况多对一，一对一都用立即加载，一对多用延迟加载），还有个延迟的查询（即延迟加载），后面会提到。

测试类

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

    @Before//测试方式运行前运行
    public  void init() throws Exception {
        //读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory工厂
        factory = new SqlSessionFactoryBuilder().build(in);
        //用工厂生产SqlSession对象
        session = factory.openSession();
        //用SqlSession创建Dao接口的代理对象
        accountDao = session.getMapper(IAccountDao.class);
    }

    @After//测试方法运行后运行
    public void destroy() throws Exception{
        //提交事务
        session.commit();   //保存、修改、删除操作时，如果你没这步提交事务，数据是不能成功写入数据库的
        in.close();
        session.close();
    }

    //查询全部
    @Test
    public void findAll(){
        List<Account> all = accountDao.findAll();
        for (Account account:all){
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }
    
}

在这里插入图片描述

一对多查询

1个人可以有多个账号的关系演示

User 类

public class User implements Serializable {

    private int userId;
    private String userName;
    private Date userBirthday;
    private String userAddress;

    //一对多关系，1个人可以有多个账号
    private List<Account> accounts;
    //省略 getter、setter、toString 方法
    }

IAccountDao 接口 添加方法

//根据个人id 查询账号信息
    @Select("select * from t_account where uid = #{uid}")
    List<Account> findByUid(Integer uid);

IUserDao 接口添加方法

 //查询所有
    @Select("select * from t_user")
    @Results(id="userMap",value = {
            @Result(id = true,column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "id",property = "accounts",many = @Many(select = "com.rgb3.dao.IAccountDao.findByUid",fetchType = FetchType.LAZY))
    })
    List<User> findAll();

@Result(column = "id",property = "accounts",many = @Many(select = "com.rgb3.dao.IAccountDao.findByUid",fetchType = FetchType.LAZY))

这里与多对一查询里面类似，@Result() 里 column 属性表示根据 用户的 id 字段去查询 这个 id 有哪些账号，property 属性指 User 类里面的变量。many 属性表示这里是使用的是一对多，所以后面使用 @Many。

@Many 与 多对一的 @One 作用类似，不同的是这里我设置了 fetchType = FetchType.LAZY 表示延迟加载。

测试方法

//查询全部
    @Test
    public void findAll(){
        List<User> all = userDao.findAll();
        for (User user:all){
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }

在这里插入图片描述

可以看到有些人有多个账号的是可以打印出来的。

现在试试把打印代码注释掉

@Test
    public void findAll(){
        List<User> all = userDao.findAll();
        /*for (User user:all){
            System.out.println(user);
            System.out.println(user.getAccounts());
        }*/
    }

在这里插入图片描述

可以看到它只去查询了 user 的数据，没有查 user 对应的 accounts 数据，即实现了延迟查询。

注解方式使用二级缓存

XML 方式和注解方式的一级缓存使用默认是开启的，所以这里讲下注解方式的使用二级缓存。

User 类

public class User implements Serializable {

    private int userId;
    private String userName;
    private Date userBirthday;
    private String userAddress;
    //省略 getter、setter、toString 方法
    }

IUserDao 接口

public interface IUserDao {

    //查询所有
    @Select("select * from t_user")
    @Results(id="userMap",value = {
            @Result(id = true,column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(column = "address",property = "userAddress"),
    })
    List<User> findAll();

    //根据id查询
    @Select("select * from t_user where id = #{id}")
    @ResultMap("userMap")
    User findById(Integer id);
    }

测试类

public class SecondCacheTest2 {
    private InputStream in ;
    private SqlSessionFactory factory;
    
    @Before//测试方式运行前运行
    public  void init() throws Exception {
        //读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory工厂
        factory = new SqlSessionFactoryBuilder().build(in);
    }

    @After//测试方法运行后运行
    public void destroy() throws Exception{
        in.close();
    }

    //根据id查询
    @Test
    public void findById(){
        SqlSession sqlSession1 = factory.openSession();
        IUserDao userDao1 = sqlSession1.getMapper(IUserDao.class);
        User user1 = userDao1.findById(39);
        System.out.println(user1);

        sqlSession1.close();//释放一级缓存

        SqlSession sqlSession2 = factory.openSession();
        IUserDao userDao2 = sqlSession2.getMapper(IUserDao.class);
        User user2 = userDao2.findById(39);
        System.out.println(user2);
        sqlSession2.close();//释放一级缓存
    }
}

在这里插入图片描述

默认没有开启二级缓存，所以这里我在代码中手动关闭了 SqlSession 后，再创建，再查询同样的内容，它还是会去数据库里面查。

开启二级缓存步骤：

MyBatis 的主配置文件 SqlMapConfig.xml 开启二级缓存（与 XML 方式类似）

<settings>
        <!--开启二级缓存的支持，这里默认是true的，不写也行-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

IUserDao 接口上添加注解

@CacheNamespace(blocking = true)    //使用二级缓存
public interface IUserDao {...}

再次启动测试方法

在这里插入图片描述

可以看到只向数据库里查询了1次，即使用了二级缓存。

a_wing啊
关注
专栏目录
mybatis 3 入门
Berwin的博客
05-05 1332
mybatis 3.5 文章目录简介快速开始：IDEA方式创建第一个MyBatis项目开启日志功能基本的CURD自定义 创建sqlSession 工具类insertupdatedeleteIdea的代码模板MyBatis 对象分析Resources 类SqlSessionFactoryBuilder 类SqlSessionFactory 接口SqlSession 接口mybatis动态代理参数parameterTypeMyBatis 传递参数一个简单类型的参数多个参数使用 @Param命名参数多个参数 使用
MyBatis入门(三)
TinaCSDN的博客
11-19 251
0. 学习目标 MyBatis连接池 MyBatis的事务控制 MyBatis一对一查询（一对多） MyBatis多对多查询 1. Mybatis连接池 1.1 MyBatis连接池的分类 在mybatis中，我们将他的数据源datasource分为以下几类： 可以看出 Mybatis 将它自己的数据源分为三类： UNPOOLED 不使用连接池的数据源 POOLED 使用连接池的数据源 JNDI 使用 JNDI 实现的数据源 具体结构如下： 在这三种数据源中，我们一般采
ajax+controller+Mybatis实现登录注册、修改和删除以及session操作
06-25
本项目实现了用户的登录、注册、删除账号、修改账号和退出账号等功能，具体的操作以及效果图可以参见博文https://blog.csdn.net/qq_29656961/article/details/80806066
在MyBatis的Controller中
caiweijiancsdn的博客
03-02 889
在MyBatis中的Controller中 1:@CrossOrigin(origins = “http://www.jmxyi.com”, maxAge = 3600)代表服务器的域名 2:@RequestMapping(value="/app/integralmall")代表方法的入口，前缀为APP的时候，代表App忽略拦截器 3. @ResponseBody @RequestMapping(...
mybatis 控制器注解介绍（一）
weixin_30362233的博客
04-24 157
@RequestMapping("LoginController")publicclassLoginController { // 路径参数{name}填入用户名，{pass}填入密码。我们设置为GET请求。@RequestMapping(value ="/login_get.json/{name}/{pass}", method = RequestMethod.GET)@Respons...
SSM框架中Dao层，Mapper层，controller层，service层，model层，entity层都有什么作用
qq_45068508的博客
02-16 2081
SSM是sping+springMVC+mybatis集成的框架。 MVC即model view controller。 model层=entity层。存放我们的实体类，与数据库中的属性值基本保持一致。 service层。存放业务逻辑处理，也是一些关于数据库处理的操作，但不是直接和数据库打交道，他有接口还有接口的实现方法，在接口的实现方法中需要导入mapper层，mapper层是直接跟数据库打交道的，他也是个接口，只有方法名字，具体实现在mapper.xml文件里，service是供我们使用的方法。 map
mybatis 代码生成器，生成Controller和service
wyazyf
05-13 2481
废话不多说了，直接上代码 目录结构（红框中的文件为有用文件） 入库类 package com.wy; import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.s
java资源之Mybatis基础入门学习笔记
10-29
【Mybatis基础入门学习笔记】 Mybatis是一款广泛使用的Java持久层框架，它的主要目标是简化对数据库的操作，提供更加灵活的SQL映射机制。Mybatis起源于Apache组织的ibatis框架，历经发展，在2010年迁移到Google ...
mybatis入门学习资料
06-07
MyBatis的入门学习主要包括以下几个方面： 1. 什么是MyBatis？ MyBatis是一款优秀的持久层框架，其设计目标之一是减少JDBC代码的手动设置和结果集的检索工作。它提供了两种主要的API，分别是基于XML的配置和注解的...
MyBatis入门.pdf
09-24
MyBatis入门 MyBatis是一个优秀的持久层框架，使用XML将SQL与程序解耦，便于维护。MyBatis学习简单，执行高效，是JDBC的延伸。MyBatis提供了数据库增删改查的便捷操作，极大提高了开发效率、统一的编码规则、利于...
mybatis入门学习的完整项目代码
06-27
本项目"mybatis入门学习的完整项目代码"旨在为初学者提供一个完整的 MyBatis 学习环境，帮助理解 MyBatis 的基本概念、配置以及如何在实际项目中应用。 首先，我们要了解 MyBatis 的核心概念： 1. **配置文件**：...
Mybatis学习--理解controller层，service层，dao层，model层
qq_41834729的博客
04-07 2162
Mybatis学习 理解controller层，service层，dao层，model层：https://www.cnblogs.com/tooyi/p/13340374.html 1、导入包——pom.xml内 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-sta
springboot+Mybatis项目搭建教学（controller、service、dao、entity），并写一个简单的接口
随便写写
04-15 4726
springboot+Mybatis项目搭建教学（controller、service、dao），并写一个简单的接口，后面再来一篇mybatis-plus
SpringBoot+Mybatis后台管理系统
2303_77877769的博客
03-31 872
我还为大家准备了一套体系化的架构师学习资料包以及BAT面试资料，供大家参考及学习已经将知识体系整理好（源码，笔记，PPT，学习视频）《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！个数组，user是遍历的元素通过这种方式就可以把数据库所有的数据展示到表格中了==(获取到对象后，通过对象的get方法获取对应的属性)==自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
mybatis学习(34):动态sql-choose
qq_41632427的博客
07-07 287
java
MyBatis使用梳理
CSRAWD的博客
02-27 226
一、MyBatis使用时数据流动顺序分析 需求： 前端提交表单，请求后台使用MyBatis往数据库里插入一条数据 使用流程： 前端传回数据，此时数据传到controller的对应方法里 controller使用调用service对象对应方法，将数据传递过去 service实际上是个接口，数据只是通过这个接口，传递到service的接口实现类serviceImp serviceImp接收到调用，接到数据，调用本类中的userDAO对象对应方法，将数据传递出去 userDAO实际上也是个接口，它头上有个Map
配合Mybatis-Plus的公共类，IController(CommonController)，利用泛型，直接生成较为简单的接口
质量不太好的博客
05-16 830
配合Mybatis-Plus的公共类，IController(CommonController)，直接生成较为简单的接口
MybatisPlus的LambdaQueryWrapper用法
最新发布
2301_79693537的博客
08-21 4900
【代码】MybatisPlus的LambdaQueryWrapper用法。
MyBatis深入学习与Spring整合基础
"本文将深入探讨MyBatis的基础知识，包括其与原生态JDBC的比较、配置、核心组件以及如何在实际项目中使用MyBatis。" MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。在传统的JDBC编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值