参考示例源代码:
https://github.com/huangzhenshi/SpringFreamworkDemo/tree/master
概述
Spring代理模式的运用场景: 操作日志、事务控制、异常处理（AOP ThrowsAdvice）、权限认证、缓存
Spring AOP实现的默认两种方式：DK动态代理、CGLIB
- JDK动态代理 反射原理的类依赖其接口，代理接口的实现方法，普通方法无法代理。
- CGLIB，字节码增强技术，根据代理类实现一个增强的子类,采用方法拦截的技术拦截所有父类方法的调用，并顺势织入横切逻辑
设置proxy-target-class=true，全部都用CGLIB，false则接口类用反射，非接口类用CGLIB
Spring实现代理有4种方式：子类继承、@Aspect注解、JDK动态代理、CGLIB，各有各适用的场景
代理模式分析
继承的方法，最灵活，可以精准实现一个被代理类的一个方法。
@Aspect 先定义一个自定义注解，再定义一个@Aspect类，并且把切点指定为自定义注解，编写不同业务场景下的代理逻辑，最后直接在需要代理的方法上使用。优点是非常容易复用，而且封装了复杂性。编译期生成代码。
JDK动态代理，半灵活，把需要代理的方法写在继承接口里面，不希望被代理的方法，写在普通方法里面。
CGLIG最方便，不依赖接口，全部方法都用相同的代理逻辑
可以通过继承的方式，然后重写父类的方法，这样实现代理模式。
优势：特别灵活，可以根据业务需求，为某个代理类的每个方法实现不同的代理逻辑
缺点：代码量太大。如果一个类的多个方法代理逻辑一样，或者多各类的代理逻辑一样，无法复用。@Aspect是针对某一类方法而创造的，比如对service层的所有新增的方法，添加日志的功能。
优势： 编码简洁（写一个工具注解既可以，然后在需要代理的类上做注解即可），可以实现精准代理，是针对方法的代理模式
JDK动态代理，实体类所有的接口方法，都会执行相同的代理逻辑
优点：可以批量代理一个代理类里面所有接口中的方法；不同的代理类继承相同的接口，可以复用代理工具类，只要代理逻辑一样
缺点：完全依赖接口，所有要代理的方法必须要在接口中存在，否则无法代理CGLIG代理模式：
优点：没有束缚，通过特殊的处理，通过继承和织入，对该类的所有的方法，都织入相同的代理逻辑
缺点：缺乏灵活性，无法为代理类的某一个方法定制特殊的代理逻辑
JDK动态代理实现
实现步骤：
- 写一个接口Subject，把所有要代理的方法都要写在接口里面
- 被代理类RealSubject实现接口，实现自己本身的业务逻辑，当然也可以包含一些不想被代理的方法，只要接口里没有，都不会被代理
- 写一个代理工具类Dynamicproxy，实现InvocationHandler接口，实现invoke方法，编写代理逻辑
- 创建代理类，调用代理方法
注意事项：被代理类里面可以包含接口里面没有的方法，实现保护某些方法被代理，这些未暴露的方法，在代理类中是不可见的，也不能被调用。
代码
public interface Subject {
public void rent();
public void hello(String str);
}
public class RealSubject implements Subject{
@Override
public void rent() {
System.out.println("I want rent my house");
}
@Override
public void hello(String str) {
System.out.println("hello:"+str);
}
public void test(){
System.out.println("Test");
}
}
代理工具类
public class Dynamicproxy implements InvocationHandler{
//这就是我们代理的真实对象
private Object subject;
//构造方法，给我们要代理的真实对象赋值
public Dynamicproxy(Object subject){
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//在代理真实对象前我们可以添加一些自己的操作
System.out.println("代理开始");
System.out.println("代理Method:"+method);
//当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
method.invoke(subject, args);
//在代理真实对象后我们可以添加一些自己的操作
System.out.println("代理结束");
return null;
}
}
代理
public class JDK动态代理 {
public static void main(String[] args) {
//我们要代理的真实对象
RealSubject realSubject = new RealSubject();
//我们要代理哪个真实对象，就将该对象传进去，最后通过该真实的对象调用该方法
InvocationHandler handler = new Dynamicproxy(realSubject);
Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);
System.out.println(subject.getClass().getName());
subject.rent();
subject.hello("world");
}
}
CGLib实现
- 通过实现MethodInterceptor的intercept方法，来对所有的代理类进行代理操作。
- 具体涉及到继承的增强类子类Enhancer类。并设置子类的方法调用触发器
public class CglibProxy implements MethodInterceptor {
// 被代理对象
Object targetObject;
//参数为被代理类，返回结果为代理类
public Object getProxyObject(Object object) {
this.targetObject = object;
//增强器，动态代码生成器
Enhancer enhancer=new Enhancer();
//回调方法
enhancer.setCallback(this);
//设置生成类的父类类型
enhancer.setSuperclass(targetObject.getClass());
//动态生成字节码并返回代理对象
return enhancer.create();
}
// 拦截方法
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("方法调用前");
// 调用方法
Object result = methodProxy.invoke(targetObject, args);
System.out.println("方法调用后");
return result;
}
}
Spring中的配置
- Pointcut（切点）：指定在哪些类的哪些方法上织入横切逻辑
- Advice（增强）：描述横切逻辑和方法的具体织入点（方法前、方法后、方法的两端等）
- Advisor（切面）：将Pointcut和Advice两者组装起来。有了Advisor的信息，Spring就可以利用JDK或CGLib的动态代理技术采用统一的方式为目标Bean创建织入切面的代理对象了
<aop:config expose-proxy="true" proxy-target-class="true">
<aop:pointcut id="txPointcut" expression="execution(* com.test.service..*.*(..))"/>
<aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/>
</aop:config>
自定义注解的使用
https://www.jianshu.com/p/7dcd59bdbb0a
- 通过元注解给注解做修饰
- 在对应的地方使用注解（可以是类上加注解、方法上加注解、属性上加注解)
- 通过反射获取到目标（类、方法、属性），并调用 ***.getAnnotation()，从而获取注解类
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyMessage {
String name() default "sam";
int num() default 0;
String desc();
}
public class AnnotationTest {
@MyMessage(num = 10, desc = "参数a")
private static int a;
@MyMessage(name = "Sam test", desc = "测试方法test")
public void test() {
System.out.println("test");
}
}
public static void main(String[] args) throws Throwable{
//加载annotationTest.class类
Class clazz = Class.forName("com.test.aop.自定义注解.AnnotationTest");
//获取属性
Field[] fields = clazz.getDeclaredFields();
//遍历属性
for (Field field : fields) {
MyMessage myMessage = field.getAnnotation(MyMessage.class);
System.out.println("name:" + myMessage.name() + " num:" + myMessage.num() + " desc:" + myMessage.desc());
}
//获取类中的方法
Method[] methods = clazz.getMethods();
//遍历方法
for (Method method : methods) {
//判断方法是否带有MyMessage注解
if (method.isAnnotationPresent(MyMessage.class)) {
// 获取所有注解 method.getDeclaredAnnotations();
// 获取MyMessage注解
MyMessage myMessage = method.getAnnotation(MyMessage.class);
System.out.println("name:" + myMessage.name() + " num:" + myMessage.num() + " desc:" + myMessage.desc());
}
}
}
Aspect
https://www.cnblogs.com/magicalSam/p/7161942.html
原理：通过自定义注解+Aspect技术实现AOP代理
- 通过@Aspect注解使该类成为切面类
- 通过@Pointcut 指定切入点 ，这里指定的切入点为MyLog注解类型，也就是被@MyLog注解修饰的方法，进入该切入点。
- @Before 前置通知：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
- @Around 环绕通知：可以实现方法执行前后操作，需要在方法内执行point.proceed(); 并返回结果。
- @AfterReturning 后置通知：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
- @AfterThrowing 异常通知：在方法抛出异常退出时执行的通知。
- @After 后置通知：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回
@Aspect
@Component
public class MyLogAspect {
//切入点
@Pointcut(value = "@annotation(com.test.aop.aspectj.MyLog)")
private void pointcut() {
}
//pointcut() 设置切点，也就是aspect绑定Mylog注解的一个纽带
//@annotation(myLog) 注入当前的mylog，这样才可以正常的mylog.requestUrl了
@Around(value = "pointcut()&& @annotation(myLog)")
public Object around(ProceedingJoinPoint point, MyLog myLog) {
System.out.println("++++执行了around方法++++");
//拦截的类名
Class clazz = point.getTarget().getClass();
//拦截的方法
Method method = ((MethodSignature) point.getSignature()).getMethod();
System.out.println("执行了 类:" + clazz + " 方法:" + method + " 自定义请求地址:"+myLog.requestUrl());
try {
Object result=point.proceed();
System.out.println("++++执行了around方法结束++++");
return result;//执行程序
} catch (Throwable throwable) {
throwable.printStackTrace();
return throwable.getMessage();
}
}
}
