Mybatis

已于 2023-06-09 10:19:51 修改
阅读量86 收藏
点赞数
分类专栏： SSM 文章标签： java
于 2022-04-05 18:38:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OrientalPearl/article/details/123882824
版权

MyBatis

1. 简介

1.1 什么是MyBatis

mybatis

  • MyBatis 是一款优秀的持久层框架
  • 它支持自定义 SQL、存储过程以及高级映射
  • MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
  • MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录
  • MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github。

如何获得Mybatis?(GitHub或maven仓库选其一)

1.2 持久化

数据持久化

  • 持久化就是将程序中的数据在持久状态和瞬时状态转化的过程
  • 内存：断电即失
  • 数据库（JDBC）或io文件持久化

为什么需要持久化

  • 有一些对象，不能让它丢掉
  • 内存太贵了

1.3 持久层

  • 完成持久化工作的代码块
  • 层界限十分明显

1.4 为什么需要MyBatis

  • 传统的JDBC代码太复杂，简化，框架，自动化
  • 帮助程序员将数据存入到数据库中
  • 优点：
    • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件。易于学习，易于使用。通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
    • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
    • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
    • 提供映射标签，支持对象与数据库的orm字段关系映射。
    • 提供对象关系映射标签，支持对象关系组建维护。
    • 提供xml标签，支持编写动态sql

2. 第一个MyBatis程序

思路：搭建环境->导入MyBatis->编写代码->测试

在这里插入图片描述

2.1 搭建环境

搭建数据库

create database if not exists `mybatis`;
use `mybatis`
create table if not exists `user`(
    `id` int primary key,
    `name` varchar(20) not null,
    `pwd` varchar(20) not null
)engine=INNODB default charset=utf8;

新建项目

  1. 新建一个普通的Maven项目

  2. 删除src目录

  3. 导入依赖：mysql-connector-java、MyBatis.jar、Junit.jar

        <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

2.2 创建一个模块

  1. 编写mybatis的核心配置文件

    <?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/users?useUnicode=true&amp;useSSL=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

  2. 编写MyBatis工具类

    package com.jian.utils;

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 java.io.IOException;
import java.io.InputStream;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {

        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

2.3 编写代码

  1. 实体类

  2. Dao接口

    package com.jian.dao;

import com.jian.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> getUsers();
}

  3. Dao接口实现类–>由原来的UserDaoImpl.java转为UserMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.jian.dao.UserDao">
    <!--select查询语句，id是接口中对应的方法名，resultType是返回类型，泛型使用<具体类型>-->
    <select id="getUsers" resultType="com.jian.pojo.User">
        select *
        from users
    </select>
</mapper>

2.4 测试

注意点*😗*需要在MyBatis核心配置文件中注册mappers，MyBatis的配置文件中不能有中文注释

package com.jian.dao;

import com.jian.pojo.User;
import com.jian.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test() {
        //1.第一步：获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //方式一：getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.getUsers();
        for (User user : users) {
            System.out.println(user.getName());
        }
        //关闭SqlSession
        sqlSession.close();
    }
}

3. CRUD

3.1 namespace

namespace中的包名要和Dao/mapper接口的包名一致

3.2 select

选择，查询语句

  • id：就是对应的namespace中的方法名
  • resultType：Sql语句执行的返回值
  • parameterType：参数类型

UserMapper

    //根据Id查询用户
    User getUserById(int id);

UserMapper.xml

    <select id="getUserById" parameterType="int" resultType="com.jian.pojo.User">
        select *
        from users
        where id = #{id}
    </select>

Test

    @Test
    public void getUserById() {
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

3.3 Insert、update、delete

UserMapper

    //增添用户
    int addUser(User user);

    //修改用户
    int updateUser(User user);

    //删除用户
    int deleteUser(int id);

UserMapper.xml

    <insert id="addUser" parameterType="com.jian.pojo.User">
        insert into users
        values (#{id}, #{name}, #{password}, #{email}, #{birthday})
    </insert>
    <update id="updateUser" parameterType="com.jian.pojo.User">
        update users
        set name=#{name}
        where id = #{id}
    </update>
    <delete id="deleteUser" parameterType="int">
        delete
        from users
        where id = #{id}
    </delete>

Test

    @Test
    public void addUser() throws ParseException {
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int rec = mapper.addUser(new User(5, "张三", "123456", "666666@qq.com", new SimpleDateFormat("yyyy-MM-dd").parse("1999-10-10")));
        if (rec>0){
            System.out.println("插入成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void updateUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user=new User();
        user.setId(5);
        user.setName("Jack");
        int i = mapper.updateUser(user);
        if (i>0){
            System.out.println("修改成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void deleteeUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteUser(5);
        if (i>0){
            System.out.println("删除成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }

增删改需要提交事务

3.4 分析错误

  • 标签不要匹配错
  • resource绑定mapper，需要使用路径/

3.5 万能Map

假设我们的实体类或者数据库中的表，字段或者参数过多，我们应当考虑使用Map

UserMapper

    //修改用户，使用万能Map
    int modifyUser(Map<String, Object> map);

UserMapper.xml

    <update id="modifyUser" parameterType="map">
        update users
        set name=#{username}
        where id = #{userId}
    </update>

Test

    //万能Map传参
    @Test
    public void modifyUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String, Object> map = new HashMap<>();
        map.put("username","Jack");
        map.put("userId",4);
        int i = mapper.modifyUser(map);
        if (i>0){
            System.out.println("修改成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }
  • Map传递参数，直接在sql中取出key即可（parameterType=“map”)
  • 对象传递参数，直接在sql中取对象的属性即可（parameter.Type=“com.jian.pojo.Object”）
  • 只有一个基本参数类型的情况下，可以直接在sql中取到
  • 传递多个参数用Map或者注解

3.6 模糊查询

  1. Java代码执行的时候，传递通配符% %

        //模糊查询
    @Test
    public void getUsersLike(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsersLike("%J%");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

  2. 在SQL拼接中使用通配符

    UserMapper.xml

        <select id="getUsersLike" resultType="com.jian.pojo.User">
        select *
        from users
        where name like concat("%",#{value},"%")
    </select>

        <select id="getUsersLike" resultType="com.jian.pojo.User">
        select *
        from users
        where name like "%"#{value}"%"
    </select>

4. 配置解析

4.1 核心配置文件

  • mybatis-config.xml
  • Mybatis的配置文件包含了影响MyBatis行为的设置和属性信息
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

4.2 环境配置(environments)

Mybatis可以配置成适应多种环境

    <environments default="test">
        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&amp;useSSL=true&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境

Mybatis默认的事务管理器就是JDBC、连接池：POOLED

4.3 属性（properties)

我们可以通过properties属性来实现引用配置文件

这些属性都是可外部配置且可动态替换的，既可以在典型的Java属性文件中配置，也可通过properties元素的子元素来传递

  1. 编写外部配置文件

    db.properties

    driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&useSSL=true&characterEncoding=utf-8
username=root
password=123456

  2. 在MyBatis核心配置文件中引入

        <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>

注意点

  • 可以直接引入外部文件

    <properties resource="db.properties"/>

  • 可以在其中添加一些属性配置

    <properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="password" value="123456">
</properties>

  • 如果两个文件有同一个字段，优先使用外部配置文件的

  • 在mybatis-config.xml中标签定义有顺序，比如<properties>在<environments>前

4.4 类型别名(typeAliases)

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写

<!--可以给实体类取别名-->
<typeAliases>
    <typeAlias type="com.jian.pojo.User" alias="User"/>
</typeAliases>

也可以指定一个包名，MyBatis会在包名下搜索需要的Java Bean，比如：

扫描实体类的包，它的默认别名就是这个类的类名，首字母小写

<!--可以给实体类所在包取别名-->
<typeAliases>
    <package name="com.jian.pojo"/>
</typeAliases>

在实体类比较少的时候，使用第一种方式

如果实体类十分多，建议使用第二种

第一种可以DIY别名；第二种则不行，如果非要改，可以在实体上增加注解@Alias(“user”)

4.5 设置

这是MyBatis中极为重要的调整设置，它们会改变MyBatis的运行时行为

在这里插入图片描述

在这里插入图片描述

4.6 其他设置

4.7 映射器(mappers)

MapperRegistry：注册绑定我们的Mapper文件

方式一：

    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/jian/dao/UserMapper.xml"/>
    </mappers>

方式二：使用class文件绑定注册

<mappers>
    <mapper class="com.jian.dao.UserMapper"/>
</mappers>

注意点

  • dao/mapper接口和它对应的Mapper配置文件必须同名
  • dao/mapper接口和它对应的Mapper配置文件必须在同一个包下

方式三：使用扫描包进行注册，注意点同上

<mappers>
    <package name="com.jian.dao"/>
</mappers>

4.8 生命周期和作用域

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题

在这里插入图片描述

SqlSessionFactoryBuilder:

  • 一旦创建了 SqlSessionFactory，就不再需要它了
  • SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）

SqlSessionFactory:

  • SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
  • 可以想象为数据库连接池
  • SqlSessionFactory 的最佳作用域是应用作用域
  • 最简单的就是使用单例模式或者静态单例模式

SqlSession:

  • 连接到连接池的一个请求
  • SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
  • 用完之后要赶紧关闭，否则资源被占用

在这里插入图片描述

每一个Mapper就代表一个具体的业务

5. 解决属性名和字段名不一致的问题

5.1 问题

数据库中的字段

在这里插入图片描述

新建一个项目，拷贝之前的，测试实体类字段不一致的情况

在这里插入图片描述

出现问题

在这里插入图片描述

解决方法

  • 起别名

    <select id="getUserById" resultType="User">
    select id,name,password as pwd from users where id=#{id}
</select>

5.2 ResultMap

数据库：id name password
实体类：id name pwd

结果集映射

<!--结果集映射-->
<resultMap id="UserMap" type="com.jian.pojo.User">
    <!--column数据库中的字段，property实体类的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="password" property="pwd"/>
</resultMap>
<select id="getUserById" resultMap="UserMap">
    select * from users where id = #{id}
</select>
  • resultMap 元素是 MyBatis 中最重要最强大的元素
  • ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了
  • ResultMap 的优秀之处——你完全可以不用显式地配置它们

6. 日志

6.1 日志工厂

如果一个数据库操作，出现了异常，我们需要排错，日志就是最好的助手

曾经：sout、debug

现在：日志工厂

在这里插入图片描述

  • SLF4J
  • LOG4J
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING
  • NO_LOGGING

在Mybatis中具体使用哪一个日志实现，在设置中设定

STDOUT_LOGGING标准日志输出

在mybatis核心配置文件mybatis-config.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="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>
    <!--日志配置-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <typeAliases>
        <typeAlias type="com.jian.pojo.User" alias="user"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url"
                          value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--<mapper resource="com/jian/dao/UserMapper.xml"/>-->
        <!--<mapper class="com.jian.dao.UserMapper"/>-->
        <package name="com.jian.dao"/>
    </mappers>
</configuration>

在这里插入图片描述

6.2 LOG4J

什么是LOG4J：

  • Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
  • 可以控制每一条日志的输出格式
  • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
  • 以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

  1. 导log4j的jar包

    <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

  2. log4j配置文件log4j.properties

    #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/jian.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

  3. 配置log4j为日志的实现

        <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

  4. log4j的使用，直接测试运行！

    在这里插入图片描述

简单使用

  1. 在要使用Log4j的类中，导入包import org.apache.log4j.Logger

  2. 日志对象，参数为当前类的Class对象

    static Logger logger=Logger.getLogger(UserMapperTest.class);

  3. 日志级别

    logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");

7. 分页

思考：为什么要分页：

  • 减少数据的处理量

7.1 使用Limit分页

select * from users limit startIndex,pageSize
select * from user limit 3; #[0,n]

使用MyBatis实现分页，核心SQL

  1. 接口

    //分页查询用户
List<User> getUserLimit(Map<String, Integer> map);

  2. Mapper.xml

    <select id="getUserLimit" parameterType="map" resultMap="UserMap">
    select *
    from users limit #{startIndex},#{pageSize}
</select>

  3. 测试

    //分页查询
@Test
public void getUserLimit() {
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map<String,Integer> map=new HashMap<String,Integer>();
    map.put("startIndex",0);
    map.put("pageSize",3);
    List<User> userList = mapper.getUserLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

7.2 RowBounds分页

不再使用SQL实现分页

  1. 接口

    //查询所有用户
List<User> getUsers();

  2. Mapper.xml

    <select id="getUsers" resultType="user">
    select *
    from users
</select>

  3. 测试

    //RowBounds分页
@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    RowBounds rowBounds = new RowBounds(1, 3);
    List<User> users = sqlSession.selectList("com.jian.dao.UserMapper.getUsers", null, rowBounds);
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
}

7.3 分页插件

https://pagehelper.github.io/

8 使用注解开发

8.1 面向接口编程

  • 之前学过面向对象编程，也学过接口，但是在真正开发中，很多时候我们会选择面向接口编程
  • 根本原因：解耦，可拓展，提高复用，分层开发中上层不用管具体的实现，大家都遵守共同的标准，使得开发变的容易，规范性更好
  • 在一个面向对象的系统中，系统的各种功能是有许许多多的不同对象协作完成的，在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了
  • 而各个对象之间的协作关系则成为系统设计的关键，小到不同类之间的通信，大到各个模块之间的交互在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容，面向接口编程就是指按照这种思想来编程

关于接口的理解

  • 接口从更深层次的理解，应是定义（规范、约束）与实现（名实分离的原则）的分离
  • 接口本身反映了系统设计人员对系统的抽象理解
  • 接口应有两类：
    • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)
    • 第二类是对一个个体某一方面的抽象，即形成一个抽象面(interface)
  • 一个个体可能有多个抽象面，抽象体和抽象面是有区别的

三个面向区别

  • 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性和方法
  • 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现
  • 接口设计和非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构

8.2 使用注解开发

  1. 注解直接在接口上使用

    package com.jian.dao;

import com.jian.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {

    @Select("select * from users")
    List<User> getUsers();
}

  2. 需要在核心配置文件中绑定接口

    <mappers>
    <mapper class="com.jian.dao.UserMapper" />
</mappers>

  3. 测试

    @Test
public void getUsers(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = mapper.getUsers();
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
}

本质：反射机制实现

底层：动态代理

Mybatis执行原理

在这里插入图片描述

8.3 CRUD

我们可以在工具类创建的时候实现自动提交事务！

public static SqlSession getSqlSession() {
    return sqlSessionFactory.openSession(true);
}

编写接口，增加注解

package com.jian.dao;

import com.jian.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface UserMapper {

    @Select("select * from users")
    List<User> getUsers();

    //方法中存在多个形参时，所有参数前必须加上@Param("id")注解，引用对象不需要写@Param()
    @Select("select * from users where id=#{id}")
    User getUserById(@Param("id") int userId);
    
    @Insert("insert into users values(#{id},#{name},#{pwd},#{birthday},#{email})")
    int addUser(User user);
    
    @Update("update users set name=#{name} where id=#{id}")
    int updateUser(User user);
    
    @Delete("delete from users where id=#{id}")
    int deleteUser(@Param("id") int id);
}

注意：我们必须要将接口注册绑定到我们的核心配置文件中！

关于@Param()注解

  • 基本类型的参数或者String类型需要加上
  • 引用类型不用加
  • 如果只有一个基本类型的话，可以忽略，但是建议加上
  • 我们在SQL中引用的就是我们这里的@Param()中设定的属性名

9. Lombok

  • java library
  • plugs
  • build tools
  • with one annotation your class

使用步骤：

  1. 在IDEA中安装Lombok插件

  2. 在项目pom.xml中导入lombokjar包

    <dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

  3. 在实体类上加注解

    package com.jian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
    private String email;
    private Date birthday;
}

    @Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors

说明

@Data：无参构造、有参、无参、toString、hashCode、equals
@AllargsConstructor
@NoArgsConstructor

10. 多对一处理

  • 多个学生对应一个老师
  • 对于学生这边而言，关联—多个学生，关联一个老师【多对一】
  • 对于老师而言，集合—一个老师，有很多学生【一对多】

在这里插入图片描述

测试环境搭建

在这里插入图片描述

  1. 导入lombok

  2. 新建实体类Teacher、Student

    package com.jian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;
}

    package com.jian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private Teacher teacher;
}

  3. 配置Mybatis核心配置文件

    <?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="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url"
                          value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.jian.dao"/>
    </mappers>
</configuration>

  4. 建立Mapper接口

  5. 建立Mapper.xml文件

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.dao.StudentMapper">

</mapper>

  6. 测试查询是否能够成功

按照查询嵌套处理

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.dao.StudentMapper">
    <select id="getStudent" resultMap="StudentMap">
        select *
        from student
    </select>
    <resultMap id="StudentMap" type="Student">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <!--复杂属性单独处理，如果是对象使用association，如果是集合，使用collection-->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="Teacher">
        select *
        from teacher
        where id = #{id}
    </select>
</mapper>

按照结果嵌套处理

<select id="getStudent2" resultMap="StudentMap2">
    select s.id sid, s.name sname, t.name tname
    from teacher t,
         student s
    where t.id = s.tid
</select>
<resultMap id="StudentMap2" type="Student">
    <result column="sid" property="id"/>
    <result column="sname" property="name"/>
    <association property="teacher" javaType="Teacher">
        <result column="tname" property="name"/>
    </association>
</resultMap>

@Test
public void getStudent(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> student2 = mapper.getStudent2();
    for (Student student : student2) {
        System.out.println(student);
    }
    sqlSession.close();
}

11. 一对多处理

比如：一个老师拥有多个学生

对于老师而言，就是一对多的关系

  1. 环境搭建，和刚才一样

    实体类

    package com.jian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;
    private List<Student> students;
}

    package com.jian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private int tid;
}

  2. 编写接口和mapper.xml

    package com.jian.dao;

import com.jian.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface TeacherMapper {
    List<Teacher> getTeachers();

    //获取指定老师下的所有学生信息
    Teacher getTeacherById(@Param("tid") int id);
}

按结果嵌套处理

<select id="getTeacherById" resultMap="TeacherMap">
    select s.id sid, s.name sname, t.id tid, t.name tname
    from student s,
         teacher t
    where s.tid = t.id
      and t.id = #{tid}
</select>
<resultMap id="TeacherMap" type="Teacher">
    <result property="id" column="id"/>
    <result property="name" column="tname"/>
    <!--复杂的属性，我们需要单独处理，对象：association 集合：collection javaType：指定属性的类型  集合中的泛型信息，我们使用ofType获取-->
    <collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

按查询嵌套处理

<select id="getTeacherById2" resultMap="TeacherMap2">
    select *
    from teacher
    where id = #{tid}
</select>
<resultMap id="TeacherMap2" type="Teacher">
    <result property="id" column="id"/>
    <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="SelectStudent"/>
</resultMap>
<select id="SelectStudent" resultType="Student">
    select *
    from student
    where tid = #{tid}
</select>

小结

  1. 关联-association【多对一】
  2. 集合-collection【一对多】
  3. javaType & ofType
    • javaType用来指定实体类中属性的类型
    • ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

注意点：

  1. 保证SQL的可读性，尽量保证能够通俗易懂
  2. 注意一对多和多对一中，属性名和字段的问题
  3. 如果问题不好排错，可以使用日志，建议Log4j

12. 动态SQL

什么是动态SQL：动态SQL就是指根据不同的条件生成不同的SQL语句

根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

  • if
  • choose (when, otherwise)
  • trim (where, set)
  • foreach

搭建基础环境

CREATE TABLE `blog`(
`id` VARCHAR(50) NOT NULL COMMENT '博客id',
`title` VARCHAR(100) NOT NULL COMMENT '博客标题',
`author` VARCHAR(30) NOT NULL COMMENT '博客作者',
`create_time` DATETIME NOT NULL COMMENT '创建时间',
`views` INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8

  1. 导包

  2. 编写核心配置文件

    <?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="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--数据库属性驼峰命名处理-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <package name="com.jian.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url"
                          value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.jian.dao"/>
    </mappers>
</configuration>

  3. 编写实体类pojo和工具类utils

    package com.jian.utils;

import org.junit.Test;

import java.util.UUID;

public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replace("-","");
    }
}

  4. 编写接口以及接口实现mapper.xml文件

  5. 测试

12.1 IF

接口

List<Blog> queryBlogIF(Map map);

blogMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.dao.BlogMapper">
    <select id="queryBlogIF" parameterType="map" resultType="Blog">
        select *
        from blog
        where 1 = 1
        <if test="title!=null">
            and title=#{title}
        </if>
        <if test="author!=null">
            and author=#{author}
        </if>
    </select>
</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.dao.BlogMapper">
    <select id="queryBlogIF" parameterType="map" resultType="Blog">
        select *
        from blog
        <where>
        <if test="title!=null">
            title=#{title}
        </if>
        <if test="author!=null">
            and author=#{author}
        </if>
        </where>
    </select>
</mapper>

Test

@Test
public void queryBlogIF(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap map=new HashMap();
    map.put("title","Java如此简单");
    List<Blog> blogs = mapper.queryBlogIF(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.close();
}

12.2 Choose(when,otherwise)、where

接口

List<Blog> queryBlogChoose(Map map);

BlogMapper.xml

<select id="queryBlogChoose" parameterType="map" resultType="Blog">
    select *
    from blog
    <where>
        <choose>
            <when test="title!=null">
                title=#{title}
            </when>
            <when test="author!=null">
                and author=#{author}
            </when>
            <otherwise>and views=#{views}</otherwise>
        </choose>
    </where>
</select>

Test

@Test
public void queryBlogChoose(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    map.put("author","小飞机");
    List<Blog> blogs = mapper.queryBlogChoose(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.close();
}

12.3 Trim(where,set)

接口

int updateBlog(Map map);

BlogMapper.xml

<update id="updateBlog" parameterType="map">
    update blog
    <set>
        <if test="title!=null">title=#{title},</if>
        <if test="author!=null">author=#{author}</if>
    </set>
    where id=#{id}
</update>

Test

@Test
public void updateBlog(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    map.put("id","98beac9a791242c5ad2f704ab9401254");
    map.put("author","大灰狼");
    int i = mapper.updateBlog(map);
    if (i>0){
        System.out.println("Update Successfully");
    }
    sqlSession.close();
}

所谓动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码

与 set 元素等价的自定义 trim 元素

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

12.4 SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用

  1. 使用SQL标签抽取公共部分

  2. 在需要使用的地方使用include标签引用即可

    <sql id="if-title-author">
    <if test="title!=null">
        title=#{title}
    </if>
    <if test="author!=null">
        and author=#{author}
    </if>
</sql>
<select id="queryBlogIF" parameterType="map" resultType="Blog">
    select *
    from blog
    <where>
        <include refid="if-title-author"></include>
    </where>
</select>

注意事项：

  • 最好基于单表来定义SQL片段
  • 不要存在where标签

12.4 foreach

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。比如：

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
        #{item}
  </foreach>
</select>

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！

提示 你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

接口

List<Blog> queryBlogForeach(Map map);

BlogMapper.xml

<select id="queryBlogForeach" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <foreach collection="ids" item="id" open="and (" close=")" separator="or">
            id=#{id}
        </foreach>
    </where>
</select>

Test

@Test
public void queryBlogForeach(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    ArrayList<String> ids = new ArrayList<String>();
    ids.add("98beac9a791242c5ad2f704ab9401254");
    ids.add("8b1341eb59d646d0a0114971911920dc");
    map.put("ids",ids);
    List<Blog> blogs = mapper.queryBlogForeach(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.close();
}

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

13. 缓存

13.1 缓存简介

  1. 什么是缓存[Cache]？
    • 存在内存中的临时数据
    • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题
  2. 为什么使用缓存？
    • 减少和数据库的交互次数，减少系统开销，提高系统效率
  3. 什么样的数据能使用缓存
    • 经常查询并且不经常改变的数据

13.2 Mybatis缓存

  • MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存，缓存可以极大的提升查询效率
  • MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
    • 默认情况下，只有一级缓存开启（SqlSession级别的缓存，也称本地缓存）
    • 二级缓存需要手动开启和配置，他是给予namespace级别的缓存
    • 为了提高扩展性，MyBatis定义了缓存的接口Cache，我们可以通过实现Cache接口来定义二级缓存

13.3 一级缓存

  • 一级缓存也叫本地缓存：SqlSession
    • 与数据库同一次会话期间查询到的数据会放在本地缓存中
    • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

测试步骤：

  1. 开启日志

  2. 测试在一个SqlSession中查询两次相同记录

  3. 查看日志输出

    在这里插入图片描述

缓存失效的情况

  1. 查询不同的东西

  2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存

  3. 查询不同的Mapper.xml

  4. 手动清理缓存

    import com.jian.dao.UserMapper;
import com.jian.pojo.User;
import com.jian.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {
    @Test
    public void getUserById() {
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user1 = mapper.getUserById(1);
        System.out.println(user1);
        sqlSession.clearCache();  //手动清理一级缓存
        System.out.println("=======================");
        User user2 = mapper.getUserById(1);
        System.out.println(user2);
        System.out.println(user1==user2);
        sqlSession.close();
    }
}

小结：一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段

13.4 二级缓存

  • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以就诞生了二级缓存
  • 给予namespace级别的缓存，一个命名空间，对应一个二级缓存
  • 工作机制
    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
    • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要到的是，一级缓存中的数据被保存在二级缓存中
    • 新的会话查询信息，就可以从二级缓存中获取内容
    • 不同的mapper查出的数据会放在自己对应的缓存(map)中

步骤：

  1. 开启全局缓存（在mybatis核心配置文件中开启，默认是开启的）

    <settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!--显示开启全局缓存-->
    <setting name="cacheEnabled" value="true"/>
</settings>

  2. 在要使用二级缓存的Mapper中开启

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.dao.UserMapper">
    <!--在当前Mapper.xml中使用二级缓存-->
    <cache/>
    <select id="getUserById" resultType="User" useCache="true">
        select *
        from users
        where id = #{uid}
    </select>
</mapper>

    也可以自定义参数

    <cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>
<!--这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突-->

  3. 测试

    @Test
public void TestCache(){
    SqlSession s1 = MyBatisUtils.getSqlSession();
    SqlSession s2 = MyBatisUtils.getSqlSession();
    UserMapper m1 = s1.getMapper(UserMapper.class);
    UserMapper m2 = s2.getMapper(UserMapper.class);
    User user1 = m1.getUserById(1);
    System.out.println(user1);
    s1.close();
    User user2 = m2.getUserById(1);
    System.out.println(user2);
    System.out.println(user1==user2);
    s2.close();
}
    • 可能遇到的问题是没有将实体类序列化，否则会报错
    @Data
class User implements Serializable{
    private int id;
    private String name;
    private String password;
    private Date birthday;
    private String eamil;
}

    在这里插入图片描述

小结：

  • 只要开启了二级缓存，在同一个Mapper接口下就有效
  • 所有的数据都会先放在一级缓存中
  • 只有当前会话提交，或者关闭的时候，才会提交到二级缓存中

13.5 缓存原理

在这里插入图片描述

13.6 自定义缓存ehcache

Ehcache是一种广泛使用的开源Java分布式缓存，主要面向通用缓存

  1. 要在程序中使用，需要先导包
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.0.0</version>
</dependency>
  1. 在mapper.xml中指定使用我们的encache缓存实现
<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
  1. 还要新建一个ehcache.xml配置文件放到resources目录下
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    
    <diskStore path="./tmpdir/Tmp_EhCache"/>

    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>

    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>
故人は似て
关注
专栏目录
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL...
Mybatis增强版MyBatis-Flex介绍
沉淀、分享、成长，让自己和他人都能有所收获！
08-14 3万+
本文介绍了 Mybatis-Flex，一个用于增强 MyBatis 的框架。相对于 MyBatis-Plus，Mybatis-Flex提供了一些显著的特点，如支持联表查询以及在Mybatis-Plus中收费的功能在Mybatis-Flex中是免费的。文章概述了 MyBatis-Flex 的功能特点，并深入介绍了联表查询的不同方案。
MyBatis
weixin_45984258的博客
12-25 3138
MyBatisMyBatis快速入门Mapper代理开发MyBatis核心配置文件配置文件完成增删改查注解完成增删改查动态SQL MyBatis快速入门 MyBatis： Mybatis 是一款优秀的持久层框架，用于简化JDBC开发 JDBC的缺点： 1、硬编码： 注册驱动 SQL与君 2、操作繁琐 手动设置参数 手动封装结果集 MyBatis本是Apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到google code，并改名
完美解决org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflec
05-15 7万+
org.mybatis.spring.MyBatisSystemException是MyBatis与Spring集成时可能出现的异常，主要原因是在MyBatis的配置或使用过程中出现了问题。解决此异常的方法包括以下步骤：
Mybatis 返回Map数据
菜鸟记录
03-30 3万+
⏹Mybatis 返回Map数据
完美解决org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.Per
05-14 7万+
org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException: Error querying database. Cause: java.sql.SQLSyntaxErrorException: ORA-00942: table or view does not exist 这个异常通常是因为 MyBatis 无法找到指定的表或视图而引起的。
Mybatis 开启控制台打印sql语句
热门推荐
路西法Lucifer
09-21 18万+
springboot+mybatis整合过程中，开启控制台sql语句打印的两种方式： 方法一： 1.在mybatis的配置文件中添加： &lt;settings&gt; &lt;!-- 打印sql日志 --&gt; &lt;setting name="logImpl" value="STDOUT_LOGGING" /&gt; &lt;/settings&gt; myba...
MyBatis的特点
m0_51718823的博客
09-14 3442
MyBatis特点？ 　　1.轻量级自身不依赖其他任何JAR,但需要提供JDBC实现 　　2.灵活,更加适用于需求变化频繁的互联网应用 　　3.学习成本低,相比ORM框架而言,掌握MyBatis的使用是很轻松的 MyBatis在结构中的位置？ 　　MyBatis处在DAO(数据访问对象)的位置,回顾一下DAO的工作职责: 　　连接数据库 　　接收输入数据 　　拼接并执行SQL 　　解析并返回结果 MyBatis可以做什么？ 　　使用JDBC完成DAO层存在以下问题 　　每次操作都需要
Spring——Spring整合MyBatis
胜天半子祁同伟
03-13 2万+
Spring——Spring整合MyBatis
MyBatis入门.pdf
09-24
MyBatis入门 MyBatis是一个优秀的持久层框架，使用XML将SQL与程序解耦，便于维护。MyBatis学习简单，执行高效，是JDBC的延伸。MyBatis提供了数据库增删改查的便捷操作，极大提高了开发效率、统一的编码规则、利于...
MyBatis.pdf
12-02
MyBatis 详解 MyBatis 是一个基于 Java 的持久层框架，它提供了一个简单的方式来交互数据库。下面是 MyBatis 的详解： MyBatis 基本概念 MyBatis 是一个基于传统 DAO 模式开发的框架，提供了一个简单的方式来交互...
mybatis
01-19
mybatis　“玩转”Java 系列
mybatis-3.5.10.zip
07-21
MyBatis is a first class persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 726
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 994
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 205
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 813
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
MyBatis Plus
04-30
MyBatis Plus是一个基于MyBatis的增强工具，提供了很多方便的功能和特性，如自动生成代码、配置简化、增强查询效率等。它基于MyBatis进行封装，使用更方便，功能更强大。 MyBatis Plus提供了以下主要功能： 1. 自动生成代码：MyBatis Plus提供了代码生成器，可以根据数据库表自动生成相应的实体类、Mapper接口和XML文件，减少了手动编写代码的工作量。 2. 配置简化：MyBatis Plus简化了配置文件，提供了更加方便的注解方式，使得配置更加简洁明了。 3. 缓存优化：MyBatis Plus对缓存进行了优化，支持一级缓存和二级缓存，可以提高查询效率。 4. 查询优化：MyBatis Plus提供了多种查询方式，如批量查询、分页查询、排序查询等，可以提高查询效率。 5. 插件机制：MyBatis Plus提供了插件机制，可以通过编写插件来扩展功能，如数据校验、日志记录等。 6. 数据库连接池管理：MyBatis Plus提供了数据库连接池管理功能，可以自动管理数据库连接，提高性能。 总之，MyBatis Plus是一个功能强大的ORM框架，它简化了开发过程，提高了开发效率，使得开发者能够更加专注于业务逻辑的实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值