JAVA三种代理模式:静态代理、动态代理和cglib代理的实现

一、代理模式介绍
代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。代理模式UML类图：
举个例子，我们生活中经常到火车站去买车票，但是人一多的话，就会非常拥挤，于是就有了代售点，我们能从代售点买车票了。这其中就是代理模式的体现，代售点代理了火车站对象，提供购买车票的方法。

二、静态代理
这种代理方式需要代理对象和目标对象实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能。

缺点：
1.冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
2.不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

举例：保存用户功能的静态代理实现

需要被代理的目标对象类的接口： IUserDao

package com.wang.proxy;

public interface UserDao {
    void save ();
}

需要被代理的目标对象类

package com.wang.proxy;

public class UserDaoImpt implements UserDao{
    @Override
    public void save() {
        System.out.println("保存数据");
    }
}

静态代理对象类UserDaoProxy，需要实现与目标对象类相同的接口！

package com.wang.proxy;

public class UserDaoProxy implements UserDao {
    private UserDaoImpt us;
    public UserDaoProxy(UserDaoImpt us){
        this.us=us;
    }
    @Override
    public void save() {
        System.out.println("打开事务");
        us.save();
        System.out.println("关闭事务");
    }
}

测试类

  @Test
  public void test1(){
        //目标对象
        UserDaoImpt udi=new UserDaoImpt();     
        //代理对象
        UserDaoProxy udp=new UserDaoProxy(udi);
        udp.save();
    }

输出结果：

三、动态代理
动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

静态代理与动态代理的区别主要在：

静态代理在编译时就已经实现，编译完成后代理类是一个实际的字节码文件（.class文件）
动态代理则是在运行时动态生成字节码，即编译完成后没有实际的class文件，而是在运行时通过反射+拼接字符串动态生成.java文件，然后经过java动态编译成.class，并加载到JVM内存中，类加载器加载生成并生成类对象，类对象生成构造器对象，并构造出实例返回
特点：
动态代理要求被代理的类必须实现接口，否则不能使用动态代理。
JDK中动态代理实现涉及的类及方法有

import java.lang.reflect.Proxy

//该方法返回一个代理类实例，此实例所在的代理类和被代理类的实现了相同的接口；
static Object newProxyInstance(ClassLoader loader,  //指定当前目标对象使用的类加载器
 Class<?>[] interfaces,    //目标对象实现的接口的类型
 InvocationHandler h      //事件处理器
) 

import java.lang.reflect.Proxy.InvocationHandler
//proxy代表代理类的实例，method代表被代理类的方法对象，args代表方法参数，
public Object invoke(Object proxy, Method method, Object[] args){
 		return null;
 }

举例：保存功能的动态代理实现
需要被代理的目标对象类的接口： Service

public interface Service {
    public void save();
}

需要被代理的目标对象类 RealService

public class RealService implements Service{
    public void save(){
        System.out.println("正在保存");
    }
}

实现代理行为的Handler类

public class Handler<T> implements InvocationHandler {
    private T obj;
    public Handler(){}
    public Handler(T obj) {
        this.obj=obj;
    }
    public Handler(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        this.obj=clazz.newInstance();
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	//如果只想代理名字为save的方法
    	  //if(method.getName().equals("save")){
            //System.out.println("开启事务");
           // method.invoke(obj,args);
            //System.out.println("关闭事务");
       // }
        //正常情况调用时所有方法都被代理
        System.out.println("开启事务");
        method.invoke(obj,args);
        System.out.println("关闭事务");
        return null;
    }
}

测试类

import java.lang.reflect.Proxy;

public class Demo {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        //目标对象
        RealService service=new RealService();
        System.out.println("目标对象所在的类"+service.getClass().toString());
        Service proxyService  = (Service) Proxy.newProxyInstance(RealService.class.getClassLoader(), RealService.class.getInterfaces(),(new <RealService>Handler(service)));
        System.out.println("代理对象所在的类"+proxyService.getClass().toString());
        //执行代理对象代理的方法
        proxyService.save();
    
}

输出结果：

简单来说，JDK动态代理技术可以为一组接口生成代理类，这个代理类也就是一层壳，简单的实现了接口中定义的方法。通过提供一个构造函数传入InvocationHandler实例，然后将方法的具体实现交给它。

四、cglib代理

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

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

使用动态代理的对象必须实现一个或多个接口
使用cglib代理的对象则无需实现接口，达到代理类无侵入。
使用cglib需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

举例：保存用户功能的动态代理实现

目标对象：UserDao

package com.wang.proxy;

public class UserDao{

    public void save() {
        System.out.println("保存数据");
    }
}

代理对象：ProxyFactory

package com.wang.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 实现cglib代理
 */
//实现cglib代理先实现MethInterceptor接口
public class proxyFactory implements MethodInterceptor {
    private UserDaoImpt us;
    public proxyFactory(UserDaoImpt us) {
        this.us = us;
    }
    public Object getProxyInstance(){
        //工具类
        Enhancer en=new Enhancer();
        //设置父类
        en.setSuperclass(us.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建子类代理对象
        return en.create();
    }

    @Override
    //此方法拦截目标对象中的方法，并增强其功能
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("打开事务");
        //执行目标对象中的方法
        method.invoke(us,objects);
        System.out.println("提交事务");
        return null;
    }
}

测试类：TestProxy

   @Test
public void test3(){
    //目标对象
    UserDaoImpt udi=new UserDaoImpt();
    //输出目标对象所属类
    System.out.println(udi.getClass());
    //代理对象
    UserDaoImpt usi= (UserDaoImpt) new proxyFactory(udi).getProxyInstance();
    //输出代理对象所属类
    System.out.println(usi.getClass());
    usi.save();
}

输出结果：