目录
AspectJ方式设置通知绑定参数
创建方法类，有接收参数的切点方法
创建通知类
修改配置
AOP介绍
AOP（Aspect Oriented Programming），面向切面编程。
我们在平时编写的代码在执行的时候，都是从上往下开始执行的，比如下面的图示：
AOP这个切面，就是指在某一点的前、后，分别进行一些操作，几个简单的例子就是下面这样：
根据AOP的相关内容，介绍上面的有关细节：
1、actionTwo称为切点（PointCut）；
2、actionBefore称为前置通知（beforeAdvice）；
3、actionAfter称为后置通知（afterAdvice）；
4、由actionBefore、actionTwo、actionAfter共同组成切面（Aspect）
Spring进行2种实现AOP的方式
在Spring中，有两种方式可以实现AOP，分别是schema-based、aspectJ，这两种方式的区别在于：
1、schema-based方式：每个通知（advicor）都需要我们自己创建接口或者类；并且在配置的时候，如果使用xml配置，schema-based方式是在<aop:config>标签中配置的。
2、aspectJ方式：不需要我们为每个通知创建接口或者类；在配置的时候，如果使用xml配置，aspectJ方式是在<aop:aspect>标签中配置的。
导入jar包
Spring对于每一个部分的功能，都单独有一个jar包，但是多数jar包之间都是相互依赖的，所以，为了解决不必要的麻烦，初期阶段可以导入所有的Spring jar包。
另外，Spring框架还需要commons-logging、log4J的功能支持，所以还需要导入commons-logging、log4J的jar包。
如果涉及到数据库操作，还需要额外导入jdbc-mysql驱动包
如果需要集成mybatis，则还需要导入mybatis-spring的jar包。
对于AOP来说，除了spring框架下关于aop的jar包外，还需要导入下面两个jar包：aspectjweaver.jar包以及其依赖的aopalliance.jar包。
基于schema-based方式实现AOP
创建前置通知类
package cn.ganlixin.advisor;
import java.lang.reflect.Method;
import java.util.Arrays;
import org.springframework.aop.MethodBeforeAdvice;
/**
* 创建自定义前置通知类
*/
public class MyBeforeAdvisor implements MethodBeforeAdvice {
/**
* 重写MethodBeforeAdvice中before，就是前置通知执行的代码
* @param arg0 代表被调用的切点方法签名
* @param arg1 代表传入切点方法的参数列表
* @param arg2 代表调用的是哪个对象大的切点方法
* @throws Throwable
*/
@Override
public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
System.out.println("arg0" + arg0);
System.out.println("arg1" + Arrays.toString(arg1));
System.out.println("arg3" + arg2);
}
}
创建后置通知类
package cn.ganlixin.advisor;
import java.lang.reflect.Method;
import java.util.Arrays;
import org.springframework.aop.AfterReturningAdvice;
/**
* 自定义的后置通知类
*/
public class MyAfterAdvisor implements AfterReturningAdvice {
/**
* 后置通知被调用的时候执行的方法
* @param arg0 切点方法的返回值
* @param arg1 切点方法的签名
* @param arg2 传递给切点方法的参数
* @param arg3 切点方法所在类的对象
* @throws Throwable
*/
@Override
public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
System.out.println("arg0 " + arg0);
System.out.println("arg1 " + arg1);
System.out.println("arg2 " + Arrays.toString(arg2));
System.out.println("arg3 " + arg3);
}
}
修改Spring配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="demo" class="cn.ganlixin.test.Demo"></bean>
<!-- 创建前置通知类bean -->
<bean id="myBeforeAdvisor" class="cn.ganlixin.advisor.MyBeforeAdvisor"></bean>
<!-- 创建 后置通知类bean -->
<bean id="myAfterAdvisor" class="cn.ganlixin.advisor.MyAfterAdvisor"></bean>
<aop:config>
<!-- 使用<aop:pointcut>来设置切点：
满足条件：访问权限，返回类型任意，包名+类名+方法名+参数类型 (访问权限可省，默认为public)-->
<!-- 将cn.ganlixin.test包下的Demo类中，接收两个int类型的参数的demo1、任意返回值的方法 设置为切点 -->
<aop:pointcut expression="execution(public * cn.ganlixin.test.Demo.demo1(int, int))" id="point_cut1"/>
<!-- 将cn.ganlixin.test包下的Demo类中，接收任意参数的、返回值类型任意的demo1方法设置切点 -->
<aop:pointcut expression="execution(* cn.ganlixin.test.Demo.demo1(..))" id="point_cut2"/>
<!-- 将cn.ganlixin.test包下的Demo类中，只要返回值为String，参数列表任意，全部设置为切点 -->
<aop:pointcut expression="execution(String cn.ganlixin.test.Demo.*(..))" id="point_cut3"/>
<!-- 将cn.ganlixin.test包下的所有类中的所有方法都设置为切点 -->
<aop:pointcut expression="execution(* cn.ganlixin.test.*.*(..))" id="point_cut4"/>
<!-- 将满足包名为cn.ganlixin.*.test的包下的所有类中的所有方法都设置为切点 -->
<aop:pointcut expression="execution(* cn.ganlixin.*.test.*.*(..))" id="point_cut5"/>
<!-- 为指定的切点 设置通知， 直接引用自己创建的通知bean， 运行时会自动判断是前置通知和后置通知 -->
<aop:advisor advice-ref="myBeforeAdvisor" pointcut-ref="point_cut3"/>
<aop:advisor advice-ref="myAfterAdvisor" pointcut-ref="point_cut3"/>
</aop:config>
</beans>
测试
package cn.ganlixin.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("config/applicationContext.xml");
Demo d = ac.getBean("demo", Demo.class);
d.demo2(5, 6);
}
}
测试输出结果
// 自定义前置通知打印的内容 arg0public java.lang.String cn.ganlixin.test.Demo.demo2(int,int) arg1[5, 6] arg3cn.ganlixin.test.Demo@dd8ba08 # 切点方法的输出内容 调用public String demo2(int 5, int 6) # 自定义后置通知打印的内容 arg0 hello world arg1 public java.lang.String cn.ganlixin.test.Demo.demo2(int,int) arg2 [5, 6] arg3 cn.ganlixin.test.Demo@dd8ba08
基于schema-based方式实现环绕通知
环绕通知介绍
servlet中有过滤器filter，可以在接收到请求之后，先一步处理请求，然后交给servlet处理，之后在返回响应之前，再对响应进一步操作之后再返回给客户端。
而环绕通知有点类似于filter，但是环绕通知其实是一个拦截器，在处理流程上和filter相似。
其实就是将前置通知和后置通知结合结合在一起，不用单独创建一个前置通知类和后置通知类，使用schema-based方式就只需要建立一个环绕通知类即可。
创建环绕通知类
package cn.ganlixin.advisor;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
* 自定义环绕通知类
* @author 13550
*
*/
public class MyAroundAdvisor implements MethodInterceptor {
/**
* 环绕通知执行的代码
* @param arg0 切点方法
* @return
* @throws Throwable
*/
@Override
public Object invoke(MethodInvocation arg0) throws Throwable {
System.out.println("环绕通知--前");
// 执行切点方法，获得切点方法执行后的返回值
Object result = arg0.proceed();
System.out.println("环绕通知--后");
return result;
}
}
修改Spring配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="demo" class="cn.ganlixin.test.Demo"></bean>
<!-- 创建环绕通知类 -->
<bean id="myAroundAdvisor" class="cn.ganlixin.advisor.MyAroundAdvisor"></bean>
<aop:config>
<!-- 设置cn.ganlixin.test包下的Demo类中的所有方法都为切点方法 -->
<aop:pointcut expression="execution(* cn.ganlixin.test.Demo.*(..))" id="point_cut"/>
<!-- 只需要配置一个advisor， 该advisor中包含了前置通知和后置通知 -->
<aop:advisor advice-ref="myAroundAdvisor" pointcut-ref="point_cut"/>
</aop:config>
</beans>
测试：
package cn.ganlixin.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("config/applicationContext.xml");
Demo d = ac.getBean("demo", Demo.class);
d.demo2(5, 6);
}
}
输出：
环绕通知--前
调用public String demo2(int 5, int 6)
环绕通知--后
基于schema-based方式实现异常通知
异常通知介绍
我们平时编写function的时候，如果function中可能出现异常，我们一般有两种方式处理异常：
1、在本function内部自己通过try{ } catch(ex) { } 来捕获并处理异常。
2、定义function的时候，通过throws ex来抛出异常，如果出现异常，就将异常交给调用者处理。
上面两种方式，我们都需要自己在每一个可能出现异常的地方编写处理异常的操作，这样有点麻烦，因为有时候，某个类下的某些function出现异常之后，处理异常的操作都相同，如果每次都单独编写异常处理，就有点冗余，也有点麻烦。
此时，我们可以使用AOP方式的异常通知：设置切点后，为切点绑定异常通知，不需要在切点方法或者切点方法的调用方处理异常，而是在出现异常的时候，统一调用我们编写的异常通知。
异常通知的目的不仅限于上面这个原因。
需要注意的是：如果使用异常通知，那么在切点方法中就不要进行try { } catch，否则不会触发异常通知，可以在定义切点方法的时候使用throws Exception。
创建异常通知类
我们自定义的异常通知类需要继承Spring-aop中ThrowsAdvice接口，这个ThrowsAdvice接口中并没有定义任何抽象方法，但是我们却需要在子类（也就是我们的自定义异常通知类）中定义一个afterThrowing方法，可以参考Spring-aop下ThrowsAdvice接口的说明：
package org.springframework.aop;
/**
* Tag interface for throws advice.
*
* <p>There are not any methods on this interface, as methods are invoked by
* reflection. Implementing classes must implement methods of the form:
*
* <pre class="code">void afterThrowing([Method, args, target], ThrowableSubclass);</pre>
*
* <p>Some examples of valid methods would be:
*
* <pre class="code">public void afterThrowing(Exception ex)</pre>
* <pre class="code">public void afterThrowing(RemoteException)</pre>
* <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre>
* <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre>
*/
public interface ThrowsAdvice extends AfterAdvice {
}
上面的介绍中，重点就是，必须在实现类中定义一个名称为afterThrowing的方法，并且方法签名有四种格式：
public void afterThrowing(Exception ex) public void afterThrowing(RemoteException) public void afterThrowing(Method method, Object[] args, Object target, Exception ex) public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)
上面这四种签名中，第一种和第二种参数是一个Exeception，注意，这里的Exception种类最好指定确切的Exception，如果此处定义Exception和运行时抛出的XxxxException不匹配的话，就不会触发我们自定义的异常通知。
下面我们创建自定义的异常通知类：
package cn.ganlixin.advisor;
import org.springframework.aop.ThrowsAdvice;
public class MyExceptionAdvisor implements ThrowsAdvice {
/**
* 创建一个异常通知处理方法，只处理ArithmeticException这一种异常
* @param ex
*/
public void afterThrowing(ArithmeticException e) {
System.out.println("触发ArithmeticException异常通知");
System.out.println(e.getMessage());
}
/**
* 重载一个异常通知方法，只处理ArrayIndexOutOfBoundsException这一种异常
* @param e
*/
public void afterThrowing(ArrayIndexOutOfBoundsException e) {
System.out.println("触发ArrayIndexOutOfBoundsException异常通知");
System.out.println(e.getMessage());
}
}
修改Spring配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="demo" class="cn.ganlixin.test.Demo"></bean>
<!-- 创建异常通知类bean -->
<bean id="myExceptionAdvisor" class="cn.ganlixin.advisor.MyExceptionAdvisor"></bean>
<aop:config>
<!-- 设置cn.ganlixin.test包下的Demo类中的所有方法都为切点方法 -->
<aop:pointcut expression="execution(* cn.ganlixin.test.Demo.*(..))" id="point_cut"/>
<!-- 引用自定义的通知异常bean -->
<aop:advisor advice-ref="myExceptionAdvisor" pointcut-ref="point_cut"/>
</aop:config>
</beans>
修改Demo类，定义两个function，分别触发不同种类的异常：
package cn.ganlixin.test;
public class Demo {
public void demo1() {
int[] a = new int[2];
a[3] = 9;
}
public void demo2() {
int a = 5/0;
}
}
测试：
package cn.ganlixin.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("config/applicationContext.xml");
Demo d = ac.getBean("demo", Demo.class);
try {
d.demo1();
} catch (Exception e) {
}
try {
d.demo2();
} catch (Exception e) {
}
}
}
输出：
触发ArrayIndexOutOfBoundsException异常通知 3 触发ArithmeticException异常通知 / by zero
基于AspectJ方式实现AOP
AspectJ方式的介绍
前面实现AOP的方式是基于schema-based方式的，这种方式需要我们为每一种通知都单独创建一个通知类，并且实现某个特定方法，然后在配置文件中，每一个通知类都要写一个<aop:advisor>。
而基于AspectJ的方式，不需要为每一种通知都单独创建一个通知类，而是只创建一个通知类，该类不需要实现某个接口，并且需要在该类中编写多个方法（方法名随意，没有明确要求）。这多个方法的每一个方法都可以对应一种通知，在配置文件中可以绑定方法和指定的通知种类。
创建很基础的通知类
package cn.ganlixin.advisor;
import org.aspectj.lang.ProceedingJoinPoint;
/**
* 自定义通知类，有多个方法，每个方法可以绑定到不同的通知种类上
*/
public class MyAdvisor {
public void mybefore() {
System.out.println("执行前置通知方法");
}
public void myafter() {
System.out.println("执行后置通知方法");
}
public void myafterReturnging() {
System.out.println("执行myafterReturning");
}
public Object myaround(ProceedingJoinPoint p) throws Throwable {
System.out.println("执行环绕通知-前置");
// 执行切点方法
Object result = p.proceed();
System.out.println("执行环绕通知-后置");
return result;
}
public void mythrow() {
System.out.println("执行异常通知方法");
}
}
修改Spring配置类
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="demo" class="cn.ganlixin.test.Demo"></bean>
<!-- 创建通用通知类 -->
<bean id="myadvisor" class="cn.ganlixin.advisor.MyAdvisor"></bean>
<aop:config>
<!-- 如果使用aspectJ方式，就要使用<aop:aspect>标签 -->
<aop:aspect ref="myadvisor">
<!-- 设置cn.ganlixin.test包下的Demo类中的所有方法都为切点方法 -->
<aop:pointcut id="point_cut" expression="execution(* cn.ganlixin.test.Demo.*(..))" />
<aop:before method="mybefore" pointcut-ref="point_cut"/>
<aop:after method="myafter" pointcut-ref="point_cut"/>
<aop:after-returning method="myafterReturning" pointcut-ref="point_cut"/>
<aop:after-throwing method="mythrow" pointcut-ref="point_cut"/>
<!-- 设置前置和后置之后，不要再设置around
<aop:around method="myaround" pointcut-ref="point_cut"/>
-->
</aop:aspect>
</aop:config>
</beans>
介绍一下上面的几个新标签：
1、<aop:aspect>：使用aspectJ方式实现AOP需要的标签。
2、<aop:before /> ：为指定的切点绑定前置通知，该通知会先于切点方法执行。
3、<aop:after />：为指定的切点绑定后置通知，会后于切点方法执行。
4、<aop:after-returning />：为指定的切点绑定后置通知，会后于切点方法执行。
5、<aop:throwing /> ：为指定的切点方法绑定异常通知，当切点方法执行时出现异常，就会执行该通知。
6、<aop:around />：为指定的切点方法绑定环绕通知。
其中，需要注意下面几点：
1、<aop:after-returning /> 标签绑定的通知，只有当切点方法没有出现异常时，该通知才会执行。
2、<aop:after />标签绑定的通知，不论切点方法是否出现异常，该通知都会执行。
3、如果同时有<aop:after>和<aop:after-returning />标签，他们的顺序是有意义的，如果切点方法没有出现异常，那么就会按照<aop:after>和<aop:after-returning>出现的顺序执行。
4、一个<aop:config>标签中可以有多个<aop:aspect>标签，同时，一个<aop:aspect>标签中可以有多个<aop:point-cut>，可以为不同的point-cut绑定通知。
AspectJ方式设置通知绑定参数
前面使用aspectJ方式完成AOP的功能，其实是比较简单的，因为我们的通知方法没有接收任何参数（除了环绕通知方法有一个ProceedingJoinPoint类型的参数）。
Schema-based方式中创建的每个通知类都实现了某个接口，并且重写了某个方法，方法接收多个参数，通过这些参数可以获取切点方法的相关信息。但是上面AspectJ方式，我们的通知方法中却没有接收参数，这是因为如果要接收参数的话，就稍微复杂一点点。
创建切点方法类，有接受参数的切点方法
package cn.ganlixin.test;
public class Demo {
public void demo1(int id, String name) {
System.out.println(id + " " + name);
}
}
创建通知类
package cn.ganlixin.advisor;
import org.aspectj.lang.ProceedingJoinPoint;
public class MyAdvisor {
/**
* 注意，mybefore方法接收两个参数，并且参数名和切点方法的参数相同（个数、名称）
* @param id
* @param name
*/
public void mybefore(int id, String name) {
System.out.println("前置 " + id + " " + name);
}
}
配置文件修改
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 创建切点方法的类 -->
<bean id="demo" class="cn.ganlixin.test.Demo"></bean>
<!-- 创建通用通知类 -->
<bean id="myadvisor" class="cn.ganlixin.advisor.MyAdvisor"></bean>
<aop:config>
<aop:aspect ref="myadvisor">
<!-- 设置一个确定的方法为切点方法 -->
<aop:pointcut id="point_cut"
expression="execution(* cn.ganlixin.test.Demo.demo1(int, String)) and args(id, name)" />
</aop:aspect>
</aop:config>
</beans>
测试
package cn.ganlixin.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("config/applicationContext.xml");
Demo d = ac.getBean("demo", Demo.class);
d.demo1(99, "hello");
}
}