# 内容
1. 两种动态代理（基于接口或子类的动态代理）
2. AOP
* 概述、作用
* AOP相关术语
* 基于XML或注解的AOP配置
## 动态代理
1. 动态代理
* 特点：字节码随用随创建，随用随加载
* 作用：不修改源码的基础上对方法增强
2. 分类
* 基于接口的动态代理
* 基于子类的动态代理
3. 基于接口的动态代理
1. 提供者：提供者：JDK 官方的 Proxy 类。
2. 要求：被代理类至少实现一个接口。
3. 涉及的类：Proxy
4. 创建的方式：Proxy.newProxyInstance(三个参数)
5. newProxyInstance方法的参数：
* ClassLoader：类加载器
它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
* Class[]：字节码数组
它是用于让代理对象和被代理对象有相同方法。固定写法。
* InvocationHandler：用于提供增强的代码
它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
此接口的实现类都是谁用谁写。
* 基于接口的动态代理写生产者代理对象（Producer实现接口IProducer）：
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
producer.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 作用：执行被代理对象的任何接口方法都会经过该方法
* 方法参数的含义
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 当前执行方法所需的参数
* @return 和被代理对象方法有相同的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
proxyProducer.saleProduct(10000f);
}
}
3. 基于子类的动态代理
1. 提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
2. 要求：被代理类不能用 final 修饰的类（最终类）。
3. 涉及的类:Enhancer
4. 创建的方式：Enhancer.create(参数)
5. create方法的参数：
* Class：字节码
它是用于指定被代理对象的字节码。
* Callback：用于提供增强的代码
它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
此接口的实现类都是谁用谁写。
我们一般写的都是该接口的子接口实现类：MethodInterceptor、
* 基于子类的动态代理写producer代理对象
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {
/**
* 执行代理对象的任何方法都会经过该方法
* @param proxy
* @param method
* @param args
* 以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
* @param methodProxy ：当前执行方法的代理对象
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
cglibProducer.saleProduct(12000f);
}
}
## AOP
1. 概述
* 面向切面编程AOP（Aspect Oriented Programming），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
* AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
* 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
* 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强
2. 作用与优势：
* 作用：在程序运行期间，不修改源码对已有方法进行增强。
* 优势：减少重复代码、提高开发效率、方便维护
3. 实现方式：使用动态代理技术
4. AOP相关术语
* Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
* Pointcut(切入点): 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
* Advice(通知/增强): 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知。
* Introduction(引介): 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或Field。
* Target(目标对象): 代理的目标对象。
* Weaving(织入): 是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
* Proxy（代理）: 一个类被 AOP 织入增强后，就产生一个结果代理类。
* Aspect(切面): 是切入点和通知（引介）的结合。
5. AOP配置前的环境搭配
1. 必要的代码，包括实体类、业务层和持久层的代码
2. 导入必要的jar包到工程的lib目录
AOP所需的jar包
* aopalliance-1.0.jar
* aspectjweaver-1.8.7.jar
* spring-aop-5.0.2.RELEASEjar
* spring-aspect-5.0.2.RELEASEjar
IoC所需的jar包
* commons-logging-1.2.jar
* log4j-1.2.16.jar
* spring-beans-5.0.2.RELEASE.jar
* spring-context-5.0.2.RELEASE.jar
* spring-core-5.0.2.RELEASE.jar
* spring-expression-5.0.2.RELEASE.jar
3. 创建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">
</beans>
4. 配置spring的IoC
* 配置业务层、持久层、数据库操作对象等的bean对象以及配置数据源
5. 抽取公共部分代码制作成通知
* 新建一个事务控制类包括了开启事务、提交事务、回滚事务、释放资源等方法
6. 基于XML的AOP配置步骤
1. 把通知Bean也交给spring来管理：把环境搭建的事务控制类写入spring的配置文件中
2. 使用aop:config标签表明开始AOP的配置
3. 使用aop:pointcut标签配置切入点表达式（当需要时，不需要可以省去该步骤）
* 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
* 此标签写在aop:aspect标签内部只能当前切面使用。
* 此标签写在aop:aspect外面，此时就变成了所有切面可用
4. 使用aop:aspect标签表明配置切面
id属性：是给切面提供一个唯一标识
ref属性：是指定通知类bean的Id。
5. 在aop:aspect标签的内部使用对应标签来配置通知的类型
<aop:before>:表示前置通知，在切入点方法执行之前执行
<aop:after-returning>:表示后置通知，在切入点方法正常执行之后值。它和异常通知永远只能执行一个
<aop:after-throwing>:表示异常通知，在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
<aop:after>:表示最终通知，无论切入点方法是否正常执行它都会在其后面执行
各类通知标签里面的属性：
* method属性：用于指定通知类中哪个方法是前置通知
* pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
* pointcut-ref属性：使用已经指定切入点表达式
6. 切入点表达式的写法：
关键字：
execution(表达式)
表达式：
访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表)
通常写法：
* 切到业务层实现类下的所有方法
com.lyp.service.impl.*.*(..)
* 全通配写法：
* *..*.*(..)
1. 访问修饰符可以省略
写法：void com.lyp.service.impl.AccountServiceImpl.saveAccount()
2. 返回值可以使用通配符，表示任意返回值
写法：* com.lyp.service.impl.AccountServiceImpl.saveAccount()
3. 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
写法：* *.*.*.*.AccountServiceImpl.saveAccount())
4. 包名可以使用*..表示当前包及其子包
写法：* *..AccountServiceImpl.saveAccount()
5. 类名和方法名都可以使用*来实现通配
写法：* *..*.*()
6. 参数列表：
* 可以直接写数据类型：
基本类型直接写名称 如：int
引用类型写包名.类名的方式 如：java.lang.String
* 可以使用通配符表示任意类型，但是必须有参数
* 可以使用..表示有无参数均可，有参数可以是任意类型
<!-- 配置Logger类 -->
<bean id="logger" class="com.lyp.utils.Logger"></bean>
<!--配置AOP-->
<aop:config>
<!--配置切面 -->
<aop:aspect id="logAdvice" ref="logger">
<!-- 配置前置通知：在切入点方法执行之前执行
<aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>-->
<!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个
<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->
<!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->
<!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行
<aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->
</aop:aspect>
</aop:config>
7. 基于注解的AOP配置步骤
1. 在bean.xml的配置
<!-- 配置spring创建容器时要扫描的包-->
<context:component-scan base-package="com.lyp"></context:component-scan>
<!-- 配置spring开启注解AOP的支持 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
2. 在通知类的配置
* 在通知类的上面加上注解：@Aspect ，表示当前类是一个切面类
3. 可先在通知类中定义切入点表达式：
@Pointcut("execution(* com.lyp.service.impl.*.*(..))")
private void pt1(){}
3. 在各个通知方法的配置
* 方法上面加入通知类型的注解，通知指定切入点表达式
* 如：@Before("pt1()")
8. 学习Spring的AOP要明确的点：
a. 开发阶段
* 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
* 把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
* 在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。
b. 运行阶段
* Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
