当前位置:首页 > 编程教程 > java技术文章 > java设计模式-代理模式(实例讲解)

java设计模式中代理模式的知识点

  • 发布时间:
  • 作者:码农之家
  • 点击:94

这篇文章主要知识点是关于java、代理模式、的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

Java Web开发实例大全:提高卷
  • 类型:Java大小:179.4 MB格式:PDF作者:软件开发技术联盟
立即下载

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设计模式-代理模式(实例讲解)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持码农之家。

以上就是本次给大家分享的关于java的全部知识点内容总结,大家还可以在下方相关文章里找到相关文章进一步学习,感谢大家的阅读和支持。

您可能感兴趣的文章:

  • 详解Java策略模式定义与用法
  • java装饰者模式23种设计模式总结
  • javascript设计模式之对象工厂函数与构造函数实例详解
  • Java设计模式之原型模式Prototype
  • Java 观察者模式学习
  • Java设计中Builder模式实例详解
  • JavaScript命令模式实例讲解
  • java单例模式知识点深入了解
  • 实例分析JavaScript设计模式之策略模式
  • java备忘录模式
  • 相关电子书
    学习笔记
    网友NO.168521

    通过代码快速理解Java的三种代理模式

    代理模式 代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式,即通过代理对象访问目标对象。这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需要修改,可以通过代理的方式来扩展该方法 UML图表示如下: 代理模式 静态代理 静态代理在使用时,需要定义接口或者父类。被代理对象与代理对象一起实现相同的接口或者是继承相同父类。 代码示例: interface Source{ void method();}class OldClass implements Source{@Overridepublic void method() {}}class Proxy implements Source{private Source source = new OldClass();void doSomething(){}@Overridepublic void method() {new Class1().Func1();source.method();new Class2().Func2();doSomething();}public static void main(String[] args) {Proxy proxy = new ……

    网友NO.446980

    详解Java 中的三种代理模式

    代理模式 代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。 举个例子来说明代理的作用:假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子。 代理模式的 关键点是:代 理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象 . 静态代理 静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起……

    网友NO.379554

    Java设计模式之代理模式_动力节点Java学院整理

    引言 Java 动态代理机制的出现,使得 Java 开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程中,开发人员还可以按需调整委托类对象及其功能,这是一套非常灵活有弹性的代理框架。通过阅读本文,读者将会对 Java 动态代理机制有更加深入的理解。本文首先从 Java 动态代理的运行机制和特点出发,对其代码进行了分析,推演了动态生成类的内部实现。 代理:设计模式 代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理。 图 1. 代理模式 为了保持行为的一致性,代理类和委托类通常会实现相……

    <
    1
    >

    Copyright 2018-2020 www.xz577.com 码农之家

    投诉 / 推广 / 赞助:QQ:520161757