Java基础学习03--网络BIO

1.服务端单线程：

Server端：

package socket.demo.singlethread;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try {
            //1.定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket serverSocket = new ServerSocket(9999);

            //2.监听客户端的sokcet链接请求
            Socket socket = serverSocket.accept();

            //3.从客户端得到一个字节输入流对象
            InputStream inputStream = socket.getInputStream();

            //4.把字节输入流包装成缓冲字节输入流
            //BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

            //4.把字节输入流包装成缓冲字节输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while ((msg = bufferedReader.readLine()) != null) {
                System.out.println("服务端接收到：" + msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Client端：

package socket.demo.singlethread;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建Sokcet对象请求服务端
        Socket socket = new Socket("127.0.0.1", 9999);

        //2.从Socket对象中获取一个字节输出流
        OutputStream outputStream = socket.getOutputStream();

        //3.把字节输出流包装成打印流
        PrintStream printStream = new PrintStream(outputStream);

        //打印
        printStream.println("hello world");

        //刷新
        printStream.flush();
    }
}

2.服务端多线程

Server端：

package socket.demo.multithread;

import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        while (true) {
            Socket socket = serverSocket.accept();
            new ServerThreadReader(socket).start();
        }
    }
}

线程类：

package socket.demo.multithread;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ServerThreadReader extends Thread {
    private Socket socket;

    public ServerThreadReader(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            InputStream inputStream = this.socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while ((msg = bufferedReader.readLine()) != null) {
                System.out.println(msg);
            }

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

Client端：

package socket.demo.multithread;

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

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("127.0.0.1", 9999);
        PrintStream printStream = new PrintStream(socket.getOutputStream());
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("请输入:");
            String msg = scanner.nextLine();
            printStream.println(msg);
            printStream.flush();
        }
    }
}

3.C#版本服务端多线程，和Java的对比一下：

Server端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace ServerSocket
{
    class Program
    {
        private static byte[] m_DataBuffer = new byte[1024];
        //设置端口号
        private static int m_Port = 8099;
        static Socket serverSocket;
        static void Main(string[] args)
        {
            //为了方便在本机上同时运行Client和server，使用回环地址为服务的监听地址
            IPAddress ip = IPAddress.Loopback;
            //实例化一个Socket对象，确定网络类型、Socket类型、协议类型
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //Socket对象绑定IP和端口号
            serverSocket.Bind(new IPEndPoint(ip, m_Port));
            //挂起连接队列的最大长度为15，启动监听
            serverSocket.Listen(15);

            Console.WriteLine("启动监听{0}成功", serverSocket.LocalEndPoint.ToString());
            //一个客户端连接服务器时创建一个新的线程
            Thread myThread = new Thread(ListenClientConnect);
            myThread.Start();
        }

        /// <summary>
        /// 接收连接
        /// </summary>
        private static void ListenClientConnect()
        {
            while (true)
            {
                //运行到Accept()方法是会阻塞程序(同步Socket)，
                //收到客户端请求创建一个新的Socket Client对象继续执行
                Socket clientSocket = serverSocket.Accept();
                clientSocket.Send(Encoding.UTF8.GetBytes("Server说：Client 你好！"));
                //创建一个接受客户端发送消息的线程
                Thread reciveThread = new Thread(ReciveMessage);
                reciveThread.Start(clientSocket);
            }
        }
          
        /// <summary>
        /// 接收信息
        /// </summary>
        /// <param name="clientSocket">包含客户端信息的套接字</param>
        private static void ReciveMessage(Object clientSocket)
        {
            if (clientSocket != null)
            {
                Socket m_ClientSocket = clientSocket as Socket;
                while (true)
                {
                    try
                    {
                        //通过clientSocket接收数据
                        int reciverNumber = m_ClientSocket.Receive(m_DataBuffer);
                        if (reciverNumber == 0)
                        {
                            m_ClientSocket.Shutdown(SocketShutdown.Both);
                            m_ClientSocket.Close();
                            Console.WriteLine("客户端连接已断开");
                            break;
                        }
                        Console.WriteLine("接收客户端：{0}消息：{1}", m_ClientSocket.RemoteEndPoint.ToString(), Encoding.UTF8.GetString(m_DataBuffer, 0, reciverNumber));
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        m_ClientSocket.Shutdown(SocketShutdown.Both);
                        m_ClientSocket.Close();
                        break;
                    }
                }
            }
        }
    }
}

Client端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace ClientSocket
{
    class Program
    {
        //创建一个数据缓冲区
        private static byte[] m_DataBuffer = new byte[1024];
        static void Main(string[] args)
        {
            IPAddress ip = IPAddress.Loopback;
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                clientSocket.Connect(new IPEndPoint(ip, 8099));
                Console.WriteLine("连接服务器成功");
            }
            catch (Exception ex)
            {
                Console.WriteLine("连接服务器失败，按回车键退出");
                Console.WriteLine(ex.Message);
                return;
            }
            //通过clientSocket接收数据
            int receiveLength = clientSocket.Receive(m_DataBuffer);
            Console.WriteLine("接受服务器消息：{0}", Encoding.UTF8.GetString(m_DataBuffer, 0, receiveLength));
            //通过clientSocket发送数据
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    Thread.Sleep(1000);
                    string sendMessage = string.Format("{0} {1}", "Server 你好！", DateTime.Now.ToString());
                    clientSocket.Send(Encoding.UTF8.GetBytes(sendMessage));
                    Console.WriteLine("向服务器发送消息：{0}", sendMessage);
                }
                catch
                {
                    clientSocket.Shutdown(SocketShutdown.Both);
                    clientSocket.Close();
                    break;
                }
            }
            Console.WriteLine("发送完毕，按回车键退出");
            //发送完消息后关闭连接
            clientSocket.Shutdown(SocketShutdown.Both);
            clientSocket.Close();
            Console.Read();
        }
    }
}