首页 > 代码库 > 【java项目实战】代理模式（Proxy Pattern），静态代理 VS 动态代理

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

2024-07-19 01:24:08   225人阅读


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


定义


       代理模式（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项目实战】代理模式（Proxy Pattern），静态代理 VS 动态代理


联系
我们