java設計模式-代理模式

時間  2020-06-09
標籤 java 設計 模式 代理 欄目 Java 简体版
原文   原文鏈接

代理模式是java最多見的設計模式之一。spring的aop就是使用了代理模式。java

通常而言，代理模式分爲靜態代理和動態代理兩種。spring

做爲結構類的設計模式，做用在於不修改類內部代碼的狀況下，對類進行拓展，是對繼承機制的一種補充。編程

eg ：下面就用戶登陸這個例子實現一下代理模式。設計模式

　　基本需求是：實現用戶的登陸和修改暱稱功能。ide

上代碼，先是IUser接口和user實現類this

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);
    }

}

客戶端類spa

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裏的動態代理，不是特別完美，由於這種動態代理須要實體類實現至少一個接口。問題是並非全部的類都會有接口，因此說不完美在這裏。

 

           以上都是我本身對於代理模式的理解，若有錯漏，還請批評指正，多謝。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程