我的设计模式学习之路3(动态代理)

  代理模式(Proxy)

 
1.静态代理

  角色：

  抽象主题角色：声明了代理角色和真实角色的共同接口

  代理角色：代理角色内部含有对真实角色的引用，通常在将客户端调整用传弟它们真实角色之前或者之后，都要执行某个操作

  真实角色：定了代理角色所代表的真实对象

  类图:

 

  下面是我的写的一个例子:

  首先是抽象主题角色:

 

package com.design.proxy;

public interface Runable
{
	public void move();

}

   代理角色，这里有两个:

package com.design.proxy;

public class TankTimeProxy implements Runable
{
	private Runable t;
	
	public TankTimeProxy(Runable t)
	{
		this.t=t;
	}
	
	@Override
	public void move()
	{
		System.out.println("time is start ........");
		t.move();
		
	}

}

package com.design.proxy;

public class TankLogProxy implements Runable
{
	private Runable t;
	
	public TankLogProxy(Runable t)
	{
		this.t=t;
	}
	
	@Override
	public void move()
	{
		System.out.println("Log is record");
		t.move();
	}

}

 真实角色:

public class Tank implements Runable
{
	@Override
	public void move()
	{
		long start=System.currentTimeMillis();
	    
		System.out.println("tank is move..");
		try
		{
			Thread.sleep(new Random().nextInt(10000));
		} catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		long end=System.currentTimeMillis();
		
		System.out.println("time:"+(end-start));
	}

}

 

  最后是测试类:

package com.design.proxy;

public class Client
{
	public static void main(String[] args)
	{
		Tank tank = new Tank();
		
		TankTimeProxy ttp=new TankTimeProxy(tank); 
		
		TankLogProxy tlp = new TankLogProxy(ttp);
		
		tlp.move();
		
	}

}

输出结果:

Log is record
time is start ........
tank is move..
time:1728

   测试类可以动态地改变，相应由不同的代理角色来完成不同的功能，这是简单的代理，缺点就是不太灵活。

 2.动态代理

  动态代理需要实现InvocationHandler这个接口，并且@Ovrride里面的invoke()方法，让InvocationHandler接口来帮我们代理，代理类需要有个静态工厂的方法，下面是我的一个例子：

  接口：

package com.proxy2;

public interface UserManager
{
	public void save();
}

 接口的实现：

package com.proxy2;

public class UserManagerImpl implements UserManager
{
	@Override
	public void save()
	{
		System.out.println("用户保存中...");
	}
}

  两个代理类:

package com.proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserLogProxy implements InvocationHandler
{
	private Object target;
	
	public UserLogProxy(Object target)
	{
		this.target=target;
	}
	
	public static Object factory(Object obj)
	{
		Class<?> clazz= obj.getClass();
		
		return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new UserLogProxy(obj));
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable
	{
		System.out.println("开始写日记...");
		
		Object o=method.invoke(target, args);
		
		System.out.println("记录完毕....");
		
		return  o;
	}
}

package com.proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserInvokedProxy implements InvocationHandler
{
	private Object target;
	
	public UserInvokedProxy(Object target)
	{
	   this.target=target;	
	}
	
	public static Object factory(Object obj)
	{
		Class<?> clazz= obj.getClass();
		
		return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new UserInvokedProxy(obj));
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable
	{
		System.out.println("类加载...");
		
		Object o=method.invoke(target, args);
		
		return o;
	}
}

 测试类：

package com.proxy2;

public class Client
{
	public static void main(String[] args) 
	{
		UserManager user = new UserManagerImpl();
		
		UserManager user1=(UserManager)UserLogProxy.factory(user);
		
		UserManager user2=(UserManager)UserInvokedProxy.factory(user1);
		
		user2.save();
	}
}

 测试的结果：

类加载中...
开始写日记...
用户保存中...
记录完毕....

   这样就可以实现了动态代理，而且是一个对象对应多个代理。动态代理的应用还是很广泛的，比如Spring的AOP等，感谢《JAVA与设计模式》这本书，让我知道了多个代理的写法。