java 开发之 Spring 集成 MyBatis 知识分享

​

集成步骤

第一步：创建数据库、数据表

数据库各位跟随自己爱好建就行，java培训数据表我这里是 programmer，字段有这几个：

• id 主键，varchar(64)、自动增长、不为 null

• name 姓名，varchar(125)

• age 年龄，int

第二步：新建项目，完成基本配置

新建基于 maven 的 Java 项目，完成如下配置：

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>com.javafirst</groupId>

<artifactId>spring-mybatis</artifactId>

<version>1.0-SNAPSHOT</version>

<properties>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

</properties>

<dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.11</version>

</dependency>

<!-- MySQL 驱动-->

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>8.0.25</version>

</dependency>

<!--MyBatis 依赖-->

<dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

<version>3.5.7</version>

</dependency>

<!-- Spring 依赖 -->

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.3.14</version>

</dependency>

<!-- MyBatis 集成 Spring -->

<dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis-spring</artifactId>

<version>1.3.3</version>

</dependency>

<!-- Spring 事务-->

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-tx</artifactId>

<version>5.3.14</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>1.2.6</version>

</dependency>

<!-- 阿里数据库连接池 druid -->

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>druid</artifactId>

<version>1.2.8</version>

</dependency>

</dependencies>

<build>

<resources>

<resource>

<directory>src/main/java</directory>

<includes>

<include>**/*.properties</include>

<include>**/*.xml</include>

</includes>

<filtering>false</filtering>

</resource>

</resources>

</build>

</project>

以上配置基本是固定的，用到什么依赖就在这里配置即可。

第三步：创建实体类

这个和我们之前学习过，就是创建和表中字段对应 Java 实体类对象，代码如下：

package com.javafirst.daomain;

/**

* desc: 数据表 对应的 实体类

* <p>

* author: 推荐学 java

* <p>

* weChat: studyingJava

*/

public class Programmer {

private Integer id;

private String name;

private Integer age;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@Override

public String toString() {

return "Programmer 信息：{" +

"id=" + id +

", name='" + name + '\'' +

", age=" + age +

'}';

}

}

第四步：创建 dao 接口和 mapper 文件

这一步其实还属于 MyBatis 的配置，需要注意的是我这里将接口和对应的 mapper 文件没有放在同一个目录（package）下，这里不同会引起 MyBatis 配置文件中给 JavaBean 对象起别名的配置有区别，看个人习惯，我习惯将 class 和 xml 分开。

ProgrammerDao.java 代码如下：

/**

* desc: MyBatis 对应的 dao 层,操作 SQL 使用

* <p>

* author: 推荐学 java

* <p>

* weChat: studyingJava

*/

public interface ProgrammerDao {

int addProgrammer(Programmer programmer);

List<Programmer> selectAllProgrammer();

}

这个应该不陌生，使我们学习 MyBatis 的时候用到的，这里定义的接口，实际会映射到去执行 Mapper 中的 SQL 语句。

ProgrammerMapper.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.javafirst.dao.ProgrammerDao">

<insert id="addProgrammer">

insert into programmer(`name`,age) values (#{name},#{age})

</insert>

<select id="selectAllProgrammer" resultType="com.javafirst.daomain.Programmer">

select * from programmer

</select>

</mapper>

该类在 resource 目录下的 mapper 文件夹下。

第五步：完成 MyBatis 主配置文件

这个文件的位置在 resource 目录下，名为 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">

<configuration>

<!-- 日志 -->

<settings>

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

</settings>

<typeAliases>

<typeAlias type="com.javafirst.daomain.Programmer" alias="programmerDao"/>

<!-- 要求 dao 接口和 mapper 文件在同一文件夹下 -->

<!-- <package name="com.javafirst.daomain"/>-->

</typeAliases>

<mappers>

<mapper resource="mapper/ProgrammerMapper.xml"/>

</mappers>

</configuration>

第四步中提到的不同之处就在这里的 <typeAliases> 标签里面的内容了，各位看注释或者看往期文章就明白了。

接下来的操作就和 Spring 相关了，可能细心的同学已经有疑惑了，我们的数据源去哪了，也就是连接数据库的配置去哪了？java培训能想到这一点，说明我们对学过的内容记忆的很好，其实，MyBatis 和 Spring 结合使用的时候，数据源是交给 Spring 容器来处理的，相对我们单独使用 MyBatis 更简单轻松了，快往下看：

第六步：创建 Service 接口和实现类

定义 ProgrammerService 接口代码如下：

public interface ProgrammerService {

int insertProgrammer(Programmer programmer);

List<Programmer> queryProgrammers();

}

这步操作其实就是我们学习 Spring 的流程，会动态创建 Java 对象，然后通过相关设置方式来赋值。

实现类代码：

/**

* desc:

* author: 推荐学 java

* <p>

* weChat: studyingJava

*/

public class ProgrammerServiceImpl implements ProgrammerService {

private ProgrammerDao programmerDao;

public void setProgrammerDao(ProgrammerDao programmerDao) {

this.programmerDao = programmerDao;

}

@Override

public int insertProgrammer(Programmer programmer) {

return programmerDao.addProgrammer(programmer);

}

@Override

public List<Programmer> queryProgrammers() {

return programmerDao.selectAllProgrammer();

}

}

这里可以理解为代理对象的作用。

第七步：创建 Spring 的配置文件

这个应该很熟悉了，名为 applicationContext.xml 在 resource 目录下，不同前面我们使用的是，这里的内容有所变化：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

<!-- 使用属性文件 配置数据源中数据库链接信息 -->

<context:property-placeholder location="jdbc.properties"/>

<!-- 声明数据源-->

<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">

<!-- <property name="driver" value="com.mysql.jdbc.Driver"/>-->

<property name="url" value="${jdbc.url}"/>

<property name="username" value="${jdbc.username}"/>

<property name="password" value="${jdbc.password}"/>

</bean>

<!-- 声明 SQLSessionFactoryBean -->

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

<property name="dataSource" ref="myDataSource"/>

<property name="configLocation" value="classpath:mybatis-config.xml"/>

</bean>

<!-- 声明 MapperScannerConfigurer -->

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>

<!--指定包名，包名是 dao 接口所在的包名

MapperScannerConfigurer 会扫描 basePackage 给定包中的所有接口，把每个接口都执行

一次 getMapper()方法，得到每个接口的 dao 对象

创建好的 dao 对象放入到 spring 的容器中

dao 默认对象的名称：是接口名字的首字母小写

-->

<property name="basePackage" value="com.javafirst.dao"/>

<!-- 多个包下有实体,使用,分割 -->

<!-- <property name="basePackage" value="com.javafirst.dao,com.javafirst.dao2"/>-->

</bean>

<!-- 注册自定义 Service -->

<bean id="programmerService" class="com.javafirst.service.impl.ProgrammerServiceImpl">

<property name="programmerDao" ref="programmerDao"/>

</bean>

</beans>

这里其实主要有四小步工作，且这四步基本都是固定模式，我们在理解的基础上把流程记下来就行，后面用就知道为什么这么写了。

为了方便，我这里将数据库相关的配置信息放在了外部文件 jdbc.properties 中，这和我们前面学习 MyBatis 的时候引用外部配置文件是一样的用法，该文件在 resource 目录下，Spring 配置文件中引用就是这里的第一句代码。

jdbc.properties 文件内容如下：

jdbc.url=jdbc:mysql://localhost:3306/spring_demo

jdbc.username=root

jdbc.password=root

下面说这四小步都代表什么意思：

• 声明数据源 ：其实就是和数据库建立链接，这个过程交给了 Spring 容器来管理

• 声明 SQLSessionFactoryBean ：这个工作的意思就是读取 MyBatis 主配置文件，讲声明的 javaBean 对象映射到 SqlSessionFactoryBean 管理器中。

• 声明 MapperScannerConfigurer ：会扫描给定包下的接口对象，将所有接口执行一次 getMapper() 后得到接口的 dao 对象，将这些对象交给 Spring 容器管理。

• 注册自定义 Service ：这是我们自定义的东西，也就是我们自己的业务层。

第八步：测试

到这里其实有两种测试可以进行，一种是测试 Dao 层是否能访问数据库，并进行相关操作，不经过我们的业务层。

@Test

public void test_addProgrammer() {

String config = "applicationContext.xml";

ApplicationContext context = new ClassPathXmlApplicationContext(config);

ProgrammerDao programmerDao = (ProgrammerDao) context.getBean("programmerDao");

Programmer programmer = new Programmer();

programmer.setName("王重阳");

programmer.setAge(102);

programmerDao.addProgrammer(programmer);

}

这一步测试不需要我们前面配置中的自定义 Service 即可进行。需要注意的是 Spring 中添加记录，已经不需要我们手动 commit() 了。

第二种测试，就是我们 Spring 和 MyBatis 集成后的测试，代码如下：

@Test

public void test_addProgrammer_spring() {

String config = "applicationContext.xml";

ApplicationContext context = new ClassPathXmlApplicationContext(config);

ProgrammerService programmerService = (ProgrammerService) context.getBean("programmerService");

Programmer programmer = new Programmer();

programmer.setName("周伯通");

programmer.setAge(112);

int row = programmerService.insertProgrammer(programmer);

System.out.println("插入结果：" + row);

}

结果大家自行验证，看下数据表中这里插入的值：

我们还定义了一个查询功能，测试代码如下：

/**

* Spring 方式 查询记录

*/

@Test

public void test_selectProgrammers_spring() {

String config = "applicationContext.xml";

ApplicationContext context = new ClassPathXmlApplicationContext(config);

ProgrammerService programmerService = (ProgrammerService) context.getBean("programmerService");

List<Programmer> programmers = programmerService.queryProgrammers();

System.out.println("查询结果：" + programmers);

}

结果各位自己验证哈，一般前面流程跑通，到这里不会有问题。

最后，再看下我的项目结构：

总结

本文将前面学习的 MyBatis 和 Spring 结合起来使用，掌握其流程和原理很重要，其实思考一下，结合起来反倒简单多了，可能第一次接触的时候，被各种流程性的东西搞的有点懵，但这并不妨碍我们后面的顺利上手。

文章来源推荐学 java

​