java socket文件传输（java 使用ServerSocket和Socket实现文件传输）

本文目录

• java 使用ServerSocket和Socket实现文件传输
• JAVA怎么通过socket传输各种类型文件
• JAVA SOCKET文件传输问题
• 关于用JAVA的SOCKET传输文件
• 用java socket实现一个服务器对多个客户端的文件传输
• JAVA socket传输二进制文件问题
• 在JAVA的socket中进行传输对象和文件
• java中怎么用socket 一次传多个文件啊
• java socket传送文件

java 使用ServerSocket和Socket实现文件传输

ServerSocket server=new ServerSocket（port）；
Socket socket=server.accept（）；
byte b=new byte；
int len=0；
while（（len=socket.read（b，0，b.length））！=-1）{
}

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好久没用了哈哈
依稀记得有个方法是socket.shutdownouputstream,告诉对方已经传输完毕，这时候就可以先断client再断service就不会报错啦

关于用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;
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;

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;

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实现一个服务器对多个客户端的文件传输

通过socket可以用如下方式进行。
1.启动服务端代码。
2.启动客户端自动连接服务端。
3.服务端上传文件，保存文件和路径。
4.将路径发送给连接服务端的客户端。

JAVA socket传输二进制文件问题

可能LZ对使用浏览器进行用户名密码认证比较清楚
SOCKET走的是TCP/IP协议，而浏览器方式走的是HTTP协议
不管哪种方式，都是通过客户端程序上发到服务器端，而浏览器方式的通道都是默认OK的，而TCP方式则需要通过SOCKET来建立通道，传输的数据是通过报文格式，报文你可以理解是一串东东，这个东东可以是二进制，可以是十进制，可以是字符串
对于进行用户名密码认证，你看成是字符串就行了
根据客户端和服务端规定好的报文格式进行解析，验证的工作和HTTP协议的方式一样，简单来说就是放在servlet上进行。
区别就是，SOCKET要自己建立连接以及自己制定报文格式，而浏览器方式只要通过request方式传送就OK了

在JAVA的socket中进行传输对象和文件

服务端监听：ServerSocket server=new ServerSocket(port);//port：绑定的端口号
Socket client=server.accept();//监听端口，一旦取得连接则获得客户端的socket连接对象client

客户端： Socket s=new Socket(ip,port);//要连接的服务器的ip以及端口号

如果正常连接上之后，socket的对象可以获得InputStream和OutputStreame，然后就可以进行通信了

完成通信之后，执行socket对象的close（）方法关闭连接，完成一次完整的socket连接

java中怎么用socket 一次传多个文件啊

　　java中用socket一次传多个文件，参考思路如下：
　　1、把线程放到Vector 线程池里面；
　　2 、每次从Vector里面拿到第一个空闲的，如果没有，就新建一个线程，并保存到线程池， 线程状态为使用中；
　　3 、线程完毕后，通知管理类，管理类把线程标识为空闲；
　　可以封装为简单的方法，如下：
　　public MyThread getFreeThread(){
　　.. // 从池里面获取一个空闲线程
　　}
　　
　　public void finished(MyThread o){
　　// 线程通知管理类，我已经完成了
　　}

java socket传送文件

客户端代码如下：

import java.io.DataOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.net.Socket;  
  
/** 
 * 文件发送客户端主程序 
 * @author admin_Hzw 
 * 
 */  
public class BxClient {  
      
    /** 
     * 程序main方法 
     * @param args 
     * @throws IOException 
     */  
    public static void main(String args) throws IOException {  
        int length = 0;  
        double sumL = 0 ;  
        byte sendBytes = null;  
        Socket socket = null;  
        DataOutputStream dos = null;  
        FileInputStream fis = null;  
        boolean bool = false;  
        try {  
            File file = new File(“D:/天啊.zip“); //要传输的文件路径  
            long l = file.length();   
            socket = new Socket();    
            socket.connect(new InetSocketAddress(“127.0.0.1“, 48123));  
            dos = new DataOutputStream(socket.getOutputStream());  
            fis = new FileInputStream(file);        
            sendBytes = new byte;    
            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 (Exception e) {  
            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?“成功“:“失败“);  
    }  
}

服务端代码如下：

import java.io.DataInputStream;  
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.net.ServerSocket;  
import java.net.Socket;  
import java.util.Random;  
import com.boxun.util.GetDate;  
  
  
/** 
 * 接收文件服务 
 * @author admin_Hzw 
 * 
 */  
public class BxServerSocket {  
      
    /** 
     * 工程main方法 
     * @param args 
     */  
    public static void main(String args) {  
        try {  
            final ServerSocket server = new ServerSocket(48123);  
            Thread th = new Thread(new Runnable() {  
                public void run() {  
                    while (true) {  
                        try {    
                            System.out.println(“开始监听...“);  
                            /* 
                             * 如果没有访问它会自动等待 
                             */  
                            Socket socket = server.accept();  
                            System.out.println(“有链接“);  
                            receiveFile(socket);  
                        } catch (Exception e) {  
                            System.out.println(“服务器异常“);  
                            e.printStackTrace();  
                        }  
                    }  
                }  
            });  
            th.run(); //启动线程运行  
        } catch (Exception e) {  
            e.printStackTrace();  
        }       
    }  
  
    public void run() {  
    }  
  
    /** 
     * 接收文件方法 
     * @param socket 
     * @throws IOException 
     */  
    public static void receiveFile(Socket socket) throws IOException {  
        byte inputByte = null;  
        int length = 0;  
        DataInputStream dis = null;  
        FileOutputStream fos = null;  
        String filePath = “D:/temp/“+GetDate.getDate()+“SJ“+new Random().nextInt(10000)+“.zip“;  
        try {  
            try {  
                dis = new DataInputStream(socket.getInputStream());  
                File f = new File(“D:/temp“);  
                if(!f.exists()){  
                    f.mkdir();    
                }  
                /*   
                 * 文件存储位置   
                 */  
                fos = new FileOutputStream(new File(filePath));      
                inputByte = new byte;     
                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 (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}