개발자가 놓치기 쉬운 자바의 기본원리

public final static Color WHITE = new Color(255, 255, 255);

                public class T ..
                    private int a;
                    private int b;
                    private int c;
                    
                    private int calc(){
                        c = a + b;
                        return c * c;
                    }
   
                    ....other method or getter/setter...

            private static int calc(int a, int b){
               int c = a + b;
               return c * c;
            }

            String str = "111222";
            String a = "111";
            String b = "222";
            String c = "111";
            String d = b;
            String t = str.substring(0,3);  //111

        //(참고)Member에는 두개의 field(Identity Class 형의 ID와 Family Class 형의 family)가 있다. 
        
        /** shallow copy */
        Member shallowCopy(){
            Member newer = new Member();
            newer.id = this.id;
            newer.family = this.family;
            
            return newer;
        }     
        
        /** deep copy */
        Member deepCopy(){
            Member newer = new Member();
            newer.id = new Idetity(this.id.getId(), this.id.getName());
            newer.family = new Family(this.family.getFamilyName(), this.family.getFamilyInfo());
            
            return newer;
        }
        

        synchronized void method1(){
            ...
        }
        
        void method2(){
            synchronized(this){
                ...
            }
        }

        try{
            ...
            System.exit(1);
        }catch(...){
        }finally{
            ... //이 부분은 실행되지 않는다.
        }

private void writeObject(java.io.ObjectOutputStream out) throws IOException;
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;

        private synchronized void writeObject(java.io.ObjectOutputStream s) throws IOException {
            s.defaultWrtieObject(); //이 코드는 무조건 들어가게 되는데 이곳 소스의 System.arraycopy()에서 overflow발생한다.
            
            s.writeInt(size);   //이부분이 실제 추가되어 Stack Overflow를 예방한다.
            
            for(Entry e = ...)
                s.writeObject(e.element);
            }
            ...
        }
        
        //readObject()도 이와 같은 개념으로 변경되어 있다.

        class Test{
            class InnerClass {
                int i;
                ...
            }
            
            public static void main(String[] args){
                InnerClass icls = new InnerClass();
                ...
            }
        }

        public class OuterClass {
            public int get(){
                int i = 9;
                int id = 99;
                int id2 = 99;
                final int id3 = 100000;
                
                class LocalInnerClass {
                    int id = 100;
                    
                    LocalInnerClass(){
                        System.out.println("LocalInnerClass");   
                    }
                    
                    int getId(){
                        return id3 + id;
                    }
                }   
                
                LocalInnerClass lic = new LocalInnerClass();
                return id + lic.getId();
            }   
            
            public static void main(String[] args){
                OuterClass outer = new OuterClass();
                System.out.println("id = " + outer.get());  
                //결과 값은 "100000(id3) + 100(LocalInnerClass.id) + 99(OuterClass.get())" 인 100199가 나온다.
            }
            
        }

        class AnonymousTest {
            private interface Printable {
                void print();
            }
            
            static void doPrint(Printable p){
                p.print();
            }
            
            public static void main(String[] args){
                doPrint( new Printable(){
                            public void print(){
                                System.out.println("this is new Printable print()");
                            }
                         });
            }
        }

        //IFS.java
        interface IFS {
            public String getName();
        }
        
        //Impl1.java
        class Impl1 implements IFS {
            public String getName(){
                return "Impl1";
            }
        }
     
        //Impl2.java
        class Impl2 implements IFS {
            public String getName(){
                return "Impl2";
            }
        }   
        
        //main이 있는 OverloadTest.java
        public class OverloadTest {
    
            static void pr(int i){
                System.out.println("pr_int : " + i);   
            }
            
            static void pr(String s){
                System.out.println("pr_string : " + s);   
            }
            
            static void pr(IFS ifs){
                System.out.println("pr_string : " + ifs.getName());
            }
            
            static void pr_run(Impl1 i1){
                System.out.println("pr_run : " + i1.getName());
            }
            
            static void pr_run(Impl2 i2){
                System.out.println("pr_run : " + i2.getName());
            }
            
            public static void main(String[] args){
                OverloadTest test = new OverloadTest();
                test.pr(10);
                test.pr("Jeid");   
                
                IFS ifs1 = new Impl1();
                test.pr(ifs1);
                
                IFS ifs2 = new Impl2();
                test.pr(ifs2);
                
                //pr_run(ifs1);
                //pr_run(ifs2);
            }
        }

        OverloadTest.java:36: cannot resolve symbol
        symbol  : method pr_run (IFS)
        location: class OverloadTest
                pr_run(ifs1);
                ^
        OverloadTest.java:37: cannot resolve symbol
        symbol  : method pr_run (IFS)
        location: class OverloadTest
                pr_run(ifs2);
                ^
        2 errors

        class OverloadTest2 {
            static int base(double a, double b){ ... }  //method A
            
            static int count(int a, int b){ ... }  //method B
            static int count(double a, double b){ ... }  //method C
            
            static int sum(int a, double b){ ... }  //method D
            static int sum(double a, int b){ ... }  //method E
        }

             OverloadTest.java:48: reference to sum is ambiguous, both method sum(int,double)
               in OverloadTest and method sum(double,int) in OverloadTest match
                    System.out.println("sum(3,4) = " + sum(3,4));
                                                       ^
             1 error

        public class Member {
            private int memberNo;
            
            public int getMemberNo(){
                return this.memberNo;
            }
            
            public void setMemberNo(int menberNo){
                this.memberNo = memberNo;
            }
            
            ......
        }

        ClassA a = new ClassA(); 
        int i = a.AA;       //instance를 경유하여 접근
        int j = ClassA.AA;  //올바르게 접근

        public class ConstructorTest{
            void ConstructorTest(){
                System.out.println("Constuctor");
            }
            .....
        }

        ....
        if( a < 5 )
            b = 3;
            c = 10;   //이부분은 나중에 추가된 라인이다.
            
            
        if( isStudent )
            if( isFemale )
                sayHello("Hi~~");
        else
            sayHello("Hello Professor~");

        public static final int LEFT = 0;
        public static final int CENTER = 1;
        public static final int RIGHT = 2;
        ...
        
        label.setAlignment(Label.CENTER);
        ...

        //LabelAlignment.java
        public class LabelAlignment {
            private LabelAlignment() {} //이는 생성자를 private으로 하여 다른데서는 만들지 못하도록 하기위함이다.
            
            public static final LabelAlignment LEFT = new LabelAlignment():
            public static final LabelAlignment CENTER = new LabelAlignment():
            public static final LabelAlignment RIGHT = new LabelAlignment():
        }
        
        //변형된 Label.java 의 일부..
        public synchronized void setAlignment(LabelAlignment alignment){
            if( alignment == LabelAlignment.LEFT ){
                ...//왼쪽으로 맞추기..
            }else if( ...
                ...
            }
        }
        ...

        //LabelAlignment.java
        public class LabelAlignment {
            private int flag;
            private LabelAlignment(int flag){
                this.flag = flag;
            } 
            
            public static final LabelAlignment LEFT = new LabelAlignment(0):
            public static final LabelAlignment CENTER = new LabelAlignment(1):
            public static final LabelAlignment RIGHT = new LabelAlignment(2):
            
            public boolean equals(Object obj){
                return ((LabelAlignment)obj).flag == this.flag;
            }
        }
        
        //변형된 Label.java 의 일부..
        public synchronized void setAlignment(LabelAlignment alignment){
            if( LabelAlignment.LEFT.equals(alignment) ){
                ...//왼쪽으로 맞추기..
            }else if( ...
                ...
            }
        }
        ...

        #ifdef DEBUG
            fprintf(stderr, "error...%d\n", error);
        #endif /* DEBUG */

        if( Debug.isDebug ){
            System.out.println("error..." + error);
        }

        // 1. GetCallerSecurityManager.java
        public final class GetCallerSecurityManager extends SecurityManager {
            public Class[] getStackTrace(){
                return this.getClassContext();   
            }
        }
        
        // 2. GetCallerClass.java
        public final class GetCallerClass {
            private static GetCallerSecurityManager mgr;
            
            static{
                mgr = new GetCallerSecurityManager();
                System.setSecurityManager(mgr);
            }
            
            public static void writeCaller(String str){
                Class[] stk = mgr.getStackTrace();
                int size = stk.length;
                for(int i = 0; i < size; i++){
                    System.out.println("stk[" + i + "] = " + stk[i]);   
                }   
                
                String className = stk[2].getName();
                
                System.out.println("className is " + className + " : " + str);
            }
        }
        
        // 3. GetCallerClassMain1 : 호출하는 클래스 예제 1
        public class GetCallerClassMain1 {
            public static void main(String[] args){
                GetCallerClass.writeCaller(", real is 1.");
            }
        }
        
        // 4. GetCallerClassMain1 : 호출하는 클래스 예제 2
        public class GetCallerClassMain2 {
            public static void main(String[] args){
                GetCallerClass.writeCaller(", real is 2.");
            }
        }

    className is GetCallerClassMain1 : , real is 1.
    className is GetCallerClassMain2 : , real is 2.

package com.jeid.tiger;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class ArraysTester {

	private int[] arr;

	private String[] strs;

	public ArraysTester(int size) {
		arr = new int[size];
		strs = new String[size];
		for (int i = 0; i < size; i++) {
			if (i < 10) {
				arr[i] = 100 + i;
			} else if (i < 20) {
				arr[i] = 1000 - i;
			} else {
				arr[i] = i;
			}
			strs[i] = "str" + arr[i];
		}
	}

	public int[] getArr() {
		return this.arr;
	}

	public String[] getStrs() {
		return this.strs;
	}

	public static void main(String[] args) {
		int size = 50;
		ArraysTester tester = new ArraysTester(size);

		int[] testerArr = tester.getArr();
		int[] cloneArr = tester.getArr().clone();
		String[] testerStrs = tester.getStrs();
		String[] cloneStrs = tester.getStrs().clone();

		// clone test
		if (Arrays.equals(cloneArr, testerArr)) {
			System.out.println("clonse int array is same.");
		} else {
			System.out.println("clonse int array is NOT same.");
		}

		if (Arrays.equals(cloneStrs, testerStrs)) {
			System.out.println("clonse String array is same.");
		} else {
			System.out.println("clonse String array is NOT same.");
		}

		// 2부터 10까지 값 셋팅
		Arrays.fill(cloneArr, 2, 10, new Double(Math.PI).intValue());

		testerArr[10] = 98;
		testerStrs[10] = "corea";
		testerStrs[11] = null;

		List<String> listTest = Arrays.asList(testerStrs);
		System.out.println("listTest[10] = " + listTest.get(10));

		System.out.println("------- unsorted arr -------");
		System.out.println("Arrays.toString(int[]) = " + Arrays.toString(testerArr));
		System.out.println("Arrays.toString(String[]) = " + Arrays.toString(testerStrs));

		Arrays.sort(testerArr);
		// Arrays.sort(testerStrs); //NullPointerException in sort method..(null이 없더라도 길이에 대한 크기 체크는 못함)
		Arrays.sort(testerStrs, new Comparator<String>() {
			public int compare(String s1, String s2) {
				if (s1 == null && s2 == null) {
					return 0;
				} else if (s1 == null && s2 != null) {
					return -1;
				} else if (s1 != null && s2 == null) {
					return 1;
				} else if (s1.length() < s2.length()) {
					return -1;
				} else if (s1.length() > s2.length()) {
					return 1;
				} else if (s1.length() == s2.length()) {
					return 0;
				} else {
					return s1.compareTo(s2);
				}
			}
		});

		System.out.println("------- sorted arr -------");
		System.out.println("Arrays.toString(int[]) = " + Arrays.toString(testerArr));
		System.out.println("Arrays.toString(String[]) = " + Arrays.toString(testerStrs));
		
		System.out.println("------------------------------------------------");

		String[][] mstrs1 = { { "A", "B" }, { "C", "D" } };
		String[][] mstrs2 = { { "a", "b" }, { "c", "d" } };
		String[][] mstrs3 = { { "A", "B" }, { "C", "D" } };

		System.out.println("Arrays.deepToString(mstrs1) = " + Arrays.deepToString(mstrs1));
		System.out.println("Arrays.deepToString(mstrs2) = " + Arrays.deepToString(mstrs2));
		System.out.println("Arrays.deepToString(mstrs3) = " + Arrays.deepToString(mstrs3));
		
		if( Arrays.deepEquals(mstrs1, mstrs2)) {
			System.out.println("mstrs1 is same the mstrs2.");
		}else {
			System.out.println("mstrs1 is NOT same the mstrs2.");
		}
		
		if( Arrays.deepEquals(mstrs1, mstrs3)) {
			System.out.println("mstrs1 is same the mstrs3.");
		}else {
			System.out.println("mstrs1 is NOT same the mstrs3.");
		}
		
		System.out.println("mstrs1's hashCode = " + Arrays.deepHashCode(mstrs1));
		System.out.println("mstrs2's hashCode = " + Arrays.deepHashCode(mstrs2));
		System.out.println("mstrs3's hashCode = " + Arrays.deepHashCode(mstrs3));
	}

}

package com.jeid.tiger;

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;

public class QueueTester {
	public static void main(String[] args) {
		System.out.println("---------- testFIFO ----------");
		testFIFO();
		System.out.println("---------- testOrdering ----------");
		testOrdering();
	}

	private static void testFIFO() {
		Queue<String> q = new LinkedList<String>();
		q.add("First");
		q.add("Second");
		q.add("Third");

		String str;
		while ((str = q.poll()) != null) {
			System.out.println(str);
		}
	}

	private static void testOrdering() {
		int size = 10;
		Queue<Integer> qi = new PriorityQueue<Integer>(size);
		Queue<String> qs = new PriorityQueue<String>(size);
		for (int i = 0; i < size; i++) {
			qi.offer(10 - i);
			qs.offer("str" + (10 - i));
		}
		
		for (int i = 0; i < size; i++) {
			System.out.println("qi[" + i + "] = " + qi.poll() + ", qs[" + i + "] = " + qs.poll());
		}
	}
}

package com.jeid.tiger;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StringBuilderTester {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("str1");
		list.add("str2");
		list.add("str3");

		String ret = appendItems(list);
		System.out.println("ret = " + ret);
	}

	private static String appendItems(List<String> list) {
		StringBuilder sb = new StringBuilder();
		for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
			sb.append(iter.next()).append(" ");
		}
		return sb.toString();
	}
}

package com.jeid.tiger;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class ListTester {
	public static void main(String[] args) {
		List<String> list = new LinkedList<String>();
		list.add("str1");
		list.add("str2");
		list.add(new Integer(123));  // <-- String이 아니므로 compile error!!
		
		//Iterator에 String type을 명시하므로 정삭작동됨.
		for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
			String str = iter.next();
			System.out.println("srt = " + str);
		}
		
		//Iterator에 String type을 명시하지 않았으므로 아래 A 부분에서 compile 오류 발생!!
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			String str = iter.next(); //A
			System.out.println("srt = " + str);
		}
		
		//byte, short, int, long, double, float 동시 사용
		List<Number> lstNum = new LinkedList<Number>();
		lstNum.add(1);
		lstNum.add(1.2);
		for (Iterator<Number> iter = lstNum.iterator(); iter.hasNext();) {
			Number num = iter.next();
			System.out.println("num = " + num);
		}
	}
}

class AnyTypeList<T> {
//class AnyTypeList<T extends Number> {  // <-- 이는 Number를 상속한 type은 허용하겠다는 의미.
	private List<T> list;
	//private static List<T> list;  // <-- 이는 정적이므로 compile error 발생!!! 
	public AnyTypeList(){
		list = new LinkedList<T>();
	}
	
	public boolean isEmpty(){
		return list == null || list.size() == 0;
	}
	
	public void add(T t){
		list.add(t);
	}
	
	public T grap(){
		if (!isEmpty() ) {
			return list.get(0);
		} else {
			return null;
		}
	}
}

package com.jeid.tiger;

import com.jeid.BaseObject;
import com.jeid.MyLevel;

public class EnumTester extends BaseObject {
	private static long start = System.currentTimeMillis();
	
	public static void main(String[] args) {
		try {
			test();
			enum1();
		} catch (Exception e) {
			e.printStackTrace();
		}
		printEllapseTime();
	}
	
	private static void test() throws Exception {
		byte[] b = new byte[0];
		System.out.println(b.length);
	}

	private static void enum1() {
		//enum TestEnum { A, B };  //enum cannot be local!!!
		
		for(MyVO.TestEnum te: MyVO.TestEnum.values()){
			System.out.println("Allow TestEnum value : " + te);
		}
		System.out.println("---------------------------------------");
		
		MyVO vo = new MyVO();
		vo.setName("enum1");
		vo.setLevel(MyLevel.A);
		System.out.println(vo);
		System.out.println("isA = " + vo.isA() + ", isGradeA = " + vo.isLevelA()+ ", isValueOfA = " + vo.isValueOfA());
		System.out.println("getLevelInKorean = " + vo.getLevelInKorean());
	}

	private static void printEllapseTime() {
		System.out.println("==> ellapseTime is " + (System.currentTimeMillis() - start) + " ms.");
	}
}


package com.jeid.tiger;

import com.jeid.BaseObject;
import com.jeid.MyLevel;

public class MyVO extends BaseObject {
	enum TestEnum {
		A, B
	}; // this is same public static final

	private int id;

	private String name;

	private MyLevel grade;

	// private List<T> list;

	public MyLevel getLevel() {
		return grade;
	}

	public void setLevel(MyLevel grade) {
		this.grade = grade;
	}

	public boolean isA() {
		return "A".equals(this.grade);
	}

	public boolean isValueOfA() {
		return MyLevel.valueOf("A").equals(grade);
	}

	public boolean isLevelA() {
		return MyLevel.A.equals(this.grade);
	}

	//A,B,C..대신 0,1,2... 도 동일함.
	public String getLevelInKorean() {
		switch(this.grade){
		case A:
			return "수";
		case B:
			return "우";
		case C:
			return "미";
		case D:
			return "양";
		case E:
			return "가";
		default:
			return "없음";
		}
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

package com.jeid.tiger;

import java.util.EnumMap;

public class EnumMapTester {

	private enum MyEnum {
		A, B, C
	}; // this is same the static final..

	public static void main(String[] args) {
		MyEnum[] enums = MyEnum.values();
		System.out.println("MyEnum is " + enums[0] + ", " + enums[1] + ", " + enums[2]);

		EnumMap<MyEnum, String> em = new EnumMap<MyEnum, String>(MyEnum.class);
		em.put(MyEnum.A, "수");
		em.put(MyEnum.B, "우");
		em.put(MyEnum.C, "미");
		em.put(MyEnum.B, "가"); //key 중복은 HashMap과 동일하게 overwrite임.

		for (MyEnum myEnum : MyEnum.values()) {
			System.out.println(myEnum + " => " + em.get(myEnum));
		}
	}
}

package com.jeid.tiger;

import java.util.EnumSet;

public class EnumSetTester {

	private enum MyEnum {
		A, B, C, a, b, c
	}; // this is same the static final..

	public static void main(String[] args) {
		MyEnum[] enums = MyEnum.values();
		System.out.println("MyEnum is " + enums[0] + ", " + enums[1] + ", " + enums[2]);

		EnumSet<MyEnum> es1 = EnumSet.of(MyEnum.A, MyEnum.B, MyEnum.C);
		EnumSet<MyEnum> es2 = EnumSet.of(MyEnum.a, MyEnum.b, MyEnum.c);
		EnumSet<MyEnum> es3 = EnumSet.range(MyEnum.a, MyEnum.c);
		if (es2.equals(es3)) {
			System.out.println("e2 is same e3.");
		}

		for (MyEnum myEnum : MyEnum.values()) {
			System.out.println(myEnum + " contains => " + es1.contains(myEnum));
		}
	}
}

package com.jeid.tiger;

public class AutoBoxingTester {

	public static void main(String[] args) {
		int i = 0;
		Integer ii = i; // boxing. JDK 1.4에서는 incompatible type error가 발생 했었으나 Tiger에서는 괜찮다.
		int j = ii; // unboxing

		for (ii = 0; ii < 5; ii++) { // Integer인데도 ++ 연산자 지원.
		}

		i = 129;
		ii = 129;
		if (ii == i) {
			System.out.println("i is same ii.");
		}

		// -128 ~ 127 사이의 수는 unboxing이 되어 == 연산이 허용되지만,
		// 그 범위 외의 경우 Integer로 boxing된 상태므로 equals를 이용해야함.
		// 이는 버그가 발생했을 경우 찾기 쉽지 않은 단점도 내포하고 있다.!!
		checkIntegerSame(127, 127); // same
		checkIntegerSame(128, 128); // Not same
		checkIntegerEquals(128, 128); // equals
		checkIntegerSame(-128, -128); // same
		checkIntegerSame(-129, -129); // Not same
		checkIntegerEquals(-129, -129); // equals
		
		System.out.println("--------------------------------------------");
		Boolean arriving = false;
		Boolean late = true;
		String ret = arriving ? (late ? "도착했지만 늦었네요." : "제시간에 잘 도착했군요.") : 
								(late ? "도착도 못하고 늦었군요." : "도착은 못했지만 늦진 않았군요.");
		System.out.println(ret);
		
		StringBuilder sb = new StringBuilder();
		sb.append("appended String");
		String str = "just String";
		boolean mutable = true;
		CharSequence chSeq = mutable ? sb : str;
		System.out.println(chSeq);
	}

	private static void checkIntegerSame(Integer ii, Integer jj) {
		if (ii == jj) {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is same ii.");
		} else {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is NOT same ii!!");
		}
	}

	private static void checkIntegerEquals(Integer ii, Integer jj) {
		if (ii.equals(jj)) {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is equals ii.");
		} else {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is NOT equals ii!!");
		}
	}

}

package com.jeid.tiger;

public class OverloadTester {
	public static void main(String[] args) {
		double d = 10;
		Integer ii = new Integer(10);
		doSomething(10);
		doSomething(1000);
		doSomething(ii);
		doSomething(d);
	}

	private static void doSomething(Integer ii) {
		System.out.println("This is doSomething(Integer)");
	}

	private static void doSomething(double d) {
		System.out.println("This is doSomething(double)");
	}
}

package com.jeid.tiger;

public class VarArgsTester {
	public static void main(String[] args) {
		setNumbers(1, 2);
		setNumbers(1, 2, 3, 4);
		setNumbers(1);
		// setNumbers(); //해당 되는 method가 없어 compile error!!
		System.out.println("==============================================");
		setNumbers2(1, 2, 3, 4);
		setNumbers2(1);
		setNumbers2();
	}

	// this is same setNumbers(int first, int[] others)
	private static void setNumbers(int first, int... others) {
		System.out.println("-----------setNumbers()----------- : " + first);
		for (int i : others) {
			System.out.println("i = " + i);
		}
	}

	// this is same setNumbers(int[] others)
	private static void setNumbers2(int... others) {
		System.out.println("-----------setNumbers2()----------- : "
				+ (others != null && others.length > 0 ? others[0] : "null"));
		for (int i : others) {
			System.out.println("i = " + i);
		}
	}
}

    //정상적인 사용
    @Override
    public int hashCode(){
        return toString().hashCode();
    }
    
    //스펠링이 틀려 compile error!!
    @Override
    public int hasCode(){   //misspelled => method does not override a method from its superclass error!!
        return toString().hashCode();
    }

package com.jeid.tiger;

public class AnnotationDeprecateTester {
	public static void main(String[] args){
		DeprecatedClass dep = new DeprecatedTester();
		dep.doSomething(10);    //deprecated
	}
}

class DeprecatedClass {
	@Deprecated
	public void doSomething(int ii){    //deprecated
		System.out.println("This is DeprecatedClass's doSomething(int)");
	}
	
	public void doSomethingElse(int ii){
		System.out.println("This is DeprecatedClass's doSomethingElse(int)");
	}
}

class DeprecatedTester extends DeprecatedClass {
	@Override
	public void doSomething(int ii){
		System.out.println("This is DeprecatedTester's doSomething(int)");
	}
}

package com.jeid.tiger;

import java.util.ArrayList;
import java.util.List;

public class AnnotationSuppressWarningsTester {
	@SuppressWarnings({"unchecked", "fallthrough"} )
	private static void test1(){
		List list = new ArrayList();
		list.add("aaaaaa");
	}
	
	@SuppressWarnings("unchecked")
	private static void test2(){
		List list = new ArrayList();
		list.add("aaaaaa");
	}
	
	//warning이 없는 소스.
	private static void test3(){
		List<String> list = new ArrayList<String>();
		list.add("aaaaaa");
	}
}

package com.jeid.tiger;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target( { ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
	String columnName();
	String methodName() default "";
}

//사용하는 쪽..
public class AnnotationTester {

	@MyAnnotation(columnName = "test", methodName = "setTest")
	private String test;

	@MyAnnotation(columnName = "grpid")
	public String grpid;

    ....
}

//위의 test 멤버의 경우 다음과 같이 접근 가능하다.
Field testField = cls.getDeclaredField("test");
if (testField.isAnnotationPresent(MyAnnotation.class)) {
    Annotatioin anno = testField.getAnnotation(MyAnnotation.class);
    System.out.println(anno.columnName() + ", method = " + anno.methodName());
}

//1. 가장 단순한 형태인 배열(array)
String[] strs = { "aaa", "bbb", "ccc" };
for (String str : strs) {
    System.out.println(str);
}

//2. List by using Iterator
List<Number> lstNum = new LinkedList<Number>();
lstNum.add(1);
lstNum.add(1.2);
for (Iterator<Number> iter = lstNum.iterator(); iter.hasNext();) {
	Number num = iter.next();
	System.out.println("num = " + num);
}

//3. List를 바로 사용
List<String> lst = new LinkedList<String>();
lst.add("aaaaa");
lst.add("bbbbb");
lst.add("ccccc");
lst.add("ddddd");
for (String str : lst) {
	System.out.println("str = " + str);
}

// 4. List of List
List[] lists = { lst, lst };
for (List<String> l : lists) {
	for (String str : l) {
		System.out.println("str = " + str);
	}
}

//예를 들어 System.out.println() 이라는 것을 사용하기 위해서는 다음의 import 문이 필요하다.

import java.lang.System;   //물론 java.lang 이기에 import 문이 필요없지만 예를 들자면 그렇다는 것이다.&^^
//허나, Tiger에서는 다음과 같이 사용할수 있다.
import static java.lang.System.out;
...
out.println(...);

// method를 import 한다면..
import static java.lang.System.out.println;
...
println(...);

정적 쿼리와 동적 쿼리는 저도 이번에 공부하면서 처음 알게된 것인데 (;;)
사실 닷넷 프레임워크 공부할 때 계속 동적 쿼리를 사용한 것 같군요.
하지만 이게 동적 쿼리인지는 몰랐답니다. 컥 ;;

정적 쿼리 방식 : 변수가 바뀔 때마다 새로운 SQL 을 생성 하여 DB쿼리 수행
동적 쿼리 방식 : 변수가 바뀔 때마다 파싱을 하지 않고 변수 바인딩 과정을 통해 DB 쿼리 수행

insert into person values (null, '홍길동', '888888-1111111', '2002-02-02');
이것이 정적 쿼리입니다.

insert into person values (null, ?, ?, ?);
쿼리문을 이런 식으로 해놓고 ? 부분을 변수 바인딩을 통해 입력받는 것을 동적 쿼리라고 합니다.

정적 쿼리와 동적 쿼리는 각각 장단점이 있습니다.

동적 쿼리문을 사용한 간단한 예제를 보겠습니다.

팩토리얼 값 얻기 예제: factorial Method Example

FetchRequest fetch = FetchRequest.createFetchRequest();
fetch.addAttribute("email", "http://schema.openid.net/contact/email", true);
authReq.addExtension(fetch);

정상적으로 돌아간다면 위의 정보를 다 받아오고 화면에 출력해 준다.

근데 이상한건 fullname의 경우는 받아오지를 못한다. myid측에서는 인코딩의 문제점을 제기했는데 시간의 압박으로 그부분까지 확인해 보지는 못했다. 나같은 경우에는 fullname이 들어가면 인증자체가 실패해서 일단 fullname은 제외해 놓은 상태이다.(이름만 한글이 넘어왔으므로 인코딩 문제라는데 심증이 가기는 한다.) 참고로 End-User가 "승인"을 하면("이번만 승인"이 아닌..) 로그인 할 때 마다 요청한 정보가 넘어온다. 정보를 갱신하고자 한다면 로그인처리를 할 때 갱신에 대한 처리를 하면 End-User가 OP측에서 개인정보를 수정하면 새 정보를 받을 수 있을 것이다.

이것외에도 해야할 일은 많겠지만 일단 필요한 기능은 간단하게 다 구현했다. 난 여기까지만.... 소스가 많지 않아서 내용만 보아도 이해가 되겠지만 혹 더 도움이 될까봐 위의 결과로 나온 소스를 첨부로 올린다.

SampleConsumer.zip

그리고 이부분은 해결은 안되었는데 다음과 같은 에러가 나는 경우가 있다.

URI is not absolute라는데 URI가 절대경로가 아니라는건데 이건 엄청 찾아봤는데 죽어도 이유를 모르겠다. 절대경로인데 절대경로가 아니라니.. ㅡ..ㅡ 더군다나 java.lang에서 나는것처럼 보이니 이유를 모르겠다. 나같은 경우에는 Jeus환경에서 나타났고 웹에서 찾아보니 다른 분은 Resin환경에서 같은 문제가 발생했었다. 나는 자연스럽게 환경이 tomcat으로 바뀌면서 더이상 이문제를 가지고 고민할 필요가 없어지긴 했는데 일단 이문제는 tomcat에서는 발생하지 않는다.

그럼 이제 DB에 대한 부분이 남는다. DB구성을 어떻게 할 것인가. OpenID의 개념상에는 한명이 여러 OpenID를 사용할 수도 있고 그것들은 같은 유저로서 인식되어야 하는 것 같고 거기에 OpenID를 추가해고 삭제할 수도 있어야 하는데 사이트마다 적용하는 범위는 다를 수 있다. 어쨌든 A Recipe for OpenID-Enabling Your Site 라는 글에 DB에 대한 내용이 자세히 나와있다. 이곳에서는 기존유저가 있다는 가정하에 OpenID를 추가하는 것을 전제로 하고 있지만 내가 찾아본 자료중에 DB구성에 대해서 자세히 나와 있는 포스팅은 이곳말고는 보지 못했다.

그리고 OpenID Book 이라는 프로젝트가 있는데 OpenID에 대한 내용을 정리하는 것 같다. 해당 사이트에서 무료로 다운로드를 받을 수 있고 사이트에 가기 귀찮으신 분을 위해서 올려둔다. PDF파일로 되어 있으면 250page정도 되는데 아마 이걸 읽으면 거진다 이해할 수 있을듯 하다. 분량이 분량이니 만큼....(당연히 영문이고 나도 안읽었다. ㅎ)

openidbook.zip

이제 필요한 처리는 다 했다. 로그인처리도 했고 정보도 받아왔으니 이제 자신의 사이트에서 필요한 처리를 하면 된다. 로그인처리를 하려면 세션에 로그인정보를 심는다든가 회원가입을 받으려면 약관동의를 하고 디비에 넣는다든가 하는 각자 원하는 처리를 해주면 된다.

이제 정책적인 문제가 남는데 인증 확인후 회원가입등의 절차나 추가정보를 요청할 수 있다. 하지만 OpenID의 취지는 자신을 증명하는 것이기 때문에 사이트가 필요해서 요청하는 절차에 대해서 강제사항이 되지 않아야 한다. 즉 인증을 받은 뒤에 회원가입 요청을 한다고 하였을 때 회원가입을 하지 않는다 하더라고 로그인처리를 해주어 OpenID사용자가 사이트 사용에 무리가 없도록 해야한다. 다 구현하고 나서도 이때문에 고민을 많이 했는데 로그인과 회원가입을 같은 개념으로 두지 않아야 한다. OpenID는 회원가입을 하지 않아도 자신이 누군지를 증명해서 사이트를 이용할 수 있게 되는 것이다.(이부분은 비디오가게를 비회원으로 이용할 수도 있는 것과 같다.)

다음 문제는 로그아웃의 문제이다. 로그아웃은 어떻게 해야되는가... 여기서의 고민은 로그인이 RP와 OP에 둘다 된다는 것에 문제가 있다. RP측은 정보를 받아왔으니 RP에서 일반 회원이 로그인처리를 하는 것과 동일하게 처리하면 된다. 보통이면 세션에 정보를 심어서 처리할텐데 로그아웃할때는 세션을 날려버리면서 로그아웃을 처리한다. 하지만 테스트해보면 RP에서 로그아웃을 해도 OP쪽에는 로그인상태로 남아있는데 그런 RP가 로그아웃정보를 OP로 날려야 하는가 그럼 어떻게 날려야 하는가의 고민이 남았는데 다음 글을 참고하면 답을 얻을 수 있다.

http://cs.myid.net/issues/8737
http://cs.myid.net/issues/8747
http://cs.myid.net/issues/8748

결론부터 얘기하자면 RP측에서만 로그아웃을 처리해주면 되고 이에 큰 문제는 없어보인다. 위의 정책적인 부분들은(사실은 구현하면서 어렵던 부분들도 ㅎㅎ) myid측에서 많은 도움을 받았다. 달리 OpenID에 대해서 도움을 얻을 곳이 없고 그래도 myid에 계신분이 이해도가 제일 높다고 생각했기 때문에 여러차례 문의를 했는데 항상 빠르고 친절하게 답변을 주신데에 이자리를 빌어 감사드립니다. ^^

Dan Becker
소프트웨어 개발자, IBM Software Group
2002년 11 월

웹 사이트를 코딩하고 지원하거나 인터넷에 페이지를 갖고 있다면 독자들의 필요를 충족시키는 이미지를 제공하는 것이 얼마나 어려운 일인지 알 것이다. JavaServer Pages (JSP) 태그를 이용하여 이미지 관리를 시도해보자.

세상을 지배하라! 그렇지 않다면, 적어도 이미지라도 지배하라!
사이트 개발자 또는 페이지 작성자로서 다양한 선호를 만족시키는 것은 어려운 일이라는 것을 안다. 이를 수작업으로 수행하기 위해서는 사이트의 이미지 하나하나를 웹 사이트가 지원하는 이미지 사이즈로 변환해야한다. 그런다음 사이트의 각 페이지에 이미지 태그를 조정하여 각각의 태그가 이미지 사이즈를 적절하게 반영할 수 있도록 해야한다. 이미지를 변경하지 않고서는 HTML img 태그의 넓이와 높이를 간단히 변경시킬 수 없다. 이는 저대역 사용자들은 큰 이미지를 다운로드하여 클라이언트 측에서 리사이징을 해야한다는 것을 뜻한다. 이러한 종류의 이미지 관리는 성가실 뿐 아니라 에러를 양산해낸다. 그리고 대부분의 웹 사이트가 다양한 이미지 사이즈를 제공하지 않는 이유를 쉽게 알 수 있다.

문제는 기술의 문제가 아니다. 자바 프로그래밍으로 이미지를 다양한 사이즈나 포맷으로 변환하기는 쉽다. 서비스만의 문제 또한 아니다. 웹 서비스를 사용하여 각자의 필요에 맞춰 페이지를 커스터마이징하는 것이 일반적이기 때문이다. 문제는 전개와 관리가 쉽도록 기술과 서비스를 조합하는 일이다.

이 글은 JavaServer Pages (JSP) 태그를 사용하는 솔루션으로 이미지를 관리하는 방법을 다룬다. 예를들어 HTML에서 이미지 태그를 코딩하고 다양한 버전의 이미지 사이즈를 갖추는 대신 다음과 같이 하는것이다:

<img src="images/LazyDog.jpg" width="800" height="600" >

사용자의 선호에 맞춰 이미지를 자동으로 사이징하는 태그를 갖추는 것이 합리적이다:

<util:imagesizer src="images/LazyDog.jpg"/>

사용자가 다양한 사이즈 중에서 선택하고 선호도에 따라 사이트상의 모든 이미지가 바뀌도록 하는 것이 가능하다. 그림 1의 샘플 이미지를 보자. 또한 넓이와 높이 속성을 삽입하고 태그를 수동으로 편집하는 일 따위는 하지 않아도 된다.

그림 1. 이미지 선택이 있는 JSP 페이지

한번도 JSP 커스텀 태그를 본 적이 없다면 예제에서 신택스를 연구해보자. JSP 커스텀 태그를 HTML 태그와 비교해보자:

JSP 페이지가 커스텀 image-sizer 태그를 사용할 때, 태그의 자바 구현은 이미지 파일을 찾아 적절한 사이즈로 변환하고 이 이미지를 독자에게 제공한다. 태그는 퍼블리싱하기 전에 이미지 변환 부터 사이트 매니저를 저장한다. 또한 웹 페이지 작성 작업을 단순화한다. 단지 하나의 페이지가 많은 이미지 사이즈 선택을 핸들하는데 필요하기 때문이다. 무엇보다도, 중요한 것은 각자의 사이트 이미지에 이러한 유연성을 제공한다면 인기있는 사이트가 될 것이다.

웹 서버
이제는, 클라이언트(웹 브라우저를 이용하는 독자)가 JSP 페이지를 제공하는 사이트를 방문할 때 그 배후에 어떤일이 벌어지는지 알아보자. 세 개의 인터랙션이 이루어진다. (그림 2):

그림 2. 웹 클라이언트와 서버 간 인터랙션

첫 번째 경우, 브라우저가 HTML 파일이나 이미지 파일 같은 정적 문서를 요청한다고 가정해보자. 서버는 파일 공간에 리소스를 위치시키고 브라우저에 파일을 제공한다. 문서를 요청하고 요청에 응답하는 것은 HTTP에 정의되어 있는데 이것은 인터넷 상에서 클라이언트-서버 인터랙션의 기초가 된다. 웹 서버는 요청을 완벽하게 핸들하고 웹 애플리케이션 서버나 서블릿 콘테이너와 인터랙션 할 필요가 없다.

두 번째 경우 브라우저가 자바 서블릿을 포함하는 웹 리소스를 요청한다고 가정해보자. 자바 서블릿은 웹 서버가 자바 프로그래밍 언어를 사용하여 서버상에서 태스크를 수행하도록 한다. 서블릿들은 효율적이어서 CGI와 서버측 JavaScript 같은 오래된 기술보다 메모리와 프로세싱 파워를 덜 사용한다. 서블릿은 IBM WebSphere Application Server과 Apache Tomcat 같은 웹 서버에서 다른 기술들에 비해 이동성이 강하고, 다양한 플랫폼 상에서 같은 서블릿을 구동할 수 있는 서블릿 콘데이너를 지원한다. 마지막으로, 자바언어 고유의 안정성으로 인해 잘못된 서블릿이 웹 서버에 영향을 주는 경우도 드물다. 웹 서버는 적절한 서블릿을 찾아 필요할 경우 서블릿 소스 코드를 컴파일하고 서블릿 프로세싱 결과를 요청자에게 리턴한다. 자주 요청되는 서블릿은 서버 메모리에 캐싱된다. (그림 2).

세 번째 경우, 브라우저가 JSP 페이지를 포함하는 웹 페이지를 요청한다는 것을 가정해보자. JSP 페이지는 정보를 디스플레이 하는 작업을 쉽게 하고 동적 콘텐트를 정적 페이지와 분리하는 것을 돕는다. 웹 페이지 디자이너는 HTML 라이브러리에 있는 다른 태그인 것 처럼 하여 JSP 태그를 사용한다. JSP 프로그래머는 JSP 프로그래밍 스팩에 따라 태그를 구현한다.

이번에는 이미지-사이징 JSP 태그를 구현하고 JSP 코드를 작성하는 방법을 알아보자. 웹 콘테이너의 관점에서 볼 때 JSP 페이지는 자바 서블릿과 밀접하게 관련되어 있다. 텍스트 기반 JSP 페이지는 웹 콘테이너에 의해 자바 구현으로 변환된다. 웹 콘테이너는 자바 구현을 찾아 자바 서블릿 같은 구현을 처리하고 코드를 구동하여 프로세싱 결과를 클라이언트에 리턴한다. 많은 레이어와 리다이렉트가 있는 듯이 보이지만 디스패칭은 빠르고 사용자에게도 투명하다. 서블릿과 마찬가지로 자주 요청되는 JSP 페이지는 서버 메모리에 캐싱된다.

JSP 커스텀 태그 작성하기
웹 서비스가 JSP 페이지 요청을 어떻게 처리하는지 보았다. 이제는 JSP 커스텀 태그를 어떻게 구현하는지 보자. JSP 태그는 Java Standard Template Library(JSTL) 같은 표준 라이브러리와 일명 커스텀 태그라고 하는 스스로 작성한 라이브러리에도 해당된다는 것을 명심하라. 일반적으로 커스텀 태그는 특정 문제 도메인을 다룬다. 이 글에서는 이미지를 관리하는 방법을 다루겠다. 현재 Java 2 Extended Edition (J2EE) Versions 1.2와 1.3은 JSP Version 1.2를 사용한다. 현재 Sun은 JSP 스팩 2.0 버전을 발표했다. 이 새로운 스팩은 커스텀 태그를 구현하는 방식에 있어서 큰 변화가 없다.

표준과 커스텀 태그 라이브러리를 taglib 디렉티브를 통해 JSP 페이지로 반입할 수 있다:

<%@ taglib uri='imagesizer.tld' prefix='util' %>

이 디렉티브는 태그 라이브러리 디스크립터 파일의 위치를 명명한다. 여기서는 imagesizer.tld로 명명되었다. 그리고 사용된 프리픽스는 util로 명명되었다. 태그 예제에서 보았듯이 프리픽스와 이름으로 태그를 사용할 수 있다:

<util:imagesizer src="images/LazyDog.jpg"/>

태그 라이브러리 디스크립터는 웹 콘데이너에게 사용가능한 태그가 무엇인지 그들이 어떻게 작용하는지를 설명한다. Listing 1은 그 예제이다. 이 파일은 XML 포맷으로 되어있고 읽기 쉽다. 하지만 IBM WebSphere Studio Application Developer 같은 애플리케이션 개발 플랫폼은 필드를 채우고 파일을 검사하는 것을 돕는다. 가장 중요한 정보는 태그 엘리먼트이다. 이것은 JSP 커스텀 태그의 이름과 태그를 구현하는 자바 클래스를 정의한다. 또한 태그가 받아들이는 모든 속성과 바디 콘텐트를 보여준다.

<taglib >
  <tlibversion> 1.0 </tlibversion>
  <jspversion> 1.1 </jspversion>
  <tag>
    <name>imagesizer</name>
    <tagclass>tags.ImageSizerTag</tagclass>
    <bodycontent>empty</bodycontent>
    <attribute>
      <name>src</name>
      <required>required</required>
    </attribute>
    <attribute>
      <name>alt</name>
    </attribute>
    <attribute>
      <name>quality</name>
    </attribute>
  </tag>
</taglib>

이 예제에서 태그는 src 속성이 요구하는 세 개의 속성을 갖고 있다. alt 속성은 HTML img alt 속성을 모방한 것이다. 이 JSP 태그를 확장하여 다른 이미지 속성을 포함시켜도 된다.

JSP 커스텀 태그를 작성하는 다음 단계는 태그 용 자바 코드를 구현하는 것이다. 이 글에서 imagesizer 태그는 tags.ImageSizerTag 자바 클래스에서 구현된다. J2EE 커스텀 태그 지원 대부분은 javax.servlet.jsp.tagext 패키지에 위치해있다. imagesizer 클래스는 표준 TagSupport를 확장한다. 이것은 바디 없이 태그를 구현한다. 이것의 자손 클래스는 BodyTagSupport인데 이것은 바디가 있는 태그를 구현한다. 두 클래스 모두 Tag 인터페이스를 구현한다. doStartTag과 doEndTag 메소드는 태그가 처음 읽혀지고 태그가 웹 컨테이너에 의해 완전히 읽혀진 후에 호출된다. ImageSizer 태그는 doEndTag 만 구현한다.

TagSupport 클래스에서 PageContext 클래스는 JSP 페이지와 관련된 중요한 정보에 액세스 하도록 한다. 예를들어, PageContext는 HttpRequest와 HttpResponse 객체에 액세스를 가능하게 한다. 이러한 객체들은 값을 읽고 응답을 작성하는데 필수적이다. 요청은, 사용자 선택을 트래킹하고 페이지에서 페이지로 값을 수행할 경우 HttpSession로 액세스를 허용한다. PageContext는 ServletContext로 액세스를 허용하는데 이것은 서블릿 경로, 이름, 기타정보를 위치시키는데 도움이 된다. ImageSizer 코드(Listing 2)에서, PageContext 객체에 대한 레퍼런스와 정보가 있다. 그림 3은 이들 클래스들의 관계이다. 다른 표준 클래스 다이어그램 처럼 실선으로 된 박스는 클래스를 나타내고 점선 박스는 인터페이스를 나타낸다. 상속은 파생된 클래스나 인터페이스부터 부모까지 선으로 이어져있다.

// Implement the tag once the complete tag has been read.
public int doEndTag() throws JspException {

  // Move request data to session.
  int outputSize = 0;
  String sizeVal = request.getParameter( REQUESTSIZEKEY );
  if ( sizeVal != null ) {
    session.setAttribute( REQUESTSIZEKEY, sizeVal );
    sizeVal = (String) session.getAttribute( REQUESTSIZEKEY );
    if ( sizeVal != null ) {
      outputSize = Integer.parseInt( sizeVal );
    }
  }
  
  // Get specified image locally.
  String contextPath = getContextPath( request );
  Image image = Toolkit.getDefaultToolkit().getImage(contextPath + src );
  ImageSizer.waitForImage( image );
  int imageWidth = image.getWidth( null );
  int imageHeight = image.getHeight( null );

  if (( imageWidth > 0 ) && ( imageHeight > 0 )) {
    if (( outputSize > 0 ) && ( outputSize != imageWidth )) {
      // Convert image to new size.
      Image outputImage = ImageSizer.setSize( image, outputSize, -1 );
      ImageSizer.waitForImage( outputImage );
      int outputWidth = outputImage.getWidth( null );
      int outputHeight = outputImage.getHeight( null );
 
      if ( outputWidth > 0 && outputHeight > 0 ) {
        // Change image file name to xxxx.size.jpg
        String originalSrc = src;
        int lastDot = src.lastIndexOf( '.' );
        if ( lastDot > -1 ) {
          src = src.substring( 0, lastDot + 1 );
        }
        setSrc( src + outputSize + ".jpg" );

        // Write new size image to JPEG file.
        File file = new File( contextPath + src );
        if ( !file.exists() ) {
          out.println( "" );
          FileOutputStream fos = new FileOutputStream( contextPath + src );
          ImageSizer.encodeJPEG( fos, outputImage, quality );
          fos.close( ) ;
        }
        
        imageWidth = outputWidth;
        imageHeight = outputHeight;
      }
    } // if outputSize
  } // if image found

  // Produce output tag.
  out.print( "<img src=\"" + src + "\"" );
  // Add alt text, if any
  if ((alt != null ) && ( alt.length() > 0 )) {
    out.print( " alt=\"" + alt + "\"" );
  }
  
  // Add proper width, height.
  out.print( " width=\"" + imageWidth + "\" height=\"" + 
    imageHeight + "\"" );
  out.println( ">" );

  return EVAL_PAGE;
} // doEndTag

그림 3. javax.servlet.jsp.tagext 클래스

ImageSizerTag 클래스의 doEndTag 메소드는 Listing 2에 나와있다. 이것은 JSP 커스텀 태그를 구현하는데 필요한 거의 모든 자바 코드라고 볼 수 있다. 큰 블록이지만 메소드를 완벽하게 보는데 도움이 된다. 우선 모든 HTTP 요청 매개변수는 HTTP 세션에 저장된다. 이것은 이미지 사이즈에 대한 사용자 선택 같은 속성을 가져다가 세션에 저장하여 페이지에 따라 사용자가 이를 따르도록 한다. 이 태그의 기능을 확장하기 위해서 이것을 확장하여 쿠키에 선택을 저장하여 사용자가 다음에 이 사이트를 방문할 때 선택을 사용하도록 할 수 있다.

이미지 사이징
지금까지 JSP 태그를 작성하는 단계를 검토했다. ImageSizerTag 클래스는 이미지를 자동으로 리사이징하여 사용자 선택에 맞춘다. 이번에는 ImageSizer 클래스를 사용하여 JPEG 파일로서 이미지를 리사이징하고 저장하는 구체적인 방법을 설명하겠다. 자바 코드로 이미지를 리사이징 할 때 java.awt.Image 클래스의 getScaledInstance 메소드를 사용할 때 쉬워진다. 이 메소드를 새로운 넓이와 높이로 하거나 형태 비율을 보존하기위해 -1에서 1까지의 매개변수 값을 제공한다. 그리고 나서 새롭게 리사이징된 이미지를 얻는다. 하지만 모든 자바 이미지는 즉시 사용할 수 있는 것은 아니다. 따라서 java.awt.MediaTracker 를 사용하여 이미지가 완전히 로딩될 때까지 기다려야한다. ImageSizer의 waitForImage 메소드는 이 코드를 캡슐화한다.

이 예제에서 가장 어려운 디자인 포인트는 이미지 저장 방법을 결정하는 일이다. 자바 프로그래밍에는 이미지 인코딩과 저장에 많은 선택권이 있어 비교를 해야한다.

Listing 3의 경우 com.sun.image.codec 패키지를 사용했는데 IBM WebSphere와 Apache Tomcat 같은 J2EE 1.2 와 1.3 웹 서버 콘테이너에서 사용할 수 있기 때문이다. 인코더는 단순하며 100% 순수한 자바 코드이지만 com.sun 패키지에 있다. 장기적인 시각으로 볼 때 Java Image I/O 패키지는 보완해야 할 사항이 많이있다. 이미지 변형 기능과 많은 파일 포맷을 저장하는 기능이 훌륭하다. Java Image I/O 패키지는 Java 2 version 1.4 이전까지는 표준이 아니다.

어떤 이미징 패키지를 사용할 것인가에 대해 결정이 끝났다면 JPEG 파일을 저장하는 코드는 간단하다. ImageSizer의 encodeJPEG 메소드는 다음 절차를 캡슐화한다:

1. java.awt.image.BufferedImage 객체-자바 Image 자손-는 리사이징된 아웃풋 이미지에서 만들어진다. 주석은 로고, watermark, 타임스탬프, 이미지 저작권 정보를 추가할 때 코드에 주석이 달린다.
   
   
2. Image에서 BufferedImage로 변환한 후에, 아웃풋 스트림에 JPEGImageEncoder 객체를 만들어라. 아웃풋 인코딩 평가는 0.0 (최악)부터 1.0 (최고) 까지 이다. 0.75는 디폴트이지만 0.95는 좀더 자세한 이미지와 함께 큰 파일 사이즈로 만들어진다.
   
   
3. 이미지는 아웃풋 스트림으로 인코딩되고 스트림은 모든 정보가 이미지 파일에 나타나도록 플러쉬된다.

// Encodes the given image at the given
// quality to the output stream.
public static void encodeJPEG
  ( OutputStream outputStream,
  Image outputImage, float outputQuality )
  throws java.io.IOException {

  // Get a buffered image from the image.
  BufferedImage bi = new BufferedImage
    ( outputWidth, outputHeight,
      BufferedImage.TYPE_INT_RGB );
  Graphics2D biContext =
    bi.createGraphics( );
  biContext.drawImage
    ( outputImage, 0, 0, null );
  // Additional drawing code, such as
  // watermarks or logos can be placed here.

  // com.sun.image.codec.jpeg package
  // is included in Sun and IBM sdk 1.3.
  JPEGImageEncoder encoder =
    JPEGCodec.createJPEGEncoder
    ( outputStream );
  // The default quality is 0.75.
  JPEGEncodeParam jep =
    JPEGCodec.getDefaultJPEGEncodeParam
    ( bi );
  jep.setQuality( outputQuality, true );
  encoder.encode( bi, jep );
  outputStream.flush();
} // encodeImage

여기까지는 이미지를 리사이징하고 저장하는데 필요한 모든 단계이다.

WebSphere또는 Tomcat에서 패키징 및 전개
이번에는 Application Server version 4.0이나 Apache Tomcat version 4.0에서 ImageSizer JSP 태그의 패키지 및 전개 방법을 설명하겠다. 그림 4는 Application Developer 이다. 왼쪽 칼럼의 상단에 있는 Navigator는 웹 애플리케이션의 디렉토리 구조를 나타내고 JSP 태그가 J2EE 스팩에 따라 어떻게 패키지되어야 하는지를 보여준다. J2EE 스팩에 필요하기 때문이 이 디렉토리 구조는 모든 웹 애플리케이션에 일반적이다. 일단 구조가 저장되면 Web Archive (WAR) 파일이 되고 WebSphere, Tomcat, 기타 웹 콘테이너에 쉽게 전송된다. Application Developer 같은 좋은 개발 환경은 다음의 스팩을 따르고 훌륭한 애플리케이션을 만들어낸다.

그림 4. WebSphere Studio Application Developer에서 ImageSizer 패키징

ImageSizer 프로젝트에는 소스 코드용 디렉토리가 있다. 최종 WAR 파일에 이 디렉토리를 추가할 것인지의 여부는 개발자가 선택하기 나름이다. webApplication 디렉토리에는 실제 프로그램 코드가 포함되어 있다. 예제 프로젝트에는 PickASize.jsp이라고 하는 테스트 JSP 페이지와 LazyDog.jpg 이라고 하는 테스트 이미지가 포함되어 있다. 일반적으로 이들은 ImageSizer 커스텀 태그의 라이브러리 버전에 포함되지 않는다. 이 태그의 구현은 WEB-INF 디렉토리에 있다. 자바 클래스는 WEB-INF/classes에 있고 Tag Library Descriptor 파일은 WEB-INF/tlds에 있다. 이들은 모든 웹 애플리케이션에 적용되는 표준 디렉토리 위치이다. 이 트리에 있는 다른 파일들은 서버 옵션 설정에 도움을 주지만 그렇지 않더라도 WAR 파일에 필수적인 것은 아니다. Application Developer나 Java SDK를 사용하여 이 애플리케이션 용 WAR 파일을 만들어보라.

To m c a t 에 웹 애플리케이션을 설치하려면 ROOT/webapps 디렉토리에 파일을 놓고 서버가 WAR 파일을 디렉토리 구조로 확장하도록 해야한다. Application Server의 경우, Administrators Console의 웹 애플리케이션 마법사(Web Application wizard)를 사용하여 애플리케이션을 설치할 수 있다. 전개한 후에, http://yourhostname:port/ImageSizer/PickASize.jsp를 방문하여 JSP 페이지를 구동해보라.

결론
지금까지 이미지 사이징을 자동으로 관리하는 JSP 커스텀 태그를 만들었다. 커스텀 태그는 이미지 리사이징 작업에 도움이 되고 웹 사이트를 방문하는 사용자들이 선택을 할 수 있도록 한다. 예제 태그를 확장하여 모든 종류의 이미지 조작을 할 수 있다. 저작권 텍스트, 타임스탬프, 로고, 워터 마크 등이 그것이다. Application Server나 Apache Tomcat에 이를 전개하고 이미지 기반 JSP 페이지를 작성하거나 예제를 사용하여 코드를 실험할 수 있다. 이 글이 JSP 태그에 대해 실질적인 팁을 주었기를 바라며 각자의 필요에 맞춰 기능을 확장해보기를 바란다.

출처 : http://www-128.ibm.com/developerworks/kr/library/j-jspdwj/index.html

참고자료

• developerWorks worldwide 사이트에서 이 기사에 관한 영어원문.
  
  
• Apache Software Foundation.
  
  
• Advanced JavaServer Pages (Prentice Hall, 2001).

썸네일 이미지 만들기

Java SDK1.4부터 Image I/O API가 추가되었다.

############################################
# 이미지 파일 읽어오기
############################################

javax.imageio.ImageIO 클래스가 제공하는 read()메소드를 이용한다.

BufferedImage read(File input)
BufferedImage read(InputStream input)
BufferedImage read(URL input)

File file = new File("c:\\image\\good.gif")
BufferedImage image = imageIO.read(file)

FileInputStream input = new FileInputStream("c:\\image\\good.gif")
BufferedImage image = imageIO.read(input)

URL logUrl = new URL("http://www.xxx.com/main/xxx.gif")
BufferedImage logoImage = imageIO.read(logUrl)

############################################
# 썸네일 이미지 만들기
############################################

1. ImageIO.read()메소드를 이용하여 BufferedImage에 저장한다.(원본)
2. 변경할 크기를 갖는 새로운 BufferedImage 객체를 생성한다.
3. 대상 BufferedImage객체의 createGraphics()메소드를 호출하여 대상 BufferedImage에 그림을 그릴 수 있는 Graphics2D 객체를 구한다.
4. Graphics2D 객체를 사용하여 원본 BufferedImage를 대상 BufferedImage에 그린다. 이때 크기를 조절한다.

BufferedImage srcimg = imageIO.read(imgFile);
BufferedImage destimg = new BufferedImage(w, h, BufferedImage.TYPE_3BYTE_BGR);
Graphics2D g = srcImg.createGraphics();
g.drawimage(srcImg, 0, 0, width, height, null);

###########################################
# BufferedImage를 파일로 저장하기
###########################################

imageIO.write()메소드를 통해서 BufferedImage를 출력할 수 있다.

write(RenderedImage im, String formatName, File output)
write(RenderedImage im, String formatName, OutputStream output)

formatName : PNG png, jpeg JPEG jpg JPG

###########################################
# 이미지크기를 변경
###########################################

boolean isResult = false;

FileInputStream srcls = null;
srcls = new FileInputStream("c:\\sample.gif");

BufferedImage srcimg = ImageIO.read(srcls);
BufferedImage destimg = new BufferedImage(30, 30, BufferedImage.TYPE_3BYTE_BGR);
Graphics2D g = destimg.createGraphics();
g.drawImage(srcimg, 0, 0, 30, 30, null);

File dest = new File("c:\\thum2_sample.jpg");
isResult = ImageIO.write(destimg, "jpg", dest);

if (isResult)
{
 out.println("Image변환 성공");
}

Chart Types

This document gives an overview of the types of charts you can create using the Chart API.

Table of Contents

Line charts

Specify a line chart with

cht=<line chart style>

Where <line chart style> is lc, ls, or lxy as described in the following table.

Parameter	Description	Example
cht=lc	For charts of type lc, data points are spaced evenly along the x-axis. Multiple data sets are drawn as multiple lines. For information on how to specify multiple data sets see Using multiple data series. For information on available parameters, see Optional parameters by chart type.	cht=lc chd=t:40,60,60,45,47,75,70,72
cht=ls	Line charts of type ls are also known as sparklines. They take the same parameters, and behave in the same way, as charts of type lc. The difference between charts of type lc and charts of type ls, is that by default, no axis lines are drawn for charts of type ls. For information on how to add axis lines and labels to a line chart, see Axis styles and labels.	cht=ls chd=t:27,25,60,31,25,39,25, 31,26,28,80,28,27,31,27, 29,26,35,70,25
cht=lxy	For charts of type lxy, a pair of data sets is required for each line. The first data set of each pair specifies the x-axis coordinates, and the second data set specifies y-axis coordinates. If you pass in an odd number of data sets, the last set is ignored. To space the data points evenly along the x-axis, provide a single undefined value as the first data set of the pair. For more information about undefined values, see Data formats.	cht=lxy chd=t:10,20,40,80,90,95,99| 20,30,40,50,60,70,80| -1| 5,25,45,65,85

Back to top

Bar charts

Specify a bar chart with

cht=<bar chart style>

Where <bar chart style> is bhs, bhg, bvs or bvg as described in the following table.

Depending on the bar chart style, multiple data sets are drawn as stacked or grouped bars. For information on how to specify multiple data sets, see Using multiple data series.

For information on available parameters, see Optional parameters by chart type.

Parameter	Description	Example
cht=bhs	Horizontal bar chart, with stacked bars. The first example (all bars in dark blue) has a single data set. The second example (bars in dark and pale blue) has two data sets. As you can see, multiple data sets are stacked. You must specify a color for each data set. You can also specify a color for each data point, or bar, within a single data set. See Colors for information about specifying colors. The second example does not use data scaling. Data points that have a combined value greater than 100 are only partially visible. See Text encoding with data scaling for more information about data scaling.	cht=bhs chco=4D89F9 cht=bhs chco=4D89F9,C6D9FD chd=t:10,50,60,80,40| 50,60,100,40,20
cht=bvs	Vertical bar chart, with stacked bars. This example has two data sets, and uses data scaling to ensure that the bars are fully visible.	cht=bvs chco=4D89F9,C6D9FD chd=t:10,50,60,80,40| 50,60,100,40,20 chds=0,160
cht=bhg	Horizontal bar chart, with grouped bars.	cht=bhg chco=4D89D9,C6D9FD
cht=bhg cht=bvg	Vertical bar chart, with grouped bars.	cht=bvg chco=4D89F9,C6D9FD
chbh	The default width for bars is 23 pixels. If you specify too many bars for the available chart size, not all bars appear. Use chbh=a to fix this problem, by automatically resizing bars so that they fit within the chart size. For more options, see Bar width and spacing.	cht=bvg chbh omitted cht=bvg chbh=a

Back to top

Pie charts

Specify a pie chart with

cht=<pie chart style>

Where <pie chart style> is p, p3, or pc as described in the following table. For information on available parameters, see Optional parameters by chart type.

Back to top

Venn diagrams

Specify a venn diagram with

cht=v

Supply one data set where:

• The first three values specify the relative sizes of three circles: A, B, and C.
• The fourth value specifies the area of A intersecting B.
• The fifth value specifies the area of A intersecting C.
• The sixth value specifies the area of B intersecting C.
• The seventh value specifies the area of A intersecting B intersecting C.

Back to top

Scatter plots

Specify a scatter plot with

cht=s

For information on available parameters, see Optional parameters by chart type.

Back to top

Radar charts

Specify a radar chart with

cht=r or cht=rs

For information on available parameters, see Optional parameters by chart type.

Parameter	Description	Example
cht=r	In a radar chart, data points are drawn between the center of the chart and the perimeter. Points of value zero (0, A or AA depending on the type of encoding) are drawn at the center. Points with the maximum value for the encoding used (100, 9 or ..) are drawn at the perimeter. Intermediate values are scaled between the two. The points representing the first and last values in the data set are drawn between the center of the chart and the top of the chart. The remaining points are evenly spaced clockwise around the chart, and a line is drawn between each pair of points. For a chart of type r, points are connected with straight lines. This example shows a simple radar chart, with a single data set.	cht=r chd=t:10,20,30,40,50,60,70,80,90
	You can add further information and clarity to a radar chart by adding colors, line styles, and axis labels. This example is a more complex radar chart with two data sets. The color of each data set is specified with chco, as described in Chart colors. Line styles are specified with chls, as described in Line styles. Axis labels are specified with chxt, chxl, and chxr, as described in Axis styles and labels. For radar charts, the x-axis is drawn in a circle, and the y- and r-axes go from the center of the chart to the top. The t-axis is ignored. When labels are included in a radar chart, the spacing of the data points around the chart is determined by the number of labels, or the number of data points, whichever is larger.	chco=FF0000,FF9900 chls=2.0,4.0,0.0|2.0,4.0,0.0 chxt=x chxl=0:|0|45|90|135|180|225|270|315 chxr=0,0.0,360.0
cht=rs	This example uses the same parameters as the previous example, but has a Fill area specified for both data sets. This example includes an added grid. See Grid lines for more information. For charts of type rs, points are connected with splines to form a curved line.	chg=25.0,25.0,4.0,4.0 chm= B,FF000080,0,1.0,5.0| B,FF990080,1,1.0,5.0
	The final example shows the previous example with added Shape markers. The horizontal line shape marker (specified with chm=h) produces a circle on a radar chart. The vertical line shape marker specified with chm=v is drawn as a line from the center of the radar chart to the specified data point. The vertical line shape marker specified with chm=V is drawn as a line from the center of the chart to the perimeter. The shape markers are specified as follows: the outer blue circle is specified with chm=h,0000FF,... the inner, partially transparent, blue circle is specified with chm=h,3366CC80,... the partially transparent green line (between 1 and 2 o'clock) is specified with chm=V,00FF0080,... the dark green line (at 8 o'clock) is specified with chm=V,008000,... the green line (at 10 o'clock) is specified with chm=v,00A000,... See Shape markers for more information about available shapes. You can also specify range markers. See Range markers for more information.	chm= h,0000FF,0,1.0,4.0| h,3366CC80,0,0.5,5.0| V,00FF0080,0,1.0,5.0| V,008000,0,5.5,5.0| v,00A000,0,6.5,4

Back to top

Maps

Specify a map with

cht=t, and chtm=<geographical area>

Where <geographical area> is one of the following:

• africa
• asia
• europe
• middle_east
• south_america
• usa
• world

For example:

chs=440x220
chd=s:_
cht=t
chtm=world

This is the default map for the world. The size used in the example (440 by 220 pixels) is the maximum for all maps. Note that the data set contains just one character, an underscore (_). The underscore specifies a missing value in simple encoding and gives us the simplest map possible. You can make your map more informative and interesting by using color for one or more countries.

Specify the colors on a map, and how they are applied to each country or state, with three parameters in combination:

chco=<default color>,<start of gradient>,<end of gradient>
chld=<country or state codes>
chd=<color levels>

Where:

• <default color>, <start of gradient>, and <end of gradient> are RRGGBB format hexadecimal numbers. The default color is applied to countries or states that are not listed in the chld parameter. The other colors specify the extremes of a color gradient that is used to color all countries listed in the chld parameter. The color that is applied depends on the country's value in the chd parameter. To control the gradient further, specify more colors.
• <country or state codes> is a list of either of the following:
  • ISO 3166-1-alpha-2 codes for countries as defined by ISO3166, see ISO 3166 Country codes.
  • USA state codes as listed in United States of America state codes.
• <color levels> are text encoding, simple encoding, or extended encoding values. Text encoding with data scaling is not available for maps. The first value is used for the first country listed in the chld parameter, the second value is used for the second country listed, and so on. The lowest data value (A, 0, or AA depending on the type of encoding used) is drawn in the color specified by <start of gradient> in chco. The highest value (9, 100, or ..) is drawn in the color specified by <end of gradient>. Intermediate values give intermediate colors.

For example:

chtm=africa
chco=FFFFFF,FF0000,FFFF00,00FF00
chld=DZEGMGAOBWNGCFKECGCVSNDJTZGHMZZM
chd=t:0,100,50,32,60,40,43,12,14,54,98,17,70,76,18,29
chf=bg,s,EAF7FE

In this example:

• The first color is FFFFFF, which specifies white. This color is used for any country not listed in the chld parameter.
• The other colors specify a color gradient from red, through yellow, to green.
• The first country listed is Algeria (DZ). The first value listed is 0. Therefore, Algeria is drawn with the color at the beginning of the gradient, and appears in red.
• The second country listed is Madagascar (MG). The second value listed is 100. Therefore, Madagascar is drawn with the color at the end of the gradient, and appears in green.
• The third country listed is Egypt (EG). The third value listed is 50. Therefore, Egypt is drawn with the color that lies midway across the gradient. The gradient is specified as going from red, through yellow, to green. Egypt appears in yellow.
• Water masses are considered to be the map's background. They are drawn in pale blue (EAF7FE), as specified in the chf parameter. See Chart area and background fill for more details on background colors.

Back to top

Google-o-meters

Specify a Google-o-meter with

cht=gom

For information on available parameters, see Optional parameters by chart type.

Back to top

QR codes

QR Codes are a popular type of two-dimensional barcode, which are also known as hardlinks or physical world hyperlinks. QR Codes store text, which can be a URL, contact information, telephone number, even whole verses of poems!

QR codes can be read by any device that has the appropriate software installed. Such devices range from dedicated QR code readers to mobile phones.

Specify a QR code with

cht=qr
chl=<text to encode>
choe=<output encoding>

Where:

• <text to encode> is the text for the QR code. The text must be url-encoded in UTF8. Note that the space between hello and world is written as %20 in the following example.
• <output encoding> specifies how the output is encoded. If this parameter is omitted, the default encoding of UTF-8 is used. Available encodings are Shift_JIS, UTF-8, or ISO-8859-1.

For example:

cht=qr
chl=hello%20world
choe=UTF-8

The example QR code above is the simplest possible type of QR code, and is known as Version 1. It has 21 rows and 21 columns.

• Version 1 has 21 rows and 21 columns, and can encode up to 25 alphanumeric characters
• Version 2 has 25 rows and 25 columns, and can encode up to 47 alphanumeric characters
• Version 3 has 29 rows and 29 columns, and can encode up to 77 alphanumeric characters
• ...
• Version 40 has 177 rows and 177 columns, and can encode up to 4,296 alphanumeric characters

The Chart API generates the appropriate QR code version depending on the number of characters you provide. For example, if you provide 55 alphanumeric characters, the Chart API will generate a Version 3 QR code. This may be modified by the error correction (EC) level you choose to use.

Don't confuse the number of rows and columns with size of the QR code image. The number of characters you provide determines the number of rows and columns. The pixel size of the chart is determined with chs as usual (see Chart size).

Error correction and margins

Four levels of error correction (EC) are available. The default level (L) allows the QR code to be read even if up to 7% of the code is misread, missing, or obscured. Other levels provide error correction for codes where up to 30% of the code cannot be read. The number of characters that can be encoded decreases as the EC level increases. See Versions, error correction and maximum characters for details.

The default margin is 4 modules. This means that a blank space equivalent to four rows at the top and bottom and four columns on the left and right is placed around the QR code. This is the minimum required by QR readers.

Optionally, specify an EC level and margin with

chld=<EC level>|<margin>

Where:

• <EC level> is one of the following:
  • L allows 7% of a QR code to be restored
  • M allows 15% of a QR code to be restored
  • Q allows 25% of a QR code to be restored
  • H allows 30% of a QR code to be restored
• <margin> defines the margin (or blank space) around the QR code. The default image has a margin equivalent to 4 rows / columns of the chart.
  

Versions, error correction and maximum characters

Before generating your QR code, consider what kind of device is used to read your code. The best QR code readers are able to read Version 40 codes, mobile devices may read only up to Version 4.

See the following table for information on maximum number of characters for each version and EC level.

Further information and standards

QR code is trademarked by Denso Wave, Inc. As you'd expect, the Denso Wave website includes a lot of useful information about QR codes.

QR code was approved as:

• AIM International (Automatic Identification Manufacturers International) standard (ISS - QR Code) in October 1997.
• JEIDA (Japanese Electronic Industry Development Association) standard (JEIDA-55) in March 1998.
• JIS (Japanese Industrial Standards) standard (JIS X 0510) in January 1999.
• ISO international standard (ISO/IEC18004) in June 2000.

QR code reader software is available from many sources. Google offers a QR Code reader library, Zebra Crossing (ZXing), for free. See http://code.google.com/p/zxing/ for details.

See Barcode Contents for a rough guide to standard encoding of information in barcodes.

MyRemote.java

MyRemoteImpl.java

MyRemoteImpl_Stub.class

 1. 원격 인터페이스를 만든다

 : 원격 인터페이스(interface)는 쉽게말하면 서버와 클라이언트간의 규약을 만드는것이라 할 수 있다. 인터페이스를 만들어놓고, 서버측, 클라이언트측모두 이 인테페이스를 사용 하게 만든다면 효과적으로 메소드들을 연계시킬 수 있을 것이다.

<예제파일 : MyRemote.java>

1) java.rmi.Remote를 확장한 인터페이스를 만든다. 이때, Remote는 '표지' 인터페이스로서,  아무런 메소드도 가지고 있지 않다. 이 인터페이스를 확장해서 자신만의 인터페이스를 만든다

      

2) 서버측이 구현하고, 클라이언트측이 실행시킬 메소드를 만든다. 이때, 모든 메소드들이 RemoteException을 던지도록 선언해 주어야만 한다

      

* 여기서는 예제로 sayHello라는 메소드를 사용할것임을 알 수 있다.

2. 원격 인터페이스를 구현한 클래스를 만든다

: 서버측에서는 방금전에 만든 인터페이스를 확장한 클래스를 만들어야 하며, 이 클래스 내부에 우리가 서비스해줄 메소드가 들어있다.

<예제파일 : MyRemoteImpl.java>

1) 인터페이스와 메소드를 구현한다. 이때, 이 파일이 원격서비스 객체역할을 하려면 객체 자체에 원격으로 돌아가는 역할에 관한 내용을 포함하고 있어야 하며, 이를위해 Unicast-RemoteObject를 확장하게 된다.

   

3) 서비스를 RMI레지스트리에 등록 합니다. 반드시 서비스가 RMI레지스트리에 등록되어야 하는데 이를 위해서 java.rmi.Naming 클래스의 rebind() 메소드를 이용한다. 아래 그림은 서비스에 Remote_Hello라는 이름을 붙여주고, 이를 RMI레지스트리에 등록하는 작업을 나타낸다.

   

4. rmic를 이용해 stub, skelecton을 만든다

: 이제 서비스 보조객체인 스터브와 스켈렉톤을 생성한다. 이때 생성되는 스터브와 스켈렉톤은  MyRemoteImpl에 관한 것이므로 모든 작업은 클래스 파일을 접근할 수 있는 위치에서 이루어 져야 한다.

1) 명령행에서 MyRemoteImpl이 있는 폴더로 이동한다

2) rmic명령어를 실행시켜 스터브와 스켈렉톤을 만든다   

   

   

   

* 이때도 역시, 실행시키면 커서가 계속 깜박거리고있다. 절대로 끄면 안된다..

7. 주의사항

: 여기서 우리는 엄청난 사실을 발견하게 된다. 4-2)rmic실행시 stub는 생성되었으나 skelecton은 생성되지 않은것이다. 왜일까... rmic명령어에 관한걸 좀더 알아보기 위해서 명령어창에 rmic 만을 쳐보자. 그러면 아래와 같은 도움말 창이 뜨게된다.

1) 1.2버전으로 오면서 default값이 stub만 생성하는것으로 바뀐것을 알 수 있다. 즉, 1.2버전에서 skelecton은 필요가 없어졌다.

2) -v1.1옵션을 사용하면 1.1버전의 stub/skelecton을 만들 수 있는것을 알 수 있다.

3) -vcompat옵션을 사용하여 1.2에서 1.1호환버전의 skelecton을 생성할 수 있음을 알 수 있다.

RMI(Remote Method Invocation)

 다형성 기본 개념 이해하고 있어야한다..

 다형성은 항상 상위(Super) 클래스의 멤버필드만 사용할수 있다..

  (단 메서드는 상위 클래스의 메서드를 사용하나 재정의시에는 상속받은 클래스의 메서드를 사용한다..)

UnicastRemoteObject 같은 클래스에 이미 상속해 두었다..

가.원격 인터페이스 작성

1. 서버와 클라이언트에서 동시에 사용할 원격(Remote) 인터페이스를 생성한다...

 인터페이스 작성규칙..

  조건1. java.rmi.Remote를 상속받아야한다..

          -  이 인터페이스에 있는 메서드는 로컬이 아닌 원격에서 사용할수 있어야 한다는 것을 명시하기 위해서이다..

  조건2. 무조건 public 이어야한다..

          - 원격은 클래스 내부에서의 접근만 허용하는 private 지정도 안될 것이고 상속의 관계에서 사용하는 protected지정도

            안될것 이고 동일 package에서의 호출만 가능한 package지정도 안될 것이기 때문이다..

  조건3. 메서드는 무조건 RemoteException 처리를 하여야한다..(예외발생처리)

    ex)  import  java.rmi.*;

       public interface Ex01 extends Remote {

          public String Message() throws RemoteException;  //인터넷상의 예외를 위해 반드시 처리..

             //특정 메세지를 전송하기 위한 메서드..

          public void printData() thorws RemoteException;

            // 호출된 시간을 서버에 출력하는 메서드..

2. 서버에 바인딩될 클래스의 멤버 메서드를 재정의 한다..(클래스가 실제 요청이 있을경우 실행하는 부분..)

- 서버에서는 이 객체가 바인딩되어 있어야하고 클라이언트는 이 객체를 통해 서버의 내용을 실행할수 있다..

   이 클래스는 외부 요청을 받기 위해 자신의 객체를 바인딩하기 때문에 직렬화가 되어있어야 하고 이전 단계에서 작성한

   원격인터페이스를 구현해야한다..

나. 인터페이스를 구현한 실제 서버 클래스 작성

이 클래스는 인터페이스를 구현할 목적으로 만든 클래스로 원격으로 객체를 복사해서 통신할 수 있는 형태를 표현하기 위해

미리 만들어진 UnicastRemoteObject와 같은 계열의 클래스를 상속받아야 한다. 실제 서버 행동의 주체(동작되는)가 되는 클

래스이기도 하다..

 구현 클래스의 규칙

  조건1 : 무조건 public이어야 한다.

  조건2 : 앞에서 만든 인터페이스를 상속받아 구현해 주어야한다.

             (인터페이스를 상속받았으니 메서드를 재정의하는것은 당연..)

  조건3 : UnicastRemoteObject 계열의 통신 클래스를 상속받아야한다.

              (해당 통신의 하부 구조를 일부 구현해주고 객체의 직렬화를 만들어준다..)

  조건4 : 이 클래스의 디폴트 생성자는 반드시 정의해야 한다. 또한 그 생성자는 RemoteException 처리.

              (UnicastRemoteObject생성자에서 해당 예외를 발생시키기 때문)

ex)

import java.rmi.*;
import java.rmi.server.*;
import java.util.*;

public class Ex02 extends UnicastRemoteObject implements Ex01 {
  public Ex02() throws RemoteException {
   super();
  }

  public String Message() throws RemoteException {
   printDate();
   return "안녕하세요! 반갑습니다.";
  }

  public void printDate() throws RemoteException {
   Date d = new Date();
   System.out.println("Connect Date = " + d.toString());
  }
}

다. 객체를 바인딩하는 Run 클래스 작성

 이 클래스는 객체인 Ex02를 RMIRestry라는 데몬 서버에 바인딩시키는 역할을 한다. 여기에서 객체를 바인딩시키는

메서드는 Naming 클래스의 rebind()라는 매서드이다.. 객체의 이름은 임의로 apple로 정한다..

import java.rmi.*;
import java.net.*;

public class Ex03 {
 public static void main(String[] args) {
  try {
   Ex02 sr = new Ex02();
   System.out.println("Server Ready...");
   Naming.rebind("apple", sr);
  } catch (RemoteException ee) {
   ee.printStackTrace();
  } catch (MalformedURLException ee) {
   ee.printStackTrace();
}
 }
}

라. 클라이언트가 객체를 찾아 호출하는 클래스작성

클라이언트가 유일하게 작성하는 클래스를 서버의 객체를 복사해서 가지고 와서 사용할수 있도록한다.

이것의 실행조건은  당연히 1번에서 작성한 원격인터페이스가 동일한 폴더에 있어야 한다는 것이다.

그것을 통해 다형성의 개념으로 실행할 수 있기 때문이다. 객체를 찾는 방법으로 사용된 클래스는

Naming이라는 클래스의 static메서드인 lookup()이다.

import java.net.*;
import java.rmi.*;

public class Ex04 {
 public static void main(String[] args) {
    try {
     Ex01 fr = (Ex01) Naming.lookup("rmi://원격시키고자 하는 서버 ip주소값/apple"); // 다형성...
     String msg = fr.Message();
     System.out.println("Message = " + msg);
    } catch (RemoteException ee) {
     ee.printStackTrace();
    } catch (MalformedURLException ee) {
     ee.printStackTrace();
    } catch (NotBoundException ee) {
     ee.printStackTrace();
    }
    }
}

< RMI 실행방법 (Dos화면에서)>

  1. 네 개의 파일을 모두 컴파일한다..(시작->실행->cmd)

   -> 관련파일경로 > java -d . *.java

  2. 두번째 작성한 실제 서버 클래스를 RMI컴파일을 통해 스텁클래스(파일명_Stub.class)를 생성..

   ( 스텁클래스는 내부 통신의 통로 역할을 하게 된다..)

   ->관련파일경로 > rmic -d . Ex02

 3.자바폴더의 bin폴더안에 rmiregistry.exe 파일을 실행하여 RMI서버를 가동한다.(새창이 생성됨)

   ( 보안경고창이 뜨면 차단해제 클릭~!) - 서버를 실행할수 있는 상태를 만든다..

 4. 생성된 새창은 실행상태로 두고 기존에 컴파일시켰던 도스창으로 돌아와 세번쨰 예제인 서버 실행 클래스를

   실행시킨다. 이것으로 RMI 서버에 객체를 바인딩할수 있다. - 서버실행상태

  ->관련파일경로 > java Ex03

    (실행하면 "Server Ready..."라는 메세지가 뜬다.)

 5. 마지막으로 또 하나의 Dos창을 열어 네번째 작성된 클래스를 통해 실행을 확인한다. 네번째 클래스는 다른 컴퓨터에

  있어도 되지만 첫번째 예제로 작성된 Remote를 상속받은 interface와 함께 있어야 한다.
  ->관련파일경로 > java Ex04

  (실행시 첫번째 도스창에 Date(날짜)값이 출력되고  입력창에는 "안녕하세요!반갑습니다"라는 메세지가 뜬다.)


출처 : http://shizuku.tistory.com/category/☆%20IT/JAVA

[Calculator.java]

import java.rmi.*;

public interface Calculator extends Remote
{
 public int sum(int num1, int num2) throws RemoteException;
 public int sub(int num1, int num2) throws RemoteException;
 public int multy(int num1, int num2) throws RemoteException;
 public int division(int num1, int num2) throws RemoteException;
}



[CalculatorImpl.java]

import java.rmi.server.*;
import java.rmi.*;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator
{
 public CalculatorImpl() throws RemoteException{

 }

  public int sum(int num1, int num2) {
   return num1+num2;
  }

  public int sub(int num1, int num2) {
   return num1-num2;
  }
 
  public int multy(int num1, int num2) {
   return num1*num2;
  }
 
  public int division(int num1, int num2) {
   return num1/num2;
  }

}


[Server.java]

import java.rmi.*;

public class Server
 {
  public static void main(String[] args) throws Exception
   {
    CalculatorImpl c = new CalculatorImpl();
    Naming.rebind("Calculator",c);
    System.out.println("server ready...");
   }
 }


[Client]

 public static void main(String[] args) throws Exception
 {
  Calculator c = (Calculator)Naming.lookup("Calculator");
  int num1 = Integer.parseInt(args[0]);
  int num2 = Integer.parseInt(args[1]);

  int result1 = 0, result2 = 0, result3 = 0, result4 = 0;
  result1 = c.sum(num1, num2);
  result2 = c.sub(num1, num2);
  result3 = c.multy(num1, num2);
  result4 = c.division(num1, num2);

  System.out.println("sum : " + result1);
  System.out.println("sub : " + result2);
  System.out.println("multy : " + result3);
  System.out.println("division : " + result4);
 }
}



출처 : http://shizuku.tistory.com/category/☆%20IT/JAVA

 : commons-email.jar
 : mail.jar
 : activation.jar

2. 아래의 링크에서 다운 받으실수 있어요.

Commons-Email을 사용하기 위해서는 JavaMail의 mail.jar와 JAF의 activation.jar 가 필요합니다

Commons-Email

http://jakarta.apache.org/site/downloads/downloads_commons-email.cgi

JavaMail 1.3

http://java.sun.com/products/javamail/downloads/index.html

JAF 1.0.2

http://java.sun.com/products/javabeans/glasgow/jaf.html

3. 예제

Ex1> SimpleEmail

SimpleEmail email = new SimpleEmail();
email.setHostName("mail.nate.com");       //ex) nate.com 일 경우!! ->> mail.nate.com
email.addTo(onamt@nate.com, "받는사람");    //ex) onamt@nate.com
email.setFrom("onamt@nate.com", "보내는사람");
email.setSubject("제목을 입력합니다");
email.setMsg("메일의 내용을 입력합니다.");
email.send();

위의 예제는 아주 간단한 예제로 SimpleEmail입니다.

받는사람, 보내는사람, 호스트, 제목, 내용만을 보낼수 있습니다.

Ex2> 파일 첨부 메일

//첨부하실 파일의 정보를 넣습니다.
EmailAttachment attachment = new EmailAttachment();
attachment.setPath("mypictures/john.jpg");      //파일의 경로
attachment.setDisposition(EmailAttachment.ATTACHMENT);      //파일의 형태
attachment.setDescription("Picture of John");      //파일의 성명
attachment.setName("John");       // 첨부파일명

//그 후 MultiPartEmail 을 통해 SimpleEmail 처럼 기본 메일정보를 설정합니다
MultiPartEmailemail = new MultiPartEmail();
email.setHostName("mail.nate.com");
email.addTo("onamt@nate.com", "받는사람");
email.setFrom("onamt@nate.com", "보내는사람");
email.setSubject("제목");
email.setMsg("내용");

// 마지막으로 MultiPartEmail의 attach() 함수를 통해 첨부 파일을 추가하여 전송합니다
email.attach(attachment);

// 메일을 전송합니다
email.send();

만약 첨부파일이 여러개라면 EmailAttachment 를 여러개 생성하여 파일 정보를 설정 한 후 attach()를 통해 추가해 주기만 하면 됩니다

Ex3>HTML 이메일 보내기

// 기본 메일 정보를 생성합니다
HtmlEmailemail = new HtmlEmail();
email.setHostName("mail.nate.com");
email.addTo("onamt@nate.com", "받는사람");
email.setFrom("onamt@nate.com", "보내는사람");
email.setSubject("제목");

// 삽입할 이미지와 그 Content Id를 설정합니다
URL url = new URL("http://www.이미지 경로");

String contentId = email.embed(url, "Apache logo");

// HTML 메세지를 설정합니다

email.setHtmlMsg("<html>뭐뭐뭐뭐뭐뭐뭐</html>");

// HTML 이메일을 지원하지 않는 사람이면 다음 메세지를 뿌려웁니다
email.setTextMsg(" HTML 이메일을 지원하지 않습니다..ㅋㅋ");

// 메일을 전송합니다
email.send();

HtmlEmail 클래스는 setHtmlMsg()로 작성된 html을 보낼 수 있습니다

Extract All Classes Loaded in the JVM into a Single JAR

This entry was posted on Wednesday, August 27th, 2008 at 11:32 pm and is filed under java, blog. You can follow any responses to this entry through the comments RSS 2.0 feed. Both comments and pings are currently closed.

Comments are closed.

JAVA 환경변수 설정

시스템변수(S)에서 설정
1. 변수값 : path(맨끝에) : 수정
   변수값 : ;%JAVA_HOME%\bin

2. 변수이름 : CLASSPATH : 생성
   변수값 : .;%JAVA_HOME%\lib\tools.jar
   ※ 앞에 .; <= 주의할것 빼먹지말것

3. 변수이름 : JAVA_HOME : 생성
   변수값 : C:\Program Files\Java\jdk1.5.0_16

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

TOMCAT 환경변수 설정 (tomcat은 설치하는거 없이 압축풀면 설치끝)

시스템변수(S)에서 설정

   변수이름 : CATALINA_HOME - 생성
   변수값  : d:\www\apache-tomcat-5.5.27
   톰캣Start : apache-tomcat-5.5.27\bin\startup.bat
   톰캣Shutdown : apache-tomcat-5.5.27\bin\shutdown.bat

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Servlet 설정 (web.xml 수정)

   Tomcat이 설치된 폴더 => \conf\web.xml
     ex> apache-tomcat-5.5.27\conf\web.xml
   ※ 기본적으로 보안상 Servlet은 막혀있으므로 Servlet개발을 위해서
       주석을 제거하여 사용 환경을 만든다.

  1. "invoker" 찾기

########################################################
# <!--        #
#    <servlet>       #
#       <servlet-name>invoker</servlet-name>    #
#       <servlet-class>      #
#           org.apache.catalina.servlets.InvokerServlet   #
#          </servlet-class>      #
#          <init-param>      #
#             <param-name>debug</param-name>    #
#             <param-value>0</param-value>    #
#       </init-param>      #
#       <load-on-startup>2</load-on-startup>    #
#    </servlet>       #
# -->        #
########################################################
  [▲ 이부분을 찾는다]
  2. 주석제거 <!--, --> 이것만 삭제할것
########################################################
#    <servlet>       #
#       <servlet-name>invoker</servlet-name>    #
#       <servlet-class>      #
#           org.apache.catalina.servlets.InvokerServlet   #
#          </servlet-class>      #
#          <init-param>      #
#             <param-name>debug</param-name>    #
#             <param-value>0</param-value>    #
#       </init-param>      #
#       <load-on-startup>2</load-on-startup>    #
#    </servlet>       #
########################################################
  [▲ 이렇게 만들면 됨]
  3. Servlet Mapping의 주석도 제거("invoker" 찾기)

########################################################
#    <!-- The mapping for the invoker servlet -->   #
# <!--        #
#    <servlet-mapping>      #
#       <servlet-name>invoker</servlet-name>    #
#       <url-pattern>/servlet/*</url-pattern>    #
#    </servlet-mapping>      #
# -->        #
########################################################
     [▲ 이부분을 찾아서 주석제거,  ▼ 이렇게 만든다]
########################################################
#    <!-- The mapping for the invoker servlet -->   #
#        #
#    <servlet-mapping>      #
#       <servlet-name>invoker</servlet-name>    #
#       <url-pattern>/servlet/*</url-pattern>    #
#    </servlet-mapping>      #
#        #
########################################################
  4. web.xml을 저장하고 닫는다.
   ※ Servlet를 작성하기위해 API를 연결한다.
      여기서는 Tomcat에 있는 servlet-api.jar파일을 이용한다.
      EJB를 개발한다면 JavaEE를 설치하는게 좋다.
  5. tomcat\common\lib\
     위의 경로에서 servlet-api.jar파일을 복사하여
     Program Files/Java/jdk/lib/
     위의 lib폴더에 복사

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Servlet 환경변수 설정

시스템변수(S)에서 설정
1. 변수값 : CLASSPATH  : 지금까지 설정되있는것
   변수값 : .;%JAVA_HOME%\lib\tools.jar

2. jar파일 복사
    원본파일 : 톰캣경로\common\lib\servlet-api.jar (복사)
    사본파일 : C:\Program Files\Java\jdk1.5.0_16\lib\servlet-api.jar (여기에 복사할것)

3. 변수값 : CLASSPATH(맨끝에) : 수정
   변수값 : .;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Java\jdk1.5.0_15\lib\servlet-api.jar
   위치 : 톰캣경로\common\lib\servlet-api.jar

   ※ 뒤에 servlet-api파일의 경로만 넣어주면된다.
      ;C:\Program Files\Java\jdk1.5.0_15\lib\servlet-api.jar

   ※ tomcat이설치된 경로\webaps\ROOT\WEB-INF\
      classes란 폴더를 만든다. (WEB-INF 폴더아래에)

   ※ Servlet은 웹 어플리케이션 폴더 아래에
      WEB-INF\classes폴더가 존재해야함

   ※ sevlet가 잘돌아가는지 확인하는것은
      classes폴더에 servlet파일을 넣고
      웹브라우저에 http://127.0.0.1/servlet/서블릿파일(확장자빼고)
      실행되는지 볼것 ( servlet도 java기반이기때문에 대소문자 구분.. 조심!! )

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Eclipse 설치

http://www.eclipse.org/downloads

■ 환경 설정

개발 환경 설정에는 다음과 같이 3가지 방법이 있다.

1. JSDK 1.3이하 버젼 & JCE 1.2.1 글로벌 버전 JCE 1.2.1 버전은 http://java.sun.com 사이트에서 회원가입을 해야지 Down 받을수 있다. JCE는 미국에서 무기로 관주 되기 때문에 글로벌 버전은 미국, 케나다 버전과 다르다.

2. JSDK 1.4에는 Java Cryptography Extension 1.2.1 버전이 포함되어 있다.

3. 다운 받은 JCE의 압축을 풀고 lib방 밑에 있는 모든 jar파일을[JavaHome]jrelibext방으로 카피한다. 그리고 JCE 알고리즘을 사용하기 위해서 SunJCE 프로바이터를 설치 해야 한다.

설치하기 위해서는 [JavaHome]jrelibsecurityjava.security 파일에 다음을 추가한다.

security.provider.1=sun.security.provider.Sun,

security.provider.2=com.sun.crypto.provider.SunJCE

■ 서로 다른 개념들

1. 보안 != 암호 : 애플리케이션에 암호를 추가하는 것이 애플리케이션을 안전하게 하지 못한다.

2. 올바른 보안 모델 != 버그가 없는 구현 : 훌륭한 보안 모델이라고 해도 구현 과정에서의 버그는 공겨자의 대상이 될 수 있다.

3. 테스트 != 공식적인 증명

4. 컴포넌트 보안 != 전반적인 시스템 보안

5. 자바 보안 != 애플릿 통제

Base 64

Base64는 바이트 배열을 아스키 문자로 표현하기 위한 시스템이다. Base64체계는 RFC1521의 Section5.2에 완전하게 기술되어 있다. sun.misc.BASE64Encoder는 바이트 배열을 가지고 base64 disit를 가지 문자열을 생성한다. 이에 대응하는 클래스 BASE64Decoder는 문자열을 가지고 원래 바이트 배열을 생성한다.

Sun에서는 Base64를 지원할 의무가 없다.

■ 예제 프로그램

//-- Masher 메시지 축약

package test.crypto.part1;

import java.security.*;

import java.io.*;

import sun.misc.*;

public class Masher {

public Masher() {

}

private void exec(String targetFileName) {

try {

// MD5알고리즘을 이용한 메시지 축약 객체를 생성한다.

MessageDigest md = MessageDigest.getInstance("MD5");

FileInputStream fin = new FileInputStream(targetFileName);

byte[] buffer = new byte[8192];

int length;

while ( (length = fin.read(buffer)) != -1 ) {

md.update(buffer,0,length);

}

byte[] raw = md.digest();

// 출력 가능한 문자열로 변환한다.

BASE64Encoder encoder = new BASE64Encoder();

String base64 = encoder.encode(raw);

System.out.println(base64);

} catch(NoSuchAlgorithmException nalgoe) {

System.err.println(nalgoe);

} catch(FileNotFoundException fnote) {

System.err.println(fnote);

} catch(IOException ioe) {

System.err.println(ioe);

}

}

public static void main(String[] args) {

if(args.length < 1) {

System.out.println("메시지 축약의 대상 파일을 선택하여 주십시요");

System.exit(0);

}

String targetFileName = args[0];

Masher masher = new Masher();

masher.exec(targetFileName);

}

}

매시지 축약은 데이터를 증명하지만, 메시지에 대해서는 전혀 알 수 없다.

// DES알고리즘을 이용한 대칭키 암복호화

package test.crypto.part1;

import javax.crypto.*;

import java.io.*;

import java.security.*;

import sun.misc.*;

public class SecretWriting {

public SecretWriting() {

}

public void exec(String args[]) throws Exception{

// key를 얻어 생성한다.

Key key;

try{

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

key = (Key)in.readObject();

in.close();

} catch (FileNotFoundException fnote) {

// ser Key 파일이 없으면 실행된다.

// DES 대칭키 알고리즘을 정의해서 키 제너레이터를 생성한다.

KeyGenerator keygenerator = KeyGenerator.getInstance("DES");

// 랜덤 함수로 초기화한다.

keygenerator.init(new SecureRandom());

// 키를 생성한다.

key = keygenerator.generateKey();

// 생성된 키 객체를 바이널리 파일로 저장한다.

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("SecretKey.ser"));

out.writeObject(key);

out.close();

}

Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");

// -e문자열이 없으면 복호화 한다. 다음은 암호화 한다.

if(args[0].indexOf("e") != -1) {

cipher.init(Cipher.ENCRYPT_MODE,key);

String amalgam = args[1];

for(int i = 2; i < args.length; i++) {

amalgam += " "+args[i];

}

byte[] stringBytes = amalgam.getBytes("UTF8");

byte[] raw = cipher.doFinal(stringBytes);

BASE64Encoder encoder = new BASE64Encoder();

String base64 = encoder.encode(raw);

System.out.println(base64);

} else if(args[0].indexOf("d") != -1) {

cipher.init(Cipher.DECRYPT_MODE,key);

BASE64Decoder decoder = new BASE64Decoder();

byte[] raw = decoder.decodeBuffer(args[1]);

byte[] stringBytes = cipher.doFinal(raw);

String result = new String(stringBytes, "UTF8");

System.out.println(result);

}

}

public static void main(String[] args) throws Exception{

if(args.length < 2) {

System.out.println("사용예 java tesst.crypto.part1.SecretWriting -[e|d] STRING1 STRING2 ...");

System.exit(0);

}

SecretWriting secretWriting = new SecretWriting();

secretWriting.exec(args);

}

}

DES 알고리즘은 동일한 키를 생성하여 암호화와 복호화가 이루워지는 대칭키 방식이다.

Chapter 2 기본기

■ 보안의 3대 규칙

1. 기밀성(Confidentially) : 비인가 된 사람은 내용을 볼 수 없어야 한다.

① 대칭암호화 : 송신측과 수신측이 동일한 키를 사용한다.(비밀키, 개인키 방식)

② 비대칭 암호화 : A의 공개키로 암호화 한 내용은 A의 개인키로만 풀 수 있다. 비대칭 암호화는 대칭 암호화에 비해 상당히 느리다.

2. 무결성(Integrity) : Date가 불법수정되지 못하게 보장한다. 암호화된 메시지 축약을 서명(signature)이라고 한다.

3. 인증(Authentication) : 상호 교신하는 사람이 각각 믿을수 있는 객체임을 보장한다.

인증서는 한 사람에 의해 발급되는 문장으로 다른 사람의 공개키를 가지는 어떤 값이다. 필수적으로 인증서는 서명된 공개키이다.

■ 알고리즘

비대칭 암호화와 서명은 다양한 키 크기를 가진다. 적절한 키 크기를 선태가하는 것은 사용자와 애플리케이션에 달려 있다.

명 칭
타 입
비 고

MD-5
메시지 축약
128비트 메시지 축약 생성

저항력에 약간의 허점을 발견

SHA-1
메시지 축약
160비트의 메시지 축약 생성

저항력이 증가

HmacMD5와 HmacSHA1
메시지 인증 코드


DSA
서명
512 ~ 1024비트 까지의 키 생성

ElGamal 서명
서명


DES
대칭 암호화


DESede
대칭 암호화


PBEWithMD5AndDES
대칭 암호화


ElGamal 암호
비대칭 암호화


DH
키 교환

표) 암호화 알고리즘

클래스/인터페이스
정의

java.security.cert.Certificate
암호인증

javax.crypto.Cipher
암호화

java.security.Key. java.security.PrivateKey, java.security.PublicKey, javax.crypto.SecretKey
서명이나 암호화에 사용되는키

javax.crypto.KeyAgreement
비밀키 교환 프로토콜

java.security.KeyFActory
공개키와 비밀키의 형식 변환

javax.crypto.KeyGenerator
대칭암호문에 사용될 키 생성

java.security.KeyPairGenerator
암호화와 인증에 사용된 공개키와 비밀키 생성

javax.crypto.Mac
메시지 인증 코드(MAC)

java.security.MessageDigest
암호화 해시함수

javax.crypto.SecretKeyFactory
비밀키의 형식 변환

java.security.SecureRandom
난수생성

java.security.Signature
전자서명

표) JDK와 JCE에 포함된 암호화 클래스

개념클래스
Sun이 지원하는 암호화 알고리즘
SunJCE가 지원하는 암호화 알고리즘

Cipher

DES, Desede, PBEWithMD5AndDES

KeyAgreement

DH

KeyFactory
DSA


KeyGenerator

DES,DESede

KeyPairGenerator Mac
DSA


Mac

HmacMD5, HmacSHA1

MessageDigest
MD5, SHA-1


SecretKeyFactory

DES, Desede, PBEWithMD5AndDES

Signature
DSA

표) 표준 알고리즘 이름

Chapter 3 난수

Chapter 4 키관리

■ Key 인터페이스

1. java.security.Key 인터페이스( 암호화 키를 캡슐화 )

- public String getAlgorithm() : 키가 사용된 암호 알고리즘 이름을 리턴

- public byte[] getEncoded() : 키의 암호화 값을 구할 수 있다.

- public String getFormat() : 암호화 하는데 사용된 키 포맷의 이름을 리턴한다.

- 자식 인터페이스 : java.security.PublicKey, java.security.PrivateKey,

javax.crypto.SecretKey(JCE)

2 java.security.KeyPair 클래스( 공개키와 개인키 )

- publicKeyPair(PublicKey publicKey, PrivateKey, privateKey) : 주어진 공개키와 개인키로 KeyPair를 생성한다.

- public PublicKey getPublic() : 공개키를 리턴한다.

- public PrivateKey getPrivate() : 개인키를 리턴한다.

■ 키 생성기

1. java.security.KeyPairGenerator( 비대칭 방식 JDK에 포함 )

- public KeyPair generateKeyPair () : 열쇠 페어를 생성합니다.

- public final KeyPair genKeyPair () : 열쇠 페어를 생성합니다.

- public String getAlgorithm () : 이 열쇠 페어 제네레이터의 알고리즘의 표준명을 돌려줍니다.

- public static KeyPairGenerator getInstance (String algorithm) : 지정된 다이제스트 알고리즘을 구현하는 KeyPairGenerator 오브젝트를 작성합니다.

- public static KeyPairGenerator getInstance (String algorithm, String provider) : 지정된 프로바이더로부터 지정된 알고리즘이 사용 가능한 경우에, 그 프로바이더가 제공한 알고리즘을 구현하는 KeyPairGenerator 오브젝트를 작성합니다.

- public final Provider getProvider () : 이 열쇠 페어 제네레이터 오브젝트의 프로바이더를 돌려줍니다.

- pubic void initialize (AlgorithmParameterSpec params) : 제공된 파라미터를 사용하여 KeyPairGenerator를 초기화 한다.

- public void initialize (AlgorithmParameterSpec params, SecureRandom random) : 제공된 파라미터를 사용하여 KeyPairGenerator를 초기화 한다.

- public void initialize (int keysize) : 랜덤 비트의 소스 역할을 하는 새로운 SecureRandom을 생성하는 것을 제외하고 임의의 키 사이즈에 대하여 열쇠 페어 제네리이터를 초기화합니다.

- pubic void initialize (int keysize, SecureRandom random) : 제공된 랜덤 비트 소스를 사용하여 임의의 키 사이즈 대하는 열쇠 페어 제네레이터를 초기화합니다.

KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");

kpg.initialize(1024);

KeyPair pair = kpg.getKeyPair();

2. javax.crypto.KeyGenerator( 대칭 방식 JCE에 포함 )

- public final SecretKey generateKey() : 새로운 랜덤 SecretKey를 생성한다.

- public String getAlgorithm() : KeyGenerator 객체에 사용된 알고리즘의 이름을 리턴합니다.

- public static KeyGenerator getInstance(.String algorithm) : 주어진 알고리즘으로 인스턴스 생성

- pubic static KeyGenerator getInstance(String algorithm, String provider) : 주어진 알고리즘과 프로바이터로 인스턴스 생성

- pubic Provider getProvider() : 사용된 프로바이터 리턴

- public void init(AlgorithmParameterSpec params) : 제공된 파라미터를 사용하여 초기화 한다.

- public void init(AlgorithmParameterSpec params, SecureRandom random) : 제공된 파라미터를 사용하여 초기화 한다.

- public void init(int keysize) : 주어진 크기로 키를 생성하기 위하여 초기화한다.

- public void init(int keysize, SecureRandom random) : 주어진 키와 랜덤소스로 초기화 한다.

- public void init(java.security.SecureRandom random) : 주어진 랜덤소스로 초기화 한다.

KeyGenerator kg = KeyGenerator.getInstance("DES");

kg.init(new SecureRandom());

SecretKey key = kg.generateKey()

■ 키 해석기

키를 저장하는 방법중 하나는 키를 직렬화 하여 저장하는것과 단순히 바이트의 배열과 같이 키를 저장하거나 전송하는 방법이 있다. 키 객체를 바이트로 또는 역으로 변환하는 방법이 다음의 클래스에 정의 되어있다.