'01.JAVA/Java'에 해당되는 글 199건

  1. 2009.12.21 classpath내 properties파일로 Properties객체 생성 1
  2. 2009.12.21 배열을 for 사용하지 않고 출력하기...
  3. 2009.12.21 중급 자바 개발자의 난관, 클래스 로딩 문제 분석하기
  4. 2009.12.18 Paging.java 페이지 계산 및 링크 출력 클래스
  5. 2009.12.09 자바 String Util 들
  6. 2009.12.08 Insert BLOG(Picture or Photo) Data Type Into Oracle Database
  7. 2009.12.08 Create a table in database
  8. 2009.12.08 Demo ResultSet Oracle
  9. 2009.09.25 •The Google Plugin for Eclipse, for Eclipse 3.5 (Galileo):
  10. 2009.09.25 JFree Chart Plugin
  11. 2009.09.16 @SuppressWarnings("unchecked") 란 무엇인가?
  12. 2009.09.01 JAR 파일
  13. 2009.08.25 [java] java.util.Calendar 사용한 날짜출력 및 윤년 판단 조건식
  14. 2009.07.29 게시판용 페이징 클래스
  15. 2009.07.27 JVM Memory 정리
  16. 2009.07.09 WAS에서 동작하는 프로그램 원격 디버깅하기
  17. 2009.07.03 java jar 를 exe 파일로 만들기
  18. 2009.07.03 간단한 파일 handling
  19. 2009.06.29 자바 파일 복사 코드
  20. 2009.06.29 [Java] FileChannel을 이용해 파일을 복사
  21. 2009.06.27 메일(첨부자료 3개) 보내기 .. 한글도 잘됨
  22. 2009.06.27 Java 튜닝 (반복문 최적화 #1)
  23. 2009.06.26 자바 튜닝 자료
  24. 2009.06.21 try-catch 로 왠만한 error 잡아내기
  25. 2009.06.21 class 파일을 java 파일로 디컴파일 해주는거... 1
  26. 2009.06.21 Exception in thread "main" java.lang.NoClassDefFoundError:xxxxx 1
  27. 2009.06.20 java 프로그램 실행시간 측정 3
  28. 2009.06.20 WEB-INF 밑에 환경 설정 파일(xml, properties) 추출
  29. 2009.06.18 [Tip] 오라클 CLOB 데이터 입출력 (oracle clob 2번 연속 넣기)
  30. 2009.06.18 java.lang.ClassCastException: oracle.sql.CLOB 에러
01.JAVA/Java2009. 12. 21. 18:10
반응형

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";

Posted by 1010
01.JAVA/Java2009. 12. 21. 18:06
반응형
String[] a = {"a", "b"};
System.out.println(Arrays.asList(a));
Posted by 1010
01.JAVA/Java2009. 12. 21. 16:31
반응형

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



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

2007년 12월 11일

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

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

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

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

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

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

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

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

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

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

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

  • 마지막으로 클래스 로더 교착 상태, 클래스 로더 제약 조건 위반 같은 쉽게 발생하지 않지만 일단 발생하면 해결하기 어려운 문제들에 대해 자세히 설명합니다.
Posted by 1010
01.JAVA/Java2009. 12. 18. 15:11
반응형

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;
 }
}

Posted by 1010
01.JAVA/Java2009. 12. 9. 11:40
반응형

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

Posted by 1010
01.JAVA/Java2009. 12. 8. 20:16
반응형
/*

Defining the Table: Oracle and MySql


create table MyPictures (
   id INT PRIMARY KEY,
   name VARCHAR(0),
   photo BLOB
);
*/

import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import oracle.jdbc.OracleResultSet;

public class Main {
  public static void main(String[] args) throws Exception {
    Connection conn = getOracleConnection();
    int rows = 0;
    FileInputStream fin = null;
    OutputStream out = null;
    ResultSet rs = null;
    Statement stmt = null;
    oracle.sql.BLOB photo = null;
    conn.setAutoCommit(false);
    stmt = conn.createStatement();
    String id = "001";
    String binaryFileName = "fileName.dat";

    rows = stmt.executeUpdate("insert into my_pictures(id, photo ) values ('" + id
        + "', empty_blob() )");
    System.out.println(rows + " rows inserted");

    rs = stmt.executeQuery("select photo from  my_pictures where id = '" + id
        + "' for update nowait");
    rs.next();
    photo = ((OracleResultSet) rs).getBLOB(1);

    fin = new FileInputStream(new File(binaryFileName));
    out = photo.getBinaryOutputStream();
    // Get the optimal buffer size from the BLOB
    byte[] buffer = new byte[photo.getBufferSize()];
    int length = 0;
    while ((length = fin.read(buffer)) != -1) {
      out.write(buffer, 0, length);
    }
    conn.commit();

    out.close();
    fin.close();
    rs.close();
    stmt.close();
    conn.close();

  }

  private static Connection getHSQLConnection() throws Exception {
    Class.forName("org.hsqldb.jdbcDriver");
    System.out.println("Driver Loaded.");
    String url = "jdbc:hsqldb:data/tutorial";
    return DriverManager.getConnection(url, "sa", "");
  }

  public static Connection getMySqlConnection() throws Exception {
    String driver = "org.gjt.mm.mysql.Driver";
    String url = "jdbc:mysql://localhost/demo2s";
    String username = "oost";
    String password = "oost";

    Class.forName(driver);
    Connection conn = DriverManager.getConnection(url, username, password);
    return conn;
  }

  public static Connection getOracleConnection() throws Exception {
    String driver = "oracle.jdbc.driver.OracleDriver";
    String url = "jdbc:oracle:thin:@localhost:1521:databaseName";
    String username = "userName";
    String password = "password";

    Class.forName(driver); // load Oracle driver
    Connection conn = DriverManager.getConnection(url, username, password);
    return conn;
  }

}


Posted by 1010
01.JAVA/Java2009. 12. 8. 20:15
반응형
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

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

    Class.forName("oracle.jdbc.driver.OracleDriver");

    String url = "jdbc:oracle:thin:@localhost:1521:javaDemo";
    String username = "username";
    String password = "welcome";

    String sql = "CREATE TABLE books (id NUMBER(11), title VARCHAR2(64))";
    Connection connection = DriverManager.getConnection(url, username, password);
    Statement statement = connection.createStatement();
    statement.execute(sql);
    connection.close();
  }
}
 

Posted by 1010
01.JAVA/Java2009. 12. 8. 20:14
반응형
 
import
java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class DemoResultSetOracle {

  public static Connection getConnection() throws Exception {
    String driver = "oracle.jdbc.driver.OracleDriver";
    String url = "jdbc:oracle:thin:@localhost:1521:databaseName";
    String username = "username";
    String password = "password";

    Class.forName(driver); // load Oracle driver
    Connection conn = DriverManager.getConnection(url, username, password);
    return conn;
  }

  public static void main(String[] args) {
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    try {
      conn = getConnection();
      System.out.println("conn=" + conn);
      // prepare query
      String query = "select id, name, age from employees";
      // create a statement
      stmt = conn.createStatement();
      // execute query and return result as a ResultSet
      rs = stmt.executeQuery(query);
      // extract data from the ResultSet
      while (rs.next()) {
        String id = rs.getString(1);
        String name = rs.getString(2);
        int age = rs.getInt(3);
        System.out.println("id=" + id);
        System.out.println("name=" + name);
        System.out.println("age=" + age);
        System.out.println("---------------");
      }
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    } finally {
      // release database resources
      try {
        rs.close();
        stmt.close();
        conn.close();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    }
  }
}
           
         
Posted by 1010
01.JAVA/Java2009. 9. 25. 20:40
반응형
이전에도 Eclipse Plugin을 Eclipse에서 설치해서 사용하는 것에 대해서 설명한 적이 있다.
이이 Eclipse에 익숙한 개발자라면,

구글에서 제공하는 아래와 간은 정보를 이용해서 원하는 버전에 적합한 Plug-in을 설치할 수 있을 것이다.

  • The Google Plugin for Eclipse, for Eclipse 3.3 (Europa):
    http://dl.google.com/eclipse/plugin/3.3
  • The Google Plugin for Eclipse, for Eclipse 3.4 (Ganymede):
    http://dl.google.com/eclipse/plugin/3.4
  • The Google Plugin for Eclipse, for Eclipse 3.5 (Galileo):
    http://dl.google.com/eclipse/plugin/3.5

구글의 Plug-in은 위와 같이 Eclipse의 세가지 버전(3.3, 3.4, 3.5)을 지원한다.
이중 3.5버전인 Galileo는 최근에 구글에서 Plug-in을 제공하기 시작했다. (얼마전까지는은 Eclipse 3.5버전에서는 사용하지 못했다는 말이다.)
 
어떻게 설치하고, 환경을 만드는지는 "Google App Engine Java SDK 1.2.1 Released" 의 글을 참조하면 된다. (처음 Eclipse를 사용하는  사람은 "Google App Engine SDK 설치 및 실행"를 참조)

Eclipse 3.5인 Galileo는 이전 버전들과 Plug-in 설치 방식이 약간 달라졌다.
이전 3.4 버전에서 제공 하던 방식은 플러그인을 찾는 방식이 편하지 많은 않았다. 왜냐하면, 백그라운드에서 사용자가 입력한 플러그인 이름을 실시간으로 키 입력시마다 추천해 주는 방식을 제공했는데, 네트워크에서 대기하는 시간에 대한 부담을 사용자가 가져야 했기 때문이다. 3.5 버전에서는 이러한 것들이 개선되어 졌다.

아래는 Eclipse 3.5에 GAE 플러그인을 설치한 것들을 캡쳐한 화면이다.

Eclipse 3.5의 Help > Install New Software... 를 클릭하면 아래 화면이 나타난다.


위 화면에서 상단 오른쪽에 있는 "Add..." 버튼을 클릭하면 창이 나타나면 아래와 같이 "Name"과 "Location"을 입력하고 "OK"버튼을 누른다. (Name은 사용자가 원하는 이름을 넣으면 된다.)


입력한 주소(Location) 정보가 정확하면, 아래과 같이 설치 가능한 플러그인들 목록이 표시된다.
모두 설치를 할것이므로 아래처럼 모두 체크해서 선택하면 된다. 그리고 "Next"버튼을 클릭한다.


위에서 "Next" 버튼을 클릭하면, 아래와 같이 상세 정보들이 나타난다. 다시 "Next"버튼을 클릭한다.

설치할 플러그인들에 대한 Licese 정책에 동의 할 것인지를 묻는 창인데, 당연히 동의해야 한다.
만약 동의하지 않는다면, 설치가 안될테니까... ^^;;;

위에서 동의하고 "Finish"버트을 누루면, 아래와 같이 설치가 진행된다.



출처 : http://happyzoo.tistory.com/169
Posted by 1010
01.JAVA/Java2009. 9. 25. 20:35
반응형
Java plug in 중 chart 를 쉽고 빠르게  만들 수 있게 해주는 JFree Chart Plugin을 소개한다.



다음과 같이 원형과 막대형의 그래프도 만들 수 있고 그외 만들수 있는 그래프의 숫자는 아주 많다. 지원되는 많은 차트를 확인 하려면
http://www.jfree.org/jfreechart/jfreechart-1.0.13-demo.jnlp

Library Download:

 http://www.jfree.org/ -->Download -->SourceForge Download page Click --> 하단의 jfreechart-1.0.13-javadocs.zip와 jfreechart-1.0.13.zip 받기


다음을 실행 시켜서 확인해 보면 된다.


작업순서

일단 차트를 만드는 기본적인 컨셉은 데이터가 있어야 차트로 변환할 수 있다는 점이다. 데이터가 들어가 있지 않으면 어떤것도 차트로 표현 할 수 없는 것은 당연한 일이다.


기본적인 Class의 구조는 다음과 같다.(API를 확인 하면서 보면 된다.)

가장 큰 밑바탕의 역할을 하는 JFreeChart Class가 존재 한다. JFreeChart class의 인스턴스를 생성하려면 Plot이라는 Class가 필요하다.
Plot은 정확하게 어떤 모양을 구현할지 선택하는 클래스 이다.(원형, 막대형, 꺽은선형...)
Plot은 모든 그래프 모형의 상위에 존재 하며 하위의 클래스들은 Plot을 상속하고 있다.
예를 들어 PiePlot 이라는 클래스는 원형 모델을 지원하며 PiePlot class로 구현한 그래프트는 맨 첫번째 그림의 왼쪽 모형이 되겠다.
PiePlot이라는 class는 또 다양한 형태의 class에 부모가 되며 하위 클래스 들은 3D형태의 클래스 부터 다양한 모양의 클래스가 존재 하며 예를 들면 PiePlot3D class가 원형이면서 3D형태로 구현된다.



                                                               Plot
                                                                ↑
                                                            PiePlot
                                                                ↑
                                                            PiePlot3D

이런 형태가 된다.

이 Pie class에 데이터를 넣어 줘야 하는데 데이터를 저장하고 넣게 해주는 것은 PieDataset 이라는 interface가 존재 하고 이것을 구현하고 있는 다양한 class가 있는데 일반적으로 DefaultPieDataset class를 사용한다.

작업순서
               
                           
1) Library파일 추가

struts 2 에서 제공하는 다음과 같은 library를 추가한다.

struts2-jfreechart-plugin-2.0.14.jar
commons-digester-1.8.jar

위에서 다운받은 JFreeChart library를 추가 한다.

jcommon-1.0.16.jar
jfreechart-1.0.13.jar

2) action mapping 설정

extends="struts-default,jfreechart-default"

<action name="register"
           class="chart.actions.RegisterAction"
           method="execute">
          <result name="success" type="chart">
              <param name="width">500</param>
              <param name="height">400</param>
          </result>   
 </action>

꼭 extends를 다음과 같이 설정해 주어야 하고 result type을 chart로 해주면 jFreeChart가 실행되어 차트가 보여지게 된다.
그러나 보통 웹페이지에서는 웹페이지에 전체 다 차트가 나오는 경우는 없으며 html 사이에 추가 되길 원한다.

그렇기 때문에 보통은 type="chart" 로 선언하지 않고 BusinussLogic상에서 차트를 이미지로 만들어 주어 저장한후 jsp페이지에서 링크를 걸어 주는 형식을 취하고 있다.

<action name="result"
           class="chart.actions.ResultAction"
           method="execute">
          <result name="success">/chart/result.jsp</result>    
</action>

다음과 같이 평범하게 결과 페이지로 이동시킨다.


3) Business Logic을 수행하고 JFreeChart class로 chart를 생성한다.

Logic을 수행할 class - 투표로직!
----------------------------------------------------------------------------------------------------------
package chart.actions;

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

Posted by 1010
01.JAVA/Java2009. 9. 16. 09:48
반응형

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


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

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

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

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


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


@Override

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

경우 컴파일 에러 발생


@Deprecated

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


@SuppressWarning

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


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

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


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

Posted by 1010
01.JAVA/Java2009. 9. 1. 10:26
반응형


JAR 파일

JAR 파일 포맷의 힘

문서 옵션

 

 


제안 및 의견
피드백

난이도 : 초급

Pagadala J. Suresh, 소프트웨어 엔지니어, IBM Global Services India
Palaniyappan Thiagarajan, 소프트웨어 엔지니어, IBM Global Services India

2003 년 10 월 09 일

대부분의 자바 프로그래머들은 JAR 파일의 기본 작동에 익숙하다. 하지만 JAR 파일 포맷의 막강한 힘을 아는 개발자는 드물다.

JAR 파일

JAR 파일 포맷은 대중적인 ZIP 파일 포맷을 근간으로 하여 많은 파일들을 하나로 모으는데 사용된다. ZIP 파일과는 달리 JAR 파일은 압축과 디스트리뷰션 뿐만 아니라 라이브러리, 컴포넌트, 플러그인 등의 전개와 캡슐화에도 사용되며 컴파일러나 JVM 같은 툴이 직접 사용하기도 한다. 전개 디스크립터 같이 JAR에 포함된 특별한 파일은 특정 JAR가 취급되는 방법을 툴에 지시한다.

JAR 파일은 다음과 같은 데에 사용된다:

JAR 파일 포맷은 많은 혜택과 기능을 제공하며 ZIP 또는 TAR 같은 전통적인 아카이브 포맷이 줄 수 없는 많은 것들을 제공한다. 이를 테면:

JAR의 압축과 압축풀기

jar 툴(jar 참조)은 파일을 기본적으로 압축한다. 압축이 풀린 JAR 파일은 압축된 JAR 파일 보다 더 빠르게 로딩될 수 있다. 로딩 시간 동안 파일의 압축 풀기 시간이 줄어들기 때문이다. 하지만 네트워크를 통한 다운로드 시간은 압축이 풀린 파일이 더 길다.

META-INF 디렉토리

대부분의 JAR 파일에는 META-INF 디렉토리가 포함되어 있는데 이는 패키지의 저장과 보안 및 버저닝 정보 같은 확장 설정 데이터를 저장하는데 사용된다. META-INF 디렉토리의 파일과 디렉토리는 Java2platform에서 인식 및 인터프리팅되어 애플리케이션, 확장, 클래스 로더를 설정한다:

jar 툴

JAR 파일로 기본적인 태스크를 수행하려면 자바 개발 킷의 일부로 제공되는 Java Archive Tool (jar 툴)을 사용한다. jar 툴을 jar 명령어로 호출한다. 표 1은 일반 애플리케이션이다:

표 1. jar 툴의 일반적인 사용

기능 명령어
개별 파일에서 JAR 파일 만들기 jar cf jar-file input-file...
디렉토리에서 JAR 파일 만들기 jar cf jar-file dir-name
압축 풀린 JAR 파일 만들기 jar cf0 jar-file dir-name
JAR 파일 업데이트 jar uf jar-file input-file...
JAR 파일 내용보기 jar tf jar-file
JAR 파일 내용 추출하기 jar xf jar-file
JAR 파일에서 특정 파일 추출하기 jar xf jar-file archived-file...
실행 JAR 파일로 패키지된 애플리케이션 실행하기 java -jar app.jar



위로


실행 JAR 파일

실행 JAR 파일은 특별히 설정된 JAR 파일에 저장된 독립적인 자바 애플리케이션이다. 파일을 추출하거나 클래스 경로를 설정하지 않고 JVM에 의해 직접 실행될 수 있다. 비 실행 JAR에 저장된 애플리케이션을 구동하려면 이를 클래스 경로에 추가하고 애플리케이션의 메인 클래스를 이름별로 호출해야한다. 하지만 실행 JAR 파일을 사용하면 이를 추출하거나 메인 엔트리 포인트를 알 필요 없이 애플리케이션을 실행할 수 있다.

실행 JAR 파일 만들기

실행 JAR 파일을 만들기는 쉽다. 모든 애플리케이션 코드를 하나의 디렉토리에 놓는 것으로 시작한다. 애플리케이션의 메인 클래스가 com.mycompany.myapp.Sample이라고 가정해보자. 애플리케이션 코드를 포함하고 메인 클래스를 구분하는 JAR 파일 생성이 필요하다. 이를 위해 라는 manifest 파일을 어딘가에(애플리케이션 디렉토리는 아니다) 만들고 여기에 다음 행을 추가한다:


Main-Class: com.mycompany.myapp.Sample

그런 다음 JAR 파일을 다음과 같이 만든다:


jar cmf manifest ExecutableJar.jar application-dir

실행 JAR 파일 시작하기

애플리케이션을 ExecutableJar.jar라는 실행 JAR 파일로 묶었으므로 다음 명령어를 사용하여 파일에서 직접 애플리케이션을 시작할 수 있다:


java -jar ExecutableJar.jar




위로


패키지 실링(sealing)

JAR 파일안에 패키지를 봉합(sealing)한다는 것은 이 패키지에 정의된 모든 클래스가 같은 JAR 파일에서 찾아져야 한다는 것을 의미한다. 이로서 패키지 작성자는 패키지된 클래스들의 버전 영속성을 강화할 수 있다. 봉합은 보안 조치도 제공하여 코드 탬퍼링을 탐지한다.

패키지를 봉합하려면 패키지용 Name 헤더를 추가한다. 그 뒤에 Sealed 헤더 값을 JAR manifest 파일에 대해 "true"로 한다. 실행 JAR 파일과 마찬가지로 manifest 파일을 적절한 헤더 엘리먼트로 지정하여 JAR를 봉합할 수 있다:


Name: com/samplePackage/
Sealed: true

Name 헤더는 패키지의 관련 경로명을 정한다. 파일이름과 구별되도록 "/"로 끝난다. Name 헤더에 뒤따르는 모든 헤더는 공백 라인 없이 Name 헤더에 지정된 파일이나 패키지에 붙는다. 위 예제에서 Sealed 헤더가 공백 라인 없이 Name 헤더 다음에 발생했기 때문에 Sealed 헤더는 com/samplePackage 패키지에만 붙는것으로 인터프리팅된다.

확장 패키징

확장은 자바 플랫폼에 기능을 추가한다. 확장 메커니즘은 JAR 파일 포맷에 구현된다. 확장 메커니즘으로 JAR 파일이 다른 필요한 JAR 파일들을 Class-Path 헤더를 통해 manifest 파일에 지정할 수 있다.

extension1.jar와 extension2.jar가 같은 디렉토리 안의 두 개의 JAR 파일에 있다고 가정해보자. extension1.jar의 manifest는 다음 헤더를 포함하고 있다:


Class-Path: extension2.jar

이 헤더는 extension2.jar의 클래스들이 extension1.jar의 클래스를 목표에 맞춘 확장 클래스로서 작용한다는 것을 나타내고 있다. extension1.jar의 클래스들은 extension2.jar가 클랫의 경로의 일부가 될 필요 없이 extension2.jar의 클래스를 호출할 수 있다.

예를 들어 ExtensionDemo 클래스를 레퍼런싱하는 ExtensionClient 클래스가 ExtensionClient.jar라고 하는 JAR 파일에 번들되었고 ExtensionDemo 클래스가 ExtensionDemo.jar에 번들되었다고 가정해보자. ExtensionDemo.jar가 확장으로 취급되기 위해서는 ExtensionDemo.jar는 ExtensionClient.jar의 manifest 안의 Class-Path 헤더에 리스트되어야 한다:


Manifest-Version: 1.0
Class-Path: ExtensionDemo.jar




위로


JAR 파일의 보안

JAR 파일은 jarsigner 툴을 사용하거나 java.security API를 통해서 직접 서명될 수 있다. 서명된 JAR 파일은 원래 JAR 파일과 정확히 같다. manifest만이 업데이트 된 것과 두 개의 추가 파일들이 META-INF 디렉토리에 추가된 것을 제외하고.

Keystore 데이터베이스에 저장된 인증을 사용하여 JAR 파일은 서명된다. Keystore에 저장된 인증은 패스워드로 보호된다.


그림 1. Keystore 데이터베이스
Keystore Database

JAR의 각 서명자는 JAR 파일의 META-INF 디렉토리안에 있는 .SF 확장자가 붙은 서명으로 표현된다. 이 파일의 포맷은 manifest 파일과 비슷하다. 메인 섹션과 개별 엔트리들로 구성되어 있다. 서명된 JAR에서 오는 파일을 확인하기 위해 서명 파일의 다이제스트 값은 JAR 파일의 상응 엔트리에 대비하여 계산된 다이제스트와 비교된다.


Listing 1. Manifest와 서명 파일
Contents of signature file META-INF/MANIFEST.MF

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

Name: Sample.java
SHA1-Digest: 3+DdYW8INICtyG8ZarHlFxX0W6g=

Name: Sample.class
SHA1-Digest: YJ5yQHBZBJ3SsTNcHJFqUkfWEmI=

Contents of signature file META-INF/JAMES.SF

Signature-Version: 1.0
SHA1-Digest-Manifest: HBstZOJBuuTJ6QMIdB90T8sjaOM=
Created-By: 1.3.0 (Sun Microsystems Inc.)

Name: Sample.java
SHA1-Digest: qipMDrkurQcKwnyIlI3Jtrnia8Q=

Name: Sample.class
SHA1-Digest: pT2DYby8QXPcCzv2NwpLxd8p4G4=

디지틀 서명

디지틀 서명은 .SF 서명 파일의 서명완료된 버전이다. 디지틀 서명 파일은 바이너리 파일이며 .SF 파일과 같은 파일이름을 갖고 있지만 다른 확장이다. 확장은 디지틀 서명 유형에 따라 다양하고 (RSA, DSA, PGP). JAR 서명에 사용된 인증 유형에 따라 다르다.

Keystore

JAR 파일에 서명하려면 프라이빗 키를 가져야 한다. 프라이빗 키와 관련 퍼블릭 키 인증은 패스워드로 보호된 데이터베이스(keystores)에 저장된다. JDK는 Keystore를 구현 및 변경하는 툴을 포함하고 있다. Keystore의 각 키는 앨리어스에 의해 구분되는데 전형적으로 키를 소유한 서명자의 이름이다.

모든 Keystore 엔트리들은 고유 앨리어스로 액세스된다. 앨리어스는 Keystore에 엔터티를 추가할 때 keytool -genkey 명령어를 사용하여 지정되어 키 쌍을 만든다. 뒤따르는 keytool 명령어는 이와 같은 앨리어스를 사용하여 엔터티를 언급해야 한다.

예를 들어 "james"라는 앨리어스로 새로운 퍼블릭/프라이빗 키 쌍을 만들고 퍼블릭 키를 자가 서명된 인증으로 래핑하려면 다음 명령어를 사용한다:


keytool -genkey -alias james -keypass jamespass 
        -validity 80 -keystore jamesKeyStore 
        -storepass jamesKeyStorePass

jarsigner 툴

jarsigner 툴은 Keystore를 사용하여 JAR 파일에 대한 디지틀 서명을 만들거나 확인한다.

위 예제에서 처럼 "jamesKeyStore" Keystore를 만들었고 여기에 "james" 앨리어스와 키를 포함하고 있다고 가정해보자. 다음 명령어로 JAR 파일에 서명할 수 있다:


jarsigner -keystore jamesKeyStore -storepass jamesKeyStorePass 
          -keypass jamespass -signedjar SSample.jar Sample.jar james

이 명령어는 앨리어스가 "james"이고 패스워드가 "jamespass"인 키를 보내 Sample.jar 파일에 서명하고 SSample.jar라는 서명된 JAR를 만든다.


jarsigner -verify SSample.jar




위로


JAR 인덱싱(indexing)

애플리케이션 또는 애플릿이 다중의 JAR 파일들로 번들된다면 클래스 로더는 단순한 리니어 검색 알고리즘을 사용하여 클래스 경로의 엘리먼트를 검색한다. 클래스 로더가 존재하지 않은 리소스를 찾으려고 하면 애플리케이션 또는 애플릿 내의 모든 JAR 파일들은 다운로드 되어야한다. 큰 네트워크 애플리케이션과 애플릿의 경우 늦은 시작, 지연된 응답, 네트워크 대역 낭비를 초래한다.

JDK 1.3 이후 JAR 파일 포맷은 인덱싱(indexing)을 지원하여 네트워크 애플리케이션(특히 애플릿)의 클래스 검색 프로세스를 최적화했다. JarIndex 메커니즘은 애플릿 또는 애플리케이션에 정의된 모든 JAR 파일의 내용을 모아 첫 번째 JAR 파일의 인덱스 파일에 이 정보를 저장한다. 첫 번째 JAR 파일이 다운로드된 후에 애플릿 클래스 로더는 모아진 콘텐트 정보를 사용하여 JAR 파일을 효율적으로 다운로드한다. 이 디렉토리 정보는 INDEX.LIST라는 이름으로 간단한 텍스트 파일로 저장된다.(META-INF 디렉토리).

JarIndex 만들기


그림 2. JarIndex
JarIndex Demo

다음 명령어를 사용하여 JarIndex_Main.jar, JarIndex_test.jar, JarIndex_test1.jar용 인덱스 파일을 만든다:


jar -i JarIndex_Main.jar JarIndex_test.jar SampleDir/JarIndex_test1.jar 

INDEX.LIST 파일은 간단한 포맷을 갖고 있으며 색인된 JAR 파일에 저장된 패키지 또는 클래스 이름을 포함하고 있다.(Listing 2):


Listing 2. JarIndex INDEX.LIST 파일
JarIndex-Version: 1.0

JarIndex_Main.jar
sp

JarIndex_test.jar
Sample

SampleDir/JarIndex_test1.jar
org
org/apache
org/apache/xerces
org/apache/xerces/framework
org/apache/xerces/framework/xml4j



참고자료

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



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

Posted by 1010
01.JAVA/Java2009. 8. 25. 09:58
반응형

출처 : 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("올해는 윤년이 아닙니다");
    }
  }
}



첨부파일: 20090303(tue)-calendar_util.zip
Posted by 1010
01.JAVA/Java2009. 7. 29. 11:54
반응형

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

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


---------------------------------------------------------------------------------------
페이징 클래스 소스코드 :
---------------------------------------------------------------------------------------
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>


---------------------------------------------------------------------------------------
결과 :
---------------------------------------------------------------------------------------
prev [11] [12] [13] [14] [15] next
Posted by 1010
01.JAVA/Java2009. 7. 27. 14:45
반응형
출처 : http://fly32.tistory.com/438

* JVM Memory 영역에 대한 설명


- Method Area : 메소드와 클래스 변수를 저장하기 위한 공간, 모든 프로그램에 의해 공유.
- Heap Area : 사용자가 생성하는 Java Object들이 저장되는 공간, 동적으로 할당하여 사용되어짐.
- Stack Area : 메소드 호출시 해당 메소드의 매개변수, 지역변수, 임시변수 등을 저장하기 위한 Stack 구조의 메모리.
- Native Heap Area : Java Object가 아닌 Native Object들이 거주하는 공간. OS 차원에서 결정.
- Permanent Space : Class에 대한 Meta 정보를 저장하는 공간. (Permanent Space는 Java Heap의 하위 영역)


* Java 실행 Option

1. -X Option (모든 VM에서 동작하지 않을 수 있는 비표준 option이며, 버젼별로 언급없이 변경되어질 수 있음)
-Xms : 초기 Heap size 설정
-Xmx : 최대 Heap size 설정
-Xss : 각 Thread에 할당되는 Stack size 설정
-Xmn : New 영역을 위한 Heap size 설정

2. -XX Option (올바른 동작을 위해 특정한 시스템 요구사항들이 있으며, 시스템 설정 파라미터에 대한 접근 권한이 요구됨)
-XX:PermSize : 초기 Permanent size 설정
-XX:MaxPermSize : 최대 Permanent size 설정

※ 참고 사이트 : http://blogs.sun.com/watt/resource/jvm-options-list.html
                           http://www.monosun.com/doc/hotspotvmoption.html


* Heap Size 구하기

long   heapSize   = Runtime.getRuntime().totalMemory();
String heapSizeMB = (heapSize / (1024*1024)) + "MB";


* 영역별 OutOfMemoryError 대처 방법

1. Heap Area
Exception in thread "main": java.lang.OutOfMemoryError: Java heap space
Exception in thread main: java.lang.OutOfMemoryError: Requested array size exceeds VM limit

원인 : Heap size의 부족으로 Java Object를 생성하지 못하여 발생
해결 : 1. -Xmx Option을 이용하여 최대 Heap size의 크기를 늘려줌
           2. Application 로직이 잘못되었거나 JDK나 WAS의 Bug로 인한 Memory 누수가 있는지 확인하여 수정
           3. finalize method에 의해 즉각적인 GC가 이루어지지 않으므로 로직 수정을 통해 해결

※ Object Allocation Profiling (Hprof)
java -Xrunhprof:heap=sites [Main Class]
java -Xrunhprof:heap=sites,doe=n [Main Class] (Thread Dump 생성)


2. Permanent Space
Exception in thread "main": java.lang.OutOfMemoryError: Perm Gen space'

원인 : Permanent 저장 공간이 부족하여 발생.
          JSP -> Servlet 변환, Reflection을 사용하여 동적으로 로딩되는 Class가 많은 경우에 발생할 수 있으며,
          WAS의 Class Reloading 기능이 자주 실행 될 경우에도 발생할 수 있음.
해결 : -XX:PermSize, -XX:MaxPermSize Option을 이용하여 크기를 늘려줌

※ Class Loading Monitoring
java 실행시 -verbose:gc을 사용하여 Class가 Loading 되는 것을 Monitoring


3. Native Heap Area
java.lang.OutOfMemoryError: request bytes for . Out of swap space?
java.lang.OutOfMemoryError: (Native method)'
java.lang.OutOfMemoryError: unable to create new native thread

원인 : Native Heap memory가 부족하여 발생
해결 : 1. Physical memory를 초과할 경우 Virtual Memory를 요청하여 필요한 메모리를 확보하게 되는데,
             이 과정에서 오류가 발생할 경우 OS가 제공하는 툴을 통해 이를 모니터링 하고
             이 공간 자체가 부족할 경우 크기를 늘려줌
          2. -Xmx Option을 이용하여 Heap Area 공간을 줄이고 Native Heap Area 공간을 늘림
          3. Thread Stack Space가 부족한 경우 Thread의 수를 줄이거나,
              -Xss Option을 통해 Thread별 Stack Size를 줄여줌
              (단, Thread별 Stack Size를 과도하게 줄였을 경우 Stack Overflow Error가 발생할 수 있음)



참고 사이트 : http://ukja.tistory.com/61
                      http://2005elc.elancer.co.kr/eTimes/page/eTimes_view.html?str=c2VsdW5vPTIwODY=
Posted by 1010
01.JAVA/Java2009. 7. 9. 17:58
반응형


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

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

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

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

java.lang.NullPointerException
  kr.nextree.common.nexuser.spi.jdbc.JDBCCredentialsSPI.authenticate(JDBCCredentialsSPI.java:32)
  kr.nextree.common.nexuser.impl.NexUserImpl.authenticate(NexUserImpl.java:13)
  kr.nextree.bcf.user.impl.UserServiceImpl.authenticate(UserServiceImpl.java:79)
  kr.nextree.bcf.ui.authentication.BcfAuthenticationProvider.authenticate(BcfAuthenticationProvider.java:26)
  org.acegisecurity.providers.ProviderManager.doAuthentication(ProviderManager.java:195)
  org.acegisecurity.AbstractAuthenticationManager.authenticate(AbstractAuthenticationManager.java:43)
  ...

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

   conn = JDBCSPIEnv.getInstance().getDataSource().getConnection();
   ps = conn.prepareStatement(JDBCSPIEnv.getInstance().getAuthenticateSql());
   ps.setString(1, id);

   rs = ps.executeQuery();

   if (rs.next()) {
    return rs.getString(1).equals(NexUserEnv.getInstance().getPasswordEncoder().encode(password));
   }

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

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

-Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n

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

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

>set JAVA_OPTS=-Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n

>catalina.bat run

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

...
Using JRE_HOME:        C:\java\jdk1.6.0_01
Listening for transport dt_socket at address: 8000
...

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

set MAVEN_OPTS= -Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n


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

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

사용자 삽입 이미지
여기서 "Remote Java Application"을 선택하고 마우스 오른쪽 버튼을 클릭해 팝업 메뉴에서 "New"를 선택하면

사용자 삽입 이미지

위와 같이 새로운 디버그 연결을 위한 설정이 나타난다. 여기서 위와 같이 선택하고(Host와 Port는 변경할 수 있다. 위의 예에서 Port를 8000으로 설정했다.) "Debug 버튼"를 클릭한다.
그 후 "Debug" Perspective로 가면 (Window > Open Perspective를 통해 이동할 수 있음) 아래 그림과 같은 WAS의 쓰레드가 보이면 연결에 성공한 것이다.
사용자 삽입 이미지


3. Breakpoint 설정하기
이전 에러 스택을 통해 JDBCCredentialsSPI.java 소스의 32라인에서 무언가 null이라고 했다. 이 자바 소스를 열고 편집창 맨 앞에서 더블 클릭을 하거나 팝업 메뉴로 해당 라인에 breakpoint를 걸어두자.
사용자 삽입 이미지


4. 실행하고 상태 살펴보기(Inspect)
이제 에러가 난 부분을 실행하면 breakpoint에서 실행이 멈추고 대기할 것이다. 그럼 이제 어떤 부분이 null인지 살펴보자. Debug perspective에서 Variable 뷰에서 보면 rs는 nul로 나오지 않았다. 따라서 rs.getString(1) 부분이 null인지 살펴볼 것이다. 아래와 같이 rs.getString(1)을 선택하고 팝업메뉴로 "Inspect"를 선택한다.
사용자 삽입 이미지

그러면 위와 같이 현재의 rs.getStrng(1)을 평가하고 그 값을 보여준다. 이런 벌써 이 부분이 null인 것이 판명이 났다. 도대체 어떤 SQL을 실행했는데 첫번째 컬럼마저 null일까.

위의 소스에서 SQL 문장을 보려고 했다. 아 이것도 상수가 아니구나. 마찬가지 방법으로 inspect해서 SQL 문장을 확인한다. 소스 윗줄의 JDBCSPIEnv.getInstance().getAuthenticateSql()를 선택하여 살펴보았다. (팝업메뉴나 ctl+shift+i)
사용자 삽입 이미지

확인한 결과 실행한 SQL은 "select password from users where user_id = ?" 이고 넘어가는 파라메터는 "dykim"이었다.
DB의 테이블 내용을 살펴보니 dykim의 password 컬럼 값이 null 이었다.
사용자 삽입 이미지
아... rs.getString()이 null을 던질 수도 있는데... 단위 테스트하나 더 추가하고 고쳐야겠다.
Posted by 1010
01.JAVA/Java2009. 7. 3. 14:30
반응형

자바도 간단히 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 파일과 같은 경로에 위치 시킨다.


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

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


사용자 삽입 이미지
 
 
[오른쪽의 화살표 버튼을 눌러서 Window Wrapper 를 선택한다]
 
윈도우 어플리케이션 : 콘솔에 뜨는 메시지 안보임
콘솔 : 콘솔에 뜨는 메시가 보임
 
사용자 삽입 이미지
 
 
[바이너리는 만들어질 실행 파일의 이름을 적어준다]
 
필요하면 아이콘도 추가 -
 
 
사용자 삽입 이미지
 
 
 
[메인 클래스에는 main 클래스 이름을 입력한다]
[꾸겨넣는 jar 에는 아까 압축한 jar 항목을 입력한다]
[클래스패스에는 Source 클래스 파일 경로를 적어준다.] - 없어도 되기는 함.
 
사용자 삽입 이미지
 
 

[Version 을 기록한다]

사용자 삽입 이미지
 
[Java 프로퍼티들을 추가한다. - 없어도 상관없다.]
 
[메뉴의 프로젝트-컴파일] 로 컴파일 한다.
문제 없으면 EXE가 생성된다.
 
 
더 자세한 사항은 아래 사이트를 방문하길 바란다.
나도 여기 보고 정리한거..
 
Posted by 1010
01.JAVA/Java2009. 7. 3. 12:43
반응형
Java로 프로그래밍을 하다 보면 파일 핸들링이 꼭 필요한 경우가 있다. 자주 사용했던 걸 요약하면 다음과 같다.

1. UTF-8로 되어있는 파일 읽고 쓰기

BufferedReader br = new BufferedReader(new InputStreamReader( new FileInputStream(args[0]), "UTF-8"));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( new FileOutputStream(args[1]), "UTF-8"));
 
,

args[0]과 args[1]은 각각 입력, 출력 파일 이름이다.
인코딩은 보통 utf-8, ksc5601, euc-kr, ms949, iso-8859-1, 8859-1 중에 하나로 합니다.
파일을 쓸 때 새로운 파일로 생성하게 되는데 이게 아니라 뒤에 파일을 추가해서 쓰게 하는 모드로 바꾸려면
new FileOutputStream( args[1] );
new FileOutputStream( args[1] , true); 로 바꾸어 주면 됩니다.

br.readLine( str )bw.write( str )을 쓰면
C언어에서 fprintf(in,"%s",str) ;  fprintf(out,"%s",str)
C++언어에서 fin>>str; fout<<str 을 하는 효과가 된다.

2. 파일 이동/변경, 삭제

- 파일 이동/변경
File file = new File( from );
File destFile = new File( to );
if (!file1.renameTo(file2)) {
      System.err.println("Failed to move this file.");
}


- 파일 삭제
File f = new File( fileName );
if (!f.delete())
{
      System.err.println("Failed to remove this file.");
}


3. 폴더 만들기, 폴더 삭제
- 폴더 만들기
File f = new File( fileName );

if (!f.mkdirs())
{
      System.err.println("Failed to make this directory.");
}


- 폴더 이동/변경(파일 이동/변경하는 것과 같다)
- 폴더 삭제(파일 삭제하는 것과 같다)

--
try-catch는 물론 해 줘야 합니다.
Posted by 1010
01.JAVA/Java2009. 6. 29. 17:15
반응형

자바에서 파일을 복사하는 코드이다. 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();
    }
}

2. JDK 1.4 이상에서 NIO 패키지 이용 (더 빠름)
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();
    }
}

Posted by 1010
01.JAVA/Java2009. 6. 29. 17:12
반응형

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

}

[출처] FileChannel을 이용한 파일 복사 팁|작성자 리트머스


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

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();
    }
}
Posted by 1010
01.JAVA/Java2009. 6. 27. 01:19
반응형
public boolean sendMail(String filePath,String host, String receiver, String sender, String subject, String contents, InquireFile[] files){
 
  boolean flag = false;
 
  Properties prop = new Properties();
 
  prop.put("mail.smtp.host" , host);
 
  Session mailSession = Session.getDefaultInstance(prop, null);
 
  try{
   
   InternetAddress from = new InternetAddress(sender);
   
   Message msg = new MimeMessage(mailSession);
   
   msg.setFrom(from);
   
   msg.setRecipient(Message.RecipientType.TO, new InternetAddress(receiver));
   
   msg.setSubject(subject);
   
   Multipart multi = new MimeMultipart();      
   
   MimeBodyPart mbp = new MimeBodyPart();
   
   mbp.setContent(contents, "text/html; charset=ms949");
   
   multi.addBodyPart(mbp);
   
   if(files != null){
   
    for(int i = 0; i < files.length; i++){
     
     if(files[i] == null ) continue;
     
     DataSource fds = new FileDataSource(filePath + "/" + files[i].getFileName() );
     
     MimeBodyPart m = new MimeBodyPart();
     
     m.setDataHandler(new DataHandler(fds));
 
     m.setFileName(  toEng(fds.getName() ) );
     
     multi.addBodyPart(m);
     
    }
   }
   
   msg.setContent(multi);
   
   msg.setSentDate(new Date());
   
   Transport.send(msg);
   
   
   flag = true;
   
   
  }catch(Exception e){
   
   Logger logger = Logger.getLogger(this.getClass());  
   
   logger.error(this.getClass().getName() + " : " + e);
   
  }
 
  return flag;
 
 }

 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

Posted by 1010
01.JAVA/Java2009. 6. 27. 00:41
반응형

1. 배열 요소의 사용을 자제하라.
   - JVM은 배열의 Index에 대해 경계검사(bound-checking)을 하므로, 부하가 커진다.

접기

  for (int i=0; i<Repeat; i++)
    countArr[0] += 10;
  ==>

  count = countArr[0];
  for(int i=0; i<Repeat; i++)
    count+=10;
  countArr[0]=count;

접기


2. 메소드의 호출로 반복문을 종료하지 마라.

접기

 for(int i=0; i<collection.size(); i++)
  ==>

  int max = collection.size();
  for(int i=0; i<max; i++)

접기


3. 인덱스 변수에는 int형을 사용하라
  - JVM은 int형에 최적화되어있다, 다른형을 사용할 경우 int로 암시적 캐스팅을 유발한다.

더보기


4. 효율적인 비교
   - JVM은  -1,0,1,2,3,4,5로 비교하는것에  최적화 되어있다

더보기

 5. 숏서킷 연산을 앞쪽에 두어라
   - a || b,  a && b 연산자는 앞의 조건을 통과해야 뒤의 조건절도 수행한다.

더보기


6. 반복문 안에서는 리플렉션(java.lang.reflect)의 사용을 자제하라  
   ==> 직접 메소드를 실행하는 경우에 비해서 느리다

※ 참고 : 자바 퍼포먼스 튜닝 : 성능 향상을 위한 205가지 핵심 기법
             7장. 반복문,스위치,재귀

Posted by 1010
01.JAVA/Java2009. 6. 26. 23:14
반응형
1. 프로그램의 최적화 원칙

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) 가지고 있습니다.

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

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

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

String 대신 고정적이지 않은 StringBuffer를 사용하는 것이 좋습니다

(String 결합은 과도한 쓰레기와 array 복사를 일으킨다.)

 

q     String s = “hi ” + “Mr. ” + “ ” + “Buddy!”;

문자열을 컴파일할 때 완전히 결정 할 수 있다면, 연결연산자가 StringBuffer 사용보다 효율적입니다.

컴파일 할 때 결정할 수 없다면(런타임시 결정) StringBuffer를 이용하는 것이 효율적입니다.

 

q     StringBuffer 버퍼 크기 초기값을 생략하면 불필요한 resizing 일으킬 있습니다.

(정확한 크기를 모른다면 그냥 두는 것이 나음)

 

StringBuffer sb = new StringBuffer();

sb.append("aaa" + "\n");

는 불필요한 스트링 연결작업으로  성능을 저하시킵니다

sb.append("aaa").append("\n");

 

sb.append("\n");

String을 추가하는 것보다 char를 추가하는 것이 빠릅니다

sb.append('\n');

 

setLength라는 메쏘드를 통해서 객체를 새로 생성하지 않고서 계속 사용할 수 있습니다.

StringBuffer sb=new StringBuffer();

sb.append("Hello");

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

sb.setLength(0);

sb.append("World");

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

 

StringBuffer는 동기 StringBuilder는 비동기방식이다

 

q     문자열을 분석해서 분할해야하는 경우. 보통은  StringTokenizer 객체를 쓰게된다. 하지만 클래스는 내부적으로.. 굉장히 무거운 클래스이다.. 왜냐하면. 이전에 분할한 정보를 가지고 있기 때문이다.. 따라서 단순히 앞으로 나가면서 잘라내기만을 시도할 문자열은 간단히 스스로 구현하여 쓰도록 하자


 

스트링비교할때

 

if (name.compareTo("John") == 0) ...

if (name == "John") ...

if (name.equals("John")) ...

if ("".equals(name)) ...

 

위의 비교중 잘못된 것은 없지만 좋은것도 없다.

q     compareTo 메소드는 너무 거창하고 장황하다.

q     == 연산자는 object identity 테스트하는 것으로 (--> 동일한 object인지 체크) 아마도 여러분이 원하는 것이 아닐 것이다.

q     equals 메소드가 가야할 길이지만, 상수와 변수를 거꾸로하면 name null 때도 안전하며 추가로 loop안에서 사용될 경우 equals 메소드가 항상 동일한 object에서 호출되기 때문에 속도상의 이점을 있다.

q     빈문자열을 테스트할 때는 길이가 0인지 체크하는 것이 빠르다. 이는 equals에서 처음에 hash value 먼저 계산할수도 있기 때문이다.

(--> Sun JDK에서는 길이를 먼저 체크한 후 문자열의 char를 비교하며 hash값을 체크하지 않는다.)

 

if ("John".equals(name)) ...

if (name.length() == 0) ...

 

 

 

 

 

 

 


 

1.2.  for 루프에서 객체를 생성금지. 재사용 매개변수를 보내는 것이 중요하다.

 

임시 객체를 빠른 캐시에 저장하는 C C++와 달리, 자바에서는 메모리의 힙 영역에 객체를 저장합니다.

따라서 임시 객체를 생성할 때마다 힙에 액세스해야 하므로 속도가 느려집니다.

또한 임시 객체에 대한 가비지 컬렉션의 오버헤드가 큽니다.

 

가능한 루프안에서는 객체를 생성하지 말라

스트링 객체를 더하지도 말라 같은 오버헤드가 발생한다

 

루프문이나 자주 불리워지는 메쏘드에서의 객체 생성을 피합니다.

한 개의 employee 객체에 계속 값을 할당하고 지우고 하는 식으로 사용합니다.

for ( int i = 0; i < 100; i++ ) {

             Employee employee = new Employee();

             list.add( employee );

} // end for i

 

Employee employee = null;

for ( int i = 0; i < 100; i++ ) {

             employee = new Employee();

             list.add( employee );

} // end for i

 

 

for 문의 증가값이나. 기본적인 정수의 사용에 있어 int 보다 작은 byte, char, short

사용할려는 경향이 있다 하지만 이것은 오산이다.

 

또한 반복문 내의 비교 상대값을 메쏘드 호출해서 계산해 오는 것이라면 다음처럼 미리 지역 변수에 그 값을 저장한 후에 그것을 사용하는 것이 좋습니다.

for(int k=0; k< s.length(); k++) 보다는

int limit = s.length();

for(int k=0; k < limit; k++)

 

 

 

 

 

1.3. 기타 등등

1.3.1.  Overkill initialization

public class B {

    private String name = null;

}

이 프로그래머는 C로 코딩하는데 익숙하다. 그래서 자연스럽게 모든 변수가 적절하게 초기화되기를 원했다. 하지만 이는 필요하지 않다. 자바 언어 명세서는 멤버 변수가 항상 0이나 null, false 등의 특정 값으로 자동으로 초기화되는 것을 보장한다. 이를 명시적으로 선언함으로써 프로그래머는 constructor에 앞서 클래스 initializer에서 수행되도록 만든다. 이는 불필한 과잉행동으로 피해야한다.

public class B {

    private String name;

}

 

1.3.2. Converting numbers to Strings

"" + set.size()

new Integer(set.size()).toString()

Set.size() 메소드의 반환형은 int이다. 여기서는 String으로 변환하고자 한다. 위의 두 예제는 사실상 변환을 하고 있다. 하지만 첫번째는 불필요한 String 연결 작업을 수행하고, 두번째는 임시로 Integer 래퍼를 생성한다. 변환을 하는 바른 방법은 아래와 같다.

String.valueOf(set.size())

 

1.3.3. Not taking advantage of immutable objects

zero = new Integer(0);

return Boolean.valueOf("true");

Boolean Integer는 불편값이다. 따라서 같은 값을 표시하는 다수의 개체를 생성하는 것은 의미없는 일이다. 이러한 클래스들은 내부에 자주 사용되는 인스턴스에 대한 캐쉬를 가지고 있다. Boolean의 경우 단지 두 개의 인스턴스만이 존재한다. 프로그래머는 이러한 사실을 활용할 수 있다.

zero = Integer.valueOf(0);

return Boolean.TRUE;

 

1.3.4.  etcetera

q     Strength reduction : Shift 연산은 비트 단위로 값을 이동하는 것입니다. 좌로 1비트 이동하면 곱하기 2, 우로 1비트 이동하면 나누기 2 됩니다. 이때 곱하기나 나누기보다 Shift 연산이 훨씬 빠릅니다

x >> 2 또는 x / 4, x << 1 또는 x * 2

(증감연산은 ++ -- +1, -1보다 훨씬 빠르고, shift 연산이 곱셈이나 나눗셈보다 빠릅니다.)

q     Unrolling loops: 반복문 내에서 이상의 연산을 수행함으로써 반복 회수를 줄여 반복 제어의 부하를 줄여 주는 것을 말합니다. 다음예제에서 x배열은 항상 2 배수이기 때문에 제어변수 i 2 증가시키면서 내부에서는 연산을 2 수행합니다. 이는 결과적으로 연산 회수는 같으나 반복제어 회수가 줄어든다는 이점이 있습니다.

double picosy = Math.PI * Math.cos(y);

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

x[i] *= picosy;

x[i+1] *= picosy;

}

q     new 통한 생성자 호출대신 static 메쏘드를 사용합니다. 다음의 예제 9에서는 Integer 클래스를 생성한 다음 string에서 정수 값을 추출해냈습니다. 예제 10에서는 Object Instance 필요없는 static 메쏘드를 사용했습니다.

 

예제 9

String string="55";

int theInt=new Integer(string).intValue();

 

예제 10

String string="55";

int theInt=Integer.parseInt(string);

 

q     캐스팅의 지향

캐스팅을 하면 컴파일 시간에 그 타입이 결정될 수 없기 때문에 실행 시간을 느리게 만듭니다. 인터페이스를 캐스팅할 경우 더욱 많은 실행 시간을 필요로 하게 됩니다. 이를 위해서 같은 객체를 여러 번 캐스팅할 필요가 있을 경우 지역 변수에 저장해서 사용합니다. 캐스팅을 될 수 있는 한 피하고, 가장 빠른 변수 타입은 int이기 때문에 불가피한 경우를 제외하고는 int를 사용하는 것이 좋습니다.

 

q     빠른 변수 타입의 사용

변수의 성능은 그것의 범위와 타입에 의해서 결정됩니다. 가장 빠른 변수는 지역 메쏘드 변수이며, 가장 빠른 변수 타입은 int와 참조 변수입니다. 또한 어떻게 배열을 초기화시킬지가 중요한 요소가 됩니다. 다차원 배열로 정의할 경우 매번 생성자를 호출하기 때문에 꼭 필요한 경우가 아니면 다차원 배열로 정의하지 않습니다. 배열이 지역변수일 경우 메쏘드 호출시 매번 초기화를 수행하므로, 배열을 static으로 선언하면 초기화가 반복되는 것을 제거할 수 있습니다

 

 

1.4.  Collection 객체의 크기를 필요한 만큼 크게 잡는다

Ex) Vector의 크기를 증가하는 방법은

더 큰 크기의 내부 배열 객체를 생성 -> 이전 배열에서 새로운 배열로 새롭게 복제

 -> 이전 배열을 삭제

하는 방법으로 크기를 증가 시킨다 따라서 Colloection 을 가능한 큰 크기로 잡아두는 것이 좋다

 

 

1.5.  참조변수 유지보다 고정변수?

 

1.6. Thread Connection  오버헤드가 매우크므로 스레드풀과 커넥션풀을 사용하라
- VectorPoolManager - Collection
재사용

 

 

1.7.  Vector 사용후 Size 0으로 설정한다. 참조가 없기때문에 레퍼런스가 제거된다.

 

 

1.8.  객체의 정규화

  - 많은 객체의 사본을 몇 개의 객체로 대체한다.

  - Boolean의 정규화

  - 자주 사용하는 Integer의 정규화

  - "" 공백 또는 요소없는 배열, Date 객체

  - String.intern()을 통하여 정규화가 가능하다.

 

 

 

1.9.  Reference 객체 사용.

  - WeakReference를 사용하여 메모리가 부족하면 레퍼런스 객체는 가비지 컬렉션되면서 초기화된다.

  - 가비지 컬렉션이 되었다면 그 객체는 null이 된다.

  - 재사용하고 싶으나 곧바고 필요하지 않는 객체를 메모리에 유지할 수 있다 하지만 부족해지면

    우선적으로 가비지 컬렉션 된다.

 

1.10.  상수는 정수로 사용하자.

 

1.11.  String 정수를 int 변환시 객체 생성이 아닌 ParseInt 사용하자.

 

1.12.  자료형을 변환할때

 

"" + set.size()

new Integer(set.size()).toString()

 

Set.size() 메소드의 반환형은 int이다. 여기서는 String으로 변환하고자 한다.  위의 두 예제는 사실상 변환을 하고 있다.

하지만 첫번째는 불필요한 String 연결 작업을 수행하고,

두번째는 임시로 Integer 래퍼를 생성한다. (참고. Integer.toString() 함수는 static 함수가 아니다)

 

String.valueOf(set.size())

 

 

zero = new Integer(0);

return Boolean.valueOf("true");

 

Boolean Integer는 불편값이다. 따라서 같은 값을 표시하는 다수의 개체를 생성하는 것은 의미없는 일이다.

이러한 클래스들은 내부에 자주 사용되는 인스턴스에 대한 캐쉬를 내부에 가지고 있다.

Boolean의 경우 단지 두 개의 인스턴스만이 존재한다. 프로그래머는 이러한 사실을 활용할 수 있다.

 

zero = Integer.valueOf(0);

return Boolean.TRUE;

(이 메소드(valueOf) 가 빈번하게 요구되는 값을 캐쉬하므로 new Integer보다 비용이 훨씬 적음)

 

 

1.13.  기타등등

 

public class B {

    private int count = 0;

    private String name = null;

    private boolean important = false;

}

이 프로그래머는 C로 코딩하는데 익숙하다. 그래서 자연스럽게 모든 변수가 적절하게 초기화되기를 원했다.

하지만 이는 필요하지 않다. 자바 언어 명세서는 멤버 변수가 항상 0이나 null, false 등의 특정 값으로 자동으로 초기화되는 것을 보장한다.

이를 명시적으로 선언함으로써 프로그래머는 constructor에 앞서 클래스 initializer에서 수행되도록 만든다.

이는 불필한 과잉행동으로 피해야한다.

public class B {

    private int count;

    private String name;

    private boolean important;

}

 

 

Collection l = new Vector();

for (...) {

   l.add(object);

}

Vector는 동기화된 ArrayList이다. 그리고 Hashtable은 동기화된 HashMap이다. 두 클래스는 동시 접근이 필요한 경우만 사용되어야 한다.

만약 이러한 컬렉션 클래스가 로컬 변수로 일시적으로 사용될 때는 동기화가 필요없으며, 이는 성능을 저하시킬 수 있다.

Collection l = new ArrayList();

for (...) {

   l.add(object);

}

 

 

// returns [1]: Location, [2]: Customer, [3]: Incident

bject[] getDetails(int id) {...

 

설령 문서화되었다 해도, 이런 종류의 메소드의 값 반환은 다루기 난처하고 에러를 쉽게 유발한다.

여러분은 반드시 이 값들을 담는 작은 클래스를 선언해서 사용해야 한다. 이는 C struct와 유사하다.

Details getDetails(int id) {...}

 

private class Details {

    public Location location;

    public Customer customer;

    public Incident incident;

}

 

 

1.14. 성능 확인표

대부분의 제안은 병목점을 확인한 후에만 적용이 가능하다.

. 메모리 문제가 있는지 확인한다.

. 특히 루프에서 사용하는 임시 객체의 개수를 줄인다.

- 자주 사용하는 메소드에서 임시 객체의 생성을 피한다.

- 컬렉션 객체의 크기를 미리 설정한다.

- 가능하면 객체를 재사용한다.

- 재사용하기 전에 컬렉션 객체를 비운다(너무 크지 않다면 용량을 줄일 필요

는 없다) .

- 데이터 타입간의 변환에서 임시 객체의 생성을 줄일 수 있는 메소드를 사

용한다(특히 스트링과 스트림) .

- 메소드가 객체를 리턴하기 보다는 재사용 가능한 객체를 매개변수로 받도

록 정의한다.

- 가능하면객체를 정규화한다.'=='연산자로 정규화한 객체를비교한다.

- (그 개수가 별로 많지 않다면) 클래스가 필요한 개수의 객체만 생성한다.

- 스트링과 다른 객체를 int 상수로 대체한다. '=='연산자로 비교한다.

- 객체 대신에 원시 데이터 타입을 사용한다.

- 메소드를 사용하기 위해 객체 생성하는 것을 피한다.

- 내포하는 객체를 줄이기 위해 여러 객체를 묶는다.

- 큰 사이즈의 객체 컬렉션은 배열을 사용하여 미리 할당한다.

- 스트링 연결 연산자(+) 대신에S t r i n g B u ff e r를 사용한다.

- 사본을 생성하지 않고 직접 객체를 변경하는 메소드를 사용한다.

- 원시 데이터 타입을 직접 사용하는 클래스를 사용한다.

? T h r e a d L o c a l을 사용하여 싱글톤에 접근하는 것을 고려한다.

? f i n a l을 사용하여 변수의 변경을 방지한다.

? We a k R e f e r e n c e를 사용하여 정규화용 테이블을 유지한다(캐시는 S o f t R e f e r e n c e를 사용한다) .

? 객체 생성 병목점을 객체 생성 방식을 변경하여 줄인다.

─ 생성자를 간단하게 유지하고 상속을 너무 깊이 하지 않는다.

─ 한 번 이상의 변수 초기화를 피한다.

c l o n e() 메소드를 사용하여 생성자의 사용을 피한다.

─ 배열의 생성이 더 빨라질 수 있다면 복제한다.

─ 간단한 배열은 초기화가 더 빠르고, 복잡한 배열은 복제가 더 빠르다.

? 객체 생성에 의한 성능 저하는 생성 시간을 변경하여 제거한다.

─ 객체를 미리 생성하여 필요할 때까지 유지한다.

─ 사용하지 않는 객체나 변수가 있거나 나누어서 생성할 필요가 있을 경우

에는 추후 초기화 기법을 사용한다.

─ 디자인에서 필요하거나 추후 초기화로 성능을 향상시킬 수 있을 경우에만

추후 초기화를 사용한다.

Posted by 1010
01.JAVA/Java2009. 6. 21. 04:47
반응형
class ThrowableTest {
 public static void main(String[] args) {
  try {
   main(null);
  } catch (Exception e) {
   System.out.println("Exception");
  } catch (StackOverflowError soe) {
   System.out.println("StackOverflowError");
  } catch (Error err) {
   System.out.println("Error");
  } catch (Throwable t) {
   System.out.println("Throwable");
  }
 }
}
Posted by 1010
01.JAVA/Java2009. 6. 21. 04:10
반응형




.class 파일을 java 파일로 디컴파일 해주는 프로그램입니다.

jad실행 - open - .class 선택

Posted by 1010
01.JAVA/Java2009. 6. 21. 03:27
반응형

Exception in thread 'main' java.lang.NoClassDefFoundError

도스창이나, eclipse 등등 자바 실행시 이런 문구가 떠서

당황해본 경험이 있다. OTL...

이런 메세지가 뜨는 것에는 2가지 이유가 있다.

자바실행시, 파일명을 잘못 입력했던가

아니면, classpath 를 잘못 지정했기 때문이다.


1. 자바실행시 잘못된 파일명 입력

예를 들어, 도스창에서 자바파일을 컴파일하고, (javac Hello.java)

실행을 시킬 때, (파일명 : Hello.java , Hello.class)

java Hello.java                 <- 이렇게 하면 당연히 위에 메시지가 뜬다 ㅡㅡ;;...

java hello.java                 <- 이렇게해도 당연히 뜬다 ㅡㅡ....

java Hello                        <- 이렇게 해야한다!! ^^


java 실행시 대소문자를 구분하고, 컴파일된 것을 실행시키는 것이기 때문에,

*.java를 실행시키려는 무모한 도전은 자제를 부탁한다.


<여기서 잠깐!! 자바프로그램 실행의 기본적인 개념>

 

※ 컴파일(compile)이 뭐죠?

 

- 컴파일(compile)이란 사람이 알아 볼수있게 만든 프로그램소스를 기계가 알아 볼수있게

  만들어주는 작업입니다. 사람은 십진수를 쓰고, 영어를 사용하지만, 컴퓨터는 2진수에

  영어도 쓸줄 모르잖아요. ^^ 그래서, 컴퓨터가 쉽게 이해할수 있게 컴파일을 하는 것입니다.

  결국 프로그램을 실행시켜주는 것은 사람이 아니라, 컴퓨터니까요.

 

※ java파일과 class파일의 차이가 뭐죠?

 

- 자바를 실행시킬 때, 컴파일을 합니다. 그러면, *.java파일이 컴파일되어서 *.class파일이

  생겨납니다. 컴퓨터가 처리할수 있는 파일은 *.class파일이기 때문에 자바에서 실행시

  명령어를 [java 파일명] 으로 쓰는 것입니다. 확장자 java를 붙이면 안되는 거죠. ^^

  결국, java파일은 사람이 만들고 쓰는 것이고, class파일은 컴퓨터가 만들고 처리하는

  것이죠.


2. classpath지정이 잘못 되어있을 경우
 보통 jdk1.5이상의 버전을 설치하면, 자동으로 환경변수를 설정해주기 때문에,
 문제가 발생하지 않아야하는데, 종종 이러한 문제가 발생한다 ㅡㅡ...
 이유는 나도 모른다. ㅠ_ㅠ...
 어쨌든!!
 이것을 해결하는 방법은
 "내컴퓨터에서 마우스 오른쪽키 " -> "속성" -> "고급 탭" - > "환경변수"
 에 들어가서,
 아래쪽 부분에 있는 "CLASSPATH" 부분을 '편집"을 통해 수정해줘야 한다는 것이다.
 jdk가 설치된 디렉토리의 경로를 적어주는데, 조심해야  할 점이 있다.
 .;C:\Program Files\Java\jdk1.6.0_01\bin;
 이렇게 제일 앞부분에 .; <- 이게 꼭 들어가야한다는 것이다.
 (. 은 보통 현재 위치를 가리키는 표시)

 
이 그림 처럼 해주면 된다.
 
그러면 문제없이 잘 실행된다. ^^


Exception in thread "main" java.lang.NoClassDefFoundError:xxxxx


대략 이런식으로 에러 뜰떄는 클래스를 못찾는거다

CLASSPATH=.;    <=이걸 추가시켜줘야 한다
( 현재폴더를 classpath에 추가하는걸 의미한다)
Posted by 1010
01.JAVA/Java2009. 6. 20. 13:29
반응형

// 시작 부분에 아래처럼 현재 시간을 계산하고

long start = System.currentTimeMillis();


// 프로그램 본문


// 끝에 아래와 같이 삽입

long end = System.currentTimeMillis();

System.out.println( "실행 시간 : " + ( end - start )/1000.0 );

Posted by 1010
01.JAVA/Java2009. 6. 20. 13:27
반응형

독자적인 환경 설정 파일을 구축하려 할 때 WEB-INF 밑에 넣어놓기 마련인데

경로 때문에 컨텍스트 이전시 문제가 될수 있다.


  ClassLoader loader = Thread.currentThread().getContextClassLoader();
  File file = new File(loader.getResource("").getFile());

  file = new File(file.getParent() + File.separator
    + "gh-config.xml" );


위와 같이 정의하면 WEB-INF\gh-config.xml 을 가져올 수 있다.


원래의 아래와 같은 소스라면 WEB-INF\classes\gh-config.xml 을 가져오도록 되있다.


  ClassLoader loader = Thread.currentThread().getContextClassLoader();
  File file = new File(loader.getResource("gh-config.xml").getFile());

Posted by 1010
01.JAVA/Java2009. 6. 18. 18:43
반응형
[Tip] 오라클 CLOB 데이터 입출력

/**
 CLOB 자료를 오라클 DB에 넣기 위한 자바 소스 파일
 
 1. CLOB 자료형인 column을 오라클의 empty_clob()을 이용해 초기화를 해야 한다.
    : 또는 CLOB column의 기본값을 empty_clob()으로 하던가..
   
 2. setAutoCommit(false)를 꼭 해야 한다.
 
 3. select clob_column from table where pk = value for update
    : for update를 이용해 CLOB column을 lock한다.
    : stream을 이용해 CLOB column을 업데이트 하는동안 다른 process의 접근을 막는다.
    : 또한 stream을 이용해 자료를 넣기 전까지는 실제로 commit되지 말아야 하기 때문에
      2번의 auto commit을 false로 했던 것이다. (이것때문에 하루 보냄 ㅜㅜ;;)
    : 모두 쓰고 나서는 commit() <-- 옵션
    : setAutoCommit(true) <-- 옵션
     
 4. 여기서 특이한 점은 오라클의 jdbc 드라이버의 OracleResultSet과 CLOB을 이용한다는 것이다.
    : java.sql.ResultSet과 java.sql.Clob을 이용하면 오라클 JDBC 드라이버가 해석시에 에러를 발생시킨다.
    : 아마도 오라클 jdbc 드라이버의 문제점이 아닐까 하는 생각이 든다.
    : 아니면 표준과 싸우는 오라클인가? ㅡㅡ;;
   
 5. 나머지 부분은 Stream을 이용한 input과 output이므로 언급을 생략하겠다.
*/

import java.io.*;
import java.net.*;
import java.sql.*;

import oracle.sql.*;
import oracle.jdbc.driver.*;

public class ClobTest {
 public static void main(String[] argv) {
 
  String drv = "oracle.jdbc.driver.OracleDriver";
  String dburl = "jdbc:oracle:thin:@192.168.3.30:1521:GRDB21";
  String user = "scott";
  String password = "tiger";
 
  Connection conn = null;
  Statement st;
  ResultSet rs;
 
  try {
         Class.forName(drv);         
         System.out.println("Drive Loading...");
            conn = DriverManager.getConnection(dburl, user, password);
            System.out.println("Connecting...");
            st = conn.createStatement();
           
            // 입력할 텍스트 만들기
            StringBuffer sb = new StringBuffer();
            String clobTest = "한글 테스트입니다\nIt is difficult\n";
            for (int i = 0; i < 300; i++)
    sb.append(clobTest);
   
   
   
   // 1. CLOB 데이터 입력하기 위해, empty_clob() 생성
            try {
             st.executeUpdate("insert into test_clob values ('02', empty_clob())");
            } catch (Exception ee) {
             ee.printStackTrace(System.out);
            }
   
   // 2. setAutoCommit을 false로 꼭 해야 한다.
   conn.setAutoCommit(false);
   
   
   // 3. CLOB column에 대한 lock을 얻는다.
   rs = st.executeQuery("select desc2 from test_clob where code = '02' for update");
   if (rs. next()) {
   
    // 4. 오라클의 함수들을 사용하기 위해 cast 하였다.
    CLOB cl = ((OracleResultSet)rs).getCLOB("desc2");
   
    // 스트림을 이용한 값 저장
    BufferedWriter writer = new BufferedWriter(cl.getCharacterOutputStream());
    writer.write(sb.toString());
    writer.close();
   }
   conn.commit();
   conn.setAutoCommit(true);
               
   // 입력한 값 읽어 오기    
   rs = st.executeQuery("select * from test_clob where code = '02'");
   
   if (rs.next()) {
    String code = rs.getString("code");
   
    // CLOB column에 대한 스트림을 얻는다.
    Reader rd = rs.getCharacterStream("desc2");
   
    sb = new StringBuffer();
    char[] buf = new char[1024];
    int readcnt;
    while ((readcnt = rd.read(buf, 0, 1024)) != -1) {
     // 스트림으로부터 읽어서 스트링 버퍼에 넣는다.
     sb.append(buf, 0, readcnt);
    }
    rd.close();
   
    System.out.println("code : " + code);
    System.out.println("desc2 : " + sb.toString());
   }
 
 
  }
  catch (Exception e) {
   e.printStackTrace(System.out);
  }
 }
}

Posted by 1010
01.JAVA/Java2009. 6. 18. 14:12
반응형
java.lang.ClassCastException: oracle.sql.CLOB 에러

exception message
oracle.sql.CLOB
exception stack trace
java.lang.ClassCastException: oracle.sql.CLOB
	at project.web.pds.PdsDAOOracle.write(PdsDAOOracle.java:169)

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


시기 : 오라클 CLOB타입으로 DB인서트할때

원인 : tomcat common lib과 WEB-INF lib에 동시에 오라클 드라이버 라이브러리가 들어 있었음.

odbc14.jar


해결책 : tomcat common lib에만 오라클 드라이버를 남기고 나머지는 다 지운다.

Posted by 1010