❶ java socket传送文件一直被阻塞
是不能等于-1撒..
他在等你那边给他写东西呢..
你应该在服务器端结束的时候给他写个东西过去..让他知道已经结束了..
还有什么问题HI我哈
但是read方法本身不就有告知客户端文件传送结束的功能么 当读到文件结束符的时候它会返回-1的啊
确实读文件结束就是-1...
但是你的客户端读的不是文件啊..服务器才是读文件..所以服务器能正常结束..
你的客户端读的服务器发来的东西..服务器读文件结束后就不给客户端发信息了..
而客户端的read()方法是阻塞式方法..意思就是服务器不传给他数据他就会一直等..
所以还是那样..在服务器端结束的时候给客户端发个消息说明已经结束了..客户端读到这个结束标志的时候也就不要再往文件里面写东西了..也结束..这样你的程序就正确了..
❷ 关于用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的socket进行文件传输谁能给个简单的例子，包括发送端和接收端。
java中的网络信息传输方式是基于TCP协议或者UD协议P的,socket是基于TCP协议的
例子1
（1）客户端程序：
import java.io.*;
import java.net.*;
public class Client
{ public static void main(String args[])
{ String s=null;
Socket mysocket;
DataInputStream in=null;
DataOutputStream out=null;
try{
mysocket=new Socket("localhost",4331);
in=new DataInputStream(mysocket.getInputStream());
out=new DataOutputStream(mysocket.getOutputStream());
out.writeUTF("你好！");//通过 out向"线路"写入信息。
while(true)
{
s=in.readUTF();//通过使用in读取服务器放入"线路"里的信息。堵塞状态，
//除非读取到信息。
out.writeUTF(":"+Math.random());
System.out.println("客户收到:"+s);
Thread.sleep(500);
}
}
catch(IOException e)
{ System.out.println("无法连接");
}
catch(InterruptedException e){}
}
}
（2）服务器端程序：
import java.io.*;import java.net.*;
public class Server
{ public static void main(String args[])
{ ServerSocket server=null;
Socket you=null;String s=null;
DataOutputStream out=null;DataInputStream in=null;
try{ server=new ServerSocket(4331);}
catch(IOException e1){System.out.println("ERRO:"+e1);}
try{ you=server.accept();
in=new DataInputStream(you.getInputStream());
out=new DataOutputStream(you.getOutputStream());
while(true)
{
s=in.readUTF();// 通过使用in读取客户放入"线路"里的信息。堵塞状态，
//除非读取到信息。
out.writeUTF("你好:我是服务器");//通过 out向"线路"写入信息.
out.writeUTF("你说的数是:"+s);
System.out.println("服务器收到:"+s);
Thread.sleep(500);
}
}
catch(IOException e)
{ System.out.println(""+e);
}
catch(InterruptedException e){}
}
}
例子(2)
(1) 客户端
import java.net.*;import java.io.*;
import java.awt.*;import java.awt.event.*;
import java.applet.*;
public class Computer_client extends Applet implements Runnable,ActionListener
{ Button 计算;TextField 输入三边长度文本框,计算结果文本框;
Socket socket=null;
DataInputStream in=null; DataOutputStream out=null;
Thread thread;
public void init()
{ setLayout(new GridLayout(2,2));
Panel p1=new Panel(),p2=new Panel();
计算=new Button(" 计算");
输入三边长度文本框=new TextField(12);计算结果文本框=new TextField(12);
p1.add(new Label("输入三角形三边的长度,用逗号或空格分隔:"));
p1.add( 输入三边长度文本框);
p2.add(new Label("计算结果："));p2.add(计算结果文本框);p2.add(计算);
计算.addActionListener(this);
add(p1);add(p2);
}
public void start()
{ try
{ //和小程序所驻留的服务器建立套接字连接：
socket = new Socket(this.getCodeBase().getHost(), 4331);
in =new DataInputStream(socket.getInputStream());
out = new DataOutputStream(socket.getOutputStream());
}
catch (IOException e){}
if(thread == null)
{ thread = new Thread(this);
thread.start();
}
}
public void run()
{ String s=null;
while(true)
{ try{ s=in.readUTF();//堵塞状态，除非读取到信息。
计算结果文本框.setText(s);
}
catch(IOException e)
{ 计算结果文本框.setText("与服务器已断开");
break;
}
}
}
public void actionPerformed(ActionEvent e)
{ if(e.getSource()==计算)
{ String s=输入三边长度文本框.getText();
if(s!=null)
{ try { out.writeUTF(s);
}
catch(IOException e1){}
}
}
}
}
(2) 服务器端
import java.io.*;import java.net.*;
import java.util.*;import java.sql.*;
public class Computer_server
{ public static void main(String args[])
{ ServerSocket server=null;Server_thread thread;
Socket you=null;
while(true)
{ try{ server=new ServerSocket(4331);
}
catch(IOException e1)
{ System.out.println("正在监听"); //ServerSocket对象不能重复创建。
}
try{ you=server.accept();
System.out.println("客户的地址:"+you.getInetAddress());
}
catch (IOException e)
{ System.out.println("正在等待客户");
}
if(you!=null)
{ new Server_thread(you).start(); //为每个客户启动一个专门的线程。
}
else
{ continue;
}
}
}
}
class Server_thread extends Thread
{ Socket socket;Connection Con=null;Statement Stmt=null;
DataOutputStream out=null;DataInputStream in=null;int n=0;
String s=null;
Server_thread(Socket t)
{ socket=t;
try { in=new DataInputStream(socket.getInputStream());
out=new DataOutputStream(socket.getOutputStream());
}
catch (IOException e)
{}
}
public void run()
{ while(true)
{ double a[]=new double[3] ;int i=0;
try{ s=in.readUTF();堵塞状态，除非读取到信息。
StringTokenizer fenxi=new StringTokenizer(s," ,");
while(fenxi.hasMoreTokens())
{ String temp=fenxi.nextToken();
try{ a[i]=Double.valueOf(temp).doubleValue();i++;
}
catch(NumberFormatException e)
{ out.writeUTF("请输入数字字符");
}
}
double p=(a[0]+a[1]+a[2])/2.0;
out.writeUTF(" "+Math.sqrt(p*(p-a[0])*(p-a[1])*(p-a[2])));
sleep(2);
}
catch(InterruptedException e){}
catch (IOException e)
{ System.out.println("客户离开");
break;
}
}
}
}
这些例子都是Java2实用教程上的.
❹ 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怎么通过socket传输各种类型文件
IO
流的概念 什么叫流？
管道 -
流的分类
字节流 字符流
节点流 过滤流 （包装流 处理流 功能流）
输入流 输出流
InputStream抽象类 所有字节输入流统一的父类
OutputStream抽象类 所有字节输出流统一的父类
FileInputStream节点流 能够连接文件作为节点
int read() 无参read 一次读取一个字节 返回的就是字节数据
int read(byte[] data)*
int read(byte[] data,int off,int len)
FileOutputStream
构造方法：File Stringboolean append
*:输出流连接的文件会被自动创建出来 如果已存在那么替换
*:但是输出流连接的文件夹都不存在 直接Exception
write(int data)
write(byte[] data)
write(byte[] data,int off,int len)*
BufferedInputStream(节点输入流[,缓冲空间大小])
BufferedOutputStream(节点输出流[,缓冲空间大小])
*：它们是过滤流 包装流 处理流 它们只能连接节点流 不能直接连文件
使用它们俩是为了提供缓冲空间 从而大幅度的提高每次读写的
吞吐量 从而提高效率
*：Buffered 意味着有缓冲空间 一定要清空缓冲区
flush();
close();
*:一定注意 你可以使用的依然是read方法来实现读取 write 写出
read() read(byte[] data,int off,int len)
write(int data) write(byte data,int off,int len)
DataInputStream
DataOutputStream
*：它们是过滤刘 包装流 处理流 它们只能连接节点流 不能直接连文件
使用他们俩是为了提供读写基本数据类型内存原型的功能
readBoolean()readInt()readLong()
writeBoolean()writeInt()writeLong()
ObjectInputStream
ObjectOutputStream
*：它们是过滤刘 包装流 处理流 它们只能连接节点流 不能直接连文件
使用他们俩是为了能够提供对象持久化的功能
把Java当中不是基本数据类型的对象类型也能保存到文件中
implements Serializable
一个类型的对象如果想被持久化 那么这个类型必须序列化
而且当中所有的属性页必须实现序列化接口
如果是个集合概念 那么不但这个类型需要序列化
当中存放的任何一个元素都需要序列化
readObject()writeObject()
*:如果一个属性不需要参与持久化 那么可以直接把属性定义
为 transient 短暂的 转瞬即逝的
Reader抽象类 所有字符输入流统一的父类
Writer抽象类 所有字符输出流统一的父类
FileReader
int read() 无参read 一次读取一个字符 返回的就是字符数据
int read(char[] data)
int read(char[] data,int off,int len)
FileWriter
*:输出流连接的文件会被自动创建出来 如果已存在那么替换
*:但是输出流连接的文件夹都不存在 直接Exception
write(int data)
write(char[] data)
write(char[] data,int off,int len);
过滤流 包装流 处理流
BufferedReader
String readLine() 一次读取一行
字符串不能返回-1 返回null代表读取结束
BufferedWriter
write(String str) 写出字符串的方法
newLine() 写出一个换行标识
PrintStreamSystem.out
PrintWriter
太有魅力了 太强大了
1.可以连接字符流也可以连接字节流
2.可以当做节点流也可以当做过滤流
3.能够指定自动清空缓冲 (流,true) autoFlush
4.可以指定字符集 字符编码
5.一个println() = write()+newLine()
InputStreamReader
OutputStreamWriter
将原本的字节流包装转换成字符流
RandomAccessFilesetLength();
Socket
服务器 ServerSocket ss = new ServerSocket(7777);
while(true){
Socket s = ss.accept()
new XxxThread(s).start();
}
客户端 Socket socket = new Socket(ip,port);
getInputStream();
getOutputStream();
❻ 用java socket实现一个服务器对多个客户端的文件传输
通过socket可以用如下方式进行。
1.启动服务端代码。
2.启动客户端自动连接服务端。
3.服务端上传文件，保存文件和路径。
4.将路径发送给连接服务端的客户端。
❼ 利用java 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 java.net.ServerSocket;
import java.net.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 BufferedInputStream(s.getInputStream()));
dis.readByte();
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
DataOutputStream ps = new DataOutputStream(s.getOutputStream());
//将文件名及长度传给客户端。这里要真正适用所有平台，例如中文名的处理，还需要加工，具体可以参见Think In Java 4th里有现成的代码。
ps.writeUTF(fi.getName());
ps.flush();
ps.writeLong((long) fi.length());
ps.flush();
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
while (true) {
int read = 0;
if (fis != null) {
read = fis.read(buf);
}
if (read == -1) {
break;
}
ps.write(buf, 0, read);
}
ps.flush();
// 注意关闭socket链接哦，不然客户端会等待server的数据过来，
// 直到socket超时，导致数据不完整。
fis.close();
s.close();
System.out.println("文件传输完成");
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String arg[]) {
new ServerTest().start();
}
}
2.socket的Util辅助类
package sterning;
import java.net.*;
import java.io.*;
public class ClientSocket {
private String ip;
private int port;
private Socket socket = null;
DataOutputStream out = null;
DataInputStream getMessageStream = null;
public ClientSocket(String ip, int port) {
this.ip = ip;
this.port = port;
}
/** *//**
* 创建socket连接
*
* @throws Exception
* exception
*/
public void CreateConnection() throws Exception {
try {
socket = new Socket(ip, port);
} catch (Exception e) {
e.printStackTrace();
if (socket != null)
socket.close();
throw e;
} finally {
}
}
public void sendMessage(String sendMessage) throws Exception {
try {
out = new DataOutputStream(socket.getOutputStream());
if (sendMessage.equals("Windows")) {
out.writeByte(0x1);
out.flush();
return;
}
if (sendMessage.equals("Unix")) {
out.writeByte(0x2);
out.flush();
return;
}
if (sendMessage.equals("Linux")) {
out.writeByte(0x3);
out.flush();
} else {
out.writeUTF(sendMessage);
out.flush();
}
} catch (Exception e) {
e.printStackTrace();
if (out != null)
out.close();
throw e;
} finally {
}
}
public DataInputStream getMessageStream() throws Exception {
try {
getMessageStream = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
return getMessageStream;
} catch (Exception e) {
e.printStackTrace();
if (getMessageStream != null)
getMessageStream.close();
throw e;
} finally {
}
}
public void shutDownConnection() {
try {
if (out != null)
out.close();
if (getMessageStream != null)
getMessageStream.close();
if (socket != null)
socket.close();
} catch (Exception e) {
}
}
}
3.客户端
package sterning;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class ClientTest {
private ClientSocket cs = null;
private String ip = "localhost";// 设置成服务器IP
private int port = 8821;
private String sendMessage = "Windwos";
public ClientTest() {
try {
if (createConnection()) {
sendMessage();
getMessage();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
private boolean createConnection() {
cs = new ClientSocket(ip, port);
try {
cs.CreateConnection();
System.out.print("连接服务器成功!" + "\n");
return true;
} catch (Exception e) {
System.out.print("连接服务器失败!" + "\n");
return false;
}
}
private void sendMessage() {
if (cs == null)
return;
try {
cs.sendMessage(sendMessage);
} catch (Exception e) {
System.out.print("发送消息失败!" + "\n");
}
}
private void getMessage() {
if (cs == null)
return;
DataInputStream inputStream = null;
try {
inputStream = cs.getMessageStream();
} catch (Exception e) {
System.out.print("接收消息缓存错误\n");
return;
}
try {
//本地保存路径，文件名会自动从服务器端继承而来。
String savePath = "E:\\";
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
int passedlen = 0;
long len=0;
savePath += inputStream.readUTF();
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(savePath))));
len = inputStream.readLong();
System.out.println("文件的长度为:" + len + "\n");
System.out.println("开始接收文件!" + "\n");
while (true) {
int read = 0;
if (inputStream != null) {
read = inputStream.read(buf);
}
passedlen += read;
if (read == -1) {
break;
}
//下面进度条本为图形界面的prograssBar做的，这里如果是打文件，可能会重复打印出一些相同的百分比
System.out.println("文件接收了" + (passedlen * 100/ len) + "%\n");
fileOut.write(buf, 0, read);
}
System.out.println("接收完成，文件存为" + savePath + "\n");
fileOut.close();
} catch (Exception e) {
System.out.println("接收消息错误" + "\n");
return;
}
}
public static void main(String arg[]) {
new ClientTest();
}
}
❽ java socket多文件传输问题
用多线程,每个线程创建一个socket连接,每个socket连接负责传输一个文件,服务端的serversocket每次accept一个socket连接,也建立一个新线程,该线程负责对应socket的文件传输
每个文件写入完毕的时候关闭输出流,建新文件后重新建立输出流用于写入
❾ java中怎么用socket 一次传多个文件啊
java中用socket一次传多个文件，参考思路如下：
1、把线程放到Vector 线程池里面；
2 、每次从Vector里面拿到第一个空闲的，如果没有，就新建一个线程，并保存到线程池， 线程状态为使用中；
3 、线程完毕后，通知管理类，管理类把线程标识为空闲；
可以封装为简单的方法，如下：
public MyThread getFreeThread(){
.. // 从池里面获取一个空闲线程
}
public void finished(MyThread o){
// 线程通知管理类，我已经完成了
}