第十七章.网络编程

Java的基本网络支持：

　　使用InetAddress：

import java.net.InetAddress;

public class InetAddressTest{
    public static void main(String[] args) throws Exception{
        //根据主机名来获取对应的InetAddress实例
        InetAddress ip = InetAddress.getByName("www.lanshanxiao.cc");
        //判断是否可达
        System.out.println("lanshanxiao是否可达：" + ip.isReachable(2000));
        //获取该InetAddress实例的IP字符串
        System.out.println(ip.getHostAddress());
        //根据原始IP地址来获取对应的InetAddress实例
        InetAddress local = InetAddress.getByAddress(new byte[] {127,0,0,1});
        System.out.println("本机是否可达：" + local.isReachable(5000));
        //获取该InetAddress实例对应的权限定域名
        System.out.println(local.getCanonicalHostName());
    }
}

注意上面程序中：InetAddress local = InetAddress.getByAddress(new byte[] {127,0,0,1});大括号中的127,0,0,1之间的符号是逗号

　　使用URLDecoder和URLEncoder：

　　　　URLDecoder和URLEncoder用于完成普通字符串和application/x-www-form-urlencoded MIME字符串之间的相互转换。

import java.net.URLEncoder;
import java.net.URLDecoder;

public class URLDecoderTest{
    public static void main(String[] args) throws Exception{
        //将application/x-www-form-urlencoded字符串
        //转换成普通字符串
        String keyWord = URLDecoder.decode("%E7%96%AF%E7%8B%82java", "utf-8");
        System.out.println(keyWord);
        //将普通字符串转换成
        //application/x-www-form-urlencoded字符串
        String urlStr = URLEncoder.encode("疯狂Android讲义", "GBK");
        System.out.println(urlStr);
    }
}

　　URL、URLConnection、URLPermission：

　　　　URL（Uniform Resource Locator）对象代表统一资源定位器，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是复杂的对象的引用，如：对数据库

　　　　　或搜索引擎的查询。

　　　　URL可以由协议名、主机、端口、资源组成：

　　　　protocol://host:port/resourceName

　　　　如下：

　　　　http://www.crazyit.org/index.php

　　　　多线程下载工具类：

import java.io.RandomAccessFile;
import java.io.InputStream;
import java.net.URL;
import java.net.HttpURLConnection;

public class DownUtil{
    //定义下载资源的路径
    private String path;
    //指定所下载的文件的保存位置
    private String targetFile;
    //定义需要使用多少个线程下载资源
    private int threadNum;
    //定义下载的线程对象
    private DownThread[] threads;
    //定义下载的文件的总大小
    private int fileSize;
    
    public DownUtil(String path, String targetFile, int threadNum){
        this.path = path;
        this.threadNum = threadNum;
        //初始化threads数组
        threads = new DownThread[threadNum];
        this.targetFile = targetFile;
    }
    
    public void download() throws Exception{
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(5 * 1000);
        conn.setRequestMethod("GET");
        conn.setRequestProperty(
            "Accept",
            "image/gif, image/jpeg, image/pjpeg, image/pjpeg, "
            + "application/x-shockwave-flash, application/xaml+xml, "
            + "application/vnd.ms-xpsdocument, application/x-ms-xbap, "
            + "application/x-ms-application, application/vnd.ms-excel, "
            + "application/vnd.ms-powerpoint, application/msword, */*");
        conn.setRequestProperty("Accept-Language", "zh-CN");
        conn.setRequestProperty("Charset", "UTF-8");
        conn.setRequestProperty("Connection", "Keep-Alive");
        //得到文件大小
        fileSize = conn.getContentLength();
        conn.disconnect();
        int currentPartSize = fileSize / threadNum + 1;
        RandomAccessFile file = new RandomAccessFile(targetFile, "rw");
        //设置本地文件大小
        file.setLength(fileSize);
        file.close();
        for (int i = 0; i < threadNum; i++)
        {
            // 计算每条线程的下载的开始位置
            int startPos = i * currentPartSize;
            // 每个线程使用一个RandomAccessFile进行下载
            RandomAccessFile currentPart = new RandomAccessFile(targetFile,
                "rw");
            // 定位该线程的下载位置
            currentPart.seek(startPos);
            // 创建下载线程
            threads[i] = new DownThread(startPos, currentPartSize,
                currentPart);
            // 启动下载线程
            threads[i].start();
        }
    }

    // 获取下载的完成百分比
    public double getCompleteRate()
    {
        // 统计多条线程已经下载的总大小
        int sumSize = 0;
        for (int i = 0; i < threadNum; i++)
        {
            sumSize += threads[i].length;
        }
        // 返回已经完成的百分比
        return sumSize * 1.0 / fileSize;
    }

    private class DownThread extends Thread
    {
        // 当前线程的下载位置
        private int startPos;
        // 定义当前线程负责下载的文件大小
        private int currentPartSize;
        // 当前线程需要下载的文件块
        private RandomAccessFile currentPart;
        // 定义已经该线程已下载的字节数
        public int length;

        public DownThread(int startPos, int currentPartSize,
            RandomAccessFile currentPart)
        {
            this.startPos = startPos;
            this.currentPartSize = currentPartSize;
            this.currentPart = currentPart;
        }

        @Override
        public void run()
        {
            try
            {
                URL url = new URL(path);
                HttpURLConnection conn = (HttpURLConnection)url
                    .openConnection();
                conn.setConnectTimeout(5 * 1000);
                conn.setRequestMethod("GET");
                conn.setRequestProperty(
                    "Accept",
                    "image/gif, image/jpeg, image/pjpeg, image/pjpeg, "
                    + "application/x-shockwave-flash, application/xaml+xml, "
                    + "application/vnd.ms-xpsdocument, application/x-ms-xbap, "
                    + "application/x-ms-application, application/vnd.ms-excel, "
                    + "application/vnd.ms-powerpoint, application/msword, */*");
                conn.setRequestProperty("Accept-Language", "zh-CN");
                conn.setRequestProperty("Charset", "UTF-8");
                InputStream inStream = conn.getInputStream();
                // 跳过startPos个字节，表明该线程只下载自己负责哪部分文件。
                inStream.skip(this.startPos);
                byte[] buffer = new byte[1024];
                int hasRead = 0;
                // 读取网络数据，并写入本地文件
                while (length < currentPartSize
                    && (hasRead = inStream.read(buffer)) != -1)
                {
                    currentPart.write(buffer, 0, hasRead);
                    // 累计该线程下载的总大小
                    length += hasRead;
                }
                currentPart.close();
                inStream.close();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

　　　　程序中DownUtil类中的download()方法负责按如下步骤实现多线程下载：

　　　　　　1.创建URL对象

　　　　　　2.获取指定URL对象所指向资源的大小（通过getContentLength()方法获得），此处用到了URLConnection类，该类代表Java应用程序和URL之间的通信链接。

　　　　　　3.在本地磁盘上创建一个与网络资源具有相同大小的空文件。

　　　　　　4.计算每个线程应该下载网络资源的哪个部分（从哪个字节开始，到哪个字节结束）

　　　　　　5.依次创建、启动多个线程来下载网络资源的指定部分

上面程序已经实现了多线程下载的核心代码，若要实现断点下载，则需要额外增加一个配置文件（读者可以发现，所有的断点下载工具都会在下载开始时生成两个文件：一个是与网络资源具有相同大小的空文件，一个是配置文件），该配置文件分别记录每个线程已经下载到哪个字节，当网络断开后再次下载时，每个线程根据配置文件里记录的位置向后下载即可。

public class MultiThreadDown
{
    public static void main(String[] args) throws Exception
    {
        // 初始化DownUtil对象
        final DownUtil downUtil = new DownUtil("http://www.crazyit.org/"
            + "attachments/month_1403/1403202355ff6cc9a4fbf6f14a.png"
            , "ios.png", 4);
        // 开始下载
        downUtil.download();
        new Thread(() -> {
                while(downUtil.getCompleteRate() < 1)
                {
                    // 每隔0.1秒查询一次任务的完成进度，
                    // GUI程序中可根据该进度来绘制进度条
                    System.out.println("已完成："
                        + downUtil.getCompleteRate());
                    try
                    {
                        Thread.sleep(1000);
                    }
                    catch (Exception ex){}
                }
        }).start();
    }
}

　　通常创建一个和URL的连接，并发送请求、读取此URL引用的资源需要如下几个步骤：

　　　　1.通过调用URL对象的openConnection()方法来创建URLConnection对象

　　　　2.设置URLConnection的参数和普通请求属性

　　　　3.若只是发送GET方式请求，则使用connect()方法建立和远程资源之间的实际连接即可；若要发送POST方式的请求，则需要获取URLConnection实例对应的输出流来发

　　　　　送请求参数

　　　　4.远程资源变为可用，程序可以访问远程资源的头字段或通过输入流读取远程资源的数据

　　若既要使用输入流读取URLConnection响应的内容又要使用输出流发送请求参数，则一定要先使用输出流，在使用输入流。

下面程序示范了如何向Web站点发送GET请求、POST请求，并从Web站点取得响应：

import java.net.URL;
import java.net.URLConnection;
import java.util.Map;
import java.util.List;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class GetPostTest
{
    /**
     * 向指定URL发送GET方法的请求
     * @param url 发送请求的URL
     * @param param 请求参数，格式满足name1=value1&name2=value2的形式。
     * @return URL所代表远程资源的响应
     */
    public static String sendGet(String url , String param)
    {
        String result = "";
        String urlName = url + "?" + param;
        try
        {
            URL realUrl = new URL(urlName);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent"
                , "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            // 建立实际的连接
            conn.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = conn.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet())
            {
                System.out.println(key + "--->" + map.get(key));
            }
            try(
                // 定义BufferedReader输入流来读取URL的响应
                BufferedReader in = new BufferedReader(
                    new InputStreamReader(conn.getInputStream() , "utf-8")))
            {
                String line;
                while ((line = in.readLine())!= null)
                {
                    result += "\n" + line;
                }
            }
        }
        catch(Exception e)
        {
            System.out.println("发送GET请求出现异常！" + e);
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 向指定URL发送POST方法的请求
     * @param url 发送请求的URL
     * @param param 请求参数，格式应该满足name1=value1&name2=value2的形式。
     * @return URL所代表远程资源的响应
     */
    public static String sendPost(String url , String param)
    {
        String result = "";
        try
        {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent",
            "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            try(
                // 获取URLConnection对象对应的输出流
                PrintWriter out = new PrintWriter(conn.getOutputStream()))
            {
                // 发送请求参数
                out.print(param);
                // flush输出流的缓冲
                out.flush();
            }
            try(
                // 定义BufferedReader输入流来读取URL的响应
                BufferedReader in = new BufferedReader(new InputStreamReader
                    (conn.getInputStream() , "utf-8")))
            {
                String line;
                while ((line = in.readLine())!= null)
                {
                    result += "\n" + line;
                }
            }
        }
        catch(Exception e)
        {
            System.out.println("发送POST请求出现异常！" + e);
            e.printStackTrace();
        }
        return result;
    }
    // 提供主方法，测试发送GET请求和POST请求
    public static void main(String args[])
    {
        // 发送GET请求
        String s = GetPostTest.sendGet("http://localhost:8888/abc/a.jsp"
            , null);
        System.out.println(s);
        // 发送POST请求
        String s1 = GetPostTest.sendPost("http://localhost:8888/abc/login.jsp"
            , "name=crazyit.org&pass=leegang");
        System.out.println(s1);
    }
}

　　这一部分需要创建Web应用，现在我还不会。但是会在接下来学习《轻量级Java EE企业应用实战》的时候创建Web应用。Web应用的代码我上传到GitHub网站（会在文章最后写出），是一个abc的文件夹。

基于TCP协议的网络编程：

　　使用ServerSocket创建TCP服务器端：

　　　　Java中能接收其他通信实体连接请求的类是ServerSocket，ServerSocket对象用于监听来自客户端的Socket连接，若没有连接，它将一直处于等待状态。ServerSocket包含

　　　　　一个监听来自客户端连接请求的方法。

　　　　　　1.Socket accept()：若接收到一个客户端Socket的连接请求，该方法返回一个与客户端Socket对应的Socket；否则该方法一直处于等待状态，线程也被阻塞

　　使用Socket进行通信：

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

public class Server
{
    public static void main(String[] args)
        throws IOException
    {
        // 创建一个ServerSocket，用于监听客户端Socket的连接请求
        ServerSocket ss = new ServerSocket(30000);
        // 采用循环不断接受来自客户端的请求
        while (true)
        {
            // 每当接受到客户端Socket的请求，服务器端也对应产生一个Socket
            Socket s = ss.accept();
            // 将Socket对应的输出流包装成PrintStream
            PrintStream ps = new PrintStream(s.getOutputStream());
            // 进行普通IO操作
            ps.println("您好，您收到了服务器的新年祝福！");
            // 关闭输出流，关闭Socket
            ps.close();
            s.close();
        }
    }
}

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

public class Client
{
    public static void main(String[] args)
        throws IOException
    {
        Socket socket = new Socket("127.0.0.1" , 30000);   // ①
        // 将Socket对应的输入流包装成BufferedReader
        BufferedReader br = new BufferedReader(
        new InputStreamReader(socket.getInputStream()));
        // 进行普通IO操作
        String line = br.readLine();
        System.out.println("来自服务器的数据：" + line);
        // 关闭输入流、socket
        br.close();
        socket.close();
    }
}

　　在Windows系统下分别用两个cmd，一个运行Server端，一个运行Client端，先运行Server端：

 加入多线程：

import java.net.Socket;
import java.net.ServerSocket;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyServer
{
    // 定义保存所有Socket的ArrayList，并将其包装为线程安全的
    public static List<Socket> socketList
        = Collections.synchronizedList(new ArrayList<>());
    public static void main(String[] args)
        throws IOException
    {
        ServerSocket ss = new ServerSocket(30000);
        while(true)
        {
            // 此行代码会阻塞，将一直等待别人的连接
            Socket s = ss.accept();
            socketList.add(s);
            // 每当客户端连接后启动一条ServerThread线程为该客户端服务
            new Thread(new ServerThread(s)).start();
        }
    }
}

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

// 负责处理每个线程通信的线程类
public class ServerThread implements Runnable
{
    // 定义当前线程所处理的Socket
    Socket s = null;
    // 该线程所处理的Socket所对应的输入流
    BufferedReader br = null;
    public ServerThread(Socket s)
    throws IOException
    {
        this.s = s;
        // 初始化该Socket对应的输入流
        br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    }
    public void run()
    {
        try
        {
            String content = null;
            // 采用循环不断从Socket中读取客户端发送过来的数据
            while ((content = readFromClient()) != null)
            {
                // 遍历socketList中的每个Socket，
                // 将读到的内容向每个Socket发送一次
                for (Socket s : MyServer.socketList)
                {
                    PrintStream ps = new PrintStream(s.getOutputStream());
                    ps.println(content);
                }
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
    // 定义读取客户端数据的方法
    private String readFromClient()
    {
        try
        {
            return br.readLine();
        }
        // 如果捕捉到异常，表明该Socket对应的客户端已经关闭
        catch (IOException e)
        {
            // 删除该Socket。
            MyServer.socketList.remove(s);      // ①
        }
        return null;
    }
}

import java.io.PrintStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;

public class MyClient
{
    public static void main(String[] args)throws Exception
    {
        Socket s = new Socket("127.0.0.1" , 30000);
        // 客户端启动ClientThread线程不断读取来自服务器的数据
        new Thread(new ClientThread(s)).start();   // ①
        // 获取该Socket对应的输出流
        PrintStream ps = new PrintStream(s.getOutputStream());
        String line = null;
        // 不断读取键盘输入
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        while ((line = br.readLine()) != null)
        {
            // 将用户的键盘输入内容写入Socket对应的输出流
            ps.println(line);
        }
    }
}

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

public class ClientThread implements Runnable
{
    // 该线程负责处理的Socket
    private Socket s;
    // 该线程所处理的Socket所对应的输入流
    BufferedReader br = null;
    public ClientThread(Socket s)
        throws IOException
    {
        this.s = s;
        br = new BufferedReader(
            new InputStreamReader(s.getInputStream()));
    }
    public void run()
    {
        try
        {
            String content = null;
            // 不断读取Socket输入流中的内容，并将这些内容打印输出
            while ((content = br.readLine()) != null)
            {
                System.out.println(content);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

　　　　上面程序ServerSocket服务端MyServer创建了两个线程主线程用来接收每个客户端发送的Socket请求，ServerThread线程用来向每个客户端发送客户端发送的信息

　　　　Socket客户端MyClient创建了两个线程主线程用来接收用户键盘输入，ClientThread线程用来接收服务端发送的信息。

 记录用户信息：

　　上面程序的每个客户端不知道显示的每条信息都是谁的。这是因为服务端没有记录用户信息，当客户端使用Socket连接到服务器端后，程序只是使用socketList集合保存了服

　　　务器端对应生成的Socket，并没有保存该Socket关联的用户信息。

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

public class Server
{
    private static final int SERVER_PORT = 30000;
    // 使用CrazyitMap对象来保存每个客户名字和对应输出流之间的对应关系。
    public static CrazyitMap<String , PrintStream> clients
        = new CrazyitMap<>();
    public void init()
    {
        try(
            // 建立监听的ServerSocket
            ServerSocket ss = new ServerSocket(SERVER_PORT))
        {
            // 采用死循环来不断接受来自客户端的请求
            while(true)
            {
                Socket socket = ss.accept();
                new ServerThread(socket).start();
            }
        }
        // 如果抛出异常
        catch (IOException ex)
        {
            System.out.println("服务器启动失败，是否端口"
                + SERVER_PORT + "已被占用？");
        }
    }
    public static void main(String[] args)
    {
        Server server = new Server();
        server.init();
    }
}

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

public class ServerThread extends Thread
{
    private Socket socket;
    BufferedReader br = null;
    PrintStream ps = null;
    // 定义一个构造器，用于接收一个Socket来创建ServerThread线程
    public ServerThread(Socket socket)
    {
        this.socket = socket;
    }
    public void run()
    {
        try
        {
            // 获取该Socket对应的输入流
            br = new BufferedReader(new InputStreamReader(socket
                .getInputStream()));
            // 获取该Socket对应的输出流
            ps = new PrintStream(socket.getOutputStream());
            String line = null;
            while((line = br.readLine())!= null)
            {
                // 如果读到的行以CrazyitProtocol.USER_ROUND开始，并以其结束，
                // 可以确定读到的是用户登录的用户名
                if (line.startsWith(CrazyitProtocol.USER_ROUND)
                    && line.endsWith(CrazyitProtocol.USER_ROUND))
                {
                    // 得到真实消息
                    String userName = getRealMsg(line);
                    // 如果用户名重复
                    if (Server.clients.map.containsKey(userName))
                    {
                        System.out.println("重复");
                        ps.println(CrazyitProtocol.NAME_REP);
                    }
                    else
                    {
                        System.out.println("成功");
                        ps.println(CrazyitProtocol.LOGIN_SUCCESS);
                        Server.clients.put(userName , ps);
                    }
                }
                // 如果读到的行以CrazyitProtocol.PRIVATE_ROUND开始，并以其结束，
                // 可以确定是私聊信息，私聊信息只向特定的输出流发送
                else if (line.startsWith(CrazyitProtocol.PRIVATE_ROUND)
                    && line.endsWith(CrazyitProtocol.PRIVATE_ROUND))
                {
                    // 得到真实消息
                    String userAndMsg = getRealMsg(line);
                    // 以SPLIT_SIGN分割字符串，前半是私聊用户，后半是聊天信息
                    String user = userAndMsg.split(CrazyitProtocol.SPLIT_SIGN)[0];
                    String msg = userAndMsg.split(CrazyitProtocol.SPLIT_SIGN)[1];
                    // 获取私聊用户对应的输出流，并发送私聊信息
                    Server.clients.map.get(user).println(Server.clients
                        .getKeyByValue(ps) + "悄悄地对你说：" + msg);
                }
                // 公聊要向每个Socket发送
                else
                {
                    // 得到真实消息
                    String msg = getRealMsg(line);
                    // 遍历clients中的每个输出流
                    for (PrintStream clientPs : Server.clients.valueSet())
                    {
                        clientPs.println(Server.clients.getKeyByValue(ps)
                            + "说：" + msg);
                    }
                }
            }
        }
        // 捕捉到异常后，表明该Socket对应的客户端已经出现了问题
        // 所以程序将其对应的输出流从Map中删除
        catch (IOException e)
        {
            Server.clients.removeByValue(ps);
            System.out.println(Server.clients.map.size());
            // 关闭网络、IO资源
            try
            {
                if (br != null)
                {
                    br.close();
                }
                if (ps != null)
                {
                    ps.close();
                }
                if (socket != null)
                {
                    socket.close();
                }
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
    }
    // 将读到的内容去掉前后的协议字符，恢复成真实数据
    private String getRealMsg(String line)
    {
        return line.substring(CrazyitProtocol.PROTOCOL_LEN
            , line.length() - CrazyitProtocol.PROTOCOL_LEN);
    }
}

import java.util.Collections;
import java.util.Map;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

// 通过组合HashMap对象来实现CrazyitMap，CrazyitMap要求value也不可重复
public class CrazyitMap<K,V>
{
    // 创建一个线程安全的HashMap
    public Map<K ,V> map = Collections.synchronizedMap(new HashMap<K,V>());
    // 根据value来删除指定项
    public synchronized void removeByValue(Object value)
    {
        for (Object key : map.keySet())
        {
            if (map.get(key) == value)
            {
                map.remove(key);
                break;
            }
        }
    }
    // 获取所有value组成的Set集合
    public synchronized Set<V> valueSet()
    {
        Set<V> result = new HashSet<V>();
        // 将map中所有value添加到result集合中
        map.forEach((key , value) -> result.add(value));
        return result;
    }
    // 根据value查找key。
    public synchronized K getKeyByValue(V val)
    {
        // 遍历所有key组成的集合
        for (K key : map.keySet())
        {
            // 如果指定key对应的value与被搜索的value相同，则返回对应的key
            if (map.get(key) == val || map.get(key).equals(val))
            {
                return key;
            }
        }
        return null;
    }
    // 实现put()方法，该方法不允许value重复
    public synchronized V put(K key,V value)
    {
        // 遍历所有value组成的集合
        for (V val : valueSet() )
        {
            // 如果某个value与试图放入集合的value相同
            // 则抛出一个RuntimeException异常
            if (val.equals(value)
                && val.hashCode()== value.hashCode())
            {
                throw new RuntimeException("MyMap实例中不允许有重复value!");
            }
        }
        return map.put(key , value);
    }
}

public interface CrazyitProtocol
{
    // 定义协议字符串的长度
    int PROTOCOL_LEN = 2;
    // 下面是一些协议字符串，服务器和客户端交换的信息
    // 都应该在前、后添加这种特殊字符串。
    String MSG_ROUND = "§γ";
    String USER_ROUND = "∏∑";
    String LOGIN_SUCCESS = "1";
    String NAME_REP = "-1";
    String PRIVATE_ROUND = "★【";
    String SPLIT_SIGN = "※";
}

import java.net.Socket;
import java.net.UnknownHostException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.IOException;
import javax.swing.JOptionPane;

public class Client
{
    private static final int SERVER_PORT = 30000;
    private Socket socket;
    private PrintStream ps;
    private BufferedReader brServer;
    private BufferedReader keyIn;
    public void init()
    {
        try
        {
            // 初始化代表键盘的输入流
            keyIn = new BufferedReader(
                new InputStreamReader(System.in));
            // 连接到服务器
            socket = new Socket("127.0.0.1", SERVER_PORT);
            // 获取该Socket对应的输入流和输出流
            ps = new PrintStream(socket.getOutputStream());
            brServer = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
            String tip = "";
            // 采用循环不断地弹出对话框要求输入用户名
            while(true)
            {
                String userName = JOptionPane.showInputDialog(tip
                    + "输入用户名");    //①
                // 将用户输入的用户名的前后增加协议字符串后发送
                ps.println(CrazyitProtocol.USER_ROUND + userName
                    + CrazyitProtocol.USER_ROUND);
                // 读取服务器的响应
                String result = brServer.readLine();
                // 如果用户重复，开始下次循环
                if (result.equals(CrazyitProtocol.NAME_REP))
                {
                    tip = "用户名重复！请重新";
                    continue;
                }
                // 如果服务器返回登录成功，结束循环
                if (result.equals(CrazyitProtocol.LOGIN_SUCCESS))
                {
                    break;
                }
            }
        }
        // 捕捉到异常，关闭网络资源，并退出该程序
        catch (UnknownHostException ex)
        {
            System.out.println("找不到远程服务器，请确定服务器已经启动！");
            closeRs();
            System.exit(1);
        }
        catch (IOException ex)
        {
            System.out.println("网络异常！请重新登录！");
            closeRs();
            System.exit(1);
        }
        // 以该Socket对应的输入流启动ClientThread线程
        new ClientThread(brServer).start();
    }
    // 定义一个读取键盘输出，并向网络发送的方法
    private void readAndSend()
    {
        try
        {
            // 不断读取键盘输入
            String line = null;
            while((line = keyIn.readLine()) != null)
            {
                // 如果发送的信息中有冒号，且以//开头，则认为想发送私聊信息
                if (line.indexOf(":") > 0 && line.startsWith("//"))
                {
                    line = line.substring(2);
                    ps.println(CrazyitProtocol.PRIVATE_ROUND +
                    line.split(":")[0] + CrazyitProtocol.SPLIT_SIGN
                        + line.split(":")[1] + CrazyitProtocol.PRIVATE_ROUND);
                }
                else
                {
                    ps.println(CrazyitProtocol.MSG_ROUND + line
                        + CrazyitProtocol.MSG_ROUND);
                }
            }
        }
        // 捕捉到异常，关闭网络资源，并退出该程序
        catch (IOException ex)
        {
            System.out.println("网络通信异常！请重新登录！");
            closeRs();
            System.exit(1);
        }
    }
    // 关闭Socket、输入流、输出流的方法
    private void closeRs()
    {
        try
        {
            if (keyIn != null)
            {
                ps.close();
            }
            if (brServer != null)
            {
                ps.close();
            }
            if (ps != null)
            {
                ps.close();
            }
            if (socket != null)
            {
                keyIn.close();
            }
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }
    public static void main(String[] args)
    {
        Client client = new Client();
        client.init();
        client.readAndSend();
    }
}

import java.io.BufferedReader;
import java.io.IOException;

public class ClientThread extends Thread
{
    // 该客户端线程负责处理的输入流
    BufferedReader br = null;
    // 使用一个网络输入流来创建客户端线程
    public ClientThread(BufferedReader br)
    {
        this.br = br;
    }
    public void run()
    {
        try
        {
            String line = null;
            // 不断从输入流中读取数据，并将这些数据打印输出
            while((line = br.readLine())!= null)
            {
                System.out.println(line);
                /*
                本例仅打印了从服务器端读到的内容。实际上，此处的情况可以更复杂：
                如果希望客户端能看到聊天室的用户列表，则可以让服务器在
                每次有用户登录、用户退出时，将所有用户列表信息都向客户端发送一遍。
                为了区分服务器发送的是聊天信息，还是用户列表，服务器也应该
                在要发送的信息前、后都添加一定的协议字符串，客户端此处则根据协议
                字符串的不同而进行不同的处理！
                更复杂的情况：
                如果两端进行游戏，则还有可能发送游戏信息，例如两端进行五子棋游戏，
                则还需要发送下棋坐标信息等，服务器同样在这些下棋坐标信息前、后
                添加协议字符串后再发送，客户端就可以根据该信息知道对手的下棋坐标。
                */
            }
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
        // 使用finally块来关闭该线程对应的输入流
        finally
        {
            try
            {
                if (br != null)
                {
                    br.close();
                }
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

 

 

半关闭的Socket：

　　Socket提供如下两个半关闭方法，只关闭Socket的输入流或输出流，用来表示输出数据已经发送完成

　　　　1.shutdownInput()：关闭该Socket的输入流，程序还可以通过该Socket的输出流输出数据

　　　　2.shutdownOutput()：关闭该Socket的输出流，程序还可以通过该Socket的输入流读取数据

　　即使同一个Socket实例先后调用shutdownInput()、shutdownOutput()方法，该Socket实例依然没有关闭，只是Socket既不能输出数据，也不能读取数据而已。

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

public class Server
{
    public static void main(String[] args)
        throws Exception
    {
        ServerSocket ss = new ServerSocket(30000);
        Socket socket = ss.accept();
        PrintStream ps = new PrintStream(socket.getOutputStream());
        ps.println("服务器的第一行数据");
        ps.println("服务器的第二行数据");
        // 关闭socket的输出流，表明输出数据已经结束
        socket.shutdownOutput();
        // 下面语句将输出false，表明socket还未关闭。
        System.out.println(socket.isClosed());
        Scanner scan = new Scanner(socket.getInputStream());
        while (scan.hasNextLine())
        {
            System.out.println(scan.nextLine());
        }
        scan.close();
        socket.close();
        ss.close();
    }
}

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

public class Client
{
    public static void main(String[] args)
        throws Exception
    {
        Socket s = new Socket("localhost" , 30000);
        Scanner scan = new Scanner(s.getInputStream());
        while (scan.hasNextLine())
        {
            System.out.println(scan.nextLine());
        }
        PrintStream ps = new PrintStream(s.getOutputStream());
        ps.println("客户端的第一行数据");
        ps.println("客户端的第二行数据");
        ps.close();
        scan.close();
        s.close();
    }
}

使用NIO实现非阻塞Socket通信：

import java.net.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;

public class NServer
{
    // 用于检测所有Channel状态的Selector
    private Selector selector = null;
    static final int PORT = 30000;
    // 定义实现编码、解码的字符集对象
    private Charset charset = Charset.forName("UTF-8");
    public void init()throws IOException
    {
        selector = Selector.open();
        // 通过open方法来打开一个未绑定的ServerSocketChannel实例
        ServerSocketChannel server = ServerSocketChannel.open();
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);
        // 将该ServerSocketChannel绑定到指定IP地址
        server.bind(isa);
        // 设置ServerSocket以非阻塞方式工作
        server.configureBlocking(false);
        // 将server注册到指定Selector对象
        server.register(selector, SelectionKey.OP_ACCEPT);
        while (selector.select() > 0)
        {
            // 依次处理selector上的每个已选择的SelectionKey
            for (SelectionKey sk : selector.selectedKeys())
            {
                // 从selector上的已选择Key集中删除正在处理的SelectionKey
                selector.selectedKeys().remove(sk);      // ①
                // 如果sk对应的Channel包含客户端的连接请求
                if (sk.isAcceptable())        // ②
                {
                    // 调用accept方法接受连接，产生服务器端的SocketChannel
                    SocketChannel sc = server.accept();
                    // 设置采用非阻塞模式
                    sc.configureBlocking(false);
                    // 将该SocketChannel也注册到selector
                    sc.register(selector, SelectionKey.OP_READ);
                    // 将sk对应的Channel设置成准备接受其他请求
                    sk.interestOps(SelectionKey.OP_ACCEPT);
                }
                // 如果sk对应的Channel有数据需要读取
                if (sk.isReadable())     // ③
                {
                    // 获取该SelectionKey对应的Channel，该Channel中有可读的数据
                    SocketChannel sc = (SocketChannel)sk.channel();
                    // 定义准备执行读取数据的ByteBuffer
                    ByteBuffer buff = ByteBuffer.allocate(1024);
                    String content = "";
                    // 开始读取数据
                    try
                    {
                        while(sc.read(buff) > 0)
                        {
                            buff.flip();
                            content += charset.decode(buff);
                        }
                        // 打印从该sk对应的Channel里读取到的数据
                        System.out.println("读取的数据：" + content);
                        // 将sk对应的Channel设置成准备下一次读取
                        sk.interestOps(SelectionKey.OP_READ);
                    }
                    // 如果捕捉到该sk对应的Channel出现了异常，即表明该Channel
                    // 对应的Client出现了问题，所以从Selector中取消sk的注册
                    catch (IOException ex)
                    {
                        // 从Selector中删除指定的SelectionKey
                        sk.cancel();
                        if (sk.channel() != null)
                        {
                            sk.channel().close();
                        }
                    }
                    // 如果content的长度大于0，即聊天信息不为空
                    if (content.length() > 0)
                    {
                        // 遍历该selector里注册的所有SelectionKey
                        for (SelectionKey key : selector.keys())
                        {
                            // 获取该key对应的Channel
                            Channel targetChannel = key.channel();
                            // 如果该channel是SocketChannel对象
                            if (targetChannel instanceof SocketChannel)
                            {
                                // 将读到的内容写入该Channel中
                                SocketChannel dest = (SocketChannel)targetChannel;
                                dest.write(charset.encode(content));
                            }
                        }
                    }
                }
            }
        }
    }
    public static void main(String[] args)
        throws IOException
    {
        new NServer().init();
    }
}

import java.util.*;
import java.net.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;

public class NClient
{
    // 定义检测SocketChannel的Selector对象
    private Selector selector = null;
    static final int PORT = 30000;
    // 定义处理编码和解码的字符集
    private Charset charset = Charset.forName("UTF-8");
    // 客户端SocketChannel
    private SocketChannel sc = null;
    public void init()throws IOException
    {
        selector = Selector.open();
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);
        // 调用open静态方法创建连接到指定主机的SocketChannel
        sc = SocketChannel.open(isa);
        // 设置该sc以非阻塞方式工作
        sc.configureBlocking(false);
        // 将SocketChannel对象注册到指定Selector
        sc.register(selector, SelectionKey.OP_READ);
        // 启动读取服务器端数据的线程
        new ClientThread().start();
        // 创建键盘输入流
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextLine())
        {
            // 读取键盘输入
            String line = scan.nextLine();
            // 将键盘输入的内容输出到SocketChannel中
            sc.write(charset.encode(line));
        }
    }
    // 定义读取服务器数据的线程
    private class ClientThread extends Thread
    {
        public void run()
        {
            try
            {
                while (selector.select() > 0)    // ①
                {
                    // 遍历每个有可用IO操作Channel对应的SelectionKey
                    for (SelectionKey sk : selector.selectedKeys())
                    {
                        // 删除正在处理的SelectionKey
                        selector.selectedKeys().remove(sk);
                        // 如果该SelectionKey对应的Channel中有可读的数据
                        if (sk.isReadable())
                        {
                            // 使用NIO读取Channel中的数据
                            SocketChannel sc = (SocketChannel)sk.channel();
                            ByteBuffer buff = ByteBuffer.allocate(1024);
                            String content = "";
                            while(sc.read(buff) > 0)
                            {
                                sc.read(buff);
                                buff.flip();
                                content += charset.decode(buff);
                            }
                            // 打印输出读取的内容
                            System.out.println("聊天信息：" + content);
                            // 为下一次读取作准备
                            sk.interestOps(SelectionKey.OP_READ);
                        }
                    }
                }
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
    }
    public static void main(String[] args)
        throws IOException
    {
        new NClient().init();
    }
}

上面这段程序不太好理解，可以参考结果和注释。一定要吃透。

使用Java7的AIO实现非阻塞通信：

import java.nio.channels.AsynchronousServerSocketChannel; 
import java.nio.channels.AsynchronousSocketChannel;
import java.net.InetSocketAddress;
import java.util.concurrent.Future; 
import java.nio.ByteBuffer;


public class SimpleAIOServer{
    static final int PORT = 30000;
    public static void main(String[] args) throws Exception{
        try(
            //创建AsynchronousServerSocketChannel对象
            AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open()
        ){
            //指定在指定地址、端口监听
            serverChannel.bind(new InetSocketAddress(PORT));
            while(true){
                //采用循环接受来自客户端的连接
                Future<AsynchronousSocketChannel> future = serverChannel.accept();
                //获取连接完成后返回的AsynchronousSocketChannel
                AsynchronousSocketChannel socketChannel = future.get();
                //执行输出
                socketChannel.write(ByteBuffer.wrap("欢迎你来到AIO的世界！".getBytes("UTF-8"))).get();
            }
        }
    }
}

import java.nio.channels.AsynchronousSocketChannel;
import java.nio.charset.Charset;
import java.net.InetSocketAddress;
import java.util.concurrent.Future; 
import java.nio.ByteBuffer;

public class SimpleAIOClient{
    static final int PORT = 30000;
    public static void main(String[] args) throws Exception{
        //用于读取数据的ByteBuffer
        ByteBuffer buff = ByteBuffer.allocate(1024);
        Charset utf = Charset.forName("utf-8");
        try(
            //创建AsynchronousSocketChannel对象
            AsynchronousSocketChannel clientChannel = AsynchronousSocketChannel.open()
        ){
            //连接远程服务器
            clientChannel.connect(new InetSocketAddress("127.0.0.1", PORT)).get();
            buff.clear();
            //从clientChannel中读取数据
            clientChannel.read(buff).get();
            buff.flip();
            //将buff中的内容转换为字符串
            String content = utf.decode(buff).toString();
            System.out.println("服务器信息：" + content);
        }
    }
}

import java.net.*;
import java.io.*;
import java.util.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.concurrent.*;

public class AIOServer
{
    static final int PORT = 30000;
    final static String UTF_8 = "utf-8";
    static List<AsynchronousSocketChannel> channelList
        = new ArrayList<>();
    public void startListen() throws InterruptedException,
        Exception
    {
        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(20);
        // 以指定线程池来创建一个AsynchronousChannelGroup
        AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup
            .withThreadPool(executor);
        // 以指定线程池来创建一个AsynchronousServerSocketChannel
        AsynchronousServerSocketChannel serverChannel
            = AsynchronousServerSocketChannel.open(channelGroup)
            // 指定监听本机的PORT端口
            .bind(new InetSocketAddress(PORT));
        // 使用CompletionHandler接受来自客户端的连接请求
        serverChannel.accept(null, new AcceptHandler(serverChannel));  // ①
        Thread.sleep(5000);
    }
    public static void main(String[] args)
        throws Exception
    {
        AIOServer server = new AIOServer();
        server.startListen();
    }
}
// 实现自己的CompletionHandler类
class AcceptHandler implements
    CompletionHandler<AsynchronousSocketChannel, Object>
{
    private AsynchronousServerSocketChannel serverChannel;
    public AcceptHandler(AsynchronousServerSocketChannel sc)
    {
        this.serverChannel = sc;
    }
    // 定义一个ByteBuffer准备读取数据
    ByteBuffer buff = ByteBuffer.allocate(1024);
    // 当实际IO操作完成时候触发该方法
    @Override
    public void completed(final AsynchronousSocketChannel sc
        , Object attachment)
    {
        // 记录新连接的进来的Channel
        AIOServer.channelList.add(sc);
        // 准备接受客户端的下一次连接
        serverChannel.accept(null , this);
        sc.read(buff , null
            , new CompletionHandler<Integer,Object>()  // ②
        {
            @Override
            public void completed(Integer result
                , Object attachment)
            {
                buff.flip();
                // 将buff中内容转换为字符串
                String content = StandardCharsets.UTF_8
                    .decode(buff).toString();
                // 遍历每个Channel，将收到的信息写入各Channel中
                for(AsynchronousSocketChannel c : AIOServer.channelList)
                {
                    try
                    {
                        c.write(ByteBuffer.wrap(content.getBytes(
                            AIOServer.UTF_8))).get();
                    }
                    catch (Exception ex)
                    {
                        ex.printStackTrace();
                    }
                }
                buff.clear();
                // 读取下一次数据
                sc.read(buff , null , this);
            }
            @Override
            public void failed(Throwable ex, Object attachment)
            {
                System.out.println("读取数据失败: " + ex);
                // 从该Channel读取数据失败，就将该Channel删除
                AIOServer.channelList.remove(sc);
            }
        });
    }
    @Override
    public void failed(Throwable ex, Object attachment)
    {
        System.out.println("连接失败: " + ex);
    }
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.concurrent.*;

public class AIOClient
{
    final static String UTF_8 = "utf-8";
    final static int PORT = 30000;
    // 与服务器端通信的异步Channel
    AsynchronousSocketChannel clientChannel;
    JFrame mainWin = new JFrame("多人聊天");
    JTextArea jta = new JTextArea(16 , 48);
    JTextField jtf = new JTextField(40);
    JButton sendBn = new JButton("发送");
    public void init()
    {
        mainWin.setLayout(new BorderLayout());
        jta.setEditable(false);
        mainWin.add(new JScrollPane(jta), BorderLayout.CENTER);
        JPanel jp = new JPanel();
        jp.add(jtf);
        jp.add(sendBn);
        // 发送消息的Action,Action是ActionListener的子接口
        Action sendAction = new AbstractAction()
        {
            public void actionPerformed(ActionEvent e)
            {
                String content = jtf.getText();
                if (content.trim().length() > 0)
                {
                    try
                    {
                        // 将content内容写入Channel中
                        clientChannel.write(ByteBuffer.wrap(content
                            .trim().getBytes(UTF_8))).get();    //①
                    }
                    catch (Exception ex)
                    {
                        ex.printStackTrace();
                    }
                }
                // 清空输入框
                jtf.setText("");
            }
        };
        sendBn.addActionListener(sendAction);
        // 将Ctrl+Enter键和"send"关联
        jtf.getInputMap().put(KeyStroke.getKeyStroke('\n'
            , java.awt.event.InputEvent.CTRL_MASK) , "send");
        // 将"send"和sendAction关联
        jtf.getActionMap().put("send", sendAction);
        mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainWin.add(jp , BorderLayout.SOUTH);
        mainWin.pack();
        mainWin.setVisible(true);
    }
    public void connect()
        throws Exception
    {
        // 定义一个ByteBuffer准备读取数据
        final ByteBuffer buff = ByteBuffer.allocate(1024);
        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(80);
        // 以指定线程池来创建一个AsynchronousChannelGroup
        AsynchronousChannelGroup channelGroup =
            AsynchronousChannelGroup.withThreadPool(executor);
        // 以channelGroup作为组管理器来创建AsynchronousSocketChannel
        clientChannel = AsynchronousSocketChannel.open(channelGroup);
        // 让AsynchronousSocketChannel连接到指定IP、指定端口
        clientChannel.connect(new InetSocketAddress("127.0.0.1"
            , PORT)).get();
        jta.append("---与服务器连接成功---\n");
        buff.clear();
        clientChannel.read(buff, null
            , new CompletionHandler<Integer,Object>()   //②
        {
            @Override
            public void completed(Integer result, Object attachment)
            {
                buff.flip();
                // 将buff中内容转换为字符串
                String content = StandardCharsets.UTF_8
                    .decode(buff).toString();
                // 显示从服务器端读取的数据
                jta.append("某人说：" + content + "\n");
                buff.clear();
                clientChannel.read(buff , null , this);
            }
            @Override
            public void failed(Throwable ex, Object attachment)
            {
                System.out.println("读取数据失败: " + ex);
            }
        });
    }
    public static void main(String[] args)
        throws Exception
    {
        AIOClient client = new AIOClient();
        client.init();
        client.connect();
    }
}

 　　这里运行先运行AIOServer.java代码的时候，过5S后会自动关闭，因为程序中有Thread.sleep(5000);这么一行代码导致的。

 基于UDP协议的网络编程：

　　UDP是一种不可靠的网络协议，它在通信实例的两端各建立一个Socket，但这两个Socket之间并没有虚链路，这两个Socket只是发送、接收数据报的对象。Java提供

　　　了DatagramSocket对象作为基于UDP协议的Socket，使用DatagramSocket发送、接收的数据报。

　　对于UDP协议的通信双方而言，没有所谓的客户端和服务器端的概念。

　　TCP协议：可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大

　　UDP协议：不可靠，差错控制开销小，传输大小限制在64KB以下，不需要建立连接。

　　Java中使用DatagramSocket来接收和发送数据报，使用DatagramPacket来代表数据报。

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

public class UdpServer
{
    public static final int PORT = 30000;
    // 定义每个数据报的最大大小为4K
    private static final int DATA_LEN = 4096;
    // 定义接收网络数据的字节数组
    byte[] inBuff = new byte[DATA_LEN];
    // 以指定字节数组创建准备接受数据的DatagramPacket对象
    private DatagramPacket inPacket =
        new DatagramPacket(inBuff , inBuff.length);
    // 定义一个用于发送的DatagramPacket对象
    private DatagramPacket outPacket;
    // 定义一个字符串数组，服务器发送该数组的的元素
    String[] books = new String[]
    {
        "疯狂Java讲义",
        "轻量级Java EE企业应用实战",
        "疯狂Android讲义",
        "疯狂Ajax讲义"
    };
    public void init()throws IOException
    {
        try(
            // 创建DatagramSocket对象
            DatagramSocket socket = new DatagramSocket(PORT))
        {
            // 采用循环接受数据
            for (int i = 0; i < 1000 ; i++ )
            {
                // 读取Socket中的数据，读到的数据放入inPacket封装的数组里。
                socket.receive(inPacket);
                // 判断inPacket.getData()和inBuff是否是同一个数组
                System.out.println(inBuff == inPacket.getData());
                // 将接收到的内容转成字符串后输出
                System.out.println(new String(inBuff
                    , 0 , inPacket.getLength()));
                // 从字符串数组中取出一个元素作为发送的数据
                byte[] sendData = books[i % 4].getBytes();
                // 以指定字节数组作为发送数据、以刚接受到的DatagramPacket的
                // 源SocketAddress作为目标SocketAddress创建DatagramPacket。
                outPacket = new DatagramPacket(sendData
                    , sendData.length , inPacket.getSocketAddress());
                // 发送数据
                socket.send(outPacket);
            }
        }
    }
    public static void main(String[] args)
        throws IOException
    {
        new UdpServer().init();
    }
}

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

public class UdpClient
{
    // 定义发送数据报的目的地
    public static final int DEST_PORT = 30000;
    public static final String DEST_IP = "127.0.0.1";
    // 定义每个数据报的最大大小为4K
    private static final int DATA_LEN = 4096;
    // 定义接收网络数据的字节数组
    byte[] inBuff = new byte[DATA_LEN];
    // 以指定字节数组创建准备接受数据的DatagramPacket对象
    private DatagramPacket inPacket =
        new DatagramPacket(inBuff , inBuff.length);
    // 定义一个用于发送的DatagramPacket对象
    private DatagramPacket outPacket = null;
    public void init()throws IOException
    {
        try(
            // 创建一个客户端DatagramSocket，使用随机端口
            DatagramSocket socket = new DatagramSocket())
        {
            // 初始化发送用的DatagramSocket，它包含一个长度为0的字节数组
            outPacket = new DatagramPacket(new byte[0] , 0
                , InetAddress.getByName(DEST_IP) , DEST_PORT);
            // 创建键盘输入流
            Scanner scan = new Scanner(System.in);
            // 不断读取键盘输入
            while(scan.hasNextLine())
            {
                // 将键盘输入的一行字符串转换字节数组
                byte[] buff = scan.nextLine().getBytes();
                // 设置发送用的DatagramPacket里的字节数据
                outPacket.setData(buff);
                // 发送数据报
                socket.send(outPacket);
                // 读取Socket中的数据，读到的数据放在inPacket所封装的字节数组里。
                socket.receive(inPacket);
                System.out.println(new String(inBuff , 0
                    , inPacket.getLength()));
            }
        }
    }
    public static void main(String[] args)
        throws IOException
    {
        new UdpClient().init();
    }
}

使用MulticastSocket实现多点广播：

　　DatagramSocket只允许数据报发送给指定的目标地址，而MulticastSocket可以将数据报以广播的方式发送到多个客户端。

　　若要使用多点广播，则需要让一个数据报有一组目标主机地址，当数据报发出后，整个组的所有主机都能收到该数据报。

局域网聊天软件：

public interface YeekuProtocol
{
    String PRESENCE = "⊿⊿";
    String SPLITTER = "▓";
}

import java.net.*;

public class UserInfo
{
    // 该用户的图标
    private String icon;
    // 该用户的名字
    private String name;
    // 该用户的MulitcastSocket所在的IP和端口
    private SocketAddress address;
    // 该用户失去联系的次数
    private int lost;
    // 该用户对应的交谈窗口
    private ChatFrame chatFrame;
    public UserInfo(){}
    // 有参数的构造器
    public UserInfo(String icon , String name
        , SocketAddress address , int lost)
    {
        this.icon = icon;
        this.name = name;
        this.address = address;
        this.lost = lost;
    }

    // 省略所有成员变量的setter和getter方法

    // icon的setter和getter方法
    public void setIcon(String icon)
    {
        this.icon = icon;
    }
    public String getIcon()
    {
        return this.icon;
    }

    // name的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }

    // address的setter和getter方法
    public void setAddress(SocketAddress address)
    {
        this.address = address;
    }
    public SocketAddress getAddress()
    {
        return this.address;
    }

    // lost的setter和getter方法
    public void setLost(int lost)
    {
        this.lost = lost;
    }
    public int getLost()
    {
        return this.lost;
    }

    // chatFrame的setter和getter方法
    public void setChatFrame(ChatFrame chatFrame)
    {
        this.chatFrame = chatFrame;
    }
    public ChatFrame getChatFrame()
    {
        return this.chatFrame;
    }

    // 使用address作为该用户的标识，所以根据address作为
    // 重写hashCode()和equals方法的标准
    public int hashCode()
    {
        return address.hashCode();
    }
    public boolean equals(Object obj)
    {
        if (obj != null && obj.getClass() == UserInfo.class)
        {
            UserInfo target = (UserInfo)obj;
            if (address != null)
            {
                return address.equals(target.getAddress());
            }
        }
        return false;
    }
}

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

// 登录用的对话框
public class LoginFrame extends JDialog
{
    public JLabel tip;
    public JTextField userField = new JTextField("李刚" , 20);
    public JComboBox<Integer> iconList = new JComboBox<>(
        new Integer[]{1, 2, 3, 4, 5 , 6, 7, 8 ,9 ,10});
    private JButton loginBn = new JButton("登录");
    // 聊天的主界面
    private LanTalk chatFrame;
    // 聊天通信的工具实例
    public static ComUtil comUtil;
    // 构造器，用于初始化的登录对话框
    public LoginFrame(LanTalk parent , String msg)
    {
        super(parent , "输入名字后登录" , true);
        this.chatFrame = parent;
        setLayout(new GridLayout(5, 1));
        JPanel jp = new JPanel();
        tip = new JLabel(msg);
        tip.setFont(new Font("Serif" , Font.BOLD , 16));
        jp.add(tip);
        add(jp);
        add(getPanel("用户名" , userField));
        iconList.setPreferredSize(new Dimension(224, 20));
        add(getPanel("图    标" , iconList));
        JPanel bp = new JPanel();
        loginBn.addActionListener(new MyActionListener(this));
        bp.add(loginBn);
        add(bp);
        pack();
        setVisible(true);
    }
    // 工具方法，该方法将一个字符串和组件组合成JPanel对象
    private JPanel getPanel(String name , JComponent jf)
    {
        JPanel jp = new JPanel();
        jp.add(new JLabel(name + "："));
        jp.add(jf);
        return jp;
    }
    // 该方法用于改变登录窗口最上面的提示信息
    public void setTipMsg(String tip)
    {
        this.tip.setText(tip);
    }
    // 定义一个事件监听器
    class MyActionListener implements ActionListener
    {
        private LoginFrame loginFrame;
        public MyActionListener(LoginFrame loginFrame)
        {
            this.loginFrame = loginFrame;
        }
        // 当鼠标单击事件发生时
        public void actionPerformed(ActionEvent evt)
        {
            try
            {
                // 初始化聊天通信类
                comUtil = new ComUtil(chatFrame);
                final String loginMsg = YeekuProtocol.PRESENCE + userField.getText()
                    + YeekuProtocol.SPLITTER + iconList.getSelectedObjects()[0]
                    + YeekuProtocol.PRESENCE;
                comUtil.broadCast(loginMsg);
                // 启动定时器每20秒广播一次在线信息
                javax.swing.Timer timer = new javax.swing.Timer(1000 * 10
                    , event-> comUtil.broadCast(loginMsg));
                timer.start();
                loginFrame.setVisible(false);
                chatFrame.setVisible(true);
            }
            catch (Exception ex)
            {
                loginFrame.setTipMsg("确认30001端口空闲，且网络正常！");
            }
        }
    }
}

import java.text.*;
import java.util.Date;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.net.*;

public class LanTalk extends JFrame
{
    private DefaultListModel<UserInfo> listModel
        = new DefaultListModel<>();
    // 定义一个JList对象
    private JList<UserInfo> friendsList = new JList<>(listModel);
    // 定义一个用于格式化日期的格式器
    private DateFormat formatter = DateFormat.getDateTimeInstance();
    public LanTalk()
    {
        super("局域网聊天");
        // 设置该JList使用ImageCellRenderer作为单元格绘制器
        friendsList.setCellRenderer(new ImageCellRenderer());
        listModel.addElement(new UserInfo("all" , "所有人"
            , null , -2000));
        friendsList.addMouseListener(new ChangeMusicListener());
        add(new JScrollPane(friendsList));
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(2, 2, 160 , 600);
    }
    // 根据地址来查询用户
    public UserInfo getUserBySocketAddress(SocketAddress address)
    {
        for (int i = 1 ; i < getUserNum() ; i++)
        {
            UserInfo user = getUser(i);
            if (user.getAddress() != null
                && user.getAddress().equals(address))
            {
                return user;
            }
        }
        return null;
    }
    // ------下面四个方法是对ListModel的包装------
    // 向用户列表中添加用户
    public void addUser(UserInfo user)
    {
        listModel.addElement(user);
    }
    // 从用户列表中删除用户
    public void removeUser(int pos)
    {
        listModel.removeElementAt(pos);
    }
    // 获取该聊天窗口的用户数量
    public int getUserNum()
    {
        return listModel.size();
    }
    // 获取指定位置的用户
    public UserInfo getUser(int pos)
    {
        return listModel.elementAt(pos);
    }
    // 实现JList上的鼠标双击事件的监听器
    class ChangeMusicListener extends MouseAdapter
    {
        public void mouseClicked(MouseEvent e)
        {
            // 如果鼠标的击键次数大于2
            if (e.getClickCount() >= 2)
            {
                // 取出鼠标双击时选中的列表项
                UserInfo user = (UserInfo)friendsList.getSelectedValue();
                // 如果该列表项对应用户的交谈窗口为null
                if (user.getChatFrame() == null)
                {
                    // 为该用户创建一个交谈窗口，并让该用户引用该窗口
                    user.setChatFrame(new ChatFrame(null , user));
                }
                // 如果该用户的窗口没有显示，则让该用户的窗口显示出来
                if (!user.getChatFrame().isShowing())
                {
                    user.getChatFrame().setVisible(true);
                }
            }
        }
    }
    /**
     * 处理网络数据报，该方法将根据聊天信息得到聊天者，
     * 并将信息显示在聊天对话框中。
     * @param packet 需要处理的数据报
     * @param single 该信息是否为私聊信息
     */
    public void processMsg(DatagramPacket packet , boolean single)
    {
        // 获取该发送该数据报的SocketAddress
        InetSocketAddress srcAddress = (InetSocketAddress)
            packet.getSocketAddress();
        // 如果是私聊信息，则该Packet获取的是DatagramSocket的地址，
        // 将端口减1才是对应的MulticastSocket的地址
        if (single)
        {
            srcAddress = new InetSocketAddress(srcAddress.getHostName()
                , srcAddress.getPort() - 1);
        }
        UserInfo srcUser = getUserBySocketAddress(srcAddress);
        if (srcUser != null)
        {
            // 确定消息将要显示到哪个用户对应窗口上。
            UserInfo alertUser = single ? srcUser : getUser(0);
            // 如果该用户对应的窗口为空，显示该窗口
            if (alertUser.getChatFrame() == null)
            {
                alertUser.setChatFrame(new ChatFrame(null , alertUser));
            }
            // 定义添加的提示信息
            String tipMsg = single ? "对您说：" : "对大家说：";
            try{
                // 显示提示信息
                alertUser.getChatFrame().addString(srcUser.getName()
                    + tipMsg + "......................("
                    + formatter.format(new Date()) + ")\n"
                    + new String(packet.getData() , 0 , packet.getLength()
                    , ComUtil.CHARSET) + "\n");
            } catch (Exception ex) { ex.printStackTrace(); }
            if (!alertUser.getChatFrame().isShowing())
            {
                alertUser.getChatFrame().setVisible(true);
            }
        }
    }
    // 主方法，程序的入口
    public static void main(String[] args)
    {
        LanTalk lanTalk = new LanTalk();
        new LoginFrame(lanTalk , "请输入用户名、头像后登录");
    }
}
// 定义用于改变JList列表项外观的类
class ImageCellRenderer extends JPanel
    implements ListCellRenderer<UserInfo>
{
    private ImageIcon icon;
    private String name;
    // 定义绘制单元格时的背景色
    private Color background;
    // 定义绘制单元格时的前景色
    private Color foreground;
    @Override
    public Component getListCellRendererComponent(JList list
        , UserInfo userInfo , int index
        , boolean isSelected , boolean cellHasFocus)
    {
        // 设置图标
        icon = new ImageIcon("ico/" + userInfo.getIcon() + ".gif");
        name = userInfo.getName();
        // 设置背景色、前景色
        background = isSelected ? list.getSelectionBackground()
            : list.getBackground();
        foreground = isSelected ? list.getSelectionForeground()
            : list.getForeground();
        // 返回该JPanel对象作为单元格绘制器
        return this;
    }
    // 重写paintComponent方法，改变JPanel的外观
    public void paintComponent(Graphics g)
    {
        int imageWidth = icon.getImage().getWidth(null);
        int imageHeight = icon.getImage().getHeight(null);
        g.setColor(background);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(foreground);
        // 绘制好友图标
        g.drawImage(icon.getImage() , getWidth() / 2 - imageWidth / 2
            , 10 , null);
        g.setFont(new Font("SansSerif" , Font.BOLD , 18));
        // 绘制好友用户名
        g.drawString(name, getWidth() / 2 - name.length() * 10
            , imageHeight + 30 );
    }
    // 通过该方法来设置该ImageCellRenderer的最佳大小
    public Dimension getPreferredSize()
    {
        return new Dimension(60, 80);
    }
}

import java.util.*;
import java.net.*;
import java.io.*;
import javax.swing.*;

// 聊天交换信息的工具类
public class ComUtil
{
    // 定义本程序通信所使用的字符集
    public static final String CHARSET = "utf-8";
    // 使用常量作为本程序的多点广播IP地址
    private static final String BROADCAST_IP
        = "230.0.0.1";
    // 使用常量作为本程序的多点广播目的的端口
    // DatagramSocket所用的的端口为该端口+1。
    public static final int BROADCAST_PORT = 30000;
    // 定义每个数据报的最大大小为4K
    private static final int DATA_LEN = 4096;
    // 定义本程序的MulticastSocket实例
    private MulticastSocket socket = null;
    // 定义本程序私聊的Socket实例
    private DatagramSocket singleSocket = null;
    // 定义广播的IP地址
    private InetAddress broadcastAddress = null;
    // 定义接收网络数据的字节数组
    byte[] inBuff = new byte[DATA_LEN];
    // 以指定字节数组创建准备接受数据的DatagramPacket对象
    private DatagramPacket inPacket =
        new DatagramPacket(inBuff , inBuff.length);
    // 定义一个用于发送的DatagramPacket对象
    private DatagramPacket outPacket = null;
    // 聊天的主界面程序
    private LanTalk lanTalk;
    // 构造器，初始化资源
    public ComUtil(LanTalk lanTalk) throws Exception
    {
        this.lanTalk = lanTalk;
        // 创建用于发送、接收数据的MulticastSocket对象
        // 因为该MulticastSocket对象需要接收，所以有指定端口
        socket = new MulticastSocket(BROADCAST_PORT);
        // 创建私聊用的DatagramSocket对象
        singleSocket = new DatagramSocket(BROADCAST_PORT + 1);
        broadcastAddress = InetAddress.getByName(BROADCAST_IP);
        // 将该socket加入指定的多点广播地址
        socket.joinGroup(broadcastAddress);
        // 设置本MulticastSocket发送的数据报被回送到自身
        socket.setLoopbackMode(false);
        // 初始化发送用的DatagramSocket，它包含一个长度为0的字节数组
        outPacket = new DatagramPacket(new byte[0]
            , 0 , broadcastAddress , BROADCAST_PORT);
        // 启动两个读取网络数据的线程
        new ReadBroad().start();
        Thread.sleep(1);
        new ReadSingle().start();
    }
    // 广播消息的工具方法
    public void broadCast(String msg)
    {
        try
        {
            // 将msg字符串转换字节数组
            byte[] buff = msg.getBytes(CHARSET);
            // 设置发送用的DatagramPacket里的字节数据
            outPacket.setData(buff);
            // 发送数据报
            socket.send(outPacket);
        }
        // 捕捉异常
        catch (IOException ex)
        {
            ex.printStackTrace();
            if (socket != null)
            {
                // 关闭该Socket对象
                socket.close();
            }
            JOptionPane.showMessageDialog(null
                , "发送信息异常，请确认30000端口空闲，且网络连接正常！"
                , "网络异常", JOptionPane.ERROR_MESSAGE);
            System.exit(1);
        }
    }
    // 定义向单独用户发送消息的方法
    public void sendSingle(String msg , SocketAddress dest)
    {
        try
        {
            // 将msg字符串转换字节数组
            byte[] buff = msg.getBytes(CHARSET);
            DatagramPacket packet = new DatagramPacket(buff
                , buff.length , dest);
            singleSocket.send(packet);
        }
        // 捕捉异常
        catch (IOException ex)
        {
            ex.printStackTrace();
            if (singleSocket != null)
            {
                // 关闭该Socket对象
                singleSocket.close();
            }
            JOptionPane.showMessageDialog(null
                , "发送信息异常，请确认30001端口空闲，且网络连接正常！"
                , "网络异常", JOptionPane.ERROR_MESSAGE);
            System.exit(1);
        }
    }
    // 不断从DatagramSocket中读取数据的线程
    class ReadSingle extends Thread
    {
        // 定义接收网络数据的字节数组
        byte[] singleBuff = new byte[DATA_LEN];
        private DatagramPacket singlePacket =
            new DatagramPacket(singleBuff , singleBuff.length);
        public void run()
        {
            while (true)
            {
                try
                {
                    // 读取Socket中的数据。
                    singleSocket.receive(singlePacket);
                    // 处理读到的信息
                    lanTalk.processMsg(singlePacket , true);
                }
                // 捕捉异常
                catch (IOException ex)
                {
                    ex.printStackTrace();
                    if (singleSocket != null)
                    {
                        // 关闭该Socket对象
                        singleSocket.close();
                    }
                    JOptionPane.showMessageDialog(null
                        , "接收信息异常，请确认30001端口空闲，且网络连接正常！"
                        , "网络异常", JOptionPane.ERROR_MESSAGE);
                    System.exit(1);
                }
            }
        }
    }
    // 持续读取MulticastSocket的线程
    class ReadBroad extends Thread
    {
        public void run()
        {
            while (true)
            {
                try
                {
                    // 读取Socket中的数据。
                    socket.receive(inPacket);
                    // 打印输出从socket中读取的内容
                    String msg = new String(inBuff , 0
                        , inPacket.getLength() , CHARSET);
                    // 读到的内容是在线信息
                    if (msg.startsWith(YeekuProtocol.PRESENCE)
                        && msg.endsWith(YeekuProtocol.PRESENCE))
                    {
                        String userMsg = msg.substring(2
                            , msg.length() - 2);
                        String[] userInfo = userMsg.split(YeekuProtocol
                            .SPLITTER);
                        UserInfo user = new UserInfo(userInfo[1]
                            , userInfo[0] , inPacket.getSocketAddress(), 0);
                        // 控制是否需要添加该用户的旗标
                        boolean addFlag = true;
                        ArrayList<Integer> delList = new ArrayList<>();
                        // 遍历系统中已有的所有用户,该循环必须循环完成
                        for (int i = 1 ; i < lanTalk.getUserNum() ; i++ )
                        {
                            UserInfo current = lanTalk.getUser(i);
                            // 将所有用户失去联系的次数加1
                            current.setLost(current.getLost() + 1);
                            // 如果该信息由指定用户发送过来
                            if (current.equals(user))
                            {
                                current.setLost(0);
                                // 设置该用户无须添加
                                addFlag = false;
                            }
                            if (current.getLost() > 2)
                            {
                                delList.add(i);
                            }
                        }
                        // 删除delList中的所有索引对应的用户
                        for (int i = 0; i < delList.size() ; i++)
                        {
                            lanTalk.removeUser(delList.get(i));
                        }
                        if (addFlag)
                        {
                            // 添加新用户
                            lanTalk.addUser(user);
                        }
                    }
                    // 读到的内容是公聊信息
                    else
                    {
                        // 处理读到的信息
                        lanTalk.processMsg(inPacket , false);
                    }
                }
                // 捕捉异常
                catch (IOException ex)
                {
                    ex.printStackTrace();
                    if (socket != null)
                    {
                        // 关闭该Socket对象
                        socket.close();
                    }
                    JOptionPane.showMessageDialog(null
                        , "接收信息异常，请确认30000端口空闲，且网络连接正常！"
                        , "网络异常", JOptionPane.ERROR_MESSAGE);
                    System.exit(1);
                }
            }
        }
    }
}

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.net.InetSocketAddress;

// 定义交谈的对话框
public class ChatFrame extends JDialog
{
    // 聊天信息区
    JTextArea msgArea = new JTextArea(12 , 45);
    // 聊天输入区
    JTextField chatField = new JTextField(30);
    // 发送聊天信息的按钮
    JButton sendBn = new JButton("发送");
    // 该交谈窗口对应的用户
    UserInfo user;
    // 构造器，用于初始化交谈对话框的界面
    public ChatFrame(LanTalk parent , final UserInfo user)
    {
        super(parent , "和" + user.getName() + "聊天中" , false);
        this.user = user;
        msgArea.setEditable(false);
        add(new JScrollPane(msgArea));
        JPanel buttom = new JPanel();
        buttom.add(new JLabel("输入信息："));
        buttom.add(chatField);
        buttom.add(sendBn);
        add(buttom , BorderLayout.SOUTH);
        // 发送消息的Action，Action是ActionListener的子接口
        Action sendAction = new AbstractAction()
        {
            @Override
            public void actionPerformed(ActionEvent evt)
            {
                InetSocketAddress dest = (InetSocketAddress)user.getAddress();
                // 在聊友列表中，所有人项的SocketAddress是null
                // 这表明是向所有人发送消息
                if (dest == null)
                {
                    LoginFrame.comUtil.broadCast(chatField.getText());
                    msgArea.setText("您对大家说："
                        + chatField.getText() + "\n" + msgArea.getText());
                }
                // 向私人发送信息
                else
                {
                    // 获取发送消息的目的
                    dest = new InetSocketAddress(dest.getHostName(),
                        dest.getPort() + 1);
                    LoginFrame.comUtil.sendSingle(chatField.getText(), dest);
                    msgArea.setText("您对" + user.getName() +  "说："
                        + chatField.getText() + "\n" + msgArea.getText());

                }
                chatField.setText("");
            }
        };
        sendBn.addActionListener(sendAction);
        // 将Ctrl+Enter键和"send"关联
        chatField.getInputMap().put(KeyStroke.getKeyStroke('\n'
            , java.awt.event.InputEvent.CTRL_MASK) , "send");
        // 将"send"与sendAction关联
        chatField.getActionMap().put("send", sendAction);
        pack();
    }
    // 定义向聊天区域添加消息的方法
    public void addString(String msg)
    {
        msgArea.setText(msg + "\n" + msgArea.getText());
    }
}

 由于实现这个局域网组播的聊天软件，必须在两台电脑之间有一台支持组播通信的路由器，查看自己电脑连接的路由器是否支持组播：

因为我电脑所连接的路由器不支持组播通信，所以没有看到局域网组播通信。这里就没有结果的截图。

但是代码一定是对的。