为了学习这篇文章里面下载的代码:http://www.cnblogs.com/charlesblc/p/6083687.html
需要用Intellij导入一个已有工程。源文件原始内容也可见:link
选择 Import Project -> "Create Project from existing sources" ->选择root目录,一步步选择完毕。
为了从百度maven服务器更快的下载,在pom.xml最下面加上以下repo地址:
<repositories>
<repository>
<id>nexus-public</id>
<url>http://maven.scm.baidu.com:8081/nexus/content/groups/public</url>
</repository>
<repository>
<id>nexus-public-snapshots</id>
<url>http://maven.scm.baidu.com:8081/nexus/content/groups/public-snapshots</url>
</repository>
</repositories>
然后可能需要在报错的文件里用 option+enter进行一些错误的更正。
然后在project structure里面进行一些artifact的添加,就可以生成JAR。
一直在报错找不到依赖文件。看了一下 Project里面有两个module,删掉其中的main,只留aop。然后就不再报错啦。。。
然后看例子。
demo4
CGLib 动态代理
我们使用开源的 CGLib 类库可以代理没有接口的类,这样就弥补了 JDK 的不足。
demo7
抛出异常AOP
Hello! Jack
---------- Throw Exception ----------
Target Class: aop.demo7.GreetingImpl
Method Name: sayHello
Exception Message: Error
-------------------------------------
Exception in thread "main" java.lang.RuntimeException: Error
...... Process finished with exit code
demo8
Spring AOP:引入增强
以上提到的都是对方法的增强,那能否对类进行增强呢?用 AOP 的行话来讲,对方法的增强叫做 Weaving(织入),而对类的增强叫做 Introduction(引入)。而 Introduction Advice(引入增强)就是对类的功能增强,它也是 Spring AOP 提供的最后一种增强。
@Component
public class GreetingIntroAdvice extends DelegatingIntroductionInterceptor implements Apology { public void saySorry(String name) {
System.out.println("Sorry! " + name);
} @Override
public Object invoke(MethodInvocation invocation) throws Throwable {
return super.invoke(invocation);
}
}
然后在spring的配置文件里面这样配:
<bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="interfaces" value="aop.demo8.Apology"/>
<property name="target" ref="greetingImpl"/>
<property name="interceptorNames" value="greetingIntroAdvice"/>
<property name="proxyTargetClass" value="true"/>
</bean>
需要注意 proxyTargetClass 属性,它表明是否代理目标类,默认为 false,也就是代理接口了,此时 Spring 就用 JDK 动态代理。如果为 true,那么 Spring 就用 CGLib 动态代理。这简直就是太方便了.
9. Spring AOP:切面
配置如下:
<bean id="greetingAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice" ref="greetingAroundAdvice"/>
<property name="pattern" value="aop.demo9.GreetingImpl.good.*"/>
</bean> <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="greetingImpl"/>
<property name="interceptorNames" value="greetingAdvisor"/>
<property name="proxyTargetClass" value="true"/>
</bean>
10. Spring AOP:自动代理(扫描 Bean 名称)
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames" value="*Impl"/>
<property name="interceptorNames" value="greetingAroundAdvice"/>
<property name="optimize" value="true"/>
</bean>
通过以上配置,就可以自动扫描bean进行匹配。
以上使用 BeanNameAutoProxyCreator 只为后缀为“Impl”的 Bean 生成代理。
需要注意的是,这个地方我们不能定义代理接口,也就是 interfaces 属性,因为我们根本就不知道这些 Bean 到底实现了多少接口。
此时不能代理接口,而只能代理类。所以这里提供了一个新的配置项,它就是 optimize。若为 true 时,则可对代理生成策略进行优化(默认是 false 的)。
也就是说,如果该类有接口,就代理接口(使用 JDK 动态代理);如果没有接口,就代理类(使用 CGLib 动态代理)。
而并非像之前使用的 proxyTargetClass 属性那样,强制代理类,而不考虑代理接口的方式。可见 Spring AOP 确实为我们提供了很多很好地服务。
11. Spring AOP:自动代理(扫描切面配置)
如果既要自动扫描bean,并且匹配方法,可以用下面的
<bean id="greetingAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="pattern" value="aop.demo11.GreetingImpl.good.*"/>
<property name="advice" ref="greetingAroundAdvice"/>
</bean> <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
<property name="optimize" value="true"/>
</bean>
但是匹配的时候,还是有一些问题。很麻烦。
在 Spring 配置文件中,仍然会存在大量的切面配置。然而在有很多情况下 Spring AOP 所提供的切面类真的不太够用了,
比如:想拦截指定注解的方法,我们就必须扩展 DefaultPointcutAdvisor 类,自定义一个切面类,然后在 Spring 配置文件中进行切面配置。
不做不知道,做了您就知道相当麻烦了。
12. Spring + AspectJ(基于注解:通过 AspectJ execution 表达式拦截方法)
主要代码如下:
@Aspect
@Component
public class GreetingAspect { @Around("execution(* aop.demo12.GreetingImpl.*(..))")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
before();
Object result = pjp.proceed();
after();
return result;
} private void before() {
System.out.println("Before");
} private void after() {
System.out.println("After");
}
}
下面重点来分析一下这个切点表达式:
execution(* aop.demo.GreetingImpl.*(..))
execution():表示拦截方法,括号中可定义需要匹配的规则。
第一个“*”:表示方法的返回值是任意的。
第二个“*”:表示匹配该类中所有的方法。
(..):表示方法的参数是任意的。
XML配置内容:
<context:component-scan base-package="aop.demo"/> <aop:aspectj-autoproxy proxy-target-class="true"/>
需要注意的是 proxy-target-class="true" 属性,它的默认值是 false,默认只能代理接口(使用 JDK 动态代理),当为 true 时,才能代理目标类(使用 CGLib 动态代理)。
13. Spring + AspectJ(基于注解:通过 AspectJ @annotation 表达式拦截方法)
首先用annotation定义一个tag
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; @Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Tag {
}
然后针对这个tag来写增强方法:
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component; @Aspect
@Component
public class GreetingAspect { @Around("@annotation(aop.demo13.Tag)")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
before();
Object result = pjp.proceed();
after();
return result;
} private void before() {
System.out.println("Before");
} private void after() {
System.out.println("After");
}
}
最后,在方法上面打上tag就可以了:
@Component
public class GreetingImpl implements Greeting { @Tag
public void sayHello(String name) {
System.out.println("Hello! " + name);
}
}
除了 @Around 注解外,其实还有几个相关的注解,稍微归纳一下吧:
@Before:前置增强
@After:后置增强
@Around:环绕增强
@AfterThrowing:抛出增强
@DeclareParents:引入增强
此外还有一个 @AfterReturning(返回后增强),也可理解为 Finally 增强,相当于 finally 语句,它是在方法结束后执行的,也就说说,它比 @After 还要晚一些。
最后一个 @DeclareParents 竟然就是引入增强!为什么不叫做 @Introduction 呢?我也不知道为什么,但它干的活就是引入增强。
14. Spring + AspectJ(引入增强)
首先要定义一个aspect类:
@Aspect
@Component
public class GreetingAspect { @DeclareParents(value = "aop.demo14.GreetingImpl", defaultImpl = ApologyImpl.class)
private Apology apology;
}
在这个接口上标注了 @DeclareParents 注解,该注解有两个属性:
value:目标类
defaultImpl:引入接口的默认实现类
然后在实现一个ApologyImpl类:
package aop.demo14; public class ApologyImpl implements Apology { public void saySorry(String name) {
System.out.println("Sorry! " + name);
}
}
从 Spring ApplicationContext 中获取 greetingImpl 对象(其实是个代理对象),可转型为自己静态实现的接口 Greeting,也可转型为自己动态实现的接口 Apology,切换起来非常方便。
使用 AspectJ 的引入增强比原来的 Spring AOP 的引入增强更加方便了,而且还可面向接口编程(以前只能面向实现类),这也算一个非常巨大的突破。
上面这一句指的是如下,可以直接转型为Greeting,而不需要转型为GreetingImpl这个类了
public class Client { public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("aop/demo14/spring.xml");
Greeting greeting = (Greeting) context.getBean("greetingImpl");
greeting.sayHello("Jack"); Apology apology = (Apology) greeting;
apology.saySorry("Jack");
}
}
15. Spring + AspectJ(基于配置)
仍然还是有用户不能尝试这些特性,因为他们还在使用 JDK 1.4(根本就没有注解这个东西),怎么办呢?没想到 Spring AOP 为那些遗留系统也考虑到了。
demo15基本完全基于配置,因为代码很简单:
package aop; public interface Greeting { void sayHello(String name);
}
而配置会复杂一些:
<bean id="greetingImpl" class="aop.demo15.GreetingImpl"/> <bean id="greetingAspect" class="aop.demo15.GreetingAspect"/> <aop:config>
<aop:aspect ref="greetingAspect">
<aop:around method="around" pointcut="execution(* aop.demo15.GreetingImpl.*(..))"/>
</aop:aspect>
</aop:config>
使用 <aop:config> 元素来进行 AOP 配置,在其子元素中配置切面,包括增强类型、目标方法、切点等信息。
无论您是不能使用注解,还是不愿意使用注解,Spring AOP 都能为您提供全方位的服务。
下面这张图非常好。
给一张牛逼的高清无码思维导图,总结一下以上各个知识点:
再来一张表格,总结一下各类增强类型所对应的解决方案:
增强类型 | 基于 AOP 接口 | 基于 @Aspect | 基于 <aop:config> |
Before Advice(前置增强) | MethodBeforeAdvice | @Before | <aop:before> |
AfterAdvice(后置增强) | AfterReturningAdvice | @After | <aop:after> |
AroundAdvice(环绕增强) | MethodInterceptor | @Around | <aop:around> |
ThrowsAdvice(抛出增强 | ThrowsAdvice | @AfterThrowing | <aop:after-throwing> |
IntroductionAdvice(引入增强) | DelegatingIntroductionInterceptor | @DeclareParents | <aop:declare-parents> |
最后给一张 UML 类图描述一下 Spring AOP 的整体架构:
代码位置:/Users/baidu/Documents/Data/Work/Code/Demo_Code/aop_demo/
(完)