diff --git a/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.java b/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.java
index 8db504b3139cf3284f5216daed16ce3770e173fb..862b879a8dcfe777025fb581154f44405c008cd1 100644
--- a/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.java
+++ b/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.java
@@ -47,6 +47,8 @@ public interface FormMapper {
 
     FormVo getFormByUuid(String formUuid);
 
+    FormVo getFormByName(String formName);
+
     FormVersionVo getFormVersionByUuid(String formVersionUuid);
 
     List<FormVersionVo> getFormVersionByFormUuid(String formUuid);
diff --git a/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.xml b/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.xml
index 057982f3cb6a4981993ac31c5460d90ff62e6a39..888660967a3f1aef5c340979a16be4213a6d8cfa 100644
--- a/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.xml
+++ b/src/main/java/neatlogic/framework/form/dao/mapper/FormMapper.xml
@@ -212,6 +212,14 @@ limitations under the License.
         WHERE `uuid` = #{value}
     </select>
 
+    <select id="getFormByName" parameterType="java.lang.String" resultType="neatlogic.framework.form.dto.FormVo">
+        SELECT `uuid`,
+               `name`,
+               `is_active` AS isActive
+        FROM `form`
+        WHERE `name` = #{value}
+    </select>
+
     <select id="getFormVersionByFormUuid" parameterType="java.lang.String"
             resultType="neatlogic.framework.form.dto.FormVersionVo">
         SELECT `uuid`,
diff --git a/src/main/java/neatlogic/framework/form/service/IFormCrossoverService.java b/src/main/java/neatlogic/framework/form/service/IFormCrossoverService.java
index be267be142eb93af84f70ef668baea13e62861a8..6c4e0f73f45c8e19b868ec8f4029abf5f351ac16 100644
--- a/src/main/java/neatlogic/framework/form/service/IFormCrossoverService.java
+++ b/src/main/java/neatlogic/framework/form/service/IFormCrossoverService.java
@@ -17,10 +17,10 @@ limitations under the License.
 package neatlogic.framework.form.service;
 
 import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import neatlogic.framework.crossover.ICrossoverService;
 import neatlogic.framework.form.dto.AttributeDataVo;
 import neatlogic.framework.form.dto.FormAttributeVo;
-import com.alibaba.fastjson.JSONObject;
 import neatlogic.framework.form.dto.FormVersionVo;
 import neatlogic.framework.form.exception.AttributeValidException;
 
diff --git a/src/main/java/neatlogic/framework/importexport/constvalue/FrameworkImportExportHandlerType.java b/src/main/java/neatlogic/framework/importexport/constvalue/FrameworkImportExportHandlerType.java
index 9123e2b3d3fb833aa65231813f212f6822c93306..0da6bd4986dab737f6f7010fe57dd203eaf7c485 100644
--- a/src/main/java/neatlogic/framework/importexport/constvalue/FrameworkImportExportHandlerType.java
+++ b/src/main/java/neatlogic/framework/importexport/constvalue/FrameworkImportExportHandlerType.java
@@ -20,7 +20,13 @@ import neatlogic.framework.importexport.core.ImportExportHandlerType;
 import neatlogic.framework.util.$;
 
 public enum FrameworkImportExportHandlerType implements ImportExportHandlerType {
-    FILE("file", "common.attachment"),
+    FILE("file", "附件"),
+    INTEGRATION("integration", "集成"),
+    FORM("form", "表单"),
+    MATRIX("matrix", "矩阵"),
+    NOTIFY_POLICY("notifyPolicy", "通知策略"),
+    CMDB_CI("cmdbCi", "配置项模型"),
+    AUTOEXEC_COMBOP("autoexecCombop", "组合工具"),
     ;
 
     private String value;
diff --git a/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerBase.java b/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerBase.java
index fc504b144360992d1e2d88ce2ec8a92083afab78..7c3a3e65463ebcb711b3e3a7106396c94f0eda21 100644
--- a/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerBase.java
+++ b/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerBase.java
@@ -33,6 +33,9 @@ import java.util.zip.ZipOutputStream;
 public abstract class ImportExportHandlerBase implements ImportExportHandler {
 
     private static Logger logger = LoggerFactory.getLogger(ImportExportHandlerBase.class);
+
+    protected final String IMPORT = "import";
+    protected final String EXPORT = "export";
     /**
      * 检查导入依赖列表中的对象是否已经存在，存在则需要让用户决定是否覆盖
      * @param dependencyBaseInfoList
diff --git a/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerFactory.java b/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerFactory.java
index 43a0cb8214066b9334ce4222992c01cd0cfcc80d..deba5e016015be4725595607442be4596eab78d1 100644
--- a/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerFactory.java
+++ b/src/main/java/neatlogic/framework/importexport/core/ImportExportHandlerFactory.java
@@ -102,7 +102,7 @@ public class ImportExportHandlerFactory extends ModuleInitializedListenerBase {
         if (StringUtils.isNotBlank(userSelection)) {
             JSONObject userSelectionObj = JSONObject.parseObject(userSelection);
             if (MapUtils.isNotEmpty(userSelectionObj)) {
-                checkAll = userSelectionObj.getBooleanValue("checkAll");
+                checkAll = userSelectionObj.getBooleanValue("checkedAll");
                 JSONArray typeArray = userSelectionObj.getJSONArray("typeList");
                 if (CollectionUtils.isNotEmpty(typeArray)) {
                     typeList = typeArray.toJavaList(ImportDependencyTypeVo.class);
@@ -144,16 +144,29 @@ public class ImportExportHandlerFactory extends ModuleInitializedListenerBase {
                         if (!Objects.equals(mainImportExportVo.getType(), targetType)) {
                             throw new ImportExportTypeInconsistencyException(mainImportExportVo.getType(), targetType);
                         }
+                        boolean alreadyExists = false;
+                        JSONObject resultObj = new JSONObject();
+                        ImportExportBaseInfoVo mainImportExportBaseInfoVo = new ImportExportBaseInfoVo(mainImportExportVo.getType(), mainImportExportVo.getPrimaryKey(), mainImportExportVo.getName());
+                        if (importExportHandler.checkIsExists(mainImportExportBaseInfoVo)) {
+                            mainImportExportBaseInfoVo.setType(importExportHandler.getType().getText());
+                            resultObj.put("alreadyExists", mainImportExportBaseInfoVo);
+                            alreadyExists = true;
+                        }
                         List<ImportExportBaseInfoVo> dependencyBaseInfoList = mainImportExportVo.getDependencyBaseInfoList();
                         if (CollectionUtils.isNotEmpty(dependencyBaseInfoList) && StringUtils.isBlank(userSelection)) {
                             List<ImportDependencyTypeVo> importDependencyTypeList = importExportHandler.checkDependencyList(dependencyBaseInfoList);
                             if (CollectionUtils.isNotEmpty(importDependencyTypeList)) {
-                                JSONObject resultObj = new JSONObject();
                                 resultObj.put("checkedAll", false);
                                 resultObj.put("typeList", importDependencyTypeList);
                                 return resultObj;
+                            } else {
+                                checkAll = true;
+                                resultObj.put("checkedAll", true);
+                                resultObj.put("typeList", new ArrayList<>());
                             }
-                            checkAll = true;
+                        }
+                        if (alreadyExists) {
+                            return resultObj;
                         }
                     }
                 }
diff --git a/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.java b/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.java
index cd903b65992f997bbb32063d9c2774ec66208a5c..d6514d88cfe0bccbb18519fe0c158c2999d5e0df 100644
--- a/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.java
+++ b/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.java
@@ -30,6 +30,8 @@ public interface IntegrationMapper {
 
     IntegrationVo getIntegrationByUuid(String uuid);
 
+    IntegrationVo getIntegrationByName(String name);
+
     int checkIntegrationExists(String uuid);
 
     List<IntegrationVo> searchIntegration(IntegrationVo integrationVo);
diff --git a/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.xml b/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.xml
index 69fd5ce3dc5eca315b336d9b030c545a204cf5d1..2106076ae37ac320142fcb6a8662a81666742a77 100644
--- a/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.xml
+++ b/src/main/java/neatlogic/framework/integration/dao/mapper/IntegrationMapper.xml
@@ -87,6 +87,21 @@ limitations under the License.
 		uuid = #{value}
 	</select>
 
+	<select id="getIntegrationByName" parameterType="java.lang.String" resultType="neatlogic.framework.integration.dto.IntegrationVo">
+		SELECT
+			`uuid`,
+			`name`,
+			`url`,
+			`handler`,
+			`method`,
+			is_active AS isActive,
+			`config`
+		FROM
+			`integration`
+		WHERE
+			`name` = #{value}
+	</select>
+
 	<select id="checkIntegrationExists" parameterType="java.lang.String" resultType="int">
 		SELECT COUNT(`uuid`) FROM `integration` WHERE `uuid` = #{value}
 	</select>
diff --git a/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.java b/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.java
index 5b11ee36079a2a9fa0eb3ef0dc6d68d609643938..b4dd7642444e30a7256b47adc489f815c0836be1 100644
--- a/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.java
+++ b/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.java
@@ -13,6 +13,8 @@ public interface MatrixMapper {
 
     MatrixVo getMatrixByUuid(String uuid);
 
+    MatrixVo getMatrixByLabel(String label);
+
     int checkMatrixIsExists(String uuid);
 
     int checkMatrixNameIsRepeat(MatrixVo matrixVo);
diff --git a/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.xml b/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.xml
index fa3a34ebacec60c27dbffe8e9f0f69edd3f6a5a1..18bdbdb598e721f3d10f1bbfa38a72f8b2d8d044 100644
--- a/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.xml
+++ b/src/main/java/neatlogic/framework/matrix/dao/mapper/MatrixMapper.xml
@@ -17,6 +17,21 @@
 		WHERE `uuid` = #{uuid}
 	</select>
 
+	<select id="getMatrixByLabel" parameterType="String" resultType="neatlogic.framework.matrix.dto.MatrixVo">
+		SELECT
+			`id`,
+			`uuid`,
+			`name`,
+			`label`,
+			`type`,
+			`fcu`,
+			`fcd`,
+			`lcu`,
+			`lcd`
+		FROM `matrix`
+		WHERE `label` = #{value}
+	</select>
+
 	<select id="checkMatrixIsExists" parameterType="java.lang.String" resultType="int">
 		SELECT COUNT(`uuid`) FROM `matrix` WHERE `uuid` = #{uuid}
 	</select>
diff --git a/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.java b/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.java
index aa671082c79bcb49b8531720ac7ef378c5b5b5ac..dd9e272502c6fc285bf400141087fb4395634c50 100644
--- a/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.java
+++ b/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.java
@@ -1,16 +1,18 @@
 package neatlogic.framework.notify.dao.mapper;
 
-import java.util.List;
-
 import neatlogic.framework.common.dto.ValueTextVo;
 import neatlogic.framework.notify.dto.NotifyPolicyVo;
 
+import java.util.List;
+
  public interface NotifyMapper {
 
 	 NotifyPolicyVo getNotifyPolicyById(Long id);
 
 	 NotifyPolicyVo getNotifyPolicyByName(String name);
 
+	 List<NotifyPolicyVo> getNotifyPolicyListByName(String name);
+
 	 List<NotifyPolicyVo> getNotifyPolicyListByIdList(List<Long> idList);
 
 	 int checkNotifyPolicyNameIsRepeat(NotifyPolicyVo notifyPolicyVo);
diff --git a/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.xml b/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.xml
index 3483c68cb846e3367697133c8aad29dea0ff2dde..dc7bdfced2d9e337848c3bc9a0969fe0aa020394 100644
--- a/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.xml
+++ b/src/main/java/neatlogic/framework/notify/dao/mapper/NotifyMapper.xml
@@ -34,6 +34,20 @@
 	Limit 1
 	</select>
 
+	<select id="getNotifyPolicyListByName" parameterType="java.lang.String" resultType="neatlogic.framework.notify.dto.NotifyPolicyVo">
+		SELECT
+			`id`,
+			`name`,
+			`is_default` AS isDefault,
+			`handler`,
+			`fcd`,
+			`fcu`,
+			`lcd`,
+			`lcu`
+		FROM `notify_policy`
+		WHERE `name` = #{value}
+	</select>
+
 	<select id="getNotifyPolicyListByIdList" parameterType="java.lang.Long" resultType="neatlogic.framework.notify.dto.NotifyPolicyVo">
 	SELECT
 	`id`,
diff --git a/src/main/java/neatlogic/module/framework/form/service/FormService.java b/src/main/java/neatlogic/module/framework/form/service/FormService.java
index 7ee683d216ce218d89a026264baec848d1e5de44..7841665b97f6c24402b5be92bd8062c46e868918 100644
--- a/src/main/java/neatlogic/module/framework/form/service/FormService.java
+++ b/src/main/java/neatlogic/module/framework/form/service/FormService.java
@@ -17,10 +17,10 @@ limitations under the License.
 package neatlogic.module.framework.form.service;
 
 import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import neatlogic.framework.common.dto.ValueTextVo;
 import neatlogic.framework.form.dto.AttributeDataVo;
 import neatlogic.framework.form.dto.FormAttributeVo;
-import com.alibaba.fastjson.JSONObject;
 import neatlogic.framework.form.dto.FormVersionVo;
 import neatlogic.framework.form.exception.AttributeValidException;
 
diff --git a/src/main/java/neatlogic/module/framework/importexport/handler/FormImportExportHandler.java b/src/main/java/neatlogic/module/framework/importexport/handler/FormImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceacb072a3c6bce145f3ac6d34e1c5eccd067030
--- /dev/null
+++ b/src/main/java/neatlogic/module/framework/importexport/handler/FormImportExportHandler.java
@@ -0,0 +1,314 @@
+package neatlogic.module.framework.importexport.handler;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import neatlogic.framework.asynchronization.threadlocal.UserContext;
+import neatlogic.framework.crossover.CrossoverServiceFactory;
+import neatlogic.framework.dependency.core.DependencyManager;
+import neatlogic.framework.form.constvalue.FormHandler;
+import neatlogic.framework.form.dao.mapper.FormMapper;
+import neatlogic.framework.form.dto.FormAttributeVo;
+import neatlogic.framework.form.dto.FormVersionVo;
+import neatlogic.framework.form.dto.FormVo;
+import neatlogic.framework.form.exception.FormActiveVersionNotFoundExcepiton;
+import neatlogic.framework.form.exception.FormNotFoundException;
+import neatlogic.framework.form.service.IFormCrossoverService;
+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.framework.dependency.handler.Integration2FormAttrDependencyHandler;
+import neatlogic.module.framework.dependency.handler.MatrixAttr2FormAttrDependencyHandler;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class FormImportExportHandler extends ImportExportHandlerBase {
+
+    private List<String> handlerList = new ArrayList<>();
+
+    {
+        handlerList.add(FormHandler.FORMSELECT.getHandler());
+        handlerList.add(FormHandler.FORMRADIO.getHandler());
+        handlerList.add(FormHandler.FORMCHECKBOX.getHandler());
+        handlerList.add(FormHandler.FORMTABLESELECTOR.getHandler());
+    }
+
+    @Resource
+    private FormMapper formMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return FrameworkImportExportHandlerType.FORM;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return formMapper.getFormByName(importExportBaseInfoVo.getName()) != null
+                || formMapper.getFormByUuid((String) importExportBaseInfoVo.getPrimaryKey()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        FormVo form = formMapper.getFormByUuid((String) importExportVo.getPrimaryKey());
+        if (form != null) {
+            return form.getUuid();
+        }
+        form = formMapper.getFormByName(importExportVo.getName());
+        if (form != null) {
+            return form.getUuid();
+        }
+        throw new FormNotFoundException(importExportVo.getName());
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        FormVersionVo formVersion = importExportVo.getData().toJavaObject(FormVersionVo.class);
+        // 处理表单基本信息
+        FormVo form = new FormVo();
+        form.setUuid(formVersion.getFormUuid());
+        form.setName(formVersion.getFormName());
+        form.setIsActive(1);
+        form.setFcu(UserContext.get().getUserUuid());
+        FormVo oldForm = formMapper.getFormByUuid(formVersion.getFormUuid());
+        if (oldForm == null) {
+            oldForm = formMapper.getFormByName(formVersion.getFormName());
+            if (oldForm != null) {
+                form.setUuid(oldForm.getUuid());
+            }
+        }
+        if (oldForm != null) {
+            if (Objects.equals(oldForm.getIsActive(), 1) || Objects.equals(oldForm.getName(), form.getName())) {
+                formMapper.updateForm(form);
+            }
+        } else {
+            formMapper.insertForm(form);
+        }
+
+        importHandle(formVersion, primaryChangeList);
+
+        // 处理表单版本
+        formVersion.setFormUuid(form.getUuid());
+        formVersion.setIsActive(0);
+        FormVersionVo oldFormVersion = formMapper.getFormVersionByUuid(formVersion.getUuid());
+        if (oldFormVersion != null) {
+            // 删除依赖
+            formMapper.deleteFormAttributeMatrixByFormVersionUuid(oldFormVersion.getUuid());
+            List<FormAttributeVo> formAttributeList = oldFormVersion.getFormAttributeList();
+            if (CollectionUtils.isNotEmpty(formAttributeList)) {
+                for (FormAttributeVo formAttributeVo : formAttributeList) {
+                    DependencyManager.delete(MatrixAttr2FormAttrDependencyHandler.class, formAttributeVo.getUuid());
+                    DependencyManager.delete(Integration2FormAttrDependencyHandler.class, formAttributeVo.getUuid());
+                }
+            }
+            formVersion.setLcu(UserContext.get().getUserUuid());
+            formMapper.updateFormVersion(formVersion);
+        } else {
+            Integer version = formMapper.getMaxVersionByFormUuid(form.getUuid());
+            if (version == null) {
+                version = 1;
+            } else {
+                version += 1;
+            }
+            formVersion.setVersion(version);
+            formVersion.setFcu(UserContext.get().getUserUuid());
+            formMapper.insertFormVersion(formVersion);
+        }
+
+        IFormCrossoverService formCrossoverService = CrossoverServiceFactory.getApi(IFormCrossoverService.class);
+        // 插入依赖
+        List<FormAttributeVo> formAttributeList = formVersion.getFormAttributeList();
+        for (FormAttributeVo formAttributeVo : formAttributeList) {
+            formCrossoverService.saveDependency(formAttributeVo);
+        }
+        // 激活版本
+        FormVersionVo oldActiveFormVersion = formMapper.getActionFormVersionByFormUuid(form.getUuid());
+        if (oldActiveFormVersion != null) {
+            formMapper.resetFormVersionIsActiveByFormUuid(formVersion.getFormUuid());
+        }
+        FormVersionVo updateIsActive = new FormVersionVo();
+        updateIsActive.setUuid(formVersion.getUuid());
+        //将当前版本设置为激活版本
+        updateIsActive.setIsActive(1);
+        formMapper.updateFormVersion(updateIsActive);
+        formMapper.deleteFormAttributeByFormUuid(formVersion.getFormUuid());
+        if (CollectionUtils.isNotEmpty(formAttributeList)) {
+            for (FormAttributeVo formAttributeVo : formAttributeList) {
+                formMapper.insertFormAttribute(formAttributeVo);
+            }
+        }
+        return form.getUuid();
+    }
+
+    /**
+     * 导入处理，更新依赖组件的唯一标识
+     * @param formVersion
+     * @param primaryChangeList
+     */
+    private void importHandle(FormVersionVo formVersion, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        JSONObject formConfig = formVersion.getFormConfig();
+        dependencyHandle(IMPORT, formConfig, null, null, primaryChangeList);
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        String uuid = (String) primaryKey;
+        FormVo form = formMapper.getFormByUuid(uuid);
+        if (form == null) {
+            throw new FormNotFoundException(uuid);
+        }
+        FormVersionVo formVersion = formMapper.getActionFormVersionByFormUuid(uuid);
+        if (formVersion == null) {
+            throw new FormActiveVersionNotFoundExcepiton(form.getName());
+        }
+        exportHandle(formVersion, dependencyList, zipOutputStream);
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, formVersion.getFormName());
+        importExportVo.setDataWithObject(formVersion);
+        return importExportVo;
+    }
+
+    /**
+     * 导出处理，先导出依赖组件
+     * @param formVersion
+     * @param dependencyList
+     * @param zipOutputStream
+     */
+    private void exportHandle(FormVersionVo formVersion, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        JSONObject formConfig = formVersion.getFormConfig();
+        dependencyHandle(EXPORT, formConfig, dependencyList, zipOutputStream, null);
+    }
+
+    /**
+     * 导出处理，先导出依赖组件
+     * 导入处理，更新依赖组件的唯一标识
+     * @param action
+     * @param formConfig
+     * @param dependencyList
+     * @param zipOutputStream
+     * @param primaryChangeList
+     */
+    private void dependencyHandle(String action, JSONObject formConfig, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        if (MapUtils.isEmpty(formConfig)) {
+            return;
+        }
+        JSONArray tableList = formConfig.getJSONArray("tableList");
+        if (CollectionUtils.isNotEmpty(tableList)) {
+            for (int i = 0; i < tableList.size(); i++) {
+                JSONObject tableObj = tableList.getJSONObject(i);
+                if (MapUtils.isEmpty(tableObj)) {
+                    continue;
+                }
+                JSONObject component = tableObj.getJSONObject("component");
+                componentHandle(action, component, dependencyList, zipOutputStream, primaryChangeList);
+
+            }
+        }
+        JSONArray sceneList = formConfig.getJSONArray("sceneList");
+        if (CollectionUtils.isNotEmpty(sceneList)) {
+            for (int i = 0; i < sceneList.size(); i++) {
+                JSONObject sceneObj = sceneList.getJSONObject(i);
+                dependencyHandle(action, sceneObj, dependencyList, zipOutputStream, primaryChangeList);
+            }
+        }
+    }
+
+    /**
+     * 处理表单单个组件配置信息
+     * @param action
+     * @param component
+     * @param dependencyList
+     * @param zipOutputStream
+     * @param primaryChangeList
+     */
+    private void componentHandle(String action, JSONObject component, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        if (MapUtils.isEmpty(component)) {
+            return;
+        }
+        Boolean inherit = component.getBoolean("inherit");
+        if (Objects.equals(inherit, true)) {
+            return;
+        }
+        String handler = component.getString("handler");
+        if (handlerList.contains(handler)) {
+            // 单选框、复选框、下拉框、表格选择组件
+            JSONObject config = component.getJSONObject("config");
+            if (MapUtils.isEmpty(config)) {
+                return;
+            }
+            String dataSource = config.getString("dataSource");
+            if (!Objects.equals(dataSource, "matrix")) {
+                return;
+            }
+            String matrixUuid = config.getString("matrixUuid");
+            if (StringUtils.isBlank(matrixUuid)) {
+                return;
+            }
+            if (action == IMPORT) {
+                Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.MATRIX, matrixUuid, primaryChangeList);
+                if (newPrimaryKey != null) {
+                    config.put("matrixUuid", newPrimaryKey);
+                }
+            } else if (action == EXPORT) {
+                doExportData(FrameworkImportExportHandlerType.MATRIX, matrixUuid, dependencyList, zipOutputStream);
+            }
+        } else if (Objects.equals(handler, FormHandler.FORMTABLEINPUTER.getHandler())) {
+            // 表格输入组件
+            JSONObject config = component.getJSONObject("config");
+            if (MapUtils.isEmpty(config)) {
+                return;
+            }
+            JSONArray dataConfig = config.getJSONArray("dataConfig");
+            for (int i = 0; i < dataConfig.size(); i++) {
+                JSONObject dataObj = dataConfig.getJSONObject(i);
+                if (Objects.equals(dataObj.getString("handler"), "formtable")) {
+                    JSONObject config1 = dataObj.getJSONObject("config");
+                    if (MapUtils.isEmpty(config1)) {
+                        continue;
+                    }
+                    JSONArray dataConfig1 = config1.getJSONArray("dataConfig");
+                    for (int j = 0; j < dataConfig1.size(); j++) {
+                        JSONObject dataObj1 = dataConfig1.getJSONObject(j);
+                        componentHandle(action, dataObj1, dependencyList, zipOutputStream, primaryChangeList);
+                    }
+                } else {
+                    componentHandle(action, dataObj, dependencyList, zipOutputStream, primaryChangeList);
+                }
+            }
+        } else if (Objects.equals(handler, FormHandler.FORMTAB.getHandler()) || Objects.equals(handler, FormHandler.FORMCOLLAPSE.getHandler())) {
+            // 选项卡、折叠面板
+            JSONArray componentArray = component.getJSONArray("component");
+            for (int i = 0; i < componentArray.size(); i++) {
+                JSONObject componentObj = componentArray.getJSONObject(i);
+                componentHandle(action, componentObj, dependencyList, zipOutputStream, primaryChangeList);
+            }
+        } else if (Objects.equals(handler, FormHandler.FORMSUBASSEMBLY.getHandler())) {
+            // 子表单
+            JSONObject formData = component.getJSONObject("formData");
+            if (MapUtils.isEmpty(formData)) {
+                return;
+            }
+            JSONObject formConfig = formData.getJSONObject("formConfig");
+            dependencyHandle(action, formConfig, dependencyList, zipOutputStream, primaryChangeList);
+        }
+    }
+}
diff --git a/src/main/java/neatlogic/module/framework/importexport/handler/IntegrationImportExportHandler.java b/src/main/java/neatlogic/module/framework/importexport/handler/IntegrationImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a15918901808c6bff2efeceadc4a2d38ffee97a
--- /dev/null
+++ b/src/main/java/neatlogic/module/framework/importexport/handler/IntegrationImportExportHandler.java
@@ -0,0 +1,83 @@
+package neatlogic.module.framework.importexport.handler;
+
+import neatlogic.framework.asynchronization.threadlocal.UserContext;
+import neatlogic.framework.exception.integration.IntegrationNotFoundException;
+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.framework.integration.dao.mapper.IntegrationMapper;
+import neatlogic.framework.integration.dto.IntegrationVo;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class IntegrationImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private IntegrationMapper integrationMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return FrameworkImportExportHandlerType.INTEGRATION;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return integrationMapper.getIntegrationByName(importExportBaseInfoVo.getName()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        IntegrationVo integration = integrationMapper.getIntegrationByName(importExportVo.getName());
+        if (integration == null) {
+            throw new IntegrationNotFoundException(importExportVo.getName());
+        }
+        return integration.getUuid();
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        IntegrationVo integration = importExportVo.getData().toJavaObject(IntegrationVo.class);
+        IntegrationVo oldIntegration = integrationMapper.getIntegrationByName(importExportVo.getName());
+        if (oldIntegration != null) {
+            integration.setUuid(oldIntegration.getUuid());
+            integration.setLcu(UserContext.get().getUserUuid());
+            integrationMapper.updateIntegration(integration);
+        } else {
+            if (integrationMapper.getIntegrationByUuid(integration.getUuid()) != null) {
+                integration.setUuid(null);
+            }
+            integration.setFcu(UserContext.get().getUserUuid());
+            integrationMapper.insertIntegration(integration);
+        }
+        return integration.getUuid();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        String uuid = (String) primaryKey;
+        IntegrationVo integration = integrationMapper.getIntegrationByUuid(uuid);
+        if (integration == null) {
+            throw new IntegrationNotFoundException(uuid);
+        }
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, integration.getName());
+        importExportVo.setDataWithObject(integration);
+        return importExportVo;
+    }
+}
diff --git a/src/main/java/neatlogic/module/framework/importexport/handler/MatrixImportExportHandler.java b/src/main/java/neatlogic/module/framework/importexport/handler/MatrixImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..274968ba7cbc1b4d0409a1cfb4c7344f615be003
--- /dev/null
+++ b/src/main/java/neatlogic/module/framework/importexport/handler/MatrixImportExportHandler.java
@@ -0,0 +1,112 @@
+package neatlogic.module.framework.importexport.handler;
+
+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.framework.matrix.core.IMatrixDataSourceHandler;
+import neatlogic.framework.matrix.core.MatrixDataSourceHandlerFactory;
+import neatlogic.framework.matrix.dao.mapper.MatrixMapper;
+import neatlogic.framework.matrix.dto.MatrixVo;
+import neatlogic.framework.matrix.exception.MatrixDataSourceHandlerNotFoundException;
+import neatlogic.framework.matrix.exception.MatrixNotFoundException;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Objects;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class MatrixImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private MatrixMapper matrixMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return FrameworkImportExportHandlerType.MATRIX;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return matrixMapper.getMatrixByLabel(importExportBaseInfoVo.getName()) != null
+                || matrixMapper.getMatrixByUuid((String) importExportBaseInfoVo.getPrimaryKey()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        MatrixVo matrix = matrixMapper.getMatrixByUuid((String) importExportVo.getPrimaryKey());
+        if (matrix != null) {
+            return matrix.getUuid();
+        }
+        matrix = matrixMapper.getMatrixByLabel(importExportVo.getName());
+        if (matrix != null) {
+            return matrix.getUuid();
+        }
+        throw new MatrixNotFoundException(importExportVo.getName());
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        MatrixVo matrix = importExportVo.getData().toJavaObject(MatrixVo.class);
+        MatrixVo oldMatrix = matrixMapper.getMatrixByUuid(matrix.getUuid());
+        if (oldMatrix == null) {
+            oldMatrix = matrixMapper.getMatrixByLabel(importExportVo.getName());
+            if (oldMatrix != null) {
+                matrix.setUuid(oldMatrix.getUuid());
+            }
+        }
+        IMatrixDataSourceHandler matrixDataSourceHandler = MatrixDataSourceHandlerFactory.getHandler(matrix.getType());
+        if (matrixDataSourceHandler == null) {
+            throw new MatrixDataSourceHandlerNotFoundException(matrix.getType());
+        }
+        if (Objects.equals(matrix.getType(), "external")) {
+            Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.INTEGRATION, matrix.getIntegrationUuid(), primaryChangeList);
+            if (newPrimaryKey != null) {
+                matrix.setIntegrationUuid((String) newPrimaryKey);
+            }
+        } else if (Objects.equals(matrix.getType(), "cmdbci")) {
+            Object newPrimaryKey = getNewPrimaryKey(FrameworkImportExportHandlerType.CMDB_CI, matrix.getId(), primaryChangeList);
+            if (newPrimaryKey != null) {
+                matrix.setCiId((Long) newPrimaryKey);
+            }
+        }
+        matrixDataSourceHandler.importMatrix(matrix);
+        return matrix.getUuid();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        String uuid = (String) primaryKey;
+        MatrixVo matrix = matrixMapper.getMatrixByUuid(uuid);
+        if (matrix == null) {
+            throw new MatrixNotFoundException(uuid);
+        }
+        IMatrixDataSourceHandler matrixDataSourceHandler = MatrixDataSourceHandlerFactory.getHandler(matrix.getType());
+        if (matrixDataSourceHandler == null) {
+            throw new MatrixDataSourceHandlerNotFoundException(matrix.getType());
+        }
+        MatrixVo matrixVo = matrixDataSourceHandler.exportMatrix(matrix);
+        if (Objects.equals(matrix.getType(), "external")) {
+            doExportData(FrameworkImportExportHandlerType.INTEGRATION, matrixVo.getIntegrationUuid(), dependencyList, zipOutputStream);
+        } else if (Objects.equals(matrix.getType(), "cmdbci")) {
+            doExportData(FrameworkImportExportHandlerType.CMDB_CI, matrixVo.getId(), dependencyList, zipOutputStream);
+        }
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, matrixVo.getLabel());
+        importExportVo.setDataWithObject(matrixVo);
+        return importExportVo;
+    }
+}
diff --git a/src/main/java/neatlogic/module/framework/importexport/handler/NotifyPolicyImportExportHandler.java b/src/main/java/neatlogic/module/framework/importexport/handler/NotifyPolicyImportExportHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..6409635c2406ef7fa6b54c6d9208c6924052742e
--- /dev/null
+++ b/src/main/java/neatlogic/module/framework/importexport/handler/NotifyPolicyImportExportHandler.java
@@ -0,0 +1,110 @@
+package neatlogic.module.framework.importexport.handler;
+
+import neatlogic.framework.asynchronization.threadlocal.UserContext;
+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.framework.notify.core.INotifyPolicyHandler;
+import neatlogic.framework.notify.core.NotifyPolicyHandlerFactory;
+import neatlogic.framework.notify.dao.mapper.NotifyMapper;
+import neatlogic.framework.notify.dto.NotifyPolicyVo;
+import neatlogic.framework.notify.exception.NotifyPolicyHandlerNotFoundException;
+import neatlogic.framework.notify.exception.NotifyPolicyNotFoundException;
+import neatlogic.framework.util.$;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Objects;
+import java.util.zip.ZipOutputStream;
+
+@Component
+public class NotifyPolicyImportExportHandler extends ImportExportHandlerBase {
+
+    @Resource
+    private NotifyMapper notifyMapper;
+
+    @Override
+    public ImportExportHandlerType getType() {
+        return FrameworkImportExportHandlerType.NOTIFY_POLICY;
+    }
+
+    @Override
+    public boolean checkImportAuth(ImportExportVo importExportVo) {
+        return true;
+    }
+
+    @Override
+    public boolean checkExportAuth(Object primaryKey) {
+        return true;
+    }
+
+    @Override
+    public boolean checkIsExists(ImportExportBaseInfoVo importExportBaseInfoVo) {
+        return getNotifyPolicyByName(importExportBaseInfoVo.getName()) != null;
+    }
+
+    @Override
+    public Object getPrimaryByName(ImportExportVo importExportVo) {
+        NotifyPolicyVo notifyPolicy = getNotifyPolicyByName(importExportVo.getName());
+        if (notifyPolicy == null) {
+            throw new NotifyPolicyNotFoundException(importExportVo.getName());
+        }
+        return notifyPolicy.getId();
+    }
+
+    @Override
+    public Object importData(ImportExportVo importExportVo, List<ImportExportPrimaryChangeVo> primaryChangeList) {
+        NotifyPolicyVo notifyPolicy = importExportVo.getData().toJavaObject(NotifyPolicyVo.class);
+        NotifyPolicyVo oldNotifyPolicy = getNotifyPolicyByName(importExportVo.getName());
+        if (oldNotifyPolicy != null) {
+            notifyPolicy.setId(oldNotifyPolicy.getId());
+            notifyPolicy.setLcu(UserContext.get().getUserUuid(true));
+            notifyMapper.updateNotifyPolicyById(notifyPolicy);
+        } else {
+            if (notifyMapper.getNotifyPolicyById(notifyPolicy.getId()) != null) {
+                notifyPolicy.setId(null);
+            }
+            notifyPolicy.setFcu(UserContext.get().getUserUuid(true));
+            notifyMapper.insertNotifyPolicy(notifyPolicy);
+        }
+        return notifyPolicy.getId();
+    }
+
+    @Override
+    protected ImportExportVo myExportData(Object primaryKey, List<ImportExportBaseInfoVo> dependencyList, ZipOutputStream zipOutputStream) {
+        Long id = (Long) primaryKey;
+        NotifyPolicyVo notifyPolicy = notifyMapper.getNotifyPolicyById(id);
+        if (notifyPolicy == null) {
+            throw new NotifyPolicyNotFoundException(id);
+        }
+        INotifyPolicyHandler notifyPolicyHandler = NotifyPolicyHandlerFactory.getHandler(notifyPolicy.getHandler());
+        if (notifyPolicyHandler == null) {
+            throw new NotifyPolicyHandlerNotFoundException(notifyPolicy.getHandler());
+        }
+        String name = $.t(notifyPolicyHandler.getName()) + "/" + notifyPolicy.getName();
+        ImportExportVo importExportVo = new ImportExportVo(this.getType().getValue(), primaryKey, name);
+        importExportVo.setDataWithObject(notifyPolicy);
+        return importExportVo;
+    }
+
+    private NotifyPolicyVo getNotifyPolicyByName(String name) {
+        String[] spilt = name.split("/");
+        String handlerName = spilt[0];
+        String notifyPolicyName = spilt[1];
+        List<NotifyPolicyVo> list = notifyMapper.getNotifyPolicyListByName(notifyPolicyName);
+        for (NotifyPolicyVo notifyPolicy : list) {
+            INotifyPolicyHandler notifyPolicyHandler = NotifyPolicyHandlerFactory.getHandler(notifyPolicy.getHandler());
+            if (notifyPolicyHandler == null) {
+                continue;
+            }
+            if (Objects.equals($.t(notifyPolicyHandler.getName()), handlerName)) {
+                return notifyPolicy;
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/neatlogic/module/framework/matrix/handler/CustomDataSourceHandler.java b/src/main/java/neatlogic/module/framework/matrix/handler/CustomDataSourceHandler.java
index 5a9fc401b6e6b769d490ec972f7f5e0abc59e1e6..9b743e224f3bfa79e1e283910dcb12cdd1045570 100644
--- a/src/main/java/neatlogic/module/framework/matrix/handler/CustomDataSourceHandler.java
+++ b/src/main/java/neatlogic/module/framework/matrix/handler/CustomDataSourceHandler.java
@@ -117,6 +117,8 @@ public class CustomDataSourceHandler extends MatrixDataSourceHandlerBase {
                 attributeVo.setUuid(targetAttributeUuid);
                 attributeMapper.insertMatrixAttribute(attributeVo);
             }
+            sourceColumnList.add("sort");
+            targetColumnList.add("sort");
             attributeMapper.createMatrixDynamicTable(attributeVoList, targetUuid);
             //数据拷贝
             matrixDataMapper.insertDynamicTableDataForCopy(sourceUuid, sourceColumnList, targetUuid, targetColumnList);