随笔-文件的读写

接口

/**
 * http 请求服务
 * @author shijx
 * 2010-8-16
 */
public interface HttpService
{
    /**
     * 将HTTP资源另存为文件
     * @param destUrl String
     * @param fileName String
     * @throws Exception
     */
    public void saveToFile(String destUrl, String fileName) throws IOException ;
}
/////////////////////////////////////////////////////////////////////////////////////////

实现类

import java.net.URL;

import java.net.HttpURLConnection;

import java.io.BufferedInputStream;
import java.io.FileOutputStream;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * http 请求服务
 */
@Service("httpService")
@Transactional
public class HttpServiceImpl implements HttpService
{

    protected Log logger = LogFactory.getLog(getClass());

    /*<!--http请求保存文件--> 这块是spring bean配置
    <bean id="httpService" class="http.HttpServiceImpl">
        <property name="bufferSize">
            <value>1024</value>
        </property>
    </bean>*/
    private int bufferSize=1024;  // 缓冲区大小

    public int getBufferSize() {
        return bufferSize;
    }

    public void setBufferSize(int bufferSize) {
        this.bufferSize = bufferSize;
    }

    /*private int threadNum;//线程数量

    public int getThreadNum() {
        return threadNum;
    }

    public void setThreadNum(int threadNum) {
        this.threadNum = threadNum;
    }
*/
    /**
     * 构造方法
     */
    public HttpServiceImpl() {
    }

    /**
     * 将HTTP资源另存为文件
     * @param destUrl String
     * @param fileName String
     * @throws Exception
     */
    public void saveToFile(String destUrl, String fileName){
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        HttpURLConnection httpUrl = null;
        URL url = null;
        byte[] buf = new byte[getBufferSize()];
        int size = 0;

        // 建立链接
        try {
            url = new URL(destUrl);
            httpUrl = (HttpURLConnection) url.openConnection();
            // 连接指定的资源
            httpUrl.connect();
            //判断此次http请求是否成功
            if(HttpURLConnection.HTTP_OK==httpUrl.getResponseCode()){
                // 获取网络输入流
                bis = new BufferedInputStream(httpUrl.getInputStream());
                // 建立文件
                fos = new FileOutputStream(fileName);
                logger.info("正在获取链接[" + destUrl + "]的内容,将其保存为文件["+ fileName + "]");
                // 保存文件
                while ((size = bis.read(buf)) != -1){
                    fos.write(buf, 0, size);
                }
                fos.flush();
                fos.close();
                bis.close();
            } else {
                logger.info("正在获取链接[" + destUrl + "]的内容,连接未成功");
            }
            httpUrl.disconnect();
            fos=null;
            bis=null;
            httpUrl=null;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

http读写结束

文件读写开始

接口

/**
 * 文件读写 目录操作
 */
public interface DirectoryOperationService {
    /**
     * 新建目录
     * @param folderPath 目录
     * @return 返回目录创建后的路径
     */
    public String createFolder(String folderPath)throws Exception;
   
    /**
     * 多级目录创建
     * @param folderPath 准备要在本级目录下创建新目录的目录路径 例如 c:myf
     * @param paths 无限级目录参数各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:myfac
     */
    public String createFolders(String folderPath, String paths)throws Exception;

   
    /**
     * 新建文件
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @return
     */
    public void createFile(String filePathAndName, String fileContent)throws Exception;
    /**
     * 有编码方式的文件创建
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @param encoding 编码方式 例如 GBK 或者 UTF-8
     * @return
     */
    public void createFile(String filePathAndName, String fileContent, String encoding)throws Exception;


    /**
     * 删除文件
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public boolean delFile(String filePathAndName)throws Exception;


    /**
     * 删除文件夹
     * @param folderPath 文件夹完整绝对路径
     * @return
     */
    public void delFolder(String folderPath)throws Exception;
   
   
    /**
     * 删除指定文件夹下所有文件
     * @param path 文件夹完整绝对路径
     * @return
     * @return
     */
    public boolean delAllFile(String path)throws Exception;


    /**
     * 复制单个文件
     * @param oldPathFile 准备复制的文件源
     * @param newPathFile 拷贝到新绝对路径带文件名
     * @return
     */
    public void copyFile(String oldPathFile, String newPathFile)throws Exception;
   

    /**
     * 复制整个文件夹的内容
     * @param oldPath 准备拷贝的目录
     * @param newPath 指定绝对路径的新目录
     * @return
     */
    public void copyFolder(String oldPath, String newPath)throws Exception;


    /**
     * 移动文件
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFile(String oldPath, String newPath)throws Exception;
   

    /**
     * 移动目录
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFolder(String oldPath, String newPath)throws Exception;

 /**
     * 读取文本文件内容
     * @param filePathAndName 带有完整绝对路径的文件名
     * @param encoding 文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    public String readTxt(String filePathAndName,String encoding) throws IOException;
    
    
    /**
     * 获得文件扩展名
     * @param fileName
     * @return
     * @throws Exception
     */
    public  String getExtension(String fileName)throws Exception;
    
    /**
     * 对 a|b 的 目录结构转行成 a/b (File.separator)
     * @param fold
     * @return
     */
    public  String getFoldPath(String fold);
    
    /**
     * 对 a|b 的 目录结构转行成 a/b
     * @param fold
     * @return
     */
    public  String getFoldPathForHttp(String fold);
}

/////////////////////////////////////////////////////////////////////////

实现类

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;  //用到这个工具类

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jeecgframework.core.util.Validate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 文件读写 目录操作
 */
@Service("directoryOperationService")
@Transactional
public class DirectoryOperationServiceImpl implements DirectoryOperationService
{
    protected Log logger = LogFactory.getLog(getClass());
    /**
     * 新建目录
     *
     * @param folderPath 目录
     * @return 返回目录创建后的路径
     */
    public String createFolder(String folderPath) throws Exception{
        String txt = folderPath;
        try {
            java.io.File myFilePath = new java.io.File(txt);
            txt = folderPath;
            if (!myFilePath.exists()) {
                myFilePath.mkdir();
            }
        }catch (Exception e) {
            logger.debug("createFolder ERROR folderPath="+folderPath+" " + e.toString());
            throw new Exception(e.getMessage());
        }
        return txt;
    }

    /**
     * 多级目录创建
     *
     * @param folderPath  准备要在本级目录下创建新目录的目录路径 例如 c:\myf
     * @param paths  无限级目录参数各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:\my\a\b\c
     */
    public String createFolders(String folderPath, String paths)throws Exception{
        String txts = folderPath;
        try {
            String txt;
            txts = folderPath;
            StringTokenizer st = new StringTokenizer(paths, "|");
            for (int i = 0; st.hasMoreTokens(); i++) {
                txt = st.nextToken().trim();
                logger.info( "txts="+txts);
                if (txts.lastIndexOf(File.separator) == -1){
                    logger.info(  "== -1 createFolder("+txts +File.separator+ txt+")");
                    txts = createFolder(txts +File.separator+ txt);
                }else {   
                    if(txts.lastIndexOf(File.separator)==(txts.length()-1)){
                        logger.info(  "createFolder("+txts + txt+")");
                        txts = createFolder(txts + txt);
                    }else{
                        logger.info(  "!= -1 createFolder("+txts +File.separator+ txt+")");
                        txts = createFolder(txts +File.separator+ txt);
                    }
                }
            }
        } catch (Exception e){
            logger.info(
                    "createFolders ERROR folderPath="+folderPath+" paths="+paths+" " + e.toString());
            throw new Exception(e.getMessage());
        }
        return txts;
    }

    /**
     * 新建文件
     *
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent  文本文件内容
     * @return
     */
    public void createFile(String filePathAndName, String fileContent)throws Exception
    {

        try {
            String filePath = filePathAndName;
            logger.debug("==========================================================="+filePath);
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            FileWriter resultFile = new FileWriter(myFilePath);
            PrintWriter myFile = new PrintWriter(resultFile);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
            resultFile.close();
        } catch (Exception e) {
            logger.debug(
                    "createFile ERROR filePathAndName="+filePathAndName+" " + e.toString());
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 有编码方式的文件创建
     *
     * @param filePathAndName   文本文件完整绝对路径及文件名
     * @param fileContent  文本文件内容
     * @param encoding   编码方式 例如 GBK 或者 UTF-8
     * @return
     */
    public void createFile(String filePathAndName, String fileContent,String encoding) throws Exception
    {

        try {
            String filePath = filePathAndName;
            logger.debug("==========================================================="+filePath);
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            PrintWriter myFile = new PrintWriter(myFilePath, encoding);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.flush();
            myFile.close();
            myFile=null;
        } catch (Exception e) {
            logger.debug(
                    "createFile encoding ERROR filePathAndName="+filePathAndName+" " + e.toString());
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 删除文件
     *
     * @param filePathAndName   文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public boolean delFile(String filePathAndName)throws Exception
    {
        boolean flag = false;
        try {
            String filePath = filePathAndName;
            File myDelFile = new File(filePath);
            if (myDelFile.exists()) {
                myDelFile.delete();
                flag = true;
            } else {
                flag = false;

            }
        } catch (Exception e) {
            logger.debug(
                    "delFile ERROR filePathAndName="+filePathAndName+" " + e.toString());
            throw new Exception(e.getMessage());
        }
        return flag;
    }

    /**
     * 删除文件夹
     *
     * @param folderPath  文件夹完整绝对路径
     * @return
     */
    public void delFolder(String folderPath)throws Exception{
        try {
            delAllFile(folderPath); // 删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File(filePath);
            myFilePath.delete(); // 删除空文件夹
        } catch (Exception e) {
            logger.debug(
                    "delFolder ERROR folderPath="+folderPath+" " + e.toString());
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 删除指定文件夹下所有文件
     *
     * @param path 文件夹完整绝对路径
     * @return
     * @return
     */
    public boolean delAllFile(String path)throws Exception{

        boolean flag = false;
        try{
            File file = new File(path);
            if (!file.exists()) {
                return flag;
            }
            if (!file.isDirectory()) {
                return flag;
            }
            String[] tempList = file.list();
            File temp = null;
            for (int i = 0; i < tempList.length; i++) {
                if (path.endsWith(File.separator)) {
                    temp = new File(path + tempList[i]);
                } else {
                    temp = new File(path + File.separator + tempList[i]);
                }
                if (temp.isFile()) {
                    temp.delete();
                }
                if (temp.isDirectory()) {
                    delAllFile(path + File.separator + tempList[i]);// 先删除文件夹里面的文件
                    delFolder(path + File.separator + tempList[i]);// 再删除空文件夹
                    flag = true;
                }
            }
        }catch(Exception e){
            logger.debug(
                    "delAllFile ERROR path="+path+" " + e.toString());
            throw new Exception(e.getMessage());
        }
        return flag;
    }

    /**
     * 复制单个文件
     *
     * @param oldPathFile
     *            准备复制的文件源
     * @param newPathFile
     *            拷贝到新绝对路径带文件名
     * @return
     */
    public void copyFile(String oldPathFile, String newPathFile)throws Exception{
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPathFile);
            if (oldfile.exists()) { // 文件存在时
                InputStream inStream = new FileInputStream(oldPathFile); // 读入原文件
                FileOutputStream fs = new FileOutputStream(newPathFile);
                byte[] buffer = new byte[1444];
                while ((byteread = inStream.read(buffer)) != -1) {
                    bytesum += byteread; // 字节数 文件大小
                    //System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        } catch (Exception e) {
            logger.debug(
                    "copyFile ERROR oldPathFile="+oldPathFile+" newPathFile="+newPathFile+" " + e.toString());
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 复制整个文件夹的内容
     *
     * @param oldPath
     *            准备拷贝的目录
     * @param newPath
     *            指定绝对路径的新目录
     * @return
     */
    public void copyFolder(String oldPath, String newPath)throws Exception{
        try {
            new File(newPath).mkdirs(); // 如果文件夹不存在 则建立新文件夹
            File a = new File(oldPath);
            String[] file = a.list();
            File temp = null;
            for (int i = 0; i < file.length; i++) {
                if (oldPath.endsWith(File.separator)) {
                    temp = new File(oldPath + file[i]);
                } else {
                    temp = new File(oldPath + File.separator + file[i]);
                }
                if (temp.isFile()) { //如果是文件
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(newPath+ File.separator + (temp.getName()).toString()); //写到指定位置
                    byte[] b = new byte[1024 * 5];
                    int len;
                    while ((len = input.read(b)) != -1) { //缓存的读
                        output.write(b, 0, len);          //写
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if (temp.isDirectory()) {// 如果是子文件夹
                    copyFolder(oldPath + File.separator + file[i], newPath + File.separator + file[i]); //再次执行当前方法
                }
            }
        } catch (Exception e) {
            logger.debug("copyFolder ERROR oldPath="+oldPath+" newPath="+newPath+" " + e.toString());
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 移动文件
     *
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFile(String oldPath, String newPath) throws Exception{
        copyFile(oldPath, newPath);
        delFile(oldPath);
    }

    /**
     * 移动目录
     *
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFolder(String oldPath, String newPath)throws Exception{
        copyFolder(oldPath, newPath);
        delFolder(oldPath);
    }

    /**
     * 读取文本文件内容
     *
     * @param filePathAndName
     *            带有完整绝对路径的文件名
     * @param encoding
     *            文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    public String readTxt(String filePathAndName, String encoding)throws IOException {
        encoding = encoding.trim();
        StringBuffer str = new StringBuffer("");
        String st = "";
        try {
            FileInputStream fs = new FileInputStream(filePathAndName);
            InputStreamReader isr;
            if (encoding.equals("")) {
                isr = new InputStreamReader(fs);
            } else {
                isr = new InputStreamReader(fs, encoding);
            }
            BufferedReader br = new BufferedReader(isr);
            try {
                String data = "";
                while ((data = br.readLine()) != null) {
                    str.append(data + " ");
                }
            } catch (Exception e) {
                str.append(e.toString());
            }
            st = str.toString();
        } catch (IOException es) {
            st = "";
        }
        return st;
    }


    /**
     * 获得文件扩展名
     * @param fileName
     * @return
     * @throws Exception
     */
    public  String getExtension(String fileName)throws Exception{
        String ext="";
        if ((fileName != null) && (fileName.length() > 0)) {
            int i = fileName.lastIndexOf('.');

            if ((i > 0) && (i < (fileName.length() - 1))){
                ext=fileName.substring(i + 1);
            }else{
                throw new Exception("无法获得扩展名");
            }
        }else{
            throw new Exception("无法获得扩展名");
        }
        return ext;
    }

    /**
     * 对 a|b 的 目录结构转行成 a/b (File.separator)
     * @param fold
     * @return
     */
    public  String getFoldPath(String fold)
    {
        if(Validate.isEmpty(fold)){
            return "";
        }
        if(fold.indexOf("|")==-1){
            return fold;
        }
        StringTokenizer st = new StringTokenizer(fold, "|");
        String back="";
        for (int i = 0; st.hasMoreTokens(); i++) {
            if(i!=0){
                back=back+File.separator;
            }
            back=back+st.nextToken().trim();
            logger.info("+++++++++++++++++++++++++++++++++++"+back);
        }

        return back;
    }


    /**
     * 对 a|b 的 目录结构转行成 a/b
     * @param fold
     * @return
     */
    public  String getFoldPathForHttp(String fold){
        if(Validate.isEmpty(fold)){
            return "";
        }

        if(fold.indexOf("|")==-1){
            return fold;
        }
        StringTokenizer st = new StringTokenizer(fold, "|");
        String back="";
        for (int i = 0; st.hasMoreTokens(); i++) {
            if(i!=0)
            {
                back=back+"/";
            }
            back=back+st.nextToken().trim();
        }
        return back;
    }

}