Java--网络编程(二)

Udp 服务器和客户端

一.回显服务器

复制代码

import java.io.IOException;
import java.net.*;

public class EdpChoServe {
    private DatagramSocket socket = null;
    public EdpChoServe(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            //创建接收缓冲区DatagramPacket
            DatagramPacket requestparcket = new DatagramPacket(new byte[1024],1024);
            //接收客户端数据
            socket.receive(requestparcket);
            //将数据转化为字符串类型
            String request = new String(requestparcket.getData(),0, requestparcket.getLength());
            //将转化后的数据通过process方法进行处理（此处直接返回，如果要进行相关数据的处理直接修改process方法）
            String response = process(request);
            //再次创建DatagramPacket套接字，将加工的数据给客户端发送
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
                    response.getBytes().length,requestparcket.getSocketAddress());
            //发送数据
            socket.send(responsePacket);
            //打印客户端地址,端口,请求和相应信息
            System.out.printf("[%s:%d] req:%s,resp:%s\n",requestparcket.getAddress().toString(),
                    requestparcket.getPort(),request,response);
        }
    }
    private String process(String request){
        String response = "服务端返回的消息："+request;
        return response;
    }

    public static void main(String[] args) throws IOException {
        EdpChoServe serve = new EdpChoServe(1010);
        serve.start();
    }
}

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

public class EdpChoClient {
    private DatagramSocket socket = null;
    private String IP;
    private int Port;
    public EdpChoClient(String ip,int port) throws SocketException {
        socket = new DatagramSocket();
        this.IP = ip;
        this.Port = port;
    }
    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scanner = new Scanner(System.in);
        while (true){
            //输入要传输的内容
            String request = scanner.next();
            //创建DatagramPacket来储存数据 字节数组，数组长度,IP地址和端口号
            DatagramPacket requestpacket = new DatagramPacket(request.getBytes(),request.getBytes().length, InetAddress.getByName(this.IP),this.Port);
            //发送数据
            socket.send(requestpacket);
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
            //接收客户端处理后的消息
            socket.receive(responsePacket);
            //转化为 String 类型
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            //打印
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        EdpChoClient client = new EdpChoClient("127.0.0.1",1010);
        client.start();
    }
}

二.翻译服务器

翻译服务器跟我们上个文章做的回显服务器相似：

我们用 HashMap 来模拟字典，当我们输入单词的时候，返回相对应的意思

翻译服务器和回显服务器的区别就是对收到的信息进行处理的方式不同，回显服务器我们直接返回的字符串，翻译服务器我们通过 HashMap 来获取翻译后的结果并返回，

复制代码

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.HashMap;

public class UdpServe {
    private HashMap<String,String> dic = new HashMap<String,String>();
    private DatagramSocket socket= null;
    public UdpServe(int port) throws SocketException {
        socket = new DatagramSocket(port);
        //创建词典，实际应用的话，数据要比这些多的多
        dic.put("hello","你好");
        dic.put("world","世界");
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            //创建数据缓存区，准备接收数据
            DatagramPacket resquestpacket = new DatagramPacket(new byte[1024],1024);
            //接收数据，将数据存入缓存区
            socket.receive(resquestpacket);
            //将数据转化为字符串
            String request = new String(resquestpacket.getData(),0, resquestpacket.getLength());
            //对内容进行处理
            String newrequest = process(request);
            //创建数据缓存区，准备发送处理后的数据
            DatagramPacket response = new DatagramPacket(newrequest.getBytes(),
                    newrequest.getBytes().length,resquestpacket.getSocketAddress());
            //发送数据
            socket.send(response);
            //打印相关内容
            System.out.printf("[%s:%d] req:%s,resq:%s\n",resquestpacket.getAddress().toString(),resquestpacket.getPort()
            ,resquestpacket,response);
        }
    }

    private String process(String request) {
        return dic.getOrDefault(request,"未找到单词");
    }

    public static void main(String[] args) throws IOException {
        UdpServe serve = new UdpServe(9090);
        serve.start();
    }
}

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

public class UdpClient {
    private DatagramSocket socket = null;
    private String IP;
    private int Port;
    public UdpClient(String IP,int Port) throws SocketException {
        //实例化对象并且添加属性
        socket = new DatagramSocket();
        this.IP = IP;//IP地址
        this.Port = Port;//端口号
    }
    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scanner = new Scanner(System.in);
        while (true){
            //读取输入内容
            String request = scanner.next();
            //创建数据缓存区，准备发送数据
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                    request.getBytes().length, InetAddress.getByName(this.IP),this.Port);
            //发送数据
            socket.send(requestPacket);
            //再次创建数据缓存区，准备接收数据
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
            //接收数据
            socket.receive(responsePacket);
            //转化为字符串类型
            String response = new String(responsePacket.getData(),0, responsePacket.getLength());
            //打印接收到的内容
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpClient Client = new UdpClient("127.0.0.1",9090);
        Client.start();
    }
}

Tcp 服务器和客户端

一.回显服务器

复制代码

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.Scanner;

public class TcpServe {
    private ServerSocket serversocket = null;
    public TcpServe(int Port) throws IOException {
        serversocket = new ServerSocket(Port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket socket = serversocket.accept();
            ProcessNection(socket);
        }
    }

    private void ProcessNection(Socket socket) throws IOException {
        System.out.printf("[%s:$d]","客户端上线",socket.getInetAddress(),socket.getPort());
        //创建输入流和输出流分别用来读取和输出数据
        try(InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream()) {
            //创建 scanner 来读取数据
            Scanner scanner = new Scanner(inputStream);
            //将字符串直接写入到socket的输出流中发送给客户端。
            PrintWriter writer = new PrintWriter(outputStream);
            while(true){
                //检查客户端是否下线
                if (!scanner.hasNext()){
                    System.out.printf("[%s:%d] 客户端下线\n",socket.getInetAddress(),socket.getPort());
                }
                //读取数据
                String request = scanner.next();
                //处理数据
                String resoponse = process(request);
                //输出数据给客户端
                writer.println(resoponse);
                //冲刷缓冲区
                writer.flush();
                //打印客户端信息
                System.out.printf("[%s:%d] req:%s resp:%s\n",socket.getInetAddress(),socket.getPort(),
                        request,resoponse);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                //关闭与客户端的socket连接
                socket.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpServe server = new TcpServe(1010);
        server.start();
    }
}

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

public class TcpClient {
    private Socket socket = null;
    public TcpClient(String IP,int Port) throws IOException {
        socket = new Socket(IP,Port);
        //socket.connect(new InetSocketAddress(InetAddress.getByName(IP),Port));
    }
    public void start(){
        System.out.println("客户端启动");
        //创建输入流和输出流分别用来读取和输出数据
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()){
            System.out.println("->");
            //输入要发送给服务器的数据
            Scanner scanner = new Scanner(System.in);
            //用于获取数据和输出数据
            Scanner newScanner = new Scanner(inputStream);
            PrintWriter writer = new PrintWriter(outputStream);
            while (true){
                //读取输入内容
                String request = scanner.next();
                //发送数据
                writer.println(request);
                //缓存区冲刷
                writer.flush();
                //检查从服务器接收的数据流是否还有下一个数据项
                if (!newScanner.hasNext()){
                    break;
                }
                //将数据转化为字符串类型
                String response = newScanner.next();
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpClient client = new TcpClient("127.0.0.1",1010);
        client.start();
    }
}

二.翻译服务器

为了方便，此处我们直接继承回显服务器（记得改变客户端端口号）

复制代码

import java.io.IOException;
import java.util.HashMap;

public class DicTcpServe extends TcpServe{
    HashMap<String,String> dic = new HashMap<String,String>();
    public DicTcpServe(int Port) throws IOException {
        super(Port);
        dic.put("hello","你好");
        dic.put("world","世界");
    }
    @Override
    public String process(String request) {
        return dic.getOrDefault(request,"未找到单词");
    }

    public static void main(String[] args) throws IOException {
        DicTcpServe server = new DicTcpServe(2020);
        server.start();
    }
}