由于需要研究了下用 java socket 传输文件,由于需要传输多个文件,因此,采用了多线程设计。客户端每个线程创建一个 socket 连接,每个 socket 连接负责传输一个文件,服务端的ServerSocket每次 accept 一个 socket 连接,创建一个线程用于接收客户端传来的文件。
1、服务端
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TransferServer {
private int defaultBindPort = Constants.DEFAULT_BIND_PORT; //默认监听端口号为10000
private int tryBindTimes = 0; //初始的绑定端口的次数设定为0
private ServerSocket serverSocket; //服务套接字等待对方的连接和文件发送
private ExecutorService executorService; //线程池
private final int POOL_SIZE = 4; //单个CPU的线程池大小
/**
* 不带参数的构造器,选用默认的端口号
* @throws Exception
*/
public TransferServer() throws Exception{
try {
this.bingToServerPort(defaultBindPort);
executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
System.out.println("开辟线程数 : " + Runtime.getRuntime().availableProcessors() * POOL_SIZE);
} catch (Exception e) {
throw new Exception("绑定端口不成功!");
}
}
/**
* 带参数的构造器,选用用户指定的端口号
* @param port
* @throws Exception
*/
public TransferServer(int port) throws Exception{
try {
this.bingToServerPort(port);
executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
} catch (Exception e) {
throw new Exception("绑定端口不成功!");
}
}
private void bingToServerPort(int port) throws Exception{
try {
serverSocket = new ServerSocket(port);
System.out.println(port);
System.out.println("服务启动!");
} catch (Exception e) {
this.tryBindTimes = this.tryBindTimes + 1;
port = port + this.tryBindTimes;
if(this.tryBindTimes >= 20){
throw new Exception("您已经尝试很多次了,但是仍无法绑定到指定的端口!请重新选择绑定的默认端口号");
}
//递归绑定端口
this.bingToServerPort(port);
}
}
public void service(){
Socket socket = null;
while (true) {
try {
socket = serverSocket.accept();
executorService.execute(new Handler(socket));
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Handler implements Runnable{
private Socket socket;
public Handler(Socket socket){
this.socket = socket;
}
public void run() {
System.out.println("New connection accepted " + socket.getInetAddress() + ":" + socket.getPort());
DataInputStream dis = null;
DataOutputStream dos = null;
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
try {
dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
String savePath = Constants.RECEIVE_FILE_PATH + dis.readUTF();
long length = dis.readLong();
dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(savePath)));
int read = 0;
long passedlen = 0;
while ((read = dis.read(buf)) != -1) {
passedlen += read;
dos.write(buf, 0, read);
System.out.println("文件[" + savePath + "]已经接收: " + passedlen * 100L/ length + "%");
}
System.out.println("文件: " + savePath + "接收完成!");
} catch (Exception e) {
e.printStackTrace();
System.out.println("接收文件失败!");
}finally{
try {
if(dos != null){
dos.close();
}
if(dis != null){
dis.close();
}
if(socket != null){
socket.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws Exception{
new TransferServer().service();
}
}
2、客户端
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Random;
import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TransferClient {
private static ArrayList<String> fileList = new ArrayList<String>();
private String sendFilePath = Constants.SEND_FILE_PATH;
/**
* 带参数的构造器,用户设定需要传送文件的文件夹
* @param filePath
*/
public TransferClient(String filePath){
getFilePath(filePath);
}
/**
* 不带参数的构造器。使用默认的传送文件的文件夹
*/
public TransferClient(){
getFilePath(sendFilePath);
}
public void service(){
ExecutorService executorService = Executors.newCachedThreadPool();
Vector<Integer> vector = getRandom(fileList.size());
for(Integer integer : vector){
String filePath = fileList.get(integer.intValue());
executorService.execute(sendFile(filePath));
}
}
private void getFilePath(String dirPath){
File dir = new File(dirPath);
File[] files = dir.listFiles();
if(files == null){
return;
}
for(int i = 0; i < files.length; i++){
if(files[i].isDirectory()){
getFilePath(files[i].getAbsolutePath());
}
else {
fileList.add(files[i].getAbsolutePath());
}
}
}
private Vector<Integer> getRandom(int size){
Vector<Integer> v = new Vector<Integer>();
Random r = new Random();
boolean b = true;
while(b){
int i = r.nextInt(size);
if(!v.contains(i))
v.add(i);
if(v.size() == size)
b = false;
}
return v;
}
private static Runnable sendFile(final String filePath){
return new Runnable(){
private Socket socket = null;
private String ip ="localhost";
private int port = 10000;
public void run() {
System.out.println("开始发送文件:" + filePath);
File file = new File(filePath);
if(createConnection()){
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
try {
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(file.getName());
dos.flush();
dos.writeLong(file.length());
dos.flush();
int read = 0;
int passedlen = 0;
long length = file.length(); //获得要发送文件的长度
while ((read = fis.read(buf)) != -1) {
passedlen += read;
System.out.println("已经完成文件 [" + file.getName() + "]百分比: " + passedlen * 100L/ length + "%");
dos.write(buf, 0, read);
}
dos.flush();
fis.close();
dos.close();
socket.close();
System.out.println("文件 " + filePath + "传输完成!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
private boolean createConnection() {
try {
socket = new Socket(ip, port);
System.out.println("连接服务器成功!");
return true;
} catch (Exception e) {
System.out.println("连接服务器失败!");
return false;
}
}
};
}
public static void main(String[] args){
new TransferClient().service();
}
}
3、常量类
public interface Constants {
public final static String RECEIVE_FILE_PATH = "E:\\receive\\";
public final static String SEND_FILE_PATH = "E:\\send";
public final static int DEFAULT_BIND_PORT = 10000;
}
转自【http://software.intel.com/zh-cn/user/817741】
分享到:
相关推荐
java socket 多线程网络传输多个文件
使用java socket开发的多线程文件上传下载的实例项目,多线程并发测试中可以支持200个,可能由于我电脑的配置问题,一般在并发大于200时client端可能会出现"阻塞"问题,还请大家指教
服务端知识进行连接 之后调用服务端的线程 服务端并没有大的改动,在原有的基础上加上线程池, 客户端界面只有简单的传一个...调用客户端的方法,方法中有线程,线程中进行socket的链接,这样才能实现多个文件的传输。
2. 实现socket多线程,监听端口1314,最大socket队列100,都可以人为设置 3. 模拟了对串口助手发送来的一串十六进制数据进行解析 4. 使用串口助手发送数据,模拟数据如图“模拟数据.png”所示 爱吃凉拌辣芒果 ...
Java Socket 传输自定义对象,服务端可以接受多个客户端的连接。
接收用户的聊天信息是由多线程技术实现的,因为客户端必须时时关注更新服务器上是否有最新消息,在本程序中设定的是3秒刷新服务器一次,如果间隔时间太短将会增加客户端与服务器端的通信负担,而间隔时间长就会让人...
DougLee可扩展的网络服务事件驱动Reactor模式基础版多线程版其他变体java.io包中分阻塞IOAPI一览Web服务器,分布式对象系统等等它们的共同特点Read请求解码请求报文业务处理编码响应报文发送响应实际应用中每一个...
多线程处理:通过多线程实现并发处理多个文件传输请求,提高传输效率。 异常处理:处理网络异常、文件读写异常等,确保文件传输的稳定性和可靠性。 应用领域: Java文件传输的实现可以应用于各个领域,包括但不限于...
socket协议数据传输,客户端发起请求每个五秒检测服务端是否在线。同时客户端读、写线程接收和发送数据;如果对方服务器挂掉,客户端数据收取超时会自动断开连接,当服务端重新上线,客户端会重启连接,继续发送请求...
读取txt文本文件,将数据以多线程通过socket网络传输存储到另一个客户端的mysql数据库中,整个过程使用就AVA,mysql,仅供学习参考
任务概述 本项任务要开发一款P2P文件传输软件,该软件可以在局域网和互连上使用,具有文件传输,断点续传,多线程连接等功能。
支持多人聊天,离线消息,文件传输的网络编程
为了保证文件传输的高效性和安全性,本系统采用多线程技术和数据加密技术。同时,本系统还提供了GUI界面,让用户可以轻松地进行文件传输操作。 ## 功能实现 本系统的主要功能包括但不限于以下几点: - 支持文件的...
java多线程tcp socket server源码@Netty 笔记 1. 内蒂 网络应用框架 特征 设计 支持多种传输类型 事件模型 高度可定制的线程模型 表现 高吞吐量,低延迟 更少的资源消耗 最小化内存拷贝 安全SSL/TLS 支持 建筑学 核 ...
当前网络十分发达,网络聊天软件也十分盛行,本文基于Java 平台,使用多线程技术,采用TCP 协议来实现网络聊天程序,为Java 平台下的数据传输类系统开发提供了底层的技术支持。
Java局域网通信——飞鸽传书源代码,大家都知道VB版、VC版还有Delphi版的飞鸽传书软件,但是Java版的确实不多,因此这个Java文件传输实例不可错过,Java网络编程技能的提升很有帮助。 Java聊天程序,包括服务端和...
也具有可移植性、高性能和安全性,并提供了多线程的功能,而Java语言最大的成功之处在于它的平台无关性和具有强大的网络编程功能,基于Java网络编程的强大功能,本人将用Java编写一个网络聊天系统。 论文首先论述了...
也具有可移植性、高性能和安全性,并提供了多线程的功能,而Java语言最大的成功之处在于它的平台无关性和具有强大的网络编程功能,基于Java网络编程的强大功能,本人将用Java编写一个网络聊天系统。 论文首先论述了...
本项目是基于Linux的多线程火车售票系统设计源码,包含154个文件,其中主要包含53个xml配置文件,25个java源代码文件,21个png图片文件等。系统采用了Java、C和Python编程语言,实现了具有上下两层架构(app、device...
系统架构:基于JAVA Socket实现,采用多线程、IO流和数据传输协议等技术。 功能模块:包括用户登录、注册、私聊、群聊、文件传输等模块。 技术要点:包括Socket连接的建立与维护、多线程编程、IO流的使用、数据...