spring aop 注解入门

转载 2015年07月08日 20:18:42

面向方法的切面:

执行前:对入参D inData或者调用者进行处理

执行后:对返回值T 或者调用者进行处理

异常处理:对获取的异常或调用者进行处理

执行之中:对调用者,入参,返回值,以及异常进行处理--很强大,其实直接用这个就行。

 

小例子:

1.有一个业务,很简单,对传入的参数进行处理,然后返回

 

Java代码  收藏代码
  1. package com.aop.service;  
  2.   
  3.   
  4. import org.springframework.stereotype.Component;  
  5.   
  6. import com.aop.bo.InputVal;  
  7. import com.aop.bo.ReturnVal;  
  8.   
  9. @Component  
  10. public class ServiceImpl {  
  11.     public ReturnVal getData(InputVal val) throws Exception{  
  12.         ReturnVal rtVal = new ReturnVal();  
  13.         //模拟处理  
  14.         rtVal.setKey(val.getKey()+"处理后");  
  15.         rtVal.setValue(val.getValue()+"处理后");  
  16.         System.out.println("------------执行中-------------");  
  17.         //模拟异常  
  18. //      if(val.getKey().equals("ex")){  
  19. //          throw new Exception("异常!");  
  20. //      }  
  21.         return rtVal;  
  22.     }  
  23.       
  24.     public String toString() {  
  25.         return "ServiceImpl调用者";  
  26.     }  
  27.   
  28. }  
 

2.入参数据:

 

Java代码  收藏代码
  1. package com.aop.bo;  
  2.   
  3.   
  4. public class InputVal {  
  5.     private String key = null;  
  6.     private String value = null;  
  7.     public String getKey() {  
  8.         return key;  
  9.     }  
  10.     public void setKey(String key) {  
  11.         this.key = key;  
  12.     }  
  13.     public String getValue() {  
  14.         return value;  
  15.     }  
  16.     public void setValue(String value) {  
  17.         this.value = value;  
  18.     }  
  19.     @Override  
  20.     public String toString() {  
  21.         return "InputVal [key=" + key + ", value=" + value + "]";  
  22.     }  
  23.       
  24.       
  25. }  

 

 3.出参数据:

 

Java代码  收藏代码
  1. package com.aop.bo;  
  2.   
  3. public class ReturnVal {  
  4.     private String key = null;  
  5.     private String value = null;  
  6.       
  7.     public String getKey() {  
  8.         return key;  
  9.     }  
  10.     public void setKey(String key) {  
  11.         this.key = key;  
  12.     }  
  13.     public String getValue() {  
  14.         return value;  
  15.     }  
  16.     public void setValue(String value) {  
  17.         this.value = value;  
  18.     }  
  19.     @Override  
  20.     public String toString() {  
  21.         return "ReturnVal [key=" + key + ", value=" + value + "]";  
  22.     }  
  23.       
  24. }  
 

 

4.对业务进行切面:

 

Java代码  收藏代码
  1. package com.aop.aop;  
  2.   
  3.   
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5. import org.aspectj.lang.annotation.Around;  
  6. import org.aspectj.lang.annotation.Aspect;  
  7. import org.springframework.stereotype.Component;  
  8.   
  9. import com.aop.bo.InputVal;  
  10. import com.aop.bo.ReturnVal;  
  11.   
  12. @Component  
  13. @Aspect  
  14. public class AopService {  
  15.       
  16. //  @Pointcut("execution(* com.aop.service.ServiceImpl.getData(..))")  
  17. //  private void cut(){}  
  18.     private final String CUT = "execution(* com.aop.service.ServiceImpl.getData(..))";  
  19.       
  20.     /* 
  21.     //方法执行前调用 
  22.     @Before(CUT) 
  23.     public void before(){ 
  24.         System.out.println("-----------执行前--------------------"); 
  25.     } 
  26.      
  27.     //方法执行后调用   
  28.     @After(CUT)   
  29.     public void after() {   
  30.         System.out.println("------------执行后------");   
  31.     } 
  32.     */  
  33.     @Around(CUT)   //spring中Around通知  环绕通知  
  34.     public Object logAround(ProceedingJoinPoint joinPoint) {  
  35.         Object tarjet = joinPoint.getTarget();//1.调用者  
  36.         //-----日志,调用者  
  37.         System.out.println("1.调用者:------"+tarjet);  
  38.           
  39.         Object[] args = joinPoint.getArgs();//2.传参  
  40.         System.out.println("2.传参:----"+args[0]);  
  41.           
  42.         if(args[0instanceof InputVal){  
  43.             InputVal val = (InputVal) args[0];  
  44.             val.setKey(val.getKey()+"改了么?");  
  45.         }  
  46.           
  47.         Object obj = null;  
  48.         try {  
  49.             obj = joinPoint.proceed(args);  
  50.             if(obj.getClass().equals(ReturnVal.class)){  
  51.                 ReturnVal rval = (ReturnVal) obj;  
  52.                 rval.setValue(rval.getValue()+"改了?");  
  53.             }  
  54.         } catch (Throwable e) {  
  55.             e.printStackTrace();  
  56.         }  
  57.           
  58.         System.out.println("3.返回参数:---"+obj);//3.返回参数  
  59.           
  60.         return obj;  
  61.     }   
  62. }  

 

 5.调用测验:

 

Java代码  收藏代码
  1. package com.aop.test;  
  2.   
  3.   
  4. import org.springframework.context.ApplicationContext;  
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  6.   
  7. import com.aop.bo.InputVal;  
  8. import com.aop.service.ServiceImpl;  
  9.   
  10. public class Main {  
  11.   
  12.     /** 
  13.      * @param args 
  14.      * @throws Exception  
  15.      */  
  16.     public static void main(String[] args) throws Exception {  
  17.         ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");  
  18.           
  19.         ServiceImpl si = (ServiceImpl) ctx.getBean("serviceImpl");  
  20.           
  21.         InputVal val = new InputVal();  
  22.         val.setKey("inKey");  
  23.         val.setValue("inVal");  
  24.         System.out.println(si.getData(val));  
  25.     }  
  26.   
  27. }  

 

 6.配置文件,要打开aop注解扫描:

 

Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop"  
  5.     xmlns:context="http://www.springframework.org/schema/context"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  7.  http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  8.  http://www.springframework.org/schema/context  
  9.  http://www.springframework.org/schema/context/spring-context-2.5.xsd  
  10.  http://www.springframework.org/schema/aop  
  11.  http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
  12.       
  13.    
  14.     <!-- 扫描com.ioc下的所有类,自动为spring容器管理 -->  
  15.     <context:component-scan base-package="com"/>  
  16.      <!-- 打开面向切面工具 -->  
  17.      <aop:aspectj-autoproxy/>  
  18. </beans>  
 

使用Spring的注解方式实现AOP入门

首先在Eclipse中新建一个普通的Java Project,名称为springAOP。为了使用Spring的注解方式进行面向切面编程,需要在springAOP项目中加入与AOP相关的jar包,spr...
  • yerenyuan_pku
  • yerenyuan_pku
  • 2016年10月20日 00:28
  • 4073

SpringMVC中使用aop注解无效的问题

aop注解无效的问题
  • u010483289
  • u010483289
  • 2016年10月03日 00:10
  • 2553

spring aop注解失效之谜

问题:在spring 中使用 @Transactional 、 @Cacheable 或 自定义 AOP 注解时,会发现个问题:在对象内部的方法中调用该对象的其他使用aop机制的方法,被调用方法的ao...
  • u012373815
  • u012373815
  • 2017年08月18日 00:53
  • 715

spring AOP 之 注解 配置实现(附 Java 代码实例)

导入类扫描的注解解析器 命名空间:xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=...
  • qq_27093465
  • qq_27093465
  • 2016年11月28日 18:16
  • 1787

spring 注解aop不生效

首先基础要理解spring配置文件和springmvc配置文件 spring注解不生效可从以下几个方面找原因 1 springmvc的配置文件中只配置扫描@Controller的注解,spri...
  • zhaoyachao123
  • zhaoyachao123
  • 2017年06月28日 09:50
  • 1506

Spring笔记——AOP(注解方式)

在Java EE应用中,常常通过AOP来处理一些具有横切性质的系统级服务,如事务管理、安全检查、缓存、对象池管理等。1.AOP的基本概念AOP从程序运行角度考虑程序的流程,提取业务处理过程的切面。AO...
  • qiuxiao630320
  • qiuxiao630320
  • 2015年11月02日 15:13
  • 1924

【Spring aop】Spring aop的XML和注解的两种配置实现

一:XML形式配置
  • flysun3344
  • flysun3344
  • 2016年06月15日 11:42
  • 3675

Spring AOP编程(注解实现)

一、基本概述Aop(aspect object programming) 面向切面编程 功能: 让关注点代码与业务代码分离!关注点 重复代码就叫做关注点;切面 关注点形成的类,...
  • scgaliguodong123_
  • scgaliguodong123_
  • 2015年11月11日 11:13
  • 1050

使用Spring的注解方式实现AOP的细节

前面我们已经入门使用Spring的注解方式实现AOP了,现在我们再来学习使用Spring的注解方式实现AOP的一些细节。本文是建立在使用Spring的注解方式实现AOP入门的案例的基础之上的。 本文...
  • yerenyuan_pku
  • yerenyuan_pku
  • 2016年10月21日 09:01
  • 2324

基于注解的Spring AOP的配置和使用--转载

AOP是OOP的延续,是Aspect Oriented Programming的缩写,意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。...
  • qq_26562641
  • qq_26562641
  • 2016年12月29日 08:58
  • 1236
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:spring aop 注解入门
举报原因:
原因补充:

(最多只允许输入30个字)