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