김군...

프로세스(Processes)

프로세스는 리눅스와 Windows에서 모두 실행 프로그램을 뜻한다. Windows에서는 .exe 확장자가 있는 파일 이름이 실행파일이다. 프로세스는 소스 파일을 컴파일 하고 실행 파일을 생산함으로서 만들어진다. 컴파일 단계는 Windows와 리눅스 모두 비슷하다:

    WINDOWS:   cl -O2 create-pt2.cpp
    LINUX  :   gcc -O2 create-pt2.cpp -lpthread -o create-pt2

위 두개의 컴파일 결과는 create-pt2.exe (Windows)와, create-pt2 (리눅스)라는 실행파일이다.

프로세스는 오픈 파일 핸들을 상속 받을 수 있다. Windows에서, 핸들이 작은 정수가 아니기 때문에 정확한 값은 알 수 없다. Windows에서 기존의 오픈 파일을 위해 핸들을 정확한 값으로 초기화 하는 것은 문서화된 프로시져가 아니다. 리눅스에서 파일 디스크립터(descriptor)를 20으로 설정하고 사용하는 것은 매우 쉽다.

일단 프로세스가 만들어지면 시작할 때 명령행에서 프로그램 이름을 타이핑 하면 된다. 리눅스와 Windows 모두 같다:

    create-pt2

Windows 프로그램의 경우, .exe 서픽스를 타이핑 할 필요가 없다. 프로그램이 실행권한이 있고 합법적인 Windows 바이너리 형식의 프로그램이라면 Windows는 모든 프로그램 이름을 실행 파일로서 인식한다. 따라서 나는 마이크로소프트 컴파일러의 아웃풋을 리눅스와 마찬가지로 create-pt2 라고 이름을 붙였다.

리눅스 프로세스 만들기

리눅스는 매개변수가 없는 단일 시스템 호출을 사용하여 새로운 프로세스를 만든다. fork 시스템 호출로 정확한 부모 프로세스 카피(copy)를 만들고 부모에게는 자식 프로세스 ID를, 자식에게는 0(zero)을 리턴한다:

        #include <sys/types.h>
        #include <unistd.h>

        pid_t child_pid;

        child_pid = fork();

        if(child_pid == -1) {
            ERROR;
        }
        else if(child_pid == 0) {
            do_child();
        }
        else {
            do_parent();
        }

Fork는 새로운 프로세스를 만들지만 어떻게 이것이 새로운 프로그램을 실행하는가? 표준 수행 방법은 다음과 같다:

        child_pid = fork();
        if(child_pid == -1) ERROR

        if(child_pid == 0) { // Child executes a new program image
            execl("/bin/view", "view", "/etc/hosts");
            ERROR;
        }
        else {               // Parent waits for child to finish (exit).
            int status;

            while(wait(&status) != child_pid);
        }

프로그램을 만들고 실행하는 코드는 깊은 의미를 가지고 있다. 프로그램은 main 으로 부터 리턴하거나 시스템 호출을 사용하여 종료한다.

Windows 프로세스 만들기

Windows 프로세스는 CreateProcess() API를 사용하여 만들어진다. 리눅스의 단순한 fork 호출과는 달리, CreateProcess API는 시도하기에 앞서 공부를 해두는 것이 필요하다.

BOOL CreateProcess(
    LPCTSTR lpApplicationName,                 // name of executable module
    LPTSTR lpCommandLine,                      // command line string
    LPSECURITY_ATTRIBUTES lpProcessAttributes, // SD
    LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SD
    BOOL bInheritHandles,                      // handle inheritance option
    DWORD dwCreationFlags,                     // creation flags
    LPVOID lpEnvironment,                      // new environment block
    LPCTSTR lpCurrentDirectory,                // current directory name
    LPSTARTUPINFO lpStartupInfo,               // startup information
    LPPROCESS_INFORMATION lpProcessInformation // process information
);

CreateProcess API는 리눅스의 execl() 시스템 호출과 비교되어야 공정하다. execl() 는 프로그램 이름과 인자는 API에 있는 스트링으로 지정되어야 하는 반면, CreateProcess()는 많은 옵션들을 제공한다.

create-pt2.cpp 프로그램은 프로세스 또는 쓰레드를 만들 수 있다. 프로세스를 만드는 코드는 다음과 같다:

    extern char *applname;
    extern char *progname;
    HANDLE t1;
    char buf[1024];
    BOOL b;
    #define errno   GetLastError()

    sprintf(buf, "%s-child", applname);
    buf[sizeof(buf)-1] = 0;

    STARTUPINFO         startInfo;
    PROCESS_INFORMATION pidInfo;

    //
    //    child process
    //
    startInfo.cb          = sizeof(STARTUPINFO);
    startInfo.lpReserved  = NULL;
    startInfo.lpTitle     = buf;
    startInfo.lpDesktop   = NULL;
    startInfo.dwX         = 0;
    startInfo.dwY         = 0;
    startInfo.dwXSize     = 0;
    startInfo.dwYSize     = 0;
    startInfo.dwXCountChars    = 0;
    startInfo.dwYCountChars    = 0;
    startInfo.dwFlags     = STARTF_USESTDHANDLES;
    startInfo.wShowWindow = 0; //SW_SHOWDEFAULT;
    startInfo.lpReserved2 = NULL;
    startInfo.cbReserved2 = 0;
    startInfo.hStdInput   = GetStdHandle(STD_INPUT_HANDLE);
    startInfo.hStdOutput  = GetStdHandle(STD_OUTPUT_HANDLE);
    startInfo.hStdError   = GetStdHandle(STD_ERROR_HANDLE);

    b = CreateProcess(
            progname,
            buf,
            NULL,
            NULL,
            TRUE,
            0,//CREATE_NEW_CONSOLE,
            NULL,
            NULL,
            &startInfo,
            &pidInfo);

    if(!b) {
        printf("Creation of child process failed: err=%d\n", errno);
        printf("applname=<%s>, buf=<%s>\n",applname,buf);
        return;
    }
    t1 = pidInfo.hProcess;

보다시피 필요한 코드의 양이 많다. 이와 유사한 리눅스의 wait() 호출을 보자:

    if(WaitForSingleObject(t1,INFINITE) == WAIT_FAILED) {
        printf("WaitForSingleObject FAILED: err=%d\n", GetLastError());
        return;
    }

Windows 프로그램은 종료 방식이 여러가지 이다. 두 가지는 리눅스와 유사하다. main 에서 리턴하거나 표준 C 라이브러리에서 exit() 루틴을 호출할 수 있다. 세 번째 옵션은 ExitProcess() API를 호출하는 것이다. 여기에서는 exit 루틴을 사용한다.

쓰레드(Threads)

쓰레드는 실행 콘텍스트(context)이다. 처음에 각 프로세스는 하나의 실행 콘텍스트를 갖는다. 이 실행 콘텍스트를 쓰레드라고 한다. 프로세스가 다른 실행 콘텍스트를 필요로 한다면 간단히 다른 프로세스를 만들 수 있다. 하지만 프로세스 생성은 프로세서 사이클과 메모리 사용의 관점에서 볼 때 사치스러운 일이다. 쓰레드는 다중 실행 콘텍스트를 만드는데 경량의(lightweight) 메커니즘을 제공하도록 되어있다. Windows와 리눅스는 한 쌍의 실행 환경을 제공할 목적으로 오퍼레이팅 시스템에서 쓰레드를 스케쥴링한다.

프로세스와 쓰레드의 가장 뚜렷한 차이는 프로세스의 모든 쓰레드가 같은 메모리 공간과 시스템 정의의 "도구(facility)"를 공유한다는 점이다. 오픈 파일 핸들(파일 디스크립터), 공유 메모리, 프로세스 동기화 프리머티브(process synchronization primitives), 현재 디렉토리 등이 "도구"이다. 글로벌 메모리가 공유되고 새로운 메모리가 할당되지 않기 때문에 쓰레드를 만드는 것은 프로세스를 만드는 것보다 간단하고 빠르다.

리눅스 쓰레드 만들기

리눅스는 POSIX 쓰레드를 지원한다. 리눅스 쓰레드는 다음의 코드로 만들어진다:

        #    define DEC    ( void *(*)(void*) )

        if(pthread_create(&t1, NULL, DEC  threadwork, NULL)) {
            printf("pthread_create A failed: err=%d\n", errno);
            return;
        }

여기에서, t1은 쓰레드 ID를 받기위해 사용되는 매개변수이다. 두 번째 인자는 많은 스케쥴링 옵션을 지원하는 쓰레드 속성 인자이다. 우리는 여기서 디폴트 세팅을 사용할 것이다. 세 번째 인자는 쓰레드를 생성할 때 실행 될 서브루틴(subroutine) 이다. 네 번째 인자는 서브루틴으로 전달된 포인터이다. 이것은 쓰레드나 새로 만들어진 쓰레드에 필요한 것을 위해 저장한 메모리를 지시할 수 있다.

리눅스 쓰레드는 서브루틴에서 리턴하거나 pthread_exit() 루틴을 호출하여 종료한다. 쓰레드가 가지고 있는 리소스는 부모 쓰레드가 pthread_join() 루틴을 호출할 때 회복된다. pthread_join()는 프로세스용 wait() 함수와 비슷하다. pthread_join()는 쓰레드에 의해 할당된 힙 메모리(heap memory)를 회복하지 않는다. 전역으로(globally) 할당된 메모리가 프로그램 또는 쓰레드에 의해 자유로워 져야 한다.

Windows 쓰레드 만들기

Windows 쓰레드는 Windows 프로세스를 만드는 것보다 훨씬 간단하다. 쓰레드를 만드는 데에는 리눅스에서 사용한 매개변수를 비롯하여 보안 디스크립터와 초기 스택 크기도 포함된다.

        t1 = CreateThread(NULL,4096,(THRDFN)threadwork,"L",NULL,&threadid);
        if(t1 == NULL) {
            printf("CreateThread FAILED: err=%d\n", errno);
            return;
        }

첫 번째 인자는 보안 디스크립터 로서 쓰레드 핸들이 상속 될 수 있을 지의 여부를 결정한다. NULL 은 이것이 상속될 수 없다는 것을 의미한다. 두 번째 인자는 스택 사이즈이다. 세 번째와 네 번째 인자는 서브루틴과 패스된 매개변수이다. 다섯 번째 인자는 플래그 인자이다. 쓰레드는 플래그가 CREATE_SUSPENDED로 설정될 때 중지 상태에서 만들어진다. 여섯 번째 인자는 결과 쓰레드 ID를 시스템에 저장한 위치를 가리킨다.

Windows 쓰레드는 호출된 서브루틴에서 리턴하거나 ExitThread() API를 호출하여 종료한다. 부모는 WaitForSingleObject(threadid)를 호출하여 쓰레드를 정리하거나 WaitForMultipleObjects() API를 사용하여 다중 이벤트를 기다릴 수 있다.

퍼포먼스 결과

프로세스와 쓰레드의 생성과 리눅스와 Windows에서 그들의 유사성을 설명하기 위해 create-pt2.cpp를 작성했다. "시간 측정 (timed-test)" 방식을 사용한다.

Linux 2.4.2 커널( Red Hat 7.2), Windows 2000 Advanced Server, Windows XP Professional에서 프로그램을 실행했다. 세 개의 오퍼레이팅 시스템은 같은 Thinkpad 600X (320 MB메모리)에서 실행되었다. 그림1과 2는 오퍼레이팅 시스템의 퍼포먼스를 나타낸다.

쓰레드와 프로세스를 만들 때 리눅스가 Windows(2000, XP)보다 상당히 빠르다는 것을 알 수 있다.

create-pt2.cpp 는 주어진 시간 간격에서 가능한 오랜 시간동안 쓰레드(프로세스)를 만들고 소멸시키는 단순한 프로그램이다. 다음과 같이 테스트를 실행했다:

    create-pt 2         # create threads for 2 seconds
    create-pt 4
    create-pt 8
    create-pt 16

    create-pt -p 2      # create processes for 2 seconds
    create-pt -p 4
    create-pt -p 8
    create-pt -p 16

두 개의 Windows 결과는 프로그램 실행이 길어질수록 퍼포먼스가 악화되었음을 나타냈다. 그림 3은 이 문제를 보여주고 있다.

Windows가 쓰레드를 생성할 때 동시에 핸들도 생성한다. 이 핸들은 쓰레드를 만들었던 프로세스 상에서 열려있다. 프로세스의 경우, Windows는 두 개의 핸들을 만든다. 하나는 프로세스 용이고 다른 하나는 그 프로세스의 실행 쓰레드용이다. 이 핸들들은 나중에 OpenProcess()이나 OpenThread() API를 이용하여 얻을 수 있기 때문에 불필요한 것들이다. 그럼에도 불구하고 그들이 닫히지 않는다면 프로그램은 계속해서 핸들을 얻을 것이고 시스템 전역의 리소스를 소비하는 결과가 된다.

create-pt2.cpp 의 첫 번째 버전은 생성된 쓰레드와 프로세스를 위해 핸들을 닫지 않았다. 쇠퇴하는 퍼포먼스는 메모리 유출을 증명하고 있다. Task Manager 를 사용하거나 프로세스 탭에 나타내기 위해 칼럼으로서 "핸들" 을 선택함으로서 create-pt2.exe 프로그램이 가진 핸들의 수는 증가한다. 핸들의 유출은 Windows 프로그램의 퍼포먼스가 실행 시간이 길어질수록 쇠퇴하는 이유가 된다.

문제를 고쳤을 때 Task Manager는 create-pt2a.cpp가 고정된 수의 핸들을 가지고 있다는 것을 나타냈다. 퍼포먼스 결과는 테스트 실행이 길어져도 더 이상 쇠퇴하지 않았다.

Windows XP는 쓰레드 생성 속도에 있어서 Windows 2000를 능가했다. 하지만 리눅스 속도의 60% 에 그치는 수준이다. 프로그램이나 측정 기술에 이상이 없는 한, Windows XP의 프로세스 생성은 Windows 2000보다 현저하게 느리고, Windows 2000의 프로세스 생성은 리눅스 보다 느리다.

요약

프로세스와 쓰레드에 대해 간단히 설명했고 내가 작성한 프로그램에서 두 가지의 프로그래밍을 설명했다. 프로세스와 쓰레드의 퍼포먼스를 측정한 결과 리눅스가 Windows 2000 이나 Windows XP 보다 빨랐다. 여러분도 테스트 스크립트 (create-pt2a-sh.sh) 와 create-pt2a.cpp용 소스 코드를 다운로드 하여 직접 실행해보기 바란다.

Windows 프로세스와 쓰레드 생성속도를 높이는 코드를 만드는 방법을 알고있다면 discussion forum에서 의견을 나눠주기 바란다.

객체 직렬화란?
- 간단히 말하면 객체를 스트림으로 보낼 수 있는 형태의 데이터로 바꿔즈는 것을 말한다.
- 직렬화가 가능한 클래스라는 것을 JVM에게 알려주기 위해서는 Serializble이라는 인터페이스를 구현한다.


코드예제)

// 클래스 -> 파일로 직렬화

Test test = new Test();

ObjectOutputStream outStream = new ObjectOutputStream(new FileOutputStream("Test.ser"));

outStream.writeObject(test);

outStream.close();

//파일 -> 클래스

ObjectInputStream in = new ObjectInputStream(new FileInputStream("Test.ser"));

Test test = (Test)in.readObject();

그래픽을 구현하는 클래스로 Graphics 클래스와 이를 상속하는 Graphics2D 클래스가 있다. Graphics2D 클래스는 JDK1.2 이후에 추가된 것으로 2D(평면) 그래픽 환경을 강력히 지원하는 고수준의 API이다. 이번 장에서는 Java2D 그래픽을 이해하고 애니메이션이나 게임과 같은 응용프로그램에 활용하는 방법을 생각해 보자.

컴포넌트에 그리기

컴포넌트의 paint 메소드는 자신을 그릴 때 호출되는 메소드이다. 이 메소드는 컴포넌트가 다시 그려질 필요가 있을 때 자동으로 호출된다. 예를 들어 컴포넌트의 일부가 어떤 것에 의해 가려진 후, 다시 보여지면 가려졌던 부분을 다시 그릴 필요가 있을 것이다. 그때 이 메소드가 호출된다. 이 메소드의 헤더는 다음과 같다.

paint 메소드의 인수로 Graphics 객체(일반적으로 Graphic context라고 함)가 넘어온다. 컴포넌트의 일부를 다시 그릴 필요가 있으면 Graphics 객체를 이용하여 컴포넌트를 그린다. 프로그래머는 paint 메소드를 오버라이드해서 컴포넌트에 원하는 그림이나 도형을 그릴 수 있다.

import java.awt.*;

public class Paint1 extends Frame{

  public Paint1(String title){               // 생성자

    super(title);

  }

  public void paint(Graphics g){

    g.drawLine(10,30,50,50);              // 선을 그린다.

    g.drawRect(60,30,50,50);             // 사각형을 그린다.

    g.drawString("Hello!",120,50);         // 문자열을 그린다.

  }

  public static void main(String[] args){

    Paint1 f=new Paint1("paint");

    f.setSize(200,100);

    f.setVisible(true);                     // 프레임이 보여질 때 paint가 호출된다.

  }

}

[그림 18-1] paint 메소드

paint 메소드는 필요에 의해 자동으로 호출된다. 하지만 화면이 가려지지 않더라도 화면을 갱신해야할 경우가 생길 것이다. 그 때는 repaint 메소드들 호출하면 된다. repaint 메소드가 호출되면 빠르게 update 메소드가 호출되고 update 메소드는 컴포넌트를 원래의 모습대로 그린 후에 paint를 호출한다.

paint 메소드를 오버라이드하지 않고도 컴포넌트에 그릴 수 있는 방법이 있다. Component 클래스의 getGraphics 메소드를 이용하는 것이다. 이 메소드는 컴포넌트의 Graphics 객체의 레퍼런스를 반환한다. 주의할 것은 컴포넌트가 보여질 수 없는 상태에서 getGraphics를 호출하면 null을 반환한다는 점이다.

다음 예제를 실행하면 Paint1과 같은 모양의 프레임이 보인다. 하지만 paint 메소드를 오브라이드하지 않았기 때문에 프레임의 일부가 가려지면 가려진 화면은 지워진다.

import java.awt.*;

public class Paint2{

  public static void main(String[] args){

    Frame f=new Frame("paint");

    f.setSize(200,100);

    f.setVisible(true);                  // 프레임을 보이게 한다.

    Graphics g=f.getGraphics();    // 프레임의 Graphics 객체를 얻어온다.

    g.drawLine(10,30,50,50);

    g.drawRect(60,30,50,50);

    g.drawString("Hello!",120,50);

  }

}

도형 그리기

Graphics 클래스는 여러 가지의 도형을 그릴 수 있는 메소드를 제공한다. Graphics 클래스는 대부분의 메소드가 추상이지만 편의상 abstract 키워드는 생략할 것이다.

다음 예제는 프레임에 각종 다각형을 그리는 것이다.

import java.awt.*;

public class Draw1 extends Frame{

  public Draw1(String title){                    // 생성자

    super(title);

  }

  public void paint(Graphics g){

    g.drawLine(10,30,50,50);                  // 직선을 그린다.

    g.drawRect(60,30,50,50);                  // 사각형을 그린다.

    g.drawRoundRect(120,30,50,50,20,20);    // 둥근 사각형을 그린다.

    g.drawOval(10,100,70,50);                 // 타원을 그린다.

    g.drawArc(100,100,50,50,90,180);          // 원호를 그린다.

    int[] x=new int[]{200,240,200,220,240};

    int[] y=new int[]{80,80,120,60,120};

    g.drawPolygon(x,y,5);                     // 다각형을 그린다.

  }

  public static void main(String[] args){

    Frame f=new Draw1("도형 그리기");

    f.setSize(300,200);

    f.setVisible(true);

  }

}

[그림 18-2] 도형 그리기

안이 색으로 채워진 도형을 그릴 때는 다음과 같은 메소드를 사용한다.

위의 메소드외에도 fillRoundRect, fillPolygon 등이 있다.

import java.awt.*;

public class Draw2 extends Frame{

  public Draw2(String title){

    super(title);

  }

  public void paint(Graphics g){

    g.fillRect(60,30,50,50);

    g.fillRoundRect(120,30,50,50,20,20);

    g.fillOval(10,100,70,50);

  }

  public static void main(String[] args){

    Frame f=new Draw2("도형 그리기");

    f.setSize(300,200);

    f.setVisible(true);

  }

}

[그림 18-3] 채워진 도형 그리기

마우스로 곡선 그리기

마우스의 버튼을 누른 채로 움직이면 마우스 포인터를 따라 곡선이 그려지도록 해보자. 움직이기 전의 마우스 좌표(ox, oy)에서 움직인 후의 마우스 좌표(x, y)까지 직선을 긋는 방법을 이용한다.

import java.awt.*;

import java.awt.event.*;

public class Draw3 extends Frame{

  Graphics g;                     // 프레임의 Graphics 객체를 위한 변수

  int x, y, ox, oy;         // 움직인 후의 좌표(x, y)와 움직이기 전의 좌표(ox, oy)

  public Draw3(String title){      // 생성자

    super(title);

    setSize(200,200);

    setVisible(true);

    g=this.getGraphics();       // 프레임의 Graphics 객체를 얻는다.

    g.setColor(Color.red);        // 그리기 색을 빨간 색으로 정한다.

    // 마우스 움직임 이벤트 처리

    addMouseMotionListener(new MouseMotionAdapter(){

        public void mouseDragged(MouseEvent e){        // 마우스가 움직이면

          x=e.getX(); y=e.getY();              // 마우스의 현재 위치를 알아온다.

          // 전 위치부터 현재 위치까지 직선을 긋는다.

          g.drawLine(ox, oy, x, y);

          ox=x; oy=y;                  // x와 y를 ox와 oy에 대입한다.

        }

    });

    // 마우스 이벤트 처리

    addMouseListener(new MouseAdapter(){

        // 마우스를 누르면 호출된다.

        public void mousePressed(MouseEvent e){

           ox=e.getX(); oy=e.getY();             // 마우스의 위치를 기억한다.

        }

    });

  }

  public static void main(String[] args){

    Frame f=new Draw3("도형 그리기");

  }

}

[그림 18-4] 곡선 그리기

이미지 그리기

로컬 컴퓨터에 있는 이미지뿐만 아니라 네트워크 상에 있는 이미지도 쉽게 불러올 수 있다. 이미지를 처리하는 과정은 크게 이미지를 불러오는 작업과 이미지를 그리는 작업으로 생각할 수 있다. 그런데 문제는 이미지를 그리는 작업은 Graphics 객체가 담당한다지만 이미지를 불러오는 작업은 Toolkit 객체가 담당한다는 것이다. 이는 이미지를 불러오는 작업과 이미지를 그리는 작업이 비동기적임 의미한다. 따라서 이미지가 완전히 다운로드 되었는지, 혹은 다운로드하고 있는 중인지하는 이미지의 상태를 추적하는 작업을 필요하다. URL 객체는 이미지의 위치를 나타낼 수 있고, MediaTracker 객체는 이미지의 상태를 추적할 수 있다.

이미지처리에 필요한 클래스와 그 역할을 정리하면 다음과 같다.

Graphics 클래스

Graphics 클래스는 이미지를 확대 또는 축소하여 그리거나 이미지의 부분 영역을 그릴 수 있는 메소드, drawImage를 제공한다. drawImage 메소드는 ImageObserver라는 객체를 인수로 받는데 ImageObserver는 이미지의 정보를 전달받아서 이미지를 업데이트시키는 역할을 한다. 이미지가 완전히 불려지지 않았을 때 drawImage를 호출하면 ImageObserver 객체에게 그 정보가 전달되고 ImageObserver는 이미지를 관찰하고 있다가 이미지가 완전히 불려지면 이미지를 업데이트시킨다. 컴포넌트 클래스가 이 인터페이스를 구현하고 있다. 따라서 이미지가 그려질 컴포넌트를 ImageObserver로 두면 된다.

Graphics 클래스는 다음과 같이 이미지를 그리는 메소드를 제공한다.

실제로 그리는 작업은 조금 후에 알아보고 Image 클래스와 URL 클래스를 살펴보자.

Image 클래스

Image 클래스는 그래픽 이미지를 표현하는 추상 클래스이다. 따라서 new 키워드를 사용하여 이미지 객체를 생성할 수는 없다. 대신에 Toolkit 객체로부터 이미지를 받아오면 된다.

또는 Component 클래스의 createImage 메소드를 이용하여 새로운 이미지를 만들 수도 있다.

이렇게 만든 이미지는 더블 버퍼링에 사용될 수 있다. Toolkit 클래스와 더블 버퍼링 기법은 조금 후에 알아보고 Image 클래스의 유용한 메소드를 살펴보자.

URL 클래스

URL 클래스는 월드와이드웹(www)상의 URL(Uniform Resource Locator)을 표현하는 클래스이다. URL은 웹 상에 있는 특정 파일의 위치를 명시하기 위한 것으로 서비스의 종류, 서버의 위치(도메인), 파일 이름으로 구성된다.

다음은 sun의 자바 홈페이지에 있는 어떤 그림에 대한 URL 객체를 생성하는 예이다.

어떤 클래스에 대한 상대 경로를 이용하여 URL 객체를 얻을 수도 있다.

import java.awt.*;

import java.net.*;                      // URL을 import한다.

public class Url1{

  public static void main(String[] args){

    Url1 ob=new Url1();

    Class cl= ob.getClass();                 // ob에 대한 클래스 객체를 얻는다.

    URL url=cl.getResource("Url1.java");    // "Url1.java"의 Url 객체를 만든다.

    System.out.println(cl.toString());

    System.out.println(url.toString());

  }

}

class Url1

file:/C:/java2/source/Url1.java

URL 클래스는 네트워크 프로그래밍 장에서 다시 살펴보자.

Toolkit 클래스

이 클래스는 이미지를 불러오거나 화면에 대한 정보를 제공한다.

getImage 메소드는 이미지의 위치(URL)만 생성할 뿐이지 이미지를 불러오는 것은 아니다. 그래픽 객체의 drawImage 메소드를 호출하면 비로소 이미지를 불러와서 그리게 된다. 이미지를 불러오는 시간이 소요되기 때문에 drawImage를 호출했을 때, 바로 그려지지 않는다. 그래서 이미지를 불러와 그릴 수 있는 상태로 만들어주는 prepareImage 메소드를 따로 만들어 두었다. 이 메소드를 호출하면 이미지를 불러오는 작업을 시작하고 이미지가 그려질 수 있는 상태가 되면 true를 반환한다. 그러나 이미지의 크기가 크거나 인터넷상에 있어서 불러오는 시간이 많이 소요되는 경우에는 prepareImage를 호출하여도 바로 준비시켜주지 못하고 false를 반환하는 경우가 있다. 이때는 다시 prepareImage를 호출하여 이미지가 준비된 상태인지 알아보아야 하는 불편함이 있다.

다음은 인터넷상에 있는 그림을 불러와 프레임에 그리는 예제이다. 그림이 존재하지 않아서 그려지지 않는다면 다른 URL을 사용해 보자.

import java.awt.*;

import java.net.*;

public class Image1 extends Frame{

  Image img;

  Toolkit tkit;

  public Image1(String title){                  // 생성자

    super(title);

    tkit=getToolkit();                // this(프레임)의 Toolkit 객체를 얻는다.

    try{

      URL url=new URL("http://java.sun.com/images/v4_java_logo.gif");

      img = tkit.getImage(url);               // url에 대한 이미지 객체를 만든다.

      tkit.prepareImage(img,-1,-1,this);     // 이미지를 준비시킨다.

    }catch(MalformedURLException e){      // URL이 이상할 경우에 발생한다.

      System.out.println("URL이 올바르지 않습니다.");

    }

  }

  public void paint(Graphics g){

     g.drawImage(img,80,80,this);             // 이미지를 그린다.

  }

  public static void main(String[] args){

    Frame f=new Image1("이미지 그리기");

    f.setSize(200,200);

    f.setVisible(true);

  }

}

[그림 18-5] 이미지 그리기

MediaTracker 클래스

미디어 트래커는 많은 이미지의 상태를 점검하는데 편리하게 사용된다. 미디어 트래커는 다운로드할 이미지를 추가하거나 제거할 수 있는 리스트를 가지고 있다. 리스트에 이미지를 추가할 때는 이미지와 함께 아이디(ID)도 함께 추가한다. ID는 중복될 수 있고 같은 ID의 이미지들은 묶어서 처리할 수 있다.

다음 예제는 이미지를 모두 불러온 후에 프레임에 그리는 예제이다. 불러오지 못한 이미지가 있으면 에러 메시지를 출력하고 프로그램을 종료할 것이다. 그러면 지정한 URL에 해당하는 이미지가 없을 수도 있으므로 URL을 바꾸어 실행해 보자.

import java.awt.*;

import java.net.*;

public class Image2 extends Frame{

  Image[] img;                         // 이미지를 위한 배열

  Toolkit tkit;

  public Image2(String title){           // 생성자

    super(title);

    tkit=getToolkit();                   // this의 툴킷 객체를 얻는다.

    img=new Image[2];                // 2개의 이미지

    URL url;

    try{

      url=new URL("http://java.sun.com/docs/books/tutorial/figures/2d/2D-1.gif");

      img[0]=tkit.getImage(url);          // 이미지 객체를 생성한다.

      url=new URL("http://java.sun.com/docs/books/tutorial/figures/2d/2D-2.gif");

      img[1]=tkit.getImage(url);         // 이미지 객체를 생성한다.

      MediaTracker mTracker =new MediaTracker(this);  // 미디어 트래커 객체

      // 미디어 트래커에 이미지를 추가한다.

      mTracker.addImage(img[0],0);                   // ID = 0

      mTracker.addImage(img[1],1);                      // ID = 1

      System.out.println("이미지 로딩중...");

      mTracker.waitForAll();             // 이미지가 완전히 로딩되도록 기다린다.

      if(mTracker.isErrorAny()){                       // 이미지에 에러가 있으면

        System.out.println("이미지 다운로드 오류");      // 메시지를 출력한다.

        System.exit(1);                               // 프로그램을 종료한다.

      }

      System.out.println("이미지 로딩 완료");

    }catch(Exception e){

      System.out.println(e);

    }

  }

  public void paint(Graphics g){

    g.drawImage(img[0],20,30,this);   // 이미지를 그린다.

    g.drawImage(img[1],20,160,this);

  }

  public static void main(String[] args){

    Frame f=new Image2("이미지 그리기");

    f.setSize(450,250);

    f.setVisible(true);

  }

}

[그림 18-6] MediaTracker 활용

Graphics2D

Graphics2D는 Graphics 클래스를 상속하는 클래스이다. 이 클래스는 2D 그래픽 환경을 강력히 지원하는 진보된 그래픽 클래스이다. AWT 컴포넌트의 paint(Graphics g) 메소드의 인수로 넘어오는 Graphics 객체는 Graphics2D 객체로 형 변환이 가능하다.

사실 컴포넌트의 그래픽 객체는 Graphics 객체가 아니라 Graphics2D 객체이기 때문에 형 변환이 가능한 것이다. Graphics2D는 JDK1.2 이후에 추가된 API로 이전의 기본적인 그래픽 환경을 강력한 2D 그래픽 환경으로 개선시켰다. 그러므로 Graphics 객체를 Graphic2D 객체로 형 변환만 하면 2D 그래픽 환경을 사용할 수 있다.

기하학적 도형

java.awt.geom 패키지를 보면 기하학적인 도형을 나타내는 클래스들이 있다. 모두 Shape(도형) 인터페이스를 구현한다. Shape 인터페이스를 구현하는 클래스의 종류로 Line2D, Rectangle2D, Ellipse2D, GeneralPath 등이 있다. 2D 환경에서는 좌표계가 확대, 축소 또는 회전이 되기 때문에 이런 클래스들은 정수가 아닌 double 또는 float으로 이루어진 좌표를 사용한다.

Graphics2D 객체의 draw와 fill 메소드를 이용하면 도형을 그릴 수 있다.

Line2D

이 클래스는 평면상의 직선을 나타내는 추상 클래스이다. 자식 클래스로 double 좌표를 사용하는 Line2D.Double과 float 좌표를 사용하는 Line2D.Float이 있다. 생성자의 인수로 두 점의 좌표 (x1, y1), (x2, y2)을 필요로 한다.

Rectangle2D

이 클래스는 평면상의 사각형을 나타내는 추상 클래스이다. 자식 클래스로 Line2D와  마찬가지로 Rectangle2D.Double과 Rectangle2D.Float이 있다. 생성자의 인수로 왼쪽 상단의 꼭지점의 좌표(x, y)와 너비, 높이가 필요하다.

Ellipse2D

이 클래스는 평면상의 타원을 구현하는 추상 클래스이다. 생성자의 인수로 타원을 포함하는 사각형의 왼쪽 상단의 좌표(x, y)와 너비, 높이가 필요하다. 너비와 높이를 같게 하면 원이 된다.

다음 예제는 Line2D와 Rectangle2D, Ellipse2D를 이용하여 직선과 사각형, 타원(원)을 그리는 예제이다.

import java.awt.*;

import java.awt.geom.*;

public class Shape1 extends Frame{

  public Shape1(String title){

    super(title);

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    Line2D line1=new Line2D.Double(50.0, 50.0, 250.0, 50.0);

    Rectangle2D rect1=new Rectangle2D.Double(50.0, 100.0, 100.0, 100.0);

    Ellipse2D ellipse1=new Ellipse2D.Double(200.0, 100.0, 100.0, 100.0);

    g2.draw(line1);

    g2.draw(rect1);

    g2.fill(ellipse1);

  }

  public static void main(String[] args){

    Frame f=new Shape1("평면 도형");

    f.setSize(350,250);

    f.setVisible(true);

  }

}

[그림 18-7] 2D 도형

GeneralPath

GeneralPath는 직선 또는 곡선으로 연결된 경로에 의해서 형성되는 도형을 구현한 클래스이다.

단순한 예제이므로 이해하기 쉬울 것으로 생각된다.

import java.awt.*;

import java.awt.geom.*;

public class Shape2 extends Frame{

  public Shape2(String title){

    super(title);

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    GeneralPath gp=new GeneralPath();  // GeneralPath 객체를 만든다.

    gp.moveTo(150,50);                  // (150, 50)으로 현재의 점을 옮긴다.

    gp.lineTo(150,250);                   // (150, 250)까지 직선을 긋는다.

    gp.lineTo(250,150);                   // (250, 150)까지 직선을 긋는다.

    gp.lineTo(50,150);                    // (50, 150)까지 직선을 긋는다.

    gp.closePath();                 // 처음 점과 끝점을 연결하여 경로를 닫는다.

    g2.draw(gp);                           // GeneralPath 객체를 그린다.

  }

  public static void main(String[] args){

    Frame f=new Shape2("GeneralPath");

    f.setSize(300,300);

    f.setVisible(true);

  }

}

[그림 18-8] GeneralPath

렌더링 속성

2D 그래픽 환경에서 도형이나 이미지를 그릴 때 선의 두께와 스타일, 칠하기 패턴과 색의 연산, 좌표의 변환 등을 적용할 수 있다. 이런 것들을 렌더링 속성(Rendering Attributes)이라고 하고 Stroke, Paint, Composite, Transform, Clip, RenderingHints 등이 있다.

Stroke 속성

스트로크(Stroke)란 도형의 외각선 모양을 결정하는 속성이다. 스트로크를 구현하는 클래스로 BasicStroke가 있다. BasicStroke 객체는 선의 두께와 스타일, 끝점(end cap)의 모양, 꼭지점(end join: 선과 선이 만나는 부분)의 모양을 설정한다.

BasicStroke를 그래픽 환경에 적용하려면 Graphics2D 객체의 setStroke 메소드를 호출한다.

다음은 Stroke를 설정하여 도형을 그리는 예제이다.

import java.awt.*;

import java.awt.geom.*;

public class Stroke1 extends Frame{

  public Stroke1(String title){

    super(title);

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    // CAP_ROUND를 사용한 직선 그리기

    g2.setStroke(new BasicStroke(30,BasicStroke.CAP_ROUND,0));

    g2.draw(new Line2D.Double(50,50,200,50));

    // JOIN_ROUND로 사각형 그리기

    g2.setStroke(new BasicStroke(30,0,BasicStroke.JOIN_ROUND));

    g2.draw(new Rectangle2D.Double(50,100,50,50));

    // JOIN_BEVEL으로 사각형 그리기

    g2.setStroke(new BasicStroke(30,0,BasicStroke.JOIN_BEVEL));

    g2.draw(new Rectangle2D.Double(150,100,50,50));

    // JOIN_MITER로 점선 그리기

    float[] dash=new float[]{10,5,5,5};

    g2.setStroke(new BasicStroke(5,0,BasicStroke.JOIN_MITER,1.0f,dash, 0));

    g2.draw(new Rectangle2D.Double(50,200,150,50));

  }

  public static void main(String[] args){

    Frame f=new Stroke1("스트로크");

    f.setSize(250,300);

    f.setVisible(true);

  }  

}

[그림 18-9] Stroke 속성

Paint 속성

이 속성은 도형의 내부를 채울 때 적용되는 속성으로 단일 색 속성, 그라데이션 속성, 타일 속성이 있다.

Paint 속성을 적용하려면 Graphics2D 객체의 setPaint 메소드들 사용한다. 단일 색으로 채우려면 다음 코드와 같이 할 수 있다.

다음으로 그라데이션 효과를 위한 GradientPaint 클래스를 살펴보자.

GradientPaint 객체를 생성하고 Graphics2D 객체에 적용하는 코드를 예로 들면 아래와 같다.

다음은 프레임의 생성자에서 네 개의 GradientPaint 객체를 생성한 후에 paint 메소드에서 GradientPaint 속성을 적용하여 사각형을 그리는 예제이다.

import java.awt.*;

import java.awt.geom.*;

public class Gradient1 extends Frame{

  Paint gPaint1, gPaint2, gPaint3, gPaint4;   // Paint 속성을 위한 변수들

  public Gradient1(String title){              // 생성자

    super(title);

    // GradientPaint 객체를 생성한다.

    gPaint1=new GradientPaint(10, 50, Color.white, 20, 60, Color.blue, true);

    gPaint2=new GradientPaint(100, 50, Color.white, 100, 30, Color.blue, true);

    gPaint3=new GradientPaint(190, 50, Color.white, 270, 250, Color.blue, false);

    gPaint4=new GradientPaint(280, 50, Color.white, 280, 250, Color.blue, false);

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    // GradientPaint를 적용하여 사각형을 그린다.

    g2.setPaint(gPaint1);

    g2.fill(new Rectangle2D.Double(10,50,80,200));

    g2.setPaint(gPaint2);

    g2.fill(new Rectangle2D.Double(100,50,80,200));

    g2.setPaint(gPaint3);

    g2.fill(new Rectangle2D.Double(190,50,80,200));

    g2.setPaint(gPaint4);

    g2.fill(new Rectangle2D.Double(280,50,80,200));

  }  

  public static void main(String []args){

    Frame f=new Gradient1("그라데이션 효과");

    f.setSize(400,300);

    f.setVisible(true);

  }

}

[그림 18-10] 그라데이션 효과

마지막으로 TexturePaint는 작은 그림을 반복적으로 채우기 위한 클래스이다. 작은 그림으로 BufferedImage 객체를 사용하는데 BufferedImage 클래스는 이미지의 각 픽셀의 정보를 버퍼에 기억하고 있어 프로그래머는 그 버퍼에 직접 접근하여 이미지의 정보를 바꿀 수 있다. 따라서 BufferedImage를 사용하면 이미지를 다양하게 처리할 수 있다.

image type은 하나의 픽셀이 차지하는 비트 수와 RGB의 정보를 나타내는 것으로 상수로 정의 되어있다. 예를 들어 TYPE_INT_RGB은 한 픽셀의 크기가 4바이트(Int)이고 RGB는 각각 8비트씩 차지하는 이미지 타입을 나타낸다.

TexturePaint 속성은 BufferedImage 객체와 더불어 이미지를 맵핑시키는 사각형 영역에 대한 정보를 필요로 한다. 이 영역을 앵커(anchor)라고 하고 Rectangle2D 객체로 표현한다. TexturePaint 속성은 다음 그림과 같이 앵커를 기준으로 모든 방향으로 BufferedImage을 채운다.

실제로 TexturePaint 클래스의 생성자는 다음과 같다.

다음은 TexturePaint 속성으로 도형을 그리는 예제이다.

import java.awt.*;

import java.awt.geom.*;

import java.awt.image.*;

public class Texture1 extends Frame{

  Paint tPaint1, tPaint2, tPaint3, tPaint4;    // TexturePaint 속성을 위한 변수들

  public Texture1(String title){             // 생성자

    super(title);

    // 10×10 크기의 BufferedImage 객체를 만든다.

    BufferedImage buf=

               new BufferedImage(10,10,BufferedImage.TYPE_INT_RGB);

    // BufferedImage 객체의 Graphics2D 객체를 얻는다.

    Graphics2D g2buf=(Graphics2D)buf.getGraphics();

    // BufferedImage 객체에 채워진 원을 그린다.

    g2buf.setPaint(new Color(100,100,255)); // Paint 설정

    g2buf.fill(new Ellipse2D.Float(0,0,10,10)); // 채워진 원

    // 네 개의 TexturePaint 객체를 만든다.

    tPaint1=new TexturePaint(buf, new Rectangle.Float(10,50,10,10));

    tPaint2=new TexturePaint(buf, new Rectangle.Float(100,50,15,15));

    tPaint3=new TexturePaint(buf, new Rectangle.Float(190,50,20,20));

    tPaint4=new TexturePaint(buf, new Rectangle.Float(280,50,25,25));

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    // TextPaint 객체를 적용하여 네 개의 사각형을 그린다.

    g2.setPaint(tPaint1);

    g2.fill(new Rectangle2D.Double(10,50,80,200));

    g2.setPaint(tPaint2);

    g2.fill(new Rectangle2D.Double(100,50,80,200));

    g2.setPaint(tPaint3);

    g2.fill(new Rectangle2D.Double(190,50,80,200));

    g2.setPaint(tPaint4);

    g2.fill(new Rectangle2D.Double(280,50,80,200));

  }  

  public static void main(String []args){

    Frame f=new Texture1("타일 효과");

    f.setSize(400,300);

    f.setVisible(true);

  }

}

[그림 18-11] 타일 효과

Composite 속성

합성(Composite)은 이미지와 이미지가 겹칠 때 색상을 조합하는 속성이다. Composite를 구현하는 클래스로 AlphaComposite가 있다.

AlphaComposite 객체를 생성하려면 static 멤버인 getInstance 메소드를 이용한다.

합성 규칙으로는 CLEAR, SRC_IN, SRC_OVER 등이 있는데 대표적으로 SRC_OVER 규칙으로 합성하면 그리는 이미지가 반투명하게 그려진다. 투명도가 0.0f이면 이미지가 완전 투명하게 그려지며 1.0f이면 완전 불투명하게 그려진다.

Graphics2D 객체의 setComposite 메소드를 사용하면 합성 속성이 적용된다.

다음 예제는 투명 효과를 테스트해 보는 것이다.

import java.awt.*;

import java.awt.geom.*;

import java.awt.image.*;

public class Composite1 extends Frame{

  public Composite1(String title){

    super(title);

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    // 빨간 원을 그린다.

    g2.setPaint(Color.red);

    g2.fill(new Ellipse2D.Float(50,50, 100,100));

    // 파란색 Paint 설정

    g2.setPaint(Color.blue);

   // 투명도를 0.0에서 0.01씩 증가시키며 원을 그린다.

    for(float i=0.0f; i<=1.0f;i+=0.01f){

      g2.setComposite(

             AlphaComposite.getInstance(AlphaComposite.SRC_OVER, i)

      );

      g2.fill(new Ellipse2D.Float(100,50,100,100));

      try{

        Thread.sleep(100);        // 변화를 관찰하기 위해 간격을 둔다.

      }catch(Exception e){}

    }

  }

  public static void main(String []args){

    Frame f=new Composite1("투명 효과");

    f.setSize(250,200);

    f.setVisible(true);

  }

}

[그림 18-12] 투명 효과

Transform 속성

java2D 환경은 좌표를 자유롭게 변환할 수 있는 강력한 인터페이스를 기본으로 제공한다.

java.awt.geom 패키지의 AffineTransform 클래스는 좌표의 평행 이동, 회전, 스케일링(확대/축소), 반전(flip), 변형(shearing)의 좌표 변환을 구현한다. 이러한 좌표 변환은 3 × 3 행렬로 표현되고 이 행렬과 좌표 (x, y)를 곱하여 변형된 좌표 (x', y')를 구한다.

좌표 변환에 사용되는 3 × 3 행렬을 변환 행렬이라고 하며 변환 행렬 각 원소의 기능은 다음과 같다.

좌표를 원하는 형태로 자유자재로 변환하려면 선형 대수에 대한 기초 지식이 있어야 할 것이다. 하지만 기본적인 좌표 변환은 AffineTransform 클래스와 Graphics2D가 제공하기 때문에 편리하게 이용할 수 있다.

 setTransform 메소드를 사용하면 AffinTransform 객체를 Graphics2D에 적용할 수 있다.

Graphics2D도 다음과 같은 좌표 변환 메소드를 직접 제공하고 있어서 쉽게 좌표를 변환할 수 있다.

다음은 프레임의 원점을 가운데로 평행 이동시키고 x축과 y축을 Line2D로 그려보는 예제이다.

import java.awt.*;

import java.awt.geom.*;

public class Transform1 extends Frame{

  public Transform1(String title){

    super(title);

  }

  public void paint(Graphics g){

    Graphics2D g2=(Graphics2D)g;

    g2.translate(100, 100);                // 원점을 (100, 100)로 이동시킨다.

    g2.draw(new Line2D.Float(-100, 0, 100, 0));     // x축을 그린다.

    g2.draw(new Line2D.Float(0, -100, 0, 100));     // y축을 그린다.

    g2.fill(new Ellipse2D.Float(50, 50, 20, 20));      // (50, 50)에 원을 그린다.

  }

  public static void main(String []args){

    Frame f=new Transform1("평행 이동");

    f.setSize(200, 200);

    f.setVisible(true);

  }

}

[그림 18-13] 평행 이동

다음으로 원점을 중심으로 회전하는 변환에 대한 예제를 해보자. "시계 방향" 버튼을 누르면 시계 방향으로 좌표축이 15도 회전하고, "반 시계 방향" 버튼을 누르면 시계 반대 방향으로 좌표축이 15도 회전할 것이다.

import java.awt.*;

import java.awt.geom.*;

import java.awt.event.*;

public class Transform2 extends Frame implements ActionListener{

  int theta;

  Button clockwise=new Button("시계 방향");

  Button counterClockwise=new Button("반 시계 방향");

  Graphics2D g2;

  public Transform2(String title){               // 생성자

    super(title);

    setLayout(new FlowLayout());              // 레이아웃 변경

    add(clockwise);                           // 버튼 추가

    add(counterClockwise);

    clockwise.addActionListener(this);          // 이벤트 처리

    counterClockwise.addActionListener(this);

  }

  public void actionPerformed(ActionEvent ae){

    if(ae.getSource()==clockwise)                  // "시계 방향" 버튼을 누르면

      theta=15;                                   // 회전각을 15도로 한다.

    else if(ae.getSource()==counterClockwise)     // "반 시계 방향" 버튼을 누르면

      theta=-15;                                  // 회전각을 -15도로 한다.

    repaint();                                    // paint를 호출한다.

  }

  public void paint(Graphics g){

    if(g2==null){

      g2=(Graphics2D)getGraphics();

      g2.translate(150,150);                         // 좌표 축 이동

    }

    g2.rotate(Math.toRadians(theta));              // theta만큼 회전한다.

    g2.draw(new Line2D.Float(-100, 0, 100, 0));     // 축과 원을 그린다.

    g2.draw(new Line2D.Float(0, -100, 0, 100));

    g2.fill(new Ellipse2D.Float(50, 50, 20, 20));

  }  

  public static void main(String []args){

    Frame f=new Transform2("좌표축 회전");

    f.setSize(300, 300);

    f.setVisible(true);

  }

}

[그림 18-14] 좌표축 회전

Graphics2D와 AffineTransform의 scale 메소드를 사용하면 좌표계를 확대, 축소, 또는 반전시킬 수 있다.

다음은 좌표축의 확대, 축소, 반전을 테스트해보는 것이다. 이전의 예제와 그 구성이 비슷하므로 이해하기 어렵지 않을 것이다.

import java.awt.*;

import java.awt.geom.*;

import java.awt.event.*;

public class Transform3 extends Frame implements ActionListener{

  double scale=1;

  Button flipX=new Button("x축 반전");

  Button flipY=new Button("y축 반전");

  Button scaleUp=new Button("2배 확대");

  Button scaleDown=new Button("1/2로 축소");

  Graphics2D g2;

  public Transform3(String title){               // 생성자

    super(title);

    setLayout(new FlowLayout());

    add(flipX); add(flipY); add(scaleUp); add(scaleDown);

    flipX.addActionListener(this); flipY.addActionListener(this);

    scaleUp.addActionListener(this); scaleDown.addActionListener(this);

  }

  public void actionPerformed(ActionEvent ae){

    if(ae.getSource()==flipX)

      g2.scale(1, -1);      // 좌표계를 x축을 중심으로 반전한다

    else if(ae.getSource()==flipY)

      g2.scale(-1, 1);      // 좌표계를 y축을 중심으로 반전한다.

    else if(ae.getSource()==scaleUp)

      g2.scale(2, 2);       // 좌표계를 2배 확대한다.

    else if(ae.getSource()==scaleDown)

      g2.scale(0.5, 0.5);   // 좌표계를 1/2로 축소한다.

    repaint();

  }

  public void paint(Graphics g){

    if(g2==null){

      g2=(Graphics2D)getGraphics();

      g2.translate(150,150);

    }

    g2.draw(new Line2D.Float(-100, 0, 100, 0));

    g2.draw(new Line2D.Float(0, -100, 0, 100));

    g2.fill(new Ellipse2D.Float(50, 50, 20, 20));

  }  

  public static void main(String []args){

    Frame f=new Transform3("스케일링");

    f.setSize(300, 300);

    f.setVisible(true);

  }

}

[그림 18-15] 스케일링

Clip 속성

클립(Clip)이란 그리기 작업이 수행될 영역을 말한다. 일단 클립 영역이 지정되면 클립 영역 이외의 영역에는 그려지지 않는다. 따라서 관심 있는 영역에만 그리기 작업을 하려면 클립 영역으로 정하면 된다. 사각형 모양의 영역뿐만 아니라 Shape를 구현하는 도형도 클립 영역이 될 수 있다.

다음은 사진의 이미지를 타원 모양의 클립 영역에 그리는 예제이다.

import java.awt.*;

import java.awt.geom.*;

public class Clip1 extends Frame{

  Image img;

  public Clip1(String title){                  // 생성자

    super(title);

    // 이미지 객체를 생성한다.

    img=getToolkit().getImage(getClass().getResource("/images/baby.gif"));

  }

  public void paint(Graphics g){

    // 클립 영역을 지정하고 이미지를 그린다.

    g.setClip(new Ellipse2D.Float(50,30,180,260));

    g.drawImage(img, 0,0, this);

  }

  public static void main(String []args){

    Frame f=new Clip1("클리핑");

    f.setSize(300, 300);

    f.setVisible(true);

  }

}

[그림 18-16] 클리핑

더블 버퍼링

더블 버퍼링은 도형이나 그림을 컴포넌트에 바로 그리지 않고 다른 곳의 버퍼에 도형이나 그림을 그린 다음에 버퍼에 그려진 이미지를 컴포넌트에 그리는 기법을 말한다. 애니메이션이나 게임과 같이 짧은 시간에 많은 이미지를 그리면 화면에 깜빡임이 생기거나 그리는 작업 과정이 보인다. 이런 경우에 더블 버퍼링을 이용하여 한번에 그리면 화면에 그리는 작업 과정이 보이지 않으며 화면의 깜빡임이 줄어든다.

[그림 18-17] 더블 버퍼링

여기서 버퍼란 Image 클래스의 객체로 구현된다. Image 객체를 생성한 후, 그 Image 객체의 그래픽 객체를 얻어와서 그리기 작업을 하면 된다. 이때 버퍼의 크기는 컴포넌트의 크기와 같아야 할 것이다.

더블 버퍼링을 사용하면 이미지를 버퍼에 그리는 동안 컴포넌트에는 그리지 않기 때문에 컴포넌트에 바로 그리는 경우보다 속도 면에서 조금은 늦을 것이다. 따라서 그리는 작업을 최소화하여 반응속도를 개선하는 것이 좋다.

다음은 더블 버퍼링을 사용한 경우와 그렇지 않은 경우를 비교하기 위한 예제이다. 시스템에 따라 정도의 차이가 있으나 더블 버퍼링을 하지 않은 경우에 화면이 깜빡이는 것을 확인할 수 있다.

import java.awt.*;

import java.awt.event.*;

public class DBuffering1 extends Frame implements ActionListener{

  Button b1= new Button("바로 그리기");

  Button b2= new Button("버퍼 사용하기");

  public DBuffering1(String title){               // 생성자

    super(title);

    setLayout(new FlowLayout());

    add(b1);                                    // 버튼을 추가한다.

    add(b2);

    b1.addActionListener(this);                   // 이벤트 처리를 한다.

    b2.addActionListener(this);

  }

  // 그래픽 객체 g에 color색으로 직선을 긋는 메소드

  private void drawLines(Graphics g, Color color){

    g.setColor(color);

    for(int i=0;i<getHeight();i++){                   // 선으로 채운다.

      g.drawLine(0,i,getWidth(),i);

    }

  }

  private void drawOnFrame(){              // 프레임에 바로 그리는 메소드

    Graphics g=getGraphics();

    g.clearRect(0,0,getWidth(),getHeight());    // 프레임에 그려진 이미지를 지운다.

    drawLines(g,Color.red);                   // 프레임에 빨간 색으로 선을 그린다.

  }

  private void drawOnBuffer(){        // 버퍼에 그려서 프레임에 복사하는 메소드

    // 프레임과 같은 크기의 버퍼를 생성한다.

    Image buffer=createImage(getWidth(), getHeight());

    Graphics g=buffer.getGraphics();         // 버퍼의 그래픽 객체를 얻는다.

    drawLines(g, Color.blue);                // 버퍼에 파란색으로 선을 그린다.

   // 버퍼에 그려진 이미지를 프레임에 그린다.

    getGraphics().drawImage(buffer,0,0,this);

  }

  public void actionPerformed(ActionEvent ae){

    if(ae.getSource()==b1)               // b1을 누르면

      drawOnFrame();                  // 프레임에 바로 그린다.

    else if(ae.getSource()==b2)          // b2를 누르면

      drawOnBuffer();                 // 버퍼에 그려서 프레임에 복사한다.

  }

  public static void main(String []args){

    Frame f=new DBuffering1("더블 버퍼링");

    f.setSize(300, 300);

    f.setVisible(true);

  }

}

[그림 18-18] 더블 버퍼링 테스트

java2D 그래픽은 나중에 Applet 게임과 네트워크 게임을 만들 때 응용되어진다.

-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256M
-vmargs
-Dosgi.requiredJavaVersion=1.5
-Xms40m
-Xmx512m   
이부분에서
맨 마지막의 -Xms40m와 -Xmx512m을 각각 -Xms128과 -Xmx256m으로 고치기.

-Xms와 -Xmx는 JVM이 차지하는 최소메모리와 최대메모리를 설정하는 옵셥임.
최대메모리가 너무 높아 다른 프로그램의 메모리 영역과 충돌하여 발생하는 것임.

Scalable Vector Graphics (SVG) 1.1 [W3C Recommendation]은 2차원 그래픽을 기술하는 언어이다.
일부 래스터 그래픽 기능도 사용할 수 있지만, 기본적으로는 벡터 그래픽 언어이다. SVG는 실질적이고
유연한 그래픽 포맷을 XML에 제공한다는 목표를 갖고 있으며, 이 부분에서 성공을 거두었다.
SVG의 기능에는 중첩된 변형, 클리핑 경로, 알파 마스크, 래스터 필터 효과, 템플릿 객체 등이 포함되어 있고,
확장성도 우수하다. SVG는 애니메이션, 줌과 플래닝 뷰, 다양한 그래픽 명령어, 그룹핑, 스크립팅, 하이퍼링크,
구조화 된 메타데이터, CSS, 특화된 DOM 수퍼세트, 기타 XML 문서로의 임베딩을 지원한다. SVG의 일부
디자인은 벡터 경로가 개별 애트리뷰트 내에서 공간 한정적인 숫자 리스트로 표현된다는 점에서 논란이
되고 있지만, 메인 SVG는 가장 광범위하게 XML 애플리케이션들을 포용하고 있다. 이 스팩은 여러 언어들로
번역되었다.

SVG 1.1은 XHTML 1.1+과 비슷한 방식으로 모듈화 되었다. Mobile SVG Profiles: SVG Tiny and SVG Basic
[W3C Recommendation]에서는 모바일 폰과 PDA에 적합한 감소된 SVG 모듈을 정의하고 있다. SVG 1.2 [개발중]는 SVG를 완벽한 애플리케이션 플랫폼으로 만드는 새로운 툴과 그래픽 포맷을 추가했다.

import java.awt.event.*; // 각 컴포넌트에 대한 이벤트를 작성하기 위한 패키지
import javax.swing.*; // 스윙 컴포넌트를 사용하기위한 패키지
import java.net.*; // 네트워크 클래스를 사용하기 위한 패키지
import java.io.*; // 입출력 스트림을 사용하기 위한 패키지

public class MailSender extends JFrame implements ActionListener{

    // 보낸이, 받는이, 제목을 입력 받기 위한 텍스트 상자

    //private JTextField from, to, suject;

    private JTextField from, to, subject;

    // 메일 본문 작성으로 위한 텍스트 상자
    private JTextArea data;

    // 메일보내기 버튼, 모든 텍스트상자 지우기버튼, 종료 버튼
    private JButton send, clear, exit;

    // SMTP서버에 접속하기 위한 서버주소와 도메인을 담는 변수
    private String server, domain;

    // MailSender 생성자(객체 생성시 자동으로 호출)

 //public void MailSender(String server, String domain) { 생성자는 반환형이 없음

    public MailSender(String server, String domain) {

         // 부모 클래스의 생성자를 호출해 창의 제목을 설정
        //Super("send Mail");

        super("send Mail");

        // 생성자로 넘어온 SMTP서버의 주소와 도메인을 각 변수에 할당
        this.server = server;
        this.domain = domain;
  

        // 각 컴포넌트를 생성해 이벤트연결
        from = new JTextField();
        to = new JTextField();
        subject = new JTextField();
        data = new JTextArea();
        send = new JButton("SEND");
        send.addActionListener(this);
        clear = new JButton("CLEAR");
        clear.addActionListener(this);
        exit = new JButton("EXIT");
        exit.addActionListener(this);

        // 각 컴포넌트를 패널에 위치 시킴

        JPanel c = new JPanel(new PositionLayout());
        c.add("5%, 2%, 20%, 9%", new JLabel("FROM: "));
        c.add("25%, 2%, 95%, 9%", from);
        c.add("5%, 11%, 20%, 18%", new JLabel("To: "));
        c.add("25%, 11%, 95%, 18%", to);
     //c.add("5%, 20%, 20%, 27%", new JLable("SUBJECT: "));

        c.add("5%, 20%, 20%, 27%", new JLabel("SUBJECT: "));
     //C.add("25%, 20%, 95%, 27%", subject);

        c.add("25%, 20%, 95%, 27%", subject);
        c.add("5%, 29%, 20%, 34%", new JLabel("DATA: "));
        c.add("5%, 35%, 95%, 85%", new JScrollPane(data));
        c.add("8%, 88%, 28%, 95%", send);
        c.add("40%, 88%, 60%, 95%", clear);
        c.add("72%, 88%, 92%, 95%", exit);
 

         // 컴포넌트들을 담고 있는 패널을 프레임에 추가 시킴
      //SetContentPane(c);

        setContentPane(c);

        // 기본 닫힘명령 설정
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        // 프레임의 사이즈 설정
        setSize(400, 450);

        // 프레임을 띄움.
        setVisible(true);
    }

    // 이벤트 핸들러
    public void actionPerformed(ActionEvent e){

        // 이벤트를 발생한 객체를 가져옴
        Object c = e.getSource();

        // 서버로 부터 수신된 응답 메시지를 담기위한 변수
        String incoming;

        // exit버튼을 눌렀을경우 프레임을 닫고 프로그램 종료

        if(c==exit) {
         //setvisible(false);

            setVisible(false);
            System.exit(0);

        // clear버튼을 눌렀을경우 모든 텍스트 상자 초기화
        }else if(c==clear) {
            from.setText("");
            to.setText("");
            subject.setText("");
            data.setText("");

        // send버튼을 눌렀을 경우 SMTP서버로 접속 후 메일을 보냄.
        }else if(c==send) {
            try{

                // SMTP서버에 접속 하기위한 소켓 생성(SMTP서버 Def.Port:25)
                Socket s = new Socket(server, 25);

                // 서버로 송신하기 위한 출력 스트림을 얻어온다.
                PrintStream out = new PrintStream(s.getOutputStream(), true);

                // 서버로 부터 수신된 데이터를 받기위한 입력 스트림을 얻어온다.
             //BufferedReader in = new BufferedReader(new InputStreamReader(s.GetInputStream()));

                BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));

                // 서버로 연결 요청 메시지를 송신한다.
                out.println("HELO"+domain);

                // 서버로 부터의 응답메시지를 수신 한다.
                incoming = in.readLine();

                // 서버로 메일 보낸이에 대한 정보를 송신 한다.
                out.println("MAIL FROM: < "+from.getText()+" >");

                // 서버로 부터의 응답메시지를 수신 한다.
                incoming = in.readLine();

                // 서버로 메일 받는이에 대한 정보를 송신 한다.
                out.println("RCPT TO:< "+to.getText()+" >");

                // 서버로 부터의 응답메시지를 수신 한다.
                incoming = in.readLine();

                // 서버로 데이터를 보낸다는 메시지를 송신한다.
                out.println("DATA");

                // 서버로 부터의 응답메시지를 수신 한다.
                incoming = in.readLine();

                // 서버로 메일 제목을 송신 한다.
                out.println("Subject: "+subject.getText());

                // 서버로 부터의 응답메시지를 수신 한다.
                incoming = in.readLine();

                // 본문 내용의 끝에 캐리지리턴값과 라인피드값을 합친 내용을 서버에 전송
                String msg = data.getText();
               out.println(msg+"\r\n.\r\n");

               // 서버로 부터의 응답메시지를 수신 한다.
               incoming = in.readLine();

               // 서버로 종료한다는 메시지를 송신 한다.
               out.println("QUIT");

               // 각 텍스트 상자들의 값을 초기화 한다.

               to.setText("");
               subject.setText("");
               data.setText("");

           // try{}구문에서 예외 발생시 예외 처리 부분..
           }catch(Exception ex){
               ex.printStackTrace();

           }
        }

    }

    public static void main(String args[]) {

        // 프로그램을 실행시 아규먼트 2개가 넘어오지 않았을경우
     //if(args.length(2)){  length는 메소드가 아님

        if(args.length != 2){

            // SMTP서버의 주소와 도메인을 객체에 생성자를 통해 객체 생성
            new MailSender("localhost", "mokpo.ac.kr");
        }else{ // 프로그램을 실행시 아규먼트가 넘어 왔다면

            // SMTP서버의 주소와 도메인을 객체에 생성자를 통해 객체 생성
         //new MailSender(args[0], arg[1]);

            new MailSender(args[0], args[1]);
        }
    }
}