Java开发中的代理模式：实现原理、设计原则及静态代理示例

代理模式：

在Java开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用。如房东出租房子

客户（客户类） 中介（代理类） 房东（委托类）一样。

什么是代理模式？

为某一个对象（委托类）提供一个代理（代理类)，用来控制对这个对象的访问。委托类和代理类有一个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求分配给指定对象。

代理模式二个设计原则

1，代理类与委托类有相似的行为（共同方法）

2，代理类增强委托类的行为

目录

静态代理实现（模拟出租房子）

创建代理（通过构造器传递行参（目标））

创建接口父类 （如果目标对象没有接口实现，则不能通过JDK动态代理生成代理对象）

静态代理什么是静态代理？

某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

代理三要素有共同的行为（接口）目标角色（实现行为）代理角色（实现目标行为，帮助目标角色增加行为）静态代理特点目标角色固定在应用程序执行前就得到目标角色代理对象会增强目标对象的行为有可能存在多个代理引起类爆炸”（缺点：一个工作需要一个代理，多个代理引起类爆炸)静态代理实现（模拟出租房子）创建共同父类接口

package com.lsf.statics;
/**
 * 静态代理
 *      父类或者父接口
 *      共同行为
 */
public interface RentHouse {
    // 共同行为 租房
    public void  ToRentHouse();
}

创建房东

package com.lsf.statics;
//模拟户东租房
public class Tenement implements RentHouse{
    public void ToRentHouse() {
        System.out.println("我想要出租一个豪宅，面朝大海春暖花开");
    }
}

创建代理（通过构造器传递行参（目标））

package com.lsf.statics;
/**
 * 静态代理
 *      代理对象
 *      1，实现目标行为（租房）
 *      2，增强目标行为
 */
public class AgencyProxy implements RentHouse {
    //目标对象
    private RentHouse target;
    //通过构造器传递行参（目标）
    public AgencyProxy(RentHouse target){
        this.target=target;
    }
    public void ToRentHouse() {
        //增强目标行为
        System.out.println("出租房子了！！！ 便宜方便 快来啊");
        //实现目标行为（租房）
        target.ToRentHouse();
        //增强目标行为
        System.out.println("出租成功，来签合同啊，亲");
    }
}

测试租房

package com.lsf;
import com.lsf.statics.AgencyProxy;
import com.lsf.statics.RentHouse;
import com.lsf.statics.Tenement;
public class Starter {
    public static void main(String[] args) {
        //目标对象
        RentHouse target = new Tenement();
        AgencyProxy proxy = new AgencyProxy(target);
        proxy.ToRentHouse();
    }
}

动态代理

动态代理：

（注:JDK动态代理的目标对象必须有接口实现）

在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制可以生成任意类型的动态代理类。

优点：

代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。

实现方式：

jdk动态代理

CGLIB代理

动态代理特点目标对象不固定在应用程序执行时动态创建目标对象代理对象会增强目标对象的行为Jdk动态代理方法

Proxy类:

Proxy类是专门完成代理的操作可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下操作方法:

public static 0bject newProxyInstance(
            ClassLoader loader,
            class[ ] interfaces,
            InvocationHandler h){
        
    }

创建接口父类 （如果目标对象没有接口实现，则不能通过JDK动态代理生成代理对象）

package com.lsf.statics;
/**
 * 静态代理
 *      父类或者父接口
 *      共同行为
 */
public interface RentHouse {
    // 共同行为 租房
    public void  ToRentHouse();
}

创建房东（目标类）

package com.lsf.statics;
/**
 * 静态代理
 *      父类或者父接口
 *      共同行为
 */
public interface RentHouse {
    //租房
    public void  ToRentHouse();
}

创建代理类

package com.lsf.dynamic;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 *  Jdk动态代理
 */
public class Jdkproxy {
    //目标对象(目标不确定所有使用 Object )
    private  Object target;
    //构造器传递参数
    public Jdkproxy (Object target){
        this.target=target;
    }
    /**
     * 得到代理对象
      * @return
     */

    public Object getProxy(){
        /**
         * 通过调用Proxy 代理类中的静态方法newProxyInstance()，得到代理对象
          */
        //定义生成代理对象进行加载
        ClassLoader loader = this.getClass().getClassLoader();
        //定义代理对象通过的接口
        Class[] interfase = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            /**
             * 当代理对象调用方法时，invoke方法就会被执行一次
             *
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法执行前，可以操作");
                //调用目标对象方法
                //通过反射中invoke方法，调用目标对象的指定方法
                /**
                 * 反射中的 invoke() 方法
                 * target  对象
                 * args   方法需要参数
                  */
                method.invoke(target,args);
                System.out.println("方法执行后，可以操作");
                //return 方法的返回值
                return null;
            }
        };
        //调用方法，获取代理对象
        Object object = Proxy.newProxyInstance(loader,interfase,invocationHandler);
        return object;
    }
}

测试类

package com.lsf;
import com.lsf.dynamic.Jdkproxy;
import com.lsf.statics.RentHouse;
import com.lsf.statics.Tenement;
public class Starter {
    public static void main(String[] args) {
        //目标对象
        RentHouse target = new Tenement();
        //得到代理
        Jdkproxy jdkproxy = new Jdkproxy(target);
        //获取代理对象
        RentHouse object = (RentHouse) jdkproxy.getProxy();
        //通过代理调用方法
        object.ToRentHouse();
    }
}

CGLIB代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用JDK的动态代理，cglib是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，

特点：

采用的是 继承 ， 所以不能对final修饰的类进行代理。

CGLIB代理实现

1,添加pom.xml依赖

            org.lucee
            cglib
            2.2.2
        

package com.lsf.dynamic;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**Cgilb动态代理
 *      继承思想
 *      创建一个代理类，代理类是目标类的子类，代理类对目标类进行重写
 */
public class CgilbProxy {
    //得到代理对象
    private Object target;
    public CgilbProxy(Object target){
        this.target=target;
    }
    public  Object getProxy(){
        //通过Enhancer对象的create()方法生成一个类，生成代理类
        Enhancer enhancer = new Enhancer();
        //设置当前类的父类（将目标类作为父类）
        enhancer.setSuperclass(target.getClass());
        //定义方法拦截器
        MethodInterceptor methodInterceptor = new MethodInterceptor() {
            /**
             * 当对象调用方法时，intercept就会调用
              * @param o  Cglib动态代理生成代理类
             * @param method  目标方法
             * @param objects  方法需要参数
             * @param methodProxy  代理对象方法引用
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("方法执行前...");
                Object result = method.invoke(target,objects);
                System.out.println("方法执行后...");
                return null;
            }
        };
        //设置代理过程(调用目标对象方法，增强目标行为)
        enhancer.setCallback(methodInterceptor);
        //生成一个类
        return enhancer.create();
    }
}

package com.lsf;
import com.lsf.dynamic.CgilbProxy;
import com.lsf.dynamic.Jdkproxy;
import com.lsf.statics.RentHouse;
import com.lsf.statics.Tenement;
public class CglibTest {
    public static void main(String[] args) {
        //目标对象
        RentHouse target = new Tenement();
        //得到代理
        CgilbProxy cgilbProxy = new CgilbProxy(target);
        //获取代理对象
        RentHouse object = (RentHouse) cgilbProxy.getProxy();
        //通过代理调用方法
        object.ToRentHouse();
    }
}

代理 对象 目标 方法 public 行为