java传送文件_关于用JAVA的SOCKET传输文件

Ⅰ java中如何实现从客户端发送文件到服务器端

服务器端源码：x0dx0aimport java.io.BufferedReader;x0dx0aimport java.io.File;x0dx0aimport java.io.FileNotFoundException;x0dx0aimport java.io.FileOutputStream;x0dx0aimport java.io.IOException;x0dx0aimport java.io.InputStream;x0dx0aimport java.io.InputStreamReader;x0dx0aimport java.net.ServerSocket;x0dx0aimport java.net.Socket;x0dx0ax0dx0a/**x0dx0a *x0dx0a * 文件名：ServerReceive.javax0dx0a * 实现功能：作为服务器接收客户端发送的文件x0dx0a *x0dx0a * 具体实现过程：x0dx0a * 1、建立SocketServer，等待客户端的连接x0dx0a * 2、当有客户端连接的时候，按照双方的约定，这时要读取一行数据x0dx0a * 其中保存客户端要发送的文件名和文件大小信息x0dx0a * 3、根据文件名在本地创建文件，并建立好流通信x0dx0a * 4、循环接收数据包，将数据包写入文件x0dx0a * 5、当接收数据的长度等于提前文件发过来的文件长度，即表示文件接收完毕，关闭文件x0dx0a * 6、文件接收工作结束x0dx0ax0dx0apublic class ServerReceive {x0dx0a x0dx0a public static void main(String[] args) {x0dx0a x0dx0a /**与服务器建立连接的通信句柄*/x0dx0a ServerSocket ss = null;x0dx0a Socket s = null;x0dx0a x0dx0a /**定义用于在接收后在本地创建的文件对象和文件输出流对象*/x0dx0a File file = null;x0dx0a FileOutputStream fos = null;x0dx0a x0dx0a /**定义输入流，使用socket的inputStream对数据包进行输入*/x0dx0a InputStream is = null;x0dx0a x0dx0a /**定义byte数组来作为数据包的存储数据包*/x0dx0a byte[] buffer = new byte[4096 * 5];x0dx0a x0dx0a /**用来接收文件发送请求的字符串*/x0dx0a String comm = null;x0dx0ax0dx0a/**建立socekt通信，等待服务器进行连接*/x0dx0a try {x0dx0a ss = new ServerSocket(4004);x0dx0a s = ss.accept();x0dx0a } catch (IOException e) {x0dx0a e.printStackTrace();x0dx0a }x0dx0ax0dx0a/**读取一行客户端发送过来的约定信息*/x0dx0a try {x0dx0a InputStreamReader isr = new InputStreamReader(s.getInputStream());x0dx0a BufferedReader br = new BufferedReader(isr);x0dx0a comm = br.readLine();x0dx0a } catch (IOException e) {x0dx0a System.out.println("服务器与客户端断开连接");x0dx0a }x0dx0a x0dx0a /**开始解析客户端发送过来的请求命令*/x0dx0a int index = comm.indexOf("/#");x0dx0a x0dx0a /**判断协议是否为发送文件的协议*/x0dx0a String xieyi = comm.substring(0, index);x0dx0a if(!xieyi.equals("111")){x0dx0a System.out.println("服务器收到的协议码不正确");x0dx0a return;x0dx0a }x0dx0a x0dx0a /**解析出文件的名字和大小*/x0dx0a comm = comm.substring(index + 2);x0dx0a index = comm.indexOf("/#");x0dx0a String filename = comm.substring(0, index).trim();x0dx0a String filesize = comm.substring(index + 2).trim();x0dx0ax0dx0a/**创建空文件，用来进行接收文件*/x0dx0a file = new File(filename);x0dx0a if(!file.exists()){x0dx0a try {x0dx0a file.createNewFile();x0dx0a } catch (IOException e) {x0dx0a System.out.println("服务器端创建文件失败");x0dx0a }x0dx0a }else{x0dx0a /**在此也可以询问是否覆盖*/x0dx0a System.out.println("本路径已存在相同文件，进行覆盖");x0dx0a }x0dx0a x0dx0a /**【以上就是客户端代码中写到的服务器的准备部分】*/x0dx0ax0dx0a/**x0dx0a * 服务器接收文件的关键代码*/x0dx0a try {x0dx0a /**将文件包装到文件输出流对象中*/x0dx0a fos = new FileOutputStream(file);x0dx0a long file_size = Long.parseLong(filesize);x0dx0a is = s.getInputStream();x0dx0a /**size为每次接收数据包的长度*/x0dx0a int size = 0;x0dx0a /**count用来记录已接收到文件的长度*/x0dx0a long count = 0;x0dx0a x0dx0a /**使用while循环接收数据包*/x0dx0a while(count < file_size){x0dx0a /**从输入流中读取一个数据包*/x0dx0a size = is.read(buffer);x0dx0a x0dx0a /**将刚刚读取的数据包写到本地文件中去*/x0dx0a fos.write(buffer, 0, size);x0dx0a fos.flush();x0dx0a x0dx0a /**将已接收到文件的长度+size*/x0dx0a count += size;x0dx0a System.out.println("服务器端接收到数据包，大小为" + size);x0dx0a }x0dx0a x0dx0a } catch (FileNotFoundException e) {x0dx0a System.out.println("服务器写文件失败");x0dx0a } catch (IOException e) {x0dx0a System.out.println("服务器：客户端断开连接");x0dx0a }finally{x0dx0a /**x0dx0a * 将打开的文件关闭x0dx0a * 如有需要，也可以在此关闭socket连接x0dx0a * */x0dx0a try {x0dx0a if(fos != null)x0dx0a fos.close();x0dx0a } catch (IOException e) {x0dx0a e.printStackTrace();x0dx0a }//catch (IOException e)x0dx0a }//finallyx0dx0a x0dx0a }//public static void main(String[] args)x0dx0a}//public class ServerReceivex0dx0ax0dx0a客户端源码：x0dx0ax0dx0aimport java.io.File;x0dx0aimport java.io.FileInputStream;x0dx0aimport java.io.FileNotFoundException;x0dx0aimport java.io.IOException;x0dx0aimport java.io.OutputStream;x0dx0aimport java.io.PrintStream;x0dx0aimport java.net.Socket;x0dx0ax0dx0a/**x0dx0a *x0dx0a * 文件名：ClientSend.javax0dx0a * 实现功能：作为客户端向服务器发送一个文件x0dx0a *x0dx0a * 具体实现过程：x0dx0a * 1、建立与服务器端的连接，IP：127.0.0.1， port：4004x0dx0a * 2、将文件的名字和大小通过自定义的文件传输协议，发送到服务器x0dx0a * 3、循环读取本地文件，将文件打包发送到数据输出流中x0dx0a * 4、关闭文件，结束传输x0dx0a *x0dx0a * */x0dx0a x0dx0apublic class ClientSend {x0dx0a x0dx0a public static void main(String[] args) {x0dx0a x0dx0a /**与服务器建立连接的通信句柄*/x0dx0a Socket s = null;x0dx0a x0dx0a /**定义文件对象，即为要发送的文件x0dx0a * 如果使用绝对路径，不要忘记使用'/'和'\'的区别x0dx0a * 具体区别，请读者自行查询x0dx0a * */x0dx0a File sendfile = new File("API.CHM");x0dx0a /**定义文件输入流，用来打开、读取即将要发送的文件*/x0dx0a FileInputStream fis = null;x0dx0a /**定义byte数组来作为数据包的存储数据包*/x0dx0a byte[] buffer = new byte[4096 * 5];x0dx0a x0dx0a /**定义输出流，使用socket的outputStream对数据包进行输出*/x0dx0a OutputStream os = null;x0dx0ax0dx0a/**检查要发送的文件是否存在*/x0dx0a if(!sendfile.exists()){x0dx0a System.out.println("客户端：要发送的文件不存在");x0dx0a return;x0dx0a }x0dx0ax0dx0a/**与服务器建立连接*/x0dx0a try {x0dx0a s = new Socket("127.0.0.1", 4004);x0dx0a }catch (IOException e) {x0dx0a System.out.println("未连接到服务器");x0dx0a }x0dx0a x0dx0a /**用文件对象初始化fis对象x0dx0a * 以便于可以提取出文件的大小x0dx0a * */x0dx0a try {x0dx0a fis = new FileInputStream(sendfile);x0dx0a } catch (FileNotFoundException e1) {x0dx0a e1.printStackTrace();x0dx0a }x0dx0ax0dx0a/**首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作x0dx0a * 具体的准备工作，请查看服务器代码。x0dx0a *x0dx0a * 发送的内容包括：发送文件协议码（此处为111）/#文件名（带后缀名）/#文件大小x0dx0a * */x0dx0a try {x0dx0a PrintStream ps = new PrintStream(s.getOutputStream());x0dx0a ps.println("111/#" + sendfile.getName() + "/#" + fis.available());x0dx0a ps.flush();x0dx0a } catch (IOException e) {x0dx0a System.out.println("服务器连接中断");x0dx0a }x0dx0ax0dx0a/**x0dx0a * 此处睡眠2s，等待服务器把相关的工作准备好x0dx0a * 也是为了保证网络的延迟x0dx0a * 读者可自行选择添加此代码x0dx0a * */x0dx0a try {x0dx0a Thread.sleep(2000);x0dx0a } catch (InterruptedException e1) {x0dx0a e1.printStackTrace();x0dx0a }x0dx0ax0dx0a/**之前的准备工作结束之后x0dx0a * 下面就是文件传输的关键代码x0dx0a * */x0dx0a try {x0dx0a x0dx0a /**获取socket的OutputStream，以便向其中写入数据包*/x0dx0a os = s.getOutputStream();x0dx0a x0dx0a /** size 用来记录每次读取文件的大小*/x0dx0a int size = 0;x0dx0a x0dx0a /**使用while循环读取文件，直到文件读取结束*/x0dx0a while((size = fis.read(buffer)) != -1){x0dx0a System.out.println("客户端发送数据包，大小为" + size);x0dx0a /**向输出流中写入刚刚读到的数据包*/x0dx0a os.write(buffer, 0, size);x0dx0a /**刷新一下*/x0dx0a os.flush();x0dx0a }x0dx0a } catch (FileNotFoundException e) {x0dx0a System.out.println("客户端读取文件出错");x0dx0a } catch (IOException e) {x0dx0a System.out.println("客户端输出文件出错");x0dx0a }finally{x0dx0a x0dx0a /**x0dx0a * 将打开的文件关闭x0dx0a * 如有需要，也可以在此关闭socket连接x0dx0a * */x0dx0a try {x0dx0a if(fis != null)x0dx0a fis.close();x0dx0a } catch (IOException e) {x0dx0a System.out.println("客户端文件关闭出错");x0dx0a }//catch (IOException e)x0dx0a }//finallyx0dx0a x0dx0a }//public static void main(String[] args)x0dx0a}//public class ClientSend

Ⅱ 如何使用java远程传输文件，client只提供ip\文件路径等参数，server端无需部署服务！

其实有几种方式的，
1 ftp传输应用情况，加入在linux系统端有一些文件需要下载到用户电脑client端，而linux系统又不是web服务器，那么可以通过java程序FTP方式登录到linux，读取文件转换为流输出到用户IE端， java访问Linux服务器读取文件所需jar包：j2ssh-core-0.2.2.jar
2 socket方式，可以应用于比如server-client 聊天窗，传输文字；
3 http协议，这种就是最常用的了，比如打开IE下载，上传东西，java是通过jsp servlet来实现的，然后部署放在tomcat web 服务器上，在其他局域网环境下的电脑登录IE即可访问到。没有特殊jar，只用java servlet的jar即可。例子如附件，可能上传不成功哈，网络网络会有很多哈

Ⅲ java socket传送文件

客户端代码如下：

importjava.io.DataOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.net.Socket;

/**
*文件发送客户端主程序
*@authoradmin_Hzw
*
*/
publicclassBxClient{

/**
*程序main方法
*@paramargs
*@throwsIOException
*/
publicstaticvoidmain(String[]args)throwsIOException{
intlength=0;
doublesumL=0;
byte[]sendBytes=null;
Socketsocket=null;
DataOutputStreamdos=null;
FileInputStreamfis=null;
booleanbool=false;
try{
Filefile=newFile("D:/天啊.zip");//要传输的文件路径
longl=file.length();
socket=newSocket();
socket.connect(newInetSocketAddress("127.0.0.1",48123));
dos=newDataOutputStream(socket.getOutputStream());
fis=newFileInputStream(file);
sendBytes=newbyte[1024];
while((length=fis.read(sendBytes,0,sendBytes.length))>0){
sumL+=length;
System.out.println("已传输："+((sumL/l)*100)+"%");
dos.write(sendBytes,0,length);
dos.flush();
}
//虽然数据类型不同，但JAVA会自动转换成相同数据类型后在做比较
if(sumL==l){
bool=true;
}
}catch(Exceptione){
System.out.println("客户端文件传输异常");
bool=false;
e.printStackTrace();
}finally{
if(dos!=null)
dos.close();
if(fis!=null)
fis.close();
if(socket!=null)
socket.close();
}
System.out.println(bool?"成功":"失败");
}
}

服务端代码如下：

importjava.io.DataInputStream;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.Random;
importcom.boxun.util.GetDate;


/**
*接收文件服务
*@authoradmin_Hzw
*
*/
publicclassBxServerSocket{

/**
*工程main方法
*@paramargs
*/
publicstaticvoidmain(String[]args){
try{
finalServerSocketserver=newServerSocket(48123);
Threadth=newThread(newRunnable(){
publicvoidrun(){
while(true){
try{
System.out.println("开始监听...");
/*
*如果没有访问它会自动等待
*/
Socketsocket=server.accept();
System.out.println("有链接");
receiveFile(socket);
}catch(Exceptione){
System.out.println("服务器异常");
e.printStackTrace();
}
}
}
});
th.run();//启动线程运行
}catch(Exceptione){
e.printStackTrace();
}
}

publicvoidrun(){
}

/**
*接收文件方法
*@paramsocket
*@throwsIOException
*/
publicstaticvoidreceiveFile(Socketsocket)throwsIOException{
byte[]inputByte=null;
intlength=0;
DataInputStreamdis=null;
FileOutputStreamfos=null;
StringfilePath="D:/temp/"+GetDate.getDate()+"SJ"+newRandom().nextInt(10000)+".zip";
try{
try{
dis=newDataInputStream(socket.getInputStream());
Filef=newFile("D:/temp");
if(!f.exists()){
f.mkdir();
}
/*
*文件存储位置
*/
fos=newFileOutputStream(newFile(filePath));
inputByte=newbyte[1024];
System.out.println("开始接收数据...");
while((length=dis.read(inputByte,0,inputByte.length))>0){
fos.write(inputByte,0,length);
fos.flush();
}
System.out.println("完成接收："+filePath);
}finally{
if(fos!=null)
fos.close();
if(dis!=null)
dis.close();
if(socket!=null)
socket.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}
}

Ⅳ java中如何实现从客户端发送文件到服务器端

服务器端源码：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
*
* 文件名：ServerReceive.java
* 实现功能：作为服务器接收客户端发送的文件
*
* 具体实现过程：
* 1、建立SocketServer，等待客户端的连接
* 2、当有客户端连接的时候，按照双方的约定，这时要读取一行数据
* 其中保存客户端要发送的文件名和文件大小信息
* 3、根据文件名在本地创建文件，并建立好流通信
* 4、循环接收数据包，将数据包写入文件
* 5、当接收数据的长度等于提前文件发过来的文件长度，即表示文件接收完毕，关闭文件
* 6、文件接收工作结束

public class ServerReceive {

public static void main(String[] args) {

/**与服务器建立连接的通信句柄*/
ServerSocket ss = null;
Socket s = null;

/**定义用于在接收后在本地创建的文件对象和文件输出流对象*/
File file = null;
FileOutputStream fos = null;

/**定义输入流，使用socket的inputStream对数据包进行输入*/
InputStream is = null;

/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[4096 * 5];

/**用来接收文件发送请求的字符串*/
String comm = null;

/**建立socekt通信，等待服务器进行连接*/
try {
ss = new ServerSocket(4004);
s = ss.accept();
} catch (IOException e) {
e.printStackTrace();
}

/**读取一行客户端发送过来的约定信息*/
try {
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
comm = br.readLine();
} catch (IOException e) {
System.out.println("服务器与客户端断开连接");
}

/**开始解析客户端发送过来的请求命令*/
int index = comm.indexOf("/#");

/**判断协议是否为发送文件的协议*/
String xieyi = comm.substring(0, index);
if(!xieyi.equals("111")){
System.out.println("服务器收到的协议码不正确");
return;
}

/**解析出文件的名字和大小*/
comm = comm.substring(index + 2);
index = comm.indexOf("/#");
String filename = comm.substring(0, index).trim();
String filesize = comm.substring(index + 2).trim();

/**创建空文件，用来进行接收文件*/
file = new File(filename);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("服务器端创建文件失败");
}
}else{
/**在此也可以询问是否覆盖*/
System.out.println("本路径已存在相同文件，进行覆盖");
}

/**【以上就是客户端代码中写到的服务器的准备部分】*/

/**
* 服务器接收文件的关键代码*/
try {
/**将文件包装到文件输出流对象中*/
fos = new FileOutputStream(file);
long file_size = Long.parseLong(filesize);
is = s.getInputStream();
/**size为每次接收数据包的长度*/
int size = 0;
/**count用来记录已接收到文件的长度*/
long count = 0;

/**使用while循环接收数据包*/
while(count < file_size){
/**从输入流中读取一个数据包*/
size = is.read(buffer);

/**将刚刚读取的数据包写到本地文件中去*/
fos.write(buffer, 0, size);
fos.flush();

/**将已接收到文件的长度+size*/
count += size;
System.out.println("服务器端接收到数据包，大小为" + size);
}

} catch (FileNotFoundException e) {
System.out.println("服务器写文件失败");
} catch (IOException e) {
System.out.println("服务器：客户端断开连接");
}finally{
/**
* 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}//catch (IOException e)
}//finally

}//public static void main(String[] args)
}//public class ServerReceive

客户端源码：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

/**
*
* 文件名：ClientSend.java
* 实现功能：作为客户端向服务器发送一个文件
*
* 具体实现过程：
* 1、建立与服务器端的连接，IP：127.0.0.1， port：4004
* 2、将文件的名字和大小通过自定义的文件传输协议，发送到服务器
* 3、循环读取本地文件，将文件打包发送到数据输出流中
* 4、关闭文件，结束传输
*
* */

public class ClientSend {

public static void main(String[] args) {

/**与服务器建立连接的通信句柄*/
Socket s = null;

/**定义文件对象，即为要发送的文件
* 如果使用绝对路径，不要忘记使用'/'和'\'的区别
* 具体区别，请读者自行查询
* */
File sendfile = new File("API.CHM");
/**定义文件输入流，用来打开、读取即将要发送的文件*/
FileInputStream fis = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[4096 * 5];

/**定义输出流，使用socket的outputStream对数据包进行输出*/
OutputStream os = null;

/**检查要发送的文件是否存在*/
if(!sendfile.exists()){
System.out.println("客户端：要发送的文件不存在");
return;
}

/**与服务器建立连接*/
try {
s = new Socket("127.0.0.1", 4004);
}catch (IOException e) {
System.out.println("未连接到服务器");
}

/**用文件对象初始化fis对象
* 以便于可以提取出文件的大小
* */
try {
fis = new FileInputStream(sendfile);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}

/**首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作
* 具体的准备工作，请查看服务器代码。
*
* 发送的内容包括：发送文件协议码（此处为111）/#文件名（带后缀名）/#文件大小
* */
try {
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("111/#" + sendfile.getName() + "/#" + fis.available());
ps.flush();
} catch (IOException e) {
System.out.println("服务器连接中断");
}

/**
* 此处睡眠2s，等待服务器把相关的工作准备好
* 也是为了保证网络的延迟
* 读者可自行选择添加此代码
* */
try {
Thread.sleep(2000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}

/**之前的准备工作结束之后
* 下面就是文件传输的关键代码
* */
try {

/**获取socket的OutputStream，以便向其中写入数据包*/
os = s.getOutputStream();

/** size 用来记录每次读取文件的大小*/
int size = 0;

/**使用while循环读取文件，直到文件读取结束*/
while((size = fis.read(buffer)) != -1){
System.out.println("客户端发送数据包，大小为" + size);
/**向输出流中写入刚刚读到的数据包*/
os.write(buffer, 0, size);
/**刷新一下*/
os.flush();
}
} catch (FileNotFoundException e) {
System.out.println("客户端读取文件出错");
} catch (IOException e) {
System.out.println("客户端输出文件出错");
}finally{

/**
* 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fis != null)
fis.close();
} catch (IOException e) {
System.out.println("客户端文件关闭出错");
}//catch (IOException e)
}//finally

}//public static void main(String[] args)
}//public class ClientSend

Ⅳ 5 java 如何使用udp协议传送文件

//发送端SocketSendFile.java
import java.io.*;
import java.net.*;

public class SocketSendFile {
public static final int SER_PORT=666;
public static final int CLI_PORT=8484;
public static final String SER_IP="192.168.0.35";
public static int bufSize = 1024;
public static byte] mess = new bytebufSize];
//建立Socket引用
public static DatagramSocket dp;

public static void main(String] args) throws Exception {
dp = new DatagramSocket(SER_PORT);
//调用构造函数SocketSendFile,并传递参数args0](所要传输的文件名)
SocketSendFile(args0]);
}

public static void SocketSendFile(String file2) throws Exception {
//定义一个计数器
int pos =0;
//设置写入流
FileInputStream fis = new FileInputStream(file2);
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream dis = new DataInputStream(bis);

int i;
do {
i = dis.read();
int j=0;
while (j<1024 & i != -1) {
messpos++] = (byte) i;
i=dis.read();
j++;
}
dp.send(new DatagramPacket(mess,pos,InetAddress.getByName(SER_IP),CLI_PORT));
}
while (i != -1);
fis.close();
}
}

//接收端SocketReceiveFile.java
import java.net.*;
import java.io.*;

public class SocketReceiveFile {
public static int bufSize=1024;
public static byte] mess=new bytebufSize];
public static DatagramSocket dp;
public static final int SER_PORT=8484;

public static void main(String] args) throws Exception {
dp = new DatagramSocket(SER_PORT);
SocketReceiveFile(args0]);
}

public static void SocketReceiveFile(String file1) throws Exception {
FileOutputStream fos = new FileOutputStream(file1);
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream dos = new DataOutputStream(bos);

int i;
DatagramPacket p = new DatagramPacket(mess,mess.length);

while(true) {
boolean j=false;
while (p.getData().length != 0) {
dos.write(p.getData());
dp.receive(p);
j=true;
}
// System.out.println(new String(p.getData(),0,p.getLength()));
if (j)
System.out.println("文件传送完毕．");
}
// fos.close();
}
}

Ⅵ 关于用JAVA的SOCKET传输文件

点对点传输文件
/*
import java.io.*;
import java.net.*;
import java.util.*;
*/
private HttpURLConnection connection;//存储连接
private int downsize = -1;//下载文件大小,初始值为-1
private int downed = 0;//文加已下载大小,初始值为0
private RandomAccessFile savefile;//记录下载信息存储文件
private URL fileurl;//记录要下载文件的地址
private DataInputStream fileStream;//记录下载的数据流
try{
/*开始创建下载的存储文件,并初始化值*/
File tempfileobject = new File("h:\\webwork-2.1.7.zip");
if(!tempfileobject.exists()){
/*文件不存在则建立*/
tempfileobject.createNewFile();
}
savefile = new RandomAccessFile(tempfileobject,"rw");

/*建立连接*/
fileurl = new URL("https://webwork.dev.java.net/files/documents/693/9723/webwork-2.1.7.zip");
connection = (HttpURLConnection)fileurl.openConnection();
connection.setRequestProperty("Range","byte="+this.downed+"-");

this.downsize = connection.getContentLength();
//System.out.println(connection.getContentLength());

new Thread(this).start();
}
catch(Exception e){
System.out.println(e.toString());
System.out.println("构建器错误");
System.exit(0);
}
public void run(){
/*开始下载文件,以下测试非断点续传,下载的文件存在问题*/
try{
System.out.println("begin!");
Date begintime = new Date();
begintime.setTime(new Date().getTime());
byte[] filebyte;
int onecelen;
//System.out.println(this.connection.getInputStream().getClass().getName());
this.fileStream = new DataInputStream(
new BufferedInputStream(
this.connection.getInputStream()));
System.out.println("size = " + this.downsize);
while(this.downsize != this.downed){
if(this.downsize - this.downed > 262144){//设置为最大256KB的缓存
filebyte = new byte[262144];
onecelen = 262144;
}
else{
filebyte = new byte[this.downsize - this.downed];
onecelen = this.downsize - this.downed;
}
onecelen = this.fileStream.read(filebyte,0,onecelen);
this.savefile.write(filebyte,0,onecelen);
this.downed += onecelen;
System.out.println(this.downed);
}
this.savefile.close();
System.out.println("end!");
System.out.println(begintime.getTime());
System.out.println(new Date().getTime());
System.out.println(begintime.getTime() - new Date().getTime());
}
catch(Exception e){
System.out.println(e.toString());
System.out.println("run()方法有问题!");
}
}

/***
//FileClient.java
import java.io.*;
import java.net.*;
public class FileClient {
public static void main(String[] args) throws Exception {

//使用本地文件系统接受网络数据并存为新文件

File file = new File("d:\\fmd.doc");

file.createNewFile();

RandomAccessFile raf = new RandomAccessFile(file, "rw");

// 通过Socket连接文件服务器

Socket server = new Socket(InetAddress.getLocalHost(), 3318);
//创建网络接受流接受服务器文件数据
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();
}
}

//FileServer.java
import java.io.*;
import java.util.*;
import java.net.*;
public class FileServer {
public static void main(String[] args) throws Exception {

//创建文件流用来读取文件中的数据

File file = new File("d:\\系统特点.doc");

FileInputStream fos = new FileInputStream(file);

//创建网络服务器接受客户请求

ServerSocket ss = new ServerSocket(8801);

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();
}
}
*/

导航:首页 > 编程语言 > java传送文件

java传送文件

与java传送文件相关的资料