程序博客网 > 苏联大清洗知乎

技术实现(2)之数据库备份恢复的设计与实现

来源：互联网 发布：苏联大清洗知乎 编辑：程序博客网 时间：2024/05/18 09:35

APDPlat提供了web接口的数据库备份与恢复，支持手工操作和定时调度，可下载备份文件到本地，也可把备份文件发送到异地容错，极大地简化了数据库的维护工作。

 

设计目标：

1、多数据库支持

2、横切关注点隔离

3、异地容错

 

下面阐述具体的设计及实现：

 

1、为了支持多数据库，统一的接口是不可避免的，如下所示：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  * 备份恢复数据库接口 
  3.  * @author 杨尚川 
  4.  */  
  5. public interface BackupService {  
  6.     /** 
  7.      * 备份数据库 
  8.      * @return 是否备份成功 
  9.      */  
  10.     public boolean backup();  
  11.     /** 
  12.      * 恢复数据库 
  13.      * @param date 
  14.      * @return 是否恢复成功 
  15.      */  
  16.     public boolean restore(String date);  
  17.     /** 
  18.      * 获取已经存在的备份文件名称列表 
  19.      * @return  备份文件名称列表 
  20.      */  
  21.     public List<String> getExistBackupFileNames();      
  22.     /** 
  23.      * 获取备份文件存放的本地文件系统路径 
  24.      * @return 备份文件存放路径 
  25.      */  
  26.     public String getBackupFilePath();  
  27.     /** 
  28.      * 获取最新的备份文件 
  29.      * @return 最新的备份文件 
  30.      */  
  31.     public File getNewestBackupFile();}  
 

 

    对于各个不同的数据库来说，有一些通用的操作，如对加密的数据库用户名和密码的解密操作，还有接口定义的备份文件存放的本地文件系统路径，用一个抽象类来实现接口中的通用方法以及其他通用方法如decrypt：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  *备份恢复数据库抽象类，抽象出了针对各个数据库来说通用的功能 
  3.  * @author 杨尚川 
  4.  */  
  5. public abstract class AbstractBackupService implements BackupService{    
  6.     protected final APDPlatLogger LOG = new APDPlatLogger(getClass());  
  7.       
  8.     protected static final StandardPBEStringEncryptor encryptor;  
  9.     protected static final String username;  
  10.     protected static final String password;  
  11.     //从配置文件中获取数据库用户名和密码，如果用户名和密码被加密，则解密  
  12.     static{  
  13.             EnvironmentStringPBEConfig config=new EnvironmentStringPBEConfig();  
  14.             config.setAlgorithm("PBEWithMD5AndDES");  
  15.             config.setPassword("config");  
  16.   
  17.             encryptor=new StandardPBEStringEncryptor();  
  18.             encryptor.setConfig(config);  
  19.             String uname=PropertyHolder.getProperty("db.username");  
  20.             String pwd=PropertyHolder.getProperty("db.password");  
  21.             if(uname!=null && uname.contains("ENC(") && uname.contains(")")){  
  22.                 uname=uname.substring(4,uname.length()-1);  
  23.                 username=decrypt(uname);  
  24.             }else{  
  25.                 username=uname;  
  26.             }  
  27.             if(pwd!=null && pwd.contains("ENC(") && pwd.contains(")")){  
  28.                 pwd=pwd.substring(4,pwd.length()-1);  
  29.                 password=decrypt(pwd);  
  30.             }else{  
  31.                 password=pwd;  
  32.             }  
  33.     }  
  34.     @Override  
  35.     public String getBackupFilePath(){  
  36.         String path="/WEB-INF/backup/"+PropertyHolder.getProperty("jpa.database")+"/";  
  37.         path=FileUtils.getAbsolutePath(path);  
  38.         File file=new File(path);  
  39.         if(!file.exists()){  
  40.             file.mkdirs();  
  41.         }  
  42.         return path;  
  43.     }  
  44.     @Override  
  45.     public File getNewestBackupFile(){  
  46.         Map<String,File> map = new HashMap<>();  
  47.         List<String> list = new ArrayList<>();  
  48.         String path=getBackupFilePath();  
  49.         File dir=new File(path);  
  50.         File[] files=dir.listFiles();  
  51.         for(File file : files){  
  52.             String name=file.getName();  
  53.             if(!name.contains("bak")) {  
  54.                 continue;  
  55.             }  
  56.             map.put(name, file);  
  57.             list.add(name);  
  58.         }  
  59.         if(list.isEmpty()){  
  60.             return null;  
  61.         }  
  62.         //按备份时间排序  
  63.         Collections.sort(list);  
  64.         //最新备份的在最前面  
  65.         Collections.reverse(list);  
  66.           
  67.         String name = list.get(0);  
  68.         File file = map.get(name);  
  69.         //加速垃圾回收  
  70.         list.clear();  
  71.         map.clear();  
  72.           
  73.         return file;  
  74.     }    @Override  
  75.     public List<String> getExistBackupFileNames(){  
  76.         List<String> result=new ArrayList<>();  
  77.         String path=getBackupFilePath();  
  78.         File dir=new File(path);  
  79.         File[] files=dir.listFiles();  
  80.         for(File file : files){  
  81.             String name=file.getName();  
  82.             if(!name.contains("bak")) {  
  83.                 continue;  
  84.             }  
  85.             name=name.substring(0, name.length()-4);  
  86.             String[] temp=name.split("-");  
  87.             String y=temp[0];  
  88.             String m=temp[1];  
  89.             String d=temp[2];  
  90.             String h=temp[3];  
  91.             String mm=temp[4];  
  92.             String s=temp[5];  
  93.             name=y+"-"+m+"-"+d+" "+h+":"+mm+":"+s;  
  94.             result.add(name);  
  95.         }  
  96.         //按备份时间排序  
  97.         Collections.sort(result);  
  98.         //最新备份的在最前面  
  99.         Collections.reverse(result);  
  100.   
  101.         return result;  
  102.     }  
  103.     /** 
  104.      * 解密用户名和密码 
  105.      * @param encryptedMessage 加密后的用户名或密码 
  106.      * @return 解密后的用户名或密码 
  107.      */  
  108.     protected static String decrypt(String encryptedMessage){  
  109.         String plain=encryptor.decrypt(encryptedMessage);  
  110.         return plain;  
  111.     }    
  112. }  

 

 

    下面来看一个MySQL数据库的实现：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  *MySQL备份恢复实现 
  3.  * @author 杨尚川 
  4.  */  
  5. @Service("MYSQL")  
  6. public class MySQLBackupService extends AbstractBackupService{  
  7.    
  8.     /** 
  9.      * MySQL备份数据库实现 
  10.      * @return  
  11.      */  
  12.     @Override  
  13.     public boolean backup() {  
  14.         try {  
  15.             String path=getBackupFilePath()+DateTypeConverter.toFileName(new Date())+".bak";  
  16.             String command=PropertyHolder.getProperty("db.backup.command");  
  17.             command=command.replace("${db.username}", username);  
  18.             command=command.replace("${db.password}", password);  
  19.             command=command.replace("${module.short.name}", PropertyHolder.getProperty("module.short.name"));  
  20.   
  21.             Runtime runtime = Runtime.getRuntime();  
  22.             Process child = runtime.exec(command);  
  23.             InputStream in = child.getInputStream();  
  24.   
  25.             try(OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(path), "utf8");BufferedReader reader = new BufferedReader(new InputStreamReader(in, "utf8"))){  
  26.                 String line=reader.readLine();  
  27.                 while (line != null) {  
  28.                     writer.write(line+"\n");  
  29.                     line=reader.readLine();  
  30.                 }  
  31.                 writer.flush();  
  32.             }  
  33.             LOG.debug("备份到："+path);  
  34.             return true;  
  35.         } catch (Exception e) {  
  36.             LOG.error("备份出错",e);  
  37.         }  
  38.         return false;  
  39.     }  
  40.   
  41.     /** 
  42.      * MySQL恢复数据库实现 
  43.      * @param date 
  44.      * @return  
  45.      */  
  46.     @Override  
  47.     public boolean restore(String date) {  
  48.         try {  
  49.             String path=getBackupFilePath()+date+".bak";  
  50.             String command=PropertyHolder.getProperty("db.restore.command");  
  51.             command=command.replace("${db.username}", username);  
  52.             command=command.replace("${db.password}", password);  
  53.             command=command.replace("${module.short.name}", PropertyHolder.getProperty("module.short.name"));  
  54.               
  55.             Runtime runtime = Runtime.getRuntime();  
  56.             Process child = runtime.exec(command);  
  57.             try(OutputStreamWriter writer = new OutputStreamWriter(child.getOutputStream(), "utf8");BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(path), "utf8"))){  
  58.                 String line=reader.readLine();  
  59.                 while (line != null) {  
  60.                     writer.write(line+"\n");  
  61.                     line=reader.readLine();  
  62.                 }  
  63.                 writer.flush();  
  64.             }  
  65.             LOG.debug("从 "+path+" 恢复");  
  66.             return true;  
  67.         } catch (Exception e) {  
  68.             LOG.error("恢复出错",e);  
  69.         }  
  70.         return false;  
  71.     }  
  72. }  

 

 

    这里的关键有两点，一是从配置文件db.properties或db.local.properties中获取指定的命令进行备份和恢复操作，二是为实现类指定注解@Service("MYSQL")，这里服务名称必须和配置文件db.properties或db.local.properties中jpa.database的值一致，jpa.database的值指定了当前使用哪一种数据库，如下所示：

 

Java代码 复制代码 收藏代码
  1. #mysql  
  2. db.driver=com.mysql.jdbc.Driver  
  3. db.url=jdbc:mysql://localhost:3306/${module.short.name}?useUnicode=true&characterEncoding=UTF-8&createDatabaseIfNotExist=true&autoReconnect=true  
  4. db.username=ENC(i/TOu44AD6Zmz0fJwC32jQ==)  
  5. db.password=ENC(i/TOu44AD6Zmz0fJwC32jQ==)  
  6. jpa.database=MYSQL  
  7. db.backup.command=mysqldump  -u${db.username} -p${db.password} ${module.short.name}  
  8. db.restore.command=mysql -u${db.username} -p${db.password} ${module.short.name}  

 

 

    有了接口和多个实现，那么备份和恢复的时候究竟选择哪一种数据库实现呢？BackupServiceExecuter充当工厂类（Factory)，负责从多个数据库备份恢复实现类中选择一个并执行相应的备份和恢复操作，BackupServiceExecuter也实现了BackupService接口，这也是一个典型的外观(Facade)设计模式，封装了选择特定数据库的逻辑。

    定时调度器和web前端控制器也是使用BackupServiceExecuter来执行备份恢复操作，BackupServiceExecuter通过每个实现类以@Service注解指定的名称以及配置文件db.properties或db.local.properties中jpa.database的值来做选择的依据，如下所示：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  *执行备份恢复的服务，自动判断使用的是什么数据库，并找到该数据库备份恢复服务的实现并执行 
  3.  * @author 杨尚川 
  4.  */  
  5. @Service  
  6. public class BackupServiceExecuter extends AbstractBackupService{    
  7.     private BackupService backupService=null;  
  8.       
  9.     @Resource(name="backupFileSenderExecuter")  
  10.     private BackupFileSenderExecuter backupFileSenderExecuter;  
  11.     /** 
  12.      * 查找并执行正在使用的数据的备份实现实例 
  13.      * @return  
  14.      */  
  15.     @Override  
  16.     public boolean backup() {  
  17.         if(backupService==null){  
  18.             backupService=SpringContextUtils.getBean(PropertyHolder.getProperty("jpa.database"));  
  19.         }  
  20.         boolean result = backupService.backup();  
  21.         //如果备份成功，则将备份文件发往他处  
  22.         if(result){  
  23.             backupFileSenderExecuter.send(getNewestBackupFile());  
  24.         }  
  25.         return result;  
  26.     }  
  27.     /** 
  28.      * 查找并执行正在使用的数据的恢复实现实例 
  29.      * @param date 
  30.      * @return  
  31.      */  
  32.     @Override  
  33.     public boolean restore(String date) {  
  34.         if(backupService==null){  
  35.             backupService=SpringContextUtils.getBean(PropertyHolder.getProperty("jpa.database"));  
  36.         }  
  37.         return backupService.restore(date);  
  38.     }      
  39. }  

 

 

    关键是这行代码backupService=SpringContextUtils.getBean(PropertyHolder.getProperty("jpa.database"));

 

    2、在记录备份恢复日志的时候，如果每种数据库的实现类都要粘贴复制通用的代码到备份和恢复方法的开始和结束位置，那么四处就飘散着重复的代码，对易读性和可修改性都是极大的破坏。

 

    AOP是解决这个问题的不二之选，为了AOP能工作，良好设计的包结构、类层级，规范的命名都是非常重要的，尤其是这里的BackupServiceExecuter和真正执行备份恢复的实现类有共同的方法签名（都实现了BackupService接口），所以把他们放到不同的包里有利于AOP。

 

    使用AOP首先要引入依赖：

 

Xml代码 复制代码 收藏代码
  1. <dependency>  
  2.     <groupId>org.aspectj</groupId>  
  3.     <artifactId>aspectjrt</artifactId>  
  4.     <version>${aspectj.version}</version>  
  5. </dependency>      
  6. <dependency>  
  7.     <groupId>org.aspectj</groupId>  
  8.     <artifactId>aspectjweaver</artifactId>  
  9.     <version>${aspectj.version}</version>  
  10. </dependency>   

 

 

    其次是要在spring配置文件中指定启用自动代理：

Xml代码 复制代码 收藏代码
  1. <aop:aspectj-autoproxy />  

 

 

    最后就可以编写代码实现日志记录：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  * 备份恢复数据库日志Aspect 
  3.  * org.apdplat.module.system.service.backup.impl包下面有多个数据库的备份恢复实现 
  4.  * 他们实现了BackupService接口的backup方法（备份数据库）和restore（恢复数据库）方法 
  5.  * @author 杨尚川 
  6.  */  
  7. @Aspect  
  8. @Service  
  9. public class BackupLogAspect {  
  10.     private static final APDPlatLogger LOG = new APDPlatLogger(BackupLogAspect.class);  
  11.     private static final boolean MONITOR_BACKUP = PropertyHolder.getBooleanProperty("monitor.backup");  
  12.     private BackupLog backupLog = null;  
  13.       
  14.     static{  
  15.         if(MONITOR_BACKUP){              
  16.             LOG.info("启用备份恢复日志");  
  17.             LOG.info("Enable backup restore log", Locale.ENGLISH);  
  18.         }else{  
  19.             LOG.info("禁用备份恢复日志");  
  20.             LOG.info("Disable backup restore log", Locale.ENGLISH);  
  21.         }  
  22.     }  
  23.       
  24.     //拦截备份数据库操作      
  25.     @Pointcut("execution( boolean org.apdplat.module.system.service.backup.impl.*.backup() )")  
  26.     public void backup() {}  
  27.       
  28.     @Before("backup()")  
  29.     public void beforeBackup(JoinPoint jp) {  
  30.         if(MONITOR_BACKUP){  
  31.             before(BackupLogType.BACKUP);  
  32.         }  
  33.     }     
  34.       
  35.     @AfterReturning(value="backup()", argNames="result", returning = "result")    
  36.     public void afterBackup(JoinPoint jp, boolean result) {  
  37.         if(MONITOR_BACKUP){  
  38.             after(result);  
  39.         }  
  40.     }  
  41.       
  42.     //拦截恢复数据库操作      
  43.     @Before(value="execution( boolean org.apdplat.module.system.service.backup.impl.*.restore(java.lang.String) ) && args(date)",  
  44.             argNames="date")  
  45.     public void beforeRestore(JoinPoint jp, String date) {  
  46.         if(MONITOR_BACKUP){  
  47.             before(BackupLogType.RESTORE);  
  48.         }  
  49.     }         
  50.       
  51.     @AfterReturning(pointcut="execution( boolean org.apdplat.module.system.service.backup.impl.*.restore(java.lang.String) )",   
  52.             returning = "result")    
  53.     public void afterRestore(JoinPoint jp, boolean result) {  
  54.         if(MONITOR_BACKUP){  
  55.             after(result);  
  56.         }  
  57.     }  
  58.       
  59.     private void before(String type){  
  60.         LOG.info("准备记录数据库"+type+"日志");  
  61.         User user=UserHolder.getCurrentLoginUser();  
  62.         String ip=UserHolder.getCurrentUserLoginIp();  
  63.         backupLog=new BackupLog();  
  64.         if(user != null){  
  65.             backupLog.setUsername(user.getUsername());  
  66.         }  
  67.         backupLog.setLoginIP(ip);  
  68.         try {  
  69.             backupLog.setServerIP(InetAddress.getLocalHost().getHostAddress());  
  70.         } catch (UnknownHostException e) {  
  71.             LOG.error("无法获取服务器IP地址", e);  
  72.             LOG.error("Can't get server's ip address", e, Locale.ENGLISH);  
  73.         }  
  74.         backupLog.setAppName(SystemListener.getContextPath());  
  75.         backupLog.setStartTime(new Date());  
  76.         backupLog.setOperatingType(type);  
  77.     }  
  78.     private void after(boolean result){  
  79.         if(result){  
  80.             backupLog.setOperatingResult(BackupLogResult.SUCCESS);  
  81.         }else{  
  82.             backupLog.setOperatingResult(BackupLogResult.FAIL);  
  83.         }  
  84.         backupLog.setEndTime(new Date());  
  85.         backupLog.setProcessTime(backupLog.getEndTime().getTime()-backupLog.getStartTime().getTime());  
  86.         //将日志加入内存缓冲区  
  87.         BufferLogCollector.collect(backupLog);  
  88.         LOG.info("记录完毕");  
  89.     }  
  90. }  

 

 

   3、怎么样才能异地容错呢？将备份文件保存到与服务器处于不同地理位置的机器上，最好能多保存几份。除了能自动把备份文件传输到异地服务器上面，用户也可以从web界面下载。

 

    APDPlat使用推模型来发送备份文件，接口如下：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  * 备份文件发送器 
  3.  * 将最新的备份文件发送到其他机器，防止服务器故障丢失数据 
  4.  * @author 杨尚川 
  5.  */  
  6. public interface BackupFileSender {  
  7.     public void send(File file);  
  8. }  

 

 

    有了统一的接口，就可以有灵活的实现方式，如通过HTTP、FTP、SOCKET等方式发送到异地机房。

 

    在上面的BackupServiceExecuter类中我们已经看到，当备份成功之后就会调用BackupFileSenderExecuter的send方法发送备份文件，如下：

 

Java代码 复制代码 收藏代码
  1. boolean result = backupService.backup();  
  2. //如果备份成功，则将备份文件发往他处  
  3. if(result){  
  4.     backupFileSenderExecuter.send(getNewestBackupFile());  
  5. }  

 

 

   BackupFileSenderExecuter的设计和BackupServiceExecuter类似，不过策略不一样，如果配置有多个Sender，那么会调用所有的Sender，达到拥有多个副本的目的。BackupFileSenderExecuter利用配置项log.backup.file.sender的值来指定启用哪些Sender，并依次调用各个Sender的send方法来完成文件的发送，如下所示：

 

Java代码 复制代码 收藏代码
  1. log.backup.file.sender=localBackupFileSender;  

 

 

    这里 localBackupFileSender是LocalBackupFileSender的Spring Bean名称。

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  *执行备份文件的发送服务，根据配置文件来判断使用哪些发送器，并按配置的前后顺序依次调用 
  3.  * @author 杨尚川 
  4.  */  
  5. @Service  
  6. public class BackupFileSenderExecuter  implements  BackupFileSender, ApplicationListener{  
  7.     protected final APDPlatLogger LOG = new APDPlatLogger(getClass());  
  8.     private static final List<BackupFileSender> backupFileSenders = new LinkedList<>();    
  9.     @Override  
  10.     public void send(File file) {  
  11.         for(BackupFileSender sender : backupFileSenders){  
  12.             sender.send(file);  
  13.         }  
  14.     }  
  15.     @Override  
  16.     public void onApplicationEvent(ApplicationEvent event){  
  17.             if(event instanceof ContextRefreshedEvent){  
  18.                     LOG.info("spring容器初始化完成,开始解析BackupFileSender");  
  19.                     String senderstr = PropertyHolder.getProperty("log.backup.file.sender");  
  20.                     if(StringUtils.isBlank(senderstr)){  
  21.                             LOG.info("未配置log.backup.file.sender");  
  22.                             return;  
  23.                     }  
  24.                     LOG.info("log.backup.file.sender："+senderstr);  
  25.                     String[] senders = senderstr.trim().split(";");  
  26.                     for(String sender : senders){  
  27.                             BackupFileSender backupFileSender = SpringContextUtils.getBean(sender.trim());  
  28.                             if(backupFileSender != null){  
  29.                                     backupFileSenders.add(backupFileSender);  
  30.                                     LOG.info("找到BackupFileSender："+sender);  
  31.                             }else{  
  32.                                     LOG.info("未找到BackupFileSender："+sender);  
  33.                             }  
  34.                     }  
  35.             }  
  36.     }  
  37. }  

 

 

    看一个备份文件发送者示例LocalBackupFileSender：

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  * 将备份文件从本地一个目录复制到另一个目录 
  3.  * @author 杨尚川 
  4.  */  
  5. @Service  
  6. public class LocalBackupFileSender implements BackupFileSender{  
  7.     protected final APDPlatLogger LOG = new APDPlatLogger(getClass());  
  8.   
  9.     @Override  
  10.     public void send(File file) {  
  11.         try {  
  12.             String dist = PropertyHolder.getProperty("log.backup.file.local.dir");  
  13.             LOG.info("备份文件："+file.getAbsolutePath());  
  14.             LOG.info("目标目录："+dist);  
  15.             FileUtils.copyFile(file, new File(dist,file.getName()));  
  16.         } catch (IOException ex) {  
  17.             LOG.info("LocalBackupFileSender失败", ex);  
  18.         }  
  19.     }  
  20. }  

 

0 0
苏联大清洗知乎 苏联大清洗知乎
原创粉丝点击
热门IT博客
什么是淘宝店铺维护什么是淘宝店铺维护
网络电视怎么看本港台网络电视怎么看本港台
唯歌生民病 愿得天子知
数据有效性检验 挖掘
java实现zip的解压
淘宝优惠券在哪里看
淘宝代金券最多
知乎kindle推送
zdm软件绘制纵断面
微信拓客软件
超星尔雅网络课程心得
微商必备软件
威斯汀酒店知味餐厅
js filereader文件路径
链家java开发
哪里注册域名最好
网络语713是什么意思
实验支撑岗 知乎
歪歪是什么软件
光谷软件新城
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 三七灰土白灰用量算法 小型灰土拌合机 37灰土配合比 三七灰土多少钱一立方 三七灰土比例 灰土计算公式 三七灰土施工工艺 坑灰未冷 古墓丽影暗影灰岩坑 客厅浅灰瓷砖与景墙图片 壳牌灰喜力价格 灰壳牌机油价格 壳牌 灰 上洋壳灰 灰壳机油 灰壳是全合成机油吗 灰鸽子脱壳版 灰壳全合成机油怎么样 灰壳价格 灰壳超凡喜力价格 灰壳5w40价格 灰壳机油价格 金美孚和灰壳哪个好 黑防灰鸽子脱壳版 灰壳 金美孚 壳牌机油灰壳 灰壳和美孚一号哪个好 灰壳和金美孚哪个好 灰壳5w 30 灰壳 5w 30 灰壳5w30 蓝壳 灰壳 灰壳5w40机油报价 灰壳 蓝壳 灰壳5w-30价格 灰壳 5w40 蓝壳和灰壳的区别 灰壳 价格 灰壳蓝壳 灰壳 5w 灰壳机油好吗

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里