jdk1.4 构建 java多线程,并发设计框架 使用列子(四)

 使用jvm反射，通过类名取得一个处理数据客户端的实例。

2. import java.io.ByteArrayOutputStream;
3. import java.lang.reflect.InvocationTargetException;
4. //import java.nio.ByteBuffer;
6. /**
7.  * 处理接收的流数据,把获取的相关数据流内容，发送给客户程序处理。
8.  * @author guishuanglin 2008-11-3
9.  * 
10.  */
11. public class ProcessRequestData implements Runnable {
12.     //ByteArrayOutputStream
13.     private ConcurrentQueue dataQueue;
14.     private Class clientClass;
15.     private IProcessClientData clientObejct = null;
16.     private int requestCount;
17.     private String netAddress;
19.     /**
20.      * @param ss
21.      * @param requestNum
22.      */
23.     public ProcessRequestData(int requestCount,String netAddress,Class clientClass,ConcurrentQueue dataQueue) {
24.         this.clientClass = clientClass;
25.         this.dataQueue   = dataQueue;
26.         this.requestCount= requestCount;
27.         this.netAddress  = netAddress;
28.         clientObejct = this.CreateClientObject();
29.     }
31.     public void run() {
32.         try {
33.             // 把当前处理流数据的线程,压入线程并发队列,在线程队列中等待处理.
34.             if(clientObejct!=null ){
35.                 clientObejct.ProcessStreamData(dataQueue,requestCount,netAddress);
36.                 clientObejct.run();
37.             }else{
38.                 System.out.println("Request["+requestCount+"],创建客户端数据流处理对象实例失败,系统将丢失当前的数据流.");
39.             }
40.         } finally{
41.             ReleaseResource();
42.         }
43.     }
45.     public void ReleaseResource() {
46.             if (dataQueue != null)
47.                 dataQueue.clear();
48.             dataQueue = null;
49.             clientObejct = null;
50.             clientClass = null;
51.     }
53.     /**
54.      * 根据类名获取Class对象 Class c=Class.forName("java.lang.Integer"); 
55.      * 参数类型数组 
56.      * Class[] parameterTypes={String.class}; 
57.      * 根据参数类型获取相应的构造函数
58.      * java.lang.reflect.Constructor
59.      * constructor=c.getConstructor(parameterTypes); 
60.      * 参数数组 
61.      * Object[] parameters={"1"};
62.      * 根据获取的构造函数和参数，创建实例 Object
63.      * o=constructor.newInstance(parameters);
64.      */
65.     
66.     private IProcessClientData CreateClientObject() {
67.         Class[] parameterTypes=new Class[]{};
68.         java.lang.reflect.Constructor constructor;
69.         Object[] parameters=new Object[]{};
70.         //ByteArrayOutputStream
71.         IProcessClientData o=null;
72.         try {
73.             constructor = clientClass.getConstructor(parameterTypes);
74.             o = (IProcessClientData)constructor.newInstance(parameters);
75.         }catch (SecurityException e) {
76.             e.printStackTrace();
77.         } catch (NoSuchMethodException e) {
78.             e.printStackTrace();
79.         } catch (IllegalArgumentException e1) {
80.             e1.printStackTrace();
81.         } catch (InstantiationException e1) {
82.             e1.printStackTrace();
83.         } catch (IllegalAccessException e1) {
84.             e1.printStackTrace();
85.         } catch (InvocationTargetException e1) {
86.             e1.printStackTrace();
87.         }
88.         return o;
89.     }
90. }