【Java笔记】动态代理原型

Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。

参与角色

1. 接口
2. 被代理的类
3. 代理类

接口

public interface UserMapper {
	void delete();
	void add();
}

被代理的类

实现接口 UserMapper

public class UserMapperImpl implements UserMapper {
	@Override
	public void delete() {
		System.out.println("调用delete！");
	}

	@Override
	public void add() {
		System.out.println("调用add！");
	}
}

代理类

代理了横向扩展了 before 和 after 两个方法

public class MapperProxy implements InvocationHandler {

	private Object target;

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

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		before(proxy, method, args);
		method.invoke(target, args);
		after(proxy, method, args);
		return null;
	}

	private void before(Object proxy, Method method, Object[] args) {
		System.out.println(method.getName() + "方法执行开始！");
	}
	
	private void after(Object proxy, Method method, Object[] args) {
		System.out.println(method.getName() + "方法执行完成！");
	}
}

客户端

public static void main(String[] args) throws Throwable {
		ClassLoader loader = UserMapper.class.getClassLoader();
		UserMapper mapper = new UserMapperImpl();
		
		UserMapper proxyMapper = (UserMapper) Proxy.newProxyInstance(loader,
				new Class[] { UserMapper.class },
				new MapperProxy(mapper));
		proxyMapper.delete();
		System.out.println("=============");
		proxyMapper.add();
	}

执行结果

通过钩子方法优化

在上面的例子中，before 和 after 方法都是在 MapperProxy 类中写死的，为了让这两个方法可以灵活指定，可以通过定义一个接口 IHook 来实现钩子方法

public interface IHook {

    void before(Object proxy, Method method, Object[] args);

    void after(Object proxy, Method method, Object[] args);

}

MapperProxy 优化之后，我们可以通过 setHook 方法指定钩子实现类，从而实现可以灵活指定before 和 after 方法

public class MapperProxy implements InvocationHandler {

    private Object target;

    /**
     * 钩子
     */
    private IHook hook;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (null != hook) {
            hook.before(proxy, method, args);
        }
        method.invoke(target, args);
        if (null != hook) {
            hook.after(proxy, method, args);
        }
        return null;
    }

    /**
     * 设置钩子
     * 
     * @param hook 钩子接口实现类
     */
    public void setHook(IHook hook) {
        this.hook = hook;
    }

}

在客户端调用

public static void main(String[] args) throws Throwable {
        ClassLoader loader = UserMapper.class.getClassLoader();
        UserMapper mapper = new UserMapperImpl();

        MapperProxy proxy = new MapperProxy(mapper);
        proxy.setHook(new IHook() {

            @Override
            public void before(Object proxy, Method method, Object[] args) {
                System.out.println("钩子before");

            }

            @Override
            public void after(Object proxy, Method method, Object[] args) {
                System.out.println("钩子after");
            }

        });

        UserMapper proxyMapper = (UserMapper) Proxy.newProxyInstance(loader,
                new Class[] { UserMapper.class },
                proxy);

        proxyMapper.delete();
        System.out.println("=============");
        proxyMapper.add();
    }

运行结果：