Taeco's Blog

지난 2003/7/22 Tech Tip인 "Compiling Source Directly From a Program"에서는 자바 프로그램으로부터 소스 파일을 직접적으로 컴파일하는 방법에 대해 설명하며, 클래스의 이름을 짓고 소스를 제공할 수 있는 간단한 편집기를 소개했다. 이 접근방법에는 별 문제가 없지만,여기서 제공된 클래스는 프로그램의 실행 중에 사용자가 컴파일하고 로드했던 클래스가 아니라는 것을 알아야 한다. 만약 이미 클래스를 컴파일하고 로드한 상태라면, 지난 Tech Tip 에서 소개했던 접근방법을 이용해서 클래스를 편집하고 리컴파일하는 것은 불가능하다. 이번 Tech Tip 에서는 underlying class loader 에 관해서 이야기 하고자 한다. 시스템 클래스 로더를 통해서 로드된 모든 클래스는 절대로 unload될 수 없기 때문에 프로그램 상에서 클래스의 소스를 재편집한 후, 리컴파일(recompile)하고 재생하고자 한다면, 다른 클래스 로더(class loader)를 사용해야 한다. 이 글에서는 이미 컴파일된 클래스(또는 어떤 클래스라도)를 로드하게끔 해주는 커스텀 클래스 로더의 생성법을 알아보고, 클래스를 컴파일하고, 이 컴파일된 클래스가 로드되었을 때, 기존의 클래스를 버리는 방법에 대해서 배우게 될 것이다.

모든 클래스의 로딩을 책임지는 것은 java.lang 패키지 내에 있는 ClassLoader클래스의 한 인스턴스이다. 시스템 클래스의 경우에는 ClassLoader의 getSystemClassLoader메소드를 통해서 클래스 로더를 사용할 수 있고, 사용자 클래스의 경우에는 이미 클래스가 로드되어 있는 상태라면, Class 클래스의 getClassLoader 메소드를 통해 ClassLoader에게 요청할 수가 있다.

지난 Tech Tip의 RunIt 프로그램에서는 클래스의 인스턴스를 만들어 내는 클래스 데이터를 로드하기 위해 forName 메소드를 사용하였다. 하지만 forName 메소드가 아닌 다른 클래스 로더를 사용하고자 한다면, ClassLoader의 loadClass 메소드를 사용할 수 있다.

다시 말해서,

   String className = ...;
   Class aClass = Class.forName(className);   

위의 코드 대신에,
다음과 같이 코딩한다.

   String className = ...;
   Class aClass = loader.loadClass(className);   

위의 두 코드가 같은 클래스 로더를 통해 로딩되었을 때에는 기능적으로 동일하지만, 첫번째 블럭은 코드가 위치해 있는 로더를 통해서 클래스를 로드하는 반면, 두번째 블럭은 로더 변수가 명시한 클래스 로더를 통해 클래스를 로드하게 된다. 이 두 경우 모두, 클래스의 인스턴스를 생성하기 위해서는 newInstance와 같은 메소드를 호출해야 한다.

호출하는 클래스의 클래스 로더가 변하지 않는다는 가정하에, Class.forName메소드를 반복호출하면 같은 클래스를 로드하게 된다. 마찬가지로 loader.loadClass를 반복적으로 호출해도 같은 클래스를 로드한다. 하지만 두번째 블럭은 클래스를 리로드할 수 있게 한다. 이를 위해서 새로운 ClassLoader를 생성한다.

   String className = ...;
   // create new loader instance
   ClassLoader loader = ...; 
   Class aClass = loader.loadClass(className);

위의 코드 블럭에서는 loadClass의 호출들 사이에 새로운 로더가 만들어진다. 만약 호출 중에 className 의 클래스 정의가 바뀐다면 두번째 호출에서는 클래스의 새로운 버전이 로드된다.

이 메카니즘을 사용하기 위해 RunIt 프로그램을 변경하면, 프로그램을 컴파일, 실행한 후에 소스를 편집하는 것이 가능하고, 이 때 출력값은 이전의 소스가 아닌 새로운 소스에 부합하는 값이다.

이제 남은 것은 어디에서 추상 클래스인 ClassLoader를 받느냐 하는 것이다. permission support가 추가된 java.security 의 SecureClassLoader 와 java.net 의 URLClassLoader는 미리 정의된 로더들이다. 이렇게 미리 정의된 두개의 로더 중에서 URLClassLoader 만이 그것의 생성자(constructor) 또는 static newInstance 메소드를 통해서 public construction을 지원하게 된다. URLClassLoader 에 관한 자세한 정보를 원하면 documentation을 참고한다.

URLClassLoader를 생성하는 것은 URL객체들의 배열의 생성을 수반한다. 이 URL객체들은 커스텀 클래스 로더가 클래스를 찾기 위해 사용하는 장소의 역할을 한다. 배열의 요소를 지정할 때에는 CLASSPATH 환경변수의 패스 요소(path elements)를 지정했던 것과 비슷한 방법을 써야 한다. (이때 패스 요소는 윈도우에서는 a ; , 유닉스에서는 a : 로 분리된다.) URL 배열의 개개의 요소는 지역적으로 혹은 원거리 호스트에 위치시킬 수 있다. "/"으로 끝나는 모든 것들은 디렉토리로 추정할 수 있으며, 이 외의 모든 것들은 JAR 파일로 추정된다.

가령, 현재 디렉토리에서만 찾아지는 디폴트 클래스패스(classpath)와 같은 역할을 하는 ClassLoader를 만들고 싶다면, 다음과 같이 코딩하면 된다.

   File file = new File(".");
   ClassLoader loader = new URLClassLoader(
     new URL[] {file.toURL()}
   );

이 코딩의 첫번째 라인은 현재 디렉토리를 참고해서 File 객체를 만들고, 두번째 라인은 URLClassLoader 생성자를 호출하고 있다. 이렇게 넘겨진 생성자는 URL 객체(File에 대한URL)의 배열이 생성자의 인수로 넘겨진다.

RunIt프로그램에 다음의 코드를 포함하여 리컴파일하고 실행시키면, RunIt프로그램은 이를 실행하고 리로드하는 중에 로드된 클래스를 버릴 것이다. 지난 Tech Tip에서 소개했던 RunIt프로그램과는 다르게 밑의 코드는 메인메소드를 불러내는 클래스의 인스턴스를 생성하지 않는다. 왜냐하면 메인메소드가 static이기 때문에 클래스의 인스턴스를 만들 필요가 없기 때문이다.

   // Create new class loader 
   // with current dir as CLASSPATH
   File file = new File(".");
   ClassLoader loader = new URLClassLoader(
     new URL[] {file.toURL()}
   );
   // load class through new loader
   Class aClass = loader.loadClass(className.getText());
   // run it
   Object objectParameters[] = {new String[]{}};
   Class classParameters[] =
     {objectParameters[0].getClass()};
   Method theMethod = aClass.getDeclaredMethod(
     "main", classParameters);
   // Static method, no instance needed
   theMethod.invoke(null, objectParameters);

다음은 RunItReload라고 새롭게 이름붙인 코드이다.

   import java.awt.*;
   import java.awt.event.*;
   import javax.swing.*;
   import java.io.*;
   import java.net.*;
   import java.lang.reflect.*;

   public class RunItReload extends JFrame {
     JPanel contentPane;
     JScrollPane jScrollPane1 = new JScrollPane();
     JTextArea source = new JTextArea();
     JPanel jPanel1 = new JPanel();
     JLabel classNameLabel = new JLabel("Class Name");
     GridLayout gridLayout1 = new GridLayout(2,1);
     JTextField className = new JTextField();
     JButton compile = new JButton("Go");
     Font boldFont = new java.awt.Font(
                                  "SansSerif", 1, 11);

     public RunItReload() {
       super("Editor");
       setDefaultCloseOperation(EXIT_ON_CLOSE);
       contentPane = (JPanel) this.getContentPane();
       this.setSize(400, 300);
       classNameLabel.setFont(boldFont);
       jPanel1.setLayout(gridLayout1);
       compile.setFont(boldFont);
       compile.setForeground(Color.black);
       compile.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
           try {
             doCompile();
           } catch (Exception ex) {
             System.err.println(
                   "Error during save/compile: " + ex);
             ex.printStackTrace();
           }
         }
       });
       contentPane.add(
                    jScrollPane1, BorderLayout.CENTER);
       contentPane.add(jPanel1, BorderLayout.NORTH);
       jPanel1.add(classNameLabel);
       jPanel1.add(className);
       jScrollPane1.getViewport().add(source);
       contentPane.add(compile, BorderLayout.SOUTH);
     }
     public static void main(String[] args) {
       Frame frame = new RunItReload();
       // Center screen
       Dimension screenSize =
         Toolkit.getDefaultToolkit().getScreenSize();
       Dimension frameSize = frame.getSize();
       if (frameSize.height > screenSize.height) {
         frameSize.height = screenSize.height;
       }
       if (frameSize.width > screenSize.width) {
         frameSize.width = screenSize.width;
       }
       frame.setLocation(
         (screenSize.width - frameSize.width) / 2,
         (screenSize.height - frameSize.height) / 2);
       frame.show();
     }
     private void doCompile() throws Exception {
       // write source to file
       String sourceFile = className.getText() + ".java";
       FileWriter fw = new FileWriter(sourceFile);
       fw.write(source.getText());
       fw.close();
       // compile it
       int compileReturnCode =
         com.sun.tools.javac.Main.compile(
             new String[] {sourceFile});
       if (compileReturnCode == 0) {
         // Create new class loader 
         // with current dir as CLASSPATH
         File file = new File(".");
         ClassLoader loader = 
         new URLClassLoader(new URL[] {file.toURL()});
         // load class through new loader
         Class aClass = loader.loadClass(
                                  className.getText());
         // run it
         Object objectParameters[] = {new String[]{}};
         Class classParameters[] =
                     {objectParameters[0].getClass()};
         Method theMethod = aClass.getDeclaredMethod(
                              "main", classParameters);
         // Static method, no instance needed
         theMethod.invoke(null, objectParameters);
       }
     }
   }

이 프로그램을 컴파일하고 실행할 때는 지난 Tech Tip 의 RunIt 프로그램에서 했던 것과는 약간 다른 방법을 써야 한다. 왜냐하면 커스텀 클래스 로더 는 현재 디렉토리를 리로드 가능한 클래스들의 출처가 되는 장소로 사용하고 있기 때문에 사용자가 같은 클래스패스로부터 실제 RunItReload 클래스를 로드할 수가 없다. 그렇지 않으면, 시스템클래스 로더는 같은 위치로부터 온 클래스 로더와 컴파일된 클래스를 로드하게 될 것이다. 따라서 사용자는 컴파일러가 RunItReload를 위해서 컴파일된 클래스를 다른 위치로 보낼 수 있도록 해줘야 한다. 또한 "."을 포함하지 않은 클래스패스의 지점에서 프로그램을 실행시켜야 한다. 클래스패스를 컴파일하기 위해서는 tools.jar 파일을 포함시켜야 함을 잊지 말자. 밑의 명령문은 RunItReload 의 컴파일된 클래스 파일들을 XYZ 서브디렉토리로 보내고 있다. 여기서 subdirectory name은 마음대로 지정해 줘도 상관없다. (여기서는 커맨드 라인이 여러줄로 보이지만 실제로는 한줄에 기입되도록 한다.)

윈도우에서는,

    mkdir XYZ
    javac -d XYZ -classpath 
     c:\j2sdk1.4.2\lib\tools.jar RunItReload.java

유닉스에서는,

    mkdir XYZ
    javac -d XYZ -classpath 
     /homedir/jdk14/j2sdk1.4.2/lib/tools.jar 
     RunItReload.java

homedir을 실제 홈 디렉토리로 대체하라.

이 때 시스템이 지정된 패스를 찾을 수 없다는 에러가 뜨면, 컴파일 전에 XYZ 디렉토리를 생성했었는지 확인하라.

방금 전에 했던 것처럼 런타임 클래스패스에 tools.jar파일을 포함시키고 실제 RunItReload 프로그램을 위한 XYZ 디렉토리 또한 포함시켜라. 프로그램을 실행하기 위해서는, 다음과 같은 커맨드를 첨부한다. (다시, 여기서는 커맨드 라인이 여러줄로 보이지만 실제로는 한줄에 기입되도록 한다.)

윈도우에서는,

    java -classpath 
     c:\j2sdk1.4.2\lib\tools.jar;XYZ RunItReload

유닉스에서는,

   java -classpath 
      /homedir/jdk14/j2sdk1.4.2/lib/tools.jar:
      XYZ RunItReload

XYZ 디렉토리는 이전의 javac 과정으로부터 영향을 받는다. 따라서 컴파일하기 위한 타겟 디렉토리(-d뒤에 명시된 디렉토리)는 반드시 런타임 클래스패스와 매치되어야 한다.

이 프로그램은 실행되면서 GUI를 디스플레이하기 때문에 다음과 같은 사항을 할 수가 있다.

1. JTextField안에 클래스를 컴파일하고자 한다면, Sample2 와 같은 클래스의 이름을 입력한다.
2. JTextArea 에 소스코드를 입력한다. 여기 Sample2의 소스코드를보자.

       public class Sample2 {
         public static void main(String args[]) {
           System.out.println(new java.util.Date());
           // System.out.println("Hello, World!");
         }
       }
   

3. Go 버튼을 클릭한다.

출력값은 콘솔창으로 보내진다. 가령 Sample2는 다음과 같은 출력값을 산출한다.

  Tue Aug 19 11:25:16 PDT 2003

날짜를 프린트하는 라인을 주석에 달고, "Hello World"를 프린트하는 라인의 주석을 없앤다. 그리고 Go버튼을 클릭하면 콘솔창에 다음을 보게 된다.

  Hello, World!

이전에 로드된 클래스를 unload한 새로운 클래스 로더가 생성되었기 때문에 여러분은 다른 라인이 디스플레이되는 것을 보게 되는 것이다.

국제화(Internalization)는 다양한 언어와 지역에서 애플리케이션이 작동할 수 있도록 디자인하는 프로세스이다. 이것은 text label을 다른 언어로 번역하는 것 뿐만 아니라 날짜나 시간과 같은 정보를 특정지역의 형식에 맞게 표시하는 것을 뜻한다.

text label과 메시지를 국제화 하는 첫번째 과정은 모든 정보를 리소스 번들로 옮기는 것이다. 이 때 각각의 인용된 스트링을 사용자가 볼 수 있게 하기 위해서는, 우선 리소스 번들에 엔트리를 만들고, text label과 메시지가 사용자가 위치한 지역에 따라 다이내믹하게 변하도록 코드를 바꿔줘야 한다. 이것을 제대로 했을 때, 미국에 있는 사용자는 Help를, 스페인에 있는 사용자는 Ayuda를 도움 메뉴를 나타내는 라벨로 이해할 것이다.

이러한 기법은 전체가 하나의 메시지로 되어 있어서 text에서 text로의 번역이 가능한 경우에는 완벽하게 들어맞지만, 여러 개의 메시지로 이루어진 하나의 긴 메시지의 경우에는 그렇지 않다. 다음의 예를 보자.

   Hello, John. Good luck.

사용자는 여기에서 단순하게 연결된 스트링(string concatenation)을 떠올리며, 다음과 같이 여러 개의 스트링을 덧붙이는 방법으로 합성된 메시지를 만들려고 할 것이다.

   System.out.println(
     "Hello, " +
     name +
     ". Good luck.")

혹은, Hello 와 Good luck 스트링을 리소스 번들로 옮겨 가면서 메시지를 합성시키려는 생각을 할 지도 모른다. 사실 이 방법은 잘 돌아갈 수도 있다. 하지만 인사말의 형태가 다음과 같이 나타나는 현상이 일어난다.

   Hello and good luck, John.

그렇다면 이번엔 리소스 번들 스트링을 이름 앞, 뒤의 접두사와 접미사 부분으로 구별해서 쪼개는 방법을 생각해 보자. 하지만 이 때에는 번역가가 어떤 것들이 같이 쓰이는지 그 용법을 모두 알고 있어야만 하기 때문에 일을 더욱 복잡하게 만들 뿐이다. 따라서 이보다 나은 접근방법은 가운데에 이름 변수를 넣을 수 있는 텍스트 스트링(text string)을 만들어 주는 것이다.

영어의 경우에는 다음과 같다.

   Hello, {0}. Good luck.

이렇게해서 생성된 스트링을 본다면, 스페인어 번역가는 다음과 같이 hello 와 good luck 을 함께 넣어버리는 것이 더 낫다는 것을 깨닫게 될 것이다.

   Hola y buena suerte, {0}.

이 메시지가 실제적으로 디스플레이 될 때에는 java.text 패키지의 MessageFormat 클래스가 변수들을 대체하기 위해 사용된다. 이 때 MessageFormat은 한 세트의 객체들을 가져와서 그것들을 포맷하고, 포맷된 스트링을 "Hello, {0}. Good luck." 과 같은 패턴에 삽입한다.

MessageFormat을 사용하기 위해서는 우선 formatter를 생성해야 한다.

   String pattern = ...; // from bundle
   Locale aLocale = ...; // the Locale

   MessageFormat formatter = new MessageFormat(pattern);
   formatter.setLocale(aLocale);

각각의 패턴을 만들기 위해서는 그에 대응하는 각각의 다른 MessageFormat 객체를 생성할 수도 있지만, 새로운 패턴 템플릿에 applyPattern 메소드를 호출함으로써 또 다른 패턴을 가진 MessageFormat 객체를 재사용 할 수도 있다. 이것은 지역정보(locales)를 바꾼 후에 해야 하는 작업임을 기억하자.

   formatter.setLocale(aNewLocale);
   formatter.applyPattern(aPatternForNewLocale);

포맷터를 만든 후에는 출력 메시지를 생성해야 한다. 이를 위해서는 인수(argument)들의 배열(array)을 넘겨 주어야 하는데, 배열안의 인덱스값에 따라서 패턴안의 각 {#}을 이 인수들의 배열이 교체해주게 된다. "Hello, {0}. Good luck." 이라는 패턴을 위해서는 하나의 요소를 갖는 배열이 필요하고, 이 배열안의 요소는 스트링의 위치0에 삽입될 텍스트를 포함한다는 것이다. 앞서 설명한 패턴에 "John" 이라는 스트링값을 삽입한 한개의 요소를 갖는 배열의 예가 있다.

  Object messageArgs[] = {"John"};

출력값을 생성하기 위해선, message arguments을 지정하여 MessageFormat의 포맷 메소드를 호출한다.

   System.out.println(formatter.format(messageArgs));

아래의 HelloGoodLuck 프로그램은 MessageFormat이 어떻게 사용되는지 보여주고 있으며, 여기에서는 프로그램을 간단하게 유지하기 위해 리소스 번들을 사용하지 않는다.

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

   public class HelloGoodLuck {
     public static void main(String args[]) {
       String pattern = "Hello, {0}. Good luck.";
       Locale aLocale = Locale.US;
       MessageFormat formatter = new MessageFormat(
                                   pattern, aLocale);
       Object messageArgs[] = {"John"};
       System.out.println(
                        formatter.format(messageArgs));
       // Pass in command line args
       if (args.length != 0) {
         System.out.println(formatter.format(args));
       }
     }
   }

커맨드 라인에 이름값을 주면 HelloGoodLuck프로그램은 두번째 메시지를 산출한다.
예를 들어, 다음과 같은 명령을 주고 프로그램을 실행했을 때,

   java HelloGoodLuck Spot

이와 같은 출력값을 보게 될 것이다.

   Hello, John. Good luck.
   Hello, Spot. Good luck.

MessageFormat을 사용하면 텍스트를 대입하는 기능뿐만 아니라, NumberFormat 이나 DateFormat 클라스를 사용하지 않고서도 숫자나 날짜를 포맷할 수가 있다. javadoc은 MessageFormat 클라스에서 가능한 모든 지원에 대해 설명하고 있으니 이를 참고하길 바란다.

{#}의 argument index 뒷부분에는 포맷의 타입과 스타일을 컴마로 구분해서 지정할 수 있다. 예를 들어 날짜의 경우, short, medium, long, full 등의 타입을 지정하여 DateFormat 상수(constants)에 매핑할 수 있다. 만약 이때 인수의 타입이 Date이고, MessageFormat이 "{1,date,long}"을 인수로 갖는다면, 출력값으로 지역에 맞는 포맷에 long 타입으로 디스플레이 된 날짜를 보게 될 것이다. 또한 똑같은 short, medium, long, full 옵션을 이용해서 날짜를 "시간"과 함께 디스플레이할 수도 있다. 여기에서 숫자값에는 정수(integer), 통화(currency), 퍼센트(percent) 스타일도 가능하다. 만약 이렇게 미리 짜여진 스타일이 싫다면, 또 SimpleDateFormat과 DecimalFormat의 패턴 스트링을 이미 알고 있다면, 정보를 직접 명시해서 사용해도 된다.

시간, 날짜, 숫자를 사용하는 MessageFormat 패턴의 예를 보자.

   At the tone, the time is now {0, time, short} 
   on {0, date, long}. 
   You now owe us {1, number, currency}.

입력 인수로 Date와 Number를 주었다면, 미국과 독일 지역에 맞는 출력값을 보게 될 것이다.

다음은 위의 출력값을 생성한 프로그램이다. 단순한 프로그램을 위해서는 리소스 번들을 사용하지 말고, 대신에 패턴변수와 germanPattern 변수의 스트링을 리소스 번들에 위치시켜야 한다.

   import java.text.*;
   import java.util.*;
   import java.io.*;
   import java.awt.*;
   import javax.swing.*;

   public class ExtendedFormat {
     public static void main(String args[]) {
       String pattern = 
         "At the tone, the time is now {0, time, short}" + 
         " on {0, date, long}." +
         " You now owe us {1, number, currency}.";
       String germanPattern =
         "Beim Zeitton ist es {0, time, short} Uhr" +
         " am {0, date, long}." +
         " Sie schulden uns jetzt {1, number, currency}.";
       
       StringWriter sw = new StringWriter(100);
       PrintWriter out = new PrintWriter(sw, true);
       MessageFormat formatter = 
                 new MessageFormat(pattern, Locale.US);
       Object messageArgs[] = 
                     {new Date(), new Double(9000.12)};
       out.println(formatter.format(messageArgs));
       formatter.setLocale(Locale.GERMAN);
       // Need to reset pattern after changing locales
       formatter.applyPattern(germanPattern);
       out.println(formatter.format(messageArgs));
       out.close();
       // Put output in window
       JFrame frame = new JFrame("Extended Format");
       frame.setDefaultCloseOperation(
                                 JFrame.EXIT_ON_CLOSE);
       JTextArea ta = new JTextArea(sw.toString());
       JScrollPane pane = new JScrollPane(ta);
       frame.getContentPane().add(
                            pane, BorderLayout.CENTER);
       frame.setSize(500, 100);
       frame.show();
     }
   }

MessageFormat 을 사용하는 것 말고도 애플리케이션을 국제화하는 방법은 매우 많다. 스트링 패턴의 출처인 리소스 번들의 사용에 관한 자세한 사항은 "Resource Bundles" 1998/5/21 Tech Tip을, 날짜와 시간 스트링 포맷에 관한 자세한 정보는 "Internationalizing Dates, Times, Months, and Days of the Week" 2003/6/24 Tech Tip을 참고하길 바란다.

J2SE 1.4 의 릴리즈 이전에는 모든 스윙 컴포넌트는 "이후 릴리즈 될 스윙은 long term persistence 을 지원할 것이다."라고 약속했다. 이는 "모든 자바빈의 long term storage에 대한 지원은 1.4버전에서 java.beans 패키지에 추가되었다."는 메세지로 바뀌었다.

java.beans 패키지의 XMLEncoder클래스는 XML 파일에 자바빈을 존속시키고 스윙 컴포넌트를 저장하는 방법을 제공한다. 스윙 컴포넌트를 저장한 후에는 java.beans패키지의 XMLDecoder클래스를 이용해서 컴포넌트를 재구성할 수가 있다.

FrameCreator프로그램은 JFrame을 생성하고 사용자 설정을 하고 있다. main()메소드는 XMLEncoder객체를 생성하고, 이것을 이용해서 JFrame의 XML버전을 Frame.xml파일에 저장한다.

   import javax.swing.*;
   import java.awt.*;
   import java.awt.event.ActionListener;
   import java.beans.XMLEncoder;
   import java.beans.EventHandler;
   import java.io.BufferedOutputStream;
   import java.io.FileOutputStream;

   public class FrameCreator {
      public static JFrame createFrame() {
        JFrame jFrame = new JFrame();
        jFrame.setTitle("My Frame");
        jFrame.setSize(200, 100);
        JPanel jPanel = new JPanel();
        jFrame.getContentPane().add(jPanel);
        Controller controller = new Controller();
        JButton button1 = new JButton("Hello, world");
        button1.addActionListener(
          (ActionListener) EventHandler.create(
            ActionListener.class, controller,
            "helloWorld"));
        JButton button2 = new JButton(
            "Goodbye, cruel world");
        button2.setBackground(Color.RED);
        button2.addActionListener(
          (ActionListener) EventHandler.create(
            ActionListener.class, controller,
            "exit"));
        jPanel.add(button1);
        jPanel.add(button2);
        jFrame.setVisible(true);
        return jFrame;
      }

      public static void main(String[] args)
                                    throws Exception {
        XMLEncoder encoder = new XMLEncoder(
            new BufferedOutputStream(
                new FileOutputStream("Frame.xml")));
        encoder.writeObject(createFrame());
        encoder.close();
      }
   }

FrameCreator는 non-GUI클래스인 Controller.java에 정의된 메소드를 호출한다. 제어 Controller 클래스는;

   public class Controller {
        public void helloWorld() {
            System.out.println("Hello, world");
        }

        public void exit() {
            System.exit(0);
        }
   }

Frame.xml 컨텐츠를 보면 FrameCreator클래스에 설정되어 있는 속성들을 쉽게 확인할 수 있다. JFrame의 디멘존(dimension)이 저장되는 것을 주목할 필요가 있다. JFrame안에 저장된 JPanel에 관한 정보들과 JPanel의 구성 요소인 2개의 Jbuttons(Controller클래스의 인스턴스에 링크되어 있다.)이 파일안에 저장되어 있다.

   <?xml version="1.0" encoding="UTF-8"?>
   <java version="1.4.1_01" class="java.beans.XMLDecoder">
     <object class="javax.swing.JFrame">
      <void property="size">
       <object class="java.awt.Dimension">
        <int>200</int>
        <int>100</int>
       </object>
      </void>
      <void property="contentPane">
       <void method="add">
        <object class="javax.swing.JPanel">
         <void method="add">
          <object class="javax.swing.JButton">
           <string>Hello, world</string>
           <void method="addActionListener">
            <object class="java.beans.EventHandler"
                    method="create">
             <class>java.awt.event.ActionListener</class>
             <object id="Controller0" class="Controller"/>
             <string>helloWorld</string>
            </object>
           </void>
          </object>
         </void>
         <void method="add">
          <object class="javax.swing.JButton">
           <string>Goodbye, cruel world</string>
           <void property="background">
            <object class="java.awt.Color">
             <int>255</int>
             <int>0</int>
             <int>0</int>
             <int>255</int>
            </object>
           </void>
           <void method="addActionListener">
            <object class="java.beans.EventHandler"
                    method="create">
             <class>java.awt.event.ActionListener</class>
             <object idref="Controller0"/>
             <string>exit</string>
            </object>
           </void>
          </object>
         </void>
        </object>
       </void>
      </void>
      <void property="name">
       <string>frame0</string>
      </void>
      <void property="title">
       <string>My Frame</string>
      </void>
      <void property="visible">
       <boolean>true</boolean>
      </void>
     </object>
   </java>

이를 이용해 Frame.xml파일로부터 형성된 JFrame를 놀랍도록 쉽게 재구성할 수 있다. 다음의 FrameRecreator프로그램을 보면 XMLDecoder가 Frame.xml파일을 읽고 있는 것을 알 수 있고, 이를 실행하면 FrameCreator에서 생성/ 구성되었던 것과 같은 JFrame를 보게 된다.

   import java.beans.XMLDecoder;
   import java.io.BufferedInputStream;
   import java.io.FileInputStream;

   public class FrameRecreator {

      public static void main(String[] args)
                                    throws Exception {
        XMLDecoder decoder = new XMLDecoder(
            new BufferedInputStream(
                new FileInputStream("Frame.xml")));
        decoder.readObject();
        decoder.close();
      }
   }

XMLEncoder와 XMLDecoder을 이용해서 JavaBeans을 저장하고 복구하는 방법을 살펴보았다. 하지만 XMLEncoder와 XMLDecoder는 이 예제에세 다루는 것보다 훨씬 더 광범위하게 사용된다. XMLEncoder는 모든 프리미티브 데이터타입, 날짜, 스트링, 어레이, 리스트,hashmaps(primitive data types, dates, strings, arrays, lists, )그리고 JavaBeans이 아닌 J2SE SDK 의 클래스들을 저장하기 위해 미리 구성된다. JavaBeans이 아니더라도, 사용자만의 자바 클래스들을 저장하기 위해 XMEncoder를 형성할 수도 있다. 이 테크닉에 대해 좀 더 알고 싶다면, 스윙 커넥션의 다음 아티클을 참고한다.

• Using XMLEncoder
• Long Term Persistence of JavaBeans Components: XML Schema

사용자의 persistence techniques에 XMLEncoder를 추가하려면, Core Java Technologies Tech Tips의 "Using the Preferences API" July 15 issue에서 설명했던 Preferences API를 참고한다.

자바 데스크탑 애플리케이션에 오디오 큐(audio cues)를 추가하면 세련된 느낌을 줄 뿐만 아니라 사용성을 극적으로 증가시킬 수가 있다. Musical Instrument Digital Interface (MIDI)는 장치간에 뮤지컬 이벤트를 주고 받을때 사용되는 커뮤니케이션 프로토콜이다. MIDI파일은 실제 오디오가 아닌 오디오 명령어를 포함한다. MIDI 가 사운드를 재현하기 위해 사운드 엔진에 명령어를 기술하는 반면, 오디오는 사운드의 디지탈 표현(digital representation)이다. 이 TechTip에서는 J2SE 1.3이후의 자바 플랫폼에서 지원하는 javax.sound.midi 패키지를 사용하여 MIDI사운드를 생성하는 3가지 방법을 소개한다.

첫번째 테크닉은, MidiChannel객체를 직접 호출해서 사운드를 생성하는 것이다. 이 객체는 MIDI전송을 위한 하나의 MIDI 채널을 나타낸다. 채널을 통해서 연주를 시작하기 위해서는 MidiChannel객체의 noteOn()메소드를 사용하고, 멈추기 위해서는 noteOff()메소드를 사용한다.

noteOn()메소드는 2개의 int값을 필요로 한다. 첫번째 int는 연주될 음을 지정하는데, 다음 SingleNoteChannel프로그램에서 noteOn()메소드에 넘겨진 int 60은 가운데 도(middle C)를 위한 표준 MIDI 음의 번호이다. 위아래의 정수는 반음에 해당하고 12 반음은 한 옥타브를 이룬다.

noteOn()메소드의 두번째 매개변수는 키가 눌려질 속도를 지정한다. 사실 이 매개변수는 흔히 속도를 나타내지만, 그것을 제어볼륨(volume control)으로 봐도 무방하다. SingleNoteChannel에서 noteOn()메소드의 두번째 매개변수는 70이다. 속도를 나타내는 70을 다른 숫자로 바꿔서 실험을 해보자.

noteOff()메소드는 두개의 signature를 갖는데, 하나는 noteOn()에서와 동일한 두개의 매개변수이고, 다른 하나는 연주될 음을 나타내는 번호이다.

음을 연주하기 전에, SingleNoteChannel생성자에 필요한 셋업을 해야한다. 사운드를 생성하기 위해서는 Synthesizer객체가 필요하다. 이 객체는 MIDI 1.0 명세(specification)에서 규정하는 각각의 16개 채널을 말하는 MidiChannel들의 컬랙션을 보여준다. SingleNoteChannel생성자는 MidiSystem클래스의 팩토리 메소드를 이용해서 Synthesizer에 대한 핸들을 받고, Synthesizer의 open()메소드를 호출한 후, getChannels()메소드를 호출함으로써 가능한 MidiChannels의 array를 얻어낸다. 그리고는 index 0자리에 첫번째 MidiChannel을 넣는다.

   import javax.sound.midi.MidiChannel;
   import javax.sound.midi.Synthesizer;
   import javax.sound.midi.MidiSystem;
   import javax.sound.midi.MidiUnavailableException;

   public class SingleNoteChannel {

      private MidiChannel channel;

      public SingleNoteChannel() {
        try {
          Synthesizer synth = 
                          MidiSystem.getSynthesizer();
          synth.open();
          channel = synth.getChannels()[0];
        } catch (MidiUnavailableException e) {
          e.printStackTrace();
        }
      }

      public void playNote(int note) {
        channel.noteOn(note, 70);
        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        channel.noteOff(note, 70);
      }

      public static void main(String[] args) {
        new SingleNoteChannel().playNote(60);
      }
   }

SingleNoteChannel프로그램의 playNote()메소드는 MidiChannel noteOn()메소드를 호출해서 음을 연주하기 시작한다. 연주는 쓰레드가 휴면하는 1초동안 지속되다가 MidiChannel noteOff()메소드가 호출됨으로 해서 끝나게 된다. 또한 버튼이나 키 혹은 on-screen event를 누르거나 떼서 특정 음들을 결합시킬 수도 있다.

MIDI사운드를 생성하기 위한 두번째 테크닉은, Synthesizer로 결합된 Receiver객체를 사용하는 것이다. 이 때에 특정 MidiChannel 대신 Receiver에 대한 핸들을 받아야 한다. 사용자는 ShortMessage타입의 MIDI메세지를 만들고 사용자설정을 한 후에 Receiver객체의 send()메소드를 호출해서 연주를 시작할 수 있다.

ShortMessage객체는 많아야 2데이터 바이트를 갖는 MIDI 메세지를 포함한다. MIDI 메세지의 매개변수를 설정하거나, 채널 메세지를 위한 메세지 매개변수를 설정하기 위해서 setMessage() 메소드를 사용할 수 있다. SingleNoteSynthesizer프로그램의 setMessage()메소드는 채널 메세지를 위한 메세지 매개변수를 설정하기 위해서 4개의 int값을 포함하는 signature를 갖는다. 첫번째 int는 NOTE_ON 와 NOTE_OFF중 보내질 코맨드를, 두번째 int는 타겟 채널을 지정한다. (앞의 예제와 일관되게, index 0을 조건으로 지정했다.) 마지막 두개의 int값은 음 식별자와 속도이다. SingleNoteSynthesizer에서 noteOn()과 noteOff()에 넘겨지는 int값은 SingleNoteChannel예제에서와 동일하다.

   import javax.sound.midi.ShortMessage;
   import javax.sound.midi.InvalidMidiDataException;
   import javax.sound.midi.Receiver;
   import javax.sound.midi.Synthesizer;
   import javax.sound.midi.MidiSystem;
   import javax.sound.midi.MidiUnavailableException;

   public class SingleNoteSynthesizer {

      private ShortMessage message = 
                                    new ShortMessage();
      private Receiver receiver;

      private SingleNoteSynthesizer() {
        try {
          Synthesizer synth = 
                           MidiSystem.getSynthesizer();
          synth.open();
          receiver = synth.getReceiver();
        } catch (MidiUnavailableException e) {
          e.printStackTrace();
        }
      }
  
      public void playNote(int note) {
        setShortMessage(note, ShortMessage.NOTE_ON);
        receiver.send(message, -1);
        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
       e.printStackTrace();
        }
        setShortMessage(note, ShortMessage.NOTE_OFF);
        receiver.send(message, -1);
      }

      private void setShortMessage(
                               int note, int onOrOff) {
        try {
          message.setMessage(onOrOff, 0, note, 70);
        } catch (InvalidMidiDataException e) {
          e.printStackTrace();
        }
      }

      public static void main(String[] args) {
        new SingleNoteSynthesizer().playNote(60);
      }
   }

지금까지는 디폴트 악기에서 하나의 음을 연주하는 예만을 살펴보았다. 그렇다면 다른 악기에서의 연주는 어떨까? 세번째 테크닉에서 이 물음의 답을 보게 될 것이다. 실험을 통해 시작해보자. 연주 가능한 악기의 리스트를 생성하는 메소드가 있다.

   public void listAvailableInstruments(){
      Instrument[] instrument =
                     synth.getAvailableInstruments();
      for (int i=0; i<instrument.length; i++){
        System.out.println(i + "   "
                          + instrument[i].getName());
      }
   }

위의 메소드를 호출하면 다음과 같은 아이템 리스트를 보게 된다.

0   Piano
1   Bright Piano
2   Electric Grand
3   Honky Tonk Piano
4   Electric Piano 1
5   Electric Piano 2
6   Harpsichord
7   Clavinet
8   Celesta
9   Glockenspiel
10   Music Box
11   Vibraphone
12   Marimba
13   Xylophone
14   Tubular Bell
15   Dulcimer
16   Hammond Organ
17   Perc Organ
18   Rock Organ
19   Church Organ
20   Reed Organ
21   Accordion
22   Harmonica
23   Tango Accordion
24   Nylon Str Guitar
25   Steel String Guitar
26   Jazz Electric Gtr
27   Clean Guitar
28   Muted Guitar
29   Overdrive Guitar
30   Distortion Guitar

SingleNoteSynthesizer2는 다른 악기들을 사용하여 하나 이상의 음을 연주하기 위해 SingleNoteSynthesizer를 보강한 프로그램이다. 하지만 이를 실행해보면, 시간을 맞추기 위해 Thread가 여전히 휴면하는 것을 볼 수 있다. 이는 음악을 만들고 연주하기 위한 좋은 방법이 아닐 뿐더러, AWT Event Dispatch thread에서 이를 실행했다면 GUI가 이벤트를 처리하거나 보수하는 것을 막게 될 것이다. 이 부분은 마지막 테크닉을 설명할 때 다루기로 하겠다.

SingleNoteSynthesizer2를 보면, 사용자가 만든 악기 리스트에서 사용하고 싶은 악기의 int값을 찾아 MidiChannel의 programChange()메소드에 넣고, 이를 호출해서 연주될 악기를 바꿀 수가 있다. 예에서 교회 오르간을 나타내는 int는 19이다.

startNote()와 stopNote()메소드가 각각 NOTE_ON명령어와 NOTE_OFF명령어를 이용해서 메세지를 생성할 수 있도록 코드를 추가한 것을 주목하자. playNote()메소드는 startNote()를 호출하고, duration에 지정된 밀리초(milliseconds)동안 휴면한 후, stopNote()를 호출한다.

   import javax.sound.midi.ShortMessage;
   import javax.sound.midi.Synthesizer;
   import javax.sound.midi.Receiver;
   import javax.sound.midi.MidiSystem;
   import javax.sound.midi.MidiUnavailableException;
   import javax.sound.midi.InvalidMidiDataException;

   public class SingleNoteSynthesizer2 {
      private ShortMessage message = new ShortMessage();
      private Synthesizer synth;
      private Receiver receiver;

      public SingleNoteSynthesizer2() {
        try {
          synth = MidiSystem.getSynthesizer();
          synth.open();
          receiver = synth.getReceiver();
        } catch (MidiUnavailableException e) {
          e.printStackTrace();
        }
      }

      public void startNote(int note) {
        setShortMessage(ShortMessage.NOTE_ON, note);
        receiver.send(message, -1);
      }

      public void stopNote(int note) {
        setShortMessage(ShortMessage.NOTE_OFF, note);
        receiver.send(message, -1);
      }

      public void playNote(int note, int duration){
        startNote(note);
        try {
          Thread.sleep(duration);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        stopNote(note);
      }

      public void setInstrument(int instrument){
        synth.getChannels()[0].programChange(
                                           instrument);
      }

      private void setShortMessage(
                               int onOrOff, int note) {
        try {
          message.setMessage(onOrOff, 0, note, 70);
        } catch (InvalidMidiDataException e) {
          e.printStackTrace();
        }
      }

      public void playMajorChord(int baseNote){
        playNote(baseNote,1000);
        playNote(baseNote+4,1000);
        playNote(baseNote+7, 1000);
        startNote(baseNote);
        startNote(baseNote+4);
        playNote(baseNote+7,2000);
        stopNote(baseNote+4);
        stopNote(baseNote);
      }

      public static void main(String[] args) {
        SingleNoteSynthesizer2 synth
                        = new SingleNoteSynthesizer2();
        synth.setInstrument(19);
        synth.playMajorChord(60);
      }
   }

주요 화음은 한개의 기본 음, 기본음으로부터 4개 반음 올린 음, 3개 반음 선간(spaces)을 올린 음으로 구성된다. SingleNoteSynthesizer2에서, playMajorChord()메소드는 먼저 하나씩 3개의 음를 연주한 뒤, 이들을 동시에 연주한다. 타이밍은 Threads를 이용해서 맞추는데, 타이밍이 중요할 경우에는 Sequencer를 이용하는 것이 좋다.

Sequencer객체는 MIDI 이벤트의 타이밍을 좀 더 효과적으로 컨트롤 할 수 있는 메소드를 포함한다. 전에는 MidiSystem의 팩토리 메소드를 사용했던 반면, 여기서는 Sequencer를 이용한다. Sequencer를 사용한 예는 다음 예제인 SequencerSound에서 볼 수 있다. 앞선 예와 비교해서 여기서는 코드에 몇몇 주요한 변경이 있음을 유의해야 한다. 먼저 startNote()와 stopNote()메소드는 생성되는 메세지가 일어나는 시점을 나타내는 int값을 갖는다. createTrack()메소드는 8분음표마다 4번의 똑딱 소리를 내서 하나의 Sequence를 생성한다. 예를 들면, 4/4박자는 4개의 8분음표 혹은 16번의 똑딱 소리로 나뉘어 질 수 있는 것처럼, 박자를 나눌 때 이 메소드를 사용할 수 있다.

setShortMessage()메소드는 setMessage()를 호출한후, ShortMessage에 기반하고, 똑딱 소리로 결합된 MidiEvent객체를 생성한다. 그리고는 마지막으로 트랙에 MidiEvent를 추가한다. 트랙을 재생할 때, startSequencer()메소드는 새롭게 생성된 Sequence를 기존 Sequence에 할당하고, start()메소드를 호출해서 재생시킬수가 있다. 또한 setTempoInBPM()메소드를 이용해서 템포를 분당 16 비트(BPM)으로 설정할 수가 있다.

   import javax.sound.midi.Track;
   import javax.sound.midi.Sequencer;
   import javax.sound.midi.Sequence;
   import javax.sound.midi.MidiSystem;
   import javax.sound.midi.MidiUnavailableException;
   import javax.sound.midi.InvalidMidiDataException;
   import javax.sound.midi.ShortMessage;
   import javax.sound.midi.MidiEvent;

   public class SequencerSound {
      private Track track;
      private Sequencer sequencer;
      private Sequence sequence;

      public SequencerSound() {
        try {
          sequencer = MidiSystem.getSequencer();
          sequencer.open();
        } catch (MidiUnavailableException e) {
          e.printStackTrace();
        }
        createTrack();
        makeScale(20);
        startSequencer();
      }

      private void startSequencer() {
        try {
          sequencer.setSequence(sequence);
        } catch (InvalidMidiDataException e) {
          e.printStackTrace();
        }
        sequencer.start();
        sequencer.setTempoInBPM(60);
      }

      private void createTrack() {
        try {
          sequence = new Sequence(Sequence.PPQ, 4);
        } catch (InvalidMidiDataException e) {
          e.printStackTrace();
        }
        track = sequence.createTrack();
      }

      public void startNote(int note, int tick) {
        setShortMessage(
                     ShortMessage.NOTE_ON, note, tick);
      }

      public void stopNote(int note, int tick) {
        setShortMessage(
                    ShortMessage.NOTE_OFF, note, tick);
      }

      private void setShortMessage(
                    int onOrOff, int note, int tick) {
        ShortMessage message = new ShortMessage();
        try {
          message.setMessage(onOrOff, 0, note, 90);
          MidiEvent event = new MidiEvent(
                                       message, tick);
          track.add(event);
        } catch (InvalidMidiDataException e) {
          e.printStackTrace();
        }
      }

      public void makeScale(int baseNote) {
        for (int i = 0; i < 13; i++) {
          startNote(baseNote + i, i);
          stopNote(baseNote + i, i + 1);
          startNote(baseNote + i, 25 - i);
          stopNote(baseNote + i, 26 - i);
        }
      }

      public static void main(String[] args) {
        new SequencerSound();
      }
   }

이 글은 MIDI 파일을 생성하고 재생하는 방법을 설명했다. 개발자는 사운드뱅크가 J2SE SDK에 따라서 자동적으로 인스톨되기 때문에 음악을 들을 수가 있다. 사운드 뱅크는 악기 설정을 보여주고, 사운드를 종합하기 위해 필요하다. (사운드뱅크에 대해서는 후에 더 자세히 다루도록 하겠다.) 비 개발자들은 생성한 파일을 들으려면 사운드뱅크를 따로 설치해야 될 것이다. J2SE 1.4.1 혹은 이후버전에 JRE를 인스톨할 때, 사용자는 사운드뱅크를 포함시키도록 설정해야 한다.

MIDI파일의 저장과 재생관련 정보는 javax.sound.midi의 documentation를, 이 팁에 대한 자세한 내용은 Java Sound API home page를 참고한다.