现在的位置: 首页 > 综合 > 正文

浅析代理模式

2013年05月03日 ⁄ 综合 ⁄ 共 2095字 ⁄ 字号 评论关闭

代理模式的定义:对其他对象提供一种代理以控制对这个对象的访问。

代理模式的主要作用:是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式涉及的角色:

1:抽象角色--声明了代理主题和真实主题的公共接口,使任何需要真实主题的地方都能用代理主题代替.

2:代理角色--含有真实主题的引用,从而可以在任何时候操作真实主题,代理主题功过提供和真实主题相同的接口,使它可以随时代替真实主题.代理主题通过持有真实主题的引用,不但可以控制真实主题的创建或删除,可以在真实主题被调用前进行拦截,或在调用后进行某些操作.

3:真实代理对象--定义了代理角色所代表的具体对象. 就是我们最终要引用的对象

代理模式又分为动态代理和静态代理:首先来看看静态代理:

有一个用户类接口有一个抽象work的方法。然后有一个实现这个接口的类。然后用抽象代理帮我们代理创建这个实现类的对象。

public interface UserDao {
	public void insert(String name);
	public void test();
}public class UserDaoImpl implements UserDao {
	@Override
	public void insert(String name) {
		System.out.println("你好,"+name);
	}
	@Override
	public void test() {
		System.out.println("test success......");
	}
}

然后再创建一个代理类:

public class UserProxy implements UserDao {
	private UserDaoImpl userdaoImpl;//被代理的类
	public UserProxy(UserDaoImpl userdaoImpl) {
		this.userdaoImpl = userdaoImpl;
	}
	@Override
	public void insert(String name) {
		validate();
		userdaoImpl.insert(name);
		log();
	}
	@Override
	public void test() {
		validate();
		userdaoImpl.test();
		log();
	}
	public void validate(){
		System.out.println("权限验证");
	}
	public void log(){
		System.out.println("记录日志");
	}
}

然后就可以测试了:

public static void main(String[] args) {
		UserProxy up=new UserProxy(new UserDaoImpl());
		up.insert("fdsa");
		System.out.println("-----------");
		up.test();
	}

这就是静态代理:可以自动帮你生成这个对象。在代理类中你可以随意想插入什么插入什么。想删除不想要的操作就删除。非常的透明式的一个设计模式。而动态代理类就更高级了。就不用写这么多代码了。主要修改代理类就能跑了。。

public class UserProxy implements InvocationHandler {
	private Object obj;//被代理的对象

	public void validate(){//执行方法前的动作
		System.out.println("权限验证");
	}
	public void log(){//执行方法后的动作
		System.out.println("记录日志");
	}
	/**
	 * 
	 * @param proxy 代理对象实例
	 * @param method 执行的方法
	 * @param args 方法中的参数列表
	 * @return 返回一个代理实例
	 * @throws Throwable
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		validate();
		Object o=(Object)method.invoke(obj, args);
		log();
		return o;
	}
	public Object createObject(Object object){
		this.obj = object;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
	}
}

当然测试类也要改了:

UserProxy up=new UserProxy();
		UserDao userdao=(UserDao)up.createObject(new UserDaoImpl());
		userdao.insert("young");
		userdao.test();

相比静态代理。动态代理非常灵活轻巧。能省很多事。在spring中的AOP其实就是贯穿着这一设计模式来着的。

抱歉!评论已关闭.