代理模式
在学习 AOP 之前，我们先来了解下代理模式， 代理模式分为静态代理以及动态代理，属于23中设计模式之一。 AOP 的底层机制就是动态代理。
作用：
通过代理类为原始类增加额外的功能
1、静态代理
1）案例展示
【1】定义一个 Teacher 接口，接口中定义两个方法：teachOnLine 和 teachOffLine。
package cn.gc.spring03.interfce;
public interface Teacher {
String teachOnLine(String course);
String teachOffLine(String course);
}
【2】定义一个实现 Teacher 接口的 TeacherA 实现类，代码如下：
package cn.gc.spring03.interfce.impl;
import cn.gc.spring03.interfce.Teacher;
public class TeacherA implements Teacher {
@Override
public String teachOnLine(String course) {
System.out.println("开始"+course+"课程线上教学");
return course+"课程线上教学";
}
@Override
public String teachOffLine(String course) {
System.out.println("开始"+course+"课程线下教学");
return course+"课程线下教学";
}
}
【3】现在我们要在两个方法中的 开始课程教学 的前后添加上下课铃声的功能，此时我们再定义一个实现 Teacher 接口的静态代理类 TeacherAStaticProxy，代码如下：
package cn.gc.spring03.proxy;
import cn.gc.spring03.interfce.Teacher;
import cn.gc.spring03.interfce.impl.TeacherA;
public class TeacherAStaticProxy implements Teacher {
TeacherA teacherA=new TeacherA();
@Override
public String teachOnLine(String course) {
System.out.println(course+"课程上课时间到了");
String s = teacherA.teachOnLine(course);
System.out.println(course+"课程下课时间到了");
return s;
}
@Override
public String teachOffLine(String course) {
System.out.println(course+"课程上课时间到了");
String s = teacherA.teachOffLine(course);
System.out.println(course+"课程下课时间到了");
return s;
}
}
【4】运行效果如下
2）静态代理优缺点
（1）优点 ：在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展；可以使得真实角色更加纯粹，不再去关注一些公共的事情；公共的业务由代理来完成，实现了业务的分工。
（2）缺点 ：因为代理对象需要与目标对象实现一样的接口，所以会很多代理类 ,一旦接口增加方法，目标对象与代理对象都要维护，工作量变大，开发效率降低。
3）开发代理对象的原则
- 代理对象和目标对象实现相同的接口
- 代理对象依赖于目标对象
2、动态代理
在不改变原来的代码的情况下，实现了对原有功能的增强，这是 AOP 中最核心的思想。
AOP：纵向开发，横向开发
1）简介
动态代理的角色和静态代理的一样。但是动态代理的代理类是动态生成的，而静态代理的代理类是提前写好的。
动态代理分为两类，一类是基于接口动态代理（JDK），一类是基于类的动态代理（CGLib）。
2）基于接口动态代理（JDK）
程序运行的过程中，通过 JDK 提供代理技术动态的为某个类产生动态代理对象的过程。
开发代理对象的原则：
- 代理对象，不需要实现接口，但是目标对象要实现接口，否则不能用JDK动态代理。
- 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象。
- 动态代理也叫做 ：JDK代理、接口代理。
JDK 的动态代理需要了解两个类：
核心 : InvocationHandler （调用处理程序） 和 Proxy （代理）
实现步骤：在上面案例的基础上实现。
创建一个基于 JDK 的代理工具类 DynamicProxy 类：
package cn.gc.spring03.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxy {
//被代理对象
private Object target;
public DynamicProxy(Object obj) {
this.target = obj;
}
//生成代理对象
public Object getProxy() {
//获取类加载器
ClassLoader classLoader = target.getClass().getClassLoader();
//获取被代理对象实现的所有接口
Class<?>[] interfaces = target.getClass().getInterfaces();
//增强功能代码编写的位置
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 增强的功能
System.out.println(args[0] + "课程上课时间到了");
// 通过反射执行目标方法
Object invoke = method.invoke(target, args);
// 增强的功能
System.out.println(args[0] + "课程下课时间到了");
return invoke;
}
};
Object o = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
return o;
}
}
测试：
@Test
public void test02() {
Teacher teacher = new TeacherA();
DynamicProxy dynamicProxy = new DynamicProxy(teacher);
Teacher teacherProxy = (Teacher) dynamicProxy.getProxy();
teacherProxy.teachOnLine("Java");
System.out.println("______________________");
teacherProxy.teachOnLine("C++");
}
运行效果：
3）基于类的动态代理（CGLib）
开发代理对象的原则：
- 代理对象无需和原始类对象实现相同的接口
- 代理对象和原始类对象要存在父子类关系
CGLib 的动态代理需要了解两个类：
- 核心 : Enhancer 和 MethodInterceptor
实现步骤
创建一个 Aoo 类：
package cn.gc.spring03.interfce.impl;
public class Aoo {
public String test01(String info){
System.out.println("Aoo中的test01方法被调用。");
return info;
}
}
创建一个基于 CGLib 的代理工具类 CglibProxy 类：
package cn.gc.spring03.proxy;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxy {
private Object target;
public CglibProxy(Object obj){
this.target=obj;
}
public Object getProxy(){
Enhancer enhancer=new Enhancer();
//设置类加载器
enhancer.setClassLoader(CglibProxy.class.getClassLoader());
//设置被代理对象
enhancer.setSuperclass(target.getClass());
//增强功能代码编写的位置
MethodInterceptor methodInterceptor=new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("-------------cglib log--------------");
Object invoke = method.invoke(target, objects);
System.out.println("-------------cglib log--------------");
return invoke;
}
};
enhancer.setCallback(methodInterceptor);
//代理对象
Object o = enhancer.create();
return o;
}
}
测试：
@Test
public void test03() {
Aoo aoo=new Aoo();
CglibProxy cglibProxy = new CglibProxy(aoo);
Aoo proxy = (Aoo) cglibProxy.getProxy();
String info = proxy.test01("java");
System.out.println("info = " + info);
}
运行效果：
4）动态代理的优势
- 可以使得真实角色更加纯粹，不再去关注一些公共的事情。
- 公共的业务由代理来完成，实现了业务的分工。
- 公共业务发生扩展时变得更加集中和方便。
- 一个动态代理，一般代理某一类业务。
- 一个动态代理可以代理多个类，代理的是接口。
到此这篇关于Spring细数两种代理模式之静态代理和动态代理概念及使用的文章就介绍到这了,更多相关Spring静态代理与动态代理内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
