spring知识点

Spring知识点

1.Spring是什么？

Spring是于2003年兴起的一个轻量级的，IOC和AOP的Java开发框架，它是为了简化企业级应用开发而生。

官网：https://spring.io/

2.Spring优点

轻量级的

Spring框架使用的jar都比较小，一般在1M以下或者几百kb。Spring核心功能所需的jar总共在3M左右。Spring框架运行占用的资源少，运行效率高。

非侵入式

编写一些业务类（我们写的service,servlet,dao）的时候不需要继承spring特定的类，通过配置完成依赖注入后就可以使用，此时，Spring就没有侵入到我们业务类的代码里。

IOC

即 Inversion of Control, 缩写为IOC（控制反转）, 就是由Spring IOC 容器管理管理对象，而非传统实现中由程序代码直接操控，面向接口式编程，使得耦合度（类和类之间的关联关系）更低。

AOP

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付在Spring中，开发人员可以从凡在的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

一站式框架

spring本身也提供了数据访问功能和web功能，以及可以很好的管理其他框架。

3.Spring 体系结构

Core Container(核心容器)：

​ Beans: 管理Beans(Bean工程，创建bean类中的对象)

​ Core: Spring核心，里面有一些最原始的功能。

​ Context: 管理我们创建出来的对象。配置文件。

​ SpEL: 是一种表达式，在配置文件中取一些属性的值。

Data Access(数据库整合):

​ JDBC, ORM, OXM, JMS, Transaction

Web(MVC Web 开发):

​ Web, Servlet, Portlet, Struts

4.Spring 项目的搭建

Maven导入spring核心基础jar

       <!-- spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
                

编写spring的配置文件（Spring.xml）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
    添加自己的配置文件
    -->
    <bean id="user" class="com.ff.spring.bean.User"> 		</bean>
</beans>

创建User实体类。

测试：

 public static void main(String[] args) {
        // 创建spring容器  ClassPathXmlApplicationContext是其中的一个实现类 ApplicationContext 上层接口
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
     
        User user = (User)context.getBean("user"); // 获得对象
        System.out.println(user);

    }

5.IOC(控制反转)

读作“控制反转”（Inversion of Control) ,是一种设计思想。就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。把（创建对象）的控制权反转给（Spring框架，spring容器）。

IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由IOC容器进行管理，不需要我们再去手动通过new的方式去创建对象，有IOC容器直接帮我们组装好，当我们需要使用的时候直接从IOC容器中直接获取就可以了。

正控：若要使用某个对象，需要自己去负责对象的创建。

反控：若要使用某个对象，只需要从Spring容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架。

目的：降低耦合度

底层实现方式：解析xml/扫描注解标签 + 工厂模式 + 反射机制

6.Spring Bean管理

基于xml配置方式

bean 配置需要 spring 管理的类

id 生成的对象名

class 全类名

name 对象别名,可以为多个

scope:

​ singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式.

​ prototype:原型 getBean()的时候都会 new Bean()

​ request:每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext

环境

​ session:同一个 http session 共享一个 Bean, 不同 Session 使用不同的 Bean, 使用环境同上

Xml 配置方式依赖注入【DI：Dependency Injection】

指spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设置给该对象。

实现IOC需要DI做支持

注入方式：

​ set方法注入

​ 构造方法注入

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

    <!--
        在bean标签中配置交给spring管理的类
        id="对象名"
        class="类的地址"
        scope="singleton" 对象生成作用域
              singleton(默认值) 对象只被创建一次，而且是spring容器加载时就创建

        prototype 原型的 （多例）每次使用时，都会创建一个新的对象
    -->

    <!--
    XML配置方式依赖注入 DI
     在Spring框架创建对象时，可以像对象中的属性赋值（注入值）
    -->
    <!--方式1 通过属性的set方法注入-->
    <bean id="phone" name="phone" class="com.ff.spring.bean.Phone">
    </bean>
   <!-- <bean id="user" name="user1,user2" class="com.ff.spring.bean.User" scope="prototype">
        <property name="id" value="1"></property>
        <property name="name" value="admin"></property>
        <property name="phone" ref="phone"></property>&lt;!&ndash; 注入一个关联的对象 &ndash;&gt;
        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>

        <property name="map">
            <map>
                <entry key="key1" value="val1"></entry>
                <entry key="key2" value="val2"></entry>
                <entry key="key3" value="val3"></entry>
            </map>
        </property>

        <property name="set">
           <set>
               <value>val1</value>
               <value>val2</value>
               <value>val3</value>
           </set>
        </property>
        
        <property name="properties">
            <props>
                <prop key="key1">val1</prop>
                <prop key="key2">val2</prop>
                <prop key="key3">val3</prop>
            </props>
        </property>
        
    </bean>-->

    <!-- 方式2：构造方法注入 -->
    <bean id="user" name="user1,user2" class="com.ff.spring.bean.User" scope="prototype">
        <constructor-arg name="id" value="10"></constructor-arg>
        <constructor-arg name="name" value="admin"></constructor-arg>
        <constructor-arg name="phone" ref="phone"></constructor-arg>
    </bean>

</beans>

注解方式实现

注解需要的jar包，注解功能封装在AOP包中，导入Spring aop jar 包即可。

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

开启注解扫描

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- spring开启注解扫描 -->
    <context:component-scan base-package="com.ff.spring"> </context:component-scan>

</beans>

注解创建对象

@Component(value=“user”)------bean层/pojo层

​ 相当于

@Service ------service层

@Repository ------dao层

以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不同的注解标记。

注解方式注入属性

@Autowired

@Autowired 是 Spring 提供的注解,可以写在字段和 setter 方法上。如果写在 字段上，那么就不需要再写 setter 方法。默认情况下它要求依赖对象必须存在， 如果允许 null 值，可以设置它的 required 属性为 false。

byType 自动注入

该注解默认使用按类型自动装配 Bean 的方式。

byName 自动注入

如果我们想使用按照名称（byName）来装配，可以结合@Qualifier 注解一起 使用。

需要在引用属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的

value 属性用于指定要匹配的 Bean 的 id 值。

JDK 注解@Resource 自动注入

Spring 提供了对 jdk 中@Resource 注解的支持。@Resource 注解既可以按名 称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByName 自动注入

byName 注入引用类型属性

@Resource

注解指定其 name 属性，则 name 的值即为按照名称进行匹配 的 Bean 的 id。

注解与XML的对比

**注解优点：**方便、直观、高效（代码少，没有配置文件的书写那么复杂）。

**注解缺点：**以硬编码的方式写入到Java代码中，修改是需要重新编译代码的。

**xml优点：**配置和代码是分离的，在xml中做修改，无需编译代码，只需重启服务器即可将新的配置加载。

**xml缺点：**编写麻烦，效率低，大型项目过于复杂。

7.Spring JDBC

Spring是一个一站式框架：Spring自身也提供了控制层的 SpringMVC 和持久层的Spring JdbcTemplate。

开发步骤：

下载Spring JdbcTemplate的jar包

         <!--MySQL 连接数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <!-- spring-jdbc 包含数据库事务管理 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!-- 阿里数据源 提供数据库连接池的功能 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

导入属性文件

    <!-- 读取属性文件 -->
    <context:property-placeholder location="config.properties"></context:property-placeholder>

config.properties内容如下：

drivername=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mybatis_db?characterEncoding=utf8&serverTimezone=UTC
uname=root
password=root

path=D:/ 

管理数据源对象

spring 管理与数据库链接 (数据源)

 <!-- spring 生成数据库连接管理对象
         DruidDataSource帮助我们获取数据库的连接对象 Connection连接池
         减少频繁创建连接对象，销毁连接对象
    -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${drivername}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${uname}"></property>
        <property name="password" value="${password}"></property>

        <property name="initialSize" value="10"></property>
        <property name="minIdle" value="5"></property>
        <property name="maxActive" value="20"></property>
    </bean>

在配置文件中创建JdbcTemplate

    <!-- spring提供的jdbc支持 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

在类中获得 JdbcTemplate 对象，就可以直接使用。

@Autowired
JdbcTemplate jdbcTemplate;

JdbcTemplate 中常用的方法

execute：无返回值，可执行 ddl，增删改语句

update：执行新增、修改、删除语句；

queryForXXX：执行查询相关语句；

8.AOP概述

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP、OOP在字面上虽然非常相似，但却是面向不同领域的两种设计思想。OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。

而AOP则是针对于业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。

面向切面编程的好处就是：减少重复，专注业务。

注意：面向切面编程只是面向对象编程的一种补充。

核心原理：

使用动态代理的方式在执行方法前后或者出现异常的时候做加入相关的逻辑。

使用案例：

​ 事务处理：开启事务，关闭事务，出现异常后回滚事务

​ 权限判断：在执行方法前，判断是否具有权限

​ 日志：在执行前进行日志处理

AOP的基本概念

连接点（Joinpoint）：类中可以被增强的方法（添加额外的功能），这个方法就被称为连接点

切入点（pointcut）：类中有很多方法可以被增强，但实际中只有add和update被增了，那么add和update方法就被称为切入点（实际实现的连接点）

通知（Advice）：通知是指一个切面在特定的连接点要做的事情（增强的功能）。通知分为方法执行前通知，方法执行后通知，环绕通知等。通知类型：前置通知、后置通知、环绕通知、异常通知、最终通知。

切面（Aspect）：把通知添加到切入点的过程叫切面。

目标（Target）：代理的目标对象（要增强的类）

代理（Proxy）：向目标对象应用通知之后创建的代理对象

springAOP实现

对于AOP这种编程思想，很多框架都进行了实现。spring就是其中之一，可以完成面向切面编程。

然而，AspectJ 也实现了AOP的功能，AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能，且其实现方式更为简洁，使用更为方便，而且还支持注解式开发。所以，Spring又将 AspectJ 的对于AOP的实现也引入到了自己的框架中。

在Spring中使用AOP开发时，一般使用 AspectJ 的实现方式。

AspectJ 是一个优秀面向切面的框架，它扩展了java语言，提供了强大的切面实现。

AspectJ 中常用的通知有五种类型：

前置通知、后置通知、环绕通知、异常通知、最终通知。

下载AOP相关jar

<dependency> 
	<groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId> 
    <version>5.2.2.RELEASE</version>
</dependency>

基于 AspectJ 的xml配置方式实现

    <!--配置装有通知的类-->
    <bean id="common" class="com.ff.spring.common.Common"></bean>

    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="save" expression="execution(* com.ff.spring.dao.UserDao.save(..))"/>
        <!--将切入点和通知关联植入-->
        <aop:aspect ref="common">
            <!--前置通知-->
            <aop:before method="savelog" pointcut-ref="save" ></aop:before>
            <!--后置通知-->
            <aop:after method="savelog" pointcut-ref="save"></aop:after>
            <!--环绕通知-->
            <aop:around method="trans" pointcut-ref="save"></aop:around>
            <!--异常通知-->
            <aop:after-throwing method="exception" pointcut-ref="save" throwing="e"></aop:after-throwing>
            <!--最终通知-->
            <aop:after-returning method="savelog" pointcut-ref="save"></aop:after-returning>
        </aop:aspect>
    </aop:config>

基于注解方式的实现

​ 启动AspectJ支持：

    <!--基于注解方式的实现
        开启自动代理
    -->
    <aop:aspectj-autoproxy />

定义通知：

@Component
@Aspect 
public class AOPDemo { 
    @Before("execution(* com.ff.spring.demo1.dao.UserDao.*(..))") 
    public void before(){ 
        System.out.println("before"); 
    }
    @After("execution(* com.ff.spring.demo1.dao.UserDao.*(..))") 
    public void after(){ 
        System.out.println("after");
    } 
    @Around("execution(* com.ff.spring.demo1.dao.UserDao.*(..))")
	public void around(ProceedingJoinPoint point) throws Throwable { 
        System.out.println("start");
        point.proceed(); 
        System.out.println("end");
    }
    @AfterThrowing(value = "execution(* com.ff.spring.demo1.dao.UserDao.*(..))",throwing = "e") 
    public void afterthrow(Throwable){ 
        System.out.println("afterthrow"); 
    }
    @AfterReturning("execution(* com.ff.spring.demo1.dao.UserDao.*(..))") 
    public void afterreturn(){ 
        System.out.println("afterreturn"); 
    } 
}

9.Spring事务管理

事务可以看做是由对数据库若干操作组成的一个单元。

我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作的结合。由于数据操作在顺利执行的过程中，任何一步操作都有可能发生异常，异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，需要在这种情况下进行回退。

事务4大特性：原子性（要么都成功，要么都失败。）、隔离性（比如A事务正在对账号操作，B事务就不能对账号在操作，两个事务要进行隔离）、持久性（一旦事务提交，我们的数据就定格，不可更改）、一致性（多个事务轮番操作后，要保证我们的数据是没有问题的）。

事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就会退到事务开始未进行操作的状态，这些操作要么都完成，要么都取消，从而保证数据满足一致性的要求。

Spring 中的事务管理分为两种形式，一种是编程式事务，一种是声明式事务。

编程式事务在项目中很少使用，这种方式需要注入一个事务管理对象TransactionTemplate,然后在我们代码中需要提交事务或回滚事务时自己写代码实现。（我们在代码中要手动的进行事务提交，还需在代码添加操作）

声明式事务管理建立在AOP基础上，本质是对方法前后进行拦截，所以声明式事务是方法级别的。（只要声明那个方法需要在事务中执行，那么spring就会为方法添加事务功能。出现异常自动回滚，没有异常提交事务）

Spring声明式事务管理方式有两种：

​ 基于xml配置

​ 基于注解实现

Spring 事务管理 API

PlatformTransactionManager 事务管理器接口

Spring 针对不同的 dao 框架，提供了不同的实现类,Jdbc,mybatis 事物管理实现类是 DataSourceTransactionManager.

配置事务管理器

    <!--
       xml方式配置spring对事物管理
    -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

xml配置方式

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

    <!--spring事物传播行为-->
    <tx:advice id="txadvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--spring配置事务-->
    <aop:config>
        <aop:pointcut expression="execution(* com.ff.spring.dao.UserDao.save(..))" id="save"/>
        <aop:advisor advice-ref="txadvice" pointcut-ref="save"/>
    </aop:config>

注解方式

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

在 service 中控制事务

@Service(value=“userservice”)

@Transactional(propagation=Propagation.REQUIRED) ,可以添加在类上，表示此类中的所有方法都在事务管理中运行。用在方法上，表示此方法在事务管理中运行。

10.Spring 事务传播行为

什么叫事务传播行为？

既然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior)指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。

例如：methodA 事务方法调用 methodB 事务方法时，methodB 是继续在调用者 methodA 的事务中运行呢，还是为自己开启一个新事务运行，这就是由 methodB 的事务传播行为决定的。

Spring 定义了七种传播行为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZwGEKlTv-1625555861675)(D:\HJ2010\笔记\文档里面的图片\事务传播行为上.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PBr2eJN2-1625555861677)(D:\HJ2010\笔记\文档里面的图片\事务传播行为下.png)]

1. PROPAGATION_REQUIRED （默认的传播行为）

指定的方法必须在事务内执行,若当前存在事务,加入到当前事务中,若当前没 有事务,则创建一个新事务,这种传播行为是最常见的,也是 spring 默认的传播行为。

2. PROPAGATION_SUPPORTS

支持当前事务，如果当前没有事务，就以非事务方式执行。

3. PROPAGATION_REQUIRES_NEW

总是新建一个事务，如果当前存在事务，把当前事务挂起,直到新建的事务结束。

传播行为失效：

​ 1.调用本类中的方法；

​ 2.方法必须是public；

​ 3.传播行为使用不当

​ 4.异常被 catch 捕获导致 @Transactional 失效

​ 5.数据库引擎不支持事务

11.Spring 集成 Mybatis

需要的jar包：数据库（mysql）、日志（log4j）、mybatis、Spring（context,jdbc,aop)、阿里数据源、spring-mybatis(spring整合mybatis)

       <!-- mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.16</version>
		</dependency>
	   <!-- https://mvnrepository.com/artifact/log4j/log4j -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
	   <!--mybatis-->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.2</version>
		</dependency>
		<!-- spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
		<!-- spring-aop -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>5.2.2.RELEASE</version>
		</dependency>
	   <!-- 阿里数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
	   <!--spring-mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

补充jar:

<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

配置：

spring注解包扫描

    <!--spring注解包扫描-->
    <context:component-scan base-package="com.ff.springmybatis"></context:component-scan>

config.properties内容：

drivername=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mybatis_db?characterEncoding=utf8&serverTimezone=UTC
uname=root
password=root

创建阿里巴巴 提供的数据库连接对象管理类 数据库连接池:

<!--导入属性文件-->
    <context:property-placeholder location="config.properties"></context:property-placeholder>
    <!--
      创建阿里巴巴  提供的数据库连接对象管理类 数据库连接池
    -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${drivername}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${uname}"></property>
        <property name="password" value="${password}"></property>
        <property name="initialSize" value="10"></property>
        <property name="minIdle" value="5"></property>
        <property name="maxActive" value="20"></property>
    </bean>

配置spring提供的事务管理类：

    <!--配置spring提供的事务管理类-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

开启spring注解事务：

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

mybatis里配置spring管理sqlSessionFactory对象的创建：

    <import resource="db.xml"></import>

    <!--spring管理sqlSessionFactory对象的创建-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name=" " ref="dataSource"></property>
        <property name="configLocation" value="mybatis-config.xml"></property>
        <property name="mapperLocations" value="mapper/*Mapper.xml"></property>
    </bean>

mybatis-config里配置设置，及类型别名：

    <!--设置-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <!--配置类型别名-->
    <typeAliases>
        <package name="com.ff.springmybatis.bean"/>
    </typeAliases>

mybatis里配置扫描dao接口，生成接口的代理对象：

    <!--扫描dao接口，生成接口的代理对象-->
    <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ff.springmybatis.dao"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"> </property>
    </bean>