Java 设计模式（代理模式）

最新推荐文章于 2023-01-17 15:14:57 发布
最新推荐文章于 2023-01-17 15:14:57 发布
阅读量120 收藏
点赞数
分类专栏： # Java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43820352/article/details/108071593
版权

代理模式

为另一个对象提供一个替身或占位符以控制对这个对象的访问。
需使用 RMI (Remote Method Invocation) 远程方法调用，需简单了解。

RMI 注意：

  1. 启动远程服务前先启动 rmiregistry（使用 Naming.rebind() 注册服务，rmiregister 必须运行）。
  2. 变量和返回值的泪水称为可序列化的类型（编译期无法发现）。
  3. 给客户提供 stub 类
RMI 测试
import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * @author NNroc
 * @date 2020/8/18 12:36
 */
public interface MyRemote extends Remote {
    public String sayHello() throws RemoteException;
}

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;

/**
 * @author NNroc
 * @date 2020/8/18 12:37
 */
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote {
    public String sayHello() {
        return "Server says, 'Hey'";
    }

    public MyRemoteImpl() throws RemoteException {
    }

    public static void main(String[] args) {
        try {
            LocateRegistry.createRegistry(1099);
            MyRemote service = new MyRemoteImpl();
            Naming.rebind("rmi://localhost:1099/RemoteHello", service);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.rmi.Naming;

/**
 * @author NNroc
 * @date 2020/8/18 12:42
 */
public class MyRemoteClient {
    public static void main(String[] args) {
        new MyRemoteClient().go();
    }

    public void go() {
        try {
            MyRemote service = (MyRemote) Naming.lookup("rmi://127.0.0.1:1099/RemoteHello");
            String s = service.sayHello();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
远程代理

远程代理控制访问远程对象。
可以作为另一个 JVM 上的对象的本地代表。调用代理的方法，会被代理利用网络转发到远程执行，并且结果会通过网络返回给代理，再由代理将结果转给客户。

卖糖果机器服务端示例

CEO 想要获取远端每个糖果机的情况。

public interface State extends Serializable {
    public void insertQuarter();

    public void ejectQuarter();

    public void turnCrank();

    public void dispense();
}

public interface GumballMachineRemote extends Remote {
    public int getCount() throws RemoteException;

    public String getLocation() throws RemoteException;

    public State getState() throws RemoteException;
}

其中 5 种方式（soldOutState、noQuarterState、hasQuarterState、soldState、winnerState）请参考https://blog.csdn.net/weixin_43820352/article/details/108053317
需将其中类前两行中GumballMachine gumballMachine;改为transient GumballMachine gumballMachine;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

/**
 * @author NNroc
 * @date 2020/8/18 11:51
 */
public class GumballMachine extends UnicastRemoteObject implements GumballMachineRemote {
    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;
    State winnerState;
    State state = soldOutState;
    int count = 0;
    String location;

    public GumballMachine(String location, int numberGumballs) throws RemoteException {//设计一个构造方法来抛出异常，这是因为UnicastRemoteObject 就抛出异常，超类抛出异常时，子类也只得抛出同样的异常。
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState = new SoldState(this);
        winnerState = new WinnerState(this);

        this.count = numberGumballs;
        if (numberGumballs > 0) {
            state = noQuarterState;
        }
        this.location = location;
    }

    public void insertQuarter() {
        state.insertQuarter();
    }

    public void ejectQuarter() {
        state.ejectQuarter();
    }

    public void turnCrank() {
        state.turnCrank();
        state.dispense();
    }

    void setState(State state) {
        this.state = state;
    }

    void releaseBall() {
        System.out.println("A gumball comes rolling out the slot...");
        if (count != 0) {
            count = count - 1;
        }
    }

    public void refill(int count) {
        this.count = count;
        state = noQuarterState;
    }

    public int getCount() {
        return count;
    }

    public State getState() {
        return state;
    }

    public String getLocation() {
        return location;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }

    public State getWinnerState() {
        return winnerState;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("/nMighty Gumball, Inc.");
        result.append("/nJava-enabled Standing Gumball Model #2004");
        result.append("/nInventory: " + count + " gumball");
        if (count != 1) {
            result.append("s");
        }
        result.append("/n");
        result.append("Machine is " + state + "/n");
        return result.toString();
    }
}

测试

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

/**
 * @author NNroc
 * @date 2020/8/18 14:49
 */
public class GumballMachineTestDrive {
    public static void main(String[] args) {
        GumballMachineRemote gumballMachine = null;
        int count;
//        if (args.length < 2) {
//            System.out.println("GumballMachine ");
//            System.exit(1);
//        }

        try {
            // 本地注册
            LocateRegistry.createRegistry(1099);
            count = 100;
            gumballMachine = new GumballMachine("1099", count);
//            count = Integer.parseInt(args[1]);
//            gumballMachine = new GumballMachine(args[0], count);
            Naming.rebind("rmi://localhost:" + "1099" + "/gumballmachine", gumballMachine);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
虚拟代理

虚拟代理控制访问创建开销大的资源。
作为创建开销大的对象的代表。当我们真正需要创建一个对象时才创建它，当对象在创建前和创建中时，虚拟代理来扮演对象的替身，对象创建后，代理会将请求直接委托给对象。

加载图片示例

ImageProxy 工作过程：

  1. ImageProxy 首先创建一个 ImageIcon，然后开始从网络 URL 上加载图片。
  2. 在加载过程中，ImageProxy 显示“CD封面加载中，请稍候······”
  3. 当图像加载完毕，ImageProxy 把所有方法调用委托给真正的 ImageIcon，这些方法包括了 paintIcon()、getWidth() 和 getHeight()。
  4. 如果用户请求新的图像，我们就创建新的代理，重复过程。
import java.awt.*;
import javax.swing.*;

/**
 * @author NNroc
 * @date 2020/8/18 15:38
 */
public class ImageComponent extends JComponent {
    private static final long serialVersionUID = 1L;
    private Icon icon;

    public ImageComponent(Icon icon) {
        this.icon = icon;
    }

    public void setIcon(Icon icon) {
        this.icon = icon;
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        int w = icon.getIconWidth();
        int h = icon.getIconHeight();
        int x = (800 - w) / 2;
        int y = (600 - h) / 2;
        icon.paintIcon(this, g, x, y);
    }
}

import java.awt.*;
import java.net.URL;
import javax.swing.*;

/**
 * @author NNroc
 * @date 2020/8/18 15:34
 */
public class ImageProxy implements Icon {
    // imageIcon是我们希望加载后显示出来的真正图象
    volatile ImageIcon imageIcon;
    final URL imageURL;
    Thread retrievalThread;
    // 是否已经下载完毕
    boolean retrieving = false;

    // url图像的位置
    public ImageProxy(URL url) {
        imageURL = url;
    }

    // 图象加载完毕前，返回默认的宽度，否则返回真实的宽度
    public int getIconWidth() {
        if (imageIcon != null) {
            return imageIcon.getIconWidth();
        } else {
            return 800;
        }
    }

    // 图象加载完毕前，返回默认的高度，否则返回真实的高度
    public int getIconHeight() {
        if (imageIcon != null) {
            return imageIcon.getIconHeight();
        } else {
            return 600;
        }
    }

    // 绘制图象的方法
    public void paintIcon(final Component c, Graphics g, int x, int y) {
        if (imageIcon != null) {
            // 如果图象加载完毕，则通知图象绘制自己
            imageIcon.paintIcon(c, g, x, y);
        } else {
            // 无图像则显示Loading
            g.drawString("Loading CD cover, please wait...", x + 300, y + 190);
            if (!retrieving) {
                retrieving = true;

                retrievalThread = new Thread(new Runnable() {
                    public void run() {
                        try {
                            setImageIcon(new ImageIcon(imageURL, "CD Cover"));
                            c.repaint();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });
                retrievalThread.start();
            }
        }
    }

    synchronized void setImageIcon(ImageIcon imageIcon) {
        this.imageIcon = imageIcon;
    }
}

import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Hashtable;
import javax.swing.*;

/**
 * @author NNroc
 * @date 2020/8/18 15:39
 */
public class ImageProxyTestDrive {
    ImageComponent imageComponent;
    JFrame frame = new JFrame("CD Cover Viewer");
    JMenuBar menuBar;
    JMenu menu;
    Hashtable<String, String> cds = new Hashtable<String, String>();

    public static void main(String[] args) throws Exception {
        ImageProxyTestDrive testDrive = new ImageProxyTestDrive();
    }

    public ImageProxyTestDrive() throws Exception {
        cds.put("Buddha Bar", "http://images.amazon.com/images/P/B00009XBYK.01.LZZZZZZZ.jpg");
        cds.put("Ima", "http://images.amazon.com/images/P/B000005IRM.01.LZZZZZZZ.jpg");
        cds.put("Karma", "http://images.amazon.com/images/P/B000005DCB.01.LZZZZZZZ.gif");
        cds.put("MCMXC A.D.", "http://images.amazon.com/images/P/B000002URV.01.LZZZZZZZ.jpg");
        cds.put("Northern Exposure", "http://images.amazon.com/images/P/B000003SFN.01.LZZZZZZZ.jpg");
        cds.put("Selected Ambient Works, Vol. 2", "http://images.amazon.com/images/P/B000002MNZ.01.LZZZZZZZ.jpg");

        URL initialURL = new URL((String) cds.get("Selected Ambient Works, Vol. 2"));
        menuBar = new JMenuBar();
        menu = new JMenu("Favorite CDs");
        menuBar.add(menu);
        frame.setJMenuBar(menuBar);

        for (Enumeration<String> e = cds.keys(); e.hasMoreElements(); ) {
            String name = (String) e.nextElement();
            JMenuItem menuItem = new JMenuItem(name);
            menu.add(menuItem);
            menuItem.addActionListener(event -> {
                imageComponent.setIcon(new ImageProxy(getCDUrl(event.getActionCommand())));
                frame.repaint();
            });
        }

        // set up frame and menus

        Icon icon = new ImageProxy(initialURL);
        imageComponent = new ImageComponent(icon);
        frame.getContentPane().add(imageComponent);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(800, 600);
        frame.setVisible(true);

    }

    URL getCDUrl(String name) {
        try {
            return new URL((String) cds.get(name));
        } catch (MalformedURLException e) {
            e.printStackTrace();
            return null;
        }
    }
}
保护代理

保护代理基于权限控制对资源的访问。

个人信息示例

要防止随意修改别人的信息

/**
 * 用户信息接口
 *
 * @author NNroc
 * @date 2020/8/18 15:46
 */
public interface PersonBean {
    //名称
    String getName();

    //性别
    String getGender();

    //爱好
    String getInterests();

    //平均评分
    int getHotOrNotRating();

    void setName(String name);

    void setGender(String gender);

    void setInterests(String interests);

    void setHotOrNotRating(int rating);
}

/**
 * @author NNroc
 * @date 2020/8/18 15:47
 */
public class PersonBeanImpl implements PersonBean {
    String name;
    String gender;
    String interests;
    //总评分
    int rating;
    //被评价次数
    int ratingCount = 0;

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender;
    }

    public String getInterests() {
        return interests;
    }

    //获得平均评分
    public int getHotOrNotRating() {
        if (ratingCount == 0) return 0;
        return (rating / ratingCount);
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setInterests(String interests) {
        this.interests = interests;
    }

    //更新总评分和被评价次数
    public void setHotOrNotRating(int rating) {
        this.rating += rating;
        ratingCount++;
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 本类和OwnerInvocationHandler同理
 *
 * @author NNroc
 * @date 2020/8/18 17:48
 */
public class NonOwnerInvocationHandler implements InvocationHandler {
    PersonBean person;

    public NonOwnerInvocationHandler(PersonBean person) {
        this.person = person;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException {
        try {
            if (method.getName().startsWith("get")) {
                return method.invoke(person, args);
            } else if (method.getName().equals("setHotOrNotRating")) {
                return method.invoke(person, args);
            } else if (method.getName().startsWith("set")) {
                //不允许评价者设置被评价者的“名称”、“性别”、“爱好”三个信息
                throw new IllegalAccessException();
            }
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author NNroc
 * @date 2020/8/18 15:55
 */
public class OwnerInvocationHandler implements InvocationHandler {
    //持有RealSubject的引用(这样底层就可以调用RealSubject的方法)
    PersonBean person;

    public OwnerInvocationHandler(PersonBean person) {
        this.person = person;
    }

    //proxy的任何代码被调用，就会导致invoke方法被调用
    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException {
        try {
            if (method.getName().startsWith("get")) {
                return method.invoke(person, args);
            } else if (method.getName().equals("setHotOrNotRating")) {
                //不允许被评价者调用setHotOrNotRating方法，会抛出异常
                throw new IllegalAccessException();
            } else if (method.getName().startsWith("set")) {
                return method.invoke(person, args);
            }
        } catch (InvocationTargetException e) {
            //捕捉真正主题抛出的异常
            e.printStackTrace();
        }
        //如果调用的是其他的方法，这里不予理会
        return null;
    }
}

import java.lang.reflect.Proxy;
import java.util.HashMap;

/**
 * @author NNroc
 * @date 2020/8/18 17:50
 */
public class MatchMakingTestDrive {
    // 装载PersonBean的容器
    HashMap<String, PersonBean> datingDB = new HashMap<String, PersonBean>();

    public static void main(String[] args) {
        MatchMakingTestDrive test = new MatchMakingTestDrive();
        test.drive();
    }

    public MatchMakingTestDrive() {
        //初始化datingDB
        initializeDatabase();
    }

    public void drive() {
        //取得PersonBean
        PersonBean joe = getPersonFromDatabase("Joe Javabean");
        //创建出PersonBean的"被评分者代理"对象
        PersonBean ownerProxy = getOwnerProxy(joe);
        System.out.println("Name is " + ownerProxy.getName());
        //被评分者可以设置“名称”、“性别”、“爱好”三个信息
        ownerProxy.setInterests("bowling, Go");
        System.out.println("Interests set from owner proxy");
        try {
            //被评分者不能设置HotOrNotRating值
            ownerProxy.setHotOrNotRating(10);
        } catch (Exception e) {
            System.out.println("Can't set rating from owner proxy");
        }
        System.out.println("Rating is " + ownerProxy.getHotOrNotRating());

        //创建出PersonBean的"评分者代理"对象
        PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
        System.out.println("Name is " + nonOwnerProxy.getName());
        try {
            //评分者不可以设置“名称”、“性别”、“爱好”三个信息
            nonOwnerProxy.setInterests("bowling, Go");
        } catch (Exception e) {
            System.out.println("Can't set interests from non owner proxy");
        }
        //评分者可以设置HotOrNotRating值
        nonOwnerProxy.setHotOrNotRating(3);
        System.out.println("Rating set from non owner proxy");
        System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
    }

    //返回"被评分者的代理"对象
    PersonBean getOwnerProxy(PersonBean person) {

        return (PersonBean) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new OwnerInvocationHandler(person));
    }

    //返回"评分者的代理"对象
    PersonBean getNonOwnerProxy(PersonBean person) {

        return (PersonBean) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new NonOwnerInvocationHandler(person));
    }

    //根据名称从容器中获得PersonBean
    PersonBean getPersonFromDatabase(String name) {
        return (PersonBean)datingDB.get(name);
    }

    void initializeDatabase() {
        PersonBean joe = new PersonBeanImpl();
        joe.setName("Joe Javabean");
        joe.setInterests("cars, computers, music");
        joe.setHotOrNotRating(7);
        datingDB.put(joe.getName(), joe);

        PersonBean kelly = new PersonBeanImpl();
        kelly.setName("Kelly Klosure");
        kelly.setInterests("ebay, movies, music");
        kelly.setHotOrNotRating(6);
        datingDB.put(kelly.getName(), kelly);
    }
}
代理模式与装饰者模式

代理模式目的：控制被代理者的访问。
装饰者模式目的：为被装饰者加上新的行为。
代表对象而不是装饰对象，作为真正主题的替身，可以保护对象避免不想要的访问，也可以避免在加载大对象的过程中GUI会挂起，或者隐藏主题在远程运行的事实。

幽影相随
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java常用设计模式-代理模式
08-26
java常用设计模式-代理模式
基于Java Swing的图片浏览器
Jack魏
06-11 643
图片浏览器一般都具有打开jpg、gif、png、tiff等格式图片文件并对图片文件夹中的图片进行顺序浏览的功能。一般的图片浏览器还有“上一页”、“下一页”的翻页功能和图片“放大”、“缩小”的浏览功能。功能比较强大的图片浏览器还有文件选择的功能，功能更强大一些的图片浏览器可以对未打开的图片文件进行缩放预览效果的实现。这次课程设计做的图片浏览器实现了上述的大部分功能，不过稳定性和精确度的问题还有待进一步完善。......
RMI原理揭秘之远程对象
weixin_33816611的博客
06-07 145
讨论开始之前，我们先看看网上的一个例子，这个例子我腾抄了一分，没有用链接的方式，只是为了让大家看得方便，如有侵权，我立马***。定义远程接口:package com.guojje; import java.rmi.Remote; import java.rmi.RemoteException; public interface IHello extends Remote {     public ...
【Java】【系列篇】【Spring源码解析】【三】【体系】【Registry体系】
时光与简的博客
01-17 576
【Java】【系列篇】【Spring源码解析】【三】【体系】【Registry体系】
java rmi 存根是什么_Java RMI – UnicastRemoteObject：UnicastRemoteObject.exportObject()和扩展UnicastRemoteObje...
weixin_39915700的博客
02-16 363
我正在准备考试，我有一个问题，希望有人能回答我。它关于RMI和远程对象。我不知道为什么这两个实现之间有很大的区别。一个是扩展UnicastRemoteObject，而另一个则以UnicastRemoteObject的形式导出该对象。我没有真正的区别 – 顺便说一句，这只是一个很简单的例子:-)接口：public interface EchoI extends Remote {public Stri...
Dubbo系列-4.工厂模式的Registry
熊猫猫
07-17 3572
工厂模式创建Registry RegistryFactory AbstractRegistryFactory 　ZookeeperRegistryFactory Registry AbstractRegistry FailbackRegistry ZookeeperRegistry 构造 doRegister doSubscribe本想按照服务发布和服务引用来写，但是感觉先理解Registry，后面
详解JAVA设计模式之代理模式
08-19
主要介绍了JAVA设计模式之代理模式的的相关资料，文中代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
java设计模式课程设计
10-13
使用5种设计模式完成的一个点单系统，显示不同系列下的所有商品，点击选择冰度甜度之后添加到订单中，计算总金额，下单之后发送订单到门店的后厨制作商品。使用了抽象工厂模式、装饰模式、单例模式、代理模式、原型...
Java 经典设计模式讲解以及项目实战
最新发布
06-14
Java 经典设计模式讲解以及项目实战 设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述...
基于Java的代理设计模式
01-08
而生产厂商通过代理商将自己的产品推广出去，而且可以将一些销售服务的任务交给代理商来完成（当然代理商要和厂商来共同分担风险，分配利润），这样自己就可以花更多的心思在产品的设计和生产上了。 在美国，任何...
Java23种设计模式
王涛的博客
07-01 1万+
一、设计模式入门：1.设计模式是人们在面对同类型软件工程设计问题所总结出的一些有用经验。模式不是代码，而是某类问题的通用设计解决方案 2.设计模式的本质目的是使软件工程在维护性、扩展性、变化性、复杂度方面成O(N) 3.OOP是原则，设计模式是具体方法、工具 ————————————————————————————————————————————二、策略模式从文字方面可能我们很难理解，所以我们
设计模式:Registry of Singleton模式
12-06 2388
原文地址:http://leihuang.org/2014/12/05/registry-of-singleton/ Creational 模式 物件的产生需要消耗系统资源，所以如何有效率的产生、管理 与操作物件，一直都是值得讨论的课题， Creational 模式即与物件的建立相关，在这个分类下的模式给出了一些指导原则及设计的方向。下面列举到的全属于Creational 模式
java 注册模式_java实现的注册工厂模式
weixin_39975529的博客
02-12 363
package com.eric.reflect;import java.util.ArrayList;import java.util.Random;/** factory interface* */interface Factory {public T create();}public class RegisterFactory {public static void main(String[...
java实现的注册工厂模式
我是传奇
02-07 534
package com.eric.reflect; import java.util.ArrayList; import java.util.Random; /* * factory interface * */ interface Factory&lt;T&gt; { public T create(); } public class RegisterFactory { publi...
注册机制 Registry 实现
qq_38343151的博客
05-04 1946
看一下注册机制是如何使用的： registry_machine = Registry('registry_machine') registry_machine.register() def print_hello_world(word): print('hello {}'.format(word)) registry_machine.register() def print_h...
【最小Demo】Java RMI入门 使用Registry、Naming、Zookeeper（注册中心）实现rmi
alwarse
02-23 2094
【最小Demo】Java RMI入门 使用Registry、Naming、Zookeeper（注册中心）实现rmi
一个java状态机样例的代码
热门推荐
seacean2000的专栏
08-29 2万+
在UML当中有状态机视图，这个状态机可以用于自动售货机，自动售票机等等场景，下面是用java代码模拟的一个状态机： 1.状态机接口 package stateMachine; /** * 状态机接口 * @author seacean * @date 2013-8-29 */ public interface State { /** * 投入硬币 */ void inser
head first 设计模式
wenjieyatou的博客
06-08 1868
一、概述设计模式不是代码，而是解决问题的方案，学习现有的设计模式可以做到经验复用。拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。源码以及 UML 图二、创建型1. 单例（Singleton）意图确保一个类只有一个实例，并提供该实例的全局访问点。类图使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。私有构造函数保证了不能通过构造函数来创建对象实例，只能通过...
java设计模式代理模式
06-11
在 Java 中，代理模式可以使用接口或抽象类来定义代理对象和实际对象之间的公共接口。代理对象通常会持有一个实际对象的引用，并在需要时将请求转发给它。 代理模式有多种类型，包括静态代理、动态代理和远程代理等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值