AOP编程
一、静态代理设计模式
1.为什么需要代理设计模式
（1）问题
（1）在javaEE分层开发中，哪个层次对于我们来讲最重要
DAO（操作数据库）–> Service（服务代码）–> Controller
Service最重要
（2）Service层包含了哪些代码
核心功能：业务运算 DAO的调用
额外功能：不属于业务、可有可无、代码量少，如：事务、日志、性能等
（3）额外功能在Service层中完成好不好
Service层的调用者角度(Controller)：需要在Service层中加额外功能
软件设计这角度：Service层不需要额外功能
（4）为了解决问题
2.代理设计模式
（1）概念
通过代理类，为原始（目标）类增加额外的功能
好处：利于原始类的维护
（2）名词解释
（1）原始类：业务类（只做核心功能 —> 业务运算、DAO调用）
（2）原始方法：原始类中的方法
（3）额外功能：日志、事务、性能等
（3）代理开发的核心要素
代理类 = 原始类（目标类）+ 额外功能 + 与原始类实现相同的接口
3.静态代理开发
//静态代理：为每一个原始类，手工编写一个代理类
public class UserServiceProxy implements UserService{
private UserServiceImpl userService=new UserServiceImpl();
@Override
public void register(User user) {
System.out.println("-------log--------");
userService.register(user);
}
@Override
public boolean login(String name, String password) {
System.out.println("------log--------");
return userService.login(name, password);
}
}
4.静态代理存在的问题
（1）静态代理文件数量过多，不利于项目管理
（2）额外功能的维护性差，代理类中额外功能修改复杂麻烦
二、Spring动态代理开发
1.动态代理概念
（1）概念：通过代理类，为原始（目标）类增加额外的功能
（2）好处：利于原始类的维护
2.搭建开发环境
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.3.22</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.9.1</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
3.Spring动态代理的开发步骤
（1）创建原始对象
（1）创建原始类
public class UserServiceImpl implements UserService{
@Override
public void register(User user) {
System.out.println("UserServiceImpl.register");
}
@Override
public boolean login(String name, String password) {
System.out.println("UserServiceImpl.login");
return false;
}
}
（2）在Spring配置文件中配置
<bean id="userService" class="www.study.proxy.UserServiceImpl"/>
（2）额外功能
MethodBeforeAdvice 接口，需要将额外功能书写在接口的实现中（在原始方法运行之前运行额外功能）
public class Before implements MethodBeforeAdvice {
/**
* 作用：需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
*/
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("---------method before advice log------------");
}
}
<bean id="before" class="www.study.dynamic.Before"/>
（3）定义切入点
切入点：额外功能加入的位置
目的：由程序员根据自己的需要，来决定额外功能加入给哪个原始方法
配置文件中配置切入点
<aop:config>
<!--所有的方法都作为切入点，增加额外功能-->
<aop:pointcut id="" expression="execution(* *(..))"/>
</aop:config>
（4）组装
将（2）和（3）进行整合
<aop:config>
<!--所有的方法都作为切入点，增加额外功能-->
<aop:pointcut id="pc" expression="execution(* *(..))"/>
<!--组装：把切入点和额外功能进行整合-->
<aop:advisor advice-ref="before" pointcut-ref="pc"/>
//表达含义：所有的方法都加入before额外功能
</aop:config>
（5）调用
目的：获得Spring工厂创建的动态代理对象，并进行调用
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//注意：1.Spring的工厂通过原始对象的 id值 获得的是代理对象。2.获得代理对象后，可以通过声明接口类型进行对象的存储
UserService userService = (UserService)ac.getBean("userService");
//调用
userService.login("");
userService.register("");
4.Spring动态代理的细节
（1）Spring创建的动态代理类在哪里
（1）Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后，会和JVM一起消失
（2）动态字节码：通过第三方动态字节码框架，在JVM中常见对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失
（3）结论：动态代理不需要定义文件，都是JVM运行过程中动态创建的，所以不造成静态代理（解决静态代理的问题）
（2）动态代理编程简化代理的开发
在额外功能不改边的前提下，创建其他原始类的代理对象时，之u需要指定原始对象
（4）动态代理额外功能的维护性大大增加了
三、Spring动态代理详解
1.额外功能详解
（1）MethodBeforeAdvice分析
public class Before implements MethodBeforeAdvice {
/**
* 作用：需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
* method：额外功能所增加给的那个原始方法
* Object[]：额外功能所增加给的那个原始方法的参数
* Object：额外功能所增加给的那个原始对象
*/
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("---------method before advice log------------");
}
}
before方法中的3个参数在开发中如何使用
before方法的参数在实际开发中根据需要来进行使用
（2）MethodIntercepter（方法拦截器）：开发常用
（1）MethodBeforeAdvice ----> 原始方法执行之前
MethodIntercepter ----> 原始方法执行前后都可以
（2）作用：额外功能可以运行在原始方法 之前/ 之后/ 前后
//额外功能运行在原始方法之前
public class Arround implements MethodInterceptor {
/**
*invoke方法的作用：额外功能书写在invoke中，额外功能可以运行在原始方法 之前/ 之后/ 前后
* 确定：原始方法怎么运行
* MethodInvocation：额外功能所增加给的那个原始方法
* 返回值：原始方法执行之后的返回值
*/
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("-------log--------");//运行在原始方法之前
Object ret = invocation.proceed();//运行原始方法
return ret;
}
}
//额外功能运行在原始方法之后
public class Arround implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Object ret = invocation.proceed();//运行原始方法
System.out.println("-------log--------");//运行在原始方法之后
return ret;
}
}
//前后都运行【事务】
public class Arround implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("-------前--------");//运行在原始方法之前
Object ret = invocation.proceed();//运行原始方法
System.out.println("-------后--------");//运行在原始方法之后
return ret;
}
}
//额外功能运行在原始方法抛出异常的时候
public class Arround implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Object ret=null;
try{
ret=invocation.proceed();
}catch (Throwable throwable){
System.out.println("-----抛异常之后------");
throwable.printStackTrace();
}
return ret;
}
}
MethodIntercepter影响原始方法的返回值
（1）原始方法的返回值直接作为 invoke 方法的返回值返回， MethodIntercepter 不会影响原始方法的返回值
（2）影响返回值看如下代码：
public class Arround implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("-------前--------");//运行在原始方法之前
Object ret = invocation.proceed();//运行原始方法
return false;
}
}
2.切入点详解
切入点决定额外功能的加入位置（方法）
<aop:pointcut id=“pc” expression=“execution(* *(…))”/>
（1）切入点函数
作用:用于执行切入点表达式
（1）execution
（1）优点：最为重要的切入点表达式，功能最全。
可以执行方法切入点表达式 类切入点表达式 包切入带你表达式。
（2）弊端：执行切入点表达式书写麻烦
（3）注意：其他的切入点函数，简化的是 execution 书写复杂度，功能完全一致
（2）args
（1）作用：主要用于方法参数的匹配
切入点：方法参数是两个String类型， args(String,String)
（3）within
（1）作用：主要用于进行类、包切入点表达式的匹配
切入点：UserServiceImpl这个类，within(…UserServiceImpl)
切入点：包下的，within(www.study.proxy…)
（4）@annotation
（1）作用：为具有特殊注解的方法加入额外功能
//首先定义切入点
@Target(ElementType.METHOD)//决定了这个注解用在方法(.METHOD),如果用在类的话则用(.TYPE)
@Retention(RetentionPolicy.RUNTIME)//决定了这个注解在什么时候起作用
public @interface Log {
}
//在配置文件中配置
<aop:pointcut id="pc" expression="@annotation(www.study.Log)"/>
（5）切入点函数的逻辑运算
指的是整合多个切入点函数一起配合工作，进而完成更为复杂的需求
and与操作
案例：方法名是 login，参数：两个字符串
（1）execution(* login(String,String))
（2）execution(* login(…)) and args(String,String)
注意：与操作不能用于同种类型的切入点函数
or或操作
案例：register方法 和 login方法
execution(* register(…)) or execution(* login(…))
（2）方法切入点表达式
（1）方法切入点
表达式 ：* *(…)表示所有方法
第一个 * 代表修饰符 返回值
第二个 * 代表方法名
()代表参数表
…代表参数
//使用 login 方法作为切入点
<aop:pointcut id="pc" expression="execution(* login(..))"/>
//使用 login 方法作为切入点 并且有两个字符串类型的参数
<aop:pointcut id="pc" expression="execution(* login(String,String))"/>
//注意：非 java.lang 包中的类型，必须写权限定名
<aop:pointcut id="pc" expression="execution(* register(www.study.proxy.User))"/>
//精准的切入点：修饰符 返回值 包.类.方法(参数)
精准的切入点：修饰符 返回值 包.类.方法(参数)
（2）类切入点
指定特定类作为切入点，这个类中的所有方法都会加上对应的额外功能
选择一个类下的方法 ：* 包.类.*(…)
//类中所有的方法都加上额外功能
<aop:pointcut id="pc" expression="execution(* www.study.proxy.UserServiceImpl.*(..))"/>
//忽略包
//1.类只存在一级包 www.UserServiceImpl
<aop:pointcut id="pc" expression="execution(* *.UserServiceImpl.*(..))"/>
//2.类存在多级包 www.study.proxy.UserServiceImpl
<aop:pointcut id="pc" expression="execution(* *..UserServiceImpl.*(..))"/>
（3）包切入点（实际开发常用这个）
指定包作为额外功能加入的位置，保重所有类及其方法都会加入额外功能
// * 包.*.*(..) 当前包
<aop:pointcut id="pc" expression="execution(* www.study.proxy.*.*(..))"/>
// * 包..*.*(..) 当前包及其子包
<aop:pointcut id="pc" expression="execution(* www.study.proxy..*.*(..))"/>
3.动态代理总结
（1）动态代理作用：通过代理类为原始类增加额外功能
（2）好处：利于原始类维护
四、AOP编程
1.AOP概念
（1）AOP（Aspect Oriented Programing）面向切面编程 = Spring动态代理开发：
以切面为基本单位的程序开发，通过切面间的彼此协同、相互调用，完成程序的构建
（2）切面 = 切入点 + 额外功能
（3）AOP的概念：本质就是Spring的动态代理开发，通过代理类为原始类增加额外功能，好处是利于原始类的维护。
（4）注意：AOP编程不能取代OOP(面向对象编程)，是OOP编程的补充。
2.AOP编程的开发步骤
（1）原始对象
（2）额外功能（MethodInterceptor）
（3）切入点
（4）组装切面（额外功能 + 切入点）
3.切面的名词解释
（1）切面 = 切入点 + 额外功能
五、AOP的底层实现原理
1.核心问题
（1）AOP如何创建动态代理类（动态字节码技术）
（2）Spring工厂如何加工创建代理对象的
2.动态代理的创建
（1）JDK的动态代理
（1）Proxy.newProxyInstance(1,2,3) 第三个参数的作用
（2）Proxy.newProxyInstance(1,2,3) 第一个参数的作用
编码
public class TestJDKProxy {
public static void main(String[] args) {
//1.创建原始对象
UserService userService=new UserServiceImpl();
//2.JDK创建动态代理
InvocationHandler handler=new InvocationHandler() {
//invoke：书写额外功能
/**
*Object：原始方法的返回值
* Proxy：可以忽略，代表的是代理对象
* Method：额外功能所增加给的那个原始方法
* Object[]：原始方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("----------前----------");
//原始方法运行
Object ret = method.invoke(userService,args);
return ret;
}
};
//Proxy.newProxyInstance的返回值就是创建好的动态代理
/**
* 第三个参数代表着额外功能，需要实现
* 第二个参数：原始对象所实现的接口
* 第一个参数：借用一个类加载器，为了创建代理类的Class对象，进而可以创建代理对象
*/
UserService userServiceProxy=(UserService) Proxy.newProxyInstance(TestJDKProxy.class.getClassLoader(),userService.getClass().getInterfaces(),handler);
userServiceProxy.login("jack","123456");
userServiceProxy.register(new User());
}
}
（2）Cglib的动态代理
原理：父子继承的关系来创建对象，原始类作为父类，代理类作为子类，这样既可以保证二者方法一致，同时在代理类中提供新的实现方法（原始方法+额外功能）
编码
public class TestCglib {
public static void main(String[] args) {
//1.创建原始对象
UserService userService=new UserService();
/**
* 2.通过cglib方式来创建动态代理对象
* Enhancer.setClassLoader()借用一个类加载器，为了创建代理类的Class对象，进而可以创建代理对象
* Enhancer.setSuperClass()设置父类
* Enhancer.setCallback()设置额外功能 ---->MethodInterceptor()
* Enhancer.create() ---->代理
*/
Enhancer enhancer=new Enhancer();
enhancer.setClassLoader(TestCglib.class.getClassLoader());
enhancer.setSuperclass(userService.getClass());
MethodInterceptor interceptor=new MethodInterceptor() {
//等同于InvocationHandler --- invoke
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//额外功能
System.out.println("-------前-------");
Object ret=method.invoke(userService,args);
return ret;
}
};
enhancer.setCallback(interceptor);
UserService userServiceProxy=(UserService) enhancer.create();
userServiceProxy.login("mark","123456");
userServiceProxy.register(new User());
}
}
（3）总结
（1）JDK动态代理 Proxy.newProxyInstance() 通过接口创建代理的实现类
（2）Cglib动态代理 Enhancer 通过继承父类创建的代理类
3.Spring工厂如何加工原始对象
编码
public class ProxyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
/**
*Proxy.newProxyInstance();
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
InvocationHandler handler=new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-------new log-----------");
Object ret=method.invoke(bean,args);//原始方法运行
return ret;
}
};
return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(),handler);
}
}
<!--Spring工厂如何加工原始对象-->
<bean id="userService" class="www.study.factory.UserServiceImpl"/>
<!--1.实现 BeanPostProcessor 进行加工
2.配置文件中对 BeanPostProcessor 进行配置-->
<bean id="proxyBeanPostProcessor" class="www.study.factory.ProxyBeanPostProcessor"/>
六、基于注解的AOP编程
1.基于注解的AOP编程的开发步骤
（1）原始对象
（2）额外功能
（3）切入点
（4）组装切面
（2）（3）（4）联合，通过切面类来完成（定义了额外功能，定义了切入点）
/**
* 切面类（需要提供Aspect注解）
* 组成：
* 1.额外功能
* 2.切入点
*/
@Aspect
public class MyAspect {
//1.定义额外功能方法（需要加入Around注解）,方法名自己定义
@Around("execution(* login(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("-------aspect log----------");//额外功能
Object ret = joinPoint.proceed();//运行原始方法
return ret;
}
//2.切入点
//@Around("execution(* login(..))")注解里边添加参数，直接写好了切入点
}
配置文件中配置
<!--基于注解的AOP编程-->
<bean id="userService" class="www.study.aspect.UserServiceImpl"/>
<!--切面：
1.额外功能
2.切入点
3.组装切面-->
<bean id="around" class="www.study.aspect.MyAspect"/>
<!--告知Spring要通过基于注解来进行AOP编程-->
<aop:aspectj-autoproxy/>
2.细节
（1）切入点复用
//切入点复用：在切面类中定义一个函数，上边加 @Pointcut 注解，通过这种方式，定义切入点表达式，后续更加有利于切入点的复用
@Aspect
public class MyAspect {
@Pointcut("execution(* login(..))")
public void myPointcut(){}//定义这个，方便以后修改
//1.定义额外功能方法（需要加入Around注解）,方法名自己定义
@Around(value = "myPointcut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("-------aspect log----------");//额外功能
Object ret = joinPoint.proceed();//运行原始方法
return ret;
}
//2.切入点
//@Around("execution(* login(..))")注解里边添加参数，直接写好了切入点
@Around(value = "myPointcut()")
public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("-------aspect tx----------");//额外功能
Object ret = joinPoint.proceed();//运行原始方法
return ret;
}
}
（2）动态代理的创建方式
（1）JDK 通过实现接口，做新的实现类方式，来创建代理对象
（2）Cglib 通过继承父类，做新的子类，来创建代理对象
（3）默认情况下，AOP编程底层是应用JDK动态代理创建方式
（4）如果切换Cglib： <aop:aspectj-autoproxy proxy-target-class=“true”/>
七、AOP开发中的一个坑
在同一个业务类中，进行业务方法间的相互调用，只有最外层方法，才加入了额外功能（内部的方法，通过普通的方法调用，都调用的是原始方法）。如果下想让内层的方法也调用代理对象的方法，就要用 ApplicationContextAware 获得工厂，进而获得代理对象。
public class UserServiceImpl implements UserService, ApplicationContextAware {
private ApplicationContext ac;
@Override
public void login(String name, String password) {
System.out.println("UserService.login");
}
@Override
public void register(User user) {
System.out.println("UserServiceImpl.register");
//调用的是原始对象的 login方法，只能完成核心功能
UserService userService=(UserService) ac.getBean("userService");
userService.login("jack","123");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.ac=applicationContext;
}
}
八、AOP阶段知识总结
1、AOP编程的概念（Spring的动态代理开发）
概念：通过代理类为原始类增加额外功能
好处：利于原始类的维护
2、AOP编程的开发（Spring动态代理的开发）
传统的：
（1）原始对象
（2）额外功能
（3）切入点
切入点表达式：方法： * login(…) ，类：* …UserServiceImpl.(…) ， 包： www.study….(…)
切入点函数：execution,within,args,@annotation
（4）组装切面
注解的：
（1）原始对象
（2）额外功能
（3）切入点
（4）组装切面
（2），（3），（4）联合
3.AOP编程的底层实现
（1）JDK ，proxy.newProxyInstance() -----> 原始对象的接口，来创建代理对象（默认的）
（2）Cglib ，Enhancer.create() ------> 把原始类作为代理类的父类，通过继承的方式创建代理对象
使用BeanPostProcessor 进行对象的加工
