spring03_AOP的简述与配置

AOP概述

AOP的优势及作用

作用：
	在程序运行期间，不修改源码对已有方法进行增强。
优势：
	减少重复代码
	提高开发效率
	维护方便

AOP的实现

使用动态代理技术

动态代理的特点

• 字节码随用随创建，随用随加载。
• 它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
• 装饰者模式就是静态代理的一种体现。

动态代理常用的有两种方式

基于接口的动态代理
	提供者： JDK 官方的 Proxy 类。
	要求：被代理类最少实现一个接口。
基于子类的动态代理
	提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
	要求：被代理类不能用 final 修饰的类（最终类）。

使用 JDK 官方的 Proxy 类创建代理对象

• 接口

public interface IActor {
/**
 * 基本演出
 * @param money
*/
public void basicAct(float money);
/**
 * 危险演出
 * @param money
*/
public void dangerAct(float money);
}

• 接口实现类

public class Actor implements IActor{
	public void basicAct(float money){
		System.out.println("拿到钱，开始基本的表演： "+money);
	}
	public void dangerAct(float money){
		System.out.println("拿到钱，开始危险的表演： "+money);
	}
}

实现代理

public class Client {
public static void main(String[] args) {
//一个剧组找演员：
final Actor actor = new Actor();//直接
	/**
	* 代理：
	* 间接。
	* 获取代理对象：
	* 要求：
	* 被代理类最少实现一个接口
	* 创建的方式
	* Proxy.newProxyInstance(三个参数)
	* 参数含义：
	* ClassLoader：和被代理对象使用相同的类加载器。
	* Interfaces：和被代理对象具有相同的行为。实现相同的接口。
	* InvocationHandler：如何代理。
	* 策略模式：使用场景是：
	* 数据有了，目的明确。
	* 如何达成目标，就是策略。
	*
*/
	IActor proxyActor = (IActor) Proxy.newProxyInstance(
		actor.getClass().getClassLoader(),
		actor.getClass().getInterfaces(),
		new InvocationHandler() {
		/**
		* 执行被代理对象的任何方法，都会经过该方法。
		* 此方法有拦截的功能。
		*
		* 参数：
		* proxy：代理对象的引用。不一定每次都用得到
		* method：当前执行的方法对象
		* args：执行方法所需的参数
		* 返回值：
		* 当前执行方法的返回值
		*/
		@Override
		public Object invoke(Object proxy, Method method, Object[] args)
		throws Throwable {
			String name = method.getName();
			Float money = (Float) args[0];
			Object rtValue = null;
			//每个经纪公司对不同演出收费不一样，此处开始判断
		if("basicAct".equals(name)){
			//基本演出，没有 2000 不演
			if(money > 2000){
				//看上去剧组是给了 8000，实际到演员手里只有 4000
				//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
				rtValue = method.invoke(actor, money/2);
			}
		}
		if("dangerAct".equals(name)){
			//危险演出,没有 5000 不演
			if(money > 5000){
				//看上去剧组是给了 50000，实际到演员手里只有 25000
				//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
				rtValue = method.invoke(actor, money/2);
			}
		}
		return rtValue;
	}
});
		//没有经纪公司的时候，直接找演员。
		// actor.basicAct(1000f);
		// actor.dangerAct(5000f);
		//剧组无法直接联系演员，而是由经纪公司找的演员
		proxyActor.basicAct(8000f);
		proxyActor.dangerAct(50000f);
	}
}

CGlib实现动态代理

public class Actor{//没有实现任何接口
	public void basicAct(float money){
		System.out.println("拿到钱，开始基本的表演： "+money);
	}
	public void dangerAct(float money){
		System.out.println("拿到钱，开始危险的表演： "+money);
		}
	}
	public class Client {
	/**
	* 基于子类的动态代理
	* 要求：
	* 被代理对象不能是最终类
	* 用到的类：
	* Enhancer
	* 用到的方法：
	* create(Class, Callback)
	* 方法的参数：
	* Class：被代理对象的字节码
	* Callback：如何代理
	* @param args
	*/
	public static void main(String[] args) {
		final Actor actor = new Actor();
		Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
		new MethodInterceptor() {
	/**
	* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
	方法进行增强。
	*
	* 参数：
	* 前三个和基于接口的动态代理是一样的。
	* MethodProxy：当前执行方法的代理对象。
	* 返回值：
	* 当前执行方法的返回值
	*/
	@Override
	public Object intercept(Object proxy, Method method, Object[] args,
		MethodProxy methodProxy) throws Throwable {
		String name = method.getName();
		Float money = (Float) args[0];
		Object rtValue = null;
		if("basicAct".equals(name)){
		//基本演出
		if(money > 2000){
			rtValue = method.invoke(actor, money/2);
		}
	}
	if("dangerAct".equals(name)){
		//危险演出
		if(money > 5000){
			rtValue = method.invoke(actor, money/2);
		}
	}
	return rtValue;
}
});
	cglibActor.basicAct(10000);
	cglibActor.dangerAct(100000);
	}
}

AOP 相关术语

Joinpoint(连接点):
	所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的
	连接点。
Pointcut(切入点):
	所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强):
	所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
	通知的类型： 前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):
	引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方
	法或 Field。
Target(目标对象):
	代理的目标对象。
Weaving(织入):
	是指把增强应用到目标对象来创建新的代理对象的过程。
	spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理） :
	一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):
	是切入点和通知（引介）的结合

基于xml的AOP配置

spring中基于XML的AOP配置步骤
        1、把通知Bean也交给spring来管理
        2、使用aop:config标签表明开始AOP的配置
        3、使用aop:aspect标签表明配置切面
                id属性：是给切面提供一个唯一标识
                ref属性：是指定通知类bean的Id。
        4、在aop:aspect标签的内部使用对应标签来配置通知的类型
               我们现在示例是让printLog方法在切入点方法执行之前之前：所以是前置通知
               aop:before：表示配置前置通知
                    method属性：用于指定Logger类中哪个方法是前置通知
                    pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

切入点表达式的写法：
    关键字：execution(表达式)
    表达式：
        访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
    标准的表达式写法：
        public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
    访问修饰符可以省略
        void com.itheima.service.impl.AccountServiceImpl.saveAccount()
    返回值可以使用通配符，表示任意返回值
        * com.itheima.service.impl.AccountServiceImpl.saveAccount()
    包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
        * *.*.*.*.AccountServiceImpl.saveAccount())
    包名可以使用..表示当前包及其子包
        * *..AccountServiceImpl.saveAccount()
    类名和方法名都可以使用*来实现通配
        * *..*.*()
    参数列表：
        可以直接写数据类型：
            基本类型直接写名称           int
            引用类型写包名.类名的方式   java.lang.String
        可以使用通配符表示任意类型，但是必须有参数
        可以使用..表示有无参数均可，有参数可以是任意类型
    全通配写法：
        * *..*.*(..)

    实际开发中切入点表达式的通常写法：
        切到业务层实现类下的所有方法
            * com.it.service.impl.*.*(..)

切点表达式

 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
              此标签写在aop:aspect标签内部只能当前切面使用。
              它还可以写在aop:aspect外面，此时就变成了所有切面可用

环绕通知

配置方式:
<aop:config>
	<aop:pointcut  id="pt1"  expression="execution(* com.itheima.service.impl.*.*(..))"/>
	<aop:aspect id="txAdvice" ref="txManager">
	<!-- 配置环绕通知 -->
		<aop:around method="transactionAround" pointcut-ref="pt1"/>
	</aop:aspect>
</aop:config>

aop:around：
作用：
	用于配置环绕通知
属性：
	method：指定通知中方法的名称。
	pointct：定义切入点表达式
	pointcut-ref：指定切入点表达式的引用
说明：
	它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
	通常情况下，环绕通知都是独立使用的


/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口： ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时， spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

AOP注解配置

在配置文件中指定 spring 要扫描的包
第一步：把通知类也使用注解配置
第二步：在通知类上使用@Aspect 注解声明为切面
第三步：在增强的方法上使用注解配置通知
第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持(aop:aspectj-autoproxy/
)

切入点表达式注解

@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1() {}

引用方式：
@Around("pt1()")//注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
	...
}

不使用 XML 的配置方式

@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy 
public class SpringConfiguration {
}