ftp,sftp上传案例代码

于 2024-07-04 17:11:17 发布
阅读量382 收藏 3
点赞数 4
分类专栏： 笔记 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44221093/article/details/140184428
版权

ftp上传

package com.xnh.atom.server;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class FtpChinaFileUtil {
	private static final Logger log = LoggerFactory.getLogger(FtpChinaFileUtil.class);

    private String ip = "";

    private String username = "";

    private String password = "";

    private int port = 21;

    private String path = "";

    FTPClient ftpClient = null;

    OutputStream os = null;

    FileInputStream is = null;
    
    private String LOCAL_CHARSET = "GBK";
    
    public FtpChinaFileUtil(){}
    
    public FtpChinaFileUtil(String path,String serverIP, int port, String username, String password) {
    	this.path = path;
        this.ip = serverIP;
        this.username = username;
        this.password = password;
        this.port = port;
    }
    
    /**
     * 连接ftp服务器
     *
     * @throws IOException ,FtpProtocolException
     */
    public void connectServer() throws IOException {
    	System.out.println("ftp开始创建:"+ip+","+port);
        
    	ftpClient = new FTPClient();
        ftpClient.setConnectTimeout(20000);
        ftpClient.setDataTimeout(3*60*1000);
        ftpClient.setControlKeepAliveReplyTimeout(10000);
        ftpClient.setControlKeepAliveTimeout(10000);
        ftpClient.setBufferSize(1024 * 1024*10);
        ftpClient.connect(ip, port);
        //连接
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            throw new IOException("FTP server refused connection.");
        }
        
        //登录
        System.out.println("ftp开始登录:"+username+","+password+","+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        
        boolean success = ftpClient.login(username, password);
        
        System.out.println("ftp登录状态:"+success+","+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        
        if (!success) {
            ftpClient.disconnect();
            throw new IOException("Could not login to FTP server.");
        }
        ftpClient.enterLocalPassiveMode();
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        LOCAL_CHARSET = "GBK";
        if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))){
            LOCAL_CHARSET="UTF-8";
        }  
        
        System.out.println("ftp切换目录"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        
        boolean changed = ftpClient.changeWorkingDirectory(remoteFile(path));  
        System.out.println("ftp切换目录结果:"+changed+","+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        if (!changed) {
        	ftpClient.disconnect();
            throw new IOException("Failed to change to directory: " + path);
		}
    }
    
    //目录转换
    private String remoteFile(String remoteFilePath) throws IOException{
    	System.out.println("目录转换:"+remoteFilePath+","+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
    	  
    	return new String(remoteFilePath.getBytes(LOCAL_CHARSET),"iso-8859-1");
    }
    
    /**
     * 断开与ftp服务器连接 
     *
     * @throws IOException
     */
    public void closeServer(){
        try{
            if (ftpClient != null&&ftpClient.isConnected()) {
            	ftpClient.logout();
                ftpClient.disconnect();
            }
            System.out.println("已从服务器断开"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    
    /**
     * 切换目录
     *
     * @param path
     */
    public void changeDirectory(String path) {
    	try {
    		boolean changed = ftpClient.changeWorkingDirectory(remoteFile(path));
    		if (!changed) {
            	ftpClient.makeDirectory(remoteFile(path));
            	ftpClient.changeWorkingDirectory(remoteFile(path));
    		}
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
    
    /**
     * 切换目录
     *
     * @param path
     */
    public void changeWorkingDirectory(String path) throws IOException {
    	ftpClient.changeWorkingDirectory(remoteFile(path));  
    }
    
    /**
     * 上传文件
     *
     * @param data
     * @param ftpFile
     */
    public Boolean outUploadTxt(String data, String ftpFile) {
    	System.out.println("outUploadTxt:"+ftpFile);
    	ByteArrayOutputStream byteArrayOutputStream = null;
    	ByteArrayInputStream byteArrayInputStream = null;
    	boolean done = true;
        try {
        	byteArrayOutputStream = new ByteArrayOutputStream();
            byteArrayOutputStream.write(data.getBytes());
            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            System.out.println("开始请求上传,文件流大小:"+byteArrayOutputStream.size());            
            //ftpClient.setSoTimeout(60*1000);
            //ftpClient.setBufferSize(1024*1024*10);
            done = ftpClient.storeFile(remoteFile(ftpFile),byteArrayInputStream);
            if (done) {
            	//传输后发送一个命令,避免传送下1个文件服务器进行拒绝
                if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))){
                    LOCAL_CHARSET="UTF-8";
                    System.out.println("isPositiveCompletion！"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
                }
                System.out.println("上传成功！"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            } else {
                System.out.println("上传失败！"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (byteArrayOutputStream != null){
                	byteArrayOutputStream.close();
                }
                if (byteArrayInputStream != null){
                	byteArrayInputStream.close();
                }
               
                	
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return done;
    }
    
    /**
     * 上传文件
     *
     * @param outputStream
     * @param ftpFile
     */
    public Boolean outUpload(ByteArrayOutputStream outputStream, String ftpFile) {
        ByteArrayInputStream byteArrayInputStream = null;
        boolean done = true;
        try {
        	byteArrayInputStream = new ByteArrayInputStream(outputStream.toByteArray());
            done = ftpClient.storeFile(remoteFile(ftpFile),byteArrayInputStream);
            if (done) {
                System.out.println("上传成功！"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            } else {
                System.out.println("上传失败！"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
            	if (byteArrayInputStream != null)
                	byteArrayInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return done;
    }
    
    /**
     * 创建本地文件夹
     * @param file 路径 + 文件夹名称
     */
    public void createFile(String file){
    	//创建文件夹
    	Path dirFile = Paths.get(file);
    	try {
			Files.createDirectories(dirFile);
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("创建目录失败：" + e.getMessage()+","+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
		}
    }
    
    /**
     * 写入数据
     * @param file 路径 + 文件夹名称 + 文件名
     * @param content 数据
     */
    public void content(String file,String content){
    	try{  
    		Path path = Paths.get(file);
    		Files.write(path, content.getBytes());
        } catch (IOException e) {  
            e.printStackTrace();  
            System.out.println("写入文件失败：" + e.getMessage()+","+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        }
    }
     
    /**
     * 压缩文件
     * @param sourceFilePath 源文件路径
     * @param zipFilePath 压缩文件路径
     * @throws IOException
     */
    public void compressFile(String sourceFilePath, String zipFilePath) throws IOException {  
    	FileOutputStream fos = new FileOutputStream(zipFilePath);  
        ZipOutputStream zos = new ZipOutputStream(fos);  
        addFolderToZip("", sourceFilePath, zos);  
        zos.close();  
        fos.close();  
    }
    
    private void addFileToZip(String path, File file, ZipOutputStream zos) throws IOException {  
        FileInputStream fis = new FileInputStream(file);  
        ZipEntry zipEntry = new ZipEntry(path + file.getName());  
        zos.putNextEntry(zipEntry);  
  
        byte[] bytes = new byte[1024];  
        int length;  
        while ((length = fis.read(bytes)) >= 0) {  
            zos.write(bytes, 0, length);  
        }  
  
        zos.closeEntry();  
        fis.close();  
    }  
  
    private void addFolderToZip(String path, String folderPath, ZipOutputStream zos) throws IOException {  
        File folder = new File(folderPath);  
        for (File file : folder.listFiles()) {  
            if (file.isDirectory()) {  
                addFolderToZip(path + file.getName() + "/", file.getAbsolutePath(), zos);  
            } else {  
                addFileToZip(path, file, zos);  
            }  
        }  
    } 
    
//    private void addFileToZip(String filePath, ZipOutputStream zos) throws IOException {  
//        File file = new File(filePath);  
//        FileInputStream fis = new FileInputStream(file);  
//        ZipEntry zipEntry = new ZipEntry(file.getPath());  
//        zos.putNextEntry(zipEntry);  
//  
//        byte[] bytes = new byte[1024];  
//        int length;  
//        while ((length = fis.read(bytes)) >= 0) {  
//            zos.write(bytes, 0, length);  
//        }  
//  
//        zos.closeEntry();  
//        fis.close();  
//    }  
//  
//    private void addFolderToZip(String folderPath, String srcFolder, ZipOutputStream zos) throws IOException {  
//        File folder = new File(srcFolder + folderPath);  
//        for (File file : folder.listFiles()) {  
//            if (file.isDirectory()) {  
//                addFolderToZip(folderPath + File.separator + file.getName(), srcFolder, zos);  
//            } else {  
//                addFileToZip(srcFolder + File.separator + folderPath + File.separator + file.getName(), zos);  
//            }  
//        }  
//    }
    /**
     * 
     * @param localFilePath 本地路径
     * @param ftpFilePath ftp路径
     * @return
     * @throws IOException
     */
    public Boolean uploadFileToFtp(String localFilePath, String ftpFilePath) throws IOException {  
        boolean done = true;
        // 上传文件  
        File file = new File(localFilePath);
        InputStream inputStream = new FileInputStream(file);  
        //FileInputStream inputStream = new FileInputStream(localFilePath); 
        done = ftpClient.storeFile(file.getName(), inputStream);
        inputStream.close(); 
        return done;
    }  
    
    /**
     * 删除文件
     * @param filePath 文件路径
     */
    public void deleteFile(String filePath){
    	File directory = new File(filePath); 
        try {  
            deleteDirectory(directory);  
        } catch (Exception e) {  
            e.printStackTrace();  
            System.err.println("删除失败: " + e.getMessage());  
        } 
    }
    
    private void deleteDirectory(File directory) {  
        if (directory.exists()) {  
            File[] files = directory.listFiles();  
            if (files != null) { // 文件或目录可能为空  
                for (File file : files) {  
                    if (file.isDirectory()) {  
                        // 递归删除子目录  
                        deleteDirectory(file);  
                    } else {  
                        // 删除文件  
                        file.delete();  
                    }  
                }  
            }  
            // 最后删除目录本身  
            directory.delete();  
        }  
    }
}

sftp上传

package com.xnh.atom.server;


import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.jcraft.jsch.*;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Properties;
import java.util.Vector;


public class SftpChinaFileUtil {

    private static final Logger logger = LoggerFactory.getLogger(SftpChinaFileUtil.class);
    
    //session会话
    private Session session = null;
    //连接通道
    private ChannelSftp channel = null;
    //超时时间
    private int timeout = 60000;
    
    private String LOCAL_CHARSET = "GBK";
    
    /**
    * 连接sftp服务器
    */
    public boolean connect(String ftpUsername, String ftpAddress, int ftpPort, String ftpPassword) {
        boolean isSuccess = false;
        if (channel != null) {
            System.out.println("通道不为空");
            return false;
        }
        //创建JSch对象
        JSch jSch = new JSch();
        try {
            // 根据用户名，主机ip和端口获取一个Session对象
        	System.out.println("session创建开始:"+ftpUsername+","+ftpAddress+","+ftpPort);
        	jSch.getSession(ftpUsername, ftpAddress, ftpPort);
        	
        	session = jSch.getSession(ftpUsername, ftpAddress, ftpPort);
        	
        	System.out.println("session创建成功");
        	
            //设置密码
            session.setPassword(ftpPassword);
            System.out.println(ftpPassword);
            
            Properties config = new Properties();
            config.put("StrictHostKeyChecking", "no");
            //为Session对象设置properties
            session.setConfig(config);
            //设置超时
            session.setTimeout(timeout);
            
            System.out.println("session创建连接");
            
            //通过Session建立连接
            session.connect();
            
            System.out.println("session连接成功");
            
            // 打开SFTP通道
            channel = (ChannelSftp) session.openChannel("sftp");
            // 建立SFTP通道的连接
            channel.connect();
            
            isSuccess = true;
        } catch (JSchException e) {
            logger.error("连接服务器异常", e);
        }
        return isSuccess;
    }
 
    /**
     * 关闭连接
     */
    public void close() {
        //操作完毕后，关闭通道并退出本次会话
        if (channel != null && channel.isConnected()) {
            channel.disconnect();
        }
        if (session != null && session.isConnected()) {
            session.disconnect();
        }
    }
 
    /**
    * 文件上传
    * @param data      文件数据
    * @param dst      上传路径
    * @param fileName 上传文件名
    * @param document dom对象
    * @param preffix 文件后缀
    *
    * @throws SftpException
     * @throws IOException 
    */
    public boolean upLoadFile(String data, String dst, String fileName,Document document,String prefix) throws SftpException, IOException {
        boolean isSuccess = false;
        ByteArrayOutputStream byteArrayOutputStream = null;
    	ByteArrayInputStream byteArrayInputStream = null;
        try {
        	dst = new String(dst.getBytes(LOCAL_CHARSET),"iso-8859-1");
            if(createDir(dst)) {
            	byteArrayOutputStream = new ByteArrayOutputStream();
            	if(prefix==null){
            		logger.info("文件后缀为空:{}",prefix);
            		return false;
            	}
            	//根据文件后缀进行匹配文件 把字符数组转换成输入流进行上传
            	if(!"xml".equals(prefix)){
        			byteArrayOutputStream.write(data.getBytes());
            	}else{
            		OutputFormat format = OutputFormat.createCompactFormat();
                    format.setEncoding("UTF-8");

                    byteArrayOutputStream = new ByteArrayOutputStream();
            		XMLWriter writer = new XMLWriter(byteArrayOutputStream, format);
                    writer.write(document);
                    writer.close();
            	}
            	byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                InputStream src = byteArrayInputStream;
                channel.put(src, fileName);
                isSuccess = true;
            }
        } catch (SftpException e) {
            logger.error(fileName + "文件上传异常", e);
        }finally {
            try {
            	if (byteArrayOutputStream != null)
                	byteArrayOutputStream.close();
            	if (byteArrayInputStream != null)
                	byteArrayInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return isSuccess;
    }
 
    /**
    * 创建一个文件目录
    *
    * @param createpath  路径
    * @return
    */
    public boolean createDir(String createpath) {
        boolean isSuccess = false;
        try {
            if (isDirExist(createpath)) {
                channel.cd(createpath);
                return true;
            }
            String pathArry[] = createpath.split("/");
            StringBuffer filePath = new StringBuffer("/");
            for (String path : pathArry) {
                if (path.equals("")) {
                    continue;
                }
                filePath.append(path +"/");
                if (isDirExist(filePath.toString())) {
                    channel.cd(filePath.toString());
                } else {
                    // 建立目录
                    channel.mkdir(filePath.toString());
                    //文件夹授权 读写执行
                    //channel.chmod(Integer.parseInt("755", 8), filePath.toString());
                    // 进入并设置为当前目录
                    channel.cd(filePath.toString());
                }
            }
            channel.cd(createpath);
            isSuccess = true;
        } catch (SftpException e) {
            logger.error("目录创建异常！", e);
        }
        return isSuccess;
    }
    
 
    /**
     * 判断目录是否存在
     * @param directory     路径
     * @return
     */
    public boolean isDirExist(String directory) {
        boolean isSuccess = false;
        try {
            SftpATTRS sftpATTRS = channel.lstat(directory);
            isSuccess = true;
            return sftpATTRS.isDir();
        } catch (Exception e) {
            if (e.getMessage().toLowerCase().equals("no such file")) {
                isSuccess = false;
            }
        }
        return isSuccess;
    }
 
    /**
    * 重命名指定文件或目录
    *
    */
    public boolean rename(String oldPath, String newPath) {
        boolean isSuccess = false;
        try {
            channel.rename(oldPath, newPath);
            isSuccess = true;
        } catch (SftpException e) {
            logger.error("重命名指定文件或目录异常", e);
        }
        return isSuccess;
    }
 
    /**
    * 列出指定目录下的所有文件和子目录。
    */
    public Vector ls(String path) {
        try {
            Vector vector = channel.ls(path);
            return vector;
        } catch (SftpException e) {
            logger.error("列出指定目录下的所有文件和子目录。", e);
        }
        return null;
    }
 
    /**
    * 删除文件
    *
    * @param directory  linux服务器文件地址
    * @param deleteFile 文件名称
    */
    public boolean deleteFile(String directory, String deleteFile) {
        boolean isSuccess = false;
        try {
            channel.cd(directory);
            channel.rm(deleteFile);
            isSuccess = true;
        } catch (SftpException e) {
            logger.error("删除文件失败", e);
        }
        return isSuccess;
    }
 
    /**
    * 下载文件
    *
    * @param directory    下载目录
    * @param downloadFile 下载的文件
    * @param saveFile     下载到本地路径
    */
    public boolean download(String directory, String downloadFile, String saveFile) {
        boolean isSuccess = false;
        try {
            channel.cd(directory);
            File file = new File(saveFile);
            channel.get(downloadFile, new FileOutputStream(file));
            isSuccess = true;
        } catch (SftpException e) {
            logger.error("下载文件失败", e);
        } catch (FileNotFoundException e) {
            logger.error("下载文件失败", e);
        }
        return isSuccess;
    }
 
    /**
     * 上传压缩包
     * @param localFile 本地路径
     * @param sftpFile sftp路径
     * @return
     * @throws SftpException 
     * @throws IOException 
     */
    public void upLoadFile(String localFile,String sftpFile){
    	try {
    		sftpFile = new String(sftpFile.getBytes(LOCAL_CHARSET),"iso-8859-1");
            if(createDir(sftpFile)) {
            	File localZipFile = new File(localFile);
            	InputStream inputStream = new FileInputStream(localZipFile);  
            	channel.put(inputStream, sftpFile + "/" + localZipFile.getName());
    			inputStream.close();
            }
		} catch (IOException e) {
			logger.error("上传压缩包失败", e);
		} catch (SftpException e) {
			// TODO Auto-generated catch block
			logger.error("上传压缩包失败", e);
		}
    }
}

获取本地 temp 目录 String tempDir = System.getProperty(“java.io.tmpdir”);

调用上传

if ("0".equals(fileType)){
        	
        	System.out.println("-----上传----"+"/"+dateString+"/"+fileName+".txt"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
			
        	flag = ftpUtil.outUploadTxt(TempStr, "/"+dateString+"/"+fileName+".txt");
			//ftpUtil.closeServer();
			ftpUtil.changeWorkingDirectory(ftpUrl);
        }else{
        	OutputFormat format = OutputFormat.createCompactFormat();
            format.setEncoding("UTF-8");
            
            // 5、生成xml文件
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            XMLWriter writer = new XMLWriter(out, format);
            writer.write(document);
            writer.close();
    		flag = ftpUtil.outUpload(out,"/"+dateString+"/"+fileName+".xml");
    		//ftpUtil.closeServer();
    		ftpUtil.changeWorkingDirectory(ftpUrl);
        }

以及document转string

OutputFormat format = OutputFormat.createPrettyPrint();  
            format.setEncoding("UTF-8"); // 设置编码格式  
            // 创建一个StringWriter，它将用于收集XML内容  
            StringWriter writer = new StringWriter();  
            // 创建一个XMLWriter，用于将Document对象写入StringWriter  
            XMLWriter xmlWriter = new XMLWriter(writer, format);  
            // 将Document对象写入StringWriter  
            try {
				xmlWriter.write(document);
				// 关闭XMLWriter，释放资源  
				xmlWriter.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
        	return writer.toString();
qq_44221093
关注
专栏目录
java实现FTP和 SFTP连接远程服务器下载文件
zhx__的博客
08-26 6987
java实现FTP和 SFTP连接远程服务器下载文件 文章目录java实现FTP和 SFTP连接远程服务器下载文件前言一、FTP是什么？如何实现。1.实现代码二、SFTP是什么？如何实现。1.代码实现总结 前言 为什魔写这片文章呢，因为关于ftp和sftp的文章介绍的太少啦 。 提示：以下是本篇文章正文内容，下面案例可供参考 一、FTP是什么？如何实现。 来自百度百科 ：文件传输协议（File Transfer Protocol，FTP）是用于在网络上进行文件传输的一套标准协议，它工作在 OSI 模型
JAVA通过SFTP实现远程上传下载demo代码
06-14
本文将详细介绍如何使用Java通过SFTP实现远程文件的上传和下载，并提供一个简单的示例代码。 首先，为了实现SFTP功能，我们需要一个第三方库，如JSch（Java Secure Channel）。JSch是一个纯Java实现的SSH2库，它...
FTP协议文件上传下载代码实现案例
2301_77852117的博客
07-08 360
简介：FTP是基于TCP协议之上的具有C/S架构的文件服务器。需要通过控制连接20端口来控制双方的通信需要通过数据连接21端口来进行双方的通信在基于FTP实现文件的上传下载钱，我们首先需要下载commons-net-3.6.jar,
java实现sftp的上传下载
liouwb的博客
04-06 2216
java sftp操作文件
Shell开发脚本 通过SFTP 定时 上传文件
u012972294的博客
03-10 7792
【背景】与三方公司对接，有数据传输需求，数据传到对方的服务器，对方提供的传输方式是SFTP。 【思路】数据来自于ORACLE，项目先提供在服务器上使用sqluldr2来操作【数据导出】工作，之前的博客有提到大批量数据【导入】工具sqluldr，注意不要弄混了，然后把数据存到指定的文件下，接着通过crontab 任务定时调用传输工具脚本就行了，之前未接触过SFTP，这次遇到一些坑，网上查了许多文章没有我需要的，简单记录一下： 1.FTP传输示例 先放之前FTP上传下载文件的做法，连接到指定IP和端口
FTP与SFTP传输文件的Python、shell脚本
追光的鲲的博客
09-02 5061
在工作中我们经常遇到在不同的电脑之间传输文件，有时是同一网络下，有时是不同的网络之间传输文件，甚至是向客户传输文件。本文主要介绍常用的两种传输方式：FTP和SFTP，以及Python和shell脚本实现。或许你会说，传文件嘛，U盘拷一下喽，QQ、微信、邮箱等都可以呀！是的，方法有很多，但是如果每天都要你定时传一份文件给对方呢？你天天定时去插U盘拔U盘吗？对于同一网络之间的电脑，我们可以在一台机器上设置一个共享目录，然后其他的电脑挂载这一个共享目录，这样就不用互传了。
Java完成sftp上传
Li_XJ99的博客
03-18 707
SFTP 是一种数据流链接，提供文件访问、传输和管理功能的网络传输协议。它允许用户以文件操作的方式（如文件的增、删、改、查、传送等）与另一主机相互通信。
shell操作典型案例--FTP操作
天涯的浪子
11-12 1752
思路一：使用shell调用ftp等客户端 　　使用FTP方式，通过shell调用ftp等客户端，从而完成FTP文件的上传、下载等操作。 方式一：ftp方式  一个基本的ftp工具，需安装ftp（yum -y install ftp，后同）。一个样例如下： ########################################################### ##函...
FTP服务器上传文件-Java实战
cjhlovecsdn66的博客
08-10 96
FTP服务器上传文件-Java实战，十足的干货
【Shell】ftp上传示例脚本
比嗨皮兔
03-21 173
【代码】【Shell】ftp上传示例脚本。
基于QT开发的ftp客户端程序源代码
10-06
【FTP客户端概述】 ...总的来说，这份基于QT5.3.1的FTP客户端源代码为学习者提供了一个实际应用案例，涵盖了网络编程、文件操作和GUI设计等多个方面，是提升QT开发技能和理解FTP工作原理的良好实践。
Ftp应用程序案例DEMO
最新发布
04-22
在这个“Ftp应用程序案例DEMO”中，我们很可能会看到一个实际的FTP客户端或服务器端的示例代码，它可以帮助理解FTP的工作原理和编程实现。 FTP协议基于TCP/IP模型，主要包含两个端：客户端和服务器端。客户端通过...
java实现导出csv文件并上传sftp
10-09
使用JSch进行SFTP上传的基本步骤如下： 1. 创建`JSch`实例。 2. 使用`getSession()`方法设置用户名、密码和主机信息。 3. 调用`connect()`方法建立连接。 4. 使用`openSftp()`方法获取`SftpSession`对象。 5. 使用`...
vue对象与对象、集合与集合的添加
qq_44221093的博客
09-17 3682
vue对象与集合的添加 持续更新中… //集合的添加（rowDatas总体集合，rowData新集合（一般都是通过循环获取并存放入到rowDatas集合中）相当于rowDatas.addAll(rowData)） this.rowDatas = this.rowDatas.concat(rowData) //对象的添加（rowDatas合并后的对象，rowData1,rowData2新对象，相当于（rowDatas.putAll(rowData1).putAll(rowData2)）） this.rowD
vue中xe-utils的强大
qq_44221093的博客
11-25 1718
每当遇到一个新需求，新问题，都想找到最新最棒的技术… //引入前端计算工具类 import XEUtils from 'xe-utils' //案例： let amountNoTax = 0 let amount = 0 const salesResult = [1,2,3,4,5,6,7.9,8] for (let i = 0; i < salesResult.length; i++) { amountNoTax = XEUtils.sum([amountNoTax, salesResult[i]]
使用Java读取PDF文件内容
qq_44221093的博客
10-26 1669
1.引入读取PDF的jar包。2.编写PFD工具类。3.调用工具类实现读取功能。
Duplicate entry ‘‘ for key ‘index_***‘
qq_44221093的博客
10-22 1545
Caused by: java.sql.BatchUpdateException: Duplicate entry '' for key 'index_code' at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at
使用js简单输出字符串中有几个相同的那个字符
qq_44221093的博客
04-07 1262
使用js简单输出字符串中有几个相同的那个字符 function ceshi(num){ //判断首先出现三次的字符 var c=new Array(); c=num.split(""); var t=new Map(); for(var i=0;i<c.length;i++){ var temp=c[i]; if(t.get(temp)==2){ return temp; } if(t.g...
Java实现sftp与ftp远程服务器文件下载
这个设计使得代码可以根据配置动态选择使用FTP还是SFTP。 此外，`max`变量表示一次最多可以下载50个文件，这可能是一个并发控制的限制，以防止过多的文件传输导致系统负载过高。`ExecutorService`可能被用来管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值