Spring入门

spring简介

spring全家桶：spring , sprngmvc ,springboot,spring cloud

Spring 核心技术：ioc(控制反转) 和 aop(面向切面)，能实现模块之间，类之间的解耦合

、

Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度。根据功能的不同，可以将一个系统中的代码分为主业务逻辑与系统级业务逻辑两类。它们各自具有鲜明的特点：主业务代码间逻辑联系紧密，有具体的专业业务应用场景，复用性相对较低；系统级业务相对功能独立，没有具体的专业业务应用场景，主要是为主业务提供系统级服务，如日志、安全、事务等，复用性强。

 

Spring 根据代码的功能特点，将降低耦合度的方式分为了两类：IoC 与 AOP。IOC 使得主

业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了。而是由 Spring 容器统一管理，自动“注入”。而 AOP 使得系统级服务得到了最大复用，且不用再由程序员手工将系统级服务“混杂”到主业务逻辑中了，而是由 Spring 容器统一完成“织入”。Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。简单来说，Spring是一个分层的 Java SE/EE full-stack(一站式)轻量级开源框架。

Spring 特点

（1）方便解耦，简化开发

（2）Aop 编程支持

（3）方便程序测试

（4）方便和其他框架进行整合

（5）方便进行事务操作

（6）降低 API 开发难度

 

 

控制反转（IOC）

IOC ：控制反转，是一个理论，概念，思想

 

描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现，也就是对象的创建是由其他的外部资源完成。

 

控制：创建对象，对象的属性赋值，对象之间的关系管理；

 

反转：把原来开发人员创建对象的权力转交给代码之外的容器实现，由容器代替开发人员管理对象，创建对           象，给对象赋值。

 

正转：由开发人员在代码中，使用New构造方法创建对象，开发人员主动管理对象

容器：是一个微服务软件，一个框架

为什么使用ioc：目的就是减少对代码的改动，也能实现不同的功能。实现解耦合。

 

Java中创建对象的方法：

   1.构造方法 new studebt();

  2.反射

   3.序列化

   4.克隆

   5.动态代理

   6.ioc 容器创建对象

 

 

Ioc的体现：servlet

       servlet 是tomcat服务器创建的

 

Ioc的技术实现：

  DI是ioc的技术实现，

 DI：依赖注入，只需要在程序中提供要使用的对象名称即可，其他都有容器内部实现

 spring是使用的di实现的ioc功能，spring底层创建对象，使用的是反射机制。

 spring是一个容器，管理对象，给属性赋值，底层是反射创建对象。

 

bean的生命周期

1、生命周期 : 从对象创建到对象销毁的过程

2、bean 生命周期

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（4）bean 可以使用了（对象获取到了）

（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

3、bean 的后置处理器，bean 生命周期有七步

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（6）bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

 

spring框架使用的基本流程

1：创建一个maven项目

2：加入spring依赖 

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.2.6.RELEASE</version>

</dependency>

 

3：创建spring的配置文件（ApplicationConText.xml）,使用<bean>声明对象

4：使用容器中的对象，通过ApplicationContext接口和他的实现类ClassPathXmlApplicationContext的方法getBean()

 

<?xmlversion="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

http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--告诉spring创建对象

声明bean，就是告诉spring要创建某个类的对象

id：对象的自定义名称，唯一值，spring通过这个名称找到这个对象

class：类的全限定名称（不能是接口，因为spring是反射机制创建对象，必须使用类）

-->

<bean  id="SomeService"  class="com.service.impl.SomeServiseImpl"/>

</beans>

 

 

 

二：ioc：控制反转

     1）：di给属性赋值

1.set注入：使用 property  标签给属性赋值

<bean   id="myStudent2"     class="com.powernode.ba04.Student"autowire=" byType ">

            <property   name="name"  value="清"/>

            <property   name="age"      value="22"/>

</bean>

 

 

 

2.构造注入：使用   constructor-arg  标签给属性赋值

<constructor-arg>标签属性：

name:  表示构造方法的形参名

index:  表示构造方法的参数的位置，从左往右0，1，2

value:  构造方法的形参类型是简单数据类型，使用value

ref:   构造方法的形参类型是引用类型，使用ref

 

<bean    id="myStudent"   class="com.powernode.ba03.Student">

<constructor-arg    index="0"    value="张三"/>

<constructor-arg    index="1"    value="22"/>

<constructor-arg    index="2"    ref="mySchool"/>

</bean>

 

<bean    id="myStudent"    class="com.powernode.ba03.Student">

<constructor-arg    name="age"    value="20"/>

<constructor-arg    name="name"   value="lisi"/>

<constructor-arg    name="school"  ref="mySchool"/>

</bean>

 

<bean   id="mySchool"   class="com.powernode.ba03.School">

<property   name="name"    value="北京大学"/>

<property   name="address"   value="北京市海淀区"/>

</bean>

 

 

3.引用类型的自动注入：通过byName， byType

    1.byName: java类引用数据类型的属性名和spring容器中(配置文件)<bean>的id名称一样

       

<bean    id="myStudent"    class="com.powernode.ba03.Student"  autowire="byName">

<property   name="name"  value="清"/>

           <property   name="age"      value="22"/>

</bean>

    假如引用类型的属性名是school那么使用byName自动注入，则id名要和属性名一样

<bean   id="school"   class="com.powernode.ba03.School">

<property   name="name"    value="北京大学"/>

<property   name="address"   value="北京市海淀区"/>

</bean>

 

  2.  byType： java类引用数据类型的属性名和spring容器中(配置文件)<bean>的class属性是同源关系

同源就是一类的意思：

1.Java类中引用类型的数据类型和bean中class的值一样

1.Java类中引用类型的数据类型和bean中class的值父子类关系

1.Java类中引用类型的数据类型和bean中class的值接口和实现类关系的

 

<bean    id="myStudent"    class="com.powernode.ba03.Student"  autowire="byType">

 <property   name="name"  value="清"/>

            <property   name="age"      value="22"/>

</bean>

    加入引用类型的数据类型是School类型 ，那么使用byType自动注入时，class的属性同源

<bean   id="mySchool"   class="com.powernode.ba03.School">

<property   name="name"    value="北京大学"/>

<property   name="address"   value="北京市海淀区"/>

</bean>

 

使用注解完成属性赋值

一：使用注解赋值的基本步骤

 

   1：创建一个maven项目

   2：加入spring依赖

   3：加入Resource注解使用的jar包(所以要加入依赖)   

<dependency>

<groupId>javax.annotation</groupId>

<artifactId>javax.annotation-api</artifactId>

<version>1.3.2</version>

</dependency>

 

  4：使用注解创建对象，创建容器ApplicationContext接口和他的实现类ClassPathXmlApplicationContext的方法getBean()

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="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

Index of /schema/context

https://www.springframework.org/schema/context/spring-context.xsd">

 

声明组件扫描器(component-scan)组件就是Java对象

base-package：指定注解在你项目中的包名

工作方式：spring会扫描遍历base-package指定的包

把包中和子包中所有的类，找到类中的注解，按照注解的功能创建对象，或给属性赋值

 

<context:   component-scan   base-package="com.spring.ba06"/>

</beans>

 

 一：七大常用注解

          @Component :  创建对象

@Repository：创建dao对象，用来访问数据库

@Service：创建service对象，处理业务逻辑的，可以有事务功能

@Controller：创建控制器对象的,接收请求，显示处理结果

@Value：简单类型的属性赋值

@Autowired：引用类型的属性赋值,支持byName,byType ，默认byType

@Resource：jdk中的注解，使用自动注入给引用类型赋值，支持byName,byType ，默认byName，使用该注解时需要导入依赖：

<!--注解JDK-->

<dependency>

<groupId>javax.annotation</groupId>

<artifactId>javax.annotation-api</artifactId>

<version>1.3.2</version>

</dependency>

 

 

二：注解的具体使用方法

 @Component：创建对象的，等同于<bean>的功能

*

*属性：value就是对象的名称，也就是bean的id值,value可以省略不写

*value的值是唯一的，创建的对象在整个spring容器中就一个

*位置：在类的上面

*@Value：简单类型的属性赋值

*属性：value是string类型，表示简单类型的属性赋值

*位置：1.放在属性定义的上面，无需set方法，推荐使用

*2.在set方法的上面

*声明一个引用类型

*@Autowired:spring框架提供注解，实现引用类型的赋值

*

*@Autowired：默认使用的是byType自动注入

*位置：1.在属性定义上面，无需set方法

*2.在set方法上面

*

*如果要使用byName方式，需要做的是：

*1.在属性定义上面加@Autowired

*2.在属性定义上面加@Qualifier(value="bean的id")：表示使用指定名称的bean完成赋值。

*

**/

*声明一个引用类型

*@Resource:来自jdk中的注解，spring框架提供了对这个注解的功能支持，可以使用该注解给引用类型赋值，

*使用的也是自动注入的原理，支持byType,byName,默认是byName

*

 

  @Component ("myStudent")

  Public  class  Student{

@Value(value="展昭")

Private   String   name;

@Value(value="29")

Private   Integer   age;

@Autowired

@Qualifier("mySchool")

Private  School  school;

@Override

publicStringtoString(){

return"student{"+

"age="+age+

",name='"+name+'\''+

'}';

       }

 

面向切面编程（aop）

第三章：  aop

 

1.动态代理

          实现方式：jdk动态代理，使用jdk中的proxy，method，invocationHandler创建代理对象。jdk动态代理要求目标类必须实现接口。

          cglib ：第三方工具库，创建代理对象，原理是继承，通过继承目标类，创建子类。

子类就是代理对象，要求目标类不能是final的，方法也不能是final的

 

作用：

    1：在目标类源代码不改变的情况下，增加功能。

    2：减少代码的重复。

    3：专注业务逻辑代码

    4：解耦合，让你的业务功能和日志，事务非业务功能分离。

 

2.aop:面向切面编程，基于动态代理的，aop就是动态代理的规范化，把动态代理的实现步骤，方法·都定义好了，让开发人员用统一的方式，使用动态代理。

 

 

怎么理解面向切面编程：

1）需要在分析项目功能时，找出切面。

2）合理的安排切面执行时间（在目标方法前，还是目标方法后）

3）合理的安全切面执行的位置，在哪个类，哪个方法增强功能。

 

 

术语：

Aspect：切面，表示增强的功能，就是一堆代码，完成某一个功能。非业务功能，常见的切面功能有日志，事务，统计信息，参数检查，权限验证

JoinPoint：连接点，连接业务方法和前面的位置。就某类中的业务方法

Pointcut:切入点，指多个连接点方法的集合。多个方法

目标对象：给哪个类的方法增强功能，这个类就是目标对象。

advice：通知，通知切面功能执行的时间

 

说一个切面有三个关键的要素：

1）切面的功能代码，切面干什么

2）切面的执行位置，使用Pointcut表示切面的执行位置

3）切面的执行时间，使用Advice表示时间，在目标方法之前，还是在目标方法中后

 

面向切面编程的基本步骤（asceptj）

使用aspectj的具体步骤：

  1：新建maven项目

  2：加入依赖

           spring依赖

           aspectj依赖：

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>5.2.6.RELEASE</version>

</dependency>

           junit依赖

  3：创建目标类：接口和他的实现类，

     要做的是给类中的方法·增加功能，

  4：创建切面类：普通类

     1)在类的上面加入@Aspect

     2)在类中定义方法，方法就是切面要执行的功能代码，

       在方法上面加入aspectj中的通知注解，例如@Before

       还需要指定切入点表达式execution();

 

  5:创建spring的配置文件，声明对象，把对象交给容器统一管理，声明对象你可以使用注解或者xml配置文件<bean>

      1)声明目标对象

      2)声明切面类对象

      3)声明aspectj框架中的自动代理生成器标签

          自动代理生成器:用来完成代理对象的自动创建功能的

 

  6:创建测试类：从spring容器中获取目标对象(实际就是代理对象)，通过代理执行方法，实现aop的功能增强。

 

@Aspect:是aspectj框架中的注解

*作用：表示当前类是切面类。

*切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码。

*位置：在类定义上面。

 

@Before:前置通知

*属性:value切入点表达式，表示切面的功能执行的位置。

*位置：方法的上面

*特点：

*1.在目标方法之前执行。

*2.不会改变目标方法执行的结果

*3.不会影响目标方法的执行

*execution(访问修饰符返回值包名.类名.方法名称(方法参数))

@Before(value= "execution(publicvoidcom.ning.ba01.SomeServiceImpl.doSome(String,Integer))")

Public  void  myBefore(){

System.out.println("0===前置通知，在方法执行之前输出时间:"+newDate());

}

 

*指定通知方法中的参数：JoinPoint

*JoinPoint：要加入切面功能的业务方法

*作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法实参。

*这个JoinPoint参数值是由框架赋予的，必需是第一个位置的参数。

 

 

*@AfterReturning:后置通知

*属性：1.value：切入点表达式

*2.returning：自定义的变量，表示目标方法的返回值。

*自定义变量名必须和通知方法的形参名一样。

*特点：

*1.在目标方法之后执行

*2.能够获取目标方法的返回值，可以根据这个返回值做不同的功能处理

*3.可以修改这个返回值

 

 

*@Around:环绕通知

*属性：value：切入点表达式

*特点：

*1、他是功能最强的通知

*2.在目标方法前后都能增强功能

*3、控制目标方法是否被调用执行，

*4、修改原来的目标方法的执行结果。影响最后的调节结果

*环绕通知，等同于jdk动态代理，InvocationHandler接口

*参数：ProceedingJoinPoint就等同于Method

*作用：执行目标方法的

*返回值：就是目标方法的执行结构，可以修改

 

*@After:最终通知

*value:切入点表达式

*位置：在方法的上面

*特点：总是会执行

*在目标方法之后执行

 

*@Pointcut:定义和管理切入点，如果你的项目中有多个切入点表达式是重复的，可以重复使用的。

*就可以使用@Poinycut注解

*属性：value：切入点表达式

*位置：在自定义方法的上面

*特点：当使用@Pointcut定义在一个方法上面时，该方法里面不需要代码。此时该方法的名称就是切入点表达式的别名

*在其他的通知中，value属性就可以使用这个方法名代替切入点表达式了

*

@Before(value="myPoint()")   value就是下面的方法名

publicvoidmyBefore(){

System.out.println("执行前置通知：先执行的代码");

}

 

*

@Pointcut(value="execution(**..SomeServiceImpl.doFinally*(..))")

publicvoidmyPoint(){

//不需要代码

}

 

在spring配置文件中僧名自动代理生成器：

<!--声明自动代理生成器：使用aspectj内部框架的功能，创建目标对象的代理对象。

创建代理对象实在内存中实现的，修改目标对象的内存中的结构，创建为代理对象

所以目标对象就是被修改后的代理对象

-->

<aop:aspectj-autoproxy/>

 

spring集成mybatis

使用的技术：IOC

原因：因为ioc能创建对象，可以把mybatis框架中的对象交给spring统一管理，开发人员从spring中获取对象，就不用同时面的两个框架了，直接使用spring

 

基本步骤

1、在maven项目中加入各种依赖

     1）、spring核心依赖

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.2.6.RELEASE</version>

</dependency>

     2）mybatis依赖

<dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

<version>3.5.4</version>

</dependency>

     3）MySQL驱动

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>5.1.9</version>

</dependency>

     4）、spring事务依赖

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>5.2.6.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-tx</artifactId>

<version>5.2.6.RELEASE</version>

</dependency>

 

   5）阿里公司数据库连接池

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>druid</artifactId>

<version>1.1.12</version>

</dependency>

    6）spring集成mybatis依赖

<dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis-spring</artifactId>

<version>1.3.1</version>

</dependency>

 

2：创建实体类：（domain）

3：创建Service接口和实现类，属性是dao

4：创建dao接口和mapper文件

5：创建mybatis主配置文件

6：创建spring主配置文件：声明mybatis的对象交给spring创建

1)数据源DataSource

<!--把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容

sprin知道jdbc.properties文件位置-->

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

 

<!--声明数据源DataSource,作用是连接数据库的-->

<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"  init-method="init"  destroy-method="close">

<!--使用属性配置文件中的数据${key}-->

<property name="url" value="${jdbc.url}"/>

<property name="username" value="${jdbc.username}"/>

<property name="password" value="${jdbc.password}"/>

<property name="maxActive" value="${jdbc.max}"/>

</bean>

 

2)SqlSessionFactory

<!--声明mybatis包中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory-->

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

<!--set注入，把数据库连接池付给了dataSource属性-->

<property  name="dataSource"  ref="myDataSource"/>

<!--

mybatis主配置文件的位置

configLocation的属性是Resource

-->

<property  name="configLocation"  value="classpath:mybatis.xml"/>

</bean>

3)Dao对象

<bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">

<!--指定SqlSessionFactory对象的id-->

<property  name="sqlSessionFactoryBeanName"value="sqlSessionFactory"/>

 

<!--指定包名，包名是dao接口所在的包名

MapperScannerConfigurer会扫描这个包中的所有接口，

把每个接口都执行一次getMapper()方法，得到每个接口的dao对象。

创建好的dao对象放入到spring容器中

-->

<property  name="basePackage"  value="com.ning.Dao"/>

</bean>

4)声明自定义service

<!--声明service-->

<bean  id="studentService"  class="com.ning.service.impl.StudentServiceImpl">

<property  name="studentDao"  ref="studentDao"/>

</bean>

7：创建测试类，获取Service对象，通过service调用dao完成数据库的访问

 

spring事务处理

 

 

1：什么是事务：

讲mybatis的时候，提出了事务。事务是指一组sql语句的集合，集合中有多少条sql语句,可能是insert ,delete ,select ,update,我们希望这些sql语句都能成功，或者都能失败，这些sql语句的执行是一致的，作为一个整体执行。

 

2：在什么时候想到用事务：

当我的操作涉及到多个表时，或者时多个sql语句，需要保证这些语句都是成功才能完成我的功能，或者都失败，保证操作时符合要求的。

 

3：通常使用jdbc访问数据库,还有mybatis访问数据库，怎么处理事务？

jdbc访问数据库，处理事务  connection  conn;   conn.commit();      conn.rollback();

mybatis访问数据库，处理事务  sqlsession.commit();      sqlsession.rollback();

hibernate访问数据库，处理事务 ，session.commit();   session.rollback();

 

4：问题3中事务的处理方式有什么不足？

1)不同的数据库访问技术，处理事务的对象，方法不同，需要了解不同数据库访问技术使用事务原理

2)掌握多种数据库中事务的处理逻辑，什么时候提交事务，什么时候回滚事务。

3)处理事务的多种方法

 

总结：就是多种数据库访问技术，有不同的事务处理机制，对象，方法。

 

5：怎么解决不足？

spring提供一种处理事务的统一模型，能使用统一步骤，方式完成多种不同数据库访问技术的事物处理

 

6：处理事务需要怎么做，做什么？

1）事务内部提交，回滚事务，使用事务管理器对象，代替你完成commit，rollback

事务管理器是一个接口和他的众多实现类。

接口：PlatfromTransactionManager,定义了事务重要方法commit，rollback

实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了。

mybatis访问数据库----spring创建好的是DataSourceTransactionManager

 

怎么使用：你需要告诉spring你用的是那种数据库访问技术

声明数据库访问技术的事务管理器实现类，在spring的配置文件中使用<bean>声明即可

<bean id="xxx" class="….DataSourceTranscactionManager">

 

2）说明需要事务的类型。

a)事物的隔离级别：4个值：

default：采用DB默认的事务隔离级别。MySQL默认为repeatable_read    oracle认为 read_committed

Read_uncommitted:读未提交，未解决任何并发问题

Read_committed:读已提交，解决脏读，存在不可重复读与幻读

Repeatable_read:可重复读。解决脏读、不可重复读，存在幻读

Serializable:串行化，不存在并发问题

b)事务的超时时间：表示一个方法最长的执行时间，如果方法执行超过了时间，事务就回滚。单位是秒，整数值，默认-1

c)事务的传播行为：控制业务方法是不是有事务，是什么样的事务。7个传播行为，表示你的业务方法调用时，事务在方法之间是如何使用的。

Propagation_required

Propagation_requires-new

Propagrion_supports

以上三个需要掌握

 

Propagation-mandatory

Propagation-nested

Propagation-never

Propagation-not-supported

 

3）spring提交事务，回滚事务的时机

4）总结spring事务：

1：管理事务的是事务管理和他的实现类

2：spring的事务是一个统一模型

 a)指定要使用的事务挂历其实现类，使用<bean>

b)指定哪些类，哪些方法需要加入事务的功能

c)指定方法需要的隔离级别，传播行为，超时

你需要告诉spring，你的项目中类信息，方法名称，方法的事务传播行为。

 

spring事务处理方案：

1：适合中小型项目，注解方案

1：spring框架自己用aop实现给业务方法增加事务的功能，使用@Transactional 注解增加事务

声明事务管理器对象

<!--使用spring·事务处理-->

<!--1.声明事务管理器-->

<bean  id="transactionManager"  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!--连接的数据库，指定数据源-->

<property  name="dataSource"  ref="myDataSource"/>

</bean>

2：开启事务注解驱动，spring使用aop机制，创建@Transactional 所在类的代理对象，给方法·加入事务的功能

<!--2.开启事务注解驱动

transaction-manager:事务管理器对象的id

-->

<tx : vannotation-driventransaction-manager="transactionManager"/>

 

 

3：在方法上面加入@Transactional

/**使用的是事务控制默认值，默认的传播行为是：REQUIRED，默认的隔离级别是：DEFAULT

*默认抛出运行时异常，回滚事务*/

@Transactional

 

 

 

@Transactional(

//propagation=Propagation.REQUIRED,

//isolation=Isolation.DEFAULT,

//readOnly=false,

//rollbackFor={

//NullPointerException.class,NotEnoughException.class

//}

//)

 

 

 

2：适合大型项目。使用aspetj框架，在spring配置文件中声明类，方法需要的事务，这种方式  业务方法和事务配置完全分离。

 

 

实现步骤：都是在xml文件中配置文件中实现。

   1）：加入aspectj依赖；

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>5.2.6.RELEASE</version>

</dependency>

 

2）：声明事务管理器对象

<bean  id="transactionManager"  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!--连接的数据库，指定数据源-->

<property  name="dataSource"  ref="myDataSource"/>

</bean>

 

 

3）声明方法需要的事务类型，（配置方法的事务属性【隔离级别，传播行为，超时】）

 

4）：配置aop，指定哪些类要创建代理