威尼斯手机平台登陆-官方网站登录

威尼斯手机平台登陆为您带来世界三大博彩公司最新相关资讯,威尼斯官方网站登录充分考虑到不同地域网民的不同需求,威尼斯手机平台登陆良好的用户界面,人性化的操作,实用的功能设计使其广泛受到欢迎,推动实体出版、影视、动漫、游戏等相关文化产业的发展。

您的位置:威尼斯手机平台登陆 > 最新文章 > 套接字使用TCP提供了两台Computer之间的通讯机制,付费投稿安排

套接字使用TCP提供了两台Computer之间的通讯机制,付费投稿安排

发布时间:2020-04-21 16:06编辑:最新文章浏览(196)

    本文由码农网 – 小峰原创翻译,转发请看清文末的转载必要,应接参加我们的付费投稿安排!

    Socket 编程
    套接字使用TCP提供了两台计算机之间的通讯机制。 客商端程序创设三个套接字,并尝试连接服务器的套接字。
    当连接创设即,服务器会创设多个 Socket 对象。顾客端和服务器以往得以经过对 Socket 对象的写入和读取来举办通讯。
    java.net.Socket 类代表一个套接字,何况 java.net.ServerSocket 类为服务器程序提供了一种来监听客商端,并与他们树立连接的建制。
    以下步骤在两台Computer之间接选举拔套接字创建TCP连接时会现身:
    服务器实例化叁个 ServerSocket 对象,表示通过服务器上的端口通讯。
    服务器调用 ServerSocket 类的 accept(卡塔尔国方法,该措施将直接等候,直到客商端连接到服务器上加以的端口。
    服务器正在守候时,多少个客商端实例化叁个 Socket 对象,内定服务器名称和端口号来乞求连接。
    Socket 类的构造函数试图将客商端连接到钦赐的服务器和端口号。即使通讯被确立,则在客商端创造一个Socket 对象能够与服务器举行通讯。
    在服务器端,accept(State of Qatar 方法重回服务器上贰个新的 socket 援引,该 socket 连接到顾客端的 socket。
    连续几天营造后,通过运用 I/O 流在开展通讯,每种socket皆有二个输出流和三个输入流,客商端的出口香岛股票(stock卡塔尔国配资流连接到服务器端的输入流,而顾客端的输入流连接到服务器端的输出流。
    TCP 是三个双向的通讯合同,因而数据足以因此五个数据流在同一时候发送.以下是一些类提供的一套完整的有效的法子来达成socket。
    ServerSocket 类的章程
    服务器应用程序通过应用 java.net.ServerSocket 类以获取三个端口,何况侦听客商端央浼。
    ServerSocket 类有四个构造方法:
    序号 方法描述
    1 public ServerSocket(int port) throws IOException
    创建绑定到特定端口的服务器套接字。
    2 public ServerSocket(int port, int backlog) throws IOException
    选拔钦点的 backlog 成立服务器套接字并将其绑定到钦赐的本地端口号。
    3 public ServerSocket(int port, int backlog, InetAddress address) throws IOException
    采取钦点的端口、侦听 backlog 和要绑定到的当地 IP 地址创立服务器。
    4 public ServerSocket() throws IOException
    创设非绑定服务器套接字。
    开创非绑定服务器套接字。 假如 ServerSocket 布局方法没有抛出十分,就象征你的应用程序已经成功绑定到钦定的端口,而且侦听客商端央求。
    此间有一点点 ServerSocket 类的常用方法:
    序号 方法描述
    1 public int getLocalPort()
    回来此套接字在其上侦听的端口。
    2 public Socket accept() throws IOException
    侦听并接收到此套接字的总是。
    3 public void setSoTimeout(int timeout)
    通过点名超时值启用/禁止使用 SO_TIMEOUT,以飞秒为单位。
    4 public void bind(SocketAddress host, int backlog)
    将 ServerSocket 绑定到一定地方(IP 地址和端口号)。
    Socket 类的法子
    java.net.Socket 类代表顾客端和服务器都用来互相联系的套接字。顾客端要赢得四个 Socket 对象通超过实际例化 ,而 服务器取得三个 Socket 对象则经过 accept()方法的重回值。
    Socket 类有四个组织方法.
    序号 方法描述
    1 public Socket(String host, int port) throws UnknownHostException, IOException.
    成立叁个流套接字并将其三回九转到内定主机上的钦点端口号。
    2 public Socket(InetAddress host, int port) throws IOException
    创制一个流套接字并将其总是到钦定 IP 地址的钦命端口号。
    3 public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException.
    威尼斯正规官网,创造三个套接字并将其三回九转到钦赐远程主机上的钦赐远程端口。
    4 public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.
    创造三个套接字并将其总是到钦赐远程地址上的钦点远程端口。
    5 public Socket()
    由此系统默许类型的 SocketImpl 创设未连接套接字
    当 Socket 布局方法再次来到,并未轻便的实例化了贰个 Socket 对象,它实际上会尝试连选用内定的服务器和端口。
    上边列出了一些感兴趣的格局,注意顾客端和劳务器端都有一个 Socket 对象,所以无论客商端或许服务端都能够调用那么些艺术。
    序号 方法描述
    1 public void connect(SocketAddress host, int timeout) throws IOException
    将此套接字连接到服务器,并钦命叁个超时值。
    2 public InetAddress getInetAddress()
    回来套接字连接的地点。
    3 public int getPort()
    归来此套接字连接到的远程端口。
    4 public int getLocalPort()
    归来此套接字绑定到的地头端口。
    5 public SocketAddress getRemoteSocketAddress()
    归来此套接字连接的端点的地址,假若未连接则赶回 null。
    6 public InputStream getInputStream() throws IOException
    回来此套接字的输入流。
    7 public OutputStream getOutputStream() throws IOException
    归来此套接字的输出流。
    8 public void close() throws IOException
    关门此套接字。
    InetAddress 类的主意
    以此类表示网络球组织议(IP卡塔尔国地址。下边列出了 Socket 编制程序时相比实用的方法:
    序号 方法描述
    1 static InetAddress getByAddress(byte[] addr)
    在加以原始 IP 地址的动静下,再次来到 InetAddress 对象。
    2 static InetAddress getByAddress(String host, byte[] addr)
    听别人说提供融金汇银的主机名和 IP 地址创造 InetAddress。
    3 static InetAddress getByName(String host)
    在给定主机名的情景下规定主机的 IP 地址。
    4 String getHostAddress()
    归来 IP 地址字符串(以文件表现情势)。
    5 String getHostName()
    赢得此 IP 地址的主机名。
    6 static InetAddress getLocalHost()
    回到本地主机。
    7 String toString()
    将此 IP 地址调换为 String。
    Socket 客商端实例
    如下的 GreetingClient 是一个顾客端程序,该程序通过 socket 连选拔服务器并发送三个诉求,然后等待三个响应。
    GreetingClient.java 文件代码:
    // 文件名 GreetingClient.java

    Chapter1 贰个粗略的Web服务器

    介绍

    Socket用于进度间通讯。进度间通讯平时根据客商端—服务端模型。这时,顾客端—服务端是能够大同小异的应用程序。客户端和服务端之间的相互影响需求连接。Socket编制程序担任的正是为应用程序之间建设布局可进行交互作用的接连。

    在本文中,大家将学习怎么着用PHP成立三个简约的客商端—服务端。大家还将学习怎么客户端应用程序如何发送消息到服务端,以至哪些从服务端选用音信。

    威尼斯正规官网 1

    import java.net.;
    import java.io.
    ;

    1.1 HTTP

    HTTP
    RFC 2616 - Hypertext Transfer Protocol — HTTP/1.1
    版本: HTTP/1.1
    TCP 连接
    基于:“请求—响应”的协议

    接纳代码

    目标:开辟一个客商端用于发送string音信到服务端,服务端将一律的音讯反转后回去给顾客端。

    PHP服务器

    第1步:设置变量,如“主机”和“端口”

    $host = "127.0.0.1";
    $port = 5353;
    // No Timeout 
    set_time_limit(0);
    

    端口号能够是1024 -65535之间的别样正整数。

    第2步:创建socket

    $socket = socket_create(AF_INET, SOCK_STREAM, 0) or die("Could not create socketn");
    

    第3步:绑定socket到端口和主机

    创建的socket能源绑定到IP地址和端口号。

    $result = socket_bind($socket, $host, $port) or die("Could not bind to socketn");
    

    第4步:启动socket监听

    在绑定到IP和端口后,服务端发轫等候顾客端的连年。在未曾连接早前它就直接等下去。

    $result = socket_listen($socket, 3) or die("Could not set up socket listenern");
    

    第5步:接受连接

    那些函数会采用所建的socket传入的总是央求。在承担来自客户端socket的接连后,该函数重临另叁个socket财富,实际上正是担负与相应的客商端socket通讯。这里的“$spawn”就是担负与顾客端socket通讯的socket能源。

    $spawn = socket_accept($socket) or die("Could not accept incoming connectionn");
    

    到前段时间截止,大家早已寻思好了劳动端socket ,但其实这些本子并从未做其余职业。所认为了世襲形成上述指标,大家将读取顾客端socket音信,然后将吸纳到的消息反转后发回给顾客端socket。

    第6步:从客商端socket读取音讯

    $input = socket_read($spawn, 1024) or die("Could not read inputn");
    

    第7步:反转音讯

    $output = strrev($input) . "n";
    

    第8步:发送消息给客户端socket

    socket_write($spawn, $output, strlen ($output)) or die("Could not write outputn");
    

    关闭socket

    socket_close($spawn);
    socket_close($socket);
    

    那就完了了服务端。未来,大家学习怎样创建PHP客户端。

    PHP客户端

    前多少个步骤与服务端雷同。

    第1步:设置变量,如“主机”和“端口”

    $host = "127.0.0.1";
    $port = 5353;
    // No Timeout 
    set_time_limit(0);
    

    注:这里的端口和主机应该和服务端中的定义是均等的。

    第2步:创建socket

    $socket = socket_create(AF_INET, SOCK_STREAM, 0) or die("Could not create socketn");
    

    第3步:连接到服务端

    $result = socket_connect($socket, $host, $port) or die("Could not connect toservern");
    

    此刻和服务端分裂,客商端socket不绑定端口和主机。相反,它总是到劳动端socket,等待接受来自顾客端socket的连年。这一步创立了顾客端socket到服务端socket的接连。

    第4步:写入服务端socket

    socket_write($socket, $message, strlen($message)) or die("Could not send data to servern");
    

    在那步骤中,顾客端socket的数额被发送到服务端socket。

    第5步:阅读来自服务端的响应

    $result = socket_read ($socket, 1024) or die("Could not read server responsen");
    echo "Reply From Server  :".$result;
    

    第6步:关闭socket

    socket_close($socket);
    

    完全的代码

    服务端(server.php)

    // set some variables
    $host = "127.0.0.1";
    $port = 25003;
    // don't timeout!
    set_time_limit(0);
    // create socket
    $socket = socket_create(AF_INET, SOCK_STREAM, 0) or die("Could not create socketn");
    // bind socket to port
    $result = socket_bind($socket, $host, $port) or die("Could not bind to socketn");
    // start listening for connections
    $result = socket_listen($socket, 3) or die("Could not set up socket listenern");
    
    // accept incoming connections
    // spawn another socket to handle communication
    $spawn = socket_accept($socket) or die("Could not accept incoming connectionn");
    // read client input
    $input = socket_read($spawn, 1024) or die("Could not read inputn");
    // clean up input string
    $input = trim($input);
    echo "Client Message : ".$input;
    // reverse client input and send back
    $output = strrev($input) . "n";
    socket_write($spawn, $output, strlen ($output)) or die("Could not write outputn");
    // close sockets
    socket_close($spawn);
    socket_close($socket);
    

    客户端(client.php)

    $host    = "127.0.0.1";
    $port    = 25003;
    $message = "Hello Server";
    echo "Message To server :".$message;
    // create socket
    $socket = socket_create(AF_INET, SOCK_STREAM, 0) or die("Could not create socketn");
    // connect to server
    $result = socket_connect($socket, $host, $port) or die("Could not connect to servern");  
    // send string to server
    socket_write($socket, $message, strlen($message)) or die("Could not send data to servern");
    // get server response
    $result = socket_read ($socket, 1024) or die("Could not read server responsen");
    echo "Reply From Server  :".$result;
    // close socket
    socket_close($socket);
    

    确立上述文件(server.php和client.php)后,实践如下操作:

    1. 复制www目录中的那些文件(假诺WAMP),安放于C:wamp。
    2. 开拓Web浏览器,在地点栏中键入localhost 。
    3. 先浏览server.php然后client.php。

    public class GreetingClient
    {
    public static void main(String [] args)
    {
    String serverName = args[0];
    int port = Integer.parseInt(args[1]);
    try
    {
    System.out.println("连接到主机:" + serverName + " ,端口号:" + port卡塔尔(قطر‎;
    Socket client = new Socket(serverName, port);
    System.out.println("远程主机地址:" + client.getRemoteSocketAddress(卡塔尔国卡塔尔;
    OutputStream outToServer = client.getOutputStream();
    DataOutputStream out = new DataOutputStream(outToServer);

    1.1.1 HTTP 请求

    一个 HTTP 央求包括以下三有个别
    * 诉求方法 —— U昂CoraI(Uniform Resource Identifier, 统一财富标记符卡塔尔国
    * 请求头
    * 实体

    POST /examples/default.jsp HTTP/1.1
    Accept: text/plain; text/html
    Accept-Language: en-gb
    Connection: Keep-Alive
    Host: Localhost
    User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
    Content-Length: 33
    Content-Type: application/x-www-form-urlencoded
    Accept-Encoding: gzip, deflate
    
    lastName=Franks&firstName=Michael
    

    威尼斯正规官网 2

    http .png

    HTTP 扶持的多种央浼方法

    1. GET
    2. POST
    3. HEAD
    4. OPTIONS
    5. PUT
    6. DELET
    7. TRACE

    UOdysseyI(Uniform Resource Identifier, 统一财富标志符卡塔尔国 制定 Internet 资源的完全路线。 UTucsonI 常常会被解释为相对于服务器根目录的相对路线,由此,它总是以 “/” 初始的。
    UEnclaveL(Uniform Resource Locator, 统一能源定位符卡塔尔(قطر‎ 实际上是 UPAJEROI 的一种类型。

    本子契约指明了当下伏乞使用的 HTTP 合同的本子。

    许可证

    那篇著作,以致别的相关的源代码和文书,是经过The Code Project Open License (CPOLState of Qatar许可的。

         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         System.bjrongjinhuiyin.com.out.println("服务器响应: " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
    

    1.1.2 HTTP 响应

    一个 HTTP 响应蕴含三某个

    • 协议——状态码——描述
    • 响应头
    • 对应实体段
    HTTP/1.1 200 OK
    Server: Microsoft-IIS/4.0
    Data: Mon, 5 Jan 2004 13:13:33 GMT
    Content-Length: 112
    
    <html>
        <head>
            <title>HTTP Response Example</title>
        </head>
        <body>
            Welcome to Brainy Software
        </body>
    </html>
    

    威尼斯正规官网 3

    http-respond.jpg

    意况码 200 表示央浼成功。
    八方呼应实体正文是一段 HTML 代码

    }
    }
    Socket 服务端实例
    正如的GreetingServer 程序是七个劳动器端应用程序,使用 Socket 来监听叁个点名的端口。
    GreetingServer.java 文件代码:
    // 文件名 GreetingServer.java

    1.2 Socket 类

    Socket (套接字卡塔尔(قطر‎ 是网络连接的端点。Socket 使应用程序可以从互连网中读取数据,能够向互连网中写入数据。分化Computer上的五个应用程序能够通过一连发送或接纳字节流,以此抵达互相通讯的指标。为了从叁个应用程序向另三个应用程序发送音讯,需求知道另一个应用程序中 Socket 的 IP 地址和端口号。

    public class Socket
    extends Object
    implements Closeable
    This class implements client sockets (also called just "sockets"). A socket is an endpoint for communication between two machines.
    The actual work of the socket is performed by an instance of the SocketImpl class. An application, by changing the socket factory that creates the socket implementation, can configure itself to create sockets appropriate to the local firewall.

    创办贰个 Socket :

    Socket() Creates an unconnected socket, with the system-default type of SocketImpl.
    Socket(String host, int port) Creates a stream socket and connects it to the specified port number on the named host.
    Socket(String host, int port, boolean stream) Deprecated. Use DatagramSocket instead for UDP transport.

    host - the host name, or null for the loopback address.

    port - the port number.

    host:远程主机的称呼或 IP 地址 (127.0.0.1 表示二个本地主机卡塔尔(قطر‎
    post:连接远程应用程序的端口号

    接收 socket 实例发送/选用字节流:
    socket.getOutputStream()

    出殡文书
    PrintWriter out = new PrintWriter(socket.getOutputStream(), true)

    选拔字节流:
    socket.getInputStream()

    import java.net.;
    import java.io.
    ;

    Example: 创设贰个Socket,用于与当地 HTTP 服务器进行通讯


    Socket socket = new Socket(host, portNumber);
    OutputStream os = socket.getOutputStream();
    boolean autoflush = true;
    PrintWriter out = new PrintWriter(socket.getOutputStream(), autoflush);
    String message = command.getText();
    out.println(message);
    out.println("Host: localhost:8080");
    out.println("Connection: Close");
    out.println();
    BufferedReader in = new BufferedReader(
            new InputStreamReader(socket.getInputStream()));
    boolean loop = true;
    StringBuffer sb = new StringBuffer(8096);
        while(loop){
        if (in.ready()) {
            int i = 0;
            while (i != -1) {
                i = in.read();
                sb.append((char) i);
            }
            loop = false;
        }
        Thread.currentThread().sleep(50);
    }
        response.setText(sb.toString());
        socket.close();
    

    public class GreetingServer extends Thread
    {
    private ServerSocket serverSocket;

    ServerSocket 类

    Socket 类:表示二个顾客端套接字。
    ServerSocket 类:服务器套接字。

    public class ServerSocket
    extends Object
    implements Closeable
    This class implements server sockets. A server socket waits for requests to come in over the network. It performs some operation based on that request, and then possibly returns a result to the requester.
    The actual work of the server socket is performed by an instance of the SocketImpl class. An application can change the socket factory that creates the socket implementation to configure itself to create sockets appropriate to the local firewall.

    服务器套接字要等待来自客商端的接连几天诉求。当服务器套接字选用到了连年央浼之后,它会创制四个Socket 实例来拍卖与客商端的通讯。

    ServerSocket 的构造函数

    Constructor Description
    ServerSocket() Creates an unbound server socket.
    ServerSocket(int port) Creates a server socket, bound to the specified port.
    ServerSocket(int port, int backlog) Creates a server socket and binds it to the specified local port number, with the specified backlog.
    ServerSocket(int port, int backlog,InetAddress bindAddr) Create a server with the specified port, listen backlog, and local IP address to bind to.

    port - the port number, or 0 to use a port number that is automatically allocated.

    backlog - requested maximum length of the queue of incoming connections.

    bindAddr - the local InetAddress the server will bind to

    backlog:服务端socket处理顾客端socket连接是索要自然时间的。ServerSocket有三个队列,贮存还未来得及管理的顾客端Socket,这一个行列的容积正是backlog的含义。若是队列已经被客商端socket占满了,纵然还应该有新的三番五次过来,那么ServerSocket会回绝新的连天。也正是说backlog提供了容积节制作而成效,幸免太多的客商端socket占用太多服务器资源。

    bindAddr:必须是 java.net.InetAddress. 类的实例

    创建 InetAddress 实例对象的一种简易方法是调用其静态方法 getByName(),传入包括主机名的字符串:

    InetAddress.getByName("127.0.0.1");

    创建了 ServerSocket 实例后,能够使其等待传入的连接乞请,该央求会通过劳动器套接字侦听的端口上的绑定地址传入,这一个专门的职业能够通过调用 ServerSocket 类的 accept 方法成功。只有收纳连接央浼后,该方式才会重临。

    public Socket accept() throws IOException

    A new Socket s is created and, if there is a security manager, the security manager's checkAccept method is called with s.getInetAddress().getHostAddress() and s.getPort() as its arguments to ensure the operation is allowed. This could result in a SecurityException.

    Returns: the new Socket.

    public GreetingServer(int port) throws IOException
    {
    serverSocket = new ServerSocket(port);
    serverSocket.setSoTimeout(10000);
    }

    1.3 应用程序

    本章的 Web 服务器富含多个类:

    • HttpServer
    • Request
    • Response
    1. 次第的入口点(静态 main()方法)在 HttpServer 类中。main()办法成立三个 HttpServer 实例,然后调用其 await() 方法。
    2. await()方法会在钦点端口上等待 HTTP 诉求,对其拍卖,然后发送响应新闻回客商端。在接到到关闭命令前,它会维持等待状态。

    该应用程序仅发送坐落于钦点目录的静态财富诉求,如 HTML 文件和图像文件,它将盛传到的 HTTP 须求字节流现实到调控台上。不过它不发送任何 header (头音信卡塔尔国到浏览器,如日期或 cookies 等。

    public void run()
    {
    while(true)
    {
    try
    {
    System.out.println("等待远程连接,端口号为:" + serverSocket.getLocalPort(卡塔尔 + "..."State of Qatar;
    Socket server = serverSocket.accept();
    System.out.println("远程主机地址:" + server.getRemoteSocketAddress(卡塔尔国卡塔尔;
    DataInputStream in = new DataInputStream(server.getInputStream());
    System.out.println(in.readUTF());
    DataOutputStream out = new DataOutputStream(server.getOutputStream());
    out.writeUTF("多谢连接作者:" + server.getLocalSocketAddress(卡塔尔 + "nGoodbye!");
    server.close();
    }catch(SocketTimeoutException s)
    {
    System.out.println("Socket timed out!");
    break;
    }catch(IOException e)
    {
    e.printStackTrace();
    break;
    }
    }
    }
    public static void main(String [] args)
    {
    int port = Integer.parseInt(args[0]);
    try
    {
    Thread t = new GreetingServer(port);
    t.run();
    }catch(IOException e)
    {
    e.printStackTrace();
    }
    }
    }

    1.3.1 HttpServer

    package ch1;
    import java.io.IOException;
    import java.io.File;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    
    // 处理对指定目录中静态资源的请求
    public class HttpServer {
    
        // 指明目录
        public static final String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";
    
        //目录名为 'webroot'
    
    
        // shutdown command
        private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
        // 关闭命令——/SHUTDOWN
    
        // the shutdown command received
        private boolean shutdown = false;
    
        public static void main(String[] args) {
            HttpServer server = new HttpServer();
            server.await();
        }
    
        public void await() {
    
            ServerSocket serverSocket = null;
            int port = 8080;
    
            try {
                serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }
    
            //Loop waiting for a request
            while (!shutdown) {
                Socket socket = null;
                InputStream input = null;
                OutputStream output = null;
    
                try {
                    // accept()
                    // Listens for a connection to be made to this socket
                    // and accepts it. The method blocks until a connection is made.
                    socket = serverSocket.accept();
    
                    // getInputStream()
                    // an input stream for reading bytes from this socket.
                    input = socket.getInputStream();
    
                    // getOutputStream()
                    // an output stream for writing bytes to this socket.
                    output = socket.getOutputStream();
    
                    // creat Request object and parse
                    Request request = new Request(input);
                    request.parse();
    
                    // creat Response object
                    Response response = new Response(output);
                    response.setRequest(request);
                    response.sendStaticResource();
    
                    // close the socket
                    socket.close();
    
                    // check if the prevous URI is a shutdown command
                    shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
                    // 判断一个输入元素与是否与已知元素相同
    
                } catch (Exception e) {
                    e.printStackTrace();
                    continue;
                }
            }
        }
    }
    

    其一 Web 服务器能够拍卖对点名目录中的静态财富的乞求。该目录包涵国有静态变量 final WEB_ROOT 指明的目录及其全数子目录。WEB_ROOT 的开首值为:

    public static final String WEB_ROOT = 
        System.getProperty("user.dir") + File.separator + "webroot";
    

    若要须要静态能源,能够在浏览器的地址栏或 URL 框中输入如下的 URL

    http://machineName:port/staticResource

    http://localhost:8080/source

    若从另一台计算机上向该应用程序发出央求,则 machineName 是应用程序所在Computer的名目或 IP 地址;若在长久以来台机器上爆发的倡议,则足以将 machineName 替换为 localhost

    此延续必要使用的端口为 8080。

    staticResourse 是要求的文书的名字,该文件必得放在 WEB_ROOT 指向的目录下。

    若要关闭服务器,可以透过 Web 浏览器之处栏或 URAV4I 框,在 U昂CoraI 的 host:port 部分前面输入预先定义好的字符串,从 WEB 浏览器发送一条关闭命令,那样服务器就能够接到关闭命令了。

    例中的关闭命令定义在 HttpServer 类的 SHUTDOWN 静态 final 变量中:

    private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
    

    若要关闭服务器,输入

    http://localhost:8080/SHUTDOWN

    await() 方法并不是 wait() 方法,是因为 wait() 方法是 java.lang.Object 类中与使用线程相关的机要方法。

    1. await() 方法先创设一个 ServerSocket 实例,然后进入一个 while 循环,从 8080 端口选取到 Http 请求后, await() 方法会从 accept() 方法重回的 Socket 实例中,获取 java.io.InputStreamjava.io.OutputStream 对象:

      input = socket.getInputStream();
      output = socket.getOutputStream();
      
    2. 之后,await() 方法创立三个 Request 对象,并调用其 paser() 方法来深入分析 HTTP 须求的本来数据:

    //create Request object and parse
    Request request = new Request(input);
    request.parse(); 
    
    1. 然后,await() 方法会创制叁个 Response 对象,并分别调用其 setRequest() 方法和 sendStaticResource() 方法:

      // creat Response object
      Response response = new Response(output);
      response.setRequest(request);
      response.sendStaticResource();
      
    2. 最后,await() 方法关闭套接字,调用 Request 类的 getUri() 方法来测验 HTTP 请求的 URI 是不是是关闭命令,借使,则将变量 shutdown 设置为 true,程序退出 while 循环。

      // close the socket
      socket.close();
      
      // check if the prevous URI is a shutdown command
      shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
      

    1.3.2 Request

    Request 类表示贰个 HTTP 央浼,能够传递 InputStream 对象(从通过拍卖与顾客端通讯的 Socket 对象中获取的),来成立 Request 对象。能够调用 InputStream 对象中的 read() 方法来读取 HTTP 央浼的原本数据。

    package ch1;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    public class Request {
        private InputStream input;
        private String uri;
    
        public Request(InputStream input) {
            this.input = input;
        }
    
        // 解析 HTTP 请求的原始数据
        public void parse() {
            // read a set of characters from the socket
            StringBuffer request = new StringBuffer(2048);
            int i;
            byte[] buffer = new byte[2048];
            try {
                i = input.read(buffer);
    
            } catch (IOException e) {
                e.printStackTrace();
                i = -1;
            }
    
            for (int j = 0; j < i; j++) {
                request.append((char) buffer[j]);
            }
    
            System.out.print(request.toString());
            uri = parseUri(request.toString());
        }
    
        private String parseUri(String requestString) {
            int index1, index2;
            index1 = requestString.indexOf(' ');
            if (index1 != -1) {
                index2 = requestString.indexOf(' ', index1 + 1);
                if (index2 > index1)
                    return requestString.substring(index1 + 1, index2);
            }
            return null;
        }
    
        public String getUri() {
            return uri;
        }
    
    }
    

    Request

    parse():解析 HTTP 央求中的原始数据。通过调用 private 方法 parseUri() 来解析 HTTP 请求的 URI

    parseUri(String requestString):将 URI 存款和储蓄在变量 uri 中。

    getUri():返回 HTTP 请求的 URI

    1. parse() 方法从传出到 Request 对象中的套接字的 InputStream 对象中读取整个字节流,并将字节数据存储在缓冲区中。然后使用缓冲区字节数组中的数组填充 StringBuffer 对象 request ,并将 StringBufferString表示 传递给 parseUri() 方法。

      public void parse() {
              // read a set of characters from the socket
              StringBuffer request = new StringBuffer(2048);
              int i;
              byte[] buffer = new byte[2048];
              try {
                  i = input.read(buffer);
      
              } catch (IOException e) {
                  e.printStackTrace();
                  i = -1;
              }
      
              for (int j = 0; j < i; j++) {
                  request.append((char) buffer[j]);
              }
      
              System.out.print(request.toString());
              uri = parseUri(request.toString());
          }
      
    2. parseURI() 方法从呼吁行中收获 URI

      private String parseUri(String requestString) {
              int index1, index2;
              index1 = requestString.indexOf(' ');
              if (index1 != -1) {
                  index2 = requestString.indexOf(' ', index1 + 1);
                  if (index2 > index1)
                      return requestString.substring(index1 + 1, index2);
              }
              return null;
          }
      

    1.3.3 Response

    Response 类表示 HTTP 响应。

    package ch1;
    
    import java.io.*;
    
    public class Response {
        private static final int BUFFER_SIZE = 2048;
        Request request;
        OutputStream output;
    
        public Response(OutputStream output) {
            this.output = output;
        }
    
        public void setRequest(Request request) {
            this.request = request;
        }
    
        public void sendStaticResource() throws IOException {
    
            byte[] bytes = new byte[BUFFER_SIZE];
            FileInputStream fis = null;
    
            try {
                File file = new File(HttpServer.WEB_ROOT, request.getUri());
                if (file.exists()){
                    fis = new FileInputStream(file);
                    int ch = fis.read(bytes, 0, BUFFER_SIZE);
    
                    String msg = "HTTP/1.1 404 File Not Foundrn" +
                            "Content-Type: text/htmlrn" +
                            "rn";
                    output.write(msg.getBytes());
    
                    while (ch != -1){
                        output.write(bytes, 0, ch);
                        ch = fis.read(bytes, 0, BUFFER_SIZE);
                    }
                }
                else {
                    // find not found
                    String errorMessage = "HTTP/1.1 404 File Not Foundrn" +
                            "Content-Type: text/htmlrn" +
                            "Content-Length: 23rn" +
                            "rn" +
                            "<h1>File Not Found</h1>";
                    output.write(errorMessage.getBytes());
                }
    
            }catch (Exception e){
                // thrown if cannot instantiate a File object
                System.out.println(e.toString());
            }
            finally {
                if (fis != null ){
                    fis.close();
                }
            }
    
        }
    }
    
    1. Response 类的布局函数接收二个 java.io.OutputStream 对象,:

          public Response(OutputStream output) {
              this.output = output;
          }
      
    2. Response 对象在 HttpServer 类的 await() 方法中,通过传播从套接字中得到的 OutputStream 来创建。

    3. Response 内有三个 public 方法:setRequest()sendStaticResourse()setRequest() 方法会采纳三个 Request 对象作为参数。

    4. sendStaticResource() 方法用于发丝绸之路过一个静态财富到浏览器,如 HTML 文件。

      1. 它首先会经过传播父路线和子路线到 File 类的布局函数中来实例化 java.io.File 类:

        File file = new File(HttpServer.WEB_ROOT, request.getUri());
        
      2. 下一场,它检查该文件是或不是存在。

      3. 若存在,sedStaticResource() 方法会使用 File 对象创造 java.io.InputStream 。然后它调用 FileInputStream 类的 read() 方法,并将字节数据写入到 OutputStream 输出中。(这种气象下,静态能源的始末作为村生泊长数据发送到浏览器的):

        if (file.exists()){
            fis = new FileInputStream(file);
            int ch = fis.read(bytes, 0, BUFFER_SIZE);
        
            // mac 防止出错
            String msg = "HTTP/1.1 404 File Not Foundrn" +
                    "Content-Type: text/htmlrn" +
                    "rn";
            output.write(msg.getBytes());
        
            while (ch != -1){
                output.write(bytes, 0, ch);
                ch = fis.read(bytes, 0, BUFFER_SIZE);
            }
        }
        
      4. 若一纸空文,staticResource() 会发送错误新闻到浏览器:

         else {
            // find not found
            String errorMessage = "HTTP/1.1 404 File Not Foundrn" +
                    "Content-Type: text/htmlrn" +
                    "Content-Length: 23rn" +
                    "rn" +
                    "<h1>File Not Found</h1>";
            output.write(errorMessage.getBytes());
        }
        

    1.3.5 运转应用程序

    1. 执行 ch1 包

    2. 在地点栏或 URL 框输入:

      http://localhost:8080/source.html

    Result

    GET /source.html HTTP/1.1
    Host: localhost:8080
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
    Upgrade-Insecure-Requests: 1
    Cookie: __utma=111872281.722673633.1521287843.1521287843.1521287843.1; __utmz=111872281.1521287843.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); Idea-7e6930cd=8b83b26b-bd8b-480c-832b-3c0b6e5d4c39
    User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/604.5.6 (KHTML, like Gecko) Version/11.0.3 Safari/604.5.6
    Accept-Language: zh-cn
    Accept-Encoding: gzip, deflate
    Connection: keep-alive
    
    GET /favicon.ico HTTP/1.1
    Host: localhost:8080
    Accept: */*
    Connection: keep-alive
    Cookie: __utma=111872281.722673633.1521287843.1521287843.1521287843.1; __utmz=111872281.1521287843.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); Idea-7e6930cd=8b83b26b-bd8b-480c-832b-3c0b6e5d4c39
    User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/604.5.6 (KHTML, like Gecko) Version/11.0.3 Safari/604.5.6
    Accept-Language: zh-cn
    Referer: http://localhost:8080/source.html
    Accept-Encoding: gzip, deflate
    

    威尼斯正规官网 4

    ch1_result.png

    本文由威尼斯手机平台登陆发布于最新文章,转载请注明出处:套接字使用TCP提供了两台Computer之间的通讯机制,付费投稿安排

    关键词: