通用财经数据传输与监控平台1.0（泛型，接口与基类，Sql,Ibatis,Awt,Swing）

Posted 2020-09-29 空余恨

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了通用财经数据传输与监控平台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="${driver}" name="JDBC.Driver" />
   <property value="${url}" name="JDBC.ConnectionURL" />
   <property value="${username}" name="JDBC.Username" />
   <property value="${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="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

作用：该接口使用了泛型，它指定了业务逻辑层需要的方法。

8.2.2 抽象类BaseServiceImp

作用：根据实际的业务需要，通过调用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

//抽象类，定义了业务流程。
//当具体的类继承该抽象类后，便能完成对特定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;