Java设计模式（代理模式）

什么是代理模式

代理模式(Proxy Pattern)是23种Java常用设计模式之一。

代理模式的定义：Provide a surrogate or placeholder for another object to controlaccess to it.(为其他对象提供一种代理以控制对这个对象的访问)。

使用代理模式创建代理对象，让代理对象控制目标对象的访问(目标对象可以是远程的对象、创建开销大的对象或需要安全控制的对象),并且可以在不改变目标对象的情况下添加一些额外的功能。

我理解的代理模式就像球员的经纪人一样，谈工作安排，球员薪资都和经纪人（所谓的代理）谈，球员只要踢好球就行了，使球员隐藏在经纪人（代理的后面）。

代理模式实例

静态代理模式

静态代理模式实例

下面这个实例是调用静态代理实现UserManager接口的addUser方法的打印日志的功能：

interface UserManager{
void addUser(String userId, String userName);//添加
void delUser(String userId);//删除
String findUser(String userId);//查找
void modifyUser(String userId, String userName);//修改
}

class UserManagerImpl implements UserManager {
@Override
public void addUser(String userId, String userName) {
System.out.println("UserManagerImpl.addUser");
}

@Override
public void delUser(String userId) {
System.out.println("UserManagerImpl.delUser");
}

@Override
public String findUser(String userId) {
System.out.println("UserManagerImpl.findUser");
return "张三";
}

@Override
public void modifyUser(String userId, String userName) {
System.out.println("UserManagerImpl.modifyUser");
}
}

class UserManagerImplProxy implements UserManager {
private UserManager userManager;  // 目标对象
// 通过构造方法传入目标对象
public UserManagerImplProxy(UserManager userManager){
this.userManager=userManager;
}
@Override
public void addUser(String userId, String userName) {
try{
//添加打印日志的功能
//开始添加用户
System.out.println("start-->addUser()");
userManager.addUser(userId, userName);
//添加用户成功
System.out.println("success-->addUser()");
}catch(Exception e){
//添加用户失败
System.out.println("error-->addUser()");
}
}

@Override
public void delUser(String userId) {
userManager.delUser(userId);
}

@Override
public String findUser(String userId) {
userManager.findUser(userId);
return "张三";
}

@Override
public void modifyUser(String userId, String userName) {
userManager.modifyUser(userId,userName);
}
}

//客户端调用
public class ProxyTest {
public static void main(String[] args){
//UserManager userManager=new UserManagerImpl();
UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
userManager.addUser("1111", "张三");
//userManager.findUser("1111");
}
}
/*Output
start-->addUser()
UserManagerImpl.addUser
success-->addUser()
*/

静态代理模式优缺点

优点：

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。

缺点：

1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

例：如果我们在上例的基础上还想要为findUser方法打印日志，这时我们必须修改代码如下

@Override
public String findUser(String userId) {
try{
//添加打印日志的功能
//开始查找用户
System.out.println("start-->findUser()");
userManager.findUser(userId);
//查找用户结束
System.out.println("success-->findUser()");
}catch(Exception e){
//添加用户失败
System.out.println("error-->findUser()");
}
userManager.findUser(userId);
return "张三";
}

//客户端调用
public class ProxyTest {
public static void main(String[] args){
UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
userManager.findUser("1111");
}
}

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）

即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

动态代理模式

动态代理模式实例

import java.lang.reflect.*;
class UserManagerImpl1 implements UserManager {
@Override
public void addUser(String userId, String userName) {
System.out.println("UserManagerImpl.addUser");
}

@Override
public void delUser(String userId) {
System.out.println("UserManagerImpl.delUser");
}

@Override
public String findUser(String userId) {
System.out.println("UserManagerImpl.findUser");
return "张三";
}

@Override
public void modifyUser(String userId, String userName) {
System.out.println("UserManagerImpl.modifyUser");
}
}

class LogHandler implements InvocationHandler {
// 目标对象
private Object targetObject;
//绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。
public Object newProxyInstance(Object targetObject){
this.targetObject=targetObject;
//该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
//第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
//第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
//第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
//根据传入的目标返回一个代理对象
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(),this);
}
@Override
//关联的这个实现类的方法被调用时将被执行
/*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("start-->>");
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
Object ret=null;
try{
/*原对象方法调用前处理日志信息*/
System.out.println("satrt-->>");

//调用目标方法
ret=method.invoke(targetObject, args);
/*原对象方法调用后处理日志信息*/
System.out.println("success-->>");
}catch(Exception e){
e.printStackTrace();
System.out.println("error-->>");
throw e;
}
return ret;
}
}

public class DynamicProxyTest {
public static void main(String[] args){
LogHandler logHandler=new LogHandler();
UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());
//UserManager userManager=new UserManagerImpl();
userManager.addUser("1111", "张三");

Department departmentManager=(Department)logHandler.newProxyInstance(new DepartmentImpl());
departmentManager.addDepartment("1111", "财务处");
}
}

动态代理模式优缺点

参考文献

/article/8837457.html

/content/2513429.html

/content/615101.html

Thinking In Java

Head First Design Patterns