java项目实战代理模式(Proxy Pattern),静态代理 VS 动态代理

Posted yangykaifa

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java项目实战代理模式(Proxy Pattern),静态代理 VS 动态代理相关的知识,希望对你有一定的参考价值。


这篇博文,我们主要以类图和代码的形式来对照学习一下静态代理和动态代理。重点解析各自的优缺点。


定义


       代理模式(Proxy Pattern)是对象的结构型模式,代理模式给某一个对象提供了一个代理对象,并由代理对象控制对原对象的引用。


       代理模式不会改变原来的接口和行为,仅仅是转由代理干某件事,代理能够控制原来的目标,比如:代理商,代理商仅仅会买东西,但并不会改变行为。不会制造东西。

让我们通过以下的代码好好理解一下这句话。


分类


静态代理和动态代理


静态代理


静态代理类图

                技术分享


代码演示样例

     技术分享


接口

package com.liang.pattern;

public interface UserManager {

	public void addUser(String userId,String userName);
	
	public void delUser(String userId);
	
	public void modifyUser(String userId,String userName);
	
	public String findUser(String userId);
	
}

目标对象

package com.liang.pattern;

public class UserManagerImpl implements UserManager {

	public void addUser(String userId, String userName) {

		try{
			System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
		}catch(Exception e){
			e.printStackTrace();
			
			throw new RuntimeException();
		}
		
		
	}

	public void delUser(String userId) {

		System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
	}

	public String findUser(String userId) {

		System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
		return "于亮";
	}

	public void modifyUser(String userId, String userName) {

		System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
	}

}

代理类,我们使用代理对象做一些日志记录,我们将简略的打印信息到控制台。

package com.liang.pattern;

public class UserManagerImplProxy implements UserManager {

	private UserManager userManager;
	public UserManagerImplProxy(UserManager userManager){
		this.userManager = userManager;
	}
	public void addUser(String userId, String userName) {
                //记录日志等操作或打印输入參数
		System.out.println("start-->>addUser() userId-->>" + userId);
		try{

			userManager.addUser(userId, userName);
                //运行成功。打印成功信息
			System.out.println("success-->>addUser()");
		}catch(Exception e){
			e.printStackTrace();
                //失败时。打印失败信息
			System.out.println("error-->>addUser()");
			//throw new RuntimeException();
		}
	}

	public void delUser(String userId) {
		//同上,略
		userManager.delUser(userId);
	}

	public String findUser(String userId) {
		//同上。略
		userManager.findUser(userId);
		return null;
	}

	public void modifyUser(String userId, String userName) {
		//同上。略
		userManager.modifyUser(userId, userName);
		
	}

}

client调用

package com.liang.pattern;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
		userManager.addUser("001","于亮");
	}
} 

输出结果,此方法运行成功

start-->>addUser() userId-->>001
UserManagerImpl.addUser() userId-->>001
success-->>addUser()

       从类图我们能够看出。client本来能够直接和目标对象打交道,代理中间加了一个间接层。他们实现的功能是一样的,也没有改变參数。相信大家对上面的类图和代码非常熟悉。跟我们平时看别人的博文一样。没有不论什么差别。以下我们看一下静态代理的优缺点。


优缺点


长处

1、直观感受,静态代理是实实在在的存在的,我们自己写的。

2、在编译期增加,提前就指定好了谁调用谁,效率高。


缺点

相同,它的长处也成了它致命的缺点。

1、静态代理非常麻烦。须要大量的代理类

     当我们有多个目标对象须要代理时,我就须要建立多个代理类。改变原有的代码,改的多了就非常有可能出问题,必须要又一次測试。

2、反复的代码会出如今各个角落里,违背了一个原则:反复不是好味道

      我们应该杜绝一次次的反复。

3、在编译期增加,系统的灵活性差



       我们能够看到代理类的每一个方法中,都有记录日志,运行成功或失败的代码,每一个方法都反复了一遍,假设我们须要改动的话,并没有比不用静态代理时降低改动的地方。仅仅是不用改动目标类。动态代理非常好的为我们攻克了这个问题。以下我们看一下动态代理。


动态代理


动态代理类图


               技术分享


代码演示样例

技术分享


代理类(不明确,就看看凝视吧)

package com.liang.pattern;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 採用JDK动态代理必须实现InvocationHandler接口。採用Proxy类创建对应的代理类
 * @author liang
 *
 */
public class ProxyHandler implements InvocationHandler {

	private Object targetObject;
	/**
	 * 目标的初始化方法。依据目标生成代理类
	 * @param targetObject
	 * @return
	 */
	public Object newProxyInstance(Object targetObject){
		this.targetObject = targetObject;
		//第一个參数,目标的装载器
		//第二个參数,目标接口,为每一个接口生成代理
		//第三个參数,调用实现了InvocationHandler的对象。当你一调用代理,代理就会调用InvocationHandler的invoke方法
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
	}
	
	/**
	 * 反射,这样你能够在不知道详细的类的情况下,依据配置的參数去调用一个类的方法。

在灵活编程的时候很实用。 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //记录日志等操作或打印输入參数 System.out.println("start-->>" + method.getName()); for(int i=0;i<args.length;i++){ //打印调用目标方法的參数 System.out.println(args[i]); } Object ret = null; try{ //调用目标方法 ret = method.invoke(targetObject, args); //运行成功。打印成功信息 System.out.println("success-->>" + method.getName()); }catch(Exception e){ e.printStackTrace(); //失败时,打印失败信息 System.out.println("error-->>" + method.getName()); throw e; } return ret; } }


client调用

package com.liang.pattern;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ProxyHandler proxyHandler = new ProxyHandler();
		UserManager userManager = (UserManager)proxyHandler.newProxyInstance(new UserManagerImpl());
		
		String name = userManager.findUser("0001");
		System.out.println("client.main-->>" + name);
	}

} 


输出结果,执行成功

start-->>findUser
0001
UserManagerImpl.findUser() userId-->>0001
success-->>findUser
client.main-->>于亮


接口和目标类,同上,我就不再浪费大家的带宽了。


优缺点


长处

1、一个动态代理类更加简单了,能够解决创建多个静态代理的麻烦,避免不断的反复多余的代码

2、调用目标代码时,会在方法“执行时”动态的增加,决定你是什么类型,才调谁,灵活


缺点

1、系统灵活了。可是相比而言,效率减少了,比静态代理慢一点

2、动态代理比静态代理在代码的可读性上差了一点,不太easy理解

3、JDK动态代理仅仅能对实现了接口的类进行代理


总结


       静态代理VS动态代理,打成了平手,各自有各的独特之处,均不可取代,在项目中究竟使用哪种代理,没有最好。仅仅有更合适。










































以上是关于java项目实战代理模式(Proxy Pattern),静态代理 VS 动态代理的主要内容,如果未能解决你的问题,请参考以下文章

结构型模式-安卓源码实战之的Proxy(代理)、Delegate(委托)

java设计模式之代理设计模式(Proxy)

代理模式-JDK Proxy(Java实现)

Java设计模式之代理模式(Proxy)

Java设计模式Proxy代理模式

行为模式--代理Proxy模式(Java)