利用java代理实现代码的松耦合

好久没有写博客了，小编最近一直在研究java的动态代理机制，最近在阅读fourinone框架，看到里面有好多代理机制，于是对代理进行了研究，代理可以将类与接口之间的继承关系转化为使用关系，极大地降低了代码的耦合性，以下面为例：

import java.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Delegate
{
	String interfaceName();
	String methodName();
	int paramNum() default 0;
}

import java.lang.reflect.*;
import java.util.*;
public class DelegateConsole implements InvocationHandler
{
	public Object[] obj;
	public DelegateConsole(Object [] obj)
	{
		this.obj=obj;
	}
	public static Object bind(Class [] classes,Object... obj)
	{
       return Proxy.newProxyInstance(classes[0].getClassLoader(),classes,new DelegateConsole(obj));
	}
	public static <I> I bind(Class<I> cla,Object... obj)
	{
		return (I)bind(new Class[]{cla},obj);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
	{
		Object result = null;
		Object mimplObj=null;
		Method mimpl=null;
		
		for(int j=0;j<obj.length;j++)
		{
			Method[] bms = obj[j].getClass().getMethods();
			for(int i=0;i<bms.length;i++)
			{
				boolean anflag = bms[i].isAnnotationPresent(Delegate.class);
				if(anflag)
				{
					Delegate dl = bms[i].getAnnotation(Delegate.class);//得到这个方法的注释
					Class dlifl = Class.forName(dl.interfaceName());//注释中定义的要代理的接口
					if(dlifl.isAssignableFrom(proxy.getClass())&&dl.methodName().equals(method.getName())&&
							Arrays.equals(method.getParameterTypes(),bms[i].getParameterTypes())&&
							method.getReturnType().equals(bms[i].getReturnType())){
						mimplObj=obj[i];
						mimpl=bms[i];
					}
				}
			}
		}
		if(mimpl!=null)
		{
			result = mimpl.invoke(mimplObj, args);
		}
		return result;
	}

}

public interface Sell
{
	public void sell();
}

public class Factory
{
	@Delegate(interfaceName="Sell",methodName="sell")
	public void sell()
	{
		System.out.println("卖东西");
	}
}

public class Test
{
	public static void main(String [] args)
	{
		Sell s=DelegateConsole.bind(Sell.class,new Factory());
		s.sell();
	}
}

可以看到，利用动态代理，我们将原本都属于继承关系的Sell和Factory转化为弱耦合的使用关系，这个手法极大地降低了程序的耦合性，我想着也是框架开发者大量使用动态代理的意义。