diff --git a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.java b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.java
index c688fc0fad080ba45e65c1ae02bb5245f35e7619..c3058c332dc4b49a41d1a3220256a40e37d43a64 100644
--- a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.java
+++ b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.java
@@ -50,6 +50,8 @@ public interface AttrMapper extends IAttrCrossoverMapper {
 
     List<AttrVo> getAttrByCiId(Long ciId);
 
+    List<AttrVo> getAttrBaseInfoByCiId(Long ciId);
+
 
     int checkAttrNameIsRepeat(AttrVo attrVo);
 
diff --git a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.xml b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.xml
index a8e77001fa8d868d90a673e55f1fd54777f0b612..7e3295895e1021161f2f82ccdbc9941eb6a3cf45 100644
--- a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.xml
+++ b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/AttrMapper.xml
@@ -263,6 +263,29 @@
         id<!-- 按照视图设置的排序 -->
     </select>
 
+    <select id="getAttrBaseInfoByCiId" parameterType="java.lang.Long" resultType="neatlogic.framework.cmdb.dto.ci.AttrVo"
+            useCache="true">
+        SELECT
+            `id`,
+            `ci_id` AS ciId,
+            `type`,
+            `prop_id` AS propId,
+            `target_ci_id` AS targetCiId,
+            `expression`,
+            `name`,
+            `label`,
+            `description`,
+            `validator_id` AS validatorId,
+            `is_required` AS isRequired,
+            `is_unique` AS isUnique,
+            `input_type` AS inputType,
+            `group_name` AS groupName,
+            `is_private` AS isPrivate,
+            `config` AS configStr
+        FROM `cmdb_attr`
+        WHERE `ci_id` = #{value}
+    </select>
+
     <select id="checkAttrNameIsRepeat" parameterType="neatlogic.framework.cmdb.dto.ci.AttrVo" resultType="int"
             useCache="false">
         SELECT COUNT(1)
diff --git a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.java b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.java
index 9d42ef6bb08f962a4879d09bfeb8b98d69339d66..a6dc231f90b6141caebed6453a1e8d91f6fa1b8a 100644
--- a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.java
+++ b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.java
@@ -50,6 +50,8 @@ public interface RelMapper extends IRelCrossoverMapper {
 
     List<RelVo> getRelByCiId(Long ciId);
 
+    List<RelVo> getRelBaseInfoByCiId(Long ciId);
+
     int updateRel(RelVo relVo);
 
     int updateRelGroup(RelGroupVo relGroupVo);
@@ -64,4 +66,5 @@ public interface RelMapper extends IRelCrossoverMapper {
 
     void deleteRelativeRelByRelId(Long relId);
 
+    void deleteRelGroupByCiId(Long ciId);
 }
diff --git a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.xml b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.xml
index f60c985abfdd0bdff91ceb4443fbec8bb6f33430..3d57daa440390c1df385209bf7d406dad7ba6ae6 100644
--- a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.xml
+++ b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelMapper.xml
@@ -415,6 +415,33 @@
         ORDER BY sort, id
     </select>
 
+    <select id="getRelBaseInfoByCiId" parameterType="java.lang.Long" resultMap="relDetailMap"
+            useCache="true">
+        SELECT
+            `id`,
+            `type_id` AS typeId,
+            `input_type` AS inputType,
+            `from_ci_id` AS fromCiId,
+            `from_name` AS fromName,
+            `from_label` AS fromLabel,
+            `from_rule` AS fromRule,
+            `from_group_id` AS fromGroupId,
+            `from_is_unique` AS fromIsUnique,
+            `from_is_cascade_delete` AS fromIsCascadeDelete,
+            `from_is_required` AS fromIsRequired,
+            `to_ci_id` AS toCiId,
+            `to_name` AS toName,
+            `to_label` AS toLabel,
+            `to_rule` AS toRule,
+            `to_group_id` AS toGroupId,
+            `to_is_unique` AS toIsUnique,
+            `to_is_cascade_delete` AS toIsCascadeDelete,
+            `to_is_required` AS toIsRequired
+        FROM `cmdb_rel`
+        WHERE `from_ci_id` = #{value}
+           OR `to_ci_id` = #{value}
+    </select>
+
     <update id="updateRel" parameterType="neatlogic.framework.cmdb.dto.ci.RelVo">
         UPDATE
             `cmdb_rel`
@@ -510,4 +537,10 @@
         WHERE rel_id = #{value}
     </delete>
 
+    <delete id="deleteRelGroupByCiId" parameterType="java.lang.Long">
+        DELETE
+        from `cmdb_relgroup`
+        WHERE `ci_id` = #{value}
+    </delete>
+
 </mapper>
diff --git a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.java b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.java
index 4e9550c18e3c3c6a24d463b8edc68d6b3cfaeeb3..21fa4c8477c62d13a41417f5965bf35608609bdc 100644
--- a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.java
+++ b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.java
@@ -27,6 +27,8 @@ public interface RelTypeMapper {
 
     RelTypeVo getRelTypeById(Long id);
 
+    RelTypeVo getRelTypeByName(String name);
+
     List<RelTypeVo> getAllRelType();
 
     int insertRelType(RelTypeVo relTypeVo);
diff --git a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.xml b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.xml
index 49a96f3f2d98201f6f5e19ad1230d28fd51a52ba..5c5acd264cdf5f93e7fbed23b4ef190c75976768 100644
--- a/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.xml
+++ b/src/main/java/neatlogic/module/cmdb/dao/mapper/ci/RelTypeMapper.xml
@@ -43,6 +43,16 @@
         WHERE id = #{value}
     </select>
 
+    <select id="getRelTypeByName" parameterType="java.lang.String" resultType="neatlogic.framework.cmdb.dto.ci.RelTypeVo"
+            useCache="false">
+        SELECT `id`,
+               `name`,
+               `is_showintopo` AS isShowInTopo,
+               `description`
+        FROM `cmdb_reltype`
+        WHERE name = #{value}
+    </select>
+
     <select id="getAllRelType" resultType="neatlogic.framework.cmdb.dto.ci.RelTypeVo" useCache="false">
         SELECT `id`,
                `name`,
diff --git a/src/main/java/neatlogic/module/cmdb/importexport/handler/CiImportExportHandler.java b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6e61e46ff33d6061398d706ed20758daf444005
--- /dev/null
+++ b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiImportExportHandler.java
@@ -0,0 +1,330 @@
+package neatlogic.module.cmdb.importexport.handler;
+
+import neatlogic.framework.cmdb.dto.ci.*;
+import neatlogic.framework.cmdb.enums.CmdbImportExportHandlerType;
+import neatlogic.framework.cmdb.exception.ci.CiNotFoundException;
+import neatlogic.framework.file.dao.mapper.FileMapper;
+import neatlogic.framework.importexport.constvalue.FrameworkImportExportHandlerType;
+import neatlogic.framework.importexport.core.ImportExportHandlerBase;
+import neatlogic.framework.importexport.core.ImportExportHandlerType;
+import neatlogic.framework.importexport.dto.ImportExportBaseInfoVo;
+import neatlogic.framework.importexport.dto.ImportExportPrimaryChangeVo;
+import neatlogic.framework.importexport.dto.ImportExportVo;
+import neatlogic.module.cmdb.dao.mapper.ci.*;
+import neatlogic.module.cmdb.service.attr.AttrService;
+import neatlogic.module.cmdb.service.ci.CiService;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class CiImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private CiMapper ciMapper;
+
+    @Resource
+    private FileMapper fileMapper;
+
+    @Autowired
+    private AttrMapper attrMapper;
+
+    @Autowired
+    private CiViewMapper ciViewMapper;
+
+    @Resource
+    private RelMapper relMapper;
+
+    @Autowired
+    private CiAuthMapper ciAuthMapper;
+
+    @Resource
+    private CiService ciService;
+
+    @Resource
+    private AttrService attrService;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return FrameworkImportExportHandlerType.CMDB_CI;
+    }
+
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return ciMapper.getCiByName(importExportBaseInfoVo.getName()) != null
+                || ciMapper.getCiById((Long)importExportBaseInfoVo.getPrimaryKey()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        CiVo ci = ciMapper.getCiByName(importExportVo.getName());
+        if (ci == null) {
+            throw new CiNotFoundException(importExportVo.getName());
+        }
+        return ci.getId();
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        CiVo ciVo = importExportVo.getData().toJavaObject(CiVo.class);
+        Long originalId = ciVo.getId();
+        CiVo oldCi = ciMapper.getCiById(ciVo.getId());
+        if (oldCi == null) {
+            oldCi = ciMapper.getCiByName(ciVo.getName());
+            if (oldCi != null) {
+                ciVo.setId(oldCi.getId());
+            }
+        }
+        importHandle(ciVo, primaryChangeList);
+        List<RelVo> relList = ciVo.getRelList();
+        for (RelVo relVo : relList) {
+            if (Objects.equals(relVo.getFromCiId(), originalId)) {
+                relVo.setFromCiId(ciVo.getId());
+            }
+            if (Objects.equals(relVo.getToCiId(), originalId)) {
+                relVo.setToCiId(ciVo.getId());
+            }
+        }
+        List<AttrVo> attrList = ciVo.getAttrList();
+        for (AttrVo attr : attrList) {
+            attr.setCiId(ciVo.getId());
+        }
+        ciVo.setAttrList(null);
+        if (oldCi == null) {
+            ciService.insertCi(ciVo);
+            List<RelVo> oldRelList = relMapper.getRelBaseInfoByCiId(ciVo.getId());
+            List<Long> oldRelIdList = oldRelList.stream().map(RelVo::getId).collect(Collectors.toList());
+            for (RelVo relVo : relList) {
+                if (oldRelIdList.contains(relVo.getId())) {
+                    relMapper.updateRel(relVo);
+                    relMapper.deleteRelativeRelByRelId(relVo.getId());
+                } else {
+                    relMapper.insertRel(relVo);
+                }
+                if (CollectionUtils.isNotEmpty(relVo.getRelativeRelList())) {
+                    for (RelativeRelVo relativeRelVo : relVo.getRelativeRelList()) {
+                        relativeRelVo.setRelId(relVo.getId());
+                        relMapper.insertRelativeRel(relativeRelVo);
+                    }
+                }
+            }
+            for (AttrVo attr : attrList) {
+                attrService.insertAttr(attr);
+            }
+        } else {
+            ciService.updateCi(ciVo);
+            List<RelVo> oldRelList = relMapper.getRelBaseInfoByCiId(oldCi.getId());
+            List<Long> oldRelIdList = oldRelList.stream().map(RelVo::getId).collect(Collectors.toList());
+            for (RelVo relVo : relList) {
+                if (oldRelIdList.contains(relVo.getId())) {
+                    relMapper.updateRel(relVo);
+                    relMapper.deleteRelativeRelByRelId(relVo.getId());
+                } else {
+                    relMapper.insertRel(relVo);
+                }
+                if (CollectionUtils.isNotEmpty(relVo.getRelativeRelList())) {
+                    for (RelativeRelVo relativeRelVo : relVo.getRelativeRelList()) {
+                        relativeRelVo.setRelId(relVo.getId());
+                        relMapper.insertRelativeRel(relativeRelVo);
+                    }
+                }
+            }
+            List<AttrVo> oldAttrList = attrMapper.getAttrBaseInfoByCiId(oldCi.getId());
+            List<Long> oldAttrIdList = oldAttrList.stream().map(AttrVo::getId).collect(Collectors.toList());
+            for (AttrVo attr : attrList) {
+                if (oldAttrIdList.contains(attr.getId())) {
+                    attrService.updateAttr(attr);
+                } else {
+                    attrService.insertAttr(attr);
+                }
+            }
+            relMapper.deleteRelGroupByCiId(ciVo.getId());
+            ciViewMapper.deleteCiViewByCiId(ciVo.getId());
+            ciAuthMapper.deleteCiAuthByCiId(ciVo.getId());
+            if (CollectionUtils.isNotEmpty(oldCi.getUniqueAttrIdList())) {
+                ciMapper.deleteCiUniqueByCiId(ciVo.getId());
+            }
+        }
+        List<RelGroupVo> relGroupList = ciVo.getRelGroupList();
+        for (RelGroupVo relGroup : relGroupList) {
+            relGroup.setCiId(ciVo.getId());
+            relMapper.insertRelGroup(relGroup);
+        }
+        List<CiViewVo> viewList = ciVo.getViewList();
+        for (CiViewVo view : viewList) {
+            view.setCiId(ciVo.getId());
+            ciViewMapper.insertCiView(view);
+        }
+        List<CiAuthVo> authList = ciVo.getAuthList();
+        for (CiAuthVo auth : authList) {
+            auth.setCiId(ciVo.getId());
+            ciAuthMapper.insertCiAuth(auth);
+        }
+        List<Long> uniqueAttrIdList = ciVo.getUniqueAttrIdList();
+        for (Long attrId : uniqueAttrIdList) {
+            ciMapper.insertCiUnique(ciVo.getId(), attrId);
+        }
+        return ciVo.getId();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        Long id = (Long) primaryKey;
+        CiVo ciVo = ciMapper.getCiById(id);
+        if (ciVo == null) {
+            throw new CiNotFoundException(id);
+        }
+        if (Objects.equals(ciVo.getIsVirtual(), 1) && ciVo.getFileId() != null) {
+            ciVo.setFileVo(fileMapper.getFileById(ciVo.getFileId()));
+        }
+        List<AttrVo> attrList = attrMapper.getAttrBaseInfoByCiId(id);
+        List<RelVo> relList = relMapper.getRelBaseInfoByCiId(id);
+        for (RelVo rel : relList) {
+            List<RelativeRelVo> relativeRelList = relMapper.getRelativeRelByRelId(rel.getId());
+            rel.setRelativeRelList(relativeRelList);
+        }
+        List<RelGroupVo> relGroupList = relMapper.getRelGroupByCiId(id);
+        List<CiViewVo> viewList = ciViewMapper.getCiViewBaseInfoByCiId(id);
+        List<CiAuthVo> authList = ciAuthMapper.getCiAuthByCiId(id);
+        List<Long> uniqueAttrIdList = ciMapper.getCiUniqueByCiId(id);
+        ciVo.setAttrList(attrList);
+        ciVo.setRelList(relList);
+        ciVo.setViewList(viewList);
+        ciVo.setAuthList(authList);
+        ciVo.setUniqueAttrIdList(uniqueAttrIdList);
+        ciVo.setRelGroupList(relGroupList);
+        exportHandle(ciVo, dependencyList, zipOutputStream);
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, ciVo.getName());
+        importExportVo.setDataWithObject(ciVo);
+        return importExportVo;
+    }
+
+    /**
+     * 导入处理，更新依赖组件的唯一标识
+     * @param ciVo
+     * @param primaryChangeList
+     */
+    private void importHandle(CiVo ciVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        handleDependency(IMPORT, ciVo, null, null, primaryChangeList);
+    }
+
+    /**
+     * 导出处理，先导出依赖组件
+     * @param ciVo
+     * @param dependencyList
+     * @param zipOutputStream
+     */
+    private void exportHandle(CiVo ciVo, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        handleDependency(EXPORT, ciVo, dependencyList, zipOutputStream, null);
+    }
+
+    private void handleDependency(String action, CiVo ciVo, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        if (ciVo.getParentCiId() != null) {
+            if (action == IMPORT) {
+                Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.CMDB_CI, ciVo.getParentCiId(), primaryChangeList);
+                if (newPrimaryKey != null) {
+                    ciVo.setParentCiId((Long) newPrimaryKey);
+                }
+            } else if (action == EXPORT) {
+                doExportData(FrameworkImportExportHandlerType.CMDB_CI, ciVo.getParentCiId(), dependencyList, zipOutputStream);
+            }
+        }
+        if (ciVo.getTypeId() != null) {
+            if (action == IMPORT) {
+                Object newPrimaryKey = getNewPrimaryKey(CmdbImportExportHandlerType.CI_TYPE, ciVo.getTypeId(), primaryChangeList);
+                if (newPrimaryKey != null) {
+                    ciVo.setTypeId((Long) newPrimaryKey);
+                }
+            } else if (action == EXPORT) {
+                doExportData(CmdbImportExportHandlerType.CI_TYPE, ciVo.getTypeId(), dependencyList, zipOutputStream);
+            }
+        }
+        if (Objects.equals(ciVo.getIsVirtual(), 1) && ciVo.getFileId() != null) {
+            if (action == IMPORT) {
+                Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.FILE, ciVo.getFileId(), primaryChangeList);
+                if (newPrimaryKey != null) {
+                    ciVo.setFileId((Long) newPrimaryKey);
+                }
+            } else if (action == EXPORT) {
+                doExportData(FrameworkImportExportHandlerType.FILE, ciVo.getFileId(), dependencyList, zipOutputStream);
+            }
+        }
+        List<AttrVo> attrList = ciVo.getAttrList();
+        if (CollectionUtils.isNotEmpty(attrList)) {
+            for (AttrVo attr : attrList) {
+                if (attr.getTargetCiId() != null) {
+                    if (action == IMPORT) {
+                        Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.CMDB_CI, attr.getTargetCiId(), primaryChangeList);
+                        if (newPrimaryKey != null) {
+                            attr.setTargetCiId((Long) newPrimaryKey);
+                        }
+                    } else if (action == EXPORT) {
+                        doExportData(FrameworkImportExportHandlerType.CMDB_CI, attr.getTargetCiId(), dependencyList, zipOutputStream);
+                    }
+                }
+                if (attr.getValidatorId() != null) {
+                    if (action == IMPORT) {
+                        Object newPrimaryKey = getNewPrimaryKey(CmdbImportExportHandlerType.CI_VALIDATOR, attr.getValidatorId(), primaryChangeList);
+                        if (newPrimaryKey != null) {
+                            attr.setValidatorId((Long) newPrimaryKey);
+                        }
+                    } else if (action == EXPORT) {
+                        doExportData(CmdbImportExportHandlerType.CI_VALIDATOR, attr.getValidatorId(), dependencyList, zipOutputStream);
+                    }
+                }
+            }
+        }
+        List<RelVo> relList = ciVo.getRelList();
+        if (CollectionUtils.isNotEmpty(relList)) {
+            for (RelVo rel : relList) {
+                if (rel.getTypeId() != null) {
+                    if (action == IMPORT) {
+                        Object newPrimaryKey = getNewPrimaryKey(CmdbImportExportHandlerType.CI_REL_TYPE, rel.getTypeId(), primaryChangeList);
+                        if (newPrimaryKey != null) {
+                            rel.setTypeId((Long) newPrimaryKey);
+                        }
+                    } else if (action == EXPORT) {
+                        doExportData(CmdbImportExportHandlerType.CI_REL_TYPE, rel.getTypeId(), dependencyList, zipOutputStream);
+                    }
+                }
+                if (rel.getFromCiId() != null && !Objects.equals(rel.getFromCiId(), ciVo.getId())) {
+                    if (action == IMPORT) {
+                        Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.CMDB_CI, rel.getFromCiId(), primaryChangeList);
+                        if (newPrimaryKey != null) {
+                            rel.setFromCiId((Long) newPrimaryKey);
+                        }
+                    } else if (action == EXPORT) {
+                        doExportData(FrameworkImportExportHandlerType.CMDB_CI, rel.getFromCiId(), dependencyList, zipOutputStream);
+                    }
+                }
+                if (rel.getToCiId() != null && !Objects.equals(rel.getToCiId(), ciVo.getId())) {
+                    if (action == IMPORT) {
+                        Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.CMDB_CI, rel.getToCiId(), primaryChangeList);
+                        if (newPrimaryKey != null) {
+                            rel.setToCiId((Long) newPrimaryKey);
+                        }
+                    } else if (action == EXPORT) {
+                        doExportData(FrameworkImportExportHandlerType.CMDB_CI, rel.getToCiId(), dependencyList, zipOutputStream);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/neatlogic/module/cmdb/importexport/handler/CiRelTypeImportExportHandler.java b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiRelTypeImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..010de63b23ea9136747580fd5b3ab3f3273346ed
--- /dev/null
+++ b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiRelTypeImportExportHandler.java
@@ -0,0 +1,80 @@
+package neatlogic.module.cmdb.importexport.handler;
+
+import neatlogic.framework.cmdb.dto.ci.RelTypeVo;
+import neatlogic.framework.cmdb.enums.CmdbImportExportHandlerType;
+import neatlogic.framework.cmdb.exception.reltype.RelTypeNotFoundException;
+import neatlogic.framework.importexport.core.ImportExportHandlerBase;
+import neatlogic.framework.importexport.core.ImportExportHandlerType;
+import neatlogic.framework.importexport.dto.ImportExportBaseInfoVo;
+import neatlogic.framework.importexport.dto.ImportExportPrimaryChangeVo;
+import neatlogic.framework.importexport.dto.ImportExportVo;
+import neatlogic.module.cmdb.dao.mapper.ci.RelTypeMapper;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class CiRelTypeImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private RelTypeMapper relTypeMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return CmdbImportExportHandlerType.CI_REL_TYPE;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return relTypeMapper.getRelTypeByName(importExportBaseInfoVo.getName()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        RelTypeVo relType = relTypeMapper.getRelTypeByName(importExportVo.getName());
+        if (relType == null) {
+            throw new RelTypeNotFoundException(importExportVo.getName());
+        }
+        return relType.getId();
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        RelTypeVo relType = importExportVo.getData().toJavaObject(RelTypeVo.class);
+        RelTypeVo oldRelType = relTypeMapper.getRelTypeByName(importExportVo.getName());
+        if (oldRelType != null) {
+            relType.setId(oldRelType.getId());
+            relTypeMapper.updateRelType(relType);
+        } else {
+            if (relTypeMapper.getRelTypeById(relType.getId()) != null) {
+                relType.setId(null);
+            }
+            relTypeMapper.insertRelType(relType);
+        }
+        return relType.getId();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        Long id = (Long) primaryKey;
+        RelTypeVo relType = relTypeMapper.getRelTypeById(id);
+        if (relType == null) {
+            throw new RelTypeNotFoundException(id);
+        }
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, relType.getName());
+        importExportVo.setDataWithObject(relType);
+        return importExportVo;
+    }
+}
diff --git a/src/main/java/neatlogic/module/cmdb/importexport/handler/CiTypeImportExportHandler.java b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiTypeImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..c936ed284c5eebebc54972403b729128ed46a5b9
--- /dev/null
+++ b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiTypeImportExportHandler.java
@@ -0,0 +1,87 @@
+package neatlogic.module.cmdb.importexport.handler;
+
+import neatlogic.framework.cmdb.dto.ci.CiTypeVo;
+import neatlogic.framework.cmdb.enums.CmdbImportExportHandlerType;
+import neatlogic.framework.cmdb.exception.ci.CiTypeNotFoundException;
+import neatlogic.framework.importexport.core.ImportExportHandlerBase;
+import neatlogic.framework.importexport.core.ImportExportHandlerType;
+import neatlogic.framework.importexport.dto.ImportExportBaseInfoVo;
+import neatlogic.framework.importexport.dto.ImportExportPrimaryChangeVo;
+import neatlogic.framework.importexport.dto.ImportExportVo;
+import neatlogic.module.cmdb.dao.mapper.ci.CiTypeMapper;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class CiTypeImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private CiTypeMapper ciTypeMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return CmdbImportExportHandlerType.CI_TYPE;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return ciTypeMapper.getCiTypeByName(importExportBaseInfoVo.getName()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        CiTypeVo ciType = ciTypeMapper.getCiTypeByName(importExportVo.getName());
+        if (ciType == null) {
+            throw new CiTypeNotFoundException(importExportVo.getName());
+        }
+        return ciType.getId();
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        CiTypeVo ciType = importExportVo.getData().toJavaObject(CiTypeVo.class);
+        CiTypeVo oldCiType = ciTypeMapper.getCiTypeByName(importExportVo.getName());
+        if (oldCiType != null) {
+            ciType.setId(oldCiType.getId());
+            ciTypeMapper.updateCiType(ciType);
+        } else {
+            if (ciTypeMapper.getCiTypeById(ciType.getId()) != null) {
+                ciType.setId(null);
+            }
+            Integer maxsort = ciTypeMapper.getMaxSort();
+            if (maxsort == null) {
+                maxsort = 1;
+            } else {
+                maxsort += 1;
+            }
+            ciType.setSort(maxsort);
+            ciTypeMapper.insertCiType(ciType);
+        }
+        return ciType.getId();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        Long id = (Long) primaryKey;
+        CiTypeVo ciType = ciTypeMapper.getCiTypeById(id);
+        if (ciType == null) {
+            throw new CiTypeNotFoundException(id);
+        }
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, ciType.getName());
+        importExportVo.setDataWithObject(ciType);
+        return importExportVo;
+    }
+}
diff --git a/src/main/java/neatlogic/module/cmdb/importexport/handler/CiValidatorImportExportHandler.java b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiValidatorImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..2dab68de2fd98cbec6d7e8c820ffb2f05974ef48
--- /dev/null
+++ b/src/main/java/neatlogic/module/cmdb/importexport/handler/CiValidatorImportExportHandler.java
@@ -0,0 +1,80 @@
+package neatlogic.module.cmdb.importexport.handler;
+
+import neatlogic.framework.cmdb.dao.mapper.validator.ValidatorMapper;
+import neatlogic.framework.cmdb.dto.validator.ValidatorVo;
+import neatlogic.framework.cmdb.enums.CmdbImportExportHandlerType;
+import neatlogic.framework.cmdb.exception.validator.ValidatorNotFoundException;
+import neatlogic.framework.importexport.core.ImportExportHandlerBase;
+import neatlogic.framework.importexport.core.ImportExportHandlerType;
+import neatlogic.framework.importexport.dto.ImportExportBaseInfoVo;
+import neatlogic.framework.importexport.dto.ImportExportPrimaryChangeVo;
+import neatlogic.framework.importexport.dto.ImportExportVo;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class CiValidatorImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private ValidatorMapper validatorMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return CmdbImportExportHandlerType.CI_VALIDATOR;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return validatorMapper.getValidatorByName(importExportBaseInfoVo.getName()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        ValidatorVo validator = validatorMapper.getValidatorByName(importExportVo.getName());
+        if (validator == null) {
+            throw new ValidatorNotFoundException(importExportVo.getName());
+        }
+        return validator.getId();
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        ValidatorVo validator = importExportVo.getData().toJavaObject(ValidatorVo.class);
+        ValidatorVo oldValidator = validatorMapper.getValidatorByName(importExportVo.getName());
+        if (oldValidator != null) {
+            validator.setId(oldValidator.getId());
+            validatorMapper.updateValidator(validator);
+        } else {
+            if (validatorMapper.getValidatorById(validator.getId()) != null) {
+                validator.setId(null);
+            }
+            validatorMapper.insertValidator(validator);
+        }
+        return validator.getId();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        Long id = (Long) primaryKey;
+        ValidatorVo validator = validatorMapper.getValidatorById(id);
+        if (validator == null) {
+            throw new ValidatorNotFoundException(id);
+        }
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, validator.getName());
+        importExportVo.setDataWithObject(validator);
+        return importExportVo;
+    }
+}