package client;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import com.josephoconnell.html.HTMLInputFilter;

public class RequestWrapper extends HttpServletRequestWrapper 
{
    public RequestWrapper(HttpServletRequest servletRequest) {   
        super(servletRequest);   
    }   
       
    public String[] getParameterValues(String parameter) {   
  
      String[] values = super.getParameterValues(parameter);   
      if (values==null)  {   
                  return null;   
          }   
      int count = values.length;   
      String[] encodedValues = new String[count];   
      for (int i = 0; i < count; i++) {   
                 encodedValues[i] = filter(values[i]);   
       }     
      return encodedValues;    
    }   
       
    public String getParameter(String parameter) {   
          String value = super.getParameter(parameter);   
          if (value == null) {   
                 return null;    
                  }   
          return filter(value);   
    }   
       
    public String getHeader(String name) {   
        String value = super.getHeader(name);   
        if (value == null)   
            return null;   
        return filter(value);   
           
    }   
  
    private String filter(String input) {
        if(input==null) {
            return null;
        }
        String clean = new HTMLInputFilter().
        	filter(input.replaceAll("\"", "%22").
                    replaceAll("\'","%27"));
        return clean.replaceAll("<", "%3C").replaceAll(">", "%3E");
    }
}

package client;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

public class XssFilter implements Filter 
{
	private FilterConfig fc;
	public void destroy() {
		this.fc = null; 
	}

	public void doFilter(ServletRequest req, ServletResponse resp,
			FilterChain chain) throws IOException, ServletException {
		chain.doFilter(new RequestWrapper(
				(HttpServletRequest) req), resp);

	}

	public void init(FilterConfig fc) throws ServletException {
		this.fc = fc;
	}
}

<FILTER>  
    <FILTER-NAME>XSS</FILTER-NAME>  
    <DISPLAY-NAME>XSS</DISPLAY-NAME>  
    <DESCRIPTION></DESCRIPTION>  
    <FILTER-CLASS>client.XssFilter</FILTER-CLASS>  
</FILTER>  
<FILTER-MAPPING>  
    <FILTER-NAME>XSS</FILTER-NAME>  
    <URL-PATTERN>/*</URL-PATTERN>  
</FILTER-MAPPING>

1 객체지향의 구멍 static

1.1 Java는 객체지향 언어이다?

1.2 전역변수

2 Java는 Pointer언어이다? (Java에는 Pointer밖에 없다?)

2.1 Java는 primitive형을 제외하곤 모두 Pointer이다

2.2 null은 객체인가?

2.3 String에 대하여

2.4 객체지향의 캡슐화 파괴 주의

2.5 배열에 대하여

2.5.1 배열은 object 인가?

2.5.2 배열의 length는 왜 field(member variable)인가?

2.5.3 final과 배열에 대하여...

2.5.4 "Java에서의 다차원 배열은 존재하지 않는다."

2.6 인수(parameter/argument)전달의 개념

2.6.1 "Java에서 parameter(argument) 전달은 무조건 'call by value' 이다"

2.6.2 "C와 같은 언어는 static linking이지만, Java는 dynamic linking이다."

2.7 GC 에 대하여 잠깐!

2.7.1 "Garbage Collection은 만능이 아니다."

2.8 Java Pointer 결론

2.8.1 "결국 Java에는 pointer가 있는 것인가, 없는 것인가?"

3 상속과 interface의 문제점

3.1 상속

3.1.1 상속에 있어서의 생성자(constructor)

3.1.2 "down cast는 본질적으로 매우 위험하다"

3.1.3 "추상클래스에 final이 있으면 compile error이다"

3.2 interface

3.2.1 "interface는 interface일뿐 다중 상속의 대용품이 아니다."

3.3 상속 제대로 사용하기

4 package와 access 제어에 관한 이해

4.1 package

4.1.1 "package는 '계층구조' 인가?"

4.1.2 "compiler 가 인식하는 class검색 순서(소스코드내 클래스가 발견될 경우 그 클래스의 위치를 찾는 순서)"

4.2 access 제어

4.2.1 "interfacde member의 access 제어"

4.2.2 그렇다면 interface를 다른 package에 대하여 숨기고 싶으면 어떻게 하는가?

5 기타 Java 기능

5.1 Thread

5.1.1 "Multi Thread에서는 흐름은 복수이지만 data는 공유될 수 있다."

5.1.2 "Thread는 객체와 직교하는 개념이다."

5.1.3 "Synchronized 의 이해"

5.1.4 "Thread 사용법의 정석은?"

5.2 Exception

5.2.1 "finally 절은 반드시 어떠한 경우에도 실행되는가?"

5.2.2 "예외의 종류 3가지 (Error, RuntimeException, 그밖의 Exception)"

5.2.2.1 Error

5.2.2.2 RuntimeException

5.2.2.3 그밖의 Exception

5.2.3 "OutOfMemoryError는 어떻게 처리해야 하는가?"

5.3 Object Serialize

5.3.1 "Serialize를 위해서는 marker interface인 java.io.Serializable interface를 implements해야한다."

5.3.2 "super class는 Serializable이 아닌데 sub class만 Serializable인 경우의 문제점"

5.3.3 "transient field의 복원(?)관련"

5.3.4 "Stack Overflow에 주의하라!"

5.4 "nested class / inner class / 중첩클래스"

5.4.1 "중첩클래스의 개념"

5.4.2 "내부클래스는 부모의 참조를 몰래 보유하고 있다."

5.4.3 "local inner class에 대하여"

5.4.4 "anonymous class(무명클래스)에 대하여"

6 이래도 Java가 간단한가?

6.1 method overload 에서의 혼란?

6.1.1 "overload란 이름이 가고 인수가 다른 method에 compiler가 다른 이름을 붙이는 기능"

6.1.2 "그렇다면 overload에서 실제로 혼동되는 부분은 무엇인가?"

6.1.3 (참고) 또다른 혼동, overload한 method를 override 하면?

6.2 상속/override/은폐 에서의 복잡함

6.2.1 "Java class의 member 4 종류"

6.2.2 "override시 method 이름에 대한 함정"

6.2.3 "또다른 나의(?) 실수 - 말도 안되는 오타"

6.2.4 "static member를 instance를 경유하여 참조해서는 안 된다."

6.2.5 "super keyword는 부모의 this"

6.3 상속에 관한 또 다른 문제

6.4 그밖의 함정

6.4.1 "생성자에 void 를 붙인다면?"

6.4.2 "if / switch 의 함정"

7 Java 기능 적용 몇가지

7.1 대규모 개발에서 interface 분리하기

7.1.1 "interface 분리의 필요성"

7.2 Java에서의 열거형

7.3 Debug write

8 Java 5.0 Tiger 에 대하여

8.1 Working with java.util.Arrays

8.2 Using java.util.Queue interface

8.3 java.lang.StringBuilder 사용하기

8.4 Using Type-Safe Lists

8.5 Writing Generic Types

8.6 새로운 static final enum

8.7 Using java.util.EnumMap

8.8 Using java.util.EnumSet

8.9 Convert Primitives to Wrapper Types

8.10 Method Overload resolution in AutoBoxing

8.11 가변적인 argument 개수 ...

8.12 The Three Standard Annotation

8.13 Creating Custom Annotation Types

9 The for/in Statement

9.1 for/in 의 자주 사용되는 형태

10 Static Import

10.1 static member/method import

11 References

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(...);

Properties configProps = new Properties();
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
InputStream inputStream = classLoader.getResourceAsStream(propertyFilePath);
configProps.load(inputStream);

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



// 메일보낼사람 정보 가져오기
  // db.properties 가져오기 (* db.properties file은 DBCheckThread.class와 같은곳에  존재...)
  Properties properties = new Properties();
  InputStream inputstream = getClass().getResourceAsStream("/senduser.properties");
  properties.load(inputstream);
  String sendUser = properties.getProperty("mailuser");

  String toUser = "hanho9@nate.com";

중급 자바 개발자의 난관, 클래스 로딩 문제 분석하기

필자 | 장동수, 한컴 씽크프리 모바일 오피스 개발팀 dsjang@thinkfree.com 2007년 12월 11일

초급을 넘어 중급 단계로 들어서는 자바 개발자에게 몇 가지 난관 중 하나가 클래스 로딩 문제입니다.

적당한 jar 파일을 찾아 적당한 디렉터리에 넣어주면 해결되는 단순한 문제부터, 커스텀 클래스 로더가 필요한 경우까지 다양한 원인과 해결책이 있겠지만, 원리를 이해하지 않고 검색 엔진의 힘에 의지해 문제를 해결하다 보면 더 큰 문제를 만들게 됩니다.

이 연재에서는 클래스 로딩의 작동 원리에서 시작해, 개발하는 과정에서 발생할 수 있는 다양한 클래스 로딩 관련 문제에 대한 원인과 해결책을 4회에 걸쳐 설명하고 있습니다.

또한 직접 확인해 볼 수 있는 풍부한 예제와 실습을 통해, 이 연재에서 설명하지 않은 다른 형태의 클래스 로딩 문제를 만나더라도 신속하게 원인을 규명하고 해결책을 찾을 수 있는 응용 능력을 습득할 수 있을 것입니다.

• 1회: 클래스 로딩과 디버깅 툴 소개(한글)

첫 번째 연재에서는 클래스 로더 위임 모델과 각각의 클래스 로더를 제어하기 위한 JVM의 명령어 옵션을 알아봅니다. 그리고 클래스 로딩 과정을 단계별로 설명합니다. 마지막으로 IBM의 JDK에 내장된 도구들을 사용해 이러한 과정들을 직접 확인하는 방법을 설명합니다.


• 2회: 기본적인 클래스 로딩 예외(Exception)(한글)

흔히 볼 수 있는 ClassNotFoundException, NoClassDefFoundError 같은 예외부터 ClassCircularityError, ExceptionInInitializerError 같은 평생 한 번 보기도 힘든 예외까지 클래스 로딩과 관련된 거의 모든 예외와 에러(error) 들에 대해 자세히 알아봅니다.


• 3회: 특이한 클래스 로딩 문제 해결(한글)

클래스패스 끝에 붙은 '/' 문자 때문에 발생하는 사소한 문제부터, 클래스 로더 위임 모델과 클래스 가시성 때문에 발생하는 문제, 커스텀 클래스 로더를 만들 때 부주의로 발생하는 문제, 그리고 클래스로 로더가 가비지 컬렉션되면서 발생하는 문제까지, 클래스 로딩시 일어날 수 있는 더 복잡한 문제들에 대해 자세히 설명합니다.


• 4회: 교착 상태와 제약 조건(한글)

마지막으로 클래스 로더 교착 상태, 클래스 로더 제약 조건 위반 같은 쉽게 발생하지 않지만 일단 발생하면 해결하기 어려운 문제들에 대해 자세히 설명합니다.

package com.jisan.common.util.page;

public class Paging {

 private int totalCount;  
 private int currentPage;
 private int listLimit;
 private int pageLimit;

 private int totalPage;
 private int startPage;
 private int endPage;
 private int startNum;
 private int endNum;

 private String btnStart="";
 private String btnEnd="";
 private String btnListPrev="";
 private String btnListNext="";
 private String btnPageList="";
 private String btnListTenPrev= "";
 private String btnListTenNext= "";
 

 public Paging(int totalCount, int currentPage, String queryOption) {
  this.totalCount = totalCount;
  this.currentPage = currentPage;
  this.listLimit = 15;
  this.pageLimit = 5;
 }
 public Paging(int totalCount, int currentPage, String queryOption, int listLimit, int pageLimit) {
  this.totalCount = totalCount;
  this.currentPage = currentPage;
  this.listLimit = listLimit;
  this.pageLimit = pageLimit;
 }

 public PagingBean pagingProcess() throws Exception {

  PagingBean pb = new PagingBean();

  totalPage = (totalCount - 1) / listLimit + 1;
  startPage = ( (currentPage - 1) / pageLimit) * pageLimit + 1;
  endPage = startPage + pageLimit - 1;

  if (totalPage < endPage) {
  endPage = totalPage;
  }
  if (totalCount == 0) {
   totalPage = 0;
  }

  startNum = (currentPage - 1) * listLimit;
  endNum = listLimit;

  //제일 처음 페이지로.
  if (currentPage > 1) {
   btnStart = "<a href=\"javascript:go_Page('1')\"><img src=\"/spi/images/board/pag_rr.jpg\" border=\"0\" class=\"m_lr2\" /></a>&nbsp;";
  } else{
   btnStart = "<a href=\"#\"><img src=\"/spi/images/board/pag_rr.jpg\" border=\"0\" class=\"m_lr2\" /></a>&nbsp;";
  }

  //바로 이전 페이지 목록으로. (예: 이전 10 페이지로)
  if (currentPage > pageLimit) {
   int prevListPage = startPage - 1;
   btnListPrev = "<a href=\"javascript:go_Page('"+prevListPage+"')\"><img src=\"/spi/images/board/pag_r.jpg\" border=\"0\" class=\"m_lr5\" /></a>&nbsp;";
  } else{
   btnListPrev = "&nbsp;";
  }

  //페이지 목록
  btnPageList = "";
  for (int i = startPage; i <= endPage; i++) {
   if (currentPage == i) {
    btnPageList += "<b><a href=\"#\" align=\"center\" valign=\"middle\" class=\"text_05\">" + i + "</a></b>";
   } else {
    btnPageList += "<a href=\"javascript:go_Page('"+i+"')\" align=\"center\" valign=\"middle\" class=\"text_05\"> " + i + "</a>";
   }
   if (i < endPage) {
    btnPageList += "<img src=\"/spi/images/board/icon_pagingdot.jpg\" class=m_lr2>";
   }
  }

  //바로 다음 페이지 목록으로. (예: 다음 10 페이지로)
  int nextListPage = endPage + 1;
  if (nextListPage <= totalPage) {
   btnListNext = "&nbsp;<a href=\"javascript:go_Page('"+nextListPage+"')\"><img src=\"/spi/images/board/pag_f.jpg\" border=\"0\" class=\"m_lr5\" /></a>&nbsp;";
  } else {
   btnListNext = "&nbsp;";
  }

  //제일 마지막 페이지로.
  if (currentPage < totalPage) {
   btnEnd = "&nbsp;<a href=\"javascript:go_Page('"+totalPage+"')\"><img src=\"/spi/images/board/pag_ff.jpg\" border=\"0\" class=\"m_lr2\" /></a>";
  } else {
   btnEnd = "&nbsp;<a href=\"#\"><img src=\"/spi/images/board/pag_ff.jpg\" border=\"0\" class=\"m_lr2\" /></a>";
  }

  StringBuffer pageInfo = new StringBuffer();

  pb.setPageInfo(pageInfo.toString());

  StringBuffer pageHtml= new StringBuffer();

  pageHtml.append("<table width=\"100%\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">");
  pageHtml.append(" <tr>");
  pageHtml.append("  <td align=\"center\">" );
  pageHtml.append(   btnStart);
  pageHtml.append(   btnListPrev);
  pageHtml.append(   btnPageList);
  pageHtml.append(   btnListNext);
  pageHtml.append(   btnEnd);
  pageHtml.append("  </td>");
  pageHtml.append(" </tr>");
  pageHtml.append("</table>");

  pb.setPageHtml(pageHtml.toString());

  //페이징 처리 내용을 넘기기 위해 PagingBean에 처리한 값들을 담는다.
  pb.setTotalCount(totalCount);
  pb.setCurrentPage(currentPage);
  pb.setTotalPage(totalPage);
  pb.setStartPage(startPage);
  pb.setEndPage(endPage);
  pb.setStartNum(startNum);
  pb.setEndNum(endNum);
  pb.setBtnStart(btnStart);
  pb.setBtnEnd(btnEnd);
  pb.setBtnListPrev(btnListPrev);
  pb.setBtnListNext(btnListNext);
  pb.setBtnPageList(btnPageList);

  return pb;
 }

 public PagingBean pagingProcess2() throws Exception {

  PagingBean pb = new PagingBean();
 
 
 

  totalPage = (totalCount - 1) / listLimit + 1;
  startPage = ( (currentPage - 1) / pageLimit) * pageLimit + 1;
  endPage = startPage + pageLimit - 1;
 

  if (totalPage < endPage) {
  endPage = totalPage;
  }
  if (totalCount == 0) {
   totalPage = 0;
  }

  startNum = (currentPage - 1) * listLimit;
  endNum = listLimit;  
 

  //제일 처음 페이지로.
  if (currentPage > 1) {
   btnStart = "<a href=\"javascript:go_Page('1')\"><img src=\"/spi/images/board/button_start_be.gif\" border=\"0\" class=\"m_lr2\" /></a>&nbsp;";
  } else{
   //btnStart = "<a href=\"#\"><img src=\"/spi/images/board_img/button_start.gif\" border=\"0\" align=\"middle\" /></a>&nbsp;";
  }
 
 

  //이전 10 페이지
  int pretenpage = (currentPage/pageLimit-1)*10+1;
  if (pretenpage > 0) {
   btnListTenPrev += "<a href=\"javascript:go_Page('"+pretenpage+"')\"><img src=\"/spi/images/board/pag_rr.jpg\" border=\"0\" class=\"m_lr2\" /></a>&nbsp;";
  } else{
   //btnStart = "<a href=\"#\"><img src=\"/spi/images/board_img/button_start.gif\" border=\"0\" align=\"middle\" /></a>&nbsp;";
  } 

  //바로 이전 페이지 목록으로.
  //if (currentPage > pageLimit) {
  if (totalPage > 1) {
   int prevListPage = currentPage - 1;
   if(prevListPage < 1){
    //btnListPrev = "<a href=\"#\"><img src=\"/spi/images/board_img/button_pre.gif\" border=\"0\" align=\"middle\" /></a>&nbsp;&nbsp;&nbsp;&nbsp;";
   }else{
    btnListPrev = "<a href=\"javascript:go_Page('"+prevListPage+"')\"><img src=\"/spi/images/board/pag_r.jpg\" border=\"0\" class=\"m_lr5\" /></a>&nbsp;";
   }

  } else{
   btnListPrev = "&nbsp;";
  }

  //페이지 목록
  btnPageList = "";
  for (int i = startPage; i <= endPage; i++) {
   if (currentPage == i) {
    btnPageList += "<a href=\"#\" align=\"center\" valign=\"middle\" ><b>" + i + "</b></a>";
   } else {
    btnPageList += "<a href=\"javascript:go_Page('"+i+"')\" align=\"center\" valign=\"middle\">" + i + "</a>";
   }
   if (i < endPage) {
    btnPageList += "&nbsp;<img src=\"/spi/images/board/icon_pagingdot.jpg\" class=\"m_lr2\">";
   }
   if(endPage==1){
   }else{
    btnPageList += "&nbsp;";
   }
  } 

 
  //바로 다음 페이지 목록으로. (예: 다음 10 페이지로)  
  int nextListPage = currentPage + 1;
  if (nextListPage <= totalPage) {
   btnListNext = "<a href=\"javascript:go_Page('"+nextListPage+"')\"><img src=\"/spi/images/board/pag_f.jpg\" border=\"0\" class=\"m_lr5\" /></a>&nbsp;";
  } else {
   //btnListNext = "&nbsp;";
  }
 
  //다음 10 페이지
  int nexttenpage = (1+currentPage/pageLimit)*10+1;
  if (totalPage > nexttenpage) {
   btnListTenNext += "<a href=\"javascript:go_Page('"+nexttenpage+"')\"><img src=\"/spi/images/board/pag_ff.jpg\" border=\"0\" class=\"m_lr2\" /></a>&nbsp;";
  } else{
   //btnStart = "<a href=\"#\"><img src=\"/spi/images/board_img/button_start.gif\" border=\"0\" align=\"middle\" /></a>&nbsp;";
  } 

  //제일 마지막 페이지로.
  if (currentPage < totalPage) {
   btnEnd = "<a href=\"javascript:go_Page('"+totalPage+"')\"><img src=\"/spi/images/board/button_end_last.gif\" border=\"0\" class=\"m_lr2\" /></a>";
  } else {
   //btnEnd = "&nbsp;<a href=\"#\"><img src=\"/spi/images/board_img/button_end.gif\" border=\"0\" align=\"middle\" /></a>";
  }

  StringBuffer pageInfo = new StringBuffer();

  pb.setPageInfo(pageInfo.toString());

  StringBuffer pageHtml= new StringBuffer();

  pageHtml.append("<table width=\"100%\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">");
  pageHtml.append(" <tr>");
  pageHtml.append("  <td align=\"center\" >" );
  pageHtml.append(   btnStart);
  pageHtml.append(   btnListTenPrev);
  pageHtml.append(   btnListPrev);
  pageHtml.append(   btnPageList);
  pageHtml.append(   btnListNext);
  pageHtml.append(   btnListTenNext);
  pageHtml.append(   btnEnd);
  pageHtml.append("  </td>");
  pageHtml.append(" </tr>");
  pageHtml.append("</table>");

  pb.setPageHtml(pageHtml.toString());

  //페이징 처리 내용을 넘기기 위해 PagingBean에 처리한 값들을 담는다.
  pb.setTotalCount(totalCount);
  pb.setCurrentPage(currentPage);
  pb.setTotalPage(totalPage);
  pb.setStartPage(startPage);
  pb.setEndPage(endPage);
  pb.setStartNum(startNum);
  pb.setEndNum(endNum);
  pb.setBtnStart(btnStart);
  pb.setBtnEnd(btnEnd);
  pb.setBtnListPrev(btnListPrev);
  pb.setBtnListNext(btnListNext);
  pb.setBtnPageList(btnPageList);

  return pb;
 }
}

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

/**
 * 공통 String Util
 * org.apache.commons.lang.StringUtils 상속후 필요 메소드 추가
 * 자세한 기타 자세한 스펙은 org.apache.commons.lang.StringUtils 참조
 * (url : http://jakarta.apache.org/commons/lang/api-release/org/apache/commons/lang/StringUtils.html)
 */
public class StringUtil extends StringUtils {
 
 public static String nullToZero(String value){
  ;
  if(value == null || value.equals("")){
   value   =   "0";
  }
  return value;
 }
 
 
 
 /**
  * 문자열 좌측의 공백을 제거하는 메소드
  * @param  str 대상 문자열
  * @return trimed string with white space removed from the front.
  */
 public static String ltrim(String str){
  int len = str.length();
  int idx = 0;

  while ((idx < len) && (str.charAt(idx) <= ' '))
  {
   idx++;
  }
  return str.substring(idx, len);
 }

 /**
  * 문자열 우측의 공백을 제거하는 메소드
  * @param  str 대상 문자열
  * @return trimed string with white space removed from the end.
  */
 public static String rtrim(String str){
  int len = str.length();

  while ((0 < len) && (str.charAt(len-1) <= ' '))
  {
   len--;
  }
  return str.substring(0, len);
 }

 /**
  * String을
  * @param str
  * @return
  */
 public static String changeMoney(String str) {
  DecimalFormat df = new DecimalFormat("###,###");

  return df.format(parseInt(str));
 }

 /**
  * 파라미터로 넘어오는 String을 , 를 제거해준다.
  *
  * @param s java.lang.String
  * @return java.lang.String
  */
 public static String removeComma(String str) {
  String rtnValue = str;
  if ( isNull(str) ) {
   return "";
  }

  rtnValue = replace(rtnValue, ",", "");
  return rtnValue;
 }

 /**
  * 숫자 0이 넘어오면 ""로 대치
  * @param  int 대상 숫자
  * @return java.lang.String
  */
 public static String isOneNull(int num){
  if (num == 0) return "";
  else return Integer.toString(num);
 }
 
 /**
  * str이 null 이거나 "", "    " 일경우 return true
  * @param str
  * @return
  */
 public static boolean isNull(String str) {

  return (str == null || (str.trim().length()) == 0 );
 }

 public static boolean isNull(Object obj) {
  String str = null;
  if( obj instanceof String ) {
   str = (String)obj;
  } else {
   return true;
  }

  return isNull(str);
 }

 /**
  * null이 아닐때.
  * @param str
  * @return
  */
 public static boolean isNotNull(String str) {
  /**
   * isNull이 true이면 false
   * false이면 true
   */
  if( isNull(str) ){
   return false;

  } else {
   return true;
  }
 }

 /***
  * 널체크
  * @param obj
  * @return
  */
 public static boolean isNotNull(Object obj) {
  String str = null;
  if( obj instanceof String ) {
   str = (String)obj;
  } else {
   return false;
  }

  return isNotNull(str);
 }

 /**
  * 파라미터가 null 이거나 공백이 있을경우
  * "" 로 return
  * @param value
  * @return
  */
 public static String replaceNull(String value) {
  return replaceNull(value, "");
 }

 /**
  * Object를 받아서 String 형이 아니거나 NULL이면 ""를 return
  * String 형이면 형 변환해서 넘겨준다.
  * @param value
  * @return
  */
 public static String replaceNull(Object value) {
  Object rtnValue = value;
  if( rtnValue == null || !"java.lang.String".equals(rtnValue.getClass().getName())) {
   rtnValue = "";
  }

  return replaceNull((String)rtnValue, "");
 }

 /**
  * 파라미터로 넘어온 값이 null 이거나 공백이 포함된 문자라면
  * defaultValue를 return
  * 아니면 값을 trim해서 넘겨준다.
  * @param value
  * @param repStr
  * @return
  */
 public static String replaceNull(String value, String defaultValue) {
  if (isNull(value)) {
   return defaultValue;
  }

  return value.trim();
 }

 /**
  * Object를 받아서 String 형이 아니거나 NULL이면 defaultValue를 return
  * String 형이면 형 변환해서 넘겨준다.
  * @param value
  * @param repStr
  * @return
  */
 public static String replaceNull(Object value, String defaultValue) {
  String valueStr = replaceNull(value);
  if ( isNull(valueStr) ) {
   return defaultValue;
  }

  return valueStr.trim();
 }

 /**
  * Method ksc2asc.
  * 8859-1를 euc-kr로 인코딩하는 함수
  * @param str - String
  * @return String
  */
 public static String ksc2asc(String str) {
  String result = "";

  if (isNull(str)) {
   result = "";
  } else {
   try {
    result = new String( str.getBytes("euc-kr"), "8859_1" );
   } catch( Exception e ) {
    result = "";
   }
  }

  return result;
 }

 /**
  * Method asc2ksc.
  * euc-kr을 8859-1로 인코딩하는 함수
  * @param str - String
  * @return String
  */
 public static String asc2ksc(String str) {
  String result = "";

  if (isNull(str)) {
   result = "";
  } else {
   try {
    result = new String( str.getBytes("8859_1"), "euc-kr" );
   } catch( Exception e ) {
    result = "";
   }
  }

  return result;
 }

 /**************************************************************************************/
 /* parse method start */

 /**
  * String을 int형으로
  * @param value
  * @return
  */
 public static int parseInt(String value) {
  return parseInt(value, 0);
 }
 /**
  * Object를 int형으로
  * defaultValue는 0이다.
  * @param value
  * @return
  */
 public static int parseInt(Object value) {
  String valueStr = replaceNull(value);
  return parseInt(valueStr, 0);
 }
 /**
  * Object를 int형으로
  * Object가 null이면 defaultValue return
  * @param value
  * @param defaultValue
  * @return
  */
 public static int parseInt(Object value, int defaultValue) {
  String valueStr = replaceNull(value);
  return parseInt(valueStr, defaultValue);
 }
 /**
  * String을 int형으로
  * String이 숫자 형식이 아니면 defaultValue return
  * @param value
  * @param defaultValue
  * @return
  */
 public static int parseInt(String value, int defaultValue) {
  int returnValue = 0;

  if( isNull(value) ) {
   returnValue = defaultValue;
  } else if( !isNumeric(value) ) {
   returnValue = defaultValue;
  } else {
   returnValue = Integer.parseInt(value);
  }

  return returnValue;
 }

 /**
  * String을 long형으로
  * defaultValue는 0이다.
  * @param value
  * @return
  */
 public static long parseLong(String value) {
  return parseLong(value, 0);
 }

 /**
  * String을 long형으로
  * 잘못된 데이타 일시 return은 defaultValue
  * @param value
  * @return
  */
 public static long parseLong(String value, long defaultValue) {
  long returnValue = 0;

  if( isNull(value) ) {
   returnValue = defaultValue;
  } else if( !isNumeric(value) ) {
   returnValue = defaultValue;
  } else {
   returnValue = Long.parseLong(value);
  }

  return returnValue;
 }

 /**
  * Exception을 String으로 뽑아준다.
  * @param ex
  * @return
  */
 public static String stackTraceToString(Throwable e) {
  try {
   StringWriter sw = new StringWriter();
   PrintWriter pw = new PrintWriter(sw);
   e.printStackTrace(pw);
   return "------\r\n" + sw.toString() + "------\r\n";
   }catch(Exception e2) {
    return StringUtil.stackTraceToString2(e);
   }
 }
 /**
  * Exception을 String으로 뽑아준다.
  * @param ex
  * @return
  */
 public static String stackTraceToString2(Throwable e) {
  ByteArrayOutputStream b = new ByteArrayOutputStream();
  PrintStream p = new PrintStream(b);
  e.printStackTrace(p);
  p.close();
  String stackTrace = b.toString();
  try {
   b.close();
  } catch (IOException ex) {
   ex.printStackTrace();
  }

//  return convertHtmlBr(stackTrace);
  return stackTrace;
 }

 /**
  * Html 코드에서 &#60;br&#62; 태크 제거
  * @param comment
  * @return
  */
 public static String convertHtmlBr(String comment) {
  String rtnValue = "";
  if( isNull(comment) ) {
   return "";
  }

  rtnValue = replace(comment, "\r\n", "<br>");

  return rtnValue;
 }

 /**
  * String 배열을 List로 변환한다.
  * @param values
  * @return
  */
 public static List changeList(String [] values) {
  List list = new ArrayList();

  if( values == null ) {
   return list;
  }
  for(int i=0,n=values.length; i<n; i++) {
   list.add(values[i]);
  }

  return list;
 }

 public static String[] toTokenArray(String str, String sep){

  String[] temp = null;

  try{
   StringTokenizer st = new StringTokenizer(str, sep);
   temp = new String[st.countTokens()];
   int index = 0;
   while(st.hasMoreTokens()){
    temp[index++] = st.nextToken();
   }
  }catch(Exception e){
   e.printStackTrace();
  }

  return temp;
 }
    public static String strip(String str, String str1){

     if(str == null || "".equals(str.trim())) return "";

     String temp = str;
  int pos = -1;
  while((pos = temp.indexOf(str1, pos)) != -1) {
   String left = temp.substring(0, pos);
   String right = temp.substring(pos + 1, temp.length());
   temp = left + "" + right;
   pos += 1;
  }
  return temp;
    }

    /**
  * Method ksc2asc.
  * euc-kr을 euc-kr로 인코딩하는 함수
  * @param str - String
  * @return String
  */
 public static String ksc2utf8(String str) {
  String result = "";

  if (isNull(str)) {
   result = "";
  } else {
   try {
    result = new String( str.getBytes("euc-kr"), "utf-8" );
   } catch( Exception e ) {
    result = "";
   }
  }

  return result;
 }

 /**
  * string에 있는 ', ", \r\n 를 HTML 코드로 변환한다.
  * @param str
  * @return
  */
 public static String changeQuotation(String str) {
  String rtnValue = str;
  rtnValue = replaceNull(rtnValue);
  rtnValue = replace(replace(replace(rtnValue, "'", "&#39;"), "\"", "&#34;"), "\r\n", "<br>");

  return rtnValue;
 }
 public static String changeQuotation(Object obj) {
  if( isStringInteger(obj) ) {
   return changeQuotation(String.valueOf(obj));
  }

  return "";
 }

 /**
  * 해당 Object가 String or Integer 이면 true
  * 아니면 false
  * @param obj
  * @return
  */
 public static boolean isStringInteger(Object obj) {

  boolean flag = false;

  if( obj instanceof String || obj instanceof Integer ) {
   flag = true;
  }

  return flag;
 }

 /**
  * 백분율을 구한다.
  * %는 빼고 값만 리턴
  * @param value
  * @param total
  * @return
  */
 public static String percentValue(int value, int total) {
  double val = Double.parseDouble(String.valueOf(value)) / Double.parseDouble(String.valueOf(total)) * 100;

  DecimalFormat df = new DecimalFormat("##0.0");
  return df.format(val);
 }

 /**
  *  XSS(Cross Site Scripting) 취약점 해결을 위한 처리
  *
  * @param sourceString String 원본문자열
  * @return String 변환문자열
  */
 public static String replaceXSS(String sourceString){
  String rtnValue = null;
  if(sourceString!=null){
   rtnValue = sourceString;
   if(rtnValue.indexOf("<x-") == -1){
    rtnValue = rtnValue.replaceAll("< *(j|J)(a|A)(v|V)(a|A)(s|S)(c|C)(r|R)(i|I)(p|P)(t|T)", "<x-javascript");
    rtnValue = rtnValue.replaceAll("< *(v|V)(b|B)(s|S)(c|C)(r|R)(i|I)(p|P)(t|T)", "<x-vbscript");
    rtnValue = rtnValue.replaceAll("< *(s|S)(c|C)(r|R)(i|I)(p|P)(t|T)", "<x-script");
    rtnValue = rtnValue.replaceAll("< *(i|I)(f|F)(r|R)(a|A)(m|M)(e|E)", "<x-iframe");
    rtnValue = rtnValue.replaceAll("< *(f|F)(r|R)(a|A)(m|M)(e|E)", "<x-frame");
    rtnValue = rtnValue.replaceAll("(e|E)(x|X)(p|P)(r|R)(e|E)(s|S)(s|S)(i|I)(o|O)(n|N)", "x-expression");
    rtnValue = rtnValue.replaceAll("(a|A)(l|L)(e|E)(r|R)(t|T)", "x-alert");
    rtnValue = rtnValue.replaceAll(".(o|O)(p|P)(e|E)(n|N)", ".x-open");
    rtnValue = rtnValue.replaceAll("< *(m|M)(a|A)(r|R)(q|Q)(u|U)(e|E)(e|E)", "<x-marquee");
    rtnValue = rtnValue.replaceAll("&#", "&amp;#");
   }
  }

  return rtnValue;
    }

 /**
  * 특정문자를 HTML TAG형식으로 변경하는 메소드.
  *
  * <xmp>
  * & --> &amp;
  * < --> &lt;
  * > --> &gt;
  * " --> &quot;
  * ' --> &#039;
  *-----------------------------------------------------------------
  * <option type=radio  name=r value="xxxxxxxx"> yyyyyyy
  * <input  type=hidden name=h value="xxxxxxxx">
  * <input  type=text   name=t value="xxxxxxxx">
  * <textarea name=msg rows=20 cols=53>xxxxxxx</textarea>
  *-
  * 위와 같은 HTML 소스를 생성할 때, xxxxxxx 부분의 문자열 중에서
  * 아래에 있는 몇가지 특별한 문자들을 변환하여야 합니다.
  * 만약 JSP 라면 미리 변환하여 HTML 전체 TAG를 만들거나, 혹은 아래처럼 사용하세요.
  *-
  * <option type=radio  name=r value="<%= StringUtil.translate(s) %>"> yyyyyyy
  * <input  type=hidden name=n value="<%= StringUtil.translate(s) %>">
  * <input  type=text   name=n value="<%= StringUtil.translate(s) %>">
  * <textarea name=body rows=20 cols=53><%= StringUtil.translate(s) %></textarea>
  *-
  * 또 필요하다면 yyyyyyy 부분도  translate(s)를 할 필요가 있을 겁니다.
  * 필요할 때 마다 사용하세요.
  *-
  * </xmp>
  *
  * @return the translated string.
  * @param str java.lang.String
  */
 public static String translate(String str){
  if ( str == null ) return null;

  StringBuffer buf = new StringBuffer();
  char[] c = str.toCharArray();
  int len = c.length;

  for ( int i=0; i < len; i++){
   if      ( c[i] == '&' ) buf.append("&amp;");
   else if ( c[i] == '<' ) buf.append("&lt;");
   else if ( c[i] == '>' ) buf.append("&gt;");
   else if ( c[i] == '"' ) buf.append("&quot;"); // (char)34
   else if ( c[i] == '\'') buf.append("&#039;"); // (char)39
   else buf.append(c[i]);
  }
  return buf.toString();
 }

   /**
    * String 앞 또는 뒤를 특정문자로 지정한 길이만큼 채워주는 함수    <BR>
    * (예) pad("1234","0", 6, 1) --> "123400"   <BR>
    *
    * @param    src  Source string
    * @param    pad  pad string
    * @param    totLen     total length
    * @param    mode     앞/뒤 구분 (-1:front, 1:back)
    * @return   String
    */
 public static String pad(String src, String pad, int totLen, int mode){
  String paddedString = "";

  if(src == null) return "";
  int srcLen = src.length();

  if((totLen<1)||(srcLen>=totLen)) return src;

  for(int i=0; i< (totLen-srcLen); i++){
   paddedString += pad;
  }

  if(mode == -1)
   paddedString += src; // front padding
  else
       paddedString = src + paddedString; //back padding

  return paddedString;
 }

 /**
  * 주어진 길이(iLength)만큼 주어진 문자(cPadder)를 strSource의 왼쪽에 붙혀서 보내준다.
  * ex) lpad("abc", 5, '^') ==> "^^abc"
  *     lpad("abcdefghi", 5, '^') ==> "abcde"
  *     lpad(null, 5, '^') ==> "^^^^^"
  *
  * @param strSource
  * @param iLength
  * @param cPadder
  */
 public static String lpad(String strSource, int iLength, char cPadder){
  StringBuffer sbBuffer = null;

  if (!isEmpty(strSource)){
   int iByteSize = getByteSize(strSource);
   if (iByteSize > iLength){
    return strSource.substring(0, iLength);
   }else if (iByteSize == iLength){
    return strSource;
   }else{
    int iPadLength = iLength - iByteSize;
    sbBuffer = new StringBuffer();
    for (int j = 0; j < iPadLength; j++){
     sbBuffer.append(cPadder);
    }
    sbBuffer.append(strSource);
    return sbBuffer.toString();
   }
  }

  //int iPadLength = iLength;
  sbBuffer = new StringBuffer();
  for (int j = 0; j < iLength; j++){
   sbBuffer.append(cPadder);
  }
  return sbBuffer.toString();
 }

 /**
  * 주어진 길이(iLength)만큼 주어진 문자(cPadder)를 strSource의 오른쪽에 붙혀서 보내준다.
  * ex) lpad("abc", 5, '^') ==> "abc^^"
  *     lpad("abcdefghi", 5, '^') ==> "abcde"
  *     lpad(null, 5, '^') ==> "^^^^^"
  *
  * @param strSource
  * @param iLength
  * @param cPadder
  */
 public static String rpad(String strSource, int iLength, char cPadder){
  StringBuffer sbBuffer = null;
   if (!isEmpty(strSource)){
   int iByteSize = getByteSize(strSource);
   if (iByteSize > iLength){
    return strSource.substring(0, iLength);
   }else if (iByteSize == iLength){
    return strSource;
   }else{
    int iPadLength = iLength - iByteSize;
    sbBuffer = new StringBuffer(strSource);
    for (int j = 0; j < iPadLength; j++){
     sbBuffer.append(cPadder);
    }
    return sbBuffer.toString();
   }
  }
  sbBuffer = new StringBuffer();
  for (int j = 0; j < iLength; j++){
   sbBuffer.append(cPadder);
  }
  return sbBuffer.toString();
 }

 /**
  *  byte size를 가져온다.
  *
  * @param str String target
  * @return int bytelength
  */
 public static int getByteSize(String str){
  if (str == null || str.length() == 0)
   return 0;
  byte[] byteArray = null;
   try{
   byteArray = str.getBytes("UTF-8");
  }catch (UnsupportedEncodingException ex){}
  if (byteArray == null) return 0;
  return byteArray.length;
 }
      /**
     * 긴 문자열 자르기
     * @param srcString      대상문자열
     * @param nLength        길이
     * @param isNoTag        테그 제거 여부
     * @param isAddDot        "..."을추가 여부
     * @return
     */
    public static String strCut(String srcString, int nLength, boolean isNoTag, boolean isAddDot){  // 문자열 자르기
        String rtnVal = srcString;
        int oF = 0, oL = 0, rF = 0, rL = 0;
        int nLengthPrev = 0;

        // 태그 제거
        if(isNoTag) {
            Pattern p = Pattern.compile("<(/?)([^<>]*)?>", Pattern.CASE_INSENSITIVE);  // 태그제거 패턴
            rtnVal = p.matcher(rtnVal).replaceAll("");
        }
        rtnVal = rtnVal.replaceAll("&amp;", "&");
        rtnVal = rtnVal.replaceAll("(!/|\r|\n|&nbsp;)", "");  // 공백제거
        try {
         byte[] bytes = rtnVal.getBytes("UTF-8");     // 바이트로 보관
         // x부터 y길이만큼 잘라낸다. 한글안깨지게.
         int j = 0;
         if(nLengthPrev > 0) while(j < bytes.length) {
          if((bytes[j] & 0x80) != 0) {
           oF+=2; rF+=3; if(oF+2 > nLengthPrev) {break;} j+=3;
             } else {if(oF+1 > nLengthPrev) {break;} ++oF; ++rF; ++j;}
         }

         j = rF;

         while(j < bytes.length) {
          if((bytes[j] & 0x80) != 0) {
           if(oL+2 > nLength) {break;} oL+=2; rL+=3; j+=3;
             } else {if(oL+1 > nLength) {break;} ++oL; ++rL; ++j;}
         }

         rtnVal = new String(bytes, rF, rL, "UTF-8");  // charset 옵션

         if(isAddDot && rF+rL+3 <= bytes.length) {rtnVal+="...";}  // ...을 붙일지말지 옵션
        } catch(UnsupportedEncodingException e){
         e.printStackTrace();
         return srcString;
        }

     return rtnVal;
    }
   
    /**
     * total과 success 로 % 구하고 소수점 1자리까지 계산
     * @param int success     
     * @param int total      

     * @return String %
     */
    public static String calculatePercent(int success,int total){
     String result   =  "0";
     
     if(total == 0){
       
     
     }else{
     
        Double tempSuccess  = new Double(success+".0");
        Double tempTotal    = new Double(total+".0");
        Double tempPercent   = new Double(100+".0");
     
        double cal =  tempSuccess.doubleValue()*tempPercent.doubleValue()/tempTotal.doubleValue();
     
      result = new java.text.DecimalFormat("#.#").format(cal);
     
     }
     
     return result;
    }

}


출처 : http://shonm.tistory.com/177?srchid=BR1http%3A%2F%2Fshonm.tistory.com%2F177

import org.jfree.chart.JFreeChart;

import com.opensymphony.xwork2.ActionSupport;
import chart.model.dao.ChartDAO;
import chart.model.dto.ChartDTO;
import chart.poll.PollChart;

public class RegisterAction extends ActionSupport {

 public static final long serialVersionUID = 1L;
 
 /*property fields*/
 private int answer;
 private ChartDTO dto;
 private JFreeChart chart;
 
 public JFreeChart getChart(){          //action mapping 의 result로 데이터를 보내야 하기 때문에 JFreeChart로 리턴한다.
  return chart;
 }
 
 @Override
 public String execute()throws Exception {
  dto = new ChartDTO();
  calc();                                        //jsp페이지의 radio 버튼으로 들어오는 오는 값을 세팅 시켜준다.
  ChartDAO dao = new ChartDAO();
  dao.update(dto);                          //DB에 데이터 업데이트
  //list query
  dto = dao.list(dto);                        //DB에 있는 데이터 가져옴
  //chart 정보 가져옴
  chart = PollChart.getPie3dChart(dto);  // 실질적 차트를 생성하는 부분
  return SUCCESS;
 }

 public void calc(){
  switch(answer){
   case 1 : dto.setAnswer1(1);break;
   case 2 : dto.setAnswer2(1);break;
   case 3 : dto.setAnswer3(1);break;
   case 4 : dto.setAnswer4(1);
  }
  dto.setTot(1);
 }
 
 public int getAnswer() {
  return answer;
 }

 public void setAnswer(int answer) {
  this.answer = answer;
 }

}
----------------------------------------------------------------------------------------------------------

PollChart class

----------------------------------------------------------------------------------------------------------
package chart.poll;

import org.jfree.chart.JFreeChart;
//import org.jfree.chart.ChartFactory;
import org.jfree.chart.plot.PiePlot3D;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.category.DefaultCategoryDataset;
//import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.entity.StandardEntityCollection;
import chart.model.dto.ChartDTO;
import java.io.File;

import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.axis.CategoryAxis3D;
import org.jfree.chart.axis.NumberAxis3D;
import org.jfree.chart.renderer.category.BarRenderer3D;

public class PollChart {
 
 
 
 /*pie 3D chart*/
 public static JFreeChart getPie3dChart(ChartDTO dto)throws Exception {
 
  String path="D://JAVA/java document/web 2/workspace/struts2/WebContent/chart_images/pie3d.png";  //이미지 파일을 저장할 경로 설정
  JFreeChart chart = null;
// 차트에 삽입할 데이터를 집어 넣는다.
  DefaultPieDataset dataset = new DefaultPieDataset();
  dataset.setValue("1번("+dto.getAnswer1()+"명)", dto.getAnswer1());
  dataset.setValue("2번("+dto.getAnswer2()+"명)", dto.getAnswer2());
  dataset.setValue("3번("+dto.getAnswer3()+"명)", dto.getAnswer3());
  dataset.setValue("4번("+dto.getAnswer4()+"명)", dto.getAnswer4());
  PiePlot3D plot = new PiePlot3D(dataset);         //값을 넣어서 3DChart를 생성한다.
  chart = new JFreeChart(
     "설문조사 통계",
     JFreeChart.DEFAULT_TITLE_FONT,
     plot,
     true
          ); //true는 범례설정
  plot.setOutlineVisible(false);  //사각 테두리 사용하지 않음
  chart.setBackgroundPaint(java.awt.Color.WHITE); //background color설정
  new PollChart().createImage(path, chart);   //png파일로 저장해서 저장한 폴더위치에 저장하자
 
  return chart;
 }
 
 /*bar 3D chart*/
 public static JFreeChart getBar3dChart(ChartDTO dto)throws Exception {
  String path="D://JAVA/java document/web 2/workspace/struts2/WebContent/chart_images/bar3d.png";
  JFreeChart chart = null;
  DefaultCategoryDataset dataset = new DefaultCategoryDataset();
  dataset.setValue(dto.getAnswer1(), "1번", "1번("+dto.getAnswer1()+"명)");
  dataset.setValue(dto.getAnswer2(), "2번", "2번("+dto.getAnswer2()+"명)");
  dataset.setValue(dto.getAnswer3(), "3번", "3번("+dto.getAnswer3()+"명)");
  dataset.setValue(dto.getAnswer4(), "4번", "4번("+dto.getAnswer4()+"명)");
  /*
  chart = ChartFactory.createBarChart3D(
    "설문조사 통계",
    "선택항목",
    "인원수",
    dataset,
    PlotOrientation.VERTICAL,
    true, false, false);
  */
  CategoryAxis3D axis = new CategoryAxis3D("선택항목");
  NumberAxis3D numAxis = new NumberAxis3D("인원수");
  BarRenderer3D renderer = new BarRenderer3D(35.0,10.0);
  renderer.setItemMargin(0.10);
  renderer.setShadowVisible(true);
  CategoryPlot plot = new CategoryPlot(dataset,axis,numAxis, renderer);
  chart = new JFreeChart(
    "설문조사 통계",
    JFreeChart.DEFAULT_TITLE_FONT,
    plot,
    false
  );
  chart.setBackgroundPaint(java.awt.Color.WHITE);
  new PollChart().createImage(path, chart);
  return chart;
 }
 
 /*image 생성부분*/
 public void createImage(String file, JFreeChart chart)throws Exception {
  ChartRenderingInfo info = new ChartRenderingInfo(
                      new StandardEntityCollection());
  ChartUtilities.saveChartAsPNG(new File(file), chart, 380, 300, info);
 }

}

----------------------------------------------------------------------------------------------------------
사진 파일을 저장할 위치를 프로젝트가 접근 가능한 폴더에 넣어야 jsp페이지에서 링크 걸때 정확하게 걸린다.


출처 : http://javastore.tistory.com/53

Jdk 5.0 에서 새로 선보인 (Annotation) 어노테이션 이라는 겁니다.

자바 언어로 표현할수 없지만 프로그램 전체적으로 표현해야할 테이터를 기술하는 방법을 제공하죠.

다시말하면, 어노테이션을 사용하면 프로그램에서 컴파일러가 테스트하고 검증해야하는 부가 정보를 정해진

형식으로 설명하는 것이 가능하게 됩니다. 또한 설명 파일이나 새로운 클래스 정의를 생성하여 공통코드를

작성하는 부담을 줄이는 용도로도 활용할 수 있죠.

가장 자주 쓰이는 어노테이션은

@Override

 : 기반 클래스의 메소드를 오버라이드한 것을 표시한다. 메소드 이름을 잘못 표기하거나 시그니처를 잘못 지정할

경우 컴파일 에러 발생

@Deprecated

 : 해당 요소가 사용될 경우 컴파일러가 경고를 발생 시킨다.

@SuppressWarning

 : 부적절한 컴파일러의 경고를 제거하기 위해 사용된다.

음..어노테이션은 자바 고급기술에 속하는 편이어서 그냥 이런게 있구나 하고 넘어가셔도 무방합니다만

좀더 자세히 알고 싶으시면 관련서적을 보시거나 검색해보시는 편이 나으실 겁니다^^


출처 : http://ydeity.tistory.com/tag/@SuppressWarnings

출처 : http://fendee.egloos.com/8682738

윤년이 되려면,

1.연도가 4 로 나누어 떨어질것
2.단, 100으로 나누어 떨어지는 해는 제외한다.
3.400으로 나누어 떨어지는 해는 윤년이다.

이것을 공식으로 처리하면,(변수 year 는 연도)

(year % 4 == 0 && year % 100 !=0) || (year % 400 == 0)

현재 년도를 year 에 대입한후, 위 식의 값이 true 이면 윤년이고, false 이면 윤년이 아니다.

java.util.Calendar 를 이용한, 날짜 출력 및 윤년계산

<a.java>

import java.io.*;
import java.util.*;
import java.util.Calendar;

public class a
{
  public static void main(String [] args)
  {
    Date today = new Date();
    System.out.println(today);

    Calendar cal = Calendar.getInstance();
   
    int year = cal.get(cal.YEAR);  //YEAR 는 모두 대문자로 써야한다.
    // 또는 cal.get(Calendar.YEAR);
    int year2 = cal.get(Calendar.YEAR);
    System.out.println("다른 방식:" + year2);
   
    System.out.println(year);
    int mont = cal.get(cal.MONTH) + 1;  //MONTH 는 모두 대문자로 써야한다.(월에는 1을 더해줘야 한다.)
    System.out.println(mont);
    int dat = cal.get(cal.DATE); //DATE 는 모두 대문자로 써야한다.
    System.out.println(dat);
           
    System.out.println("오늘은 " + year + "년 " + mont + "월 " + dat + "일 입니다");
   
    int weeknum = cal.get(cal.DAY_OF_WEEK);
    String weekstr = "00";
    switch(weeknum){
      case 1 : weekstr = "일"; break;
      case 2 : weekstr = "월"; break;
      case 3 : weekstr = "화"; break;
      case 4 : weekstr = "수"; break;
      case 5 : weekstr = "목"; break;
      case 6 : weekstr = "금"; break;
      case 7 : weekstr = "토"; break;
    }
    System.out.println(weekstr + "요일");
   
    int hour = cal.get(cal.HOUR);
    int min = cal.get(cal.MINUTE);
    int sec = cal.get(cal.SECOND);
    String thistime = hour + ":" + min + ":" + sec;
   
    System.out.println("현재시각은 " + thistime + " 입니다");
   
   
    //(year % 4 == 0 && year % 100 !=0) || (year % 400 == 0)
    if((year % 4 == 0 && year % 100 !=0) || (year % 400 == 0)){
      System.out.println("올해는 윤년입니다");
    }else{
      System.out.println("올해는 윤년이 아닙니다");
    }
  }
}

출처 : http://theeye.pe.kr/82

게시판에서 쓸만한 페이징 클래스를 제작해 보았다. 문제 발견시 피드백 부탁드립니다^^

guide.txt

public class PageNavigation {
    
    private        boolean        isPrevPage;
    private        boolean        isNextPage;
    protected    int            nowPage;
    protected    int            rowTotal;
    protected    int            blockList;
    protected    int            blockPage;
    private        int            totalPage;
    private        int            startPage;
    private        int            endPage;
    private        int            startRow;
    private        int            endRow;
    
    // 페이지를 계산하는 생성자
    public PageNavigation(int nowPage, int rowTotal, int blockList, int blockPage) {
        super();
        
        // 각종 플래그를 초기화
        isPrevPage = false;
        isNextPage = false;
        
        // 입력된 전체 열의 수를 통해 전체 페이지 수를 계산한다
        this.totalPage    = (int) Math.ceil((double)rowTotal / (double)blockList);
        
        // 현재 페이지가 전체 페이지수보다 클경우 전체 페이지수로 강제로 조정한다
        if(nowPage > this.totalPage)
        {
            nowPage = this.totalPage;
        }
        
        // DB입력을 위한 시작과 종료값을 구한다
        this.startRow    = (int) (nowPage - 1) * blockList;
        this.endRow        = (int) this.startRow + blockList - 1;
        
        // 시작페이지와 종료페이지의 값을 구한다
        this.startPage    = (int) ((nowPage - 1) / blockPage) * blockPage + 1;
        this.endPage    = (int) this.startPage + blockPage - 1;
        
        // 마지막 페이지값이 전체 페이지값보다 클 경우 강제 조정
        if(this.endPage > this.totalPage)
        {
            this.endPage = totalPage;
        }
        
        // 시작 페이지가 1보다 클 경우 이전 페이징이 가능한것으로 간주한다
        if(this.startPage > 1)
        {
            this.isPrevPage = true;
        }
        
        // 종료페이지가 전체페이지보다 작을경우 다음 페이징이 가능한것으로 간주한다
        if(this.endPage < this.totalPage)
        {
            this.isNextPage = true;
        }
        
        // 기타 값을 저장한다
        this.nowPage = nowPage;
        this.rowTotal = rowTotal;
        this.blockList = blockList;
        this.blockPage = blockPage;
    }
    
    public void Debug()
    {
        System.out.println("Total Page : " + this.totalPage + " / Start Page : " + this.startPage + " / End Page : " + this.endPage);
        System.out.println("Total Row : " + this.rowTotal + " / Start Row : " + this.startRow + " / End Row : " + this.endRow);
    }
    
    // 전체 페이지 수를 알아온다
    public int getTotalPage() 
    {
        return totalPage;
    }
    
    // 시작 Row값을 가져온다
    public int getStartRow()
    {
        return startRow;
    }
    
    // 마지막 Row값을 가져온다
    public int getEndRow()
    {
        return endRow;
    }
    
    // Block Row 크기를 가져온다
    public int getBlockSize()
    {
        return blockSize;
    }
    
    // 시작페이지값을 가져온다
    public int getStartPage()
    {
        return startPage;
    }
 
    // 마지막 페이지값을 가져온다
    public int getEndPage()
    {
        return endPage;
    }
    
    // 이전페이지의 존재유무를 가져온다
    public boolean isPrevPage()
    {
        return isPrevPage;
    }
    
    // 다음페이지의 존재유무를 가져온다
    public boolean isNextPage()
    {
        return isNextPage;
    }
}

---------------------------------------------------------------------------------------
서블릿(Controller) 소스코드 :
---------------------------------------------------------------------------------------

// 리스트를 가져온다
if(request.getParameter("page") == null)
{
    nowPage = 1;
}
else
{
    nowPage = Integer.parseInt(request.getParameter("page"));
    
    if(nowPage < 1)
    {
        nowPage = 1;
    }
}
 
// 객체를 생성한다 (현재페이지, 전체글수, 페이지당표시할 글의수, 한번에 표시할 페이징블록수)    
PageNavigation pageNav = new PageNavigation(nowPage, rowTotal, 10, 5);
 
// 디버깅이 필요할시 사용한다. 안써도 됨
pageNav.Debug();
 
// 시작Row값과 종료Row값을 넣어 쿼리문을 작성한다
sql = "SELECT * FROM TableName ORDER BY no DESC LIMIT " + pageNav.getStartRow() + ", " + pageNav.getBlockSize();
 
// 뷰에게 넘길 값을 지정한다
request.setAttribute("pageIsPrev",    pageNav.isPrevPage());    // 이전페이지 블록의 존재유무
request.setAttribute("pageIsNext",    pageNav.isNextPage());    // 다음페이지 블록의 존재유무
request.setAttribute("pageStart",    pageNav.getStartPage());// 시작페이지 번호
request.setAttribute("pageEnd",        pageNav.getEndPage());    // 종료페이지 번호

---------------------------------------------------------------------------------------
jsp(View) 소스코드(EL표기법, JSTL사용) :
---------------------------------------------------------------------------------------

<div>
    <center>
        <c:if test="${pageIsPrev}">
            <a href="index.do?page=${pageStart - 1}">prev</a>
        </c:if>
        <c:forEach var="page" begin="${pageStart}" end="${pageEnd}">
            <a href="index.do?page=${page}">[${page}] </a>
        </c:forEach>
        <c:if test="${pageIsNext}">
            <a href="index.do?page=${pageEnd + 1}">next</a>
        </c:if>
    </center>
</div>

0. 지혜롭게 살자
많은 개발자가 전통적(?)인 방법인 System.out....로 디버깅을 많이 하고 있다. 물론 이것처럼 확실한 방법도 없지만 eclipse나 다른 IDE의 디버그 기능을 이용하면 훨씬 빨리 문제를 찾을 수 있다.
특히 WAS에 배포된 환경에서 이런 방법으로 하려면 확인하기 위한 System.out...을 고칠 때마다 배포해야 하는데 이건 너무 고통스러운 작업이다.

단위 테스트시 에러가 발생했을 때는 eclipse등을 이용해서 디버깅하기가 수월하다.
그러나 WAS에 배포된 후에 에러가 발생했을 때는 약간의 작업이 필요하다. WAS를 eclipse에 embeded한 플러그인을 이용하는 방법도 있지만 WAS와 이클립스를 따로 띄워 원격으로 버그를 찾는 방법을 정리한다.
이럴 경우 서버환경에서 돌아가는 자바 코드의 문제점도 쉽게 잡을 수 있다. (물론 절대! 운영서버에서 하면 안되겠지만)

여기서는 tomcat 6와 eclipse 3.3 그리고 java6 환경을 가정하고 설명한다. (그 하위 버전도 방법은 동일하다)

1. 문제지점 찾기
WAS에서 애플리케이션을 배포하고 돌려보니 에러가 발생하고 아래와 같은 예외스택을 출력했다.

이걸보면 JDBCCredentialsSPI.java 소스의 32 라인에서 null 객체를 참조하여 뭔가를 했다는 것을 짐작할 수 있다. 그럼 그 소스를 볼까?

아~ 한 줄에 많은 것들이 있네 ㅠㅠ. 이중 어떤 객체가 null 인지 알 수가 있나. 좀 고생하겠는데...

2. 디버깅을 걸자 (가장 중요)
다음과 같은 JVM 옵션을 사용하면 JVM을 기동할 때 디버그 모드로 기동되고 원격에서 그 디버그 세션으로 접속할 수 있다.

이는 8000 소켓으로 디버그 세션을 열어두겠다는 뜻이다.

내 경우 Tomcat을 사용하기에 다음과 같이 JAVA_OPTS의 환경변수에 저 옵션을 설정했다. Tomcat은 JAVA_OPTS 환경변수를 이용하여 JVM을 기동한다.

시작쯤에 다음과 같은 라인이 출력되면서 기동되면 성공한 것이다.

각 WAS에 -Xdebug ... 옵션을 설정하는 것은 조금씩 다르다. 각 WAS의 shell 스크립트를 살펴보고 적당한 환경변수를 주거나 직접 java 실행하는 부분에서 저 옵션을 추가하면 된다.
참고로 Maven 2로 개발할 경우 mvn jetty:run으로 WAS를 띄울 경우가 있는데 이런 경우는 다음과 같은 환경변수를 설정하고 띄우면 된다.

3. JVM 디버깅 세션에 연결
이클립스에서 디버깅 세션을 열기 위해서는 다음 단계를 따라하면 된다. 물론 디버깅하기 위한 소스는 이클립스 프로젝트에 있다고 가정한다. 프로젝트를 선택한 상태에서 디버그를 시작하는 것을 있지 말라.

"Run > Open Debug Dialog..." 메뉴를 선택하면 아래와 같은 Debug 다이얼로그가 나타난다.

자바도 간단히 exe파일로 실행할 수 있다? 없다?

답은 있다!!

간단한 프로젝트 수행과정에서 실행파일을 exe로 해주세요 라는 요구에 이런저런 자료를 찾다가 드뎌 찾았다.
도움을 주신 승용이형 감솨~!

필요한 파일 : jsmooth (압축파일은 제일 하단에 첨부해 놨으니 모두읽어보신 후에 다운바드세요);;

먼저 C:\Test 폴더에 패키지 및 Class 파일이 있다는 가정하에 진행하겠다.

1. jar 파일을 생성한다.

2. jar 파일에 main 클래스를 지정한다.

3. jsmooth 파일을 이용해서 jar 파일을 exe 파일로 변환한다.

1. jar 파일을 생성한다.

jar

jar 프로그램의 기본적인 명령 순서는 다음과 같다.
jar <option> <target_file> <src_files>

[명령 프롬프트]

C:\Test>jar cvf ImageViewer.jar .

(마지막 점(dot)에 주의.)

2. jar 파일에 main 클래스를 지정한다

여기서 생선된 jar 파일이 실행되지 않는 이유는 main 메소드를 찾지 못하기 때문이다.

jar 파일의 압축을 풀어보자.

META-INF 폴더 안에 MANIFEST.MF 파일이 있는데 이것을 수정해줘야한다.

Manifest-Version: 1.0
Created-By: 1.5.0_11 (Sun Microsystems Inc.)

Manifest-Version: 1.0
Created-By: 1.5.0_11 (Sun Microsystems Inc.)
Main-Class: ImageViewer //추가

(자신의 메인 클래스 이름을 적어야 한다)

주의) 공백도 일치해야 한다...

[명령 프롬프트]

C:\Test>jar umf manifest.mf ImageViewer.jar

여기까지 성공했다면, ImageViewer.jar 만 클릭해도 바로 실행될것이다..!!

MANIFEST.MF 파일을 *.jar 파일과 같은 경로에 위치 시킨다.

블로그 목록의 jsmooth를 다운로드 받은 후에 압축을 푼 후에, jsmoothgen.exe 를 실행한다.

[Version 을 기록한다]

http://hayashi18.egloos.com/2535436

파일

jsmooth-0.9.7.zip

자바에서 파일을 복사하는 코드이다. JDK 1.4 이상에부터는 java.nio.* 패키지를 사용하며 더 빠른 IO 작업을 할 수 있다.

1. JDK 1.4 이전에서 IO 패키지 이용

import java.io.*;

public static void copyFile(String source, String target) throws IOException {
    FileInputStream fis = new FileInputStream(source);
    FileOutputStream fos = new FileOutputStream(target);
    try {
        byte[] buf = new byte[1024];
        int i = 0;
        while ((i = fis.read(buf)) != -1) {
            fos.write(buf, 0, i);
        }
    } catch (IOException e) {
        throw e;
    } finally {
        if (fis != null)
            fis.close();
        if (fos != null)
            fos.close();
    }
}

import java.io.*;
import java.nio.channels.*;

public static void copyFile(String source, String target) throws IOException {
    FileChannel inChannel = new FileInputStream(source).getChannel();
    FileChannel outChannel = new FileOutputStream(target).getChannel();
    try {
        // magic number for Windows, 64Mb - 32Kb
        int maxCount = (64 * 1024 * 1024) - (32 * 1024);
        long size = inChannel.size();
        long position = 0;
        while (position < size) {
            position += inChannel.transferTo(position, maxCount, outChannel);
        }
    } catch (IOException e) {
        throw e;
    } finally {
        if (inChannel != null)
            inChannel.close();
        if (outChannel != null)
            outChannel.close();
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;

public class FChannel {

 public FChannel() {
  // TODO Auto-generated constructor stub
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  long size = 0;
 
  try {
   // 원본 파일
   FileInputStream fis = new FileInputStream("D:\\filedown2\\pn2060.exe");
   
   // 카피할 파일
   FileOutputStream fos = new FileOutputStream("D:\\filedown2\\pn2060_copy.exe");
   
   
   // FileStream 으로부터 File Channel 을 가져온다.
   FileChannel fcin = fis.getChannel();
   FileChannel fcout = fos.getChannel();
   
   size = fcin.size();
   
   System.out.println("In File Size :" + size);
   
   // 파일의 처음 부터 끝까지, fcout 으로 전송 copy
   fcin.transferTo(0, size, fcout);
   
   fcout.close();
   fcin.close();
   
   fos.close();
   fis.close();
   
   System.out.println("File Copy OK");
   
   
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
 }

}

import java.io.*;
import java.nio.channels.*;

public static void copyFile(String source, String target) throws IOException {
    FileChannel inChannel = new FileInputStream(source).getChannel();
    FileChannel outChannel = new FileOutputStream(target).getChannel();
    try {
        // magic number for Windows, 64Mb - 32Kb
        int maxCount = (64 * 1024 * 1024) - (32 * 1024);
        long size = inChannel.size();
        long position = 0;
        while (position < size) {
            position += inChannel.transferTo(position, maxCount, outChannel);
        }
    } catch (IOException e) {
        throw e;
    } finally {
        if (inChannel != null)
            inChannel.close();
        if (outChannel != null)
            outChannel.close();
    }
}
[출처] 자바 파일 복사 IO , NIO|작성자 인연이길

 public static String toEng(String origin) throws Exception{
 
 
  return new String(origin.getBytes(), "ISO-8859-1");
 }

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

재미 있는건  한글 변환 부분 에서 new String(한글.getBytes("KSC5601"), "ISO-8859-1") 처럼 안해두 된다는것임...

다운로드시 한글 변환도 위와 같이 하면 URLEncoding 을 안해도 됨 ㅡㅡ

daum.net , naver.com, hotmail.com, outlook express 에서 테스트 함

테스트 환경 : Win xp , tomcat 4.1.30 , Apache 2.0.49 , j2sdk 1.4.2_05

사용 디비 :  MySQL, Informix , Oracle

q        80/20 룰: 이것은 프로그램 수행 시간의 80%를 실제 프로그램 코드의 20%가 잡아먹는다는 것을 의미합니다. 때문에 실제 프로그램 코드 중 수행 시간의 80%를 차지하는 그 일부 코드를 찾는 일이 중요하다는 것입니다.

q       빠른 알고리즘: 같은 프로그램이라도 열 번 수행하는 프로그램을 한 번만 수행해도 되도록 코딩 한다면 훨씬 빠르겠죠. 평소에 다양한 로직으로 프로그램을 짜 보고, 어떻게 하면 더 간결하고 빠르게 돌아가는 코드를 만들 수 있을지를 많이 궁리해야 하겠습니다.

q       가벼운 데이터 구조: 리소스를 적게 사용하는 것이 훨씬 빠르게 작동한다는 것은 당연한 이치일 것입니다. 불필요하게 메모리를 많이 쓰는 코딩은 지양합니다.

q       가독성과 최적화: 프로그램의 최적화를 더 중요시 할지, 가독성을 더 중요시 할지를 잘 판단해야 합니다. 다음 예제 1은 가독성과 최적화의 딜레마라 볼 수 있습니다.

   예제 1

   x >> 2 또는 x / 4,

   x << 1 또는 x * 2

<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /> 

1.1.  자바에서 String은 한 번 생성되면 변하지 않는 성질(immutable)을 가지고 있습니다.

따라서 스트링들 사이에 + 연산을 수행하면 새로운 스트링을 생성하고,

양쪽 스트링의 내용을 복사한 후 앞의 스트링을 가비지 컬렉션합니다.

이에 따른 부하가 많아지므로 스트링의 연산이 필요할 경우,