互联网Java工程师面试题·Java 总结篇·第八弹

目录

72、用 Java 的套接字编程实现一个多线程的回显（echo）服务器。

73、XML 文档定义有几种形式？它们之间有何本质区别？解析XML 文档有哪几种方式？

74、你在项目中哪些地方用到了 XML？

---

72、用 Java 的套接字编程实现一个多线程的回显（echo）服务器。

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

public class EchoServer {
    private static final int ECHO_SERVER_PORT = 6789;
    public static void main(String[] args) {
    try(ServerSocket server = new
ServerSocket(ECHO_SERVER_PORT)) {
        System.out.println("服务器已经启动...");
        while(true) {
            Socket client = server.accept();
            new Thread(new ClientHandler(client)).start();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private static class ClientHandler implements Runnable {
    private Socket client;
    
    public ClientHandler(Socket client) {
        this.client = client;
    }

@Override
    public void run() {
        try(BufferedReader br = new BufferedReader(new
InputStreamReader(client.getInputStream()));
            PrintWriter pw = new
PrintWriter(client.getOutputStream())) {
        String msg = br.readLine();
        System.out.println("收到" + client.getInetAddress() + " 发送的: " + msg);
        pw.println(msg);
        pw.flush();
    } catch(Exception ex) {
        ex.printStackTrace();
        } finally {
        try {
            client.close();
        } catch (IOException e) {
        e.printStackTrace();
        }
        }
        }
}
}

注意：上面的代码使用了 Java 7 的 TWR 语法，由于很多外部资源类都间接的实现了 AutoCloseable 接口（单方法回调接口），因此可以利用 TWR 语法在 try结束的时候通过回调的方式自动调用外部资源类的 close()方法，避免书写冗长的finally 代码块。此外，上面的代码用一个静态内部类实现线程的功能，使用多线程可以避免一个用户 I/O 操作所产生的中断影响其他用户对服务器的访问，简单的说就是一个用户的输入操作不会造成其他用户的阻塞。当然，上面的代码使用线程池可以获得更好的性能，因为频繁的创建和销毁线程所造成的开销也是不可忽视的。

下面是一段回显客户端测试代码：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class EchoClient {
    public static void main(String[] args) throws Exception {
        Socket client = new Socket("localhost", 6789);
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入内容: ");
        String msg = sc.nextLine();
        sc.close();
        PrintWriter pw = new PrintWriter(client.getOutputStream());
        pw.println(msg);
        pw.flush();
        BufferedReader br = new BufferedReader(new
        InputStreamReader(client.getInputStream()));
        System.out.println(br.readLine());
        client.close();
    }
}

如果希望用 NIO 的多路复用套接字实现服务器，代码如下所示。NIO 的操作虽然带来了更好的性能，但是有些操作是比较底层的，对于初学者来说还是有些难于理解。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class EchoServerNIO {
    private static final int ECHO_SERVER_PORT = 6789;
    private static final int ECHO_SERVER_TIMEOUT = 5000;
    private static final int BUFFER_SIZE = 1024;
    private static ServerSocketChannel serverChannel = null;
    private static Selector selector = null;// 多路复用选择器
    private static ByteBuffer buffer = null;// 缓冲区


public static void main(String[] args) {
    init();
    listen();
}

private static void init() {
    try {
        serverChannel = ServerSocketChannel.open();
        buffer = ByteBuffer.allocate(BUFFER_SIZE);
        serverChannel.socket().bind(new
        InetSocketAddress(ECHO_SERVER_PORT));
        serverChannel.configureBlocking(false);
        selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    } catch (Exception e) {
    throw new RuntimeException(e);
    }

}
private static void listen() {
    while (true) {
        try {
            if (selector.select(ECHO_SERVER_TIMEOUT) != 0) {
                Iterator it =
selector.selectedKeys().iterator();
                while (it.hasNext()) {
                        SelectionKey key = it.next();
                        it.remove();
                        handleKey(key);
            }
        }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
private static void handleKey(SelectionKey key) throws IOException {
    SocketChannel channel = null;
    try {
        if (key.isAcceptable()) {
            ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
            channel = serverChannel.accept();
            channel.configureBlocking(false);
            channel.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
                channel = (SocketChannel) key.channel();
            buffer.clear();
            if (channel.read(buffer) > 0) {
            buffer.flip();
            CharBuffer charBuffer =
CharsetHelper.decode(buffer);
            String msg = charBuffer.toString();
            System.out.println("收到" + channel.getRemoteAddress() + "的消息：" + msg);

channel.write(CharsetHelper.encode(CharBuffer.wrap(msg)));
            } else {
                channel.close();
            }
        }
        } catch (Exception e) {
            e.printStackTrace();
            if (channel != null) {
                channel.close();
            }
        }
        }
}

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public final class CharsetHelper {
    private static final String UTF_8 = "UTF-8";
    private static CharsetEncoder encoder =
Charset.forName(UTF_8).newEncoder();
    private static CharsetDecoder decoder =
Charset.forName(UTF_8).newDecoder();
    private CharsetHelper() {
    }
    public static ByteBuffer encode(CharBuffer in) throws
CharacterCodingException{
        return encoder.encode(in);
    }
    public static CharBuffer decode(ByteBuffer in) throws
CharacterCodingException{
        return decoder.decode(in);
    }
}

---

73、XML 文档定义有几种形式？它们之间有何本质区别？解析XML 文档有哪几种方式？

        XML 文档定义分为 DTD 和 Schema 两种形式，二者都是对 XML 语法的约束，其本质区别在于 Schema 本身也是一个 XML 文件，可以被 XML 解析器解析，而且可以为 XML 承载的数据定义类型，约束能力较之 DTD 更强大。对 XML 的解析主要有 DOM（文档对象模型，Document Object Model）、SAX（Simple API for XML）和 StAX（Java 6 中引入的新的解析 XML 的方式，Streaming API for XML），其中 DOM 处理大型文件时其性能下降的非常厉害，这个问题是由 DOM 树结构占用的内存较多造成的，而且 DOM 解析方式必须在解析文件之前把整个文档装入内存，适合对 XML 的随机访问（典型的用空间换取时间的策略）；SAX 是事件驱动型的 XML 解析方式，它顺序读取 XML 文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过事件回调代码来处理 XML 文件，适合对 XML 的顺序访问；顾名思义，StAX 把重点放在流上，实际上 StAX 与其他解析方式的本质区别就在于应用程序能够把 XML 作为一个事件流来处理。将 XML 作为一组事件来处理的想法并不新颖（SAX 就是这样做的），但不同之处在于 StAX 允许应用程序代码把这些事件逐个拉出来，而不用提供在解析器方便时从解析器中接收事件的处理程序。

---

74、你在项目中哪些地方用到了 XML？

        XML 的主要作用有两个方面：数据交换和信息配置。

        在做数据交换时，XML 将数据用标签组装成起来，然后压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再从 XML 文件中还原相关信息进行处理，XML 曾经是异构系统间交换数据的事实标准，但此项功能几乎已经被 JSON（JavaScript Object Notation）取而代之。当然，目前很多软件仍然使用 XML 来存储配置信息，我们在很多项目中通常也会将作为配置信息的硬代码写在 XML 文件中，Java 的很多框架也是这么做的，而且这些框架都选择了 dom4j 作为处理 XML 的工具，因为 Sun 公司的官方API 实在不怎么好用。

补充：现在有很多时髦的软件（如 Sublime）已经开始将配置文件书写成 JSON格式，我们已经强烈的感受到 XML 的另一项功能也将逐渐被业界抛弃。

---

要想了解更多：

千题千解·Java面试宝典_时光の尘的博客-CSDN博客