一种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方法；