Java 개발: network

레이블이 network인 게시물을 표시합니다. 모든 게시물 표시

2014년 2월 27일 목요일

DatagramPacket 재사용

참고: http://www.coderanch.com/t/206099/sockets/java/DatagramPacket-getLength-refresh

아래와 같이 DatagramPacket 을 한번 생성하고
DatagramPacket pack = new DatagramPacket(data, data.length);

매번 pack.setLength(data.length); 로 길이를 초기화해주면 다음에도 pack 을 사용할 수 있다.

2012년 9월 13일 목요일

SocketChannel 이용한 non-blocking server/client 예제

시간: 오전 3:51

예제는 SocketChannel 을 이용한 non-blocking 서버와 클라이언트 입니다.
서버는 여러개의 클라이언트 접속을 처리합니다.
클라이언트는 서버에 메시지를 전달할 수 있고 서버는 전달받은 메시지를 화면에 출력합니다.

실행 예)

- 서버측 -

Server :: started
Server :: waiting for accept
Server :: accepted - client [java.nio.channels.SocketChannel[connected local=/127.0.0.1:9891 remote=/127.0.0.1:61334]]
Client :: started
From Client : Hello
From Client : Hello World

- 클라이언트 측 -

Client :: started
Client :: connected
From Server : Welcome
Hello
[write :: text : Hello / len : 5]
Hello World
[write :: text : Hello World / len : 11]

폴더 구조:

소스 코드:

Abortable.java : 간단하게 종료를 나타내는 클래스를 만들었습니다.

package com.tcpsample;

public class Abortable {
    public boolean done = false;
    
    public Abortable() {
        init();
    }
    
    public void init() {
        done = false;
    }
    
    public boolean isDone() {
        return done;
    }
}

Server.java
- ServerThread 클래스는 accept 처리하는 스레드입니다.
- ClientHandlerThread 클래스는 접속한 client 를 처리하는 스레드입니다.

package com.tcpsample;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 *
 */
public class Server {
    
    public static final int PORT_NUMBER = 9891;
    
    private Abortable abortable;
    private ServerThread serverThread;
    
    /**
     * 
     */
    public Server() {
        abortable = new Abortable();
    }
    
    /**
     * 
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        
        
        Server server = new Server();
        server.start();
        
        Thread.sleep(500);
        
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        reader.readLine();
        
        server.stop();

        System.out.println("BYE");
    }
    
    /**
     * start server
     */
    public void start() {
        
        abortable.init();
        
        if (serverThread == null || !serverThread.isAlive()) {
            serverThread = new ServerThread(abortable);
            serverThread.start();
        }
    }
    
    /**
     * stop server
     */
    public void stop() {
        
        abortable.done = true;
        
        if (serverThread != null && serverThread.isAlive()) {
            serverThread.interrupt();
        }
        
    }
    
    /**
     *
     */
    public class ServerThread extends Thread {
        
        private Abortable abortable;
        private List<Thread> clientList = new ArrayList<Thread>();
        
        public ServerThread(Abortable abortable) {
            this.abortable = abortable;
        }

        @Override
        public void run() {
            super.run();
            
            ServerSocketChannel server = null;
            Selector selector = null;
            
            try {
                
                System.out.println("Server :: started");
                
                server = ServerSocketChannel.open();
                server.socket().bind(new InetSocketAddress("", PORT_NUMBER));
                server.configureBlocking(false);
                
                selector = Selector.open();
                server.register(selector, SelectionKey.OP_ACCEPT);
                
                System.out.println("Server :: waiting for accept");
                
                while (!Thread.interrupted() && !abortable.isDone()) {
                    selector.select(3000);
                    
                    Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                    while (iter.hasNext()) {
                        
                        SelectionKey key = iter.next();
                        if (key.isAcceptable()) {
                            
                            SocketChannel client = server.accept();
                            
                            if (client != null) {
                                System.out.printf("Server :: accepted - client [%s]\n", client);
                                Thread t = new ClientHandlerThread(abortable, client);
                                t.start();
                                clientList.add(t);
                            }
                        }
                    }
                }
                
            } catch (Exception e) {
                
                e.printStackTrace();
                
            } finally {
                
                for (Thread t : clientList) {
                    
                    if (t != null && t.isAlive())
                        t.interrupt();
                    
                    try {
                        t.join(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                if (server != null) {
                    
                    try {
                        server.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                System.out.println("Server :: done");
                
            }
        }
    }

    /**
     *
     */
    public class ClientHandlerThread extends Thread {
        
        private Abortable abortable;
        private SocketChannel client;
        
        public ClientHandlerThread(Abortable abortable, SocketChannel client) {
            this.abortable = abortable;
            this.client = client;
        }

        @Override
        public void run() {
            super.run();
            
            Selector selector = null;
            Charset cs = Charset.forName("UTF-8");
            
            boolean done = false;
            
            try {
                
                System.out.println("Client :: started");
                
                client.configureBlocking(false);
                selector = Selector.open();
                
                client.register(selector, SelectionKey.OP_READ);
                
                // send welcome message
                client.write(ByteBuffer.wrap(new String("Welcome").getBytes()));
                
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                
                while (!Thread.interrupted() && !abortable.isDone() && !done) {
                    selector.select(3000);
                    
                    Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                    while (!abortable.isDone() && iter.hasNext() && !done) {
                        SelectionKey key = iter.next();
                        if (key.isReadable()) {
                            int len = client.read(buffer);
                            if (len < 0) {
                                done = true;
                                break;
                            } else if (len == 0) {
                                continue;
                            }
                            buffer.flip();
                            
                            CharBuffer cb = cs.decode(buffer);
                            
                            System.out.printf("From Client : ");
                            while (cb.hasRemaining()) {
                                System.out.printf("%c", cb.get());
                            }
                            System.out.println();
                            
                            buffer.compact();
                        }
                    }
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                
                if (client != null) {
                    try {
                        client.socket().close();
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                System.out.println("Client :: bye");
            }
        }
    }
}

Client.java
- ClientThread 클래스는 서버에 접속하고 통신하는 스레드입니다.

package com.tcpsample;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;

/**
 *
 */
public class Client {
    
    private Abortable abortable = new Abortable();
    private ClientThread clientThread;
    
    /**
     * 
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        
        Client client = new Client();
        client.start("127.0.0.1", Server.PORT_NUMBER);
        
        Thread.sleep(500);

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        while (true) {
            String line = reader.readLine();
            
            if (line.equals("quit"))
                break;
            
            try {
                client.sayToServer(line);
            } catch (Exception e) {
                e.printStackTrace();
                break;
            }
            
        }
        
        client.stop();
         
        System.out.println("BYE");
    }
    
    /**
     * start client
     * 
     * @param host
     * @param port
     */
    public void start(String host, int port) {
        
        abortable.init();
        
        
        if (clientThread == null || !clientThread.isAlive()) {
            clientThread = new ClientThread(abortable, host, port);
            clientThread.start();
        }
    }
    
    /**
     * stop client
     */
    public void stop() {
        
        abortable.done = true;
        
        if (clientThread != null && clientThread.isAlive()) {
            clientThread.interrupt();
        }
        
    }
    
    /**
     * 
     * @param text
     * @throws IOException
     */
    public void sayToServer(String text) throws IOException {
        clientThread.sayToServer(text);
    }
    
    /**
     *
     */
    public class ClientThread extends Thread {
        
        private Abortable abortable;
        private String host;
        private int port;
        private SocketChannel client;
        
        /**
         * 
         * @param abortable
         * @param host
         * @param port
         */
        public ClientThread(Abortable abortable, String host, int port) {
            this.abortable = abortable;
            this.host = host;
            this.port = port;
        }

        /**
         * 
         * @param text
         * @throws IOException 
         */
        public void sayToServer(String text) throws IOException {
            int len = client.write(ByteBuffer.wrap(text.getBytes()));
            System.out.printf("[write :: text : %s / len : %d]\n", text, len);
        }

        @Override
        public void run() {
            super.run();
            
            boolean done = false;
            Selector selector = null;
            Charset cs = Charset.forName("UTF-8");
            
            try {
                
                System.out.println("Client :: started");
                
                client = SocketChannel.open();
                client.configureBlocking(false);
                client.connect(new InetSocketAddress(host, port));
                
                selector = Selector.open();
                client.register(selector, SelectionKey.OP_READ);
                
                while (!Thread.interrupted() && !abortable.isDone() && !client.finishConnect()) {
                    Thread.sleep(10);
                }
                
                System.out.println("Client :: connected");
                
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                
                while (!Thread.interrupted() && !abortable.isDone() && !done) {
                    
                    selector.select(3000);
                    
                    Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                    while (!Thread.interrupted() && !abortable.isDone() && !done && iter.hasNext()) {
                        SelectionKey key = iter.next();
                        if (key.isReadable()) {
                            int len = client.read(buffer);
                            if (len < 0) {
                                System.out.println("Client :: server closed");
                                done = true;
                                break;
                            } else if (len == 0) {
                                continue;
                            }
                            buffer.flip();
                            
                            CharBuffer cb = cs.decode(buffer);
                            
                            System.out.printf("From Server : ");
                            while (cb.hasRemaining()) {
                                System.out.printf("%c", cb.get());
                            }
                            System.out.println();
                            
                            buffer.compact();
                        }
                    }
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                
                if (client != null) {
                    try {
                        client.socket().close();
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                System.out.println("Client :: done");
            }
            
        }
    }
}

2012년 3월 19일 월요일

HTTPS 통신

시간: 오후 11:06

참고 - http://docs.oracle.com/javase/6/docs/technotes/guides/security/jsse/JSSERefGuide.html

프로젝트명: HTTPSPractice

파일 구성:

- HttpsClientWithCustomCert.java - 사용자가 만든 인증서를 이용한 서버 인증
- HttpsClientWithDefaultCACert.java - 공인 인증된 인증서로 서버 인증
- HttpsClientWithoutValidation.java - 인증 없이 서버 접속
- SimpleHttpsServer.java - 사용자가 만든 인증키를 이용하는 간단한 HTTPS 서버
- keystore.jks - 서버(SimpleHttpsServer) 에서 사용하는 인증키 저장소
- truststore.jks - 클라이언트(HttpsClientWithCustomCert) 에서 서버 인증시 사용하는 인증서 저장소

다음과 같은 순서로 설명
1. HttpsURLConnection 을 이용한 접속 (인증 과정 없음)
2. 공인 인증된 인증서로 서버 인증
3. 사용자가 만든 인증서로 서버 인증

1. HttpsURLConnection 을 이용한 접속 (인증 과정 없음)

인증 과정을 결정하는 부분은 SSLContext.init() 함수이다.
아래 소스에는 init() 함수에 모두 null 을 집어 넣음으로써 인증 과정을 무시하고 서버의 내용물을 받는다.

소스:

package com.test.https.practice;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;


/**
 * 
 */
public class HttpsClientWithoutValidation {
 
 /**
  * 
  * @param urlString
  * @throws IOException
  * @throws NoSuchAlgorithmException
  * @throws KeyManagementException
  */
 public void getHttps(String urlString) throws IOException, NoSuchAlgorithmException, KeyManagementException {
  
  // Get HTTPS URL connection
  URL url = new URL(urlString);  
  HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
  
  // Set Hostname verification
  conn.setHostnameVerifier(new HostnameVerifier() {
   @Override
   public boolean verify(String hostname, SSLSession session) {
    // Ignore host name verification. It always returns true.
    return true;
   }
   
  });
  
  // SSL setting
  SSLContext context = SSLContext.getInstance("TLS");
  context.init(null, null, null);  // No validation for now
  conn.setSSLSocketFactory(context.getSocketFactory());
  
  // Connect to host
  conn.connect();
  conn.setInstanceFollowRedirects(true);
  
  // Print response from host
  InputStream in = conn.getInputStream();
  BufferedReader reader = new BufferedReader(new InputStreamReader(in));
  String line = null;
  while ((line = reader.readLine()) != null) {
   System.out.printf("%s\n", line);
  }
  
  reader.close();
 }
 
 /**
  * 
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
  HttpsClientWithoutValidation test = new HttpsClientWithoutValidation();
  test.getHttps("https://www.google.com");
 }
}

결과:

2. 공인 인증된 인증서로 서버 인증

SSLContext.init() 함수의 두번째 인자에 X509TrustManager 를 선언하여 집어 넣었다.
그리고 JRE 를 설치하면 기본적으로 [JRE 경로]/lib/security/cacerts 라는 파일명의 공인 인증된 인증서 저장소 파일이 있다.
해당 인증서 저장소를 이용하여 서버의 인증서를 검사하게 하였다.

소스:

package com.test.https.practice;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

/**
 *
 */
public class HttpsClientWithDefaultCACert {
 
 /**
  * 
  * @param urlString
  * @throws IOException
  * @throws NoSuchAlgorithmException
  * @throws KeyManagementException
  */
 public void getHttps(String urlString) throws IOException, NoSuchAlgorithmException, KeyManagementException {
  
  // Get HTTPS URL connection
  URL url = new URL(urlString);  
  HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
  
  // Set Hostname verification
  conn.setHostnameVerifier(new HostnameVerifier() {
   @Override
   public boolean verify(String hostname, SSLSession session) {
    // Ignore host name verification. It always returns true.
    return true;
   }
   
  });
  
  // SSL setting
  SSLContext context = SSLContext.getInstance("TLS");
  context.init(null, new TrustManager[] { new X509TrustManager() {

   @Override
   public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    // client certification check
   }

   @Override
   public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    
    // Server certification check
    
    try {
     
     // Get trust store
     KeyStore trustStore = KeyStore.getInstance("JKS");
     String cacertPath = System.getProperty("java.home") + "/lib/security/cacerts"; // Trust store path should be different by system platform.
     trustStore.load(new FileInputStream(cacertPath), "changeit".toCharArray()); // Use default certification validation
     
     // Get Trust Manager
     TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
     tmf.init(trustStore);
     TrustManager[] tms = tmf.getTrustManagers();
     ((X509TrustManager)tms[0]).checkServerTrusted(chain, authType);
     
    } catch (KeyStoreException e) {
     e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
     e.printStackTrace();
    } catch (IOException e) {
     e.printStackTrace();
    }
    
   }

   @Override
   public X509Certificate[] getAcceptedIssuers() {
    return null;
   }
  } }, null);
  conn.setSSLSocketFactory(context.getSocketFactory());
  
  // Connect to host
  conn.connect();
  conn.setInstanceFollowRedirects(true);
  
  // Print response from host
  InputStream in = conn.getInputStream();
  BufferedReader reader = new BufferedReader(new InputStreamReader(in));
  String line = null;
  while ((line = reader.readLine()) != null) {
   System.out.printf("%s\n", line);
  }
  
  reader.close();
 }
 
 /**
  * 
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
  HttpsClientWithDefaultCACert test = new HttpsClientWithDefaultCACert();
  test.getHttps("https://www.google.com");
 }
}

결과:

3. 사용자가 만든 인증서로 서버 인증

우선 인증키 저장소와 인증서 저장소를 만들어 보자.
Portecle 라는 툴을 사용했다.

3.1. 인증키 저장소 만들기(keystore.jks)

3.2. 인증키에서 인증서 추출

3.3. 인증서 저장소 만들기(truststore.jks)

서버는 지정된 인증키 저장소를 이용해 클라이언트에 자신을 인증하는 키를 보내게 된다. 인증과정이 성공하면 클라이언트에 html 내용물을 전달하고 종료한다.
클라이언트는 지정된 인증서 저장소를 이용해 서버를 인증한다. 인증과정이 성공하면 서버로 부터 html 내용물을 전달받는다.

서버 소스:
참고 - http://www.java2s.com/Tutorial/Java/0490__Security/SSLContextandKeymanager.htm

package com.test.https.practice;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

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

public class SimpleHttpsServer {
 
 public void run(int port) throws NoSuchAlgorithmException, KeyManagementException, IOException, KeyStoreException, CertificateException, UnrecoverableKeyException {
  
  // create ssl context
  SSLContext context = SSLContext.getInstance("TLS");
  
  // set key store
  KeyStore keyStore = KeyStore.getInstance("JKS");
  keyStore.load(new FileInputStream("keystore.jks"), "changeit".toCharArray());
  KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
  kmf.init(keyStore, "changeit".toCharArray());
  context.init(kmf.getKeyManagers(), null, null);
  
  // create ssl socket
  SSLServerSocketFactory factory = context.getServerSocketFactory();
  SSLServerSocket socket = (SSLServerSocket)factory.createServerSocket(port);
  SSLSocket client = (SSLSocket)socket.accept();
  InputStream in = client.getInputStream();
  OutputStream out = client.getOutputStream();
  
  // read from client
  BufferedReader reader = new BufferedReader(new InputStreamReader(in));
  reader.readLine();
  
  // write to client
  BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));
  writer.write("HTTP/1.0 200 OK");
  writer.newLine();
  writer.write("Content-Type: text/html");
  writer.newLine();
  writer.newLine();
  writer.write("<html><head><title>Hello</title></head><body>Hellow!</body></html>");
  writer.flush();
  
  // close
  writer.close();
  reader.close();
  client.close();
 }
 
 /**
  * 
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
  SimpleHttpsServer server = new SimpleHttpsServer();
  server.run(9999);
 }
}

클라이언트 소스:

package com.test.https.practice;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

public class HttpsClientWithCustomCert {
 
 /**
  * 
  * @param urlString
  * @throws IOException
  * @throws NoSuchAlgorithmException
  * @throws KeyManagementException
  */
 public void getHttps(String urlString) throws IOException, NoSuchAlgorithmException, KeyManagementException {
  
  // Get HTTPS URL connection
  URL url = new URL(urlString);  
  HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
  
  // Set Hostname verification
  conn.setHostnameVerifier(new HostnameVerifier() {
   @Override
   public boolean verify(String hostname, SSLSession session) {
    // Ignore host name verification. It always returns true.
    return true;
   }
   
  });
  
  // SSL setting
  SSLContext context = SSLContext.getInstance("TLS");
  context.init(null, new TrustManager[] { new X509TrustManager() {

   @Override
   public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    // client certification check
   }

   @Override
   public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    
    // Server certification check
    
    try {
     
     // Get trust store
     KeyStore trustStore = KeyStore.getInstance("JKS");
     trustStore.load(new FileInputStream("truststore.jks"), "changeit".toCharArray()); // Use default certification validation
     
     // Get Trust Manager
     TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
     tmf.init(trustStore);
     TrustManager[] tms = tmf.getTrustManagers();
     ((X509TrustManager)tms[0]).checkServerTrusted(chain, authType);
     
    } catch (KeyStoreException e) {
     e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
     e.printStackTrace();
    } catch (IOException e) {
     e.printStackTrace();
    }
    
   }

   @Override
   public X509Certificate[] getAcceptedIssuers() {
    return null;
   }
  } }, null);
  conn.setSSLSocketFactory(context.getSocketFactory());
  
  // Connect to host
  conn.connect();
  conn.setInstanceFollowRedirects(true);
  
  // Print response from host
  InputStream in = conn.getInputStream();
  BufferedReader reader = new BufferedReader(new InputStreamReader(in));
  String line = null;
  while ((line = reader.readLine()) != null) {
   System.out.printf("%s\n", line);
  }
  
  reader.close();
 }
 
 /**
  * 
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
  HttpsClientWithCustomCert test = new HttpsClientWithCustomCert();
  test.getHttps("https://127.0.0.1:9999");
 }
}

결과:

2011년 7월 25일 월요일

InvalidKeyException: Illegal key size 문제

시간: 오후 7:43

JKS 에서 BKS 로 변형하는데 InvalidKeyException: Illegal key size 에러가 발생했다.

Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy 파일을 설치하여 해결하였다.

참고: http://stackoverflow.com/questions/3862800/invalidkeyexception-illegal-key-size

다운로드: http://www.oracle.com/technetwork/java/javase/downloads/index.html

위 링크로 들어가 맨 아래 보면 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6 를 다운로드 받을 수 있다.

설치:

압축을 풀고

/lib/security 에 파일을 복사한다.

기존에 같은 이름의 파일들을 덮어쓴다.

2011년 6월 13일 월요일

html 내용 출력

시간: 오후 5:46

BufferedReader 를 이용하여 html 내용 출력

package http.test;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;

public class Reader {
 public static void main(String[] args) throws Exception {
  URL url = new URL("http://www.w3.org/");
  InputStream is = url.openStream();
  BufferedReader reader = new BufferedReader(new InputStreamReader(is, "utf-8"));
  String line = null;
  while ((line = reader.readLine()) != null) {
   System.out.println(line);
  }
  is.close();
 }
}

페이지