`

【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);
		
	}

}


客户端调用

 

 

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()


从类图我们可以看出,客户端本来可以直接和目标对象打交道,代理中间加了一个间接层,他们实现的功能是一样的,也没有改变参数。相信大家对上面的类图和代码很熟悉,跟我们平时看别人的博文一样,没有任何区别,下面我们看一下静态代理的优缺点。

 

 

优缺点

 

优点

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;
	}

}


客户端调用

 

 

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、动态代理比静态代理在代码的可读性上差了一点,不太容易理解

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

 

总结

 

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

 

 

分享到:
评论

相关推荐

    java高手真经 (UML建模+设计模式+面向服务架构) 卷8

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/structure/...

    设计模式java源码-design-pattern:java设计模式源代码

    2. 结构型模式:这类模式关注类和对象的组合,如适配器模式(Adapter)、装饰器模式(Decorator)、代理模式(Proxy)、桥接模式(Bridge)、组合模式(Composite)、外观模式(Facade)和享元模式(Flyweight)。...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷1

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷9

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/structure/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷3

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷6

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/structure/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷10

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/structure/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷5

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/structure/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷7

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/structure/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷2

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/...

    java高手真经 (UML建模+设计模式+面向服务架构) 卷4

    pattern/src/structure/proxy //12.3代理模式 pattern/src/structure/facade //12.4外观模式 pattern/src/structure/bridge //12.5桥接模式 pattern/src/structure/composite //12.6组合模式 pattern/src/...

    23中设计模式详解

    十二、代理模式(Proxy) 代理模式为其他对象提供一种代理以控制对这个对象的访问。在远程代理、虚拟代理、智能引用等方面有广泛应用。 十三、命令模式(Command) 命令模式将请求封装为一个对象,以便使用不同的...

    二十三种设计模式【PDF版】

    设计模式之 Proxy(代理) 以 Jive 为例,剖析代理模式在用户级别授权机制上的应用 设计模式之 Facade(门面?) 可扩展的使用 JDBC针对不同的数据库编程,Facade提供了一种灵活的实现. 设计模式之 Composite(组合) ...

    PracticeJava-DesignPattern

    在Java中,静态代理和动态代理(JDK Proxy和CGLIB)是常见的实现方式。 9. **桥接模式**: 将抽象部分与它的实现部分分离,使它们都可以独立地变化。这有助于降低系统的耦合度。 10. **组合模式**: 也称为部分整体...

    Java新手学习路线.pdf

    3. **代理**:了解动态代理(Java Proxy、CGlib等)及其在AOP中的应用。 4. **泛型**:学习泛型的概念,理解其在类型安全方面的优势。 5. **枚举**:掌握枚举类型及其用法。 6. **正则表达式**:使用Pattern和...

    job4j_design

    在"job4j_design-master"中,静态代理和动态代理的实现将帮助你掌握如何在不影响原对象的情况下增加额外的功能。 7. **模板方法模式**(Template Method Pattern):模板方法模式定义了一个操作中的算法骨架,而将...

    开涛高可用高并发-亿级流量核心技术

    9.6.6 Copy Pattern 181 9.7 性能测试 181 9.8 参考资料 182 10 HTTP缓存 183 10.1 简介 183 10.2 HTTP缓存 184 10.2.1 Last-Modified 184 10.2.2 ETag 190 10.2.3 总结 192 10.3 HttpClient客户端缓存 192 10.3.1 ...

    J2EE开发全程实录PDF J2EE开发全程实录PDF

    - **`java.util.regex`的使用**:通过`Pattern.compile("pattern")`创建模式对象,再调用`matcher(String input)`方法生成匹配器对象进行匹配。 - **实战正则表达式**:通过实例练习正则表达式的具体应用,如验证...

Global site tag (gtag.js) - Google Analytics