一种B/S模式下基于JAVA反射机制的可伸缩动态加载模块的解决方案

源代码下载（Jcreator工程）

 

项目需求：

项目主体采用B/S架构，在逻辑层需要用到不同形式的数据（分别可能从数据库或者配置文件进行读取所需数据），进而进行数据的业务计算，得出结果。

实际项目中，模型的设计是不同的部门或者单位进行设计，但是主运行框架，现设计一试用方案如下：

 

其中详细的模块说明已经给予注释，测试框架列表如下：

该设计中涉及到三个接口，分别为：ICalculateModule，IDataProvider，IModuleValid；

CalculateModule：负责进行整个嵌入模块的计算任务，定义了计算函数等；

IDataProvider：接口定义计算模块所需数据的提供方式；

IModuleValid：提供相关的校验工作，例如模块有效性校验，规范性校验，数据校验等等；

接口定义代码如下：

接口ICalculateModule 

 

/**
 * @(#)ICalculateModule.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/24
  */
package com.hw.wm.calculate;

public  interface ICalculateModule {
     int getResult();
}

 

接口IDataProvider

 

/**
 * @(#)IDataProvider.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/24
  */
package com.hw.wm.data;

public  interface IDataProvider {
     int getDataA();
    
     int getDataB();
    
}

 

 

抽象类ACalculateModule： 

 

/**
 * @(#)ACalculateModule.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/24
  */
package com.hw.wm.calculate;

import com.hw.wm.data.*;

public  abstract  class ACalculateModule  implements ICalculateModule{

     public ACalculateModule() {
    }
    
     public ADataProvider adp= null;
    
}

 

抽象计算模块的工厂生产类：

 

/**
 * @(#)CalModuleInstanceFactory.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/24
  */

package com.hw.wm.factory;

import com.hw.wm.calculate.*;

public  class CalModuleInstanceFactory {

     public CalModuleInstanceFactory() {
    }
    
     public  static ACalculateModule getModuleForName(String mName)
    {
        ACalculateModule obj= null;
         try
        {
            Class cls = Class.forName(mName);
            System.out.println("load the target class");
            obj=(ACalculateModule)cls.newInstance();
             /*
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod("add", partypes);
            System.out.println("get method of the class");
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
             */
             // object retobj = meth.invoke(methobj, arglist);
             // Object retobj = meth.Invoke(cls.newinstance(null), arglist);
             // Integer retval = (Integer)retobj;
             // System.out.println(retval.intValue());
        }
         catch(Exception e)
        {
            System.err.println(e);
        }
         return obj;
    }
}

 

 

 

 抽象类ADataProvider

 

/**
 * @(#)ADataProvider.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/24
  */

package com.hw.wm.data;

abstract  public  class ADataProvider  implements IDataProvider{

     public ADataProvider() {
    }
}

 

数据提供者工厂类：

 

/**
 * @(#)DataProviderFactory.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/24
  */

package com.hw.wm.data.factory;
import com.hw.wm.data.*;

public  class DataProviderFactory {

     public DataProviderFactory() {
    }
    
     public  static ADataProvider getInstance(DataProviderType dpt)
    {
         try
        {
             if(dpt==DataProviderType.CONSTVAR)
            {
                 return  new DpForConst();
            }
        }
         catch(Exception e)
        {
            System.err.println((e.toString()));
        }
         return  null;
    }
    
}

 

 

承包方需要继承抽象类ACalculateModule，并overload getResult()函数；

 

/**
 * @(#)ModuleA.java
 *
 *
 *  @author  
 *  @version  1.00 2011/10/24
  */

package com.hw.wm.module;
import com.hw.wm.calculate.*;
public  class ModuleA  extends ACalculateModule{
    
     public  int getResult()
    {
        System.out.println("************moduleA is running~*****************");
         return  this.add(adp.getDataA(),adp.getDataB());
    }
    
     public  int add( int a, int b)
    {
         return a+b;
    }
    
}

 

 

 

实际主测试方法：

 

/**
 * @(#)getReflection.java
 *
 *
 *  @author  wm is wei&mei
 *  @version  1.00 2011/10/23
  */

package com.hw.wm.TestCase;

import java.lang.reflect.*;
import com.hw.wm.calculate.*;
import com.hw.wm.factory.*;
import com.hw.wm.data.factory.*;
import com.hw.wm.data.*;
import java.util.Scanner;

public  class getReflection {

     public getReflection() {
    }
    
     public  static  void main(String[] args)
    {
        System.out.println("Please intput the moduleID to calculate:\n1.com.hw.wm.module.ModuleA\n2.com.hw.wm.module.ModuleB\n3.com.hw.wm.module.ModuleC");
        Scanner scanner =  new Scanner(System.in);
         int inID=scanner.nextInt();
        ACalculateModule acm= null;
         switch(inID)
        {
             case 1:
                acm=CalModuleInstanceFactory.getModuleForName("com.hw.wm.module.ModuleA"); // 通过代理工厂进行生产数据库中注册的模块
                 break;
             case 2:
                acm=CalModuleInstanceFactory.getModuleForName("com.hw.wm.module.ModuleB"); // 通过代理工厂进行生产数据库中注册的模块
                 break;
             case 3:
                acm=CalModuleInstanceFactory.getModuleForName("com.hw.wm.module.ModuleC"); // 通过代理工厂进行生产数据库中注册的模块
                 break;
        }
         // ACalculateModule acm=CalModuleInstanceFactory.getModuleForName("com.hw.wm.module.ModuleC"); // 通过代理工厂进行生产数据库中注册的模块
         // System.out.println("acm.getResult()");
        acm.adp=DataProviderFactory.getInstance(DataProviderType.CONSTVAR); // 通过工厂提供一个数据的提供者
                                                                            // 数据抽象到上层，方便框架进行重定向
                                                                            // 若在模型中选择，则不符合项目中承包方的需要
         if(acm!= null)
        {
            System.out.println(acm.getResult()); // 调用工厂后的模块，进行计算
        }
         else
        {
            System.out.println("acm is NULL"); // 工厂生产失败
        }
    }
}

 

其中ACaculateModule实现了ICalculateModule接口，其创建过程是通过工厂模型进行创建；其为一个抽象类；

其中数据提供类也是同样方式进行实现；

具体的模型计算模块需要实现ACaculateModule抽象类，抽象类中组合了数据提供类的实例，需要的数据可以直接通过抽象类指针ADataProvider*直接进行读取；

同时具体的计算模块中需要重载getResult方法；