Mybatis

最新推荐文章于 2024-05-16 14:17:50 发布
最新推荐文章于 2024-05-16 14:17:50 发布
阅读量429 收藏
点赞数
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43774354/article/details/110206639
版权

Mybatis

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](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis 。
  • 2013年11月迁移到Github。

如何获得Mybatis

  • Maven

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

  • 中文文档 https://mybatis.org/mybatis-3/zh/index.html

  • GitHub https://github.com/mybatis/mybatis-3

1.2 持久化

数据持久化

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

为什么需要持久化？

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

1.3 持久层

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

1.4 为什么需要Mybatis

  • 帮助程序猿将数据存入到数据库中
  • 方便
  • 传统的JDBC代码太复杂了。简化
  • 优点：
    • 简单易学
    • 灵活
    • sql和代码的分离，提高了可维护性。
    • 提供映射标签，支持对象与数据库的orm字段关系映射
    • 提供对象关系映射标签，支持对象关系组建维护
    • 提供xml标签，支持编写动态sql。

2、第一个Mybatis程序

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

2.1 搭建环境

搭建数据库

CREATE DATABASE `mybatis`;
USE `mybatis`;

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

INSERT INTO `user`(`id`,`name`,`pwd`)VALUES
(1,'雅艺','1234'),
(2,'米亚','123'),
(3,'西西','1233')

新建项目

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

  2. 删除src目录

  3. 导入maven依赖

     <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>

        <!-- Mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <!-- Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

2.2 创建一个模块

  • 编写mybatis的核心配置文件

    mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--mybatis核心配置文件-->
<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?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>
    <!--每个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/yzp/dao/UserMapper.xml"/>
    </mappers>
</configuration>

    XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）
environment 元素体中包含了事务管理和连接池的配置。mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息

  • 编写Mybatis工具类

    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();
    }

}

    每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。
MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

2.3 编写代码

  1. 实体类

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

  2. Dao接口

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

  3. 接口实现类(由原来的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.yzp.dao.UserDao">
    <!--select查询语句-->
    <select id="getUserList" resultType="com.yzp.pojo.User">
    select * from mybatis.user;
  </select>
</mapper>

2.4 测试

@Test
    public void test(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一： 执行SQL
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

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

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

注意点：

  1. 在pom.xml文件中的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>
  1. 每个Mapper.xml都需要在Mybatis核心配置文件中注册
  2. mybatis配置文件中需配置serverTimezone=UTC

3、CURD

1.namespace

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

2.select

选择，查询语句

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

  1. 编写接口

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

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

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

  3. 测试

    //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一： 执行SQL
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User user = mapper.getUserById(2);


        System.out.println(user);


        //关闭SqlSession
        sqlSession.close();

3.insert

<!--对象中的属性可以直接读出来-->
    <insert id="addUser" parameterType="com.yzp.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.yzp.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd}  where id=#{id};
    </update>

注意点：

  • 增删改需要提交事务！ sqlSession.commit();

6.Map

如果，我们的实体类或者数据库中的表，字段或者参数过多，我们可以考虑用Map

<insert id="addUser1" parameterType="map">
        insert into mybatis.user(id,pwd)values (#{userId},#{pwd});
    </insert>


@Test
    public void update1Test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("userId",4);
        map.put("pwd",33333);
        mapper.addUser1(map);
        sqlSession.commit();
        sqlSession.close();
    }

7.模糊查询

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

    List<User> users = mapper.getUserLike("%米%");


    <select id="getUserLike" resultType="com.yzp.pojo.User">
        select * from mybatis.user where name like #{value};
    </select>

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

    <select id="getUserLike" resultType="com.yzp.pojo.User">
        select * from mybatis.user where name like "%"#{value}"%";
    </select>


    List<User> users = mapper.getUserLike("米");

4、配置解析

1.核心配置文件

mybatis-config.xml

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

configuration（配置）

2.环境配置（environments）

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

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

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

3.属性（properties）

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

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

编写一个配置文件 db.properties

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

在核心配置文件中引入

<properties resource="db.properties"/>

也可以在 properties 元素的子元素中设置 :

 <properties resource="db.properties">
  <property name="username" value="root"/>
  <property name="password" value="123"/>
</properties>
  • 如果外部配置文件和 properties 元素的子元素有相同的字段，优先使用外部配置文件的

4.类型别名（typeAliases）

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

<!--给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.yzp.entity.User" alias="User"/>
    </typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean ,比如：扫描实体类的包，它的默认别名就是这个类的类名，首字母小写

<typeAliases>
       <package name="com.yzp.entity"/>
    </typeAliases>

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

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

第一种可以DIY别名（自定义），第二种不行，如果非要改，需要在实体上增加注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eoFQaH0a-1606399183209)(D:\image\1606227026318.png)]

5.设置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FSNxooei-1606399183212)(D:\image\1606227331526.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JiiZCrCB-1606399183213)(D:\image\1606227367972.png)]

6.其他配置

7.映射器（mappers）

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

方式一： 使用相对于类路径的资源引用 （推荐）

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

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

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

注意：

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

方式三：使用扫描包进行绑定注册(注意点同方式二)

 <package name="com.yzp.mapper"/>

8.生命周期和作用域

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LAhmqcoJ-1606399183214)(D:\image\1606229932584.png)]

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

  • 可以想象为：数据库连接池

  • 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。

  • 最佳作用域是应用作用域

  • 最简单的就是使用单例模式或者静态单例模式

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kdh6ZvVj-1606399183215)(D:\image\1606230477947.png)]

这里的每个Mapper，就代表每一个业务

5、解决属性名和字段名不一致的问题——resultMap(重点)

1.问题

数据库字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IdQXOVVy-1606399183216)(D:\image\1606232119606.png)]

类属性：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BX8Kib4z-1606399183217)(D:\image\1606232148621.png)]

测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MsAnNfRW-1606399183218)(D:\image\1606232169109.png)]

select * from mybatis.user where id=#{id};
//以上通过类型处理器得到
select id,name,pwd from mybatis.user where id=#{id};

解决方法：

  1. 起别名

     select id,name,pwd as password from mybatis.user where id=#{id};

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g26xY9fA-1606399183218)(D:\image\1606232450507.png)]

  2. 使用resultMap

2.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" resultMap="UserMap" parameterType="int">
        select *  from mybatis.user where id=#{id};
    </select>

  • resultMap元素是Mybatis中最强大的元素

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

  • ResultMap 的优秀之处——虽然你已经对它相当了解，但你完全可以不用显式地配置它们

    <resultMap id="UserMap" type="User">
        <!--column数据库表中的字段 property实体类中的属性-->
        <!--<result column="id" property="id"/>
        <result column="name" property="name"/>-->
        <result column="pwd" property="password"/>
    </resultMap>

语句中设置 resultMap 属性就行了（注意我们去掉了 resultType 属性）

6、日志

6.1 日志工厂

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

曾经：sout\debug

现在：日志工厂

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1h697k5j-1606399183219)(D:\image\1606234255871.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-bEB9XrdM-1606399183219)(D:\image\1606234765207.png)]

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>

  1. 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/yu.log
log4j.appender.file.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

  2. 配置LOG4J 为日志的实现

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

  3. 测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QCKWF4AV-1606399183220)(D:\image\1606237193712.png)]

简单使用

  1. 日志对象 参数为当前类的class
static Logger logger = Logger.getLogger(LogTest.class);
  1. 日志级别
ogger.info("info:进入到了Log4jTest方法");
        logger.debug("debug:进入到了Log4jTest方法");
        logger.error("error:进入到了Log4jTest方法");


public class LogTest {
    static Logger logger = Logger.getLogger(LogTest.class);
    @Test
    public void Log4jTest(){
        logger.info("info:进入到了Log4jTest方法");
        logger.debug("debug:进入到了Log4jTest方法");
        logger.error("error:进入到了Log4jTest方法");

    }
    @Test
    public void test(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        logger.info("测试,进入test方法");
        //方式一： 执行SQL
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(2);
        System.out.println(user);
        //关闭SqlSession
        sqlSession.close();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3eDX0kAl-1606399183221)(D:\image\1606238336288.png)]

7、分页

思考：为什么要分页？

  • 减少数据的处理量

7.1 使用Limit分页（重点）

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

使用Mybatis实现分页，核心SQL

  1. 接口
//分页查询
    List<User> getUserByLimit(Map<String,Integer> map);
  1. Mapper.xml
<select id="getUserByLimit" resultMap="UserMap" parameterType="map">
        select * from mybatis.user limit #{startIndex},#{pageSize}
    </select>
  1. 测试
@Test
    public void getUserByLimitTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> users = mapper.getUserByLimit(map);
        for (User user:users
             ) {
            System.out.println(user);
        }
    }

7.2 RowBounds分页（了解）

  1. 接口

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

  2. Mapper.xml

    <select id="getUserByRowBounds" resultMap="UserMap" parameterType="map">
        select * from mybatis.user
    </select>

  3. 测试

     @Test
    public void getUserByRowBoundsTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //RowBounds实现分页
        RowBounds rowBounds = new RowBounds(1, 2);
        List<User> userList = sqlSession.selectList("com.yzp.mapper.UserMapper.getUserByRowBounds", null, rowBounds);
        for (User user:userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

7.3分页插件

（了解）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CQIIEJQp-1606399183221)(D:\image\1606273546706.png)]

8、使用注解开发

8.1 面向接口编程

我们学过面向对象编程,也学过接口,但在真正的开发中,很多时候我们会选择面向接口编程.

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

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

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

关于接口的理解

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

三个面向区别

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

8.2 使用注解开发

  1. 注解直接在接口上实现

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

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

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

mybatis详细执行过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nSeopyPh-1606399183222)(D:\image\微信图片_20201125144710.jpg)]

8.3 CRUD

  1. 编写接口

  2. 绑定接口

    <!--    绑定接口-->
    <mappers>
        <mapper class="com.yzp.mapper.UserMapper"/>
    </mappers>
查询
//    有多个参数时必须加上@Param
    @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);


public static SqlSession getSqlSession(){

        return sqlSessionFactory.openSession(true);//true自动提交事务
    }
修改
@Update("update user set name=#{name},pwd=#{password} where id=#{id}")
    int updateUser(User user);
删除
@Delete("delete from user where id=#{yid}")
    int deleteUser(@Param("yid") int id);
@Param()注解
  • 基本类型的参数或者String类型，需要加上
  • 应用类型不需要加
  • 如果只有一个基本类型可以加也可以不加
  • 我们在SQL中引用的（#{yid}）就是@Param(“yid”)中设定的属性名

#{} 可以防止sql注入

${} 不可以防止sql注入

9、Lombok

Features
@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
@val
@var
experimental @var
@UtilityClass
Lombok config system
Code inspections
Refactoring actions (lombok and delombok)

使用步骤：

  1. 在idea中下载Lombok

  2. 在项目导入lombok依赖

    <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

  3. 在实体类上加注解

@Data :无参构造，get，set，toString，hashcode，equals方法

@AllArgsConstructor

@NoArgsConstructor

@EqualsAndHashCode

@ToString

@Getter and @Setter

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AntYPT8I-1606399183222)(D:\image\1606291409326.png)]

10、多对一处理

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

SQL

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

INSERT INTO teacher(`id`,`name`)VALUES(1,'游老师')

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

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

实体类：

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

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

业务需求：查询所有的学生信息，以及对应的老师信息

首次尝试：

首先在mybatis核心配置文件中绑定接口或配置文件

<mappers>
        <mapper class="com.yzp.mapper.TeacherMapper"/>
        <mapper class="com.yzp.mapper.StudentMapper"/>
    </mappers>

  1. 编写接口

     public List<Student> getStudent();

  2. 编写Mapper.xml

    <mapper namespace="com.yzp.mapper.StudentMapper">
    <select id="getStudent" resultType="Student">
        select * from student s,teacher t where s.tid = t.id;
    </select>
</mapper>

  3. 测试

    @Test
    public void getStudentTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> studentList = mapper.getStudent();
    for (Student stu:studentList) {
        System.out.println(stu);
    }
    sqlSession.close();
}

    测试结果：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LVeQSSqs-1606399183223)(D:\image\1606313231576.png)]

teacher为null

解决方法：

按照查询嵌套处理

修改StudentMapper.xml为

<mapper namespace="com.yzp.mapper.StudentMapper">
<!--    思路：
            1.查询所有学生的信息
            2.根据查询出来的学生的tid，寻找对应得老师-->
   <select id="getStudent" resultMap="StudentTeacher">
       select * from student
   </select>
    <resultMap id="StudentTeacher" 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>
</mapper>

测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MboDRUZD-1606399183224)(D:\image\1606313791527.png)]

按照结果嵌套处理

修改StudentMapper.xml为

<!--按照结果嵌套处理-->
    <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>

11、一对多处理

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

对于老师而言就一对多

实体类：

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

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


获取指定老师下的所有学生及老师的信息

  1. 接口

    List<Teacher> getTeacher(@Param("tid") int id);

  2. Mapper.xml

    方式一

    <!--    按结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select t.id tid,t.name tname,s.id sid,s.name sname
        from teacher t,student s
        where t.id = s.tid and t.id=#{tid};
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>

   </resultMap>

    方式二

    <!--按查询嵌套处理-->
<select id="getTeacher2" resultMap="TeacherStudent2">
        select * from 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 student where tid =#{tid}
    </select>

  3. 测试结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JH9cvIqr-1606399183224)(D:\image\1606352350924.png)]

小结：

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

注意点：

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

面试高频

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

12、动态SQL（重点）

什么是动态sQL

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

​ 其本质还是SQL语句，只是我们可以在SQL层面，去执行逻辑代码

  • if（重点）
  • choose (when, otherwise)
  • trim (where, set)
  • foreach

where

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

if

希 望通过 “title” 和 “author” 两个参数进行可选搜索该怎么办呢

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

choose

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

相当于switch case

set

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

SQL片段

<sql id="if-title-author">
        <if test="title !=null">
            title =#{title},
        </if>
        <if test="author !=null">
            author =#{author}
        </if>
    </sql>
<!--在需要使用sql片段是使用include标签引用即可-->
<update id="updateBlogSet" parameterType="map">
        update blog
        <set>
            <include refid="if-title-author"></include>
        </set>
        where id = #{id}
    </update>

注意事项：

  • 最好基于单表来定义SQL片段（一般是if）
  • 不要存在where标签

foreach

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

测试：

@Test
    public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        Map<String, Object> map = new HashMap<String, Object>();
        ArrayList<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(3);
        ids.add(4);
        map.put("ids",ids);
        mapper.queryBlogForeach(map);
        sqlSession.close();
    }

13、缓存（了解）

13.1 缓存简介

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

13.2 Mybatis缓存

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

13.3 一级缓存

  • 一级缓存也叫本地缓存：SQLSession

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

    测试：

    1. 开启日志

    2. 测试

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

        System.out.println("==================");
        User user2 = mapper.queryUserById(1);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }
```

查看日志：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-twY5Pmio-1606399183225)(D:\image\1606377219061.png)]

从日志中可以看出第二次查询没有生成sql，直接查出来了。并且两次查询的user是同一个

缓存失效的情况：

  1. 查询不同的东西

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

  3. 查询不同的Mapper.xml

  4. 手动清理缓存

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

        System.out.println("==================");
        mapper.updateUser(new User(2,"思妮","yyy"));
        System.out.println("==================");

        User user2 = mapper.queryUserById(1);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FfLnGjD7-1606399183226)(D:\image\1606377771570.png)]

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

        System.out.println("==================");
        sqlSession.clearCache();//清理缓存

        User user2 = mapper.queryUserById(1);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HysvknAr-1606399183226)(D:\image\1606377828947.png)]

小结：

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

一级缓存就是一个Map

13.4 二级缓存

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

二级缓存需要手动开启和配置，他是基于namespace级别的缓存。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B0fN7luz-1606399183227)(D:\image\1606380116437.png)]

使用步骤：

  1. 开启全局缓存

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

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

    <mapper namespace="com.yzp.dao.UserMapper">
<!--    在当前mapper中使用二级缓存-->
    <cache />
</mapper>

    也可以自定义参数

    <mapper namespace="com.yzp.dao.UserMapper">
<!--    在当前mapper中使用二级缓存-->
    <cache eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>
</mpper>
    1. 测试
     @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.queryUserById(1);
        System.out.println(user);
        sqlSession.close();
        System.out.println("==================");
        
        SqlSession sqlSession2 = MybatisUtils.getSqlSession();
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
        User user2 = mapper2.queryUserById(1);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession2.close();
    }

    出错：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ttVRDN5E-1606399183227)(D:\image\1606381237760.png)]

    需将实体类User序列化

    修改后，测试结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lJDF1RBV-1606399183228)(D:\image\1606381574780.png)]

    可以在mapper的某个查询中手动关闭或开启二级缓存

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J5KHtODK-1606399183229)(D:\image\1606381909575.png)]

    小结：

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

13.5 缓存原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uFhYaPkF-1606399183229)(D:\image\1606381793558.png)]

13.6 自定义缓存-ehcache()

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

  1. 在程序中使用ehcache,先要导包
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.0.0</version>
</dependency>

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>
  1. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MGZ4OQQC-1606399183230)(D:\image\1606383330100.png)]

Redis数据库来做缓存

13.7 Mybatis总结

smile@守护
关注
专栏目录
MyBatis官方文档-入门，java异步编程实战
m0_64867047的博客
12-13 442
每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例。 从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但是也可
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
MyBatis 中文官方文档
06-30
MyBatis 中文官方文档， 比较齐全， 有例子
Mybatis入门笔记
weixin_49707895的博客
11-02 207
Mybatis入门 1.what is mybatis? 什么是 MyBatis？ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 why idea扫描不到mapper层的UserMapper.xml文件,
MyBatis官方文档
qq_63055262的博客
03-27 6028
MyBatis框架的入门学习文档，MyBatis框架的详细解析文档（MyBatis官方文档）小编已经翻译好了，记得收藏加关注！
Mybatis中文官方文档
Garson的博客
09-29 4840
Mybatis中文文档
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的...
mybatis官方文档，中文版
11-08
系统全面的mysql教程，中文版，查看无压力，快速使用mybatis
myBatis官方文档
12-24
myBatis官方文档
Mybatis官方文档
08-16
Mybatis官方文档
MyBatis真正的官方教程(来自官网)
02-12
MyBatis真正的官方教程(来自官网)
Mybatis文档（中英）
01-06
Mybatis文档（中英）
mybatis官方文档
adsadadaddadasda的博客
03-09 1235
Java API既然你已经知道如何配置 MyBatis 和创建映射文件,你就已经准备好来提升技能了。 MyBatis 的 Java API 就是你收获你所做的努力的地方。正如你即将看到的,和 JDBC 相比, MyBatis 很大程度简化了你的代码而且保持简洁,很容易理解和维护。MyBatis 3 已经引入 了很多重要的改进来使得 SQL 映射更加优秀。应用目录结构在我们深入 Java API 之...
MyBatis官方文档-入门
最新发布
2401_84815783的博客
05-16 1056
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
MyBatis官方文档-日志
2401_84010457的博客
04-02 481
org.apache.ibatis.logging.LogFactory.useSlf4jLogging();org.apache.ibatis.logging.LogFactory.useLog4JLogging();org.apache.ibatis.logging.LogFactory.useJdkLogging();org.apache.ibatis.logging.LogFactory.useCommonsLogging();org.apache.ibatis.logging.LogFactory
MyBatis项目实践教程
MyBatis的配置文件是一个XML文件，用于配置整个MyBatis应用的环境，包括数据源（DataSource）、事务管理器（TransactionManager）、映射文件（Mapper XML）等。 5. MyBatis的优点： - 灵活性高，几乎可以配置所有的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值