Spring笔记（三）:Aop详解

一、Aop原理

（一）动态代理

1、详见：java进阶（七）：详解JAVA代理

2、主要是Proxy 与 InvocationHandle r接口

（二）Cglib 实现

1、主要是 Enhancer 和 MethodInterceptor 接口

2、实现代码如下：

<span style="font-size:18px;">	/**
	 * 利用 cglib 实现
	 * @param targrt
	 * @return
	 */
	public static Object getCgProxy(final Object targrt,final Advice advice){
		
		//利用cglib 中的Enhancer
		Enhancer enhancer = new Enhancer();
		
		//把目标类设置为代理的父类(继承目标类，覆盖其所有非final的方法)
		enhancer.setSuperclass(targrt.getClass());
		
		//设置回调
		enhancer.setCallback(new MethodInterceptor() {//实现MethodInterceptor 接口
			
			@Override
			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				Object object = null;
				try{
					advice.before(method);//前置
					object = methodProxy.invoke(targrt, args);
					advice.after(method);//后置
				}catch (Exception e) {
					advice.afterThrow(method);//例外
				}finally{
					advice.afterFinally(method);//最终
				}

				return object;
			}
		});
		
		return enhancer.create();
	}
</span>

（三）环境及概念

1、需要的包：spring的包，还需要 aspectjweaver.jar，aopalliance.jar ，asm.jar 和cglib.jar 。

2、Aop的实现方式：Spring 接口方式，schema配置方式和注解的三种方式

3、概念

1）切面(aspect)：用来切插业务方法的类。

2）连接点(joinpoint)：是切面类和业务类的连接点，其实就是封装了业务方法的一些基本属性，作为通知的参数来解析。

3）通知(advice)：在切面类中，声明对业务方法做额外处理的方法。

4）切入点(pointcut)：业务类中指定的方法，作为切面切入的点。其实就是指定某个方法作为切面切的地方。

5）目标对象(target object)：被代理对象。

6）AOP代理(aop proxy)：代理对象。

7）前置通知(before advice)：在切入点之前执行。

8）后置通知(after returning advice)：在切入点执行完成后，执行通知。

9）环绕通知(around advice)：包围切入点，调用方法前后完成自定义行为。

10、异常通知(after throwing advice)：在切入点抛出异常后，执行通知。

二、Spring接口的aop实现

（一）详见：Spring AOP (上)

（二）分析

1、实现依赖比较麻烦，spring定义了一堆通知的接口，只要是实现即可。如前置通知接口 MethodBeforeAdvice

<span style="font-size:18px;">package main.java.com.spring.aop.apj;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * Spring接口的前置通知
 * BaseBeforeAdvice
 * @title
 * @desc
 * @author SAM-SHO
 * @Jan 17, 2015
 */
public class BaseBeforeAdvice implements MethodBeforeAdvice {

    /**
     * method : 切入的方法 <br>
     * args ：切入方法的参数 <br>
     * target ：目标对象
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("===========进入beforeAdvice()============ \n");

        System.out.print("准备在" + target + "对象上用");
        System.out.print(method + "方法进行对 '");
        System.out.print(args[0] + "'进行删除！\n\n");

        System.out.println("要进入切入点方法了 \n");
    }

}</span>

2、需要 指定切点：实现接口 MethodBeforeAdvice 

<span style="font-size:18px;">/**
 * 定义一个切点，指定对应方法匹配。来供切面来针对方法进行处理<br>
 * 
 * 继承NameMatchMethodPointcut类，来用方法名匹配
 * 
 * @author 
 * 
 */
public class Pointcut extends NameMatchMethodPointcut {

    private static final long serialVersionUID = 3990456017285944475L;

    @SuppressWarnings("rawtypes")
    @Override
    public boolean matches(Method method, Class targetClass) {
        // 设置单个方法匹配
        this.setMappedName("delete");
        // 设置多个方法匹配
        String[] methods = { "delete", "modify" };
        
        //也可以用“ * ” 来做匹配符号
        // this.setMappedName("get*");
        
        this.setMappedNames(methods);

        return super.matches(method, targetClass);
    }

}</span>

3、需要配置。很麻烦。

三、spring利用aspectj 实现aop

（一）源码

1、业务类(target)

<span style="font-size:18px;">package main.java.com.spring.aop.service;

/**
 * 业务接口
 * PersonService
 * @title
 * @desc
 * @author SAM-SHO
 * @Jan 17, 2015
 */
public interface PersonService {
	/**
	 * 保存用户实体
	 * @param name
	 */
	public void save(String name);
	
	/**
	 * 删除用户实体
	 * @param id
	 */
	public void delete(Integer id);
	
	/**
	 * 查询编号为id的使用用户姓名
	 * @param id
	 */
	public String queryPersonName(Integer id);
	
	/**
	 * 更新实体
	 * @param name
	 * @param id
	 */
	public void update(String name ,Integer id);
}
</span>

<span style="font-size:18px;">package main.java.com.spring.aop.service.impl;

import main.java.com.spring.aop.service.PersonService;

/**
 * 业务实现类
 * PersionServiceImpl
 * @title
 * @desc
 * @author SAM-SHO
 * @Jan 17, 2015
 */
public class PersonServiceImpl implements PersonService {

	
	@Override
	public void save(String name) {
		System.out.println("我是save()方法");

	}

	@Override
	public void delete(Integer id) {
		System.out.println("我是 delete() 方法");

	}

	@Override
	public String queryPersonName(Integer id) {
		System.out.println("我是 query() 方法");
		return "XXX";
	}

	@Override
	public void update(String name, Integer id) {
		System.out.println("我是 update() 方法");

	}

}
</span>

2、切面类(aspect：类内部定义各种通知advice)

<span style="font-size:18px;">package main.java.com.spring.aop.apj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 
 * AspectAdvice
 * @title 切面类
 * @desc
 * @author SAM-SHO
 * @Jan 11, 2015
 */
public class AspectAdvice {

    /**
     * 前置通知
     * 
     * @param jp
     */
    public void doBefore(JoinPoint jp) {
        System.out.println("===========进入before advice============ \n");

        System.out.println("准备在" + jp.getTarget().getClass() + "对象上用");
        System.out.println(jp.getSignature().getName() + "方法进行对 '");
        System.out.println(jp.getArgs()[0] + "'进行删除！\n\n");

        System.out.println("要进入切入点方法了 \n");
    }

    /**
     * 后置通知
     * 
     * @param jp
     *            连接点
     * @param result
     *            返回值
     */
    public void doAfter(JoinPoint jp, String result) {
        System.out.println("==========进入after advice=========== \n");
        System.out.println("切入点方法执行完了 \n");

        System.out.print(jp.getArgs()[0] + "在");
        System.out.print(jp.getTarget().getClass() + "对象上被");
        System.out.print(jp.getSignature().getName() + "方法删除了");
        System.out.print("只留下：" + result + "\n\n");
    }

    /**
     * 环绕通知
     * 
     * @param pjp
     *            连接点
     */
    public void doAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("===========进入around环绕方法！=========== \n");

        // 调用目标方法之前执行的动作
        System.out.println("调用方法之前: 执行！\n");

        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object result = pjp.proceed();

        System.out.println("调用方法结束：之后执行！\n");
        
        System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";" + result + "\n");
        
    }

    /**
     * 异常通知
     * 
     * @param jp
     * @param e
     */
    public void doThrow(JoinPoint jp, Throwable e) {
        System.out.println("删除出错啦");
    }

}</span>

3、配置。

<span style="font-size:18px;">    <!-- 声明一个业务类的Bean -->
    <bean id="personService" class="main.java.com.spring.aop.service.impl.PersonServiceImpl" /> 

    <!-- 声明通知类 -->
 	<bean id="aspectAdvice" class="main.java.com.spring.aop.apj.AspectAdvice" />

    <aop:config>
        <aop:aspect id="businessAspect" ref="aspectAdvice">
            <!--配置指定切入的对象  -->
            <aop:pointcut id="point_cut" expression="execution(* main.java.com.spring.aop.service..*.*(..))" />
            <!--只匹配add方法作为切入点  -->
            <!-- <aop:pointcut id="except_add" expression="execution(* aop.schema.*.add(..))" /> -->
            <!--前置通知  -->
            <aop:before method="doBefore" pointcut-ref="point_cut" />
            <!--后置通知 returning指定返回参数  -->
            <!-- <aop:after-returning method="doAfter" pointcut-ref="point_cut" returning="result" /> -->
            <!--环绕  -->
            <!-- <aop:around method="doAround" pointcut-ref="point_cut"/> -->
            <!--throw中  -->
            <!-- <aop:after-throwing method="doThrow" pointcut-ref="point_cut" throwing="e"/> -->
        </aop:aspect>
    </aop:config>
</span>

4、测试。

<span style="font-size:18px;">	@Test
	public void sopTest(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationAopContext.xml");
		PersonService personService = (PersonService) cxt.getBean("personService");
		personService.save("shaoxiaobao...");
//		tAspectBusiness.delete("zhaoxioaniu");
	} 
</span>

四、注解实现aop

（一）实现配置

1、开打自动扫描，注解实现Bean的管理与注入。（目标与切面都交由spring管理）

<span style="font-size:18px;">    <!-- 开打自动扫描 -->
    <context:component-scan base-package="main.java.com.spring" /></span>

2、开发Aop的注解

<span style="font-size:18px;">    <!-- 打开aop 注解 -->
    <aop:aspectj-autoproxy /></span>

（二）注解实现切面类。

<span style="font-size:18px;">package main.java.com.spring.aop.apj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component//让spring管理bean
@Aspect//定义切面类
public class AnnotationAspectAdvice {
	/*
     * 指定切入点匹配表达式，注意它是以方法的形式进行声明的。
     * 分析：
     *  execution 是方法的织入语言
     * 	第一个 * ：返回任意类型
     *  main.java.com.spring.aop.service： 包。
     *  ..：service包以及其子包。
     *  第二个 * ：service包以及其子包下的任意类。
     *  第三个 * ：service包以及其子包下的任意类的任意方法。
     *  (..) ：方法的参数为任意。
     *  总结：对 main.java.com.spring.aop.service包以及其子包下的任意类的任意方法作切入
     */
    @Pointcut("execution(* main.java.com.spring.aop.service..*.*(..))")
    public void anyMethod() {
    }

    /**
     * 前置通知
     * 
     * @param jp
     */
    @Before(value = "execution(* main.java.com.spring.aop.service..*.*(..))")
    public void doBefore(JoinPoint jp) {
        System.out.println("===========进入before advice============ \n");

        System.out.print("准备在" + jp.getTarget().getClass() + "对象上用");
        System.out.print(jp.getSignature().getName() + "方法进行对 '");
        System.out.print(jp.getArgs()[0] + "'进行删除！\n\n");

        System.out.println("要进入切入点方法了 \n");
    }

    /**
     * 后置通知
     * 
     * @param jp
     *            连接点
     * @param result
     *            返回值
     */
    @AfterReturning(value = "anyMethod()", returning = "result")
    public void doAfter(JoinPoint jp, String result) {
        System.out.println("==========进入after advice=========== \n");
        System.out.println("切入点方法执行完了 \n");

        System.out.print(jp.getArgs()[0] + "在");
        System.out.print(jp.getTarget().getClass() + "对象上被");
        System.out.print(jp.getSignature().getName() + "方法删除了");
        System.out.print("只留下：" + result + "\n\n");
    }

    /**
     * 环绕通知
     * 
     * @param pjp
     *            连接点
     */
    @Around(value = "execution(* main.java.com.spring.aop.service..*.*(..))")
    public void doAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("===========进入around环绕方法！=========== \n");

        // 调用目标方法之前执行的动作
        System.out.println("调用方法之前: 执行！\n");

        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object result = pjp.proceed();

        System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";" + result + "\n");
        System.out.println("调用方法结束：之后执行！\n");
    }

    /**
     * 异常通知
     * 
     * @param jp
     * @param e
     */
    @AfterThrowing(value = "execution(* main.java.com.spring.aop.service.*.*(..))", throwing = "e")
    public void doThrow(JoinPoint jp, Throwable e) {
        System.out.println("删除出错啦");
    }


}
</span>

1、JoinPoint ：切入点，可以得到切入代理对象的信息

1）getArgs()：获取方法参数。

2）getTarget()：得到目标对象。

3）getSignature()：得到方法。

2、ProceedingJoinPoint：环绕方法的使用。

1）proceed()：执行目标对象的方法。

3、Throwable：异常获取。