客户访问限制管理器

    前段时间开发短信收发系统，遇到一个问题，就是有n个对象都可以通过Mobile对象发短信，但同一时刻只允许一个对象进行操作。所以设计了一个客户限制管理器的对象来解决，但由于种种原因没有用到实际系统中。后来经过仔细考虑，发现它不仅可以用于端口的管理，还可用于其他需要针对客户访问数量进行限制的各种服务中去。----这里的“客户”是指要操作该管理器的对象

 

1. /**
2.  * 客户限制管理器的抽象类<br>
3.  * 此抽象类实现了对客户访问的限制，当一个客户访问该服务时，可以通过halt(long guestid)方法阻止其他客户进行
4.  * 访问，防止多个客户同时访问产生的冲突。例如：对通讯端口的访问等。<br>
5.  * 
6.  * @author none
7.  * 
8.  */
9. public abstract class GuestManager {
11.     /**
12.      * 时间：一分钟
13.      */
14.     protected static final long ONE_MINUTE = 60L * 1000L;
15.     
16.     /**
17.      * 时间：一小时
18.      */
19.     protected static final long ONE_HOUR = 60L * ONE_MINUTE;
21.     /**
22.      * 自动清理客户记录的间隔时间
23.      */
24.     private long cleanInterval;
26.     /**
27.      * 客户记录<客户标识，最近访问时间>
28.      */
29.     private Hashtable<String, String> guests;
31.     /**
32.      * 当前限制的客户
33.      */
34.     private long limitGuest;
36.     /**
37.      * 自动清除过期客户的线程
38.      */
39.     private Thread autoCleanThread;
41.     /**
42.      * 客户注册
43.      * 
44.      * @return 返回分配给客户端的唯一标识，如果注册失败，返回-1
45.      */
46.     public long login() {
47.         long guestid = -1L;
49.         // 增加客户记录
50.         Hashtable<String, String> guests = getGuests();
51.         if (guests != null) {
52.             guestid = System.currentTimeMillis();
53.             guests.put("" + guestid, "" + guestid);
54.             update(guestid);
55.             // if (guests.size() == 1)
56.             // connect();
57.         }
59.         return guestid;
60.     }
62.     /**
63.      * 检查客户是否已经注册
64.      * 
65.      * @param guestid
66.      *            客户标识
67.      * @return 如果客户已经注册返回true，否则返回false
68.      */
69.     public boolean isLogin(long guestid) {
70.         boolean flag = false;
71.         if (guestid > 0) {
72.             Hashtable<String, String> guests = getGuests();
73.             if (guests != null)
74.                 flag = guests.containsKey("" + guestid);
75.             if (flag)
76.                 update(guestid);
77.         }// end if (guestid > 0)
78.         return flag;
79.     }
81.     /**
82.      * 注销客户<br>
83.      * 如果仍有其他客户在使用此对象，则仅仅注销guestid客户，否则调用disconnect()方法关闭连接。
84.      * 
85.      * @param guestid
86.      *            客户标识
87.      * @return 返回是否成功注销
88.      */
89.     public void logout(long guestid) {
90.         Hashtable<String, String> guests = getGuests();
91.         if (guests != null) {
92.             if (guestid > 0 && guests.containsKey("" + guestid)) {
93.                 guests.remove("" + guestid);
94.             }// end if (guestid > 0 && getGuests().containsKey("" +
95.             // guestid))
96.         }// end if (guests != null)
97.     }
99.     /**
100.      * 限制<br>
101.      * 如果某一客户调用了该方法，那么其他客户将无法访问，直至该客户调用resume()释放。
102.      * 
103.      * @param guestid
104.      *            中断标识
105.      * @return 返回是否成功中断
106.      */
107.     public boolean limit(long guestid) {
108.         boolean flag = false;
109.         if (isLogin(guestid)) {
110.             update(guestid);
112.             if (isLimit(guestid))
113.                 return flag;
115.             limitGuest = guestid;
116.             flag = true;
117.         }// end if (isLogin(guestid))
118.         return flag;
119.     }
121.     /**
122.      * 释放
123.      * 
124.      * @param guestid
125.      *            客户标识
126.      * @return 返回是否释放成功
127.      */
128.     public boolean resume(long guestid) {
129.         boolean flag = false;
130.         if (isLogin(guestid)) {
131.             update(guestid);
132.             if (limitGuest == guestid) {
133.                 limitGuest = -1L;
134.             }// end if(haltGuest == guestid)
135.             flag = !isLimit();
136.         }
137.         return flag;
138.     }
140.     /**
141.      * 是否限制其他客户调用
142.      * 
143.      * @return 返回是否限制其他客户调用
144.      */
145.     protected boolean isLimit() {
146.         boolean flag = false;
148.         if (limitGuest > 0) {
149.             long lasttime = Long.parseLong((getGuests().get(
150.                     "" + limitGuest)));
151.             if (lasttime > 0) {
152.                 // 如果10分钟内无响应，则注释放该客户的中断
153.                 long time = System.currentTimeMillis() - 10L
154.                         * ONE_MINUTE;
156.                 if (time < lasttime)
157.                     flag = true;
158.                 else
159.                     limitGuest = -1;
160.             }
161.         }// end if(this.id <= 0)
162.         return flag;
163.     }
165.     /**
166.      * 该客户是否被限制访问
167.      * 
168.      * @param haltId
169.      *            客户标识
170.      * @return 返回true表示禁止访问，false表示可以访问
171.      */
172.     public boolean isLimit(long guestid) {
173.         boolean flag = true;
174.         if (isLogin(guestid)) {
175.             update(guestid);
176.             flag = isLimit();
177.             if (flag) {
178.                 if (guestid > 0 && limitGuest == guestid)
179.                     flag = false;
180.             }// end if(flag)
181.         }
182.         return flag;
183.     }
185.     /**
186.      * 取得当前限制客户的标识（该标识是该管理器为客户分配的一个唯一标识）
187.      * 
188.      * @return 返回当前限制客户的标识
189.      */
190.     protected long getLimitGuest() {
191.         return limitGuest;
192.     }
194.     /**
195.      * 更新客户最近使用时间<br>
196.      * 
197.      * @param guestid
198.      *            客户标识
199.      */
200.     protected void update(long guestid) {
201.         runThread();
202.         Hashtable<String, String> guests = getGuests();
203.         if (guests != null && guests.containsKey("" + guestid))
204.             guests.put("" + guestid, ""
205.                     + System.currentTimeMillis());
206.     }
208.     /**
209.      * 运行监听线程
210.      */
211.     protected void runThread() {
212.         // 客户自动清理线程
213.         if (autoCleanThread != null && !autoCleanThread.isAlive())
214.             autoCleanThread = null;
215.         if (autoCleanThread == null) {
216.             autoCleanThread = new AutoCleanThread();
217.             autoCleanThread.start();
218.         }// end if (autoCleanThread == null)
219.     }
221.     /**
222.      * 设置自动清理客户记录的间隔时间
223.      * 
224.      * @param time
225.      *            间隔时间（毫秒）
226.      */
227.     public void setCleanInterval(long time) {
228.         if (time > 0)
229.             cleanInterval = time;
230.     }
232.     /**
233.      * 取得自动清理客户记录的间隔时间
234.      * 
235.      * @return 返回自动清理客户记录的间隔时间（毫秒）
236.      */
237.     public long getCleanInterval() {
238.         return cleanInterval;
239.     }
241.     /**
242.      * 取得客户记录
243.      * 
244.      * @return 返回客户记录。格式为<客户标识，最近访问时间>
245.      */
246.     protected Hashtable<String, String> getGuests() {
247.         if (guests == null)
248.             guests = new Hashtable<String, String>();
249.         return guests;
250.     }
252.     /**
253.      * 输出错误信息
254.      * 
255.      * @param err
256.      */
257.     public abstract void trace(String err);
259.     /**
260.      * 自动清除超时的客户端的线程
261.      * 
262.      */
263.     private class AutoCleanThread extends Thread {
265.         public void run() {
266.             trace("AutoCleanThread thread start runing...");
269.             long interval = ONE_HOUR / 4L;
270.             if (getCleanInterval() > 0)
271.                 interval = getCleanInterval();
272.             
273.             while (autoCleanThread == this && getGuests().size() > 0) {
274.                 long time = System.currentTimeMillis()
275.                         - ONE_HOUR / 2L;
277.                 Enumeration<?> keys = getGuests().keys();
278.                 while (keys.hasMoreElements()) {
279.                     String key = (String) keys.nextElement();
280.                     if (key != null) {
281.                         long lasttime = Long.parseLong(getGuests()
282.                                 .get(key));
283.                         if (time > lasttime)
284.                             // 超时
285.                             getGuests().remove(key);
286.                     }// end if (key != null)
287.                 }// end while (keys.hasMoreElements())
289.                 try {
290.                     Thread.sleep(interval);
291.                 } catch (InterruptedException e) {
292.                     e.printStackTrace();
293.                     trace("error - " + e.toString());
294.                 }
295.             }// end while (mobiles != null && mobiles.size() > 0)
297.             trace("AutoCleanThread thread end...");
298.         }
299.     }
300. }

 

1. /**
2.  * 通讯端口的客户端限制管理器的抽象类<br>
3.  * 该类继承自GuestManager类，增加了connect()、disconnect()等方法
4.  * 
5.  * @author none
6.  *
7.  */
8. public abstract class PortGuestManager extends GuestManager {
9.     
10.     /**
11.      * 连接
12.      * 
13.      * @return 返回是否连接成功
14.      */
15.     protected abstract boolean connect();
17.     /**
18.      * 断开
19.      * 
20.      * @return 返回是否断开成功
21.      */
22.     protected abstract boolean disconnect();
24.     /**
25.      * 是否已经连接
26.      * 
27.      * @return 返回端口是否已经连接
28.      */
29.     protected abstract boolean isConnected();
30.     
31.     public long login() {
32.         long guestid = -1L;
33.         if (!isConnected())
34.             connect();
36.         if (isConnected())
37.             guestid = super.login();
38.         
39.         return guestid;
40.     }
42.     public boolean limit(long guestid) {
43.         boolean flag = false;
44.         if (isConnected())
45.             flag = super.limit(guestid);
46.         return flag;
47.     }
48.     
49.     public void logout(long guestid) {
50.         super.logout(guestid);
51.         
52.         Hashtable<String, String> guests = getGuests();
53.         if (guests != null)
54.             if (guests.size() <= 0)
55.                 disconnect();
56.     }
57.     
58.     public boolean isLimit(long guestid) {
59.         boolean flag = true;
60.         if (isConnected())
61.             flag = super.isLimit(guestid);
62.         return flag;
63.     }
64. }