文件绑定java socket多线程网络传输多个文件Strut2教程-java教程

最新推荐文章于 2024-11-04 20:33:37 发布

weixin_34323858

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量80

点赞数

文章标签： java 操作系统 runtime

题记：写这篇博客要主是加深自己对文件绑定的认识和总结实现算法时的一些验经和训教，如果有错误请指出，万分感谢。

由于要需究研了下用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;
    }