Mybatis学习

Mybatis学习

环境

  • JDK1.8
  • Mysql 5.7
  • maven 3.6.1
  • IDEA

回顾

  • JDBC
  • Mysql
  • Java基础    
  • Junit

SSM框架:学习配置文件的,最好的方式:看官网文档


 

1、简介


1.1、什么是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?

  • maven仓库
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>

1.2、持久化

数据持久化

  • 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
  • 内存:断电即失
  • 数据库(Jdbc),io文件持久化
  • 生活中:冷藏,罐头

为什么需要持久化?

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

1.3、持久层

我们学过的层有:Dao层,Service层,Controller层

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

1.4、为什么需要Mybatis?

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

最重要的一点:使用的人多

比如后期学习的Spring、SpringMVC、 SpringBoot

 

2、第一个Mybatis程序


思路:搭建环境-->导入Mybatis-->编写代码-->测试!

2.1、搭建环境

搭建数据库

create database `mybatis`;

use `mybatis`;

create table `user`(
    `id` int(10) not null,
    `name` varchar(30) not null,
    `pwd` varchar(20) not null,
    primary key(`id`)
)engine = innodb default charSet = utf8;

insert into `user`(`id`,`name`,`pwd`)
values
(1,'张三','123456'),
(2,'李四','123456'),
(3,'王五','123456');

新建项目

  1. 新建一个普通的Maven项目
  2. 删除src目录
  3. 导入maven依赖
    <!--导入依赖-->
    <dependencies>
        <!--Mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.24</version>
        </dependency>
        
        <!--Mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

    </dependencies>

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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

</configuration>
  • 编写Mybatis工具类
//SqlSessionFactory --> sqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //既然有了 SqlSessionFactory,顾名思义,我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    public static  SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3、编写代码

  • 实体类
package com.lt.pojo;

//实体类
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配置文件
<?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">
<mapper namespace="com.lt.dao.UserDao">
    <!--select查询语句-->
    <select id="getUserList" resultType="com.lt.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

2.4、测试

  • junit测试

1.org.apache.ibatis.binding.BindingException: Type interface com.lt.dao.UserDao is not known to the MapperRegistry.

没有绑定mapper

    <!--每一个Mapper.xml,都需要在Myvatis核心配置文件中进行绑定-->
    <mappers>
        <mapper resource="com/lt/dao/UserMapper.xml"/>
    </mappers>

2.org.apache.ibatis.exceptions.PersistenceException: ### Error building SqlSession. xml

去掉配置文件中的中文注释,或者将 encoding = UTF8;不是UTF-8

3.资源导出问题

加一个build配置即可

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

3、CRUD


1、namespace

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

2、select

选择,查询语句

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

1.编写接口

    List<User> getUserList();

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

    <select id="getUserList" resultType="com.lt.pojo.User">
        select * from mybatis.user
    </select>

3.测试

   public void test(){
       //第一步:获取SqlSession对象
       SqlSession sqlSession = MybatisUtils.getSqlSession();

       //方法一:getMapper
       UserMapper userDao = sqlSession.getMapper(UserMapper.class);
       List<User> userList = userDao.getUserList();

       for(User user : userList){
           System.out.println(user);
       }

       //关闭SqlSession
       sqlSession.close();
   }

3、insert

    <insert id="addUser" parameterType="com.lt.pojo.User">
        insert into mybatis.user(id,name,pwd)values (#{id},#{name},#{pwd})
    </insert>

4、delete

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

5、update

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

注意点:增删改需要提交事务

6、万能的Map

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

    int addUser2(Map<String,Object> map);
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user(id,name,pwd) values(#{userId},#{userName},#{userPwd})
    </insert>
    public void addUser2(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       HashMap<String, Object> map = new HashMap<String, Object>();
       map.put("userId",4);
       map.put("userName","王五");
       map.put("userPwd","123456");
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       mapper.addUser2(map);
       //提交事务
       sqlSession.commit();
       sqlSession.close();
   }

Map传递参数,直接在sql中取出key即可!【parameterType="map"】

对象传递参数,直接在sql中取出对象的属性即可!【parameterType="Object"】

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

多个参数用Map,或者注解!

7、思考题

模糊查询怎么写?

  • Java代码执行的时候,传递通配符
List<User> userList = mapper.getUserLike("%李%");
  • 在sql拼接中使用通配符!
<select id="getUserLike" parameterType="string" resultType="com.lt.pojo.User">
        select * from mybatis.user where name like "%"#{value}"%"
</select>

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】

编写一个配置文件 db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
name=root
password=123456

在核心配置文件中引入

    <!--引入一个外部配置文件-->
    <properties resource="db.properties">
        <property name="name" value="root"/>
        <property name="password" value="123456"/>
    </properties>
  • 可以直接引入外部配置文件
  • 可以在其中增加一些属性配置
  • 如果俩个文件中有同一个字段,优先使用外部配置配置文件的!

4、类型别名(typeAliases)

  • 类型别名可为 Java 类型设置一个缩写名字。
  • 它仅用于 XML 配置,意在降低冗余的全限定类名书写。
    <!--可以给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.lt.pojo.User" alias="User"></typeAlias>
    </typeAliases>

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

每一个在包 domain.blog 中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author

    <typeAliases>
        <package name="com.lt.pojo"/>
    </typeAliases>

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

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

第一种可以DIY别名,第二种则不行,只是类名小写(首字母也可以大写)如果非要改,需要在实体上增加注解

@Alias("author")
public class Author {
    ...
}

5、设置(settings)

重要的设置

6、其他配置

7、映射器(mappers)

我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面,Java 并没有提供一个很好的解决方案,所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。

方式一: 

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

方式二: 

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

方式三: 

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

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

注意点:使用第二种和第三种方式:

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

8、作用域(Scope)和生命周期

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

SqlSessionFactoryBuilder

  • 一旦创建了 SqlSessionFactory,就不再需要它了。
  • 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域(也就是局部方法变量)

SqlSessionFactory

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

SqlSession

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

这里的每一个Mapper,就代表一个具体的业务!

 

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


数据库中的字段

 

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

测试出现问题

解决方法

  • 起别名
    <select id="getUserById" parameterType="int" resultType="user">
        select id,name,pwd as password from mybatis.user where id = #{id}
    </select>
  • 结果集映射 resultMap
    <!--结果集映射-->
    <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" parameterType="int" resultMap="userMap">
        select * from mybatis.user where id = #{id}
    </select>
  • resultMap 元素是 MyBatis 中最重要最强大的元素。
  • ResultMap 的设计思想是,对简单的语句做到零配置,对于复杂一点的语句,只需要描述语句之间的关系就行了。
  • 没有一个需要显式配置 ResultMap,这就是 ResultMap 的优秀之处——你完全可以不用显式地配置它们。
  • 如果这个世界总是这么简单就好了。

 

 

6、日志


6.1 日志工厂

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

曾经:sout、debug

现在:日志工厂

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

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

STDOUT_LOGGING 标准日志输出

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

 

6.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.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/lt.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>
        <!--log4j的日志工厂实现-->
        <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:进入了log4jTest方法");
        logger.debug("debug:进入了log4jTest方法");
        logger.error("error:进入了log4jTest方法");

7、分页


思考:为什么要分页?

  • 减少数据的处理量

 

7.1、使用Limit分页

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

使用Mybatis实现分页,核心SQL

  • 接口
    //分页查询用户
    List<User> getUsersByLimit(Map map);
  • Mapper.xml
    <resultMap id="userMap" type="user">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>

    <select id="getUserById" parameterType="int" resultMap="userMap">
        select * from mybatis.user where id = #{id}
    </select>

    <!--分页查询用户-->
    <select id="getUsersByLimit" parameterType="map" resultMap="userMap">
        select * from mybatis.user limit #{startIndex},#{pageSize}
    </select>
  • 测试
    //分页查询用户
    @Test
    public void getUsersByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Integer> map = new HashMap<>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> userList = mapper.getUsersByLimit(map);
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭资源
        sqlSession.close();
    }

7.2、使用RowBounds实现分页

不在使用SQL实现分页

  • 接口
    //分页查询用户2
    List<User> getUserByRowBounds();
  • mapper.xml
    <!--rowBounds实现分页查询-->
    <select id="getUserByRowBounds" resultMap="userMap">
        select * from mybatis.user
    </select>
  • 测试
    public void getUserByRowBounds(){
        RowBounds rowBounds = new RowBounds(0, 2);
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        List<User> userList = sqlSession.selectList("com.lt.dao.UserMapper.getUserByRowBounds", null, rowBounds);
        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }

7.3、分页插件

8、使用注解开发


8.1、面向接口编程

在真正的开发中,很多时候我们会选择面向接口编程

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

  • 在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;
  • 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

 

关于接口的理解

  • 接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。

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

  • 接口应有两类:

  1. 第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);

  2. 第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface);

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

三个面向的区别:

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

面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现

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

8.2、使用注解开发

  • 注解在接口上实现
    //使用注解获取用户列表
    @Select("select * from mybatis.user")
    List<User> getUsers();
  • 需要在核心配置文件中绑定接口
    <!--绑定接口-->
    <mappers>
        <mapper class="com.lt.dao.UserMapper"></mapper>
    </mappers>
  • 测试
    //测试:使用直接获取用户列表
    @Test
    public void getUsers(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUsers();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭资源
        sqlSession.close();
    }

直接本质:反射机制实现

底层:动态代理模式!

 

 

 

Mybatis详细的执行流程!

 

使用注解进行CRUD

  • 接口
    //使用注解通过用户ID获取用户信息
    @Select("select * from mybatis.user where id = #{id}")
    User getUserById(@Param("id") int id);

    //使用注解增加用户
    @Insert("insert into mybatis.user(`id`,`name`,`pwd`)values (#{id},#{name},#{password})")
    int insertUser(Map<String,Object> map);

    //使用注解删除用户
    @Delete("delete from mybatis.user where id = #{id}")
    int deleteUserById(@Param("id") int id);

    //使用注解更新用户信息
    @Update("update mybatis.user set name = #{name},pwd = #{password} where id = #{id}")
    int updateUser(Map<String,Object> map);
  • 绑定接口
    <!--绑定接口-->
    <mappers>
        <mapper class="com.lt.dao.UserMapper"></mapper>
    </mappers>

 

  • 测试
    //测试:使用注解通过用户ID获取用户
    @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();
    }

    //测试:使用注解插入新用户
    @Test
    public void insertUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",8);
        map.put("name","王照奎");
        map.put("password","123456");
        int i = mapper.insertUser(map);
        if(i>0){
            System.out.println("插入用户成功!");
        }

        sqlSession.close();
    }

    //测试:使用注解删除用户
    @Test
    public void deleteUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteUserById(8);

        if(i>0){
            System.out.println("删除成功!");
        }

        //关闭资源
        sqlSession.close();
    }

    //测试:使用注解更新用户
    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","叶周乐");
        map.put("password","123456");
        map.put("id",6);
        int i = mapper.updateUser(map);
        if(i>0){
            System.out.println("更新成功!");
        }
        //关闭资源
        sqlSession.close();
    }

9、Lombok


  • 导入依赖
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>

10、多对一处理


多对一:

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

创建的对应的数据库如下

USE mybatis

CREATE TABLE `teacher`(
    `id` INT(10) NOT NULL,
    `name` VARCHAR(30) DEFAULT NULL,
    PRIMARY KEY(`id`)

)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO mybatis.`teacher`(`id`,`name`) VALUES(1,"李老师");
SELECT * FROM `teacher`;

CREATE TABLE `student`(
    `id` INT(10) NOT NULL,
    `name` VARCHAR(30) DEFAULT NULL,
    `tid` INT(10) DEFAULT NULL,
    PRIMARY KEY(`id`),
    KEY `fktid`(`tid`),
    CONSTRAINT `fktid` FOREIGN KEY(`tid`) REFERENCES `teacher` (`id`)

)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO mybatis.`student`(`id`,`name`,`tid`) VALUES (1,"张三",1);
INSERT INTO mybatis.`student`(`id`,`name`,`tid`) VALUES (2,"李四",1);
INSERT INTO mybatis.`student`(`id`,`name`,`tid`) VALUES (3,"王五",1);
INSERT INTO mybatis.`student`(`id`,`name`,`tid`) VALUES (4,"赵六",1);
INSERT INTO mybatis.`student`(`id`,`name`,`tid`) VALUES (5,"周七",1);
INSERT INTO mybatis.`student`(`id`,`name`,`tid`) VALUES (6,"王八",1);

10.1、测试环境搭建

  1. 导入lombok
  2. 新建实体类Teacher,Student
  3. 建立Mapper接口
  4. 建立Mapper.xml文件
  5. 在核心配置文件中绑定我们的Mapper接口或者文件!
  6. 测试查询是否成功

10.1、按照查询嵌套处理(重点)


    <!--
    思路:
        1.查询所有的学生信息
        2.根据查询出来的学生的tid,寻找对应的老师!子查询
    -->  
  <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    </select>

    <resultMap id="StudentTeacher" type="student">
        <result property="id" column="id"></result>
        <result property="name" column="name"></result>
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"></association>
    </resultMap>

    <select id="getTeacher" resultType="teacher">
        select * from teacher where id = #{id}
    </select>

10.2、按照结果嵌套查询(重点)

<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>
        <result property="name" column="name"></result>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"></result>
        </association>
    </resultMap>

回顾Mysql多对一查询方式:

  • 子查询
  • 联表查询

 

11、一对多处理


比如:一个老师拥有多个学生!

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

 

11.1、环境搭建

实体类

public class Student {
    private int id;
    private String name;
    private int tid;
}
public class Teacher {
    private int id;
    private String name;
    //一个老师,对应很多学生
    List<Student> students;
}

 11.2、按照结果嵌套处理

    <!--按结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
        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 = 1;
    </select>
    <resultMap id="TeacherStudent" type="teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"></result>
        <!-- 复杂的属性,我们需要单独处理,对象:association  集合:collection
        javaType = "" 指定属性的类型!
        集合中的泛型信息,我们使用ofType获得!
        -->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"></result>
            <result property="name" column="sname"></result>
            <result property="name" column="sname"></result>
        </collection>
    </resultMap>

11.3、按照查询嵌套处理

    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from teacher where id = #{id}
    </select>
    <resultMap id="TeacherStudent2" type="teacher">
        <collection property="students" javaType="ArrayList" ofType="student" column="id" select="getStudent2"></collection>
    </resultMap>
    <select id="getStudent2" resultType="student">
        select * from student where tid = #{id}
    </select>

11.4、小结

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

注意点:

  • 保证SQL的可读性,尽量保证通俗易懂
  • 注意一对多和多对一中,属性名和字段的问题!
  • 如果问题不好排查,可以使用日志,建议使用Log4j

慢SQL  1s    1000s

 

面试高频

  • Mysql引擎
  • innoDB底层原理
  • 索引
  • 索引优化

 

12、动态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
DESC blog

12.1、 搭建环境

  • 导包
  • 编写配置文件
  • 编写实体类
@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;//属性名和字段名不一致
    private int views;
}
  • 编写实体类对应的Mapper接口和Mapper.xml文件

12.2、if

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

 

12.3、trim (where, set)

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

 

12.4、choose (when, otherwise)

    <select id="queryBlogChoose" resultType="blog" parameterType="map">
        select * from mybatis.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>

 

12.5、foreach

    <!--Foreach:
    select * from mybatis.blog where 1=1 and (id = 1 or id = 2 or id = 3)
    -->
    <select id="queryBlogForeach" parameterType="map" resultType="blog">
        select * from mybatis.blog
        <where>
            <foreach collection="ids" item="id" open="and (" separator="or" close=")">
                id = #{id}
            </foreach>
        </where>
    </select>
    //测试foreach
    @Test
    public void queryBlogForeachTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        List ids = new ArrayList();
        ids.add(1);
        ids.add(2);
        ids.add(3);
        map.put("ids",ids);
        List<Blog> blogList = mapper.queryBlogForeach(map);

        for (Blog blog : blogList) {
            System.out.println(blog);
        }

        sqlSession.close();
    }

12.6、24道练习题(实战开发)

 

13、缓存


13.1、简介

1.什么是缓存【Cache】?

  • 存在内存中的零时数据。
  • 将用户经常查询的数据放在缓存(内存)中,用户去查数据就不会从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。

2.为什么使用缓存?

  • 减少和数据库的交互次数,减少系统开销,提高系统效率。

3.什么样的数据能使用缓存?

  • 经常查询并且不经常改变的数据。

13.2、Mybatis缓存

1.MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。

2.MyBatis系统中默认定义了俩级缓存:一级缓存二级缓存

  • 默认情况下,只有一级缓存开启,(SqlSession级别的缓存,也称本地缓存)
  • 二级缓存需要手动开启配置,他是基于namespace级别的缓存
  • 为了提高扩展性,Mybatis定义了接口Cache。我们可以通过实现Cache接口来自定义二级缓存。

13.3、一级缓存

    @Test
    public void queryUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.queryUserById(1);
        System.out.println(user);

        //mapper.updateUserById(new User(1,"狂神","1234567"));
        //System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        User user2 = mapper.queryUserById(1);
        System.out.println(user2);
        System.out.println(user == user2);
        sqlSession.close();
    }

缓存失效的情况:

  • 查询不同的东西
  • 增删改操作,可能会改变原来的数据,所以必定会刷新缓存!

  • 查询不同的Mapper.xml
  • 手动清理缓存
 sqlSession.clearCache();

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

一级缓存就是一个Map。

 

13.4、二级缓存

1.二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存

2.基于namespace级别的缓存,一个名称空间,对应一个二级缓存

3.工作机制

  • 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中;
  • 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存在二级缓存中;
  • 新的会话查询信息,就可以从二级缓存中获取内容;
  • 不同的mapper查处的数据会放在自己对应缓存(map)中

4.步骤

  • 显示的开启全局缓存
        <!--显示的开启全局缓存-->
        <setting name="cacheEnabled" value="true"/>
  • 开启二级缓存
    <!--开启二级缓存-->
    <cache />
  • 也可以自定义二级缓存的配置
<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>
  • 测试
    @Test
    public void queryUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        SqlSession sqlSession2 = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryUserById(1);
        System.out.println(user);
        sqlSession.close();

        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
        User user2 = mapper2.queryUserById(1);
        System.out.println(user2);
        System.out.println(user == user2);
        sqlSession2.close();
    }

 

注意:在二级缓存配置中,若不使用配置(如FIFO),实体类没有序列化的话,会报如下错误

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

小结:

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

 

13.5、缓存原理

 

13.6、自定义缓存-ehcache

1.导包

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

2.改变cache的种类

    <!--开启二级缓存-->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

3.配置文件

<?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:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
     user.home – 用户主目录 user.dir – 用户当前工作目录 java.io.tmpdir – 默认临时文件路径 -->
    <diskStore path="java.io.tmpdir/Tmp_EhCache"/>
    <!-- defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。 -->
    <!-- name:缓存名称。 maxElementsInMemory:缓存最大数目 maxElementsOnDisk:硬盘最大缓存个数。
    eternal:对象是否永久有效,一但设置了,timeout将不起作用。 overflowToDisk:是否保存到磁盘,当系统宕机时
    timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。
    仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
    timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。
    最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
    diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine.
    The default value is false.
    diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
    diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
    memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。
    默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
    clearOnFlush:内存数量最大时是否清除。
    memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。
    FIFO,first in first out,这个是大家最熟的,先进先出。
    LFU, Less Frequently Used,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。
    如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
    LRU,Least Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,
    而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。 -->
    <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>

自定义缓存,实现接口Cache

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MyBatis是一个开源的持久层框架,它可以帮助开发人员简化数据库操作。如果你想学习MyBatis,下面是一个学习路线的建议: 1. 数据库基础:在学习MyBatis之前,建议先掌握数据库的基本概念和SQL语言。了解关系型数据库的原理、表设计和常用的SQL语句会对学习MyBatis有很大帮助。 2. MyBatis入门:开始学习MyBatis之前,可以先了解一下MyBatis的基本概念和核心特性。阅读官方文档或者参考一些入门教程可以帮助你快速上手。 3. 配置文件:学习如何配置MyBatis的核心配置文件,包括数据源、映射文件、类型处理器等。了解不同配置项的作用和常用配置方式。 4. 映射文件:深入学习MyBatis的映射文件,了解如何使用SQL语句进行数据库操作,并学习动态SQL的使用技巧。掌握映射文件中各种标签的含义和用法。 5. 注解方式:学习使用注解方式来配置和使用MyBatis。了解常用的注解和使用方式,与映射文件相比,注解方式更加简洁和灵活。 6. 缓存机制:了解MyBatis的缓存机制,包括一级缓存和二级缓存的原理和使用方式。了解如何配置和优化缓存,提高系统的性能。 7. 整合框架:学习如何将MyBatis与其他框架进行整合,如Spring和Spring Boot。掌握整合的配置方式和常见问题的解决方法。 8. 实践项目:通过实践项目来巩固所学的知识,可以自己动手搭建一个简单的Web应用或者实现一些常见的数据库操作。在实践中不断提升自己的技能。 以上是一个大致的学习路线,你可以根据自己的实际情况和学习进度进行调整。希望对你有帮助!

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值