lonelycat's cellar

DB : Oracle 9i

JAVA : Sdk 1.5.0_06

1. 오라클 설치 후 환경 설정

시스템의 환경변수 설정 화면에서

---\Oracle\jre\1.3.1\bin;

---\Oracle\jre\1.1.8\bin;

을 삭제한다.

오라클 설치 시 인스톨 되는 jre 버젼과 우리가 자바를 설치했을 때 인스톨 한 jre 버젼이

맞지 않아서 생기는 문제를 없앤다.

2. JDBC로 DB에 접속하는 4가지 타입

① Type 1 : JDBC-ODBC Bridge Plus ODBC Driver
  ■ Bridge 방식은 현존하는 DB의 ODBC driver를 그대로 이용하여 JDBC access를 지원하는 module
  ■ ODBC는 각 database client에 install되어 있는 Native code를 사용
  ■ Failure Point 발생 가능성

② Type 2 : Native API
  ■ Native database client library를 이용하여 작성
  ■ Driver는 JDBC 호출을 번역하여 database client library의 API로 변경
  ■ Library는 DBMS provider에 의해 제공
  ■ 플랫폼에 독립적이지 못하므로 플랫폼에 맞는 곳에서만 사용가능

③ Type 3 : JDBC-Net
  ■ Client와 Server사이의 중간에서 통신을 수행
  ■ 중간 Server의 Protocol에 특정적으로 동작 해야 함. JDBC 메소드를 호출해서 DBMS에 독립적인 네트웍 프로토콜로 전환해 주는 드라이버
  ■ No native code model
  ■ DB를 바꾸더라도 Middleware만 교체해주면 된다.
  ■ 주로 규모가 큰 회사에서 사용 - Middleware가 필요하므로 비용이 많이 들어서.

④ Type 4 : Native Protocol
  ■ JDBC 호출을 DBMS에서 사용하는 Network protocol로 곧바로 번역 함
  ■ Client에서 Database로의 direct 호출이 가능
  ■ Best Performance
  ■ 사용하는 DBMS를 변경할 때는 유연하지 못함
  ■ 가장 많이 사용하는 방식.

3. Oracle에서 JDBC를 사용하기 위해서 해주어야 할 일

① 환경변수 - 클래스패스에 D:\Java\jdk1.5.0_06\lib\classes12.zip; 를 추가해주어야 한다.

 classes12.jar 는 JSP에서 사용하고, zip은 자바 응용 프로그램에서 사용하므로 주의!!!

/*******************************************************************************************
* 파일  : Test.java
* 용도  : JDBC 시작
* 작성자 : 성홍제
* 작성일 : 2006. 07. 21
* Version : 1.0
*******************************************************************************************/

// ① 패키지 임포트
import java.sql.*;

public class Test
{
  // Fields
  // Constructor
  // Methods
  // Main

  public static void main(String[] args)
  {
    Connection con = null; // DB가 연결될 때 그 정보를 받는다
    Statement stmt = null; // SQL 명령어를 사용하기 위한 변수
    ResultSet rs = null;  // SQL 명령을 실행한 후, 그 결과를 받기 위한 변수

    System.out.println("지금부터 시작합니다");

    // ② 드라이버 로딩 - 드라이버 로딩에 실패할 경우에 대비하여 try-catch
    try
    {
      Class.forName("oracle.jdbc.driver.OracleDriver");  // 글자 틀리지 말 것
      System.out.println("오라클 드라이버 로딩 성공");
    }
    catch(Exception e)
    {
      System.out.println(e);
    }

    // thin: Type4 방식을 사용하여 접속
    // 서버 IP, 1521: 포트 번호 - default: 1521
    // ora92: DB 이름
    String url = "jdbc:oracle:thin:@61.109.232.128:1521:ora92";  // 글자 틀리지 말 것

    try
    {
      // ③ 오라클 데이터베이스 연결
      con = DriverManager.getConnection(url, "scott", "tiger"); // 임시로 scott으로 접속

      System.out.println("오라클 데이터베이스 연결 성공");
    }
    catch(Exception e)
    {
      System.out.println("오라클 데이터베이스 연결 실패");
    }

    try
    {
      // ④ Statement 객체 생성
      stmt = con.createStatement();

      // ⑤ SQL 구문 실행

      // DB에서 실행할 뿐, 결과는 ResultSet으로 받는다.
      rs = stmt.executeQuery("select * from emp");

      // ⑥ ResultSet 결과 사용하기
      while(rs.next()) // 다음 데이터가 없을 때 까지 무한루프
      {

        // rs의 결과중 1번째 것: empno. empno는 number이므로 getInt로 가져온다.
        //String empno = rs.getInt(1);  
       int empno = rs.getInt("empno"); // rs의 결과중 컬럼 이름이 empno인 것.

       // 마찬가지로 결과중 2번째 것: ename. varchar2이므로 getString으로 가져온다.
       //String ename = rs.getString(2);  

       // 숫자로 몇 번째 것: 보다는 이렇게 컬럼명을 사용하는게 좋다.
       String ename = rs.getString("ename");

       System.out.print("empno: " + empno + "\t");
       System.out.println("ename: " + ename);
     }
   }
   catch(Exception e)
   {
      e.printStackTrace();
   }
   finally  // 예외가 발생하든 안하든 반드시 자원을 반납해주어야 서버가 다운되지 않는다.
   {
      try
      {
        // ⑦ 자원 반납
        stmt.close();
        con.close();
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }

      System.out.println("객체 반납");
    }
  }
}

/******************************************************************************
*   파일      : 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 인코딩을 읽어서 문자열 타입으로  반환