Spring AOP Sample Code

最新推荐文章于 2021-11-18 00:49:46 发布
最新推荐文章于 2021-11-18 00:49:46 发布
阅读量118 收藏
点赞数
分类专栏： AOP 文章标签： AOP Spring Bean

转自         http://www.iteye.com/topic/40725

 

Before Advice

代码

   1. package test3; 
   2. public class MessageWriter { 
   3.     public void writeMessage()  { 
   4.         System.out.print("World"); 
   5.     } 
   6. } 
   7.  
   8. package test3; 
   9. import java.lang.reflect.Method; 
  10. import org.springframework.aop.MethodBeforeAdvice; 
  11. import org.springframework.aop.framework.ProxyFactory; 
  12. public class SimpleBeforeAdvice implements MethodBeforeAdvice{ 
  13.     public void before(Method method,Object[] args,Object target) throws Throwable{ 
  14.         System.out.println("Before method:"+method.getName()); 
  15.     } 
  16.     public static void main(String[] args){ 
  17.         MessageWriter target = new MessageWriter(); 
  18.         ProxyFactory pf = new ProxyFactory(); 
  19.         pf.addAdvice(new SimpleBeforeAdvice()); 
  20.         pf.setTarget(target); 
  21.         MessageWriter proxy = (MessageWriter)pf.getProxy(); 
  22.         proxy.writeMessage(); 
  23.     } 
  24. } 

AfterReturningAdvice

代码

   1. package test3; 
   2. import java.lang.reflect.Method; 
   3. import org.springframework.aop.AfterReturningAdvice; 
   4. import org.springframework.aop.framework.ProxyFactory; 
   5. public class SimpleAfterReturningAdvice implements AfterReturningAdvice{ 
   6.     public void afterReturning(Object returnValue,Method method,Object[] args,Object target){ 
   7.         System.out.println(""); 
   8.         System.out.println("After method:"+method.getName()); 
   9.     } 
  10. public static void main(String[] args) { 
  11.         MessageWriter target = new MessageWriter(); 
  12.         ProxyFactory pf = new ProxyFactory(); 
  13.         pf.addAdvice(new SimpleAfterReturningAdvice()); 
  14.         pf.setTarget(target); 
  15.         MessageWriter proxy = (MessageWriter)pf.getProxy(); 
  16.         proxy.writeMessage(); 
  17.     } 
  18. } 

Around Advice

代码

   1. package test3; 
   2. import org.aopalliance.intercept.MethodInterceptor; 
   3. import org.aopalliance.intercept.MethodInvocation; 
   4. public class MessageDecorator implements MethodInterceptor{ 
   5.     public Object invoke(MethodInvocation invocation) throws Throwable{ 
   6.         System.out.print("Hello"); 
   7.         Object retVal = invocation.proceed(); 
   8.         System.out.println("!"); 
   9.         return retVal; 
  10.     }    
  11. } 
  12.  
  13. package test3; 
  14. import org.springframework.aop.framework.ProxyFactory; 
  15. public class HelloWorldAOPExample { 
  16.     public static void main(String[] args) { 
  17.         MessageWriter target=new MessageWriter(); 
  18.         ProxyFactory pf = new ProxyFactory(); 
  19.         pf.addAdvice(new MessageDecorator()); 
  20.         pf.setTarget(target); 
  21.         MessageWriter proxy = (MessageWriter)pf.getProxy(); 
  22.         target.writeMessage(); 
  23.         System.out.print(" "); 
  24.         proxy.writeMessage(); 
  25.     } 
  26. } 

ThrowsAdvice

代码

   1. package test3; 
   2. public class ErrorBean { 
   3.     public void errorProneMethod() throws  Exception{ 
   4.         throw new  Exception("Foo"); 
   5.     } 
   6.     public void otherErrorProneMethod() throws IllegalArgumentException{ 
   7.         throw new IllegalArgumentException("Bar"); 
   8.     } 
   9. } 
  10.  
  11. package test3 
  12. import java.lang.reflect.Method; 
  13. import org.springframework.aop.ThrowsAdvice; 
  14. import org.springframework.aop.framework.ProxyFactory; 
  15.  
  16. public class SimpleThrowsAdvice implements ThrowsAdvice{ 
  17.     public static void main(String[] args) throws Exception { 
  18.         ErrorBean errorBean = new ErrorBean(); 
  19.         ProxyFactory pf = new ProxyFactory(); 
  20.         pf.setTarget(errorBean); 
  21.         pf.addAdvice(new SimpleThrowsAdvice()); 
  22.         ErrorBean proxy = (ErrorBean)pf.getProxy(); 
  23.         try 
  24.         { 
  25.             proxy.errorProneMethod(); 
  26.         }catch(Exception ignored) 
  27.         { 
  28.             //ignored.printStackTrace(); 
  29.         } 
  30.         try 
  31.         { 
  32.             proxy.otherErrorProneMethod(); 
  33.         }catch(Exception ignored) 
  34.         { 
  35.             //ignored.printStackTrace(); 
  36.         }        
  37.     } 
  38.     public void afterThrowing(Exception ex) throws Throwable{ 
  39.         System.out.println("***"); 
  40.         System.out.println("Generic Exception Capture"); 
  41.         System.out.println("Caught: "+ex.getClass().getName()); 
  42.         System.out.println("***\n"); 
  43.     } 
  44.     public void afterThrowing(Method method,Object[] args,Object target,IllegalArgumentException ex) throws Throwable{ 
  45.         System.out.println("***"); 
  46.         System.out.println("IllegalArgumentException Capture"); 
  47.         System.out.println("Caught: "+ex.getClass().getName()); 
  48.         System.out.println("***\n");         
  49.     } 
  50. } 

StaticPointcut

代码

   1. package test3; 
   2. public class BeanOne { 
   3.     public void foo() { 
   4.         System.out.println("foo"); 
   5.     } 
   6.     public void bar() { 
   7.         System.out.println("bar"); 
   8.     } 
   9. } 
  10.  
  11. package test3; 
  12. public class BeanTwo { 
  13.     public void foo() { 
  14.         System.out.println("foo"); 
  15.     } 
  16.     public void bar() { 
  17.         System.out.println("bar"); 
  18.     } 
  19. } 
  20.  
  21. package test3; 
  22.  
  23. import org.aopalliance.intercept.MethodInterceptor; 
  24. import org.aopalliance.intercept.MethodInvocation; 
  25. public class SimpleAdvice implements MethodInterceptor{ 
  26.     public Object invoke(MethodInvocation invocation) throws Throwable 
  27.     { 
  28.         System.out.println(">> Invoking "+invocation.getMethod().getName()); 
  29.         Object retVal = invocation.proceed(); 
  30.         System.out.println(">> Done"); 
  31.         return retVal; 
  32.     } 
  33. } 
  34.  
  35. package test3; 
  36.  
  37. import java.lang.reflect.Method; 
  38. import org.springframework.aop.ClassFilter; 
  39. import org.springframework.aop.support.StaticMethodMatcherPointcut; 
  40. public class SimpleStaticPointcut extends StaticMethodMatcherPointcut { 
  41.     public boolean matches(Method method, Class cls) { 
  42.         return ("foo".equals(method.getName())); 
  43.     } 
  44.     public ClassFilter getClassFilter() { 
  45.         return new ClassFilter() { 
  46.             public boolean matches(Class cls) { 
  47.                 return (cls == BeanOne.class); 
  48.             } 
  49.         }; 
  50.     } 
  51. } 
  52.  
  53. package test3; 
  54. import org.aopalliance.aop.Advice; 
  55. import org.springframework.aop.Advisor; 
  56. import org.springframework.aop.Pointcut; 
  57. import org.springframework.aop.framework.ProxyFactory; 
  58. import org.springframework.aop.support.DefaultPointcutAdvisor; 
  59.  
  60. public class StaticPointcutExample { 
  61.     public static void main(String[] args) { 
  62.         BeanOne one = new BeanOne(); 
  63.         BeanTwo two = new BeanTwo(); 
  64.          
  65.         BeanOne proxyOne; 
  66.         BeanTwo proxyTwo; 
  67.          
  68.         Pointcut pc = new SimpleStaticPointcut(); 
  69.         Advice advise = new SimpleAdvice(); 
  70.         Advisor advisor = new DefaultPointcutAdvisor(pc,advise); 
  71.          
  72.         ProxyFactory pf = new ProxyFactory(); 
  73.         pf.addAdvisor(advisor); 
  74.         pf.setTarget(one); 
  75.         proxyOne = (BeanOne)pf.getProxy(); 
  76.          
  77.         pf = new ProxyFactory(); 
  78.         pf.addAdvisor(advisor); 
  79.         pf.setTarget(two); 
  80.         proxyTwo = (BeanTwo)pf.getProxy(); 
  81.          
  82.         proxyOne.foo(); 
  83.         proxyTwo.foo(); 
  84.      
  85.         proxyOne.bar(); 
  86.         proxyTwo.bar(); 
  87.     } 
  88. } 

Dynamic pointcut

代码

   1. package test3; 
   2. public class SampleBean { 
   3.     public void foo(int x){ 
   4.         System.out.println("Invoked foo() with: "+x); 
   5.     } 
   6.     public void bar(){ 
   7.         System.out.println("Invoked bar()"); 
   8.     } 
   9. } 
  10.  
  11. package test3; 
  12.  
  13. import java.lang.reflect.Method; 
  14. import org.springframework.aop.ClassFilter; 
  15. import org.springframework.aop.support.DynamicMethodMatcherPointcut; 
  16. public class SimpleDynamicPointcut extends DynamicMethodMatcherPointcut{ 
  17.     public boolean matches(Method method, Class cls) { 
  18.         System.out.println("Static check for " + method.getName()); 
  19.         return ("foo".equals(method.getName())); 
  20.     } 
  21.     public boolean matches(Method method, Class cls, Object[] args) { 
  22.         System.out.println("Dynamic check for " + method.getName()); 
  23.         int x = ((Integer) args[0]).intValue(); 
  24.         return (x != 100); 
  25.     } 
  26.     public ClassFilter getClassFilter() { 
  27.         return new ClassFilter() { 
  28.             public boolean matches(Class cls) { 
  29.                 return (cls == SampleBean.class); 
  30.             } 
  31.         }; 
  32.     } 
  33. } 
  34.  
  35. package test3; 
  36.  
  37. import org.springframework.aop.Advisor; 
  38. import org.springframework.aop.framework.ProxyFactory; 
  39. import org.springframework.aop.support.DefaultPointcutAdvisor; 
  40. public class DynamicPointcutExample { 
  41.     public static void main(String[] args) { 
  42.         SampleBean target = new SampleBean(); 
  43.         Advisor advisor = new DefaultPointcutAdvisor(new SimpleDynamicPointcut(),new SimpleAdvice()); 
  44.          
  45.         ProxyFactory pf = new ProxyFactory(); 
  46.         pf.setTarget(target); 
  47.         pf.addAdvisor(advisor); 
  48.         SampleBean proxy = (SampleBean)pf.getProxy(); 
  49.          
  50.         proxy.foo(1); 
  51.         proxy.foo(10); 
  52.         proxy.foo(100); 
  53.          
  54.         proxy.bar(); 
  55.         proxy.bar(); 
  56.         proxy.bar(); 
  57.     } 
  58. } 

NamePointcut

代码

   1. package test3; 
   2. public class NameBean { 
   3.     public void foo() { 
   4.         System.out.println("foo"); 
   5.     } 
   6.     public void foo(int x) { 
   7.         System.out.println("foo " + x); 
   8.     } 
   9.     public void bar() { 
  10.         System.out.println("bar"); 
  11.     } 
  12.     public void yup() { 
  13.         System.out.println("yup"); 
  14.     } 
  15. } 
  16.  
  17. package test3; 
  18.  
  19. import org.aopalliance.intercept.MethodInterceptor; 
  20. import org.aopalliance.intercept.MethodInvocation; 
  21.  
  22. public class SimpleAdvice implements MethodInterceptor{ 
  23.     public Object invoke(MethodInvocation invocation) throws Throwable 
  24.     { 
  25.         System.out.println(">> Invoking "+invocation.getMethod().getName()); 
  26.         Object retVal = invocation.proceed(); 
  27.         System.out.println(">> Done"); 
  28.         return retVal; 
  29.     } 
  30. } 
  31.  
  32. package test3; 
  33. import org.springframework.aop.Advisor; 
  34. import org.springframework.aop.framework.ProxyFactory; 
  35. import org.springframework.aop.support.DefaultPointcutAdvisor; 
  36. import org.springframework.aop.support.NameMatchMethodPointcut; 
  37.  
  38. public class NamePointcutExample { 
  39.     public static void main(String[] args) { 
  40.         NameBean target = new NameBean(); 
  41.         NameMatchMethodPointcut pc = new NameMatchMethodPointcut(); 
  42.         pc.addMethodName("foo"); 
  43.         pc.addMethodName("bar"); 
  44.         Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleAdvice()); 
  45.         ProxyFactory pf = new ProxyFactory(); 
  46.         pf.setTarget(target); 
  47.         pf.addAdvisor(advisor); 
  48.         NameBean proxy = (NameBean)pf.getProxy(); 
  49.          
  50.         proxy.foo(); 
  51.         proxy.foo(999); 
  52.         proxy.bar(); 
  53.         proxy.yup(); 
  54.     } 
  55. } 

NamePointcutAdvisor

代码

   1. package test3; 
   2. import org.springframework.aop.framework.ProxyFactory; 
   3. import org.springframework.aop.support.NameMatchMethodPointcutAdvisor; 
   4.  
   5. public class NamePointcutUsingAdvisor { 
   6.     public static void main(String[] args) { 
   7.         NameBean target = new NameBean(); 
   8.          
   9.         NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor(new SimpleAdvice()); 
  10.          
  11.         advisor.addMethodName("foo"); 
  12.         advisor.addMethodName("bar"); 
  13.         ProxyFactory pf = new ProxyFactory(); 
  14.         pf.setTarget(target); 
  15.         pf.addAdvisor(advisor); 
  16.         NameBean proxy = (NameBean)pf.getProxy(); 
  17.         proxy.foo(); 
  18.         proxy.foo(999); 
  19.         proxy.bar(); 
  20.         proxy.yup(); 
  21.     } 
  22. } 

RegexpPointcut

代码

   1. package test3; 
   2. public class RegexpBean { 
   3.     public void foo1() { 
   4.         System.out.println("foo1"); 
   5.     } 
   6.     public void foo2() { 
   7.         System.out.println("foo2"); 
   8.     } 
   9.     public void bar() { 
  10.         System.out.println("bar"); 
  11.     } 
  12. } 
  13.  
  14. package test3; 
  15. import org.springframework.aop.Advisor; 
  16. import org.springframework.aop.framework.ProxyFactory; 
  17. import org.springframework.aop.support.DefaultPointcutAdvisor; 
  18. import org.springframework.aop.support.JdkRegexpMethodPointcut; 
  19. public class RegexpPointcutExample { 
  20.     public static void main(String[] args) { 
  21.         RegexpBean target = new RegexpBean(); 
  22.         JdkRegexpMethodPointcut pc = new JdkRegexpMethodPointcut(); 
  23.         pc.setPattern(".*foo.*"); 
  24.         Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleAdvice()); 
  25.         ProxyFactory pf = new ProxyFactory(); 
  26.         pf.setTarget(target); 
  27.         pf.addAdvisor(advisor); 
  28.         RegexpBean proxy = (RegexpBean)pf.getProxy(); 
  29.         proxy.foo1(); 
  30.         proxy.foo2(); 
  31.         proxy.bar(); 
  32.     } 
  33. } 

ControlFlow Pointcut

代码

   1. package test4; 
   2.  
   3. public class TestBean { 
   4.     public void foo() { 
   5.         System.out.println("foo()"); 
   6.     } 
   7. } 
   8.  
   9. package test4; 
  10. import java.lang.reflect.Method; 
  11. import org.springframework.aop.MethodBeforeAdvice; 
  12. public class SimpleBeforeAdvice implements MethodBeforeAdvice { 
  13.     public void before(Method method,Object[] args,Object target) throws Throwable 
  14.     { 
  15.         System.out.println("before method: "+method); 
  16.     } 
  17. } 
  18.  
  19. package test4; 
  20. import org.springframework.aop.Advisor; 
  21. import org.springframework.aop.Pointcut; 
  22. import org.springframework.aop.framework.ProxyFactory; 
  23. import org.springframework.aop.support.ControlFlowPointcut; 
  24. import org.springframework.aop.support.DefaultPointcutAdvisor; 
  25.  
  26. public class ControlFlowExample { 
  27.  
  28.     public static void main(String[] args) { 
  29.         ControlFlowExample ex = new ControlFlowExample(); 
  30.         ex.run(); 
  31.     } 
  32.     public void run() 
  33.     { 
  34.         TestBean target = new TestBean(); 
  35.         Pointcut pc = new ControlFlowPointcut(ControlFlowExample.class,"test"); 
  36.         Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleBeforeAdvice()); 
  37.         ProxyFactory pf = new ProxyFactory(); 
  38.         pf.setTarget(target); 
  39.         pf.addAdvisor(advisor); 
  40.         TestBean proxy = (TestBean)pf.getProxy(); 
  41.         System.out.println("Trying normal invoke"); 
  42.         proxy.foo(); 
  43.         System.out.println("Trying under ControlFlowExample.test()"); 
  44.         test(proxy); 
  45.     } 
  46.     private void test(TestBean bean){ 
  47.         bean.foo(); 
  48.     } 
  49. } 

ComposablePointcut

代码

   1. package test4; 
   2. public class SampleBean { 
   3.     public String getName() { 
   4.         return "Rob Harrop"; 
   5.     } 
   6.     public void setName(String abc) { 
   7.     } 
   8.     public int getAge() 
   9.     { 
  10.         return 100; 
  11.     } 
  12. } 
  13.  
  14. package test4; 
  15. import java.lang.reflect.Method; 
  16. import org.springframework.aop.Advisor; 
  17. import org.springframework.aop.ClassFilter; 
  18. import org.springframework.aop.framework.ProxyFactory; 
  19. import org.springframework.aop.support.ComposablePointcut; 
  20. import org.springframework.aop.support.DefaultPointcutAdvisor; 
  21. import org.springframework.aop.support.StaticMethodMatcher; 
  22. public class ComposablePointcutExample { 
  23.     public static void main(String[] args) { 
  24.         SampleBean target = new SampleBean(); 
  25.         ComposablePointcut pc = new ComposablePointcut(ClassFilter.TRUE,new GetterMethodMatcher()); 
  26.         System.out.println("Test 1"); 
  27.         SampleBean proxy = getProxy(pc,target); 
  28.         testInvoke(proxy); 
  29.          
  30.         System.out.println("Test 2"); 
  31.         pc.union(new SetterMethodMatcher()); 
  32.         proxy = getProxy(pc,target); 
  33.         testInvoke(proxy); 
  34.          
  35.         System.out.println("Test 3"); 
  36.         pc.intersection(new GetAgeMethodMatcher()); 
  37.         proxy = getProxy(pc,target); 
  38.         testInvoke(proxy); 
  39.     } 
  40.      
  41.     private static SampleBean getProxy(ComposablePointcut pc,SampleBean target) 
  42.     { 
  43.         Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleBeforeAdvice()); 
  44.          
  45.         ProxyFactory pf = new ProxyFactory(); 
  46.         pf.setTarget(target); 
  47.         pf.addAdvisor(advisor); 
  48.          
  49.         return (SampleBean)pf.getProxy(); 
  50.     } 
  51.      
  52.     private static void testInvoke(SampleBean proxy) 
  53.     { 
  54.         proxy.getAge(); 
  55.         proxy.getName(); 
  56.         proxy.setName("Rob Harrop"); 
  57.     } 
  58.      
  59.     private static class GetterMethodMatcher extends StaticMethodMatcher{ 
  60.         public boolean matches(Method method,Class cls) 
  61.         { 
  62.             return (method.getName().startsWith("get")); 
  63.         } 
  64.     } 
  65.      
  66.     private static class GetAgeMethodMatcher extends StaticMethodMatcher{ 
  67.         public boolean matches(Method method,Class cls) 
  68.         { 
  69.             return "getAge".equals(method.getName()); 
  70.         } 
  71.     } 
  72.      
  73.     private static class SetterMethodMatcher extends StaticMethodMatcher{ 
  74.         public boolean matches(Method method,Class cls) 
  75.         { 
  76.             return (method.getName().startsWith("set")); 
  77.         } 
  78.     } 
  79. } 

Introduction

代码

   1. package test4; 
   2. public class TargetBean { 
   3.     private String name; 
   4.     public void setName(String name) { 
   5.         this.name = name; 
   6.     } 
   7.     public String getName() { 
   8.         return name; 
   9.     } 
  10. } 
  11.  
  12. package test4; 
  13. public interface IsModified { 
  14.     public boolean isModified(); 
  15. } 
  16.  
  17. package test4; 
  18.  
  19. import java.lang.reflect.Method; 
  20. import java.util.HashMap; 
  21. import java.util.Map; 
  22.  
  23. import org.aopalliance.intercept.MethodInvocation; 
  24. import org.springframework.aop.support.DelegatingIntroductionInterceptor; 
  25.  
  26. public class IsModifiedMixin extends DelegatingIntroductionInterceptor implements IsModified { 
  27.     private boolean isModified=false; 
  28.     private Map methodCache = new HashMap(); 
  29.     public boolean isModified() 
  30.     { 
  31.         return isModified; 
  32.     } 
  33.     public Object invoke(MethodInvocation invocation) throws Throwable 
  34.     { 
  35.         if (!isModified) 
  36.         { 
  37.             if ((invocation.getMethod().getName().startsWith("set"))&&(invocation.getArguments().length==1)) 
  38.             { 
  39.                  
  40.                 Method getter = getGetter(invocation.getMethod()); 
  41.                  
  42.                 if (getter!=null) 
  43.                 { 
  44.                     Object newVal = invocation.getArguments()[0]; 
  45.                     Object oldVal = getter.invoke(invocation.getThis(),null); 
  46.                     if ((newVal == null)&&(oldVal == null)) 
  47.                     { 
  48.                         isModified = false; 
  49.                     }else if ((newVal == null)&&(oldVal!=null)) 
  50.                     { 
  51.                         isModified = true; 
  52.                     }else if ((newVal!=null)&&(oldVal==null)) 
  53.                     { 
  54.                         isModified = true; 
  55.                     }else 
  56.                     { 
  57.                         isModified = (!newVal.equals(oldVal)); 
  58.                     } 
  59.                 } 
  60.             } 
  61.         } 
  62.         return super.invoke(invocation); 
  63.     } 
  64.  
  65.         private Method getGetter(Method setter) 
  66.         { 
  67.             Method getter = null; 
  68.              
  69.             getter = (Method)methodCache.get(setter); 
  70.              
  71.             if (getter!=null) 
  72.             { 
  73.                 return getter; 
  74.             } 
  75.              
  76.             String getterName = setter.getName().replaceFirst("set","get"); 
  77.             try 
  78.             { 
  79.                 getter = setter.getDeclaringClass().getMethod(getterName,null); 
  80.                 synchronized(methodCache) 
  81.                 { 
  82.                     methodCache.put(setter,getter); 
  83.                 } 
  84.                 return getter; 
  85.             }catch(NoSuchMethodException ex) 
  86.             { 
  87.                 return null; 
  88.             } 
  89.         } 
  90. } 
  91.  
  92. package test4; 
  93. import org.springframework.aop.support.DefaultIntroductionAdvisor; 
  94. public class IsModifiedAdvisor extends DefaultIntroductionAdvisor{ 
  95.  
  96.     public IsModifiedAdvisor(){ 
  97.         super(new IsModifiedMixin()); 
  98.     } 
  99. } 
 100.  
 101. package test4; 
 102.  
 103. import org.springframework.aop.IntroductionAdvisor; 
 104. import org.springframework.aop.framework.ProxyFactory; 
 105.  
 106. public class IntroductionExample { 
 107.  
 108.     public static void main(String[] args) { 
 109.         TargetBean target = new TargetBean(); 
 110.         target.setName("Rob Harrop"); 
 111.          
 112.         IntroductionAdvisor advisor = new IsModifiedAdvisor(); 
 113.          
 114.         ProxyFactory pf = new ProxyFactory(); 
 115.         pf.setTarget(target); 
 116.         pf.addAdvisor(advisor); 
 117.         pf.setOptimize(true); 
 118.          
 119.         TargetBean proxy = (TargetBean)pf.getProxy(); 
 120.         IsModified proxyInterface = (IsModified)proxy; 
 121.          
 122.         System.out.println("Is TargetBean?: "+(proxy instanceof TargetBean)); 
 123.         System.out.println("Is IsModified?: "+(proxy instanceof IsModified)); 
 124.          
 125.         System.out.println("Has been Modified?: "+proxyInterface.isModified()); 
 126.         proxy.setName("Rob Harrop"); 
 127.         System.out.println("Has been Modified?: "+proxyInterface.isModified()); 
 128.         proxy.setName("Joe Schmoe"); 
 129.         System.out.println("Has been Modified?: "+proxyInterface.isModified()); 
 130.     } 
 131. }

zizila
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AopSample:面向切片AOP示例
05-18
AopSample 面向切片AOP示例 基于AOP 的两个库： 一个注解搞定安卓动态权限的所有复杂逻辑和兼容处理 一个注解搞定安卓线程转换 欢迎star
Spring AOP Sample
07-15 494
1、mkyong.com http://www.mkyong.com/spring/spring-aop-examples-advice/
Spring AOP示例
u011183517的专栏
11-18 574
官方文档：7.Aspect Oriented Programming with Spring spring aop像一个拦截器，可以对被拦截的方法（join point）做增强处理，而且对连接点无代码入侵。在使用aop编程时，先分析业务以便定义PointCut，然后定义切面类和advice。示例如下： 连接点所在的类： package com.example.demo.aopdemo; import org.springframework.web.bind.annotation.GetMapp..
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring aop.docx
最新发布
12-14
**Spring AOP 入门** 在深入探讨Spring AOP之前，我们先理解AOP（面向切面编程）的概念。AOP是一种编程范式，旨在减少代码的重复性，提高代码的可维护性和可读性。它通过将关注点（如日志记录、事务管理、安全性等...
SpringAOP.rar_springAOP
09-23
《Spring AOP：面向切面编程的深度解析》 在软件开发中，Spring框架以其强大的功能和灵活性，已经成为Java企业级应用的首选框架之一。其中，Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP使用总结
Chandler的博客
09-24 452
一、AOP切面的方式 1.很多时候我们需要对一层进行切面，例如我们要对系统的Controler层进行切面，但是关于登陆和注册的Controller则放开；书写方式如下，切Service同理：以下表达方式涵盖了包名、类名切面方法； //所有以controller下面的请求都要经过校验 排除掉登录 @Pointcut("execution(public * cn.czyfwpla.xm...
Spring系列之AOP实现的两种方式
weixin_34102807的博客
10-24 647
AOP常用的实现方式有两种，一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）。 首先复习下AOP中一些比较重要的概念： Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行 。Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法是需要被增强、被代理的。一般都是按照一定的...
Spring学习笔记 —— AOP（面向切面编程） 之使用ProxyFactoryBean实现AOP
Mr_SeaTurtle_的博客
10-19 1046
这篇文章主要介绍了Spring中AOP概念，以及Spring内置的AOP实现。提供了一个实现的实例，也对实例的生成过程进行了具体分析。
Spring AOP : AspectJ Pointcut 切点
爱莲说的博客
07-26 3747
基本理论切点函数可以定位到准确的横切逻辑位置 @AspectJ使用AspectJ专门的切点表达式描述切面，Spring所支持的AspectJ表达式可分为四类: 方法切点函数：通过描述目标类方法信息定义连接点。 方法参数切点函数：通过描述目标类方法入参信息定义连接点。 目标类切点函数：通过描述目标类类型信息定义连接点。 代理类切点函数：通过描述代理类信息定义连接点。常见的AspectJ表达式
白话Spring（基础篇）---AOP（execution表达式）
y-yg的博客
03-05 5万+
[一知半解，就是给自己挖坑] 作为AOP的最后一节内容，我们来简单总结一下切面表达式上见的书写方法。下面的那内容有参考其他博文，在此先对开源博客的各位大神表示感谢！ -------------------------------------------------------------------------------------------------------------------
Spring AOP使用示例
热门推荐
最怕一生碌碌无为，还安慰自己平凡可贵
06-13 6万+
AOP:【面向切面编程】 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式。 1、导入aop模块：Spring AOP：（spring-aspects） 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候讲日志进行打印（方法之前、方法运行结束、方法出现异常等) 3、定义一个日志切面类（LOgAspects）；切面类里面...
spring AspectJ的Execution表达式-备忘笔记(转)
zhuchengzzcc的专栏
04-28 2276
Aspectj切入点语法定义 在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式  execution (* com.sample.service.impl..*.*(..)) execution()是最常用的切点函数，其语法如下所示：  整个表达式可以分为五个部分：  1、execution():...
Spring AOP四种实现方式Demo详解与相关知识探究
Leeon的博客
08-27 3万+
一、前言 在网络上看到一篇博客Spring实现AOP的4种方式，博主写的很通俗易懂，但排版实在抓狂，对于我这么一个对排版、代码格式有强迫症的人来说，实在是不能忍受~~~~(>_ 我亲手实现了一遍，重新整理，加上了一些不易关注到的细节、漏掉的知识，以及自己对AOP的一些理解，写成这篇博客。 二、AOP相关概念 （1）AOP是什么？AOP与拦截器的区别？ 太抽象的不说，如果你知道St
Spring AOP：聚焦方法拦截
"Spring AOP是Spring框架中的一个重要模块，专注于面向切面编程，它通过提供方法级别的Joinpoint来实现AOP的功能。虽然Spring AOP仅支持方法执行类型的Joinpoint，但这已经足够应对大部分开发场景。" Spring AOP，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值