导入,适配开发

src/main/java/com/yihu/hos/standard/match/dictionary/DictItemStrategyExecute.java

@@ -0,0 +1,106 @@
package com.yihu.hos.standard.match.dictionary;
import com.yihu.hos.standard.dao.IStdDictionaryModelDao;
import com.yihu.hos.standard.dao.StdDictionaryEntryModelDao;
import com.yihu.hos.standard.match.matchModel.DictItemMatchVO;
import com.yihu.hos.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.hos.standard.service.adapter.AdapterDictEntryService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/6/24.
 * 字典项匹配器
 */
public class DictItemStrategyExecute implements Runnable {
    public static Map<String, List<Integer>> size = new HashMap<String, List<Integer>>();
    private DictItemMatchVO matchVO;
    private DictitemStandardExistStrategy standardExistStrategy;
    private AdapterDictEntryModel adapterDictEntryModel;
    private String adapter_std_version;
    private String version;
    private IStdDictionaryModelDao stdDictionaryDao;
    private StdDictionaryEntryModelDao stdDictionaryEntryDao;
    private AdapterDictEntryService adapterDictEntryService;
    public DictItemStrategyExecute(
            AdapterDictEntryModel adapterDictEntryModel,
            DictItemMatchVO matchVO,
            String adapter_std_version,
            String version,
            IStdDictionaryModelDao stdDictionaryDao,
                    StdDictionaryEntryModelDao stdDictionaryEntryDao,
                    AdapterDictEntryService adapterDictEntryService) {
        this.adapterDictEntryModel = adapterDictEntryModel;
        this.matchVO = matchVO;
        this.adapter_std_version = adapter_std_version;
        this.version = version;
        standardExistStrategy = new DictitemStandardExistStrategy();
        standardExistStrategy.setStdDictionaryDao(stdDictionaryDao);
        standardExistStrategy.setStdDictionaryEntryDao(stdDictionaryEntryDao);
        standardExistStrategy.setAdapterDictEntryService(adapterDictEntryService);
    }
    public static void setVersionYes(String version) {
        List<Integer> sizeList = new ArrayList<Integer>();
        size.put(version, sizeList);
    }
    @Override
    public void run() {
        try {
            if (matchVO != null) {
                if (standardExistStrategy.match(adapterDictEntryModel, matchVO,adapter_std_version, version)) {
                    updateAdapt(version);
                    return;
                }
            }
            updateAdapt(version);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Map<String, List<Integer>> getSize() {
        return size;
    }
    public synchronized static void updateAdapt(String version) {
        List<Integer> sizeList = size.get(version);
        sizeList.add(1, sizeList.get(1) + 1);
        System.out.println("更新匹配数目:" + sizeList.get(0) + "/" + (sizeList.get(1)));
    }
    public synchronized static void setFirst(String version, Integer allCount) {
        List<Integer> sizeList = new ArrayList<Integer>();
        sizeList.add(0, allCount);
        sizeList.add(1, 0);
        size.put(version, sizeList);
    }
    public synchronized static void removeAdapt(String version) {
        size.remove(version);
    }
    public synchronized static boolean isAdapt(String version) {
        if (size.get(version) == null) {
            return false;
        } else {
            return true;
        }
    }
    public synchronized static Map getAllNumAndAdaptNum(String version) {
        Map<String, Integer> adapt = new HashMap<String, Integer>();
        List<Integer> list = size.get(version);
        if(list!=null){
            adapt.put("all", list.get(0));
            adapt.put("adapt", list.get(1));
        }
        return adapt;
    }
}

src/main/java/com/yihu/hos/standard/match/dictionary/DictitemStandardExistStrategy.java

@@ -0,0 +1,94 @@
package com.yihu.hos.standard.match.dictionary;
import com.yihu.hos.standard.dao.IStdDictionaryModelDao;
import com.yihu.hos.standard.dao.StdDictionaryEntryModelDao;
import com.yihu.hos.standard.match.matchModel.DictItemMatchVO;
import com.yihu.hos.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.hos.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.hos.standard.model.standard.StdDictionaryModel;
import com.yihu.hos.standard.service.adapter.AdapterDictEntryService;
import com.yihu.hos.standard.util.GetChineseFirst;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
 * Created by Administrator on 2016/6/24.
 */
@Scope("prototype")
@Component("dictitemStandardExistStrategy")
public class DictitemStandardExistStrategy {
    private IStdDictionaryModelDao stdDictionaryDao;
    private StdDictionaryEntryModelDao stdDictionaryEntryDao;
    private AdapterDictEntryService adapterDictEntryService;
    public DictitemStandardExistStrategy(IStdDictionaryModelDao stdDictionaryDao, StdDictionaryEntryModelDao stdDictionaryEntryDao, AdapterDictEntryService adapterDictEntryService) {
        this.stdDictionaryDao = stdDictionaryDao;
        this.stdDictionaryEntryDao = stdDictionaryEntryDao;
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public IStdDictionaryModelDao getStdDictionaryDao() {
        return stdDictionaryDao;
    }
    public void setStdDictionaryDao(IStdDictionaryModelDao stdDictionaryDao) {
        this.stdDictionaryDao = stdDictionaryDao;
    }
    public StdDictionaryEntryModelDao getStdDictionaryEntryDao() {
        return stdDictionaryEntryDao;
    }
    public void setStdDictionaryEntryDao(StdDictionaryEntryModelDao stdDictionaryEntryDao) {
        this.stdDictionaryEntryDao = stdDictionaryEntryDao;
    }
    public AdapterDictEntryService getAdapterDictEntryService() {
        return adapterDictEntryService;
    }
    public void setAdapterDictEntryService(AdapterDictEntryService adapterDictEntryService) {
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public DictitemStandardExistStrategy() {
    }
    @Transactional
    public boolean match(AdapterDictEntryModel adapterDictEntryModel, DictItemMatchVO matchVO, String adapter_std_version,String version) throws Exception {
        boolean flag = false;
        String dictitemNameFirstCode = GetChineseFirst.cn2py(adapterDictEntryModel.getStdEntryValue());//待匹配
        List<AdapterDictEntryModel> matchList = matchVO.getCodeAdapter().get(dictitemNameFirstCode);//已存在
        if (matchList != null && matchList.size() > 0) {
            Integer unAdaptDicId = adapterDictEntryModel.getStdDictId();
            StdDictionaryModel stdDictionaryModel = stdDictionaryDao.getDictionaryName(adapter_std_version,unAdaptDicId);
            String orgName = stdDictionaryModel.getName();
            for (AdapterDictEntryModel adapterDictEntry : matchList) {
                if(adapterDictEntry.getStdEntryValue().contains(adapterDictEntryModel.getStdEntryValue())){
                    String orgDicEntryValue= adapterDictEntry.getAdapterEntryValue();
                    //根据值查找出 该项目下面的字典项
                    List<StdDictionaryEntryModel> dictionaryEntryTemps = stdDictionaryEntryDao.getDictionaryEntry(adapter_std_version,orgDicEntryValue,orgName);
                    if(dictionaryEntryTemps!=null&&dictionaryEntryTemps.size()>0){
                        String adapterInfo = "1";//查找到就默认疑似适配
                        if(dictionaryEntryTemps.size()==1){//查找到的条数为1,则为完全适配
                            adapterInfo = "2";
                        }
                        StdDictionaryEntryModel stdDictionaryEntryModel = dictionaryEntryTemps.get(0);
                        //保存适配
                        adapterDictEntryService.saveAdapt(adapterDictEntryModel, stdDictionaryEntryModel, version,adapterInfo);
                        flag=true;
                        break;
                    }
                }
            }
        }
        return flag;
    }
}

src/main/java/com/yihu/hos/standard/match/matchModel/DictItemMatchVO.java

@@ -0,0 +1,46 @@
package com.yihu.hos.standard.match.matchModel;
import com.yihu.hos.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.hos.standard.util.GetChineseFirst;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/6/29.
 */
public class DictItemMatchVO {
   private Map<String, List<AdapterDictEntryModel>> codeAdapter = new HashMap<String, List<AdapterDictEntryModel>>();
    public Map<String, List<AdapterDictEntryModel>> getCodeAdapter() {
        return codeAdapter;
    }
    public void setCodeAdapter(Map<String, List<AdapterDictEntryModel>> codeAdapter) {
        this.codeAdapter = codeAdapter;
    }
    /**
     * 根据name的首字母分组
     * @param stdeAdapterDictitems
     * @return
     */
    public Map<String, List<AdapterDictEntryModel>> geNameGroup(List<AdapterDictEntryModel> stdeAdapterDictitems) {
        Map<String, List<AdapterDictEntryModel>> returnMap = new HashMap<String, List<AdapterDictEntryModel>>();
        for (AdapterDictEntryModel stdeAdapterDictitem : stdeAdapterDictitems) {
            String firstCode= GetChineseFirst.cn2py(stdeAdapterDictitem.getStdEntryValue());
            List<AdapterDictEntryModel> temp=returnMap.get(firstCode);
            if(temp!=null){
                temp.add(stdeAdapterDictitem);
            }else{
                temp=new ArrayList<AdapterDictEntryModel>();
                temp.add(stdeAdapterDictitem);
            }
            returnMap.put(firstCode,temp);
        }
        return returnMap;
    }
}

src/main/java/com/yihu/hos/standard/match/matchModel/MetadataMatchVO.java

@@ -0,0 +1,57 @@
package com.yihu.hos.standard.match.matchModel;
import com.yihu.hos.standard.model.adapter.AdapterMetadataModel;
import com.yihu.hos.standard.model.standard.StdMetaDataModel;
import com.yihu.hos.standard.util.GetChineseFirst;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/6/29.
 */
public class MetadataMatchVO {
    private Map<String, List<AdapterMetadataModel>> codeAdapter = new HashMap<String, List<AdapterMetadataModel>>();
    private Map<String, StdMetaDataModel> orgMetadata = new HashMap<String, StdMetaDataModel>();
    public Map<String, List<AdapterMetadataModel>> getCodeAdapter() {
        return codeAdapter;
    }
    public void setCodeAdapter(Map<String, List<AdapterMetadataModel>> codeAdapter) {
        this.codeAdapter = codeAdapter;
    }
    /**
     * 根据name的首字母分组
     *
     * @param stdeAdapterMetadatas
     * @return
     */
    public Map<String, List<AdapterMetadataModel>> geNameGroup(List<AdapterMetadataModel> stdeAdapterMetadatas) {
        Map<String, List<AdapterMetadataModel>> returnMap = new HashMap<String, List<AdapterMetadataModel>>();
        for (AdapterMetadataModel stdeAdapterMetadata : stdeAdapterMetadatas) {
            String firstCode = GetChineseFirst.cn2py(stdeAdapterMetadata.getStdMetadataName());
            List<AdapterMetadataModel> temp = returnMap.get(firstCode);
            if (temp != null) {
                temp.add(stdeAdapterMetadata);
            } else {
                temp = new ArrayList<AdapterMetadataModel>();
                temp.add(stdeAdapterMetadata);
            }
            returnMap.put(firstCode, temp);
        }
        return returnMap;
    }
    public Map<String, StdMetaDataModel> getOrgMetadata() {
        return orgMetadata;
    }
    public void setOrgMetadata(Map<String, StdMetaDataModel> orgMetadata) {
        this.orgMetadata = orgMetadata;
    }
}

src/main/java/com/yihu/hos/standard/match/metadata/MetadataStrategyExecute.java

@@ -0,0 +1,109 @@
package com.yihu.hos.standard.match.metadata;
import com.yihu.hos.standard.dao.IStdDataSetModelDao;
import com.yihu.hos.standard.dao.IStdMetaDataModelDao;
import com.yihu.hos.standard.match.matchModel.MetadataMatchVO;
import com.yihu.hos.standard.model.adapter.AdapterMetadataModel;
import com.yihu.hos.standard.service.adapter.AdapterMetadataService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/5/18.
 * 数据元匹配执行器
 */
public class MetadataStrategyExecute implements Runnable {
    private AdapterMetadataModel metadata;
    private MetadataMatchVO matchVO;
    public static Map<String, List<Integer>> size = new HashMap<String, List<Integer>>();
    private String adapter_std_version;
    private String version;
    private MetatdataStandardExistStrategy standardExistStrategy;
    private AdapterMetadataService adapterMetadataService;
    public MetadataStrategyExecute(
            AdapterMetadataModel metadata,
            MetadataMatchVO matchVO,
            String adapter_std_version,
            String version,
            IStdMetaDataModelDao stdMetaDataModelDao,
            IStdDataSetModelDao stdDataSetModelDao,
            AdapterMetadataService adapterMetadataService) {
        this.metadata = metadata;
        this.matchVO = matchVO;
        this.adapter_std_version = adapter_std_version;
        this.version = version;
        this.adapterMetadataService = adapterMetadataService;
        //项目之间学习适配
        standardExistStrategy = new MetatdataStandardExistStrategy();
        standardExistStrategy.setStdMetaDataModelDao(stdMetaDataModelDao);
        standardExistStrategy.setAdapterMetadataService(adapterMetadataService);
        standardExistStrategy.setStdDataSetModelDao(stdDataSetModelDao);
    }
    @Override
    public void run() {
        try {
            if (matchVO != null) {
                //项目间学习
                if (standardExistStrategy.match(metadata, matchVO,adapter_std_version, version)) {
                    updateAdapt(version);
                    return;
                }
            }
            updateAdapt(version);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Map<String, List<Integer>> getSize() {
        return size;
    }
    public synchronized static void updateAdapt(String version) {
        List<Integer> sizeList = size.get(version);
        sizeList.add(1, sizeList.get(1) + 1);
    }
    public synchronized static void setFirst(String version, Integer allCount) {
        List<Integer> sizeList = new ArrayList<Integer>();
        sizeList.add(0, allCount);
        sizeList.add(1, 0);
        size.put(version, sizeList);
    }
    public synchronized static void setVersionYes(String version) {
        List<Integer> sizeList = new ArrayList<Integer>();
        size.put(version, sizeList);
    }
    public synchronized static void removeAdapt(String version) {
        size.remove(version);
    }
    public synchronized static boolean isAdapt(String version) {
        if (size.get(version) == null) {
            return false;
        } else {
            return true;
        }
    }
    public synchronized static Map getAllNumAndAdaptNum(String version) {
        Map<String, Integer> adapt = new HashMap<String, Integer>();
        List<Integer> list = size.get(version);
        if(list!=null){
            adapt.put("all", list.get(0));
            adapt.put("adapt", list.get(1));
        }
        return adapt;
    }
}

src/main/java/com/yihu/hos/standard/match/metadata/MetatdataStandardExistStrategy.java

@@ -0,0 +1,99 @@
package com.yihu.hos.standard.match.metadata;
import com.yihu.hos.standard.dao.IStdDataSetModelDao;
import com.yihu.hos.standard.dao.IStdMetaDataModelDao;
import com.yihu.hos.standard.match.matchModel.MetadataMatchVO;
import com.yihu.hos.standard.model.adapter.AdapterMetadataModel;
import com.yihu.hos.standard.model.standard.StdDataSetModel;
import com.yihu.hos.standard.model.standard.StdMetaDataModel;
import com.yihu.hos.standard.service.adapter.AdapterMetadataService;
import com.yihu.hos.standard.util.GetChineseFirst;
import com.yihu.hos.web.framework.dao.SQLGeneralDAO;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
 * Created by Administrator on 2016/5/16.
 * 对已经存在的匹配
 */
@Scope("prototype")
@Component("metatdataStandardExistStrategy")
public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
    private IStdMetaDataModelDao stdMetaDataModelDao;
    private AdapterMetadataService adapterMetadataService;
    private IStdDataSetModelDao stdDataSetModelDao;
    public MetatdataStandardExistStrategy(IStdMetaDataModelDao stdMetaDataModelDao){
       this.stdMetaDataModelDao = stdMetaDataModelDao;
   }
    public IStdMetaDataModelDao getStdMetaDataModelDao() {
        return stdMetaDataModelDao;
    }
    public void setStdMetaDataModelDao(IStdMetaDataModelDao stdMetaDataModelDao) {
        this.stdMetaDataModelDao = stdMetaDataModelDao;
    }
    public AdapterMetadataService getAdapterMetadataService() {
        return adapterMetadataService;
    }
    public void setAdapterMetadataService(AdapterMetadataService adapterMetadataService) {
        this.adapterMetadataService = adapterMetadataService;
    }
    public IStdDataSetModelDao getStdDataSetModelDao() {
        return stdDataSetModelDao;
    }
    public void setStdDataSetModelDao(IStdDataSetModelDao stdDataSetModelDao) {
        this.stdDataSetModelDao = stdDataSetModelDao;
    }
    public MetatdataStandardExistStrategy() {
    }
    /**
     * 对传进来的StdeMetadata进行匹配
     *
     * @param strategyMetadata
     * @param matchVO
     * @return
     * @throws Exception
     */
    @Transactional
    public boolean match(AdapterMetadataModel strategyMetadata,MetadataMatchVO matchVO, String adapter_std_version,String version ) throws Exception {
        boolean flag = false;
        String metadataNameFirstCode= GetChineseFirst.cn2py(strategyMetadata.getStdMetadataName());//待匹配
        List<AdapterMetadataModel> adapterMetadatas=matchVO.getCodeAdapter().get(metadataNameFirstCode);//已存在
        if(adapterMetadatas!=null&&adapterMetadatas.size()>0){
            //获取待适配的数据集名
            Integer unAdaptDatasetId = strategyMetadata.getStdDatasetId();
            StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(adapter_std_version, unAdaptDatasetId);
            String stdDatasetName = stdDataset.getName();
            for (AdapterMetadataModel stdeMetadataTemp : adapterMetadatas) {
                //利用名字來匹配
                if(stdeMetadataTemp.getStdMetadataName().contains(strategyMetadata.getStdMetadataName())){
                    String orgMetadataName= stdeMetadataTemp.getAdapterMetadataName();
                    //根据名字查找出 该项目下面的数据元名称
                    List<StdMetaDataModel> metadataTemps = stdMetaDataModelDao.getMetadata(adapter_std_version,orgMetadataName,stdDatasetName);
                    if(metadataTemps!=null&&metadataTemps.size()>0){
                        String adapterInfo = "1";//找到默认为疑似适配
                        if(metadataTemps.size()==1){//找到条数为1,默认为完全适配
                            adapterInfo="2";
                        }
                        StdMetaDataModel orgMetadata=metadataTemps.get(0);
                        //保存适配
                        adapterMetadataService.saveAdapt(strategyMetadata, orgMetadata, version,adapterInfo);
                        flag=true;
                        break;
                    }
                }
            }
        }
        return flag;
    }
}