zs

src/main/java/com/zjty/adaptationmaster/adaptor/controller/DBManageController.java

+package com.zjty.adaptationmaster.adaptor.controller;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBManage;
+import com.zjty.adaptationmaster.adaptor.service.DBManageService;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/database")
+public class DBManageController {
+
+    @Autowired
+    private DBManageService databaseService;
+
+    @PostMapping("/save")
+    public ServerResponse add(@RequestBody DBManage databaseManagement){
+        return databaseService.saveDatabase(databaseManagement);
+    }
+
+    @PutMapping("/delete/{id}")
+    public ServerResponse delete(@PathVariable("id") Integer id){
+        return databaseService.deleteDatabase(id);
+    }
+
+    @GetMapping("/find")
+    public ServerResponse findDatabaseManagement(){
+        return databaseService.findDatabase();
+    }
+}

src/main/java/com/zjty/adaptationmaster/adaptor/controller/DBMigrateController.java

+package com.zjty.adaptationmaster.adaptor.controller;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DatabaseResponse;
+import com.zjty.adaptationmaster.adaptor.service.DBMigrateService;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+@RequestMapping("/dbMigrate")
+@RestController
+public class DBMigrateController {
+
+    @Autowired
+    private DBMigrateService dbMigrateService;
+
+    @PostMapping("/migrate")
+    public ServerResponse addDatabase(@RequestBody DatabaseResponse databaseResponse){
+        return dbMigrateService.dbMigrate(databaseResponse);
+    }
+
+    @PutMapping("/find")
+    public ServerResponse find(@RequestBody String dbType){
+        return dbMigrateService.findDBByDBType(dbType);
+    }
+
+}

src/main/java/com/zjty/adaptationmaster/adaptor/controller/DBRecordController.java

+package com.zjty.adaptationmaster.adaptor.controller;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBDeleteResponse;
+import com.zjty.adaptationmaster.adaptor.entity.db.DBRecordPage;
+import com.zjty.adaptationmaster.adaptor.service.DBRecordService;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/dbRecord")
+public class DBRecordController {
+    @Autowired
+    private DBRecordService dbRecordService;
+
+    @PutMapping("/page")
+    public ServerResponse page(@RequestBody DBRecordPage dbRecordPage){
+        return dbRecordService.pageFind(dbRecordPage);
+    }
+
+    @PutMapping("deleteDB")
+    public ServerResponse deleteDB(@RequestBody DBDeleteResponse dbDeleteResponse){
+        return dbRecordService.deleteDB(dbDeleteResponse);
+    }
+}

src/main/java/com/zjty/adaptationmaster/adaptor/entity/db/DBDeleteResponse.java

+package com.zjty.adaptationmaster.adaptor.entity.db;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class DBDeleteResponse {
+    private String dbName;//数据库名称
+    private String dbType;//数据库类型
+}

src/main/java/com/zjty/adaptationmaster/adaptor/entity/db/DBManage.java

+package com.zjty.adaptationmaster.adaptor.entity.db;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+@Entity
+public class DBManage {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+    private String databaseName;//数据库名字
+    private String userName;//用户名
+    private String password;//密码
+    private String databaseType;//数据库类型
+    private String driver;//数据库驱动
+    private String address;//连接地址
+    private String port;//数据库端口号
+    private String connectionType;//数据库连接时的sql
+    private Integer status;//逻辑删除 0-删除 1-未删除
+}

src/main/java/com/zjty/adaptationmaster/adaptor/entity/db/DBRecord.java

+package com.zjty.adaptationmaster.adaptor.entity.db;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import java.util.Date;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+@Entity
+public class DBRecord {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Integer id;//主键id，自增
+    private String dbName;//数据库名字
+    private String sourceType;//原库类型
+    private String createType;//生成库类型
+    private String userName;//用户名
+    private String sqlPath;//上传sql本地地址
+    private String createSqlPath;//转换后的sql本地地址
+    private Date createTime;//创建时间
+    private Integer status;//逻辑删除 0-删除 1-未删除
+}

src/main/java/com/zjty/adaptationmaster/adaptor/entity/db/DBRecordPage.java

+package com.zjty.adaptationmaster.adaptor.entity.db;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class DBRecordPage {
+    private String createType;//生成库类型
+    private String userName;//用户名
+    private Integer page;//当前页
+    private Integer size;//每页数量
+}

src/main/java/com/zjty/adaptationmaster/adaptor/entity/db/DBRecordReturn.java

+package com.zjty.adaptationmaster.adaptor.entity.db;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class DBRecordReturn {
+    private long count;//总数
+    private List<DBRecord> dbRecords;
+}

src/main/java/com/zjty/adaptationmaster/adaptor/entity/db/DatabaseResponse.java

+package com.zjty.adaptationmaster.adaptor.entity.db;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class DatabaseResponse {
+    private String databaseName;//数据库名称
+    private String sourceType;//原库类型
+    private String createType;//生成库类型
+    private String sqlPath;//上传数据库地址
+    private String userName;//用户名
+}

src/main/java/com/zjty/adaptationmaster/adaptor/repository/DBManageDao.java

+package com.zjty.adaptationmaster.adaptor.repository;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBManage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+public interface DBManageDao extends JpaRepository<DBManage,Integer> {
+
+    DBManage findDatabaseManagementByDatabaseTypeAndStatus(String databaseType, Integer status);
+
+    List<DBManage> findDatabaseManagementByStatus(Integer status);
+
+    @Query("update DBManage d set d.status =:status where d.id =:id")
+    @Modifying
+    void delete(@Param(value = "id") Integer id, @Param(value = "status") Integer status);
+
+}

src/main/java/com/zjty/adaptationmaster/adaptor/repository/DBRecordDao.java

+package com.zjty.adaptationmaster.adaptor.repository;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBRecord;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+public interface DBRecordDao extends JpaRepository<DBRecord,Integer>, JpaSpecificationExecutor {
+
+    @Query("update DBRecord d set d.status =:status where d.dbName =:dbName")
+    @Modifying
+    void delete(@Param(value = "dbName") String dbName, @Param(value = "status") Integer status);
+
+}

src/main/java/com/zjty/adaptationmaster/adaptor/service/DBManageService.java

+package com.zjty.adaptationmaster.adaptor.service;
+
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBManage;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+
+public interface DBManageService {
+
+    ServerResponse saveDatabase(DBManage databaseManagement);
+
+    ServerResponse deleteDatabase(Integer id);
+
+    ServerResponse findDatabase();
+}

src/main/java/com/zjty/adaptationmaster/adaptor/service/DBMigrateService.java

+package com.zjty.adaptationmaster.adaptor.service;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DatabaseResponse;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+
+
+public interface DBMigrateService {
+
+    ServerResponse dbMigrate(DatabaseResponse databaseResponse);
+
+    ServerResponse findDBByDBType(String dbType);
+
+}

src/main/java/com/zjty/adaptationmaster/adaptor/service/DBRecordService.java

+package com.zjty.adaptationmaster.adaptor.service;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBDeleteResponse;
+import com.zjty.adaptationmaster.adaptor.entity.db.DBRecordPage;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+
+
+public interface DBRecordService {
+
+    ServerResponse pageFind(DBRecordPage dbRecordPage);
+
+    ServerResponse deleteDB(DBDeleteResponse dbDeleteResponse);
+}

src/main/java/com/zjty/adaptationmaster/adaptor/service/Impl/DBManageServiceImpl.java

+package com.zjty.adaptationmaster.adaptor.service.Impl;
+
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBManage;
+import com.zjty.adaptationmaster.adaptor.repository.DBManageDao;
+import com.zjty.adaptationmaster.adaptor.service.DBManageService;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class DBManageServiceImpl implements DBManageService {
+
+    @Autowired
+    private DBManageDao databaseDao;
+
+    /**
+     * 新增数据库配置文件
+     * @param databaseManagement
+     * @return
+     */
+    @Override
+    @Transactional
+    public ServerResponse saveDatabase(DBManage databaseManagement) {
+        databaseManagement.setStatus(1);//1-未删除
+        return ServerResponse.success(databaseDao.save(databaseManagement));
+    }
+
+
+    /**
+     * 根据id删除数据库配置文件
+     * @param id
+     * @return
+     */
+    @Override
+    @Transactional
+    public ServerResponse deleteDatabase(Integer id) {
+        databaseDao.delete(id,0);//逻辑删除
+        return ServerResponse.success(id);
+    }
+
+    /**
+     * 查找未被逻辑删除的数据库配置文件
+     * @return
+     */
+    @Override
+    public ServerResponse findDatabase() {
+        return ServerResponse.success(databaseDao.findDatabaseManagementByStatus(1));
+    }
+
+}

src/main/java/com/zjty/adaptationmaster/adaptor/service/Impl/DBMigrateServiceImpl.java

+package com.zjty.adaptationmaster.adaptor.service.Impl;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBManage;
+import com.zjty.adaptationmaster.adaptor.entity.db.DBRecord;
+import com.zjty.adaptationmaster.adaptor.entity.db.DatabaseResponse;
+import com.zjty.adaptationmaster.adaptor.repository.DBManageDao;
+import com.zjty.adaptationmaster.adaptor.repository.DBRecordDao;
+import com.zjty.adaptationmaster.adaptor.service.DBMigrateService;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+import com.zjty.adaptationmaster.utils.Regular;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+@Service
+public class DBMigrateServiceImpl implements DBMigrateService {
+
+    @Autowired
+    private DBManageDao dbManageDao;
+    @Autowired
+    private DBRecordDao dbRecordDao;
+
+    /**
+     * 创建新数据库和数据库中的表
+     */
+    @Override
+    public ServerResponse dbMigrate(DatabaseResponse databaseResponse) {
+        if(databaseResponse != null && databaseResponse.getDatabaseName() != null){
+            String databaseName = databaseResponse.getDatabaseName();
+            //查询新建的数据库是否存在
+            ServerResponse serverResponse = findDBByDBType(databaseResponse.getCreateType());
+            Object obj = serverResponse.getData();
+            List<String> dbNameList = new ArrayList<>();
+            if(obj instanceof ArrayList<?>){
+                for(Object o:((List<?>) obj)){
+                    dbNameList.add(String.class.cast(o));
+                }
+            }
+            if(dbNameList.contains(databaseName)){
+                return ServerResponse.error("该数据库已存在，请重新填写");
+            }
+            //转换后的.sql文件地址
+            String path = "";
+            //mysql数据库
+            if(databaseResponse.getCreateType().equals("highgo") && databaseResponse.getSourceType().equals("mysql")){
+                //生成数据库的名称
+                //连接系统数据库，建立新数据库
+                //根据传入的生成数据库类型，查找未被删除的配置文件
+                DBManage databaseManagement = dbManageDao.findDatabaseManagementByDatabaseTypeAndStatus(databaseResponse.getCreateType(),1);
+                Connection connection = Regular.databaseConnection(databaseManagement);
+                if(connection != null){
+                    PreparedStatement preparedStatement = null;
+                    try {
+                        String createDatabase = "CREATE DATABASE \"" + databaseName + "\" WITH OWNER = \"" + databaseManagement.getUserName() + "\" ENCODING = 'UTF8' TEMPLATE template0;";
+                        preparedStatement = connection.prepareStatement(createDatabase);
+                        preparedStatement.execute();
+                    } catch (SQLException e) {
+                        e.printStackTrace();
+                        return ServerResponse.error("创建数据库：" + databaseName + "出错");
+                    }finally {
+                        try {
+                            preparedStatement.close();
+                            connection.close();
+                        } catch (SQLException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    //建立表及导入数据
+                    databaseManagement.setDatabaseName(databaseName);
+                    Connection connection1 = Regular.databaseConnection(databaseManagement);
+                    if(connection1 != null){
+                        path = Regular.mySqlRegular(databaseResponse.getSqlPath(),databaseName);
+                        File file = new File(path);
+                        FileReader fileReader = null;
+                        BufferedReader bufferedReader = null;
+                        PreparedStatement preparedStatement1 = null;
+                        try {
+                            fileReader = new FileReader(file);
+                            bufferedReader = new BufferedReader(fileReader);
+                            String s;
+                            String sql = "";
+                            while ((s = bufferedReader.readLine()) != null){
+                                try {
+                                    sql += s;
+                                    if(s.contains(";")){
+                                        preparedStatement1 = connection1.prepareStatement(sql);
+                                        preparedStatement1.execute();
+                                        sql = "";
+                                    }
+                                }catch (SQLException e) {
+                                    sql = "";
+                                    e.printStackTrace();
+                                    continue;
+                                }
+                            }
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        } finally {
+                            try {
+                                bufferedReader.close();
+                                fileReader.close();
+                                preparedStatement1.close();
+                                connection1.close();
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+            //保存迁移记录到数据库
+            DBRecord dbRecord = new DBRecord();
+            if(databaseResponse.getSourceType() != null){
+                dbRecord.setSourceType(databaseResponse.getSourceType());
+            }
+            if(databaseResponse.getCreateType() != null){
+                dbRecord.setCreateType(databaseResponse.getCreateType());
+            }
+            if(databaseResponse.getDatabaseName() != null){
+                dbRecord.setDbName(databaseResponse.getDatabaseName());
+            }
+            if(databaseResponse.getUserName() != null){
+                dbRecord.setUserName(databaseResponse.getUserName());
+            }
+            if(databaseResponse.getSqlPath() != null){
+                dbRecord.setSqlPath(databaseResponse.getSqlPath());
+            }
+            dbRecord.setCreateSqlPath(path);
+            dbRecord.setCreateTime(new Date());
+            dbRecord.setStatus(1);
+            dbRecordDao.save(dbRecord);
+        }
+        return ServerResponse.success();
+    }
+
+    /**
+     * 根据传入的数据库类型查询所有的数据库
+     * @param dbType
+     * @return
+     */
+    @Override
+    public ServerResponse findDBByDBType(String dbType) {
+        List<String> dbNameList = new ArrayList<>();
+        //highgo查询所有数据库
+        if(dbType.equals("highgo")){
+            DBManage databaseManagement = dbManageDao.findDatabaseManagementByDatabaseTypeAndStatus(dbType, 1);
+            Connection connection = Regular.databaseConnection(databaseManagement);
+            if (connection != null) {
+                PreparedStatement preparedStatement = null;
+                try {
+                    String findDB = "select p.datname from pg_database p where p.datistemplate = false;";
+                    preparedStatement = connection.prepareStatement(findDB);
+                    preparedStatement.execute();
+                    ResultSet resultSet = preparedStatement.getResultSet();
+                    while (resultSet.next()){
+                        dbNameList.add(resultSet.getString(1));
+                    }
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                } finally {
+                    try {
+                        preparedStatement.close();
+                        connection.close();
+                    } catch (SQLException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+        return ServerResponse.success(dbNameList);
+    }
+}

src/main/java/com/zjty/adaptationmaster/adaptor/service/Impl/DBRecordServiceImpl.java

+package com.zjty.adaptationmaster.adaptor.service.Impl;
+
+import com.github.wenhao.jpa.Specifications;
+import com.zjty.adaptationmaster.adaptor.entity.db.*;
+import com.zjty.adaptationmaster.adaptor.repository.DBManageDao;
+import com.zjty.adaptationmaster.adaptor.repository.DBRecordDao;
+import com.zjty.adaptationmaster.adaptor.service.DBRecordService;
+import com.zjty.adaptationmaster.base.response.ServerResponse;
+import com.zjty.adaptationmaster.utils.Regular;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+@Service
+public class DBRecordServiceImpl implements DBRecordService {
+    @Autowired
+    private DBRecordDao dbRecordDao;
+    @Autowired
+    private DBManageDao dbManageDao;
+
+    /**
+     *  分页条件查询
+     * @param dbRecordPage
+     * @return
+     */
+    @Override
+    public ServerResponse pageFind(DBRecordPage dbRecordPage) {
+        Specification<DBRecord> specifications = Specifications.<DBRecord>and()
+                .eq(dbRecordPage.getCreateType() != null,"createType",dbRecordPage.getCreateType())
+                .eq(dbRecordPage.getUserName() != null,"userName",dbRecordPage.getUserName())
+                .eq("status",1)
+                .build();
+        Integer page = dbRecordPage.getPage();
+        Integer size = dbRecordPage.getSize();
+        if(page == null || page <= 0){
+            page = 1;
+        }
+        if(size == null || size <= 0){
+            size = 10;
+        }
+        Pageable pageable = PageRequest.of(page - 1,size, Sort.Direction.DESC,"createTime");
+        long count = dbRecordDao.count(specifications);
+        if(count < 0){
+            return ServerResponse.error();
+        }
+        return ServerResponse.success(new DBRecordReturn(count,dbRecordDao.findAll(specifications,pageable).getContent()));
+    }
+
+    /**
+     * 数据库删除
+     * @param dbDeleteResponse
+     * @return
+     */
+    @Override
+    @Transactional
+    public ServerResponse deleteDB(DBDeleteResponse dbDeleteResponse) {
+        DBManage dbManage = dbManageDao.findDatabaseManagementByDatabaseTypeAndStatus(dbDeleteResponse.getDbType(),1);
+        Connection connection = Regular.databaseConnection(dbManage);
+        if (connection != null) {
+            PreparedStatement preparedStatement = null;
+            try {
+                String findDB = "DROP DATABASE IF EXISTS " + dbDeleteResponse.getDbName()+ ";";
+                preparedStatement = connection.prepareStatement(findDB);
+                preparedStatement.execute();
+                dbRecordDao.delete(dbDeleteResponse.getDbName(),0);
+            } catch (SQLException e) {
+                e.printStackTrace();
+            } finally {
+                try {
+                    preparedStatement.close();
+                    connection.close();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return ServerResponse.success();
+    }
+}

src/main/java/com/zjty/adaptationmaster/utils/Regular.java

+package com.zjty.adaptationmaster.utils;
+
+import com.zjty.adaptationmaster.adaptor.entity.db.DBManage;
+
+import java.io.*;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+public class Regular {
+
+    /**
+     * 将mysql导出的.sql文件转为highgo可以识别的.sql文件
+     * @param path  sql文件地址
+     * @param sqlName   数据库名字
+     */
+    public static String mySqlRegular(String path,String sqlName){
+        File file = new File(path);
+        String savePath = file.getParent() + "/" + sqlName + ".sql";
+        File saveFile = new File(savePath);
+        FileReader fileReader = null;
+        BufferedReader bufferedReader = null;
+        FileWriter fileWriter = null;
+        BufferedWriter bufferedWriter = null;
+        try {
+            fileReader = new FileReader(file);
+            bufferedReader = new BufferedReader(fileReader);
+            fileWriter = new FileWriter(saveFile);
+            bufferedWriter = new BufferedWriter(fileWriter);
+            String s = "";
+            boolean database = true;//去除.sql中使用数据库的sql语句
+            String tableName = null;
+            String incrementField = null;
+            while ((s = bufferedReader.readLine()) != null){
+                s = s.replaceAll("`","\"");
+                s += "\r\n";
+                //转换mysql的int和bigint类型
+                if(s.contains("int(") || s.contains("INT(")){
+                    String dataType = s.substring(s.lastIndexOf("\"") + 1,s.indexOf("(")).trim();
+                    if(dataType.length() <= 4){
+                        //int类型
+                        String startChar = s.substring(0,s.indexOf("("));
+                        String endChar = s.substring(s.indexOf(")") + 1);
+                        s = startChar + "4" + endChar;
+                        if(lowerAndUpper(s,"AUTO_INCREMENT")){
+                            s = s.replace("AUTO_INCREMENT","");
+                            s = s.replace("auto_increment","");
+                            s = s.replace("int4","serial");
+                            s = s.replace("INT4","serial");
+                            incrementField = s.substring(s.indexOf("\"") + 1,s.lastIndexOf("\""));
+                        }
+                    }else {
+                        //bigint类型
+                        if(lowerAndUpper(s,"BIGINT")){
+                            String startChar = s.substring(0,s.indexOf("("));
+                            String endChar = s.substring(s.indexOf(")") + 1);
+                            s = startChar + endChar;
+                            if(lowerAndUpper(s,"AUTO_INCREMENT")){
+                                s = s.replace("AUTO_INCREMENT","");
+                                s = s.replace("auto_increment","");
+                                s = s.replace("bigint","bigserial");
+                                s = s.replace("BIGINT","bigserial");
+                                incrementField = s.substring(s.indexOf("\"") + 1,s.lastIndexOf("\""));
+                            }
+                        }else if(lowerAndUpper(s,"SMALLINT")){
+                            String startChar = s.substring(0,s.indexOf("("));
+                            String endChar = s.substring(s.indexOf(")") + 1);
+                            s = startChar + endChar;
+                            if(lowerAndUpper(s,"AUTO_INCREMENT")){
+                                s = s.replace("AUTO_INCREMENT","");
+                                s = s.replace("auto_increment","");
+                                s = s.replace("SMALLINT","smallserial");
+                                s = s.replace("smallint","smallserial");
+                                incrementField = s.substring(s.indexOf("\"") + 1,s.lastIndexOf("\""));
+                            }
+                        }
+                    }
+                }
+                //转换mysql的时间datetime类型
+                s = StringType(s,"datetime","timestamp");
+                //转换mysql的double类型
+                s = StringType(s,"double","float");
+                //插入值时boolean类型转换
+                if(s.contains("bit(1)")){
+                    s = s.replace("bit(1)","boolean");
+                }
+                if(s.contains("'\\0'")){
+                    s = s.replace("'\\0'","'false'");
+                }
+                if(s.contains("'\\1'")){
+                    s = s.replace("'\\1'","true");
+                }
+                //mysql的外键key值
+                if(lowerAndUpper(s,"KEY") && !lowerAndUpper(s,"FOREIGN") && !lowerAndUpper(s,"PRIMARY")){
+                    String startChar = s.substring(0,s.indexOf("\""));
+                    if(lowerAndUpper(startChar,"KEY")){
+                        continue;
+                    }
+                }
+                //记录创建表时表的名字
+                if(lowerAndUpper(s,"CREATE") && lowerAndUpper(s,"TABLE")){
+                    tableName = s.substring(s.indexOf("\"") + 1,s.lastIndexOf("\"")).trim();
+                }
+                //去除表类型的定义
+                if(lowerAndUpper(s,"ENGINE") && lowerAndUpper(s,"CHARSET")){
+                    if(lowerAndUpper(s,"AUTO_INCREMENT")){
+                        String[] array = s.split(" ");
+                        for(String a:array){
+                            if(lowerAndUpper(a.trim(),"AUTO_INCREMENT")){
+                                String num = a.substring(a.indexOf("=") + 1);
+                                String alterIncrementInital = "SELECT setval('\"" + tableName + "_" + incrementField + "_seq\"'," +  (Integer.parseInt(num) - 1) + ", true);\r\n";
+                                s = ");\r\n";
+                                s = s + alterIncrementInital;
+                            }
+                        }
+                    }else {
+                        s = ");\r\n";
+                    }
+                }
+                //去除.sql中使用数据库的sql语句
+                if(s.contains("USE") && s.contains(";") && s.contains("\"") && database){
+                    database = false;
+                }else {
+                    bufferedWriter.write(s);
+                }
+            }
+            bufferedWriter.flush();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }finally {
+            try {
+                bufferedReader.close();
+                fileReader.close();
+                bufferedWriter.close();
+                fileWriter.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return savePath;
+    }
+
+    /**
+     * 判断大写和小写
+     */
+    public static boolean lowerAndUpper(String s,String upper){
+        if(s.contains(upper) || s.contains(upper.toLowerCase())){
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    /**
+     * 判断出入的字符串
+     * @param s
+     */
+    public static String StringType(String s,String lowerCase,String replacement){
+        String startChar;
+        String endChar;
+        String upperCase = lowerCase.toUpperCase();
+        if(s.contains(lowerCase)){
+            //小写
+            startChar = s.substring(0,s.indexOf(lowerCase));
+            endChar = s.substring(s.indexOf(lowerCase) + 1);
+            if(startChar.contains("\"") && !endChar.contains("\"")){
+                return s.replaceAll(lowerCase,replacement);
+            }
+        }else if(s.contains(upperCase)){
+            //大写
+            startChar = s.substring(0,s.indexOf(upperCase));
+            endChar = s.substring(s.indexOf(upperCase) + 1);
+            if(startChar.contains("\"") && !endChar.contains("\"")){
+                return s.replaceAll(upperCase,replacement);
+            }
+        }
+        return s;
+    }
+
+    /**
+     * 自增整数，转换为highgo的自增整数
+     * @param s
+     */
+    public static String integerIncrement(String s,String integerType){
+        if(lowerAndUpper(s,"AUTO_INCREMENT")){
+            if(integerType.equals("int4")){
+                s = s.replace(integerType,"serial");
+            }else {
+                s = s.replace(integerType,"bigserial");
+            }
+            s = s.replace("AUTO_INCREMENT","");
+            s = s.replace("auto_increment","");
+        }
+        return s;
+    }
+
+    /**
+     * 数据库连接
+     * @param
+     */
+    public static Connection databaseConnection(DBManage databaseManagement){
+        Connection connection = null;
+        try {
+            Class.forName(databaseManagement.getDriver());
+            String connectionUrl = "jdbc:" + databaseManagement.getConnectionType() + ":" + "//" + databaseManagement.getAddress() + ":" + databaseManagement.getPort() + "/" + databaseManagement.getDatabaseName();
+            connection = DriverManager.getConnection(connectionUrl,databaseManagement.getUserName(),databaseManagement.getPassword());
+            return connection;
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+
+    public static void main(String[] args) {
+        mySqlRegular("C:\\Users\\admin\\Desktop\\2.sql","else");
+    }
+}