java基础16_网络编程

最新推荐文章于 2021-04-01 09:21:40 发布

Jobs1127c

最新推荐文章于 2021-04-01 09:21:40 发布

阅读量452

点赞数 1

分类专栏：第一部分java基础学习文章标签：网络编程 java socket

本文链接：https://blog.csdn.net/jobs1127c/article/details/53285469

版权

第一部分java基础学习专栏收录该内容

26 篇文章 0 订阅

订阅专栏

网络概念

这里写图片描述

连接，服务器端向客户端写入数据，客户端向服务器端读入数据：

package java基础.Socket;
import java.net.*;
import java.io.*;
/**
 * 要  点：
 *  1. Java Socket编程步骤
 *  2. Socket/ServerSocket类用法
 *  3. 通过Socket对象可以获取通信对方Socket的信息
 * @author Jobs1127
 */
public class TestServer {
    public static void main(String args[]) {
        try {       
            /*
             *服务器端new一个ServerSocket对象，占据一个端口
             *如果服务器端已经占据了某个端口，再尝试去占用的话，就报异常java.net.BindException: Address already in use: JVM_Bind
             */
            ServerSocket s = new ServerSocket(8881);
            while (true) {
                System.out.println("服务器端已经进入，正在等待接收客户端的Socket");
                /**
                 * 该应用程序一启动就会打印该句话，一旦客户端连接上来，即服务器端监听到Socket,进入这里也会打印一次，每次有连接进来都会打印
                 */
                Socket s1 = s.accept();//不停的监听连接上来的Socket
                if(s1 != null) {
                    OutputStream os = s1.getOutputStream();//服务器端拿到输出管道，准备给客户端输出写入数据
                    DataOutputStream dos = new DataOutputStream(os);//包装成数据流DataOutputStream
                    dos.writeUTF("Hello," + s1.getInetAddress() + 
                            "port#" +s1.getPort() + "  bye-bye!");
                    dos.flush();
                    dos.close();
                    s1.close();
                }
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package java基础.Socket;
import java.net.*;
import java.io.*;
/**
 * 要  点：
 *  1. Java Socket编程步骤
 *  2. Socket/ServerSocket类用法
 *  3. 通过Socket对象可以获取通信对方Socket的信息
 * @author Jobs1127
 * 服务器端Server，客户端Client，服务器端往客户端传输数据即写入到客户端，一般对应OutputStream
 * 客户端往服务器端传输数据一般对应的管道为InputStream
 */
public class TestClient {
    public static void main(String args[]) {
        try {
            Socket s1 = new Socket("127.0.0.1", 8881);//new一个连接服务器的Socket，对应好ip和端口
            InputStream is = s1.getInputStream();//拿到读入流
            DataInputStream dis = new DataInputStream(is);//包装读入流为数据流
            System.out.println("已连接上服务器，"+dis.readUTF());//读服务器的数据
            dis.close();
            s1.close();
        } catch (ConnectException connExc) {
            connExc.printStackTrace();
            System.out.println("服务器连接失败");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

程序演示，服务器端和客户端通过输入InputStream输出流OutputStream，包装成数据流DataOutputStream，可以通过写入到writeUTF()，和读入到readUTF()，实现互相通讯

package java基础.Socket;
import java.io.*;
import java.net.*;
/**
 * 服务器端
 * @author Jobs1127
 *
 */
public class TestSockServer {
    public static void main(String[] args) {
        InputStream in = null;
        OutputStream out = null;
        int i = 0;
        try {
            ServerSocket ss = new ServerSocket(5888);
            System.out.println("服务器端监听5888端口"+i++);
            Socket socket = ss.accept();//没有放在死循环里，只要服务器端监听并接收了客户端的Socket就马上关闭服务器
            if(socket != null) {
                in = socket.getInputStream();
                out = socket.getOutputStream();
                DataOutputStream dos = new DataOutputStream(out);
                DataInputStream dis = new DataInputStream(in);
                String s = null;
                if ((s = dis.readUTF()) != null) {
                    System.out.println(s);
                    System.out.println("from: " + socket.getInetAddress());
                    System.out.println("Port: " + socket.getPort());
                }
                dos.writeUTF("hi 客户端");
                dis.close();
                dos.close();
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package java基础.Socket;
import java.net.*;
import java.io.*;
/**
 * 客户端
 * @author Jobs1127
 *
 */
public class TestSockClient {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {
            /**
             * java.net.ConnectException: Connection refused: connect
             * 如果服务器端没有监听该端口，尝试去访问该端口，就会报上面异常
             */
            Socket socket = new Socket("localhost", 5888);
            is = socket.getInputStream();
            os = socket.getOutputStream();
            DataInputStream dis = new DataInputStream(is);
            DataOutputStream dos = new DataOutputStream(os);
            dos.writeUTF("hey servers");
            String s = null;
            if ((s = dis.readUTF()) != null);
            System.out.println(s);
            dos.close();
            dis.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

包装输出、输入流来实现服务器端和客户端的交流互动
BufferedReader可以读取一行readLine()，PrintWriter可以打印写入一行

package java基础.Socket;

import java.io.*;
import java.net.*;
import java.applet.Applet;

public class talkserver {
    public static void main(String args[]) {
        try {
            ServerSocket server = null;
            try {
                server = new ServerSocket(4700);
            } catch (Exception e) {
                System.out.println("can not listen to:" + e);
            }
            Socket socket = null;
            try {
                socket = server.accept();
            } catch (Exception e) {
                System.out.println("Error:" + e);
            }
            String line;
            BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter os = new PrintWriter(socket.getOutputStream());
            BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("Client:" + is.readLine());
            line = sin.readLine();
            /**
             * 只要不输入bye，就不关闭管道，即不关闭连接
             */
            while (!line.equals("bye")) {
                os.println(line);
                os.flush();
                System.out.println("Server:" + line);
                System.out.println("Client:" + is.readLine());
                line = sin.readLine();
            }
            is.close();
            os.close();
            socket.close();
            server.close();
        } catch (Exception e) {
            System.out.println("Error" + e);
        }
    }
}

package java基础.Socket;

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

public class talkclient {
    public static void main(String args[]) {
        try {
            Socket socket = new Socket("127.0.0.1", 4700);
            BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
            PrintWriter os = new PrintWriter(socket.getOutputStream());
            BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String readline;
            readline = sin.readLine();
            /**
             * 只要不输入bye，就不关闭管道，即不关闭连接
             */
            while (!readline.equals("bye")) {
                os.println(readline);
                os.flush();
                System.out.println("Client:" + readline);
                System.out.println("Server:" + is.readLine());
                readline = sin.readLine();
            }
            os.close();
            is.close();
            socket.close();
        } catch (Exception e) {
            System.out.println("Error" + e);
        }
    }
}

测试TCP：

package java基础.Socket;
import java.net.*;
import java.io.*;
public class TCPServer {
    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(6666);
        while (true) {
            Socket s = ss.accept();
            System.out.println("a client connect!");
            DataInputStream dis = new DataInputStream(s.getInputStream());
            System.out.println(dis.readUTF());
            dis.close();
            s.close();
        }
    }
}

package java基础.Socket;
import java.net.*;
import java.io.*;

public class TCPClient {
    public static void main(String[] args) throws Exception {
        Socket s = new Socket("127.0.0.1", 6666);
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        Thread.sleep(30000);
        dos.writeUTF("hello server!");
        dos.flush();
        dos.close();
        s.close();
    }
}

测试UDP：

package java基础.Socket;
import java.net.*;
import java.io.*;

public class TestUDPServer {
    public static void main(String args[]) throws Exception {
        byte buf[] = new byte[1024];
        DatagramPacket dp = new DatagramPacket(buf, buf.length);
        DatagramSocket ds = new DatagramSocket(5678);
        while (true) {
            ds.receive(dp);
            ByteArrayInputStream bais = new ByteArrayInputStream(buf);
            DataInputStream dis = new DataInputStream(bais);
            System.out.println(dis.readLong());
        }
    }
}

package java基础.Socket;

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

public class TestUDPClient {
    public static void main(String args[]) throws Exception {
        long n = 10000L;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeLong(n);

        byte[] buf = baos.toByteArray();
        System.out.println(buf.length);

        DatagramPacket dp = new DatagramPacket(buf, buf.length,
                new InetSocketAddress("127.0.0.1", 5678));
        DatagramSocket ds = new DatagramSocket(9999);
        ds.send(dp);
        ds.close();
    }
}

根据网络编程编写的聊天程序：

package java基础.Socket.myChat1;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ChatServer {
    public static void main(String[] args) {
        //服务器端建立监听
        ServerSocket ss = IoTools.getServerSocket(9999);
        try {
            Socket s = ss.accept();//服务器已经建立了监听，如果没有监听到客户端的连接，是不会往下执行的，监听到连接后开始往下执行
            System.out.println("一个客户端已经和服务器端建立了连接");
            //开始通讯
            IoTools.read_UTF(s);//服务器端读取客户端发送过来的信息,通过Socket桥梁去读取
            String context = "server say:hi client!";
            IoTools.send_UTF(s, context);

            //要和客户端端聊天，只要不输入bye就不结束聊天，通过BufferedReader/PrintWriter测试通讯
            System.out.println("haha0-----");
            System.out.println("client say:"+IoTools.read_buf_socket(s));//读取客户端发来的信息，如果在s管道里没有读取到，则停留在这里等待，直到读取成功才往下执行
            System.out.println("haha1---");
            String str = IoTools.read_buf_system_in(System.in);
            System.out.println("end haha---");//如果没有服务器端没有输入，程序执行不到这里，一直等待输入，只有输入了才会往下执行

            while(!str.equalsIgnoreCase("bye")) {
                IoTools.send_buf(s,str);//服务器端尝试从Socket管道发送数据给服务器端
                System.out.println("server say:"+str);
                System.out.println("client say:"+IoTools.read_buf_socket(s));//读取客户端发来的信息
                str = IoTools.read_buf_system_in(System.in);
            }
            //通讯结束后，关闭相关资源,断开连接
            IoTools.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package java基础.Socket.myChat1;

import java.net.Socket;

public class ChatClient {
    public static void main(String[] args) {
        //与服务器端建立连接
        Socket s = IoTools.getClientSokect("localhost", 9999);
        System.out.println("与服务器端建立连接");
        //开始通讯
        //通过DataOutputStream/DataInputStream测试通讯
        String context = "client say:我要给服务器发送一条信息，hi,chatserver";
        IoTools.send_UTF(s,context);
        IoTools.read_UTF(s);
        //要和服务器端聊天，只要不输入bye就不结束聊天，通过BufferedReader/PrintWriter测试通讯
        String str = IoTools.read_buf_system_in(System.in);
        while(!str.equalsIgnoreCase("bye")) {
            IoTools.send_buf(s,str);//客户端尝试从Socket管道发送数据给服务器端
            System.out.println("client say:"+str);
            System.out.println("server say:"+IoTools.read_buf_socket(s));//读取服务器端发来的信息
            str = IoTools.read_buf_system_in(System.in);
        }
        //结束通讯后，关闭相关资源
        IoTools.close();
    }
}

package java基础.Socket.myChat1;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
/**
 * 封装Io操作数据的方法
 * @author Jobs1127
 *
 */
public class IoTools {
    public static ServerSocket ss = null;//服务器端Socket
    public static Socket s = null;//客户端Socket
    /**
     * DataInputStream提供了readUTF()
     */
    public static DataInputStream di = null;
    /**
     * BufferedReader提供了readLine(),readLine() 
            读取一个文本行。
     */
    public static BufferedReader br = null;
    public static BufferedReader bre = null;
    public static InputStreamReader ir = null;

    /**
     * DataOutputStream提供了writeUTF();
     * writeUTF(String str) 
            以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
     */
    public static DataOutputStream dout = null;
    /**
     * PrintWriter提供了println();println(String x) 
            打印 String，然后终止该行。
     */
    public static PrintWriter pw = null;
    public static PrintWriter pwe = null;

    public static DataInputStream getDataInputStream(InputStream in) {
        di = new DataInputStream(in);
        return di;
    }
    public static DataOutputStream getDataOutputStream(OutputStream out) {
        dout = new DataOutputStream(out);
        return dout;
    }

    public static BufferedReader getBufferedReader(InputStream in) {
        ir = new InputStreamReader(in);
        br = new BufferedReader(ir);
        return br;
    }
    public static PrintWriter getPrintWriter(OutputStream out) {
        pw = new PrintWriter(out);
        return pw;
    }
    public static ServerSocket getServerSocket(int port) {
        try {
            ss = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ss;
    }
    public static Socket getClientSokect(String host,int port) {
        try {
            s = new Socket(host,port);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }
    public static void send_UTF(Socket s,String context) {
        try {
            if(dout == null) {
                dout = new DataOutputStream(s.getOutputStream());
            }
            dout.writeUTF(context);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void read_UTF(Socket s) {
        try {
            if(di == null) {
                di = new DataInputStream(s.getInputStream());
            }
            System.out.println(di.readUTF());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void send_buf (Socket s,PrintWriter pw,String str) {
        try {
            pw = new PrintWriter(s.getOutputStream());
            pw.println(str);
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 往同一根管道里写入数据
     * @param s
     * @param str
     */
    public static void send_buf(Socket s,String str) {
        try {
            pw = new PrintWriter(s.getOutputStream());
            pw.println(str);//把内存里的数据，写入到服务器端
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static String read_buf_socket(Socket s) {
        String str = null;
        try {
            br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
    public static String read_buf_system_in(InputStream in) {
        String str = null;
        try {
            bre = new BufferedReader(new InputStreamReader(in));
            str = bre.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
    /**
     * 关闭资源
     */
    public static void close() {
        try {
            if (di != null) {
                di.close();
            }
            if (dout != null) {
                dout.close();
            }
            if(ir != null) {
                ir.close();
            }
            if(br != null) {
                br.close();
            }
            if(bre != null) {
                bre.close();
            }
            if(pw != null) {
                pw.close();
            }
            if(pwe != null) {
                pwe.close();
            }
            if(ss != null) {
                ss.close();
            }
            if(s != null) {
                s.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}