java网络编程

socker

• Socket又称“套接字”，应用程序通常通过“套接字”向网络发出请求或者应答网络请求
• 常用的Socket类型有两种：流式Socket和数据报式Socket，流式是一种面向连接的Socket，针对于面向连接的TCP服务应用，数据报式Socket是一种无连接的Socket，针对于无连接的UDP服务应用
• TCP：比较靠谱，面向连接，比较慢
• UDP：不是太靠谱，比较快
• 举个例子：TCP就像货到付款的快递，送到家还必须见到你人才算一整套流程。UDP就像某快递快递柜一扔就走管你收到收不到，一般直播用UDP。

TCP编程

server

import java.net.*;
import java.io.*;
public class GreetingServer extends Thread {
    private ServerSocket serverSocket;
    public GreetingServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
//        serverSocket.setSoTimeout(1000);

    }
    public void run() {
            try {
                System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");
                // 连接服务器
                Socket server = serverSocket.accept();
                System.out.println("客户端已连接：" + server.getInetAddress());
                //构建IO流
                while(true){
                    // 接受客户端
                    BufferedReader br = new BufferedReader(new InputStreamReader(server.getInputStream()));
                    String mess = br.readLine();
                    System.out.println("接受客户端：" + mess);

                    // 发送信息到客户端
                    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(server.getOutputStream()));
                    //如果客户端发送内容q，那么服务器就断开连接
                    if (mess.equals("q")) {
                        String str1 = "服务器返回>>bye\n";
                        bw.write(str1);
                        bw.flush();
                        System.out.println("服务器关闭");

                        break;
                    } else {
                        String str = "服务器返回>>"+mess+"\n";
                        bw.write(str);
                        bw.flush();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
    public static void main(String[] args) {
        try{
            Thread t = new GreetingServer(6666);
            t.run();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

如果客户端发送内容q，那么服务器就断开连接

client

// 文件名 GreetingClient.java

import java.net.*;
import java.io.*;
import java.util.Scanner;

public class GreetingClient
{
    public static void main(String [] args)
    {

        try {
            Socket s = new Socket("127.0.0.1",6666);
            System.out.println("客户端IP:"+s.getLocalAddress()+"端口"+s.getPort());
            //构建IO流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

            //建立键盘输入：
            Scanner scanner = new Scanner(System.in);
            while(true){
                System.out.println("请输入发送消息内容：");
                bw.write(scanner.nextLine()+"\n");
                bw.newLine();
                bw.flush();
                BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                //读取服务器返回的消息数据
                String ser_msg = br.readLine();
                System.out.println(ser_msg);
                System.out.println(s.getInetAddress().getLocalHost()+":"+s.getPort()+">>"+ser_msg);
                // 服务器发送bye的内容后，服务器就主动断开链接，客户端也要关闭
                if (ser_msg.contains("bye")) {
                    System.out.println("客户端关闭");
                    break;
                }
            }

        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

客户端输入q后，接收到服务器发送bye的内容后，服务器就主动断开链接，客户端也要关闭

http

server

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;

public class SimpleHttpServer {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        server.createContext("/get", new GetHandler());
        server.createContext("/post", new PostHandler());
        server.setExecutor(null); // creates a default executor
        server.start();
        System.out.println("Server is listening on port 8000");
    }

    // get请求处理
    static class GetHandler implements HttpHandler {
        // 重写handle方法
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            String requestParamValue = null;
            if ("GET".equals(exchange.getRequestMethod())) {
                requestParamValue = handleGetRequest(exchange);
            }
            String response = "GET request received with parameter: " + requestParamValue;
            sendResponse(exchange, response);
        }
    }
    // post请求处理
    static class PostHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            String requestParamValue = null;
            if ("POST".equals(exchange.getRequestMethod())) {
                requestParamValue = handlePostRequest(exchange);
            }
            String response = "POST request received with JSON data: " + requestParamValue;
            sendResponse(exchange, response);
        }
    }
    // 获取get请求的参数
    private static String handleGetRequest(HttpExchange exchange) {
        return exchange.getRequestURI().getQuery();
    }

    // 获取post请求的参数
    private static String handlePostRequest(HttpExchange exchange) throws IOException {
        // 读取客户端发送的JSON数据
        StringBuilder sb = new StringBuilder();
        int i;
        while ((i = exchange.getRequestBody().read()) != -1) {
            sb.append((char) i);
        }
        return sb.toString();
    }
    // 发送请求到客户端
    private static void sendResponse(HttpExchange exchange, String response) throws IOException {
        exchange.sendResponseHeaders(200, response.length());
        OutputStream os = exchange.getResponseBody();
        os.write(response.getBytes());
        os.close();
    }
}

client

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class SimpleHttpClient {
    public static void main(String[] args) throws Exception {
        sendGetRequest();
        sendPostRequest();
    }

    private static void sendGetRequest() throws Exception {
        String url = "http://localhost:8000/get?param1=value1&param2=value2";
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        // 发送get请求
        con.setRequestMethod("GET");
        // 通过con.getInputStream() 获取到与服务器建立的输入流，即服务端返回的数据流
        //InputStreamReader将字节流转换为字符流，而BufferedReader提供了缓冲和高效读取的功能，常常用来包装InputStreamReader以提供更好的读取性能。
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();
        //不断地调用 BufferedReader 的 readLine() 方法，每次读取一行数据，并将其加入到 StringBuffer 中。
        // 当 readLine() 方法返回 null 时，表示已经读取完了所有的数据，循环结束
        while ((inputLine=in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        // 打印服务器的响应
        System.out.println("GET Response from server: " + response.toString());
    }

    private static void sendPostRequest() throws Exception {
        String url = "http://localhost:8000/post";
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("Content-Type", "application/json");

        String jsonInputString = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";

        con.setDoOutput(true);
        try (OutputStream os = con.getOutputStream()) {
            byte[] input = jsonInputString.getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        // 打印服务器的响应
        System.out.println("POST Response from server: " + response.toString());
    }
}

• BufferedReader 和InputStreamReader用法，一般都是BufferedReader 包装InputStreamReader。

• StringBuffer 是一个可变字符串，作用是在处理大量字符串拼接操作时提供更高效的性能

• 运行服务端和客户端代码得到结果：

GET Response from server: GET request received with parameter: param1=value1&param2=value2
POST Response from server: POST request received with JSON data: {"name":"John", "age":30, "city":"New York"}