详细了解Spring框架

最新推荐文章于 2024-02-15 14:13:11 发布
最新推荐文章于 2024-02-15 14:13:11 发布
阅读量142 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huizaishuibuxing/article/details/102331412
版权

了解Spring框架

Spring核心概念

Spring是企业应用开发的 “一站式” 选择，Spring贯穿表现层，业务层，持久层。spring框架由大约20个功能模块组成。这些模块被分成六个部分，分别是Core Cointainer，Data Access/Integration，Web，Aop，Instrumentation及Test。

1、IOC和DI

1.1 IOC: 控制反转

即控制权的转移，将我们创建对象的方式反转了,以前对象的创建是由我们开发人员自己维护,包括依赖关系也是自己注入。使用了spring之后，对象的创建以及依赖关系可以由spring完成创建以及注入，反转控制就是反转了对象的创建方式，从我们自己创建反转给了程序创建(spring)

1.2 DI: Dependency Injection 依赖注入

spring这个容器中，替你管理着一系列的类，前提是你需要将这些类交给spring容器进行管理，然后在你需要的时候，不是自己去定义，而是直接向spring容器索取，当spring容器知道你的需求之后，就会去它所管理的组件中进行查找，然后直接给你所需要的组件.实现IOC思想需要DI做支持

注入方式: 1.set方式注入 2.构造方法注入 3.字段注入
注入类型: 1.值类型注入 2.引用类型注入

1.3 构造器注入：

现在我们要在对象userServiceImpl中注入对象userDaoImpl。如果我们没有指定的话，默认情况下是调用默认的构造方法来初始化。可以看到属性值通过构造方法成功注入，这边Spring允许你通过name来对应构造器参数，也可以使用index表示对应的位置，从0开始。或者使用type，指定类型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3SauJ9PF-1570456556577)(C:\Users\Administrator\Documents\70)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RSu1GyeP-1570456556579)(C:\Users\Administrator\Documents\71)]

1.4 Collection注入：

​ 在对象中经常要使用到Collection集合类型，Spring也提供了对象的方式来注入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tVCCtQWV-1570456556580)(C:\Users\Administrator\Documents\72)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IeWZPnPU-1570456556581)(C:\Users\Administrator\Documents\73)]

1.5 setter 方法注入

对于 JavaBean 对象而言，我们一般都是通过 getter 和 setter 方法来访问和设置对象的属性。所以，当前对象只需要为其所依赖的对象提供相对应的 setter 方法，就可以通过该方法将相应的依赖对象设置到被注入对象中。如下：

public class YoungMan {
    private BeautifulGirl beautifulGirl;

​    public void setBeautifulGirl(BeautifulGirl beautifulGirl) {
​        this.beautifulGirl = beautifulGirl;
​    }
}

2.Spring AOP

2.1 AOP的基本概念

​ (1)Aspect(切面):通常是一个类，里面可以定义切入点和通知

​ (2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用

​ (3)Advice(增强处理):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around

​ (4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式

​ (5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

2.2 增强方法:
  1. 后置增强:在我们目标方法运行结束之后 ,不管有没有异常**(@After)**
  2. 返回增强:在我们的目标方法正常返回值后运行**(@AfterReturning)**
  3. 异常增强:在我们的目标方法出现异常后运行**(@AfterThrowing)**
  4. 环绕增强:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知, 执行之后就相当于我们后置通知**(@Around)**
  5. 前置增强:在我们执行目标方法之前运行(@Before)
2.3 基于注解的AOP配置方式
切面类：

package com.enjoy.cap10.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

日志切面类
@Aspect
public class LogAspects {
	@Pointcut("execution(public int com.enjoy.cap10.aop.Calculator.*(..))")
	public void pointCut(){};
	
	//@before代表在目标方法执行前切入, 并指定在哪个方法前切入

​	@Before("pointCut()")
​	public void logStart(){
​		System.out.println("除法运行....参数列表是:{}");

​	}

​	@After("pointCut()")
​	public void logEnd(){
​		System.out.println("除法结束......");
​	}
​	@AfterReturning("pointCut()")
​	public void logReturn(){
​		System.out.println("除法正常返回......运行结果是:{}");
​	}
​	
​	@AfterThrowing("pointCut()")
​	public void logException(){
​		System.out.println("运行异常......异常信息是:{}");
​	}

​	@Around("pointCut()")

​	public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

​		System.out.println("@Arount:执行目标方法之前...");

​		Object obj = proceedingJoinPoint.proceed();//相当于开始调div地
​		System.out.println("@Arount:执行目标方法之后...");
​		return obj;
​	}
}
目标方法：
package com.enjoy.cap10.aop;

public class Calculator {
//业务逻辑方法
	public int div(int i, int j){
		System.out.println("--------");
		return i/j;
	}
}
配置类：
package com.enjoy.cap10.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import com.enjoy.cap10.aop.Calculator;
import com.enjoy.cap10.aop.LogAspects;

@Configuration

@EnableAspectJAutoProxy
public class Cap10MainConfig {
	@Bean
	public Calculator calculator(){
		return new Calculator();
	}

	@Bean
	public LogAspects logAspects(){
		return new LogAspects();
	}
}
测试类：
public class Cap10Test {
	@Test
	public void test01(){
		AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap10MainConfig.class);	
		Calculator c = app.getBean(Calculator.class);
		int result = c.div(4, 3);
		System.out.println(result);
		app.close();

	}
}
结果：
@Arount:执行目标方法之前...

除法运行....参数列表是:{}
--------

@Arount:执行目标方法之后...

除法结束......
除法正常返回......运行结果是:{}
1

3.注解

3.1 定义 Bean

XML 或注解配置方式，都是表达 Bean 定义的载体，其实质都是为 Spring 容器提供 Bean 定义的信息 。 基于注解的配置方式，从 Spring2.0 开始引入， Spring2.5 完善， Spring4.0 得到了进一步的增强 。

Spring 容器成功启动的三大要件分别是：

  • bean 的定义信息。
  • bean 的实现类。
  • Spring 本身。

如果采用 XML 的配置，则 Bean 的定义信息和 Bean 的实现类本身是分离的 。 而如果采用基于注解的配置方式，则 Bean 的定义信息是通过在 Bean 的实现类上标注注解来实现 。

@Component
public class BookDao {
  ...
}

使用 @Component 注解在 BookDao 类声明处对它进行标注，这样它就可以被 Spring 容器识别， 并把这个类转换为容器管理的 Bean。

它和下面的 XML 配置是等效的：

<bean id="bookDao " class=net.deniro.spring4.anno.BookDao ">

除了 @Component 注解外， Spring 还提供了 3 个功能与 @Component 等效的注解：

注解说明
@Repository标注 DAO 实现类。
@Service标注 Service 实现类。
@Controller标注 Controller 实现类。

之所以提供了这 3 个特定的注解，是为了让标注类本身的用途更清晰，所以，推荐使用这些特定注解来标注功能类。

3.2 扫描 Bean

Spring 的 context 命名空间提供了通过扫描类包的 Bean 注解定义，来加载 Bean。

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

    <!-- 扫描包含注解定义的类包-->
    <context:component-scan base-package="net.deniro.spring4.anno"/>

</beans>

配置步骤：

  1. 声明 context 命名空间和 schema 文件。
  2. 通过 context 命名空间的 component-scan 的 base-package 属性指定一个需要扫描的基类包， Spring 容器会扫描这个基类包里的所有类，并从类的注解信息中获取 Bean 的定义信息 。

如果希望扫描特定的类，那么可以使用 resouce-pattern 属性过滤出特定的类：

<context:component-scan base-package="net.deniro.spring4"
                        resource-pattern="anno/*.class"/>

默认情况下 resource-pattern 属性的值为 **./*.class, 即基类包里所有的类 。 上面的设置，让它仅扫描基类包中的 anno 子包下的类。

resource-pattern 属性会按照资源名称对基类包中的类进行过滤。

<context:component-scan> 提供了 include-filter 与 exclude-filter 子元素，它们可以对需要过滤的包进行更精细的控制。

<context:component-scan base-package="net.deniro.spring4"
                        resource-pattern="anno/*.class">
    <!-- 需要包含的类-->
    <context:include-filter type="aspectj" expression="net.deniro.spring4..*Service+"/>
    <!-- 排除的类-->
    <context:exclude-filter type="regex" expression="net\.deniro\.spring4\.anno.*"/>
</context:component-scan>
  • <context:include-filter> 表示要包含的目标类。指定的类路径必须在 base-package 所指定的基本路径下。
  • <context:exclude-filter> 表示要排除的目标类。
  • 一个 <context:component-scan> 下可以有多个 <context:include-filter> 和 <context:exclude-filter> 元素。

这两个过滤元素支持多种类型的过滤表达式：

类别示例说明
annotationcom.deniro.XxxAnnotation表示所有标注了 XxxAnnotation 的类。
assignablecom.deniro.XxService所有继承或扩展 XXXService 的类 。
aspectjcom.deniro..*Service+所有类名以 Service 结束的类及继承或者扩展它们的类，使用的是 AspectJ 表达式。
regexcom\.deniro\.auto\..*所有 com.deniro.auto 类包下的类，使用的是正则表达式。
customcom.deniro.auto.XxxTypeFilter使用代码方式实现过滤，这个类必须实现 org.springframework.core.type.TypeFilter 接口。

这些过滤类型中，除了 custom 类型外， aspectj 的过滤表达能力是最强的，可以轻易地实现其他类型所表达的过滤规则 。

<context:component-scan> 元素有一个 use-default-filters 属性，它的默认值为 true, 表示会扫描标注了 @Component、@Controller、@Service、@Repository 的 Bean。

3.3 自动装载 Bean
@Autowired 自动注入
@Service
public class BookService {

​    @Autowired
​    private AuthorService authorService;

​    public AuthorService getAuthorService() {
​        return authorService;
​    }
}

@Autowired 默认按类型（byType） 匹配的方式在容器中查找，如果有且仅有一个匹配的 Bean 时，Spring 会将其注入到标注了 @Autowired 的变量中。

配置：

<context:component-scan base-package="net.deniro.spring4.anno"/>

单元测试：

BookService bookService= (BookService) context.getBean("bookService");

Assert.assertNotNull(bookService);

Assert.assertNotNull(bookService.getAuthorService());

@Auotwired 的 required 属性

如果容器中没有一个和标注变量类型匹配的 Bean ，那么 Spring 启动时会抛出 NoSuchBeanDefinitionException 异常 。 如果希望 Spring 即使找不到匹配的 Bean 不需要抛出异常，那么就可以使用 @Autowired(required=false) 对变量进行标注 。 形如：

@Autowired(required = false)
private PressDao pressDao;
@Qualifier

如果容器中有一个以上匹配的 Bean 时，则可以通过 @Qualifier 注解限定 Bean 的名称 。

假设在 Spring容器中存在两个类型都为 AccountDao 的 Bean：

<bean id="accountDao1" class="net.deniro.spring4.anno.AccountDao" scope="prototype"/>
<bean id="accountDao2" class="net.deniro.spring4.anno.AccountDao" scope="prototype"/>

那么通过 @Qualifier 注解指定需要注入的 Bean：

@Autowired
@Qualifier("accountDao1")
private AccountDao accountDao;
标注类方法

@Autowired 即可以标注类成员变量，也可以标注方法的入参。

private LogDao logDao;

/**
 * 标注方法
 * @param logDao
 */
@Autowired
public void setLogDao(LogDao logDao) {
    this.logDao = logDao;
}

这里会自动将 LogDao 传给方法入参。

如果一个方法拥有多个入参，在默认情况下，Spring 将自动注入匹配入参类型的 Bean。可以对方法入参标注 @Qualifier 用于指定注入 Bean 的名称 。

@Autowired
public void init(@Qualifier("accountDao1") AccountDao accountDao) {
    System.out.println("accountDao1 被注入");
}

一般情况下， Spring 容器中大部分的 Bean 是单实例的，所以一般无需通过 @Repository、@Service 等注解的 value 属性指定 Bean 的名称，也无须使用 @Qualifier 注解指定名称进行注入 。

虽然 Spring 支持在属性和方法上标注自动注入注解 @Autowired, 但在实践中建议采用在方法上标注 @Autowired 的方式，因为这样更加 “ 面向对象 ” ，也方便编写单元测试， 如果把注解标注在私有属性上，则在单元测试阶段就很难用编程的方式来设置属性值 。

标注集合类

如果使用 @Autowired 标注了类中的集合类型的变量或者方法入参，那么 Spring 会将容器中所有类型匹配的 Bean 都注入进来 。

public interface Plugin {
}

它有两个实现类：

@Component
public class Plugin1 implements Plugin {
}
@Component
public class Plugin2 implements Plugin {
}

把所有实现了 Plugin 接口的类都注入到下面的 CustomComponent 类的变量中：

@Component
public class CustomComponent {

    /**
     * 把所有类型为 Plugin 的 Bean 都注入这个 List
     */
    @Autowired(required = false)
    private List<Plugin> plugins;

    /**
     * 把所有类型为 Plugin 的 Bean 都注入这个 Map
     * key：Bean 名称；value：所有实现了 Plugin 接口的 Bean
     */
    @Autowired
    private Map<String, Plugin> pluginMap;

    public List<Plugin> getPlugins() {
        return plugins;
    }

    public Map<String, Plugin> getPluginMap() {
        return pluginMap;
    }
}

注入 Map 集合，是 Spring 4 提供的新特性。

单元测试：

CustomComponent component = (CustomComponent) context.getBean("customComponent");
System.out.println("getPluginMap:"+component.getPluginMap());
System.out.println("getPlugins:"+component.getPlugins());
assertFalse(component.getPluginMap().isEmpty());
assertFalse(component.getPlugins().isEmpty());

输出结果：

img

在默认情况下，这两个 bean 的加载顺序是不确定，在 Spring4 中可以通过 @Order 注解或者实现 Ordered 接口来决定 Bean 加载的顺序，值越小，表示优先级越高 （只对有序的集合类型有效）。

@Component
@Order(value = 1)
public class Plugin2 implements Plugin {
}

测试结果：

img

可以发现，Plugin2 已经被优先加载。

实践中，系统的插件体系完成可以利用 Spring 的集合注入功能，完成插件的识别与注入工作。

延迟依赖注入

Spring4 支持延迟依赖注入，即在 Spring 容器时，对标注了 @Lazy 和 @Autowired 注解的 Bean 属性，不会立即注入， 而是到调用该属性时才会注入 。

@Lazy
@Repository
public class LazyDao {
}
LazyDao lazyDao;

@Lazy
@Autowired
public void setLazyDao(LazyDao lazyDao) {
    this.lazyDao = lazyDao;
}

**注意：**对 Bean 实施延迟依赖注入，@Lazy 注解必须同时标注在属性及目标的 Bean 上 。

标准注解

Spring 还支持 JSR-250 中定义的 @Resource 和 JSR-330 中定义的 @Inject 注解，这两个标准注解和 @Autowired 注解的功能相似，都能对类的变更及方法入参提供自动注入功能 。

@Resource 注解要求提供一个 Bean 名称的属性，如果属性为空，则自动采用标注处的变量名或者方法名作为 Bean 的名称 。

private ResourceDao resourceDao;

@Resource(name = "resourceDao")
public void setResourceDao(ResourceDao resourceDao) {
    this.resourceDao = resourceDao;
}

如果 @Resource 未指定 name 属性，则会根据属性方法得到需要注入的 Bean 名称 。 @Autowired 默认按照类型匹配注入 bean ， @Resource 默认按照名称匹配注入 Bean。 而 @Inject 和 @Autowired 一样也是按照类型匹配注入 Bean 的，只不过它没有 required 属性 。

可见不管是 @Resource 或者 @Inject 注解，它们的功能都没有 @Autowired 来的丰富，因此除非必要，否则可以忽略这两个注解。

@Scope 注解

通过注解配置的 Bean 和通过 <bean> 配置的 Bean 是一样的，默认的作用范围都是 singleton。 Spring 为注解配置提供了一个 @Scope 注解，可以通过它显式地指定 Bean 的作用范围 。

@Scope("prototype")
@Component
public class Press {

}

@Scope 注解通过入参指定 Bean 的作用范围 。

在使用 <bean> 进行配置时，可以通过 init-method 和 destory-method 属性指定 Bean 的初始化及容器销毁前执行的方法 。Spring 从 2.5 开始支持 JSR-250 中定义的 @PostConstruct 和 PreDestory 注解 。 在 Spring 中它们相当于 init-method 和 destroy-method 属性的功能 。不过注解方式更强大，我们可以在一个 bean 中定义多个 @PostConstruct 和 @PreDestory 方法 。

@Component
public class Book {

    @PostConstruct
    private void init1(){
        System.out.println("init1");
    }

    @PostConstruct
    private void init2(){
        System.out.println("init2");
    }

    @PreDestroy
    private void destroy1(){
        System.out.println("destroy1");
    }

    @PreDestroy
    private void destroy2(){
        System.out.println("destroy2");
    }
}

单元测试：

Book book = (Book) context.getBean("book");
((ClassPathXmlApplicationContext) context).destroy();

测试结果：

init1
init2
destroy1
destroy2

可以看出，Spring 先调用了类的构造函数实例化了 Bean ，然后再执行 @Autowired 进行自动注入，接着执行标注了 @PostConstruct 的方法，最后在容器关闭时，执行标注了 @PreDestroy 的方法 。

4.事务

4.1 声明式事务：

Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。

4.2 配置方式：

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

  1. 在 spring 配置文件中引入 tx 命名空间
<?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:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
  1. 事务管理器配置
<!-- 定义事务管理器（声明式的事务） -->
<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">   
    <property name="dataSource" ref="dataSource"></property>
</bean>
  1. 注解方式

    具有 @Transactional 注解的 bean 自动配置为声明式事务支持。

<!-- 使用annotation开启对注解的支持 -->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

在接口或类的声明处 ,写一个 @Transactional 要是只在接口上写，接口的实现类就会继承下来、接口的实现类的具体方法，可以覆盖类声明处的设置。

  1. 配置文件方式

①每个Bean都有一个代理

<!-- 配置DAO -->  
<bean id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl">  
    <property name="dataSource" ref="dataSource" />  
</bean>  

<bean id="userDao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
    <!-- 配置事务管理器 -->  
    <property name="transactionManager" ref="transactionManager" />  
    <property name="target" ref="userDaoTarget" />  
    <property name="proxyInterfaces" value="com.test.spring.dao.GeneratorDao" />  
    <!-- 配置事务属性 -->  
    <property name="transactionAttributes">  
        <props>  
            <prop key="*">PROPAGATION_REQUIRED</prop>  
        </props>  
    </property>  
</bean>

②所有Bean共享一个代理基类

<bean id="transactionBase" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true">  
    <!-- 配置事务管理器 -->  
    <property name="transactionManager" ref="transactionManager" />  
    <!-- 配置事务属性 -->  
    <property name="transactionAttributes">  
        <props>  
            <prop key="*">PROPAGATION_REQUIRED</prop>  
        </props>  
    </property>  
</bean>  

<!-- 配置DAO -->  
<bean id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl">  
    <property name="dataSource" ref="dataSource" />  
</bean>  

<bean id="userDao" parent="transactionBase">  
    <property name="target" ref="userDaoTarget" />  
</bean>

③使用拦截器

<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">  
    <property name="transactionManager" ref="transactionManager" />  
    <!-- 配置事务属性 -->  
    <property name="transactionAttributes">  
        <props>  
            <prop key="*">PROPAGATION_REQUIRED</prop>  
        </props>  
    </property>  
</bean>  

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
    <property name="beanNames">  
        <list>  
            <value>*Dao</value>  
        </list>  
    </property>  
    <property name="interceptorNames">  
        <list>  
            <value>transactionInterceptor</value>  
        </list>  
    </property>  
</bean>  

<!-- 配置DAO -->  
<bean id="userDao" class="com.test.spring.dao.UserDaoImpl">  
    <property name="dataSource" ref="dataSource" />  
</bean>

④使用tx标签配置的拦截器

<tx:advice id="txAdvice" transaction-manager="transactionManager">  
    <tx:attributes>  
        <tx:method name="*" propagation="REQUIRED" />  
    </tx:attributes>  
</tx:advice>  

<aop:config>  
    <aop:pointcut id="interceptorPointCuts"  
        expression="execution(* com.test.spring.dao.*.*(..))" />  
    <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />  
</aop:config>
4.3 使用编程式事务进行事务管理

Spring的编程式事务即在代码中使用编程的方式进行事务处理，可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager，另外就是TransactionTemplate。

1、TransactionManager使用方式

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {  
    private HibernateTransactionManager transactionManager;  
    private DefaultTransactionDefinition def;  

```
public HibernateTransactionManager getTransactionManager() {  
    return transactionManager;  
}  

public void setTransactionManager(HibernateTransactionManager transactionManager) {  
    this.transactionManager = transactionManager;  
}  

public void createTransactionDefinition() {  
    def = new DefaultTransactionDefinition();  
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);  
    def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);  
}  

public void saveOrUpdate(User user) {  
    TransactionStatus status = transactionManager.getTransaction(def);  
    try {  
        this.getHibernateTemplate().saveOrUpdate(user);  
    } catch (DataAccessException ex) {  
        transactionManager.rollback(status);  
        throw ex;  
    }  
    transactionManager.commit(status);  
}  
```

}
2、TransactionTemplate方式

ResultDto ret = null;


ret = (ResultDto) this.transactionTemplate.execute(new TransactionCallback() {  
    @Override  
    public Object doInTransaction(TransactionStatus status) {  
        ResultDto ret = null;  
        try {  
            drillTaskDao.deleteByKey(taskid);  
        } catch (Exception e) {  
            logger.error("delDrillTask:" + e.getMessage(), e);  
            ret = ResultBuilder.buildResult(ResultBuilder.FAIL_CODE, null, ErrorCode.COM_DBDELETEERROR);  
            return ret;  
        }  
        finally {  
            status.setRollbackOnly();  
        }  

```
    ret = cleartaskrelativedata(taskid, appid, true);  
    return ret;  
}  
```

});  
return ret;
4.4 事务的传播行为和隔离级别
事物注解方式：

@Transactional，当标于类前时，标示类中所有方法都进行事物处理 。

@Transactional

public class TestServiceBean implements TestService {   
    private TestDao dao;   
    public void setDao(TestDao dao) {
        this.dao = dao;
    } 
    //当类中某些方法不需要事物时:  
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public List<Object> getAll() {
        return null;
    }   
}
事物传播行为：

@Transactional(propagation=Propagation.REQUIRED)
如果有事务，使用自己的事务；如果没有事务，使用调用者的事务；如果还是没有事务，新建一个(默认情况下)；如果发生异常回滚，整个事务都回滚
@Transactional(propagation=Propagation.SUPPORTS)
如果有事务或者调用者有事务，那就用事务，如果没有，那就不用事务
@Transactional(propagation=Propagation.NOT_SUPPORTED)
容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务；如果发生异常回滚，不会导致调用者也回滚
@Transactional(propagation=Propagation.NESTED)
与REQUIRES_NEW类似，但支持JDBC，不支持JPA和Hibernate
@Transactional(propagation=Propagation.MANDATORY)
必须在一个已有的事务中执行，否则抛出异常
@Transactional(propagation=Propagation.NEVER)
必须在一个没有的事务中执行，否则抛出异常(与Propagation.MANDATORY相反)

事物超时设置：

@Transactional(timeout=30)
默认是30秒

事务隔离级别：

@Transactional(isolation = Isolation.READ_UNCOMMITTED)
读取未提交数据(会出现脏读，不可重复读) 基本不使用
@Transactional(isolation = Isolation.READ_COMMITTED)
读取已提交数据(会出现不可重复读和幻读)
@Transactional(isolation = Isolation.REPEATABLE_READ)
可重复读(会出现幻读)
@Transactional(isolation = Isolation.SERIALIZABLE)
串行化

TS)
如果有事务或者调用者有事务，那就用事务，如果没有，那就不用事务
@Transactional(propagation=Propagation.NOT_SUPPORTED)
容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务；如果发生异常回滚，不会导致调用者也回滚
@Transactional(propagation=Propagation.NESTED)
与REQUIRES_NEW类似，但支持JDBC，不支持JPA和Hibernate
@Transactional(propagation=Propagation.MANDATORY)
必须在一个已有的事务中执行，否则抛出异常
@Transactional(propagation=Propagation.NEVER)
必须在一个没有的事务中执行，否则抛出异常(与Propagation.MANDATORY相反)

事物超时设置：

@Transactional(timeout=30)
默认是30秒

事务隔离级别：

@Transactional(isolation = Isolation.READ_UNCOMMITTED)
读取未提交数据(会出现脏读，不可重复读) 基本不使用
@Transactional(isolation = Isolation.READ_COMMITTED)
读取已提交数据(会出现不可重复读和幻读)
@Transactional(isolation = Isolation.REPEATABLE_READ)
可重复读(会出现幻读)
@Transactional(isolation = Isolation.SERIALIZABLE)
串行化

huizaishuibuxing
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
主流框架：SSM（Spring、SpringMVC、Mybatis）框架整合
rnang0的博客
09-22 864
主流框架：SSM（Spring、SpringMVC、Mybatis）框架整合一、搭建环境二、Spring框架三、SpringMVC框架四、Spring整合SpringMVC需要配置监听器实现启动服务创建容器五、Mybatis框架六、Spring整合Mybatis 一、搭建环境 （1）创建数据库，导入数据 （2）导入依赖坐标，创建子模块 （3）编写domain实体类，service层和dao层接...
了解Spring框架
晴天的博客
04-11 697
Spring框架 使对象的创建和对象的管理 可以交给框架去处理, 不用再关心对象的创建和管理
一文了解Spring框架
m0_61801103的博客
11-04 731
初学Spring框架
了解spring框架（第一篇）
qq_29525797的博客
08-28 115
框架简介 spring是2003年兴起的一个开源的、轻量级的框架，框架的主要优势之一就是分层结构，同时为J2EE应用程序开发提供集成的框架。spring用基本的JavaBean来完成以前只能由EJB完成的事情。spring的核心是控制反转（IOC）和面向切面（AOP）。 JavaEE开发分层结构 spring在JavaEE三层架构中的每一层都有不同的解决技术： WEB层：springMVC ser...
Spring框架-主流框架
01-15
Spring框架是中国乃至全球范围内最为流行的Java企业级应用开发框架，其设计目标是简化Java应用程序的开发，通过依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP）的理念，...
Spring框架学习指南
最新发布
06-20
这是一份专门针对Spring框架的中文学习教程，旨在帮助读者深入了解Spring的核心概念、特性和用法。无论是初学者还是有一定经验的开发者，都能从中获得宝贵的指导和参考。教程内容全面，涵盖了Spring的基础配置、核心...
spring框架搭建.rar
05-13
通过这三个部分的学习，你不仅可以掌握Spring框架的基本使用，还能深入了解Spring Boot的便捷性以及Spring Data如何与非关系型数据库集成。这些知识对于任何Java开发者来说都是非常宝贵的，无论你是初学者还是经验...
Spring框架入门资料
05-30
首先，"Spring讲义-IDEA版.doc"和"Spring讲义.doc"是两份详细的教程文档，它们通常会涵盖Spring框架的基本概念、核心组件如IoC容器、AOP、Bean管理、事务管理等内容。通过这些文档，你可以了解到Spring如何简化Java ...
spring知识框架详解
07-29
Spring : 春天 —>给软件行业带来了春天 2002年，Rod Jahnson首次推出了Spring框架雏形...你是否不了解spring,到底是什么，一张图完美诠释了spring的组成，优点，代理设计模式，面向切面编程，事务，整合mybatis等等。
快速了解Spring(超详细+干货满满)
adobe754的博客
02-15 1048
快速了解Spring(超详细+干货满满)
Spring框架介绍
探索科技 脚踏实地
09-04 3157
Spring是一个开源框架，是一个生态基石，什么是IOC和AOP，AOP是什么
spring框架详解（持续更新）
Ferao的博客
11-15 1万+
Mybatis Spring SpringMVC详解
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
带你深入了解spring框架
qq_56904337的博客
02-13 643
spring 首先，带大家回顾一下spring。 spring复习 spring是一个轻量级的，非侵入式的，IOC，AOP，一站式的，简化企业级开发而生的。 它的核心包非常小。业务代码中不侵入框架代码。 IOC：控制反转。 将生成对象的权利反转给了spring框架 依赖注入DI为属性注入值 AOP：面向切面编程，将一些与业务代码无关的公共部分抽取出来，使用时，通过代理对象调用，从而达不修改源代码的基础上增加功能，代码的耦合度降低。 一站式框架：数据持久层，web控制层… 那
什么是spring框架？spring特点与好处,使用spring框架的好处是什么.
热门推荐
技术积累
05-03 6万+
    Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开...
Spring的理解 入门
weixin_46895251的博客
09-08 2432
Spring框架—控制反转（IOC） 1 Spring框架概述 1.1 什么是Spring Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Sprin
深入理解Spring框架的作用
淡然坊
02-20 3万+
纵览Spring ， 读者会发现Spring 可以做非常多的事情。 但归根结底， 支撑Spring的仅仅是少许的基本理念， 所有的理念都可以追溯到Spring最根本的使命上： 简化Java开发。 Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？ 为了降低Java开发的复杂性， Spring采取了以下4种关键策略：
SSM框架详细实例讲解
Yang_Hui_Liang的博客
04-02 9495
SSM框架简介 SSM框架，是Spring + Spring MVC + MyBatis的缩写，这个是继SSH之后，目前比较主流的Java EE企业级框架，适用于搭建各种大型的企业级应用系统。 我们先大概的回顾一下吧。1.Spring简介 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One...
Spring框架简介.docx
06-15
Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。通过Spring框架，开发者可以解决开发中的基础性问题，使得他们可以更专注于应用程序的开发。Spring框架本身也是按照设计模式精心打造...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值