spring经典的基于代理的AOP编程-[控制粒度-类]

11520171026

11520171026
1、Spring框架提供五个增强方位实现 [增强方位 + 增强逻辑代码]

   1)、Before(前) org.apringframework.aop.MethodBeforeAdvice
   2)、After-returning(返回后) org.springframework.aop.AfterReturningAdvice
   3)、After-throwing(抛出后) org.springframework.aop.ThrowsAdvice
   4)、Arround(周围) org.aopaliance.intercept.MethodInterceptorWeaving
   5)、Introduction(引入) org.springframework.aop.IntroductionInterceptor

2、基于代理实现AOP编程步骤？

   1)、编写一个类实现于增强方位接口 

   2)、写工厂代理方法

    //代理工厂类
	ProxyFactory pf=new ProxyFactory();
	pf.setTarget(目标对象);
	//添加增强类（增强方位+增强逻辑代码）
	pf.addAdvice(advice);
	//获取代理实例
	pf.getProxy();

3、增强控制粒度(目标类下所有方法)

4、AOP 所做事情的本质：将公共的业务(如日志、安全、事务管理等)和领域业务结合，当执行领域业务时将公共业务横切加进来。实现公共业务的重复利用，领域业务更加纯粹，程序员可以专心于领域业务，本质就是动态代理package com.tiger.advice;

import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;
/**
 * 后置逻辑增强
 * @author tiger
 * @date 2017年10月26日
 */
@Component
public class AfterAdvice implements AfterReturningAdvice {
	/**
	 * 目标方法执行后执行的通知
	 * @param returnValue--返回值
	 * @param method 被调用的方法对象
	 * @param args 被调用的方法对象的参数
	 * @param target 被调用的方法对象的目标对象
	 * */
	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("[AfterAdvice:]Welcom to you next time!");
	}
}
package com.tiger.advice;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;
/**
 * 前置逻辑增强
 * @date 2017年10月26日
 */
@Component
public class BeforeAdvice implements MethodBeforeAdvice {
	/**
	 * @param method 被调用方法的对象
	 * @param agrs 被调用的方法的参数
	 * @param target 被调用方法的目标对象
	 */
	@Override
	public void before(Method method, Object[] agrs, Object target) throws Throwable {
		System.out.println("[BeforeAdvice:]how are you!");
	}
}
package com.tiger.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
 * 环绕逻辑增强
 * @author tiger
 * @date 2017年10月26日
 */
public class SurroundAdvice implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		//前置增强逻辑
		System.out.println("[SurroundAdvice:]how are you!");
		/**
		 * 目标核心方法
		 */
		Object result = invocation.proceed();
		//后置增强逻辑
		System.out.println("[SurroundAdvice:]Welcom to you next time!");
		return result;
	}
}
package com.tiger.main;

import org.springframework.aop.framework.ProxyFactory;

import com.tiger.advice.BeforeAdvice;
import com.tiger.bean.Waiter;
/**
 * 测试
 * @author tiger
 * @date 2017年10月26日
 */
public class Main {
	
	public static void main(String[] args) {
		
		Waiter waiter = new Waiter();
		BeforeAdvice beforeAdvice = new BeforeAdvice();
		
		ProxyFactory proxyFactory = new ProxyFactory();
		
		//注入目标代理类对象
		proxyFactory.setTarget(waiter);
		
		//注入增强类（增强方位+增强逻辑代码）
		proxyFactory.addAdvice(beforeAdvice);
		
		//获取代理实例
		waiter =  (Waiter) proxyFactory.getProxy();
		
		//方法调用
		waiter.greet("李老板");
//		waiter.offWork();
		
	}
}