网络通信

代码1

//客户端
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws IOException {
        //创建客户端socket
        Socket socket=new Socket("localhost",8888);
        //获取输出流对象
        OutputStream os = socket.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        //写出数据
        dos.writeUTF("你好啊，弟弟");
        //关闭客户端socket，关闭流
        dos.close();
        socket.close();
    }
}


//服务端
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        //创建socket服务端对象
        ServerSocket serverSocket=new ServerSocket(8888);
        //获取来连接的客户端socket对象
        Socket socket=serverSocket.accept();
        //获取输入流对象
        InputStream inputStream=socket.getInputStream();
        DataInputStream dis=new DataInputStream(inputStream);
        //取出数据
        String s = dis.readUTF();
        System.out.println("收到消息：\t"+s);
        //关闭资源
        dis.close();
        serverSocket.close();
    }
}

代码2

 

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws IOException {
        //创建客户端socket
        Socket socket=new Socket(InetAddress.getLocalHost(),9999);
        //获取输出流
        OutputStream os=socket.getOutputStream();
        PrintStream ps = new PrintStream(os);
        //写出数据到服务端
        ps.println("你好啊，弟弟");

        //获取输入流
        InputStream inputStream=socket.getInputStream();
        InputStreamReader reader = new InputStreamReader(inputStream);
        BufferedReader br = new BufferedReader(reader);
        //读取服务端发来的消息
        String s = br.readLine();
        System.out.println("收到服务端消息:"+s);
        //关闭资源
        br.close();
        ps.close();
        socket.close();
    }
}





import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        //创建socket服务端对象
        ServerSocket serverSocket = new ServerSocket(9999);
        //获取对应的客户端socket
        Socket socket = serverSocket.accept();
        //获取输入流
        InputStream ips=socket.getInputStream();
        //将字节流变为字符流
        InputStreamReader ipsr=new InputStreamReader(ips);
        //将字符流变为缓冲字符流
        BufferedReader bufferedReader=new BufferedReader(ipsr);

        //读取客户端发来的消息
        String s = bufferedReader.readLine();
        System.out.println("收到消息："+s);

        //获取输出流
        OutputStream ops=socket.getOutputStream();
        PrintStream ps = new PrintStream(ops);

        //写出数据到客户端
        ps.println("你好啊");

        //关闭资源
        ps.close();
        bufferedReader.close();
        socket.close();

    }
}

代码3

 

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

public class Nclient {
    public static void main(String[] args) throws IOException {
        System.out.println("------------客户端------------");
        //创建客户端对象
        Socket socket=new Socket("localhost",9999);
        //获取输出流
        OutputStream ops = socket.getOutputStream();
        PrintStream ps = new PrintStream(ops);

        //获取输入流
        InputStream ips=socket.getInputStream();
        InputStreamReader ipr=new InputStreamReader(ips);
        BufferedReader br= new BufferedReader(ipr);
        //写出消息
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入消息：");
            String mess = sc.next();
            if (mess.equalsIgnoreCase("stop")){
                break;
            }
            ps.println(mess);
            String result=br.readLine();
            System.out.println("服务端回复："+result);
        }
        br.close();
        ps.close();
        socket.close();
    }
}



import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Nserver {
    public static void main(String[] args) throws IOException {
        System.out.println("---------server-------");
        //创建服务端对象
        ServerSocket serverSocket=new ServerSocket(9999);
        //获取对应的客户端socket
        Socket socket=serverSocket.accept();
        //获取输入流
        InputStream ips = socket.getInputStream();
        BufferedReader br=new BufferedReader(new InputStreamReader(ips));
        //写出数据使用输出流
        OutputStream os = socket.getOutputStream();
        PrintStream ps=new PrintStream(os);

        //读取客户端消息
        String s ="";
        while ((s=br.readLine())!=null){
            System.out.println("客户端发来消息："+s);
            //将客户端传来的消息存到StringBuilder并反转
            StringBuilder sbder=new StringBuilder(s);
            sbder.reverse();
            //使用输出流返回给客户端
            ps.println(sbder.toString());
        }
        //关闭资源
        ps.close();
        br.close();
        socket.close();
        serverSocket.close();
    }
}

代码4

//服务端代码

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Mserver {
    public static void main(String[] args) throws IOException {
        System.out.println("------------服务端-------------");
        //创建服务端对象
        ServerSocket serverSocket=new ServerSocket(9999);
        //获取对应的客户端对象
        int count=0;
        while (true){
            Socket socket=serverSocket.accept();
            String hostName=socket.getInetAddress().getHostName();
            System.out.println(hostName+"第"+(++count)+"个来连接的客户端");
            SocketThread socketThread=new SocketThread(hostName,socket);
            socketThread.start();
        }


    }
}

class SocketThread extends Thread{
    private Socket socket;
    private String name;

    public SocketThread(String name, Socket socket) {
        super(name);
        this.name=name;
        this.socket = socket;
    }

    @Override
    public void run() {
        try(
            //接受客户端消息，输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //向客户端发送消息，输出流
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ) {
            //使用循环不停接收消息
            String mess="";
            while ((mess=br.readLine())!=null){
                System.out.println("客户端"+name+"发来消息："+mess);
                //把消息反转
                StringBuilder sb1=new StringBuilder(mess);
                sb1.reverse();
                //返回给客户端
                ps.println(sb1.toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


//客户端代码，可以多个客户端

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

public class Mclient {
    public static void main(String[] args) throws IOException {
        System.out.println("------------客户端------------");
        //创建客户端对象
        Socket socket=new Socket("localhost",9999);
        //获取输出流
        OutputStream ops = socket.getOutputStream();
        PrintStream ps = new PrintStream(ops);

        //获取输入流
        InputStream ips=socket.getInputStream();
        InputStreamReader ipr=new InputStreamReader(ips);
        BufferedReader br= new BufferedReader(ipr);
        //写出消息
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入消息：");
            String mess = sc.next();
            if (mess.equalsIgnoreCase("stop")){
                break;
            }
            ps.println(mess);
            String result=br.readLine();
            System.out.println("服务端回复："+result);
        }
        br.close();
        ps.close();
        socket.close();
    }
}

代码5

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.Arrays;

/*
UDP:非面向连接，不可靠的，一次只能最大发送64kb的数据
DatagramSocket:客户端/服务端
DatagramPacket:数据包
* */
public class Dserver {
    public static void main(String[] args) throws IOException {
        System.out.println("server");
        //服务端
        DatagramSocket dsServer=new DatagramSocket(8888);
        //准备数据包
        byte b[]=new byte[1024*20];
        DatagramPacket packet=new DatagramPacket(b,b.length);
        //接收数据
        dsServer.receive(packet);
        //获取发送来的数据
        System.out.println("packet.getData() = " + packet.getData());
        System.out.println(Arrays.toString(packet.getData()));
        //客户端地址
        System.out.println("packet.getAddress() = " + packet.getAddress());
        //获取发送数据包的客户端端口号，当客户端没有指定端口时，系统会随机分配端口
        System.out.println("packet.getPort() = " + packet.getPort());
        //有效数据的个数
        System.out.println("packet.getLength() = " + packet.getLength());
        String s=new String(b);
        System.out.println(s);
    }
}




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

public class Dclient {
    public static void main(String[] args) throws IOException {
        System.out.println("client");
        //新建客户端对象
        DatagramSocket ds = new DatagramSocket(9999);

        //准备数据包
        String mess="abcd";
        byte[] bytes=mess.getBytes();
        //数据，目的地，端口
        DatagramPacket packet= new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),8888);

        //发送数据
        ds.send(packet);
    }
}

代码6

 

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class DataServer {
    public static void main(String[] args) throws IOException {
        System.out.println("---------server---------");
        //创建服务端对象
        DatagramSocket datagramSocket=new DatagramSocket(8888);
        //准备数据包
        byte[] bs=new byte[1024];
        DatagramPacket packet=new DatagramPacket(bs,bs.length);
        //接收数据
        datagramSocket.receive(packet);
        //输出数据
        String s = new String(bs,0,bs.length);
        System.out.println("客户端发来的数据："+s);
        //返回数据给客户端
        byte[] bytes="铁锅炖大鹅".getBytes();
        DatagramPacket sendPacket=new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),packet.getPort());
        //数据发送给客户端
        datagramSocket.send(sendPacket);

    }
}



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

public class DataClient {
    public static void main(String[] args) throws IOException {
        System.out.println("----------client-----------");
        //创建客户端对象
        DatagramSocket ds=new DatagramSocket();
        //准备数据包
        String s1="今天吃什么";
        byte[] bytes=s1.getBytes();
        DatagramPacket packet=new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),8888);
        //发送数据包
        ds.send(packet);

        //准备数据包.接收服务端反馈的消息
        byte[] b = new byte[1024];
        DatagramPacket reciveData=new DatagramPacket(b,b.length);
        ds.receive(reciveData);
        String s2 = new String(b,0,b.length);
        System.out.println("服务端："+s2);
    }
}

代码7