lonelycat's cellar

public String getMcodeFromMLB() {         HttpURLConnection uc = null; // 연결용 커넥션         URL url = null;         String sUrl = "http://localhost:8080/MLBServerTest/MLBTest.jsp"; // 연결할 주소         String result = "";                 try {                         url = new URL(sUrl);                         uc = (HttpURLConnection) url.openConnection();                         uc.setDoInput(true);             uc.setDoOutput(true);             uc.setUseCaches(false);             uc.setRequestMethod("POST");             uc.setConnectTimeout(10000);  // 커넥션 타임아웃             uc.setAllowUserInteraction(true);                         // Http Header Setting             uc.setRequestProperty("Content-type", "application/x-www-form-urlencoded;charset=euc-kr");                         // Http Parameter Sending             String partner_id = "O00128";    // CP의 파트너ID             String service_code = "001";    // 각 CP서버에 할당된 코드             String music_code = "00293876";    // MLB에서 조회된 MUSIC_CODE             String content_price = "800";     // 컨텐츠 단가             String content_name = "핑계";     // 컨텐츠가 서비스되는 이름             String content_num = "1";     // 패키지에 포함한 컨텐츠의 갯수. 단일상품일 경우 1, 복합상품일 경우 2이상             String pid = "3102306023";     // PID             String sub_code = "12700000012";     // CP서버가 자체적으로 관리하는 Code(SCID등). 12자리 이하             String carrier_code = "00";     // ASP에 서비스하는 캐리어를 구분하기 위한 구분코드                         StringBuffer sb = new StringBuffer();             sb.append(MLBConstants.MCODE_REQUEST_PARTNER_ID).append("=").append(partner_id).append("&");             sb.append(MLBConstants.MCODE_REQUEST_SERVICE_CODE).append("=").append(service_code).append("&");             sb.append(MLBConstants.MCODE_REQUEST_MUSIC_CODE).append("=").append(music_code).append("&");             sb.append(MLBConstants.MCODE_REQUEST_CONTENT_PRICE).append("=").append(content_price).append("&");             sb.append(MLBConstants.MCODE_REQUEST_CONTENT_NAME).append("=").append(content_name).append("&");             sb.append(MLBConstants.MCODE_REQUEST_CONTENT_NUM).append("=").append(content_num).append("&");             sb.append(MLBConstants.MCODE_REQUEST_PID).append("=").append(pid).append("&");             sb.append(MLBConstants.MCODE_REQUEST_SUB_CODE).append("=").append(sub_code).append("&");             sb.append(MLBConstants.MCODE_REQUEST_CARRIER_CODE).append("=").append(carrier_code);                         PrintWriter pw = new PrintWriter(new OutputStreamWriter(uc.getOutputStream(), "euc-kr"));             pw.write(sb.toString());             pw.flush();                                     int resCode = 0; // RMS 와의 연결 응답값             resCode = uc.getResponseCode();                         StringBuffer resp = new StringBuffer();             if(resCode < 400){  // 연결이 성공적일때                                 String line;                 BufferedReader br = new BufferedReader(new InputStreamReader(uc.getInputStream(), "euc-kr"));                 while ((line = br.readLine()) != null) {                     System.out.println(line);                     resp.append(line);                 }                                 pw.close();                 br.close();                                 // html 파싱                 result = getResultCode(resp.toString());                 result = (result.equals("OK")) ? result : "MLB연동 중 에러 발생 : " + getResultCode(resp.toString());             }             else{                 result = "MLB연동 중 에러 발생 : " + resCode + " 에러입니다.";             }                     } catch (IOException e) {             e.printStackTrace();         }         catch(Exception e) {             e.printStackTrace();         }                 return result;     }

넘기고 받을 때 euc-kr로 변환하는 것도 주목.

참고 : http://charmpa.egloos.com/1336665

        String RMS_URL = "http://localhost:8080/SMILE_RMS/rms/request_deploy";
        URL url = new URL(RMS_URL);
        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
       
        uc.setDoInput(true);
        uc.setDoOutput(true);
        uc.setUseCaches(false);
        uc.setRequestMethod("POST");
       
        // Http Header
        String ver = "X-RMS-VER 1.0";
        String uid = "X-RMS-UID 1.0";
        String upw = "X-RMS-UPW 1.0";
        String tid = "X-RMS-TID " + System.currentTimeMillis();
        String length = msg.length()+"";
        uc.setRequestProperty("X-RMS-VER", ver);
        uc.setRequestProperty("X-RMS-UID", uid); // md5 encoded
        uc.setRequestProperty("X-RMS-UPW", upw); // md5 encoded
        uc.setRequestProperty("X-RMS-TID", tid);
        uc.setRequestProperty("Content-Length", length);
       
        // 보내기
        PrintWriter pw = new PrintWriter(uc.getOutputStream());
        pw.write(msg.toString());
        pw.flush();
        pw.close();
       
        // 받기
//        BufferedReader br = new BufferedReader(new InputStreamReader(uc.getInputStream()));
//        String str = null;
//        while((str = br.readLine()) != null) {
//            System.out.println(str);
//        }
       
        // 실질적으로 웹서버에 접속하여 요청을 보내고 응답을 수신하는 시점은 con.getResponseCode();로 판단된다.
        // getResponseCode() 를 호출하지 않으면, Network Connection 연결 요청 자체가 시도되지 않음이 확인되었다..
        // 실제로 서버로부터 아무런 정보도 받지 않더라도(현재 InputStream처리부분은 주석임), request의 결과로
        // response가 어떤지(성공/실패 등)를 받지 않으면 서버에 아무것도 보내지 않는듯.
        // 결국 서버가 request에 대한 처리를 하고 response를 주기 전까지는 대기상태. 동기화되어서 작동.
//        OutputStream out = uc.getOutputStream();// internally change to 'POST'
        int resCode = uc.getResponseCode(); // connect, send http reuqest, receive htttp request
        System.out.println ("code = "+ resCode);

http://www.ibm.com/developerworks/kr/library/j-classpath-windows/index.html

E:\workspace\java_run_test>javac -verbose -d bin -sourcepath src src\test\xml\XMLMain.java

jdk설치 디렉\jre\lib\ext에 넣어둔 라이브러리도 참조해버렸다...
dom4j관련 에러가 나야 정상일 듯 싶은데...

역시나 jdk설치 디렉\jre\lib\ext에 넣었던 dom4j 관련 라이브러리 삭제 후 실행했더니 에러 발생.
그래서 다음과 같이 해봤더니,

E:\workspace\java_run_test>javac -verbose -d bin -sourcepath src -classpath E:\workspace\java_run_test\Lib src\test\xml\XMLMain.java

E:\workspace\java_run_test\Lib 여기에 dom4j관련 라이브러리가 있는데도 에러가 난다.
왜 그런가 봤더니
"완전하고, 개별적으로 컴파일 된 서드 파티 라이브러리를 사용하지 않는 경우를 가정했다. 만약 그렇다면, 이들을 classpath에도 추가해야 한다. 라이브러리는 junit.jar 또는 icu4j.jar 같은 JAR 파일로 배포된다. 이 경우, classpath에 추가하는 것은, JAR 파일 그 자체이다. 이것을 포함하고 있는 디렉토리가 아니다." - from IBM(위의 링크 참조)
랜다.

서드 파티 라이브러리 사용시엔 jar파일 자체를 추가해야 된단 말인가라고 생각하여

E:\workspace\java_run_test>javac -verbose -d bin -sourcepath src -classpath E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar src\test\xml\XMLMain.java

로 했더니 깔끔하게 컴파일되었다.
음. 나름 이 업계서 먹고 살아왔는데도 기본을 잘 모르는군... 반성 반성...

이제 남은 건 실행.
bin폴더에 컴파일했으므로 bin폴더로 이동해서 다음과 같이 실행

E:\workspace\java_run_test\bin>java test.xml.XMLMain

당연히 될리 없다. dom4j관련 라이브러리 참조를 위해 classpath 지정

E:\workspace\java_run_test\bin>java -classpath E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar test.xml.XMLMain

왠걸. 에러다.
Exception in thread "main" java.lang.NoClassDefFoundError: test/xml/XMLMain
Caused by: java.lang.ClassNotFoundException: test.xml.XMLMain
        at java.net.URLClassLoader$1.run(Unknown Source)

현재 지정된 클래스패스에서 test.xml.XMLMain를 못찾고 있다. 컴파일 타겟인 bin폴더를 지정안했으니 당연한 것인가라고 생각해서 다시 시도

E:\workspace\java_run_test\bin>java -classpath bin;E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar test.xml.XMLMain

역시 에러. bin폴더에서 bin을 지정하고 있으니 문젠가 싶어서 상위 폴더로 이동 후 재실행

E:\workspace\java_run_test>java -classpath bin;E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar test.xml.XMLMain

옷. 된다. (사실 또다른 라이브러리가 필요해서 에러가 발생했으나 문제는 파악되었으니 무시무시)

이게 완성된 실행문

E:\workspace\java_run_test>java -classpath bin;E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar;E:\workspace\java_run_test\Lib\jaxen-1.1-beta-6.jar test.xml.XMLMain
java.net.ConnectException: Connection refused: connect --> 에러났으나 실행은 되었으니까 무시.

결론

javac -verbose -d bin(타겟 디렉토리) -sourcepath src(소스 디렉토리) -classpath E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar(컴파일에 필요한 서드 파티 라이브러리의 경우 디렉토리path가 아닌 fie path) src\test\xml\XMLMain.java(실제 컴파일할 자바 소스-main()이 있는 클래스만 해도 연관된 것은 자동으로)


java -classpath bin;E:\workspace\java_run_test\Lib\dom4j-1.6.1.jar;E:\workspace\java_run_test\Lib\jaxen-1.1-beta-6.jar(실행 시 필요한 서드 파티 라이브러리&컴파일된 class파일이 있는 디렉토리) test.xml.XMLMain(실행시킬 풀 클래스명)

일반 자바 어플서 특정 URL로 request를 날리는 방법
###########################################################################################
package test.xml;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;

public class XMLSend {
    private String targetUrl = null;
   
    public XMLSend(String targetUrl) {
        this.targetUrl = targetUrl;
    }

    public void send(ArrayList<String[]> dataList) throws IOException {
        URL url = new URL(this.targetUrl);
        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
       
        uc.setDoOutput(true);
        uc.setDoInput(true);
        uc.setUseCaches(false);
        uc.setRequestMethod("POST");
       
        StringBuffer sb = new StringBuffer();
       
        for(int i = 0; i < dataList.size(); i++) {
            String[] s = dataList.get(i);
           
//            uc.setRequestProperty(s[1], s[2]);
               // 0 = 찾을 노드의 xpath, 1 = SAP에 보낼 파라미터명, 2 = 찾은 데이타 // 왜 안되는가?

// 해당 URL을
URL url    = new URL( "http", host, port, dir + "?member_id=" + memberID );
// 연결하고
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
// 응답이
int responseCode = connection.getResponseCode();
                
String line    = "";
// 성공이면
if ( responseCode == HttpURLConnection.HTTP_OK )
{
BufferedReader  br      = new BufferedReader( new InputStreamReader( connection.getInputStream() ) );
    // 해당 URL의 끝을 볼때까지 라인을 읽어서                
    while ( ( line = br.readLine() ) != null)
    {
        result    += line;
    }                    
}

result 값을 파싱하시면 될겁니다.

/******************************************************************************
*   파일      : UDPTimeClient.java
*   용도      : UDP Client
*   작성자   : 성홍제
*   작성일   : 2006. 08. 10
*   Version : 1.0
******************************************************************************/

package Client;

import java.net.*;  
   
public class UDPTimeClient
{  
    public static void main(String[] args)
    {  
        /*if(args.length != 2)
        {
            System.out.println("사용법 : java UDPEchoClient ip port");
            System.exit(1);
        }
       
        String ip = args[0];
        int port = 0;
       
        try
        {
            port = Integer.parseInt(args[1]);
        }
        catch(Exception ex)
        {
            System.out.println("port 번호는 양의 정수로 입력하여 주세요.");
            System.exit(1);
        }*/
       
        String ip = "61.109.232.157";   
        int port = 9999;
       
        InetAddress inetaddr = null;
       
        try
        {  
            inetaddr = InetAddress.getByName(ip);
        }
        catch (UnknownHostException e)
        {  
            System.out.println("잘못된 도메인이나 ip입니다.");
            System.exit(1);
        }
       
        DatagramSocket dsock = null;
       
        try
        {
            // 클라이언트의 데이터그램소켓은 패킷에 서버의 주소와 포트를 넣어주므로

            // 생성자에 아무런 인자가 필요없다.
            dsock = new DatagramSocket();
            String line = null;
           
            // 전송
            // 일단 아무런 내용도 없는 패킷을 보내서

            // 서버가 클라이언트의 위치를 알 수 있게 해준다.
            DatagramPacket sendPacket = new DatagramPacket("".getBytes(),
                                                                                    "".getBytes().length,
                                                                                    inetaddr,
                                                                                    port);
            dsock.send(sendPacket);
             
            byte[] buffer = new byte[200];
            DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
            dsock.receive(receivePacket);
           
            // 받은 결과 출력.
            String msg = new String(receivePacket.getData(),
                                                0,
                                                receivePacket.getData().
                                                length);
           
            System.out.println("서버로 부터 전달받은 시간 :" + msg.trim());
        }
        catch(Exception ex)
        {  
            System.out.println(ex);
        }
        finally
        {  
            if(dsock != null)
            dsock.close();
        }  
    } // main  
} // class

/******************************************************************************
*   파일      : UDPTimeServer.java
*   용도      : UDP Server
*   작성자   : 성홍제
*   작성일   : 2006. 08. 10
*   Version : 1.0
******************************************************************************/

package Server;

import java.net.*;  
import java.util.*;  
   
   
public class UDPTimeServer
{  
    public static void main(String[] args)
    {  
        /*if(args.length != 1)
        {
            System.out.println("사용법 : java UDPEchoServer port");
            System.exit(1);
        }
       
        int port = 0;
       
        try
        {
            port = Integer.parseInt(args[0]);
        }
        catch(Exception ex)
        {
            System.out.println("port 번호는 양의 정수로 입력하여 주세요.");
            System.exit(1);  
        }*/
       
        int port = 9999;
       
        DatagramSocket dsock = null;
       
        try
        {  
            System.out.println("접속 대기상태입니다.");
           
            dsock = new DatagramSocket(port);  
            String line = null;  
           
            while(true)
            {  
             // 받기
                byte[] buffer = new byte[1024];
               
                // TCP와는 다르게 소켓으로 계속 연결되어있는 것이 아니므로
                // 일단 클라이언트의 정보를 얻기 위해서 먼저 받아야 한다.
                DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
                dsock.receive(receivePacket);
               
                java.text.SimpleDateFormat format

                     = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
                String sdate = format.format(new Date());
               
                System.out.println(receivePacket.getAddress().getHostAddress()

                                           + " 에 현재시간 " + sdate + " 을 전송합니다.");

                // 비연결성이므로 보내는 데이터마다 주소와 포트가 필요하다.
                // 위에서 먼저 받은 패킷을 이용해서 클라이언트의 주소와 포트 번호를 알아낸다.
                DatagramPacket sendPacket = new DatagramPacket(sdate.getBytes(),
                                                                                        sdate.getBytes().length,
                                                                                        receivePacket.getAddress(),
                                                                                        receivePacket.getPort());
               
                // getBytes() - 스트링을 바이트 배열로 바꾸어준다. 스트림으로 전송하기 위해서는
                // 바이트 단위로 바꿀 필요가 있다.
               
                dsock.send(sendPacket);
            } // while  
        }
        catch(Exception ex)
        {  
            System.out.println(ex);  
        }
        finally
        {  
            if(dsock != null)  
                dsock.close();
        }  
    } // main    
} // class

/******************************************************************************
*   파일      : RadioClient.java
*   용도      : UDP 라디오 클라이언트
*   작성자   : 성홍제
*   작성일   : 2006. 08. 10
*   Version : 1.0
******************************************************************************/

package Client;

import java.io.*;
import java.net.*;

public class RadioClient
{
    final static int MAXBUFFER = 80;
   
    public static void main(String[] args)
    {
        /*if (args.length != 1)
         * {
        System.out.println("사용법: java RadioClient port");
        System.exit(0);
        }*/
         
        byte buffer[] = new byte[MAXBUFFER];
        //int port = Integer.parseInt(args[0]);
        int port = 163;
       
        try
        {
            DatagramSocket socket = new DatagramSocket(port);
            DatagramPacket recv_packet;// 수신용 데이터그램 패킷
           
            while (true)
            {
                recv_packet = new DatagramPacket (buffer, buffer.length);
                socket.receive (recv_packet);
                // 화면 출력
                String result = new String(buffer, 0, recv_packet.getLength());
                System.out.println(port + "방송: " + result);
            }
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
    }
}

/******************************************************************************
*   파일      : RadioClient.java
*   용도      : UDP 라디오 클라이언트
*   작성자   : 성홍제
*   작성일   : 2006. 08. 10
*   Version : 1.0
******************************************************************************/
package Server;

import java.io.*;
import java.net.*;

public class RadioServer
{
    final int MAXBUFFER = 512;
   
    void work()
    {
        byte buffer[] = null;
       
        String[] str = {"배고파~배고파~배고파~배고파~배고파~배고파~배고파~배고파~배고파~배고파~배고파~",
          "졸려~~~~~~~~~~~졸려~~~~~~~~~~~졸려~~~~~~~~~~~",
          "피곤해~~~~~~~~~피곤해~~~~~~~~~피곤해~~~~~~~~~피곤해~~~~~~~~~",
          "휴가 좀 보내주~~~~~~~~~~휴가 좀 보내주~~~~~~~~~~휴가 좀 보내주~~~~~~~~~~",
          "뭐냐? 이건",
          "잠 잘거야?",
          "하고 싶당!"
        };
       
        String[] dest = {"128","130","131",
          "132",
          "133",
          "134",
          "135",
          "136",
          "137",
          "138",
          "139",
          "140",
          "141",
          "142",
          "143",
          "144",
          "145",
          "146",
          "147",
          "148",
          "149",
          "150",
          "151",
          "152",
          "153",
          "154",
          "155",
          "156",
          "157",
          "158",
          "159",
          "160",
          "161",
          "162",
          "163",
          "164",
          "165",
          "166"};
       
        //String[] dest = {"100", "12"};
        try
        {
            DatagramSocket socket = new DatagramSocket();
            DatagramPacket send_packet = null;
            int i=0;
           
            while(true)
            {
                buffer = str[i++].getBytes();
                for (int j=0; j<dest.length; j++)
                {
                    //send_packet = new DatagramPacket(buffer, 

                    //      buffer.length,InetAddress.getByName("70.12.112."+dest[j]), 163);
                    send_packet = new DatagramPacket(buffer,
                                                buffer.length,InetAddress.getByName("61.109.232."

                                                                                                      +dest[j]),163);
                    socket.send (send_packet);
                }
               
                Thread.sleep(1000);
               
                if (i>=str.length)
                    i=0;
            }
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
    }
     
    public static void main (String[] args)
    {
        new RadioServer().work();
    }
}

/******************************************************************************
*   파일      : MyFileServer.java
*   용도      : 파일 전송 서버
*   작성자   : 성홍제
*   작성일   : 2006. 08. 08
*   Version : 1.0
******************************************************************************/

package Server;

import java.net.*;             
import java.io.*;

public class MyFileServer
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        ServerSocket ss = null;
        Socket socket = null;
       
        //BufferedReader br = null; // 이건 문자로만 취급하므로 텍스트 파일만 취급 가능
        //PrintWriter pw = null;
       
        // 파일에서 읽어서 네트워크에 쓴다. 이건 1바이트 단위로 취급하므로

        // 어떤 파일이든 취급 가능하다.
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
       
        try
        {
           ss = new ServerSocket(10002);
          
           while(true)
           {
               System.out.println("클라이언트의 접속을 기다립니다.");
               socket = ss.accept();
              
               // 접속하면 접속한 클라이언트의 IP 출력
               InetAddress address = socket.getInetAddress();
               System.out.println(address.getHostAddress() + " 로부터 접속하였습니다.");
              
               //br = new BufferedReader(new )
               bis = new BufferedInputStream(new FileInputStream("d:\\Test1.txt"));
               bos = new BufferedOutputStream(socket.getOutputStream());
              
               int b = 0;
              
               while((b = bis.read()) != -1)
               {
                   try
                   {
                       bos.write(b);
                       bos.flush();
                   }
                   catch(Exception e)
                   {
                       System.out.println("파일을 클라이언트에 보내던 중에 예외 발생");
                       e.printStackTrace();
                   }
               }
                   
               System.out.println("전송을 완료했습니다.");
              
               // 전송 완료하고, 그 클라이언트와의 연결을 끊은 후,

               // 다른 클라이언트의 접속을 기다린다.
               bos.close();
               socket.close();
           }
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (Exception e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            try
            {
                bis.close();
                ss.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }

}

/******************************************************************************
*   파일      : MyFileClient.java
*   용도      : 파일 전송 클라이언트
*   작성자   : 성홍제
*   작성일   : 2006. 08. 08
*   Version : 1.0
******************************************************************************/

package Client;

import java.net.*;             
import java.io.*;

public class MyFlieClient
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Socket socket = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
       
        try
        {
            socket = new Socket("localhost", 10002);
           
            bis = new BufferedInputStream(socket.getInputStream());
            bos = new BufferedOutputStream(new FileOutputStream("d:\\Test2.txt"));
           
            int b = 0;
           
            while((b = bis.read()) != -1)
            {
                bos.write(b);
                bos.flush();
            }           
            System.out.println("파일을 다운로드 하였습니다.");
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                bos.close();
                bis.close();
                socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }

}

/******************************************************************************
*   파일      : MyFileServer.java
*   용도      : 파일 전송 서버 - 쓰레드로 바꾼 것
*   작성자   : 성홍제
*   작성일   : 2006. 08. 08
*   Version : 1.0
******************************************************************************/

package Server;

import java.net.*;             
import java.io.*;

public class MyFileServer
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        ServerSocket ss = null;
        Socket socket = null;
       
        //BufferedReader br = null; // 이건 문자로만 취급하므로 텍스트 파일만 취급 가능
        //PrintWriter pw = null;
       
        // 파일에서 읽어서 네트워크에 쓴다. 이건 1바이트 단위로 취급하므로

        // 어떤 파일이든 취급 가능하다.
        BufferedInputStream bis = null;
       
        try
        {
           // 처음에 한번만 생성해서 사용한다.
           ss = new ServerSocket(10002);
           bis = new BufferedInputStream(new FileInputStream("d:\\Test1.txt"));
          
           while(true)
           {
               System.out.println("클라이언트의 접속을 기다립니다.");
               socket = ss.accept();
              
               // 접속하면 접속한 클라이언트의 IP 출력
               InetAddress address = socket.getInetAddress();
               System.out.println(address.getHostAddress() + " 로부터 접속하였습니다.");
       
               MyFileServerThread mfst = new MyFileServerThread(bis, socket);
               mfst.start();
           }
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (Exception e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            try
            {
                bis.close();
                ss.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

class MyFileServerThread extends Thread
{
    /// Fields
    private Socket socket = null;
    private BufferedInputStream bis = null;
    private BufferedOutputStream bos = null;
   
    /// Constructor
    MyFileServerThread(BufferedInputStream bis, Socket soc)
    {
        this.socket = soc;
        this.bis = bis;
       
        try
        {
            bos = new BufferedOutputStream(this.socket.getOutputStream());
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            System.out.println("출력 스트림 생성 시 예외 발생");
            e.printStackTrace();
        }
    }
   
    /// Methods
    public void run()
    {
        int b = 0;
       
        while(true)
        {
            try
            {
                b = bis.read();
            }
            catch (IOException e1)
            {
                System.out.println("파일을 읽던 중에 예외 발생");
                e1.printStackTrace();
            }
           
            if(b == -1)
                break;
           
            try
            {
                bos.write(b);
                bos.flush();
            }
            catch(Exception e)
            {
                System.out.println("파일을 클라이언트에 보내던 중에 예외 발생");
                e.printStackTrace();
            }
        }
            
        System.out.println("전송을 완료했습니다.");
       
        // 전송 완료하고, 그 클라이언트와의 연결을 끊은 후, 다른 클라이언트의 접속을 기다린다.
        try
        {
            // bis는 서버에서 계속 사용하므로 쓰레드에서 닫으면 안된다.
            bos.close();
            socket.close();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
   
    /// Main
}

/******************************************************************************
*   파일      : MyFileClient.java
*   용도      : 파일 전송 클라이언트
*   작성자   : 성홍제
*   작성일   : 2006. 08. 08
*   Version : 1.0
******************************************************************************/

package Client;

import java.net.*;             
import java.io.*;

public class MyFlieClient
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Socket socket = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
       
        try
        {
            socket = new Socket("localhost", 10002);
           
            bis = new BufferedInputStream(socket.getInputStream());
            bos = new BufferedOutputStream(new FileOutputStream("d:\\Test2.txt"));
           
            int b = 0;
           
            while((b = bis.read()) != -1)
            {
                bos.write(b);
                bos.flush();
            }           
            System.out.println("파일을 다운로드 하였습니다.");
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                bos.close();
                bis.close();
                socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }

}

/******************************************************************************
*   파일      : SimpleWebServer.java
*   용도      : 웹 서버 - 간단한 웹 서버 기능을 한다. 익스플로러에서 http://localhost:8081/파일명 *                 이런 식으로
*                 요청하면 웹 서버 폴더에 있는 파일을 보여준다.
*   작성자   : 성홍제
*   작성일   : 2006. 08. 08
*   Version : 1.0
******************************************************************************/

package Server;

import java.net.*;             
import java.io.*;

public class SimpleWebServer
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        Socket socket = null;
        BufferedReader br = null;
        BufferedReader fin = null;
        PrintWriter pw = null;
       
        try
        {
            ServerSocket ss = new ServerSocket(8081);
           
            while(true)
            {
                System.out.println("클라이언트의 접속을 기다립니다.");
                socket = ss.accept();
                System.out.println("클라이언트가 접속했습니다.");
               
                br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
               
                String line = "";
               
                try
                {
                    line = br.readLine();
                   
                    // HTTP 프로토콜에 정해진 대로 첫줄에 사용자가 요청한 파일명이 들어가있으므로
                    // 첫 줄을 읽어서, 사용자가 요청한 파일명을 얻어온다.
                    // indexOf(" ") - " "가 시작되는 인덱스를 리턴한다.
                    int start = line.indexOf(" ") + 2;
                    int end = line.lastIndexOf("HTTP") - 1;
                   
                    String filename = line.substring(start, end);
                   
                    System.out.println("클라이언트가 " + filename + "을 요청했습니다.");
                   
                    fin = new BufferedReader(new FileReader(filename));
                    pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
                   
                    String fline = null;
                   
                    while((fline = fin.readLine()) != null)
                    {
                        //System.out.println(fline);
                       
                        pw.println(fline);
                        pw.flush();
                    }
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                finally
                {
                    if(fin != null)
                        fin.close();
                   
                    if(pw != null)
                        pw.close();
                   
                    if(br != null)
                        br.close();
                   
                    if(socket != null)
                        socket.close();
                }
               
            }//while(true)
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }//public static void main(String[] args)

}

/******************************************************************************
*   파일      : URLConnectionOutput.java
*   용도      : URLConnectionOutput test
*   작성자   : 성홍제
*   작성일   : 2006. 08. 07
*   Version : 1.0
******************************************************************************/

import java.net.*;
import java.io.*;

public class URLConnectionOutput
{
    public static void main(String[] args)
    {
        try
        {
            URL url = new URL("http://search.empas.com/search/all.html");
            URLConnection conn = url.openConnection();
           
            // URLConnection 개체가 output도 가능하게 하겠다는 설정
            conn.setDoOutput(true);
           
            System.out.println("검색어를 입력하세요:");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String strKeyword = br.readLine();
           
            OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
            wr.write("a=w&s=&f=&z=A&q="+URLEncoder.encode(strKeyword,"euc-kr"));
            wr.flush();
            wr.close();
           
            String line=null;
            br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            PrintWriter pw = new PrintWriter(new FileWriter("result.html"));
           
            while ((line = br.readLine()) != null)
            {
                System.out.println(line);
                pw.println(line);
            }
       
            pw.close();
            br.close();           
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

★ URLEncoder,URLDecoder

① URLEncoder클래스
데이터를 웹서버에서 요구하는 데이터 형식으로 바꾸어 줌
 (x-www-form-urlencoded 형식)

변환규칙
아스키문자(a~z, A~Z, 1~9), ‘,’, ‘-’, ‘*’, ‘_’ : 그대로 전달
공백문자 : ‘+’기호로 전환
기타문자 : ‘%xy’ 같은 형식으로 변환(xy: ASCII코드를 16진수화한 결과)

하나의 static 멤버 메서드를 갖음
  public static String encode(String s)  Deprecated.
  public static String encode(String s,String charset. )

② URLDecoder클래스
X-www-form-urlencoded 형식으로 인코딩된 데이터를 디코딩

하나의 static 멤버메서드를 갖음
Public static String decode(String d)

/******************************************************************************
*   파일      : URLEnDecoderTest.java
*   용도      : URLEnDecoderTest test
*   작성자   : 성홍제
*   작성일   : 2006. 08. 07
*   Version : 1.0
******************************************************************************/

import java.net.*;

public class URLEnDecoderTest
{
    public static void main(String [] args) throws Exception
    {
        String str, encodedStr, decodedStr;
       
        str = "우리가 사랑하는 모든 사람";
       
        // euc-kr로 인코딩
        encodedStr = URLEncoder.encode(str,"euc-kr");
        decodedStr = URLDecoder.decode(encodedStr,"euc-kr");
       
        System.out.println("str  :  " + str);
        System.out.println("encodedStr  :  " + encodedStr);
        System.out.println("decodedStr  :  " + decodedStr);
    }
}

★ 포트(Port)

 포트 : 하나의 주소에서 동시 작업, 여러 서비스 이용 용이
 0~1023 사이의 포트는 시스템에 예약
 사용자가 임의의 사용 포트 :1024~65535까지의 포트
 미리 할당되어 있는 포트

하나의 포트는 하나의 프로그램만이 사용가능.

동시에 2개 이상의 프로그램이 같은 포트를 사용하려하면 충돌이 발생.

★ 소켓(Socket)

① 상호 통신을 위해 사용되는 일시적인 객체
② 통신을 하기 위해 사용되는 TCP 계층
  소켓 & 포트 : 두 개의 프로그램이 하부 네트워크에 신경 쓰지 않고 통신하기 위한

    소프트웨어적인 메커니즘(mechanism)
③ 두 개의 프로그램 사이에 통신을 위한 채널이 형성
  양방향 통신이 이루짐
  서버 :  자신의 포트 번호로 요청 대기(listen) => 요청 확인(accept) => 해당 서비스 수행
④ 소켓의 기본적인 일
  원격기계에 접속
  데이터를 보냄
  연결끊음
  포트에 바인드
  들어오는 데이터에 귀를 기울임
  바인드된 포트를 통해 들어오는 원격 기계 접속요청 받음   
⑤ 가상회선 마련  : 포트와 소켓 이용
  TCP의 연결기반 서비스를 제공 
  각 TCP 애플리케이션은 고유한 포트번호를 가진 포트를 가짐. 
  가상회선을 확보 
  TCP 층은 소켓들을 마련하고 있다가, 그 소켓을 통해 들어온 요청을 전달할 표적 애플리케이션의 포트에 연결.  

   1. 서버 :  4444번 포트에 대해  계속 클라이언트의 요청대기(Listen)
   2. 클라이언트 : 4444번 포트를 통해 서버로 서비스 요청.
   3. 서버 / 클라이언트 프로그램은 각각이 사용하는 포트(소켓)을 연결
       => 하나의 논리적인 채널을 생성
   4. 서버:  결과를 클라이언트가 사용하는 포트(예에서는1234)를 통해 전달

/******************************************************************************
*   파일      : EchoServer.java
*   용도      : EchoServer test
*   작성자   : 성홍제
*   작성일   : 2006. 08. 07
*   Version : 1.0
******************************************************************************/

import java.net.*;  
import java.io.*;  
   
public class EchoServer
{  
   
    public static void main(String[] args)
    {
        ServerSocket server = null;
        Socket sock = null;
        BufferedReader br = null;
        PrintWriter pw = null;
       
        try
        {
            // 서버 소켓 생성 - 서버가 사용할 포트 번호
            server = new ServerSocket(10001);
           
            while(true)
            {
                System.out.println("접속을 기다립니다.");
               
                // 클라이언트의 접속을 기다린다. 접속한 후에 다음 라인으로 넘어간다.
                sock = server.accept();
               
                // 접속한 컴퓨터의 IP주소를 얻는다. - 소켓에 모든 정보가 들어있다.
                InetAddress inetaddr = sock.getInetAddress();
                System.out.println(inetaddr.getHostAddress() + " 로 부터 접속하였습니다.");
               
                // 역시 소켓에서 Input, OutputStream을 얻어온다.
                InputStream in = sock.getInputStream();
                OutputStream out = sock.getOutputStream();
               
                br = new BufferedReader(new InputStreamReader(in));
                pw = new PrintWriter(new OutputStreamWriter(out));           
               
                String line = null;
               
                // 한줄씩 읽어와서
                while((line = br.readLine()) != null)
                {  
                    // 화면에 출력하고
                    System.out.println("클라이언트로 부터 전송받은 문자열 : " + line);
                   
                    // 다시 그대로 클라이언트에 돌려준다.
                    pw.println(line);
                    pw.flush();
                }  
            }
        }

        catch(SocketException e) // 클라이언트가 강제 종료 시 서버에서 예외 발생하는 것을 처리
        {           
            System.out.println("클라이언트 강제 종료");
        }
        catch(Exception e)
        {  
            //System.out.println(e);
            e.printStackTrace();
        }
        finally
        {
            try
            {
                // 소켓 닫기 전에 먼저 스트림부터 닫는다.               
                pw.close();
                br.close();
                sock.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    } // main  
}    

/******************************************************************************
*   파일      : EchoClient.java
*   용도      : EchoClient test
*   작성자   : 성홍제
*   작성일   : 2006. 08. 07
*   Version : 1.0
******************************************************************************/

import java.net.*;    
import java.io.*;    
   
public class EchoClient
{    
   
    public static void main(String[] args)
    {  
        Socket sock = null;
        BufferedReader keyboard = null;
        PrintWriter pw = null;
        BufferedReader br = null;
       
        try
        {
            // 클라이언트 소켓 생성 - 서버의 IP주소와 서버 프로그램의 포트번호

            // 생성과 동시에 연결한다.
            sock = new Socket("61.109.232.156", 10001);
           
            keyboard = new BufferedReader(new InputStreamReader(System.in));
           
            pw = new PrintWriter(new OutputStreamWriter(sock.getOutputStream()));
            br = new BufferedReader(new InputStreamReader(sock.getInputStream()));
           
            String line = null;
           
            // 키보드로부터 메시지 입력 받음.
            while((line = keyboard.readLine()) != null)
            {
                if(line.toLowerCase().equals("quit"))
                    break;
               
                // 서버로 보낸다.
                pw.println(line);
                pw.flush();
               
                // 서버에서 되돌려보낸 문자열을 읽는다.
                String echo = br.readLine();
                System.out.println("서버 로부터 전달받은 문자열 :" + echo);
            }
        }
        catch(Exception e)
        {  
            System.out.println(e);
        }
        finally
        {
            try
            {
                br.close();
                pw.close();
                sock.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    } // main  
}    

★ 네트워크 용어

① IP
Internet protocol (인터넷 : 전 세계적 TCP/IP프로토콜)
다양한 기기들간의 통신을 지원
② IP 주소
인터넷에서 하나 이상의 웹사이트에 보유된 서버에 부여된 유일한 주소
x.x.x.x 의 형태(여기서 x는 1 바이트 총 4바이트로 구성)
192.108.0.106 의 형태
③ TCP
Transfer Control Protocol
IP의 상위에 존재하는 접속기반의 전송 프로토콜
전송된 모든 데이터들이 순서대로 목적지에 도착하도록 보장

★ TCP/IP(Transmission Control Protocol / Internet Protocol)
프로토콜 : 네트웍으로 연동되기 위해 상호 연동방법을 정의한 규약
인터넷의 표준 프로토콜
4개의 기능 계층으로 구성 : 대부분의 통신 응응 프로그램들은 응용 계층에서 사용

★ TCP와 UDP
전달계층은 크게 TCP와 UDP로 구분된다
패킷(packet) 단위로 전송
① TCP
연결성 통신 방식(전화)
신뢰성 보장
TELNET, HTTP, FTP 등
② UDP
비연결성 통신 방식(편지)
모든 패킷이 목적지의 주소를 가진다
신뢰성이 낮다
TCP 보다 네트웍 부하가 덜하다
PING 등

★ 소켓(socket)
컴퓨터가 연결된 컴퓨터의 끝점(전기의 소켓과 유사한 개념)
정보 송신 : 소켓에 보낼 정보를 Write
정보 수신 : 소켓으로부터 정보를 Read
TCP/IP 소켓
TCP 소켓
UDP 소켓

★ 포트(port)
하나의 컴퓨터에서 다수개의 네트웍 관련 프로그램을 서로 다른 포트를 사용하여 동시에 실행시킬 수 있다(실제 네트웍 라인은 하나)
논리적인 개념
포트 번호로 16비트 사용
예 : 203.233.51.44:8088

★ 자바 : 네트워크를 손쉽게 연결하는 도구, 네트워크 그 자체
통신을 구현하는 까다로운 부분이 이미 구현되어 있음
필요한 부분을 호출하여 통신 프로그램 개발

자바 네트워크의 구성
스트림기반 I/O 클래스 + java.net패키지 클래스

/******************************************************************************
*   파일      : INetAddressTest.java
*   용도      : INetAddress class test
*   작성자   : 성홍제
*   작성일   : 2006. 08. 04
*   Version : 1.0
******************************************************************************/

import java.net.*;
import java.io.*;

public class INetAddressTest
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        InetAddress myIp = null;
        InetAddress[] myIp2 = null;
        System.out.println("IP를 알고 싶은 사이트 주소를 입력해 주세요");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
        String strAddress = null;
       
        try
        {
            while(!(strAddress = br.readLine()).equals("stop"))
            {
                try
                {
                    //myIp = InetAddress.getByName(strAddress);
                    myIp2 = InetAddress.getAllByName(strAddress);
               
                    //System.out.println("호스트 이름: " + myIp.getHostName());
                    //System.out.println("호스트 주소: " + myIp.getHostAddress());
                    //System.out.println("toStrinjg(): " + myIp.toString());
                    //System.out.println("로컬 호스트: " + myIp.getLocalHost());
   
                    System.out.println("호스트 이름: " + myIp2[0].getHostName());
                   
                    for(int i = 0; i < myIp2.length; i++)
                    {
                        System.out.println("호스트 주소: " + myIp2[i].getHostAddress());
                        System.out.println("toString(): " + myIp2[i].toString());
                        System.out.println("로컬 호스트: " + myIp2[i].getLocalHost());
                    }
                }
                catch(UnknownHostException e)
                {
                    System.out.println("잘못된 주소입니다. 다시 입력해주세요");
                }
            }
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            try
            {
                br.close();
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

★ URL 클래스

URL(Uniform Resource Locator) : 인터넷상의 자원에 대한 고유한 주소

protocol://hostname[:port]/path/filename#section 의 형태

ex)  http://www.jabook.org:8080/web/test.html#test1

프로토콜(protocol) : 자원에 접근하기 위해 사용되는 프로토콜
호스트 이름(HostName) : 접근하고자 하는 자원이 있는 위치
포트(Port) : TCP 연결에 대한 포트 번호. 생략시 기본포트번호 사용
 (Echo:7 DayTime:13 FTP:21 Telnet:23 SMPT:25 HTTP:80)
경로명(Path) : 접근하려는 파일이 있는 위치
파일명(File) : 접근하려는 파일

웹상의 주소(URL) 그 자체를 나타내는 클래스
웹상에 존재하는 자원에 접근하거나 유일한 주소를 나타내기 위해 사용됨
InetAddress클래스보다 확장된 개념 : 네트웍 연결까지 가능

URL클래스 객체 생성
  URL url = new URL(protocol:resource);

  URL url = new URL(String protocol, String host, String file);

주요 멤버메서드
public String getFile() : URL파일명 리턴
public String getHost() : URL의 호스트명 리턴
public int getPort() : URL포트번호 리턴
public Strimg getProtocol (): URL의 프로토콜 리턴

★ URL클래스로 페이지를 다운받아 확인하기 위한 절차
① URL객체 생성
 URL home = new URL(“http://www.jabook.org:80/index.html”);
② URL객체로의 스트림 열기
InputStream in = url.openStream();
③ 받는 스트림을 버퍼에 저정
BufferedReader br = new BufferedReader( new InputStreamReader(in));
④ 버퍼를 화면에 출력하고 스트림 닫기
BufferedReader br;
URL home = new URL(“http://www.jabook.org:80/index.html”);
br = new BufferedReader(new InputStreamReader(home.openStream()));
while ((line = br.readLine()) != null)

{
    System.out.println(line);
}
br.close();

/******************************************************************************
*   파일      : URLTest.java
*   용도      : URLTest
*   작성자   : 성홍제
*   작성일   : 2006. 08. 04
*   Version : 1.0
******************************************************************************/

import java.net.*;
import java.io.*;

public class URLTest
{
    public static void main(String args[])
    {
        try
        {
            // URL 클래스를 이용하여 웹에 접속
            System.out.println("저장하고 싶은 웹페이지를 입력하세요.");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
           
            // 주소 입력 시, 페이지 파일명 - index.html이라든지 - 까지 입력해주어야 한다.
            String strUrl = br.readLine();
            URL home  = new URL("http://" + strUrl);
           
            // 접속한 웹으로부터 입력 스트림을 생성한다.
            PrintWriter pw = null;
            String line = null;
           
            System.out.println("Port: "+home.getPort());
            System.out.println("Protocol: "+home.getProtocol());
            System.out.println("HostName: "+home.getHost());
            System.out.println("FileName: "+home.getPath());
            System.out.println("File: "+home.getFile());
            System.out.println("Ref: "+home.getRef());
           
            // URL과의 스트림 생성
            br = new BufferedReader(new InputStreamReader(home.openStream()));
           
            // getFile() 하면 파일명 앞에 '/'가 하나 붙으므로 그걸 제거한다.
            String fileName = "d:\\" + home.getFile().substring(1, home.getFile().length());
            pw = new PrintWriter(new FileWriter(fileName));
           
            while ((line = br.readLine()) != null)
            {
                //System.out.println(line);
                pw.println(line);
            }
           
            System.out.println("웹페이지를 "+fileName+"에 모두 저장하였습니다.");
           
            br.close();
            pw.close();
           
        }
        catch (Exception e)
        {
            //System.out.println("Exception: " + e);
            e.printStackTrace();
        }
    }
}

/******************************************************************************
*   파일      : FileReaderWriter.java
*   용도      : FileReaderWriter
*   작성자   : 성홍제
*   작성일   : 2006. 08. 03
*   Version : 1.0
******************************************************************************/

import java.io.*;

public class FileReaderWriter
{
    /// Fields
    /// Costructor
    /// Method
    /// Main Method
    public static void main(String[] args) throws IOException, FileNotFoundException
    {  
        if(args.length<2)
        {
            System.out.println("원본 파일과 복사될 파일의 이름을 입력 하십시오!");
            System.exit(-1);
        }
       
        int i = 0, len = 0;
       
        System.out.println("복사할 원본: "+args[0]);
        System.out.println("복사할 대상: "+args[1]);
       
        FileReader in = new FileReader(new File(args[0]));
        BufferedReader br = new BufferedReader(in);
       
        FileWriter out = new FileWriter(args[1], false);
        BufferedWriter bout = new BufferedWriter(out);
        PrintWriter pout = new PrintWriter(out);   

        // 출력 시 편리한 클래스. 버퍼도 자체 내장하고 있다.
       
        char[] buffer = new char[256];  // Buffered- 를 사용하지 않고 이렇게 사용해도 되지만
                                                     // Buffered- 를 사용하는 것이 더 빠른다.
       
        String line = "";
         
        while((line = br.readLine()) != null)
        {
            i++;
            //bout.write(line+"\r\n");  // 끝에 줄바꿈 문자를 추가
           
            if(i < 10)
            {
                //bout.write(line+"\n");  // 끝에 줄바꿈 문자를 추가
                pout.println("0" + i + " " + line);     // 자동으로 끝에 줄바꿈 문자를 추가한다.
                System.out.println("0" + i + " " + line);
            }
            else
            {
                //bout.write(line+"\n");  // 끝에 줄바꿈 문자를 추가
                pout.println("" + i + " " + line);     // 자동으로 끝에 줄바꿈 문자를 추가한다.
                System.out.println("" + i + " " + line);               
            }
        }
       
        br.close();
        bout.close();
        in.close();
        out.close();
        System.out.println(len + " bytes are copied...Successfully!");
    }
}

/******************************************************************************
*   파일      : InputStreamReaderTest.java
*   용도      : InputStreamReaderTest
*   작성자   : 성홍제
*   작성일   : 2006. 08. 03
*   Version : 1.0
******************************************************************************/

import java.io.*;
import java.util.*;

public class InputStreamReaderTest
{
    public static void main(String[] args) throws java.io.IOException
    {
        String s, str;
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        Vector v = new Vector();
       
        PrintWriter pout = new PrintWriter(new FileWriter("d:\\test2.txt"));
   
        System.out.println("내용을 입력해~" );
       
        while((s = br.readLine()) != null)
        {
            if( s.equals("stop"))
            {
                break;
            }
           
            System.out.println("Read : "  + s);
            //pout.println("Read : "+s);
            v.add(s);
        }
       
        System.out.print("저장할래?(Y or N) >> ");
        s = br.readLine();
        System.out.println();
       
        if(s.equals("Y") || s.equals("y"))
        {
            for(int i = 0; i < v.size(); i++)
            {
                str = (String)v.get(i);
                pout.println(str);
            }
           
            System.out.println("저장했으~ d:\\test2.txt에" );
        }
       
        pout.close();
        br.close();
    }
}

/*******************************************************************************************
*   파일      : ChattFrame.java
*   용도      : 채팅 창 예제
*   작성자   : 성홍제
*   작성일   : 2006. 08. 03
*   Version : 1.0
*******************************************************************************************/

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

public class ChatSave extends Frame implements ActionListener
{
    // Fields  
    private TextArea    ta = new TextArea();
    private TextField   tf = new TextField();
    private Button      submit = new Button("전송");
    private Vector v = new Vector();
    private ChatSave cs = null;
    private String fileName = "d:\\Test3.txt";

    // Constructor
    public ChatSave(String title)
    {
        super(title);
        cs = this;
        this.init();
       
        this.setSize(640, 480);
        this.setResizable(false);   // 리사이즈 막기
        //this.pack();

        // 화면 중앙에 위치 시키기
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension di = tk.getScreenSize();
        Dimension di1 = this.getSize();
        this.setLocation((int)(di.getWidth() / 2 - di1.getWidth() / 2), (int)(di.getHeight() / 2 - di1.getHeight() / 2));

        this.setVisible(true);

        // Events
        this.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                // 다이얼로그
                new DialogTest(cs, "저장할래?", true);
                System.exit(0);
            }
        });
       
        tf.addActionListener(this);
        submit.addActionListener(this);

        // Focus
        tf.requestFocus();
    }

    // Methods
    /*************************************************
    * Purpose      : 초기화
    * Return           : void
    * Parameter    : none
    *************************************************/
    private void init()
    {
        this.setLayout(new BorderLayout());

        // South
        Panel p = new Panel(new BorderLayout());
        p.add("Center", tf);
        p.add("East", submit);

        ta.setEditable(false);

        this.add("Center", ta);
        this.add("South", p);  
    }

    public void actionPerformed(ActionEvent ae)
    {
        Object obj = ae.getSource();
       
        if(obj == tf || obj == submit)
        {
            //String str = tf.getText() + "\n\r";
            String str = tf.getText();
            tf.setText("");
           
            // 벡터에 저장
            v.add(str);
   
            ta.append(str + "\n\r");
           
            tf.requestFocus();
        }       
    }
   
    /*************************************************
     * Purpose      : 대화 내용을 저장한다
     * Return        : void
     * Parameter   : none
     *************************************************/
    public void saveFile()
    {
        try
        {
            PrintWriter pout = new PrintWriter(new FileWriter(fileName));
       
            String str;
           
            for(int i = 0; i < v.size(); i++)
            {
                str = (String)v.get(i);
                pout.println(str);
            }
           
            System.out.println("저장했으~ " + fileName +"에" );
           
            pout.close();
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // Main
    public static void main( String[] args )
    {
        ChatSave cf = new ChatSave( "채팅창" );
   
    }// public static void main( String[] args )
}// public class ChattFrame extends Frame

class DialogTest extends Dialog implements ActionListener
{
    // Fields
    Frame       parent;
    Dialog      d;
    Button  btYes = new Button("YES");
    Button  btNo = new Button("NO");
    Label       lb = new Label("저장할래?");

    // Constructor
    public DialogTest(Frame parent, String title, boolean modal)
    {
        super(parent, title, modal);
        this.parent = parent;
        d = this;

        init();
        start();

        this.pack();
        this.setLocation(300, 200);

        this.setVisible(true);
    }

    // Methods
    private void init()
    {
        this.add("North", lb);      

        Panel p = new Panel(new FlowLayout());
        p.add(btYes);
        p.add(btNo);

        this.add("Center", p);
    }

    private void start()
    {
        this.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent we)
            {
                //System.out.println(we);
                d.dispose();
            }
        });
       
        btYes.addActionListener(this);
        btNo.addActionListener(this);
    }

    public void actionPerformed(ActionEvent ae)
    {
        //this.dispose();
       
        Object obj = ae.getSource();
       
        if(obj == btYes)
        {
            ChatSave cs = (ChatSave)this.parent;
            cs.saveFile();
            d.dispose();
        }
        else if(obj == btNo)
        {
            d.dispose();
        }
    }

    // Main

}// public class DialogTest extends Dialog

★ ObjectOutputStream / ObjectInputStream 클래스

자바에서 객체 단위의 입출력하기 위한 ObjectOutputStream 클래스와 ObjectInputStream 클래스를 제공

파일이나 DB에 객체를 저장하거나 읽을 수 있고, 네트워크를 통해서 객체를 송 수신 할 수 있다

객체를 입출력 할 때는 직렬화(Serialization)된 데이터를 사용

직렬화된 데이터 : 객체를 순차적인 바이트로 표현한 데이터

객체를 직렬화된 데이터로 표현함으로서 객체의 영속성(Object Persistence)을 보장

영속성 : 객체가 자신의 상태를 기록해 두어 다음 기회에 또는 다른 환경에서 재생될 수 있는 능력을 의미한다

★ ObjectOutputStream 클래스 : 자바의 기본 자료형과 객체를 직렬화된 데이터로 저장하기 위해 사용되는 클래스

생성자
 ObjectOutputStream(OutputStream outputStream)

★ ObjectOutputStream 클래스의 주요 메소드
void close()     스트림을 닫는다.
void flush()     버퍼의 모든 내용을 출력한다
void wrie(byte[] b, index,int size)  바이트 배열 b의 index 위치부터 size int 만큼을 출력한다
void write(byte[] b)    바이트 배열 b를 출력한다
void write(int ontbyte)    int 값의 하위 한 바이트를 출력한다
void writeBoolean(boolean data)  boolean 값을 출력한다
void writeByte(int data)   한 바이트를 출력한다
void writeBytes(String str)  str 문자열을 연속된 바이트로 출력한다
void writeChar(int data)   한 문자를 출력한다
void writeChars(String str)  str 문자열을 연속된 문자로 출력한다
void writeDouble(double data)  double 값을 출력한다
void writeFloat(float data)  float 값을 출력한다
void writeInt(int data)   int 값을 출력한다
void writeLong(long data)  long 값을 출력한다
void writeObject(Object obj) 객체를 출력한다
void writeShort(int data)  short 값을 출력한다
void writeUTF(String data)  문자열을 UTF 인코딩으로 출력한다

★ ObjectInputStream 클래스 : 직렬화된 데이터로부터 역직렬화(Deserialization)를 수행하여 원래의 데이터로 복구하는 기능을 제공

생성자
 ObjectInputStream(InputStream inputStream)

★ ObjectInputStream 클래스의 주요 메소드
 void close()    스트림을 닫는다
 int read()     한 바이트를 읽는다
 int read(byte[] b, int off, int len)   바이트 배열로 읽어 들인다
 boolean readBoolean()    boolean 값을 읽는다
 byte readByte()    한 바이트를 읽는다
 char readChar()    문자를 읽는다
double readDouble()   double 값을 읽는다
float readFloat()   float 값을 읽는다
int readInt()    int 값을 읽는다
long readLong()    long값을 읽는다
Object readObject()   객체를 읽는다
short readShort()   short 값을 읽는다
int readUnsignedByte()  부호 없는 바이트 값을 읽는다
int readUnsignedShort()   부호 없는 short 값을 읽는다
String readUTF()   UTF 인코딩을 읽어서 문자열 타입으로  반환

 

★ BufferedOutputStream / BufferedInputStream 클래스

이 두개의 클래스는 FilterOutputStream, FilterInputStream 클래스로부터 상속된 클래스이다

① BufferedOutputStream 클래스
버퍼를 사용하여 스트림을 출력
생성자
  BufferedOutputStream(OutputStream outputStream)
  BufferedOutputStream(OutputStream outputStream, int bufSize)

② BufferedInputStream 클래스
버퍼를 사용하여 스트림을 입력
생성자
  BufferedInputStream(InputStream inputStream)
  BufferedInputStream(InputStream inputStream, int bufSize)

통신의 효율을 높이기 위해 버퍼링(Buffering)을 사용

/******************************************************************************
*   파일      : BufferedStreamTest.java
*   용도      : BufferedStreamTest
*   작성자   : 성홍제
*   작성일   : 2006. 08. 02
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class  BufferedStreamTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String [] args) throws Exception
    {
        if(args.length < 2)
        {
            System.out.println("원본 파일과 복사될 파일의 이름을 입력하십시요!");
            System.exit(-1);
        }
       
        // 화면 버퍼 테스트
        System.out.write(55);   // 화면에 바로 출력하는 게 아니라 화면 출력용 버퍼에 55,

                                        // 즉 "7"을 출력한다.
                                        // 근데 이것만으로는 화면 출력용 버퍼가 충분이 차지 않으므로

                                        // 화면에 내용이 출력되지 않는다.
        System.out.flush();      // 그래서 flush()를 이용해서 버퍼의 내용을 강제적으로 출력한다.
                                        // close()를 할 때로 출력하지만, 여기서는 아직 화면 출력을

                                        // 다 끝낸 것이 아니므로 flush()를 사용.
       
        FileInputStream fin = new FileInputStream(args[0]);
        FileOutputStream fout = new FileOutputStream(args[1]);
       
        BufferedInputStream in = new BufferedInputStream(fin);
        BufferedOutputStream out = new BufferedOutputStream(fout);
       
        //BufferedInputStream in = new BufferedInputStream(new FileInputStream(args[0]));
        //BufferedOutputStream out

        //      = new BufferedOutputStream(new FileOutputStream(args[1]));
       
        int s1=0;
        byte[] buf = new byte[1024];
       
        //while((s1 = in.read()) != -1)
        while((s1 = in.read(buf)) != -1)
        {
            //out.write(buf, 0, s1);    // 파일출력
            System.out.write(buf, 0, s1);   // 화면출력           
            //System.out.write(s1);   // 화면출력 - 하나씩 할 때
        }
       
        fin.close();
        fout.close();
       
        in.close();
        out.close();
       
        System.out.println("");
        System.out.println("Copied...Successfully!");
    }
}

★ DataOutputStream / DataInputStream 클래스

이 클래스들은 자바의 기본 자료형 데이터(Primitive Type)를 바이트 스트림으로 입출력하는 기능을 제공
① DataOutputStream
FilterOutputStream 클래스로부터 상속되었고, DataOutput 인터페이스를 사용한 클래스
기본 자료형 데이터를 바이트 스트림으로 출력
생성자
  DataOutputStream(OutputStream outputStream)
② DataInputStream
FilterInputStream 클래스로부터 상속되었고, DataInput 인터페이스를 사용한 클래스
바이트 스트림으로부터 자바의 기본 자료형 데이터를 입력
생성자
  DataInputStream(InputStream inputStream)

★ DataOutput 인터페이스에 선언된 메소드
void write(int i) throws IOException   i를 스트림으로 출력
void write(byte buffer[]) throws IOException     buffer를 스트림으로 출력
void write(byte buffer[], int index, int size)  buffer의 index위치부터 size 만큼의
          throws IOException                        바이트를 스트림으로 출력
void writeBoolean(boolean b)    b를 스트림으로 출력
          throws IOException
void writeByte(int i) throws IOException       i의 하위 8비트를 스트림으로 출력
void writeBytes(String s) throws IOException     문자열 s를 스트림으로 출력
void writeChar(int i) throws IOException        i의 하위 16비트를 스트림으로 출력
void writeChars(String s) throws IOException     문자열 s를 스트림으로 출력
void writeDouble(double d) throws IOException   d를 스트림으로 출력
void writeFloat(float f) throws IOException        f를 스트림으로 출력
void writeInt(int i) throws IOException           i를 스트림으로 출력
void writeLong(long l) throws IOException    l을 스트림으로 출력
void writeShort(short s) throws IOException  s를 스트림으로 출력
void writeUTF(String s) throws IOException    s를 스트림으로 출력. 유니코드를
                                                               UTF-8 엔코딩을 이용하여 변환
★ DataInput 인터페이스에 선언된 메소드
boolean readBoolean(boolean b)   스트림으로부터 읽은 boolean을 반환
         throws IOException 
byte readByte() throws IOException     스트림으로부터 읽은 byte를 반환
char readChar() throws IOException     스트림으로부터 읽은 char를 반환
double readDouble() throws IOExceptio   스트림으로부터 읽은 double을 반환
float readFloat() throws IOException     스트림으로부터 읽은 float를 반환
long readLong() throws IOException     스트림으로부터 읽은 long을 반환
short readShort() throws IOException    스트림으로부터 읽은 short를 반환
int readInt() throws IOException        스트림으로부터 읽은 int를 반환
void readFully(byte buffer[])    스트림으로부터 buffer 크기 만큼의 바이트를

      throws IOException                읽어 buffer 배열에 저장
void readfully(byte buffer[],int index, int size) 스트림으로부터 size 만큼의 바이트를 읽어

         throws IOException                             buffer의 index 위치에 저장
int readUnsignedByte() throws IOException  스트림으로부터 읽은unsigned byte를 반환
int readUnsignedShort() throws IOException 스트림으로부터 읽은unsigned short를 반환
int skipBytes(int n)    입력 스트림으로부터 n 바이트를 스킵

/******************************************************************************
*   파일      : DataIOApp.java
*   용도      : DataIOApp
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class DataIOApp
{
    public static void main(String args[]) throws IOException
    {
        File file = new File("d:\\test.txt");
        FileOutputStream outFile = new FileOutputStream(file);
        DataOutputStream outStream = new DataOutputStream(outFile);
       
        outStream.writeBoolean(true);   // 파일에 기본형을 출력
        outStream.writeInt(12345);
        outStream.writeChar('K');
        outStream.writeDouble(3.14);
       
        System.out.println(outStream.size()+" bytes were written");
           
        outStream.close();
        outFile.close();
       
        FileInputStream inFile = new FileInputStream(file);
        DataInputStream inStream = new DataInputStream(inFile);
       
        System.out.println(inStream.readBoolean()); // 위에서 만든 파일로부터 입력 받음
        System.out.println(inStream.readInt());
        System.out.println(inStream.readChar());
        System.out.println(inStream.readDouble());
       
        inStream.close();
        inFile.close();
       
        try
        {
            Thread.sleep(6000);
        }
        catch(Exception e)
        {}
       
        file.delete();
    }
}

★ OutputStream 클래스와 InputStream 클래스
① 바이트 스트림의 입출력에 필요로 되는 다양한 메소드를 제공하는 추상 클래스(개체생성못함)
② OutputStream 클래스 : 바이트 스트림을 출력하는 기능
③ OutputStream 클래스의 주요 메소드

   void close() throws IOException      출력 스트림을 닫는다
   void flush() throws IOException      버퍼에 남아 있는 출력 스트림을      모두 출력
   void write(int i) throws IOException  정수 i의 하위 8비트를 출력
   void write(byte buffer[]) throws IOException    buffer의 내용을 출력

★ InputStream 클래스 : 바이트 스트림으로부터 데이터를 읽어 들인다
InputStream 클래스의 주요 메소드

int available()      현재 읽기 가능한 바이트의 수를 반환
void close()        입력 스트림을 닫는다
int read()            입력 스트림으로부터 한 바이트를 읽어 int
                         값으로 반환한다. 더 이상 읽을 값이 없을 경우 –1을 반환
int read(byte buffer[])     입력 스트림으로부터 buffer[] 크기만큼을 읽어 buffer 배열에

                                    저장하고 읽은 바이트 수를 반환
int read(byte buffer[], int offset, int numBytes)     입력 스트림으로부터 numBytes 만큼을

                                                                     읽어buffer[]의  offset 위치에 저장하고

                                                                      읽은 바이트 수를 반환
int skip(long numBytes)       numBytes로 지정된 바이트를 스킵(skip)하고

                                        스킵된 바이트 수를 반환

/******************************************************************************
*   파일      : InputOutputStreamTest.java
*   용도      : InputOutputStreamTest를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class InputOutputStreamTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String args[]) throws IOException
    {
        System.out.println("아무 글이나 입력하시고 Enter를 쳐주세요");
        System.out.println(" 's'를 입력하면 프로그램이 종료됩니다.");
       
        int ch;
       
        // InputStream은 추상 클래스여서 new로 instance 생성 불가
        InputStream in = System.in;          // 표준 입력 - 키보드
        OutputStream out = System.out;   // 표준 출력 - 모니터
       
        // read()는 '한 문자씩' 입력 받으나, 키보드 버퍼에 저장되어있는 것을

        // while문을 돌면서 차례로 입력받는다.
        while((ch = in.read()) != -1)
        {
            if(ch == 's' || ch == 'S')
                break;
           
            // write()는 일단 화면 버퍼에 출력하고, 화면 버퍼가 어느 정도 차거나

            // 화면에 출력해도 괜찮을 때 출력한다.
            // 따라서 'aaaaas'와 같이 입력해도 'aaaaa'는 화면 버퍼에 있는 상태에서

            // 's'를 만나서 프로그램이 종료되므로
            // 화면에는 아무것도 나오지 않는다.
            out.write(ch);
           
            // 한글은 깨진다. print() 메소드 자체가 한글을 처리하기 위해 가공하므로,
            // 한글 문자 정보의 일부분인 ch가 가공되어 제대로 출력되지 않는다.
            //System.out.print((char)ch);
           
            //System.out.println("Char: "+(char)ch+", Available: "+in.available());
        }
    }
}

/******************************************************************************
*   파일      : FileInputOutputStreamTest.java
*   용도      : FileInputOutputStream을 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FileInputOutputStreamTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args)
    {
        /*if(args.length < 2)
        {
            System.out.println("원본 파일과 복사될 파일의 이름을 입력하십시요!");
            System.exit(-1);
        }*/
       
        BufferedReader brIn = new BufferedReader(new InputStreamReader(System.in));
        String ori = null;
        String copy = null;
       
        System.out.print("원본 파일의 이름을 입력하세요 >> ");
       
        try
        {
            ori = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
       
        System.out.print("복사될 파일의 이름을 입력하세요 >> ");
       
        try
        {
            copy = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
       
        int i, len=0;
       
        InputStream in=null;
        OutputStream out=null;
       
        //System.out.println("원본파일 : "+args[0]);
        //System.out.println("목표파일 : "+args[1]);
        System.out.println("원본파일 : " + ori);
        System.out.println("목표파일 : " + copy);       
       
        try
        {
            //in = new FileInputStream(new File(args[0]));
            //out = new FileOutputStream(args[1], true);
            in = new FileInputStream(new File(ori));
           
            // 두번째 true 옵션은 같은 이름의 파일이 있으면 그 파일의 끝에 붙여넣는다.
            out = new FileOutputStream(copy, true);
        }
        catch(FileNotFoundException e)
        {
            System.out.println(e);
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
       
        byte buffer[] = new byte[256];
       
        try
        {
            //while((i=in.read()) != -1)    // 이건 1바이트씩 읽어들이는 것
            while((i=in.read(buffer)) != -1)    // 이건 256 바이트씩?
            {
                out.write(buffer,0,i);
                //System.out.write(buffer,0,i); // 화면에 출력한다.
                len += i;
            }
           
            in.close();
            out.close();
           
            System.out.println(len + " bytes are copied...Successfully!");
        }
        catch(IOException e1)
        {
            System.out.println(e1);
        }
    }
}

/******************************************************************************
*   파일      : FakeXCopy.java
*   용도      : FakeXCopy
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FakeXCopy
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args)
    {
//        BufferedReader brIn = new BufferedReader(new InputStreamReader(System.in));
        File f = null;
        String ori = null;
        String dest = null;
/*       
        System.out.print("원본 파일의 이름을 입력하세요 >> ");
       
        try
        {
            ori = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
       
        System.out.print("복사될 파일의 이름을 입력하세요 >> ");
       
        try
        {
            dest = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
*/       
        ori = "d:\\Test\\";
        dest = "d:\\Test_Test\\";
       
        System.out.println("원본파일 : " + ori);
        System.out.println("목표파일 : " + dest);
       
        f = new File(ori);
       
        if(!f.exists())
        {
            System.out.println("디렉토리가 존재하지 않습니다.");
            System.exit(0);
        }
   
        if(f.isDirectory())
        {
            // 현재 디렉토리의 디렉토리, 파일 리스트
            File[] fileList = f.listFiles();
           
            for(int j = 0; j < fileList.length; j++)
            {
                if(fileList[j].isDirectory())
                {
                    // 디렉토리 체크
                    checkDir(fileList[j], dest);
                }
                else
                {
                    // 파일 복사
                    copyFile(fileList[j], dest);
                }
            }
           
            //checkDir(f, dest);    // 기본 디렉토리까지 복사한다.
        }
    }
   
    public static void copyFile(File file, String str)
    {
        int i, len=0;
        InputStream in=null;
        OutputStream out=null;
       
        // 파일 복사
        try
        { 
            in = new FileInputStream(file);
           
            // 두번째 false 옵션은 같은 이름의 파일이 있으면 덮어쓴다.
            out = new FileOutputStream(str + file.getName(), false);
        }
        catch(FileNotFoundException e)
        {
            System.out.println(e);
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
       
        byte buffer[] = new byte[4096];
       
        try
        {
            //while((i=in.read()) != -1)    // 이건 1바이트씩 읽어들이는 것
            while((i=in.read(buffer)) != -1)    // 이건 4096 바이트씩
            {
                out.write(buffer,0,i);
                //System.out.write(buffer,0,i); // 화면에 출력한다.
                len += i;
            }
           
            System.out.println(len + " bytes are copied...Successfully!");
        }
        catch(IOException e1)
        {
            System.out.println(e1);
        }
        finally
        {
            try
            {
                in.close();
                out.close();
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }           
        }
    }
   
    /*************************************************
    * Purpose       : 재귀호출로 디렉토리를 체크한다.
    * Return         : void
    * Parameter    : File file - 체크할 디렉토리, String str - 현재 경로
    *************************************************/
    public static void checkDir(File file, String str)
    {
        // 재귀호출로 현재 디렉토리가 계속 갱신된다. !!!!!
       
        // 목표 디렉토리로 변경
        file.renameTo(new File(str + file.getName() + "\\"));
       
        // 디렉토리 생성
        if(file.mkdirs())
        {
            //System.out.println("디렉토리 생성 성공");
        }
       
        // 디렉토리니까 다시 체크
        File[] fileList = file.listFiles();
       
        for(int j = 0; j < fileList.length; j++)
        {
            if(fileList[j].isDirectory())
            {
                // 디렉토리 체크
                checkDir(fileList[j], str);
            }
            else
            {
                // 파일 복사
                copyFile(fileList[j], str);
            }
        }
    }
}

/******************************************************************************
*   파일      : CopyDir.java
*   용도      : CopyDir - 강사님이 작성한 것
*   작성자   : 김종식
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class CopyDir
{
    /// Fields
    /// Constructor
    /// Method
    public static void copyDirectory(File source , File target) throws IOException
    {
        //디렉토리인 경우
        if (source.isDirectory())
        {
            //복사될 Directory가 없으면 만듭니다.
            if (!target.exists())
            {
                target.mkdir();
            }
           
            String[] children = source.list();
           
            for (int i=0; i<children.length; i++)
            {
                copyDirectory(new File(source, children[i]),new File(target, children[i]));
            }
        }
        else
        {
         //파일인 경우
            InputStream in = new FileInputStream(source);
            OutputStream out = new FileOutputStream(target);
           
            // Copy the bits from instream to outstream
            byte[] buf = new byte[1024];
            int len;
           
            while ((len = in.read(buf)) > 0)
            {
                out.write(buf, 0, len);
            }
           
            in.close();
            out.close();
        }
    }
   
    /// Main Method       
    public static void main(String[] args) throws IOException
    {
        if ( args.length < 2)
        {
            System.out.println("복사할 원본과 대상을 지정하세요.");
            System.exit(-1);
        }
       
        File source = new File(args[0]);
        File target = new File(args[1]);
       
        copyDirectory(source , target);
    }   
}

★ 임시파일

임시파일들을 생성하는 기능
임시파일의 사용을 위한 File 클래스의 메소드
   static File createTempFile(String prefix, String suffix)
   static File createTempFile(String prefix, String suffix,File Directory)
   저장할 디렉토리를 지정하지 않으면 시스템의 것사용

사용법
try

{
  File tmp1 = File.createTempFile("~JavaIO",".tmp");
  File tmp2 = File.createTempFile("~javaIO1",".tmp",new File("c:\\tmp"));
  tmp1.deleteOnExit();
  tmp2.deleteOnExit();
}

catch(IOException e)

{}

/******************************************************************************
*   파일      : TempFile.java
*   용도      : TempFile를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class TempFile
{
    public static void main(String[] args)
    {
        try
        {
            // 디렉토리를 설정해주지 않았으므로 기본 디렉토리
            // C:\Documents and Settings\Class4--25(자기계정)\Local Settings\Temp

            // 에 생성된다.
            File f = File.createTempFile("tmp_", ".dat");
            System.out.println("60초 동안 멈춰있습니다.");
           
            f.deleteOnExit(); // JVM이 종료될 때 임시파일을 자동으로 삭제한다.
           
            try {
                Thread.sleep(60000);// 60초 동안 프로그램이 멈춰있는다.
            }
            catch (InterruptedException e1)
            {
                System.out.println(e1);
            }
        }
        catch (IOException e)
        {
            System.out.println(e);
        }
    } // main
}

★ 파일 클래스

   입출력을 위해 필요로 되는 파일과 디렉토리를 다루기 위한 File 클래스 제공

★ Constructor Summary

File (String pathname) - 절대 경로로 생성
File (String parent, String child)  -
File (File parent, String child)  -
File (URI uri)  -

★ File 클래스의 메소드

boolean canRead()   파일이 읽기 가능하면 true, 아니면 false를 반환
boolean canWrite()    파일이 쓰기 가능하면 true, 아니면 false를 반환
boolean delete()       파일을 삭제하고 true를 반환, 파일을 삭제할 수 없으면    false를 반환
boolean equals(Object obj)   현재의 객체와 obj로 지정된 객체가 같은 파일을 가지고
                                          있으면 true, 아니면 false를 반환
boolean exists()     파일이 존재하면 true, 아니면 false를 반환

                            제일 많이 쓰는 메소드 중 하나. 파일이 존재하지 않으면 생성하고 존재하면...
String getAbsolutePath()    파일에 대한 절대 경로를 반환
String getCanonicalPath()  파일에 대한 정규 경로를 반환
String getParent()   부모 디렉토리 이름을 반환
String getName()    파일의 이름을 반환
String getPath()      파일의 경로를 반환
boolean isAbsolute()   경로가 절대 경로이면 true, 아니면 false를 반환
boolean isDirectory()   현재의 객체가 디렉토리이면 true, 아니면 false를 반환

boolean isFile()    현재의 객체가 파일이면 true, 아니면 false를 반환
long lastModified()    1970년 1월 1일(GMT)부터 파일이 마지막으로 수정된
                               날자까지의 시간을 밀리 초로 반환
long length()   파일의 바이트 수를 반환.  자주 사용한다.
String[] list()  현재 디렉토리 내의 디렉토리 및 파일들의 이름을 반환.  자주 사용한다.
boolean mkdir()   디렉토리를 생성. 경로로 지정된 모든 부모 디렉토리가
                         존재하여야 한다. 지정한 디렉토리가 생성되면 true를
                         반환하고, 아니면 false를 반환
boolean mkdirs()  디렉토리를 생성. 경로로 지정된 디렉토리가 존재하지 않으면
                          경로를 생성한 다음 지정한 디렉토리를 생성. 디렉토리가 생성되면
                          true를 아니면 false를 반환
boolean renameTo(File newName) 파일이나 디렉토리의 이름을 newName으로
                                                 변경한 다음 true를 반환.

                                                 이름을 변경하지 못하면 false를 반환

/******************************************************************************
*   파일      : FileTest.java
*   용도      : File Class를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31

*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FileTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args) throws Exception
    {

        File f1 = new File("./FileTest.java");  // 둘다 상대경로로 생성
        //File f1 = new File("FileTest.java");  // 둘다 상대경로로 생성
       
        System.out.println(" f1.getPath(): "+f1.getPath());
        // 파일의 절대 경로를 표시. 그렇다 하더라도 파일 객체 생성 시 "./FileTest.java"이렇게

        // 한 것은 ./FileTest.java 이런 식으로 나온다.
        System.out.println(" f1.getAbsolutePath(): "+f1.getAbsolutePath());
        // 파일의 경로를 표시. '.' 으로 되어있는 것도 풀어서 실제 위치를 표시한다.
        // 따라서 어떤 파일의 정확한 경로를 알고 싶으면 getCanonicalPath()를 사용하는

        // 편이 좋다.
        System.out.println(" f1.getCanonicalPath(): "+f1.getCanonicalPath());
        System.out.println(" f1.getName(): "+f1.getName());
        System.out.println(" f1.toString(): "+f1.toString());
       
        try
        {
            System.out.println(" f1.toURL(): "+f1.toURL());
        }
        catch(java.net.MalformedURLException e)
        {
            System.out.println(" f1.toURL(): "+e);
        }
       
        System.out.println(" f1.canRead(): "+f1.canRead());
        System.out.println(" f1.canWrite(): "+f1.canWrite());
        System.out.println(" f1.isAbsolute(): "+f1.isAbsolute());
        System.out.println(" f1.isDirectory(): "+f1.isDirectory());
        System.out.println(" f1.isFile(): "+f1.isFile());
        System.out.println(" f1.isHidden(): "+f1.isHidden());
        System.out.println(" f1.lastModified(): "+f1.lastModified());
       
        /*
        Date d = new Date(f1.lastModified());
        System.out.println(" f1.lastModified(): "+d.toString());
        */
       
        System.out.println(" f1.length(): "+f1.length());
        System.out.println(" f1.exists(): "+f1.exists());
    }
}

/******************************************************************************
*   파일      : FileList.java
*   용도      : FileList를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;
import java.text.*;
import java.util.*;

public class FileList
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args) throws IOException
    {

        // Date 정보를 내가 원하는 방식으로 표현하기 위해 사용하는 클래스
        SimpleDateFormat sdf = null;  
        sdf = new SimpleDateFormat("yyyy-MM-dd  a KK:mm");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
        /*if(args.length != 1)
        {
            System.out.println("사용법 : java FileList 디렉토리이름");
            System.exit(0);
        } // if end*/  
   
        //File f = new File(args[0]);
        System.out.println("디렉토리 path를 입력해주세요");
        File f = new File(br.readLine());
   
        if(!f.exists())
        {
            System.out.println("디렉토리가 존재하지 않습니다.");
            System.exit(0);
        }
   
        if(f.isDirectory())
        {
            // 현재 디렉토리의 디렉토리, 파일 리스트
            File[] fileList = f.listFiles();
           
            for(int i = 0; i < fileList.length; i++)
            {
                System.out.print(sdf.format(new Date(fileList[i].lastModified())));
                System.out.print("\t");
               
                if(fileList[i].isDirectory())
                {
                    System.out.print("<DIR>");
                    System.out.print("\t");
                }
                else
                {
                    //System.out.print("파일");
                    System.out.print("\t");
                    System.out.print(fileList[i].length());
                }
               
                System.out.print("\t");
                System.out.print(fileList[i].getName());
                System.out.println("\t");
            }
        }
        else
        {
            System.out.println("디렉토리가 아닙니다.");
        }
    }
}

/******************************************************************************
*   파일      : FileDelete.java
*   용도      : FileDelete를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FileDelete

{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args)
    {
        if(args.length != 1)
        {
            System.out.println("사용법 : java FileDelete 파일이름");
            System.exit(0);
        } // if end
   
        File f = new File(args[0]);
   
        if(f.exists())
        {
            boolean deleteflag = f.delete();
           
            if(deleteflag)
                System.out.println("파일 삭제를 성공하였습니다.");
            else
                System.out.println("파일 삭제를 실패하였습니다.");
        }
        else
        {
            System.out.println("파일이 존재하지 않습니다.");
        }

    }//main
}

★ 입출력 개요

① 자바의 입출력은 모든 하드웨어에 독립적으로 설계
② 자바는 입출력을 스트림(stream)으로 처리
   스트림 : 순서가 있고 길이가 정해져 있지 않은 일련의 데이터 흐름을 의미하는 추상적인 개념
③ 사용자는 스트림을 이용하여 입출력 수행
   스트림을 이용하여 실제 다양한 하드웨어와 입출력을 수행하는 일은 JVM에 의해 실행
④ 스트림의 개념을 이용하면 데이터의 근원지나 목적지에 상관없이 항상 일관된 방법으로 프로그램을 작성할 수 있다.
⑤ 자바는 입출력을 위한 클래스들을 java.io 패키지로 제공(API 참조)
⑥ 단방향으로 작동
   입력 스트림 : 데이터를 스트림으로 읽어 들임
   출력 스트림 : 출력 스트림으로 데이터를 보냄

 

★ 전달 데이터 형에 따른 분류
① 바이트 스트림
   바이트, 바이트 배열, Primitive형 데이터, 개체형 데이터 등의 흐름
   1byte씩 처리

   1byte씩 처리하므로, 영어권이 아닌 2bytes 문자인 한글, 한자, 일본어 등은 깨진다.
    ex) InputStream, OutputStream
② 문자 스트림
   문자, 문자 배열, 문자열의 흐름
   2byte씩 처리
    ex) Reader, Writer

★ 버퍼 - BufferedReader, BufferedWriter 등 Buffered가 붙은 녀석들.

데이터를 하나씩 받아서 하나씩 처리하는게 아니라, 데이터를 계속 받아서 모은 후에 한꺼번에 처리한다.

 

★ 데이터 처리 여부에 따른 분류
① Sink 스트림
   단순히 데이터를 근원지에서 읽어오거나 목적지에 기록
② Procession 스트림
   다른 입출력 클래스를 통해 얻어진 데이터를 중간에서 조작하거나,처리하는 프로세싱 스트림(필터 스트림)

java.lang.OutOfMemoryError

 

                     2005-05-31     송학렬    ㈜아이티플러스 기술지원부

 

 

이 문서는 기술지원 또는 개발 시 java.lang.OutOfMemoryError 를 만났을 때 원인 파악 및 해결방안 입니다.

 

 

java.lang.OutOfMemoryError 에는 크게 2가지 패턴이 있다고 볼 수 있습니다.(전적으로 개인적인 생각이지만..^^)

Java의 heap 메모리가 정말로 Full 되서 나는 종류가 있고 그렇지 않은데도 나는 종류가 있습니다.

그 둘 중에 어는 것 인지부터 가려내는 것이 가장 먼저 선행되어야 합니다.

Java 가상머신에는 메모리 구조가 여러단계로 나뉘어 져 있으므로 어느 영역에 의해 java.lang.OutOfMemoryError 가 나는지 알기 위해 JAVA OPTION으로 싸이트가 안정화 되기 전까진 –verbosegc 또는 -XX:+PrintGCDetails  옵션을 추가해 놓는 것이 java.lang.OutOfMemoryError 났을 때를 대비해 좋은 습관이라 할 수 있습니다.

 

-verbosegc 또는  -XX:+PrintGCDetails  옵션으로 로그에 남는 heap 메모리 정보를 본 후 java.lang.OutOfMemoryError 가 날 때 heap이 꽉 차서 나는 것인지 아닌지 부터 판단합니다.

 

1.     Heap Memory가 Full 차지 않았을 때

1)     Perm 영역이 full 되는 경우

 

Permanent generation is full...

increase MaxPermSize (current capacity is set to: 134217728 bytes)

 

[Full GC[Unloading class sun.reflect.GeneratedSerializationConstructorAccessor31282]

 810207K->802132K(1013632K), 8.3480617 secs]

<GC: 2 4  2465625.831280 10348 0 31 113802808 105534632 286326784 0 0 35782656 715849728 715848840 715849728 134217720 134023296 134217728 8.348677 8.348677 >

Passwd Check =============

<2005. 5. 19. 오전 9시 32분 23초 KST> <Error> <HTTP> <BEA-101017> <[ServletContext(id=2536415,name=/,context-path=)] Root cause of ServletException.

java.lang.OutOfMemoryError

위와 같은 case 인 경우네는 Java 가상머신중에 Perm 영역이 full 차는 경우 입니다. 

Perm 영역에는 class object 및 관련된 meta data가 로드되는 곳인데 싸이트가 매우 많은 수의 class를 사용하는 경우 늘려줘야 하는 case도 있습니다.

얼마가 적정한 사이즈란 정답이 없는 것 같고 max가 계속 늘어나지 않고 일정한 사이즈를 유지 하면 됩니다.

 

             위 에러가 났을때는 -XX:MaxPermSize=256m  옵션으로 사이즈를 적당하게 늘려주는게 방

             법이며 늘려주었는데도 불구하고 Full 차는 시간만 늘어날 뿐 계속 사이즈가 늘어난다면 이 영역은 일반 비즈니스 프로그램으로 핸들링 할 수 없는 영역이므로 WAS 제품의 버그 및 jdk 버그로 보는 것이 일반적입니다.

       

2)     MAXDSIZ 사이즈 관련

  - Exception in thread "CompileThread0" java.lang.OutOfMemoryError: requested 32756 bytes for ChunkPool::allocate

Possible causes:

         - not enough swap space left, or

         - kernel parameter MAXDSIZ is very small.

-          java.lang.OutOfMemoryError: unable to create new native thread

 

위 두 에러가 나는 이유는 Data 사이즈가 Full 차서 더 이상 메모리 할당을 할 수 없다는 java.lang.OutOfMemoryError 입니다.

 

Jdk도 내부적으로 c 라이브러리를 쓰고 jni를 통해서 c프로그램을 호출할 수 도 있는 환경에서 Data 영역이상으로 메모리 사용 시 위 에러를 만날 수 있습니다.

Heap 영역에는 java heap과 C heap이 있는데 C heap이 Data 메모리 영역에 영향을 미치는 것으로 보이며 보통 C의 전역 변수들이 잡히는 영역입니다.

 

위 현상을 만났을 때는 hp os의 MAXDSIZ가 너무 작게 잡혀있지 않은지 확인 후 적당한 크기로 늘려 줘야 합니다.

 

Glance 에서 shift+m 을 누른 후 jvm pid를 누르면 java가 사용하는 Data 사이즈를 모니터링 할 수 있습니다.

모니터링을 통해 적정한 사이즈로 MAXDSIZ를 늘려주어야 하며 만일 늘려 준게 에러 발생의 시간만 지연 시킬 뿐 계속 사용량이 늘어난다면 이는 사용하는 c라이브러리 쪽에 메모리 릭 버그가 있는 것이므로 c라이브러리를 체크 하셔야 합니다.

java.lang.OutOfMemoryError: unable to create new native thread

이 경우는 프로그램에서 Thread pool 프로그램 실수로 필요이상으로 쓰레드가 생성되는 경우도 과도하게 메모리를 사용할 수 있으므로 jvm 쓰레드 덤프를 통해 과도한 쓰레드가 생성되지 않았는지도 확인해 보셔야 합니다.

 

2.     Heap이 Full 찾을 때

이 경우는 java가 사용하는 heap 영역이 Full 되서 java.lang.OutOfMemoryError 가 나는 경우 인데 두 가지 패턴이 있습니다.

순간적으로 대량의 데이터를 메모리에 올리는 프로그램이 실행되어 문제를 야기 할수 있으며 다른 한 가지는 조금씩 메모리 릭이 발생하여 점차적으로 메모리가 쌓여 가는 경우 입니다.

두 가지 중에  어느 것인지 구별하는 것이 중요하며 이를 위해서도 마찬가지로 -verbosegc 또는  -XX:+PrintGCDetails  로그를 통해 순간적으로 메모리가 차는 것인지 조금씩 메모리가 차는 것인지를 확인하셔야 합니다.

 

1) 특정 프로그램의 특정시점의 과도한 메모리 사용에 의한 경우

                특정 프로그램이 과도하게 heap 메모리 이상 메모리를 사용하면서

java.lang.OutOfMemoryError가 발생하는 경우는 이 에러가 발생하는 시점의 쓰레드 덤프를 통해 어느 프로그램인지 쉽게 찾을 수 있습니다.

쓰레드 덤프에 메모리를 쓸만한 프로그램은 어느 정도의 자바프로그램 경험이 있으면 찾을 수 있습니다.

 

Ex)

"ExecuteThread: '36' for queue: 'default'" daemon prio=10 tid=0x0048e7b0 nid=48 lwp_id=4139729 runnable [0x23f32000..0x23f30500]

          at java.net.SocketInputStream.socketRead(Native Method)

          at java.net.SocketInputStream.read(Unknown Source)

          at oracle.net.ns.Packet.receive(Unknown Source)

          at oracle.net.ns.NetInputStream.getNextPacket(Unknown Source)

          at oracle.net.ns.NetInputStream.read(Unknown Source)

          at oracle.net.ns.NetInputStream.read(Unknown Source)

          at oracle.net.ns.NetInputStream.read(Unknown Source)

          at oracle.jdbc.ttc7.MAREngine.unmarshalUB1(MAREngine.java:718)

          at oracle.jdbc.ttc7.MAREngine.unmarshalSB1(MAREngine.java:690)

          at oracle.jdbc.ttc7.Oall7.receive(Oall7.java:373)

          at oracle.jdbc.ttc7.TTC7Protocol.doOall7(TTC7Protocol.java:1405)

          at oracle.jdbc.ttc7.TTC7Protocol.fetch(TTC7Protocol.java:889)

          - locked <0x35e8e3b0> (a oracle.jdbc.ttc7.TTC7Protocol)

          at oracle.jdbc.driver.OracleResultSetImpl.next(OracleResultSetImpl.java:242)

          - locked <0x36f66c98> (a oracle.jdbc.driver.OracleResultSetImpl)

          at weblogic.jdbc.pool.ResultSet.next(ResultSet.java:180)

          at Dcard.AAA.ejb.monitor.member.wbbb.WACBean.getInfoList(WACBean.java:5789)

 

java.lang.OutOfMemoryError 가 날 상황에 쓰레드 덤프를 두 세번 떠서 같은 쓰레드 번호로 위 같은 로직이 오래 결려있다면 이는 프로그램에서 while(rs.next()) 를 오랜 기간 돌면서 메모리에 DB로부터 읽어서 올리고 있다는 것을 의미 합니다… 대량 데이터 조회가 일어나는 경우인 것 입니다.

 

이런 식으로 특정 프로그램의 특정 시점에 과도한 메모리 사용으로 인한 java.lang.OutOfMemoryError 에러는 쓰레드 덤프를 통해 찾을 수 있습니다.

-- 물론 2번에서 설명 할 heap dump를 통해서도 찾을 수 있습니다.

 

2) 메모리 릭에 의해 조금씩 메모리가 쌓인 경우

JVM위 에서 실행중인 프로그램중에 어떤 것이 GC 대상에서 제외되는 영역에 data를 조금씩 쌓고 있다는 얘기입니다.

GC 대상에서 제외되는 영역은 다음과 같은 곳이 있습니다.

- Http Session에 넣는 데이터..(세션 타임아웃 또는 invilidate 씨 까지 제외됨)

- Static 변수

- 서블릿 또는 jsp의 멤버변수 ( WAS 기동 후 최초 호출 시 인스턴스 화 되어 WAS가 내려 갈 때 까지 사라지지 않음 )

- EJB의 멤버변수( pool안에서 객체가 존재하는 한 GC대상에서 제외)

          위 같은 영역에 프로그램에서 data를 add 하는 구조를 메모리 릭 이라고 할 수 있습니다.

           IBM 또는 SUN JDK 인 경우에는 heapdump를 통해서 분석하여 어느 데이터가 메모리를 많이 잡고 있는지를 알 수 있습니다.

           Heapdump 사용법 및 분석 법은 다음을 참조 하시면 됩니다.

 http://www.alphaworks.ibm.com/aw.nsf/FAQs/heaproots

http://www-1.ibm.com/support/docview.wss?uid=swg21190476

http://www-1.ibm.com/support/docview.wss?rs=180&context=SSEQTP&q1=heapdump+solaris&uid=swg21190608&loc=en_US&cs=utf-8&lang=en

http://www.skywayradio.com/tech/WAS51/IBMHeapDump/

 

 

요즘 들어 부쩍 java.lang.OutOfMemoryErorr로 인해 이클립스가 뻗어버리는 일이 많이 발생했었다. 하지만 Heap Monitor를 보면 200M 조차 사용하지 않는다. 이런 경우, 대부분은 PermGen 영역이 모자란 것이 원인일 수 있다.

{workspace}/.metadata/.log를 확인해보면 PermGen space라고 기록되어 있을 것이다.

Eclipse를 사용할 때는 JVM에 -Xmx 옵션은 대부분은 넣어서 사용하리라 생각한다. 하지만 Java는 메모리 영역을 사실상 두 부분으로 구분하여 사용한다. 일반 Java Heap space와 클래스와 같이 Permenant Generation 대상 데이터를 두기 위한 PermGen space이다.

대부분의 자바 애플리케이션에서는 기본 PermGen Size로 충분하겠지만 이클립스의 경우 클래스가 꽤 많아지면서 모자란 경우가 있는듯 하다. javanese의 경우 Callisto를 깔아놓고 JDT, CDT를 왔다갔다 하면서 사용하다보니 Heap은 별로 쓰지도 않는데 PermGen space가 종종 모자라는 경우가 있다. 아마 Web관련 Tool을 많이 사용하는 분도 같은 현상이 나타날 수 있을 것이다.

PermGen space는 -XX:MaxPermSize 옵션으로 설정할 수 있다.

eclipse -vm /usr/lib/jvm/java-1.5.0-sun/bin/java -vmargs -XX:MaxPermSize=128m -Xms128m -Xmx512m

OutOfMemory 에러가 발생한다면 -Xmx만 늘려주지말고 PermSize도 확인해보라.

http://blog.eclipsercp.or.kr/javanese/?p=34

펌...