Spring和Mybatis的整合

已于 2023-12-17 23:00:37 修改
阅读量3k 收藏 28
点赞数 5
文章标签： mybatis spring java
于 2022-11-03 15:26:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beautifulsen/article/details/127527060
版权

持久层整合

第一章、为什么
1.Spring为什么要与持久层整合
1. JavaEE开发，需要持久层，来访问操作数据库。
2. JDBC Hibernate MyBatis等，进行持久开发过程，存在大量的代码冗余
3. Spring，基于模板设计模式，对于上述的持久层技术，进行了封装
2. Spring可以与那些持久层整合
1. JDBC
     |- Spring提供了JdbcTemplate 
2. Hibernate (JPA)
     |-  Spring提供了HibernateTemplate
3. MyBatis
     |-  Spring提供了SqlSessionFactoryBean，MapperScannerConfigure
第二章、Spring与MyBatis整合
1. 原生MyBatis开发步骤（7步走）

首先需要配置开发环境，引入相关的两个依赖
在这里插入图片描述
其次，需要引入框架对应的配置文件，mybatis-config.xml和映射文件XXXMapper.xml
在这里插入图片描述
配置完成之后，就可以按七步编程来开发了。

  1. 实体User，创建实体类，构造，getset
    实体
  1. 实体别名，在mybatis-config.xml中，为User添加别名，这样在Mapper映射文件中，我们就可以不用写实体的全限定名，用别名就行了。
    在这里插入图片描述
  1. 表，需要在数据库中创建user表，表中应有与实体属性对应的字段
    在这里插入图片描述
  1. 创建DAO接口，UserDao，save方法用于一个对象的保存
    在这里插入图片描述
  1. 实现Mapper文件，UserMapper.xml对UserDao进行相关的实现
    在这里插入图片描述
  1. 注册Mapper文件，在mybatis-config.xml中进行注册，因为此时UserMapper在resources根下面，所以可以直接这样写
    在这里插入图片描述
  1. MybatisAPI调用
    在这里插入图片描述
2. Mybatis在开发过程中存在问题
上面的七步，虽然不是很难，但是很烦，配置繁琐，代码冗余 

1. 实体
2. 实体别名---》配置繁琐，每个实体都需要写一次别名
3. 表
4. 创建DAO接口
5. 实现Mapper文件
6. 注册Mapper文件---》配置繁琐，每一个mapper文件都要做一次注册映射 
7. MybatisAPI调用---》代码冗余，创建sqlsession的代码是固定的，
				得到Dao的实现也是冗余的，每个Dao都要调一次

所以Spring在整合Mybatis的过程中，就把这三步配置繁琐和代码冗余的问题解决了，这样就简化了mybatis的开发。

3. Spring与Mybatis整合思路分析

Spring主要对以下四行代码进行了封装
在这里插入图片描述

SqlSessionFactoryBean

Spring首先创建了SqlSessionFactoryBean这个类，用来封装前两行代码，用来创建sqlSessionFactory对象。

按照spring的写法，即在applicationContext.xml中对SqlSessionFactoryBean进行声明配置。

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

这里注意个细节，在原生mybatis开发中，创建sqlSessionFactory对象是需要mybatis-config.xml的，我们回顾，该配置文件中主要书写了三部分信息：

mybatis-config.xml
1.dataSource 记载数据库的连接信息
2.typeAliases 配置实体别名
3.mapper映射文件的注册

同理，使用SqlSessionFactoryBean来创建sqlSessionFactory对象，也需要这部分信息，需要这些，即依赖这些，就可以通过注入属性的方式得到这些信息。我们采用set注入的方式。

上面的三部分信息对应着SqlSessionFactoryBean的三个属性
1.dataSource–》指向数据库连接的配置
2.typeAliasesPackage–》指向实体类的包，可为该包下的所有类创建和类名相同的别名
3.mapperLocations–》值为通配符表达式，对所有匹配上的Mapper文件进行注册

此时mybatis-config.xml中的所有信息都通过注入的方式写到spring的配置文件中去了，所以mybatis-config.xml就可以不用了。

MapperScannerConfigurer

spring提供MapperScannerConfigurer类来封装第二部分代码，用于生成userDao对象。
在原生开发步骤中，我们需要是用sqlSessionFactory对象来获得sqlSession对象，再指定XXXDao的class，进而获得对应的dao对象。
在spring的封装下，我们只需要在配置文件中对MapperScannerConfigurer进行配置，

sqlSessionFactoryBeanName-》sqlSessionFactory对象需要被注入
basePackage-》指定DAO接口所在的包

4. Spring与Mybatis整合编码

  • 搭建开发环境(pom依赖)
    在这里插入图片描述

  • Spring配置文件的配置
    在这里插入图片描述

  • 编码

    1. 实体
2. 表
3. DAO接口
4. Mapper文件配置
这四步和上面一样

  • 测试
    在这里插入图片描述

5. Spring与Mybatis整合细节

  • 问题：Spring与Mybatis整合后，为什么DAO不提交事务，但是数据能够插入数据库中？
    这个问题的核心是连接对象Connection，因为他控制了事务；
    谁控制了连接对象，就变相控制了事务tx；
    是spring控制了连接对象吗？
    在这里插入图片描述
    在刚才测试的启动日志中，表明了connection对象没有被spring管理
    是mybatis控制了？

    实际上上控制连接对象(Connection)的是连接池(DataSource)

    1. 在原生开发中，使用的Mybatis提供的连接池对象—>创建Connection
      他在创建连接对象时，Connection.setAutoCommit(false) 设置手工控制事务，所以操作完成后，需要手工提交；
    2. 在sp整合mb后，引入Druid（C3P0 DBCP）作为连接池 —> 创建Connection
      Connection.setAutoCommit(true) true是默认值，保持自动控制事务，一条sql 自动提交

    答案：因为Spring与Mybatis整合时，引入了外部连接池对象，保持自动的事务提交这个机制(Connection.setAutoCommit(true)),不需要手工进行事务的操作，也能进行事务的提交

    注意：实战中，还会手工控制事务(多条sql一起成功，一起失败)，不会使用自动提交，后续Spring通过事务控制解决这个问题。

第三章、Spring的事务处理
1. 什么是事务？
概念：保证业务操作完整性（一个业务中的多个操作，一起成功或一起失败，且不会产生相互嗯影响）的一种数据库机制（是数据库来实现的，我们只是通过java代码来调用这种机制）

事务的4特点： A C I D
1. A 原子性
2. C 一致性
3. I 隔离性
4. D 持久性
2. 如何控制事务

不同的持久化方式对事务的控制不同，但都是三个操作，开启，提交，回滚

JDBC: 核心是依附连接对象connection
    Connection.setAutoCommit(false);
    Connection.commit();
    Connection.rollback();
Mybatis：sqlSession其实也封装了connection
    Mybatis自动开启事务
    sqlSession(Connection).commit();
    sqlSession(Connection).rollback();

结论：控制事务的底层 都是Connection对象完成的。
3.Spring如何控制事务
tx是业务层中的额外功能，
Spring是通过AOP的方式进行事务开发
1. 原始对象

即一个个的业务类

public class XXXUserServiceImpl{
   private xxxDAO xxxDAO
   set get
	注意细节：
   1. 原始对象的原始方法，是做核心功能 (即业务处理+DAO调用)
   2. 需要DAO，即依赖DAO，将DAO作为Service的成员变量，依赖注入的方式进行赋值
}
2. 额外功能
方式1. MethodInterceptor
   public Object invoke(MethodInvocation invocation){
      try{
        Connection.setAutoCommit(false);
        Object ret = invocation.proceed();
        Connection.commit();
      }catch(Exception e){
        Connection.rollback();
      }
        return ret;
   }
方式2. @Aspect
   @Around 加在书写额外功能的方法上

这种代码你写我写都一样，那spring也封装好了
所以spring提供了org.springframework.jdbc.datasource.DataSourceTransactionManager类，来控制事务，封装上面的代码；
注意细节：
控制事务是需要Connection对象的，连接来自于连接池，
所以需要注入DataSource
3. 切入点
@Transactional 
指定事务的额外功能加入给哪些业务方法。

该注解加入的位置：
1. 类上：类中所有的方法都会加入事务
2. 方法上：这个方法会加入事务
4 组装切面
1. 切入点
2. 额外功能
通过配置文件中的，一个标签来完成
<tx:annotation-driven transaction-manager=""/>
 transaction-manager获取额外功能，切入点自动去扫描@Transactional注解
4. Spring控制事务的编码

  • 搭建开发环境 (jar)

    <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.1.14.RELEASE</version>
</dependency>

  • 编码

1.原始对象
创建接口在这里插入图片描述
创建实现类
需要对dao接口调用，所以依赖dao，但此时dao是空的，还需要在配置文件中进行属性注入
在这里插入图片描述
配置原始对象，注入dao
此时可能回想，注入的dao哪里来的？我们没有对dao进行bean的配置啊？
我们回想，sp在和mb整合时，sp提供了两个类，一个用来创建connection对象，一个去实现dao接口生成对象（通过指定dao所在的包，动态生成类名首字母小写的dao对象），
所以此时，我们只需要指定dao接口的类名首字母小写即可注入对应的dao对象。
在这里插入图片描述

2.额外功能
额外功能-即事务，交给sp的DataSourceTransactionManager来管理了，注意需要注入连接池dataSource
在这里插入图片描述

3.切入点
我们只需要在业务类（或指定业务方法）上加上@Transactional注解即可

4.组装切面
通过该标签来组装切面，注意引入的命名空间应该是tx结尾的在这里插入图片描述
事务功能，在dataSourceTransactionManager管理，切入点，sp会去扫描@Transactional注解，即可组装好切面。
在这里插入图片描述

启动测试即可
在这里插入图片描述

  • 如何判断此时确实使用了sp的事务呢？
    1.可以通过控制台日志打印来体现
    2.也可以在业务方法中手动抛出异常，sp事务即会捕获，回滚事务。

  • 细节

    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>
 proxy-target-class进行动态代理底层实现的切换   
 默认是false，使用JDK动态代理
 改为true，则使用Cglib
第四章、 Spring中的事务属性(Transaction Attribute)
1. 什么是事务属性
属性：即描述物体特征的一系列值
     性别 身高 体重 ...
事务属性：描述事务特征的一系列值 
1. 隔离属性
2. 传播属性
3. 只读属性
4. 超时属性
5. 异常属性
2. 如何添加事务属性
@Transactional(isloation=,propagation=,readOnly=,timeout=,rollbackFor=,noRollbackFor=,)
3. 事务属性详解
1. 隔离属性 (ISOLATION)

  • 隔离属性的概念

    概念：他描述了事务解决并发问题的特征
1. 什么是并发
       多个事务(用户)在同一时间，访问操作了相同的数据
       同一时间：0.000几秒 微小前 微小后
2. 并发会产生那些问题
       1. 脏读
       2. 不可重复读
       3. 幻影读
3. 并发问题如何解决
       通过隔离属性解决，隔离属性中设置不同的值，解决并发处理过程中的问题。

  • 事务并发产生的问题

    • 脏读

      一个事务，读取了另一个事务中没有提交的数据。会在本事务中产生数据不一致的问题
解决方案，事务的隔离级别设为，读已提交
@Transactional(isolation=Isolation.READ_COMMITTED)

    • 不可重复读

      一个事务中，多次读取相同的数据，但是读取结果不一样。会在本事务中产生数据不一致的问题
注意：1 不是脏读 2 一个事务中
解决方案：隔离级别设为可重复读 
@Transactional(isolation=Isolation.REPEATABLE_READ)
本质： 一把行锁

    • 幻影读

      比如tx1对整表进行统计，tx2在此时插入了一条，tx1再次统计的时候，产生了幻影读。（可重复读只是加了行锁，不能对已有数据修改，但tx2是可以插入数据的）

      一个事务中，多次对整表进行查询统计，但是结果不一样，会在本事务中产生数据不一致的问题
解决方案：隔离级别，串行化
@Transactional(isolation=Isolation.SERIALIZABLE)
本质：表锁

    • 总结

      并发安全： SERIALIZABLE>REPEATABLE_READ>READ_COMMITTED
运行效率： READ_COMMITTED>REPEATABLE_READ>SERIALIZABLE

  • 数据库对于隔离属性的支持

    隔离属性的值MySQLOracle
    ISOLATION_READ_COMMITTED✅✅
    IOSLATION_REPEATABLE_READ✅❎
    ISOLATION_SERIALIZABLE✅✅
    Oracle不支持REPEATABLE_READ值 如何解决不可重复读？
采用的是多版本比对（版本号）的方式，解决不可重复读的问题

  • 默认隔离属性

    ISOLATION_DEFAULT：会调用不同数据库所设置的默认隔离属性

MySQL : REPEATABLE_READ 可重复读
Oracle: READ_COMMITTED  读已提交

    • 查看数据库默认隔离属性

      • MySQL

        select @@tx_isolation;

      • Oracle

        SELECT s.sid, s.serial#,
   CASE BITAND(t.flag, POWER(2, 28))
      WHEN 0 THEN 'READ COMMITTED'
      ELSE 'SERIALIZABLE'
   END AS isolation_level
FROM v$transaction t 
JOIN v$session s ON t.addr = s.taddr
AND s.sid = sys_context('USERENV', 'SID');

  • 隔离属性在实战中的建议

    推荐使用Spring指定的ISOLATION_DEFAULT，即使用默认的即可
 1. MySQL   repeatable_read
 2. Oracle  read_commited 

未来实战中，并发访问情况 很低 

如果真遇到并发问题，用乐观锁；乐观锁是应用锁，不会过多影响系统的效率，隔离属性是物理锁，对效率影响很大。
   Hibernate(JPA)  通过Version，多版本 
   MyBatis         需要我们通过mybatis拦截器自定义，来完成版本的比对，进而完成乐观锁。
2. 传播属性(PROPAGATION)

  • 传播属性的概念

    概念：他描述了事务解决嵌套问题的特征

什么叫做事务的嵌套：他指的是一个大的事务中，包含了若干个小的事务

问题：大事务中融入了很多小的事务，他们彼此影响，最终就会导致外部大的事务，丧失了事务的原子性

  • 传播属性的值及其用法

    传播属性的值外部不存在事务外部存在事务用法备注
    REQUIRED开启新的事务融合到外部事务中@Transactional(propagation = Propagation.REQUIRED)增删改方法
    SUPPORTS不开启事务融合到外部事务中@Transactional(propagation = Propagation.SUPPORTS)查询方法
    REQUIRES_NEW开启新的事务挂起外部事务，创建新的事务@Transactional(propagation = Propagation.REQUIRES_NEW)日志记录方法中
    NOT_SUPPORTED不开启事务挂起外部事务@Transactional(propagation = Propagation.NOT_SUPPORTED)及其不常用
    NEVER不开启事务抛出异常@Transactional(propagation = Propagation.NEVER)及其不常用
    MANDATORY抛出异常融合到外部事务中@Transactional(propagation = Propagation.MANDATORY)及其不常用

  • 默认的传播属性

    REQUIRED是传播属性的默认值

  • 推荐传播属性的使用方式

    增删改 方法：直接使用默认值REQUIRED 
查询   操作：显示指定传播属性的值为SUPPORTS
3. 只读属性(readOnly)
针对于只进行查询操作的业务方法，可以加入只读属性，提供运行效率
默认值：false
4. 超时属性(timeout)
指定了事务等待的最长时间

1. 为什么事务进行等待？
   当前事务访问数据时，有可能访问的数据被别的事务进行加锁的处理，那么此时本事务就必须进行等待。
2. 等待时间单位 秒
3. 如何应用？ @Transactional(timeout=2)
4. 超时属性的默认值 -1 
   最终由对应的数据库来决定超时时间
5. 异常属性
Spring事务处理过程中
默认 对于RuntimeException及其子类 采用的是回滚的策略
默认 对于Exception及其子类 采用的是提交的策略

rollbackFor = {java.lang.Exception,xxx,xxx} 
noRollbackFor = {java.lang.RuntimeException,xxx,xx}

@Transactional(rollbackFor = {java.lang.Exception.class},noRollbackFor = {java.lang.RuntimeException.class})

建议：实战中使用RuntimeExceptin及其子类 使用事务异常属性的默认值
4. 事务属性常见配置总结
1. 隔离属性   默认值 
2. 传播属性   Required(默认值) 增删改   Supports 查询操作
3. 只读属性   readOnly false  增删改   true 查询操作
4. 超时属性   默认值 -1
5. 异常属性   默认值 

增删改操作   @Transactional
查询操作     @Transactional(propagation=Propagation.SUPPORTS,readOnly=true)
5. 基于标签的事务配置方式(事务开发的第二种形式)
基于注解 @Transaction的事务配置回顾（四步）
<bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
  <property name="userDAO" ref="userDAO"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>

@Transactional(isolation=,propagation=,...)
public class UserServiceImpl implements UserService {
    private UserDAO userDAO;

<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

基于标签的事务配置（原始动态代理额外功能）
<bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
  <property name="userDAO" ref="userDAO"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>

事务属性 
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
    <tx:attributes>
          <tx:method name="register" isoloation="",propagation=""></tx:method>
          <tx:method name="login" .....></tx:method>
          等效于 
          @Transactional(isolation=,propagation=,)
          public void register(){
        
          }
      
    </tx:attributes>
</tx:advice>

<aop:config>
     <aop:pointcut id="pc" expression="execution(* com.baizhiedu.service.UserServiceImpl.register(..))"></aop:pointcut>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>

  • 基于标签的事务配置在实战中的应用方式

    <bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
  <property name="userDAO" ref="userDAO"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>

编程时候 service中负责进行增删改操作的方法 都以modify开头
                       查询操作 命名无所谓 
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
    <tx:attributes>
          <tx:method name="register"></tx:method>
          <tx:method name="modify*"></tx:method>
          <tx:method name="*" propagation="SUPPORTS"  read-only="true"></tx:method>
    </tx:attributes>
</tx:advice>

应用的过程中，service放置到service包中
<aop:config>
     <aop:pointcut id="pc" expression="execution(* com.baizhiedu.service..*.*(..))"></aop:pointcut>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>

箬雨哒哒
关注
  • 5
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring和mybatis整合小案例
07-25
这是一个小型的项目，关于spring和mybatis整合的小项目，直接可运行，无错误
Spring——Spring整合MyBatis
胜天半子祁同伟
03-13 2万+
Spring——Spring整合MyBatis
spring与mybatis四种整合方法
热门推荐
xqhys的博客
01-03 4万+
一、采用org.mybatis.spring.mapper.MapperScannerConfigurer 整体结构如下图： 1、配置文件 1>applicationContext01.xml <beansxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://www.springframework
史上最详细mybatis与spring整合教程
tianshouzhi的专栏
04-12 5051
点击上方"田守枝的技术博客"，关注我mybatis本身使用比较灵活，和spring整合也有多种方式。本文一网打尽mybatis与spring整合所有方式，让你彻底掌握my...
了解Spring整合mybatis，这一篇就够了
WuHuaSen的博客
04-19 5217
目录 一、引言： 1.1、Spring的两大核心思想： 1.2 、Spring可以对mybatis提供哪些支持？ 二、Spring整合mybatis准备工作： 2.1 创建maven工程 2.2 部署mybatis、Spring、整合依赖等框架 三、配置数据源（Druid连接池） 3.1 添加Druid依赖 3.2 创建Druid.properties属性文件 3.3 在ApplicationContext.xml配置数据源 四：配置sqlsessionFactory 五、配置Map
【MyBatis】spring整合mybatis教程（详细易懂）
无法自律的人的博客
08-25 4198
Spring提供了一种轻量级的容器和依赖注入的机制，可以简化应用程序的配置和管理。会初始化N个数据库链接对象，一般在10个，当需要用户请求操作数据库时候，那么就会直接在数据库连接池中获取链接，用完放回连接池中。我们的实体类创建属性的时候我写get、set等方法，过于麻烦，但是我们有一个lombok，可以节约掉这些。这里是自己本地路径的MySQL的jar包，是需要更改的，路径赋值后也需要再加上。把我们的生成的BookMapper里面的方法复制到我们新建的BookBiz里面。选中对应的项目，依次选中生成。
Spring整合Mybatis全过程解析
qq3164069700的博客
12-08 1757
MyBatis 是一款常用的持久层框架，使得程序能够以调用方法的方式执行某个指定的SQL，将执行SQL的底层逻辑进行封装。多数与Spring结合使用，本文讨论Spring如何整合Mybatis，首先看下Mybatis运行机制 1. Mybatis运行机制 1.1 Mybatis功能架构设计 Mybatis的功能架构分为三层： (1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。 (2)数据处理层：负责
Spring+Mybatis的整合
weixin_65824274的博客
04-06 1707
所以，该整合，只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合。实现 Spring 与 MyBatis 的整合常用的方式：扫描的 Mapper 动态代理 Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。使用mybatis，需要创建mybatis框架中的某些对象，使用这些对象，就可以使用mybatis提供的功能了。在基础的 MyBatis 中，通过。
Spring整合MyBatis
拾一二的博客
03-07 2476
本文详细的通过Maven及Spring整合MyBatis的等技术完成一个简单删除、查询、编辑、新增功能，通过spring管理SqlSessionFactory、mapper接口。
Spring 整合 MyBatis
qq_55917018的博客
09-27 921
前文介绍了Spring最基本的功能，Spring是一个DI（依赖注入）容器和AOP（面向切面）容器，但这仅仅是手段，远不是目标，Spring的目标是整合与简化其他Java框架的开发，通过DI管理其他框架和组件，利用AOP分离繁复部分，使得复杂问题透明化。下图罗列了Spring框架的部分功能，不难看出，Spring感觉就像北冥神功：海纳百川，皆为我用。
Spring和mybatis整合
最新发布
08-26
Spring和mybatis整合
spring和mybatis整合.zip
09-20
spring和mybatis整合.zip
浅析Spring和MyBatis整合及逆向工程
09-02
主要介绍了Spring和MyBatis整合及逆向工程的相关资料,非常不错，具有参考借鉴价值,需要的朋友可以参考下
spring整合Mybatis
10-24
spring整合Mybatis纯净项目，基础搭建，下载就用，包含整套源码，jar包
spring_mybatis 整合jar包
04-25
spring_mybatis 整合jar包，基本常用jar包的整合，。。。。。。。。。。。。。。。
spring和mybatis整合配置
11-19
完整的所有配置文件，不会配置的童鞋可以下载了
spring和Mybatis整合jar包
12-09
spring和Mybatis整合jar包，各个jar包的分类已经做好了。
spring和mybatis整合代码
01-18
spring4.1.7和mybatis3.4.0进行整合的示例代码
spring和mybatis整合 jar包
05-20
spring和mybatis整合 jar包 spring和mybatis整合 jar包
spring和mybatis整合
05-17
Spring 和 MyBatis 可以很容易地整合在一起。MyBatis 是一个持久层框架，它可以帮助您与数据库进行交互。通过将 MyBatis 与 Spring 集成，您可以在 Spring 中使用 MyBatis 的功能，并利用 Spring 的强大特性，如事务管理和依赖注入。 整合的具体步骤如下： 1. 在项目中引入 MyBatis 和 Spring 的相关依赖。 2. 配置 MyBatis 的 SqlSessionFactory 和 SqlSessionTemplate。 3. 配置数据源。 4. 配置 DAO 层，并使用 MyBatis 的映射文件。 5. 在 Service 层使用 DAO 层的实现。 6. 配置 Spring 的事务管理器。 7. 在 Controller 层调用 Service 层。 这样，您就可以使用 Spring 和 MyBatis 整合的应用程序了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值