java--基于socket的网络传输开发

socket的网络传输开发

attachments-2017-11-S7mpe0QI5a17d26bbee38.jpg    


第一步 充分理解Socket

1.什么是socket

所谓socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

J2SDK-1.3为例,SocketServerSocket类库位于Java.NET包中。ServerSocket用于服务器端,Socket是建立网络连接时使用的。在连接成功时,应用程序两端都会产生一个Socket实例,操作这个实例,完成所需的会话。对于一个网络连接来说,套接字是平等的,并没有差别,不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

重要的Socket API

java.Net.Socket继承于java.lang.Object,有八个构造器,其方法并不多,下面介绍使用最频繁的三个方法,其它方法大家可以见JDK-1.3文档。

.Accept方法用于产生"阻塞",直到接受到一个连接,并且返回一个客户端的Socket对象实例。"阻塞"是一个术语,它使程序运行暂时"停留"在这个地方,直到一个会话产生,然后程序继续;通常"阻塞"是由循环产生的。

.getInputStream方法获得网络连接输入,同时返回一个IutputStream对象实例,。

.getOutputStream方法连接的另一端将得到输入,同时返回一个OutputStream对象实例。

注意:其中getInputStreamgetOutputStream方法均会产生一个IOException,它必须被捕获,因为它们返回的流对象,通常都会被另一个流对象使用。

 

2.如何开发一个Server-Client模型的程序

开发原理:

服务器,使用ServerSocket监听指定的端口,端口可以随意指定(由于1024以下的端口通常属于保留端口,在一些操作系统中不可以随意使用,所以建议使用大于1024的端口),等待客户连接请求,客户连接后,会话产生;在完成会话后,关闭连接。

客户端,使用Socket对网络上某一个服务器的某一个端口发出连接请求,一旦连接成功,打开会话;会话完成后,关闭Socket。客户端不需要指定打开的端口,通常临时的、动态的分配一个1024以上的端口。

简单事例:

server端:

package com.socket;

 

import java.net.*;

import java.io.*;

 

public class Server {

    private ServerSocket ss;

    private Socket socket;

    private BufferedReader in;

    private PrintWriter out;

 

    public Server() {

        try {

            ss = new ServerSocket(10000);

            while (true) {

                socket = ss.accept();

                System.out.println("连接成功!");

                in = new BufferedReader(new InputStreamReader(socket

                        .getInputStream()));

//              out = new PrintWriter(socket.getOutputStream(), true);

                String line = in.readLine();

                System.out.println("you input is :" + line);

//              out.close();

                in.close();

                socket.close();

            }

        } catch (IOException e) {

            try {

                ss.close();

            } catch (IOException e1) {

                // TODO Auto-generated catch block

                e1.printStackTrace();

            }

            e.printStackTrace();

        }

    }

 

    public static void main(String[] args) {

        new Server();

    }

}

 

 

client端:

package com.socket;

 

import java.io.*;

import java.net.*;

 

public class Client {

    Socket socket;

    BufferedReader in;

    PrintWriter out;

 

    public Client() {

        try {

            socket = new Socket("localhost", 10000);

            in = new BufferedReader(new InputStreamReader(socket

                    .getInputStream()));

            out = new PrintWriter(socket.getOutputStream(), true);

//          BufferedReader line = new BufferedReader(new InputStreamReader(

//                  System.in));

            out.println("hello socket");

//          line.close();

            out.close();

            in.close();

            socket.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

 

    public static void main(String[] args) {

        new Client();

    }

}

 

 

第二步 多个客户同时连接

在实际的网络环境里,同一时间只对一个用户服务是不可行的。一个优秀的网络服务程序除了能处理用户的输入信息,还必须能够同时响应多个客户端的连接请求。在java中,实现以上功能特点是非常容易的。

设计原理:

主程序监听一端口,等待客户接入;同时构造一个线程类,准备接管会话。当一个Socket会话产生后,将这个会话交给线程处理,然后主程序继续监听。运用Thread类或Runnable接口来实现是不错的办法。

server端:

package com.socket;

 

import java.io.*;

import java.net.*;

 

public class Server extends ServerSocket {

    private static final int SERVER_PORT = 10000;

 

    public Server() throws IOException {

        super(SERVER_PORT);

        try {

            while (true) {

                System.out.println("-----------1--------------");

                Socket socket = accept();// 1 客户端发送请求,建立连接

                System.out.println("-----------2--------------");

                new CreateServerThread(socket);

                System.out.println("-----------3--------------");

            }

        } catch (IOException e) {

        } finally {

            close();

        }

    }

 

    // --- CreateServerThread

    class CreateServerThread extends Thread {

        private Socket client;

        private BufferedReader in;

        private PrintWriter out;

 

        public CreateServerThread(Socket s) throws IOException {

            client = s;

            in = new BufferedReader(new InputStreamReader(client

                    .getInputStream(), "GB2312"));

            out = new PrintWriter(client.getOutputStream(), true);

            out.println("--- Welcome ---");

            start();

        }

 

        public void run() {

            try {

                System.out.println("-----------4--------------");

                String line = in.readLine();// 2 等待客户端响应

                System.out.println("-----------5--------------");

                while (!line.equals("bye")) {

                    String msg = createMessage(line);

                    System.out.println("-----------6--------------");

                    out.println("123");

                    System.out.println("-----------7--------------");

                    line = in.readLine();

                }

                out.println("--- See you, bye! ---");

                client.close();

            } catch (IOException e) {

            }

        }

 

        private String createMessage(String line) {

            System.out.println(line);

            return "";

        }

    }

 

    public static void main(String[] args) throws IOException {

        new Server();

    }

}

 

 

client端:

package com.socket;

 

import java.io.*;

import java.net.*;

 

public class Client {

    Socket socket;

    BufferedReader in;

    PrintWriter out;

 

    public Client() {

        try {

            socket = new Socket("localhost", 10000);

            in = new BufferedReader(new InputStreamReader(socket

                    .getInputStream()));

            out = new PrintWriter(socket.getOutputStream(), true);

            BufferedReader line = new BufferedReader(new InputStreamReader(

                    System.in));

            out.println(in.readLine());

            line.close();

            out.close();

            in.close();

            socket.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

 

    public static void main(String[] args) {

        new Client();

    }

}

 

这个程序监听10000端口,并将接入交给CreateServerThread线程运行。CreateServerThread线程接受输入,并将输入回应客户,直到客户输入"bye",线程结束。我们可以在createMessage方法中,对输入进行处理,并产生结果,然后把结果返回给客户。

 

第三步 实现信息共享:Socket上的实时交流

网络的伟大之一也是信息共享,Server可以主动向所有Client广播消息,同时Client也可以向其它Client发布消息。下面看看如何开发一个可以实时传递消息的程序。

设计原理:

服务器端接受客户端的连接请求,同时启动一个线程处理这个连接,线程不停的读取客户端输入,然后把输入加入队列中,等候处理。在线程启动的同时将线程加入队列中,以便在需要的时候定位和取出。


server
端:

package com.socket;

 

import java.io.*;

import java.net.*;

import java.util.*;

import java.lang.*;

 

public class Server extends ServerSocket {

    private static ArrayList User_List = new ArrayList();

    private static ArrayList Threader = new ArrayList();

    private static LinkedList Message_Array = new LinkedList();

    private static int Thread_Counter = 0;

    private static boolean isClear = true;

    protected static final int SERVER_PORT = 10000;

    protected FileOutputStream LOG_FILE = new FileOutputStream(

            "d:/connect.log", true);

 

    public Server() throws FileNotFoundException, IOException {

        super(SERVER_PORT);

        new Broadcast();

        // append connection log

        Calendar now = Calendar.getInstance();

        String str = "[" + now.getTime().toString()

                + "] Accepted a connection1512";

        byte[] tmp = str.getBytes();

        LOG_FILE.write(tmp);

        try {

            while (true) {

                Socket socket = accept();

                new CreateServerThread(socket);

            }

        } finally {

            close();

        }

    }

 

    public static void main(String[] args) throws IOException {

        new Server();

    }

 

    // --- Broadcast

    class Broadcast extends Thread {

        public Broadcast() {

            start();

        }

 

        public void run() {

            while (true) {

                if (!isClear) {

                    String tmp = (String) Message_Array.getFirst();

                    for (int i = 0; i < Threader.size(); i++) {

                        CreateServerThread client = (CreateServerThread) Threader

                                .get(i);

                        client.sendMessage(tmp);

                    }

                    Message_Array.removeFirst();

                    isClear = Message_Array.size() > 0 ? false : true;

                }

            }

        }

    }

 

    // --- CreateServerThread

    class CreateServerThread extends Thread {

        private Socket client;

        private BufferedReader in;

        private PrintWriter out;

        private String Username;

 

        public CreateServerThread(Socket s) throws IOException {

            client = s;

            in = new BufferedReader(new InputStreamReader(client

                    .getInputStream()));

            out = new PrintWriter(client.getOutputStream(), true);

            out.println("--- Welcome to this chatroom ---");

            out.println("Input your nickname:");

            start();

        }

 

        public void sendMessage(String msg) {

            out.println(msg);

        }

 

        public void run() {

            try {

                int flag = 0;

                Thread_Counter++;

                String line = in.readLine();

                while (!line.equals("bye")) {

                    if (line.equals("l")) {

                        out.println(listOnlineUsers());

                        line = in.readLine();

                        continue;

                    }

                    if (flag++ == 0) {

                        Username = line;

                        User_List.add(Username);

                        out.println(listOnlineUsers());

                        Threader.add(this);

                        pushMessage("[< " + Username + " come on in >]");

                    } else {

                        pushMessage("<" + Username + ">" + line);

                    }

                    line = in.readLine();

                }

                out.println("--- See you, bye! ---");

                client.close();

            } catch (IOException e) {

            } finally {

                try {

                    client.close();

                } catch (IOException e) {

                }

                Thread_Counter--;

                Threader.remove(this);

                User_List.remove(Username);

                pushMessage("[< " + Username + " left>]");

            }

        }

 

        private String listOnlineUsers() {

            String s = "-+- Online list -+-1512";

            for (int i = 0; i < User_List.size(); i++) {

                s += "[" + User_List.get(i) + "]1512";

            }

            s += "-+---------------------+-";

            return s;

        }

 

        private void pushMessage(String msg) {

            Message_Array.addLast(msg);

            isClear = false;

        }

    }

}

 

client端:

package com.socket;

 

import java.io.*;

import java.net.*;

 

public class Client {

    Socket socket;

    BufferedReader in;

    PrintWriter out;

 

    public Client() {

        try {

            socket = new Socket("localhost", 10000);

            in = new BufferedReader(new InputStreamReader(socket

                    .getInputStream()));

            out = new PrintWriter(socket.getOutputStream(), true);

            BufferedReader line = new BufferedReader(new InputStreamReader(

                    System.in));

            out.println(in.readLine());

            line.close();

            System.out.println(new BufferedReader(new InputStreamReader(socket

                    .getInputStream())).readLine());

            out.close();

            in.close();

            socket.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

 

    public static void main(String[] args) {

        new Client();

    }

}

 

 

socket传输是基于tcp的网络传输协议进行的传输,tcp有一个特点,举个例子(视频上学的):

比如张三给李四打电话,张三拨通李四的电话号,李四接起了电话,这是张三说了一声你好,然后张三就一直等待李四的回复,如果李四不回复,那么张三那就这么一直等下去...

socket也是这样,只要server端没给client端一个回复那么后面的请求都一直等待,用法就是Socket socket = accept(); socket会根据server端是否为阻塞状态来判断是否可以进行下一个请求的传输。

 

所以为了解决这种问题,在server端或client端,请求数据的处理都单独开启一个线程进行处理。

代码如下:

              try {

                     while (true) {

                            Socket socket = accept(); // 阻塞

                            new CreateServerThread(socket);

                     }

              } finally {

                     close();

              }

 

第二行代码,是一个死循环。

第四行,是将线程通道变为阻塞的状态。

第五行,实例化一个类,此类继承Thread,在类中执行start方法。

CreateServerThread类,详见下面代码

              public CreateServerThread(Socket s) throws IOException {

                     client = s;

                     in = new BufferedReader(new InputStreamReader(client

                                   .getInputStream()));// 获取socket的输入流

                     out = new PrintWriter(client.getOutputStream(), true);// 获取到socket的输出流

                     out.println("--- Welcome to this chatroom ---");

                     out.println("Input your nickname:");

                     start();

              }

此类获取了socket的输入输出流后,开启线程处理后续工作。这样下一个请求即可快速进行,然后依次往返开启多线程来并行处理请求。

 

我理解的socket通信模式如下图:

 attachments-2017-11-098kMOUo5a17d2b6c7b43.jpg


  • 发表于 2017-11-24 16:05
  • 阅读 ( 1422 )
  • 分类:Java

你可能感兴趣的文章

相关问题

0 条评论

请先 登录 后评论
不写代码的码农
HJ社区-肖峰

IT

29 篇文章

作家榜 »

  1. 威猛的小站长 124 文章
  2. Jonny 65 文章
  3. 江南烟雨 36 文章
  4. - Nightmare 33 文章
  5. doublechina 31 文章
  6. HJ社区-肖峰 29 文章
  7. 伪摄影 22 文章
  8. Alan 14 文章