java三种代理模式

代理模式分为静态代理和动态代理，其中动态代理分为jdk动态代理和cglib动态代理

1.代理模式

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

代理模式的关键点是:代理对象与目标对象。代理对象是对目标对象的扩展,并会调用目标对象

2.代理模式的应用

可以分为如下几种：

    1）远程代理（Remote ）：为远程对象的invoke提供代理，典型的例子如RMI或者EJB，都会在本地生成一个远程对象的stub。

    2）虚拟代理（Virtual）：如果需要创建一个资源消耗大的对象，则可以首先使用一个代理，使这个对象在需要时才真正创建。

    3）Copy-On-Write 代理：把复制延迟到客户端需要时才采取行动

    4）保护（Protect）

    5）Cache代理

3.静态代理

由程序员或者自动生成工具生成代理类，然后进行代理类的编译和运行。在代理类、委托类运行之前，代理类已经以.class的格式存在

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

目标对象：UserDao

/**
 * 接口
 */
public interface UserDao {
    public void add(); //添加
    public void edit(); //编辑
}

/**
 * 接口的实现类
 * 目标对象
 */
public class UserDaoImpl implements UserDao {

    public void add() {
        System.out.println("add ok");
    }

    public void edit() {
        System.out.println("edit ok");

    }
}

//接口

public interface Subject {
    public String request();
}

//接口实现类

//目标对象

public class RealSubject implements Subject {
    public String request() {
        System.out.println("真实主题的操作内容");
        return "呵呵";
    }
}
代理对象：ProxySubject
public class ProxySubject implements Subject {
    //01.植入一个  真实主题的引用
    private RealSubject real;

    public String request() {
        System.out.println("before execute");
        real.request();
        System.out.println("after execute");
        return "proxy";
    }

    public RealSubject getReal() {
        return real;
    }

    public void setReal(RealSubject real) {
        this.real = real;
    }
}

测试类：

  
   //静态代理
    @Test
    public void proxyTest(){
        //准备一个真实主题，被代理对象
        RealSubject real=new RealSubject();

        //创建一个代理对象
        ProxySubject proxySubject=new ProxySubject();
        proxySubject.setReal(real);
        proxySubject.request();
    }

结果显示：

4.动态代理：jdk动态代理

JDK代理是不需要以来第三方的库，只要要JDK环境就可以进行代理，它有几个要求
* 实现InvocationHandler 
* 使用Proxy.newProxyInstance产生代理对象
* 被代理的对象必须要实现接口

/**
 * 接口
 */
public interface UserDao {
    public void add(); //添加
    public void edit(); //编辑
}

/**
 * 接口的实现类
 * 目标对象
 */
public class UserDaoImpl implements UserDao {

    public void add() {
        System.out.println("add ok");
    }

    public void edit() {
        System.out.println("edit ok");

    }
}

测试类：

//动态代理  jdk
    @Test
    public void jdkTest(){

        //生成代理对象

       final UserDao dao=new UserDaoImpl();

        //1参数：  被代理对象  UserDAOImpl的类加载器

        //2参数：   被代理对象  所属的接口

        UserDao proxy= (UserDao) Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {
            /**
             *  proxy:被代理对象
             *
             *  method:被代理对象的方法 add
             *
             *  args:被代理对象的方法的参数
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("开启事务");
                //真正的dao.add()
                Object result = method.invoke(dao, args);
                System.out.println("记录日志");
                return result;
            }
        });

        proxy.add();
        proxy.edit();


    }

结果显示：

5.动态代理：cglib代理

cglib代理：也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展

jdk动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

与其他代理的区别：

• JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
• Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
• Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

例如：

首先必须导入cgib的jar包

public class UserService {
	public void delete(){
		   System.out.println("delete success!");
		   
	}
}

测试类：

 //动态代理  cglib
    @Test
    public  void cglibTest(){
        final UserService service=new UserService();

        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(service.getClass());
        //中间的增强代码
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                //执行的是service  delete
                //系统级服务  交叉业务
                System.out.println("开启事务");
                //业务方法
                Object result=method.invoke(service,objects);
                //系统级服务  交叉业务
                System.out.println("记录日志");
                return result;
            }
        });

        //如何产生代理对象
        UserService proxy=(UserService)enhancer.create();
        proxy.delete();
    }
}

结果显示：