`
duyouhua1214
  • 浏览: 235931 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Spring AOP的两种实现方式

    博客分类:
  • Java
阅读更多

来源:http://javacrazyer.iteye.com/blog/794143

AOP常用实现方式是一个采用声明的方式来实现,一个采用注解的方式来实现,

温习下一些概念

   Joinpoint(连接点):程序执行时的某个特定的点,在Spring中就是某一个方法的执行
    Pointcut(切点):说的通俗点,spring中AOP的切点就是指一些方法的集合,而这些方法
是需要被增强、被代理的。一般都是按照一定的约定规则来表示的,如正则表达式等。切点是
由一类连接点组成。
    Advice(通知):还是说的通俗点,就是在指定切点上要干些什么。
    Advisor(通知器):其实就是切点和通知的结合 
     
第一种,为最基本的用法,大致步骤为:配置文件中配置pointcut, 在java中用编写实际的aspect 类, 针对对切入点进行相关的业务处理.

   编写目标对象类(CommonEmployee.java),具体代码如下(省略接口类):

Java代码 复制代码
  1. <SPAN style="FONT-SIZE: medium">package com.aop;   
  2.   
  3. public class CommonEmployee implements Employee{   
  4.   
  5.     private String name;   
  6.        
  7.     public String getName() {   
  8.         return name;   
  9.     }   
  10.   
  11.     public void setName(String name) {   
  12.         this.name = name;   
  13.     }   
  14.        
  15.     public void signIn() {   
  16.        System.out.println(name+"已经签到了...........");   
  17.     }   
  18. }</SPAN>  
package com.aop;

public class CommonEmployee implements Employee{

	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void signIn() {
	   System.out.println(name+"已经签到了...........");
	}
}

 

具体通知类Logger.java如下:

Java代码 复制代码
  1. <SPAN style="FONT-SIZE: medium">package com.aop;   
  2.   
  3. import java.util.Date;   
  4. import org.aspectj.lang.ProceedingJoinPoint;   
  5.   
  6. public class Logger{   
  7.   
  8.     //spring中Before通知   
  9.     public void logBefore() {   
  10.         System.out.println("logBefore:现在时间是:....");   
  11.     }   
  12.        
  13.     //spring中After通知   
  14.     public void logAfter() {   
  15.         System.out.println("logAfter:现在时间是:.....");   
  16.     }   
  17.        
  18.     //spring中Around通知   
  19.     public Object logAround(ProceedingJoinPoint joinPoint) {   
  20.         System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理   
  21.         Object[] args = joinPoint.getArgs();   
  22.         Object obj = null;   
  23.         try {   
  24.             obj = joinPoint.proceed(args);   
  25.         } catch (Throwable e) {   
  26.             e.printStackTrace();   
  27.         }   
  28.         System.out.println("logAround结束:现在时间是:.....");  //方法执行后的代理处理   
  29.         return obj;   
  30.     }   
  31.        
  32. }</SPAN>  
package com.aop;

import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;

public class Logger{

    //spring中Before通知
	public void logBefore() {
		System.out.println("logBefore:现在时间是:....");
	}
	
	//spring中After通知
	public void logAfter() {
		System.out.println("logAfter:现在时间是:.....");
	}
	
	//spring中Around通知
	public Object logAround(ProceedingJoinPoint joinPoint) {
		System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理
		Object[] args = joinPoint.getArgs();
		Object obj = null;
		try {
			obj = joinPoint.proceed(args);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("logAround结束:现在时间是:.....");  //方法执行后的代理处理
		return obj;
	}
	
}

Spring配置

Xml代码 复制代码
  1. <SPAN style="FONT-SIZE: medium"><bean id="employee" class="com.aop.CommonEmployee">  
  2.       <property name="name" value="good"></property>  
  3.     </bean>  
  4.     <bean id="advice" class="com.aop.Logger" />  
  5.    <aop:config >  
  6.      <aop:aspect ref="advice">  
  7.         <aop:pointcut id="pointcut" expression="execution(* com.aop.CommonEmployee.sign*(..))"/>  
  8.         <aop:before method="logBefore" pointcut-ref="pointcut"/>  
  9.         <aop:after method="logAfter" pointcut-ref="pointcut"/>  
  10.         <aop:around method="logAround" pointcut-ref="pointcut"/>  
  11.       </aop:aspect>  
  12.    </aop:config></SPAN>  
<bean id="employee" class="com.aop.CommonEmployee">
      <property name="name" value="good"></property>
    </bean>
    <bean id="advice" class="com.aop.Logger" />
   <aop:config >
     <aop:aspect ref="advice">
        <aop:pointcut id="pointcut" expression="execution(* com.aop.CommonEmployee.sign*(..))"/>
        <aop:before method="logBefore" pointcut-ref="pointcut"/>
        <aop:after method="logAfter" pointcut-ref="pointcut"/>
        <aop:around method="logAround" pointcut-ref="pointcut"/>
      </aop:aspect>
   </aop:config>

 测试类

Java代码 复制代码
  1. <SPAN style="FONT-SIZE: medium">package com;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5.   
  6. import com.aop.Employee;   
  7.   
  8. public class Test {   
  9.     public static void main(String[] args) throws Exception{   
  10.         ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-aop.xml");   
  11.         Employee e = (Employee)act.getBean("employee");   
  12.         e.signIn();   
  13.            
  14.     }   
  15. }</SPAN>  
package com;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.aop.Employee;

public class Test {
	public static void main(String[] args) throws Exception{
     	ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-aop.xml");
     	Employee e = (Employee)act.getBean("employee");
        e.signIn();
		
	}
}

 测试结果

  logBefore:现在时间是.....

  logAround开始:现在时间是:....

  good已经签到了...........
  logAfter:现在时间是:...

  logAround结束:现在时间是:...... 

 

 

第二种, 采用注解来做aop, 主要是将写在spring 配置文件中的连接点, 写到注解里面

   首先,在spring配置文件中加入如下配置(用来申明spring对@AspectJ的支持):
    <aop:aspectj-autoproxy/>   
如果你使用的是DTD,可以在Spring配置文件中加入如下配置来申明spring对@Aspect的支
持:
  
<bean class="org.springframework.aop.aspectj.annotation.
                       AnnotationAwareAspectJAutoProxyCreator" />

   目标对象类与上边一样

   具体通知类如下

Java代码 复制代码
  1. <SPAN style="FONT-SIZE: medium">package com.aop;   
  2.   
  3. import java.util.Date;   
  4.   
  5. import org.aspectj.lang.ProceedingJoinPoint;   
  6. import org.aspectj.lang.annotation.After;   
  7. import org.aspectj.lang.annotation.Around;   
  8. import org.aspectj.lang.annotation.Aspect;   
  9. import org.aspectj.lang.annotation.Before;   
  10.   
  11. /**  
  12.  * 使用@Aspect 注解的类, Spring 将会把它当作一个特殊的Bean(一个切面),也就是  
  13.  * 不对这个类本身进行动态代理  
  14.  */  
  15. @Aspect     
  16. public class AspectJLogger {   
  17.     /**  
  18.      * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的  
  19.      */  
  20.     public static final String EDP = "execution(* com.aop.CommonEmployee.sign*(..))";   
  21.        
  22.     @Before(EDP)    //spring中Before通知   
  23.     public void logBefore() {   
  24.         System.out.println("logBefore:现在时间是:......");   
  25.     }   
  26.        
  27.     @After(EDP)    //spring中After通知   
  28.     public void logAfter() {   
  29.         System.out.println("logAfter:现在时间是:.....");   
  30.     }   
  31.        
  32.     @Around(EDP)   //spring中Around通知   
  33.     public Object logAround(ProceedingJoinPoint joinPoint) {   
  34.         System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理   
  35.         Object[] args = joinPoint.getArgs();   
  36.         Object obj = null;   
  37.         try {   
  38.             obj = joinPoint.proceed(args);   
  39.         } catch (Throwable e) {   
  40.             e.printStackTrace();   
  41.         }   
  42.         System.out.println("logAround结束:现在时间是:.....");  //方法执行后的代理处理   
  43.         return obj;   
  44.     }   
  45. }</SPAN>  
package com.aop;

import java.util.Date;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * 使用@Aspect 注解的类, Spring 将会把它当作一个特殊的Bean(一个切面),也就是
 * 不对这个类本身进行动态代理
 */
@Aspect  
public class AspectJLogger {
    /**
     * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的
     */
	public static final String EDP = "execution(* com.aop.CommonEmployee.sign*(..))";
	
	@Before(EDP)    //spring中Before通知
	public void logBefore() {
		System.out.println("logBefore:现在时间是:......");
	}
	
	@After(EDP)    //spring中After通知
	public void logAfter() {
		System.out.println("logAfter:现在时间是:.....");
	}
	
	@Around(EDP)   //spring中Around通知
	public Object logAround(ProceedingJoinPoint joinPoint) {
		System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理
		Object[] args = joinPoint.getArgs();
		Object obj = null;
		try {
			obj = joinPoint.proceed(args);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("logAround结束:现在时间是:.....");  //方法执行后的代理处理
		return obj;
	}
}

 

 Spring的配置

Xml代码 复制代码
  1. <SPAN style="FONT-SIZE: medium">    <aop:aspectj-autoproxy/>    
  2.     <bean id="aspect" class="com.aop.AspectJLogger" />  
  3.     <bean id="employee" class="com.aop.CommonEmployee">  
  4.       <property name="name" value="good"></property>  
  5.     </bean></SPAN>  
    <aop:aspectj-autoproxy/> 
    <bean id="aspect" class="com.aop.AspectJLogger" />
    <bean id="employee" class="com.aop.CommonEmployee">
      <property name="name" value="good"></property>
    </bean>

 

测试类与上边一样

测试结果

      logBefore:现在时间是:....

      logAround开始:现在时间是:....

      good已经签到了...........
      logAfter:现在时间是:....

      logAround结束:现在时间是:....

注意:
      1.环绕方法通知,环绕方法通知要注意必须给出调用之后的返回值,否
        则被代理的方法会停止调用并返回null,除非你真的打算这么做。 
               
       2.只有环绕通知才可以使用JoinPoint的子类ProceedingJoinPoint,个 
         连接点类型可以调用代理的方法,并获取、改变返回值。


分享到:
评论

相关推荐

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    在 Spring 中,AOP 的实现主要依赖于代理模式,有两种代理方式:JDK 动态代理和 CGLIB 动态代理。 JDK 动态代理是基于接口的,它要求被代理的目标对象必须实现至少一个接口。Spring 使用 `java.lang.reflect.Proxy`...

    spring aop demo 两种实现方式

    压缩包中的"aop"文件可能包含了一个简单的Spring AOP示例项目,包括了上述两种实现方式的源代码和配置文件。下载后,可以直接运行以观察AOP如何工作。 总结来说,Spring AOP提供了一种强大的方式来实现横切关注点,...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    动态代理是实现AOP的一种常用技术,它允许在运行时创建代理对象,拦截对真实对象的调用,并在调用前后添加额外的行为。 在Java开发中,反射机制是实现动态代理的关键技术之一。反射提供了在运行时访问和操作类的...

    Spring AOP实现机制

    Spring AOP主要通过两种方式实现:JDK动态代理和CGLIB代理。 - **JDK动态代理**: - 当目标对象实现了至少一个接口时,Spring会使用JDK的java.lang.reflect.Proxy类创建一个代理对象。 - 代理对象在调用实际方法...

    Spring AOP的简单实现

    在Spring AOP中,切面可以通过两种方式定义:使用注解或者XML配置。在这个例子中,我们可能会选择注解方式,因为它更简洁且易于理解。 1. **创建切面类(Aspect)** 我们可以创建一个名为`LoggingAspect`的Java类...

    springAop的配置实现

    - **代理(Proxy)**:Spring AOP通过代理模式来实现切面功能,有JDK动态代理和CGLIB代理两种方式。 **2. JDK 动态代理** - 当目标类实现了接口时,Spring AOP会选择使用JDK动态代理。它会生成一个实现了目标类所有...

    Spring实现AOP的4种方式

    每种实现方式都有其适用场景和优缺点。基于代理的方式简单易懂,但受限于目标对象是否需要实现接口;AspectJ注解方式简化了代码,提高了可读性;XML配置提供了清晰的结构,适合大型项目;Java配置则结合了灵活性和可...

    Spring AOP 16道面试题及答案.docx

    Spring支持两种AOP的实现方式:Spring AspectJ注解风格和Spring XML配置风格。使用AspectJ注解风格是最常见的,它允许开发者直接在方法上使用注解来定义切面。 Spring AOP中有五种不同类型的的通知(Advice): 1....

    Spring AOP的底层实现技术

    Spring AOP基于两种代理机制实现:JDK动态代理和CGLIB代理。JDK动态代理适用于实现了接口的目标对象,通过反射机制创建一个代理类来拦截方法调用。而CGLIB是在运行时动态生成一个目标类的子类,从而实现对方法的...

    springAop默认代理方式.zip

    1. **静态代理**:Spring AOP 提供了两种代理方式,一种是静态代理,另一种是动态代理。静态代理是在编译时就确定了代理类,这种代理方式通常通过实现相同接口的方式创建。然而,Spring AOP默认并不使用静态代理,...

    简单spring aop 例子

    在Spring AOP中,切面主要通过两种方式实现:代理(Proxies)和织入(Weaving)。 1. **代理**:Spring AOP支持两种类型的代理:JDK动态代理和CGLIB代理。JDK代理用于实现了接口的类,而CGLIB代理则用于没有接口或...

    初探spring aop内部实现 java

    Spring AOP的实现主要依赖于两种技术:动态代理和AspectJ。对于接口,Spring使用Java动态代理(JDK Proxy)创建代理对象;而对于类,Spring则使用CGLIB库生成子类代理。这两种方式都是在运行时生成代理对象,从而在...

    springboot spring aop 拦截器注解方式实现脱敏

    总结一下,通过上述步骤,我们已经在Spring Boot应用中利用Spring AOP和注解方式实现了数据脱敏。这个拦截器可以在不修改原有业务代码的情况下,确保敏感信息在响应给客户端之前得到处理,提高了应用的安全性。同时...

    SpringAop学习笔记以及实现Demo

    1. **基于代理的AOP**:Spring提供了两种代理方式,JDK动态代理和CGLIB代理。JDK动态代理主要针对接口实现,而CGLIB代理则针对类实现。 2. **基于注解的AOP**:Spring 2.5开始支持注解驱动的AOP,通过在方法上使用`...

    Spring AOP面向切面三种实现

    本文将详细解析Spring AOP的三种实现方式,帮助你深入理解这一重要概念。 首先,理解AOP的基本概念至关重要。AOP是一种编程范式,它允许开发者定义“切面”,即关注点的模块化,如日志、事务管理等。这些切面可以...

    SpringAop两种配置demo

    Spring AOP,全称Spring面向切面编程,是Spring框架中的一个重要组成部分,它提供了一种在不修改原有代码的情况下,对...了解并熟练掌握这两种配置方式,能够帮助我们更好地利用Spring AOP提高代码的可维护性和复用性。

    springAOP配置动态代理实现

    动态代理则是Spring AOP实现的核心技术之一,它允许我们在运行时创建具有额外行为的对象。下面将详细阐述Spring AOP的配置以及动态代理的实现。 一、Spring AOP基础知识 1. **什么是AOP**:AOP是一种编程范式,...

    一个简单的spring AOP的实现

    1. 注解驱动的AOP:这是最常用的实现方式,通过在方法上添加注解(如`@Before`, `@After`, `@Around`, `@AfterReturning`, `@AfterThrowing`)来定义通知,并使用`@Aspect`注解定义切面。 2. XML配置驱动的AOP:...

    spring aop注解方式、xml方式示例

    Spring AOP提供了注解和XML两种方式来实现切面编程。注解方式更加简洁,易于理解和维护,适用于大多数情况。而XML配置方式则在复杂场景下更具灵活性,如需要动态调整切面配置时。在实际项目中,可以根据需求选择适合...

    反射实现 AOP 动态代理模式(Spring AOP 的实现 原理) - Java 例子 -

    Spring AOP的实现方式主要有两种:静态代理和动态代理。静态代理是开发者手动创建代理类,而动态代理则是在运行时生成代理对象,这正是反射发挥作用的地方。在Java中,可以使用`java.lang.reflect.Proxy`类和`java....

Global site tag (gtag.js) - Google Analytics