springBoot 实现ftp上传与下载

/**
 * @program: yxc
 * @description: application配置文件实体类
 * @author: maque
 * @create: 2019-05-06 14:51
 */
@Component
public class ApplicationEntity {

    /**
     * ftp站点
     */
    @Value("${ftp.host}")
    private String ftpHost;
    /**
     * ftp端口号
     */
    @Value("${ftp.port}")
    private int ftpPort;
    /**
     * ftp访问用户名
     */
    @Value("${ftp.username}")
    private String ftpUsername;
    /**
     * ftp访问密码
     */
    @Value("${ftp.password}")
    private String ftpPassword;
    /**
     * ftp访问文件路径
     */
    @Value("${ftp.filepath}")
    private String ftpFilepath;
    /**
     * ftp提供的http方式访问地址
     */
    @Value("${ftp.web.host}")
    private String ftpWebHost;
    /**
     * ftp提供的http方式访问的端口号
     */
    @Value("${ftp.web.port}")
    private String ftpWebPort;

    public String getFtpHost() {
        return ftpHost;
    }

    public void setFtpHost(String ftpHost) {
        this.ftpHost = ftpHost;
    }

    public int getFtpPort() {
        return ftpPort;
    }

    public void setFtpPort(int ftpPort) {
        this.ftpPort = ftpPort;
    }

    public String getFtpUsername() {
        return ftpUsername;
    }

    public void setFtpUsername(String ftpUsername) {
        this.ftpUsername = ftpUsername;
    }

    public String getFtpPassword() {
        return ftpPassword;
    }

    public void setFtpPassword(String ftpPassword) {
        this.ftpPassword = ftpPassword;
    }

    public String getFtpFilepath() {
        return ftpFilepath;
    }

    public void setFtpFilepath(String ftpFilepath) {
        this.ftpFilepath = ftpFilepath;
    }

    public String getFtpWebHost() {
        return ftpWebHost;
    }

    public void setFtpWebHost(String ftpWebHost) {
        this.ftpWebHost = ftpWebHost;
    }

    public String getFtpWebPort() {
        return ftpWebPort;
    }

    public void setFtpWebPort(String ftpWebPort) {
        this.ftpWebPort = ftpWebPort;
    }
}

@Bean
    public FTPClient ftpClient(){
//        BeansEntity beansEntity =new BeansEntity();
        FTPClient ftpClient = new FTPClient();
        ftpClient.setConnectTimeout(1000*30);//设置连接超时时间
        ftpClient.setControlEncoding("utf-8");//设置ftp字符集
//        ftpClient.enterLocalPassiveMode();//设置被动模式，文件传输端口设置
        try {
//            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);//设置文件传输模式为二进制，可以保证传输的内容不会被改变
//            ftpClient.connect(beansEntity.getIp()+":"+beansEntity.getPort());
            ftpClient.setDefaultPort(applicationEntity.getFtpPort());
            ftpClient.connect(applicationEntity.getFtpHost(),applicationEntity.getFtpPort());
            ftpClient.login(applicationEntity.getFtpUsername(),applicationEntity.getFtpPassword());
            int replyCode = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(replyCode)){
                ftpClient.disconnect();
                logger.error("未连接到FTP，用户名或密码错误!");
                return null;
            }else {
                logger.info("FTP连接成功!");
                return ftpClient;
            }
        } catch (SocketException socketException) {
            logger.error("FTP的IP地址可能错误，请正确配置!");
            return null;
        } catch (IOException ioException) {
            ioException.printStackTrace();
            logger.error("FTP的端口错误,请正确配置!");
            return null;
        }
    }

public interface FTPClientService {
    
    public String readFileToBase64(String remoteFileName,String remoteDir);
    
    public void download(String remoteFileName,String localFileName,String remoteDir);
    
    public boolean uploadFile(InputStream inputStream, String originName, String remoteDir);
}

/**
 * @program: yxc
 * @description: ftp服务接口
 * @author: maque
 * @create: 2019-05-06 13:39
 */
@Service("ftpClienService'")
public class FTPClientServiceImpl implements FTPClientService {
    private Logger LOGGER = LoggerFactory.getLogger(getClass());

    @Autowired
    private FTPClient ftpClient;

    @Override
    public String readFileToBase64(String remoteFileName,String remoteDir) {
        if (ftpClient == null){
            return null;
        }

        String base64 = "";
        InputStream inputStream = null;

        try {
            ftpClient.changeWorkingDirectory(remoteDir);
            FTPFile[] ftpFiles = ftpClient.listFiles(remoteDir);
            Boolean flag = false;
            //遍历当前目录下的文件，判断要读取的文件是否在当前目录下
            for (FTPFile ftpFile:ftpFiles){
                if (ftpFile.getName().equals(remoteFileName)){
                    flag = true;
                }
            }

            if (!flag){
                LOGGER.error("directory：{}下没有 {}",remoteDir,remoteFileName);
                return null;
            }
            //获取待读文件输入流
            inputStream = ftpClient.retrieveFileStream(remoteDir+remoteFileName);

            //inputStream.available() 获取返回在不阻塞的情况下能读取的字节数，正常情况是文件的大小
            byte[] bytes = new byte[inputStream.available()];

            inputStream.read(bytes);//将文件数据读到字节数组中
            BASE64Encoder base64Encoder = new BASE64Encoder();
            base64 = base64Encoder.encode(bytes);//将字节数组转成base64字符串
            LOGGER.info("read file {} success",remoteFileName);
            ftpClient.logout();
        } catch (IOException e) {
            LOGGER.error("read file fail ----->>>{}",e.getCause());
            return null;
        }finally {
            if (ftpClient.isConnected()){
                try {
                    ftpClient.disconnect();
                } catch (IOException e) {
                    LOGGER.error("disconnect fail ------->>>{}",e.getCause());
                }
            }

            if (inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    LOGGER.error("inputStream close fail -------- {}",e.getCause());
                }
            }

        }

        return base64;
    }

    @Override
    public void download(String remoteFileName, String localFileName,String remoteDir) {

    }

    /**
     *  上传文件
     * @param inputStream 待上传文件的输入流
     * @param originName 文件保存时的名字
     * @param remoteDir 文件要存放的目录
     */
    @Override
    public boolean uploadFile(InputStream inputStream, String originName, String remoteDir){
        if (ftpClient == null){
            return false;
        }

        try {
            ftpClient.changeWorkingDirectory(remoteDir);//进入到文件保存的目录
            Boolean isSuccess = ftpClient.storeFile(originName,inputStream);//保存文件
//            if (!isSuccess){
//                throw new BusinessException(ResponseCode.UPLOAD_FILE_FAIL_CODE,originName+"---》上传失败！");
//            }
            LOGGER.info("{}---》上传成功！",originName);
            ftpClient.logout();
            return true;
        } catch (IOException e) {
            LOGGER.error("{}---》上传失败！",originName);
//            throw new BusinessException(ResponseCode.UPLOAD_FILE_FAIL_CODE,originName+"上传失败！");
            return false;
        }finally {
            if (ftpClient.isConnected()){
                try {
                    ftpClient.disconnect();
                } catch (IOException e) {
                    LOGGER.error("disconnect fail ------->>>{}",e.getCause());
                }
            }
        }
    }
}

/**
 * @program: yxc
 * @description: 测试ftp
 * @author: maque
 * @create: 2019-05-06 13:54
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestFTP {

    @Autowired
    private FTPClientService ftpClientService;
    @Test
    public void test1(){
        try {
            InputStream inputStream = new FileInputStream(new File("E:\\temp\\toPDF\\index.jpg"));
            ftpClientService.uploadFile(inputStream,"000.jpg","/2018/");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}