对于BIO通道的程序来讲，建立起SSLServerSocket之后，后续的工作就和普通的ServerSocket没有什么区别了，这是因为JDK中通过JSSE的API，封装了SSL通道的实现逻辑，否则，类似于C程序员如果想要编写一个https的加密程序，那他基本得累个半死，所以，我们应该感谢JAVA。
对于NIO通道来讲，我们一贯的思维也是存在一个SSLServerSocketChannel，然后注册到selector中，后续的操作也和普通的ServerSocketChannel没什么区别了，但是，并不存在一个SSLServerSocketChannel，关于这一点，JSSE的官方的Reference Guide中：
翻译出来的原因主要有一下两点：
1.因为JDK类继承限制，无法搞出一个SSLServerSocketChannel，如果需要搞出这样的一个类，需要在源码和API中大动干戈。
2.其次，JSSE的框架设计不想因为封装出一个SSLServerSocketChannel，就将NIO的灵活多变，并且高性能的优势给抹掉。
因此，基于上述的原因，最终JSSE在NIO通道中并没有SSLServerSocketChannel，而是采用NIO + SSLEngine的方式进行实现。
NIO的selector体系这里就不再说了，也即是ServerSocketChannel注册到Selector中，然后进行轮询，如果事件发生了，SelectionKey就被遍历出来,然后判断监听的是register事件，还是read/write事件，事件触发后，将socket的数据读取到缓冲区中。这是NIO的思路，而如果在NIO中使用SSL，也是延续这样的一个套路，不用做任何的改变.
当read/write事件发生之后，普通的socket直接就开始读取数据了，这个时候SSLEngine就开始工作了，首先SSLEngine会调用beginHandShake开始准备握手，然后执行握手，握手的工作是需要通过编程，调用SSLEngine的出栈和入栈来完成的，看下面的一个图：
你可以认为SSLEngine相当于一个黑盒子，它的内部封装了SSL握手，会话等各种协议实现。而我们看到上面的四个蓝色的buffer，左面的两个是应用程序中定义的buffer，供应用程序使用的，右面的两个是需要从socket缓冲区或者socketchannel接收数据并存放的buffer，用于缓存使用的；SSLEngine的一共两个操作，一个是wrap，叫做出栈，发出的出，从应用的buffer中，到网络缓冲区的buffer中，SSLEngine起到的是转接的作用，相反的是unwrap，数据从网络缓冲区流入到应用程序中。
我们为什么要了解SSLEngine这样的一个架构呢？
因为NIO方式的SSL交互，必须要通过SSLEngine来实现，甚至是握手也需要通过这种方法来实现，我们需要编程调用wrap和unwrap，并根据出栈和入栈是否成功，和下一步的需要做的动作，再执行什么动作。
判断的依据是两个状态：
第一个是SSLEngineResult.HandShakeStatus：
这个状态指示，当每一次SSLEngine的wrap或者unwrap之后下一步应该干什么。
例如NEED_WRAP状态，相当于下一步我们需要执行wrap；如果状态是NEED_UNWRAP状态，那么下一步应该执行unwrap；NOT_HANDSHAKING说明握手没有成功，应该抛出异常；如果是是NEED_TASK状态，SSL协议中定义了一些耗时比较长的操作，需要执行delegate操作，这里应该开启一个线程，将这个耗时比较长的操作给执行了，例如CRL的远程校验。
这里可以看到，我们编程的时候，应该会有一个while循环，因为SSL的握手协议不是一下子就完成的，需要客户端和服务器端反复的进行交互，这里面会不断的通过SSLEngine进行wrap和unwrap等其它的操作；
其次，需要对上面的这几种状态进行条件判断，可以使用case语句。
还有一个状态标识是SSLEngineResult.Status
这个属性是指示wrap或者unwrap方法是否执行成功和失败的，可以看到上面，如果buffer字节数没有足够的空间，就会报overflow，因此，对于这个状态的判断，通常出现在异常处理和边界检验中。
我们来看一个例子：
public class SSLHandshakeServer {
private static Logger logger = Logger.getLogger(SSLHandshakeServer.class.getName());
private SocketChannel sc;//channel
private SSLEngine sslEngine;//SSLEngine引擎
private Selector selector;//NIO通道
private ByteBuffer myNetData;
private ByteBuffer myAppData;
private ByteBuffer peerNetData;
private ByteBuffer peerAppData;//四个buffer缓冲区
private ByteBuffer dummy = ByteBuffer.allocate(0);
private HandshakeStatus hsStatus;//SSLEngineResult.HandShakeStatus
private Status status;//SSLEngineResult.Status
public void run() throws Exception {
char[] password = "123456".toCharArray();
KeyStore keyStore = KeyStore.getInstance("JKS");
InputStream in = this.getClass().getResourceAsStream("serverkeystore");
keyStore.load(in, password);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(keyStore, password);
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(kmf.getKeyManagers(), null, null);
sslEngine = sslContext.createSSLEngine();
sslEngine.setUseClientMode(false);
SSLSession session = sslEngine.getSession();//初始化SSLEngine
myAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
myNetData = ByteBuffer.allocate(session.getPacketBufferSize());
peerAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
peerNetData = ByteBuffer.allocate(session.getPacketBufferSize());
peerNetData.clear();//定义四个缓冲区
//NIO的流程
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
selector = Selector.open();
ServerSocket serverSocket = serverChannel.socket();
serverSocket.bind(new InetSocketAddress(443));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
logger.info("Server listens on port 443... ...");
while (true) {
selector.select();
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey selectionKey = it.next();
it.remove();
handleRequest(selectionKey);//当SelectionKey有事件进来后，进行NIO的处理
}
}
}
private void handleRequest(SelectionKey key) throws Exception {
if (key.isAcceptable()) {
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel channel = ssc.accept();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);//当rigister事件发生后，下一步就是读了
} else if (key.isReadable()) {
sc = (SocketChannel) key.channel();
logger.info("Server handshake begins... ...");
//从这里，SSL的交互就开始了
sslEngine.beginHandshake();//开始begin握手
hsStatus = sslEngine.getHandshakeStatus();
doHandshake();//开始进行正式的SSL握手
if (hsStatus == HandshakeStatus.FINISHED) {//当握手阶段告一段落，握手完毕
key.cancel();
sc.close();
}
logger.info("Server handshake completes... ...");
}
}
//这个方法就是服务器端的握手
private void doHandshake() throws IOException {
SSLEngineResult result;
while (hsStatus != HandshakeStatus.FINISHED) {//一个大的while循环，
logger.info("handshake status: " + hsStatus);
switch (hsStatus) {//判断handshakestatus，下一步的动作是什么？
case NEED_TASK://指定delegate任务
Runnable runnable;
while ((runnable = sslEngine.getDelegatedTask()) != null) {
runnable.run();//因为耗时比较长，所以需要另起一个线程
}
hsStatus = sslEngine.getHandshakeStatus();
break;
case NEED_UNWRAP://需要进行入站了，说明socket缓冲区中有数据包进来了
int count = sc.read(peerNetData);//从socket中进行读取
if (count < 0) {
logger.info("no data is read for unwrap.");
break;
} else {
logger.info("data read: " + count);
}
peerNetData.flip();
peerAppData.clear();
do {
result = sslEngine.unwrap(peerNetData, peerAppData);//调用SSLEngine进行unwrap操作
logger.info("Unwrapping:\n" + result);
// During an handshake renegotiation we might need to
// perform
// several unwraps to consume the handshake data.
} while (result.getStatus() == SSLEngineResult.Status.OK//判断状态
&& result.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_UNWRAP
&& result.bytesProduced() == 0);
if (peerAppData.position() == 0 && result.getStatus() == SSLEngineResult.Status.OK
&& peerNetData.hasRemaining()) {
result = sslEngine.unwrap(peerNetData, peerAppData);
logger.info("Unwrapping:\n" + result);
}
hsStatus = result.getHandshakeStatus();
status = result.getStatus();
assert status != status.BUFFER_OVERFLOW : "buffer not overflow." + status.toString();
// Prepare the buffer to be written again.
peerNetData.compact();
// And the app buffer to be read.
peerAppData.flip();
break;
case NEED_WRAP://需要出栈
myNetData.clear();
result = sslEngine.wrap(dummy, myNetData);//意味着从应用程序中发送数据到socket缓冲区中，先wrap
hsStatus = result.getHandshakeStatus();
status = result.getStatus();
while (status != Status.OK) {
logger.info("status: " + status);
switch (status) {
case BUFFER_OVERFLOW:
break;
case BUFFER_UNDERFLOW:
break;
}
}
myNetData.flip();
sc.write(myNetData);//最后再发送socketchannel
break;
}
}
}
public static void main(String[] args) throws Exception {
new SSLHandshakeServer().run();
}
}
总结一下，NIO+SSLEngine的这种方式，可以说是高度的开放，利用SSLEngine这个工具，来完成握手这个过程，而握手的过程需要通过编程和控制状态来实现，实际上，这也是JDK的API设计的缺陷之一，没有封装的好，让我们程序员写这些莫名其妙的代码，而JDK说加不了SSLServerSocketChannel其实应该就是一个说辞而已，不过，既然如此，那我们只需按照他的要求进行编程，也能达到NIO中SSL通道的效果。
SSLEngine也可以用在BIO中，也就是在BIO你也可以这么搞，但是因为BIO中有SSLServerSocket，这个类，一个类就可以搞定了，握手的内部实现和流程控制都在这个JDK的内部来实现，作为程序员完全不用掌握那么多。
Tomcat中的代码基本上和上述的代码类似，在下一节中，我们会重点就这块分析一下Tomcat的NIO通道中的SecurityNioChannel的实现的，非常的相似。
上面的程序握手完毕就拉倒了，双方没有继续发送数据，当然你可以在双方成功握手之后，继续使用SSLEngine来发送数据，而再次发送的数据就是进行加密传输的了，这些都是SSLEngine的实现了，需要分析JDK的代码了。
最后给出上面的服务器端对应的客户端程序，可以比对一下，其实差不太多：
public class SSLHandshakeClient {
private static Logger logger = Logger.getLogger(SSLHandshakeClient.class.getName());
private SocketChannel sc;
private SSLEngine sslEngine;
private Selector selector;
private HandshakeStatus hsStatus;
private Status status;
private ByteBuffer myNetData;
private ByteBuffer myAppData;
private ByteBuffer peerNetData;
private ByteBuffer peerAppData;
private ByteBuffer dummy = ByteBuffer.allocate(0);
public void run() throws Exception {
char[] password = "123456".toCharArray();
KeyStore trustStore = KeyStore.getInstance("JKS");
InputStream in = this.getClass().getResourceAsStream("clienttruststore.jks");
trustStore.load(in, password);
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(trustStore);
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, tmf.getTrustManagers(), null);
sslEngine = sslContext.createSSLEngine();
sslEngine.setUseClientMode(true);
SSLSession session = sslEngine.getSession();
myAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
myNetData = ByteBuffer.allocate(session.getPacketBufferSize());
peerAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
peerNetData = ByteBuffer.allocate(session.getPacketBufferSize());
peerNetData.clear();
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);
selector = Selector.open();
channel.register(selector, SelectionKey.OP_CONNECT);
channel.connect(new InetSocketAddress("localhost", 443));
sslEngine.beginHandshake();
hsStatus = sslEngine.getHandshakeStatus();
while (true) {
selector.select();
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey selectionKey = it.next();
it.remove();
handleSocketEvent(selectionKey);
}
}
}
private void handleSocketEvent(SelectionKey key) throws IOException {
if (key.isConnectable()) {
sc = (SocketChannel) key.channel();
if (sc.isConnectionPending()) {
sc.finishConnect();
}
doHandshake();
sc.register(selector, SelectionKey.OP_READ);
}
if (key.isReadable()) {
sc = (SocketChannel) key.channel();
doHandshake();
if (hsStatus == HandshakeStatus.FINISHED) {
logger.info("Client handshake completes... ...");
key.cancel();
sc.close();
}
}
}
private void doHandshake() throws IOException {
SSLEngineResult result;
int count = 0;
while (hsStatus != HandshakeStatus.FINISHED) {
logger.info("handshake status: " + hsStatus);
switch (hsStatus) {
case NEED_TASK:
Runnable runnable;
while ((runnable = sslEngine.getDelegatedTask()) != null) {
runnable.run();
}
hsStatus = sslEngine.getHandshakeStatus();
break;
case NEED_UNWRAP:
count = sc.read(peerNetData);
if (count < 0) {
logger.info("no data is read for unwrap.");
break;
} else {
logger.info("data read: " + count);
}
peerNetData.flip();
peerAppData.clear();
do {
result = sslEngine.unwrap(peerNetData, peerAppData);
logger.info("Unwrapping:\n" + result);
// During an handshake renegotiation we might need to
// perform
// several unwraps to consume the handshake data.
} while (result.getStatus() == SSLEngineResult.Status.OK
&& result.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_UNWRAP
&& result.bytesProduced() == 0);
if (peerAppData.position() == 0 && result.getStatus() == SSLEngineResult.Status.OK
&& peerNetData.hasRemaining()) {
result = sslEngine.unwrap(peerNetData, peerAppData);
logger.info("Unwrapping:\n" + result);
}
hsStatus = result.getHandshakeStatus();
status = result.getStatus();
assert status != status.BUFFER_OVERFLOW : "buffer not overflow." + status.toString();
// Prepare the buffer to be written again.
peerNetData.compact();
// And the app buffer to be read.
peerAppData.flip();
break;
case NEED_WRAP:
myNetData.clear();
result = sslEngine.wrap(dummy, myNetData);
hsStatus = result.getHandshakeStatus();
status = result.getStatus();
while (status != Status.OK) {
logger.info("status: " + status);
switch (status) {
case BUFFER_OVERFLOW:
break;
case BUFFER_UNDERFLOW:
break;
}
}
myNetData.flip();
count = sc.write(myNetData);
if (count <= 0) {
logger.info("No data is written.");
} else {
logger.info("Written data: " + count);
}
break;
}
}
}
public static void main(String[] args) throws Exception {
new SSLHandshakeClient().run();
}
}