JAVA RMI分布式原理和应用

 1  package com.daniele.appdemo.rmi.server;  
 2       
 3     import java.io.Serializable;  
 4     import java.rmi.RemoteException;  
 5     import java.rmi.server.RemoteServer;  
 6     import java.rmi.server.ServerNotActiveException;  
 7       
 8     import org.apache.log4j.Logger;  
 9       
10     import com.daniele.appdemo.rmi.SystemManager;  
11     import com.daniele.appdemo.test.domain.User;  
12     import com.daniele.appdemo.util.SystemUtils;  
13       
14     /** 
15      * <p> 
16      *         系统管理远程对象实现类。有两种实现方式： 
17      *      1.继承UnicastRemoteObject或Activatable,并同时实现Remote子接口 
18      *      2.只实现Remote子接口，这种方式灵活但比较复杂： 
19      *        1)要求此实现类必须实现java.io.Serializable接口； 
20      *        2)通过这种方式定义的实现类此时还不能叫做远程对象实现类， 
21      *          因为在服务器端绑定远程对象之前，还需要利用JDK提供的rmic工具 
22      *          将此实现类手工编译生成对应的桩实现类，并放到和它相同的编译目录下。 
23      * </p> 
24      * @author  <a href="mailto:code727@gmail.com">Daniele</a> 
25      * @version 1.0.0, 2013-5-21 
26      * @see     
27      * @since   AppDemo1.0.0 
28      */  
29     public class SystemManagerImpl implements SystemManager, Serializable {  
30          
31     //public class SystemManagerImpl extends UnicastRemoteObject implements SystemManager {  
32          
33         private static final long serialVersionUID = 9128780104194876777L;  
34          
35         private static final Logger logger = Logger.getLogger(SystemManagerImpl.class);  
36          
37         private static SystemManagerImpl systemManager = null;  
38       
39         /** 
40          * <p>在服务端本地的匿名端口上创建一个用于监听目的的UnicastRemoteObject对象</p> 
41          * @author <a href="mailto:code727@gmail.com">Daniele</a> 
42          * @throws RemoteException 
43          * @since AppDemo1.0.0 
44          */  
45         private SystemManagerImpl() throws RemoteException {  
46             super();  
47             // 在控制台中显示远程对象被调用，以及返回结果时产生的日志  
48             RemoteServer.setLog(System.out);  
49         }  
50          
51         public static SystemManagerImpl getInstance() throws RemoteException {  
52             if (systemManager == null) {  
53                 synchronized (SystemManagerImpl.class) {  
54                     if (systemManager == null)  
55                         systemManager = new SystemManagerImpl();  
56                 }  
57             }  
58             return systemManager;  
59         }  
60       
61         public String getAllSystemMessage() throws RemoteException {  
62             try {  
63                 /* 
64                  * getClientHost()方法可以获取触发当前远程方法被调用时的客户端的主机名。 
65                  * 在远程服务端的环境中，如果当前线程实际上没有运行客户端希望调用的远程方法时， 
66                  * 则会抛出ServerNotActiveException。 
67                  * 因此，为了尽量避免这个异常的发生，它通常用于远程方法的内部实现逻辑中， 
68                  * 以便当此方法真正的被调用时，可以记录下哪个客户端在什么时间调用了这个方法。 
69                  */  
70                     logger.info("Client {" + RemoteServer.getClientHost() + "} invoke method [getAllSystemMessage()]" );  
71                 } catch (ServerNotActiveException e) {  
72                     e.printStackTrace();  
73                 }  
74             return SystemUtils.formatSystemProperties();  
75         }  
76       
77         public String getSystemMessage(String properties) throws RemoteException {  
78             try {  
79                 logger.info("Client {"  
80                         + RemoteServer.getClientHost()  
81                         + "} invoke method [getAllSystemMessage(String properties)]");  
82                  } catch (ServerNotActiveException e) {  
83                     e.printStackTrace();  
84                 }  
85             return SystemUtils.formatSystemProperties(properties.split(","));  
86         }  
87       
88     }  

 1     package com.daniele.appdemo.rmi.server;  
 2       
 3     import java.io.IOException;  
 4     import java.util.Arrays;   
 5     import java.rmi.Naming;  
 6     import java.rmi.registry.LocateRegistry;  
 7     import java.rmi.server.UnicastRemoteObject;  
 8       
 9     import org.apache.log4j.Logger;  
10       
11     import com.daniele.appdemo.rmi.SystemManager;  
12       
13     /** 
14      * <p> 
15      *         系统管理远程服务器，它主要完成如下任务： 
16      *      1.在绑定之前先启动注册表服务。 
17      *         2.将远程对象SystemManager绑定到注册表中，以便让客户端能远程调用这个对象所发布的方法； 
18      * </p>  
19      * @author  <a href="mailto:code727@gmail.com">Daniele</a> 
20      * @version 1.0.0, 2013-5-21 
21      * @see      
22      * @since   AppDemo1.0.0 
23      */  
24     public class SystemManagerServer {  
25           
26         private static final Logger logger = Logger.getLogger(SystemManagerServer.class);  
27           
28         public static void main(String[] args) {  
29             try {  
30                   
31                     SystemManager systemManager = SystemManagerImpl.getInstance();  
32                   
33                     /* 
34                      *  如果远程对象实现类不是通过继承UnicastRemoteObject或Activatable来定义的， 
35                      *  则必须在服务器端显示的调用UnicastRemoteObject类中某个重载的exportObject(Remote remote)静态方法， 
36                      *  将此实现类的某个对象导出成为一个真正的远程对象。否则，此步省略。 
37                      */  
38                     UnicastRemoteObject.exportObject(systemManager);  
39                      
40                     int port = 9527;  
41                     String url = "rmi://localhost:" + port + "/";  
42                     String remoteObjectName = "systemManager";  
43       
44                     /* 
45                      *  在服务器的指定端口(默认为1099)上启动RMI注册表。 
46                      *  必不可缺的一步，缺少注册表创建，则无法绑定对象到远程注册表上。 
47                      */  
48                     LocateRegistry.createRegistry(port);  
49                   
50                     /* 
51                      *  将指定的远程对象绑定到注册表中： 
52                      *  1.如果端口号不为默认的1099，则绑定时远程对象名称中必须包含Schema， 
53                      *    即"rmi://<host或ip><:port>/"部分，并且Schema里指定的端口号应与createRegistry()方法参数中的保持一致 
54                      *  2.如果端口号为RMI默认的1099，则远程对象名称中不用包含Schema部分，直接定义名称即可 
55                      */  
56                     if (port == 1099)  
57                         Naming.rebind(remoteObjectName, systemManager);  
58                     else  
59                         Naming.rebind(url + remoteObjectName, systemManager);  
60                    logger.info("Success bind remote object " + Arrays.toString(Naming.list(url)));  
61                 } catch (IOException e) {  
62                     e.printStackTrace();  
63                 }  
64           }  
65           
66     }