Spring Boot + Spring Cloud 實現權限管理系統 後端篇（十三）：系統備份還原

系統備份還原

在不少時候，咱們須要系統數據進行備份還原。咱們這裏就使用MySql的備份還原命令實現系統備份還原的功能。

新建工程

新建一個maven項目，並添加相關依賴，能夠用Spring boot腳手架生成。

新建 kitty-bakcup 工程，這是一個獨立運行於後臺系統的應用程序，能夠分開部署。

pom.xml 文件添加相關依賴。

        <!-- spring boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${swagger.version}</version>
        </dependency>

添加Spring boot啓動類。

package com.louis.kitty.backup;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages={"com.louis.kitty"})
public class KittyBackupApplication {

    public static void main(String[] args) {
        SpringApplication.run(KittyBackupApplication.class, args);
    }
}

添加配置

建立項目配置文件，添加備份還原數據源配置。

resources/application.yml

# backup datasource
spring:
  backup:
    datasource:
      host: localhost
      userName: root
      password: 123456
      database: kitty

添加配置屬性讀取配置類。

BackupDataSourceProperties.java

package com.louis.kitty.backup.datasource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component  
@ConfigurationProperties(prefix = "spring.backup.datasource")  
public class BackupDataSourceProperties {
    
    private String host;
    private String userName;
    private String password;
    private String database;
    public String getHost() {
        return host;
    }
    public void setHost(String host) {
        this.host = host;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getDatabase() {
        return database;
    }
    public void setDatabase(String database) {
        this.database = database;
    }
    
}  

添加swagger配置類，用於測試備份還原接口。

package com.louis.kitty.backup.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2).select()
                .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any()).build();
    }
    
}

添加跨域配置類，由於先後端分離，跨域確定是要支持的。

package com.louis.kitty.backup.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")    // 容許跨域訪問的路徑
        .allowedOrigins("*")    // 容許跨域訪問的源
        .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")    // 容許請求方法
        .maxAge(168000)    // 預檢間隔時間
        .allowedHeaders("*")  // 容許頭部設置
        .allowCredentials(true);    // 是否發送cookie
    }
}

備份還原邏輯

備份還原邏輯封裝在一個工具類中，能夠單獨從項目中提取出來，方便複用。

內部main方法提供簡單實用示例，能夠方便快速的知曉實用方法。

備份還原功能主要是藉助命令行執行MySql的數據備份還原命令實現的。

package com.louis.kitty.backup.util;

import java.io.File;
import java.io.IOException;

/**
 * MySQL備份還原工具類
 * @author Louis
 * @date Sep 21, 2018
 */
public class MySqlBackupRestoreUtils {

    /**
     * 備份數據庫
     * @param host host地址，能夠是本機也能夠是遠程
     * @param userName 數據庫的用戶名
     * @param password 數據庫的密碼
     * @param savePath 備份的路徑
     * @param fileName 備份的文件名
     * @param databaseName 須要備份的數據庫的名稱
     * @return
     * @throws IOException 
     */
    public static boolean backup(String host, String userName, String password, String backupFolderPath, String fileName,
            String database) throws Exception {
        File backupFolderFile = new File(backupFolderPath);
        if (!backupFolderFile.exists()) {
            // 若是目錄不存在則建立
            backupFolderFile.mkdirs();
        }
        if (!backupFolderPath.endsWith(File.separator) || !backupFolderPath.endsWith("/")) {
            backupFolderPath = backupFolderPath + File.separator;
        }
        // 拼接命令行的命令
        String backupFilePath = backupFolderPath + fileName;
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("mysqldump --opt ").append(" --add-drop-database ").append(" --add-drop-table ");
        stringBuilder.append(" -h").append(host).append(" -u").append(userName).append(" -p").append(password);
        stringBuilder.append(" --result-file=").append(backupFilePath).append(" --default-character-set=utf8 ").append(database);
        // 調用外部執行 exe 文件的 Java API
        Process process = Runtime.getRuntime().exec(getCommand(stringBuilder.toString()));
        if (process.waitFor() == 0) {
            // 0 表示線程正常終止
            System.out.println("數據已經備份到 " +backupFilePath + " 文件中");
            return true;
        }
        return false;
    }

    /**
     * 還原數據庫
     * @param restoreFilePath 數據庫備份的腳本路徑
     * @param host IP地址
     * @param database 數據庫名稱
     * @param userName 用戶名
     * @param password 密碼
     * @return
     */
    public static boolean restore(String restoreFilePath, String host, String userName, String password, String database)
            throws Exception {
        File restoreFile = new File(restoreFilePath);
        if (restoreFile.isDirectory()) {
            for (File file : restoreFile.listFiles()) {
                if (file.exists() && file.getPath().endsWith(".sql")) {
                    restoreFilePath = file.getAbsolutePath();
                    break;
                }
            }
        }
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("mysql -h").append(host).append(" -u").append(userName).append(" -p").append(password);
        stringBuilder.append(" ").append(database).append(" < ").append(restoreFilePath);
        try {
            Process process = Runtime.getRuntime().exec(getCommand(stringBuilder.toString()));
            if (process.waitFor() == 0) {
                System.out.println("數據已從 " + restoreFilePath + " 導入到數據庫中");
            }
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    private static String[] getCommand(String command) {
        String os = System.getProperty("os.name");  
        String shell = "/bin/sh";
        if(os.toLowerCase().startsWith("win")){  
            shell = "cmd";
        }  
        String[] cmd = { shell, "/c", command };
        return cmd;
    }

    public static void main(String[] args) throws Exception {
        String host = "localhost";
        String userName = "root";
        String password = "123456";
        String database = "kitty";
        
        System.out.println("開始備份");
        String backupFolderPath = "c:/dev/";
        String fileName = "kitty.sql";
        backup(host, userName, password, backupFolderPath, fileName, database);
        System.out.println("備份成功");
        
        System.out.println("開始還原");
        String restoreFilePath = "c:/dev/kitty.sql";
        restore(restoreFilePath, host, userName, password, database);
        System.out.println("還原成功");

    }
}

備份還原服務

備份還原服務經過調用工具類實現備份還原功能。

MysqlBackupService.java

package com.louis.kitty.backup.service;

import java.io.IOException;

/**
 * MySql命令行備份恢復服務
 * @author Louis
 * @date Sep 20, 2018
 */
public interface MysqlBackupService {

    /**
     * 備份數據庫
     * @param host host地址，能夠是本機也能夠是遠程
     * @param userName 數據庫的用戶名
     * @param password 數據庫的密碼
     * @param savePath 備份的路徑
     * @param fileName 備份的文件名
     * @param databaseName 須要備份的數據庫的名稱
     * @return
     * @throws IOException 
     */
    boolean backup(String host, String userName, String password, String backupFolderPath, String fileName, String database) throws Exception;

    /**
     * 恢復數據庫
     * @param restoreFilePath 數據庫備份的腳本路徑
     * @param host IP地址
     * @param database 數據庫名稱
     * @param userName 用戶名
     * @param password 密碼
     * @return
     */
    boolean restore(String restoreFilePath, String host, String userName, String password, String database) throws Exception;

}

MysqlBackupServiceImpl.java

package com.louis.kitty.backup.service.impl;

import org.springframework.stereotype.Service;

import com.louis.kitty.backup.service.MysqlBackupService;
import com.louis.kitty.backup.util.MySqlBackupRestoreUtils;

@Service
public class MysqlBackupServiceImpl implements MysqlBackupService {

    @Override
    public boolean backup(String host, String userName, String password, String backupFolderPath, String fileName,
            String database) throws Exception {
        return MySqlBackupRestoreUtils.backup(host, userName, password, backupFolderPath, fileName, database);
    }

    @Override
    public boolean restore(String restoreFilePath, String host, String userName, String password, String database)
            throws Exception {
        return MySqlBackupRestoreUtils.restore(restoreFilePath, host, userName, password, database);
    }

}

備份還原接口

備份還原服務經過調用服務類實現備份還原的REST接口。

提供備份查詢、建立備份、版本還原、刪除備份的功能。

MySqlBackupController.java

package com.louis.kitty.backup.controller;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.louis.kitty.backup.constants.BackupConstants;
import com.louis.kitty.backup.datasource.BackupDataSourceProperties;
import com.louis.kitty.backup.service.MysqlBackupService;
import com.louis.kitty.backup.util.FileUtils;
import com.louis.kitty.backup.util.HttpResult;

/**
 * 系統數據備份還原
 * 採用MYSQL備份還原命令
 * @author Louis
 * @date Sep 20, 2018
 */
@RestController
@RequestMapping("/backup")
public class MySqlBackupController {

    @Autowired
    MysqlBackupService mysqlBackupService;
    @Autowired
    BackupDataSourceProperties properties;

    @GetMapping("/backup")
    public HttpResult backup() {
        String host = properties.getHost();
        String userName = properties.getUserName();
        String password = properties.getPassword();
        String database = properties.getDatabase();
        String backupFodlerName = BackupConstants.DEFAULT_BACKUP_NAME+ "_" + (new SimpleDateFormat(BackupConstants.DATE_FORMAT)).format(new Date());
        String backupFolderPath = BackupConstants.BACKUP_FOLDER + backupFodlerName + File.separator;
        String fileName = BackupConstants.BACKUP_FILE_NAME;
        try {
            mysqlBackupService.backup(host, userName, password, backupFolderPath, fileName, database);
        } catch (Exception e) {
            return HttpResult.error(500, e.getMessage());
        }
        return HttpResult.ok();
    }

    @GetMapping("/restore")
    public HttpResult restore(@RequestParam String name) {
        String host = properties.getHost();
        String userName = properties.getUserName();
        String password = properties.getPassword();
        String database = properties.getDatabase();
        String restoreFilePath = BackupConstants.RESTORE_FOLDER + name;
        try {
            mysqlBackupService.restore(restoreFilePath, host, userName, password, database);
        } catch (Exception e) {
            return HttpResult.error(500, e.getMessage());
        }
        return HttpResult.ok();
    }
    
    @GetMapping("/findRecords")
    public HttpResult findBackupRecords() {
        List<Map<String, Object>> backupRecords = new ArrayList<>();
        File restoreFolderFile = new File(BackupConstants.RESTORE_FOLDER);
        if(restoreFolderFile.exists()) {
            for(File file:restoreFolderFile.listFiles()) {
                Map<String, Object> bean = new HashMap<>();
                bean.put("name", file.getName());
                bean.put("title", file.getName());
                if(BackupConstants.DEFAULT_BACKUP_NAME.equals(file.getName())) {
                    bean.put("title", "系統默認備份");
                }
                backupRecords.add(bean);
            }
        }
        return HttpResult.ok(backupRecords);
    }
    
    @GetMapping("/delete")
    public HttpResult deleteBackupRecord(@RequestParam String name) {
        if(BackupConstants.DEFAULT_BACKUP_NAME.equals(name)) {
            return HttpResult.error("系統默認備份沒法刪除!");
        }
        String restoreFilePath = BackupConstants.RESTORE_FOLDER + name;
        try {
            FileUtils.deleteFile(new File(restoreFilePath));
        } catch (Exception e) {
            return HttpResult.error(500, e.getMessage());
        }
        return HttpResult.ok();
    }

}

接口測試

啓動應用，訪問 http://localhost:8080/swagger-ui.html#/ ，測試Swagger接口。

建立備份

調用備份接口，生成備份。

備份建立成功以後，會在_backup目錄下生成以時間戳相關的備份目錄，目錄下包含數據庫備份SQL文件。

爲防止全部備份被刪除，backup目錄下提供系統默認備份，放置系統初始化數據，經過刪除接口，不可刪除。

查找備份

經過備份查詢接口，能夠查詢全部備份記錄，顯示在前臺，用於提供備份的還原和刪除。

備份查詢接口返回以下數據結構，name爲操做標識，title用於前臺顯示備份信息。

{
  "code": 200,
  "msg": null,
  "data": [
    {
      "name": "backup",
      "title": "系統默認備份"
    },
    {
      "name": "backup_2018-09-22_103504",
      "title": "backup_2018-09-22_103504"
    },
    {
      "name": "backup_2018-09-22_103506",
      "title": "backup_2018-09-22_103506"
    },
    {
      "name": "backup_2018-09-22_103508",
      "title": "backup_2018-09-22_103508"
    }
  ]
}

刪除備份

根據查詢結果，傳入備份的name做爲參數，便可調用刪除接口刪除備份。

還原備份

根據查詢結果，傳入備份的name做爲參數，便可調用還原接口還原備份。

 

前臺測試

結合前臺頁面操做，咱們能夠以界面的方式查詢、建立、刪除和還原備份。

咱們在前臺頁面添加備份還原操做入口，以下圖所示。

在系統備份還原操做界面，提供查詢、建立、刪除、還原備份的功能。

前臺頁面的實現參考前臺篇章教程。

規則調整

因爲咱們用的是Spring Boot，在實際部署的時候，極可能採用的是jar包部署方式，那麼咱們原先定的以類路徑來定位讀寫備份目錄和文件的方式受到了限制，因此這裏對備份目錄存放的位置從新制定。新的存放路徑規則：System.getProperty("user.home") + /backup_時間戳/kitty.sql ，user.home 在windows對應C:\Users\xxxx\，在Linux上對應/root/。

 

注意：

此版本數據庫備份還原功能依賴於服務器本地MySQL的備份還原工具，因此部署服務器必須先安裝MySQL數據庫。

且要保證在命令行可以成功執行MySQL的備份還原數據庫命令，這是系統數據備份還原功能的前提條件。

若是是在Linux環境，且執行MySQL相關命令報出如下錯誤，可參考下面解決方案：

ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)

這是由於本地MySQL工具一本都是經過Socket方式鏈接數據庫的，出現以上錯誤是沒有爲相應工具指定Socker文件。

能夠經過修改MySQL的 my.cnf 配置文件，在其中指定客戶端工具的socket文件 ， 默認是 /var/lib/mysql/mysql.sock。

my.cnf 添加以下內容：

[client]
socket=/var/lib/mysql.sock

 

 

源碼下載

後端：https://gitee.com/liuge1988/kitty

前端：https://gitee.com/liuge1988/kitty-ui.git

---

做者：朝雨憶輕塵
出處：https://www.cnblogs.com/xifengxiaoma/ 版權全部，歡迎轉載，轉載請註明原文做者及出處。