当前位置： 首页 > article >正文

Spring集成Mybatis的实现

article 2024/12/2 15:34:26

实现步骤大纲

  • 第一步：准备数据库表
    • 使用t_act表（账户表）
  • 第二步：IDEA中创建一个模块，并引入依赖
    • spring-context
    • spring-jdbc
    • mysql驱动
    • mybatis
    • mybatis-spring：mybatis提供的与spring框架集成的依赖
    • 德鲁伊连接池
    • junit
  • 第三步：基于三层架构实现，所以提前创建好所有的包
    • com.powernode.bank.mapper
    • com.powernode.bank.service
    • com.powernode.bank.service.impl
    • com.powernode.bank.pojo
  • 第四步：编写pojo
    • Account，属性私有化，提供公开的setter getter和toString。
  • 第五步：编写mapper接口
    • AccountMapper接口，定义方法
  • 第六步：编写mapper配置文件
    • 在配置文件中配置命名空间，以及每一个方法对应的sql。
  • 第七步：编写service接口和service接口实现类
    • AccountService
    • AccountServiceImpl
  • 第八步：编写jdbc.properties配置文件
    • 数据库连接池相关信息
  • 第九步：编写mybatis-config.xml配置文件
    • 该文件可以没有，大部分的配置可以转移到spring配置文件中。
    • 如果遇到mybatis相关的系统级配置，还是需要这个文件。
  • 第十步：编写spring.xml配置文件
    • 组件扫描
    • 引入外部的属性文件
    • 数据源
    • SqlSessionFactoryBean配置
      • 注入mybatis核心配置文件路径
      • 指定别名包
      • 注入数据源
    • Mapper扫描配置器
      • 指定扫描的包
    • 事务管理器DataSourceTransactionManager
      • 注入数据源
    • 启用事务注解
      • 注入事务管理器
  • 第十一步：编写测试程序，并添加事务，进行测试
    Spring集成MyBatis的实现很常见于代码开发平台，它帮助我们更方便地连接数据库和应用。今天我会带你一步步实现Spring集成MyBatis，使用通俗的话说明这个过程。如果你是初学者，也不用担心，我会运用应有的知识来渐渐接近。

一、初始化项目

首先，你需要一个常见的Spring项目。使用Maven创建一个新的Spring Boot或Spring MVC的项目项，我们在pom.xml中添加MyBatis和Spring相关的依赖。


    <!-- 仓库 -->
    <repositories>
        <repository>
            <id>mybatis-repository</id>
            <url>https://repo.mybatis.org/maven2</url>
        </repository>
    </repositories>

    <!-- 依赖 -->
    <dependencies>
        <!-- Spring Context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.12</version>
        </dependency>
        <!-- Spring Beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>6.0.12</version>
        </dependency>
        <!-- Spring Core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>6.0.12</version>
        </dependency>
        <!-- Spring JDBC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>6.0.12</version>
        </dependency>
        <!-- Spring TX -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>6.0.12</version>
        </dependency>
        <!-- MySQL 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <!-- Druid 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.20</version>
        </dependency>
        <!-- Jakarta Annotation -->
        <dependency>
            <groupId>jakarta.annotation</groupId>
            <artifactId>jakarta.annotation-api</artifactId>
            <version>2.1.1</version>
        </dependency>
        <!-- JUnit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.16</version>
        </dependency>
        <!-- MyBatis Spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>3.0.3</version>
        </dependency>
    </dependencies>

通过上述依赖，我们应用了Spring和MyBatis的库，以便连接数据库和实现代码中的DAO层。

二、数据库配置

于是，你就需要一个数据库连接源。通过以下方式配置Spring中的DataSource：

properties文件：

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/testspring
jdbc.username=root
jdbc.password=gege5211314

 <!--数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

此配置中，我们应该动态获取数据库的信息，包括驱动类名（例如MySQL）、连接地址、用户名和密码。

三、引入MyBatis和注册SqlSessionFactory

接下来，我们需要引入MyBatis，并配置一个SqlSessionFactory，这是MyBatis中用来连接数据库的核心。

 <!--SqlSessionFactoryBean-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="configLocation" value="mybatis-config.xml"/>
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.gege.bank.pojo"/>
    </bean>
       <!--Mapper扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.gege.bank.mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
     <!--事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="txManager"/>

这步步的作用是使用Spring的SqlSessionFactoryBean类来创建一个SqlSessionFactory，这样MyBatis就能和Spring连接了。

四、接口和Mapper的配置

Dao层：

package com.gege.bank.pojo;

public class Account {
    private String actno;
    private Double balance;

    @Override
    public String toString() {
        return "Account{" +
                "actno='" + actno + '\'' +
                ", balance=" + balance +
                '}';
    }

    public Account() {
    }

    public Account(String actno, Double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public Double getBalance() {
        return balance;
    }

    public void setBalance(Double balance) {
        this.balance = balance;
    }
}

为了便利调用DAO层，我们使用Mapper来将数据操作分隔开来。最先，你需要一个接口：

public interface AccountService {
    /**
     * 开户
     * @param act
     * @return
     */
    int save(Account act);

    /**
     * 根据账号销户
     * @param actno
     * @return
     */
    int deleteByActno(String actno);

    /**
     * 修改账户
     * @param act
     * @return
     */
    int update(Account act);

    /**
     * 根据账号获取账户
     * @param actno
     * @return
     */
    Account getByActno(String actno);

    /**
     * 获取所有账户
     * @return
     */
    List<Account> getAll();

    /**
     * 转账
     * @param fromActno
     * @param toActno
     * @param money
     */
    void transfer(String fromActno, String toActno, double money);
}

然后，通过一个XML文件来说明实现：
一定要注意，按照下图提示创建这个目录。注意是斜杠不是点儿。在resources目录下新建。并且要和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">
<mapper namespace="com.gege.bank.mapper.AccountMapper">


    <insert id="insert">
        insert into t_act values(#{actno}, #{balance})
    </insert>
    <delete id="deleteByActno">
        delete from t_act where actno = #{actno}
    </delete>
    <update id="update">
        update t_act set balance = #{balance} where actno = #{actno}
    </update>
    <select id="selectByActno" resultType="Account">
        select * from t_act where actno = #{actno}
    </select>
    <select id="selectAll" resultType="Account">
        select * from t_act
    </select>

</mapper>

此配置说明了MyBatis如何查询users表中的数据。中间的#{id}用来替代传入的参数。

五、服务应用

为了使用我们的Mapper，需要完成服务层接口的实现类

package com.gege.bank.service.impl;

import com.gege.bank.mapper.AccountMapper;
import com.gege.bank.pojo.Account;
import com.gege.bank.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Transactional
@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
     //AccountMapper 是一个接口，但 Spring 和 MyBatis 会自动为它生成一个实现类。
    // @Autowired 可以将这个实现类的实例注入到 AccountServiceImpl 中，
    // 从而在这个类中可以直接使用 AccountMapper 提供的方法来操作数据库。
    private AccountMapper accountMapper;

    @Override
    public int save(Account act) {
        return accountMapper.insert(act);
    }

    @Override
    public int deleteByActno(String actno) {
        return accountMapper.deleteByActno(actno);
    }

    @Override
    public int update(Account act) {
        return accountMapper.update(act);
    }

    @Override
    public Account getByActno(String actno) {
        return accountMapper.selectByActno(actno);
    }

    @Override
    public List<Account> getAll() {
        return accountMapper.selectAll();
    }

    @Override
    public void transfer(String fromActno, String toActno, double money) {
        Account fromAct = accountMapper.selectByActno(fromActno);
        if (fromAct.getBalance() < money) {
            throw new RuntimeException("余额不足");
        }
        Account toAct = accountMapper.selectByActno(toActno);
        fromAct.setBalance(fromAct.getBalance() - money);
        toAct.setBalance(toAct.getBalance() + money);
        int count = accountMapper.update(fromAct);
        count += accountMapper.update(toAct);
        // 测试异常
//        String s = null;
//        s.toString();
        if (count != 2) {
            throw new RuntimeException("转账失败");
        }
    }
}
}

这样，你的Spring就能正常调用MyBatis接口来连接数据库。

六、测试最终的结果

最后，使用Spring的单元测试模块来测试你的服务是否正常。举个例子，使用JUnit来测试这个服务接口：

    @Test
    public void testSM(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
        try {
            accountService.transfer("act-001", "act-002", 10000.0);
            System.out.println("转账成功");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("转账失败");
        }
    }

通过测试，我们确保数据库的连接和查询是正确的。

结论

Spring和MyBatis的集成可以帮助你简化数据的调用，实现DAO层的优雅封装，同时使用Spring来进行管理，有效提高你的开发效率。

为什么会有 private AccountMapper accountMapper; 的写法？

这个写法实际上是 Spring 和 MyBatis 整合后的产物。在整合了 Spring 之后，Spring 可以为 MyBatis 的 Mapper 接口自动创建代理实现，并通过依赖注入的方式将这些实现注入到你的服务层类中。这段代码依赖的是 Spring 的 DI（Dependency Injection）机制，而不是 MyBatis 自身的特性。

如何在 Spring + MyBatis 中实现 Mapper 注入
在 Spring 和 MyBatis 整合中，private AccountMapper accountMapper; 的写法是一种很常见的模式。这是因为：
MyBatis 本身的 Mapper 是接口：在 MyBatis 中，Mapper（比如 AccountMapper）通常定义为接口，里面定义了操作数据库的方法。

Spring 创建 Mapper 代理：当 Spring 和 MyBatis 整合时，Spring 会自动扫描并为这些 Mapper 接口生成实现（代理对象）。这个代理对象会根据接口方法的定义和对应的 SQL 配置（XML 或注解），自动完成数据库操作。

Spring 通过 DI 注入 Mapper：通过@Autowired或其他依赖注入方式，Spring 可以将生成的 Mapper 代理对象注入到你的服务类中，这样你可以像使用普通对象一样使用它。 这就是为什么你可以看到这样的写法：

@Autowired
private AccountMapper accountMapper;

如果不使用spring+Mybatis该如何呢？

如果不使用 Spring，你需要手动配置 MyBatis，加载 SqlSessionFactory，并获取 SqlSession 来执行数据库操作。这种方式更接近 MyBatis 原生的使用方法，但缺点是你需要手动处理会话的开启、关闭和事务管理。
详细的开启SqlSessionFactory点击以下链接查看
mybatis的Sqlsession工具类


http://www.kler.cn/a/418631.html

相关文章：

  • 使用OSPF配置不同进程的中小型网络
  • 【RabbitMQ 消息列队测试之：调试技巧】
  • 【接口封装】——11、Qt 的单例模式
  • 【HarmonyOS学习日志（11）】计算机网络之概念，组成和功能
  • 详解高斯消元
  • java之常用类和基础API—String学习一
  • 基于rpcapd与wireshark的远程实时抓包的方法
  • 【CSS in Depth 2 精译_900】附录B：CSS 预处理器简介
  • IAR Embedded Workbench for Arm 使用技巧
  • 【深度学习】【RKNN】【C++】应用程序编程接口化处理详细教程
  • 计算机网络——数据链路层Mac帧详解
  • 良好的并发编程习惯之封闭（Confinement）
  • 缓存的进化历程说说
  • 映射vim键位,基本功能键位表(未更完)
  • 虚拟机docker记录
  • leetcode_2341. 数组能形成多少数对
  • Python 3 教程第22篇（数据结构）
  • 【Python运维】容器管理新手入门：使用Python的docker-py库实现Docker容器管理与监控
  • SOA、分布式、微服务之间的关系和区别？
  • 使用Canal将MySQL数据同步到ES（Linux）
  • node.js中实现MySQL的增量备份
  • 安卓mokey测试学习思路
  • Maya 中创建游戏角色的头发，并将其导出到 Unreal Engine 5
  • 23种设计模式之桥接设计模式
  • Hadoop生态圈框架部署（九）- Hive部署
  • 游戏启动时“msvcr120.dll文件丢失”是什么原因以及解决方案。四种解决办法轻松搞定“msvcr120.dll文件丢失”问题