java socket 传多个文件下载_java socket 多线程网络传输多个文件

由于需要研究了下用 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 fileList = new ArrayList();

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 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 getRandom(int size){

Vector v = new Vector();

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;

}