java设计模式-代理模式(实例讲解)

代理模式是java最常见的设计模式之一。spring的aop就是使用了代理模式。

一般而言，代理模式分为静态代理和动态代理两种。

作为结构类的设计模式，作用在于不修改类内部代码的情况下，对类进行拓展，是对继承机制的一种补充。

eg ：下面就用户登录这个例子实现一下代理模式。

基本需求是：实现用户的登录和修改昵称功能。

上代码，先是iuser接口和user实现类

public interface iuser {
 //登录
 void login(string userid,string password);
 //修改昵称
 void editnickname(string nickname);

}

public class user implements iuser {
 
 private string nickname;
 private string userid;
 private string password;
 
 public user(string userid,string password){
  this.userid = userid;
  this.password = password;
 }

 @override
 public void login(string userid, string password){
  if(this.userid == userid && this.password == password){
   system.out.println("用户登录成功");
  }
  else
   system.out.println("用户登录失败");
 }

 @override
 public void editnickname(string nickname) {
  this.nickname = nickname;
  system.out.println("修改昵称成功，当前用户的昵称是:"+this.nickname);
 }

}

客户端类

public class client {
 public static void main(string[] args) {
  //不调用代理模式时
  iuser user = new user("firs","123");
  user.login("firs", "123");
  user.editnickname("大风");
}

还是非常简单的。可是后面产品经理跟你说，我们需要增加一个记录用户行为的功能，这下该怎么办呢？直接修改user类？不不不，用代理模式。

增加一个代理类，在代理类里面写“记录用户行为”的功能就好，不修改类，只拓展类，减少错误发生。

import java.util.date;
import java.util.hashmap;
import java.util.map;

/**
 * 静态代理类必须实现接口，而且需要新创建一个类的代码出来
 * @author administrator
 *
 */
public class staticproxy implements iuser {
 private iuser user;
 public staticproxy(string userid,string password){
  this.user = new user(userid,password);
 }
 
 //登陆前的操作，记录当前登录的时间
 void notelogininfo(string[] params, string opreate){
  map<string,object> logininfo = new hashmap<>();
  logininfo.put("params", params);
  logininfo.put("opreate", opreate);
  logininfo.put("opreatetime", new date());
  system.out.println("记录用户操作成功");
 }
 
 @override
 public void login(string userid, string password){
  
  notelogininfo(new string[]{userid, password},"login");
  
  user.login(userid, password);
 }

 @override
 public void editnickname(string nickname) {
  notelogininfo(new string[]{nickname},"editnickname");
  user.editnickname(nickname);
 }

}

客户端类：

public class client {
 public static void main(string[] args) {
  //不调用代理模式时
  iuser user = new user("firs","123");
  user.login("firs", "123");
  user.editnickname("大风");
  
  system.out.println("");
  system.out.println("=============调用静态代理模式后===========");
  
  //需要实现记录用户登录和修改昵称操作的日志功能
  //基于“拓展开发，修改关闭”的设计准则，我们可以用静态代理的方式
  iuser proxy = new staticproxy("firs","123");
  proxy.login("firs", "123");
  proxy.editnickname("我还是大风"); 

}

这样子只需要修改客户端类和增加静态代理就可以了，完美实现。可是需求是无穷无尽的，产品经理跟你说：“我们增加了一个管理员角色，还有二级管理员”啥啥啥的一大堆角色，

这就尴尬了，每个角色都要建一个静态代理类，类爆炸了吧。不急，我们有动态代理模式。

动态代理模式在于不用自己新建代理类，你传具体的实现类（主体）给他，他就默认给你生成了一个代理类。

从本质上来说，它是利用了java的反射机制在运行时动态地生成了相应的代理类。

没有反射，就没有动态代理。

import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.util.date;
import java.util.hashmap;
import java.util.map;

/**
 * 动态代理类不用和主体类继承同一个接口
 * @author administrator
 *
 */
public class dynamicproxy implements invocationhandler {
 private object object;
 public dynamicproxy(string userid,string password,class<?> c){
  object obj = null;
  try {
   obj = class.forname(c.getname())
     .getconstructor(string.class,string.class)
     .newinstance(userid,password);
  } catch (exception e) {
   // todo auto-generated catch block
   e.printstacktrace();
  }
  this.object = obj;
 }
 
 //登陆前的操作，记录当前登录的时间
 void notelogininfo(string[] params, string opreate){
  map<string,object> logininfo = new hashmap<>();
  logininfo.put("params", params);
  logininfo.put("opreate", opreate);
  logininfo.put("opreatetime", new date());
  system.out.println("记录用户操作成功");
 }

 @override
 public object invoke(object proxy, method method, object[] args)
   throws throwable {
  string[] params = new string[args.length];
  for(int i = 0 ;i < args.length ; i++){
   params[i] = args[i].tostring();
  }
  notelogininfo(params, method.getname());
  return method.invoke(object, args);
 }

}

最后的客户端类：

package com.test.my;

import java.lang.reflect.proxy;


public class client {
 public static void main(string[] args) {
  //不调用代理模式时
  iuser user = new user("firs","123");
  user.login("firs", "123");
  user.editnickname("大风");
  
  system.out.println("");
  system.out.println("=============调用静态代理模式后===========");
  
  //需要实现记录用户登录和修改昵称操作的日志功能
  //基于“拓展开发，修改关闭”的设计准则，我们可以用静态代理的方式
  iuser proxy = new staticproxy("firs","123");
  proxy.login("firs", "123");
  proxy.editnickname("我还是大风");
  
  system.out.println("");
  system.out.println("=============调用动态代理模式后===========");
  
  dynamicproxy dynamicproxy = new dynamicproxy("firs","123",admin.class);
  
  classloader cl = admin.class.getclassloader();
  iuser iuser = (iuser)proxy.newproxyinstance(cl,
        new class[]{iuser.class}, dynamicproxy);
  iuser.login("firs","123");
  iuser.editnickname("使用动态代理后的大风");
  
 }

}

因为需求而增加的admin类

public class admin implements iuser {
 
 private string nickname;
 private string userid;
 private string password;
 
 public admin(string userid,string password){
  this.userid = userid;
  this.password = password;
 }

 @override
 public void login(string userid, string password){
  if(this.userid == userid && this.password == password){
   system.out.println("用户登录成功");
  }
  else
   system.out.println("用户登录失败");
 }

 @override
 public void editnickname(string nickname) {
  this.nickname = nickname;
  system.out.println("修改昵称成功，当前用户的昵称是:"+this.nickname);
 }

}

总结：

1.静态代理模式相对来说比较简单，要点在于对于每个实现类（subject主体）新建一个代理类，该代理类内有实体类（subject主体）的引用，从而可以实现对原有实现类（subject主体）的控制，包括aop的控制等。

2.静态代理是有局限性的，对于每个实体类可能都需要新建一个静态代理类，这样子可能会造成静态代理类过多的情况，所以动态代理应运而生了。

3.动态代理不局限于具体的实现类（subject主体），在其内部是用object存取实体类的引用，再利用反射获得该实体类的各种方法，从而实现对实现类（subject主体）的面向 切面aop编程控制。

4.上述的写法是jdk里的动态代理，不是特别完美，因为这种动态代理需要实体类实现至少一个接口。问题是并不是所有的类都会有接口，所以说不完美在这里。

上面都是我自己对于代理模式的理解，如有错漏，还请批评指正，多谢。

以上这篇java设计模式-代理模式(实例讲解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。