8224人阅读
Linux C 编程连载（7）
，改进Makefile
，补充Makefile
【设计目的】
通过Linux C编程，设计一个基于TCP/IP的文件传输系统，实现网络文件的收发。
【设计环境】
VMware WorkStation 6.0.2+Fedora 10
【设计方案】
（1）文件读写
任意文件都可以二进制的方式进行读写，为了实现任意文件类型的传输，在读写文件的过程中，必须采用二进制的读写方式。
（2）传输协议
&&&&&& 为了保证数据的正确性，文件传输需要采用一种可靠的传输协议。UDP协议实现比较简单，但UDP面向无连接，传输过程中，会出现丢包的情况，导致数据发送失败。故采用面向连接的TCP/IP协议，防止传输过程中的数据丢失的情况。
（3）大文件的传输
对于比较大的文件，应该进行分包操作，以防止占用过多的内存，导致文件发送失败。
【设计流程】
如图1所示，服务器程序作为文件的发送方。首先，服务器端输入要发送的文件。然后，创建一个流式套接字(SOCK_STREAM)，进行绑定。绑定成功后，执行监听，当有客户发送连接请求，执行Accept()，接收来自客户端的请求。
连接建立后，首先服务器向客服端发送的文件的文件名及扩展名等信息。信息发送完毕，服务器方将待发送的数据读入缓冲区，通过套接字将数据发送出去。发送完成后退出，并显示发送完成的信息。
图1 服务器流程图
&&&&&& 如图2所示，客户端程序完成文件的接收操作。首先，创建一个流式套接字。套接字创建成功后，对该套接字进行绑定。绑定成功后，向服务器方发送连接请求。连接成功后，首先，接收服务器发送的文件信息。接收成功后，开始数据的接收。文件接收完毕，显示文件已接收完成。
图2 客户端流程图
【设计测试】
为了验证设计的正确性，在Fedora 10平台上对可执行文件进行了回环测试。测试了.txt，.doc，.jpg，.pdf四种类型的文件，测试源文件如图3所示。
图3 测试源文件
（1）.txt文件测试
&&&&&& 如图4所示，服务器端执行./fileserver命令，程序提示输入需要发送的文件。输入1.txt，此时服务器进入监听状态，等待客户端的连接。
&&&&&& 在客户端执行./fileclient 127.0.0.1，建立连接。此时，服务器端开始发送文件。并显示读取的文件大小为50 Bytes，小于缓冲区(4096 Bytes)大小，发送一次就可以了，不需要分包操作。发送完成，服务器端显示发送完成，客户端显示接收到来至服务器的文件。
图4 .txt文件测试
（2）.doc文件测试
&&&&&& 如图5所示，服务器端执行./fileserver命令，程序提示输入需要发送的文件。输入test.doc，此时服务器进入监听状态，等待客户端的连接。
&&&&&& 在客户端执行./fileclient 127.0.0.1，建立连接。此时，服务器端开始发送文件。并显示读取的文件大小为19.5 KByte，大于缓冲区(4096 Bytes)大小，需要分包发送，图示进行了5次分包，前4次包的大小为4096 Bytes，最后一次为3584 Bytes。发送完成，服务器端显示发送完成，客户端显示接收到来至服务器的文件。
图5 .doc文件测试
（3）.pdf文件测试
&&&&&& 如图6所示，服务器端执行./fileserver命令，程序提示输入需要发送的文件。输入test.pdf，此时服务器进入监听状态，等待客户端的连接。
&&&&&& 在客户端执行./fileclient 127.0.0.1，建立连接。此时，服务器端开始发送文件。并显示读取的文件大小为23.8 KByte，大于缓冲区(4096 Bytes)大小，需要分包发送，图示进行了6次分包，前5次包的大小为4096 Bytes，最后一次为3993 Bytes。发送完成，服务器端显示发送完成，客户端显示接收到来至服务器的文件。
图6 .pdf文件测试
（4）.jpg文件测试
&&&&&& 如图7所示，服务器端执行./fileserver命令，程序提示输入需要发送的文件。输入test.jpg，此时服务器进入监听状态，等待客户端的连接。
&&&&&& 在客户端执行./fileclient 127.0.0.1，建立连接。此时，服务器端开始发送文件。并显示读取的文件大小为7.11 KByte，大于缓冲区(4096 Bytes)大小，需要分包发送，图示进行了2次分包，第1次包的大小为4096 Bytes，第2次为3189 Bytes。发送完成，服务器端显示发送完成，客户端显示接收到来至服务器的文件。
图7 .jpg文件测试
接收到的文件如图8所示，实验证实文件接收准确无误，没有发生丢包的情况，由于采取了分包的操作，能够传送较大的文件。
图8 接收文件夹
实验证实，该网络文件系统由于采用二进制读写方式，从而能发送任意类型的文件。由于采用了分包操作，能发送比较大的文件。采用TCP/IP协议进行传输，从而保证了文件传输的可靠性。
【代码清单】
#include &stdio.h&
#include &stdlib.h&
#include &unistd.h&
#include &string.h&
#include &sys/types.h&
#include &sys/stat.h&
#include &sys/socket.h&
#include &netinet/in.h&
#define PORT 6000
#define LISTENQ 20
#define BUFFSIZE 4096
#define FILE_NAME_MAX_SIZE 512
fileclient.c
#include &common.h&
int main(int argc, char **argv[])
if(argc!=2)
fprintf(stderr,&Usage:./fileclient &IP_Address&\n&);
struct sockaddr_
bzero(&clientaddr,sizeof(clientaddr));
clientaddr.sin_family=AF_INET;
clientaddr.sin_addr.s_addr=htons(INADDR_ANY);
clientaddr.sin_port=htons(0);
clientfd=socket(AF_INET,SOCK_STREAM,0);
if(clientfd&0)
perror(&socket&);
if(bind(clientfd,(struct sockaddr*)&clientaddr,sizeof(clientaddr))&0)
perror(&bind&);
struct sockaddr_
bzero(&svraddr,sizeof(svraddr));
if(inet_aton(argv[1],&svraddr.sin_addr)==0)
perror(&inet_aton&);
svraddr.sin_family=AF_INET;
svraddr.sin_port=htons(PORT);
socklen_t svraddrlen=sizeof(svraddr);
if(connect(clientfd,(struct sockaddr*)&svraddr,svraddrlen)&0)
perror(&connect&);
//recv file imformation
char buff[BUFFSIZE];
char filename[FILE_NAME_MAX_SIZE];
bzero(buff,BUFFSIZE);
count=recv(clientfd,buff,BUFFSIZE,0);
if(count&0)
perror(&recv&);
strncpy(filename,buff,strlen(buff)&FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buff));
printf(&Preparing recv file : %s from %s \n&,filename,argv[1]);
//recv file
FILE *fd=fopen(filename,&wb+&);
if(NULL==fd)
perror(&open&);
bzero(buff,BUFFSIZE);
int length=0;
while(length=recv(clientfd,buff,BUFFSIZE,0))
if(length&0)
perror(&recv&);
int writelen=fwrite(buff,sizeof(char),length,fd);
if(writelen&length)
perror(&write&);
bzero(buff,BUFFSIZE);
printf(&Receieved file:%s from %s finished!\n&,filename,argv[1]);
fclose(fd);
close(clientfd);
fileserver.c
#include &common.h&
int main(int argc, char **argv[])
//Input the file name
char filename[FILE_NAME_MAX_SIZE];
bzero(filename,FILE_NAME_MAX_SIZE);
printf(&Please input the file name you wana to send:&);
scanf(&%s&,&filename);
getchar();
//Create socket
int sockfd,
struct sockaddr_in svraddr,
bzero(&svraddr,sizeof(svraddr));
svraddr.sin_family=AF_INET;
svraddr.sin_addr.s_addr=htonl(INADDR_ANY);
svraddr.sin_port=htons(PORT);
sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd&0)
perror(&socket&);
if(bind(sockfd,(struct sockaddr*)&svraddr,sizeof(svraddr))&0)
perror(&bind&);
if(listen(sockfd,LISTENQ)&0)
perror(&listen&);
socklen_t length=sizeof(clientaddr);
connfd=accept(sockfd,(struct sockaddr*)&clientaddr,&length);
if(connfd&0)
perror(&connect&);
//send file imformation
char buff[BUFFSIZE];
bzero(buff,BUFFSIZE);
strncpy(buff,filename,strlen(filename)&FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(filename));
count=send(connfd,buff,BUFFSIZE,0);
if(count&0)
perror(&Send file information&);
//read file
FILE *fd=fopen(filename,&rb&);
if(fd==NULL)
printf(&File :%s not found!\n&,filename);
bzero(buff,BUFFSIZE);
int file_block_length=0;
while((file_block_length=fread(buff,sizeof(char),BUFFSIZE,fd))&0)
printf(&file_block_length:%d\n&,file_block_length);
if(send(connfd,buff,file_block_length,0)&0)
perror(&Send&);
bzero(buff,BUFFSIZE);
fclose(fd);
printf(&Transfer file finished !\n&);
close(connfd);
close(sockfd);
PROGS = fileserver fileclient
all:$(PROGS)
.PHONY:all
fileserver:
gcc -g fileserver.c common.h -o fileserver
fileclient:
gcc -g fileclient.c common.h -o fileclient
rm $(PROGS)
distclean:
rm *~ $(PROGS)
【改进版本 】
PROGS = fileserver fileclient
temp = $(wildcard *~)
all:$(PROGS)
.PHONY:all
fileserver:
gcc -g fileserver.c common.h -o fileserver
fileclient:
gcc -g fileclient.c common.h -o fileclient
rm $(temp) $(PROGS)
SOURCE=$(wildcard *.c)
PROGS=$(patsubst %.c,%,$(SOURCE))
all:$(PROGS)
rm $(PROGS)
distclean:
rm *~ $(PROGS)
【改进版本 】
SOURCE=$(wildcard *.c)
PROGS=$(patsubst %.c,%,$(SOURCE))
temp = $(wildcard *~)
all:$(PROGS)
rm $(temp) $(PROGS)
*晦涩难懂，不推荐。
*改进后的Makefile版本，可自适应的删除临时文件：若临时文件存在，则删除临时文件；若临时文件不存在，则不执行删除临时文件。
转载请标明出处，仅供学习交流，勿用于商业目的
Copyright @
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：238678次
积分：3575
积分：3575
排名：第6822名
原创：113篇
评论：76条
网易博客地址：
设计模式：
阅读：17782
阅读：8998
(1)(3)(5)(4)(8)(2)(5)(5)(6)(4)(4)(11)(6)(5)(5)(4)(12)(7)(8)(8)新版 ChinaUnix 客户端强势归来！
扫描二维码安装
扫描二维码安装
支持分类信息/主题分类
支持搜索/分享/删选/注册
社区新帖热帖实时更新
所有数据和网站实时同步
查看周边用户、周边帖子
查看网友发帖位置
随时随地拍照上传
可多选5张照片
轻松录音上传
倾听ta的声音
回复信息及时通知
和好友实时语音交流
北京皓辰网域网络信息技术有限公司. 版权所有 京ICP证:060528号 北京市公安局海淀分局网监中心备案编号：
广播电视节目制作经营许可证(京) 字第1234号
中国互联网协会会员&&联系我们：
感谢所有关心和支持过ChinaUnix的朋友们
转载本站内容请注明原作者名及出处下次自动登录
现在的位置:
& 综合 & 正文
Java Socket编程 – 基于TCP方式的二进制文件传输【转】http://blog.csdn.net/jia20003/article/details/8248221
此人博客挺好的，推荐一个！
一个基于Java Socket协议之上文件传输的完整示例，基于TCP通信完成。
除了基于TCP的二进制文件传输，还演示了JAVA Swing的一些编程技巧，Demo
实现主要功能有以下几点：
基于Java Socket的二进制文件传输(包括图片，二进制文件，各种文档work，
SwingWorker集合JProgressBar显示实时传输/接受完成的百分比
其它一些Swing多线程编程技巧
首先来看一下整个Dome的Class之间的关系图：
下面按照上图来详细解释各个类的功能与实现：
服务器端：
FileTransferServer类的功能首先是在端口9999创建一个服务器套接字并
开始监听连接。相关代码如下：
private void startServer(int port) {
serverSocket = new ServerSocket(port);
System.out.println("Server started at port :" + port);
while(true) {
Socket client = serverSocket.accept();
System.out.println("Just connected to " + client.getRemoteSocketAddress());
FileReceiveTask task = new FileReceiveTask(client);
bar.setValue(0);
task.addPropertyChangeListener(new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
if ("progress".equals(evt.getPropertyName())) {
bar.setValue((Integer) evt.getNewValue());
task.execute();
} catch (IOException e) {
e.printStackTrace();
关于PropertyChangeListener, Java提供了一个非常有力的工具类来
监控任意Bean Model的数据改变，程序通过添加该监听器实现对
SwingWorker的progress属性值改变的事件捕获，然后更新JProgressBar
实例对象，实现了UI的刷新。FileTransferServer类的完整如下：
package com.gloomyfish.socket.tutorial.
import java.awt.BorderL
import java.awt.FlowL
import java.awt.event.ActionE
import java.awt.event.ActionL
import java.beans.PropertyChangeE
import java.beans.PropertyChangeL
import java.io.IOE
import java.net.ServerS
import java.net.S
import javax.swing.BoxL
import javax.swing.JB
import javax.swing.JF
import javax.swing.JOptionP
import javax.swing.JP
import javax.swing.JProgressB
public class FileTransferServer extends JFrame implements ActionListener {
public final static String START_SVR = "Start";
public final static String SHUT_DOWN_SVR = "Shut Down";
public final static String END_FLAG = "EOF";
private static final long serialVersionUID = 1L;
private ServerSocket serverS
private JButton startB
private JProgressB
public FileTransferServer() {
super("File Server");
initComponent();
setupListener();
private void setupListener() {
startBtn.addActionListener(this);
private void initComponent() {
startBtn = new JButton(START_SVR);
JPanel progressPanel = new JPanel();
progressPanel.setLayout(new BoxLayout(progressPanel, BoxLayout.Y_AXIS));
bar = new JProgressBar();
bar.setMinimum(0);
bar.setMaximum(100);
progressPanel.add(bar);
getContentPane().setLayout(new BorderLayout());
JPanel btnPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
btnPanel.add(startBtn);
getContentPane().add(btnPanel, BorderLayout.SOUTH);
getContentPane().add(progressPanel, BorderLayout.CENTER);
private void startServer(int port) {
serverSocket = new ServerSocket(port);
System.out.println("Server started at port :" + port);
while(true) {
Socket client = serverSocket.accept();
System.out.println("Just connected to " + client.getRemoteSocketAddress());
FileReceiveTask task = new FileReceiveTask(client);
bar.setValue(0);
task.addPropertyChangeListener(new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
if ("progress".equals(evt.getPropertyName())) {
bar.setValue((Integer) evt.getNewValue());
task.execute();
} catch (IOException e) {
e.printStackTrace();
public void showSuccess() {
bar.setValue(100);
JOptionPane.showMessageDialog(this, "file received successfully!");
public void actionPerformed(ActionEvent e) {
if(START_SVR.equals(e.getActionCommand())) {
Thread startThread = new Thread(new Runnable() {
public void run() {
startServer(9999);
startThread.start();
startBtn.setEnabled(false);
} else if(SHUT_DOWN_SVR.equals(e.getActionCommand())) {
public static void main(String[] args) {
FileTransferServer server = new FileTransferServer();
server.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
server.setSize(400, 400);
server.setResizable(false);
server.setVisible(true);
FileReceiveTask是服务器端的文件接受类：
首先从建立的TCP流中得到文件名与文件大小，然后开始接受文件内容字节
并写入创建的文件对象流中，最后验证文件大小与写入的字节流是否相等
最后发送一条消息到文件发送方，告诉对方文件传输完成，可以关闭TCP流。
该类的完整源代码如下：
package com.gloomyfish.socket.tutorial.
import java.io.BufferedOutputS
import java.io.BufferedW
import java.io.DataInputS
import java.io.F
import java.io.FileOutputS
import java.io.OutputStreamW
import java.net.S
import javax.swing.SwingW
public class FileReceiveTask extends SwingWorker&Integer, Object& {
private Socket _mS
public FileReceiveTask(Socket client) {
this._mSocket =
protected Integer doInBackground() throws Exception {
DataInputStream input = new DataInputStream(_mSocket.getInputStream());
String fileName = input.readUTF();
int fileLength = (int)input.readLong();
File file = new File("C:\\Users\\fish\\Downloads" + File.separator + fileName);
BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file));
System.out.println("Received File Name = " + fileName);
System.out.println("Received File size = " + fileLength/1024 + "KB");
byte[] content = new byte[2048];
int offset = 0;
int numReadBytes = 0;
while(offset & fileLength && (numReadBytes = input.read(content)) & 0) {
output.write(content, 0, numReadBytes);
float precent = 100.0f * ((float)offset)/((float)fileLength);
setProgress((int)precent);
offset += numReadB
System.out.println("numReadBytes = " + numReadBytes);
if(offset & fileLength) {
numReadBytes = input.read(content);
System.out.println("numReadBytes = " + numReadBytes);
System.out.println("File content error at server side");
System.out.println("File Receive Task has done correctly");
setProgress(100);
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(_mSocket.getOutputStream()));
bufferedWriter.write("DONE\r\n");
bufferedWriter.flush();
output.close();
_mSocket.close();
return 100;
FileTransferClient是客户端UI类，用来实现到服务端的连接，然后选择
要传输的文件(图片，PDF，Word文档等各种二进制文件)。如果没有
输入服务器信息，会弹出提示要求输入。端口已经指定为：9999
【send File】按钮会打开文件选择框，用户选择要传输文件以后，创建
FileTransferTask线程，并开始执行文件传送。客户端UI代码如下：
package com.gloomyfish.socket.tutorial.
import java.awt.BorderL
import java.awt.FlowL
import java.awt.GridL
import java.awt.event.ActionE
import java.awt.event.ActionL
import java.beans.PropertyChangeE
import java.beans.PropertyChangeL
import java.io.F
import java.net.InetSocketA
import java.net.SocketA
import javax.swing.BorderF
import javax.swing.BoxL
import javax.swing.JB
import javax.swing.JFileC
import javax.swing.JF
import javax.swing.JL
import javax.swing.JOptionP
import javax.swing.JP
import javax.swing.JProgressB
import javax.swing.JTextF
public class FileTransferClient extends JFrame implements ActionListener {
private static final long serialVersionUID = 1L;
public final static String SEND_CMD = "Send File";
public final static int MINIMUM = 0;
public final static int MAXIMUM = 100;
private JButton sendFileB
private JTextField serverF
private JTextField portF
private JProgressB
public FileTransferClient() {
super("File Transfer Client");
initComponents();
private void initComponents() {
getContentPane().setLayout(new BorderLayout());
JPanel progressPanel = new JPanel();
progressPanel.setLayout(new BoxLayout(progressPanel, BoxLayout.Y_AXIS));
bar = new JProgressBar();
progressPanel.add(bar);
bar.setMinimum(MINIMUM);
bar.setMaximum(MAXIMUM);
JPanel serverSettingPanel = new JPanel();
serverSettingPanel.setLayout(new GridLayout(2,2,5,5));
serverSettingPanel.setBorder(BorderFactory.createTitledBorder("Server Setting"));
serverField = new JTextField();
portField = new JTextField();
serverSettingPanel.add(new JLabel("Server IP/Host:"));
serverSettingPanel.add(serverField);
serverSettingPanel.add(new JLabel("Server Port:"));
serverSettingPanel.add(portField);
sendFileBtn = new JButton(SEND_CMD);
JPanel btnPanel = new JPanel();
btnPanel.setLayout(new FlowLayout(FlowLayout.RIGHT));
btnPanel.add(sendFileBtn);
getContentPane().add(serverSettingPanel, BorderLayout.NORTH);
getContentPane().add(btnPanel, BorderLayout.SOUTH);
getContentPane().add(progressPanel, BorderLayout.CENTER);
sendFileBtn.addActionListener(this);
public void actionPerformed(ActionEvent e) {
String command = e.getActionCommand();
if(command.equals(SEND_CMD)) {
if(checkNull()) {
JOptionPane.showMessageDialog(this, "Please enter server host and port in order to set up the connection!");
JFileChooser chooser = new JFileChooser();
int status = chooser.showOpenDialog(null);
if (status == JFileChooser.APPROVE_OPTION) {
File f = chooser.getSelectedFile();
SocketAddress address = new InetSocketAddress(getServer(), getPort());
FileTransferTask task = new FileTransferTask(f, address, this);
bar.setValue(0);
task.addPropertyChangeListener(new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
if ("progress".equals(evt.getPropertyName())) {
bar.setValue((Integer) evt.getNewValue());
task.execute();
public void showSuccess() {
bar.setValue(100);
JOptionPane.showMessageDialog(this, "file send successfully!");
public String getServer() {
return serverField.getText().trim();
public int getPort() {
return Integer.parseInt(portField.getText().trim());
private boolean checkNull() {
String serverName = serverField.getText();
String port = portField.getText();
if(serverName == null || serverName.length() == 0 || port == null || port.length() == 0) {
return true;
Integer.parseInt(port);
} catch(NumberFormatException ne) {
ne.printStackTrace();
return true;
return false;
public static void main(String[] args) {
FileTransferClient client = new FileTransferClient();
client.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
client.setSize(400, 400);
client.setResizable(false);
client.setVisible(true);
FileTransferTask实现的功能主要有：
1. 发送文件meta信息到接受方(文件名与文件大小)
2. 读取文件内容字节写入Socket字节流中，发送到接受方
3. 从Socket字节流中读取对方接受完成通知信息，调用弹出文件传输成功信息
该类完全源代码如下：
package com.gloomyfish.socket.tutorial.
import java.io.BufferedInputS
import java.io.BufferedR
import java.io.DataInputS
import java.io.DataOutputS
import java.io.F
import java.io.FileInputS
import java.io.IOE
import java.io.InputStreamR
import java.net.S
import java.net.SocketA
import javax.swing.SwingW
public class FileTransferTask extends SwingWorker&Integer, Object& {
private File selectedF
private Socket mS
private SocketA
private FileTransferC
public FileTransferTask(File file, SocketAddress address, FileTransferClient owner ) {
this.address =
this.selectedFile =
mSocket = new Socket();
this.parent =
protected Integer doInBackground() throws Exception {
long length = selectedFile.length();
if (length & Integer.MAX_VALUE) {
throw new IOException("Could not completely read file " + selectedFile.getName() + " as it is too long (" + length + " bytes, max supported " + Integer.MAX_VALUE + ")");
mSocket.connect(address);
mSocket.setSoLinger(true, 60);
DataOutputStream dout = new DataOutputStream(mSocket.getOutputStream());
dout.writeUTF(selectedFile.getName());
dout.writeLong(length);
dout.flush();
FileDataPackage pData = new FileDataPackage();
DataInputStream is = new DataInputStream(new FileInputStream(selectedFile));
byte[] bytes = new byte[2048];
int offset = 0;
int numRead = 0;
int fsize = (int)
while (offset & fsize && (numRead=is.read(bytes, 0, bytes.length)) &= 0) {
pData.setData(bytes, numRead);
dout.write(pData.getPackageData(), 0, pData.getPackageData().length);
dout.flush();
offset += numR
float precent = 100.0f * ((float)offset)/((float)fsize);
setProgress((int)precent);
System.out.println("total send bytes = " + offset);
if (offset & fsize) {
throw new IOException("Could not completely transfer file " + selectedFile.getName());
mSocket.shutdownOutput();
BufferedInputStream streamReader = new BufferedInputStream(mSocket.getInputStream());
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(streamReader));
String doneMsg = bufferedReader.readLine();
if("DONE".equals(doneMsg)) {
parent.showSuccess();
setProgress(100);
mSocket.close();
is.close();
System.out.println("close it now......");
return 100;
数据包类如下，不解释！
package com.gloomyfish.socket.tutorial.
public class FileDataPackage {
private int dataL
private byte[]
public final static byte[] EOF = new byte[]{'E', 'O','F'};
public FileDataPackage() {
dataLength = 0;
databuff = new byte[2048];
public byte[] getPackageData() {
byte[] pData = new byte[dataLength];
System.arraycopy(databuff, 0, pData, 0, dataLength);
public void setData(byte[] data, int bsize) {
dataLength =
for(int i=0; i&databuff. i++) {
if(i&bsize) {
databuff[i] = data[i];
databuff[i] = ' ';
每次发送的最大字节数为2048个字节。程序最终运行效果如下(win7 + JDK6u30)：
觉得不错，请顶一下啊，谢谢！
&&&&推荐文章:
【上篇】【下篇】