【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动态代理，打成了平手，各自有各的独特之处，均不可取代，在项目中究竟使用哪种代理，没有最好。仅仅有更合适。

时间： 2025-01-24 01:44:26

【java项目实战】代理模式（Proxy Pattern），静态代理 VS 动态代理的相关文章

设计模式之代理模式---Proxy Pattern

模式的定义 代理模式(Proxy Pattern)也叫做委托模式,定义如下: Provide a surrogate or placeholder for another object to control access to is. 为其他对象提供一种代理以控制对这个对象的访问. 类型 结构类 模式的使用场景 想想现实世界中,打官司为什么要找个律师?因为你不想参与中间过程的是是非非,只要完成自己的工作就可以,其它的事情比如事前调查,事后追查都可以由律师来负责,这就可以减少你的负担.代理模式使用

设计模式 - 代理模式(proxy pattern) 未使用代理模式 详解

代理模式(proxy pattern) 未使用代理模式 详解 本文地址: http://blog.csdn.net/caroline_wendy 部分代码参考: http://blog.csdn.net/caroline_wendy/article/details/37698747 如果需要监控(monitor)类的某些状态, 则需要编写一个监控类, 并同过监控类进行监控. 但仅仅局限于本地, 如果需要远程监控, 则需要使用代理模式(proxy pattern). 具体方法: 1. 类中需要提供

设计模式(结构型)之代理模式(Proxy Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(结构型)之享元模式(Flyweight Pattern)>http://blog.csdn.net/yanbober/article/details/45477551 概述 代理模式是常用的结构型设计模式之一,当无法直接访问某个对象或访问某个对象存在困难时可以通过一个

代理模式(Proxy Pattern)

一.概述在软件开发中,有些对象由于创建成本高.访问时需要与其它进程交互等原因,直接访问会造成系统速度慢.复杂度增大等问题.这时可以使用代理模式,给系统增加一层间接层,通过间接层访问对象,从而达到隐藏系统复杂性.提高系统性能的目的.二.代理模式代理模式为其他对象提供一种代理以控制对这个对象的访问.其结构图如下: Subject定义了RealSubject和Proxy共用的接口,使得在任何使用RealSubject的地方都可以使用Proxy abstract class Subject { publ

二十三种设计模式[12] - 代理模式(Proxy Pattern)

前言 代理模式,属于对象结构型模式.在<设计模式 - 可复用的面向对象软件>一书中将之描述为" 为其它对象提供一种代理以控制对这个对象的访问 ". 在代理模式中,通常使用一个类来代表另一个类的功能,并由这个代理对象去控制原对象的引用. 结构 Subjuet(公共接口):代理类和被代理类的公共接口,保证任何使用目标的地方都可以被代理类替换: RealSubject(被代理类):代理类所代表的目标类: Proxy(代理类):包含对目标类的引用,目标类的封装: 场景 在日常生活中

设计模式之（二）---代理模式Proxy Pattern

什么是代理模式呢?我很忙,忙的没空理你,那你要找我呢就先找我的代理人吧,那代理人总要知道 被代理人能做哪些事情不能做哪些事情吧,那就是两个人具备同一个接口,代理人虽然不能干活,但是被 代理的人能干活呀. 比如西门庆找潘金莲,那潘金莲不好意思答复呀,咋办,找那个王婆做代理,表现在程序上时这样的: 先定义一种类型的女人(接口): package com.fc.Proxy; public interface KindWoman { public void makeEyesWithMan(); //抛媚

设计模式 -- 代理模式 (proxy Pattern)

定义: 为其他对象提供一种代理以控制对这个对象的访问: 角色: 1,抽象主题类,(接口或者抽象类),抽象真实主题和代理的共有方法(如下Subject类): 2,具体实现的主题类,继承或者实现抽象主题类的抽象方法(如下RealSubject类): 3,代理类,继承实现抽象主题类,并提供传递具体实现主题类,在实现方法里面调用具体实现的主题类(如下ProxySubject类); Subject.java /** * Created by Administrator on 2016/8/31. */ p

13.代理模式(Proxy Pattern)

using System; namespace ConsoleApplication6 { class Program { static void Main(string[] args) { // 创建一个代理对象并发出请求 Person proxy = new Friend(); proxy.BuyProduct(); Console.Read(); } } // 抽象主题角色 public abstract class Person { public abstract void BuyPro

设计模式三: 代理模式(Proxy) -- JDK的实现方式

设计模式三: 代理模式(Proxy) -- JDK的实现方式 简介 代理模式属于行为型模式的一种, 控制对其他对象的访问, 起到中介作用. 代理模式核心角色: 真实角色,代理角色; 按实现方式不同分为静态代理和动态代理两种; 意图 控制对其它对象的访问. 类图 实现 JDK自带了Proxy的实现, 下面我们先使用JDK的API来演示代理如何使用, 随后再探究Proxy的实现原理,并自己来实现Proxy. JDK代理类的使用: (InvocationHandler,Proxy) 使用JDK实现的代