JavaSE系列-11 网络编程、JDBC编程、函数式编程

网络编程、JDBC编程、函数式编程

在Ja va的技术栈里，网络编程、JDBC和函数式编程这三块，基本上算是绕不开的硬骨头。尤其是网络编程，从最底层的Socket到Email收发，每一步都藏着不少细节。今天咱们就先把网络编程这部分彻底说透。

网络编程

Socket

说起Socket，就不得不提两个老朋友：TCP和UDP。它们俩的区别，用一句话就能说清：TCP像打电话，连接建立好了才聊，确保每句话你都能听到；UDP像写信，扔出去就不管了，能不能收到全看缘分。

TCP追求的是可靠，UDP追求的是效率。怎么选？看场景。

TCP编程

TCP的编程套路其实相当固定，核心步骤就这几步：

1. 客户端用 Socket(InetAddress, port) 打开连接。
2. 服务器端用 ServerSocket 监听端口。
3. 服务器端调用 accept() 接收请求，返回一个 Socket。
4. 双方通过 getInputStream() / getOutputStream() 读写数据。
5. 别忘了 flush()，它负责把缓冲区里的数据“推”出去。

来看个最简单的例子。服务器监听9090端口，客户端发个“time”命令，服务器就把当前时间返回去。

服务器端代码：

public class TCPServer {
    public static void main(String[] args) throws Exception {
        ServerSocket socketSocket = new ServerSocket(9090);
        System.out.println("TCP server ready...");
        Socket socket = socketSocket.accept();
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {
            try (BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8))) {
                String cmd = reader.readLine();
                if ("time".equals(cmd)) {
                    writer.write(LocalDateTime.now().toString() + "\n");
                    writer.flush();
                } else {
                    writer.write("Sorry?\n");
                    writer.flush();
                }
            }
        }
        socket.close();
        socketSocket.close();
    }
}

客户端代码：

public class TCPClient {
    public static void main(String[] args) throws IOException {
        InetAddress address = InetAddress.getLoopbackAddress();
        try (Socket socket = new Socket(address, 9090)) {
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {
                try (BufferedWriter writer = new BufferedWriter(
                        new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8))) {
                    writer.write("time\n");
                    writer.flush();
                    String response = reader.readLine();
                    System.out.println("Response: " + response);
                }
            }
        }
    }
}

这里有个细节值得注意：ServerSocket 的构造函数可以指定绑定的IP地址。你看下面这几种写法，分别对应不同的访问范围：

// 所有IP都可以访问
new ServerSocket(12345);

// 仅本机（127.0.0.1）可以访问
new ServerSocket(12345, 50, InetAddress.getLoopbackAddress());

// 仅公网IP可以访问
new ServerSocket(12345, 50, InetAddress.getByAddress(new byte[]{101, 77, 99, 88}));

// 仅内网IP可以访问
new ServerSocket(12345, 50, InetAddress.getByAddress(new byte[]{10, 1, 0, 100}));

TCP多线程是生产环境中必须掌握的套路。单线程的服务器一次只能处理一个客户端，这显然不现实。正确的做法是：每次 accept() 返回后，把客户端请求交给一个新线程去处理。这样主线程可以继续等待下一个连接。

看一个改造后的多线程服务器端：

public class TCPServer {
    public static void main(String[] args) throws Exception {
        @SuppressWarnings("resource")
        ServerSocket socketSocket = new ServerSocket(9090);
        System.out.println("TCP server ready...");
        for (;;) {
            Socket socket = socketSocket.accept();
            System.out.println("Accept from " + socket.getRemoteSocketAddress());
            TimeHandler handler = new TimeHandler(socket);
            handler.start();
        }
    }
}

class TimeHandler extends Thread {
    Socket socket;
    public TimeHandler(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {
            try (BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8))) {
                for (;;) {
                    String cmd = reader.readLine();
                    if ("q".equals(cmd)) {
                        writer.write("bye!\n");
                        writer.flush();
                    } else if ("time".equals(cmd)) {
                        writer.write(LocalDateTime.now().toString() + "\n");
                        writer.flush();
                    } else {
                        writer.write("Sorry?\n");
                        writer.flush();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                this.socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端这边，可以连续发多个命令：

public class TCPClient {
    public static void main(String[] args) throws IOException, InterruptedException {
        InetAddress address = InetAddress.getByName("localhost");
        try (Socket socket = new Socket(address, 9090)) {
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {
                try (BufferedWriter writer = new BufferedWriter(
                        new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8))) {
                    writer.write("time\n");
                    writer.flush();
                    String response = reader.readLine();
                    System.out.println("Response: " + response);
                    Thread.sleep(1000);
                    writer.write("q\n");
                    writer.flush();
                    response = reader.readLine();
                    System.out.println("Response: " + response);
                }
            }
        }
    }
}

多线程模型虽然简单，但每次连接都创建一个线程，在高并发场景下性能会急剧下降。所以通常我们会用线程池来管理线程，避免无限制的资源消耗。后面练习里你可以试试把这里改成线程池实现。

UDP编程

UDP和TCP的编程方式差异很大，核心区别就几条：

• UDP不需要建立连接，直接发数据。
• 它不保证可靠传输，丢了就丢了。
• 客户端用 DatagramSocket.connect() 指定远程地址和端口。
• 服务器端用 DatagramSocket(port) 监听端口。
• 双方通过 receive() / send() 读写数据，没有IO流那一套。

来看服务器端代码，监听9090端口，收到什么就返回什么：

public class UDPServer {
    public LocalDateTime currentTime() {
        return LocalDateTime.now();
    }
    public static void main(String[] args) throws Exception {
        @SuppressWarnings("resource")
        DatagramSocket ds = new DatagramSocket(9090);
        System.out.println("UDP server ready...");
        for (;;) {
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            ds.receive(packet);
            byte[] data = packet.getData();
            String s = new String(data, StandardCharsets.UTF_8);
            System.out.println("Packet received from: " + packet.getSocketAddress() + " " + s);
            String response = LocalDateTime.now().toString();
            packet.setData(response.getBytes(StandardCharsets.UTF_8));
            ds.send(packet);
        }
    }
}

客户端：

public class UDPClient {
    public static void main(String[] args) throws Exception {
        InetAddress address = InetAddress.getLoopbackAddress();
        try (DatagramSocket socket = new DatagramSocket()) {
            socket.connect(address, 9090);
            byte[] data = "time".getBytes(StandardCharsets.UTF_8);
            DatagramPacket packet = new DatagramPacket(data, data.length);
            socket.send(packet);
            System.out.println("Data was sent.");
            Thread.sleep(1000);
            byte[] buffer = new byte[1024];
            DatagramPacket response = new DatagramPacket(buffer, buffer.length);
            socket.receive(response);
            byte[] responseData = response.getData();
            String responseText = new String(responseData, 0, response.getLength(), StandardCharsets.UTF_8);
            System.out.println("Response: " + responseText);
        }
    }
}

UDP虽然简单，但用在实时性要求高、可以容忍丢包的场景下（比如视频通话、在线游戏）非常合适。

Email

发送Email

发送Email依赖的是SMTP协议（Simple Mail Transport Protocol）。标准端口是25，加密端口用465（SSL）或587（TLS）。在Ja va里发邮件，核心是Ja vaMail API。流程分三步：

1. 确定SMTP服务器信息：域名、端口、加密方式（明文/SSL/TLS）。
2. 创建Session和Message，设置发件人、收件人、标题、正文。
3. 调用 Transport.send(message) 发送。

调试时建议开启debug模式，能看到SMTP通信的详细内容，排查问题非常方便。

先看一个通用的发送类骨架：

// 1. 创建Session：
Session session = Session.getInstance(props, new Authenticator(){ ... });
// 2. 创建Message对象：
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress("from@email.com"));
message.setRecipient(Message.RecipientType.TO, new InternetAddress("to@email.com"));
message.setSubject("RE:how to use Ja vaMail", "UTF-8");
message.setText("blablabla...", "UTF-8");
// 3. 发送邮件：
Transport.send(message);

记得在pom.xml里加上依赖：

    ja vax.mail
    mail
    1.4

发送文本邮件

下面是一个完整的文本邮件发送示例，使用SSL加密连接到邮箱服务器：

/**
 * 发送文本邮件
 */
public class SendMail {
    /** 邮件服务器域名 */
    final String smtpHost;
    /** 邮件服务器登陆名 */
    final String username;
    /** 邮件服务器登陆密码 */
    final String password;
    final boolean debug;

    public SendMail(String smtpHost, String username, String password){
        this.smtpHost = smtpHost;
        this.username = username;
        this.password = password;
        this.debug = true;
    }

    public static void main(String[] args) throws Exception {
        SendMail sender = new SendMail("smtp.sina.com", 
                "ja vacourse001@sina.com", "ja va-12345678");
        Session session = sender.createSSLSession();
        Message message = createTextMessage(session, 
                "ja vacourse001@sina.com", "ja vacourse001@163.com", 
                "Ja va邮件测试", "Hello, 这是一封ja vamail测试邮件！");
        Transport.send(message);
    }

    Session createSSLSession() {
        Properties props = new Properties();
        props.put("mail.smtp.host", this.smtpHost);
        props.put("mail.smtp.port", "465");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.socketFactory.class", 
                "ja vax.net.ssl.SSLSocketFactory");
        props.put("mail.smtp.socketFactory.port", "465");
        Session session = Session.getInstance(props, new Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(
                        SendMail.this.username, 
                        SendMail.this.password);
            }
        });
        session.setDebug(this.debug);
        return session;
    }

    // 此外还有TLS和明文会话的创建方式，这里先注释掉，需要时可以直接启用

}

从上面的代码可以看出，createSSLSession() 方法负责配置SSL加密连接，而 createTextMessage()（代码中未完全给出，但核心就是设置发件人、收件人、主题和正文）则组装邮件内容。体验一下debug模式下的输出，你会看到SMTP协议是如何一步步跟服务器握手的。

说句实在话，Ja vaMail的API虽然历史悠久，但设计得相当成熟稳定，只要按照这个模板来写，基本不会出大问题。不过要注意：现在很多邮箱服务商（比如QQ、163）都需要开启“授权码”才能使用第三方客户端登录，直接拿密码登录会报错，遇到这种情况去邮箱设置里找一下就好。