网络编程入门

Posted 2022-12-03 TaiJi1985

网络编程入门

1 Java创建服务端监听

java在服务端监听使用一个类叫做SeverSocket

        //创建一个客户端socket，并且连接
        Socket socket = new Socket("114.214.72.203",1985);
        //获取输入输出流，并封装
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
        PrintWriter pw = new PrintWriter(out); 
        //先发送   客户端-》服务端

        pw.println("你吃了吗？");
        pw.flush();
        //服务端-》客户端 ,客户端读取。。。
        String msg = sc.nextLine();
        System.out.println("服务端说:"+msg);

        socket.close();

其中，ServerSocket的构造函数中，包含了监听的端口号。
随后获取输入输出流。

并且先读取后写出。 即 先从客户端到服务端，后从服务端发客户端。然后关闭。

这是一个最原始的服务端模型，只接受一次请求，处理一次请求。然后就关闭了。。

2 客户端的编写

java中使用socket类来进行客户端编写，他的构造函数有两个参数，一个是ip或者域名，一个是端口号。

package org.yang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client 

    /**
     * @param args
     * @throws IOException 
     * @throws UnknownHostException 
     */
    public static void main(String[] args) throws UnknownHostException, IOException 

        //创建一个客户端socket，并且连接
        Socket socket = new Socket("114.214.72.203",1985);
        //获取输入输出流，并封装
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
        PrintWriter pw = new PrintWriter(out); 
        //先发送   客户端-》服务端

        pw.println("你吃了吗？");
        pw.flush();
        //服务端-》客户端 ,客户端读取。。。
        String msg = sc.nextLine();
        System.out.println("服务端说:"+msg);

        socket.close();
    

这个例子中，先连接，后写出，后读取。完成了和上述服务器的一个通讯过程。

　服务端的改进

为了让服务端能处理多次请求，我们加了一个循环。

package org.yang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.Scanner;

public class ServerV2 

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException 
        //创建一个服务端套接字，并且在1985端口监听
        System.out.println("start start!");
        ServerSocket ss = new ServerSocket(1985); 
        //等待客户连接，如果来了连接就接受，并返回和这个客户通讯的socket
        while(true)
            Socket socket = ss.accept();
            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();
            /*
             *  通过一段时间的脑通，我们设计了一个简单协议：
             *  客户端->服务端  
             *  服务端->客户端 
             */     
            //客户端->服务端   ，服务端接受
            String ip = socket.getRemoteSocketAddress().toString();
            Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
            String msg = sc.nextLine();//读取一样
            System.out.println("收到消息: "+ ip + " " + msg );

            //服务端->客户端 ,输出
            PrintWriter pw = new PrintWriter(out); 
            pw.println(new Date()+"\\n");
            pw.flush();

            socket.close();
        
        //System.out.println("finish");
    

    //

客户端的改进

每次都是发出一样的消息，不满足需求，所以我们先读取用户的输入，然后发出去。

package org.yang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class ClientV2 

    /**
     * @param args
     * @throws IOException 
     * @throws UnknownHostException 
     */
    public static void main(String[] args) throws UnknownHostException, IOException 

        System.out.print("请输入:");
        Scanner sc_console =new Scanner(System.in);
        String myMsg  = sc_console.nextLine();

        //创建一个客户端socket，并且连接
        Socket socket = new Socket("114.214.72.203",1985);
        //获取输入输出流，并封装
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
        PrintWriter pw = new PrintWriter(out); 
        //先发送   客户端-》服务端

        pw.println(myMsg);
        pw.flush();
        //服务端-》客户端 ,客户端读取。。。
        String msg = sc.nextLine();
        System.out.println("服务端说:"+msg);

        socket.close();
    

服务端再改进

上面的服务端虽然可以处理多次请求， 但无法同时处理多个请求，这时候，我们需要一个多线程的写法。

package org.yang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.Scanner;

public class ServerV3 

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException 
        //创建一个服务端套接字，并且在1985端口监听
        System.out.println("start start!");
        ServerSocket ss = new ServerSocket(1985); 
        //等待客户连接，如果来了连接就接受，并返回和这个客户通讯的socket
        while(true)
            final Socket socket = ss.accept();
            new Thread(new Runnable()
                public void run() 
                    processOne(socket);
                               
            ).start();
        
        //System.out.println("finish");
    

    public static void processOne(Socket socket)
        try 
            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();

            //客户端->服务端   ，服务端接受
            String ip = socket.getRemoteSocketAddress().toString();
            Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
            String msg = sc.nextLine();//读取一样
            System.out.println("收到消息: "+ ip + " " + msg );

            //服务端->客户端 ,输出
            PrintWriter pw = new PrintWriter(out); 
            pw.println(new Date()+"\\n");
            pw.flush();

            socket.close();
         catch (IOException e) 
            // TODO Auto-generated catch block
            e.printStackTrace();
        
    

    //

客户端的多次发送

为了能持续发送消息，我们加入一个循环

package org.yang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class ClientV3 

    /**
     * @param args
     * @throws IOException 
     * @throws UnknownHostException 
     */
    public static void main(String[] args) throws UnknownHostException, IOException 
        while(true)
            one();
        

    

    public static void one()
        try 
            System.out.print("请输入:");
            Scanner sc_console =new Scanner(System.in);
            String myMsg  = sc_console.nextLine();

            //创建一个客户端socket，并且连接
            Socket socket = new Socket("114.214.72.203",1985);
            //获取输入输出流，并封装
            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();
            Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
            PrintWriter pw = new PrintWriter(out); 
            //先发送   客户端-》服务端

            pw.println(myMsg);
            pw.flush();
            //服务端-》客户端 ,客户端读取。。。
            String msg = sc.nextLine();
            System.out.println("服务端说:"+msg);

            socket.close();
         catch (UnknownHostException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();