Mybatis

最新推荐文章于 2024-11-03 11:01:20 发布

thebss

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量59

点赞数

文章标签： java

本文链接：https://blog.csdn.net/thebss/article/details/123841709

版权

1.简介

MyBatis 是一款优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
2013年11月迁移到Github

导入jar包

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>

持久化

将程序数据在持久状态和瞬时状态间转换的机制
内存：断电即失
数据库JDBC、io文件持久化

为什么需要持久化：

内存太贵了
有一些对象不能丢掉

持久层

Dao、Service、Controller层……

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

为什么需要Mybatis

帮助程序员将数据存入数据库
方便
传统的JDBC太复杂，简化。框架。自动化。

优点：

简单易学、灵活
sql和代码的分离，提高了可维护性。
提供映射标签，支持对象与数据库的orm字段关系映射。
提供对象关系映射标签，支持对象关系组建维护。
提供xml标签，支持编写动态sql。

2.第一个项目

①导入mybatis、mysql的jar包，连接数据库
②创建工具类，发现需要配置文件

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    //从 XML 中构建 SqlSessionFactory
     static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //获取SqlSession连接
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }
}

③配置mybatis-config文件

<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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
<!--每一个mapper.xml都需要在Mybatis核心配置文件注册！-->
    <mappers>
        <mapper resource="com/thebs/dao/UserMapper.xml"/>
    </mappers>
</configuration>

④创建实体类pojo，创建接口dao，编写Mapper.xml代替原来的接口实现类

<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.thebs.dao.UserDao">
    <!--id绑定方法 返回值类型专注于方法返回值-->
    <select id="selectUser" resultType="com.thebs.pojo.User">
        select * from user
    </select>
</mapper>

⑤测试

@Test
    public void test(){
        //获得SqlSession对象，包含了面向数据库执行sql命令的所有方法
        SqlSession session = MybatisUtils.getSession();
        //方法一：过时
        //List<User> users = session.selectList("com.thebs.dao.UserMapper.selectUser");
       //面向接口编程!,获得接口
        UserDao mapper = session.getMapper(UserDao.class);
        List<User> users = mapper.selectUser();
        for (User u:users){
            System.out.println(u);
        }
        session.close();
    }

注意点：

namespace命名空间要写绑定接口的全命名
配置文件要注册
方法名，返回类型要写对
Maven导出资源问题

3. 增删改查

对象传递参数

①编写接口

	//根据id查询
    User getUserId(int id);
    //增加一个用户
    int addUser(User user);
    //修改一个用户
    int updateUser(User user);
    //删除用户
    int deleteUser(int id);

②编写对应的mapper中的sql语句

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

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

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

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

③测试
增删改需要提交事务

    @Test
    public void adduser(){
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        mapper.addUser(new User(4,"zhuzhu","123456"));
        session.commit();
        session.close();
        }

使用万能Map

①编写接口
int addUser1(Map<String,Object> map);
②编写对应的mapper中的sql语句

<!--传递map的key-->
<insert id="addUser1" parameterType="Map" >
   insert into mybatis.user (id, name, pwd) values (#{id},#{name},#{password})
</insert>

③测试

HashMap<String, Object> map = new HashMap<>();
map.put("id",6);
map.put("password","123456");
mapper.addUser1(map);

总结：

Map传递参数，在sql中取出key的值parameterType="Map"
对象传递参数，在sql中取出对象的属性parameterType="Object"
只有一个基本数据类型属性，parameterType可以省略
多个参数时用Map，或者注解

模糊查询

①在Java代码中添加sql通配符。
List<User> user = mapper.getUserLike("%李%");
②在sql语句中拼接通配符
select * from user where name like "%"#{value}"%";

4.核心配置

学会配置多套运行环境
Mybatis默认的事务管理器是JDBC，连接池：POOLED

Properties优化

①新建一个db.properties，将核心配置文件中的属性写入

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&;useUnicode=true&;characterEncoding=utf8
username=root
password=root

②在核心配置文件首位导入
<properties resource="db.properties"/>
并修改属性赋值为形如value="${url}"

别名优化

①方式一

<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

②方式二:diy别名需要在实体类上添加注解@Alias("")

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

Java 类型内建的类型别名:
①基本数据类型：_int
②包装类、String、集合：小写integer

设置（settings）

懒加载
日志实现 logImpl
缓存开启关闭 cacheEnable

Mapper

映射器 : 定义映射SQL语句文件

引入资源方式:
①使用相对于类路径的资源引用

<mappers>
   <mapper resource="com/thebs/dao/UserMapper.xml"/>
</mappers>

② 使用映射器接口实现类的完全限定类名

<mapper class="com.thebs.dao.UserMapper"/>

③将包内的映射器接口实现全部注册为映射器

<package name="com.thebs.dao"/>

②③都需要配置文件名称和接口名称一致，并且位于同一目录下

生命周期&作用域

SqlSessionFactoryBuilder:创建了SqlSessionFactory就不再需要了，局部变量
SqlSessionFactory：可以想象为数据库连接池。一旦被创建应在运行期间一直存在，默认是单例模式，最佳作用域是应用作用域
SqlSession：通过SqlSessionFactory创建，线程不安全，使用后的关闭操作很重要
在这里插入图片描述
每一个Mapper，代表一个具体的业务

5.ResultMap

当实体类属性名和数据库字段名不一致
①方法一：
select id , name , pwd as password from user where id = #{id}
②方法二：结果集映射

    <resultMap id="UserMap" type="User">
        <result column="pwd" property="password"/>
    </resultMap>
    <select id="getUserId" resultMap="UserMap" >
        select * from mybatis.user where id=#{id}
    </select>

resultMap 元素是 MyBatis 中最重要最强大的元素。
ResultMap 的设计思想：对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

日志

曾经：sout、debug
现在：日志工厂

在mybatis中在设置中实现

SLF4J
Log4J
Log4J2
STDOUT_LOGGING
Commons Logging
JDK logging

LOG4J

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

①导入log4j的包

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

②配置log4j.properties文件
③setting设置日志实现

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

简单使用
①在要使用Log4j的类中导入import org.apache.log4j.Logger;
②日志对象，参数为当前类的class

6.分页

使用Limit实现分页:SQL层面

语法:
SELECT * FROM table LIMIT startIndex，pageSize
SELECT * FROM table LIMIT 5; // LIMIT n 等价于 LIMIT 0,n。

①Mapper接口
List<User> selectUser(Map<String,Integer> map);
②修改Mapper文件

<select id="selectUser" parameterType="map" resultType="user">
    select * from user limit #{startIndex},#{pageSize}
</select>

③测试

 Map<String,Integer> map = new HashMap<String,Integer>();
    map.put("startIndex",0);
    map.put("pageSize",2);
    List<User> users = mapper.selectUser(map);

RowBounds分页：Java层面

PageHelper

了解即可，可以自己尝试使用

官方文档：https://pagehelper.github.io/

7.注解开发

利用注解开发就不需要mapper.xml映射文件了 .
①在我们的接口中添加注解

 @Select("select id,name,pwd password from user")
    List<User> getAllUser();

②在mybatis的核心配置文件中注入

<mappers>
    <mapper class="com.kuang.mapper.UserMapper"/>
</mappers>

③测试

本质：反射机制实现
底层：动态代理

Mybatis详细的执行流程

①Resources获取全局配置文件
②实例化SqlSessionFactoryBuilder构造器
③由XMLConfigBuilder解析配置文件流
④把配置信息存放到Configuration中
⑤实例化SqlSessionFactory
⑥transaction事务管理
⑦创建excutor执行器
⑧创建sqlSession

Tips：多看源码底层实现
自动提交事务：

public static SqlSession getSession(boolean flag){
       return sqlSessionFactory.openSession(flag);
   }

注解实现增删改查

@Insert("insert into user (id,name,pwd) values (#{id},#{name},#{pwd})")

@Delete("delete from user where id = #{id}")
int deleteUser(@Param("id")int id);

@Update("update user set name=#{name},pwd=#{pwd} where id = #{id}")

@Select("select * from user where id = #{id}")

关于@Param()注解：

基本数据类型或String类型，需要加上
引用类型不用加
只有一个基本数据类型时可以忽略
在SQL中引用的就是@Param("uid")中设定的属性名

lombok

①导入jar包
②在代码中增加注解
@Data ：GET,SET,ToString，有参，无参构造
@AllArgsConstructor
@NoArgsConstructor

8.多对一的处理

理解：多个学生对应一个老师
①子查询

<select id="getStudent" resultMap="ST">
    select * from student
</select>
<resultMap id="ST" type="Student">
        <!--复杂的属性，需要单独处理。 对象：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="ST2">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t where s.tid=t.id;
</select>
<resultMap id="ST2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

9.一对多的处理

一个老师拥有多个学生

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

①联表查询

<select id="getTeacher" resultMap="T">
    select t.id tid,t.name tname,s.id sid,s.name sname
    from teacher t,student s where s.tid=t.id and t.id=#{tid};
</select>
<resultMap id="T" type="Teacher">
    <result column="tid" property="id"/>
    <result column="tname" property="name"/>
    <collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
    </collection>
</resultMap>

②子查询

   <select id="getTeacher2" resultMap="T2">
        select * from teacher where id=#{tid};
    </select>
    <resultMap id="T2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getS" column="id"/>
    </resultMap>
    <select id="getS" resultType="Student">
        select * from student where tid=#{tid}
    </select>

总结：

association是用于一对一和多对一，而collection是用于一对多的关系
javaType：是用来指定属性类型
ofType：指定的是泛型的具体类型

10.动态SQL

根据不同的查询条件 , 生成不同的Sql语句.

动态SQL本质就是拼接SQL语句，为了保证拼接准确，按照SQL的格式，去排列组合就可以了

下划线驼峰自动转换

<setting name="mapUnderscoreToCamelCase" value="true"/>

if 语句

①编写接口类

List<Blog> queryBlogIf(Map map);

②编写SQL语句

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

这会产生一个问题，当第一个条件语句判断为空时，第二个拼接的and会导致程序报错

where 语句

在上面的基础上进行改进，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。

<where>
<if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</where>

set标签

注意set是用的,隔开

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

choose标签

查询条件有一个满足即可，自动break

<where>
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                author = #{author}
            </when>
            <otherwise>
                views = #{views}
            </otherwise>
        </choose>
    </where>

SQL片段

为了增加代码的重用性，简化代码

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

需要引用的地方

<include refid="if-title-author"></include>

Foreach

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

11.Mybatis缓存

MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存

默认情况下，自动开启一级缓存。（SqlSession级别的缓存，也称为本地缓存）
二级缓存：也叫全局缓存。需要手动开启和配置，他是基于namespace级别的缓存。

一级缓存

缓存失效的情况：

①查询不同的东西
②增删改操作，可能会改变原有操作，必定会刷新缓存
③手动清理缓存
session.clearCache();
④每个sqlSession中的缓存相互独立

二级缓存

①在配置文件中开启全局缓存

<setting name="cacheEnabled" value="true"/>

②在要使用二级缓存的Mapper.xml中开启，可以自定义参数
<cache/>
③测试。测试前所有的实体类先实现序列化接口

小结

只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
查出的数据都会被默认先放在一级缓存中
只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中

自定义缓存EhCache

①在配置文件引入依赖的jar包

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>

②在mapper.xml引用,可以自定义继承于Cache类的缓存类

<cache type = “org.mybatis.caches.ehcache.EhcacheCache” />

③编写ehcache.xml文件，如果在加载时未找到/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">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <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"/>
    <!--
       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，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
</ehcache>