JAVA 向FTP服务器进行文件的上传和下载
java实现sftp客户端上传文件以及文件夹的功能代码
java实现sftp客户端上传⽂件以及⽂件夹的功能代码1.依赖的jar⽂件 jsch-0.1.53.jar2.登录⽅式有密码登录,和密匙登录代码:主函数:import java.util.Properties;import com.cloudpower.util.Login;import com.util.LoadProperties;public class Ftp {public static void main(String[] args) {Properties properties = LoadProperties.getProperties();Login.login(properties);}}登陆页⾯的代码:package com.cloudpower.util;import java.io.Console;import java.util.Properties;import com.jcraft.jsch.JSch;import com.jcraft.jsch.Session;public class Login {public static void login(Properties properties) {String ip = properties.getProperty("ip");String user = properties.getProperty("user");String pwd = properties.getProperty("pwd");String port = properties.getProperty("port");String privateKeyPath = properties.getProperty("privateKeyPath");String passphrase = properties.getProperty("passphrase");String sourcePath = properties.getProperty("sourcePath");String destinationPath = properties.getProperty("destinationPath");if (ip != null && !ip.equals("") && user != null && !user.equals("")&& port != null && !port.equals("") && sourcePath != null&& !sourcePath.equals("") && destinationPath != null&& !destinationPath.equals("")) {if (privateKeyPath != null && !privateKeyPath.equals("")) {sshSftp2(ip, user, Integer.parseInt(port), privateKeyPath,passphrase, sourcePath, destinationPath);} else if (pwd != null && !pwd.equals("")) {sshSftp(ip, user, pwd, Integer.parseInt(port), sourcePath,destinationPath);} else {Console console = System.console();System.out.print("Enter password:");char[] readPassword = console.readPassword();sshSftp(ip, user, new String(readPassword),Integer.parseInt(port), sourcePath, destinationPath);}} else {System.out.println("请先设置配置⽂件");}}/*** 密码⽅式登录** @param ip* @param user* @param psw* @param port* @param sPath* @param dPath*/public static void sshSftp(String ip, String user, String psw, int port,String sPath, String dPath) {System.out.println("password login");Session session = null;JSch jsch = new JSch();try {if (port <= 0) {// 连接服务器,采⽤默认端⼝session = jsch.getSession(user, ip);} else {// 采⽤指定的端⼝连接服务器session = jsch.getSession(user, ip, port);}// 如果服务器连接不上,则抛出异常if (session == null) {throw new Exception("session is null");}// 设置登陆主机的密码session.setPassword(psw);// 设置密码// 设置第⼀次登陆的时候提⽰,可选值:(ask | yes | no)session.setConfig("StrictHostKeyChecking", "no");// 设置登陆超时时间session.connect(300000);UpLoadFile.upLoadFile(session, sPath, dPath);} catch (Exception e) {e.printStackTrace();}System.out.println("success");}/*** 密匙⽅式登录** @param ip* @param user* @param port* @param privateKey* @param passphrase* @param sPath* @param dPath*/public static void sshSftp2(String ip, String user, int port,String privateKey, String passphrase, String sPath, String dPath) {System.out.println("privateKey login");Session session = null;JSch jsch = new JSch();try {// 设置密钥和密码// ⽀持密钥的⽅式登陆,只需在jsch.getSession之前设置⼀下密钥的相关信息就可以了 if (privateKey != null && !"".equals(privateKey)) {if (passphrase != null && "".equals(passphrase)) {// 设置带⼝令的密钥jsch.addIdentity(privateKey, passphrase);} else {// 设置不带⼝令的密钥jsch.addIdentity(privateKey);}}if (port <= 0) {// 连接服务器,采⽤默认端⼝session = jsch.getSession(user, ip);} else {// 采⽤指定的端⼝连接服务器session = jsch.getSession(user, ip, port);}// 如果服务器连接不上,则抛出异常if (session == null) {throw new Exception("session is null");}// 设置第⼀次登陆的时候提⽰,可选值:(ask | yes | no)session.setConfig("StrictHostKeyChecking", "no");// 设置登陆超时时间session.connect(300000);UpLoadFile.upLoadFile(session, sPath, dPath);System.out.println("success");} catch (Exception e) {e.printStackTrace();}}}⽂件上传的代码:package com.cloudpower.util;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.util.Scanner;import com.jcraft.jsch.Channel;import com.jcraft.jsch.ChannelSftp;import com.jcraft.jsch.Session;import com.jcraft.jsch.SftpException;public class UpLoadFile {public static void upLoadFile(Session session, String sPath, String dPath) {Channel channel = null;try {channel = (Channel) session.openChannel("sftp");channel.connect(10000000);ChannelSftp sftp = (ChannelSftp) channel;try {sftp.cd(dPath);Scanner scanner = new Scanner(System.in);System.out.println(dPath + ":此⽬录已存在,⽂件可能会被覆盖!是否继续y/n?"); String next = scanner.next();if (!next.toLowerCase().equals("y")) {return;}} catch (SftpException e) {sftp.mkdir(dPath);sftp.cd(dPath);}File file = new File(sPath);copyFile(sftp, file, sftp.pwd());} catch (Exception e) {e.printStackTrace();} finally {session.disconnect();channel.disconnect();}}public static void copyFile(ChannelSftp sftp, File file, String pwd) {if (file.isDirectory()) {File[] list = file.listFiles();try {try {String fileName = file.getName();sftp.cd(pwd);System.out.println("正在创建⽬录:" + sftp.pwd() + "/" + fileName);sftp.mkdir(fileName);System.out.println("⽬录创建成功:" + sftp.pwd() + "/" + fileName);} catch (Exception e) {// TODO: handle exception}pwd = pwd + "/" + file.getName();try {sftp.cd(file.getName());} catch (SftpException e) {// TODO: handle exceptione.printStackTrace();}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}for (int i = 0; i < list.length; i++) {copyFile(sftp, list[i], pwd);}} else {try {sftp.cd(pwd);} catch (SftpException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}System.out.println("正在复制⽂件:" + file.getAbsolutePath()); InputStream instream = null;OutputStream outstream = null;try {outstream = sftp.put(file.getName());instream = new FileInputStream(file);byte b[] = new byte[1024];int n;try {while ((n = instream.read(b)) != -1) {outstream.write(b, 0, n);}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}} catch (SftpException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {try {outstream.flush();outstream.close();instream.close();} catch (Exception e2) {// TODO: handle exceptione2.printStackTrace();}}}}}读取配置⽂件的代码:package com.util;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.util.Properties;public class LoadProperties {public static Properties getProperties() {File file = new File(Class.class.getClass().getResource("/").getPath()+ "properties.properties");InputStream inputStream = null;try {inputStream = new FileInputStream(file);} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}Properties properties = new Properties();try {properties.load(inputStream);} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}return properties;}}代码⽬录结构:测试运⾏时配置⽂件放在项⽬的bin⽬录下(打包成可运⾏jar⽂件的时候要删除,打包完成后将配置⽂件和jar包放在同级⽬录下即可):properties.propertiesip=user=pwd=port=22privateKeyPath=passphrase=sourcePath=destinationPath=/home/dbbs/f打包可运⾏jar⽂件:Export->java->Runnabe JAR file完成后在控制台运⾏java -jar 导出jar包的名字.jar 即可以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
Java操作ftpClient常用方法
Java操作ftpClient常用方法1.连接FTP服务器- connect(host: String, port: int): 建立与FTP服务器的连接。
- login(username: String, password: String): 登录FTP服务器。
2.设置工作目录- changeWorkingDirectory(path: String): 切换当前工作目录。
- printWorkingDirectory(: 获取当前工作目录。
- storeFile(remoteFileName: String, inputStream: InputStream): 上传文件到FTP服务器。
4.删除文件- deleteFile(remoteFileName: String): 删除FTP服务器上的文件。
5.列出目录中的文件- listFiles(remotePath: String): 返回指定目录中的文件列表。
6.创建和删除目录- makeDirectory(directory: String): 在FTP服务器上创建目录。
- removeDirectory(directory: String): 删除FTP服务器上的目录。
7.设置传输模式和文件类型- setFileType(fileType: int): 设置文件类型(ASCII或二进制)。
- setFileTransferMode(mode: int): 设置传输模式(主动或被动)。
8.设置数据连接模式- enterLocalPassiveMode(: 设置被动模式。
- enterLocalActiveMode(: 设置主动模式。
9.设置缓冲大小和字符编码- setBufferSize(bufferSize: int): 设置缓冲区大小。
- setControlEncoding(encoding: String): 设置字符编码。
10.断开与FTP服务器的连接- logout(: 登出FTP服务器。
java sftp 常用方法
一、介绍随着信息化时代的到来,数据传输变得越来越重要。
在企业中,有时候需要通过网络将数据从一个服务器传输到另一个服务器。
而其中一种常用的数据传输协议就是SFTP(Secure File Transfer Protocol)。
SFTP是一种基于SSH协议的安全文件传输协议。
它提供了一种安全的通信渠道以及文件传输功能,能够有效地保护传输的数据安全。
在Java中,我们可以通过一些常用的方法来实现SFTP的文件传输,本文将介绍一些Java中SFTP常用的方法。
二、建立SFTP连接在Java中,我们可以使用JSch库来建立SFTP连接。
需要在项目中导入JSch库的jar包。
我们可以通过以下方法来建立SFTP连接:1. 创建JSch对象我们可以通过new JSch()来创建一个JSch对象,用于后续的SFTP连接。
2. 建立Session使用JSch对象的getSession方法建立一个Session对象,需要传入用户名、主机位置区域和端口号等参数,并通过setPassword或setPrivateKey方法设置认证方式。
3. 打开Channel在建立Session之后,可以通过Session对象的openChannel方法打开一个Channel,类型为" sftp"。
4. 建立SFTP连接使用ChannelSftp的connect方法来建立SFTP连接。
以上即为建立SFTP连接的步骤,通过这些方法,我们可以在Java中轻松地实现SFTP连接的功能。
三、上传文件一旦建立了SFTP连接,我们就可以进行文件的上传操作了。
通过以下方法可以实现文件的上传:1. 使用put方法在ChannelSftp对象中,可以使用put方法来上传文件。
需要传入本地文件路径和远程文件路径两个参数。
2. 设置传输模式在上传文件之前,可以通过ChannelSftp对象的setmode方法来设置传输模式,常用的传输模式包括OVERWRITE、RESUME等。
java实现文件上传、下载
tomcat上传文件下载文件首先介绍一下我们需要的环境:我用的是myeclipse8.5的java开发环境,tomcat是用的apache-tomcat-6.0.26这个版本。
首先先需要准备一下使用到的jar包这些jar包是struts2的jar包。
这些jar包是都是用于上传文件的。
注意:这里的jar包版本必须是对应的,如不是可能会tomcat下报错。
所以大家最好注意一下啊。
最好是用这套jar包。
我将会在csdn上将项目jar包发上去。
Jar下载地址(0分):/detail/woaixinxin123/4193113 源代码下载(10分):/detail/woaixinxin123/4193134开始搭建我们的项目。
创建web项目名字为File。
第一步:搭建struts2框架。
1、到jar包。
2、编辑web.xml<?xml version="1.0"encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><!-- 增加struts2的支持 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepa reAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list></web-app>3、添加struts.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN""/dtds/struts-2.0.dtd"><struts></struts>4、启动tomcat测试。
Java文件上传与文件下载实现方法详解
Java⽂件上传与⽂件下载实现⽅法详解本⽂实例讲述了Java⽂件上传与⽂件下载实现⽅法。
分享给⼤家供⼤家参考,具体如下:Java⽂件上传数据上传是客户端向服务器端上传数据,客户端向服务器发送的所有请求都属于数据上传。
⽂件上传是数据上传的⼀种特例,指客户端向服务器上传⽂件。
即将保存在客户端的⽂件上传⼀个副本到服务器,并保存在服务器中。
1、上传表单要求⽂件上传要求客户端提交特殊的请求——multipart请求,即包含多部分数据的请求。
必须将<form/>标签的enctype属性值设为“multipart/form-data”,enctype表⽰encodingType,及编码类型由于客户端上传⽂件的⼤⼩是不确定的,所以http协议规定,⽂件上传的数据要存放于请求正⽂中,不能出现在URL地址栏内。
也就是说,想要上传⽂件必须提交POST请求。
表单中要有<input type="file" />标签注意:multipart/form-data请求与普通请求不同2、下载⽂件上传jar包并查看官⽅⽂档选择Commons中的FileUpload项⽬,并下载jar包和源⽂件查看FileUpload的⼯作⽅式查看FileUpload项⽬的API3、使⽤第三⽅jar包上传⽂件public class RegisterServlet extends HttpServlet {private static final long serialVersionUID = 1L;public RegisterServlet() {super();}protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.getWriter().append("Served at: ").append(request.getContextPath());}protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//第⼀步、判断请求是否为multipart请求if(!ServletFileUpload.isMultipartContent(request)) {throw new RuntimeException("当前请求只⽀持⽂件上传");}try {//第⼆步、创建FileItem⼯⼚DiskFileItemFactory factory = new DiskFileItemFactory();//设置临时⽂件存储⽬录String path = this.getServletContext().getRealPath("/Temp");File temp = new File(path);factory.setRepository(temp);//单位:字节。
ftpclient方法
ftpclient方法FTPClient方法是一种用于实现FTP(File Transfer Protocol,文件传输协议)客户端的方法。
通过使用FTPClient方法,我们可以实现与FTP服务器的连接、文件上传、文件下载、文件删除等操作。
下面将详细介绍FTPClient方法的使用。
一、连接FTP服务器在使用FTPClient方法进行文件传输之前,首先需要与FTP服务器建立连接。
可以通过以下代码实现与FTP服务器的连接:```javaFTPClient ftpClient = new FTPClient();ftpClient.connect(server, port);ftpClient.login(username, password);```其中,server是FTP服务器的IP地址,port是FTP服务器的端口号,username和password分别是登录FTP服务器的用户名和密码。
二、上传文件至FTP服务器使用FTPClient方法可以方便地将本地文件上传至FTP服务器。
可以通过以下代码实现文件上传:```javaFile file = new File(localFilePath);InputStream inputStream = new FileInputStream(file);ftpClient.storeFile(remoteFilePath, inputStream);```其中,localFilePath是本地文件的路径,remoteFilePath是上传至FTP服务器后的文件路径。
三、从FTP服务器下载文件使用FTPClient方法可以方便地从FTP服务器下载文件。
可以通过以下代码实现文件下载:```javaOutputStream outputStream = new FileOutputStream(localFilePath);ftpClient.retrieveFile(remoteFilePath, outputStream);```其中,localFilePath是文件下载后保存的本地路径,remoteFilePath是FTP服务器上待下载文件的路径。
基于Java文件输入输出流实现文件上传下载功能
基于Java⽂件输⼊输出流实现⽂件上传下载功能本⽂为⼤家分享了Java实现⽂件上传下载功能的具体代码,供⼤家参考,具体内容如下前端通过form表单的enctype属性,将数据传递⽅式修改为⼆进制”流“的形式,服务端(servlet)通过 getInputStream() 获取流信息,运⽤java I/O 流的基础操作将流写⼊到⼀个服务端临时创建的⽂件temp中,然后再次利⽤⽂件基本操作,读取并截取临时⽂件内容,根据其中信息创建相应的⽂件,将读取出来的具体信息写⼊,下载时,根据提交的⽂件名称,找到服务器端相应的⽂件,然后根据输出流outStream输出到页⾯,同时将servlet的响应类型和响应头进⾏设置。
具体传输流程如下图:流信息的部分为:具体代码如下:前端代码:<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>Insert title here</title><script src="Js/jquery.js"></script></head><body><form action="FileUpServlet" method="post" enctype="multipart/form-data"><table><tr><td>请选择上传⽂件:</td><td><input id="myfile" name="myfile" type="file" value="" /></td><td><input type="submit" value="上传"></td></tr><tr><td>${info}</td></tr></table></form>⽂件下载:<a href="FileLoadownServlet?filename=${filename}">${filename}</a></body></html>上传servlet部分(核⼼)@WebServlet("/FileUpServlet")public class FileUpServlet extends HttpServlet {private static final long serialVersionUID = 1L;/*** @see HttpServlet#HttpServlet()*/public FileUpServlet() {super();// TODO Auto-generated constructor stub}/*** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)*/protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stubdoPost(request, response);}/*** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)*/protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stubrequest.setCharacterEncoding("utf-8");InputStream filesource = request.getInputStream();//request获取流信息String tempname = "D:/temp";//tempfile代表临时存放⽂件File tempfile = new File(tempname);//创建临时⽂件FileOutputStream outputStream = new FileOutputStream(tempfile);//输出流对象,指定输出指tempfile⽬录下byte b[] = new byte[1024];int n;while((n = filesource.read(b))!= -1)//从输出流中每次读取1024字节,直⾄读完{outputStream.write(b,0,n);}outputStream.close();filesource.close();//关闭输⼊输出流/*以下为具体的⽂件操作,主要为解析临时产⽣的 temp⽂件,知识多为java输⼊输出流的内容!*/RandomAccessFile randomfile = new RandomAccessFile(tempfile, "r");//随机流,指定要读临时⽂件,只读randomfile.readLine();//读取第⼀⾏,⽆效数据,不需要String str = randomfile.readLine();//读取第⼆⾏int beginIndex = stIndexOf("=")+2;//指定所需数据的开始位置int endIndex = stIndexOf("\"");//指定所需数据截⾄位置String filename = str.substring(beginIndex,endIndex);//截取⽂件名//重新定位⽂件指针,获取⽂件内容randomfile.seek(0);//⽂件指针从头开始long startext = 0;int i = 1;//⽂件内容开始位置while((n=randomfile.readByte()) != -1&&i <= 4){if(n=='\n'){startext = randomfile.getFilePointer();i++;}}startext = randomfile.getFilePointer() - 1;//获取⽂件内容结束位置randomfile.seek(randomfile.length());long endtext = randomfile.getFilePointer();int j = 1;while(endtext >= 0 && j <= 2){endtext--;randomfile.seek(endtext);if(randomfile.readByte()=='\n'){j++;}}endtext = endtext-1;//将临时⽂件保存⾄指定⽬录中String realpath = getServletContext().getRealPath("/")+"images";//设置⽂件保存⽬录System.out.println(realpath);File fileupload = new File(realpath);if(!fileupload.exists()){fileupload.mkdir();//⽬录不存在则创建}File savefile = new File(realpath,filename);RandomAccessFile randomAccessFile = new RandomAccessFile(savefile, "rw");randomfile.seek(startext);while(startext<endtext){randomAccessFile.write(randomfile.readByte());//⽂件写⼊startext = randomfile.getFilePointer();}//关闭各种输⼊输出流randomAccessFile.close();randomfile.close();tempfile.delete();//删除临时⽂件SimpleDateFormat timed = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date nowdate = new Date();String time = timed.format(nowdate.getTime());request.setAttribute("info", time+" "+filename+"上传成功!");request.setAttribute("filename", filename);request.getRequestDispatcher("/fildeOp.jsp").forward(request, response);}}下载部分protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stubString filename = request.getParameter("filename");String path = getServletContext().getRealPath("/")+"images/";File file = new File(path+filename);//找到⽂件if(file.exists())response.setContentType("application/x-msdownload"); //设置响应类型,此处为下载类型response.setHeader("Content-Disposition", "attachment;filename=\""+filename+"\"");//以附件的形式打开 InputStream inputStream = new FileInputStream(file);ServletOutputStream outputStream = response.getOutputStream();byte b[] = new byte[1024];int n;while((n = inputStream.read(b)) != -1){outputStream.write(b,0,n);}outputStream.close();inputStream.close();}else{request.setAttribute("result", "⽂件不存在!下载失败!");request.getRequestDispatcher("/fildeOp.jsp").forward(request, response);}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
java实现ftp上传下载(jdk1.7以上)
网上有很多关于java实现ftp的上传与下载,但都是jdk1.7以下的,最近在做java实现ftp文件上传与下在,搜到的代码不是jdk1.7一下的,就是apache 的。
将我测试通过的代码与大家共享。
完整代码,复制可用FTP实现代码:package com.pifeng.util;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 .InetSocketAddress;import .SocketAddress;import .ftp.FtpClient;import .ftp.FtpProtocolException;/**** @author皮锋 java自带的API对FTP的操作**/public class FtpUtil {// FTP客户端private FtpClient ftpClient;/*** 服务器连接** @param ip* 服务器IP* @param port* 服务器端口* @param user* 用户名* @param password* 密码* @param path* 服务器路径*/public void connectServer(String ip, int port, String user, String password, String path) {try {ftpClient = FtpClient.create();try {SocketAddress addr = new InetSocketAddress(ip, port);this.ftpClient.connect(addr);this.ftpClient.login(user,password.toCharArray());System.out.println("login success!");if (path.length() != 0) {// 把远程系统上的目录切换到参数path所指定的目录this.ftpClient.changeDirectory(path);}} catch (FtpProtocolException e) {e.printStackTrace();}} catch (IOException ex) {ex.printStackTrace();throw new RuntimeException(ex);}}/*** 上传文件** @param localFile* 本地文件* @param remoteFile* 远程文件*/public void upload(String localFile, String remoteFile) { //this.localFilename = localFile;//this.remoteFilename = remoteFile;OutputStream os = null;FileInputStream is = null;try {try {// 将远程文件加入输出流中os = this.ftpClient.putFileStream(remoteFile);} catch (FtpProtocolException e) {e.printStackTrace();}// 获取本地文件的输入流File file_in = new File(localFile);is = new FileInputStream(file_in);// 创建一个缓冲区byte[] bytes = new byte[1024];int c;while ((c = is.read(bytes)) != -1) {os.write(bytes, 0, c);}System.out.println("upload success");} catch (IOException ex) {System.out.println("not upload");ex.printStackTrace();throw new RuntimeException(ex);} finally {try {if (is != null) {is.close();}} catch (IOException e) {e.printStackTrace();} finally {try {if (os != null) {os.close();}} catch (IOException e) {e.printStackTrace();}}}}/*** 文件下载** @param remoteFile* 远程文件* @param localFile* 本地文件*/public void download(String remoteFile, String localFile) { InputStream is = null;FileOutputStream os = null;try {try {// 获取远程机器上的文件filename,借助TelnetInputStream把该文件传送到本地is = this.ftpClient.getFileStream(remoteFile);} catch (FtpProtocolException e) {e.printStackTrace();}File file_in = new File(localFile);os = new FileOutputStream(file_in);byte[] bytes = new byte[1024];int c;while ((c = is.read(bytes)) != -1) {os.write(bytes, 0, c);}System.out.println("download success");} catch (IOException ex) {System.out.println("not download");ex.printStackTrace();throw new RuntimeException(ex);} finally {try {if (is != null) {is.close();}} catch (IOException e) {e.printStackTrace();} finally {try {if (os != null) {os.close();}} catch (IOException e) {e.printStackTrace();}}}}/*** 关闭连接*/public void closeConnect() {try {this.ftpClient.close();System.out.println("disconnect success");} catch (IOException ex) {System.out.println("not disconnect");ex.printStackTrace();throw new RuntimeException(ex);}}}测试代码:package test;import java.text.SimpleDateFormat;import com.pifeng.util.FtpUtil;public class TestFtpUtil {public static void main(String agrs[]) {FtpUtil fu=new FtpUtil();String filepath[] = { "AWC1002972G020-1.dwg", "AWC1002974G020-1.cgm" };String localfilepath[] = { "D:\\AWC1002972G020-1.dwg","D:\\AWC1002974G020-1.cgm" };/* * 使用默认的端口号、用户名、密码以及根目录连接FTP服务器*/fu.connectServer("127.0.0.1", 21, "pifeng", "19920720", "/");// 下载for (int i = 0; i < filepath.length; i++) {fu.download(filepath[i], localfilepath[i]);}String localfile = "D:\\WorkToolKit\\PDF\\ReadMe.htm";String remotefile = "ReadMe.htm";// 上传SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");System.out.println(sDateFormat.format(new java.util.Date()));// new Date()为获取当前系统时间fu.upload(localfile, remotefile);System.out.println(sDateFormat.format(new java.util.Date()));// new Date()为获取当前系统时间fu.closeConnect();}}。
JAVA中使用FTPClient实现文件上传下载实例代码
JAVA中使⽤FTPClient实现⽂件上传下载实例代码在java程序开发中,ftp⽤的⽐较多,经常打交道,⽐如说向FTP服务器上传⽂件、下载⽂件,本⽂给⼤家介绍如何利⽤jakarta commons中的FTPClient(在commons-net包中)实现上传下载⽂件。
⼀、上传⽂件原理就不介绍了,⼤家直接看代码吧/*** Description: 向FTP服务器上传⽂件* @Version1.0 Jul 27, 2008 4:31:09 PM by 崔红保(cuihongbao@)创建* @param url FTP服务器hostname* @param port FTP服务器端⼝* @param username FTP登录账号* @param password FTP登录密码* @param path FTP服务器保存⽬录* @param filename 上传到FTP服务器上的⽂件名* @param input 输⼊流* @return 成功返回true,否则返回false*/publicstaticboolean uploadFile(String url,int port,String username, String password, String path, String filename, InputStream input) {boolean success = false;FTPClient ftp = new FTPClient();try {int reply;ftp.connect(url, port);//连接FTP服务器//如果采⽤默认端⼝,可以使⽤ftp.connect(url)的⽅式直接连接FTP服务器ftp.login(username, password);//登录reply = ftp.getReplyCode();if (!FTPReply.isPositiveCompletion(reply)) {ftp.disconnect();return success;}ftp.changeWorkingDirectory(path);ftp.storeFile(filename, input);input.close();ftp.logout();success = true;} catch (IOException e) {e.printStackTrace();} finally {if (ftp.isConnected()) {try {ftp.disconnect();} catch (IOException ioe) {}}}return success;}<pre></pre>/*** Description: 向FTP服务器上传⽂件* @Version1.0 Jul 27, 2008 4:31:09 PM by 崔红保(cuihongbao@)创建* @param url FTP服务器hostname* @param port FTP服务器端⼝* @param username FTP登录账号* @param password FTP登录密码* @param path FTP服务器保存⽬录* @param filename 上传到FTP服务器上的⽂件名* @param input 输⼊流* @return 成功返回true,否则返回false*/public static boolean uploadFile(String url,int port,String username, String password, String path, String filename, InputStream input) {boolean success = false;FTPClient ftp = new FTPClient();try {int reply;ftp.connect(url, port);//连接FTP服务器//如果采⽤默认端⼝,可以使⽤ftp.connect(url)的⽅式直接连接FTP服务器ftp.login(username, password);//登录reply = ftp.getReplyCode();if (!FTPReply.isPositiveCompletion(reply)) {ftp.disconnect();return success;}ftp.changeWorkingDirectory(path);ftp.storeFile(filename, input);input.close();ftp.logout();success = true;} catch (IOException e) {e.printStackTrace();} finally {if (ftp.isConnected()) {try {ftp.disconnect();} catch (IOException ioe) {}}}return success;}下⾯我们写两个⼩例⼦:1.将本地⽂件上传到FTP服务器上,代码如下:@Testpublicvoid testUpLoadFromDisk(){try {FileInputStream in=new FileInputStream(new File("D:/test.txt"));boolean flag = uploadFile("127.0.0.1", 21, "test", "test", "D:/ftp", "test.txt", in); System.out.println(flag);} catch (FileNotFoundException e) {e.printStackTrace();}}<pre></pre>@Testpublic void testUpLoadFromDisk(){try {FileInputStream in=new FileInputStream(new File("D:/test.txt"));boolean flag = uploadFile("127.0.0.1", 21, "test", "test", "D:/ftp", "test.txt", in); System.out.println(flag);} catch (FileNotFoundException e) {e.printStackTrace();}}2.在FTP服务器上⽣成⼀个⽂件,并将⼀个字符串写⼊到该⽂件中@Testpublicvoid testUpLoadFromString(){try {InputStream input = new ByteArrayInputStream("test ftp".getBytes("utf-8")); boolean flag = uploadFile("127.0.0.1", 21, "test", "test", "D:/ftp", "test.txt", input); System.out.println(flag);} catch (UnsupportedEncodingException e) {e.printStackTrace();}}<pre></pre>@Testpublic void testUpLoadFromString(){try {InputStream input = new ByteArrayInputStream("test ftp".getBytes("utf-8")); boolean flag = uploadFile("127.0.0.1", 21, "test", "test", "D:/ftp", "test.txt", input); System.out.println(flag);} catch (UnsupportedEncodingException e) {e.printStackTrace();}}⼆、下载⽂件从FTP服务器下载⽂件的代码也很简单,参考如下:/*** Description: 从FTP服务器下载⽂件* @Version. Jul , :: PM by 崔红保(cuihongbao@)创建* @param url FTP服务器hostname* @param port FTP服务器端⼝* @param username FTP登录账号* @param password FTP登录密码* @param remotePath FTP服务器上的相对路径* @param fileName 要下载的⽂件名* @param localPath 下载后保存到本地的路径* @return*/publicstaticboolean downFile(String url, int port,String username, String password, String remotePath,String fileName,String localPath) { boolean success = false;FTPClient ftp = new FTPClient();try {int reply;ftp.connect(url, port);//如果采⽤默认端⼝,可以使⽤ftp.connect(url)的⽅式直接连接FTP服务器ftp.login(username, password);//登录reply = ftp.getReplyCode();if (!FTPReply.isPositiveCompletion(reply)) {ftp.disconnect();return success;}ftp.changeWorkingDirectory(remotePath);//转移到FTP服务器⽬录FTPFile[] fs = ftp.listFiles();for(FTPFile ff:fs){if(ff.getName().equals(fileName)){File localFile = new File(localPath+"/"+ff.getName());OutputStream is = new FileOutputStream(localFile);ftp.retrieveFile(ff.getName(), is);is.close();}}ftp.logout();success = true;} catch (IOException e) {e.printStackTrace();} finally {if (ftp.isConnected()) {try {ftp.disconnect();} catch (IOException ioe) {}}}return success;}<pre></pre>。
使用递归方法实现,向FTP服务器上传整个目录结构、从FTP服务器下载整个目录到本地的功能
使用递归方法实现,向FTP服务器上传整个目录结构、从FTP 服务器下载整个目录到本地的功能我最近由于在做一个关于FTP文件上传和下载的功能时候,发现Apache FTP jar包没有提供对整个目录结构的上传和下载功能,只能非目录类型的文件进行上传和下载操作,后来我查阅很多网上的实现方法,再结合自己的理解、以及符合自己的需求,完成了我自己的apache FTP jar包补充类。
上面是背景,基本叙述完毕,下面开始介绍实现方法和代码。
一。
环境搭建:1.使用的FileZilla Server开源免费软件,安装过后建立的本地FTP服务器。
2.使用的apache上下载FTP工具包,引用到工程目录中。
3.IDE,Eclipse,JDK6二。
介绍代码。
上传和下载目录的实现原理:对每一个层级的目录进行判断,是为目录类型、还是文件类型。
如果为目录类型,采用递归调用方法,检查到最底层的目录为止结束。
如果为文件类型,则调用上传或者下载方法对文件进行上传或者下载操作。
贴出代码:(其中有些没有代码,可以看看,还是很有用处的)[java]view plaincopyprint?1.package com.ftp;2.3.import java.io.File;4.import java.io.FileInputStream;5.import java.io.FileOutputStream;6.import java.io.IOException;7.import java.io.InputStream;8.import java.io.OutputStream;9.import .SocketException;10.11.import .ftp.FTP;12.import .ftp.FTPClient;13.import .ftp.FTPClientConfig;14.import .ftp.FTPFile;15.import .ftp.FTPReply;16.17.public class RemoteFtpProcess extends FTPClient {18.private static FTPClient ftpClient = new FTPClient();19.20./**21.* 本方法用户登录远程的FTP服务器22.*23.* @param url :表示FTP的IP地址24.* @param port :FTP服务器端口,默认端口为2125.* @param userName :登录FTP的用户名26.* @param password :登录FTP的密码27.*28.* @return FTPClient:返回为FTPClient对象29.*/30.public FTPClient loginFtp(String url, int port, String us erName,31.String password) {32.try {33.ftpClient.connect(url, port);34.ftpClient.setControlEncoding("UTF-8");35.FTPClientConfig ftpConfig = new FTPClientConfig(FTP ClientConfig.SYST_NT);36.ftpConfig.setServerLanguageCode("zh");37.ftpClient.login(userName, password);38.int reply = 0;39.reply = ftpClient.getReplyCode();40.System.out.println(reply);41.if (FTPReply.isPositiveCompletion(reply)) {42.System.out.println("登录成功!");43.} else {44.System.out.println("登录失败!");45.}46.} catch (SocketException e) {47. e.printStackTrace();48.} catch (IOException e) {49. e.printStackTrace();50.}51.return ftpClient;52.}53.54./**55.* @param ftpc :退出FTP登录56.* @return boolean :是否已经关闭连接57.*58.* @throws IOException59.*/60.public static boolean closeConnections(FTPClient ftpc)throws IOException {61.boolean bool = false;62.ftpc.logout();63.return bool;64.}65.66./**67.* 方法用于上传文件到FTP服务器的指定文件夹中68.*69.* @param fileName :上传文件的名称70.* @param input :上传文件的输入流对象71.* @param toFtpPath :上传到FTP的目的路径72.*73.* @return boolean:表示上传是否成功74.*75.*/76.public boolean uploadFileToFtp(String fileName, Input Stream input,77.String toFtpPath) {78.boolean bool = false;79.try {80.// 使得能够处理中文编码81.fileName = new String(fileName.getBytes("GBK"), "ISO -8859-1");82.toFtpPath = new String(toFtpPath.getBytes("GBK"), "IS O-8859-1");83.// 转到上传文件的FTP目录中84.ftpClient.changeWorkingDirectory(toFtpPath);85.// 设置处理文件的类型为字节流的形式86.ftpClient.setFileType(FTP.BINARY_FILE_TYPE);87.// 如果缺省该句传输txt正常但图片和其他格式的文件传输出现乱码88.ftpClient.storeFile(fileName, input);89.input.close();90.bool = true;91.} catch (IOException e) {92.bool = false;93. e.printStackTrace();94.}95.return bool;96.}97.98./**99.* 方法用于从FTP服务器中下载文件100.*101.* @param ftpUrl :下载文件所处FTP中路径102.* @param fileName :下载的文件名称103.* @param outputSream :下载文件的输出流对象104.*105.* @return boolean :表示是否上传成功106.*107.*/108.public boolean downloadFileFromFtp(String ftpUrl, Str ing fileName,109.OutputStream outputStream) {110.boolean bool = false;111.try {112.ftpClient.changeWorkingDirectory(ftpUrl);113.FTPFile[] ftpFile = ftpClient.listFiles();114.for (int i = 0; i < ftpFile.length; i++) {115.if (fileName.equals(ftpFile[i].getName())) {116.ftpClient.retrieveFile(new String(ftpFile[i].getName() 117..getBytes("GBK"), "ISO-8859-1"), outputStream);118.outputStream.flush();119.outputStream.close();120.}121.}122.bool = true;123.} catch (IOException e) {124. e.printStackTrace();125.bool = false;126.}127.return bool;128.}129.130./**131.* 方法用户删除FTP上的指定的文件132.*133.* @param fileUrl :文件在FTP中的路径134.* @param fileName :文件的名称135.*136.* @return boolean:删除是否成功137.*/138.public boolean deleteFileOnFtp(String fileUrl, String fil eName) {139.boolean bool = false;140.try {141.ftpClient.changeWorkingDirectory(fileUrl);142.FTPFile[] ftpFiles = ftpClient.listFiles();143.System.out.println(ftpFiles.length);144.for (int i = 0; i < ftpFiles.length; i++) {145.if (fileName.equals(ftpFiles[i].getName())) {146.ftpClient.deleteFile(fileName);147.}148.}149.} catch (IOException e) {150. e.printStackTrace();151.}152.return bool;153.}154.155./**156.* 判断指定文件中是否存在相同名称的文件157.*158.* @param remotePath :FTP上的远程目录159.* @param fileName:文件名称160.* @return boolean :判断是否存在相同名称161.*162.*/163.public boolean isSameName(String remotePath, String fileName) {164.boolean bool = false;165.try {166.FTPFile[] ftpFiles = ftpClient.listFiles();167.System.out.println(ftpFiles.length);168.ftpClient.changeWorkingDirectory(remotePath);169.for (int i = 0; i < ftpFiles.length; i++) {170.if (fileName.equals(ftpFiles[i].getName())) {171.System.out.println("存在和指定文件相同名称的文件");172.bool = true;173.} else {174.bool = false;175.}176.}177.} catch (Exception e) {178.bool = false;179.}180.return bool;181.}182.183./**184.* 更改文件名称185.*186.*/187.public String changeName(String remotePath, String fi leName, String newName) {188.if (isSameName(remotePath, fileName)) {189.fileName = fileName + "." + newName;190.}191.return fileName;192.}193.194.195.public static void newFileOnFTP(String pathName){ 196.try {197.ftpClient.mkd(pathName);198.} catch (IOException e) {199. e.printStackTrace();200.}201.}202.203.//上传整个目录到FTP的指定目录中204.public void uploadDirFiles(String dirPath,String toRem otePath) throws IOException{205.if (dirPath!=null && !dirPath.equals("")) {206.//建立上传目录的File对象207.File dirFile = new File(dirPath);208.//判断File对象是否为目录类型209.if (dirFile.isDirectory()) {210.//如果是目录类型。
java 不同系统之间传输数据的方法
java 不同系统之间传输数据的方法Java是一种强大且广泛应用的编程语言,用于开发各种类型的应用程序。
在实际开发中,经常需要在不同的系统之间传输数据。
本文将介绍一些常用的方法来实现Java不同系统之间的数据传输。
1. 使用Socket通信Socket通信是一种常用的网络通信方式,可以实现不同系统之间的数据传输。
通过Socket,我们可以在客户端和服务器之间建立一条双向通道进行数据交换。
在Java中,可以使用Java的原生Socket库来实现Socket通信。
客户端和服务器端通过准确的IP地址和端口号来建立连接。
客户端可以使用Socket类来与服务器进行通信,而服务器则使用ServerSocket类监听并接受客户端连接。
2. 使用HTTP协议HTTP协议是一种应用层协议,常用于Web应用程序中。
通过HTTP协议,不同系统之间可以通过发送和接收HTTP请求和响应来进行数据传输。
在Java中,可以使用Java的HttpURLConnection类或者第三方库,如Apache 的HttpClient来实现HTTP通信。
通过发送HTTP请求,可以将数据以请求参数或JSON/XML等格式发送到目标系统,并接收目标系统的HTTP响应。
3. 使用WebServiceWebService是一种通过网络进行通信的软件系统。
它可以使不同系统之间的应用程序通过Web服务接口进行数据传输和交互。
在Java中,可以使用Java的JAX-WS和JAX-RPC等API来开发和使用WebService。
通过定义WebService接口和实现相应的服务端和客户端,可以在不同系统之间轻松地传输数据。
4. 使用消息队列消息队列是一种常用的异步通信方式,允许不同系统之间以消息的形式传递数据。
消息队列将数据发送方发送的消息存储在队列中,接收方从队列中接收并处理消息。
在Java中,可以使用ActiveMQ、RabbitMQ等消息中间件来实现消息队列。
java实现文件上传和下载
java实现⽂件上传和下载本⽂实例为⼤家分享了java实现⽂件上传和下载的具体代码,供⼤家参考,具体内容如下⽂件的上传upload:⽂件上传客户端通过表单的⽂件域file 把客户端的⽂件上传保存到服务器的硬盘上页⾯⾸先对上传的表单有以下要求:必须有⽂件域:input type=file表单提交⽅式:method=post表单的 enctype=multipart/form-data<form method="post" action="/user/regist" enctype="multipart/form-data"><table style="border: chartreuse;solid:2px"><tr><th>⽤户名</th><td><input type="text" name="username"></td></tr><tr><th>密码</th><td><input type="password" name="password"></td></tr><tr><th>⽤户头像</th><td><input type="file" name="photo"> </td></tr><tr><td colspan="2"><input type="submit" value="提交"></td></tr></table></form>Servlet1)⾸先要导⼊以下两个jar包,通过commons-fileupload实现⽂件上传2)创建⼀个⼯⼚对象DiskFileItemFactory,在创建⼀个多部件表单解析器ServletFileUpload,构造⽅法传⼊⼯⼚对象3)解析器解析请求对象,获得⼀个list集合,其中list集合存储的是⼀个⼀个的fileItem对象,⼀个fileItem对应⼀个组件,也就是⼀个<input>4) 遍历集合⽤isFormField()⽅法判断是否为普通组件,然后着重处理⽂件域组件5)获取⽂件名,并⽤getRealPath⽅法获取服务器上传⽂件所在路径,创建新⽂件夹6)获取输⼊流和创建输出流,进⾏⽂件的读写@WebServlet(value = "/user/regist")public class UploadServlet extends HttpServlet {protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {//创建⼀个⼯⼚对象DiskFileItemFactory factory = new DiskFileItemFactory();//创建⼀个多部件解析器对象ServletFileUpload fileUpload = new ServletFileUpload(factory);User user = new User();FileOutputStream out=null;try {//⽤解析器对象解析请求,返回⼀个FileItem类型的集合List<FileItem> list = fileUpload.parseRequest(req);for (FileItem fileItem : list) {/*** fileItem.getFieldName());:::获取组件的name值* fileItem.getName());::::获取⽂件域的⽂件名* fileItem.getSize());::::获取数据的字节个数* fileItem.getString());::::获取数据的字符串* fileItem.isFormField());:::判断是否为普通组件*///判断部件是否为普通组件if (fileItem.isFormField()) {//普通组件//获取组件名字也就是name的值String fieldName = fileItem.getFieldName();//获取组件的值也就是value的值String value = fileItem.getString("utf-8");if ("username".equals(fieldName)) { //设置实体类的属性user.setUsername(value);} else if ("password".equals(fieldName)) {user.setPassword(value);}} else {// ⽂件域//获取⽂件名String fielName = fileItem.getName();//输⼊流来读数据InputStream in = fileItem.getInputStream();//设置⽂件写出的路径,并⽤随机码来保证图⽚可以重复String path=req.getServletContext().getRealPath("/imgs/"+ UUID.randomUUID()+fielName);System.out.println("⽂件路径为:"+path);File file = new File(path);out = new FileOutputStream(file);//利⽤commons-io-1.4.jar的IOUtils的copy⽅法直接实现⽂件的复制IOUtils.copy(in,out);user.setPhoto(file.getName());}}} catch (Exception e) {e.printStackTrace();}finally {if(out!=null){out.close();}}req.getSession().setAttribute("user",user);req.getRequestDispatcher("/sucess.jsp").forward(req,resp);}}⽂件的下载页⾯只需⼀个超链接,传需要下载的⽂件名,或者直接输⼊路径在浏览器例: <a href="<c:url value='/file/download?fileName=14.jpg'/>" >狗狗1</a><br/>Servlet1)接收参数,获取⽂件名2)获取imgs的路径,也就是存储⽂件的⽂件夹的路径,然后创建⽂件,传⼊该路径和⽂件名3)创建输⼊流读取⽂件4)设置响应头,⾸先根据⽂件名字获取⽂件的⼤类型,设置响应头Content-Type指定响应的类型;设置响应头Content-Disposition,指定⽂件以附件形式保存到本地磁盘5)⽤响应获取输出流,读出⽂件到客户端@WebServlet("/user/download")public class DownloadServlet extends HttpServlet {protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {request.setCharacterEncoding("UTF-8");//获取要下载的⽂件名String fileName = request.getParameter("fileName");System.out.println(fileName);//获取服务器中存储图⽚的⽂件夹的路径String path1 = request.getServletContext().getRealPath("/imgs");String path=path1+"/"+fileName;File file = new File(path);//创建输⼊流读⽂件FileInputStream in = new FileInputStream(file);//通过⽂件名字获取⽂件的⼤类型String type = request.getServletContext().getMimeType(fileName);//设置响应头ContentType指定响应内容的类型response.setHeader("Content-type",type);//设置响应头Content-Disposition 指定以附件形式保存响应的信息response.setHeader("Content-Disposition","attachment;filename="+(URLEncoder.encode(fileName, "utf-8"))); ServletOutputStream out = response.getOutputStream();//实现⽂件的读写IOUtils.copy(in,out);if(in!=null){in.close();}}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
18.Javaweb中文件的上传和下载【重要】
18.Javaweb中⽂件的上传和下载【重要】Javaweb中⽂件的上传和下载⽂件上传⽂件上传指的是⽤户通过浏览器向服务器上传某个⽂件,服务器接收到该⽂件后会将该⽂件存储在服务器的硬盘中,通常不会存储在数据库中,这样可以减轻数据库的压⼒并且在⽂件的操作上更加灵活,常见的功能是上传头像图⽚。
⽂件上传的原理所谓的⽂件上传就是服务器端通过request对象获取输⼊流,将浏览器端上传的数据读取出来,保存到服务器端。
⽂件上传的要求提供form表单,表单的提交⽅式必须是post【get请求装不下那么多】form表单中的enctype属性必须是 multipart/form-data 【照着做就⾏】表单中提供input type=”file”上传输⼊域 【⽂件那个表单】先来个表单:<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title></head><body><figure><img src=""></figure><form action="#" method="post" accept-charset="utf-8" enctype="multipart/form-data"> <!--# 提交地址记得改!--><input type="file" name="photo"><br><input type="submit" value="上传头像"></form></body></html>来个Servlet来接收⼀下这个图⽚:package upload;import java.io.IOException;import java.io.InputStream;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;/*** ⽂件上传例⼦*/public class file extends HttpServlet {protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//获取请求的输⼊流InputStream is = request.getInputStream();//读取输⼊流中的数据int leng = 0;byte[] bytes = new byte[1024];while ((leng = is.read(bytes)) != -1) {//先打印控制台看看System.out.println(new String(bytes,0,leng));}}}打印出来的数据:------WebKitFormBoundarypM4ZEsxzVdl0NfZVContent-Disposition: form-data; name="photo"; filename="4-2 鍥剧墖鍒囨崲鏁堟灉[20210508-164643].jpg"Content-Type: image/jpeg反正⼀堆乱码但是头部我们是看的懂的就是⼀些标签的属性和上传的照⽚名字!和⽂件类型!如何解决?请看:FileUpload⼯具的使⽤在实际开发中通常会借助第三⽅⼯具来实现上传功能,应⽤较多的是apache旗下的Commons-fileupload。
java实现连接ftp服务器并下载文件到本地
java实现连接ftp服务器并下载⽂件到本地1.pom.xml引⼊jar包<!--ftp--><dependency><groupId>commons-net</groupId><artifactId>commons-net</artifactId><version>3.6</version></dependency>2.连接ftp服务器⽅法/*** 连接ftp服务器* @param ip ftp地址* @param port 端⼝* @param username 账号* @param password 密码* @return* @throws IOException*/public static FTPClient ftpConnection(String ip,String port, String username, String password) throws IOException {FTPClient ftpClient = new FTPClient();try {ftpClient.connect(ip, Integer.parseInt(port));ftpClient.login(username, password);int replyCode = ftpClient.getReplyCode(); //是否成功登录服务器if(!FTPReply.isPositiveCompletion(replyCode)) {ftpClient.disconnect();logger.error("--ftp连接失败--");System.exit(1);}ftpClient.enterLocalPassiveMode();//这句最好加告诉对⾯服务器开⼀个端⼝ftpClient.setFileType(FTP.BINARY_FILE_TYPE);ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);} catch (SocketException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return ftpClient;}3.断开ftp服务⽅法/*** 断开FTP服务器连接* @param ftpClient 初始化的对象* @throws IOException*/public static void close(FTPClient ftpClient) throws IOException{if(ftpClient!=null && ftpClient.isConnected()){ftpClient.logout();ftpClient.disconnect();}}4.下载ftp服务器知道路径的⽂件到本地⽅法/*** 下载ftp服务器⽂件⽅法* @param ftpClient FTPClient对象* @param newFileName 新⽂件名* @param fileName 原⽂件(路径+⽂件名)* @param downUrl 下载路径* @return* @throws IOException*/public static boolean downFile(FTPClient ftpClient, String newFileName, String fileName, String downUrl) throws IOException {boolean isTrue = false;OutputStream os=null;File localFile = new File(downUrl + "/" + newFileName);if (!localFile.getParentFile().exists()){//⽂件夹⽬录不存在创建⽬录localFile.getParentFile().mkdirs();localFile.createNewFile();}os = new FileOutputStream(localFile);isTrue = ftpClient.retrieveFile(new String(fileName.getBytes(),"ISO-8859-1"), os);os.close();return isTrue;}5.调⽤测试mainpublic static void main(String[] args) throws IOException{FTPClient ftpClient = this.ftpConnection("172.*.*.*","*","username","password");boolean flag = downFile(ftpClient,"⽂件名","/路径/+⽂件名","本地路径"); close(ftpClients);System.out.println(flag );//flag=true说明下载成功}。
Java通用文件上传功能实现
Java通用文件上传功能实现一、文件上传流程说明:Java文件上传功能是指在Java开发中,实现文件上传的功能,可以用于各种场景,如网站上传图片、文件管理系统等。
以下是一种常见的实现方式:1、创建一个包含文件上传功能的表单页面,用户可以选择要上传的文件并提交表单。
2、在后端Java代码中,接收表单提交的文件数据。
可以使用Apache Commons FileUpload库或Spring框架提供的MultipartFile类来处理文件上传。
3、对接收到的文件进行处理,可以将文件保存到服务器的指定位置,或者将文件存储到数据库中。
4、返回上传成功或失败的信息给用户。
二、代码实现,方案一:在Java中实现文件上传功能可以通过以下步骤来完成:1、创建一个HTML表单,用于选择要上传的文件:<form action="upload"method="post" enctype="multipart/form-data"> <input type="file" name="file" /><input type="submit" value="Upload" /></form>2、创建一个Servlet或者Controller来处理文件上传请求:@WebServlet("/upload")public class UploadServlet extends HttpServlet {protected void doPost(HttpServletRequest request, HttpServletResponse response) {// 获取上传的文件Part filePart = request.getPart("file");String fileName = filePart.getSubmittedFileName();// 指定上传文件的保存路径String savePath = "C:/uploads/" + fileName;// 将文件保存到指定路径filePart.write(savePath);// 返回上传成功的消息response.getWriter().println("File uploaded successfully!");}}3、配置web.xml(如果使用传统的Servlet方式)或者使用注解(如果使用Servlet 3.0+)来映射Servlet。
java连接FTP上传和下载文件
package .yxjx.pub;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Properties;import mons.io.FileUtils;import .ftp.FTP;import .ftp.FTPClient;import .ftp.FTPClientConfig;import .ftp.FTPFile;import .ftp.FTPReply;public class FTPHandle {private String username;private String password;private String ip;private int port;private Properties property = null;// 配置private String configFile;// 配置文件的路径名private FTPClient ftpClient = null;private String filedir = "";// FTP文件路径private final String[] FILE_TYPES = { "文件", "目录", "符号链接", "未知类型" };private static SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd hh:mm");* 设置参数** @param configFile* --参数的配置文件*/private void setArg(String configFile) {property = new Properties();BufferedInputStream inBuff = null;try {inBuff = new BufferedInputStream(this.getClass().getResourceAsStream(configFile));property.load(inBuff);username = property.getProperty("username");password = property.getProperty("password");ip = property.getProperty("ip");port = Integer.parseInt(property.getProperty("port"));filedir = property.getProperty("filedir");} catch (Exception e) {e.printStackTrace();} finally {try {if (inBuff != null)inBuff.close();} catch (Exception e) {e.printStackTrace();}}}/*** 设置FTP客服端的配置--一般可以不设置** @return*/private FTPClientConfig getFtpConfig() {FTPClientConfig ftpConfig = new FTPClientConfig(FTPClientConfig.SYST_UNIX);ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING);return ftpConfig;}/*** 连接到服务器public void connectServer() {if (ftpClient == null) {int reply;try {setArg(configFile);ftpClient = new FTPClient();// ftpClient.configure(getFtpConfig());ftpClient.connect(ip);ftpClient.login(username, password);ftpClient.setDefaultPort(port);System.out.print(ftpClient.getReplyString());reply = ftpClient.getReplyCode();if (!FTPReply.isPositiveCompletion(reply)) {ftpClient.disconnect();System.err.println("FTP server refused connection.");}} catch (Exception e) {System.err.println("登录ftp服务器【" + ip + "】失败");e.printStackTrace();}}}/*** 进入到服务器的某个目录下** @param directory*/public void changeWorkingDirectory() {try {ftpClient.changeWorkingDirectory(filedir);} catch (IOException ioe) {ioe.printStackTrace();}}/*** 上传文件** @param inputStream--文件输入流* @param newFileName--新的文件名*/public void uploadFile(InputStream inputStream, String newFileName) { changeWorkingDirectory();// 进入文件夹// 上传文件BufferedInputStream buffIn = null;try {buffIn = new BufferedInputStream(inputStream);ftpClient.storeFile(newFileName, buffIn);} catch (Exception e) {e.printStackTrace();} finally {try {if (buffIn != null)buffIn.close();} catch (Exception e) {e.printStackTrace();}}}/*** 列出服务器上文件和目录** @param regStr* --匹配的正则表达式*/@SuppressWarnings("unchecked")public List listRemoteFiles(String regStr) {List list = new ArrayList();try {FTPFile[] files = ftpClient.listFiles(regStr);if (files == null || files.length == 0) {System.out.println("There has not any file!");return null;} else {for (FTPFile file : files) {if (file != null) {Map map = new HashMap();String filename = file.getName();int filenamelen = filename.length();if(filenamelen>4){String filetype = filename.substring(filenamelen-3);if("txt".equals(filetype)){String name = file.getName();name = name.substring(0,name.length()-4);map.put("filename", name);map.put("filesize",FileUtils.byteCountToDisplaySize(file.getSize()));map.put("scsj",dateFormat.format(file.getTimestamp().getTime()));list.add(map);}}}}}} catch (Exception e) {e.printStackTrace();}return list;}/*** 下载文件* @param remoteFileName --服务器上的文件名* @param localFileName--本地文件名*/public void loadFile(String remoteFileName,String localFileName){//下载文件BufferedOutputStream buffOut=null;try{buffOut=new BufferedOutputStream(new FileOutputStream(localFileName));ftpClient.retrieveFile(remoteFileName, buffOut);}catch(Exception e){e.printStackTrace();}finally{try{if(buffOut!=null)buffOut.close();}catch(Exception e){e.printStackTrace();}}}/*** 删除文件*/public void deleteFile(String filename){try{ftpClient.deleteFile(filename);}catch(IOException ioe){ioe.printStackTrace();}}/*** 关闭连接*/public void closeConnect(){try{if(ftpClient!=null){ftpClient.logout();ftpClient.disconnect();System.out.println("Ftp have closed");}}catch(Exception e){e.printStackTrace();}}public String getConfigFile() {return configFile;}public void setConfigFile(String configFile) { this.configFile = configFile;}public String[] getFILE_TYPES() {return FILE_TYPES;}public FTPClient getFtpClient() {return ftpClient;}public void setFtpClient(FTPClient ftpClient) { this.ftpClient = ftpClient;}public String getIp() {return ip;}public void setIp(String ip) {this.ip = ip;}public String getPassword() {return password;}public void setPassword(String password) { this.password = password;}public int getPort() {return port;}public void setPort(int port) {this.port = port;}public Properties getProperty() {return property;}public void setProperty(Properties property) { this.property = property;}public String getUsername() {return username;}public void setUsername(String username) { ername = username;}public String getFiledir() {return filedir;}public void setFiledir(String filedir) {this.filedir = filedir;}}。
Java使用SFTP和FTP两种连接方式实现对服务器的上传下载【我改】
Java使⽤SFTP和FTP两种连接⽅式实现对服务器的上传下载【我改】【】如何区分是需要使⽤SFTP还是FTP?【】我觉得:1、看是否已知私钥。
SFTP 和 FTP 最主要的区别就是 SFTP 有私钥,也就是在创建连接对象时,SFTP 除了⽤户名和密码外还需要知道私钥 privateKey ,如果有私钥那么就⽤ SFTP,否则就是⽤ FTP。
2、看端⼝号。
如果端⼝号是21,那么就⽤FTP,否则就⽤ SFTP===============转:Java使⽤SFTP和FTP两种连接⽅式实现对服务器的上传下载 <dependency><groupId>com.jcraft</groupId><artifactId>jsch</artifactId><version>0.1.54</version></dependency>2、SFTPUtil⼯具类:import java.io.ByteArrayInputStream;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;import mons.io.IOUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import com.jcraft.jsch.Channel;import com.jcraft.jsch.ChannelSftp;import com.jcraft.jsch.JSch;import com.jcraft.jsch.JSchException;import com.jcraft.jsch.Session;import com.jcraft.jsch.SftpException;/*** 类说明 sftp⼯具类*/public class SFTPUtil {private transient Logger log = LoggerFactory.getLogger(this.getClass());private ChannelSftp sftp;private Session session;/** SFTP 登录⽤户名*/private String username;/** SFTP 登录密码*/private String password;/** 私钥 */private String privateKey;/** SFTP 服务器地址IP地址*/private String host;/** SFTP 端⼝*/private int port;/*** 构造基于密码认证的sftp对象*/public SFTPUtil(String username, String password, String host, int port) {ername = username;this.password = password;this.host = host;this.port = port;}/*** 构造基于秘钥认证的sftp对象*/public SFTPUtil(String username, String host, int port, String privateKey) {ername = username;this.host = host;this.port = port;this.privateKey = privateKey;}public SFTPUtil(){}/*** 连接sftp服务器*/public void login(){try {JSch jsch = new JSch();if (privateKey != null) {jsch.addIdentity(privateKey);// 设置私钥}session = jsch.getSession(username, host, port);if (password != null) {session.setPassword(password);}Properties config = new Properties();config.put("StrictHostKeyChecking", "no");session.setConfig(config);session.connect();Channel channel = session.openChannel("sftp");channel.connect();sftp = (ChannelSftp) channel;} catch (JSchException e) {e.printStackTrace();}}/*** 关闭连接 server*/public void logout(){if (sftp != null) {if (sftp.isConnected()) {sftp.disconnect();}}if (session != null) {if (session.isConnected()) {session.disconnect();}}}/*** 将输⼊流的数据上传到sftp作为⽂件。
基于JAVA的FTP文件传输系统设计与开发(课程设计)
类型:课程设计基于JA V A的FTP文件传输系统设计与开发引言FTP(File Transfer Protocol)是文件传输协议的简称。
FTP 的主要作用,就是让用户连接上一个远程计算机(这些计算机上运行着FTP服务器程序)查看远程计算机有哪些文件,然后把文件从远程计算机上拷到本地计算机,或把本地计算机的文件送到远程计算机去。
目前FTP服务器软件都为国外作品,例如Server_U、IIS,国内成熟的FTP服务器软件很少,有一些如(Crob FTP Se rver),但从功能上看来远不能和那些流行的服务器软件媲美。
下面对这些软件简单的做一个比较:IIS只适用于NT/2000/XPWindows操作系统,适合建个小型的同时在线用户数不超过10个的FTP服务器。
它对账户的管理按照Windows用户账户方式进行;比起IIS来,Server_U的管理功能强大得多,而且设置也很方便。
它是一款由Rob Beckers开发的获奖的FTP服务器软件,它功能强大又易于使用,支持9x/ME/NT/2K 等全Windows系列。
FTP服务器用户通过它用FTP协议能在internet上共享文件。
Serv-U不仅100%遵从通用FTP标准,也包括众多的独特功能可为每个用户提供文件共享完美解决方案。
它并不是简单地提供文件的下载,还为用户的系统安全提供了相当全面的保护。
例如:您可以为您的 FTP 设置密码、设置各种用户级的访问许可等等;而Crob FTP Server从功能设置上可以看出,它沿用了像Server_U等主流FTP服务器软件的基本设置;并加入了不少人性化的功能;同时支持多服务器。
(即在软件中可以在任意的有效端口上建立任意多的FTP服务器并可同时运行,各服务器间互不相干的稳定运行)应该说进步是非常大的。
并且可以应用于Windows 95/98/ME/me/N/T2000及最新的.NET操作系统上。
不过,纵观上面这些软件,它们都只能在Windows操作系统中运行,并且功能过于强大,许多功能应用于我们的考试系统的话,并没有太大的意义,而且有些也没必要,于是就需要一个专用的,而且也能通用(应用于UNIX等其他的操作系统)的FTP服务器。
java实现文件上传和下载
文件上传在web应用中非常普遍,要在jsp环境中实现文件上传功能是非常容易的,因为网上有许多用java开发的文件上传组件,本文以commons-fileupload组件为例,为jsp应用添加文件上传功能。
common-fileupload组件是apache的一个开源项目之一,可以从/commons/fileupload/(/commons/fileupload/)下载。
用该组件可实现一次上传一个或多个文件,并可限制文件大小。
代码下载后解压zip包,将commons-fileupload-1.0.jar复制到tomcat的webapps你的webappWEB-INFlib下,目录不存在请自建目录。
新建一个servlet: Upload.java用于文件上传:import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;import mons.fileupload.*;public class Upload extends HttpServlet {private String uploadPath = "C:upload"; // 上传文件的目录private String tempPath = "C:uploadtmp"; // 临时文件目录public void doPost(HttpServletRequest request, HttpServletResponse response)throws IOException, ServletException{}}在doPost()方法中,当servlet收到浏览器发出的Post请求后,实现文件上传。
以下是示例代码:public void doPost(HttpServletRequest request, HttpServletResponse response)throws IOException, ServletException{try {DiskFileUpload fu = new DiskFileUpload();// 设置最大文件尺寸,这里是4MBfu.setSizeMax(4194304);// 设置缓冲区大小,这里是4kbfu.setSizeThreshold(4096);// 设置临时目录:fu.setRepositoryPath(tempPath);// 得到所有的文件:List fileItems = fu.parseRequest(request);Iterator i = fileItems.iterator();// 依次处理每一个文件:while(i.hasNext()) {FileItem fi = (FileItem)i.next();// 获得文件名,这个文件名包括路径:String fileName = fi.getName();// 在这里可以记录用户和文件信息// 写入文件,暂定文件名为a.txt,可以从fileName中提取文件名:fi.write(new File(uploadPath + "a.txt"));}}catch(Exception e) {// 可以跳转出错页面}}如果要在配置文件中读取指定的上传文件夹,可以在init()方法中执行:public void init() throws ServletException {uploadPath = ....tempPath = ....// 文件夹不存在就自动创建:if(!new File(uploadPath).isDirectory())new File(uploadPath).mkdirs();if(!new File(tempPath).isDirectory())new File(tempPath).mkdirs();}编译该servlet,注意要指定classpath,确保包含commons-upload-1.0.jar和tomcatcommonlibservlet-api.jar。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
ex.printStackTrace();
throw new RuntimeException(ex);
}
}
/**
* 关闭连接
* @author 周玲斌
* @date 2012-7-11
*/
public void closeConnect() {
try {
ftpClient.closeServer();
System.out.println("disconnect success");
* 远程文件名
*/
private String remotefilename;
/**
* FTP客户端
*/
private FtpClient ftpClient;
/**
* 服务器连接
* @param ip 服务器IP
Ftp fu = new Ftp();
/*
* 使用默认的端口号、用户名、密码以及根目录连接FTP服务器
this.localfilename = localFile;
this.remotefilename = remoteFile;
TelnetOutputStream os = null;
FileInputStream is = null;
//获取远程机器上的文件filename,借助TelnetInputStream把该文件传送到本地。
is = ftpClient.get(remoteFile);
File file_in = new File(localFile);
public void connectServer(String ip, int port, String user,
String password, String path) {
try {
/* ******连接服务器的两种方法*******/
* @param port 服务器端口
* @param user 用户名
* @param password 密码
* @param path 服务器路径
* @author 周玲斌
* @date 2012-7-11
*/
try {
//将远程文件加入输出流中
os = ftpClient.put(this.remotefilename);
//获取本地文件的输入流
File file_in = new File(this.localfilename);
os = new FileOutputStream(file_in);
byte[] bytes = new byte[1024];
int c;
while ((c = is.read(bytes)) != -1) {
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(os != null){
ex.printStackTrace();
throw new RuntimeException(ex);
} finally{
try {
if(is != null){
is.close();
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String agrs[]) {
String filepath[] = { "/temp/aa.txt", "/temp/regist.log"};
String localfilepath[] = { "C:\\tmp\\1.txt","C:\\tmp\\2.log"};
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(os != null){
}
}
/**
* 上传文件
* @param localFile 本地文件
* @param remoteFile 远程文件
* @author 周玲斌
* @date 2012-7-11
*/
public void upload(String localFile, String remoteFile) {
//第一种方法
// ftpClient = new FtpClient();
// ftpClient.openServer(ip, port);
//第二种方法
ftpClient = new FtpClient(ip);
is = new FileInputStream(file_in);
//创建一个缓冲区
byte[] bytes = new byte[1024];
int c;
while ((c = is.read(bytes)) != -1) {
os.write(bytes, 0, c);
}
System.out.println("download success");
} catch (IOException ex) {
System.out.println("not download");
import java.io.FileOutputStream;
import java.io.IOException;
import .TelnetInputStream;
import .TelnetOutputStream;
import .ftp.FtpClient;
os.write(bytes, 0, c);
}
System.out.println("upload success");
} catch (IOException ex) {
System.out.println("not upload");
}
}
}
/**
* 下载文件
* @param remoteFile 远程文件路径(服务器端)
* @param localFile 本地文件路径(客户端)
* @author 周玲斌
* @date 2012-7-11
if (path.length() != 0){
//把远程系统上的目录切换到参数path所指定的目录
ftpClient.cd(path);
}
ftpClient.binary();
实现FTP文件上传与下载可以通过以下两种种方式实现(不知道还有没有其他方式),分别为:1、通过JDK自带的API实现;2、通过Apache提供的API是实现。
第一种方式
package com.cloudpower.util;
import java.io.File;
import java.io.FileInputStream;
/**
* Java自带的API对FTP的操作
* @Title:Ftp.java
* @author: 周玲斌
*/
public class F/
private String localfilename;
/**
ex.printStackTrace();
throw new RuntimeException(ex);
} finally{
try {
if(is != null){
is.close();
ftpClient.login(user, password);
// 设置成2进制传输
ftpClient.binary();
System.out.println("login success!");
*/
public void download(String remoteFile, String localFile) {
TelnetInputStream is = null;
FileOutputStream os = null;
try {
} catch (IOException ex) {
System.out.println("not disconnect");
ex.printStackTrace();
throw new RuntimeException(ex);
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}