推荐学java——Spring集成MyBatis

推荐学java
• 阅读 1096

前情回顾

到本文，我们已经学习了 SSM 框架中的 MyBatis 和 Spring 两大核心内容，本文介绍如何将两者结合起来在项目中使用，这也是实际开发中常用的操作，必须掌握，下面开始撸码~

集成步骤

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

数据库各位跟随自己爱好建就行，数据表我这里是 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 相关了，可能细心的同学已经有疑惑了，我们的数据源去哪了，也就是连接数据库的配置去哪了？能想到这一点，说明我们对学过的内容记忆的很好，其实，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);
}

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

推荐学java——Spring集成MyBatis

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

/**
 * 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);
}

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

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

推荐学java——Spring集成MyBatis

总结

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

学编程，推荐首选Java语言，小编创建了一个专注Java的原创公众号推荐学java，各位可以在微信搜索javaFirst 关注，一起开启Java旅途！

推荐学java——Spring集成MyBatis

Java
点赞
收藏
评论区
推荐文章
推荐学java 推荐学java
•
2年前
推荐学java——Spring事务
前情回顾已经学习了和知识，在中我们还将Spring和MyBatis结合起来使用，熟悉开发模式。这节学习Spring中的事务，同样是重要内容。事务概念其实和我们前面学习MySql时，了解到的事务是同一概念，指的是一组或多条SQL语句的执行结果要么全部成功，要么全部失败，不会有其他结果，这就叫事务。事务的出现也是为了很好的解决现实生活中的问题。
1230
0
0
推荐学java 推荐学java
•
2年前
推荐学Java——应该了解的前端内容
导读本文是推荐学Java系列第四篇，通过前三篇内容已经搞定了JavaSE的内容，接下来是真正进入Java后端开发的视界。先来了解基本学习路线，可能你会有这样的疑问：前端的内容到底该不该学？Java开发需不需要会前端？下面就来一一剖析。Java正则表达式在开始之前，先带大家学习一下Java中的正则表达式，这块内容既可以放到Java基础部分学习，也可以放
1094
0
0
推荐学java 推荐学java
•
2年前
推荐学Java——数据表操作
本文首发在公众号推荐学java，这是说明上节内容学习了数据库MySQL的安装、验证、数据库管理工具、数据库的基本操作命令，还没有学习的同学可以从主页去看上一篇推送内容。本节内容就学习有关数据库中表的操作，这其中包括表内和表关联的：创建、列数据类型、数据查询、筛选、删除、添加、修改等等操作，这块内容极为重要，重点不但需要掌握基本的SQL使用规则
1021
0
0
Jacquelyn38 Jacquelyn38
•
2年前
2020年前端实用代码段，为你的工作保驾护航
有空的时候，自己总结了几个代码段，在开发中也经常使用，谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
1985
0
0
Wesley13 Wesley13
•
2年前
mysql字段默认值不生效的问题解决（上）
在项目中使用mybatis做为持久层框架，mysql数据库。项目上线前，DBA要求我们将每张数据库表中的字段都设置默认值和notnull。之前项目中有一些insert语句是将表中所有字段都列出来，然后把它做为一个通用的插入语句来使用。举个简单的例子：假如一张数据库表blog中有如下几个字段：id,title,content,author，除id外，每个字段
878
0
0
Stella981 Stella981
•
2年前
IOS数据存储之NSUserDefaults
概述数据存储是开发中必不可少的一个功能，我们可以通过Sqlite数据库手动创建数据库，定义数据表；可以使用IOS的数据框架CoreData，更方便的操作数据库；也可以直接读写文件系统；这里将介绍另外一种常用的方法：使用NSUserDefaults类，以字典形式保存数据，IOS会自动把字典中的键值对转换成对应的XML文件（也就是plist文件），这
533
0
0
Stella981 Stella981
•
2年前
Django中Admin中的一些参数配置
设置在列表中显示的字段，id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
849
0
0
Stella981 Stella981
•
2年前
RoadFlow ASP.NET Core工作流快速入门
RoadFlow新建一个流程分为以下几步：1、建表   在数据库建一张自己的业务表（根据你自己的业务需要确定表字段，如请假流程就有，请假人、请假时间、请假天数等字段），数据表必须要有一个主键，主键类型是(int自增，或者guid(uniqueidentifier)类型)。    !image.png(http://www.r
429
0
0
Stella981 Stella981
•
2年前
PostgreSQL 主键自动增长
建立主键并设置自动增加的办法好好几种，这里记录我测试过的：droptablepro_process;CREATETABLE"public"."pro_process"("id"SERIALprimarykey,//设置主键并自动增长"county_code"varchar(6)COLLATE
307
0
0
稚然 稚然
•
2个月前
基于springboot+SSM框架旅游项目系统的设计与实现(附源码)
//下仔のke：https://yeziit.cn/14675/SSM框架是Spring、SpringMVC和MyBatis的整合，是一种标准的MVC模式，常用于数据源较简单的web项目。SSM框架集成了Spring、MyBatis两个开源框架，其中Spr
99
0
0
推荐学java
推荐学java
Lv1
微信搜索「javaFirst」关注后回复「java教程」获取精品视频教程
文章
14
粉丝
3
获赞
17
热门文章
推荐学java——Spring事务
推荐学Java——数据表高级操作
推荐学java——Spring第一课
推荐学Java——第一个MyBatis程序
推荐学Java——初识数据库