Mybatis入门_将sql语句执行的java开源软件-优快云博客

在Java开发领域，Sql语句的编写一直是比较麻烦和容易出错的一个环节，传统的JDBC方式需要开发者手动拼写Sql语句，并且在执行时需要手动设置参数和处理结果集。而ORM框架则是将Java对象和数据库表进行映射，在进行增、删、改、查等操作时，只需要对Java对象进行操作，ORM框架会将操作转化为对数据库的Sql语句进行操作。但是，ORM框架常常会存在一定的性能问题，特别是对于超大型数据量和高并发的系统，ORM框架的性能会更加明显地劣于手工编写的Sql语句。

Mybatis框架结合了ORM框架和手工Sql语句编写的优点，它通过Sql映射文件与Java接口的方法进行绑定，实现了Java对象与数据库表的映射，同时也允许开发者手动控制Sql语句的生成和执行过程，这样就可以更好地控制程序的性能。另外，Mybatis框架提供了一些成熟的缓存机制，能够有效地减少数据库访问的次数，提升系统的性能。Mybatis框架还有很多其他的高级特性，如动态Sql、参数映射、插件等功能，可以进一步提升开发效率和程序性能。

2.Mybatis的的作用

Mybatis的主要作用是简化数据库访问代码的编写，提供灵活性和高度可定制性的数据持久化解决方案。具体来说，Mybatis的作用包括以下几个方面：

数据库访问：Mybatis可以帮助开发人员处理与数据库的交互，包括执行SQL语句、查询数据、插入、更新和删除等操作。它提供了丰富的API和配置方式，使得开发人员能够轻松地进行数据库访问。

SQL映射：Mybatis将SQL语句与Java代码进行分离，通过XML或注解的方式进行配置，使得开发人员可以更加专注于业务逻辑的实现。它支持动态SQL，可以根据不同的条件生成不同的SQL语句，提供了强大的灵活性。

参数映射：Mybatis支持将Java对象与SQL语句的参数进行映射，可以通过命名参数或位置参数的方式传递参数。它还提供了丰富的参数处理方式，包括自动类型转换、参数校验和参数处理器等。

结果集映射：Mybatis支持将查询结果映射为Java对象，可以通过配置文件或注解来定义映射关系。它提供了灵活的映射方式，可以将查询结果映射为单个对象、列表、嵌套对象等形式，方便数据的处理和操作。

缓存机制：Mybatis具有缓存机制，可以缓存查询结果，提高数据库访问的性能。它支持一级缓存和二级缓存，可以根据需求进行配置和使用。

总而言之，Mybatis作为一款轻量级的Java持久层框架，可以帮助开发人员简化数据库访问的代码编写，提供灵活性和高度可定制性的数据持久化解决方案。它在许多项目中得到广泛应用，成为Java开发人员进行数据库访问的首选框架之一。

3.Mybatis概述

Mybatis是一个基于Java语言的持久层框架，它通过XML描述符或注解将对象与关系型数据库中的表进行映射，使得在Java应用程序中操作数据库变得方便和高效。Mybatis具有以下优点：

灵活性高：Mybatis通过Sql映射文件与Java接口的方法进行绑定，允许开发者手动控制Sql语句的生成和执行过程，极大地提高了灵活性。

易于学习和使用：Mybatis核心配置简单明了，且集成规范，易于上手。

性能出色：Mybatis不会对Sql进行特意优化，而是将这一任务交给了开发者，因此开发者可以根据自己的需求对Sql进行优化，从而提高性能。

易于集成：Mybatis可以与Spring等大多数主流框架无缝集成。

总之，Mybatis是一款开源的、轻量级的、高效的Java持久化框架，非常适合开发中、小型项目。

4.Mybatis的定义

Mybatis是一款基于Java语言的持久层框架，它通过SQL映射文件或注解将Java对象与数据库表进行映射，方便进行数据的持久化操作。Mybatis的核心思想是将SQL语句与Java代码进行解耦，使得开发者能够更好地控制SQL语句的生成和执行过程，进而提高系统的灵活性、可维护性和性能。

当我们考虑使用 MyBatis，就好像我们在处理数据库时的一种智能方法。想象一下，你是一个数据库管理员，有一堆数据库表格和数据，而你的任务是通过编写查询语句来检索、插入、更新和删除数据。但是，你不想使用复杂的工具，而是更喜欢直接使用 SQL 语句来处理数据。

MyBatis 就像是你的助手，它让你可以轻松地执行数据库操作，而无需关心太多底层细节。你可以将数据库表格和 Java 类之间的关系告诉 MyBatis，然后告诉它你想要执行的操作，比如查询特定数据，或者将新数据插入到表格中。

与传统的方法不同，MyBatis 允许你在 XML 配置文件中编写 SQL 查询，也可以通过注解在 Java 代码中指定。这就像是你编写一份清单，告诉 MyBatis 你想要做什么，然后它会帮你将这些请求转化为真正的 SQL 查询。这样，你可以轻松地在 Java 代码中调用这些查询，就像在数据库中进行搜索一样简单。

而且，MyBatis 还有其他聪明的功能。它支持缓存，这意味着当你多次查询相同的数据时，它会从内存中快速获取，而不是每次都去数据库查询。它还支持懒加载，这意味着当你需要某些关联数据时，它才会从数据库中加载，而不是一次性加载所有内容。

总之，使用 MyBatis 就像是在处理数据库时有一个智能的助手，它帮助你编写、执行和管理数据库操作，同时让你保持对 SQL 查询和数据流的直接控制。这样，你可以更专注于业务逻辑，而不必过多担心数据库访问的复杂性。

5.Mybatis的特点

Mybatis有以下特点：

灵活性：Mybatis可以通过SQL映射文件或注解实现SQL的编写，开发者可以根据实际需求自由定义SQL语句，不受框架限制。

可维护性：Mybatis可以将SQL语句和Java代码进行解耦，使得SQL语句的修改和维护更加方便。

易于学习和使用：相对于其他ORM框架，Mybatis的学习曲线较为平缓，文档齐全，易于上手。

高性能： Mybatis使用了缓存机制，可以有效地提高系统的性能和响应速度。

支持多种数据库：Mybatis支持多种关系型数据库，包括MySQL、Oracle、SQL Server等，使用方便灵活。

当谈到 MyBatis 这个东西时，就好像在讨论一位非常擅长连接你和数据库的"翻译家"。想象一下，你有一个庞大的图书馆，里面放满了书籍，而你需要找到特定的书籍或者把新的书籍放进去。但是，你不擅长找到正确的书架，或者不知道如何将新书整理好。

MyBatis 就像是那位翻译家，它能够帮助你实现与图书馆的沟通，就像你在使用英语与其他人对话一样。你告诉这位翻译家你需要哪本书，或者你想要添加什么新书，然后它会帮你找到正确的书架，整理好新书，确保你的请求得到满足。

与其他复杂的工具不同，MyBatis 让整个过程变得非常直观。你可以告诉它，哪本书对应着哪个数据库表，然后告诉它你需要哪种操作，比如读取书籍或者添加新书。你可以在一个叫做 XML 配置文件的地方写下你的要求，或者在你的代码中用特殊的记号标明。

而且，MyBatis 还有一些额外的优点。它支持缓存，就好像你把你最常用的书放在你的书桌上，这样可以更快地拿到它们，而不是每次都去书架上翻找。还有懒加载功能，当你只需要特定的书籍时，它会帮你把那本书从书架上取下来，而不是一次性把所有书都取出来。

总之，MyBatis 就像是一个与图书馆之间建立联系的智能翻译家。它能够帮你轻松实现与数据库的交流，而不需要过多担心复杂的操作。这样，你可以更专注于你的工作，而不必花费过多时间在与数据库的互动上。

6.ORM框架是什么

ORM（Object-Relational Mapping）框架是一种将对象模型和关系数据库之间进行映射的技术。它的主要作用是将数据库中的数据映射为对象，使得开发人员可以通过面向对象的方式来操作数据库，而不需要直接编写SQL语句。

ORM框架通过提供一系列的API和工具，将数据库表和对象之间的映射关系进行定义和管理。开发人员可以通过配置或注解的方式，将对象与数据库表进行关联，定义字段之间的映射关系，以及定义对象之间的关联关系。

ORM框架的主要优点包括：

简化数据库操作：ORM框架隐藏了底层数据库的细节，开发人员可以通过面向对象的方式来进行数据库操作，无需编写复杂的SQL语句。
提高开发效率：ORM框架提供了一系列的CRUD（增删改查）操作的API和工具，可以大大简化数据库操作的代码量，提高开发效率。
跨数据库支持：ORM框架一般支持多种数据库，开发人员可以在不同的数据库之间进行切换，而无需修改大量的代码。
对象关系映射：ORM框架将数据库表和对象之间的映射关系进行管理，使得开发人员可以通过对象的方式来操作数据库，方便数据的处理和操作。
提高性能：ORM框架通过对SQL语句的预编译和缓存机制，提高数据库访问的性能，支持批量操作和延迟加载等特性，进一步优化了数据库访问的效率。

常见的ORM框架包括Hibernate、Mybatis、Spring Data JPA等。开发人员可以根据项目需求和团队的实际情况选择合适的ORM框架来进行数据库访问和操作

7.Mybatis与其他ORM框架的区别

当比较MyBatis与其他ORM（对象关系映射）框架时，以下是一些主要区别：

SQL 控制程度：
- MyBatis： MyBatis允许开发人员编写原生SQL查询，并将其映射到对象。这使得可以更精确地控制数据库操作，但需要手动处理SQL语句。
- 其他ORM框架： 其他ORM框架（如Hibernate）通常通过提供高级抽象来隐藏SQL，从而减少了手动编写SQL的工作，但可能在性能和复杂性方面具有一些限制。
灵活性：
- MyBatis： MyBatis在处理复杂查询和自定义映射方面非常灵活。开发人员可以根据需要进行细粒度的控制和优化。
- 其他ORM框架： 其他ORM框架可能在灵活性方面受到一些限制，因为它们试图提供更高级的抽象来处理数据库操作。
对象关系映射：
- MyBatis： MyBatis使用XML或注解来定义对象与数据库表之间的映射关系，允许开发人员精确地配置如何将数据库查询结果映射到对象属性。
- 其他ORM框架： 其他ORM框架通常使用类和注解来定义对象和数据库表之间的映射关系，通过约定优于配置的方式来减少映射配置的工作。
性能优化：
- MyBatis： 由于开发人员可以编写原生SQL，因此他们可以更好地优化查询性能，但需要更多的数据库知识。
- 其他ORM框架： 其他ORM框架可能在某些情况下执行性能优化，但可能不如手动优化的精确。
学习曲线：
- MyBatis： 对于熟悉SQL的开发人员来说，上手相对较容易。但对于不熟悉SQL的人来说，可能需要一些时间来理解。
- 其他ORM框架： 其他ORM框架可能提供更高级的抽象，适合那些不太了解SQL的开发人员。

综上所述，选择MyBatis还是其他ORM框架取决于项目的需求、团队的技能和对数据库操作的控制程度。

当比较 MyBatis 和其他 ORM 框架时，就像在比较两种不同的方式来处理图书馆中的书籍。这两种方式分别是“智能图书管理员”（ORM 框架）和“书架指南”（MyBatis）。

MyBatis（书架指南）：
在图书馆中，你有一个书架指南，上面标明了每本书在哪个位置。这本质上就是你在 MyBatis 中定义的 SQL 映射。
当你想要一本特定的书时，你会查阅书架指南，找到书籍的位置，然后自己去取。
MyBatis 让你在 XML 文件中定义 SQL 查询或在代码中使用注解，然后根据这些定义的内容，它会帮助你执行数据库操作。
你有更多的控制权，可以更准确地定义查询，管理数据库操作的细节。

其他 ORM 框架（智能图书管理员）：
在图书馆中，你有一位智能图书管理员，你只需告诉他你需要哪本书，他会帮你找到并递给你。
这个图书管理员代表了 ORM 框架，它会在后台自动构建和执行 SQL 查询，然后把结果封装成对象返回给你。
ORM 框架通过对象和数据库表的映射，自动处理数据库操作，不需要你手动编写 SQL 查询。
这使得操作更加方便，你只需要关心对象和业务逻辑，而不必过多关注底层的数据库细节。

总的来说，MyBatis 和其他 ORM 框架的区别在于控制程度。MyBatis 像是一个让你手动操作图书馆的书架指南，让你有更多的控制权和灵活性，但需要一些额外的配置和代码编写。另一方面，其他 ORM 框架就像是一个智能的图书管理员，自动帮你处理数据库操作，省去了很多繁琐的工作，但可能会限制一些复杂查询和优化操作的自定义。选择哪种方式取决于你对控制和自动化的需求。

8.mybatis优缺点

MyBatis优点：

灵活性高：MyBatis允许你编写原生的SQL查询，这意味着你可以完全控制查询的细节，可以根据需求编写复杂的查询语句。

适应性强：MyBatis适用于各种数据库系统，因为它的底层并不限制于特定的数据库。这使得你可以轻松地切换数据库系统而不必更改太多代码。

轻量级：相比于其他ORM框架，MyBatis的运行时开销相对较小。它不会在运行时引入过多的性能开销，适合对性能要求较高的场景。

映射灵活：MyBatis提供了多种映射方式，包括基于XML和基于注解的方式，你可以根据项目的需求选择最合适的方式。

易于调优：由于你可以编写原生SQL查询，因此可以更容易地进行数据库查询性能的调优，针对特定的数据库操作优化。

支持定制：MyBatis提供了插件机制，允许你在不修改核心代码的情况下扩展其功能，比如添加自定义的日志记录、缓存等功能。

MyBatis缺点：

SQL维护复杂：虽然原生SQL查询提供了灵活性，但也意味着你需要自己负责维护SQL语句，包括SQL的编写、优化和调试，这可能会增加一些开发工作量。

数据库依赖性：虽然MyBatis可以适应多种数据库，但在切换数据库时，仍然需要注意一些数据库特定的差异和语法问题。

学习曲线：相对于一些自动化的ORM框架，MyBatis可能有一定的学习曲线，特别是对于初次接触原生SQL的开发者。

XML配置复杂：尽管XML配置提供了很大的灵活性，但有时候需要编写大量的XML配置文件，可能会让配置变得复杂。

代码冗余：使用MyBatis时，你可能需要在Mapper接口和映射文件中定义相同的SQL语句，这可能会导致代码的冗余。

总的来说，MyBatis是一个灵活、轻量级的ORM框架，适用于那些需要更多控制和定制性的项目。它允许你编写原生的SQL查询，但也需要你自己负责SQL的维护和优化。如果你更关注自动化和减少重复性代码，其他ORM框架可能更适合你。选择使用MyBatis还是其他ORM框架，取决于项目需求和团队的技术偏好。

9.MyBatis的核心组件

SqlSessionFactory（会话工厂）：SqlSessionFactory 是 MyBatis 的核心接口之一。它的作用是创建 SqlSession 实例，SqlSession 实际上是与数据库交互的主要入口。SqlSessionFactory 负责读取 MyBatis 配置文件并构建配置信息，然后根据配置信息创建 SqlSession。
SqlSession（会话）：SqlSession 代表了一次与数据库的会话，它是 MyBatis 的核心组件之一。SqlSession 提供了对数据库的操作方法，包括查询、插入、更新和删除等。每个会话通常对应一个数据库连接，它负责管理事务的开始和结束。
Mapper接口（数据映射器接口）：Mapper 接口是定义数据访问操作的接口。它通常包含了与数据库相关的SQL查询语句的声明，以及这些操作的参数和返回值类型。Mapper 接口与XML文件（MyBatis的映射文件）一起使用，将方法与SQL语句进行映射。

SqlSessionFactory的作用和配置方式

SqlSessionFactory 的作用是创建 SqlSession 对象，它需要配置文件来初始化。配置文件通常包括以下几个关键部分：

数据源配置：指定数据库连接的信息，包括数据库类型、地址、用户名、密码等。
映射文件配置：定义了 Mapper 接口与 SQL 查询语句之间的映射关系。这些映射通常包括 SQL 查询语句的位置、输入参数和输出结果的映射。
全局配置：包括事务管理器的配置、缓存配置、插件配置等。

以下是一个简单的 MyBatis 配置文件的示例：

xml

<configuration>
    <!-- 数据源配置 -->
    <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="username"/>
        <property name="password" value="password"/>
    </dataSource>
    
    <!-- 映射文件配置 -->
    <mappers>
        <mapper resource="com/example/MyMapper.xml"/>
    </mappers>
</configuration>

SqlSession的生命周期和常用方法

SqlSession 的生命周期通常是短暂的，它的创建和销毁应该在一个方法内完成，以确保及时释放数据库资源。SqlSession 的常用方法包括：

selectOne(String statement, Object parameter)：执行查询并返回单个结果。
selectList(String statement, Object parameter)：执行查询并返回结果列表。
insert(String statement, Object parameter)：执行插入操作。
update(String statement, Object parameter)：执行更新操作。
delete(String statement, Object parameter)：执行删除操作。
commit()：提交事务。
rollback()：回滚事务。
close()：关闭 SqlSession。

Mapper接口的作用和编写方式

Mapper 接口的作用是定义数据访问操作的接口，以及这些操作与 SQL 查询语句的映射关系。Mapper 接口通常不需要手动实现，MyBatis 会在运行时动态生成实现类。

编写 Mapper 接口的方式是创建一个 Java 接口，方法名与映射文件中定义的 SQL 查询语句的 ID 相对应，方法的参数和返回值类型与查询的输入参数和输出结果类型相匹配。例如：

java

public interface UserMapper {
    User selectUserById(int id);
    List<User> selectAllUsers();
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int id);
}

在映射文件中，可以使用 <mapper> 元素来与 Mapper 接口关联，并定义查询语句的映射关系：

xml

<mapper namespace="com.example.UserMapper">
    <select id="selectUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <!-- 其他查询语句的映射 -->
</mapper>

通过这种方式，Mapper 接口的方法与 SQL 查询语句建立了映射关系，可以方便地进行数据库操作。 MyBatis 会在运行时生成 Mapper 接口的实现类，具体的数据库操作会在这个实现类中被执行。

10.MyBatis环境搭建

10.1创建Maven项目

打开IDEA创建一个Maven项目命名为mybatis，之后的操作会在Maven项目在演示

10.2pom.xml修改

之后修改pom.xml文件

<?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>mybatis</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
 
  <name>mybatis Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
 
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
 
  <dependencies>
    <!-- ********************** junit单元测试依赖 ********************** -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
<!--      <scope>test</scope>-->
    </dependency>
 
    <!-- ********************** Java Servlet API  ********************** -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.0</version>
      <scope>provided</scope>
    </dependency>
 
    <!-- ********************** Mybatis依赖 ********************** -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>
 
    <!-- ********************** Mysql JDBC驱动 ********************** -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.44</version>
    </dependency>
 
    <!-- **********************  日志配置  ********************** -->
    <!--记得修改mybatis.cfg.xml添加如下内容-->
    <!--<setting name="logImpl" value="LOG4J2"/>-->
    <!--核心log4j2jar包-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.9.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>2.9.1</version>
    </dependency>
    <!--web工程需要包含log4j-web，非web工程不需要-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-web</artifactId>
      <version>2.9.1</version>
    </dependency>
  </dependencies>
 
  <build>
    <finalName>mybatis</finalName>
    <resources>
      <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
      </resource>
      <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>jdbc.properties</include>
          <include>*.xml</include>
        </includes>
      </resource>
    </resources>
      <plugins>
 
        <plugin>
          <groupId>org.mybatis.generator</groupId>
          <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.2</version>
          <dependencies>
            <!--使用Mybatis-generator插件不能使用太高版本的mysql驱动 -->
            <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>5.1.44</version>
            </dependency>
          </dependencies>
          <configuration>
            <overwrite>true</overwrite>
          </configuration>
        </plugin>
 
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
  </build>
</project>

10.3 jdbc.properties

jdbc.properties配置文件:用于输入数据库的用户密码(注意:该配置文件的首字母不能大写)

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://47.100.191.44:3308/mybatis_ssm?useUnicode=true&characterEncoding=UTF-8
jdbc.username=test01
jdbc.password=test01

10.4web.xml

找到maven项目中webapp下WEB-INF的web.xml配置JSP文件修改为:3.1

<!-- 修改web.xml由2.3至3.0 -->
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
  <display-name>Archetype Created Web Application</display-name>
</web-app>

11.MyBatis的CRUD

11.1编写业务逻辑层

接口类

package com.liao.biz;
 
import com.liao.model.Book;
 

public interface BookBiz {
    int deleteByPrimaryKey(Integer bid);
 
    int insert(Book record);
 
    int insertSelective(Book record);
 
    Book selectByPrimaryKey(Integer bid);
 
    int updateByPrimaryKeySelective(Book record);
 
    int updateByPrimaryKey(Book record);
}

实现接口

package com.liao.biz.impl;
 
import com.liao.biz.BookBiz;
import com.liao.mapper.BookMapper;
import com.liao.model.Book;
 

public class BookBizImpl implements BookBiz {
    private BookMapper bookBiz;
 
    public BookMapper getBookBiz() {
        return bookBiz;
    }
 
    public void setBookBiz(BookMapper bookBiz) {
        this.bookBiz = bookBiz;
    }
 
    @Override
    public int deleteByPrimaryKey(Integer bid) {
        return bookBiz.deleteByPrimaryKey(bid);
    }
 
    @Override
    public int insert(Book record) {
        return bookBiz.insert(record);
    }
 
    @Override
    public int insertSelective(Book record) {
        return bookBiz.insertSelective(record);
    }
 
    @Override
    public Book selectByPrimaryKey(Integer bid) {
        return bookBiz.selectByPrimaryKey(bid);
    }
 
    @Override
    public int updateByPrimaryKeySelective(Book record) {
        return bookBiz.updateByPrimaryKeySelective(record);
    }
 
    @Override
    public int updateByPrimaryKey(Book record) {
        return bookBiz.updateByPrimaryKey(record);
    }
}

11.2SqlSession工厂类


package com.liao.utils;
 
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 
public class SessionUtil {
    private static SqlSessionFactory sessionFactory;
    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
    static {
        sessionFactory = new SqlSessionFactoryBuilder().build(SessionUtil.class.getResourceAsStream("/mybatis.cfg.xml"));
    }
 
    public static SqlSession openSession() {
        SqlSession session = threadLocal.get();
        if (null == session) {
            session = sessionFactory.openSession();
            threadLocal.set(session);
        }
        return session;
    }
 
    public static void main(String[] args) {
        SqlSession session = openSession();
        System.out.println(session.getConnection());
        session.close();
//        System.out.println(session.getConnection());
    }
}

11.3.测试类

package com.liao.demo;
 
import com.liao.biz.BookBiz;
import com.liao.biz.impl.BookBizImpl;
import com.liao.mapper.BookMapper;
import com.liao.model.Book;
import com.liao.utils.SessionUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class Demo {
    private SqlSession sqlSession;
    private BookBiz bookBiz;
    @Before
    public void a(){
        System.out.println("执行测试方法之前会执行的初始化代码块");
        sqlSession= SessionUtil.openSession();
        BookBizImpl bookBiz = new BookBizImpl();
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
    bookBiz.setBookBiz(mapper);
    this.bookBiz=bookBiz;
    }
    @After
    public void b(){
        System.out.println("执行测试方法之后会执行");
    }
 
    @Test
    public void test1(){
        Book book = bookBiz.selectByPrimaryKey(35);
        System.out.println(book);
    }
    @Test
    public void test2(){
        int i = bookBiz.deleteByPrimaryKey(35);
        if (i>0){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }
 
    }
}

简单测试查询和删除，其他的就不测试了