项目初始化

datax-common/datax-common-database/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>datax-common</artifactId>
+        <groupId>cn.datax</groupId>
+        <version>1.0.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>datax-common-database</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jdbc</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>
\ No newline at end of file

datax-common/datax-common-database/src/main/java/cn/datax/common/database/DataSourceFactory.java

+package cn.datax.common.database;
+
+import cn.datax.common.database.constants.DbQueryProperty;
+
+public interface DataSourceFactory {
+
+    /**
+     * 创建数据源实例
+     *
+     * @param property
+     * @return
+     */
+    DbQuery createDbQuery(DbQueryProperty property);
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/DbDialect.java

+package cn.datax.common.database;
+
+import cn.datax.common.database.core.DbColumn;
+import org.springframework.jdbc.core.RowMapper;
+
+/**
+ * 表数据查询接口
+ *
+ * @author yuwei
+ * @since 2020-03-14
+ */
+public interface DbDialect {
+
+    RowMapper<DbColumn> rowMapper();
+
+    /**
+     * 使用数据库
+     *
+     * @param dbName
+     * @return
+     */
+    String useDatabase(String dbName);
+
+    /**
+     * 获取指定表的所有列
+     *
+     * @param tableName
+     * @return
+     */
+    String columns(String dbName, String tableName);
+
+    /**
+     * 获取数据库下的 所有表
+     *
+     * @param dbName
+     * @return
+     */
+    String tables(String dbName);
+
+    /**
+     * 获取数据库版本
+     *
+     * @return
+     */
+    String version();
+
+    /**
+     * 获取指定数据源具有的数据库
+     *
+     * @return
+     */
+    String database();
+
+    /**
+     * 构建 分页 sql
+     *
+     * @param sql
+     * @param offset
+     * @param count
+     * @return
+     */
+    String buildPaginationSql(String sql, long offset, long count);
+
+    /**
+     * 包装 count sql
+     *
+     * @param sql
+     * @return
+     */
+    String count(String sql);
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/DbQuery.java

+package cn.datax.common.database;
+
+import cn.datax.common.database.core.DbColumn;
+import cn.datax.common.database.core.PageResult;
+
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 表数据查询接口
+ *
+ * @author yuwei
+ * @since 2020-03-14
+ */
+public interface DbQuery {
+
+    /**
+     * 检测连通性
+     */
+    boolean valid() throws SQLException;
+
+    /**
+     * 使用其他数据库
+     *
+     * @param dbName
+     * @return
+     */
+    void useDatabase(String dbName);
+
+    /**
+     * 关闭数据源
+     */
+    void close();
+
+    /**
+     * 获取版本
+     *
+     * @return
+     */
+    String getVersion();
+
+    /**
+     *  获取指定表 具有的所有字段列表
+     * @param dbName
+     * @param tableName
+     * @return
+     */
+    List<DbColumn> getTableColumns(String dbName, String tableName);
+
+    /**
+     * 获取指定数据库下 所有的表信息
+     *
+     * @param dbName
+     * @return
+     */
+    List<String> getTables(String dbName);
+
+    /**
+     * 获取数据库列表
+     *
+     * @return
+     */
+    List<String> getDatabases();
+
+    /**
+     * 获取总数
+     *
+     * @param sql
+     * @return
+     */
+    int count(String sql);
+
+    /**
+     * 查询结果列表
+     *
+     * @param sql
+     * @return
+     */
+    List<Map<String, Object>> queryList(String sql);
+
+    /**
+     * 查询结果分页
+     *
+     * @param sql
+     * @param offset
+     * @param size
+     * @return
+     */
+    PageResult<Map<String, Object>> queryByPage(String sql, long offset, long size);
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/DialectFactory.java

+package cn.datax.common.database;
+
+import cn.datax.common.database.constants.DbType;
+import cn.datax.common.database.dialect.DialectRegistry;
+
+/**
+ * 方言工厂类
+ *
+ * @author yuwei
+ * @since 2020-03-14
+ */
+public class DialectFactory {
+
+    private static final DialectRegistry DIALECT_REGISTRY = new DialectRegistry();
+
+    public static DbDialect getDialect(DbType dbType) {
+        return DIALECT_REGISTRY.getDialect(dbType);
+    }
+}

datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/entity/DataSchema.java → datax-common/datax-common-database/src/main/java/cn/datax/common/database/constants/DbQueryProperty.java

-package cn.datax.service.data.factory.api.entity;
+package cn.datax.common.database.constants;
 
-import cn.datax.common.exception.DataException;
-import cn.hutool.core.util.StrUtil;
+import cn.datax.common.database.exception.DataQueryException;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import org.apache.commons.lang.StringUtils;
 
 import java.io.Serializable;
 
 @Data
-public class DataSchema implements Serializable {
+@AllArgsConstructor
+public class DbQueryProperty implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
+    private String dbType;
     private String jdbcUrl;
     private String username;
     private String password;
@@ -19,8 +22,11 @@ public class DataSchema implements Serializable {
      * 参数合法性校验
      */
     public void viald() {
-        if (StrUtil.isBlank(jdbcUrl) || StrUtil.isBlank(username) || StrUtil.isBlank(password)) {
-            throw new DataException("参数不完整");
+        if (StringUtils.isEmpty(jdbcUrl) || StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
+            throw new DataQueryException("参数不完整");
+        }
+        if (DbType.OTHER.getDb().equals(dbType)) {
+            throw new DataQueryException("不支持的数据库类型");
         }
     }
 }

datax-common/datax-common-database/src/main/java/cn/datax/common/database/constants/DbType.java

+package cn.datax.common.database.constants;
+
+/**
+ * 数据库类型
+ *
+ * @author yuwei
+ * @since 2020-03-14
+ */
+public enum DbType {
+
+    /**
+     * MYSQL
+     */
+    MYSQL("mysql", "MySql数据库"),
+    /**
+     * MARIADB
+     */
+    MARIADB("mariadb", "MariaDB数据库"),
+    /**
+     * ORACLE
+     */
+    ORACLE("oracle", "Oracle11g及以下数据库(高版本推荐使用ORACLE_NEW)"),
+    /**
+     * oracle12c new pagination
+     */
+    ORACLE_12C("oracle12c", "Oracle12c+数据库"),
+    /**
+     * DB2
+     */
+    DB2("db2", "DB2数据库"),
+    /**
+     * H2
+     */
+    H2("h2", "H2数据库"),
+    /**
+     * HSQL
+     */
+    HSQL("hsql", "HSQL数据库"),
+    /**
+     * SQLITE
+     */
+    SQLITE("sqlite", "SQLite数据库"),
+    /**
+     * POSTGRE
+     */
+    POSTGRE_SQL("postgresql", "Postgre数据库"),
+    /**
+     * SQLSERVER2005
+     */
+    SQL_SERVER2005("sqlserver2005", "SQLServer2005数据库"),
+    /**
+     * SQLSERVER
+     */
+    SQL_SERVER("sqlserver", "SQLServer数据库"),
+    /**
+     * UNKONWN DB
+     */
+    OTHER("other", "其他数据库");
+
+    /**
+     * 数据库名称
+     */
+    private final String db;
+
+    /**
+     * 描述
+     */
+    private final String desc;
+
+    public String getDb() {
+        return this.db;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    DbType(String db, String desc) {
+        this.db = db;
+        this.desc = desc;
+    }
+
+    /**
+     * 获取数据库类型
+     *
+     * @param dbType 数据库类型字符串
+     */
+    public static DbType getDbType(String dbType) {
+        for (DbType type : DbType.values()) {
+            if (type.db.equalsIgnoreCase(dbType)) {
+                return type;
+            }
+        }
+        return OTHER;
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/core/DbColumn.java

+package cn.datax.common.database.core;
+
+import lombok.Data;
+
+@Data
+public class DbColumn {
+
+    private String name;
+
+    private String type;
+
+    private String length;
+
+    private String nullable;
+
+    private String hasKey;
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/core/PageResult.java

+package cn.datax.common.database.core;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Data
+@Accessors(chain = true)
+public class PageResult<T> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private long pageNum;
+    private long pageSize;
+    private long total;
+    private List<T> data;
+
+    public PageResult(long pageNum, long pageSize, long total, List<T> data) {
+        this.pageNum = pageNum;
+        this.pageSize = pageSize;
+        this.total = total;
+        this.data = data;
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/datasource/AbstractDataSourceFactory.java

+package cn.datax.common.database.datasource;
+
+import cn.datax.common.database.DataSourceFactory;
+import cn.datax.common.database.DbQuery;
+import cn.datax.common.database.constants.DbQueryProperty;
+import cn.datax.common.database.constants.DbType;
+import cn.datax.common.database.exception.DataQueryException;
+import cn.datax.common.database.query.MySqlDbQuery;
+import com.zaxxer.hikari.HikariDataSource;
+
+import javax.sql.DataSource;
+
+public abstract class AbstractDataSourceFactory implements DataSourceFactory {
+
+    @Override
+    public DbQuery createDbQuery(DbQueryProperty property) {
+        property.viald();
+        DbType dbType = DbType.getDbType(property.getDbType());
+        DataSource dataSource = createDataSource(property);
+        DbQuery dbQuery = createDbQueryTemplate(dataSource, dbType);
+        return dbQuery;
+    }
+
+    public DbQuery createDbQueryTemplate(DataSource dataSource, DbType dbType) {
+        DbQuery dbQuery;
+        switch (dbType) {
+            case MYSQL: {
+                dbQuery = new MySqlDbQuery(dataSource);
+                break;
+            }
+            default: {
+                throw new DataQueryException("不支持的数据库类型");
+            }
+        }
+        return dbQuery;
+    }
+
+    public DataSource createDataSource(DbQueryProperty property) {
+        HikariDataSource dataSource = new HikariDataSource();
+        dataSource.setJdbcUrl(property.getJdbcUrl());
+        dataSource.setUsername(property.getUsername());
+        dataSource.setPassword(property.getPassword());
+        return dataSource;
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/datasource/CacheDataSourceFactoryBean.java

+package cn.datax.common.database.datasource;
+
+import cn.datax.common.database.constants.DbQueryProperty;
+
+import javax.sql.DataSource;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class CacheDataSourceFactoryBean extends AbstractDataSourceFactory {
+
+    /**
+     * 数据源缓存
+     */
+    private static Map<String, DataSource> dataSourceMap = new ConcurrentHashMap<>();
+
+    @Override
+    public DataSource createDataSource(DbQueryProperty property) {
+        String key = property.getJdbcUrl();
+        DataSource dataSource = dataSourceMap.get(key);
+        if (null == dataSource) {
+            synchronized (CacheDataSourceFactoryBean.class) {
+                if (null == dataSource) {
+                    dataSource = super.createDataSource(property);
+                    dataSourceMap.put(key, dataSource);
+                }
+            }
+        }
+        return dataSource;
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/datasource/DefaultDataSourceFactoryBean.java

+package cn.datax.common.database.datasource;
+
+public class DefaultDataSourceFactoryBean extends AbstractDataSourceFactory {
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/dialect/AbstractDbDialect.java

+package cn.datax.common.database.dialect;
+
+import cn.datax.common.database.DbDialect;
+
+/**
+ * 表数据查询抽象类
+ *
+ * @author yuwei
+ * @since 2020-03-14
+ */
+public abstract class AbstractDbDialect implements DbDialect {
+
+    @Override
+    public String useDatabase(String dbName) {
+        return "use `" + dbName + "`";
+    }
+
+    @Override
+    public String columns(String dbName, String tableName) {
+        return "show columns from `" + tableName + "`;";
+    }
+
+    @Override
+    public String tables(String dbName) {
+        return "show tables";
+    }
+
+    @Override
+    public String version() {
+        return "SELECT VERSION()";
+    }
+
+    @Override
+    public String database() {
+        return "show databases";
+    }
+
+    @Override
+    public String buildPaginationSql(String sql, long offset, long count) {
+        // 获取 分页实际条数
+        StringBuilder builder = new StringBuilder(sql);
+        builder.append(" LIMIT ").append(offset).append(" , ").append(count);
+        return builder.toString();
+    }
+
+    @Override
+    public String count(String sql) {
+        return "SELECT COUNT(*) FROM ( " + sql + " ) TEMP";
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/dialect/DialectRegistry.java

+package cn.datax.common.database.dialect;
+
+import cn.datax.common.database.DbDialect;
+import cn.datax.common.database.constants.DbType;
+
+import java.util.*;
+
+public class DialectRegistry {
+
+    private final Map<DbType, DbDialect> dialect_enum_map = new EnumMap<>(DbType.class);
+
+    public DialectRegistry() {
+        dialect_enum_map.put(DbType.MYSQL, new MySqlDialect());
+    }
+
+    public DbDialect getDialect(DbType dbType) {
+        return dialect_enum_map.get(dbType);
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/dialect/MySqlDialect.java

+package cn.datax.common.database.dialect;
+
+import cn.datax.common.database.core.DbColumn;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+
+/**
+ * MySql 表数据查询
+ *
+ * @author yuwei
+ * @since 2020-03-14
+ */
+public class MySqlDialect extends AbstractDbDialect {
+
+    @Override
+    public RowMapper<DbColumn> rowMapper() {
+        return (ResultSet rs, int rowNum) -> {
+            DbColumn entity = new DbColumn();
+            entity.setName(rs.getString("Field"));
+            entity.setType(rs.getString("Type"));
+            entity.setNullable(rs.getString("Null"));
+            entity.setHasKey(rs.getString("Key"));
+            entity.setLength(rs.getString("Extra"));
+            return entity;
+        };
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/exception/DataQueryException.java

+package cn.datax.common.database.exception;
+
+public class DataQueryException extends RuntimeException {
+
+    public DataQueryException(String message) {
+        super(message);
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/query/AbstractDbQuery.java

+package cn.datax.common.database.query;
+
+import cn.datax.common.database.DbDialect;
+import cn.datax.common.database.DbQuery;
+import cn.datax.common.database.core.DbColumn;
+import cn.datax.common.database.core.PageResult;
+import cn.datax.common.database.exception.DataQueryException;
+import com.zaxxer.hikari.HikariDataSource;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+
+public abstract class AbstractDbQuery implements DbQuery {
+
+    protected DataSource dataSource;
+
+    protected JdbcTemplate jdbcTemplate;
+
+    protected DbDialect dbDialect;
+
+    public AbstractDbQuery(DataSource dataSource) {
+        this.dataSource = dataSource;
+        this.jdbcTemplate = new JdbcTemplate(dataSource);
+    }
+
+    @Override
+    public boolean valid() throws SQLException {
+        Connection conn = dataSource.getConnection();
+        boolean valid = conn.isValid(0);
+        if (conn != null) {
+            conn.close();
+        }
+        return valid;
+    }
+
+    @Override
+    public void useDatabase(String dbName) {
+        String sql = dbDialect.useDatabase(dbName);
+        jdbcTemplate.execute(sql);
+    }
+
+    @Override
+    public void close() {
+        if (dataSource instanceof HikariDataSource) {
+            ((HikariDataSource) dataSource).close();
+        } else {
+            throw new DataQueryException("不合法数据源类型");
+        }
+    }
+
+    @Override
+    public String getVersion() {
+        return jdbcTemplate.queryForObject(dbDialect.version(), String.class);
+    }
+
+    @Override
+    public List<DbColumn> getTableColumns(String dbName, String tableName) {
+        String sql = dbDialect.columns(dbName, tableName);
+        return jdbcTemplate.query(sql, dbDialect.rowMapper());
+    }
+
+    @Override
+    public List<String> getTables(String dbName) {
+        useDatabase(dbName);
+        return jdbcTemplate.queryForList(dbDialect.tables(dbName), String.class);
+    }
+
+    @Override
+    public List<String> getDatabases() {
+        return jdbcTemplate.queryForList(dbDialect.database(), String.class);
+    }
+
+    @Override
+    public int count(String sql) {
+        return jdbcTemplate.queryForObject(dbDialect.count(sql), Integer.class);
+    }
+
+    @Override
+    public List<Map<String, Object>> queryList(String sql) {
+        return jdbcTemplate.queryForList(sql);
+    }
+
+    @Override
+    public PageResult<Map<String, Object>> queryByPage(String sql, long offset, long size) {
+        int total = count(sql);
+
+        String pageSql = dbDialect.buildPaginationSql(sql, offset, size);
+        List<Map<String, Object>> records = jdbcTemplate.queryForList(pageSql);
+
+        return new PageResult<>(offset, size, total, records);
+    }
+}

datax-common/datax-common-database/src/main/java/cn/datax/common/database/query/MySqlDbQuery.java

+package cn.datax.common.database.query;
+
+import cn.datax.common.database.dialect.MySqlDialect;
+
+import javax.sql.DataSource;
+
+public class MySqlDbQuery extends AbstractDbQuery {
+
+    public MySqlDbQuery(DataSource dataSource) {
+        super(dataSource);
+        dbDialect = new MySqlDialect();
+    }
+}

datax-common/datax-common-security/pom.xml

@@ -32,7 +32,7 @@
         <dependency>
             <groupId>cn.datax</groupId>
             <artifactId>datax-common-core</artifactId>
-            <version>1.0.0</version>
+            <version>${app.version}</version>
         </dependency>
         <dependency>
             <groupId>cn.datax</groupId>

datax-common/pom.xml

@@ -18,6 +18,7 @@
         <module>datax-common-mybatis</module>
         <module>datax-common-security</module>
         <module>datax-common-log</module>
+        <module>datax-common-database</module>
     </modules>
 
 </project>
\ No newline at end of file

datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/dto/DataSourceDto.java

@@ -28,7 +28,7 @@ public class DataSourceDto implements Serializable {
     private String id;
     @ApiModelProperty(value = "数据源类型")
     @NotBlank(message = "数据源类型不能为空", groups = {ValidateGroupForSave.class, ValidateGroupForUpdate.class})
-    private String sourceType;
+    private String dbType;
     @ApiModelProperty(value = "数据源名称")
     @NotBlank(message = "数据源名称不能为空", groups = {ValidateGroupForSave.class, ValidateGroupForUpdate.class})
     private String sourceName;
@@ -37,5 +37,5 @@ public class DataSourceDto implements Serializable {
     private String sourceDesc;
     @ApiModelProperty(value = "数据源连接信息")
     @Valid
-    private DataSchemaDto sourceSchema;
+    private DbSchemaDto dbSchema;
 }

datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/dto/DataSchemaDto.java → datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/dto/DbSchemaDto.java

@@ -11,7 +11,7 @@ import java.io.Serializable;
 
 @ApiModel(value = "数据源连接信息Model")
 @Data
-public class DataSchemaDto implements Serializable {
+public class DbSchemaDto implements Serializable {
 
     private static final long serialVersionUID=1L;
 

datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/entity/DataSourceEntity.java

@@ -27,7 +27,7 @@ public class DataSourceEntity extends BaseEntity {
     /**
      * 数据源类型
      */
-    private String sourceType;
+    private String dbType;
 
     /**
      * 数据源名称
@@ -43,5 +43,5 @@ public class DataSourceEntity extends BaseEntity {
      * 数据源连接信息
      */
     @TableField(typeHandler = JacksonTypeHandler.class)
-    private DataSchema sourceSchema;
+    private DbSchema dbSchema;
 }

datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/entity/DbSchema.java

+package cn.datax.service.data.factory.api.entity;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+public class DbSchema implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String jdbcUrl;
+    private String username;
+    private String password;
+}

datax-modules/data-factory-service-parent/data-factory-service-api/src/main/java/cn/datax/service/data/factory/api/vo/DataSourceVo.java

 package cn.datax.service.data.factory.api.vo;
 
-import cn.datax.service.data.factory.api.entity.DataSchema;
+import cn.datax.service.data.factory.api.entity.DbSchema;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.Data;
 
@@ -24,8 +24,8 @@ public class DataSourceVo implements Serializable {
     private Integer status;
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private LocalDateTime createTime;
-    private String sourceType;
+    private String dbType;
     private String sourceName;
     private String sourceDesc;
-    private DataSchema sourceSchema;
+    private DbSchema dbSchema;
 }

datax-modules/data-factory-service-parent/data-factory-service/pom.xml

@@ -59,6 +59,11 @@
             <artifactId>datax-common-security</artifactId>
             <version>${app.version}</version>
         </dependency>
+        <dependency>
+            <groupId>cn.datax</groupId>
+            <artifactId>datax-common-database</artifactId>
+            <version>${app.version}</version>
+        </dependency>
 <!--        <dependency>-->
 <!--            <groupId>cn.datax</groupId>-->
 <!--            <artifactId>datax-common-log</artifactId>-->

datax-modules/data-factory-service-parent/data-factory-service/src/main/java/cn/datax/service/data/factory/controller/DataSourceController.java

@@ -120,9 +120,27 @@ public class DataSourceController extends BaseController {
         return R.ok();
     }
 
+    /**
+     * 数据库类型
+     * @return
+     */
+    @ApiOperation(value = "数据库类型", notes = "获取数据库类型")
+    @GetMapping("/dbTypes")
+    public R getDbTypes() {
+        List<String> dbTypes = dataSourceService.getDbTypes();
+        return R.ok().setData(dbTypes);
+    }
+
+    /**
+     * 检测数据库连通性
+     * @param dataSource
+     * @return
+     */
+    @ApiOperation(value = "数据库连通性", notes = "根据数据库配置信息检测数据库连通性")
+    @ApiImplicitParam(name = "dataSource", value = "详细实体dataSource", required = true, dataType = "DataSourceDto")
     @PostMapping("/checkConnection")
     public R checkConnection(@RequestBody @Validated({ValidateGroupForSave.class}) DataSourceDto dataSource) {
-        R r = dataSourceService.checkConnection(dataSource);
-        return r;
+        Boolean valid = dataSourceService.checkConnection(dataSource);
+        return valid ? R.ok() : R.error("数据库连接有误，请检查数据库配置是否正确");
     }
 }

datax-modules/data-factory-service-parent/data-factory-service/src/main/java/cn/datax/service/data/factory/service/DataSourceService.java

@@ -5,6 +5,8 @@ import cn.datax.service.data.factory.api.dto.DataSourceDto;
 import cn.datax.service.data.factory.api.entity.DataSourceEntity;
 import cn.datax.common.base.BaseService;
 
+import java.util.List;
+
 /**
  * <p>
  * 数据源信息表 服务类
@@ -21,5 +23,7 @@ public interface DataSourceService extends BaseService<DataSourceEntity> {
 
     void deleteDataSourceById(String id);
 
-    R checkConnection(DataSourceDto dataSource);
+    Boolean checkConnection(DataSourceDto dataSource);
+
+    List<String> getDbTypes();
 }

datax-modules/data-factory-service-parent/data-factory-service/src/main/java/cn/datax/service/data/factory/service/impl/DataSourceServiceImpl.java

 package cn.datax.service.data.factory.service.impl;
 
-import cn.datax.common.core.R;
+import cn.datax.common.database.DataSourceFactory;
+import cn.datax.common.database.DbQuery;
+import cn.datax.common.database.constants.DbQueryProperty;
+import cn.datax.common.database.constants.DbType;
+import cn.datax.common.database.datasource.CacheDataSourceFactoryBean;
 import cn.datax.service.data.factory.api.dto.DataSourceDto;
-import cn.datax.service.data.factory.api.entity.DataSchema;
+import cn.datax.service.data.factory.api.entity.DbSchema;
 import cn.datax.service.data.factory.api.entity.DataSourceEntity;
 import cn.datax.service.data.factory.dao.DataSourceDao;
 import cn.datax.service.data.factory.service.DataSourceService;
@@ -13,6 +17,11 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /**
  * <p>
  * 数据源信息表 服务实现类
@@ -52,10 +61,23 @@ public class DataSourceServiceImpl extends BaseServiceImpl<DataSourceDao, DataSo
     }
 
     @Override
-    public R checkConnection(DataSourceDto dataSourceDto) {
+    public Boolean checkConnection(DataSourceDto dataSourceDto) {
         DataSourceEntity dataSource = dataSourceMapper.toEntity(dataSourceDto);
-        DataSchema sourceSchema = dataSource.getSourceSchema();
-        sourceSchema.viald();
-        return null;
+        DbSchema dbSchema = dataSource.getDbSchema();
+        DataSourceFactory dataSourceFactory = new CacheDataSourceFactoryBean();
+        DbQueryProperty dbQueryProperty = new DbQueryProperty(dataSource.getDbType(), dbSchema.getJdbcUrl(), dbSchema.getUsername(), dbSchema.getPassword());
+        DbQuery dbQuery = dataSourceFactory.createDbQuery(dbQueryProperty);
+        boolean valid = false;
+        try {
+            valid = dbQuery.valid();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return valid;
+    }
+
+    @Override
+    public List<String> getDbTypes() {
+        return Arrays.stream(DbType.values()).map(s -> s.getDb()).collect(Collectors.toList());
     }
 }

datax-modules/data-factory-service-parent/data-factory-service/src/main/resources/mapper/DataSourceMapper.xml

@@ -10,10 +10,10 @@
         <result column="create_time" property="createTime" />
         <result column="update_by" property="updateBy" />
         <result column="update_time" property="updateTime" />
-        <result column="source_type" property="sourceType" />
+        <result column="db_type" property="dbType" />
         <result column="source_name" property="sourceName" />
         <result column="source_desc" property="sourceDesc" />
-        <result column="source_schema" property="sourceSchema" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" />
+        <result column="db_schema" property="dbSchema" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" />
     </resultMap>
 
     <!-- 通用查询结果列 -->
@@ -24,7 +24,7 @@
         create_time,
         update_by,
         update_time,
-        source_type, source_name, source_desc, source_schema
+        db_type, source_name, source_desc, db_schema
     </sql>
 
 </mapper>