MyBatis框架整理

最新推荐文章于 2023-12-29 14:16:14 发布

偷偷写博客

最新推荐文章于 2023-12-29 14:16:14 发布

阅读量315

点赞数

分类专栏： MyBatis 文章标签： java maven

本文链接：https://blog.csdn.net/Start1234567/article/details/107348118

版权

MyBatis 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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。

1.2、如何获得MyBatis

maven仓库：

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

GitHub：https://github.com/mybatis/mybatis-3/releases
中文文档： https://mybatis.org/mybatis-3/zh/index.html

1.3、MyBatis优点

sql和代码分离，提高了可维护性
提供映射标签，支持对象与数据库的ORM字段关系映射
提供XML标签，支持编写动态的sql

2、第一个Mybatis程序

创建数据库

CREATE DATABASE `mybatis`;
USE `mybatis`;

CREATE TABLE `user`(
  `id` INT(20) NOT NULL PRIMARY KEY,
  `name` VARCHAR(30) DEFAULT NULL,
  `pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES 
(1,'狂神','123456'),
(2,'张三','123456'),
(3,'李四','123890')

创建Maven项目配置poom文件

<?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>org.example</groupId>
    <artifactId>Myabits-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-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>

        <!--lombok简化-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>


        <!--junit-单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <!--在build中配置resources，来防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <excludes>
                    <exclude>**/*.properties</exclude>
                    <exclude>**/*.xml</exclude>
                </excludes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

创建MyBatis的核心配置文件（MyBaits-config.xml）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <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="123456"/>
            </dataSource>
        </environment>
    </environments>
    
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

编写工具类（MyBatisUtisl）

public class MyBatisUtil {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            String resource = "MyBatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static SqlSession getsqlSession(){
        return sqlSessionFactory.openSession();
    }
}

创建实体类

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

创建Mapper接口

public interface UserMapper {
    List<User> getUserlist();
}

创建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">
<!--namespace=绑定一个对应的Mapper接口-->
<mapper namespace="com.cl.Mapper.UserMapper">

    <!--select查询语句 id对应UserMapper中的方法名-->
    <select id="getUserList" resultType="com.cl.pojo.User">
       select * from user
   </select>

</mapper>

创建测试类

public class MyBatisTest {
    @Test
    public void text(){
        SqlSession sqlSession = MyBatisUtil.getsqlSession();
        System.out.println(UserMapper.class.toString());
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userlist = mapper.getUserlist();
        for (User user : userlist) {
            System.out.println(user.toString());
        }
        sqlSession.close();
    }
}

测试结果

3、CRUD（增删改中注意事物提交）

3.1、namespace

Mapper.XML文件中的namespace绑定一个对应的Mapper接口

3.2、select

选择，查询语句;

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

1.编写接口

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

2.编写对应的Mapper.XML文件中sql语句

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

3.测试

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

3.3、update

int updateUser(User user);

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

@Test
public void Text04(){
    SqlSession sqlSession = MyBatisUtil.getsqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    int i = mapper.updateUser(new User(1, "gogo", "123456"));
    if (i == 1){
        System.out.println("更新成功");
    }
    sqlSession.commit();
}

3.4、insert

int addUser(User user);

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

@Test
public void text02(){
    SqlSession sqlSession = MyBatisUtil.getsqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = new User(5,"小明","123");
    int i = mapper.addUser(user);
    if (i == 1){
        System.out.println("插入成功");
    }
    sqlSession.commit();
}

3.5、delete

int deleteUser(int id);

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

@Test
public void text03(){
    SqlSession sqlSession = MyBatisUtil.getsqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    int i = mapper.deleteUser(5);
    if (i == 1){
        System.out.println("删除成功");
    }
    sqlSession.commit();
}

4、配置解析

4.1、核心配置文件（MyBatis-config）

mybatis-config.xml
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

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

4.2、环境配置（environments）

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

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

在environments 的 default 中配置开启哪个配置

<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="123456"/>
            </dataSource>
        </environment>
        <environment id="text">
            <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="123456"/>
            </dataSource>
        </environment>
    </environments>

4.3、属性（properties）

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

创建db.properties

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

在核心配置文件MyBatis-config.xml中映入

 <!--引入外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="pwd" value="11111"/>
    </properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

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

4.4、类型别名（typeAliases）

1.在核心配置文件MyBatis-config.xml中配置(实体类少使用)

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

2.扫描实体类的包

它的默认别名就为这个类的类名，首字母小写！

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

不想用默认的别名，可以在实体类上架注解修改默认别名

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

4.5、映射器（mappers）

方式一：

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

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

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

注意点：

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

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

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

注意点：

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

4.6、声明周期和作用域

在这里插入图片描述

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

SqlSessionFactoryBuilder：

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

SqlSessionFactory：

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

SqlSession

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

在这里插入图片描述

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

4.7、解决实体类属性名和数据库中字段名不一致

1、起别名(pwd as password)

<select id="getUserById" resultType="com.kuang.pojo.User">
    select id,name,pwd as password from mybatis.user where id = #{id}
</select>

2、resultMap

结果集映射

数据库中： id   name   pwd
实体类中： id   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>

5、日志

5.1、日志工厂

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

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

STDOUT_LOGGING标准日志输出 (不用导包，配置及用)

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

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

在这里插入图片描述

5.2、LOG4J

什么是Log4j？

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

1、导入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/kuang.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、在mybatis核心配置文件中启用log4j

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

4、测试结果

在这里插入图片描述

简单使用

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

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

3.日志级别

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

6、分页

6.1、limit实现分页

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

接口

public interface UserMapper {
    List<User> getUserlistLimit(Map<String,Integer> map);
}

Mapper.xml

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

测试

 @Test
    public void textLimit(){
        SqlSession sqlSession = MyBatisUtil.getsqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        int page = 1; //表示当前页数
        map.put("startIndex",page-1);  //因为limit是从 0 开始的，所以要-1才能从数据库中拿到第一条数据
        map.put("pageSize",2);
        List<User> user = mapper.getUserlistLimit(map);
        System.out.println(user);
    }

注意点：因为limit是从 0 开始的，所以当前页 要 -1才能从数据库中拿到第一条数据

6.2、使用分页插件（PageHelper）

https://pagehelper.github.io/docs/howtouse/

7、使用注解开发

public interface UserMapper {
    @Select("select * from mybatis.user where id = #{id}")
    User getUserById(@Param("id") Integer id);
}

关于@Param() 注解

基本类型的参数或者String类型，需要加上
在SQL中引用的就是我们这里的 @Param() 中设定的属性名！

8、多对一处理

多个学生对应一个老师

实体类

//学生实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private Teacher teacher;  //对应的老师
}

//老师实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {
    private int id;
    private String name;
}

Mapper.xml

<resultMap id="Alluser" type="Student">
    <result column="sid" property="id"/>
    <result column="sname" property="name"/>
    <association property="teacher" javaType="Teacher">
        <result column="tid" property="id"/>
        <result column="tname" property="name"/>
    </association>
</resultMap>

<select id="getAllUser" resultMap="Alluser">
    select s.id as sid,s.name as sname,t.name as tname,t.id as tid
    from mybatis.student s inner join mybatis.teacher t on s.id = t.id
</select>

测试

@Test
    public void textgetAll(){
        SqlSession sqlSession = MyBatisUtil.getsqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> allUser = mapper.getAllUser();
        System.out.println(allUser);
    }

9、一对多处理

一个老师对应多个学生

实体类

//老师实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {
    private int id;
    private String name;
    private List<Student> students;   //对应多个学生
}

//学生类体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
}

Mapper.xml

<resultMap id="allteacher" type="Teacher">
     <result column="tname" property="name"/>
     <result column="tid" property="id"/>
     <collection property="students" ofType="Student">
         <result column="sid" property="id"/>
         <result column="sname" property="name"/>
     </collection>
</resultMap>

<select id="getTeacher" resultMap="allteacher">
        select s.id as sid,s.name as sname,t.name as tname,t.id as tid
        from   mybatis.teacher t left join mybatis.student s on s.id = t.id             where t.id = #{tid}
</select>

测试类

 @Test
    public void textTeacher(){
        SqlSession sqlSession = MyBatisUtil.getsqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
    }

10、动态sql( if、set、foreach)

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

数据库

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

实体类

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

接口

public interface BlogMapper {
    //if
    List<Blog> queryBlogIF(Map<String,Object> map);
    //set 
    int updateBlog(Map<String,Object> map);
    //foreach
    List<Blog> selectBlogIn(Map<String,Object> map);
}

Mapper.xml文件

<mapper namespace="com.cl.Mapper.BlogMapper">

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

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

    </update>

    <select id="selectBlogIn" parameterType="map" resultType="Blog">
        select * from mybatis.blog where id in
        <foreach collection="fff2" item="item" index="index" open="(" close=")" separator=",">
            #{item}
        </foreach>
    </select>
</mapper>

11、缓存

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

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

一级缓存

一级缓存也叫本地缓存： SqlSession

与数据库同一次会话期间查询到的数据会放在本地缓存中。
以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库。
可以使用 sqlSession.clearCache() 来手动清理缓存。

二级缓存

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

步骤：

开启全局缓存

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

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

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

也可以自定义参数

<!--在当前Mapper.xml中使用二级缓存-->
<cache  eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"/>

狂神说：https://space.bilibili.com/95256449/channel/detail?cid=90797

偷偷写博客

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录