java网络文件传输的实现
Java多方式实现文件上传
在Struts 2中实现文件上传前一阵子有些朋友在电子邮件中问关于Struts 2实现文件上传的问题,所以今天我们就来讨论一下这个问题。
实现原理Struts 2是通过Commons FileUpload文件上传。
Commons FileUpload通过将HTTP的数据保存到临时文件夹,然后Struts使用fileUpload拦截器将文件绑定到Action的实例中。
从而我们就能够以本地文件方式的操作浏览器上传的文件。
具体实现前段时间Apache发布了Struts 2.0.6 GA,所以本文的实现是以该版本的Struts 作为框架的。
以下是例子所依赖类包的列表:清单1 依赖类包的列表首先,创建文件上传页面FileUpload.jsp,内容如下:<% @ page language = " java " contentType = " text/html; charset=utf-8 " pageEncodi ng = " utf-8 " %><% @ taglib prefix = " s " uri = " /struts-tags " %><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "/ TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="/1999/xhtml"><head><title> Struts 2 File Upload </title></head><body><s:form action="fileUpload"method="POST"enctype="multipart/form-data"> <s:file name="myFile"label="Image File"/><s:textfield name="caption"label="Caption"/><s:submit /></s:form></body></html>清单2 FileUpload.jsp在FileUpload.jsp中,先将表单的提交方式设为POST,然后将enctype设为multipart/form-data,这并没有什么特别之处。
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基于Socket文件传输示例】网络编程
Java基于Socket文件传输示例最近需要进行网络传输大文件,于是对基于socket的文件传输作了一个初步的了解。
在一位网友提供的程序基础上,俺进行了一些加工,采用了缓冲输入/输出流来包装输出流,再采用数据输入/输出输出流进行包装,加快传输的速度。
废话少说,先来看服务器端的程序。
1.服务器端package sterning;import java.io.BufferedInputStream;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.File;import java.io.FileInputStream;import .ServerSocket;import .Socket;public class ServerTest {int port = 8821;void start() {Socket s = null;try {ServerSocket ss = new ServerSocket(port);while (true) {// 选择进行传输的文件String filePath = "D:\\lib.rar";File fi = new File(filePath);System.out.println("文件长度:" + (int) fi.length());// public Socket accept() throws// IOException侦听并接受到此套接字的连接。
此方法在进行连接之前一直阻塞。
s = ss.accept();System.out.println("建立socket链接");DataInputStream dis = new DataInputStream(new BufferedIn putStream(s.getInputStream()));dis.readByte();DataInputStream fis = new DataInputStream(new BufferedIn putStream(new FileInputStream(filePath)));DataOutputStream ps = new DataOutputStream(s.getOutput Stream());//将文件名及长度传给客户端。
java传输文件 方案
Java传输文件方案1. 简介在开发Java应用程序时,经常需要通过网络传输文件。
本文将介绍几种常见的Java传输文件的方案,包括使用原生Java API实现文件传输、使用FTP协议传输文件以及使用HTTP协议传输文件。
2. 使用原生Java API实现文件传输Java提供了一系列的API来处理文件传输操作。
下面将介绍如何使用原生Java API实现文件传输。
2.1 文件上传在Java中,可以使用java.io包提供的类来实现文件上传。
以下是一个简单的文件上传示例:import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.OutputStream;import .Socket;public class FileUploader {public static void uploadFile(File file, String host, int port) thr ows IOException {try (Socket socket = new Socket(host, port);FileInputStream fileInputStream = new FileInputStream(fil e);OutputStream outputStream = socket.getOutputStream()) { byte[] buffer = new byte[4096];int bytesRead;while ((bytesRead = fileInputStream.read(buffer)) != -1) {outputStream.write(buffer, 0, bytesRead);}}}}在上述示例中,我们使用Socket类实现了与服务器建立连接,并使用FileInputStream读取文件内容,并通过OutputStream将文件内容写入到服务器。
sftp java代码
sftp java代码SFTP(SSH File Transfer Protocol)是基于SSH协议的一种文件传输协议,在数据传输过程中使用加密进行保障数据的安全性。
SFTP的实现一般有两种方式:命令行工具和编程语言。
在Java中,我们可以利用jsch库实现sftp的功能。
本文将介绍sftp在Java中的实现方式。
首先,我们需要添加jsch的jar包。
可以在Maven的中央仓库中找到jsch,也可以通过其他方式下载并添加到项目中。
在Java代码中,我们需要使用JSch类来建立一个SFTP会话连接。
下面的代码建立了一个到SFTP服务器的连接:``` JSch jsch = new JSch(); Session session = jsch.getSession(username, host, port);session.setPassword(password); session.connect(); ```JSch类是整个JSch库的核心类,它表示一个SSH会话。
Session类则代表由客户端向服务器发起的远程会话。
在调用session.connect()方法之后,我们已经成功地建立了一个到SFTP服务器的连接。
下面是一个示例代码,实现了从本地上传文件到远程SFTP服务器的功能:``` JSch jsch = new JSch(); Session session = jsch.getSession(username, host, port);session.setPassword(password); session.connect();Channel channel = session.openChannel("sftp"); channel.connect();ChannelSftp sftpChannel = (ChannelSftp) channel; sftpChannel.put(localFilePath, remoteFilePath); sftpChannel.exit();session.disconnect(); ```这段代码的具体实现过程如下:1. 建立SFTP会话连接。
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实现两台电脑间TCP协议文件传输
java实现两台电脑间TCP协议⽂件传输记录下之前所做的客户端向服务端发送⽂件的⼩项⽬,总结下学习到的⼀些⽅法与思路。
注:本⽂参考⾃《⿊马程序员》视频。
⾸先明确需求,在同⼀局域⽹下的机器⼈A想给喜欢了很久的机器⼈B发送情书,但是机器⼈B事先并不知道⼩A的⼼思,那么作为⽉⽼(红娘)该如何帮助他们呢?然后建⽴模型并拆分需求。
这⾥两台主机使⽤⽹线直连,在物理层上确保建⽴了连接,接下来便是利⽤相应的协议将信息从电脑A传给电脑B。
在这⼀步上,可以将此过程抽象为⽹络+I/O(Input、Output)的过程。
如果能在⼀台电脑上实现⽂件之间的传输,再加上相互的⽹络协议,羞涩的A不就可以将情书发送给B了吗?因此要先解决在⼀台电脑上传输信息的问题。
为了在⽹络上传输,使⽤必要的协议是必要的,TCP/IP协议簇就是为了解决计算机间通信⽽⽣,⽽这⾥主要⽤到UDP和TCP两种协议。
当⼩A可以向⼩B发送情书后,⼜出现了众多的追求者,那么⼩B如何去处理这么多的并发任务呢?这时便要⽤到多线程的技术。
因此接下来将分别介绍此过程中所⽤到了I/O流(最基础)、⽹络编程(最重要)、多线程知识(较重要)和其中⼀些⼩技巧。
⼀、I/O流I/O流⽤来处理设备之间的数据传输,Java对数据的传输通过流的⽅式。
流按操作数据分为两种:字节流与字符流。
如果数据是⽂本类型,那么需要使⽤字符流;如果是其他类型,那么使⽤字节流。
简单来说,字符流=字节流+编码表。
流按流向分为:输⼊流(将硬盘中的数据读⼊内存),输出流(将内存中的数据写⼊硬盘)。
简单来说,想要将某⽂件传到⽬的地,需要将此⽂件关联输⼊流,然后将输⼊流中的信息写⼊到输出流中。
将⽬的关联输出流,就可以将信息传输到⽬的地了。
Java提供了⼤量的流对象可供使⽤,其中有两⼤基类,字节流的两个顶层⽗InputStream与OutputStream;字符流的两个顶层⽗类Reader 与Writer。
这些体系的⼦类都以⽗类名作为后缀,⽽⼦类名的前缀就是该对象的功能。
JavaSocket实现文件传输示例代码
JavaSocket实现⽂件传输⽰例代码最近学Socket学上瘾了,就写了⼀个简单的⽂件传输程序。
客户端设计思路:客户端与服务端建⽴连接,选择客户端本地⽂件,先将⽂件名及⼤⼩等属性发送给服务端,再将⽂件通过流的⽅式传输给服务端。
传输的进度打印到控制台中,直到传输完成。
服务端设计思路:服务端接收客户端的请求(阻塞式),每接收到⼀个客户端请求连接后,就新开⼀个处理⽂件的线程,开始写⼊流,将⽂件到服务器的指定⽬录下,并与传输过来的⽂件同名。
下⾯是客户端和服务端的代码实现:客户端代码:import java.io.DataOutputStream;import java.io.File;import java.io.FileInputStream;import .Socket;/*** ⽂件传输Client端<br>* 功能说明:** @author ⼤智若愚的⼩懂* @Date 2016年09⽉01⽇* @version 1.0*/public class FileTransferClient extends Socket {private static final String SERVER_IP = "127.0.0.1"; // 服务端IPprivate static final int SERVER_PORT = 8899; // 服务端端⼝private Socket client;private FileInputStream fis;private DataOutputStream dos;/*** 构造函数<br/>* 与服务器建⽴连接* @throws Exception*/public FileTransferClient() throws Exception {super(SERVER_IP, SERVER_PORT);this.client = this;System.out.println("Cliect[port:" + client.getLocalPort() + "] 成功连接服务端");}/*** 向服务端传输⽂件* @throws Exception*/public void sendFile() throws Exception {try {File file = new File("E:\\JDK1.6中⽂参考⼿册(JDK_API_1_6_zh_CN).CHM");if(file.exists()) {fis = new FileInputStream(file);dos = new DataOutputStream(client.getOutputStream());// ⽂件名和长度dos.writeUTF(file.getName());dos.flush();dos.writeLong(file.length());dos.flush();// 开始传输⽂件System.out.println("======== 开始传输⽂件 ========");byte[] bytes = new byte[1024];int length = 0;long progress = 0;while((length = fis.read(bytes, 0, bytes.length)) != -1) {dos.write(bytes, 0, length);dos.flush();progress += length;System.out.print("| " + (100*progress/file.length()) + "% |");}System.out.println();System.out.println("======== ⽂件传输成功 ========");}} catch (Exception e) {e.printStackTrace();} finally {if(fis != null)fis.close();if(dos != null)dos.close();client.close();}}/*** ⼊⼝* @param args*/public static void main(String[] args) {try {FileTransferClient client = new FileTransferClient(); // 启动客户端连接client.sendFile(); // 传输⽂件} catch (Exception e) {e.printStackTrace();}}}服务端代码:import java.io.DataInputStream;import java.io.File;import java.io.FileOutputStream;import java.math.RoundingMode;import .ServerSocket;import .Socket;import java.text.DecimalFormat;/*** ⽂件传输Server端<br>* 功能说明:** @author ⼤智若愚的⼩懂* @Date 2016年09⽉01⽇* @version 1.0*/public class FileTransferServer extends ServerSocket {private static final int SERVER_PORT = 8899; // 服务端端⼝private static DecimalFormat df = null;static {// 设置数字格式,保留⼀位有效⼩数df = new DecimalFormat("#0.0");df.setRoundingMode(RoundingMode.HALF_UP);df.setMinimumFractionDigits(1);df.setMaximumFractionDigits(1);}public FileTransferServer() throws Exception {super(SERVER_PORT);}/*** 使⽤线程处理每个客户端传输的⽂件* @throws Exception*/public void load() throws Exception {while (true) {// server尝试接收其他Socket的连接请求,server的accept⽅法是阻塞式的 Socket socket = this.accept();/*** 我们的服务端处理客户端的连接请求是同步进⾏的,每次接收到来⾃客户端的连接请求后,* 都要先跟当前的客户端通信完之后才能再处理下⼀个连接请求。
自己用java实现飞鸽传书2-实现文件传输
⾃⼰⽤java实现飞鸽传书2-实现⽂件传输第⼆步:实现⽂件传递。
上⼀步只是从服务端传递了⼀个字符串到客户端,这次需要对代码进⾏调整,实现从服务端获取⽂件,在客户端将⽂件存⼊⽬标地址。
调整后的代码:服务端:import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.File;import java.io.FileInputStream;import .ServerSocket;import .Socket;public class Server {public static void main(String[] args){//创建服务端socket,⽤以⽹络信息的接收ServerSocket serverSocket = null;try {//服务端socket使⽤本地IP,端⼝号使⽤36000serverSocket = new ServerSocket(36000);//保证服务端持续运⾏while(true){//接收⽹络信息,未接收到则阻塞当前线程Socket socket = serverSocket.accept();//将⽂件信息写⼊socket通信writeFile(socket);//关闭socket,防⽌客户端长时间等待socket.close();}} catch (Exception e) {e.printStackTrace();}}/*** 将⽂件信息写⼊socket通信流* @param socket* socket*/private static void writeFile(Socket socket){try{//获取本地⽂件String filePath ="D:/test.pdf";//创建⽂件对象File file = new File(filePath);//使⽤DataOutputStream传送⽂件信息DataOutputStream dos = new DataOutputStream(socket.getOutputStream());//写⼊⽂件名dos.writeUTF(file.getName());//写⼊⽂件⼤⼩dos.writeLong(file.length());//清空缓冲区dos.flush();//使⽤DataInputStream将⽂件写⼊DataInputStream dis = new DataInputStream( new FileInputStream(file) );byte[] buffer = new byte[1024];int head = 0;while((head=dis.read(buffer)) > 0){dos.write(buffer, 0, head);}dis.close();dos.close();}catch(Exception e){e.printStackTrace();}}}客户端:import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.FileOutputStream;import .Socket;public class Client {public static void main(String[] args){DataInputStream input = null;Socket clientSocket = null;try {//创建客户端socket,⽤以连接服务端clientSocket = new Socket("127.0.0.1", 36000);//读取服务端发送的信息流input = new DataInputStream(clientSocket.getInputStream());String fileName = input.readUTF();long fileSize = input.readLong();System.out.println("收到服务端发过来的⽂件,⽂件名称为:"+ fileName + ",⽂件⼤⼩为:" + fileSize);//将⽂件读⼊本地String savePath = "E:\\just a test.pdf";DataOutputStream fos = new DataOutputStream(new FileOutputStream(savePath));byte[] buffer = new byte[1024];int head = 0;while((head=input.read(buffer)) > 0){fos.write(buffer, 0, head);}fos.close();input.close();clientSocket.close();} catch (Exception e) {e.printStackTrace();}}}本次⽂件流的传送使⽤了DataOutputStream和DataInputStream,使⽤Data类型的字节流可以根据信息类型分别进⾏处理。
文件传输协议的简单设计与实现
文件传输协议的简单设计与实现摘要:文件传送是各种计算机网络都实现的基本功能,文件传送协议是一种最基本的应用层协议按照客户/服务器的模式进行工作,提供交互式的访问,是INTERNET使用最广泛的协议之一。
本设计是用JAVA语言简单实现文件传输协议,利用SOCKET 以及SERVERSOCKE等类方法,当中实现了上传、下载、获取服务器目录等基本文件传输功能。
关键字:文件传输、FTP。
1 具体设计任务1(1实验内容我们的计算机网络实验环境建立在TCP/IP 网络体系结构之上。
各计算机除了安装TCP/IP 软件外,还安装了TCP/IP 开发系统。
实验室各计算机具备Windows环境中套接字socket 的编程接口功能,可为用户提供全网范围的进程通信功能。
本实验要求学生利用这些功能,设计和实现一个简单的文件传送协议。
1(2具体要求用socket 编程接口编写两个程序,分别为客户程序(client.c)和服务器程序(server.c),该程序应能实现下述命令功能:get:取远方的一个文件put:传给远方一个文件pwd:显示远主当前目录dir:列出远方当前目录cd :改变远方当前目录, :显示你提供的命令quit :退出返回此命令的具体工作方式(指给出结果的形式)可以参照FTP 的相应命令,有余力的同学可以多实现几个命令。
2 基本思路及所涉及的相关理论2.1 文件传输协议网络协议是网络中计算机与终端之间正确传送信息和数据的规范格式,起包括语法、语义和时序这三部分。
文件传输协议(File Transfer Protocol, FTP)是在TCP/IP网络中传输文件的一种格式规范,其规定在用户和服务器之间开设两个通信端口:控制端口和数据端口。
前者生存周期为从用户登录开始直至用户登出,后者则在进行数据传送的时候打开,并且在数据传送完毕之后立即结束。
控制端口用来监听双方共同规定的控制字以达到及时提供服务或响应,数据端口则要先将文件拆分成分组再进行传送,这样做的目的是为了更加好的适应网络中的带宽限制,以及减少传送期间节点的延时,以达到高速传送。
Java基于TCP协议socket网络编程的文件传送的实现
Java基于TCP协议socket⽹络编程的⽂件传送的实现先了解⼀下socket基本概念socket也叫套接字:是指在⽹路中不同主机上的应⽤进程之间,进⾏双向通信的端点的抽象。
简单理解就是:两个主机之间要通信,就需要知道彼此的ip,端⼝号等信息,⽽⼀台主机这些信息的集合:就可以理解为⼀个端点,即为套接字双⽅通过套接字作为⼀种坐标,建⽴信息通道,形成连接(两点连接⼀条直线)简单理解了套接字的概念后,来看看如何通过java socket编程来实现两台主机⽂件的接收与发送:代码如下:发送⽅:import java.io.*;import .InetAddress;import .Socket;/*** 发送者*/public class TcpSendCilent {public static void main(String[] args) throws Exception {//1.通过socket对象创建socket连接Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);//2,创建⼀个字节输出流OutputStream os = socket.getOutputStream();//3.字节⽂件输⼊流读取⽂件//避免出错写需要发送⽂件的绝对路径FileInputStream fis = new FileInputStream(new File("F:/TEST/1604407051256.jpg"));//4.字节⽂件输出流写出⽂件byte[] buffer=new byte[1024*10];int len;while ((len=fis.read(buffer))!=-1){//socket编程基于I/O流所以//输出流写转为字节数组的⽂件 =向接收⽅发送⽂件os.write(buffer,0,len);}//通知服务器我传送完了调⽤shutdownOutput() 否则影响接下来代码执⾏socket.shutdownOutput();//确定服务器接受完毕,断开连接//获取接收⽅响应回来的接受完毕!响应InputStream inputStream = socket.getInputStream();ByteArrayOutputStream baos=new ByteArrayOutputStream();byte[] bytes2=new byte[1024*10];int len2;while ((len2=inputStream.read(bytes2))!=-1){baos.write(bytes2,0,len2);}//显⽰接收⽅的响应System.out.println(baos.toString());//发送结束后,最后关闭所有资源//关闭资源好习惯这部分写的简单//⼀般建议先进⾏⼀个⾮空判断再关闭baos.close();fis.close();os.close();socket.close();}}接收⽅:import java.io.*;import .ServerSocket;import .Socket;/*** 接收端*/public class TcpAcceptServer {public static void main(String[] args) throws IOException {//通过ServerSocket对象创建接收端套接字ServerSocket serverSocket=null;//套接字Socket socket=null;//字节输⼊流InputStream in=null;//默认参数定义端⼝号发送⽅依据这个端⼝号发送serverSocket=new ServerSocket(9000);socket = serverSocket.accept();//socket对象获取输⼊流,拿到⽂件in = socket.getInputStream();//将发送者发送过来的⽂件通过⽂件字节输出流输出到指定路径下FileOutputStream fos = new FileOutputStream(new File("F:/recevice.jpg"));int len;byte[] bytes=new byte[1024*10];while ((len=in.read(bytes))!=-1){fos.write(bytes,0,len);}//通知发送者接受完毕了OutputStream outputStream = socket.getOutputStream();outputStream.write("我是⽂件接收者:我已成功接受".getBytes());//接受结束后,关闭资源好习惯这部分写的简单//⼀般建议先进⾏⼀个⾮空判断再关闭fos.close();serverSocket.close();socket.close();in.close();}}测试⽅法:以上代码可直接粘贴测试1、先运⾏接收者等待接受,2、再运⾏发送者,3、等待接收者向发送者响应:我是⽂件接收者:我已成功接受;4、接收者指定接受⽬录下、查看接收⽂件存在即为接收成功!总结:这个demo实现并不是很难,主要考验了我们对于io流的熟练程度到此这篇关于Java基于TCP协议socket⽹络编程的⽂件传送的实现的⽂章就介绍到这了,更多相关Java socket⽂件传送内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。
java 不同系统之间传输数据的方法
java 不同系统之间传输数据的方法Java是一种跨平台的编程语言,可以在不同的操作系统上运行。
在不同的系统之间传输数据,可以使用多种方法。
本文将介绍一些常用的方法,并提供一些指导意义。
1. 文件传输:一个常见的方法是使用文件传输来在不同系统之间传输数据。
可以使用Java的IO包中的文件读写方法来读取和写入文件。
可以将数据保存到一个文件中,然后在另一个系统上读取该文件。
这种方法适用于需要传输大量数据的情况。
2. 网络传输:另一种常见的方法是使用网络传输来在不同系统之间传输数据。
可以使用Java的网络编程功能来创建一个网络连接,然后使用套接字来发送和接收数据。
可以使用TCP/IP协议或UDP协议来发送数据。
这种方法适用于需要实时传输数据的情况,如实时游戏。
3. 数据库传输:如果需要在不同系统之间共享数据,可以使用数据库来传输数据。
可以使用Java的JDBC技术来连接数据库,并执行SQL语句来读取和写入数据。
可以使用关系型数据库如MySQL或Oracle,也可以使用非关系型数据库如MongoDB或Redis。
这种方法适用于需要多个系统之间共享和同步数据的情况。
4. Web服务:Java提供了许多用于创建Web服务的框架和库,如JAX-RS和Spring MVC。
可以使用这些框架来创建一个Web服务,然后在不同的系统之间通过HTTP协议传输数据。
可以使用JSON或XML格式来编码和解码数据。
这种方法适用于需要通过Web进行数据传输的情况,如Web应用程序或移动应用程序。
总结起来,Java在不同系统之间传输数据时可以使用文件传输、网络传输、数据库传输和Web服务等方法。
选择合适的方法取决于具体的需求和情况。
无论使用哪种方法,都需要确保数据的完整性和安全性。
在实施时,应考虑系统之间的兼容性和性能等问题。
希望本文提供的指导对于Java开发人员在不同系统之间传输数据时有所帮助。
用Java实现基于SOAP的XML文档网络传输及远程过程调用
用Java实现基于SOAP的XML文档网络传输及远程过程调用1. 环境配置为了运行程序,我们首先务必配置好环境:共要下载四个软件包,它们都是开源免费的。
其中,前两个是Apache的,后两个是SUN网站的,如下所示:下载后将它们分别解压缩。
分别在这四个包的解压目录中找到:xerces.jar、soap.jar、mail.jar、activation.jar(JAF的),则是四个jar文件是我们所需要的。
本机安装环境:WindowsXP(SP2) + JDK1.4.2_06 + Tomcat5.0.28 + SOAP2.3.1 配置步骤:1、安装JDK与Tomcat。
过程比较简单,这里不再详述。
2、将刚才所找到的四个jar文件复制到Tomcat的“Tomcat 5.0\common\lib”目录下,这个目录是Tomcat的默认包目录,在这个目录中的所有包在Tomcat启动时都会被自动加载。
3、将\ JDK1.4.2\lib\路径下的tools.jar也复制到Tomcat的“Tomcat5.0\common\lib”目录下。
5、注意在编写程序时,需要将所得到的四个jar文件路径设置到所使用的Java编程环境中,由于在程序中需要用到其中的类文件。
具体步骤略。
6、重启Tomcat服务。
这时Tomcat会将“Tomcat 5.0\common\lib”目录下新加入的包加载到内存中。
到此,我们已经配置好了程序运行所需要的环境。
2. 基于SOAP的XML文档网络传输SOAP规范要紧定义了四个元素:SOAP信封规范,传输与协议绑定,编码规则与一个RPC协定。
用于实现消息的网络传输。
⏹SOAP信封规范,SOAP信封规范对计算机间传递的数据如何封装定义了具体的规则。
这包含应用特定的数据,如要调用的方法名,方法参数与返回值;还包含谁将处理封装内容,失败时如何编码错误消息等信息。
⏹数据编码规则,为了交换数据,计算机务必在编码特定数据类型的规则上达成一致,SOAP也有自己的一套编码数据类型的约定。
Java简单TCP文件传输
Java简单TCP⽂件传输服务端package TCP;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import .InetSocketAddress;import .ServerSocket;import .Socket;public class TCP_File_Server {public static void main(String[] args) throws Exception {/*** 创建服务端套接字*/ServerSocket ss = new ServerSocket();/*** 绑定指定端⼝*/ss.bind(new InetSocketAddress(12345));System.out.println("《《《《⽹盘开始运⾏》》》》");/*** 监听并接受客户端socket连接,并返回⼀个socket*//*** 持续接收客户端发来的信息,并交给线程处理*/while(true) {Socket socket = ss.accept();new Thread(new UpLoad(socket)).start();}}}class UpLoad implements Runnable{private Socket socket = null;public UpLoad(Socket socket) {this.socket = socket;}@Overridepublic void run() {OutputStream out = null;try {// 创建⽂件输⼊流,接收客户端的socket中的⽂件流InputStream in = socket.getInputStream();/*** 获取⽂件名长度* ⽂件格式:⽂件名长度(数字)\r\⽂件名\r\n⽂件内容\r\n* 获取⽂件名 - 读到第⼀个回车换⾏之前截取出⽂件名的长度接着读取这个长度的字节就是⽂件名* 读取数据直到遇到第⼀个回车换⾏* 每次从流中读取⼀个字节转成字符串拼到line上只要line还不是\r\n结尾就重复这个过程*/String line1 = "";byte[] by1 = new byte[1];while(!line1.endsWith("\r\n")) {in.read(by1);String str = new String(by1);line1 += str;}/*** 1.读到长度,去掉\r\n就是⽂件名字的长度* 2.parseInt():作⽤是将可分析的字符串转化为整数。
javaminioclient使用
javaminioclient使用JavaMiniClient是一个开源的网络文件传输工具,使用Java语言编写,在Windows、Mac和Linux等操作系统上均能运行。
它依赖于一个名为MiniIO 的Java库,该库提供了基本的文件传输功能。
使用JavaMiniClient进行文件传输的步骤如下:1. 下载JavaMiniClient。
您可以从GitHub或其他类似的平台上下载JavaMiniClient的源码,然后在命令行或使用集成开发环境(IDE)编译和运行它。
2. 准备好要传输的文件。
您需要在所选目录下放置要传输的文件。
如果要传输整个文件夹,则需要将整个文件夹打包为zip文件。
3. 运行JavaMiniClient。
如果您使用开发IDE,则直接运行JavaMiniClient的main()方法即可;如果您使用命令行,则键入以下命令:java -jar JavaMiniClient.jar4. 连接到MiniIO服务器。
在JavaMiniClient中,您可以通过单击“连接”按钮,通过指定IP地址和端口号连接到MiniIO服务器。
支持的协议包括FTP、SFTP和SCP等。
5. 选择要传输的文件。
在JavaMiniClient的界面中,您可以选择要传输的文件或文件夹,然后将其拖到MiniIO窗口中。
6. 开始传输文件。
单击“上传”或“下载”按钮,开始传输文件或文件夹。
如果您需要在传输过程中终止文件传输,则可以单击“取消”按钮。
在完成文件传输后,您可以关闭JavaMiniClient并断开MiniIO服务器的连接。
JavaMiniClient是一个简单易用的文件传输工具,因此即使您没有经验,也可以轻松地使用它进行文件传输。
java学习案例-上传文件
客户端向服务端上传文件【案例介绍】1.案例描述编写一个客户端向服务端上传文件的程序,要求使用TCP通信的的知识,将本地机器输入的路径下的文件上传到D盘中名称为upload的文件夹中。
并把客户端的IP地址加上count标识作为上传后文件的文件名,即IP(count)的形式。
其中,count随着文件的增多而增大,例如127.0.0.(1).jpg、127.0.0.(2).jpg。
2.效果显示上传文件之前上传文件之后【案例目标】●学会分析“文件上传”思路。
●根据思路独立完成“文件上传”任务的源代码编写、编译及运行。
●掌握网络通信中TCP协议的编程原理。
●掌握TCP网络通信ServerSocket和Socket的使用。
●掌握多线程的使用。
【案例分析】(1)根据任务描述中使用TCP通信的知识实现文件上传功能可知,要实现此功能,需要定义一个服务器接收文件的程序和一个客户端上传文件的程序。
(2)首先要编写服务器端程序来接收文件。
服务器端需要使用ServerSocket对象的accept()方法接收客户端的请求,由于一个服务器可能对于多个客户端,所以当客户端与服务器端简历连接后,服务器需要单独开启一个新的线程来处理与客户端的交互,这时需要在服务器端编写开启新线程的方法。
在新线程的方法中,需要获取客户端的端口号,并且使用输入输出流来传输文件到指定的目录中。
(3)编写客户端的功能代码,客户端功能的实现,因为是用户自己输入上传文件。
所以要定义键盘录入。
录入后需要使用Socket类来创建客户对象,并通过输入输出流来定义指定的文件。
(4)最后我们启动程序,先启动服务端程序,再运行客户端程序来测试上传的结果。
【案例实现】(1)首先编写服务器端的程序,用来接收文件,其代码具体如下所示。
FileServer.java1 package chapter0903;2 import java.io.File;3 import java.io.FileOutputStream;4 import java.io.InputStream;5 import java.io.OutputStream;6 import .ServerSocket;7 import .Socket;8 public class FileServer {9 public static void main(String[] args) throws Exception {10 //创建ServerSocket对象11 ServerSocket serverSocket = new ServerSocket(10001);12 while (true) {13 // 调用accept()方法接收客户端请求,得到Socket对象14 Socket s = serverSocket.accept();15 // 每当和客户端建立Socket连接后,单独开启一个线程处理和客户端的交互16 new Thread(new ServerThread(s)).start();17 }18 }19 }20 class ServerThread implements Runnable {21 // 持有一个Socket类型的属性22 private Socket socket;23 // 构造方法中把Socket对象作为实参传入24 public ServerThread(Socket socket) {25 this.socket = socket;26 }27 public void run() {28 // 获取客户端的IP地址29 String ip = socket.getInetAddress().getHostAddress();30 // 上传图片个数31 int count = 1;32 try {33 InputStream in = socket.getInputStream();34 // 创建上传图片目录的File对象35 File parentFile = new File("D:\\upload\\");36 // 如果不存在,就创建这个目录37 if (!parentFile.exists()) {38 parentFile.mkdir();39 }40 // 把客户端的IP地址作为上传文件的文件名41 File file = new File(parentFile, ip + "(" + count +42 ").jpg");43 while (file.exists()) {44 // 如果文件名存在,则把count++45 file = new File(parentFile, ip + "(" + (count++) +46 ").jpg");47 }48 // 创建FileOutputStream对象49 FileOutputStream fos = new FileOutputStream(file);50 // 定义一个字节数组51 byte[] buf = new byte[1024];52 // 定义一个int类型的变量len,初始值为053 int len = 0;54 // 循环读取数据55 while ((len = in.read(buf)) != -1) {56 fos.write(buf, 0, len);57 }58 // 获取服务端的输出流59 OutputStream out = socket.getOutputStream();60 // 上传成功后向客户端写出“上传成功”61 out.write("上传成功".getBytes());62 // 关闭输出流对象63 fos.close();64 // 关闭Socket对象65 socket.close();66 } catch (Exception e) {67 throw new RuntimeException(e);68 }69 }70 }运行结果如图所示。
Java网络文件传输
这两个包里,这里我提供一个基于TCP/IP的实现版本,使用基于连接的方式来完成工作.我们首先介绍几个相关的JDK中的类来完成以上任务,1. DataOutputStream和DataInputStream实现类提供了上面的字节包装和解包器的实现2. ServerSocket和Socekt提供了基于连接的网络传输和接受接口3. File,FileInputStream和FileOutputStream提供了基本的本地文件输入输出接口.服务器端实现代码:import java.io.*;import .*;public class FileServer{public static void main(String[] args)throws Exception{//创建文件流用来读取文件中的数据File file=new File("lishengjie.jpg");FileInputStream fos=new FileInputStream(file);//创建网络服务器接受客户请求ServerSocket ss=new ServerSocket(3108);Socket client=ss.accept();//创建网络输出流并提供数据包装器OutputStream netOut=client.getOutputStream();OutputStream doc=new DataOutputStream(new BufferedOutputStream(netOut));//创建文件读取缓冲区byte[] buf=new byte[2048];int num=fos.read(buf);while(num!=(-1)){//是否读完文件doc.write(buf,0,num);//把文件数据写出网络缓冲区doc.flush();//刷新缓冲区把数据写往客户端num=fos.read(buf);//继续从文件中读取数据}fos.close();doc.close();}}客户方实现代码:import java.io.*;import .*;public class FileClient{public static void main(String[] args)throws Exception{//使用本地文件系统接受网络数据并存为新文件File file=new File("newFile.jpg");file.createNewFile();RandomAccessFile raf=new RandomAccessFile(file,"rw"); // 通过Socket连接文件服务器Socket server=new Socket(InetAddress.getLocalHost(),3108);//创建网络接受流接受服务器文件数据InputStream netIn=server.getInputStream();InputStream in=new DataInputStream(new BufferedInputStream(netIn));//创建缓冲区缓冲网络数据byte[] buf=new byte[2048];int num=in.read(buf);while(num!=(-1)){//是否读完所有数据raf.write(buf,0,num);//将数据写往文件raf.skipBytes(num);//顺序写文件字节num=in.read(buf);//继续从网络中读取文件}in.close();raf.close();}}归结以上代码:服务器客户端1. 服务器从本地文件系统读取文件2. 服务器创建网络服务连接3. 服务器提供数据包装器4. 服务器将本地文件写入数据包装器5. 服务器通过包装器写入到网络 1. 客户端建立新文件准备存储来自网络的数据2. 客户端连接服务器3. 客户端通过网络接受服务器数据并进行数据解包4. 客户端将数据写入缓冲区5. 客户端从缓冲区把数据写入客户本地文件事实上java的开发环境为我们提供大多数的编程接口,为我们简化了开发工作量.我们通过java的IO 接口所提供的文件,数据包装器等接口非常方便的解决了我们上面的开发工作量.同时在java的net接口所提供的套接字也使得基于连接的数据接受和发送成为非常容易的工作.。
基于java的远程登录和文件传输功能的实现
基于java的远程登录和文件传输功能的实现摘要Internet发展至今产生了两种比较重要的网络体系结构:ISO/OSI和TCP/IP参考模型,ISO/OSI模型有7层:物理层,数据链路层,网络层,传输层,会话层,表示层,应用层。
而TCP/IP模型只有4层:主机至网络层,互连网层,传输层,应用层。
其中TCP/IP 参考模型中的应用层包含所有的高层协议,最早引入的是虚拟终端协议,文件传输协议和电子邮件协议。
本文对网络计算机相互通信的机理进行比较细致和深入的分析,并采用java编程工具实现了远程登录和文件传输的功能。
关键词:TCP/IP JAVA 远程登录文件传输AbstractInternet produces two kinds of more important network system structure so far that Internet is developed, ISO/OSI and TCP/IP consult models, ISO/OSI model is 7 layers: Physics layer, data link layer, network layer, transport layer, session layer, persentaltion layer, opplication layer. And TCP/IP model is 4 layers: From host computer to Internet, network layer, transport layer, opplication layer. TCP/IP among them consult application layer of model include all on the senior level Protocol, introduce TELecommunications NETwork , File Transfer Protocol and Simple Mail Transfer Protocol, Careful and deep analysis that this text compares mechanism that the network computer communicates each other, and adopt java programming tool to realize the functions of telecommunications network and file transfer.KEY WORDS: TCP/IP JA V A TELNET FTP目录前言--------------------------------------------------------------------------------------------1第一章互联网概述---------------------------------------------------------------------- 31.1 互联网的发展状况--------------------------------------------------------------------31.2 互联网的应用-------------------------------------------------------------------------5第二章互联网中两种重要的参考模型-----------------------------------------------62.1 OSI参考模型-------------------------------------------------------------------------62.2 TCP/IP参考模型--------------------------------------------------------------------8第3章远程登录的功能实现----------------------------------------------------------------93.1 虚拟终端-------------------------------------------------------------------------------93.2 远程登录协议 --------------------------------------------------------------------------11 3.3 有关远程登录的实现方法(线程的概念)---------------------------------------13 3.4 远程登录的最终完成---------------------------------------------------------------18第4章文件传输的执行行为和功能------------------------------------------------------27 4.1传输文件--------------------------------------------------------------------------------27 4.2 文件传输的传输模式----------------------------------------------------------------284.3 构造控制连接和数据连接------------------------------------------------------------32 4.4 文件传输程序的完成-----------------------------------------------------------------42第5章总结----------------------------------------------------------------------------------53参考文献---------------------------------------------------------------------------------------54谢辞----------------------------------------------------------------------------------------55前言历史的发展表明I n t e r n e t的产生要追溯到最开始的时间,穴壁上的画、烟信号、驿站—所有这些通信方式都使我们的祖先一直在考虑一个更好的通信方式。
Java网络文件传输的实现—Socket编程
Java网络文件传输的实现——Socket编程本程序分为服务器和客户端两个小程序。
主要实现的功能是:客户端向服务器端请求一个文件的传输连接,服务器接收到请求命令后,要求客户端发送用户名和密码,如果正确,就执行传输文件的过程,客户端接收完后,保存到一个文件中并在屏幕上显示出来。
设计原理:服务器端建立一个SocketServer等待客户端的连接,每来一个客户端的请求连接,就创建一个新的线程对其进行单独服务,然后继续等待其他的客户端的连接。
创建一个服务器文件server.txt。
客户端向服务器发送文件传输请求,在服务器端要求鉴权时,输入用户名和密码发送给服务器验证,如果验证通过就开始文件传输。
使用方法,如果需要重新编译的话输入以下两条命令:javac SendFileSocket.javajavac SendFileClient.java在命令行下的运行方式:服务器端:javac SendFileSocket.javajava SendFileSocket客户端:javac SendFileClient.javajava SendFileClient serverIPAddress例如: java SendFileClient 192.168.1.101用户名和密码:cyf@123服务器端SendFileSocket.java://package cyf.socket;import .*;import java.io.*;/***************************** 一个简单的多线程服务器程序,用于传输文件** @author cyf****************************/public class SendFileSocket extends Thread{/************** @param args*************/public static void main( String[] args ){/*if ( args.length > 0 ) // 如果有参数输入就启动服务器程序{server( );} else{// 否则启动客户端进程client( );}*/server( );//启动服务器程序}private static final int PORT = 6000;private Socket s;private static final String name = "cyf";private static final String password = "123";public SendFileSocket( Socket s ){this.s = s;}public void run(){try{OutputStream os = s.getOutputStream( );InputStream is = s.getInputStream( );os.write( "Hello,welcome you!".getBytes( ) );byte[] buf = new byte[100];while ( true ){int len = is.read( buf );String revStr = new String( buf, 0, len );System.out.println( "This client wants to "+revStr );String fileName;if ( revStr.startsWith( "get " ) )//表明客户端请求传输一个文件{os.write( "Please input your name and password! Using theformat:name@password".getBytes( ) );fileName = getFileName( revStr );len = is.read( buf );revStr = new String( buf, 0, len );System.out.println( "The received user name and password:"+revStr);if ( revStr.startsWith( "cyf@123" ) ){FileInputStream fins = new FileInputStream( fileName );//byte[] fielBuf = new byte[100];int data;while ( -1 != ( data = fins.read( ) ) )//从文件中读取数据,每次读取1字节{os.write( data ); //将读取到的数据写到网络数据流中发送给客户段}break;}} else{os.write( "geting file's usage is:get filename".getBytes( ) );}}os.close( );is.close( );s.close( );} catch ( Exception e ){e.printStackTrace( );}}/*************************************** 作用:从客户端发来了文件请求命令中提取出所请求的文件名* 参数:客户端发来了文件请求命令字符串,应该以“get ”开头* 返回值:提取出所请求的文件名***************************************/private String getFileName( String revStr ){String fileName;fileName = revStr.substring( 3 );while ( fileName.startsWith( " " ) ){fileName = fileName.substring( 1 );}return fileName;}public static void server(){System.out.println( "This is server" );try{ServerSocket ss = new ServerSocket( PORT );int count = 0;while ( true ){// 创建一个Socket等待客户端连接Socket s = ss.accept( );count++ ;System.out.println( "This is the " + count + "'st client connetion!" );new SendFileSocket( s ).start( );// 启动一个线程为这个客户端服务}} catch ( Exception ex ){ex.printStackTrace( );}}客户端SendFileClient.java:import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import .InetAddress;import .InetSocketAddress;import .Socket;public class SendFileClient{private static final int Server_PORT = 6000;private static final int Client_PORT = 6001;/************************************************************ 使用方法:运行这个程序需要带上参数,参数类型为点分十进制的ip地址,例如:192.168.1.101* @param args* @throws IOException***************************************************************/public static void main( String[] args ) throws IOException{// TODO Auto-generated method stubSystem.out.println( "This is client" );/*System.out.print("Please input your name and password, ");System.out.print("Using the format:name@password:");byte[] buf = new byte[100];System.in.read( buf );*/byte[] buf = new byte[100];byte[] name = new byte[100];//InetAddress inetAddr;if ( !isIPAddress(args[0]) ){System.out.println("The usage is : java SendFileClient ipaddress");System.out.println("For example : java SendFileClient 192.168.0.153");return;}String ipStr = args[0];try{// 创建一个SocketSocket s = new Socket();s.connect ( new InetSocketAddress (ipStr , Server_PORT ), Client_PORT );OutputStream os = s.getOutputStream( );// 输出流InputStream is = s.getInputStream( );// 输入流int len = is.read( buf );// 从输入流中读取数据到bufSystem.out.println( new String( buf, 0, len ) );// 向输出流中写入数据,请求传输一个文件os.write( "get server.txt".getBytes( ) );len = is.read( buf );// 从输入流中读取数据到bufString tempStr = new String(buf,0,len);if ( tempStr.startsWith( "Please input your name and password" ) ){System.out.println("Please input your name and password, ");System.out.println("Using the format:name@password:");do{System.in.read( name );} while ( name.length<5 );os.write( name );}//开始读取文件数据并把它写到一个名为"clientread.txt"的文件中FileOutputStream fos = new FileOutputStream( "clientread.txt" );int data;while ( -1 != ( data = is.read( ) ) ){fos.write( data );}System.out.println("\nFile has been recerved successfully.");os.close( );is.close( );s.close( );} catch ( Exception ex ){ex.printStackTrace( );}}//简单的判断字符串是否为一个ip地址//后期再完善该判断方法private static boolean isIPAddress( String ip ){if(ip.length( )<5){return false;}else{return true;}}}运行效果图:服务端:客户端:运行结束后客户端多出一个收到的文件clientread.txt。
局域网使用Java进行文件传输
局域⽹使⽤Java进⾏⽂件传输package com.herley;/**** 客户端*/import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import .Socket;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Scanner;import java.util.TimeZone;public class Send {public static void main(String[] args) {File filesrc; //需要传送的⽂件Socket socket; //套接字FileInputStream open; //读取⽂件FileOutputStream out; //传送⽂件Scanner sc;//键盘录⼊Date start;Date end;try {System.out.println("[欢迎使⽤局域⽹发送系统,仅⽀持单⽂件发送]");System.out.print("请输⼊你要发送的⽂件路径!");System.out.println("(注意格式:⽂件路径+后缀名!)");//需要传输的⽂件sc = new Scanner(System.in);String src = sc.nextLine();filesrc = new File(src);//键盘录⼊需要传输的⽂件路径open = new FileInputStream(filesrc);//创建⽂件输⼊流//连接服务器System.out.println("请输⼊服务器的ip地址");sc = new Scanner(System.in);String url = sc.nextLine();// System.out.println("请输⼊服务器的端⼝号");// sc = new Scanner(System.in);// int port = sc.nextInt();socket = new Socket(url, 2017);//创建socketout = (FileOutputStream)socket.getOutputStream();//创建⽂件输出流//开始传送byte[] b = new byte[1024];int n = open.read(b);//⾸次传送// int start = (int)System.currentTimeMillis();start = new Date();//⾸次时间while (n != -1) {out.write(b, 0, n);n = open.read(b);}// int end = (int)System.currentTimeMillis();end = new Date();long l = Send.printSplitTime(start, end);SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");formatter.setTimeZone(TimeZone.getTimeZone("GMT+00:00"));String hms = formatter.format(l);System.out.println( "发送成功,耗时:" + hms);System.out.println("谢谢使⽤");//关闭流out.close();socket.close();open.close();} catch (Exception e) {System.out.println("⽂件路径或者ip有误");}}public static long printSplitTime(Date start, Date end) {long interval = (end.getTime() - start.getTime());//System.out.println("接⼝耗时:" + interval + "毫秒");return interval;}}package com.herley;/**** 服务端*/import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import .Socket;import .ServerSocket;import java.util.Scanner;public class Receive {public static void main(String[] args) {File target; //接收到的⽂件保存的位置FileOutputStream save; //将接收到的⽂件写⼊电脑FileInputStream in; //读取穿送过来的数据⽂件ServerSocket server; //服务器Socket socket; //套接字//处理客户端的请求try {//接受前⽂件的准备System.out.print("请输⼊你将要保存⽂件的地址");System.out.println("(注意格式:⽂件路径+后缀名!)");Scanner scanner = new Scanner(System.in);String s = scanner.nextLine();target = new File(s);save = new FileOutputStream(target);server = new ServerSocket(2017); //服务端⼝//等待客户端的呼叫System.out.println("正在等待客户端的呼叫........");socket = server.accept(); //阻塞in = (FileInputStream)socket.getInputStream();//接收数据byte[] b = new byte[64];int n = in.read(b);int start = (int)System.currentTimeMillis();while (n != -1) {save.write(b, 0, n); //写⼊指定地⽅n = in.read(b);}int end = (int)System.currentTimeMillis();System.out.println("接收成功,耗时:" + (end-start)+"毫秒"); socket.close();server.close();in.close();save.close();} catch (Exception e) {System.out.println(e);}}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
java网络文件传输的实现——Socket编程本程序分为服务器和客户端两个小程序。
主要实现的功能是:客户端向服务器端请求一个文件的传输连接,服务器接收到请求命令后,要求客户端发送用户名和密码,如果正确,就执行传输文件的过程,客户端接收完后,保存到一个文件中并在屏幕上显示出来。
设计原理:服务器端建立一个SocketServer等待客户端的连接,每来一个客户端的请求连接,就创建一个新的线程对其进行单独服务,然后继续等待其他的客户端的连接。
客户端向服务器发送文件传输请求,在服务器端要求鉴权时,输入用户名和密码发送给服务器验证,如果验证通过就开始文件传输。
使用方法,如果需要重新编译的话输入以下两条命令:javac SendFileSocket.javajavac SendFileClient.java在命令行下的运行方式:服务器端:java SendFileSocket客户端:java SendFileClient serverIPAddress例如:java SendFileClient 192.168.0.153服务器程序:public class SendFileSocket extends Thread{/*** @param args*/public static void main(String[] args ){/*if ( args.length > 0 ) // 如果有参数输入就启动服务器程序 {server( );} else{// 否则启动客户端进程client( );}*/server();//启动服务器程序}private static final int PORT= 6000;private Socket s;private static final String name="zieckey";private static final String password ="123456";public SendFileSocket(Socket s ){this.s = s;}public void run(){try{OutputStream os = s.getOutputStream();InputStream is = s.getInputStream();os.write("Hello,welcome you!".getBytes());byte[] buf =new byte[100];while( true ){int len = is.read( buf );String revStr =new String( buf, 0, len );System.out.println("This client wants to "+revStr );String fileName;if( revStr.startsWith("get "))//表明客户端请求传输一个文件{os.write("Please input your name and password! Using the format:name@password".getBytes());fileName =getFileName( revStr );len = is.read( buf );revStr =new String( buf, 0, len );System.out.println("The received user name and password:"+revStr);if( revStr.startsWith("zieckey@123456")){FileInputStream fins =new FileInputStream( fileName );//byte[] fielBuf = new byte[100];int data;while(-1 !=( data = fins.read()))//从文件中读取数据,每次读取1字节{os.write( data );//将读取到的数据写到网络数据流中发送给客户段}break;}}else{os.write("geting file's usage is:get filename".getBytes());}}os.close();is.close();s.close();}catch(Exception e ){e.printStackTrace();}}/** 作用:从客户端发来了文件请求命令中提取出所请求的文件名 * 参数:客户端发来了文件请求命令字符串,应该以“get ”开头 * 返回值:提取出所请求的文件名*/private String getFileName(String revStr ){String fileName;fileName = revStr.substring( 3 );while( fileName.startsWith(" ")){fileName = fileName.substring( 1 );}return fileName;}public static void server(){System.out.println("This is server");try{ServerSocket ss =new ServerSocket(PORT);int count= 0;while( true ){// 创建一个Socket等待客户端连接Socket s = ss.accept();count++;System.out.println("This is the "+count+"'st client connetion!");new SendFileSocket( s ).start();// 启动一个线程为这个客户端服务}}catch(Exception ex ){ex.printStackTrace();}}/*public static void client(){System.out.println( "This is client" );try{// 创建一个SocketSocket s = new Socket( InetAddress.getByName( null ), PORT );OutputStream os = s.getOutputStream( );// 输出流InputStream is = s.getInputStream( );// 输入流byte[] buf = new byte[100];int len = is.read( buf );// 从输入流中读取数据到bufSystem.out.println( new String( buf, 0, len ) );// 向输出流中写入数据,请求传输一个文件os.write( "get server.txt".getBytes( ) );len = is.read( buf );// 从输入流中读取数据到bufString tempStr = new String(buf,0,len);if ( tempStr.startsWith( "Please input your name and password" ) ){System.out.print("Please input your name and password, ");System.out.print("Using the format:name@password:");System.in.read( buf );os.write( buf );}//开始读取文件数据并把它写到一个名为"clientread.txt"的文件中FileOutputStream fos = new FileOutputStream( "clientread.txt" ); int data;while ( -1 != ( data = is.read( ) ) ){fos.write( data );}System.out.println("\nFile has been recerved successfully.");os.close( );is.close( );s.close( );} catch ( Exception ex ){ex.printStackTrace( );}}*/}客户端程序:import .InetAddress;import .InetSocketAddress;import .Socket;public class SendFileClient{private static final int Server_PORT = 6000;private static final int Client_PORT = 6001;/*** 使用方法:运行这个程序需要带上参数,参数类型为点分十进制的ip地址,例如:192.168.0.153* @param args* @throws IOException*/public static void main(String[] args )throws IOException{// TODO Auto-generated method stubSystem.out.println("This is client");/*System.out.print("Please input your name and password, ");System.out.print("Using the format:name@password:");byte[] buf = new byte[100];System.in.read( buf );*/byte[] buf =new byte[100];byte[]name=new byte[100];//InetAddress inetAddr;if(!isIPAddress(args[0])){System.out.println("The usage is : java SendFileClient ipaddress");System.out.println("For example : java SendFileClient 192.168.0.153");return;}String ipStr = args[0];try{// 创建一个SocketSocket s =new Socket();s.connect(new InetSocketAddress(ipStr , Server_PORT ), Client_PORT );OutputStream os = s.getOutputStream();// 输出流InputStream is = s.getInputStream();// 输入流int len = is.read( buf );// 从输入流中读取数据到bufSystem.out.println(new String( buf, 0, len ));// 向输出流中写入数据,请求传输一个文件os.write("get server.txt".getBytes());len = is.read( buf );// 从输入流中读取数据到bufString tempStr =new String(buf,0,len);if( tempStr.startsWith("Please input your name and password")){System.out.println("Please input your name and password, ");System.out.println("Using the format:name@password:");do{System.in.read(name);}while(name.length<5 );os.write(name);}//开始读取文件数据并把它写到一个名为"clientread.txt"的文件中FileOutputStream fos =new FileOutputStream("clientread.txt");int data;while(-1 !=( data = is.read())){fos.write( data );}System.out.println("\nFile has been recerved successfully.");os.close();is.close();s.close();}catch(Exception ex ){ex.printStackTrace();}。