아날로그 데이터베이스 사무 이체 실현

아날로그 데이터베이스 사무 이체 실현
생각을 실현하다
실제 데이터베이스와 같은 전략을 채택하여 데이터베이스의 사무를 실현하다.업무의 지속성과 원자성을 확보하기 위해 레드와 undo를 사용합니다.redo log는 업무의 지속성을 확보하기 위해 데이터베이스가 데이터의 업데이트 작업을 할 때 업데이트된 결과를 디스크에 바로 쓰지 않습니다.업데이트된 데이터 (더러운 페이지) 가 디스크에 기록되지 않은 단계에서 고장이 나면데이터베이스는 redo log를 이용하여 이전에 디스크에 지속되지 않았던 데이터를 데이터베이스로 지속할 수 있습니다.undolog는 업무의 원자성을 확보하기 위해 데이터베이스는 데이터를 수정하기 전에 모두 undolog를 이용하여 데이터의 백업을 했다. 만약에 여러 번의 조작 사이에 데이터베이스가 고장나면 undo를 이용하여 원래의 데이터를 복원할 수 있다.
실제 데이터베이스에서 A가 B로 50을 이체하는 과정을 실현한다(두 사람의 계좌가 모두 100이라고 가정한다)

1.     
2.   A=100 undo log
3.   A=50
4.   A=50  redo log
5.   B=100  undo log
6.   B=50
7.   B=50 redo log
8.  redo log    
9.     

코드

import com.sun.org.apache.regexp.internal.REUtil;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class TransactionDemo {
    private static final String USER_A ="A.txt";
    private static final String USER_B ="B.txt";

    private static final String UNDO_LOG_FILE_PATH ="undolog.txt";
    private static final String REDO_LOG_FILE_PATH ="redolog.txt";

    //  A B       
    private static int userAaccount;
    private static int userBaccount;

    public static void main(String[] args) throws IOException, InterruptedException {
        //     
        if(!roleback()){
            System.out.println("  y    ，  n    ");
            String input = new Scanner(System.in).next();
            if("n".equals(input.toLowerCase())){
                return;
            }
            System.out.println("     ");
        }

        //      
        execute();
        System.out.println("    ");
    }

    /**
     *     
     * @return        false,     
     * @throws IOException
     */
    private static boolean roleback() throws IOException {
        String undo=FileUtil.getFileInfo(UNDO_LOG_FILE_PATH);
        if(!"".equals(undo)){
            System.out.println("      ，    ");
            Map info = getInfoFromLog(UNDO_LOG_FILE_PATH);
            persist(info);
            clearLogs();
            return false;
        }
        String redo=FileUtil.getFileInfo(REDO_LOG_FILE_PATH);
        if(!"".equals(redo)){
            System.out.println("            ，     ");
            Map info = getInfoFromLog(REDO_LOG_FILE_PATH);
            persist(info);
            clearLogs();
            return false;
        }
        clearLogs();
        return  true;


    }


    /**
     *            
     */
    private static void init() throws IOException {
        //  redo  undo
        FileUtil.writeToFile("", REDO_LOG_FILE_PATH);
        FileUtil.writeToFile("", UNDO_LOG_FILE_PATH);
        loader();
    }

    /**
     *          
     *
     *
     *     ：
     * redo log           ，              ，     
     *      ，      。         （  ）             
     *        redo log                     。
     *
     * undo log           ，          ，   undo log        
     *              ，    undo       
     * @throws IOException
     * @throws InterruptedException
     */
    private static void execute() throws IOException, InterruptedException {
        //     
        init();
        //    A                 undolog
        FileUtil.addInfoToFile(" A:"+userAaccount,UNDO_LOG_FILE_PATH);
        //    A   
        userAaccount-=50;

        //   A            redo log
        FileUtil.addInfoToFile(" A:"+userAaccount,REDO_LOG_FILE_PATH);
        //   B        undo log
        FileUtil.addInfoToFile(" B:"+userBaccount,UNDO_LOG_FILE_PATH);
        //    B   
        userBaccount+=50;

        //   B            redo log
        FileUtil.addInfoToFile(" B:"+userBaccount,REDO_LOG_FILE_PATH);

        //     ，               redo log ，            undo log
        FileUtil.writeToFile("", UNDO_LOG_FILE_PATH);
       
        // redo log        ，       
        Map infos=getInfoFromLog(REDO_LOG_FILE_PATH);
        persist(infos);

        //       ，        ，     redo,  
        FileUtil.writeToFile("",REDO_LOG_FILE_PATH);

    }



    /**
     *    A B         
     *               
     */
    private static void loader() throws IOException{
        userAaccount=Integer.parseInt(FileUtil.getFileInfo(USER_A));
        userBaccount=Integer.parseInt(FileUtil.getFileInfo(USER_B));
    }

    /**
     *  log     ，  map     ，    
     * @param path
     * @return
     */
    private static Map getInfoFromLog(String path) throws IOException {
        Map result=new HashMap();
        String info=FileUtil.getFileInfo(path);
        String[] infos = info.trim().split(" ");
        for(String str:infos){
            String[] items=str.split(":");

            result.put(items[0],items[1]);
        }
        return result;
    }

    /**
     *                   
     * @param infos
     */
    private static void persist(Map infos) throws IOException {
        if(infos.containsKey("A")){

            FileUtil.writeToFile(infos.get("A"),USER_A);
        }
        if(infos.containsKey("B")){
            FileUtil.writeToFile(infos.get("B"),USER_B);
        }



    }

    /**
     *        
     * @throws IOException
     */
    private static void clearLogs() throws IOException {
        FileUtil.writeToFile("",UNDO_LOG_FILE_PATH);
        FileUtil.writeToFile("",UNDO_LOG_FILE_PATH);
    }





}



class FileUtil{
    /**
     *         
     * @param path   
     * @return
     * @throws IOException
     */
    public static String getFileInfo(String path) throws IOException {
        byte[] bytes=new byte[1024];
        ByteBuffer buffer=ByteBuffer.wrap(bytes);
        FileInputStream stream = new FileInputStream(path);
        FileChannel channel = stream.getChannel();
        channel.read(buffer);
        return new String(bytes,"utf-8").trim();

    }

    /**
     *         
     * @param info       
     * @param path   
     * @throws IOException
     */
    public static void writeToFile(String info,String path) throws IOException {
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        FileOutputStream stream = new FileOutputStream(path);
        buffer.put(info.getBytes("utf-8"));
        buffer.flip();
        FileChannel channel = stream.getChannel();
        channel.write(buffer);

    }

    /**
     *         
     * @param Info       
     * @param path   
     * @throws IOException
     */
    public static void addInfoToFile(String Info,String path) throws IOException {
        String oldInfo=getFileInfo(path);
        writeToFile(oldInfo+Info,path);
    }
}