Spring整合Mybatis

孤寂的雪

已于 2022-02-19 16:18:57 修改

阅读量183

点赞数

分类专栏：学习心得文章标签： spring java maven

于 2022-02-19 16:18:53 首次发布

本文链接：https://blog.csdn.net/qq_45181103/article/details/123016147

版权

学习心得专栏收录该内容

13 篇文章 1 订阅

订阅专栏

一介绍

我也是刚刚学习，菜鸟一枚，有写得不对的地方请多多指正。

1.1 Mybatis

简单的说，其就是一个半自动的ORM框架。用来简化dao层代码的开发框架。

一套流程下来总结就是：

1 添加依赖（后面截图说明）

2 配置mybatis文件（里面比如可以配置数据库的数据源，别名，添加dao层的映射文件到这里等等）

3 配置dao层的映射文件并绑定到mybatis主配置文件中。

1.2 Spring

相信大家包括初学者都或多或少听说过Spring全家桶的大名（比如Spring boot，Spring Clound等等）

那我现在就是学的是最基本的Spring，那Spring究竟是什么东西呢？

一句话说明：Spring是一个轻量级的控制反转和面向切面的容器框架

记住：Spring的2大核心思想：IoC，AOP

轻量级：体积小，对项目代码没有侵入性
控制反转：IoC（Inverse of Control），把创建对象、给对象属性赋值的工作交由Spring完成；Spring在通过反射创建对象的同时可以给属性赋值（DI:依赖注入）
面向切面：AOP（Aspect Oriented Programming）面向切面编程，可以在不改变原有业务代码的前提下进行业务的增强（原理：动态代理）
容器：实例对象，Spring不仅可以创建对象，还可以对创建的对象进行管理。

1.2.1 控制反转怎么理解呢？

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

　　IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

　　理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

　　●谁依赖于谁：当然是应用程序依赖于IoC容器；

　　●为什么需要依赖：**应用程序需要IoC容器来提供对象需要的外部资源**；

　　●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

**　　●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）**。

　　IoC和DI由什么关系呢？其实它们是同一个概念的不同角度描述“依赖注入”，相对IoC 而言，“**依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。**

IoC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。

Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的

所以控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。

那我的理解就是以前我找父母要钱，我想要多少钱直接找父母要，父母一定是要给的（哈哈，可惜我没有这样的爸妈），但是现在父母不想直接给我钱了，而是把钱交给学校，你需要多少钱，核实情况后就给你多少钱，不会多给一分，而父母也轻松了

1.2.2 面向切面

我们从面向过程到面向对象，再到面向切面，

那面向切面又是什么呢？

面向切面编程（Aspect Oriented Programming，简称AOP）通过提供另一种程序结构的思考方式来补充面向对象的编程（Object Oriented Programming，OOP）”——Spring官方文档。面向切面编 AOP程是OOP后，又一种重要的编程思维方式。

OOP对业务中每一个功能进行抽取、封装成类、方法，让代码更加模块化，在一定程度上实现了代码的复用。此时，一个完整的业务通过一定顺序的调用对象的方法模块的来实现。如果脱离对象层面，基于业务逻辑的站在更高层面来看这种编程方式，带来的缺点是对于业务中的重复的代码模块，需要在源代码中，在业务的不同阶段重复调用。而AOP则可以对业务中重复调用的模块进行抽取，让业务中的核心逻辑与非核心逻辑进一步解耦，源代码中不需要手动调用这个重复代码的模块，在更高的层实现了代码的复用，有利于后续代码的维护升级。AOP的层次更高，AOP和OOP不是竞争关系，AOP是对OOP的补充！

AOP (Aspect Oriented Programming)面向切面编程，是一种利用“横切”的技术（底层实现就是动态代理），对原有的业务进行拦截，并且可以在拦截的横切面上添加特定的业务逻辑，从而实现对原有业务的增强。

面向切面编程：创建切面类，将新增的业务方法定义在切页面类中，通过配置定义新增业务方法插入到原有业务的哪个位置

二整合

2.1 前言

Spring 对mybatis提供的支持有

IoC支持：SpringIoC可以为MyBatis完成DataSource、SqlSessionFactory、SqlSession以及DAO对象的创建
AOP支持：使用Spring提供的事务管理类，基于AOP完成对MyBatis数据库操作的事务管理

2.2 创建一个mvan工程

后面一直点next到finish就行了

2.3 在pom.xml中导入依赖

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- spring-test -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.3.15</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.15</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.3.15</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.6</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.26</version>
    </dependency>

    <!-- MyBatis框架依赖  -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

    <!-- lombok依赖  -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
      <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>
    <!-- log4j -->
<!--    <dependency>-->
<!--      <groupId>log4j</groupId>-->
<!--      <artifactId>log4j</artifactId>-->
<!--      <version>1.2.17</version>-->
<!--    </dependency>-->


    <!-- druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.8</version>
    </dependency>

部署mybatis框架需要mysql和mybatis

部署spring框架需要context和aspects

整合需要spring和jdbc

spring单元测试需要junit和spring-test

再加个连接池依赖：druid是目前性能最好之一

2.4 配置文件

里面暂时不用配置任何东西

2.5 配置数据源

2.6 Spring整合MyBatis的IoC配置—SqlSessionFactory

开启spring工厂扫描

2.7 Spring整合MyBatis的IoC配置—MapperScannerConfigurer

2.8 Spring整合MyBatis的AOP配置—事务管理

同时开启注解支持

2.9 配置源代码奉上（个人建议不会的可以敲一遍）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd
     http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--         声明Spring工厂注解配置的扫描范围-->
    <context:component-scan base-package="com.qf " annotation-config="true"/>
    <!--    声明使用注解配置-->
    <context:annotation-config/>
    <!--  AOP  开启注解支持配置-->
    <aop:aspectj-autoproxy/>

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


    <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}" />
        <property name="initialSize" value="${druid.pool.init}"/>
        <property name="maxActive" value="${druid.pool.maxActive}"/>
        <property name="minIdle" value="${druid.pool.minIdle}"/>
        <property name="maxWait" value="${druid.pool.timeout}"/>
    </bean>

<!--    通过Spring容器创建MyBatis的sqlsessionFactoty对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 加载mybatis的配置文件 -->
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <property name="dataSource" ref="dataSource"/>
         <!--映射文件-->
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"></property>
         <!--配置实体类的包名，进行别名定义-->
        <property name="typeAliasesPackage" value="com.qf.entity"></property>
    </bean>
    <!-- 配置mapper扫描器 -->
    <!--MapperScannerConfigurer 作用：扫描指定包中的DAO/Mapper接口，通过factory对象获取SqlSession
        然后创建所有DAO对象存放到Spring容器，DAO接口对象的ID默认是接口名首字母小写 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定扫描的包名 -->
        <property name="basePackage" value="com.qf.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    </bean>

    <!-- 事物管理-->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 	数据源 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    开启注解配置事务管理-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    <!-- 通知
    配置事务管理策略（引入tx命名空间）
    isolation:配置事务的隔离级别
    propagation：配置事务的传播机制-->
  <!--  <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="get*" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>
&lt;!&ndash;    aop配置&ndash;&gt;
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.qf..*(..))"/>
    </aop:config>-->

</beans>

2.10 测试

三补充

@Transcational 默认情况下，只有方法出现的是RuntimeException或Error以及它们的子类时（未检查异常），才会导致事务回滚如果要改变默认情况
@Transactional(rollbackFor=异常类.class)
那么方法如果出现了该异常，或该异常的子类异常时，就会回滚 @Transactional(noRollbackFor=异常类.class)
当遇到这种异常时，不会回滚事务
***注意***：在业务方法中不要自己try-catch捕获异常，否则spring无法自动回滚事务
@Transactional(readOnly = true|false) ：true表示只读（只有查询） false（会有增删改）
设置为true，性能会有所提升，但是底层数据库驱动支持(对mysql支持)
事务超时设置:
@Transactional(timeout=30) //默认是30秒
事务的传播行为： @Transcational (propagation=传播行为) 只有两个业务类的方法相互调用时，传播行为才会有效
ProductService 商品业务类
@Transactional(propagation=REQUIRED)
biz1() { // 事务1
biz2()；
}
OrderService 订单业务类
@Transactional(propagation=REQUIRES_NEW)
biz2(); // 事务2
事务传播行为   说明
@Transactional(propagation=Propagation.REQUIRED)   如果有事务，那么加入事务，没有的话新建一个(默认情况)
@Transactional(propagation=Propagation.NOT_SUPPORTED)   容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW)   不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY)   必须在一个已有的事务中执行，否则抛出异常
@Transactional(propagation=Propagation.NEVER)   必须在一个没有的事务中执行，否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS)   如果其他bean调用这个方法，在其他bean中声明事务，那就用事务。如果其他bean没有声明事务，那就不用事务
事务隔离级别： @Transcational( isolation = " 事务的隔离级别 ")
事务隔离级别