`

spring在事务中定义通知

SpringAOPBean编程XML 
阅读更多

一、      AOP术语

 

切面（Aspect）：需要实现的交叉功能

连接点（Join point）：应用程序执行过程中插入切面的地点；此处可是方法的调用、异常的抛出甚至是修改的字段。

通知（Advice）：通知切面的实际实现。它通知应用系统新的行为，通知在连接点插入到应用程序系统中。

切入点(point Cut)：定义通知应该应用在哪些连接点。通常指定的类名和方法名，或匹配类名和方法名样式的正则表达式来制定切入点

引入(Introduction):允许为已存在类添加新方法和属性。

目标对象(Target)：被通知的对象。既可是编写的类也可是添加定制行为的第三方类。

代理（Proxy）：将通知应用到目标对象后创建的对象。

织入（weaving）：将切面应用到目标对此那个从而创建一个心的代理对象的过程。切面是指接入点被织入到目标对象中，织入发生在目标对象生命周期的多个点上：

在指定接入点被织入到目标对象中，注入发生在目标对象生命周期的多个点上：

编译器：切面子啊目标对象编译时织入（需特殊的编译器）

类装载期：切面在目标对象被载入到jvm时织入（需要特殊的类载器，在类的载入到应用系统之前增强目标对象的字节码）

运行期：切面在用系统运行时织入（通常，AOP容器将在织入切面时动态）

二、      Sping中Aop的实现

 

(一)        创建通知

 

 

通知类型

接口

描述

Around

import org.aopalliance.intercept.MethodInterceptor;

拦截目标方法的前后调用

Before

import org.springframework.aop.MethodBeforeAdvice;

拦截目标方法前调用

After

import org.springframework.aop.AfterReturningAdvice;

拦截目标方法的之后调用

Throws

import org.springframework.aop.ThrowsAdvice;

目标抛出异常时调用

 

 

 

1.         前置通知

 

前置通知需要实现MethodBeforeAdvice接口

 

 

 

package com.csdn.util;   
  1. import java.lang.reflect.Method;   
  2. import org.springframework.aop.MethodBeforeAdvice;   
  3. public class StudentAdvice implements MethodBeforeAdvice {   
  4.     @Override  
  5.     public void before(Method arg0, Object[] arg1, Object arg2)   
  6.             throws Throwable {   
  7.         System.out.println("开始学习....的前置通知!!");         
  8.     }   
  9. }  
package com.csdn.util;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class StudentAdvice implements MethodBeforeAdvice {
	@Override
	public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {
		System.out.println("开始学习....的前置通知!!");		
	}
}

 

 

注：Method 的一个参数是要实现通知的目标方法（连接点）， arg1 为参数，arg2为目标对象。

 

目标对象

 

package com.csdn.service;   
  1.        
  2. public class StudentServiceImpl implements StudentService {   
  3.     @Override  
  4.     public void study() {   
  5.         System.out.println("调用学习的方法...");   
  6.     }   
  7.     @Override  
  8.     public void paly() {   
  9.         System.out.println("调用paly的方法....");   
  10.     }   
  11. }  
package com.csdn.service;
	
public class StudentServiceImpl implements StudentService {
	@Override
	public void study() {
		System.out.println("调用学习的方法...");
	}
	@Override
	public void paly() {
		System.out.println("调用paly的方法....");
	}
}

 

 

 

Student.xml中如下

 

 

<?xml version="1.0" encoding="UTF-8"?>   
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">   
  4.     <!-- 前置通知 -->   
  5.     <bean id="studentAdvice" class="com.csdn.util.StudentAdvice" />   
  6.     <!-- 目标对象 -->   
  7.     <bean id="studentServiceImpl" class="com.csdn.service.StudentServiceImpl"/>   
  8.     <!-- 代理对象 基于接口编程 -->   
  9.     <bean id="studentProxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">   
  10.         <!-- 代理的接口 -->   
  11.         <property name="proxyInterfaces">   
  12.             <list>   
  13.                 <value>com.csdn.service.StudentService</value>   
  14.             </list>   
  15.         </property>   
  16.         <!-- 拦截的名称 -->   
  17.         <property name="interceptorNames">   
  18.             <list>   
  19.             <!-- 不能有空格和换行 如：<value>   studentAdvice  </value> -->   
  20.                 <value>studentAdvice</value>   
  21.             </list>   
  22.         </property>   
  23.         <!-- 目标对象 -->   
  24.         <property name="target" ref="studentServiceImpl">   
  25.         </property>   
  26.     </bean>   
  27. </beans>  
<?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 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
	<!-- 前置通知 -->
	<bean id="studentAdvice" class="com.csdn.util.StudentAdvice" />
	<!-- 目标对象 -->
	<bean id="studentServiceImpl" class="com.csdn.service.StudentServiceImpl"/>
	<!-- 代理对象 基于接口编程 -->
	<bean id="studentProxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 代理的接口 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.csdn.service.StudentService</value>
			</list>
		</property>
		<!-- 拦截的名称 -->
		<property name="interceptorNames">
			<list>
			<!-- 不能有空格和换行 如：<value>   studentAdvice  </value> -->
				<value>studentAdvice</value>
			</list>
		</property>
		<!-- 目标对象 -->
		<property name="target" ref="studentServiceImpl">
		</property>
	</bean>
</beans>

 

注：测试接口时调用studentProxyFactoryBean如下

 ApplicationContext ac = new ClassPathXmlApplicationContext(   

  1.                 "applicationContext.xml");   
  2.         StudentService ss = (StudentService) ac   
  3.                 .getBean("studentProxyFactoryBean");   
ApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		StudentService ss = (StudentService) ac
				.getBean("studentProxyFactoryBean");

 

1.         后置通知

后置通知需要实现AfterReturningAdvice接口如下

 

package com.csdn.util;   
  1. import java.lang.reflect.Method;   
  2. import org.springframework.aop.AfterReturningAdvice;   
  3. public class StudentAfterAdvice implements AfterReturningAdvice {   
  4.     @Override  
  5.     public void afterReturning(Object returnType, Method method, Object[] arg2,Object targeType) throws Throwable {   
  6.         System.out.println("后置处理 ");   
  7.     }   
  8. }   
  9.   
  10. 目标对象   
  11. package com.csdn.service;   
  12. public class StudentServiceImpl implements StudentService {   
  13.     @Override  
  14.     public void study() {   
  15.         System.out.println("调用学习的方法...");   
  16.     }   
  17.     @Override  
  18.     public void paly() {   
  19.         System.out.println("调用paly的方法....");   
  20.     }   
  21. }  
package com.csdn.util;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class StudentAfterAdvice implements AfterReturningAdvice {
	@Override
	public void afterReturning(Object returnType, Method method, Object[] arg2,Object targeType) throws Throwable {
		System.out.println("后置处理 ");
	}
}

目标对象
package com.csdn.service;
public class StudentServiceImpl implements StudentService {
	@Override
	public void study() {
		System.out.println("调用学习的方法...");
	}
	@Override
	public void paly() {
		System.out.println("调用paly的方法....");
	}
}

 

 

 

 

 

 

3.  环绕通知   
  1.   
  2. 环绕通知实现MethodInterceptor接口：   
  3. 实现的方法为   
  4. package com.csdn.util;   
  5. import org.aopalliance.intercept.MethodInterceptor;   
  6. import org.aopalliance.intercept.MethodInvocation;   
  7. public class StudentAround implements MethodInterceptor {   
  8.     @Override  
  9.     public Object invoke(MethodInvocation invocation) throws Throwable {   
  10.         System.out.println("前");   
  11.         Object obj=invocation.proceed();//调用目标方法   
  12.         System.out.println("后");   
  13.         return obj;   
  14.     }   
  15. }   
  16. 与前面的两种区别   
  17.    MethodInterceptor能控制方法是否真的被调用。通过调用MethodInvocation的Proceed（）方法来调用目标方法。   
  18.    Method能控制返回的对象。   
  19.   
  20.   
  21. 4.  异常通知   
  22.   
  23. 异常通知需要是想的接口是ThrowsAdvice   
  24.   
  25. package com.csdn.util;   
  26. import java.lang.reflect.Method;   
  27. import org.springframework.aop.ThrowsAdvice;   
  28. public class StudentException implements ThrowsAdvice {   
  29.     public void afterThrowing(Method method, Object[] args, Object target,   
  30.             Exception ex) {   
  31.         System.out.println("方法的名称：" + method + "方法的参数" + args.length + "目标对象："  
  32.                 + target.getClass().getName() + "异常" + ex.getMessage());   
  33.     }   
  34. }   
  35.   
  36. Xml中如下   
  37.   
  38.   
  39. <!-- 异常对象的获取 -->   
  40.     <bean id="studentException" class="com.csdn.util.StudentException" />   
  41.     <!-- 目标对象 -->   
  42.     <bean id="studentServiceImpl" class="com.csdn.service.StudentServiceImpl"/>   
  43.     <!-- 代理对象 基于接口编程 -->   
  44.     <bean id="studentProxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">   
  45.         <!-- 代理的接口 -->   
  46.         <property name="proxyInterfaces">   
  47.             <list>   
  48.                 <value>com.csdn.service.StudentService</value>   
  49.             </list>   
  50.         </property>   
  51.         <!-- 拦截的名称 -->   
  52.         <property name="interceptorNames">   
  53.             <list>   
  54.             <!-- 不能有空格和换行 如：<value>   studentAdvice  </value> -->   
  55.                 <value>studentException</value>   
  56.             </list>   
  57.         </property>   
  58.         <!-- 目标对象 -->   
  59.         <property name="target" ref="studentServiceImpl">   
  60.         </property>   
  61.     </bean>  
3.	环绕通知

环绕通知实现MethodInterceptor接口：
实现的方法为
package com.csdn.util;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class StudentAround implements MethodInterceptor {
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("前");
		Object obj=invocation.proceed();//调用目标方法
		System.out.println("后");
		return obj;
	}
}
与前面的两种区别
	MethodInterceptor能控制方法是否真的被调用。通过调用MethodInvocation的Proceed（）方法来调用目标方法。
	Method能控制返回的对象。


4.	异常通知

异常通知需要是想的接口是ThrowsAdvice

package com.csdn.util;
import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
public class StudentException implements ThrowsAdvice {
	public void afterThrowing(Method method, Object[] args, Object target,
			Exception ex) {
		System.out.println("方法的名称：" + method + "方法的参数" + args.length + "目标对象："
				+ target.getClass().getName() + "异常" + ex.getMessage());
	}
}

Xml中如下


<!-- 异常对象的获取 -->
	<bean id="studentException" class="com.csdn.util.StudentException" />
	<!-- 目标对象 -->
	<bean id="studentServiceImpl" class="com.csdn.service.StudentServiceImpl"/>
	<!-- 代理对象 基于接口编程 -->
	<bean id="studentProxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 代理的接口 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.csdn.service.StudentService</value>
			</list>
		</property>
		<!-- 拦截的名称 -->
		<property name="interceptorNames">
			<list>
			<!-- 不能有空格和换行 如：<value>   studentAdvice  </value> -->
				<value>studentException</value>
			</list>
		</property>
		<!-- 目标对象 -->
		<property name="target" ref="studentServiceImpl">
		</property>
	</bean>

 

Student.xml中如下   
  1.     <!-- 后置通知 -->   
  2. <bean id="studentAfterAdvice"class="com.csdn.util.StudentAfterAdvice"/>   
  3.     <!-- 目标对象 -->   
  4.     <bean id="studentServiceImpl" class="com.csdn.service.StudentServiceImpl"/>   
  5.     <!-- 代理对象 基于接口编程 -->   
  6.     <bean id="studentProxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">   
  7.         <!-- 代理的接口 -->   
  8.         <property name="proxyInterfaces">   
  9.             <list>   
  10.                 <value>com.csdn.service.StudentService</value>   
  11.             </list>   
  12.         </property>   
  13.         <!-- 拦截的名称 -->   
  14.         <property name="interceptorNames">   
  15.             <list>   
  16.             <!-- 不能有空格和换行 如：<value>   studentAdvice  </value> -->   
  17.                 <value>studentAfterAdvice</value>   
  18.             </list>   
  19.         </property>   
  20.         <!-- 目标对象 -->   
  21.         <property name="target" ref="studentServiceImpl">   
  22.         </property>   
  23.     </bean>   
  24.   
  25. 注：测试接口时调用studentProxyFactoryBean如下   
  26.     ApplicationContext ac = new ClassPathXmlApplicationContext(   
  27.                 "applicationContext.xml");   
  28.         StudentService ss = (StudentService) ac   
  29.                 .getBean("studentProxyFactoryBean");   
Student.xml中如下
	<!-- 后置通知 -->
<bean id="studentAfterAdvice"class="com.csdn.util.StudentAfterAdvice"/>
	<!-- 目标对象 -->
	<bean id="studentServiceImpl" class="com.csdn.service.StudentServiceImpl"/>
	<!-- 代理对象 基于接口编程 -->
	<bean id="studentProxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 代理的接口 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.csdn.service.StudentService</value>
			</list>
		</property>
		<!-- 拦截的名称 -->
		<property name="interceptorNames">
			<list>
			<!-- 不能有空格和换行 如：<value>   studentAdvice  </value> -->
				<value>studentAfterAdvice</value>
			</list>
		</property>
		<!-- 目标对象 -->
		<property name="target" ref="studentServiceImpl">
		</property>
	</bean>

注：测试接口时调用studentProxyFactoryBean如下
	ApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		StudentService ss = (StudentService) ac
				.getBean("studentProxyFactoryBean");

 

分享到：
| javascript 键盘监听
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring事务与数据库操作

    ### Spring事务与数据库操作 #### 一、Spring的声明式事务管理 在现代软件开发中，事务处理是非常关键的一部分，特别是在涉及多个数据操作时。Spring框架提供了强大的事务管理能力，可以方便地集成到应用程序中。...

    spring3.0两种事务管理配置

    这种方法只需要在 Spring 配置文件中定义一个事务管理对象（如 DataSourceTransactionManager），然后加入 `&lt;tx:annotation-driven/&gt;` 节点，引用该事务管理对象，然后即可在需要进行事务处理的类和方法使用 `@...

    SPRING事务机制DEMO

    Spring事务机制是Java开发中非常重要的一个概念，它在企业级应用中扮演着核心角色，确保数据的一致性和完整性。Spring提供了多种事务管理方式，包括编程式事务管理和声明式事务管理。在这篇DEMO中，我们将重点探讨...

    Spring基于XML方式配置事务

    这里我们主要探讨的是"Spring基于XML方式配置事务"，这涉及到Spring的事务管理器、事务属性以及如何在XML配置文件中定义这些元素。 首先，Spring的事务管理分为两种模式：编程式事务管理和声明式事务管理。编程式...

    spring 事务(6中配置完全降解)

    本篇文章将详细解析Spring中的六种事务配置方法，帮助开发者深入理解并掌握Spring事务的运用。 1. **基于XML的事务配置** Spring支持通过XML配置来管理事务，这是最基础的配置方式。在`spring`的配置文件中，我们...

    Spring aop、jdbc和事务tx练习

    在Spring AOP中，切面可以包含通知（advice），即在特定连接点（join point）执行的代码，如方法调用前后。例如，日志记录、性能监控或异常处理都可以作为切面实现。Spring AOP通过代理模式实现，可以是JDK动态代理...

    Spring声明式事务处理

    1. **基于XML的配置**：在Spring的`&lt;tx:advice&gt;`和`&lt;aop:config&gt;`标签中定义事务策略。例如，`&lt;tx:method&gt;`标签用于指定哪些方法需要在事务中执行，可以通过`name`属性指定方法名，`propagation`属性定义事务传播...

    spring，struts，hibernate，事务

    例如，可以在XML配置文件中定义一个事务通知，然后将其应用到具有特定注解或接口的类或方法上。这样，当新的DAO或Mgr需要事务支持时，只需要简单地加入对应的注解或实现指定的接口，而无需修改现有的事务配置。 在...

    Spring_tx事务

    本篇文章将深入探讨Spring事务管理的基础知识、工作原理以及如何在实际项目中应用。 首先，事务是数据库操作的基本单位，它确保了一组操作要么全部成功，要么全部失败，从而保证了数据的完整性和一致性。在Spring中...

    Spring AOP四种创建通知(拦截器)类型

    环绕通知是在目标方法调用前后都会执行的通知类型，它是四种通知中最强大的一种，因为它不仅可以控制目标方法是否被调用，还可以完全控制返回值。要实现环绕通知，类需实现`MethodInterceptor`接口并实现`invoke`...

    Spring配置JTA事务管理

    Spring框架在企业级Java应用中广泛用于实现事务管理，而JTA（Java Transaction API）是Java平台上的标准事务处理API，适用于分布式环境。本篇文章将深入探讨如何在Spring中配置JTA事务管理，以实现跨数据库和资源的...

    spring事务管理

    1. **事务定义**：`DefaultTransactionDefinition`用于设置事务的一些属性，如隔离级别、传播行为等。 2. **事务状态**：`TransactionStatus`对象表示当前事务的状态。 3. **事务管理器**：`...

    Spring 前置通知和后置通知

    在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点从业务逻辑中分离出来，比如日志记录、事务管理等。本文将深入探讨Spring AOP中的前置通知和后置通知，以及它们在实际开发中的应用...

    spring基于AspectJ实现事务控制

    在Spring框架中，提供了多种事务管理方式，其中之一就是基于AspectJ的事务控制。本文将深入探讨如何在Spring中利用AspectJ实现事务控制。 首先，我们需要理解什么是AspectJ。AspectJ是一种面向切面编程（AOP）的...

    spring通知例子

    在Spring AOP中，我们可以通过实现`org.springframework.aop.BeforeAdvice`接口或使用`@Before`注解来定义前置通知。 2. **后置通知**：无论目标方法是否成功执行，都会在方法执行之后调用。在Spring AOP中，可以...

    spring AOP注解的应用1

    在Spring AOP中，我们使用`@Before`注解来定义一个前置通知。这个注解需要与一个方法关联，该方法将在目标方法执行前被调用。例如： ```java @Aspect public class LoggingAspect { @Before("execution(* ...

    Spring延迟加载和声明式事务处理最终解决方案(修正版)

    - **XML配置**：在Spring的配置文件中定义事务管理器（如`PlatformTransactionManager`），并声明事务的通知（advice），指定哪些方法需要进行事务处理。 - **Java配置**：使用`@EnableTransactionManagement`注解...

    Spring通知的配置

    在Spring AOP中，通知（Advice）是一种特定类型的切面，它定义了切面应该执行的行为。Spring支持五种类型的通知： 1. **前置通知**：在目标方法执行前调用。 2. **后置通知**：无论方法是否成功执行，都会在其后...

    Spring.net通知类型，以及通知链

    每个通知可以在其内部调用` Proceed()` 方法来触发下一个通知，或者在环绕通知中不调用`Proceed()`来阻止方法的执行。 - 通知链的执行顺序由`AdviceOrder`属性控制，数值越小，优先级越高，先执行。默认情况下，...

    SpringAop xml方式配置通知

    在Spring中，我们可以通过XML配置文件来定义切面、切入点和通知。以下是一个基本的XML配置示例： ```xml &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...

Magicbox
Global site tag (gtag.js) - Google Analytics