java p2p多文件传输程序的实现,主要利用了java中的socket，SocketThread类,下面是实现过程,Server.java类，//psp文件传输服务，SocketThread.java//文件传输线程类，Application1.java import java.net.*; import java.util.List; public class Server extends Thread { public Server() { try { jbInit(); } catch (Exception ex) { ex.printStackTrace(); } }
源码中得类有:
Application1.java//程序启动类
MainFrame.java//文件传输程序的主界面类
Server.java//传输程序的服务类，主要实现p2p文件传输
SettingDialog.java//传输文件设置类，比如端口，线程数
SocketThread.java//线程类
TransFileDialog.java//选择传输文件对话框
TransFileManager.java//
TransFilePanel.java//panel
SocketThread.java类代码
package trans;
import java.net.Socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.*;
import java.net.*;
/**
* Socket线程
*/
public class SocketThread extends Thread {
public SocketThread() {
try {
jbInit();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public final static int CACHE_SIZE = 10240; //缓存大小
public final static int FILE_TRANS_STATUS_FILENAME = 0x01; //文件名传输状态
public final static int FILE_TRANS_STATUS_CONTEXT = 0x02; //文件内容传输状态
public final static int FILE_TRANS_STATUS_WAITFORCONFIRM = 0x03; //等待确认接收文件
public final static int FILE_TRANS_STATUS_SUCCESS = 0x04; //文件传输成功
public final static int FILE_TRANS_STATUS_FAIL = 0x05; //文件传输失败
public final static int FILE_TRANS_STATUS_CANCELTRANS = 0x06; //取消文件传输
public final static int PACKAGE_TYPE_FILENAME = 0x01; //文件名包
public final static int PACKAGE_TYPE_CONTEXT = 0x02; //文件内容包
public final static int PACKAGE_TYPE_CONFIRMRECEIVE = 0x03; //是否接收文件
private Socket aSocket; //套接字
private String serverName; //服务器名称
private DataInputStream dis; //输入流
private DataOutputStream dos; //输出流
private DataInputStream fDis; //文件输入流
private RandomAccessFile raf; //文件输出流
private boolean fileSender = false; //文件发送者
private boolean running = false; //线程运行
public int fileTransStatus = 0x0; //文件传输状态
private File aFile; //传输的文件
public long fileSize; //文件大小
private String fileName; //文件名称
private String errorMessage; //错误消息
private long transFileLength = 0; //已传输字节数
private byte [] dataBuf;
private String message; //验证消息
private String IP; //目标IP
private int port; //目标端口
private boolean fileTransed=false; //文件是否已经开始传输
int count=0;
//接收者构造函数
public SocketThread(Socket aSocket) {
this.aSocket = aSocket;
try {
aSocket.setSoTimeout(300000);
} catch (SocketException ex) {
}
byte[] address = aSocket.getInetAddress().getAddress();
IP = (address[0] & 0xff) + "." + (address[1] & 0xff) + "." +
(address[2] & 0xff) + "." + (address[3] & 0xff);
try {
dis = new DataInputStream(aSocket.getInputStream());
dos = new DataOutputStream(aSocket.getOutputStream());
fileTransStatus = FILE_TRANS_STATUS_FILENAME;
} catch (IOException ex) {
setError("创建连接错误！");
}
try {
aSocket.setReceiveBufferSize(CACHE_SIZE*2);
} catch (SocketException ex1) {
ex1.printStackTrace();
}
dataBuf=new byte[CACHE_SIZE+100];
}
//发送者构造函数
public SocketThread(String serverName, int portNo, String fileName,
String message) {
aFile = new File(fileName);
this.fileName = aFile.getName();
this.fileSize = fileSize;
fileSender = true;
if (message != null) {
this.message = message;
}
this.IP = serverName;
this.port = portNo;
dataBuf=new byte[CACHE_SIZE];
}
//线程执行函数
public void run() {
running = true;
if (fileSender) {
try {
aSocket = new Socket(IP, port);
aSocket.setSoTimeout(300000);
aSocket.setSendBufferSize(CACHE_SIZE*2);
dos = new DataOutputStream(aSocket.getOutputStream());
dis = new DataInputStream(aSocket.getInputStream());
fDis = new DataInputStream(new FileInputStream(aFile));
fileTransStatus = FILE_TRANS_STATUS_FILENAME;
} catch (UnknownHostException ex1) {
ex1.printStackTrace();
setError("连接服务器错误！");
} catch (IOException ex1) {
ex1.printStackTrace();
setError("创建连接错误！");
}
} while (running) {
if (fileSender) {
sendFile();
} else {
receiveFile();
}
try {
Thread.sleep(6);
} catch (InterruptedException ex) {
}
}
}
//从socket读
private int readFromSocket(byte[] data) throws IOException {
int length = 0;
length = fDis.read(data);
return length;
}
//从socket读
private int readFromSocket() throws IOException {
int buf = 0;
buf = dis.readInt();
return buf;
}
//从文件读
private int readFromFile(byte[] data,int off,int length) {
int len=0;
try {
len = fDis.read(data,off,length);
} catch (IOException ex) {
setError("文件读取错误！");
}
return len;
}
//写入socket
private void writeToSocket(byte[] data) throws IOException {
dos.write(data);
}
//写入文件
private void writeToFile(byte[] data,int off,int length) throws IOException {
raf.write(data,off,length);
}
//写入socket
private void writeToSocket(int data) throws IOException {
dos.writeInt(data);
}
private void writeToSocket(long data) throws IOException {
dos.writeLong(data);
}
private long readLongFromSocket() throws IOException {
return dis.readLong();
}
//打包
private byte[] doPackage(byte[] data, int length) throws IOException {
ByteArrayOutputStream buf = new ByteArrayOutputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream bufDos = new DataOutputStream(buf);
DataOutputStream baosDos = new DataOutputStream(baos);
switch (fileTransStatus) {
case FILE_TRANS_STATUS_FILENAME: {
bufDos.writeInt(PACKAGE_TYPE_FILENAME);
bufDos.writeInt(fileName.getBytes().length);
bufDos.write(fileName.getBytes());
bufDos.writeLong(fileSize);
if (message!=null) {
bufDos.writeInt(message.getBytes().length);
bufDos.write(message.getBytes());
} else {
bufDos.writeInt(-1);
}
baosDos.writeInt(buf.toByteArray().length);
baosDos.write(buf.toByteArray());
break;
}
case FILE_TRANS_STATUS_CONTEXT: {
bufDos.writeInt(PACKAGE_TYPE_CONTEXT);
if ((transFileLength + length) >= fileSize) {
bufDos.writeInt(0);
} else {
bufDos.writeInt(1);
}
bufDos.writeInt(length);
bufDos.write(data, 0, length);
baosDos.writeInt(buf.toByteArray().length);
baosDos.write(buf.toByteArray());
break;
}
}
return baos.toByteArray();
}
//停止线程
public void stopThread() {
running = false;
try {
if (dis != null) {
dis.close();
}
if (dos != null) {
dos.close();
}
if (fDis != null) {
fDis.close();
}
if (raf != null) {
raf.close();
}
} catch (Exception ex) {
}
}
//解包
private void upPackage(byte[] data) {
ByteArrayInputStream bias = new ByteArrayInputStream(data);
DataInputStream biasDis = new DataInputStream(bias);
int type = 0;
try {
type = biasDis.readInt();
} catch (SocketTimeoutException ex) {
setError("网络超时！");
} catch (IOException ex1) {
setError("对方取消了文件传输或网络错误！");
}
switch (type) {
case PACKAGE_TYPE_FILENAME: {
try {
int length = biasDis.readInt();
bias.read(dataBuf,0,length);
fileName = new String(dataBuf,0,length);
fileSize = biasDis.readLong();
length = biasDis.readInt();
if (length !=-1) {
bias.read(dataBuf,0,length);
message = new String(dataBuf,0,length);
}
fileTransStatus = FILE_TRANS_STATUS_WAITFORCONFIRM;
} catch (SocketTimeoutException ex) {
setError("网络超时！");
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
break ;
}
case PACKAGE_TYPE_CONTEXT: {
try {
int flag = biasDis.readInt();
int length = biasDis.readInt();
bias.read(dataBuf,0,length);
writeToFile(dataBuf,0,length);
transFileLength += length;
if (flag == 0) {
fileTransStatus = FILE_TRANS_STATUS_SUCCESS;
stopThread();
}
} catch (SocketTimeoutException ex) {
setError("网络超时！");
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
break ;
}
}
}
//发送文件
private void sendFile() {
int length;
switch (fileTransStatus) {
case FILE_TRANS_STATUS_FILENAME: {
try {
byte [] buf;
fileName = aFile.getName();
fileSize = aFile.length();
buf = doPackage(null, 0);
writeToSocket(buf);
fileTransStatus = FILE_TRANS_STATUS_WAITFORCONFIRM;
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
break ;
}
case FILE_TRANS_STATUS_WAITFORCONFIRM: {
int flag;
try {
flag = readFromSocket();
if (flag == 0) {
setError("对方拒绝了文件传输！");
} else {
fileTransStatus = FILE_TRANS_STATUS_CONTEXT;
transFileLength = readLongFromSocket();
fDis.skip(transFileLength);
aSocket.setSoTimeout(30000);
}
} catch (SocketTimeoutException ex) {
setError("网络超时！");
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
break ;
}
case FILE_TRANS_STATUS_CONTEXT: {
length = readFromFile(dataBuf,0,CACHE_SIZE);
try {
writeToSocket(doPackage(dataBuf, length));
transFileLength += length;
if (transFileLength >= fileSize) {
fileTransStatus = FILE_TRANS_STATUS_SUCCESS;
Thread.sleep(1000);
stopThread();
}
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
} catch (InterruptedException ex1) {
}
count++;
if(count==2){
//stopThread();
}
break ;
}
}
}
//接收文件
private void receiveFile() {
if (fileTransStatus == FILE_TRANS_STATUS_CONTEXT ||
fileTransStatus == FILE_TRANS_STATUS_FILENAME) {
try {
int length = dis.readInt();
int len=dis.read(dataBuf,0,length);
while(len<length){
len=len+dis.read(dataBuf,len,length-len);
}
upPackage(dataBuf);
} catch (SocketTimeoutException ex) {
setError("网络超时！");
ex.printStackTrace();
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
} else if (fileTransStatus == FILE_TRANS_STATUS_CANCELTRANS) {
try {
doPackage(null, 0);
} catch (IOException ex1) {
}
setError("已取消文件传输！");
}
}
//确认是否接收文件
public void confirmReceiveFile(boolean flag, String fileName, long off) {
if (flag) {
try {
writeToSocket(1);
if (off >0) {
writeToSocket(off);
} else {
writeToSocket(0L);
File aFile=new File(fileName);
if(aFile.exists()){
System.out.println("*");
aFile.delete();
}
}
raf = new RandomAccessFile(fileName, "rws");
this.fileName = fileName;
fileTransStatus = FILE_TRANS_STATUS_CONTEXT;
fileTransed=true;
raf.seek(off);
} catch (FileNotFoundException ex) {
setError("创建文件错误！");
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
transFileLength = off;
} else {
try {
writeToSocket(0);
writeToSocket(0L);
} catch (IOException ex) {
setError("对方取消了文件传输或网络错误！");
}
}
}
//返回已传输字节数
public long getTransFileLength() {
return transFileLength;
}
//设置错误消息
public void setError(String errorMessage) {
fileTransStatus = FILE_TRANS_STATUS_FAIL;
this.errorMessage = errorMessage;
if (!fileSender&&fileTransed) {
File tmpFile = new File(fileName + ".tmp");
try {
DataOutputStream dos = new DataOutputStream(new
FileOutputStream(
tmpFile));
dos.writeLong(transFileLength);
dos.writeLong(fileSize);
dos.close();
} catch (IOException ex) {
}
}
stopThread();
}
//返回错误消息
public String getErrorMessage() {
return errorMessage;
}
//返回传输状态
public int getStatus() {
return fileTransStatus;
}
//是否是文件发送者
public boolean isFileSender() {
return fileSender;
}
public void cancelTrans() {
if (fileTransStatus == FILE_TRANS_STATUS_WAITFORCONFIRM) {
confirmReceiveFile(false, null, 0);
}
setError("已取消文件传输！");
}
public String getMessage() {
return message;
}
public String getIP() {
return IP;
}
public int getPort() {
return port;
}
public String getFileName() {
if (fileName.length() > 10) {
return fileName.substring(0, 10) + "..." +
fileName.substring(fileName.lastIndexOf('.'),
fileName.length());
} else {
return fileName;
}
}
public String getFileTransMessage(){
if(fileSender){
return "文件发送 目标IP: "+getIP()+" 端口:"+getPort();
}
else{
return "文件接收 来自: "+getIP();
}
}
private void jbInit() throws Exception {
}
}
由于文件太多，无法一一简绍，如果需要进一步了解p2p文件传输你可以下载改源码，下载地址:
http://www.ie1.cn/Code-Source/Java_Code/bttxt-207.html
相关推荐
以上知识点都是构建基于Java的P2P文件传输系统所必需的。实际项目可能还会涉及更多细节，如网络拓扑的动态管理、节点的信用评估等。通过这个项目，你可以深入理解P2P网络的工作原理，并锻炼Java编程及网络编程的实际...
Java P2P文件传输利用P2P网络架构，其中每个节点既是服务的消费者也是服务的提供者。在Java中，这通常涉及到创建客户端和服务器端的类，分别用于发起请求和响应请求。这些节点可以动态地加入和离开网络，形成一个去...
使用JAVA进行P2P文件传输，首先需要掌握JAVA编程基础，包括类、对象、接口、多线程、网络编程等。JAVA的Socket编程是实现P2P通信的关键，它提供了在两台计算机之间建立TCP连接的能力，使得数据可以流经这个连接进行...
标题中的“java简单实现p2p”指的是使用Java编程语言实现一种简单的对等网络（Peer-to-Peer，简称P2P）系统。P2P网络是一种分布式网络架构，其中每个节点既是服务的提供者也是消费者，不同于传统的客户端-服务器模型...
笔者一直想寻求一种简 单有效，且具备多线程断点续传的方法来实现点与点之间的文件传送问题，经过大量的翻阅资料与测试，终于实现了，现把它共享出来，与大家分享。 我写了一个以此为基础的实用程序（网络传圣，包含...
【描述】：“p2p文件共享程序 java课程设计 java设计……” 本文将详细解析基于Java实现的P2P（peer-to-peer）文件共享程序的设计与实现，这是一种利用互联网技术让网络中的每个节点（用户）可以直接互相分享资源的...
Java文件传输工具是一种基于Java开发的应用程序，设计用于实现基本的点对点（P2P）文件传输功能。这个工具提供了简单易用的界面，让用户能够方便地在两台计算机之间共享和移动文件。以下是对该工具核心特性和技术...
标题和描述中提到的"P2P文件传输和聊天系统Internet网络编程P2P程序"是一个关于构建基于P2P（Peer-to-Peer）技术的文件共享和即时通讯平台的主题。在本文中，我们将深入探讨P2P技术的核心原理、网络编程基础以及如何...
在Java中实现P2P文件传输，可以使用Socket编程来创建两个或多个节点之间的连接，允许数据的双向流动。这通常涉及到TCP或UDP协议的选择，TCP保证数据的可靠传输，UDP则提供更高的传输速度但不保证数据的顺序或完整性...
【P2P聊天程序（JAVA）】是一种网络通信应用程序，它使用对等网络（P2P，Peer-to-Peer）架构来实现用户之间的实时交流。P2P技术允许网络中的每个节点既是客户端也是服务器，因此在聊天程序中，每个用户都可以发送和...
综上所述，这个项目结合了P2P文件传输的原理、Java的Socket编程技术、Java Swing的GUI设计以及SQLite数据库的使用，构建了一个高效、便捷的文件分享平台。通过这样的系统，用户可以在局域网内轻松地共享和接收文件，...
标题 "P2P文件传输源代码" 暗示了我们正在讨论的是一个涉及P2P（Peer-to-Peer）技术的文件传输软件项目。P2P网络是一种分布式架构，其中每个参与者，即“对等节点”，既是服务的消费者也是服务的提供者，允许用户...
Java实现的P2P即时聊天程序是一个基于网络通信技术的软件应用，主要用于提供实时的、点对点的以及多人互动的聊天功能。在本项目中，我们主要关注以下几个核心知识点： 1. **Java网络编程**：Java提供了丰富的API...
Java语言在实现局域网点对点（P2P）文件传输方面展现出了强大的能力。这种技术允许网络中的设备直接交换数据，而无需通过中央服务器，从而提高了效率并减少了带宽需求。以下是对这一主题的详细解释： 1. **Java基础...
- 文件传输是P2P聊天程序的一个重要功能，可以通过`java.nio.file`和`java.io.FileInputStream/FileOutputStream`实现。 - 分块传输：大文件可能需要分割成小块进行传输，以优化网络利用率和防止数据丢失。 - ...
基于java的p2p文件传输，分别实现了客户端和服务器端程序
Java编写的P2P（对等网络）程序是一种利用网络中多台计算机共享资源的技术实现。在本文中，我们将深入探讨Java在构建P2P应用程序中的应用，以及相关的技术概念和实现细节。 P2P网络的基本原理是网络中的每个节点...
在Java Socket实现的P2P聊天程序中，每台机器都可以发起或接受聊天请求。 8. **协议设计**：聊天程序需要定义自己的通信协议，包括消息格式（如文本、二进制数据）、握手过程、心跳机制等。这些细节决定了程序如何...