블로그 이미지
좋은느낌/원철
이것저것 필요한 것을 모아보렵니다.. 방문해 주셔서 감사합니다..

calendar

 «  » 2024.4
일 월 화 수 목 금 토
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30

Notice

    2009. 9. 30. 17:25 개발/Java

    객체 ( 부제 : 클래스 ) - 김춘수 시인의 꽃 패러디

    객체

     

    메인이 인스턴스를 생성하기 전에는 
    클래스는 다만 
    코드에 지나지 않았다

     

    메인이 인스턴스를 생성했을 때 
    클래스는 메모리에 올라가서 
    객체가 되었다  

     

    메인이 인스턴스를 생성한 것처럼
    클래스의 이 변수와 메소드에 알맞는 
    누가 인스턴스를 생성해다오 
    메모리에 올라가서 
    객체가 되고 싶다

     

    클래스는 모두 
    객체가 되고 싶다 
    클래스는 컴퓨터에 컴퓨터는 클래스에 
    지워지지 않는 
    하나의 프로그램이 되고 싶다

     

     

    ==========================================

    김춘수 님의 꽃을 패러디해보았습니다..

    한 번 웃어 보아요~~

    posted by 좋은느낌/원철
    2009. 5. 18. 19:40 개발/Java

    jdk 설치

    좋은 링크를 발견해서 그대로 따라 했더니 잘 됐습니다.
    http://news.softpedia.com/news/How-to-Install-Java-in-Fedora-Core-6-39724.shtml
    학교 인터넷이 느린건지 접속이 상당히 느리네요.

    1. 설치할 jdk(or jre) 다운로드
    rpm 버전이 아니라 그냥 self-extracting 파일입니다.
    사용자 삽입 이미지

    2. 설치할 폴더로 파일 이동
    mv jdk-6u1-linux-i586.bin /opt

    3. 설치할 폴더로 이동하여 권한 설정을 변경합니다.
    cd /opt
    chmod +x jdk-6u1-linux-i586.bin

    4. 설치합니다.
    ./jdk jdk-6u1-linux-i586.bin

    5. 다운 받은 파일 제거 합니다.
    rm -rf jdk-6u1-linux-i586.bin

    6. 파이어폭스의 플러그인에서 사용하는 java의 링크를 변경합니다.
    ln -s /opt/jdk1.6.0_01/jre/plugin/i386/ns7/libjavaplugin_oji.so /usr/local/firefox/plugins/libjavaplugin_oji.so
    자세한 경로는 저와 다를 수 있습니다. 각각 자바 설치 폴더와 파이어폭스 설치 폴더로 변경해 주시면 됩니다.

    7. 패스 설정
    vi /etc/profile.d/java.sh
    편집기 열고 다음과 같이 패스를 넣어 줍니다.
    export J2RE_HOME=/opt/jdk1.6.0_01/jre
    export PATH=$J2RE_HOME/bin:$PATH

    8. 위에서 만든 파일을 사용하도록 합니다.
    source /etc/profile.d/java.sh

    9. 패스 설정 확인
    which java
    명령으로 방금 설치한 java 디렉토리가 나오는지 확인합니다.

    10. 시스템에서 사용할 java 변경
    /usr/sbin/alternatives --install /usr/bin/java java /opt/jdk1.6.0_01/jre/bin/java 2
    /usr/sbin/alternatives --config java
    마지막 줄에서 선택 가능한 java가 두 개 나올 것 입니다. 이 때 2 를 입력합니다.

    11. 변경 됐는지 확인
    /usr/sbin/alternatives --display java

    12. 마지막으로 자바 버전 확인
    java -version1
    posted by 좋은느낌/원철
    2009. 4. 16. 11:30 개발/Java

    javac 의 옵션들

    출처 : http://blog.naver.com/bbellsek/150002233551 

    자바 컴파일과 실행 에 사용되어지는 javac, java 명령어의 옵션 을 다음과 같이 정리하였습니다.


    javac - 자바컴파일러로써, 자바코드를 작성한 소스파일(.java)을 자바 가상머신이 인식할수 있는 바이트 코드(.class)
    타입으로 변환시켜주는 명령어 입니다.

    사용법: javac <options> <souce files>
    예를들어, Hello.java, Greeting.java 두개의 파일이 존재한다면,
    javac Hello.java Greeting.java
    javac *.java (*을 사용해서, 모든 확장자가 .java인 파일을 컴파일할수 있다.)

     

    1) 옵션:


    a) -classpath:

     -classpath(cp) path(파일 절대 경로):
     컴파일러가 컴파일 하기 위해서 필요로 하는 참조할 클래스 파일들을 찾기 위해서 컴파일시 파일 경로를 지정해주는
    옵션. 예를 들어,  Hello.java파일이 C:Java 디렉터리에 존재하고, 필요한 클래스 파일들이 C:JavaEngclasses에 위치한다면,
    javac -classpath C:JavaEngclasses C:JavaHello.java 로 해주면 된다. 만약 참조할 클래스 파일들이 C:JavaEngclasses외의 
    다른 디렉터리에도 존재한다면, C:JavaKorclasses 일경우, 
    javac -classpath C:JavaEngclasses;C;JavaKorclasses C:JavaHello.java
    그리고, 현재 디렉터리역시 포함하고 싶다면,
    javac -classpath .;C:JavaEngclasses;C;JavaKorclasses C:JavaHello.java
    기본적으로, dos에서는 .는 현재 디렉터리를 의미하고, ..는 현재 디렉터리의 상위디렉터리를 의미한다. 
    또한 classpath 대신 단축어인 cp를 사용해도 된다.
    javac -cp C:JavaEngclasses C:JavaHello.java 

     

    b) -d: 
     -d directory
     클래스 파일을 생성할 루트 디렉터리를 지정합니다.
    기본적으로 컴파일러는 -d옵션을 주지 않으면, 소스파일이 위치한 디렉터리에 클래스 파일을 생성시킵니다.
    예를 들어,  Hello.java파일이 C:Java 디렉터리에 존재하고 클래스 파일의 루트디렉터리를 C:JavaClassfiles라고 하면, 
    javac -d C:JavaClassfiles C:JavaHello.java 입니다.

    만약 -d 옵션을 사용하려고 하는데, 루트디렉터리(위예에서는 C:JavaClassfiles) 가 존재 하지 않는다면, 
    "The system cannot find the path specified"라는 에러 메시지를 보게 됩니다. 
    현재 작업 디렉터리가 C:JavaClassfiles 에 위치하면, 
    javac -d .Classfiles Hello.java 와 같이 상대 디렉터리로 표현할수 있습니다.

     

    c) -encoding:
    -encoding encoding name
    소스 파일에 사용된 문자열 인코딩을 설정합니다.
    만약 위옵션이 설정되어 있지 않으면, 플래폼의 기본적인 컨버터가 사용되어 집니다.

     

    d) -g:
    모든 디버깅 정보를 생성시킵니다.
    만약 위옵션이 설정되어 있지 않으면, 기본적으로, 라인넘버만 생성시킵니다.
    -g:none: 디버깅 정보를 전혀 생성 시키지 않습니다.
    -g:{lines, vars, source}:
    위처럼 명시적으로, 몇몇 디버깅 정보를 생성시킬수 있습니다.
    lines은 라인정보, vars는 지역변수, sounce는 소스 파일 정보를 나타냅니다.

     

    e) -nowarn:

    경고 메시지 (warning message)를 생성시키지 않습니다.

     

    f) -verbose:

    컴파일러와 링커가 현재 어느 소스파일이 컴파일되고 있고, 어느 파일이 링크되고 있는지 
    그정보를 출력한다.

     

    h) -deprecation:

    소스 코드내에서, 사용되어진 deprecated API의 위치 를 출력 합니다.

    ex)
    C:Java> javac World.java
    Note: World.java uses a deprecated API. Recompile with "-deprecation" for details
    .
    1 warning
    C:Java> javac -deprecation World.java
    World.java:52: Note: The method java.awt.Dimension size() in class java.awt.Compon
    ent has been deprecated.
    Dimension d = size();

    Note: World.java uses a deprecated API. Please consult the doc-umentation for a be
    tter alternative.

     

    i) -sourcepath:

    -sourcepath 소스패스

    소스파일의 위치를 지정합니다.

     

    j) -target:

    -target 자바버젼

    지정된 자바버젼의 VM에서 작동 되어지도록 클래스파일을 생성 시킵니다.

    1.1
    jvm 1.1 버젼에서 호환되어질수 있는 클래스 파일생성
    1.2
    jvm 1.2 버젼에서 호환되어질수 있는 클래스 파일생성
    1.3
    jvm 1.3 버젼에서 호환되어질수 있는 클래스 파일 생성

    ex)

    javac -target 1.2 Helloworld.java 

     

    k) -bootclasspath 패스:

    특정한 bootstrap또는 확장 클래스를 지정할수 있다.
    기본적으로, 자바컴파일러는 javac(컴파일러명령)이 설치된 플래폼의 bootstrap과 확장클래스들을 통해서, 컴파일작업을 수행하지만,
    bootclasspath 옵션을 사용하면, cross-compiling이라고 해서, 다른 자바플래폼의 bootstrap과 확장클래스들을 통해서, 컴파일 할수 있는 기능을 지원한다.
    예를들어,
    javac -target 1.1 -bootclasspath jdk1.1.7/lib/classes.zip -extdirs "" OldCode.java
    컴파일러에게 현재 자신의 bootstrap을 사용하지 말고, jdk1.1.7/lib/classes.zip bootstrap클래스들을 사용해서 컴파일 하라고
    명령하는것이다.
    참고로, 모바일자바에서, 모바일폰에 설정된, jvm에 맞도록, 소스코드를 컴파일하기 위해서, 주로 사용되어지는 옵션이다.

     

     

    l) -extdirs 디렉터리:
    특정한, 확장 디렉토리를 지정한다.cross-compiling시 주로, 사용되어지는 옵션이면, 각디렉터리들은 콜론(:)에 의해서, 분리되어진다.
    컴파일시, 기술한 디렉터리의 클래스 파일을 참조한다.

    posted by 좋은느낌/원철
    2008. 9. 2. 03:13 개발/Java

    Java 날짜 계산 함수 모음

    [ 날짜 연산법 ]


    가. 이해 및 유틸

    - 시스템 시간에 대한 이해
    - 날짜 계산 종합 유틸리티

    나. 응용팁

    시스템의 밀리초 구하기.(국제표준시각(UTC, GMT) 1970/1/1/0/0/0 으로부터 경과한 시각)
    ------------------------------------------------------------------
    // 밀리초 단위(*1000은 1초), 음수이면 이전 시각
    long time = System.currentTimeMillis ( );
    System.out.println ( time.toString ( ) );
    ------------------------------------------------------------------

    현재 시각을 가져오기.
    ------------------------------------------------------------------
    Date today = new Date ();
    System.out.println ( today );

    결과 : Sat Jul 12 16:03:00 GMT+01:00 2000
    ------------------------------------------------------------------

    경과시간(초) 구하기
    ------------------------------------------------------------------
    long time1 = System.currentTimeMillis ();
    long time2 = System.currentTimeMillis ();
    system.out.println ( ( time2 - time1 ) / 1000.0 );
    ------------------------------------------------------------------

    Date를 Calendar로 맵핑시키기
    ------------------------------------------------------------------
    Date d = new Date ( );
    Calendar c = Calendar.getInstance ( );
    c.setTime ( d );
    ------------------------------------------------------------------

    날짜(년/월/일/시/분/초) 구하기
    ------------------------------------------------------------------
    import java.util.*;
    import java.text.*;

    SimpleDateFormat formatter = new SimpleDateFormat ( "yyyy.MM.dd HH:mm:ss", Locale.KOREA );
    Date currentTime = new Date ( );
    String dTime = formatter.format ( currentTime );
    System.out.println ( dTime );
    ------------------------------------------------------------------

    날짜(년/월/일/시/분/초) 구하기2
    ------------------------------------------------------------------
    GregorianCalendar today = new GregorianCalendar ( );

    int year = today.get ( today.YEAR );
    int month = today.get ( today.MONTH ) + 1;
    int yoil = today.get ( today.DAY_OF_MONTH );

    GregorianCalendar gc = new GregorianCalendar ( );

    System.out.println ( gc.get ( Calendar.YEAR ) );
    System.out.println ( String.valueOf ( gc.get ( Calendar.MONTH ) + 1 ) );
    System.out.println ( gc.get ( Calendar.DATE ) );
    System.out.println ( gc.get ( DAY_OF_MONTH ) );
    ------------------------------------------------------------------

    날짜(년/월/일/시/분/초) 구하기3
    ------------------------------------------------------------------
    DateFormat df = DateFormat.getDateInstance(DateFormat.LONG, Locale.KOREA);
    Calendar cal = Calendar.getInstance(Locale.KOREA);
    nal = df.format(cal.getTime());
    ------------------------------------------------------------------

    - 표준시간대를 지정하고 날짜를 가져오기.
    ------------------------------------------------------------------
    TimeZone jst = TimeZone.getTimeZone ("JST");
    Calendar cal = Calendar.getInstance ( jst ); // 주어진 시간대에 맞게 현재 시각으로 초기화된 GregorianCalender 객체를 반환.// 또는 Calendar now = Calendar.getInstance(Locale.KOREA);
    System.out.println ( cal.get ( Calendar.YEAR ) + "년 " + ( cal.get ( Calendar.MONTH ) + 1 ) + "월 " + cal.get ( Calendar.DATE ) + "일 " + cal.get ( Calendar.HOUR_OF_DAY ) + "시 " +cal.get ( Calendar.MINUTE ) + "분 " + cal.get ( Calendar.SECOND ) + "초 " );

    결과 : 2000년 8월 5일 16시 16분 47초
    ------------------------------------------------------------------

    영어로된 날짜를 숫자로 바꾸기
    ------------------------------------------------------------------
    Date myDate = new Date ( "Sun,5 Dec 1999 00:07:21" );
    System.out.println ( myDate.getYear ( ) + "-" + myDate.getMonth ( ) + "-" + myDate.getDay ( ) );
    ------------------------------------------------------------------

    "Sun, 5 Dec 1999 00:07:21"를 "1999-12-05"로 바꾸기
    ------------------------------------------------------------------
    SimpleDateFormat formatter_one = new SimpleDateFormat ( "EEE, dd MMM yyyy hh:mm:ss",Locale.ENGLISH );
    SimpleDateFormat formatter_two = new SimpleDateFormat ( "yyyy-MM-dd" );

    String inString = "Sun, 5 Dec 1999 00:07:21";

    ParsePosition pos = new ParsePosition ( 0 );
    Date frmTime = formatter_one.parse ( inString, pos );
    String outString = formatter_two.format ( frmTime );

    System.out.println ( outString );
    ------------------------------------------------------------------

    숫자 12자리를, 다시 날짜로 변환하기
    ------------------------------------------------------------------
    Date conFromDate = new Date();
    long ttl = conFromDate.parse ( "Dec 25, 1997 10:10:10" );
    System.out.println ( ttl ); //예 938291839221

    Date today = new Date ( ttl );
    DateFormat format = DateFormat.getDateInstance ( DateFormat.FULL,Locale.US );
    String formatted = format.format ( today );
    System.out.println ( formatted );
    ------------------------------------------------------------------

    특정일로부터 n일 만큼 이동한 날짜 구하기
    ------------------------------------------------------------------
    특정일의 시간을 long형으로 읽어온다음..
    날짜*24*60*60*1000 을 계산하여.
    long형에 더해줍니다.
    그리고 나서 Date클래스와 Calender클래스를 이용해서 날짜와 시간을 구하면 됩니다
    ------------------------------------------------------------------

    특정일에서 일정 기간후의 날짜 구하기2
    ------------------------------------------------------------------
    //iDay 에 입력하신 만큼 빼거나 더한 날짜를 반환 합니다.
    import java.util.*;

    public String getDate ( int iDay )
    {
    Calendar temp=Calendar.getInstance ( );
    StringBuffer sbDate=new StringBuffer ( );

    temp.add ( Calendar.DAY_OF_MONTH, iDay );

    int nYear = temp.get ( Calendar.YEAR );
    int nMonth = temp.get ( Calendar.MONTH ) + 1;
    int nDay = temp.get ( Calendar.DAY_OF_MONTH );

    sbDate.append ( nYear );
    if ( nMonth < 10 )
    sbDate.append ( "0" );
    sbDate.append ( nMonth );
    if ( nDay < 10 )
    sbDate.append ( "0" );
    sbDate.append ( nDay );

    return sbDate.toString ( );
    }
    ------------------------------------------------------------------

    현재날짜에서 2달전의 날짜를 구하기
    ------------------------------------------------------------------
    Calendar cal = Calendar.getInstance ( );//오늘 날짜를 기준으루..
    cal.add ( cal.MONTH, -2 ); //2개월 전....
    System.out.println ( cal.get ( cal.YEAR ) );
    System.out.println ( cal.get ( cal.MONTH ) + 1 );
    System.out.println ( cal.get ( cal.DATE ) );
    ------------------------------------------------------------------

    달에 마지막 날짜 구하기
    ------------------------------------------------------------------
    for ( int month = 1; month <= 12; month++ )
    {
    GregorianCalendar cld = new GregorianCalendar ( 2001, month - 1, 1 );
    System.out.println ( month + "/" + cld.getActualMaximum ( Calendar.DAY_OF_MONTH ) );
    }
    ------------------------------------------------------------------

    해당하는 달의 마지막 일 구하기
    ------------------------------------------------------------------
    GregorianCalendar today = new GregorianCalendar ( );
    int maxday = today.getActualMaximum ( ( today.DAY_OF_MONTH ) );
    System.out.println ( maxday );
    ------------------------------------------------------------------

    특정일을 입력받아 해당 월의 마지막 날짜를 구하는 간단한 예제.(달은 -1 해준다.)...윤달 30일 31일 알아오기.
    ------------------------------------------------------------------
    Calendar cal = Calendar.getInstance ( );
    cal.set ( Integer.parseInt ( args[0] ), Integer.parseInt ( args [1] ) - 1, Integer.parseInt ( args [2] ) );
    SimpleDateFormat dFormat = new SimpleDateFormat ( "yyyy-MM-dd" );
    System.out.println ( "입력 날짜 " + dFormat.format ( cal.getTime ( ) ) );
    System.out.println ( "해당 월의 마지막 일자 : " + cal.getActualMaximum ( Calendar.DATE ) );
    ------------------------------------------------------------------

    해당월의 실제 날짜수 구하기 ( 1999년 1월달의 실제 날짜수를 구하기 )
    ------------------------------------------------------------------
    Calendar calendar = Calendar.getInstance ( );
    calendar.set ( 1999, 0, 1 );
    int maxDays = calendar.getActualMaximum ( Calendar.DAY_OF_MONTH );
    ------------------------------------------------------------------

    어제 날짜 구하기
    ------------------------------------------------------------------
    오늘날짜를 초단위로 구해서 하루분을 빼주고 다시
    셋팅해주면 쉽게 구할수 있죠..
    setTime((기준일부터 오늘까지의 초를 구함) - 24*60*60)해주면 되겠죠..
    ------------------------------------------------------------------

    어제 날짜 구하기2
    ------------------------------------------------------------------
    import java.util.*;

    public static Date getYesterday ( Date today )
    {
    if ( today == null )
    throw new IllegalStateException ( "today is null" );
    Date yesterday = new Date ( );
    yesterday.setTime ( today.getTime ( ) - ( (long) 1000 * 60 * 60 * 24 ) );

    return yesterday;
    }
    ------------------------------------------------------------------

    내일 날짜 구하기
    ------------------------------------------------------------------
    Date today = new Date ( );
    Date tomorrow = new Date ( today.getTime ( ) + (long) ( 1000 * 60 * 60 * 24 ) );
    ------------------------------------------------------------------

    내일 날짜 구하기2
    ------------------------------------------------------------------
    Calendar today = Calendar.getInstance ( );
    today.add ( Calendar.DATE, 1 );
    Date tomorrow = today.getTime ( );
    ------------------------------------------------------------------

    오늘날짜에서 5일 이후 날짜를 구하기
    ------------------------------------------------------------------
    Calendar cCal = Calendar.getInstance();
    c.add(Calendar.DATE, 5);
    ------------------------------------------------------------------

    날짜에 해당하는 요일 구하기
    ------------------------------------------------------------------
    //DAY_OF_WEEK리턴값이 일요일(1), 월요일(2), 화요일(3) ~~ 토요일(7)을 반환합니다.
    //아래 소스는 JSP일부입니다.
    import java.util.*;

    Calendar cal= Calendar.getInstance ( );
    int day_of_week = cal.get ( Calendar.DAY_OF_WEEK );
    if ( day_of_week == 1 )
    m_week="일요일";
    else if ( day_of_week == 2 )
    m_week="월요일";
    else if ( day_of_week == 3 )
    m_week="화요일";
    else if ( day_of_week == 4 )
    m_week="수요일";
    else if ( day_of_week == 5 )
    m_week="목요일";
    else if ( day_of_week == 6 )
    m_week="금요일";
    else if ( day_of_week == 7 )
    m_week="토요일";

    오늘은 : 입니다.
    ------------------------------------------------------------------

    콤보박스로 선택된 날짜(예:20001023)를 통해 요일을 영문으로 가져오기
    ------------------------------------------------------------------
    //gc.get(gc.DAY_OF_WEEK); 하면 일요일=1, 월요일=2, ..., 토요일=7이 나오니까,
    //요일을 배열로 만들어서 뽑아내면 되겠죠.
    GregorianCalendar gc=new GregorianCalendar ( 2000, 10 - 1 , 23 );
    String [] dayOfWeek = { "", "Sun", "Mon", .... , "Sat" };
    String yo_il = dayOfWeek ( gc.get ( gc.DAY_OF_WEEK ) );
    ------------------------------------------------------------------

    두 날짜의 차이를 일수로 구하기
    ------------------------------------------------------------------
    각각의 날짜를 Date형으로 만들어서 getTime()하면
    long으로 값이 나오거든요(1970년 1월 1일 이후-맞던가?- 1/1000 초 단위로..)
    그러면 이값의 차를 구해서요. (1000*60*60*24)로 나누어 보면 되겠죠.
    ------------------------------------------------------------------

    두 날짜의 차이를 일수로 구하기2
    ------------------------------------------------------------------
    import java.io.*;
    import java.util.*;

    Date today = new Date ( );
    Calendar cal = Calendar.getInstance ( );
    cal.setTime ( today );// 오늘로 설정.

    Calendar cal2 = Calendar.getInstance ( );
    cal2.set ( 2000, 3, 12 ); // 기준일로 설정. month의 경우 해당월수-1을 해줍니다.

    int count = 0;
    while ( !cal2.after ( cal ) )
    {
    count++;
    cal2.add ( Calendar.DATE, 1 ); // 다음날로 바뀜

    System.out.println ( cal2.get ( Calendar.YEAR ) + "년 " + ( cal2.get ( Calendar.MONTH ) + 1 ) + "월 " + cal2.get ( Calendar.DATE ) + "일" );
    }

    System.out.println ( "기준일로부터 " + count + "일이 지났습니다." );
    ------------------------------------------------------------------

    두 날짜의 차이를 일수로 구하기3
    ------------------------------------------------------------------
    import java.io.*;
    import java.util.*;

    public class DateDiff
    {
    public static int GetDifferenceOfDate ( int nYear1, int nMonth1, int nDate1, int nYear2, int nMonth2, int nDate2 )
    {
    Calendar cal = Calendar.getInstance ( );
    int nTotalDate1 = 0, nTotalDate2 = 0, nDiffOfYear = 0, nDiffOfDay = 0;

    if ( nYear1 > nYear2 )
    {
    for ( int i = nYear2; i < nYear1; i++ )
    {
    cal.set ( i, 12, 0 );
    nDiffOfYear += cal.get ( Calendar.DAY_OF_YEAR );
    }
    nTotalDate1 += nDiffOfYear;
    }
    else if ( nYear1 < nYear2 )
    {
    for ( int i = nYear1; i < nYear2; i++ )
    {
    cal.set ( i, 12, 0 );
    nDiffOfYear += cal.get ( Calendar.DAY_OF_YEAR );
    }
    nTotalDate2 += nDiffOfYear;
    }

    cal.set ( nYear1, nMonth1-1, nDate1 );
    nDiffOfDay = cal.get ( Calendar.DAY_OF_YEAR );
    nTotalDate1 += nDiffOfDay;

    cal.set ( nYear2, nMonth2-1, nDate2 );
    nDiffOfDay = cal.get ( Calendar.DAY_OF_YEAR );
    nTotalDate2 += nDiffOfDay;

    return nTotalDate1-nTotalDate2;
    }

    public static void main ( String args[] )
    {
    System.out.println ( "" + GetDifferenceOfDate (2000, 6, 15, 1999, 8, 23 ) );
    }
    }
    ------------------------------------------------------------------

    파일에서 날짜정보를 가져오기
    ------------------------------------------------------------------
    File f = new File ( directory, file );

    Date date = new Date ( f.lastModified ( ) );
    Calendar cal = Calendar.getInstance ( );
    cal.setTime ( date );

    System.out.println("Year : " + cal.get(Calendar.YEAR));
    System.out.println("Month : " + (cal.get(Calendar.MONTH) + 1));
    System.out.println("Day : " + cal.get(Calendar.DAY_OF_MONTH));
    System.out.println("Hours : " + cal.get(Calendar.HOUR_OF_DAY));
    System.out.println("Minutes : " + cal.get(Calendar.MINUTE));
    System.out.println("Second : " + cal.get(Calendar.SECOND));
    ------------------------------------------------------------------

    날짜형식으로 2000-01-03으로 처음에 인식을 시킨후
    7일씩 증가해서 1년정도의 날짜를 출력해 주고 싶은데요.
    ------------------------------------------------------------------
    SimpleDateFormat sdf = new SimpleDateFormat ( "yyyy-mm-dd" );
    Calendar c = Calendar.getInstance ( );

    for ( int i = 0; i < 48; i++ )
    {
    c.clear ( );
    c.set ( 2000, 1, 3 - ( i * 7 ) );
    java.util.Date d = c.getTime ( );
    String thedate = sdf.format ( d );
    System.out.println ( thedate );
    }
    ------------------------------------------------------------------

    쓰레드에서 날짜 바꾸면 죽는 문제
    ------------------------------------------------------------------
    Main화면에 날짜와시간이Display되는 JPanel이 있습니다.
    date로 날짜와 시간을 변경하면 Main화면의 날짜와 시간이 Display되는 Panel에
    변경된 날짜가 Display되지 않고 Main화면이 종료되어 버립니다.

    문제소스:
    public void run ( )
    {
    while ( true )
    {
    try{
    timer.sleep ( 60000 );
    }
    catch ( InterruptedException ex ) { }

    lblTimeDate.setText ( fGetDateTime ( ) );
    repaint ( );
    }
    }

    public String fGetDateTime ( )
    {
    final int millisPerHour = 60 * 60 * 1000;
    String DATE_FORMAT = "yyyy / MM / dd HH:mm";
    SimpleDateFormat sdf = new SimpleDateFormat ( DATE_FORMAT );
    SimpleTimeZone timeZone = new SimpleTimeZone ( 9 * millisPerHour, "KST" );
    sdf.setTimeZone ( timeZone );

    long time = System.currentTimeMillis ( );
    Date date = new Date ( time );
    return sdf.format ( date );
    }

    해답:
    // 날짜와 요일 구한다. timezone 으로 날짜를 다시 셋팅하시면 됨니다.
    public String getDate ( )
    {
    Date now = new Date ( );
    SimpleDateFormat sdf4 = new SimpleDateFormat ( "yyyy/MM/dd HH:mm EE" );
    sdf4.setTimeZone ( TimeZone.getTimeZone ( "Asia/Seoul" ) );

    return sdf4.format ( now );
    }
    ------------------------------------------------------------------

    날짜와 시간이 유효한지 검사하려면...?
    ------------------------------------------------------------------
    import java.util.*;
    import java.text.*;

    public class DateCheck
    {
    boolean dateValidity = true;

    DateCheck ( String dt )
    {
    try
    {
    DateFormat df = DateFormat.getDateInstance ( DateFormat.SHORT );
    df.setLenient ( false );
    Date dt2 = df.parse ( dt );
    }
    catch ( ParseException e ) { this.dateValidity = false; }
    catch ( IllegalArgumentException e ) { this.dateValidity = false; }
    }

    public boolean datevalid ( )
    {
    return dateValidity;
    }

    public static void main ( String args [] )
    {
    DateCheck dc = new DateCheck ( "2001-02-28" );
    System.out.println ( " 유효한 날짜 : " + dc.datevalid ( ) );
    }
    }
    ------------------------------------------------------------------

    두 날짜 비교하기(아래보다 정확)
    ------------------------------------------------------------------
    그냥 날짜 두개를 long(밀리 세컨드)형으로 비교하시면 됩니다...

    이전의 데이타가 date형으로 되어 있다면, 이걸 long형으로 변환하고.
    현재 날짜(시간)은 System.currentTimeMillis()메소드로 읽어들이고,
    두수(long형)를 연산하여 그 결과 값으로 비교를 하시면 됩니다.

    만약 그 결과값이 몇시간 혹은 며칠차이가 있는지를 계산할려면,
    결과값을 Calender의 setTimeInMillis(long millis) 메소드를 이용해
    설정한다음 각각의 날짜나 시간을 읽어오시면 됩니다
    ------------------------------------------------------------------

    두 날짜 비교하기2
    ------------------------------------------------------------------
    //Calendar를 쓸 경우 데이타의 원본을 고치기 때문에 clone()을 사용하여
    //복사한 후에 그 복사본을 가지고 비교한다
    import java.util.*;
    import java.util.Calendar.*;
    import java.text.SimpleDateFormat;

    public class DayComparisonTest
    {
    public static void main(String args[])
    {
    Calendar cal = Calendar.getInstance();
    SimpleDateFormat dateForm = new SimpleDateFormat("yyyy-MM-dd");

    Calendar aDate = Calendar.getInstance(); // 비교하고자 하는 임의의 날짜
    aDate.set(2001, 0, 1);

    Calendar bDate = Calendar.getInstance(); // 이것이 시스템의 날짜

    // 여기에 시,분,초를 0으로 세팅해야 before, after를 제대로 비교함
    aDate.set( Calendar.HOUR_OF_DAY, 0 );
    aDate.set( Calendar.MINUTE, 0 );
    aDate.set( Calendar.SECOND, 0 );
    aDate.set( Calendar.MILLISECOND, 0 );

    bDate.set( Calendar.HOUR_OF_DAY, 0 );
    bDate.set( Calendar.MINUTE, 0 );
    bDate.set( Calendar.SECOND, 0 );
    bDate.set( Calendar.MILLISECOND, 0 );


    if (aDate.after(bDate)) // aDate가 bDate보다 클 경우 출력
    System.out.println("시스템 날짜보다 뒤일 경우 aDate = " + dateForm.format(aDate.getTime()));
    else if (aDate.before(bDate)) // aDate가 bDate보다 작을 경우 출력
    System.out.println("시스템 날짜보다 앞일 경우 aDate = " + dateForm.format(aDate.getTime()));
    else // aDate = bDate인 경우
    System.out.println("같은 날이구만");
    }
    }
    posted by 좋은느낌/원철
    2008. 7. 1. 16:40 개발/Java

    javax.naming.NameNotFoundException:

    On Tue, Jun 24, 2008 at 3:06 PM, Martin Skarsaune <martin@skarsaune.net>
    wrote:

    > Hi guys,
    >
    > Thanks for feedback on my previous post.
    >
    > Another problem is blocking mail sending though:
    >
    > I get this error in my logs:
    >
    > "
    >
    > /opt/ibm/WebSphere/AppServer/grip/logs/server1/SystemOut_08.06.24_13.29.45.log:javax.naming.ConfigurationException:
    > A JNDI operation on a "java:" name cannot be completed because the
    > serverruntime is not able to associate the operation's thread with any J2EE
    > application component.  This condition can occur when the JNDI client using
    > the "java:" name is not executed on the thread of a server application
    > request.  Make sure that a J2EE application does not execute JNDI
    > operations
    > on "java:" names within static code blocks or in threads created by that
    > J2EE application.  Such code does not necessarily run on the thread of a
    > server application request and therefore is not supported by JNDI
    > operations
    > on "java:" names. [Root exception is javax.naming.NameNotFoundException:
    > Name comp/env/mail not found in context "java:".]
    > "
    >
    > I assume continuum spawns background threads to build? Is that correct?


    Yes.

    >
    > Not really any hope of sending mails from WebSphere (6.1) then is there?
    >

    Our jndi config is fine and work is lot of app server, I don't have webshere
    to test it.
    If you have an issue with the resource name, you can :
    - change the res-ref-name in web.xml
    - change the 'jndiSessionName' in
    WEB-INF/classes/META-INF/plexus/application.xml
    - create a deployment descriptor

    Let us now how you solve it. If you look under WEB-INF directory, you'll see
    we have a specific deployment descriptor for JBoss, maybe we need to do the
    same for Websphere

    Emmanuel
    posted by 좋은느낌/원철
    2008. 7. 1. 16:38 개발/Java

    javax.naming.NameNotFoundException:

    On Tue, Jun 24, 2008 at 3:06 PM, Martin Skarsaune <martin@skarsaune.net>
    wrote:

    > Hi guys,
    >
    > Thanks for feedback on my previous post.
    >
    > Another problem is blocking mail sending though:
    >
    > I get this error in my logs:
    >
    > "
    >
    > /opt/ibm/WebSphere/AppServer/grip/logs/server1/SystemOut_08.06.24_13.29.45.log:javax.naming.ConfigurationException:
    > A JNDI operation on a "java:" name cannot be completed because the
    > serverruntime is not able to associate the operation's thread with any J2EE
    > application component.  This condition can occur when the JNDI client using
    > the "java:" name is not executed on the thread of a server application
    > request.  Make sure that a J2EE application does not execute JNDI
    > operations
    > on "java:" names within static code blocks or in threads created by that
    > J2EE application.  Such code does not necessarily run on the thread of a
    > server application request and therefore is not supported by JNDI
    > operations
    > on "java:" names. [Root exception is javax.naming.NameNotFoundException:
    > Name comp/env/mail not found in context "java:".]
    > "
    >
    > I assume continuum spawns background threads to build? Is that correct?


    Yes.

    >
    > Not really any hope of sending mails from WebSphere (6.1) then is there?
    >

    Our jndi config is fine and work is lot of app server, I don't have webshere
    to test it.
    If you have an issue with the resource name, you can :
    - change the res-ref-name in web.xml
    - change the 'jndiSessionName' in
    WEB-INF/classes/META-INF/plexus/application.xml
    - create a deployment descriptor

    Let us now how you solve it. If you look under WEB-INF directory, you'll see
    we have a specific deployment descriptor for JBoss, maybe we need to do the
    same for Websphere

    Emmanuel
    posted by 좋은느낌/원철
    2008. 7. 1. 15:44 개발/Java

    J2EE에서 JNDI의 역할

    J2EE를 마스터하는 것은 어려운 일이다. 기술과 신조어들이 나날이 늘어가기 때문이기도 하다. Java Naming and Directory Interface (JNDI)는 처음부터 Java 2 Platform, Enterprise Edition (J2EE)의 핵심에 있었지만 풋내기 J2EE 개발자들은 이를 충분히 활용하지 못한다. 이 글에서 J2EE 애플리케이션에서의 JNDI의 역할을 규명하고 애플리케이션을 전개로부터 분리하는 방법을 설명하겠다.

    J2EE 플랫폼이 엔터프라이즈 개발자의 삶을 향상시킨 것 만큼 J2EE의 많은 스팩과 기술을 배워야 하는 대가를 치러야 했다. Dolly Developer는 엔터프라이즈 애플리케이션의 전개에 수반되는 부담을 경감시키는 한 가지 기능인 JNDI를 발견하지 못한 많은 개발자들 중 하나이다. JNDI를 잘 활용했을 때 상황이 어떻게 향상되었는지를 살펴보자.



    너무나 익숙한 여행

    Dolly 개발자는 JDBC 데이터 소스를 사용하는 웹 애플리케이션을 코딩중이다. 그녀는 MySQL을 사용하고 있다는 것을 알기 때문에 MySQL JDBC 드라이버 클래스에 대한 레퍼런스를 인코딩하고 JDBC URL을 사용하여 웹 애플리케이션의 데이터베이스에 연결한다. 데이터베이스 커넥션 풀링은 중요하기 때문에 커넥션 풀링 패키지를 포함하고 이를 설정하여 단 64 커넥션만 사용해야 한다; 그녀는 데이터베이스 서버가 128 클라이언트 커넥션을 할당하도록 설정되었다는 것을 알고 있다.

    재앙으로 향하는 Dolly

    개발 단계 동안은 모든 것이 순조롭게 진행된다. 하지만 전개할 때 상황은 달라진다. 네트워크 관리자는 데스크탑에서 제품 또는 스테이징 서버로 액세스하지 못한다는 것을 지시했기 때문에 그녀는 각 전개 단계마다 다른 버전의 코드를 만들어야 한다. 상황이 이렇기 때문에 그녀에게는 테스트, 스테이징, 제품 마다 전개 가능한 새로운 JDBC URL이 필요하다. (설정 관리에 익숙한 사람들은 개별 구현을 각 환경에 전개한다는 개념 때문에 망설이지만 이는 매우 일반적인 상황이기 때문에 너무 그럴 필요는 없다.)

    Dolly가 그녀가 전개 가능한 다른 URL 들로 설정 문제를 “해결”했다라고 생각했을 때, 그녀는 데이터베이스 관리자가 제품에서 MySQL 인스턴스를 실행하는 것을 원하지 않는다는 것을 발견한다. 이것은 개발에는 알맞지만 중요한 미션을 위한 데이터용 비즈니스 표준은 DB2®이다. 이제 그녀의 구현은 데이터 URL을 달리 해야 할 뿐만 아니라 다른 드라이버를 갖추어야 한다.

    상황은 더 나빠진다. 그녀의 애플리케이션은 너무 유용해서 너무 중요해진다. 애플리케이션 서버에서 페일오버 기능을 얻고 4개의 서버 클러스터로 복제된다. 하지만 데이터베이스 관리자들은 빨간 깃발을 들어올리지만 그녀의 애플리케이션의 모든 인스턴스는 64 커넥션을 사용한다. 데이터베이스 서버는 전체적으로 200개의 사용 가능한 커넥션을 갖고 있다. 모두가 Dolly의 애플리케이션에 의해 연결되고 있다. 더욱이 DBA는 Dolly의 애플리케이션이 단 32개의 커넥션만을 필요하다는 것을 결정했고, 이것도 하루에 단 한 시간 동안이다. 그녀의 애플리케이션이 올라갈 때 애플리케이션은 데이터베이스 레이어에서의 경쟁 문제로 끝나서 그녀의 유일한 옵션은 클러스터링 된 커넥션의 수를 변경하여 클러스터가 늘어나면 다시 이와 같은 것을 준비하거나 애플리케이션이 다른 클러스터에서 복제되도록 한다. 애플리케이션 설정에 대해 내린 결정이 시스템과 데이터베이스 관리자들에겐 최상인 것 같았다.

    J2EE 역할

    Dolly는 J2EE 역할에 대한 지식을 기반으로 애플리케이션을 개발했다면 이런 딜레마는 피할 수 있었을 것이다. J2EE 스팩은 다양한 개발 역할들에 책임을 위임한다: 컴포넌트 공급자, 애플리케이션 어셈블러, 전개자, 시스템 관리자. (많은 조직들에서 컴포넌트 공급자와 어셈블러 역할은 통합되었다. 전개자와 시스템 관리자 역할 또한 통합되어 있다.) J2EE에서의 JNDI의 역할을 이해하기 전에 J2EE의 역할을 이해하는 것도 중요하다.

    컴포넌트 공급자
    이 역할은 J2EE 컴포넌트를 만드는 책임이 있다. 웹 애플리케이션, Enterprise JavaBean (EJB) 컴포넌트, 애플리케이션 컴포넌트(Swing 기반의 GUI 클라이언트 애플리케이션) 등이 될 수 있다. 컴포넌트 공급자에는 HTML 콘텐트 디자이너, 문서 프로그래머, 기타 개발자 역할들이 포함된다. 대부분의 J2EE 개발자들은 컴포넌트 공급자 역할을 수행하고 있다.

    애플리케이션 어셈블러
    이 역할은 다중의 J2EE 모듈을 인접해 있는 전개 가능한 모든 것에 묶는 것이다: enterprise archive (EAR) 파일. 애플리케이션 어셈블러는 컴포넌트를 선택하고, 이들이 인터랙팅 하는 방법을 정의하고, 보안과 트랜잭션 애트리뷰트를 설정하고, 애플리케이션을 EAR 파일로 패키징한다. WebSphere® Studio, IDEA, JBuilder, WebLogic Workshop 같은 많은 IDE 들은 EAR 파일의 인터랙티브 설정을 갖춘 애플리케이션 어셈블러를 지원하는 기능을 갖고 있다.

    전개자
    이 역할은 전개를 담당하고 있다. EAR을 J2EE 컨테이너(애플리케이션 서버)에 설치하면서 데이터베이스 커넥션 풀 같은 리소스들을 설정하고, 애플리케이션에 필요한 리소스들을 애플리케이션 서버의 특정 리소스들로 바인딩하고 애플리케이션을 시작한다.

    시스템 관리자
    이 역할은 컨테이너가 필요로 하는 리소스들이 해당 컨테이너에서 사용할 수 있는 것인지를 확인한다.

    역할 수행

    비즈니스 로직과 영속성을 위해 하나의 웹 애플리케이션과 하나의 EJB 컴포넌트를 포함하고 있는 엔터프라이즈 애플리케이션을 상상해 보자. 이 애플리케이션을 개발하는 데는 많은 컴포넌트 공급자들이 개입된다. 많은 경우 같은 사람이 이 모든 일들을 수행하곤 한다. 이 컴포넌트들은 데이터 전송 객체(JAR 파일), EJB 인터페이스(또 다른 JAR 파일), EJB 구현(이것 역시 또 다른 JAR 파일), 사용자 인터페이스 컴포넌트-서블릿, JSP, HTML 페이지, 정적 웹 콘텐트 들을 포함시킬 수 있다. 사용자 인터페이스 컴포넌트들은 웹 애플리케이션으로 패키징되고 여기에는 서블릿 클래스, JSP 파일, 정적 콘텐트, EJB 인터페이스를 비롯하여 다른 필요한 컴포넌트를 포함하고 있는 JAR 등이 포함된다.

    일반적인 웹 애플리케이션을 구현하는데 얼마나 많은 JAR 파일들이 사용되는지를 고려할 때 준비해야 할 많은 컴포넌트들이 있는 것 처럼 들린다. 종속성(dependency)은 여기에서 조심스럽게 다뤄져야 한다. 인터페이스들과 전송 객체들은 웹 애플리케이션과 EJB 구현에 대한 합당한 종속관계이다. 하지만 이러한 계열의 종속관계는 이 같은 방향으로 모두 실행되어야 한다: 주기적인 종속성은 피해야 한다. WAR 파일과 EJB JAR 파일 같은 J2EE 컴포넌트들은 전개 단위 밖에 있는 리소스에 대한 종속성을 선언해야 한다.

    애플리케이션 어셈블러는 웹 애플리케이션에서의 종속성을 추가하고 모든 것을 하나의 엔터프라이즈 애플리케이션으로 패키징 해야한다. 툴이 많은 도움이 된다. IDE는 모듈과 JAR의 종속성을 반영하는 프로젝트 구조를 만드는데 도움이 되고 모듈의 추가 또는 배제를 지정할 수 있도록 한다.

    전개자는 컴포넌트가 요구하는 리소스들이 전개 환경에 존재하는지를 확인하고 이들을 플랫폼의 사용 가능한 리소스들로 바인딩하는 책임이 있다. 예를 들어, 웹 애플리케이션의 외부 EJB 레퍼런스(전개 디스크립터의 ejb-ref) 이 지점에서 실제로 전개된 EJB 컴포넌트에 묶인다.

    외부 리소스로의 늦은 바인딩

    중요한 J2EE 애플리케이션은 작동하기로 되어있는 환경을 설명하고 있는 정보에 액세스해야 한다. 다시 말해서 컴포넌트를 개발하고 테스트 하는 데에는 개발자가 일종의 전개 의무를 지는 것이 필요하다는 것을 의미한다. 코드를 테스트하는 임시적인 목적일 경우에도 그렇다. 이렇게 함으로서 개발자 도메인 밖으로 벗어났다는 것을 이해하는 것이 중요하다. 그렇지 않으면 의도되지 않았던, 때로는 재앙 같은 함축을 지닌 JDBC 드라이버, URL, JMS 큐 이름, 기타 머신 리소스들에 의존하려는 유혹에 빠진다.

    구원자 JNDI

    Dolly의 문제에 대한 솔루션은 데이터 스토어에 대한 모든 직접적인 레퍼런스들을 애플리케이션 코드에서 제거하는 것이다. JDBC 드라이버에 대한 레퍼런스, 서버 이름, 사용자 이름 또는 패스워드, 심지어 데이터베이스 풀링 또는 커넥션 관리 도 없다.Dolly는 그녀의 코드를 작성하여 액세스하려고 하는 외부 리소스들이 무엇인지 무시해야 한다. 다른 사람들이 그러한 외부 리소스들을 활용해야 하는 링크를 제공할 것이라는 것을 이해해야 한다. 이는 전개자가 데이터베이스 커넥션을 그녀의 애플리케이션에 할당 할 수 있도록 한다. Dolly가 개입될 필요가 없다. (데이터 보안은 물론 Sarbanes-Oxley 호환성 까지 다양한 이유가 때문이다.)

    많은 개발자들은 코드와 외부 리소스들 간 강결합(tight coupling)이 잠재적으로 문제가 된다는 것을 알고 있다. 하지만 실제로는 역할의 분리를 종종 무시한다. (팀 크기 또는 전개의 관점에서)작은 개발 노력으로, 역할 분리를 무시하는 것은 충분히 성공적일 수 있다. (결국, 개인적인 애플리케이션일 경우, PostgreSQL 인스턴스로 애플리케이션을 잠그는 것이 좋고, 여기에 의존할 생각은 말아야 한다.)

    J2EE 스팩은 모든 J2EE 컨테이너들이 JNDI 스팩의 구현을 제공해야 한다는 것을 요구한다. J2EE에서의 JNDI의 역할은 “스위치보드(switchboard)” 이다—런타임 시 J2EE 컴포넌트가 다른 컴포넌트, 리소스, 서비스를 찾는 일반적인 메커니즘이다. 대부분의 경우 컨테이너가 제공되는 JNDI 공급자는 제한된 데이터 스토어로서 작용하여 관리자들이 하나의 애플리케이션에서 실행 속성을 설정할 수 있고 다른 애플리케이션들이 이들을 레퍼런스 할 수 있게 한다. (Java Management Extensions (JMX)도 이 목적으로 사용될 수 있다.) J2EE 애플리케이션에서의 JNDI의 주 역할은 인다이렉션 레이어를 제공하여 컴포넌트들이 필요한 리소스들을 인다이렉션을 의식하지 않고 찾을 수 있도록 하는 것이다.

    문제 해결

    다시 Dolly의 상황으로 돌아가보자. 그녀의 간단한 웹 애플리케이션에서 그녀는 그녀의 애플리케이션 코드에서 직접 JDBC 커넥션을 사용했다. Listing 1을 보면, JDBC 드라이버, 데이터베이스 URL, 서블릿의 사용자 이름과 패스워드의 이름을 분명히 코딩했음을 알 수 있다:


    Listing 1. 전형적인 (하지만 좋지 않은) JDBC 사용

    

Connection conn=null;
try {
  Class.forName("com.mysql.jdbc.Driver",
                true, Thread.currentThread().getContextClassLoader());
  conn=DriverManager.getConnection("jdbc:mysql://dbserver?user=dolly&password=dagger");
  /* use the connection here */
  conn.close();
} 
catch(Exception e) {
  e.printStackTrace();
} 
finally {
  if(conn!=null) {
    try {
      conn.close();
    } catch(SQLException e) {}
  }
}

    이러한 방식으로 설정 정보를 지정하는 대신 Dolly(와 그녀의 동료들)는 JNDI를 사용하여 JDBC DataSource를 찾았다면 더 좋았을 것이다. (Listing 2):


    Listing 2. JNDI를 사용하여 데이터 소스 얻기

    

Connection conn=null;
try {
  Context ctx=new InitialContext();
  Object datasourceRef=ctx.lookup("java:comp/env/jdbc/mydatasource");
  DataSource ds=(Datasource)datasourceRef;
  conn=ds.getConnection();
  /* use the connection */
  conn.close();
} 
catch(Exception e) {
  e.printStackTrace();
} 
finally {
  if(conn!=null) {
    try {
      conn.close();
    } catch(SQLException e) { }
  }
}

    JDBC 커넥션을 얻을 수 있으려면 소소한 전개 설정을 하여 로컬 컴포넌트의 JNDI 콘텍스트의 JDBC DataSource를 검색해야 한다. 조잡할 것 같지만 배우기 쉽다. 불행히도, 컴포넌트를 테스트하기 위해서 개발자는 전개자의 경지를 건너서 애플리케이션 서버를 설정하는 것을 준비해야 한다.

    JNDI 레퍼런스 설정하기

    JNDI가 java:comp/env/jdbc/mydatasource 레퍼런스를 해결하려면 전개자는 <resource-ref>태그를 web.xml 파일(웹 애플리케이션용 전개 디스크립터)에 삽입해야 한다. <resource-ref>태그는 “이 컴포넌트는 외부 리소스에 대한 의존성을 갖고 있다.”는 것을 의미한다. (Listing 3):


    Listing 3. resource-ref 엔트리

    

<resource-ref>
  <description>Dollys DataSource</description>
  <res-ref-name>jdbc/mydatasource</res-ref-name>
  <res-ref-type>javax.sql.DataSource</res-ref-type>
  <res-auth>Container</res-auth>
</resource-ref>

    <resource-ref> 엔트리는 jdbc/mydatasource라고 하는 컴포넌트 네이밍 콘텍스트의 리소스가 전개자에 의해 설정될 것이라는 것을 알려준다. 컴포넌트 네이밍 콘텍스트는 접두사 java:comp/env/로 표시되어 완전한 자격의 로컬 리소스 이름은 java:comp/env/jdbc/mydatasource이다.

    이것은 단지 외부 리소스에 대한 로컬 레퍼런스를 정의하고 이 레퍼런스가 가르키게 될 실제 리소스는 만들지 않는다. (자바와 비슷한 언어들은 <resource-ref>가 Object foo같은 레퍼런스를 선언하지만, Object를 실제로 참조하기 위해 foo를 설정하지 않는다.)

    전개자의 역할은 DataSource를 만드는 것이다. (또는, 우리의 자바 예제에서 처럼 foo가 지목할 Object를 만든다.) 각 컨테이너에는 데이터 소스를 설정하는 고유의 메커니즘이 있다. JBoss 에서 데이터 소스는 서비스와 함께 정의되고($JBOSS/server/default/deploy/hsqldb-ds.xml 참조), 이것이 DataSource를 위한 글로벌 JNDI 이름이라는 것을 지정한다. (기본적으로, DefaultDS). 일단 리소스가 만들어지면 여전히 중요한 제 3 단계가 남아있다: 리소스를 애플리케이션 컴포넌트가 사용하는 로컬 이름으로 연결 또는 바인딩하는 것. 이 웹 애플리케이션의 경우 벤더 스팩의 전개 디스크립터 확장은 바인딩을 지정하는데 사용된다. (Listing 4). (JBoss는 벤더 스팩의 웹 애플리케이션 전개 디스크립터에 jboss-web.xml이라고 하는 파일을 사용한다.)


    Listing 4. 벤더 스팩의 전개 디스크립터에서 리소스를 JNDI 이름으로 바인딩하기

    

<resource-ref>
   <res-ref-name>jdbc/mydatasource</res-ref-name>
   <jndi-name>java:DefaultDS</jndi-name>
</resource-ref>

    로컬 리소스 ref 이름 (jdbc/mydatasource)은 java:DefaultDS라는 글로벌 리소스로 매핑되어야 한다는 것을 나타내고 있다. 글로벌 리소스 이름이 변경되면 애플리케이션 코드는 변하지 않는다. 단 이 매핑만 그렇다. 여기에는 두 가지 레벨의 인다이렉션이 있다. 하나는 리소스를 정의하고 이름을 짓는 것이고 (java:DefaultDS), 다른 하나는 로컬 컴포넌트 스팩의 이름 (jdbc/mydatasource) 을 이름이 지어진 리소스에 바인딩하는 것이다. (사실, EAR 레벨에서 리소스들을 매핑할 수 있듯이 인다이렉션의 3 번째 레벨에도 가능하다.)

    과거의 DataSource 옮기기

    물론 J2EE의 리소스들은 JDBC 데이터 소스에 제한되지 않는다. 여러 유형의 레퍼런스들이 있다. 리소스 레퍼런스, 환경 엔트리, EJB 레퍼런스 등이 그것이다. 특히 EJB 레퍼런스들은 J2EE의 JNDI에 대한 또 다른 중요한 역할이 있다. 다른 애플리케이션 컴포넌트 찾기이다.

    한 회사가 전개 가능한 EJB 컴포넌트를 구입하여 Order Ontology Processing Services (OOPS) 에서 고객 주문들을 처리할 때 어떤 일이 발생하는지 생각해보자. 이 예제에서는 ProcessOrders V1.0이라고 칭하겠다. ProcessOrders 1.0은 두 조각들로 나타난다: 인터페이스와 지원 클래스 세트(홈 인터페이스 및 원격 인터페이스와 전속 객체 지원), 그리고 실제 EJB 컴포넌트들. OOPS는 이 분야의 전문이기 때문에 선택되었다.

    이 회사는 J2EE 스팩을 따라 EJB 레퍼런스를 사용하는 웹 애플리케이션을 작성한다. 전개자는 ProcessOrders 1.0을 JNDI 트리로 ejb/ProcessOrders/1.0로서 바인딩하고 웹 애플리케이션의 리소스 이름이 글로벌 JNDI 이름을 가르키도록 한다. 여기까지는 EJB 컴포넌트의 일반적인 사용법이다. 하지만 이 회사의 개발 사이클과 공급자의 개발 사이클 사이의 인터랙션을 고려해보면 상황은 더 복잡해진다. 여기에서도 JNDI가 도움이 될 수 있다.

    OOPS가 새 버전인 ProcessOrders V1.1을 발표했다고 가정해보자. 이 새 버전에는 이 회사 내부의 새로운 애플리케이션이 필요로 하는 몇 가지 기능을 갖추었고 EJB 컴포넌트를 위해 비즈니스 인터페이스를 확장한다.

    이 회사에게 몇 가지 선택권이 있다. 이 모든 애플리케이션들을 업데이트하여 새로운 버전을 선택하거나, 고유의 애플리케이션을 작성하거나, JNDI의 레퍼런스를 사용하여 다른 애플리케이션에 영향을 주지 않고 각 애플리케이션이 EJB 컴포넌트의 고유 버전을 사용하도록 할 수 있다. 모든 애플리케이션들을 한번에 업데이트하는 것은 관리가 매우 힘들고, 모든 컴포넌트의 전체 회귀 테스트가 필요하며 함수 테스트가 실패했을 때 또 다른 디버깅이 기다리고 있다.

    인하우스(in-house) 컴포넌트를 작성하는 것은 종종 불필요한 중복 작업이다. 컴포넌트가 해당 비즈니스 영역에서 전문 기술을 닦은 기업에 의해 작성된다면 주어진 IT shop은 비즈니스 기능을 마스터하기 위해 관리할 것 같지 않다. 특성화된 컴포넌트 공급자도 마찬가지다.

    이미 알고 있겠지만 최상의 솔루션은 JNDI를 사용하는 것이다. EJB JNDI 레퍼런스는 JDBC 리소스 레퍼런스들과 매우 비슷하다.
    각 레퍼런스의 경우 전개자는 새로운 컴포넌트를 특정 이름 (ejb/ProcessOrders/1.1) 에 있는 글로벌 트리로 바인딩 한다. 그리고 EJB 컴포넌트를 필요로 하는 다른 모든 컴포넌트를 위해 그 컴포넌트용 전개 디스크립터에서 EJB 레퍼런스를 결정한다. 더 오래된 애플리케이션들(1.0V 기반)은 변경 및 재테스트를 할 필요가 없고 구현 시간, 비용, 복잡성도 줄어든다. 서비스가 버저닝되는 환경에서 이것은 강력한 방식이다. 이러한 종류의 설정 관리는 애플리케이션 아키텍쳐의 모든 획득 가능한 컴포넌트들, EJB 컴포넌트에서 JMS 큐 까지 수행된다. 간단한 설정 스트링 또는 다른 객체 들까지도 수행된다. 시간이 지나면서 서비스가 변경할 때 관리 비용도 낮아지고 전개 및 통합의 수고로움도 줄어든다.

    결론

    모든 프로그래밍 문제는 단 한 개 이상의 추상화(또는 인다이렉션) 레이어로 해결될 수 있다는 오래된 컴퓨터과학 분야의 농담이 있다. J2EE에서, JNDI는 J2EE 애플리케이션들을 하나로 묶는 풀의 역할을 한다. 이것이 엔터프라이즈를 통해 확장성있고 기능이 많으면서 유연한 애플리케이션의 제공을 가능하게 하는 JNDI가 제공하는 인다이렉션이다. 이것이 J2EE가 약속하는 것이고 계획 수립과 앞선 생각이 이 모든 것을 실현할 수 있다. 사실 사람들이 생각하는 것 보다 쉽다.


    출처 : http://www.ibm.com/developerworks/kr/library/j-jndi/

    posted by 좋은느낌/원철
    2008. 7. 1. 15:22 개발/Java

    Java 입문

    자바란 무엇인가?
    왜 자바가 중요한가?
    자바 컴포넌트 기술이란 무엇인가?
    자바는 SOA/웹 서비스와 어떻게 관련이 있는가?
    자바 프로그래밍 능력을 어떻게 향상시킬 수 있는가?
    자바 프로그래머들이 사용할 수 있는 IBM 툴과 제품에는 무엇이 있는가?




    developerWorks 자바 존은 자바 기술과 애플리케이션 관련하여 수 백 개의 기술자료, 튜토리얼, 팁을 제공한다. 하지만 새로운 주제를 시작하는 사용자들에게는 오히려 이 많은 정보들이 부담스러울 것이다. 따라서 이 페이지에서는 자바의 기초를 설명한다. 기술자료, 튜토리얼과, 팁, IBM 교육 서비스, 웹 캐스트, 워크샵, IBM 제품 연구 등 다양한 리소스 형태가 준비되어 있다.


    자바란 무엇인가?

    자바(Java technology)는 객체 지향 프로그래밍 언어이자 Sun Microsystems에서 개발한 플랫폼이다. 자바는 하나의 자바 가상 머신(JVM)(언어와 기저의 소프트웨어 및 하드웨어 간 트랜슬레이터)의 개념에 근거하고 있다. 모든 프로그래밍 언어의 구현들은 JVM을 모방하여 자바 프로그램들이 JVM 버전을 가진 모든 시스템 상에서 실행될 수 있다.

    자바 프로그램이 컴파일되고 (자바 바이트코드 라고 하는 중간 언어로 번역), 인터프리팅(JVM에 의해 파싱 및 실행되는 바이트코드) 되기 때문에 자바 프로그래밍 언어는 평범한 것은 아니다. 컴파일이 일단 발생하면 프로그램이 실행될 때 마다 인터프리팅이 발생한다. 컴파일 된 바이트코드는 JVM을 위해 최적화된 머신 코드의 형태가 된다. 인터프리터는 JVM의 구현이다.

    세 가지 버전으로 되어있는 자바 플랫폼(아래 자바 플랫폼 버전 참조)은 자바와 JVM과 애플릿과 애플리케이션 개발과 전개를 돕는 소프트웨어 컴포넌트들의 컬렉션인 자바 애플리케이션 프로그래밍 인터페이스(API)로 구성되어 있다. 자바 API는 관련 클래스와 인터페이스들의 라이브러리로 나뉜다. 라이브러리는 패키지로 알려져 있다.

    자바 플랫폼 버전들
    자바의 인기가 높아지면서 개발자들은 보다 단순한 것을 요구하게 되었다. Sun Microsystems는 Standard Edition, Enterprise Edition, Micro Edition 등의 다양한 버전의 자바 플랫폼을 개발하여 이러한 요구 사항에 부응하고 있다.

    보다 자세히

    • J2SE(Java 2 Standard Edition). 자바로 애플릿과 애플리케이션을 작성, 전개 구동하는 개발자를 위한 표준 Java 2 SDK, 툴, 런타임, API이다. Magic with Merlin 칼럼에서는 J2SE version, 1.4의 버전에 대한 개요 자료를 제공한다. 최신 버전인 J2SE 1.5 (일명 "Tiger")에 대해서는 Magic with Merlin 필자가 새로운 시리즈, Taming Tiger를 계획하고 있다.

    • J2EE(Java 2 Enterprise Edition). 표준화된 모듈식 컴포넌트에 기반하고 있고, 그러한 컴포넌트에 완벽한 서비스 세트를 제공하며, 복잡한 프로그래밍 없이 애플리케이션 작동의 상세를 자동으로 핸들함으로서 멀티-티어 엔터프라이즈 애플리케이션의 구현과 전개를 간소화 한다. J2EE pathfinder 칼럼에서 J2EE에 대한 이해를 높일 수 있다.

    • J2ME(Java 2 Micro Edition). 이 버전은 고도로 최적화 된 자바 런타임 환경으로서 스마트 폰이나 페이저부터 셋톱(set-top) 박스 까지 (물리적으로나 메모리 기능에서) 작은 장치들을 다룬다. 두 개의 튜토리얼의 4부 구성된 튜토리얼과 J2ME와 Mobile Information Device Profile (MIDP)를 다룬 관련 기술자료를 참조하라.


    		위로


    왜 자바가 중요한가?

    일반적으로 자바의 큰 장점은 플랫폼과 운영 체계간 이식성에 있고 다이얼업 통신 같은 저대역 채널을 통해서 전달될 수 있다는 점이다. 또한 확장성도 있다. 기존 애플리케이션들이 제한된 메모리 리소스를 가진 장치에도 쉽게 순응한다. 게다가 네트워크를 통해서 안전한 방식으로 구동 되도록 설계되었기 때문에 인터넷을 통해 실행될 때에도 같은 수준의 보안을 확립할 수 있다. 자바는 데스크탑에서 웹의 리소스로 사용자의 컴퓨팅 경험을 확대한다.

    자바는 IBM의 온 디맨드 비즈니스 이니셔티브에 중요하다. 자바 (그리고 리눅스)는 기업에서 오픈 표준을 지원하는 기술들 중 하나였고 XML과 웹 서비스를 사용하여 비즈니스 라인들 간 정보와 애플리케이션 공유라는 새 장을 열었다. 게다가 많은 IBM 제품들과 기술 컨설팅 서비스의 중추적인 역할을 한다.

    보다 자세히:

    • 온 디맨드 비즈니스의 철학과, 시장의 요구에 빠르게 부응할 수 있는 엔터프라이즈 시스템을 구현하는데 이것이 어떤 역할을 하는지 배워보자.


    		위로


    자바 컴포넌트 기술이란 무엇인가?

    자바의 약어를 익히는 일은 만만치 않은 일이다. 이번 섹션에서는 컴포넌트, 패키지 옵션, 각 버전의 확장 리스트를 소개하겠다. 각각의 기술 마다 짧은 설명과 링크가 곁들여져 있다. 대부분의 리소스들이 에디션을 통해 사용할 수 있다.

    J2SE:

    • Java Access Bridge for Microsoft Windows는 일종의 다리 역할을 한다. Windows 기반 기술이 Java Accessibility API와 인터랙팅 할 수 있다. ("Coding for accessibility 참조.")

    • JavaBeans Component Architecture는 플랫폼 중립적인 스팩으로서 자바 플랫폼을 위한 표준 컴포넌트 소프트웨어 API를 정의한다.

    • Javadoc은 소스 코드의 doc 주석에서 API 문서를 HTML로 만드는 툴이다. ("I have to document THAT? 참조.")

    • Java Foundation Classes (Swing) (JFC)는 자바 클래스 라이브러리 세트로서 자바 기반의 클라이언트 애플리케이션을 위한 GUI와 그래픽 기능의 구현을 지원한다. ("The Java 2 user interface 참조.")

    • Java Platform Debugger Architecture (JPDA)는 Java 2용 디버깅 지원 인프라이다. JPDA에는 세 개의 레이어드 API가 있다.
      • JDI (Java Debug Interface)는 고급의 프로그래밍 언어 인터페이스로서 원격 디버깅을 지원한다.

      • JDWP (Java Debug Wire Protocol)는 디버깅 프로세스와 디버거 프론트엔드 간 전달되는 정보와 요청의 포맷을 정의한다.

      • JVMDI (Java Virtual Machine Debug Interface)는 저급의 원시 인터페이스로서 JVM이 디버깅을 위해 제공하는 서비스를 정의한다.

      ("The future of software development 참조.")

    • Java 2D API는 이미지 구성과 알파 채널 이미지를 제공하는 고급 2D 그래픽과 이미징을 위한 클래스이자, 정확한 컬러 공간 정의와 변환을 제공하는 클래스이자, 디스플레이 지향의 이미징 오퍼레이터이다. ("Introduction to Java 2D 튜토리얼 참조.")

    • Java Web Start는 설치 절차 없이 한번의 클릭으로 완전한 애플리케이션(스프레드시트)을 다운로드 및 시작할 수 있는 기능을 제공하기 때문에 자바 애플리케이션의 개발이 간단해 진다. ("Java Web Start 참조.")

    • Java Database Connectivity (JDBC)는 자바에서 테이블 형식의 데이터 소스에 액세스 하는데 사용하는 API이다. 광범위한 SQL 데이터베이스에 크로스 DBMS 연결과, 스프레드시트나 플랫 파일 같은 기타 테이블 형식의 데이터 소스로의 액세스를 지원한다. ("What's new in JDBC 3.0 참조.")

    • Remote Method Invocation (RMI)는 부트스트래핑 네이밍 서비스를 제공하며, 유형을 절단하지 않고, 객체 직렬화를 사용하여 프로그래머들이 분산된 자바 기반 애플리케이션을 만들 수 있다. 원격 자바 객체들의 메소드가 다른 호스트에 있는 자바 가상 머신에서 호출될 수 있다. ("Java distributed objects: Using RMI and CORBA 참조.")

    • Java Advanced Imaging (JAI)는 개발자가 이미지를 쉽게 조작할 수 있도록 단순하고 고급의 프로그래밍 모델을 지원하는 객체 지향 인터페이스를 제공하는 API이다. ("JSP 코드로 이미지 관리하기(한글)참조.")

    • Java Authentication and Authorization Service (JAAS)는 자바 버전의 표준 Pluggable Authentication Module (PAM)을 구현하고 사용자 기반 인증을 지원하여 액세스 제어를 인증 및 실행하는 서비스 패키지이다. ("Java security with JAAS and JSSE", "Java security, Part 2: Authentication and authorization", "Extend JAAS for class instance-level authorization" 참조.)

    • Java Cryptography Extension (JCE)은 암호화, 키 생성, 동의, Message Authentication Code (MAC) 알고리즘을 위한 프레임웍과 구현을 제공하는 패키지이다. 암호화를 제공하고 보안 스트림과 보호 객체를 지원한다. ("Java security: Crypto basics 튜토리얼 참조.")

    • Java Data Objects (JDO)는 표준의 인터페이스 기반 자바 모델 영속성의 추상화로서 애플리케이션 프로그래머가 자바 도메인 모델 인스턴스를 영속 스토어(데이터베이스)에 직접 저장할 수 있다. 또한 이 같은 메소드들을 직접적인 파일 입출력, 직렬화, JDBC, EJB Bean Managed Persistence (BMP), Container Managed Persistence (CMP) Entity Beans으로 대체할 수 있다. (튜토리얼 "Hands-on Java Data Objects","Object-relation mapping without the container 참조.")

    • Java Management Extensions (JMX)는 장치, 애플리케이션, 서비스 중심 네트워크의 관리와 모니터링을 위한 웹 기반, 모듈식의 동적인 애플리케이션을 구현하는 툴을 제공한다. JMX Remote는 이러한 에이전트에 원격으로 액세스하는 수단을 표준화하는 기능을 제공하여 JMX 스팩을 확장한 것이다. ("From black boxes to enterprises: JMX 1.1 style 참조.")

    • Java Media Framework (JMF)는 오디오, 비디오, 기타 시간 기반 미디어들을 자바 애플리케이션과 애플릿에 추가시킨다. (튜토리얼 "Java Media Framework basics참조.")

    • Java Naming and Directory Interface (JNDI)는 자바 애플리케이션에 다중 네이밍 및 디렉토리 서비스에 대한 통합 인터페이스를 제공하는 표준 확장으로서 이종의 엔터프라이즈 네이밍 및 디렉토리 서비스에 완벽한 연결이 가능하다. ( "Industrial-strength JNDI optimization"; "Navigate the JNDI maze 참조.")

    • Java Secure Socket Extensions (JSSE)는 보안 인터넷 통신을 가능케 하는 패키지 세트로서 자바 버전의 SSL (Secure Sockets Layer)과 TLS (Transport Layer Security) 프로토콜을 구현하고 데이터 암호화, 서버 인증, 메시지 무결성, 선택적 클라이언트 인증을 위한 기능을 포함시켰다. ("Java security with JAAS and JSSE", 튜토리얼 "Using JSSE for secure socket communication 참조.")

    • Java Speech API (JSAPI) -- Grammar Format (JSGF)과 Markup Language (JSML) 스팩이 포함되어 있으며, 자바 애플리케이션에서 스피치 기술과 사용자 인터페이스를 통합시켰다. JSAPI는 크로스 플랫폼 API를 정의하여 명령어와 제어 인지자, 명령 시스템, 스피치 신디사이저를 지원한다. ("The Java 2 user interface 참조.")

    • Java 3D는 확장성 있는, 플랫폼 독립의 3D 그래픽을 자바 애플리케이션으로 결합하는데 쉽게 사용할 수 있다. 간단한 고급 프로그래밍 모델을 지원하는 객체 지향 인터페이스를 제공한다. (튜토리얼 "Java 3D joy ride 참조.")

    J2EE 기술:

    • Java API for XML Processing (JAXP)는 DOM, SAX, XSLT를 사용하여 XML 문서의 프로세싱을 지원한다. 애플리케이션이 특정 XML 구현과 독립적으로 XML 문서를 파싱 및 변형할 수 있고, 개발자는 애플리케이션 코드를 변경하지 않고도 XML 프로세서들을 바꿀 수 있다. ("자바 프로그래밍으로 온라인 XML 데이터 검색하기 (한글) 참조.")

    • Java API for XML Registries (JAXR)는 다양한 종류의 XML 레지스트리에 액세스 하는 표준 API를 제공한다. (웹 서비스의 구현, 전개, 발견을 위한 인프라를 실행한다. ("Java technology standards 참조.)

    • Java API for XML-based RPC (JAX-RPC)를 사용하여 SOAP 기반의 상호 운용성 및 이식성 있는 서비스를 개발한다. ("Java technology standards 참조.)

    • SOAP with Attachments API for Java (SAAJ)를 사용하여 SOAP 1.1 스팩과 SOAP with Attachments 노트에 순응하는 메시지를 생산 및 소비할 수 있다. ("Send and receive SOAP messages with SAAJ"; "자바 웹 서비스 (한글)" , developerWorks XML 섹션 참조.)

    • Common Object Request Broker Architecture (CORBA)는 자바를 보완하는 이종의 컴퓨팅을 위한 오픈 표준이다. 분산 객체 프레임웍, 그 프레임웍을 지원하는 서비스, 다른 언어와의 상호 운용성을 제공한다. (튜토리얼 "Java distributed objects: Using RMI and CORBA"; "기업에서의 RMI-IIOP (한글)" 참조.)

    • ECperf는 웹 비즈니스 시스템의 퍼포먼스와 확장성을 측정하는데 사용되는 벤치마크이다. 애플리케이션을 구성하는 EJB 컴포넌트, 싱글 유저/인터랙티브 테스팅에 JSP를 사용하는 웹 클라이언트, 스키마 스크립트와 로드 프로그램, makefile과 전개 디스크립터, 규칙을 실행하고 클라이언트 로드를 시뮬레이트 하는 드라이버 프로그램 등이 포함된다. (Java technology standards 참조.)

    • Enterprise JavaBeans (EJB)는 트랜잭션, 보안, 데이터베이스 연결성 등을 지원하여 미들웨어 애플리케이션의 개발을 간소화 하는 컴포넌트 모델을 사용한다. (튜토리얼 "Getting started with Enterprise JavaBeans technology"와 EJB best practices 참조.)

    • Java Authorization Contract for Containers (Java ACC)는 컨테이너가 사용할 권한 공급자의 설치와 설정을 정의하는 스팩이다. Java ACC는 공급자가 사용할 인터페이스를 정의한다. (튜토리얼 "Developing accessible GUIs with Swing참조.")

    • JavaMail은 메일 시스템을 모델링 하는 추상 클래스 세트를 제공하는 API이다. (튜토리얼 "Fundamentals of JavaMail API 참조.")

    • Java Message Service (JMS)는 JMS 기술 순응의 메시징 시스템들에 의해 지원을 받을 메시징 개념과 프로그래밍 전략들을 정의하여 자바 플랫폼을 위한 이식 가능한 메시지 기반의 애플리케이션의 개발을 실행하도록 프로바이더 프레임웍을 추가하는 API 이다. ("Get the message: Messaging in J2EE 1.4", "Enterprise messaging with JMS", "벤더로 부터 독립된 JMS 솔루션 구현하기 (한글)", 튜토리얼 "Introducing the Java Message Service 참조.")

    • JavaServer Faces (JSF)는 재사용 가능한 UI 컴포넌트를 한 페이지 안에 정렬하여 웹 애플리케이션을 만드는 프로그래밍 모델을 제공한다. 이러한 컴포넌트들을 애플리케이션 데이터 소스로 연결하고 클라이언트가 생성한 이벤트를 서버측 이벤트 핸들러로 연결한다. (JSF for nonbelievers, UI development with JavaServer Faces", "Struts, Tiles, JavaServer Faces 통합하기 (한글)" 참조.")

    • JavaServer Pages (JSP)를 사용하여 동적인 플랫폼 독립의 웹 페이지를 빠르고 쉽게 개발할 수 있다. 디자이너들은 동적 콘텐트를 변경하지 않고 페이지 레이아웃을 변경할 수 있다. 이 기술을 XML 계열의 태그를 사용한다. (튜토리얼 "Introduction to JavaServer Pages technology", JSP best practices 참조.)

    • Java Servlets는 자바가 웹 서버를 확장하고 향상시키는 방식이다. CGI 프로그램의 퍼포먼스 제한 없이 웹 기반 애플리케이션을 구현하는 컴포넌트 기반, 플랫폼 독립의 메소드를 제공한다. (Roy Miller의 Introduction to Java Servlet technology 참조.)

    • J2EE Connector Architecture (JCA)는 이종의 EIS(Enterprise Information Systems)에 J2EE 플랫폼을 연결하는 표준 아키텍처를 정의한다. 확장성 있고 안전한 방식을 제공하고 EIS 벤더들은 애플리케이션 서버에 플러그인 될 수 있는 표준 리소스 어댑터를 제공한다. ("Choosing among JCA, JMS, and Web services for EAI", "Integrate remote enterprise information systems with JCA, JMS, and Web services", "Introduction to the J2EE Connector Architecture 참조.")

    • J2EE Management Specification (JMX)는 J2EE 플랫폼, J2EE 관리 모델을 위한 관리 정보 모델을 정의한다. 이 모델은 많은 관리 시스템과 프로토콜과 상호 운용될 수 있도록 설계 된다. 이 모델은 많은 관리 시스템과 프로토콜과 상호 운용되도록 설계되었다. Common Information Model (CIM), SNMP Management Information Base (MIB), EJB 컴포넌트를 통한 자바 객체 모델, J2EE Management EJB Component (MEJB)에 대한 표준 매핑이 포함되어 있다. ("From black boxes to enterprises: Management, JMX 1.1 style 참조.")

    • Java Transaction API (JTA)는 고급의 구현 및 프로토콜 독립적인 API로서 애플리케이션과 애플리케이션 서버들이 트랜잭션에 액세스 할 수 있다. Java Transaction Service (JTS) 는 JTA를 지원하는 Transaction Manager의 구현을 지정하고 OMG Object Transaction Service (OTS) 1.1 스팩의 자바 매핑을 정의한다. JTS 는 transactions using the Internet Inter-ORB Protocol (IIOP)를 사용하여 트랜잭션을 전파한다. ("JTS 이해하기 - 트랜잭션에 대한 소개 (한글) 참조.")

    J2ME:

    • Connected Limited Device Configuration (CLDC)은 리소스 제한 모바일 정보 장치용 자바 런타임 환경을 구성하는 두 개의 설정 중 하나이다. CLDC는 가장 기본적인 라이브러리와 가상 모신 기능을 구성한다. 이것은 각 J2ME 구현에 나타나며 여기에는 K 가상 머신(KVM)이 포함된다.

    • Mobile Information Device Profile (MIDP)는 리소스 제한 모바일 정보 장치용 자바 런타임 환경을 구성하는 두 개의 설정 중 하나이다. MIDP는 코어 애플리케이션 기능을 제공한다. 사용자 인터페이스, 네트워크 연결, 로컬 데이터 스토리지, 애플리케이션 수명 관리 등이 포함된다. (튜토리얼 "Implementing Push technology with J2ME and MIDP 참조.")

    • Connected Device Configuration (CDC) 은 네트워크로 연결된 사용자와 임베디드 장치간 공유될 수 있는 애플리케이션을 구현 및 전달하는 표준 기반의 프레임웍이다. ("Securing wireless J2ME 참조.")

    자바 네트워킹:

    • JAIN은 자바 기반의 API로서 차세대 텔레콤 제품과 서비스의 빠른 개발을 이끈다. JSLEE는 이벤트 중심의 컴포넌트 기반 컨테이너 기술로서 고성능의 비동기식의 오류에 강한 애플리케이션 서버이다. (Java technology standards 참조.)

    • Java Metadata Interface (JMI)는 동적인 플랫폼 중립적인 인프라를 구현하는 스팩으로서 메타데이터의 생성, 스토리지, 액세스, 발견, 교환을 실행한다. Object Management Group (OMG)의 Meta Object Facility (MOF) 스팩에 기반하고 있으며 UML (Unified Modeling Language)을 사용하여 기술되는 기본적인 모델링 생성물들로 구성되어 있다. (Java technology standards 참조)

    • JavaGroups는 분산된 시스템 솔루션을 갖춘 디자인, 구현, 실험을 위한 소프트웨어 툴킷(API 라이브러리)이다. ("High-impact Web tier clustering, Part 1" Part 2 참조.)

    • Jini는 하드웨어와 소프트웨어를 위한 네트워크 중심의 서비스를 구현하는 개방 아키텍처이다. Jini 시스템 아키텍처는 세 개 범주, 프로그래밍 모델, 인프라, 서비스로 구성되어 있다. ("Jini networking technology, the next step 참조.")

    • JXTA는 오픈 프로토콜로서 네트워크 상에서 연결된 어떤 장치라도 P2P 방식으로 통신 및 협업할 수 있다. JXTA 피어는 가상 네트워크를 만든다. 이곳에서 모든 피어들은 다른 피어들이나 리소스들과 직접 인터랙팅 한다. 피어나 리소스가 방화벽과 NAT 뒤에 있거나 다른 네트워크 트랜스포트에 있어도 통신이 가능하다. ("Making P2P interoperable: The JXTA story", "JXTA 2: A high-performance, massively scalable P2P network 참조.")


    		위로


    자바는 SOA/웹 서비스와 어떻게 관련이 있는가?

    서비스 지향 아키텍처는 애플리케이션(웹 서비스)의 기능 단위들을 잘 정의된 인터페이스들과 서비스들간 컨트랙트에 연관시키는 컴포넌트 모델이다. 인터페이스는 하드웨어, 운영 체계, 프로그래밍 언어와 독립적인 방식으로 정의된다. 다른 시스템에서 구현된 서비스들도 일관되고 통용된 방식으로 인터랙팅 할 수 있다. SOA는 약결합 방식의 모델로서, 전통적인 강결합 방식의 객체 지향 모델에 대한 대안이라고 할 수 있다.

    비즈니스 규칙과 프로세스는 XML로 정의되어 소프트웨어 애플리케이션은 플랫폼 및 프로그래밍 언어와는 독립된 방식으로 통신할 수 있다. XML은 데이터 이식성을 높이고 메시지의 생성을 수월하게 한다. XML과 자바는 웹 서비스를 구현 및 전개하는데 이상적인 조합이라 할 수 있다.

    보다 자세히:



    		 위로


    자바 프로그래밍 능력을 어떻게 향상시킬 수 있는가?

    두 가지 방법이 있다. 정규 코스를 밟는 것(인증 또는 교육)과 독학(코드 작성 연습)이다. 숙련된 개발자들의 지식을 배우는 것 외에도, 인증 과정을 밟으면서 기술을 향상시킬 수 있다. 스스로 실험해 보고, 리소스도 사용해 보면서 자바 기술을 발전시킬 수 있다.

    보다 자세히:



    		 위로


    자바 프로그래머들이 사용할 수 있는 IBM 툴과 제품에는 무엇이 있는가?

    IBM은 자바 사용에 있어서 선두적인 위치에 서 있다. 자바 다운로드와 제품 페이지에서 전체 리스트를 볼 수 있겠지만, 우선 먼저 중요한 내용만 간추렸다.

    보다 자세히:



    		위로
    posted by 좋은느낌/원철
    2008. 7. 1. 15:20 개발/Java

    ClassLoader를 이용한 서버 종류 알아내기

    현재 프로젝트가 개발은 Tomcat으로, 서버는 JEUS를 사용하고 있습니다. 이런 환경을 제가 만든건 아니고 ㅡ.ㅡ; EJB개발하는것도 아닌데 JEUS가 너무 무거우니 간단하게 그냥 tomcat가자는 다른분의 의견이 받아들여진 것이었죠.

     

    Servlet spec 2.4를 기준으로 작업을 하니 웬만한건 양쪽다 먹는데 JNDI로 datasource를 가져오는 부분의 방법이 서로 틀리더군요.

     

    Spring에서 datasource정의하는 부분도 JEUS, Tomcat용으로 따로 사용을 하곤 했죠.

    이건 그냥 Spring 설정파일 바꾸는거니 그런대로 할만 했습니다.

     

    그러다가 Spring+Ibatis조합을 안통하고 그냥 JDBC 코딩을 해야 될 상황이 생겼는데 이때는 무지하게 귀찮아지더군요. 컴파일을 새로해야 되니 너무 귀찮아서요.

     

    Liferay라는 오픈소스를 보다 정답을 찾았죠. Server의 종류를 알아내는 방법이 있더군요.

    ClassLoader.getSystemClassLoader().loadClass();을 이용하더군요.

    허접한 개발자라 몰랐습니다. 이런방법이 있을줄..

     

    다음은 그 클래스 소스입니다.

     

    package com.test;

     

    public class ServerDetector {

     

                   public static final String JEUS_CLASS = "/jeus/server/JeusServer.class";

     

                   public static final String JEUS_ID = "jeus";

     

                   public static final String GERONIMO_CLASS = "/org/apache/geronimo/system/main/Daemon.class";

     

                   public static final String GERONIMO_ID = "geronimo";

     

                   public static final String GLASSFISH_CLASS = "/com/sun/appserv/ClassLoaderUtil.class";

     

                   public static final String GLASSFISH_ID = "glassfish";

     

                   public static final String JBOSS_CLASS = "/org/jboss/Main.class";

     

                   public static final String JBOSS_ID = "jboss";

     

                   public static final String JETTY_CLASS = "/org/mortbay/jetty/Server.class";

     

                   public static final String JETTY_ID = "jetty";

     

                   public static final String JONAS_CLASS = "/org/objectweb/jonas/server/Server.class";

     

                   public static final String JONAS_ID = "jonas";

     

                   public static final String OC4J_CLASS = "oracle.oc4j.util.ClassUtils";

     

                   public static final String OC4J_ID = "oc4j";

     

                   public static final String ORION_CLASS = "/com/evermind/server/ApplicationServer.class";

     

                   public static final String ORION_ID = "orion";

     

                   public static final String PRAMATI_CLASS = "/com/pramati/Server.class";

     

                   public static final String PRAMATI_ID = "pramati";

     

                   public static final String RESIN_CLASS = "/com/caucho/server/resin/Resin.class";

     

                   public static final String RESIN_ID = "resin";

     

                   public static final String REXIP_CLASS = "/com/tcc/Main.class";

     

                   public static final String REXIP_ID = "rexip";

     

                   public static final String SUN7_CLASS = "/com/iplanet/ias/tools/cli/IasAdminMain.class";

     

                   public static final String SUN7_ID = "sun7";

     

                   public static final String SUN8_CLASS = "/com/sun/enterprise/cli/framework/CLIMain.class";

     

                   public static final String SUN8_ID = "sun8";

     

                   public static final String TOMCAT_BOOTSTRAP_CLASS = "/org/apache/catalina/startup/Bootstrap.class";

     

                   public static final String TOMCAT_EMBEDDED_CLASS = "/org/apache/catalina/startup/Embedded.class";

     

                   public static final String TOMCAT_ID = "tomcat";

     

                   public static final String WEBLOGIC_CLASS = "/weblogic/Server.class";

     

                   public static final String WEBLOGIC_ID = "weblogic";

     

                   public static final String WEBSPHERE_CLASS = "/com/ibm/websphere/product/VersionInfo.class";

     

                   public static final String WEBSPHERE_ID = "websphere";

                  

     

                   private static ServerDetector _instance = new ServerDetector();

     

                   private String _serverId;

     

                   private Boolean _jeus;

     

                   private Boolean _geronimo;

     

                   private Boolean _glassfish;

     

                   private Boolean _jBoss;

     

                   private Boolean _jetty;

     

                   private Boolean _jonas;

     

                   private Boolean _oc4j;

     

                   private Boolean _orion;

     

                   private Boolean _pramati;

     

                   private Boolean _resin;

     

                   private Boolean _rexIP;

     

                   private Boolean _sun7;

     

                   private Boolean _sun8;

     

                   private Boolean _tomcat;

     

                   private Boolean _webLogic;

     

                   private Boolean _webSphere;   

                  

                   private ServerDetector() {

                   }       

                  

     

                   public static String getServerId() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._serverId == null) {

                                                   if (ServerDetector.isJeus()) {

                                                                  sd._serverId = JEUS_ID;

                                                   }

                                                   else if (ServerDetector.isGeronimo()) {

                                                                  sd._serverId = GERONIMO_ID;

                                                   }

                                                   else if (ServerDetector.isGlassfish()) {

                                                                  sd._serverId = GLASSFISH_ID;

                                                   }

                                                   else if (ServerDetector.isJBoss()) {

                                                                  sd._serverId = JBOSS_ID;

                                                   }

                                                   else if (ServerDetector.isJOnAS()) {

                                                                  sd._serverId = JONAS_ID;

                                                   }

                                                   else if (ServerDetector.isOC4J()) {

                                                                  sd._serverId = OC4J_ID;

                                                   }

                                                   else if (ServerDetector.isOrion()) {

                                                                  sd._serverId = ORION_ID;

                                                   }

                                                   else if (ServerDetector.isPramati()) {

                                                                  sd._serverId = PRAMATI_ID;

                                                   }

                                                   else if (ServerDetector.isResin()) {

                                                                  sd._serverId = RESIN_ID;

                                                   }

                                                   else if (ServerDetector.isRexIP()) {

                                                                  sd._serverId = REXIP_ID;

                                                   }

                                                   else if (ServerDetector.isSun7()) {

                                                                  sd._serverId = SUN7_ID;

                                                   }

                                                   else if (ServerDetector.isSun8()) {

                                                                  sd._serverId = SUN8_ID;

                                                   }

                                                   else if (ServerDetector.isWebLogic()) {

                                                                  sd._serverId = WEBLOGIC_ID;

                                                   }

                                                   else if (ServerDetector.isWebSphere()) {

                                                                  sd._serverId = WEBSPHERE_ID;

                                                   }

                                                   else if (ServerDetector.isWebSphere()) {

                                                                  sd._serverId = WEBSPHERE_ID;

                                                   }

                                                   if (ServerDetector.isJetty()) {

                                                                  if (sd._serverId == null) {

                                                                                  sd._serverId = JETTY_ID;

                                                                  }

                                                                  else {

                                                                                  sd._serverId += "-" + JETTY_ID;

                                                                  }

                                                   }

                                                   else if (ServerDetector.isTomcat()) {

                                                                  if (sd._serverId == null) {

                                                                                  sd._serverId = TOMCAT_ID;

                                                                  }

                                                                  else {

                                                                                  sd._serverId += "-" + TOMCAT_ID;

                                                                  }

                                                   }

                                                  

                                                   System.out.println("Detected server ===========================> " + sd._serverId);

                                                  

                                                   if (sd._serverId == null) {

                                                                  throw new RuntimeException("Server is not supported");

                                                   }

                                  }

     

                                  return sd._serverId;

                   }

     

                   public static boolean isJeus() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._jeus == null) {

                                                   sd._jeus = _detect(JEUS_CLASS);

                                  }

     

                                  return sd._jeus.booleanValue();

                   }       

                  

                   public static boolean isGeronimo() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._geronimo == null) {

                                                   sd._geronimo = _detect(GERONIMO_CLASS);

                                  }

     

                                  return sd._geronimo.booleanValue();

                   }

     

                   public static boolean isGlassfish() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._glassfish == null) {

                                                   sd._glassfish = _detect(GLASSFISH_CLASS);

                                  }

     

                                  return sd._glassfish.booleanValue();

                   }

     

                   public static boolean isJBoss() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._jBoss == null) {

                                                   sd._jBoss = _detect(JBOSS_CLASS);

                                  }

     

                                  return sd._jBoss.booleanValue();

                   }

     

                   public static boolean isJetty() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._jetty == null) {

                                                   sd._jetty = _detect(JETTY_CLASS);

                                  }

     

                                  return sd._jetty.booleanValue();

                   }

     

                   public static boolean isJOnAS() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._jonas == null) {

                                                   sd._jonas = _detect(JONAS_CLASS);

                                  }

     

                                  return sd._jonas.booleanValue();

                   }

     

                   public static boolean isOC4J() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._oc4j == null) {

                                                   sd._oc4j = _detect(OC4J_CLASS);

                                  }

     

                                  return sd._oc4j.booleanValue();

                   }

     

                   public static boolean isOrion() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._orion == null) {

                                                   sd._orion = _detect(ORION_CLASS);

                                  }

     

                                  return sd._orion.booleanValue();

                   }

     

                   public static boolean isPramati() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._pramati == null) {

                                                   sd._pramati = _detect(PRAMATI_CLASS);

                                  }

     

                                  return sd._pramati.booleanValue();

                   }

     

                   public static boolean isResin() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._resin == null) {

                                                   sd._resin = _detect(RESIN_CLASS);

                                  }

     

                                  return sd._resin.booleanValue();

                   }

     

                   public static boolean isRexIP() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._rexIP == null) {

                                                   sd._rexIP = _detect(REXIP_CLASS);

                                  }

     

                                  return sd._rexIP.booleanValue();

                   }

     

                   public static boolean isSun() {

                                  if (isSun7() || isSun8()) {

                                                   return true;

                                  }

                                  else {

                                                   return false;

                                  }

                   }

     

                   public static boolean isSun7() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._sun7 == null) {

                                                   sd._sun7 = _detect(SUN7_CLASS);

                                  }

     

                                  return sd._sun7.booleanValue();

                   }

     

                   public static boolean isSun8() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._sun8 == null) {

                                                   sd._sun8 = _detect(SUN8_CLASS);

                                  }

     

                                  return sd._sun8.booleanValue();

                   }

     

                   public static boolean isTomcat() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._tomcat == null) {

                                                   sd._tomcat = _detect(TOMCAT_BOOTSTRAP_CLASS);

                                  }

     

                                  if (sd._tomcat == null) {

                                                   sd._tomcat = _detect(TOMCAT_EMBEDDED_CLASS);

                                  }

     

                                  return sd._tomcat.booleanValue();

                   }

     

                   public static boolean isWebLogic() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._webLogic == null) {

                                                   sd._webLogic = _detect(WEBLOGIC_CLASS);

                                  }

     

                                  return sd._webLogic.booleanValue();

                   }

     

                   public static boolean isWebSphere() {

                                  ServerDetector sd = _instance;

     

                                  if (sd._webSphere == null) {

                                                   sd._webSphere = _detect(WEBSPHERE_CLASS);

                                  }

     

                                  return sd._webSphere.booleanValue();

                   }

     

                   private static Boolean _detect(String className) {

                                  try {

                                                   ClassLoader.getSystemClassLoader().loadClass(className);

     

                                                   return Boolean.TRUE;

                                  }

                                  catch (ClassNotFoundException cnfe) {

                                                   ServerDetector sd = _instance;

     

                                                   Class c = sd.getClass();

     

                                                   if (c.getResource(className) != null) {

                                                                  return Boolean.TRUE;

                                                   }

                                                   else {

                                                                  return Boolean.FALSE;

                                                   }

                                  }

                   }

    }

    posted by 좋은느낌/원철
    2008. 6. 30. 17:51 개발/Java

    APIs_For_JAVA

    출철 : http://msinterdev.org/blog/entry/APIsForJAVA

    pistosApi

    http://pistos.pe.kr/javadocs/main.do


    JConfig

    http://www.jconfig.org/

    JConfig와 Spring - http://www.zonic-temple.org/blog.jz?fn=jconfig_spring


    displayTag - http://openframework.or.kr/displaytag/ (번역)

                      http://displaytag.sourceforge.net/


    프레임워크  및 자바 기술 관련 아티클

    http://julymon.enbee.com/


    Appfuse Wiki

    http://raibledesigns.com/wiki/


    오픈소스 프레임워크 네이버카페 - 위키 페이지

    http://openframework.or.kr

    Appfuse 한국어 번역 위키 역시 같이 있음


    그중 XmlBeans 번역 - http://openframework.or.kr/JSPWiki/Wiki.jsp?page=XMLBeans

          Groovy JDBC 번역 - http://openframework.or.kr/JSPWiki/Wiki.jsp?page=Groovyjdbcprogramming

          마소Groovy - http://openframework.or.kr/JSPWiki/Wiki.jsp?page=Groovy

          JMeter Start 페이지 - http://openframework.or.kr/JSPWiki/Wiki.jsp?page=Jmeterstartpage

          등등의 좋은 번역물및 포스트 다수


    Spring 카페

    http://cafe.naver.com/springframework.cafe


    서영아빠님 블로그

    http://blog.naver.com/ecogeo.do


    오픈시드닷넷

    http://www.OpenSeed.net


    좋은 자료들(장윤기님)

    http://www.javamania.pe.kr


    박영록님 블로그

    http://youngrok.com/wiki/wiki.php


    이종하님의 홈페이지

    http://eclipse.new21.org/phpBB2/index.php

    IT 거버넌스

    http://itgs.egloos.com/


    MyJavaPack

    http://www.open-centric.com/myjavapack/index.html


    물개선생님 블로그

    http://openseed.net/seal/


    토비님 블로그

    http://toby.epril.com/index.php


    서민구님

    http://mkseo.pe.kr/frame.htm

    이희승님


    김형준님

    http://jaso.co.kr/tatter/index.php


    써니님(개발에 대한 탁월한 지혜와 식견)

    http://sunnykwak.egloos.com


    우하하님

    http://woohaha.egloos.com/


    아키텍트로 계시는 투덜이님 블로그

    http://agrumpy.egloos.com/


    숏달님 블로그

    http://nicejay.egloos.com/


    이글루스 siegzion님..(개발자)

    http://siegzion.egloos.com/



    엠파스  쪽박님 블로그(Spring등 관련 )

    http://blog.empas.com/blackcomb7


    POSA및 주옥같은 정리[케빈님]

    http://kevinheo.cafe24.com/

    http://blog.naver.com/kyeongwook94


    최범균님 강좌페이지

    http://javacan.madvirus.net/main/content/contentCategory.jsp


    자바아티클 및 관련글 번역

    http://blog.empas.com/kkamdung/list.html?c=212880




    =================================================================

    좋은 컨텐츠를 포스팅 하시는 분들의 블로그들

    =================================================================

    뚱가님의 블로그[오픈소스와 J2SE관련 번역글및 포스트]

    http://blog.naver.com/toongas


    Ajax강의/컬럼 과 다른(자바관련등) 자료들

    http://blog.naver.com/jinoxst


    굿현님의 블로그

    http://goodhyun.com/


    이동국님의 블로그 중 iBatis SQLMap 관련

    http://openframework.or.kr/blog/?cat=4


    이글루스의 serenic - Spring등 오픈소스 관련 좋은 포스트

    http://serenic.egloos.com/


    개발관련

    http://blog.empas.com/kkamdung


    http://blog.empas.com/naruma


    건호랩님의 블로그 - 자바 관련 팁

    http://blog.naver.com/devstory


    한기아빠님 블로그 - 웹서비스등

    http://blog.naver.com/junghyun


    자바 강의 자료

    http://blog.naver.com/skyymj106

    =================================================================







    이클립스 튜토리얼 프로젝트의 한글 서비스

    https://eclipse-tutorial.dev.java.net/


    http://ubuntu.or.kr/wiki.php - 우분투 한국어 위키

    Ubuntu Linux - Welcome to Ubuntu Linux => 오리지날 홈

    * KLDP 비비에스

    http://bbs.kldp.org/


    * 오픈소스 프로젝트 지원

    http://kldp.net/


    mail 관련

    http://www.vipan.com/htdocs/javamail.html


    * DB관련

    오라클어드민

    http://blog.naver.com/kddasang.do

    Pro*C관련

    http://hobak.emailkorea.net/hobak/proc/

    오라클 technical bulletin

    http://211.106.111.113:8880/bulletin/list.jsp


    * 웹관련

    일모리님 블로그

    http://ilmol.com/wp/


    js 퍼포먼스 테스트

    http://www.umsu.de/jsperf/


    자바스크립트 정리잘된 블로그(쎄이님)

    http://blog.naver.com/tear230



    자바스크립트 관련 레퍼런스& 소스 사이트

    http://jsguide.net/

    http://www.cginjs.com

    http://java.up2.co.kr/

    코리아인터넷닷컴 자바스크립트

    안광해의 자바월드

    이용석의 자바스크립트와 다이나믹 HTML


    자바및 자바스크립트 정리노트

    http://www.javaclue.org/index.jsp ( 자바클루)








    Oracle관련 사이트

    SQL tip & 참고자료들 블로그 : http://blog.naver.com/orapybubu

    -----------------------------------------------------------------------------------

    JVM tunniing Blog -> http://blog.chosun.com/blog.screen?blogId=155&menuId=36901



    거장들

    ------------------------------------------------------------------------------------

    마틴파울러

    http://www.martinfowler.com/



    레퍼런스 사이트

    -------------------------------------------------------------------------------------

    http://www.ambysoft.com : OR 매핑 또는 Agile Modeling 관련 많은 컬럼이 있습니다.


    http://www.theserverside.com/talks/




    고급 아티클

    ☆ http://www.theserverside.com: 설명이 필요 없는 사이트 입니다. 자바 또는 엔터프라이즈 애플리케이션 개발자라면 반드시 매일 또는 매주 한번 이상은방문해봐야 하는 사이트 입니다. 초급에서 중급, 고급 기술로 넘어가기 위해서는 여기 올라오는 컬럼 또는 과거의 컬럼을 가능한많이 읽어 보고 이해해야 합니다.


    ☆ http://www.onjava.com : oreilly에서 운영하는 사이트로 자바 관련 기술 컬럼들이 많이 있습니다.


    Tips[도움이 될만한 유틸들]

    xml formatter

    http://homepage.ntlworld.com/wayne_grant/xmlformatter.html


    Tools관련

    posted by 좋은느낌/원철
    prev 1 2 next

    티스토리툴바