首页 > 代码库 > 通用财经数据传输与监控平台1.0（泛型，接口与基类，Sql,Ibatis,Awt,Swing）
通用财经数据传输与监控平台1.0（泛型，接口与基类，Sql,Ibatis,Awt,Swing）
导言
本系统通过访问url接口，实现财经数据的获取以及实时的更新到用户本地数据库的功能，并且配备了实时的数据传输的监控平台。通过本系统，用户可以的得到并保存所需的财经数据（超过200张表），并能实时的查看数据传输是否正常以及传输中的过程。
目录结构
一、相关技术总结
1、通用DAO、Service、Action的设计与实现：（VERY IMPORTMANT）
面向对象设计：接口、基类、继承；泛型
（如通用类BaseObject、接口BaseDao与实现类BaseDaoImp的设计）
2、树Tree结构的使用（树监听）、表格Table用于显示时刻刷新的数据
树目录接口的建立、监听；给单元格赋值、表格化数据的输出格式控制、自动刷新
3、使用ibatis实现对象关系映射，并控制sql语句；动态sql的生成与使用
4、部署与安装程序：打jar包注意事项、读取相对路径的XML
5、异常处理：catch与throws的使用经验
当使用了catch处理后，在更高级层就不能进行处理了;而throws不对异常进行处理，向上抛，让上级处理。
6、Json与Java对象的相互转化:Json包日期转化时的Bug的处理
二、功能描述
1、财经数据传输平台
调用url,根据动态查询条件--->获得json数组---->将其解析为对象集合（List）--->根据业务逻辑的不同，将数据插入或更新到本地数据库中，并记录必须的运行数据到数据库中--->如有数据，不断重复以上，直到更新完所有数据。
2。数据传输平台的监控平台
a.界面：可以使用可视化的桌面程序开发工具,如JFormDesigner生成主要的静态界面。
b.数据展示：通过监听获取用户的点击操作，执行相应的方法，查询到所需的数据，动态的显示在表格中并实时刷新。
三、系统架构
开发流程、系统框架、 代码的目录结构
开发流程：建立于服务器端相对应的数据库及表，并设定主键
--->生成实体类(也可选用服务器端的实体类,即导入实体类所在的jar包)
--->利用实体关系映射框架ibatis实现数据访问（撰写大量的sql）
--->设计通用的Dao接口和DaoImp基类，实现Dao组件
--->根据业务逻辑，设计通用的Service接口和SerivceImp基类，并调用Dao组件，实现Service组件
--->设计通用的Action接口和ActionImp基类，并调用Service组件，实现Action组件
--->利用工具设计桌面程序的界面
--->在监控平台中，调用Action组件并访问数据库，获得数据传输过程中的相关信息。
（--->运行Action组件中的类，实现数据传输。在监控平台中你将可以看到相应的数据。）
四、表、关系和基础类
ibatis框架下的四个配置文件：
database.properties（数据库连接所需参数）、
Object.xml（对象与表、属性与字段的映射、SQL语句）、
sql-map-config.xml（数据库连接、包含的映射文件）、
dao.xml（调用sql-map-config.xml访问数据库，并指定数据操作类与接口的的对应关系）
五、逻辑视图
六、重点难点与要点
要点：通过运用泛型，设计接口和基类，实现通用的Dao组件和Service组件。
七、收获体会
八、核心示范代码
核心提示：
8.1、设计通用接口BaseDao和baseDaoImp抽象基类，实现Dao组件；
8.2、设计通用接口BaseService和BaseServiceImp抽象基类，实现Service组件。
8.3 设计通用接口BaseAction和BaseActionImp抽象基类，实现Action组件。
//通用DAO层
8.1.1 BaseDao接口
作用：指定Dao组件所需的通用方法。
public interface BaseDao<T extends BaseObject, Q extends BaseQuery> {
8.1.2抽象类BaseDaoImp
实现接口中定义的方法；实现所有实体类所需的数据库访问方法，其他类只需要继承本类，并实现BaseDao接口，便可以有相关功能。
8.1.3 接口HKComBInfoDao:
是实体类公司基本信息类ComBInfo对应的Dao接口，用于定义数据访问操作所需要的方法。
public interface HKComBInfoDao extends BaseDao<HKComBInfo,HKComBInfoQuery>{}
8.1.4 类HKComBInfoDaoImp：
继承了基础抽象类，实现了与自身对应的特定接口。
//这样类HKComBInfoDaoImp就具有了保存、更新与查找的更能，而无需写实现代码。
//通用SERVICE层
8.2.1 接口BaseService
作用：该接口使用了泛型，它指定了业务逻辑层需要的方法。
public interface BaseService<T extends BaseDao<B, Q>, B extends BaseObject, Q extends BaseQuery> {
public String findMaxGid(T bd, B obj, String tableName);
public void saveOrUpdateGidToTable(HKGidTname hKGidTname);
public void saveOrUpdate(B obj);
public List<?> getTableObjectNew(Q bq, String param);
public Integer getUpdatedNumber();
public Integer getSavedNumber();
public Integer getErroredNumber();
}
8.2.2 抽象类BaseServiceImp
它实现了业务层的基础接口并使用了泛型，通过调用Dao组件，它实现了其他实际的业务类的所有的方法。其他业务类只需要继承它，并实现相应接口，便可以用它的所有方法。
public abstract class BaseServiceImp<T extends BaseDao<B, Q>, B extends BaseObject, Q extends BaseQuery> implements BaseService<T, B, Q> {
}
8.2.3 接口HKComBInfoService
这是一个与实体HKComBInfo类对应的业务类，它继承了业务层的基础接口，并使用了泛型。
public interface HKComBInfoService
extends BaseService<HKComBInfoDao,HKComBInfo,HKComBInfoQuery>{
}
8.2.4 类HKComBInfoServiceImp
该类具有业务层所需的所有实际方法；这个类继承了业务层的抽象类，实现了与自身对应的接口。
public class HKComBInfoServiceImp
extends BaseServiceImp<HKComBInfoDao,HKComBInfo,HKComBInfoQuery>
implements HKComBInfoService{
//通用ACTION层
8.3.1接口BaseAction
作用：该接口使用了泛型，它指定了ACTION层需要的方法名、参数列表以及返回值。
public interface BaseAction<S extends BaseService<T , B , Q>,T extends BaseDao<B, Q>,
B extends BaseObject, Q extends BaseQuery>{
public boolean startDataTranscation(S s,T t,B b,Q q) ;
}
8.3.2抽象类BaseActionImp
它实现了ACTION层的基础接口并使用了泛型，通过调用Service组件，它实现了其他实际的Action类的所有的方法。其他Action类只需要继承它，并实现相应接口，便可以用它的所有方法。
public abstract class BaseActionImp<S extends BaseService<T, B, Q>, T extends BaseDao<B, Q>,
B extends BaseObject,Q extends BaseQuery>
implements BaseAction<S, T, B, Q> { }
8.3.3接口HKBdCodeAction
public interface HKBdCodeAction extends BaseAction<
HKBdCodeService, HKBdCodeDao, HKBdCode, HKBdCodeQuery>{
}
8.3.3类HKBdCodeActionImp
这是一个与实体HKComBInfo类对应的ACTION类，它继承了ACTION层的基础接口，并使用了泛型。
public class HKBdCodeActionImp extends
BaseActionImp<HKBdCodeService, HKBdCodeDao, HKBdCode, HKBdCodeQuery>implements HKBdCodeAction2 {
public HKBdCodeAction2Imp(HKBdCodeService s, HKBdCodeDao t, HKBdCode b,
HKBdCodeQuery q) { super(s, t, b, q);}
public static void main(String[] args) {
new HKBdCodeAction2Imp(new HKBdCodeServiceImp() , new HKBdCodeDaoImp(), new HKBdCode(),
new HKBdCodeQuery());}
}
------------------------------------------------------------------------------------------
##################################以上为目录，以下为实体内容###############################
------------------------------------------------------------------------------------------
一、相关技术总结
1.5 异常处理：
当使用了catch处理后，在更高级层就不能进行处理了;而throws不对异常进行处理，向上抛，让上级处理。
如：
public void save(Object o){
try{ this.insert(o);
}catch(Exception e){e.printStackTrace();}}
public void saveAndUpdate(Object o){
try{save(o);}catch(Exception e){
update(o);
e.printStackTrace();}}
则saveAndUpdate方法将不能捕捉到save(Object o)的异常。因此应将save(Object )改为：
public void save(Object o) throws exception{
this.insert(o);}
5.2、树Tree结构的使用（树监听）、表格Table用于显示时刻刷新的数据
树目录接口的建立、监听；给单元格赋值、表格化数据的输出格式控制、自动刷新
四、表、关系和基础类
ibatis框架下的四个配置文件：
database.properties（数据库连接所需参数）、
Object.xml（对象与表、属性与字段的映射、SQL语句）、
sql-map-config.xml（数据库连接、包含的映射文件）、
dao.xml（调用sql-map-config.xml访问数据库，并指定数据操作类与接口的的对应关系）
a、database.properties
driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
url=jdbc:sqlserver://127.0.0.1:1433;DatabaseName=HKStockNew
username=sa
password =shuguang
b、Object.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<sqlMap namespace="Message">
<typeAlias alias="message" type="com.jrj.genius.api.client.entity.Message" />
<typeAlias alias="messageQuery"
type="com.jrj.genius.api.client.entity.MessageQuery" />
<resultMap id="messageResult" class="message">
<result property="tableName" column="tablename" />
<result property="interfaceName" column="interfacename" />
<result property="date" column="date" />
<result property="insertedNumber" column="insertednumber" />
<result property="updatedNumber" column="updatednumber" />
<result property="errorNumber" column="errornumber" />
<result property="isNormal" column="isnormal" />
</resultMap>
<insert id="save" parameterClass="message">
INSERT INTO HK_MESSAGE
VALUES
(#tableName#,#interfaceName#,#date#,#insertedNumber#,
#updatedNumber#,#errorNumber#,#isNormal#)
</insert>
<select id="findByTableName" parameterClass="java.lang.String"
resultClass="message">
select *
from HK_MESSAGE
where
TABLENAME=#tableName#
order by date desc
</select>
<select id="countTotalNumber" parameterClass="java.lang.String"
resultClass="message">
select
sum(insertedNumber),sum(updatedNumber),sum(errorNumber)
from HK_MESSAGE
where TABLENAME=#tableName#
</select>
</sqlMap>
c、sql-map-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd" >
<sqlMapConfig>
<properties resource="database.properties" />
<settings cacheModelsEnabled="true" enhancementEnabled="false"
maxSessions="64" maxTransactions="8" maxRequests="128"
useStatementNamespaces="true" />
<transactionManager type="JDBC">
<dataSource type="SIMPLE">
<property value="http://www.mamicode.com/${driver}" name="JDBC.Driver" />
<property value="http://www.mamicode.com/${url}" name="JDBC.ConnectionURL" />
<property value="http://www.mamicode.com/${username}" name="JDBC.Username" />
<property value="http://www.mamicode.com/${password}" name="JDBC.Password" />
</dataSource>
</transactionManager>
<sqlMap resource="HkBdCode.xml" />
<sqlMap resource="HKGidTname.xml" />
<sqlMap resource="HKMessage.xml" />
<sqlMap resource="HKIdxDMK.xml" />
<sqlMap resource="HKStkCode.xml" />
<sqlMap resource="HKStkDMK.xml" />
<sqlMap resource="HKComBInfo.xml" />
</sqlMapConfig>
d、dao.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE daoConfig
PUBLIC "-//ibatis.apache.org//DTD DAO Configuration 2.0//EN"
"http://ibatis.apache.org/dtd/dao-2.dtd" >
<daoConfig>
<context>
<transactionManager type="SQLMAP">
<property name="SqlMapConfigResource" value="http://www.mamicode.com/sql-map-config.xml" />
</transactionManager>
<dao interface="com.jrj.genius.api.client.dao.HKGidTnameDao"
implementation="com.jrj.genius.api.client.dao.HKGidTnameDaoImp" />
<dao interface="com.jrj.genius.api.client.dao.HKMessageDao"
implementation="com.jrj.genius.api.client.dao.HKMessageDaoImp" />
</context>
</daoConfig>
五、逻辑视图
六、重点难点与要点
要点：通过运用泛型，设计接口和基类，实现通用的Dao组件和Service组件。
七、收获体会
八、核心示范代码
核心提示：
8.1、计通用接口BaseDao和baseDaoImp抽象基类，实现Dao组件；
8.2、设计通用接口BaseService和BaseServiceImp抽象基类，实现Service组件。
//DAO层
//8.1.1 BaseDao接口的作用：
指定Dao组件所需的通用方法。
public interface BaseDao<T extends BaseObject, Q extends BaseQuery> {
//BaseDao<T extends BaseObject, Q extendss BaseQuery>
//保存数据
public void save(T t);
//更新数据
public void update(T t);
// 查找最大gid
public String findMaxGID();
//保存批处理中最大的gid
//public void saveMaxGID(HKGidTname hKGidTname);
//更新批处理中最大的gid
//public void updateMaxGID(HKGidTname hKGidTname);
}
//8.1.2 抽象类BaseDaoImp的作用：
实现接口中定义的方法；实现所有实体类所需的数据库访问方法，其他类只需要继承本类，并实现BaseDao接口，便可以有相关功能。
public abstract class BaseDaoImp<T extends BaseObject, Q extends BaseQuery>
implements BaseDao<T, Q> {
private static final long SQL_EXEC_TIME = 1000;
protected SqlMapClient sqlMapClient;
private Logger log = Logger.getLogger(this.getClass());
private String nameSpace;
public BaseDaoImp(String nameSpace) {
this.nameSpace = nameSpace;
sqlMapClient = SqlMapClientFactory.getSqlMapClient();
}
public void save(T t) {
sqlMapClient.insert(nameSpace + ".save", t);
}
public void update(T t) {
try {
long startTime = System.currentTimeMillis();
sqlMapClient.update(nameSpace + ".update", t);
long endTime = System.currentTimeMillis();
if (endTime - startTime > SQL_EXEC_TIME) {
log.error("Bad Sql " + nameSpace + ".update" + ","
+ "Sql Execute used " + (endTime - startTime) + " ms");
if (t != null) {
log.error("Sql Query is " + t.toString());
} else {
log.error("Sql Query is Null");
}
}
} catch (SQLException e) {
log.error(e);
}
}
public String findMaxGID() {
try {
String res = (String) sqlMapClient.queryForObject(nameSpace
+ ".findMaxGID", null);
if (res == null)
return " ";
else return res;
}
}
//8.1.3 接口HKComBInfoDao:
实体类公司基本信息类ComBInfo对应的Dao接口，用于定义数据访问操作所需要的方法。
public interface HKComBInfoDao extends BaseDao<HKComBInfo,HKComBInfoQuery>{
}
//8.1.4 类HKComBInfoDaoImp：
继承了基础抽象类，实现了与自身对应的特定接口。
//这样类HKComBInfoDaoImp就具有了保存、更新与查找的更能，而无需写实现代码。
public class HKComBInfoDaoImp extends BaseDaoImp<HKComBInfo,HKComBInfoQuery> implements HKComBInfoDao {
public HKComBInfoDaoImp(String nameSpace) {
super(nameSpace);
}
public HKComBInfoDaoImp( ) {
super("HKComBInfo");
}
}
//SERVICE层
8.2.1 接口BaseService
作用：该接口使用了泛型，它指定了业务逻辑层需要的方法。
public interface BaseService<T extends BaseDao<B, Q>, B extends BaseObject, Q extends BaseQuery> {
public String findMaxGid(T bd, B obj, String tableName);
public void saveOrUpdateGidToTable(HKGidTname hKGidTname);
public void saveOrUpdate(B obj);
public List<?> getTableObjectNew(Q bq, String param);
public Integer getUpdatedNumber();
public Integer getSavedNumber();
public Integer getErroredNumber();
}
8.2.2 抽象类BaseServiceImp
它实现了业务层的基础接口并使用了泛型，通过调用Dao组件，它实现了其他实际的业务类的所有的方法。其他业务类只需要继承它，并实现相应接口，便可以用它的所有方法。
作用：根据实际的业务需要，通过调用Dao组件，实现Service组件的功能。
public abstract class BaseServiceImp<T extends BaseDao<B, Q>, B extends BaseObject, Q extends BaseQuery> implements BaseService<T, B, Q> {
private int runTimes = 1;
private Logger log = Logger.getLogger(this.getClass());
private T t;
private HKGidTnameDao tGeniusDao;
private Integer updatedNumber = 0;
private Integer savedNumber = 0;
private Integer erroredNumber = 0;
private String max_genius_uid = " ";
// 1 find max gid.
@SuppressWarnings("unchecked")
public String findMaxGid(T bd, B obj, String tableName) {
t = (T) ProviderManager.getDao("genius", obj.getClass().getSimpleName()
+ "Dao");
// T tGeniusDao = (T) ProviderManager.getDao("genius",
// "HKGidTnameDaoImp");
DaoManager daoManager = null;
Reader reader = null;
try {
reader = new FileReader(
"E:\\work\\workSpace\\datamart-demo2\\src\\main\\resources/dao.xml");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
daoManager = DaoManagerBuilder.buildDaoManager(reader);
// System.out.println("reader: "+reader +"daoManager: "+daoManager);
tGeniusDao = (HKGidTnameDao) daoManager.getDao(HKGidTnameDao.class);
max_genius_uid = tGeniusDao.findMaxGID(tableName);
runTimes++;
return max_genius_uid;
}
// 2 set query parameter, before search.
// public void SetQueryGid(BaseQuery query) {
// query.setGenius_uid(max_genius_uid);
// }
// get object list from json array.
public List<?> getTableObjectNew(Q bq, String param) {
return GetTableObjectUtil.getTableObject(bq, param);
}
// 4 save or update object into database.
public void saveOrUpdate(B obj) {
try {
t.save(obj);
savedNumber++;
log.info("records saved: " + savedNumber);
} catch (Exception e1) {
try {
t.update(obj);
updatedNumber++;
log.info("recrods updated: " + updatedNumber);
} catch (Exception e2) {
erroredNumber++;
log.error("save or update error. +Entity info: " + obj);
e2.printStackTrace();
}
}
}
// 5 save or update max_Gid to the table(HK_GIDTNAME).
public void saveOrUpdateGidToTable(HKGidTname hKGidTname) {
try {
tGeniusDao.saveMaxGID(hKGidTname);
} catch (Exception exc) {
tGeniusDao.update(hKGidTname);
// exc.printStackTrace();
}
}
8.2.3 接口HKComBInfoService
这是一个与实体HKComBInfo类对应的业务类，它继承了业务层的基础接口，并使用了泛型。
public interface HKComBInfoService
extends BaseService<HKComBInfoDao,HKComBInfo,HKComBInfoQuery>{
}
8.2.4 类HKComBInfoServiceImp
该类具有业务层所需的所有实际方法；这个类继承了业务层的抽象类，实现了与自身对应的接口。
public class HKComBInfoServiceImp
extends BaseServiceImp<HKComBInfoDao,HKComBInfo,HKComBInfoQuery>
implements HKComBInfoService{
}
//通用ACTION层
8.3.1接口BaseAction
作用：该接口使用了泛型，它指定了ACTION层需要的方法名、参数列表以及返回值。
public interface BaseAction<S extends BaseService<T , B , Q>,T extends BaseDao<B, Q>,
B extends BaseObject, Q extends BaseQuery>{
public boolean startDataTranscation(S s,T t,B b,Q q) ;
}
8.3.2抽象类BaseActionImp
它实现了ACTION层的基础接口并使用了泛型，通过调用Service组件，它实现了其他实际的Action类的所有的方法。其他Action类只需要继承它，并实现相应接口，便可以用它的所有方法。
//抽象类，定义了业务流程。
//当具体的类继承该抽象类后，便能完成对特定API的数据调用以及更新数据到用户数据库。
public abstract class BaseActionImp<S extends BaseService<T, B, Q>,
T extends BaseDao<B, Q>,
B extends BaseObject,
Q extends BaseQuery>
implements BaseAction<S, T, B, Q> {
private static int EACH_TIME_RECORDS = 100;
int runTime = 0;
String max_genius_uid = " ";
String tb = null;
Map<String, String> LinkTableNamemap = new HashMap<String, String>();
boolean flag = true;
//构造方法，有数据的话，循环查询，得到去完所有数据
public BaseActionImp(S s, T t, B b, Q q) {
boolean myflag = true;
long start = new Date().getTime();
for (;;) {
myflag = startDataTranscation(s, t, b, q);
if (myflag == false) {
long end = new Date().getTime();
System.out.println("time spent: " + (end - start));
return;
}
}
}
//根据业务逻辑和流程循环查询数据，更新到用户数据库。
@SuppressWarnings("unchecked")
public boolean startDataTranscation(S s, T t, B b, Q q) {
// 在这里先调用配置文件得到路径(link)和表名（tb）
LinkTableNamemap = gainLinkAndTableName(b);
tb = LinkTableNamemap.get("link.hk." + b.getClass().getSimpleName());
// 1 find max gid.
// if max_genius_uid==" ",stand for no data transaction records.
// don‘t set max_genius_uid in query.
// otherwise,set this max_genius_uid in query.
// 2 set gid & size in query.
// 如果最大gid不为空，说明程序不是第一次运行，设置以该gid为起始查询时间。
max_genius_uid = s.findMaxGid(t, b, tb);// 1
if (!" ".equals(max_genius_uid)) {
q.setGenius_uid(max_genius_uid);// 2
// 如果是第一次运行
} else {
// q.setOrder(desc);//还未实现
// q.setSortfield(genius_uid);
}
q.setRecordsize(EACH_TIME_RECORDS);
// 3 get list of object
List<B> al = (List<B>) GetTableObjectUtil.getTableObject(q,
LinkTableNamemap.get("link.hk."+ b.getClass().getSimpleName()));
if (al == null || al.size() == 0) {
return false;
}
System.out.println("接口 " + b.getClass().getName() + ",查询到的记录数: "
+ al.size() + "这批数据的第一条： " + al.get(0) + "===getSeq"
+ al.get(0).getSeq());
// get max_genius_uid of this list,so later can save it to table of
if (al.size() >= 1) {
max_genius_uid = al.get(0).getGenius_uid();
}
// 4 save or update objects into database,
// and get insert update error number.
for (int i = 0; i < al.size(); i++) {
try {
s.saveOrUpdate((B) al.get(i));
} catch (Exception ee) {
}
}
// 5 write inserted updated errorNumber into table of HK_MESSAGE.
Message message = new Message();
message.setDate(new Date().getTime());
message.setInterfaceName(b.getClass().getSimpleName());
if (s.getErroredNumber() > 0) {
message.setIsNormal("n");
} else {
message.setIsNormal("y");
}
HKMessageDao daomsg = new HKMessageDaoImp();
if ((message.getErrorNumber() + message.getInsertedNumber() + message
.getUpdatedNumber()) > 1) {
message.setTableName(tb);
message.setUpdatedNumber(s.getUpdatedNumber());
daomsg.save(message);
}
// 6 save or update max gid into table HK_GIDTNAME.
if (!" ".equals(max_genius_uid)) {
HKGidTname hKGidTname = new HKGidTname();
hKGidTname.setGenius_uid(max_genius_uid);
if (al.size() < 100) {
// 0 stand for no records.
hKGidTname.setHasmore(0);
} else {
hKGidTname.setHasmore(1);
}
hKGidTname.setTable_name(tb);
s.saveOrUpdateGidToTable(hKGidTname);
}
System.out.println("-----------------------------" + runTime);
runTime++;
return flag;
}
//调用配置文件，通过实体名取得URL以及对应得表名
public Map<String, String> gainLinkAndTableName(B b) {
String link, tb;
Map<String, String> map = new HashMap<String, String>();
// ---------------------------
Properties p = new Properties();
InputStream inputFile;
File file = new File("src\\main\\resources", "link.properties");
try {
inputFile = new FileInputStream(file.getAbsoluteFile());
try {
p.load(inputFile);
inputFile.close();
System.out.println("b.getClass().getName(): "
+ b.getClass().getSimpleName());
link = p.getProperty("link.hk." + b.getClass().getSimpleName());
map.put("link.hk." + b.getClass().getSimpleName(), link);
tb = p.getProperty("tb.hk." + b.getClass().getSimpleName());
map.put("tb.hk." + b.getClass().getSimpleName(), tb);
System.out.println("link: "
+ map.get("link.hk." + b.getClass().getSimpleName())
+ " ;table name: "
+ map.get("link.hk." + b.getClass().getSimpleName()));
return map;
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return map;
}
}
8.3.3接口HKBdCodeAction
public interface HKBdCodeAction extends BaseAction<
HKBdCodeService, HKBdCodeDao, HKBdCode, HKBdCodeQuery>{
}
8.3.3类HKBdCodeActionImp
这是一个与实体HKComBInfo类对应的ACTION类，它继承了ACTION层的基础接口，并使用了泛型。
public class HKBdCodeActionImp extends
BaseActionImp<HKBdCodeService, HKBdCodeDao, HKBdCode, HKBdCodeQuery>implements HKBdCodeAction2 {
public HKBdCodeAction2Imp(HKBdCodeService s, HKBdCodeDao t, HKBdCode b,
HKBdCodeQuery q) { super(s, t, b, q);}
public static void main(String[] args) {
new HKBdCodeAction2Imp(new HKBdCodeServiceImp() , new HKBdCodeDaoImp(), new HKBdCode(),
new HKBdCodeQuery());}
}
通用财经数据传输与监控平台1.0（泛型，接口与基类，Sql,Ibatis,Awt,Swing）