mybatis

最新推荐文章于 2024-09-19 22:11:12 发布
最新推荐文章于 2024-09-19 22:11:12 发布
阅读量235 收藏
点赞数
分类专栏： Mybatis 文章标签： 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chu_dianxia/article/details/117825510
版权

Mybatis-9.28

环境：

  • JDK 1.8
  • Mysql 5.7
  • maven 3.6.1
  • IDEA

回顾：

  • JDBC
  • Mysql
  • Java基础
  • Maven
  • Junit

SSM框架：配置文件的。最好的方式：看官网文档；

1.简介

1.1、什么是Mybatis

MyBatis logo

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

如何获得Mybatis？

  • Typora：https://typora.io/#windows

  • maven仓库:

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>
  • Github：https://github.com/mybatis/mybatis-3/releases
  • 中文文档：https://mybatis.org/mybatis-3/zh/index.html

1.2、持久层

数据持久化

  • 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
  • 内存：断电即失
  • 数据库（jdbc），io文件持久化。
  • 生活：冷藏，罐头。

为什么需要持久化？

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

1.3、持久层

Dao层，Service层，Controller层…

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

1.4、为什么需要Mybatis？

  • 帮助程序猿将数据存入到数据库中。
  • 方便
  • 传统的JDBC代码太复杂了。简化。框架。自动化。
  • 不用Mybatis也可以。更容易上手。技术没有高低之分
  • 优点：
    • 简单易学
    • 灵活
    • sql和代码的分离，提高了可维护性。
    • 提供映射标签，支持对象与数据库的orm字段关系映射
    • 提供对象关系映射标签，支持对象关系组建维护
    • 提供xml标签，支持编写动态sql。

最重要的一点：使用的人多！

Spring SpringMVC SpringBoot

2.第一个Mybatis程序

思路：搭建环境——>导入Mybatis——>编写代码——>测试！

2.1、搭建环境

搭建数据库

create database `mybatis`;

user `mybatis`;

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(20) NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  `pwd` varchar(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `user` VALUES ('1', '狂神', '123456');
INSERT INTO `user` VALUES ('2', '张三', '654321');
INSERT INTO `user` VALUES ('3', '李四', '456789');

新建项目

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

  2. 删除src目录

  3. 导入maven依赖(首先得有maven和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.kuang</groupId>
    <artifactId>Mybatis-Study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-01</module>
    </modules>

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--Mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

    <!--在build中配置resources,来防止我们资源导出失败的问题-->
    <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>
</project>

2.2、创建一个模块

  • 编写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核心配置文件-->
<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/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/kuang/dao/UserMapper.xml"/>
    </mappers>
</configuration>

  • 编写mybatis工具类

    //sqlSessionFactory——>sqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //使用Mybatis第一步：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3、编写代码

  • 实体类

    //实体类
public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

  • Dao接口

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

  • 接口实现类(由原来的UserDaoImpl转变为一个Mapper配置文件)

    <?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.kuang.dao.UserDao">

    <!--select查询语句-->
    <select id="getUserList" resultType="com.kuang.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

2.4、测试

注意点：org.apache.ibatis.binding.BindingException: Type interface com.kuang.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？

核心配置文件中注册mappers

  • junit测试

     @Test    public void test(){        //第一步：获得SqlSession对象        SqlSession sqlSession = MybatisUtils.getSqlSession();        //        UserDao userDao = sqlSession.getMapper(UserDao.class);        List<User> userList = userDao.getUserList();        for (User user:userList){            System.out.println(user);        }        //关闭SqlSession        sqlSession.close();    }

你们可能会遇到的问题：

  1. 配置文件没有注册
  2. 绑定接口错误
  3. 方法名不对
  4. 返回类型不对
  5. Maven导出资源问题

3.CRUD

1、namespace

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

2、select

选择，查询语句

  • id：就是对应的namespace中的方法名

  • resultType：Sql语句执行的返回值！

  • parameterType：参数类型！

     MyBatis的传入参数parameterType类型分两种:  1. 基本数据类型：int,string,long,Date;  2. 复杂数据类型：类和Map

  1. 编写接口

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

  2. 编写对应的mapper中的sql语句

    <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">        select * from mybatis.user where id = #{id};</select>

  3. 测试

     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、insert

 <!--对象中的属性,可以直接取出来-->    <insert id="addUser" parameterType="com.kuang.pojo.User">        insert into mybatis.user(id, name, pwd) values (#{id},#{name},#{pwd});    </insert>

4、update

<update id="updateUser" parameterType="com.kuang.pojo.User">        update mybatis.user set  name=#{name},pwd=#{pwd} where id=#{id};</update>

5、delete

<delete id="deleteUser" parameterType="int">        delete from mybatis.user where id=#{id};</delete>

注意点：

  • 增删改需要提交事务！

      //提交事务    sqlSession.commit();

6、分析错误

  • 标签不要匹配错

  • resource 绑定mapper,需要使用路径（/）！

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

  • 程序配置文件必须符合规范！

    mybatis-config.xml中多添元素，列：“”错误：<property name="password" value="root""/>正确：<property name="password" value="root"/>

  • NullPointerException，没有注册到资源！

    MybatisUtils里多了个SqlSessionFactory错误： SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);正确：sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

  • 输出的xml文件中存在中文乱码问题！

    mybatis-config.xml中缺少characterEncoding=UTF-8"错误：  <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;/>正确：  <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>

  • maven资源没有导出问题！

      <!--在build中配置resources,来防止我们资源导出失败的问题-->    <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></project>

7、万能Map

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

 //万能Map    int addUser2(Map<String,Object> map);

 <!--对象中的属性,可以直接取出来  传递map的key-->    <insert id="addUser2" parameterType="map">        insert into mybatis.user(id, name, pwd) values (#{userid},#{username},#{password});    </insert>

 @Test    public void addUser2(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        Map<String, Object> map = new HashMap<String, Object>();        map.put("userid",5);        map.put("username","哈智");        map.put("password","456456");        mapper.addUser2(map);        sqlSession.commit();        sqlSession.close();    }

Map传递参数，直接在sql中取出key即可！【parameterType=“map”】

对象传递参数，直接在sql中取对象的属性即可！【parameterType=“Object”】

只有一个基本类型参数的情况下，可以直接在sql中取到！

多个参数用Map，或者注解！

8、思考题(Like)

模糊查询怎么写？

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

      List<User> userList = mapper.getUserLike("%李%");

  2. 在sql拼接中使用通配符#{}！

    select * from mybatis.user where name like "%"#{value}"%";

  3. ${}拼接

select * from mybatis.user where name like '%${value}%';

4.配置解析

1、核心配置文件

  • mybatis-config.xml

  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

    configuration（配置）properties（属性）settings（设置）typeAliases（类型别名）typeHandlers（类型处理器）objectFactory（对象工厂）plugins（插件）environments（环境配置）environment（环境变量）transactionManager（事务管理器）dataSource（数据源）databaseIdProvider（数据库厂商标识）mappers（映射器）

2、环境配置（environments）

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

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

学会使用配置多套运行环境！

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

3、属性（properties）

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

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-beXK1zXV-1623407474345)(Mybatus-9.28.assets/4-3属性.PNG)]

编写一个配置文件

db.properties

driver=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8username=rootpassword=root

在核心配置文件中映入

  • 可以直接引入外部文件

    db.properties配置(如上)

     <!--引入外部配置文件-->    <properties resource="db.properties"/>

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

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

    driver=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8

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

4、类型别名（typeAliases）

  • 类型别名可为 Java 类型设置一个缩写（短）名字。

  • 存在的意义降低冗余的全限定类名书写。

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

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

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

<!--可以给实体类起别名-->    <typeAliases>       <package name="com.kuang.pojo"/>    </typeAliases>

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

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

第一种可以DIY别名，第二种则 ·不行· ，如果非要改，需要在实体上增加注解

@Alias("user")public class User {}

5、设置

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ryVWtc9C-1623407474346)(Mybatus-9.28.assets/4-5设置.PNG)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vdq6KREU-1623407474348)(Mybatus-9.28.assets/4-5设置2.PNG)]

6、其他配置

7、映射器（mappers）

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

方式一：【推荐使用】

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

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

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

注意点：

  • 接口和他的Mapper配置文件必须同名！
  • 接口和他的Mapper配置文件必须在同一个包下！

方式三：使用扫描包进行注入绑定

 <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->    <mappers>         <package name="com.kuang.dao"/>    </mappers>

注意点：

  • 接口和他的Mapper配置文件必须同名！
  • 接口和他的Mapper配置文件必须在同一个包下！

练习时间：

  • 将数据库配置文件外部引入
  • 实体类别名
  • 保证 UserMapper 接口和 UserMapper.xml 改为一致！并且放在同一个包下！

8、生命周期和作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wagwSrPb-1623407474348)(Mybatus-9.28.assets/4-8生命周期.png)]

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

SqlSessionFactoryBuilder：

  • 一旦创建了 SqlSessionFactory，就不再需要它了。
  • 局部变量

SqlSessionFactory：

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

SqlSession ：

  • 连接到连接池的一个请求！

  • SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

  • 用完之后需要赶紧关闭，否则资源被占用！

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ouoHjUUZ-1623407474349)(Mybatus-9.28.assets/4-8-2生命周期.PNG)]

这里面的每一个Mapper，就代表一个具体的业务！

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

1、问题

数据库中的字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rFrnVUm9-1623407474350)(Mybatus-9.28.assets/5-1问题.PNG)]

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

public class User {    private int id;    private String name;    private String password;}

测试出现问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gb6cM9kH-1623407474350)(Mybatus-9.28.assets/5-1问题-2.PNG)]

    //  select * from mybatis.user where id = #{id};    //类型处理器    //  select id,name,pwd from mybatis.user where id = #{id};

解决方案：

  • 起别名
 <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">        select id,name,pwd as password from mybatis.user where id = #{id}; </select>

2、resultMap

结果集映射

id    name    pwdid    name    password

    <!--结果集映射-->    <resultMap id="UserMap" type="User">        <!--column数据库中的字段，property实体类中的属性-->        <result column="id" property="id"/>        <result column="name" property="name"/>        <result column="pwd" property="password"/>    </resultMap>    <select id="getUserById"  resultMap="UserMap">        select * from mybatis.user where id = #{id};    </select>

  • 元素是 MyBatis 中最重要最强大的元素。

  • ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

  • ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。

  • 如果这个世界总是这么简单就好了。

6.日志(项目4)

1、日志工厂

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

曾经：sout、debug

现在：日志工厂

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aJNigay0-1623407474351)(Mybatus-9.28.assets/6-1日志工厂.PNG)]

  • SLF4J
  • LOG4J 【掌握】
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING 【掌握】
  • NO_LOGGING

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

STDOUT_LOGGING标准日志输出

在mybatis核心配置文件中，配置我们的日志！

<settings>    <!--标准的日志工厂实现-->    <setting name="logImpl" value="STDOUT_LOGGING"/></settings>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YUmLj1IO-1623407474351)(Mybatus-9.28.assets/6-1日志工厂-2.PNG)]

2、Log4j

什么是Log4j？

  • Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件

  • 我们也可以控制每一条日志的输出格式

  • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程

  • 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

  1. 先导入log4j包

    <!-- https://mvnrepository.com/artifact/log4j/log4j --><dependency>    <groupId>log4j</groupId>    <artifactId>log4j</artifactId>    <version>1.2.17</version></dependency>

  2. log4j.properties

    #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码log4j.rootLogger=DEBUG,console,file#控制台输出的相关设置log4j.appender.console = org.apache.log4j.ConsoleAppenderlog4j.appender.console.Target = System.outlog4j.appender.console.Threshold=DEBUGlog4j.appender.console.layout = org.apache.log4j.PatternLayoutlog4j.appender.console.layout.ConversionPattern=[%c]-%m%n#文件输出的相关设置log4j.appender.file = org.apache.log4j.RollingFileAppenderlog4j.appender.file.File=./log/kuang.loglog4j.appender.file.MaxFileSize=10mblog4j.appender.file.Threshold=DEBUGlog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n#日志输出级别log4j.logger.org.mybatis=DEBUGlog4j.logger.java.sql=DEBUGlog4j.logger.java.sql.Statement=DEBUGlog4j.logger.java.sql.ResultSet=DEBUGlog4j.logger.java.sql.PreparedStatement=DEBUG

  3. 配置log4j为日志的实现

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

  4. Log4j的使用！直接测试运行刚才的查询

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mxZ7Vovg-1623407474351)(Mybatus-9.28.assets/6-2Log4j.PNG)]

简单使用

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

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

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

  3. 日志级别

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

7.分页（项目4）

思考：为什么要分页？

  • 减少数据的处理量

1、使用Limit分页

语法：select * from user limit startIndex,pageSize;select * from user limit 3;  #[0,n]

使用Mybatis实现分页，核心SQL

  1. 接口

      //分页 List<User> getUserByLimit(Map<String,Integer> map);

  2. Mapper.xml

    <!--分页--><select id="getUserByLimit" parameterType="map" resultMap="UserMap">    select * from mybatis.user limit #{startIndex},#{pageSize};</select>

  3. 测试

    @Testpublic void getUserByLimit(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    UserMapper mapper = sqlSession.getMapper(UserMapper.class);    HashMap<String, Integer> map = new HashMap<String, Integer>();    map.put("startIndex",0);    map.put("pageSize",2);    List<User> userList = mapper.getUserByLimit(map);    for (User user:userList){        System.out.println(user);    }    sqlSession.close();}

2、RowBounds分页

不再使用SQL实现分页

  1. 接口

    //分页2List<User> getUserByRowBounds();

  2. mapper.xml

    <!--分页2--><select id="getUserByRowBounds" resultMap="UserMap">    select * from mybatis.user;</select>

  3. 测试

    @Testpublic void getUserByRowBounds(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    //RowBounds实现    RowBounds rowBounds = new RowBounds(0, 2);    //通过Java代码层面实现分页    List<User> userList=sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds",null,rowBounds);    for (User user:userList){        System.out.println(user);    }    sqlSession.close();}

3、分页插件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xb8LJ17d-1623407474352)(Mybatus-9.28.assets/7-3分页插件.PNG)]

了解即可，万一以后公司的架构师，说要使用，你需要知道它是什么东西！

8.使用注解开发（项目5）

1、面向接口编程

大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程

根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好

在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了；

而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。

接口的本身反映了系统设计人员对系统的抽象理解。

接口应有两类：

  1. 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）；
  2. 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；

一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别：

面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法。

面向过程是指，我们考虑问题是，以一个具体的流程（事务过程）为单位，考虑它的实现。

接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题。更多的体现就是对系统整体的框架。

2、使用注解开发

  1. 注解在接口上实现

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

  2. 需要在核心配置文件(mybatis-config.xml)中绑定接口！

    <!--绑定接口--><mappers>    <mapper class="com.kuang.dao.UserMapper"/></mappers>

  3. 测试

    @Test    public void test(){        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();    }

本质：反射机制实现

底层：动态代理！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tXEjdums-1623407474352)(Mybatus-9.28.assets/8-2使用注解开发.PNG)]

Mybatis的详细的执行流程！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HiZO7LCP-1623407474353)(Mybatus-9.28.assets/8-2使用注解开发-2.png)]

3、CRUD

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

public static SqlSession getSqlSession() {    return sqlSessionFactory.openSession(true);//加入true，以后就不需要手动提交事务了}

编写接口，增加注解

public interface UserMapper {    @Select("select * from user")    List<User> getUsers();    //方法存在多个参数，所有的参数前面必须加上 @Param("id")注解    @Select("select * from user where id = #{id}")    User getUserByID(@Param("id") int id);    @Insert("insert into user(id,name,pwd) values(#{id},#{name},#{password})")    int addUser(User user);    @Update("update user set name=#{name},pwd=#{password} where id=#{id}")    int upadteUser(User user);    @Delete("delete from user where id = #{uid}")    int deleteUser(@Param("uid") int id);}

测试类

@Testpublic void test(){    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();}@Testpublic void getUserByID(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    UserMapper mapper = sqlSession.getMapper(UserMapper.class);    User userByID = mapper.getUserByID(1);    System.out.println(userByID);    sqlSession.close();}@Testpublic void addUser(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    UserMapper mapper = sqlSession.getMapper(UserMapper.class);    mapper.addUser(new User(5,"乔帅","145623"));    sqlSession.close();}@Testpublic void upadteUser(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    UserMapper mapper = sqlSession.getMapper(UserMapper.class);    mapper.upadteUser(new User(5,"乔啊帅","784592"));    sqlSession.close();}@Testpublic void deleteUser(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    UserMapper mapper = sqlSession.getMapper(UserMapper.class);    mapper.deleteUser(5);    sqlSession.close();}

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

关于@param()注解

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

#{} ${}区别

#{}就起到了防止SQL注入的作用了(具体百度一下)

9.Lombok（项目4）

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.
  • java library
  • plugs
  • build tools
  • with one annotation your class

使用步骤：

  1. 在IDEA中安装Lombok插件！

  2. 在项目中导入lombok的jar包

    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --><dependency>    <groupId>org.projectlombok</groupId>    <artifactId>lombok</artifactId>    <version>1.18.12</version>    <scope>provided</scope></dependency>

  3. 在实体类上加注解即可！

    @Data@AllArgsConstructor@NoArgsConstructor 

    @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@Wither@With@SneakyThrows

    说明：

    @Data:无参构造、get、set、tostring、hashcode、equals@AllArgsConstructor 有参@NoArgsConstructor  无参@EqualsAndHashCode    生成EqualsAndHashCode方法@ToString 生成tostring方法@Getter  生成所有的getter方法

10.多对一处理（项目6）

多对一：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LLasbpFh-1623407474353)(Mybatus-9.28.assets/10多对一处理.PNG)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zszco3j2-1623407474353)(Mybatus-9.28.assets/10多对一处理-2.PNG)]

SQL：

CREATE TABLE `teacher`(`id` INT NOT NULL,`name` VARCHAR(30) DEFAULT NULL,PRIMARY KEY(`id`))ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO teacher(`id`,`name`)VALUES (1,'秦老师');CREATE TABLE `student`(`id` INT NOT NULL,`name` VARCHAR(30) DEFAULT NULL,`tid` INT DEFAULT NULL,PRIMARY KEY(`id`),KEY `fktid`(`tid`),CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`))ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO `student`(`id`,`name`,`tid`) VALUES(1,'小明',1);INSERT INTO `student`(`id`,`name`,`tid`) VALUES(2,'小红',1);INSERT INTO `student`(`id`,`name`,`tid`) VALUES(3,'小张',1);INSERT INTO `student`(`id`,`name`,`tid`) VALUES(4,'小李',1);INSERT INTO `student`(`id`,`name`,`tid`) VALUES(5,'小王',1);

测试环境搭建

  1. 导入lombok

  2. 新建实体类Teacher ，Student

  3. 建立Mapper接口

  4. 建立Mapper.XML文件

  5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多，随心选】

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

    1. 环境搭建

    实体类

    @Datapublic class Student {    private int id;    private String name;    //学生需要关联一个老师！    private Teacher teacher;}

    @Datapublic class Teacher {    private int id;    private String name;}

按照查询嵌套处理

<!--    思路：       1.查询所有的学生信息       2.根据查询出来的学生的tid，寻找对应的老师！ 子查询    --><select id="getStudent" resultMap="StudentTeacher">    select * from student;</select><resultMap id="StudentTeacher" type="Student">    <id property="id" column="id"/>    <id property="name" column="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>

按照结果嵌套处理【推荐使用】

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

测试

@Testpublic void testStudent(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);    List<Student> studentList = mapper.getStudent();    for (Student student : studentList) {        System.out.println(student);    }    sqlSession.close();}@Testpublic void testStudent2(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);    List<Student> studentList = mapper.getStudent2();    for (Student student : studentList) {        System.out.println(student);    }    sqlSession.close();}

回顾Mysql多对一查询方式：

  • 子查询
  • 联表查询

11.一对多处理（项目7）

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

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

环境搭建

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

实体类

@Datapublic class Student {    private int id;    private String name;    private int tid;}

@Datapublic class Teacher {    private int id;    private String name;    //一个老师拥有多个学生    private List<Student> students;}

按照查询嵌套处理

<!--==================按照查询嵌套处理=========================--><select id="getTeacher2" resultMap="TeacherStudent2">    select * from mybatis.teacher where id =#{tid};</select><resultMap id="TeacherStudent2" type="Teacher">    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/></resultMap><select id="getStudentByTeacherId" resultType="Student">    select * from mybatis.student where tid = #{id};</select>

按照结果嵌套处理【推荐使用】

<!--==================按照结果嵌套处理=========================--><select id="getTeacher1" resultMap="TeacherStudent">    select s.id sid,s.name sname,t.name tname,t.id tid    from student s,teacher t    where s.tid=t.id and t.id =#{tid};</select><resultMap id="TeacherStudent" type="Teacher">    <result property="id" column="tid"/>    <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>

测试

@Testpublic void getTeacher1(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);    Teacher teacher1 = mapper.getTeacher1(1);    System.out.println(teacher1);    sqlSession.close();}@Testpublic void getTeacher2(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);    Teacher teacher2 = mapper.getTeacher2(1);    System.out.println(teacher2);    sqlSession.close();}

小结

  1. 关联 - association 【多对一】

  2. 集合 - collection 【一对多】

  3. javaType & ofType

    1. javaType 用来指定实体类中属性的类型

    2. ofType 用来指定映射到List或者集合中的 pojo类型，泛型中的约束类型！

注意点：

  • 保证SQL的可读性，尽量保证通俗易懂

  • 注意一对多和多对一中，属性名和字段的问题！

  • 如果问题不好排查错误，可以使用日志，建议使用Log4j

慢SQL 1s 1000s

面试高频

  • Mysql引擎

  • InnoDB底层原理

  • 索引

  • 索引优化！

12、动态SQL（项目8）

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

利用动态 SQL，可以彻底摆脱这种痛苦。

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。ifchoose (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核心配置文件--><configuration>    <!--引入外部配置文件-->    <properties resource="db.properties"/>    <settings>        <!--标准的日志工厂实现-->        <setting name="logImpl" value="STDOUT_LOGGING"/>        <!--是否开启驼峰命名(camel case)自动映射-->        <setting name="mapUnderscoreToCamelCase" value="true"/>    </settings>    <!--可以给实体类起别名-->    <typeAliases>        <package name="com.kuang.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>        <mapper class="com.kuang.dao.BlogMapper"/>    </mappers></configuration>

    @SuppressWarnings("all")//抑制警告，原因IDutils中u没大写public class IDutils {    public static String getId(){        return UUID.randomUUID().toString().replaceAll("-","");    }    @Test    public void test(){        System.out.println(IDutils.getId());        System.out.println(IDutils.getId());        System.out.println(IDutils.getId());    }}

  3. 编写实体类

    @Datapublic class Blog {    private int id;    private String title;    private String author;    private Date createTime;    private int views;}

  4. 编写实体类对应 Mapper 接口和 Mapper.XML文件

    //插入数据int addBlog(Blog blog);

    <?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.kuang.dao.BlogMapper">    <insert id="addBlog" parameterType="blog">        insert into mybatis.blog(id, title, author, create_time, views) values(#{id}, #{title}, #{author}, #{createTime}, #{views})    </insert></mapper>

    测试

    @Testpublic void addBlogTest() {    SqlSession sqlSession = MybatisUtils.getSqlSession();    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);    Blog blog = new Blog();    blog.setId(IDutils.getId());    blog.setTitle("Mybatis如此简单");    blog.setAuthor("狂神说");    blog.setCreateTime(new Date());    blog.setViews(9999);    mapper.addBlog(blog);    blog.setId(IDutils.getId());    blog.setTitle("Java如此简单");    mapper.addBlog(blog);    blog.setId(IDutils.getId());    blog.setTitle("Spring如此简单");    mapper.addBlog(blog);    blog.setId(IDutils.getId());    blog.setTitle("微服务如此简单");    mapper.addBlog(blog);    sqlSession.close();}

IF

//查询博客    List<Blog> queryBlogIF(Map map);

<select id="queryBlogIF" parameterType="map" resultType="blog">    select * from mybatis.blog    <where>        <if test="title!=null">            title = #{title}        </if>        <if test="author!=null">            and author = #{author}        </if>    </where></select>

测试

@Testpublic void queryBlogIF(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);    HashMap map = new HashMap();    map.put("title","Mybatis如此简单");    map.put("author","狂神说");    List<Blog> bloglist = mapper.queryBlogIF(map);    for (Blog blog : bloglist) {        System.out.println(blog);    }    sqlSession.close();}

choose (when, otherwise)

List<Blog> queryBlogChoose(Map map);

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

测试

@Testpublic void queryBlogChoose(){    SqlSession sqlSession = MybatisUtils.getSqlSession();    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);    HashMap map = new HashMap();    //        map.put("title","Mybatis如此简单");    //        map.put("author","狂神说");    map.put("views",9999);    List<Blog> blogList = mapper.queryBlogChoose(map);    for (Blog blog : blogList) {        System.out.println(blog);    }    sqlSession.close();}

trim (where, set)

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

如果 where 元素与你期望的不太一样，你也可以通过自定义 trim 元素来定制 where 元素的功能。比如，和 where 元素等价的自定义 trim 元素为：

<trim prefix="WHERE" prefixOverrides="AND |OR ">  ...</trim>

这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

来看看与 set 元素等价的自定义 trim 元素吧：

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

<select id="queryBlogIF" parameterType="map" resultType="blog">    select * from mybatis.blog    <where>        <if test="title!=null">            title = #{title}        </if>        <if test="author!=null">            and author = #{author}        </if>    </where></select>

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

//更新博客    int updateBlog(Map map);

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

测试

 @Test    public void updateBlog(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);        HashMap map = new HashMap();        map.put("title","Mybatis如此简单2");        map.put("author","狂神说2");        map.put("id","02ce579467544cc9af3f0ca794caffcc");        mapper.updateBlog(map);        sqlSession.close();    }

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）

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

if

where , set , choose , when

SQL片段

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

where

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

    <sql id="id-title-author">    <if test="title!=null">        title = #{title}    </if>    <if test="author!=null">        and author = #{author}    </if></sql>

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

    <select id="queryBlogIF" parameterType="map" resultType="blog">    select * from mybatis.blog    <where>        <include refid="id-title-author"></include>    </where></select>

set

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

    <sql id="set-if-title-author">    <if test="title!=null">        title = #{title},    </if>    <if test="author!=null">        author = #{author}    </if></sql>

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

    <update id="updateBlog" parameterType="map">    update mybatis.blog    <set>        <include refid="set-if-title-author"></include>    </set>    where id = #{id}</update>

注意事项：

  • 最好基于单表来定义SQL片段！

  • 不要存在where标签

  • 不要存在set标签

Foreach

select * from user where 1=1 and <foreach item="id" index="index" collection="ids"      open="(" separator="or" close=")">        #{id}</foreach>(id=1 or id=2 or id=3)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nlpy3bAu-1623407474354)(Mybatus-9.28.assets/12Foreach.PNG)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Czifpbr7-1623407474354)(Mybatus-9.28.assets/12-Foreach.PNG)]

 //查询第1-2-3号记录的博客    List<Blog> queryBlogForeach(Map map);

<!--      select * from mybatis.blog where 1==1 (id=1 or id=2 or id=3)      我们现在传递一个万能的map，这map中也可以存在一个集合！      --><select id="queryBlogForeach" parameterType="map" resultType="blog">    select * from mybatis.blog    <where>        <foreach collection="ids" item="id" open="and (" close=")" separator="or">            id = #{id}        </foreach>    </where></select>

测试

@Test    public void queryBlogForeach(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);        HashMap map = new HashMap();        ArrayList<Integer> ids=new ArrayList<Integer>();        ids.add(1);        ids.add(2);        ids.add(3);        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、缓存（项目9）(了解)

1、简介

查询   ：   连接数据库  ， 耗资源！     一次查询的结果，给他暂存在一个可以直接取到的地方！ --> 内存   ： 缓存我们再次查询相同数据的时候，直接走缓存，就不用走数据库了
  1. 什么是缓存[Cache]？
    • 存在内存中的临时数据。
    • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
  2. 为什么使用缓存？
    • 减少和数据库的交互次数，减少系统开销，提高系统效率。
  3. 什么样的数据能使用缓存？
    • 经常查询并且不经常改变的数据。【可以使用缓存】

2、Mybatis缓存

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

3、一级缓存

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

测试步骤：

  1. 开启日志！

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

  3. 查看日志输出

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8yQCez92-1623407474355)(Mybatus-9.28.assets/13-3一级缓存.PNG)]

缓存失效的情况：

  1. 查询不同的东西

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CqCEVlvU-1623407474355)(Mybatus-9.28.assets/13-3一级缓存-2.PNG)]

  3. 查询不同的Mapper.xml

  4. 手动清理缓存！

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k5u6rJGy-1623407474356)(Mybatus-9.28.assets/13-3一级缓存-3.PNG)]

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

一级缓存就是一个Map。

4、二级缓存

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

步骤：

  1. 开启全局缓存

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

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

    <!--在当前Mapper.xml中使用二级缓存-->    <cache/>

    也可以自定义参数

        <cache            eviction="FIFO"            flushInterval="60000"            size="512"            readOnly="true"/>

  3. 测试

    1. 问题：我们需要将实体类序列化！否则就会报错！

      Caused by: java.io.NotSerializableException: com.kuang.pojo.User

      解决方法：(实体类上加 implements Serializable )

      public class User implements Serializable {}

      结果为false，默认为false，以下默认为true

      <cache       readOnly="true"/>

小结：

  • 只要开启了二级缓存，在同一个Mappr下就有效

  • 所有的数据都会先放在一级缓存中；

  • 只有当会话提交，或者关闭的时候，才会提交到二级缓冲中！

5、缓存原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QIBEufb3-1623407474356)(Mybatus-9.28.assets/13-5缓存原理.PNG)]

6、自定义缓存——ehcache

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

要在程序中使用encache，先要导包！

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache --><dependency>    <groupId>org.mybatis.caches</groupId>    <artifactId>mybatis-ehcache</artifactId>    <version>1.1.0</version></dependency>

在mapper中指定使用我们的ehcache缓存实现！

<!--在当前Mapper.xml中使用二级缓存--><cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

ehcache.xml

<?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">    <!--http://ehcache.org/ehcache.xsd复制的不生成，手打一遍即可用-->    <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>

Redis数据库来做缓存！ K-V

练习：29道练习题实战！

J寒
关注
专栏目录
MyBatis最经典的20道面试题，你都会了吗？
weixin_44976692的博客
01-18 2万+
MyBatis是一款优秀的持久层框架，在Java开发中广受欢迎。下面是一些常见的MyBatis面试题，以及相应的案例分析，希望对你的学习和面试有所帮助。MyBatis是一款基于Java的持久层框架，它通过XML描述符或注解将对象与存储过程或SQL语句进行映射，实现了面向对象编程与关系数据库的映射。动态SQL是MyBatis中的一项强大功能，它可以根据条件判断动态拼接SQL语句，避免硬编码。例如，动态SQL可以在条件成立时插入WHERE子句：
无法获取实体类com.xxx.pojo.xxx对应的表名!
weixin_44315733的博客
08-28 122
应该是上面那个包而不是下面那个，否则就会提示这个类映射不到对应的表。主要是粗心大意，@MapperScan导入的包不对。
mybatis中java.lang.ClassCastException: com.cra.pojo.User cannot be cast to java.lang.String怎么解决
weixin_61189391的博客
01-25 1282
mybatis中java.lang.ClassCastException: com.cra.pojo.User cannot be cast to java.lang.String出现这个问题的原因就是在mybatis你想单独查询用户的姓名，然后返回的数据就是字符串，例如下图。然后myabtis就报错无法将对应的那个实体类转化成string类，然后我通过把返回值类型改写成查询一个对应的对象就可以查询成功，返回成List也是可以的。
【MyBatus学习笔记】动态SQL
替这位空想家惊讶
02-20 172
动态SQL <where>标签会自动处理第一个<if>标签中的and： <select id="queryStudentBySQLTag" parameterType="student" resultType="student"> select * from student <where> ...
Mybatis增强版MyBatis-Flex介绍
沉淀、分享、成长，让自己和他人都能有所收获！
08-14 3万+
本文介绍了 Mybatis-Flex，一个用于增强 MyBatis 的框架。相对于 MyBatis-Plus，Mybatis-Flex提供了一些显著的特点，如支持联表查询以及在Mybatis-Plus中收费的功能在Mybatis-Flex中是免费的。文章概述了 MyBatis-Flex 的功能特点，并深入介绍了联表查询的不同方案。
MyBatis
weixin_45984258的博客
12-25 3534
MyBatisMyBatis快速入门Mapper代理开发MyBatis核心配置文件配置文件完成增删改查注解完成增删改查动态SQL MyBatis快速入门 MyBatis： Mybatis 是一款优秀的持久层框架，用于简化JDBC开发 JDBC的缺点： 1、硬编码： 注册驱动 SQL与君 2、操作繁琐 手动设置参数 手动封装结果集 MyBatis本是Apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到google code，并改名
Mybatis
一份耕耘，一分收获
02-28 1885
尚硅谷2022Mybatis学习笔记 附带项目源码和md笔记
mybatis中大于等于小于等于的写法
热门推荐
chenxingde的博客
03-04 30万+
标准写法如下：大于等于 = ]]> 小于等于 sql如下： create_date_time = ]]> #{startTime} and create_date_time #{endTime}
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
Mybatis 返回Map数据
菜鸟记录
03-30 3万+
⏹Mybatis 返回Map数据
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
idea插件MybatisX-1.6.1
02-23
MybatisX是一款针对IntelliJ IDEA的高效MyBatis开发插件，版本为1.6.1。这个插件旨在简化MyBatis框架在IDEA中的使用，提高开发效率，帮助开发者快速完成与MyBatis相关的各种任务。下面将详细介绍这款插件的主要功能...
MybatisGenerate_代码生成_tkMybatis_mybatisgenerate_mybatis_
10-03
MybatisGenerate是一个强大的工具，主要用于自动化生成Mybatis相关的代码，以提高开发效率并减少手动编写重复性工作的负担。这个工具是基于tk.mybatis框架的，它整合了Mybatis的优秀特性，使得开发者能够更加便捷地...
MyBatis-Flex： 一个优雅的 MyBatis 增强框架
08-04
MyBatis-Flex： 一个优雅的 MyBatis 增强框架。很轻量，MyBatis-Flex 整个框架只依赖 MyBatis，再无其他任何第三方依赖。只增强，MyBatis-Flex 支持 CRUD、分页查询、多表查询、批量操作，但不丢失 MyBatis 原有的...
mybatis中文离线文档
04-30
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的...
Vue.js与Flask/Django后端配合详细讲解
最新发布
yang_xs的博客（只讲干货）
09-19 754
Vue.js 与 Flask 或 Django 的结合可以形成一个强大的前后端分离架构，适合构建现代 web 应用。以下是详细讲解如何将 Vue.js 与 Flask/Django 后端配合使用。
解决ruoyi-vue-pro-master框架引入报错，启动报错问题
xnian_的博客
09-13 486
以yudao-ui-admin-vue3-master为例，第一次先安装node_modules执行npm -i,然后npm run dev启动项目。如：后端接口：localhost:48080/admin-api/product/brand/page。3.后台启动后，模块启用yudao-server下的pom.xml文件将需要的模块注释去掉。1.以yudao-module-mall模块为例，maven报错情况。2.yudao下面的pom.xml 下引入的modules放开。
Vue3：el-table实现日期的格式化
weixin_73060959的博客
09-13 299
后端如果返回的是时间戳，需要我们进行日期格式化例如：2024-09-11T14:19:14 在表格中进行使用该工具完成日期解析
ngxin
卑微的码蚁
09-19 305
nginx是一个 轻量级/高性能的反向代理Web服务器，他实现非常高效的反向代理、负载平衡。正向代理：在客户端部署的一个代理服务器，类似于vpn反向代理：在服务器端部署的一个代理服务器。nginx反向代理优点：占内存小，可实现高并发连接，处理响应快可实现http服务器、虚拟主机、方向代理、负载均衡nginx配置简单可以不暴露正式的服务器IP地址。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值