代理模式(Proxy Pattern )是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。
在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
使用代理模式主要有两个目的:一是保护目标对象，二是增强目标对象。
2.1 抽象角色( Subject ): 抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类
2.2 真实角色(RealSubiect ): 该类也被称为被代理类，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象:
2.3 代理角色 ( Proxy): 也被称为代理类，其内部持有 RealSubiect 的用，因此具备完全的对RealSubiect 的代理权。客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。
2.1 创建一个抽象角色：用于代理和真实对象共同接口方法。
public interface ISubject {
void request();
}
2.2 创建一个真实角色：用于执行真正的业务逻辑处理。
public class RealSubject implements ISubject {
public void request() {
System.out.println("real service is called.");
}
}
2.3 创建一个代理角色：调用真实业务逻辑时候前后自己处理逻辑代码。
public class Proxy implements ISubject {
//1.获取真实对象封装处理
private ISubject subject;
public Proxy(ISubject subject){
this.subject = subject;
}
//2.调用真实对象业务逻辑，前后加一些自己逻辑增强处理。
public void request() {
before();
subject.request();
after();
}
//3.前后增加逻辑处理
public void before(){
System.out.println("called before request().");
}
public void after(){
System.out.println("called after request().");
}
}
2.4 测试功能
public class Client {
public static void main(String[] args) {
//创建代理对象并绑定一个真实对象
Proxy proxy = new Proxy(new RealSubject());
//执行代理对象功能调用
proxy.request();
}
}
//--结果处理------------
called before request().
real service is called.
called after request().
1.抽取角色：定义一个接口用于真实和代理对象共同的接口方法
//定义人的接口，相亲接口方法
public interface IPerson {
void findLove();
}
2.真是角色：创建一个真正的人的对象并实现相亲接口方法具体逻辑
//定义一个张三人对象并提出相亲的要求
public class ZhangSan implements IPerson {
public void findLove() {
System.out.println("张三：要求相亲女孩长得好看又善良");
}
}
3.代理角色：创建一个代理张三对象(张三的父亲)代理完成张三的相亲要求。
public class ZhangLaosan implements IPerson {
//---静态代理------------------------
//1.创建获取静态代理对象处理【只能接受张三这个人，其他人不能接受】
private ZhangSan zhangsan;
public ZhangLaosan(ZhangSan zhangsan) {
this.zhangsan = zhangsan;
}
//2.完成张三的相亲，并在相亲的前后做一些工作和处理。
public void findLove() {
System.out.println("张老三开始物色");
zhangsan.findLove();
System.out.println("开始交往");
}
//---动态代理------------------------
//1.创建获取动态代理对象处理【只要实现抽象角色的接口，任何真实对象都可以接受并执行代理逻辑】
private IPerson person;
public ZhangLaosan(IPerson person) {
this.person = person;
}
//2.完成张三的相亲，并在相亲的前后做一些工作和处理。
public void findLove() {
System.out.println("张老三开始物色");
person.findLove();
System.out.println("开始交往");
}
}
4.测试代码
public class Test {
public static void main(String[] args) {
ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
zhangLaosan.findLove();
}
}
结果：
张老三开始物色
张三：要求相亲女孩长得好看又善良
开始交往
1.抽取角色：定义一个接口用于真实和代理对象共同的接口方法
public interface IPerson {
void findLove();
}
2.真是角色：创建一个真正的人的对象并实现相亲接口方法具体逻辑
//定义一个张三人对象并提出相亲的要求
public class ZhangSan implements IPerson {
public void findLove() {
System.out.println("张三：要求相亲女孩长得好看又善良");
}
}
3.代理角色：创建一个代理张三对象(张三的父亲)代理完成张三的相亲要求。
public class JdkMeipo implements InvocationHandler {
//1.定义接受真实对象变量
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target; //真实对象赋值
//clazz.getClassLoader()：真实对象反射类对象（可以通过目标类的getClassLoader()方法来获取目标类的ClassLoader对象）
//clazz.getInterfaces()：真实对象接口列表 (Class[]对象,代理类要实现的接口列表。代理类将会实现这些接口，并且可以调用接口中定义的方法)
//this：真实对象(InvocationHandler接口的实现类对象，代理类在调用方法时会委托给该InvocationHandler对象来处理)
Class<?> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("双方同意，开始交往");
}
private void before() {
System.out.println("我是媒婆，已经收集到你的需求，开始物色");
}
}
4.测试
public class Test {
public static void main(String[] args) {
JdkMeipo jdkMeipo = new JdkMeipo();//创建一个代理对象
IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());//把真实对象代理处理一个代理张三的对象
zhangsan.findLove();
}
}
结果：
张老三开始物色
张三：要求相亲女孩长得好看又善良
开始交往
依赖maven cglib库
cglib
cglib-nodep
2.2
1.定义真实对象类并写真实的业务逻辑处理。
public class Customer {
public void findLove(){
System.out.println("儿子要求：肤白貌美大长腿");
}
}
2.定义代理对象
public class CGlibMeipo implements MethodInterceptor {
//1.定义接受真实对象处理，返回一个代理对象
public Object getInstance(Class<?> clazz) throws Exception{
//相当于Proxy，代理的工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
/*
o：被代理的对象。即原始对象，也就是目标类的实例。
method：要被调用的方法对象。即将要执行的目标方法。
objects：方法的参数数组。即目标方法的参数列表。
methodProxy：方法的代理对象。通过该对象可以调用目标方法。使用methodProxy.invokeSuper(o, objects)可以触发目标方法的执行。
*/
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("OK的话，准备办事");
}
}
3.测试
public class CglibTest {
public static void main(String[] args) {
try {
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes");//打印代理对象生成的class文件
//CGlibMeipo代理对象绑定真实对象并返回代理对象
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
//执行代理对象方法并调用真实对象
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
代理模式具有以下优点
(1)代理模式能将代理对象与真实被调用目标对象分离
(2)在一定程度上降低了系统的耦合性，扩展性好
(3)可以起到保护目标对象的作用
(4)可以增强目标对象的功能
当然，代理模式也有缺点
( 1)代理模式会造成系统设计中类的数量增加
(2)在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢.
(3)增加了系统的复杂度
JDK是采用读取接口的信息
CGLib覆盖父类方法
目的：都是生成一个新的类，去实现增强代码逻辑的功能
JDK Proxy 对于用户而言，必须要有一个接口实现，目标类相对来说复杂
CGLib 可以代理任意一个普通的类，没有任何要求
CGLib 生成代理逻辑更复杂，效率,调用效率更高，生成一个包含了所有的逻辑的FastClass，不再需要反射调用
JDK Proxy生成代理的逻辑简单，执行效率相对要低，每次都要反射动态调用
CGLib 有个坑，CGLib不能代理final的方法