远程对象工厂设计模式

    把一个远程对象注册到rmiregistry注册表，客户就能找到这个远程对象，rmiregistry注册表只能用来注册少量的远程对象。当客户端调用服务器端的远程对象方法时，客户端会向服务器传递参数，服务器端会向客户端传递返回值。RMI规范对参数及返回值的传递做了如下规定：

    （1）只有基本类型的数据，远程对象及可序列化的对象才能作为参数或者返回值进行传递。

      （2）如果参数或返回值是一个远程对象，那么把它的存根对象传递到接收方。也就是说，接收方得到的是远程对象的存根对象。

      （3）如果参数或返回值是可序列化对象，那么直接传递该对象的序列化数据。也就是说，接收方得到的是发送方的可序列化对象的复制品。

       （4）如果参数或返回值是基本类型的数据，那么直接传递该数据的序列化数据。也就是说，接收方得到的是发送方的基本类型的数据的复制品。

下面看一段代码，参数或返回值是可序列化对象：

package com.you.rmifactory; import java.io.Serializable; import java.rmi.RemoteException; import java.rmi.server.UnicastRemoteObject; public class Flight implements Serializable{ protected String flightNumber; protected String origin; protected String destination; protected String skdDepature; protected String skdArrival; public Flight(String aFlightNumber, String anOrigin, String aDestination, String aSkdDepature, String aSkdArrival) throws RemoteException{ flightNumber = aFlightNumber; origin = anOrigin; destination = aDestination; skdDepature = aSkdDepature; skdArrival = aSkdArrival; } public String getFlightNumber() throws RemoteException { System.out.println("调用getFlightNumber(),返回" + flightNumber); return flightNumber; } public String getDestination() throws RemoteException { return destination; } public String getOrigin() throws RemoteException { return origin; } public String getSkdArrival() throws RemoteException { return skdArrival; } public String getSkdDepature() throws RemoteException { return skdDepature; } public void setDestination(String destination) throws RemoteException { this.destination = destination; } public void setOrigin(String origin) throws RemoteException { this.origin = origin; } public void setSkdArrival(String skdArrival) throws RemoteException { this.skdArrival = skdArrival; } public void setSkdDepature(String skdDepature) throws RemoteException { this.skdDepature = skdDepature; } }
package com.you.rmifactory; import java.rmi.Remote; import java.rmi.RemoteException; public interface FlightFactory extends Remote{ public Flight getFlight(String flightNumber) throws RemoteException; }
package com.you.rmifactory; import java.rmi.RemoteException; import java.rmi.server.UnicastRemoteObject; import java.util.Hashtable; public class FlightFactoryImpl extends UnicastRemoteObject implements FlightFactory{ protected Hashtable<String, Flight> flights;//存放Flight对象的缓存 protected FlightFactoryImpl() throws RemoteException { flights = new Hashtable<String, Flight>(); } @Override public Flight getFlight(String flightNumber) throws RemoteException { Flight flight = flights.get(flightNumber); if(flight != null) { return flight; } flight = new Flight(flightNumber, null, null, null, null); flights.put(flightNumber, flight); return flight; } }
package com.you.rmifactory; import java.rmi.registry.LocateRegistry; import javax.naming.Context; import javax.naming.InitialContext; public class SimpleServer { public static void main(String[] args) { try { FlightFactory factory = (FlightFactory) new FlightFactoryImpl(); Context namingContext = new InitialContext(); LocateRegistry.createRegistry(1099); namingContext.rebind("rmi:FlightFactory", factory); System.out.println("服务器注册了一个flightfactory对象"); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
package com.you.rmifactory; import javax.naming.Context; import javax.naming.InitialContext; public class SimpleClient { public static void main(String[] args) { String url = "rmi://localhost/"; try { Context namingContext = new InitialContext(); FlightFactory factory = (FlightFactory) namingContext.lookup(url + "FlightFactory"); Flight flight1 = factory.getFlight("795"); flight1.setOrigin("Shanghai"); flight1.setDestination("Beijing"); System.out.println("Flight" + flight1.getFlightNumber() + ":"); System.out.println("From" + flight1.getOrigin() + "to" + flight1.getDestination()); Flight flight2 = factory.getFlight("795"); System.out.println("Flight" + flight2.getFlightNumber() + ":"); System.out.println("From" + flight2.getOrigin() + "to" + flight2.getDestination()); System.out.println("flight1是" + flight1.getClass().getName() + "的实例"); System.out.println("flight2是" + flight2.getClass().getName() + "的实例"); System.out.println("flight1 == flight2:" + (flight1 == flight2)); System.out.println("flight1.equal(flight2):" + (flight1.equals(flight2))); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
运行服务器程序结果为：

服务器注册了一个flightfactory对象
运行客户端程序结果为：

调用getFlightNumber(),返回795 Flight795: FromShanghaitoBeijing 调用getFlightNumber(),返回795 Flight795: Fromnulltonull flight1是com.you.rmifactory.Flight的实例 flight2是com.you.rmifactory.Flight的实例 flight1 == flight2:false flight1.equal(flight2):false
可以看到flight1.equal(flight2):false，参数为可序列化对象时，得到的是远程对象的两个复制品，不相等。equal方法在客户端被重写了，当参数为远程对象时，因为得到是存根对象，flight1.equal(flight2):true，同一个存根对象。