IO Foundation 3 - 파일 해상도 기 FileParser

30071 단어 자바IO

위의 문장http://supercharles888.blog.51cto.com/609344/980309 StringTemplate Parser 를 사용 하여 설정 가능 한 규칙 을 동적 으로 이용 할 수 있다 고 언급 했 습 니 다. 자리 표시 자가 있 는 문자열 을 자리 표시 자가 없 는 문자열 로 바 꿉 니 다.그래서 여기 서 언급 한 클래스 FileParser 는 StringTemplate Parser 를 이용 하여 자리 표시 자 가 있 는 파일 을 읽 고 자리 표시 자 가 없 는 파일 로 전환 하 는 것 입 니 다.
 
직접 코드 올 리 기:
 

  
  
  
  
  1. ...
  2. // import
  3.  
  4.   
  5.  
  6. /** 
  7.  
  8. * 
  9.  
  10.  * The class can do the file parse work as follows: first it will read the 
  11.  
  12. * content of the input file from the location , then,it will invoke the 
  13.  
  14. * StringTemplateParser utility method to do the parsing work(replacing the 
  15.  
  16. * placeholders) finally, it will generate a new file with the new contents 
  17.  
  18. * 
  19.  
  20.  * @author cwang58 
  21.  
  22. * @created date: Aug 2, 2012 
  23.  
  24. */ 
  25.  
  26. public class FileParser implements IFileParser { 
  27.  
  28.   
  29.  
  30.          private static Logger logger = LoggerFactory.getLogger(FileParser.class); 
  31.  
  32.   
  33.  
  34.          private IStringTemplateParser stp; 
  35.  
  36.   
  37.  
  38.          public FileParser() throws Exception { 
  39.  
  40.   
  41.  
  42.                  stp = new StringTemplateParser(); 
  43.  
  44.   
  45.  
  46.          } 
  47.  
  48.   
  49.  
  50.          public IStringTemplateParser getStp() { 
  51.  
  52.                  return stp; 
  53.  
  54.          } 
  55.  
  56.   
  57.  
  58.          public void setStp(IStringTemplateParser stp) { 
  59.  
  60.                  this.stp = stp; 
  61.  
  62.          } 
  63.  
  64.   
  65.  
  66.          /** 
  67.  
  68.          * this method will read the content from the file designated by parameter 
  69.  
  70.          * 
  71.  
  72.           * @param source 
  73.  
  74.          *            the location of the file that we read from 
  75.  
  76.          * @return the string content of the file 
  77.  
  78.          * @throws Exception 
  79.  
  80.          */ 
  81.  
  82.          public String readContentFromFile(String source) throws Exception { 
  83.  
  84.   
  85.  
  86.                  File file = new File(source); 
  87.  
  88.   
  89.  
  90.                  // first make sure the source is a file ,not a directory 
  91.  
  92.                  if (file.isDirectory()) { 
  93.  
  94.   
  95.  
  96.                           if (logger.isErrorEnabled()) { 
  97.  
  98.                                    logger.error("the source file can not be a directory"); 
  99.  
  100.                           } 
  101.  
  102.   
  103.  
  104.                           throw new ParameterInvalidException(FILE_REPLACEMENT_ERROR); 
  105.  
  106.                  } 
  107.  
  108.   
  109.  
  110.                  // open a file reader to read the file content 
  111.  
  112.                  BufferedReader reader = null
  113.  
  114.                  try { 
  115.  
  116.                           reader = new BufferedReader(new FileReader(file)); 
  117.  
  118.   
  119.  
  120.                           StringBuffer bufferedFileContent = new StringBuffer(); 
  121.  
  122.                           String line = null
  123.  
  124.   
  125.  
  126.                           while ((line = reader.readLine()) != null) { 
  127.  
  128.                                    bufferedFileContent.append(line + LINE_SEPARATOR); 
  129.  
  130.                           } 
  131.  
  132.                           reader.close(); 
  133.  
  134.   
  135.  
  136.                           return bufferedFileContent.toString(); 
  137.  
  138.   
  139.  
  140.                  } catch (FileNotFoundException ex) { 
  141.  
  142.   
  143.  
  144.                           if (logger.isErrorEnabled()) { 
  145.  
  146.                                    logger.error("File is not found"); 
  147.  
  148.   
  149.  
  150.                           } 
  151.  
  152.                           throw new FileReplacerException(FILE_REPLACEMENT_ERROR, ex); 
  153.  
  154.                  } catch (IOException ex) { 
  155.  
  156.   
  157.  
  158.                           if (logger.isErrorEnabled()) { 
  159.  
  160.                                    logger.error("IO didn't open or closed"); 
  161.  
  162.                           } 
  163.  
  164.                           throw new FileReplacerException(FILE_REPLACEMENT_ERROR, ex); 
  165.  
  166.   
  167.  
  168.                  } 
  169.  
  170.   
  171.  
  172.          } 
  173.  
  174.   
  175.  
  176.          /** 
  177.  
  178.          * This method is used for writing the string content to a file given by 
  179.  
  180.          * parameter 
  181.  
  182.          * 
  183.  
  184.           * @param fileContent 
  185.  
  186.          *            the string content 
  187.  
  188.          * @param destination 
  189.  
  190.          *            the path of the destination file which we want to write to 
  191.  
  192.          * @throws Exception 
  193.  
  194.          * 
  195.  
  196.           */ 
  197.  
  198.          public void writeContentToFile(String fileContent, String destination) 
  199.  
  200.                           throws Exception { 
  201.  
  202.   
  203.  
  204.                  File file = new File(destination); 
  205.  
  206.   
  207.  
  208.                  // first make sure the source is a file ,not a directory 
  209.  
  210.                  if (file.isDirectory()) { 
  211.  
  212.   
  213.  
  214.                           if (logger.isErrorEnabled()) { 
  215.  
  216.                                    logger.error("the destination file can not be a directory"); 
  217.  
  218.                           } 
  219.  
  220.   
  221.  
  222.                           throw new ParameterInvalidException("the destination file" 
  223.  
  224.                                             + destination + "can not be a directory"); 
  225.  
  226.                  } 
  227.  
  228.   
  229.  
  230.                  // open a file writer to write the file content 
  231.  
  232.                  BufferedWriter writer = null
  233.  
  234.                  try { 
  235.  
  236.                           writer = new BufferedWriter(new FileWriter(file, false)); 
  237.  
  238.   
  239.  
  240.                           writer.write(fileContent); 
  241.  
  242.                           writer.flush(); 
  243.  
  244.   
  245.  
  246.                  } catch (FileNotFoundException ex) { 
  247.  
  248.   
  249.  
  250.                           if (logger.isErrorEnabled()) { 
  251.  
  252.                                    logger.error("File is not found"); 
  253.  
  254.   
  255.  
  256.                           } 
  257.  
  258.                           throw new FileReplacerException("the file:" + destination 
  259.  
  260.                                             + " can't be found", ex); 
  261.  
  262.   
  263.  
  264.                  } catch (IOException ex) { 
  265.  
  266.   
  267.  
  268.                           if (logger.isErrorEnabled()) { 
  269.  
  270.                                    logger.error("IO didn't open or closed"); 
  271.  
  272.   
  273.  
  274.                           } 
  275.  
  276.                           throw new FileReplacerException( 
  277.  
  278.                                             "can't write the contents into file: " + destination, ex); 
  279.  
  280.   
  281.  
  282.                  }finally
  283.  
  284.                           writer.close(); 
  285.  
  286.                  } 
  287.  
  288.   
  289.  
  290.          } 
  291.  
  292.   
  293.  
  294.          /** 
  295.  
  296.          * the process for replacing the giving files placeholder 
  297.  
  298.          * 
  299.  
  300.           * @param source 
  301.  
  302.          *            the location of the file that has place holder 
  303.  
  304.          * @param destination 
  305.  
  306.          *            the location that put the parsed file 
  307.  
  308.          */ 
  309.  
  310.          public void parseFile(String source, String destination) throws Exception { 
  311.  
  312.   
  313.  
  314.                  if (logger.isDebugEnabled()) { 
  315.  
  316.                           logger.debug("the file location which contains placeholder is: " 
  317.  
  318.                                             + source); 
  319.  
  320.                           logger.debug("the file location that we put back is: " 
  321.  
  322.                                             + destination); 
  323.  
  324.                  } 
  325.  
  326.   
  327.  
  328.                  String placeHolderFileContent = readContentFromFile(source); 
  329.  
  330.                  if (logger.isDebugEnabled()) { 
  331.  
  332.                           logger.debug("the content in this placeholder's file is: " 
  333.  
  334.                                             + placeHolderFileContent); 
  335.  
  336.                  } 
  337.  
  338.   
  339.  
  340.                  if (logger.isDebugEnabled()) { 
  341.  
  342.                           logger.debug("Begin to use rule builder to replace the placeholders in the source file"); 
  343.  
  344.                  } 
  345.  
  346.                  String noPlaceHolderFileContent = stp 
  347.  
  348.                                    .parseStringTemplateWithRuleBuilder(placeHolderFileContent); 
  349.  
  350.   
  351.  
  352.                  if (logger.isDebugEnabled()) { 
  353.  
  354.                           logger.debug("After parsing ,the file content with no place holder is: " 
  355.  
  356.                                             + noPlaceHolderFileContent); 
  357.  
  358.                  } 
  359.  
  360.   
  361.  
  362.                  writeContentToFile(noPlaceHolderFileContent, destination); 
  363.  
  364.   
  365.  
  366.                  if (logger.isDebugEnabled()) { 
  367.  
  368.                           logger.debug("writing no placeholder file to " + destination 
  369.  
  370.                                             + " successfully"); 
  371.  
  372.                  } 
  373.  
  374.          } 
  375.  
  376.   
  377.  

 
한눈 에 알 수 있 는 세 가지 방법:
(1)readContentFromFile:
이 방법 은 매우 기본 적 인 io 작업 클래스 입 니 다. 그 목적 은 자리 표시 자 를 포함 한 파일 내용 을 문자열 에 읽 는 것 입 니 다. 왜냐하면 우리 가 지난 글 에서 언급 한 StringTemplate Parser 는 문자열 에 관 한 작업 이기 때 문 입 니 다.
(2)writeContentToFile:
이 방법 은 readContent FromFile 과 반대 되 는 일 을 했 습 니 다. 그 렇 죠? 지정 한 파일 에 문자열 내용 (일반적으로 바 뀐 내용) 을 기록 합 니 다.
(3)parseFile:
이 방법 은 바로 (1) 과 (2)결합 하면 readContentFromFile 방법 을 먼저 호출 합 니 다. 자리 표시 자가 있 는 파일 의 내용 을 문자열 변 수 를 읽 은 다음 StringTemplate Parser 류 의 parseStringTemplate With RuleBuilder 방법 을 호출 합 니 다. 자리 표시 자가 있 는 문자열 을 자리 표시 자가 없 는 문자열 로 바 꾸 고 마지막 으로 자리 표시 자가 없 는 문자열 을 writeContentToFile 방법 으로 씁 니 다.지정 한 파일 에 들 어 갑 니 다.

좋은 웹페이지 즐겨찾기