ftp工具类

1.依赖

 <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.3</version>
        </dependency>

2. 工具类

package com.example.demo.util;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.springframework.stereotype.Component;

import java.io.*;
import java.nio.charset.Charset;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

/**
 * ftp文件上传工具类
 */
@Component
public class FTPFileProUtils {
	/**
	 * 远程ftp服务器的ip、端口号、用户名、口令
	 */
	private static String hostname = "192.168.xxx.131";
	private static int port = 21;
	private static String username = "myftp";
	private static String password = "myftp";
	private static String mInRConnFilePath = "/app/data/20181126/";
	private static String mOutRConnFilePath = "/app/data/xml/LP00000001/20181126/";

	/**
	 * 
	 */

	private FTPClient client;

	/**
	 * 创建Ftp客户端对象，开启ftp链接请求对象
	 * 
	 * @return FTPClient对象
	 * @throws Exception
	 */
	public void initFtpClient() throws Exception {
		// 2.1 创建Ftp客户端, 相当于开启ftp客户端软件.
		client = new FTPClient();
		// 设置字符集, 设置上传文件体的字符集.
		client.setCharset(Charset.forName("UTF-8"));
		// 设置为被动连接迷失
		client.enterLocalPassiveMode();
		// 2.2 连接服务器, 抛出异常. 服务器找不到.
		client.connect(hostname, port);
		// 2.3 登录
		client.login(username, password);
		// 2.5 设置要上传的文件类型, 设置二进制文件类型
		client.setFileType(FTP.BINARY_FILE_TYPE);

		// return client;
	}

	// Switching path
	public void changeWorkingDirectory(String pathname) {
		try {
			client.changeWorkingDirectory(pathname);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 创建Ftp客户端对象，开启ftp链接请求对象
	 * 
	 * @return FTPClient对象
	 * @throws Exception
	 */
	public void initFtpClientPara(String hostname, int port, String username, String password) throws Exception {
		// 2.1 创建Ftp客户端, 相当于开启ftp客户端软件.
		client = new FTPClient();
		// 设置字符集, 设置上传文件体的字符集.
		client.setCharset(Charset.forName("UTF-8"));
		// 设置为被动连接迷失
		client.enterLocalPassiveMode();
		// 2.2 连接服务器, 抛出异常. 服务器找不到.
		client.connect(hostname, port);
		// 2.3 登录
		client.login(username, password);
		// 2.5 设置要上传的文件类型, 设置二进制文件类型
		client.setFileType(FTP.BINARY_FILE_TYPE);

		// return client;
	}

	/**
	 * 将用户上传的文件或图片，保存到ftp服务器上
	 * 
	 * @param uploadFile    ： 上传的文件（二进制流）
	 * @param makeDirectory ： 保存到的文件夹路径（基于ftp根路径）
	 * @return ResponseResult.code == '0' : 上传失败；<br/>
	 *         ResponseResult.code == '1' : 上传成功，其中：ResponseResult.data为保存的文件新名称
	 */
	public void fileUpload(InputStream in, String makeDirectory, String newFileName) {
		try {
			boolean isChanged = client.changeWorkingDirectory(makeDirectory);
			String s = client.printWorkingDirectory();
			System.out.println(s);
			if (!isChanged) {
				// 切换失败. 可能目录不存在, 返回创建是否成功.
				if (client.makeDirectory(new String(makeDirectory.getBytes("UTF-8"), "UTF-8"))) {
					// 如果创建成功. 切换目录
					client.changeWorkingDirectory(makeDirectory);
				} else {
				}
			}
			// storeFile(String 远程文件名称, InputStream 上传的文件输入流);
			client.enterLocalPassiveMode();
			boolean isSuccess = client.storeFile(new String(newFileName.getBytes("UTF-8"), "iso-8859-1"), in);
			System.out.println(isSuccess);
		} catch (Exception e) {
			// 异常问题
			System.out.println("异常问题 : " + e.getMessage());
			System.out.println("-------------文件上传方法结束-------------");

		}
	}

	/**
	 * 从ftp服务器上，读取文件，并将文件的输入流返回
	 * 
	 * @param makeDirectory ： 要读取文件的文件路径(父目录)
	 * @param fileName      ： 要读取文件的名称
	 * @return ResponseResult.code == '0' : 读取失败；<br/>
	 *         ResponseResult.code == '1' : 读取成功，其中：ResponseResult.data为文件的输入流对象
	 */
	public ByteArrayInputStream getByteArrayInputStream(String makeDirectory, String fileName) {
		// 设置方法返回值
		ByteArrayInputStream inStream = null;
		// 1. 确定文件上传为有效文件.
		if (fileName == null || "".equals(fileName)) {
			System.out.println("文件名称不能为空");
			return null;
		}
		try {
			// 创建Ftp客户端对象，开启ftp链接请求对象
			System.out.println("Ftp客户端对象：client = " + client);
			// 切换工作目录, 参数为相对于当前工作目录的相对路径.登录的时候,当前目录为登录用户的主目录.
			boolean isChangedFlag = true;
			if (isChangedFlag) { // 如果文件目录更换成功
				// 将ftp设置为被动连接迷失
				client.enterLocalPassiveMode();

				// 通过ftp读取目标文件，并将目标文件写入到输出流ByteArrayOutputStrem对象outStream中
				ByteArrayOutputStream outStream = new ByteArrayOutputStream();
				// System.out.println("创建输出流对象：outStream = "+outStream);
				client.retrieveFile(fileName, outStream);
				// System.out.println("从ftp上写入输出流：outStream = "+outStream);
				inStream = new ByteArrayInputStream(outStream.toByteArray());
				System.out.println("输入流:ByteArrayInputStream：inStream = " + inStream);

			}

			// 关闭ftp客户端
			// client.logout();

		} catch (Exception e) {
			// 异常问题
			e.printStackTrace();
			System.out.println("操作异常：获取文件输入流失败");
		}
		return inStream;
	}

	/**
	 * 切换工作目录
	 * 
	 * @param directory
	 */
	public void changeDir(String path) {
		if (path != null && !"".equals(path)) {
			try {
				client.changeWorkingDirectory(new String(path.getBytes("UTF-8"), "UTF-8"));
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}

		}
	}

	/**
	 * 创建一个文件夹
	 * 
	 * @param makeDirectory
	 */
	public void makeDir(String makeDirectory) {

		try {
			boolean isChanged = client.changeWorkingDirectory(makeDirectory);
			// String s = client.printWorkingDirectory();
			// System.out.println(s);
			if (!isChanged) {
				// 切换失败. 可能目录不存在, 返回创建是否成功.
				if (client.makeDirectory(new String(makeDirectory.getBytes("UTF-8"), "UTF-8"))) {
					// 如果创建成功. 切换目录
					client.changeWorkingDirectory(makeDirectory);
				} else {

				}
			}

		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	/**
	 * 打印出当前工作目录
	 */
	public void printWorkDir() {
		try {
			System.out.println(client.printWorkingDirectory());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * @param path
	 * @return function:读取指定目录下的文件名
	 * @throws IOException
	 */
	/**
	 * 获取FTP目录下面指定的文件
	 * 
	 * @param path
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFTPDirSpecifiedFile(String path, String fileName) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			for (int i = 2; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					if (file.getName().equals(fileName)) {
						System.out.println("文件夹下面的文件=====:" + file.getName());
						fileLists.add(file.getName());
					}
				}
			}
		}
		return fileLists;
	}

	/**
	 * 获取FTP目录下面指定的文件
	 * 
	 * @param path
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFTPCurrentDateDirSpecifiedFile(String path, String fileName) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			System.out.println("ftpFileList.length:" + ftpFileList.length);
			for (int i = 0; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					if (file.getName().equals(fileName)) {
						System.out.println("文件夹下面的文件=====:" + file.getName());
						fileLists.add(file.getName());
					}
				}
			}
		}
		return fileLists;
	}

	/**
	 * 获取FTP目录下面所有文件
	 * 
	 * @param path
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFTPDirAllFileList(String path) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			for (int i = 2; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					System.out.println("文件夹下面的文件=====:" + file.getName());
					fileLists.add(file.getName());
				}
			}
		}
		return fileLists;
	}

	/**
	 * 获取FTP目录当前日期下面所有文件
	 * 
	 * @param remotePath
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFTPCurrentDateDirAllFileList(String remotePath) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(remotePath);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			for (int i = 0; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					System.out.println("文件夹下面的文件=====:" + file.getName());
					fileLists.add(file.getName());
				}
			}
		}
		return fileLists;
	}

	/**
	 * 获取目录下面的某个类型的文件
	 * 
	 * @param path
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFTPDirTypeFileList(String path, String fileType) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			for (int i = 2; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					System.out.println("文件夹下面的文件=====:" + file.getName());
					// "suffix后缀在类中定全局变量，从数据库中取值"
					if (file.getName().endsWith(fileType)) {
						fileLists.add(file.getName());
					}
				}
			}
		}
		return fileLists;
	}

	/**
	 * 获取目录下面的某个类型的文件
	 * 
	 * @param path
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFTPCurrentDateDirTypeFile(String path, String fileType) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			for (int i = 2; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					System.out.println("文件夹下面的文件=====:" + file.getName());
					// "suffix后缀在类中定全局变量，从数据库中取值"
					if (file.getName().endsWith(fileType)) {
						fileLists.add(file.getName());
					}
				}
			}
		}
		return fileLists;
	}

	/**
	 * 原版支持文件和目录 传输目录下面的文件 大小为0kb 编码文件 需要解决这2个问题
	 * 
	 * @param path
	 * @return
	 * @throws ParseException
	 */
	public List<String> getFileList2(String path) throws ParseException {
		List<String> fileLists = new ArrayList<String>();
		// 获得指定目录下所有文件名
		FTPFile[] ftpFileList = null;
		try {
			ftpFileList = client.listFiles(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (ftpFileList != null && ftpFileList.length > 0) {
			for (int i = 2; i < ftpFileList.length; i++) {
				FTPFile file = ftpFileList[i];
				if (file.isFile()) {
					System.out.println("文件夹下面的文件=====:" + file.getName());
					fileLists.add(file.getName());
				}
			}
		}
		return fileLists;
	}

	/**
	 * 关闭ftp连接
	 */
	public void closeClient() {
		try {
			// 2.7 退出登录, 相当于回收了资源
			client.logout();
			// 2.8 回收资源, 回收资源方法和退出登录方法.可以选择其一执行.
//			client.quit();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	/**
	 * 删除目录下的所有文件
	 * 
	 * @param pathname
	 */
	public void delDirAllFile(String pathname) {
		try {
			client.deleteFile(pathname);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public FTPClient getClient() {
		return client;
	}

	public void setClient(FTPClient client) {
		this.client = client;
	}

	public static String getmInRConnFilePath() {
		return mInRConnFilePath;
	}

	public static void setmInRConnFilePath(String mInRConnFilePath) {
		FTPFileProUtils.mInRConnFilePath = mInRConnFilePath;
	}

	public static String getmOutRConnFilePath() {
		return mOutRConnFilePath;
	}

	public static void setmOutRConnFilePath(String mOutRConnFilePath) {
		FTPFileProUtils.mOutRConnFilePath = mOutRConnFilePath;
	}

	public static String getHostname() {
		return hostname;
	}

	public static void setHostname(String hostname) {
		FTPFileProUtils.hostname = hostname;
	}

	public static int getPort() {
		return port;
	}

	public static void setPort(int port) {
		FTPFileProUtils.port = port;
	}

	public static String getUsername() {
		return username;
	}

	public static void setUsername(String username) {
		FTPFileProUtils.username = username;
	}

	public static String getPassword() {
		return password;
	}

	public static void setPassword(String password) {
		FTPFileProUtils.password = password;
	}
}

2. 业务处理类

package com.example.demo.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.text.ParseException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Http File Transfer Service Class
 *
 * @author guobin
 * @date 2018.11.26
 */
@Service // 注册bean
@Transactional // 开启事务
public class HttpFTPServiceImpl implements HttpFTPService {

    private static Logger log = Logger.getLogger(HttpFTPServiceImpl.class);

    private String mUUID;

    private String mTransCode = "";
    private String mTransType = "";
    private String mFileName = "";
    private String mSouFilePath = "";
    private String mDesFilePath = "";

    private String jsonString = "";
    private JSONObject jsonObject = null;

    // 初始化轨迹表参数
    private int mUploadallnum = 0;// 文件总数
    private int mFilesuccnum = 0;// 上传成功文件数
    private int mFilefailnum = 0;// 上传失败文件数
    private Date tStartDate = null;
    private Date tEndDate = null;

    private String mINRConnIP = "192.168.xxx.145";
    private int mInRConnPort=21;
    private String mInRConnUser = "username";
    private String mInRConnPWD = "passwd";

    private String mOutRConnIP = "";
    private int mOutRConnPort;
    private String mOutRConnUser = "";
    private String mOutRConnPWD = "";

    // FTP Connection Entry Tool Class Introduction
    FTPFileProUtils ftpOut = new FTPFileProUtils();
    FTPFileProUtils ftpIn = new FTPFileProUtils();

    Map<String, Object> map = new HashMap<String, Object>();

    @Autowired
    HttpServletRequest httpRequest;

    @Autowired
    private FisftpinoutparainfoMapper fisftpinoutparainfoMapper;

    Fisftpcallingtrace mFisftpcallingtrace = new Fisftpcallingtrace();// 请求轨迹实体类

    @Override
    public String commonRequests(HttpServletRequest paramRequest, HttpServletResponse paramResponse,
                                 String paramRequestBody) throws Exception {

        log.info("Receive HttpRequest:!!!");

        try {

            jsonObject = JSONObject.parseObject(paramRequestBody);

        } catch (Exception e) {
            log.info("Request parameter format error, parse exception");

            // 请求错误处理
            jsonString = requestErrorDeal();

            return jsonString;
        }
        mTransCode = jsonObject.getString("TransCode");// 业务类型
        mTransType = jsonObject.getString("TransType");// 交易方式 0-单笔 1-批量
        mSouFilePath = jsonObject.getString("SouFilePath");// 源路径
        mDesFilePath = jsonObject.getString("DesFilePath");// 目标路径
        mFileName = jsonObject.getString("FileName");// 文件名

        log.info("业务类型mTransCode:" + mTransCode);
        log.info("交易方式mTransType:" + mTransType);
        log.info("源路径mSouFilePath:" + mSouFilePath);
        log.info("目标路径mDesFilePath:" + mDesFilePath);
        log.info("文件名mFileName:" + mFileName);

        if (mTransType.equals("1") && mTransType != null) {

            // Get FTP parameter information
            getFTPInOutPara(mTransCode);

            // Remote Read Write Current Date Dir All File
            remoteReadWriteCurrentDateDirAllFile();

            // Set file mTransType
            mFisftpcallingtrace.setTranstype("1");

        } else if (mTransType.equals("0") && mTransType != null) {

            // Get FTP parameter information
            getFTPInOutPara(mTransCode);
            // Remote Read Write Current Dir Specified File
            remoteReadWriteCurrentDateDirAppointFile();
            // Set file flag
            mFisftpcallingtrace.setTranstype("0");

        } else {
            log.info("This business type is not supported！！！:");
        }

        log.info("fis执行处理完毕！！！:");

        return jsonString;
    }

    /**
     * Remote Read Write Current Date Dir All File
     */
    private String remoteReadWriteCurrentDateDirAllFile() {

        try {
            // Connecting Common Methods
            connectingCommon();

            // Get all files in directory
            List<String> fileNames = ftpOut.getFTPCurrentDateDirAllFileList(mSouFilePath);
            if (fileNames.size() == 0) {
                // 原路径无符合条件的文件处理
                jsonString = mSouFilePathErrorDeal();
                return jsonString;
            }
            // Number of printed files
            log.info("fileNames.length : " + fileNames.size());

            // Total number of documents
            mUploadallnum = fileNames.size();
            mFisftpcallingtrace.setUploadallnum(String.valueOf(mUploadallnum));

            if (fileNames != null) {
                for (String fileName : fileNames) {
                    log.info("File name under directory : " + fileName);
                    InputStream in = ftpOut.getByteArrayInputStream(mSouFilePath, fileName);
                    tStartDate = new Date();
                    ftpIn.fileUpload(in, mDesFilePath, fileName);
                    tEndDate = new Date();
                }
            }
            // Successful number of documents
            // Common Variables In Trajectory
            commonVariablesInTrajectory(mDesFilePath);
            ResponseSuccRecordTrajectory(tStartDate, tEndDate);
//			int i =1/0;
        } catch (Exception e) {
            log.info("文件批量传输异常！！！");

            // 文件批量传输异常处理
            jsonString = FileTransferExceptionDeal(mUploadallnum, mFilesuccnum, mFilefailnum);
            return jsonString;
        } finally {
            // Quit logon and recycle resources
            ftpIn.closeClient();
            ftpOut.closeClient();
        }
        return jsonString;
    }

    /**
     * Remote Read Write Current Date Dir Appoint File
     */
    private String remoteReadWriteCurrentDateDirAppointFile() {

        try {
            // Connecting Common Methods
            connectingCommon();

            // Get all files in directory
            List<String> fileNames = ftpOut.getFTPCurrentDateDirSpecifiedFile(mSouFilePath, mFileName);
            if (fileNames.size() == 0) {
                // 原路径无符合条件的文件处理
                jsonString = mSouFilePathErrorDeal();
                return jsonString;
            }
            // Number of printed files
            log.info("fileNames.length : " + fileNames.size());

            // Total number of documents
            mUploadallnum = fileNames.size();
            mFisftpcallingtrace.setUploadallnum(String.valueOf(mUploadallnum));

            if (fileNames != null) {
                for (String fileName : fileNames) {
                    log.info("File name under directory : " + fileName);
                    InputStream in = ftpOut.getByteArrayInputStream(mSouFilePath, fileName);
                    tStartDate = new Date();
                    ftpIn.fileUpload(in, mDesFilePath, fileName);
                    tEndDate = new Date();
                }
            }
            // Successful number of documents
            // Common Variables In Trajectory
            commonVariablesInTrajectory(mDesFilePath);
            ResponseSuccRecordTrajectory(tStartDate, tEndDate);
//			int i =1/0;
        } catch (Exception e) {
            log.info("文件单笔读写出现异常");
            // 文件单笔读写出现异常处理
            jsonString = FileTransferExceptionDeal(mUploadallnum, mFilesuccnum, mFilefailnum);
            return jsonString;
        } finally {
            // Quit logon and recycle resources
            ftpIn.closeClient();
            ftpOut.closeClient();
        }
        return jsonString;
    }

    /****************** Successful Part Encapsulation Start **********************/
    /**
     * 1.Track success record 2.Return successful response
     *
     * @param tStartDate
     * @param tEndDate
     * @return
     */
    private String ResponseSuccRecordTrajectory(Date tStartDate, Date tEndDate) {

        // Success Trajectory Common Variable
        SuccessTrajectoryCommonVariable(tStartDate, tEndDate);

        map.put("ResultCode", "0");
        map.put("ResultMsg", "处理成功");

        jsonObject = JSONObject.parseObject(JSON.toJSONString(map));
        jsonString = JSON.toJSONString(jsonObject);
        return jsonString;
    }

    /**
     * Trajectory common variable
     *
     * @param tStartDate
     * @param tEndDate
     */
    private void SuccessTrajectoryCommonVariable(Date tStartDate, Date tEndDate) {

        mUUID = (String) httpRequest.getAttribute(TraceEntity.Trace_UUID);
        mFisftpcallingtrace.setTraceid(mUUID);
        mFisftpcallingtrace.setServicename("File transfer platform");
        mFisftpcallingtrace.setTranscode(mTransCode);
        mFisftpcallingtrace.setServicetype(TraceEntity.Trace_HttpType);
        mFisftpcallingtrace.setTranstype(mTransType);
        mFisftpcallingtrace.setReqip(httpRequest.getLocalAddr());

        mFilefailnum = mUploadallnum - mFilesuccnum;
        mFisftpcallingtrace.setFilefailnum(String.valueOf(mFilefailnum));
        mFisftpcallingtrace.setReqstatus("1");
        mFisftpcallingtrace.setReqdate(DateUtil.getyyyyMMddDate(tStartDate));
        mFisftpcallingtrace.setReqtime(DateUtil.getTimeFormat(tStartDate));
        mFisftpcallingtrace.setHandledate(DateUtil.getyyyyMMddDate(tEndDate));
        mFisftpcallingtrace.setHandletime(DateUtil.getTimeFormat(tEndDate));
        httpRequest.setAttribute("FTPTrace", mFisftpcallingtrace);
    }

    /****************** Successful partial encapsulation End **********************/

    /****************** Public Part Encapsulation Start **********************/
    /**
     * External And Intranet Network FTP Parameters
     *
     * @param mTransCode
     */
    private void getFTPInOutPara(String mTransCode) {

        Fisftpinoutparainfo ftpInOutParaInfo = fisftpinoutparainfoMapper.selectByPrimaryKey(mTransCode);

        mINRConnIP = ftpInOutParaInfo.getFtpinrconnip();
        mInRConnPort = ftpInOutParaInfo.getFtpinrconnport();
        mInRConnUser = ftpInOutParaInfo.getFtpinrconnuser();
        mInRConnPWD = ftpInOutParaInfo.getFtpinrconnpwd();
        mOutRConnIP = ftpInOutParaInfo.getFtpoutrconnip();
        mOutRConnPort = ftpInOutParaInfo.getFtpoutrconnport();
        mOutRConnUser = ftpInOutParaInfo.getFtpoutrconnuser();
        mOutRConnPWD = ftpInOutParaInfo.getFtpoutrconnpwd();
    }

    /**
     * Connecting common methods
     *
     * @throws Exception
     */
    private void connectingCommon() throws Exception {

        // OutNetWork ConnectFTP
        ftpOut.initFtpClientPara(mOutRConnIP, mOutRConnPort, mOutRConnUser, mOutRConnPWD);
        // InNetWork ConnectFTP
        ftpIn.initFtpClientPara(mINRConnIP, mInRConnPort, mInRConnUser, mInRConnPWD);

        // Print out the current working directory
        ftpOut.printWorkDir();
        ftpIn.printWorkDir();

        // Switch working directory
        ftpOut.changeDir(mSouFilePath);
        ftpIn.changeDir(mDesFilePath);

        // Print out the current working directory
        ftpOut.printWorkDir();
        ftpIn.printWorkDir();
    }

    /**
     * Common Variables In Trajectory
     *
     * @param mDesFilePath
     */
    public void commonVariablesInTrajectory(String mDesFilePath) {

        List<String> ftpInDirAllFileList;
        try {
            ftpInDirAllFileList = ftpIn.getFTPCurrentDateDirAllFileList(mDesFilePath);
            mFilesuccnum = ftpInDirAllFileList.size();
            mFisftpcallingtrace.setFilesuccnum(String.valueOf(mFilesuccnum));
            mFisftpcallingtrace.setResstatus("0");
            mFisftpcallingtrace.setResremark("文件上传成功");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    /****************** Public part encapsulation End **********************/
    /****************** Abnormal Part Encapsulation Start **********************/
    /**
     * 请求错误，返回响应
     *
     * @return
     */
    private String requestErrorDeal() {

        map.put("ResultCode", "1");
        map.put("ResultMsg", "请求参数格式不符合规约要求，请核实！！！");
        jsonObject = JSONObject.parseObject(JSON.toJSONString(map));
        jsonString = JSON.toJSONString(jsonObject);

        return jsonString;
    }

    /**
     * 原路径文件为空，返回响应
     *
     * @return
     */
    private String mSouFilePathErrorDeal() {

        map.put("ResultCode", "1");
        map.put("ResultMsg", "原路径中无符合条件的文件，请核实文件是否存在！！！");
        jsonObject = JSONObject.parseObject(JSON.toJSONString(map));
        jsonString = JSON.toJSONString(jsonObject);

        return jsonString;
    }

    /**
     * File Transfer Exception
     *
     * @return
     */
    private String FileTransferExceptionDeal(int mUploadallnum, int mFilesuccnum, int mFilefailnum) {
        tStartDate = new Date();
        tEndDate = new Date();
        FileReadAndWriteExceptionTrajectoryRecord(tStartDate, tEndDate, mUploadallnum, mFilesuccnum, mFilefailnum);

        map.put("ResultCode", "1");
        map.put("ResultMsg", "由于文件格式不符合规约要求，文件读写异常，请检查文件格式！！！");
        jsonObject = JSONObject.parseObject(JSON.toJSONString(map));
        jsonString = JSON.toJSONString(jsonObject);
        return jsonString;
    }

    /**
     * FileReadAndWriteException
     *
     * @param tStartDate
     * @param tEndDate
     * @param mUploadallnum
     * @param mFilesuccnum
     * @param mFilefailnum
     */
    private void FileReadAndWriteExceptionTrajectoryRecord(Date tStartDate, Date tEndDate, int mUploadallnum,
                                                           int mFilesuccnum, int mFilefailnum) {

        mFisftpcallingtrace.setResremark("文件格式格式不符合规约要求，请核实！！！");
        CommonVariablesOfAbnormalTrajectories(tStartDate, tEndDate, mUploadallnum, mFilesuccnum, mFilefailnum);
    }

    /**
     * Common Variables of Abnormal Trajectories
     *
     * @param tStartDate
     * @param tEndDate
     * @param mUploadallnum
     * @param mFilesuccnum
     * @param mFilefailnum
     */
    private void CommonVariablesOfAbnormalTrajectories(Date tStartDate, Date tEndDate, int mUploadallnum,
                                                       int mFilesuccnum, int mFilefailnum) {
        mUUID = (String) httpRequest.getAttribute(TraceEntity.Trace_UUID);
        mFisftpcallingtrace.setTraceid(mUUID);
        mFisftpcallingtrace.setServicename("File transfer platform");
        mFisftpcallingtrace.setServicetype(TraceEntity.Trace_HttpType);
        mFisftpcallingtrace.setReqip(httpRequest.getLocalAddr());
        mFisftpcallingtrace.setTranscode(mTransCode);
        mFisftpcallingtrace.setTranstype(mTransType);
        mFisftpcallingtrace.setUploadallnum(String.valueOf(mUploadallnum));

        mFilefailnum = mUploadallnum - mFilesuccnum;
        mFisftpcallingtrace.setFilesuccnum(String.valueOf(mFilesuccnum));
        mFisftpcallingtrace.setFilefailnum(String.valueOf(mFilefailnum));
        mFisftpcallingtrace.setReqstatus("1");
        mFisftpcallingtrace.setResstatus("1");
        mFisftpcallingtrace.setReqdate(DateUtil.getyyyyMMddDate(tStartDate));
        mFisftpcallingtrace.setReqtime(DateUtil.getTimeFormat(tStartDate));
        mFisftpcallingtrace.setHandledate(DateUtil.getyyyyMMddDate(tEndDate));
        mFisftpcallingtrace.setHandletime(DateUtil.getTimeFormat(tEndDate));
        httpRequest.setAttribute("FTPTrace", mFisftpcallingtrace);
    }

    /****************** Abnormal Part Encapsulation End **********************/
}