Java网络编程是Java开发中的重要内容之一，通过网络编程，Java应用程序能够进行数据传输，实现分布式计算和跨平台的通信。本文将全面介绍Java中的网络编程，包括基础概念、核心API、网络协议、Socket编程、URL编程、NIO网络编程、常见网络协议实现以及安全与性能优化等。希望通过这篇文章，能够帮助读者全面掌握Java网络编程的理论与实践。

一、Java网络编程的基础概念

1.1 网络基本概念

1. IP地址：网络中设备的唯一标识，用于设备之间的通信。
2. 端口：设备上应用程序的唯一标识，用于区分不同的网络应用。
3. 协议：通信双方遵循的规则和约定，如TCP、UDP、HTTP等。

1.2 Java网络编程的核心API

Java提供了一系列API用于网络编程，主要包括：

1. java.net包：包含基础的网络编程类，如Socket、ServerSocket、InetAddress、URL等。
2. java.nio包：包含NIO（非阻塞IO）类，用于高性能网络编程。

二、Socket编程

2.1 Socket编程的基本概念

1. Socket：网络通信的基本单元，表示通信的两端。
2. ServerSocket：服务器端Socket，用于监听客户端连接请求。

2.2 TCP编程

TCP（传输控制协议）是一种面向连接的可靠传输协议，保证数据的完整性和顺序性。

示例代码：简单的TCP服务器

import java.io.*;
import java.net.*;
public class TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(12345)) {
            System.out.println("Server is listening on port 12345");
            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("New client connected");
                new ServerThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class ServerThread extends Thread {
    private Socket socket;
    public ServerThread(Socket socket) {
        this.socket = socket;
    }
    public void run() {
        try (InputStream input = socket.getInputStream();
             BufferedReader reader = new BufferedReader(new InputStreamReader(input));
             OutputStream output = socket.getOutputStream();
             PrintWriter writer = new PrintWriter(output, true)) {
            String text;
            while ((text = reader.readLine()) != null) {
                System.out.println("Received: " + text);
                writer.println("Echo: " + text);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例代码：简单的TCP客户端

import java.io.*;
import java.net.*;
public class TCPClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 12345);
             OutputStream output = socket.getOutputStream();
             PrintWriter writer = new PrintWriter(output, true);
             InputStream input = socket.getInputStream();
             BufferedReader reader = new BufferedReader(new InputStreamReader(input))) {
            writer.println("Hello, Server!");
            String response = reader.readLine();
            System.out.println("Server response: " + response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.3 UDP编程

UDP（用户数据报协议）是一种无连接的传输协议，不保证数据的可靠性和顺序性，但速度快，适用于实时应用。

示例代码：简单的UDP服务器

import java.net.*;
public class UDPServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(12345)) {
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            System.out.println("Server is listening on port 12345");
            while (true) {
                socket.receive(packet);
                String received = new String(packet.getData(), 0, packet.getLength());
                System.out.println("Received: " + received);
                String response = "Echo: " + received;
                byte[] responseData = response.getBytes();
                DatagramPacket responsePacket = new DatagramPacket(responseData, responseData.length, packet.getAddress(), packet.getPort());
                socket.send(responsePacket);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例代码：简单的UDP客户端

import java.net.*;
public class UDPClient {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket()) {
            byte[] buffer = "Hello, Server!".getBytes();
            InetAddress address = InetAddress.getByName("localhost");
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, 12345);
            socket.send(packet);
            byte[] responseBuffer = new byte[1024];
            DatagramPacket responsePacket = new DatagramPacket(responseBuffer, responseBuffer.length);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.println("Server response: " + response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

三、URL编程

3.1 URL和URI

1. URL（统一资源定位符）：用于定位网络资源的地址。
2. URI（统一资源标识符）：用于唯一标识网络资源。

3.2 URL类

Java提供了java.net.URL类用于表示和操作URL。

示例代码：使用URL类

import java.io.*;
import java.net.*;
public class URLExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println(inputLine);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四、NIO网络编程

4.1 NIO概述

NIO（New Input/Output）是Java 1.4引入的新的IO API，提供了非阻塞IO操作，适用于高性能网络编程。

4.2 NIO核心组件

1. Channel：表示连接到IO设备的开放连接。
2. Buffer：用于数据的临时存储。
3. Selector：用于监听多个通道的事件。

4.3 非阻塞服务器

示例代码：NIO非阻塞服务器

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
public class NIOServer {
    public static void main(String[] args) {
        try {
            Selector selector = Selector.open();
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(12345));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("Server is listening on port 12345");
            while (true) {
                selector.select();
                Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();
                    keyIterator.remove();
                    if (key.isAcceptable()) {
                        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                        SocketChannel socketChannel = serverChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ);
                        System.out.println("New client connected");
                    } else if (key.isReadable()) {
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int bytesRead = socketChannel.read(buffer);
                        if (bytesRead == -1) {
                            socketChannel.close();
                        } else {
                            buffer.flip();
                            socketChannel.write(buffer);
                            buffer.clear();
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例代码：NIO非阻塞客户端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NIOClient {
    public static void main(String[] args) {
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress("localhost", 12345));
            while (!socketChannel.finishConnect()) {
                // 等待连接完成
            }
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("Hello, Server!".getBytes());
            buffer.flip();
            socketChannel.write(buffer);
            buffer.clear();
            int bytesRead = socketChannel.read(buffer);
            if (bytesRead != -1) {
                buffer.flip();
                while (buffer
.hasRemaining()) {
                    System.out.print((char) buffer.get());
                }
            }
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

五、常见网络协议实现

5.1 HTTP协议

HTTP（超文本传输协议）是最常用的网络协议之一，用于在客户端和服务器之间传输超文本。

示例代码：使用HttpURLConnection发送HTTP请求

import java.io.*;
import java.net.*;
public class HttpURLConnectionExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println(inputLine);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.2 FTP协议

FTP（文件传输协议）用于在客户端和服务器之间传输文件。

示例代码：使用Apache Commons Net实现FTP客户端

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class FTPClientExample {
    public static void main(String[] args) {
        FTPClient ftpClient = new FTPClient();
        try {
            ftpClient.connect("ftp.example.com");
            ftpClient.login("username", "password");
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            try (InputStream inputStream = new FileInputStream("path/to/local/file")) {
                boolean done = ftpClient.storeFile("path/to/remote/file", inputStream);
                if (done) {
                    System.out.println("File uploaded successfully.");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                ftpClient.logout();
                ftpClient.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5.3 SMTP协议

SMTP（简单邮件传输协议）用于发送电子邮件。

示例代码：使用JavaMail API发送电子邮件

import javax.mail.*;
import javax.mail.internet.*;
import java.util.Properties;
public class EmailSender {
    public static void main(String[] args) {
        String host = "smtp.example.com";
        String from = "sender@example.com";
        String to = "recipient@example.com";
        Properties properties = System.getProperties();
        properties.setProperty("mail.smtp.host", host);
        Session session = Session.getDefaultInstance(properties);
        try {
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress(from));
            message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
            message.setSubject("This is the Subject Line!");
            message.setText("This is the actual message");
            Transport.send(message);
            System.out.println("Message sent successfully.");
        } catch (MessagingException e) {
            e.printStackTrace();
        }
    }
}

六、网络编程中的安全性

6.1 数据加密

为了保护数据在网络传输中的安全性，可以使用SSL/TLS加密。

示例代码：使用HTTPS发送请求

import javax.net.ssl.HttpsURLConnection;
import java.io.*;
import java.net.URL;
public class HttpsClient {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println(inputLine);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.2 身份验证

身份验证可以确保只有授权用户可以访问网络资源。

示例代码：使用Basic Authentication发送HTTP请求

import java.io.*;
import java.net.*;
import java.util.Base64;
public class BasicAuthHttpClient {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            String userCredentials = "username:password";
            String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userCredentials.getBytes()));
            connection.setRequestProperty("Authorization", basicAuth);
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println(inputLine);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.3 防火墙和代理

通过使用防火墙和代理服务器，可以增强网络安全性，防止未经授权的访问。

示例代码：通过代理发送HTTP请求

import java.io.*;
import java.net.*;
public class ProxyHttpClient {
    public static void main(String[] args) {
        try {
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.com", 8080));
            URL url = new URL("http://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
            connection.setRequestMethod("GET");
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println(inputLine);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

七、网络编程中的性能优化

7.1 缓存

通过使用缓存，可以减少网络请求的次数，提高系统性能。

示例代码：简单的缓存实现

import java.util.HashMap;
import java.util.Map;
class Cache<K, V> {
    private final Map<K, V> map = new HashMap<>();
    public void put(K key, V value) {
        map.put(key, value);
    }
    public V get(K key) {
        return map.get(key);
    }
    public boolean containsKey(K key) {
        return map.containsKey(key);
    }
}
public class CacheExample {
    public static void main(String[] args) {
        Cache<String, String> cache = new Cache<>();
        cache.put("key", "value");
        if (cache.containsKey("key")) {
            System.out.println("Cache hit: " + cache.get("key"));
        } else {
            System.out.println("Cache miss");
        }
    }
}

7.2 连接池

通过使用连接池，可以减少连接的建立和释放开销，提高系统性能。

示例代码：使用Apache Commons Pool实现连接池

import org.apache.commons.pool2.*;
import org.apache.commons.pool2.impl.*;
import java.net.Socket;
class SocketFactory extends BasePooledObjectFactory<Socket> {
    @Override
    public Socket create() throws Exception {
        return new Socket("localhost", 12345);
    }
    @Override
    public PooledObject<Socket> wrap(Socket socket) {
        return new DefaultPooledObject<>(socket);
    }
    @Override
    public void destroyObject(PooledObject<Socket> p) throws Exception {
        p.getObject().close();
    }
    @Override
    public boolean validateObject(PooledObject<Socket> p) {
        return p.getObject().isConnected();
    }
}
public class ConnectionPoolExample {
    public static void main(String[] args) {
        GenericObjectPool<Socket> pool = new GenericObjectPool<>(new SocketFactory());
        try {
            Socket socket = pool.borrowObject();
            System.out.println("Using socket: " + socket);
            pool.returnObject(socket);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

八、常见的网络编程框架

8.1 Netty

Netty是一个高性能的网络应用框架，适用于开发高可扩展性和高吞吐量的网络应用。

示例代码：使用Netty实现简单的服务器

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
public class NettyServer {
    private int port;
    public NettyServer(int port) {
        this.port = port;
    }
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            ChannelPipeline p
 = ch.pipeline();
                            p.addLast(new StringDecoder());
                            p.addLast(new StringEncoder());
                            p.addLast(new SimpleChannelInboundHandler<String>() {
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, String msg) {
                                    System.out.println("Received: " + msg);
                                    ctx.writeAndFlush("Echo: " + msg);
                                }
                            });
                        }
                    });
            ChannelFuture f = b.bind(port).sync();
            System.out.println("Server started on port " + port);
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    public static void main(String[] args) throws Exception {
        new NettyServer(12345).run();
    }
}

示例代码：使用Netty实现简单的客户端

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
public class NettyClient {
    private final String host;
    private final int port;
    public NettyClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    public void run() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel ch) {
                            ChannelPipeline p = ch.pipeline();
                            p.addLast(new StringDecoder());
                            p.addLast(new StringEncoder());
                            p.addLast(new SimpleChannelInboundHandler<String>() {
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, String msg) {
                                    System.out.println("Received: " + msg);
                                }
                            });
                        }
                    });
            ChannelFuture f = b.connect(host, port).sync();
            f.channel().writeAndFlush("Hello, Server!");
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
    public static void main(String[] args) throws Exception {
        new NettyClient("localhost", 12345).run();
    }
}

8.2 Apache MINA

Apache MINA是一个可扩展的网络应用框架，用于简化TCP/IP和UDP/IP等网络应用的开发。

示例代码：使用Apache MINA实现简单的服务器

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.service.IoService;
import org.apache.mina.core.service.IoServiceListener;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;
public class MinaServer {
    private static final int PORT = 12345;
    public static void main(String[] args) {
        NioSocketAcceptor acceptor = new NioSocketAcceptor();
        acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        acceptor.setHandler(new IoHandlerAdapter() {
            @Override
            public void messageReceived(IoSession session, Object message) {
                String str = message.toString();
                System.out.println("Received: " + str);
                session.write("Echo: " + str);
            }
        });
        try {
            acceptor.bind(new InetSocketAddress(PORT));
            System.out.println("Server started on port " + PORT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例代码：使用Apache MINA实现简单的客户端

import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;
public class MinaClient {
    public static void main(String[] args) {
        NioSocketConnector connector = new NioSocketConnector();
        connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        connector.setHandler(new IoHandlerAdapter() {
            @Override
            public void messageReceived(IoSession session, Object message) {
                System.out.println("Received: " + message);
            }
        });
        ConnectFuture future = connector.connect(new InetSocketAddress("localhost", 12345));
        future.awaitUninterruptibly();
        IoSession session = future.getSession();
        session.write("Hello, Server!");
        session.getCloseFuture().awaitUninterruptibly();
        connector.dispose();
    }
}

九、网络编程中的测试与调试

9.1 单元测试

通过编写单元测试，可以验证网络编程中的各个功能模块，提高代码质量。

示例代码：使用JUnit编写网络编程单元测试

import static org.junit.Assert.assertEquals;
import java.io.*;
import java.net.*;
import org.junit.Test;
public class NetworkTest {
    @Test
    public void testTCPServerClient() throws IOException {
        // 启动服务器
        new Thread(() -> {
            try (ServerSocket serverSocket = new ServerSocket(12345)) {
                Socket socket = serverSocket.accept();
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                String message = in.readLine();
                out.println("Echo: " + message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
        // 启动客户端
        try (Socket socket = new Socket("localhost", 12345);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            out.println("Hello, Server!");
            String response = in.readLine();
            assertEquals("Echo: Hello, Server!", response);
        }
    }
}

9.2 网络调试工具

使用网络调试工具（如Wireshark、tcpdump等）可以捕获和分析网络通信数据，帮助诊断和解决网络问题。

十、Java网络编程的未来趋势

10.1 HTTP/2和HTTP/3

随着HTTP/2和HTTP/3协议的广泛应用，Java网络编程需要支持这些新协议，提高网络通信的效率和性能。

10.2 WebSocket

WebSocket协议提供了全双工通信通道，适用于实时应用。Java中可以使用javax.websocket API实现WebSocket通信。

示例代码：使用Java WebSocket API实现简单的WebSocket服务器

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
@ServerEndpoint("/websocket")
public class WebSocketServer {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("New connection opened");
    }
    @OnMessage
    public void onMessage(Session session, String message) {
        System.out.println("Received: " + message);
        try {
            session.getBasicRemote().sendText("Echo: " + message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @OnClose
    public void onClose(Session session) {
        System.out.println("Connection closed");
    }
    @OnError
    public void onError(Session session, Throwable throwable) {
        throwable.printStackTrace();
    }
    public static void main(String[] args) {
        Server server = new Server(8080);
        ServerContainer container = WebSocketServerContainerInitializer.configureContext(server);
        container.addEndpoint(WebSocketServer.class);
        try {
            server.start();
            server.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

示例代码：使用Java WebSocket API实现简单的WebSocket客户端

import javax.websocket.*;
import java.net.URI;
@ClientEndpoint
public class WebSocketClient {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("Connected to server");
        try {
            session.getBasicRemote().sendText("Hello, Server!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @OnMessage
    public void onMessage(String message) {
        System.out.println("Received: " + message);
    }
    @OnClose
    public void onClose() {
        System.out.println("Connection closed");
    }
    @OnError
    public void onError(Throwable throwable) {
        throwable.printStackTrace();
    }
    public static void main(String[] args) {
        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            container.connectToServer(WebSocketClient.class, new URI("ws://localhost:8080/websocket"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

十一、总结

网络编程是Java开发中重要的一部分，通过网络编程，可以实现跨平台的数据传输和分布式计算。本文详细介绍了Java网络编程的基础概念、核心API、Socket编程、URL编程、NIO网络编程、常见网络协议实现、安全与性能优化、常见网络编程框架、测试与调试方法以及未来趋势。同时，提供了丰富的示例代码，帮助读者更好地理解和应用Java网络编程。