[Java] FileUtil.java

@

package test.core.util;
 
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.attribute.PosixFilePermission;
import java.util.HashSet;
import java.util.Set;
 
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;
 
import wevenjv.core.exception.FileUtilException;
 
public class FileUtil 
{
    static Logger logger = LoggerFactory.getLogger(FileUtil.class);
    
    public static String[] imageUpload( MultipartFile file, String uploadRealPath, boolean isCreateThumbnail ) throws IllegalStateException, IOException
    {
        // 경로
        int pathPos = uploadRealPath.lastIndexOf( "/" );
        String path = uploadRealPath.substring( 0, pathPos );
        File pathData = new File( path );
        
        //해당 디렉토리의 존재여부를 확인
        if(!pathData.exists()){
            //없다면 생성
            if (pathData.mkdirs()){
              logger.debug("디렉토리 생성 성공");
            }else{
              System.out.println("디렉토리 생성 실패");
            }
        }
        
        File fileData = new File(uploadRealPath);
 
        if( fileData.exists() ){
            if( fileData.isDirectory() ){
                throw new FileUtilException("이미 존재하는 디렉토리와 이름이 같습니다. ", FileUtilException.ERROR_CODE_NOT_FILE);
            }else if( fileData.isFile() ){
                fileData.deleteOnExit();
            }
        }
        
        file.transferTo(fileData);
        
        return new String[]{"thumb"};
    }    
        
    /**
     * @param file
     * @param uploadRealPath
     * @param isOverride
     * @throws IOException 
     * @throws IllegalStateException 
     * @throws FileUtilException 
     */
    public static String upload(MultipartFile file, String uploadRealPath, boolean isOverride)
            throws IllegalStateException, IOException, FileUtilException
    {
        // 경로
        int pathPos = uploadRealPath.lastIndexOf( "/" );
        String path = uploadRealPath.substring( 0, pathPos );
        File pathData = new File( path );
        
        //해당 디렉토리의 존재여부를 확인
        if(!pathData.exists()){
            //없다면 생성
            if (pathData.mkdirs()){
                logger.debug("디렉토리 생성 성공");
            }else{
                logger.debug("디렉토리 생성 실패");
            }
        }
        
        File fileData = new File(uploadRealPath);
        
        int count = 0;
        int pos = uploadRealPath.lastIndexOf( "." );
        String ext = null;
        String fileNameExcludeExt = null;
        // [hanjd] 파일명에 .이 없는 경우가 있을 수 있음.
        // > UUID 형식의 파일명의 경우 . 을 포함하지 않는다.
        if(pos < 0){
            ext = "";
            fileNameExcludeExt = uploadRealPath; 
        }else{
            ext = uploadRealPath.substring( pos + 1 );
            fileNameExcludeExt = uploadRealPath.substring( 0, pos-1 ); 
        }
 
        if( fileData.exists() ){
            if( fileData.isFile() ){
                if( isOverride ){
                    fileData.deleteOnExit();
                }else{
                    while( fileData.exists() ){
                        uploadRealPath = fileNameExcludeExt + "(" + count + ")." + ext;
                        fileData = new File(uploadRealPath);
                        
                        count++;
                    }
                    file.transferTo(fileData);
                }
                
            }else if( fileData.isDirectory() ){
                while( fileData.exists() ){
                    uploadRealPath = fileNameExcludeExt + "(" + count + ")." + ext;
                    fileData = new File(uploadRealPath);
                    
                    count++;
                }
                file.transferTo(fileData);
            }
        }else{
            file.transferTo(fileData);
        }
        
        String fileServerName = uploadRealPath.substring( uploadRealPath.lastIndexOf( "/" ) + 1 );
        return fileServerName;
    }
    
    public static void delete(String deleteRealPath)
    {
        // 경로
        File fileData = new File(deleteRealPath);
        
        // 파일 존재 여부
        if(fileData.exists()){
            if(fileData.isDirectory()){
                try {
                    FileUtils.deleteDirectory(fileData);
                    logger.debug("delete directory :: {}", deleteRealPath);
                } catch (IOException e) {
                    logger.debug("네트워크 오류");
                }
            }else{
                if(fileData.delete()){
                    logger.debug("SUCCESS!! delete file :: {}", deleteRealPath);
                }else{
                    logger.debug("FAIL!! delete file :: {}", deleteRealPath);
                }
            }
        }
    }
    
    public static void download( HttpServletRequest request, HttpServletResponse response, String fileName, String uploadedRealPath, long fileSize ) throws IOException {
        
        String downName = fileName;
        String browser = request.getHeader("User-Agent");
        if(browser.contains("MSIE") || browser.contains("Trident")) { 
            downName = URLEncoder.encode(fileName,"UTF-8").replaceAll("\\+", "%20"); 
        } else if(browser.contains("Chrome")) {
            StringBuffer sb = new StringBuffer();
 
            for (int i = 0; i < downName.length(); i++) {
                   char c = downName.charAt(i);
                   if (c > '~') {
                         sb.append(URLEncoder.encode("" + c, "UTF-8"));
                   } else {
                         sb.append(c);
                   }
            }
            downName = sb.toString();
        } else { 
            downName = new String(fileName.getBytes("UTF-8"), "ISO-8859-1"); 
        }
        response.setHeader("Content-Disposition","attachment;filename=\"" + downName + "\"");    
        response.setContentType("application/octer-stream"); 
        response.setHeader("Content-Transfer-Encoding", "binary;");
 
//        String name = new String( (fileName).getBytes("UTF-8"),"UTF-8" );
//        response.setContentType( request.getSession().getServletContext().getMimeType( uploadedRealPath ) );
//        response.setCharacterEncoding("UTF-8");
//        response.setHeader( "Content-Disposition", "attachment;filename=" + '"' + URLEncoder.encode(name, "UTF-8") + '"');
//        response.setHeader( "Content-Description", "Weven Generated Data" );
        
        File file = null;
        FileInputStream fileIn = null;
        ServletOutputStream out = null;
        
        try {
            file = new File( uploadedRealPath );
            fileIn = new FileInputStream(file);
            out = response.getOutputStream();
            
            byte b [] = new byte[1024]; 
            int data = 0; 
            while((data=(fileIn.read(b, 0, b.length))) != -1) { 
                out.write(b, 0, data); 
            } 
            out.flush();
        } catch (IOException e) {
            logger.debug("파일 다운로드 에러");
        } finally{
            if(out != null){
                out.close();
                out = null;
            }
            if(fileIn != null){
                fileIn.close();
                fileIn = null;
            }
        }
        
        //copy binary contect to output stream
//        byte[] outputByte = new byte[4096];
//        int readLen;
//        while((readLen=fileIn.read(outputByte)) != -1) {
//            out.write(outputByte, 0, readLen);
//        }
//        fileIn.close();
//        out.flush();
//        out.close();
    }
    
    static public boolean createFileBytes(String path, String fileName, byte[] content){
        FileUtil.createDir(path);
        
        File file = new File(path+"/"+fileName);
        FileOutputStream out = null;
        try{
            if(file.exists() == false){
                if(file.createNewFile() == false){
                    return false;
                }
            }
            
            out = new FileOutputStream(file);
            out.write(content);
            out.close();
            
            setDefaultPermissions(file);
            
            return true;
        }catch(Exception e){
            logger.debug("Error : FileUtil.createFileBytes");
            return false;
        }finally {
            if(out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    logger.debug("네트워크 오류");
                }
            }
        }
    }
 
    static public boolean createFileWithUTF8(String path, String fileName, String content){
        return createFileWithEncoding(path, fileName, content, StandardCharsets.UTF_8);
    }
 
    static public boolean createFileWithEncoding(String path, String fileName, String content, Charset charset){
        
        FileUtil.createDir(path);
        
        File file = new File(path+"/"+fileName);
        BufferedWriter out = null;
        try{
            if(file.exists() == false){
                if(file.createNewFile() == false){
                    return false;
                }
            }
            
            out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset));
            out.write(content);
            out.close();
            
            setDefaultPermissions(file);
            
            return true;
        }catch(Exception e){
            logger.debug("Error : FileUtil.createFileWithEncoding");
            return false;
        }finally {
            if(out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    logger.debug("네트워크 오류");
                }
            }
        }
    }
    
    static public boolean createDir(String path){
        File file = new File(path);
        if(file.exists() == false){
            boolean result = file.mkdirs();
            
            setDefaultPermissions(file);
            
            return result;
        }
        return true;
    }
    
    private static void setDefaultPermissions(File file){
         Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
         perms.add(PosixFilePermission.OWNER_READ);
         perms.add(PosixFilePermission.OWNER_WRITE);
         perms.add(PosixFilePermission.OWNER_EXECUTE);
         perms.add(PosixFilePermission.GROUP_EXECUTE);
         perms.add(PosixFilePermission.GROUP_READ);
         perms.add(PosixFilePermission.OTHERS_EXECUTE);
         perms.add(PosixFilePermission.OTHERS_READ);
         try{
             Files.setPosixFilePermissions(file.toPath(), perms);
         }catch(IOException e){
             logger.debug("네트워크 오류");
         }catch(UnsupportedOperationException e){
             logger.debug("권한 오류");
         }
    }
    
    public static boolean smartCopy(String oldPath, String newPath) {
        try {
            logger.debug("smartCopy :: from {} to {}", oldPath, newPath);
            FileUtils.copyDirectory(new File(oldPath), new File(newPath));
            return true;
        } catch (IOException e) {
            logger.debug("네트워크 오류");
            return false;
        }
    }    
    
    /**
     * 폴더내 모든 파일 호출
     * @param pathname
     * @return
     */
    public static File[] readFilesOnFolder( File directory ){
        return FileUtils.convertFileCollectionToFileArray( FileUtils.listFiles(directory, FileFilterUtils.notFileFilter(DirectoryFileFilter.INSTANCE), FileFilterUtils.notFileFilter(DirectoryFileFilter.INSTANCE)) );
    }
    
    /**
     * 폴더내 모든 파일 호출
     * @param pathname
     * @return
     */
    public static File[] readFilesOnFolder( String pathname ){
        return readFilesOnFolder( new File(pathname) );
    }
    
    /**
     * 확장자 리스트의 것들만 뽑아서 재귀적 호출
     * @param pathname
     * @param extensions
     * @param recursive
     * @return
     */
    public static File[] readFilesOnFolder( String pathname, String[] extensions, boolean recursive ){
        File directory = new File(pathname);
        return FileUtils.convertFileCollectionToFileArray( FileUtils.listFiles(directory, extensions, recursive) );
    }
        
    public static String getNameReal( File file ){
        String originFilePath = file.getName();
        return originFilePath.substring( originFilePath.lastIndexOf("/")+1 );
    }
        
    public static void renameFileOrFolder(File srcFile, String destName, boolean isDirectory ) {
        String originFilePath = srcFile.getAbsolutePath();
        originFilePath = originFilePath.substring(0, originFilePath.indexOf( srcFile.getName() ) );
        if( isDirectory ){
            
            try {
                FileUtils.moveDirectory( srcFile, new File( originFilePath + destName ) );
            } catch (IOException e) {
                logger.debug("네트워크 오류");
            }
        }else{
            try {
                FileUtils.moveFile(srcFile, new File( originFilePath + destName ) );
            } catch (IOException e) {
                logger.debug("네트워크 오류");
            }
        }
    }
    
    public static String readFileToString(File file){
        try {
            return FileUtils.readFileToString(file);
        } catch (IOException e) {
            logger.debug("네트워크 오류");
        }
        return null;
    }
        
    public static void writeStringToFile(File file, String data){
        try {
            FileUtils.writeStringToFile(file, data);
        } catch (IOException e) {
            logger.debug("네트워크 오류");
        }
    }
}
 

@