java代理模式浅析

一、java中的代理模式

代理（Proxy）模式提供了对目标对象的间接访问模式，可在不修改目标类的情况下，扩展功能。
这里以保存用户数据的方式进行简要说明。
简单图示：

现在我们期望在保存用户数据之前打印一下日志，我们可以有以下两种方式实现

1.1 静态代理

简单图示：

代码示例：
IUserDao.java

/**
 * 目标对象与代理对象共同实现的接口
 */
public interface IUserDao {
    // 代理对象
    void save();
}

UserDao.java

/**
 * 目标对象，即被代理的对象
 */
public class UserDao implements IUserDao{
    @Override
    public void save() {
        System.out.println("==保存用户数据==");
    }
}

UserDaoProxy.java

/**
 * 代理对象，使用时用以替换目标对象
 */
public class UserDaoProxy implements IUserDao{

    IUserDao userDao;

    /**
     * 以构造方法注入 目标对象userDao，
     * 内部用共同的实现接口接收
     */
    UserDaoProxy(IUserDao userDao){
        this.userDao = userDao;
    }

    @Override
    public void save() {
        System.out.println("==打印日志==");
        userDao.save();
    }
}

这里用main方法模拟UserService

    /**
     * 测试方法
     */
    public static void main(String[] args){
        //  目标对象
        IUserDao userDao = new UserDao();
        // 代理对象
        UserDaoProxy proxy = new UserDaoProxy(userDao);
        // 代理方法
        proxy.save();
    }

静态代理小结：
一个接口需要实现一个代理类，这样在实际业务中，会产生大量的类，难以维护。

1.2 动态代理

简单图示：

代码示例：
IUserDao.java

public interface IUserDao {
    void save();
}

UserDaoProxy.java

/**
 * 代理类
 */
public class UserDaoProxy {

    private Object target;

    public UserDaoProxy(Object object){
        target = object;
    }

    public Object getProxyInstance(){

        Object obj = null;
        // 代理对象由哪一个类加载器负责加载
        ClassLoader loader = target.getClass().getClassLoader();
        // 代理对象的类型，即其中有哪些方法
        Class[] interfaces = target.getClass().getInterfaces();
        // 代理对象执行对象方法时，执行这里
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {


                Object result = null;
                try {
                    // 前置通知
                    System.out.println("前置通知: method:"+ method.getName()+" with "+ Arrays.toString(args));
                    result = method.invoke(target,args);
                    // 返回通知
                    System.out.println("返回通知： result:"+result);
                }catch (Exception e){
                    e.printStackTrace();
                    // 异常通知
                    System.out.println("异常通知："+e);
                }

                // 后置通知
                System.out.println("后置通知。。。");
                return result;
            }
        };

        obj = Proxy.newProxyInstance(loader,interfaces,handler);
        return obj;
    }

测试代码：

    public static void main(String[] args){
        //目标对象
        IUserDao target = new UserDao();
        // 动态代理,这里必须用接口接收
        IUserDao proxy = (IUserDao) new UserDaoProxy(target).getProxyInstance();
        proxy.save();
        System.out.println("=========================");
    }

动态代理小结：
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理
4.代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

代理类(studentProxy)是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

二、cglib实现代理

当目标对象未实现任何接口而需要用到代理模式时，可以使用cglib。
Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

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

代码示例：

UserDao.java

public class UserDao {

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

}

ProxyFactory.java

/**
 * cglib实现aop
 */
public class ProxyFactory implements MethodInterceptor {
    //维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println(returnValue);

        System.out.println("提交事务...");

        return returnValue;
    }
}

测试代码

    public static void main(String[] args){
        // cglib实现
        UserDao proxy1 = (UserDao)new ProxyFactory(target).getProxyInstance();
        //执行代理对象的方法
        proxy1.save();
    }

参考：https://www.cnblogs.com/cenyu/p/6289209.html