在Intellij上面导入项目 & AOP示例项目 & AspectJ学习 & Spring AoP学习

时间:2024-04-30 16:34:02

为了学习这篇文章里面下载的代码: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 都能为您提供全方位的服务。

下面这张图非常好。

给一张牛逼的高清无码思维导图,总结一下以上各个知识点:

在Intellij上面导入项目 & AOP示例项目 & AspectJ学习 & 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 的整体架构:

在Intellij上面导入项目 & AOP示例项目 & AspectJ学习 & Spring AoP学习

最后,再记录一下原文地址:link1   link2(续)

代码位置:/Users/baidu/Documents/Data/Work/Code/Demo_Code/aop_demo/

(完)