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

import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLSocket;

public class Simple_SSLServerSocket{
// 定义了监听端口号
private final static int LISTEN_PORT=54321;

public static void main(String args[]) throws IOException{
SSLServerSocket serverSocket=null;
SSLSocket clientSocket=null;
// 使用默认方式获取套接字工厂实例
SSLServerSocketFactory ssf=(SSLServerSocketFactory)SSLServerSocketFactory.getDefault();

try{
serverSocket=(SSLServerSocket)ssf.createServerSocket(LISTEN_PORT);
// 设置不需要验证客户端身份
serverSocket.setNeedClientAuth(false);
System.out.println("SSLServer is listening on "+LISTEN_PORT+" port");
// 循环监听端口，如果有客户端连入就新开一个线程与之通信
while(true){
// 接受新的客户端连接
clientSocket=(SSLSocket)serverSocket.accept();
ClientConnection clientConnection=new ClientConnection(clientSocket);
// 启动一个新的线程
Thread clientThread=new Thread(clientConnection);
System.out.println("Client "+clientThread.getId()+" is connected");
clientThread.run();
}
}catch(IOException ioExp){
ioExp.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}finally{
serverSocket.close();
}
}
}

class ClientConnection implements Runnable{
private Socket clientSocket=null;

public ClientConnection(SSLSocket sslsocket){
clientSocket=sslsocket;
}

public void run(){
BufferedReader reader=null;
// 将接收到的来自客户端的文字打印出来
try{
reader=new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
while(true){
String line=reader.readLine();
if(line==null){
System.out.println("Communication end.");
break;
}
System.out.println("Receive message: "+line);
}
reader.close();
clientSocket.close();
}catch(IOException ioExp){
ioExp.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
}
}

import java.io.BufferedReader; 
 import java.io.IOException; 
 import java.io.InputStreamReader; 
 import java.io.OutputStreamWriter; 
 import java.io.Writer; 
 import javax.net.ssl.SSLSocket; 
 import javax.net.ssl.SSLSocketFactory; 

public class Simple_SSLSocket{
// 定义要连接的服务器名和端口号
private static final int DEFAULT_PORT=54321;
private static final String DEFAULT_HOST="localhost";
public static void main(String args[]){
SSLSocket socket=null;
// 使用默认的方式获取工厂实例
SSLSocketFactory sf=(SSLSocketFactory)SSLSocketFactory.getDefault();
try{
// 连接服务端的端口，完成握手过程
socket=(SSLSocket)sf.createSocket(DEFAULT_HOST, DEFAULT_PORT);
socket.startHandshake();
System.out.println("Connected to "+DEFAULT_HOST+":"+DEFAULT_PORT+" !");
// 从控制台输入要发送给服务端的文字
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
Writer writer=new OutputStreamWriter(socket.getOutputStream());
// 可以反复向服务端发送消息
boolean done=false;
while (!done) {
System.out.print("Send Message: ");
String line=reader.readLine();
if (line!=null) {
writer.write(line+"\n");
writer.flush();
}else{
done=true;
}
}
socket.close();
}catch (Exception e) {
System.out.println("Connection failed: "+e);
try{
socket.close();
}catch(IOException ioe){}
socket=null;
}
}
}

// 相关的 jks 文件及其密码定义
 private final static String CERT_STORE="D:/test_server_cert.jks"; 
 private final static String CERT_STORE_PASSWORD="Testpassw0rd";
 // 载入 jks 文件
 FileInputStream f_certStore=new FileInputStream(CERT_STORE); 
 KeyStore ks=KeyStore.getInstance("jks"); 
 ks.load(f_certStore, CERT_STORE_PASSWORD.toCharArray()); 
 f_certStore.close(); 

// 创建并初始化证书库工厂
String alg=KeyManagerFactory.getDefaultAlgorithm();
KeyManagerFactory kmFact=KeyManagerFactory.getInstance(alg);
kmFact.init(ks, CERT_STORE_PASSWORD.toCharArray());

KeyManager[] kms=kmFact.getKeyManagers();

// 创建并初始化 SSLContext 实例
SSLContext context=SSLContext.getInstance("SSL");
context.init(kms, null, null);
SSLServerSocketFactory ssf=(SSLServerSocketFactory)context.getServerSocketFactory();

// 相关的 jks 文件及其密码定义
 private final static String TRUST_STORE="D:/test_client_trust.jks"; 
 private final static String TRUST_STORE_PASSWORD="Testpassw0rd";

// 载入 jks 文件
FileInputStream f_trustStore=new FileInputStream(TRUST_STORE);
KeyStore ks=KeyStore.getInstance("jks");
ks.load(f_trustStore, TRUST_STORE_PASSWORD.toCharArray());
f_trustStore.close();

// 创建并初始化信任库工厂
String alg=TrustManagerFactory.getDefaultAlgorithm();
TrustManagerFactory tmFact=TrustManagerFactory.getInstance(alg);
tmFact.init(ks);

TrustManager[] tms=tmFact.getTrustManagers();

// 创建并初始化 SSLContext 实例
SSLContext context=SSLContext.getInstance("SSL");
context.init(null, tms, null);
SSLSocketFactory sf=context.getSocketFactory();

// 使用自定义的 MyTrustManager 产生信任库
 TrustManager[] tms=new TrustManager[]{new MyTrustManager()}; 
……
……
 class MyTrustManager implements X509TrustManager{ 
  // 相关的 jks 文件及其密码定义
  private final static String TRUST_STORE="D:/test_client_trust.jks"; 
  private final static String TRUST_STORE_PASSWORD="Testpassw0rd"; 
  X509TrustManager xtm;
  
  public MyTrustManager() throws Exception { 
    // 载入 jks 文件
    KeyStore ks = KeyStore.getInstance("JKS"); 
    ks.load(new FileInputStream(TRUST_STORE),TRUST_STORE_PASSWORD.toCharArray()); 
    TrustManagerFactory tmf =TrustManagerFactory.getInstance("SunX509", "SunJSSE"); 
    tmf.init(ks);
    TrustManager[] tms = tmf.getTrustManagers();
    // 筛选出 X509 格式的信任证书
    for (int i = 0; i < tms.length; i++) { 
      if (tms[i] instanceof X509TrustManager) { 
        xtm = (X509TrustManager) tms[i]; 
        return; 
      } 
    } 
  }
  // 服务端检验客户端证书的接口
  public void checkClientTrusted(X509Certificate[] chain, String authType) 
throws CertificateException{ 
  }
 // 客户端检验服务端证书的接口
  public void checkServerTrusted(X509Certificate[] chain, String authType) 
throws CertificateException{ 
    try{ 
      xtm.checkServerTrusted(chain, authType); 
    }catch(CertificateException excep){ 
      System.out.println(excep.getMessage()); 
      throw excep; 
    } 
  }
  // 获取可接受的发行者
  public X509Certificate[] getAcceptedIssuers() { 
   //return xtm.getAcceptedIssuers(); 
    return null; 
  } 
 }

String enabled[]=serverSocket.getEnabledCipherSuites(); 
 Set<String> filter = new LinkedHashSet<String>(); 
 for(int i = 0; i < enabled.length; i++) { 
 if(enabled[i].indexOf("anon")<0){ 
 filter.add(enabled[i]); 
 } 
 } 
 serverSocket.setEnabledCipherSuites(filter.toArray(new String[filter.size()]));