《Head First 设计模式》笔记10

最新推荐文章于 2024-11-04 17:30:00 发布

Zoctan

最新推荐文章于 2024-11-04 17:30:00 发布

阅读量248

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/Zoctan/article/details/79899103

版权

设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

代理模式（Proxy）

为另一个对象提供一个替身或占位符以控制对这个对象的访问。

栗子

还记得上一个笔记中的糖果机吧，现在产品经理想要一份写着糖果机位置、库存和当前的状态报告。

是不是挺简单的？赶紧写代码。

糖果机加上位置信息：

class GumballMachine {
    // ...
    private String location;

    public GumballMachine(String location, int count) {
        this.location = location;
        // ...
    }

    public String getLocation() {
        return location;
    }

    // ...
}

一个监控糖果机的监视器：

class GumballMonitor {
    private GumballMachine gumballMachine;

    public GumballMonitor(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void report() {
        System.out.println("糖果机：" + gumballMachine.getLocation());
        System.out.println("当前库存：" + gumballMachine.getCount());
        System.out.println("当前状态：" + gumballMachine.getState());
    }
}

测试

public static void main(String[] args) {
    GumballMachine gumballMachine = new GumballMachine("广州", 600);
    GumballMonitor monitor = new GumballMonitor(gumballMachine);
    monitor.report();
}

完美通过测试，收拾东西回家洗澡。

满足了假的需求

产品经理的需求并没有完全表达清楚，我们就开始写了，最后白费了时间和精力，而且没完成任务。（记得问清楚需求再去实现）

需求是要一个能远程的监控器，而按我们上面的监视器和糖果机代码，它们就是在同一个 JVM 上执行的，就相当于一个本地监控器，什么意思呢？相当于在教室里装了一个摄像头，而且是实时监控，没联网的，那么只能在教室看，对于坐在办公室的老师来说这个摄像头没起作用。

前置知识

RMI：远程方法调用（Remote Method Invocation），用于不同虚拟机之间的通信，这些虚拟机可以在不同的主机上、也可以在同一个主机上；一个虚拟机中的对象调用另一个虚拟机中的对象的方法，而允许被远程调用的对象需要通过一些标志加以标识。

详情的可以看看这篇文章。

制作远程服务

将一个普通的对象变成可以被远程客户调用的远程对象，简要步骤：
1. 制作远程接口：远程接口定义出可以让客户远程调用的方法。客户将用它作为服务的类类型。Stub 和实际的服务都实现此接口。
2. 制作远程实现：做实际工作的类，为远程接口中定义的远程方法提供了真正的实现，是客户真正想要调用方法的对象（比如我们的GumballMachine）。
3. 利用 rmic 产生的 stub 和 skeleton：客户和服务的辅助类。不需要创建，因为运行 rmic 工具时就会自动处理。
4. 启动 RMI registry：rmireistry 就像电话簿，客户可以从中查到代理的位置（就是客户的 stub helper 对象）。
5. 开始远程服务：让服务对象开始运行。服务实现类会去实例化一个服务的实例，并将这个服务注册到 RMI registry。注册之后，这个服务就可以供客户调用了。

制作远程接口

扩展 java.rmi.Remote

Remote 不具有方法，只是作为一个“记号”接口。对 RMI 来说，Remote 接口具有特别的意义。

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyRemote extends Remote {
    public String sayHello() throws RemoteException;
}

注意：

所有的方法都要声明抛出 RemoteException，因为客户会调用实现远程接口的 Stub 上的方法，而 Stub 底层用到了网络和 I/O，所以各种意外都可能发生。
方法上的变量和返回值都必须属于原语（primitive）或可序列化（Serializable）类型（远程方法的变量必须被打包并通过网络运送，这需要序列化）。原语类型、字符串和许多 API 中内定的类型都不会有问题，但如果是自己定义的类，必须保证它实现了 Serializable。

制作远程实现

你的服务必须实现远程接口，它是客户将要调用的方法的接口。

import java.rmi.server.UnicastRemoteObject;

public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote {
    public MyRemoteImpl() throws RemoteException { }

    public String sayHello() {
        return "服务器：你好";
    }

    // 为了方便后面的启动服务
    public static void main(String[] args) {
        try {
            MyRemote service = new MyRemoteImpl();
            Naming.rebind("RemoteHello", service);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：

扩展 UnicastRemoteObject：为了成为远程服务对象，你的对象需要某些“远程的”功能。最简单的方式就是扩展 UnicastRemoteObject，让超类帮你做这些工作。
不带变量的构造器要声明 RemoteException，这样当类被实例化的时候，超类的构造器总是会被调用。如果超类的构造器抛出异常，那么你只能什么子类的构造器也抛出异常。

产生 Stub 和 Skeleton

在远程实现类上执行 rmic 命令：

rmic MyRemoteImpl

执行 rmireistry

执行命令启动 rmireistry

rmireistry

启动服务

在这个简单的例子中，我们从实现类中的 main 方法启动：

java MyRemoteImpl

客户取得 Stub 对象

客户总是使用远程接口做为服务类型，事实上客户不需要知道远程服务的真正类名什么。

import java.rmi.*;

class MyRemoteClient {
    public static void main(String[] args) {
        try {
            // 通过查找 RemoteHello 注册名，找到远程服务
            MyRemote service = (MyRemote) Naming.lookup("rmi://127.0.0.1/RemoteHello");
            System.out.println(service.sayHello());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：

要先启动 rmireistry 注册，再启动远程服务。
远程方法的变量和返回值类型必须为可序列化的类型。
必须给客户提供 Stub 类。

客户机内有：Client.class、MyRemoteImpl_Stub.class、MyRemote.class
远程服务机内有：MyRemoteImpl.class、MyRemoteImpl_Stub.class、MyRemoteImpl_Skel.class、MyRemote.class

继续完成需求

把糖果机变成一个远程服务

同样，按照上面的步骤进行。

1.创建远程接口：

import java.rmi.*;

public interface GumballMachineRemote extends Remote {
    public int getCount() throws RemoteException;
    public String getLocation() throws RemoteException;
    public State getState() throws RemoteException;
}

2.State 这个返回类型不是序列化的，要修改：

import java.io.Serializable;

public interface State extends Serializable {
    public void insertQuarter();
    public void ejectQuarter();
    public void turnCrank();
    public void dispense();
}

3.每个实体状态都维护着一个糖果机的引用，而我们不希望整个糖果机都被序列化并随着 State 对象一起传送：

加上 transient 关键字，告诉 JVM 不要序列化这个字段。

public class SoldState implements State {
    transient GumballMachine gumballMachine;

    // ...
}

4.糖果机要实现远程接口：

import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;

public class GumballMachine extends UnicastRemoteObject implements GumballMachineRemote {
    // 构造方法会抛 RemoteException 异常，因为超类
    public GumballMachine(String location, int count) throws RemoteException {
        // ...
    }

    // ...
}

5.修改监控器：

import java.rmi.*;

public class GumballMonitor {
    // 改成远程接口上的糖果机
    private GumballMachineRemote gumballMachine;

    public GumballMonitor(GumballMachineRemote gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void report() {
        try {
            System.out.println("糖果机：" + gumballMachine.getLocation());
            System.out.println("当前库存" + gumballMachine.getCount());
            System.out.println("当前状态" + gumballMachine.getState());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

在 RMI registry 中注册

糖果机服务已经完成了，现在要把它装上，好开始接收请求。

首先要确保将它注册到 RMI registry 中，好让客户可以找到它：

public class GumballMachineTestDrive {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("GumballMachine <location> <count>");
            System.exit(1);
        }

        try {
            String location = args[0];
            int count = Integer.parseInt(args[1]);
            GumballMachineRemote gumballMachine = new GumballMachine(location, count);
            // 用糖果机的位置发布糖果机的 stub
            Naming.rebind("//" + location + "/gumballmachine", gumballMachine);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在命令行注册：

rmiregistry

启动糖果机服务：

java GumballMachineTestDrive GuangZhou 100

监控器测试程序

现在一切就绪，可以尝试监控更多糖果机：

public class GumballMonitorTestDrive {
    public static void main(String[] args) {
        List<String> locations = Arrays.asList( "rmi://GuangZhou/gumballmachine",
                                                "rmi://ShangHai/gumballmachine",
                                                "rmi://BeiJing/gumballmachine");
        List<GumballMonitor> monitors = new ArrayList<>();

        locations.forEach(location -> {
            try {
                // 为每个远程机器创建一个代理
                GumballMachineRemote machine = (GumballMachineRemote) Naming.lookup(location);
                monitors.add(new GumballMonitor(machine));
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        monitors.forEach(monitor -> monitor.report());
    }
}