java中的对象代理：静态代理 动态代理及cglib代理

需求：

现在外部有一个接口IUserDao，其中提供了save和find方法。IUserDao与UserDao都是写好的接口和类，不能修改

我想在其实现类UserDao中方法save的执行的前后，添加逻辑功能，怎么办？

 

另一个问题是如果外部提供的是一个不能修改的类，想在其某方法的执行的前后，添加逻辑功能，又要怎么办？

 

解决方法是使用代理。将UserDao的行为转换为其代理类的行为。java中提供了三种目标对象的代理方式，下面逐一来进行研究。

 

静态代理

 

目标对象UserDao实现接口IUserDao

public interface IUserDao {
	void save();
	
	void find();
}

// 目标对象
public class UserDao implements IUserDao{
	@Override
	public void save() {
		System.out.println("模拟： 保存用户！");
	}

	@Override
	public void find() {
		System.out.println("查询");
	}

}

静态代理类

public class UserDaoProxy implements IUserDao{
	
	// 代理对象，需要维护一个目标对象
	private IUserDao target = new UserDao();

	@Override
	public void save() {
		
		System.out.println("代理操作： 开启事务...");
		
		target.save();   // 执行目标对象的方法
		
		System.out.println("代理操作：提交事务...");
	}

	@Override
	public void find() {
		target.find();
	}
}

测试方法

public class App {

	public static void main(String[] args) {
		// 代理对象
		IUserDao proxy = new UserDaoProxy();
		// 执行代理方法
		proxy.save();
		 
	}
}

 

这种方式缺点很明显：

1. 目标对象必须要实现接口

2. 代理对象要实现与目标对象一样的接口，即依赖目标对象的接口，如果接口功能变化，目标对象变化，就会引起代理对象的变化（耦合）

3. 对每一个目标对象，都要分别写一个代理类，很麻烦。

既然是生成对象，那么考虑工厂，能不能写一个代理工厂类，提供生成代理对象的方法

 

动态代理

基本上有两种方式：

方式1：代理工厂

IUserDao与UserDao不变，写一个代理工厂类

public class ProxyObjectFactory {

    //接收一个目标对象
    private Object target;

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

    /**
     * 返回对目标对象target代理后的对象
     *
     * @return
     */
    public Object getProxyInstance() {
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String methodName = method.getName();

                        //方法返回值
                        Object result = null;

                        //invoke方法用来在运行时动态的调用某个实例的方法

                        if ("save".equals(methodName)) {
                            System.out.println("目标对象方法执行前操作");
                            result = method.invoke(target, args);
                            System.out.println("目标对象方法执行前操作");
                        } else {
                            //直接调用目标对象方法
                            result = method.invoke(target, args);
                        }
                        return result;
                    }
                });
        return proxy;
    }
}

测试方法

public class AppTest
{
    @Test
    public void testProxyObject(){
        //创建目标对象
        IUserDao target = new UserDao();

        //创建目标对象的代理对象
        IUserDao proxyInstance = (IUserDao) new ProxyObjectFactory(target).getProxyInstance();

        proxyInstance.save();

        proxyInstance.find();

        //比较目标对象和代理对象
        System.out.println(target.getClass());
        System.out.println(proxyInstance.getClass());

    }
}

结果：

目标对象方法执行前操作
模拟：保存用户
目标对象方法执行前操作
模拟：查询用户
class hfi.bellychang.dynamicProxy.UserDao
class com.sun.proxy.$Proxy4

方式2：InvocationHandler

写一个InvocationHandler

public class UserSaveHandler implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        String methodName = method.getName();
        if ("save".equals(methodName)) {
            System.out.println("before user save action");
            result = method.invoke(target, args);
            System.out.println("after user save action");
        } else {
            result = method.invoke(target, args);
        }
        return result;
    }
}

测试方法

    @Test
    public void test2() {
        IUserDao target = new UserDao();
        UserSaveHandler userSaveHandler = new UserSaveHandler(target);
        IUserDao proxyInstance = (IUserDao) Proxy.newProxyInstance(userSaveHandler.getClass().getClassLoader(),
                target.getClass().getInterfaces(), userSaveHandler);
        proxyInstance.save();
        proxyInstance.find();
        System.out.println(target.getClass());
        System.out.println(proxyInstance.getClass());
    }

结果：

before user save action
模拟用户保存
after user save action
模拟用户查找
class com.hfi.proxy.UserDao
class com.sun.proxy.$Proxy2

动态代理是通过jdk在运行期间，通过反射动态生成代理对象的，其要求目标对象一定要实现接口；而代理对象不需要实现此接口。

 

cglib代理（子类代理）

对于未实现接口的类，可以通过在运行期间动态的在内存中构建一个子类对象，从而对目标对象进行扩展。

UserDao与上相同

代理工厂类：使用了spring框架中的cglib代码生成包，其可以在运行期扩展java类与实现java的接口，被Spring AOP所使用，为其提供方法的interception。

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

import java.lang.reflect.Method;

/**
 * Created by Administrator on 2017/11/16.
 */
public class ProxyObjectFactory implements MethodInterceptor {

    // 接收一个目标对象
    private Object target;
    public ProxyObjectFactory(Object target) {
        this.target = target;
    }

    /**
     * 返回目标对象的子类代理对象
     * @return
     */
    public Object getProxyInstance() {
        //字节码生成工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建子类对象
        return enhancer.create();
    }

    // 事件处理器，执行目标方法时候触发
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        String methodName = method.getName();

        //方法返回值
        Object result = null;

        //invoke方法用来在运行时动态的调用某个实例的方法

        if ("save".equals(methodName)) {
            System.out.println("目标对象方法执行前操作");
            result = method.invoke(target, objects);
            System.out.println("目标对象方法执行前操作");
        } else {
            //直接调用目标对象方法
            result = method.invoke(target, objects);
        }
        return result;
    }
}

 

测试方法：

 

public class AppTest {

    @Test
    public void testCglibProxy() {
        //目标对象
        UserDao target = new UserDao();
        //目标对象的子类代理对象
        UserDao proxyInstance = (UserDao) new ProxyObjectFactory(target).getProxyInstance();

        proxyInstance.save();
        proxyInstance.find();

        System.out.println(target.getClass());
        System.out.println(proxyInstance.getClass());
    }
}

结果：

目标对象方法执行前操作
模拟：保存用户
目标对象方法执行前操作
模拟：查询用户
class cglibProxy.UserDao
class cglibProxy.UserDao$$EnhancerByCGLIB$$cf3e68e5

 

由于是子类代理，所以

 

1. 目标对象可以不实现接口

2. 目标类不可以为final

3. 目标对象的方法如果为static，不会被代理拦截，会直接执行

 

总结

 

1. 如果目标对象有实现接口，那么就使用动态代理来生成代理对象

2. 如果目标对象没有实现接口，那么就使用cglib代理

源码参考：https://gitee.com/constfafa/data_structure_and_algorithm/tree/master/javabasic/main/java/reflectionV2