객체 직렬화란?

- 직렬화: Heap에 위치한 객체를 출력 가능한 상태로 만드는 작업

- 역직렬화: 직렬화된 객체를 다시 Heap에 넣기 위한 작업

- 직렬화의 대상은 객체의 Attribute의 값. (메소드는 그저 주소값만 필요할뿐)

- 객체를 IO하기 위해서는 필터스트림인 ObjectInputStream과 ObjectOutputStream이 필요

- 직렬화는 ObjectOutputStream

- 역직렬화는 ObjectInputStream

- 직렬화 대상객체는 java.io.Serializable를 implements한 클래스 객체여야 한다.

- 자바의 메모리 구조는 그림과 깉이 되있는데 여기서 보듯이 객체는 Attribute 데이터, 그리고 Method의 주소만 갖고 있을 뿐이다.

따라서 직렬화의 대상은 실체가 없는 Method는 제외하고 Attribute만 직렬화하게 된다.

객체 직렬화 하는 방법

- Serializable Interface를 implements한 class의 객체는 뭐든 직렬화가 가능하다.

ex) 직렬화 대상 클래스

import java.io.*; 

public class Member implements Serializable{
    private String name; 
    private transient int age;
    private String address; 
    private transient MyDate birthday;

    ...
}

ex) 객체 직렬화 하기

public void writeMemberObject(Member m) throws IOException {
    ObjectOutputStream oos = null; 
    try{ 
        oos = new ObjectOutputStream(new FileOutputStream("mem.obj")); // 연결 + 필터 추가 
        oos.writeObject(m); // 객체를 출력하는 메소드: writeObject(Object obj) 
        // write할 때 Exception이 발생하는데 이 때 close를 안하면 스트림이 안닫혀있는 상태로 방치 
    } finally { 
        if(oos!=null) { 
            oos.close(); // 그래서 close로 닫아줌 
        } 
    } 
}

객체 직렬화 피하기 (또는 피해야 되는 경우)

- 객체 Instance 변수 앞에 transient 키워드를 붙이면 직렬화 대상에서 제외된다.

- 그런데 왜 직렬화 대상에서 제외할까? 답은...

1. 보안적인 측면에서 직렬화 할 때 빼고 싶을 때

 보안 문제로 직렬화 하면 안되는 어트리뷰트가 여기에 해당한다.

2. 직렬화 대상이 아닌 객체 type일 경우

 만약 다음과 그림과 같은 A 객체와 B 객체를 직렬화 한다고 해보자.

위와 같은 구조에서 A, B 객체들을 직렬화하고 싶을 때 어떻게 할까?

답은 B 객체의 멤버 인스턴스인 C 객체에 transient 키워드를 붙여준다.

그러면 직렬화 대상에서 제외되므로 소스 코드를 통채로 고치지 않아도 된다.

역직렬화 객체를 복원하는 방법

- 객체를 만든 뒤 readObject() 메소드의 리턴하는 Attribute 대입

- 자바가 역직렬화하는 방식은 JVM이 역직렬화 하고자 하는 객체를 만들어서 리턴한다.

ex)

public Member readMemberObject() throws IOException, ClassNotFoundException {
    ObjectInputStream ois = null; 
    Member m = null; 
    try    { 
        ois = new ObjectInputStream(new FileInputStream("mem.obj")); 
        m = (Member)ois.readObject(); 
    } finally { 
        ois.close(); 
        return m; 
    } 
}

그런데 여기서 문제가 발생한다.

만약 역직렬화해서 만든 객체(readObject() 메소드로 불러들인 객체)의 클래스가 변경이 되었다면?

그런데도 역직렬화한 객체를 변경된 클래스의 인스턴스에 대입하려고 한다면?

당연히 이 때 JVM은 역직렬화 객체를 대입할 수 없다고 예외를 발생시킨다.

좀 더 자세히 살펴보면 역직렬화한 객체와 새로 변경된 클래스의 serialVersionUID가 일치하지 않아서 발생하는 문제인데

새로 변경된 클래스와 역직렬화하는 객체의 serialVerionUID를 일치시켜주면 된다.

그럼 또 어떻게 serialVerionUID를 일치시켜준단 말인가?

답은...

클래스를 작성할 때 미리 serialVerionUID를 상수로 고정시켜 놓는다. 이렇게 되면 클래스가 새로 변경이 되도 역직렬화하는 객체와 serialVerionUID가 같기 때문에 예외가 더 이상 발생하지 않는다.

ex) 직렬화 대상 클래스 (역직렬화 문제 해결)

import java.io.*; 

public class Member implements Serializable{
    // 직렬화, 역직렬화 시 serialVersionUID 상수가 없으면 JVM이 만들어서 넣어준다. 
    // 있으면 만들지 않는다. 
    static final long serialVersionUID = 100L;
    private String name; 
    private transient int age;

    ...

}
[출처] [Java] Serialize (객체 직렬화)|작성자 데쳄버

출처 : http://lotus.tistory.com/78

Map 같은 자료구조로 이터레이션 할때 여러가지 방법을 쓸 수 있는데 검색하다가 깔끔한 코드를 발견해서 첨부해 본다. ㅋ
난 자바 뉴비..ㅎㅎ

- 그저 그런 방법

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

Google이 2001년에 이미지 검색 기능을 실행했을 때, 2억 5천만 개의 인덱스된 이미지를 보유했다. 십 년이 지나지 않아, 이 검색 거인은 100억 개 이상의 이미지를 인덱스했다. 분당 35시간의 컨텐츠가 YouTube로 업로드된다. Twitter는 평균적으로 매일 5천 5백만 건의 트윗을 처리한다고 주장한다. 올해 초에 그 검색 기능은 매일 6억 개의 쿼리를 로깅했다. 대용량 데이터를 논의할 때 대용량이란 바로 그 정도이다.

이러한 엄청난 규모의 데이터는 대기업, 대학 및 정부 — 엄청나게 비싼 슈퍼컴퓨터를 구입할 수 있으며 이를 계속 실행할 직원을 가용할 수 있는 단체 —에 국한되었다. 오늘날 스토리지 비용의 절감과 프로세싱 성능의 상용화를 통해 중소기업 및 일부 개인들도 동일한 데이터를 저장하고 마이닝하기 시작하여, 애플리케이션 혁신의 흐름을 발전시킨다.

대용량 데이터 혁명이 가능한 기술 중 하나는 MapReduce이다. 이는 엄청난 규모의 분산 데이터 세트를 처리하기 위해 Google이 개발한 프로그래밍 모델 겸 구현 방식이다. 이 기사에서 필자는 Apache의 오픈 소스 MapReduce 구현 방식인 Hadoop을 소개한다. 이는 클라우드 컴퓨팅의 킬러 앱(killer app)이라고도 한다.

Hadoop 정보

Apache의 Hadoop 프레임워크는 본질적으로 대용량 데이터 세트를 분석하기 위한 메커니즘이며, 이는 반드시 데이터 저장소에 수용하지 않아도 된다. Hadoop은 MapReduce의 거대한 데이터 분석 엔진을 요약하여 개발자들이 액세스하기에 더 쉽게 만든다. Hadoop은 무수한 노드로 확장하여 데이터 정렬과 관련된 활동 및 조정을 모두 처리할 수 있다.

Hadoop은 수많은 기능과 구성을 통해 놀랍도록 유용하고 강력한 프레임워크가 된다. Yahoo!와 무수한 다른 조직들은 산더미 같은 비트와 바이트들을 분석하기 위해 이를 효율적인 메커니즘이라고 인식했다. 또한 Hadoop은 단일 노드에서 작업하기에 매우 간편하다. 즉, 분석할 데이터가 어느 정도 있고, 제네릭을 비롯한 Java 코드에 익숙하기만 하면 된다. Hadoop은 또한 Ruby, Python 및 C++로 작업한다.

대용량 데이터 세트를 처리하기 위한 개념적인 프레임워크로서 MapReduce는 다수의 컴퓨터를 사용하여 분산된 문제 해결을 위해 고도로 최적화되었다. 프레임워크는 이름이 암시하는 대로 두 가지 함수로 구성된다. map 함수는 대용량 데이터 입력을 취하여 더 잘게 나누도록 설계되었으며, 그러면 이를 통해 어떠한 작업을 할 수 있는 다른 프로세스로 전달한다. reduce 함수는 map으로 수집되는 개별 응답을 요약하고 최종 출력으로 이를 렌더링한다.

Hadoop에서 Hadoop의 자체적인 기본 클래스를 확장하여 map과 reduce 구현을 정의한다. 구현은 입력 및 출력 형식과 함께 이를 지정하는 구성으로 함께 묶인다. Hadoop은 구조화된 데이터가 들어있는 대용량 파일을 처리하기 위한 훌륭한 세트이다. Hadoop의 특히 편리한 측면 하나는 입력 파일의 원시 구문 분석을 처리하기 때문에, 사용자는 한 번에 한 행씩 다룰 수 있다. 따라서 map 함수를 정의하는 것은 실제로 텍스트의 수신되는 행에서부터 취하려는 것을 판별하는 문제에 불과하다.

위로

데이터는 어디에나 있다!

미국 정부는 일반 시민이 크게 관심을 가지는 엄청난 양의 데이터를 제작한다. 다양한 정부 기관들은 미국 경제 상태 및 변화하는 사회적 인구 통계와 관련된 데이터를 자유롭게 분배한다. 미국 지질 조사소(USGS)는 국제적인 지진 데이터를 발표한다.

여러 소규모 지진들이 전 세계 곳곳에서 매일 발생한다. 이들 중 다수는 지각 내 깊은 곳에서 발생하여 아무도 인식하지 못하지만, 그럼에도 불구하고 청취 스테이션은 이를 기록한다. USGS는 주간 CSV(또는 콤마로 분리된 값) 파일 형태로 지진 데이터를 발표한다.

평균적인 주간 파일은 엄청나게 크지는 않다 — 겨우 100KB 정도이다. 하지만 이는 Hadoop을 학습하기 위한 기초로 쓰일 것이다. 그렇다고 하더라도 Hadoop이 훨씬 더 큰 규모의 데이터 세트를 처리할 수 있다는 점을 잊지 말자.

진동 추적

최근에 USGS 웹 사이트에서 다운로드한 CSV 파일은 다음 리스트 1과 같이 약 920개의 행으로 되어있다.

$> wc -l eqs7day-M1.txt 
  920 eqs7day-M1.txt

CVS 파일의 컨텐츠는 다음 리스트 2(즉, 처음 두 개의 행)에서 보는 것과 비슷하다.

$> head -n 2 eqs7day-M1.txt 
Src,Eqid,Version,Datetime,Lat,Lon,Magnitude,Depth,NST,Region
ci,14896484,2,"Sunday, December 12, 2010 23:23:20 UTC",33.3040,-116.4130,1.0,11.70,22,
  "Southern California"

특히 총 행의 합이 920개라는 점을 고려할 때에, 필자는 이를 Information Rich 파일이라고 할 것이다. 하지만 필자는 이 파일로 보고되는 그 주의 각 날짜에 발생하는 지진의 수만 알고자 한다. 그 다음에 이러한 7일에 대부분의 지진이 나타나는 일반적인 영역이 어디인지 알고자 한다.

필자의 첫 번째 생각은 일일 지진 수를 검색하기 위해 간단한 grep 명령을 사용할 수 있었다는 점이다. 파일을 살펴보면 데이터가 12월 12일에 시작하는 것으로 표시된다. 따라서 다음 리스트 3의 결과로 그 문자열의 grep -c를 수행한다.

$> grep -c 'December 12' eqs7day-M1.txt 
98

이제 12월 12일에 98개의 항목 또는 98개의 기록된 지진이 있었음을 알게 되었다. 행 아래로 이동하여 12월 11일, 10일 등에 grep을 수행할 수도 있을 것이다. 하지만, 그것은 필자가 생각하기에는 지루하다. 더욱 나쁜 것은 이를 이끌어 내기 위해 파일에 어느 날짜가 있는지 알아야 한다는 것이다. 필자는 그 내용에 실제로 신경을 쓰지 않으며, 어떠한 경우에는 그러한 정보에 액세스 권한이 없을 수 있다. 실제로 필자는 어느 7일 범위에서나 주어진 각 날짜의 숫자만 알고자 하고, Hadoop을 통해 그러한 정보를 간편하게 얻을 수 있다.

Hadoop은 필자의 첫 번째와 두 번째 질문에 응답하는 정보의 몇 가지 부분만 필요로 한다. 다시 말해서, 처리할 입력이 어느 것이며, map과 reduce를 어떻게 다루느냐이다. 또한 모두 함께 묶는 작업도 제공해야 할 것이다. 하지만, 그 코드에 작업을 시작하기 전에 전부 필자의 CSV 데이터 순서로 되어 있는지 확인하는 데 수분이 걸릴 것이다.

위로

opencsv로 데이터 구문 분석

지진 CSV 파일의 첫 행인 헤더를 제외하고 각 행은 콤마로 분리된 데이터 값의 시리즈이다. 필자는 세 가지 데이터 부분인 각 지진의 날짜, 위치 및 규모에 주로 관심이 있다. 이러한 데이터를 확보하기 위해 opencsv라는 실용적인 오픈 소스 라이브러리를 사용할 것이며, 이는 CSV 파일을 구문 분석하는 데 유용하다.

테스트를 우선 시행하는 사람이 되기 위해, 목록 4와 같이 CSV 파일에서 확보한 샘플 행에서 원하는 정보를 확보할 수 있는지 확인하는 빠른 JUnit 테스트를 작성하여 시작할 것이다.

public class CSVProcessingTest {

 private final String LINE = "ci,14897012,2,\"Monday, December 13, 2010 " +
            "14:10:32 UTC\",33.0290,-115." +
            "5388,1.9,15.70,41,\"Southern California\"";

 @Test
 public void testReadingOneLine() throws Exception {
  String[] lines = new CSVParser().parseLine(LINE);

  assertEquals("should be Monday, December 13, 2010 14:10:32 UTC",
    "Monday, December 13, 2010 14:10:32 UTC", lines[3]);

  assertEquals("should be Southern California",
    "Southern California", lines[9]);

  assertEquals("should be 1.9", "1.9", lines[6]);
 }
}

리스트 4에서 확인 가능한 대로, opencsv는 콤마로 분리된 값으로 매우 간단하게 작업하게 해준다. 구문 분석기는 간단하게 String의 배열을 리턴하므로, 위치 상의 값을 확보할 수 있다(Java 언어에서 배열 및 콜렉션 액세스가 제로 기반인 것을 기억하자).

데이터 형식 변환하기

MapReduce로 작업할 때에 map 함수의 작업은 일부 키에 추가로 작업하기 위해 일부 값을 선택하는 것이다. 다시 말해서, map은 주로 두 가지 요소로 작업하고 리턴한다. 이는 키와 값이다. 이전의 요구사항으로 돌아가서 필자는 우선 매일 지진이 얼마나 발생하는지 알아내고자 한다. 따라서, 지진 파일을 분석할 때에 두 가지 값을 도출할 것이다. 즉, 키는 날짜가 될 것이고, 값은 카운터가 될 것이다. 그러면 reduce 함수가 카운터를 합하여(이는 1의 값으로 정수임), 대상 지진 파일에서 날짜당 발생하는 횟수를 제공할 것이다.

24시간 기간에 관심이 있기 때문에, 각 파일에서 날짜의 시간 부분을 삭제해야 할 것이다. 다음 리스트 5에서 수신되는 파일에서 특정 날짜 형태를 더 일반적인 24시간 기간 날짜로 어떻게 전환하는지 유효성 검증하는 빠른 테스트를 작성한다.

@Test
public void testParsingDate() throws Exception {
 String datest = "Monday, December 13, 2010 14:10:32 UTC";
 SimpleDateFormat formatter = new SimpleDateFormat("EEEEE, MMMMM dd, yyyy HH:mm:ss Z");
 Date dt = formatter.parse(datest);

 formatter.applyPattern("dd-MM-yyyy");
 String dtstr = formatter.format(dt);
 assertEquals("should be 13-12-2010", "13-12-2010", dtstr);
}

리스트 5에서 SimpleDateFormat Java 오브젝트를 사용하여 Monday, December 13, 2010 14:10:32 UTC의 CSV 파일 형식에서 날짜 String을 더 일반적인 13-12-2010으로 형식화했다.

위로

Hadoop의 map 및 reduce

이제 CSV 파일과 데이터 형식을 어떻게 처리할 것인지에 대한 작업을 했으니, Hadoop에서 map과 reduce 함수를 구현하여 시작할 차례가 되었다. 이 프로세스는 Hadoop이 명시 유형 안전을 선호하기 때문에, Java 일반을 이해하는 것이 필요하다.

Hadoop으로 map 구현을 정의할 때에 Hadoop의 Mapper 클래스를 간단하게 확장한다. 그러면 발신되는 키와 값 모두에 대한 명시 유형을 지정하기 위해 일반을 사용할 수 있다. 또한 유형 절은 수신되는 키와 값을 설명하며, 이는 파일 읽기의 경우에 이는 각각 바이트 개수와 텍스트의 행이다.

EarthQuakesPerDateMapper 클래스는 Hadoop의 Mapper 오브젝트를 확장한다. 이는 명시적으로 출력 키를 Text 오브젝트로 설명하고 그 값을 IntWritable로 설명하며, 이는 본질적으로 정수인 Hadoop 특화된 클래스이다. 또한 클래스 절에서 처음 두 개의 유형은 LongWritable과 Text이며, 이는 각각 바이트 개수와 텍스트의 행임을 참고하자.

클래스 정의에서 유형 절로 인해 map 메소드로 수신되는 매개변수 유형은 context.write 절 내에서 이 메소드의 출력과 함께 설정된다. 다른 것을 지정하려고 시도하면, 컴파일러 문제가 발생하거나 Hadoop에서 유형 불일치를 설명하는 메시지가 표시되며 오류가 나타날 것이다.

public class EarthQuakesPerDateMapper extends Mapper<LongWritable, 
  Text, Text, IntWritable> {
 @Override
 protected void map(LongWritable key, Text value, Context context) throws IOException,
   InterruptedException {

  if (key.get() > 0) {
   try {
     CSVParser parser = new CSVParser();
     String[] lines = parser.parseLine(value.toString());

     SimpleDateFormat formatter = 
       new SimpleDateFormat("EEEEE, MMMMM dd, yyyy HH:mm:ss Z");
     Date dt = formatter.parse(lines[3]);
     formatter.applyPattern("dd-MM-yyyy");

     String dtstr = formatter.format(dt);
     context.write(new Text(dtstr), new IntWritable(1));
   } catch (ParseException e) {}
  }
 }
}

리스트 6에서 map 구현은 간단하다. 즉, Hadoop은 기본적으로 입력 파일에서 발견하는 텍스트의 각 행에 대해 이 클래스를 호출한다. CSV의 헤더를 처리하려는 시도를 방지하기 위해 먼저, 바이트 개수(key 오브젝트)가 0이 아닌지 확인한다. 그 다음에, 목록 4와 5에서 이미 확인한 것을 수행한다. 즉, 수신되는 날짜를 취하여 변환한 다음에 이를 발신 키로 설정한다. 또한 하나의 개수인 1을 제공한다. 다시 말해서, 각 날짜에 대해 카운터를 코드했으며 reduce 구현이 호출될 때에, 키와 값의 콜렉션을 받을 것이다. 이 경우에 키는 리스트 7과 같이 날짜와 그 값이 될 것이다.

"13-12-2010":[1,1,1,1,1,1,1,1]
"14-12-2010":[1,1,1,1,1,1]
"15-12-2010":[1,1,1,1,1,1,1,1,1]

context.write(new Text(dtstr), new IntWritable(1))(리스트 6에 있음) 행이 리스트 7과 같이 논리적 콜렉션을 빌드하였음을 참고하자. 아마 이미 확인한 대로, context는 다양한 정보 부분을 보유하는 Hadoop 데이터 구조이다. 이 context는 reduce 구현으로 전달되며, 이는 이러한 1 값들을 취하고 이를 합할 것이다. 결과적으로, reduce 구현은 논리적으로 다음 리스트 8에서와 같은 데이터 구조를 작성한다.

"13-12-2010":8
"14-12-2010":6
"15-12-2010":9

reduce 구현이 리스트 9에 표시된다. Hadoop의 Mapper인 Reducer는 매개변수화되었다. 즉, 처음 두 개의 매개변수는 수신되는 키 유형(Text)과 값 유형(IntWritable)이고, 나중 두 개의 매개변수는 출력 유형인 키와 값이며, 이 경우에 이는 동일하다.

public class EarthQuakesPerDateReducer extends Reducer<Text, IntWritable, Text, 
  IntWritable> {
 @Override
 protected void reduce(Text key, Iterable<IntWritable> values, Context context)
  throws IOException, InterruptedException {
  int count = 0;
  for (IntWritable value : values) {
   count++;
  }
  context.write(key, new IntWritable(count));
 }
}

reduce 구현은 지극히 간단하다. 리스트 7에서 지적한 대로, 수신되는 값은 실제로 값의 콜렉션이며, 이 경우에는 1 값들의 콜렉션을 의미한다. 필자가 수행하는 것은 이를 합한 다음, 날짜와 개수를 표현하는 새로운 키-값 쌍을 작성하는 것이다. 그 다음에 reduce 코드가 기본적으로 리스트 8에서 확인한 행을 산출한다. 논리적 플로우는 다음과 같다.

"13-12-2010":[1,1,1,1,1,1,1,1] -> "13-12-2010":8

이 목록의 요약 양식은 물론, map -> reduce이다.

위로

Hadoop Job 정의하기

이제 map과 reduce 구현을 코드 작성했으니, 남은 일은 Hadoop Job으로 모두 연결하는 것이다. Job을 정의하는 것은 간단하다. 즉, 입력과 출력인 map과 reduce 구현(리스트 6 및 리스트 9에 표시됨) 및 출력 유형을 제공한다. 이 경우에 출력 유형은 reduce 구현에 사용되는 것과 동일하다.

public class EarthQuakesPerDayJob {

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

  Job job = new Job();
  job.setJarByClass(EarthQuakesPerDayJob.class);
  FileInputFormat.addInputPath(job, new Path(args[0]));
  FileOutputFormat.setOutputPath(job, new Path(args[1]));

  job.setMapperClass(EarthQuakesPerDateMapper.class);
  job.setReducerClass(EarthQuakesPerDateReducer.class);
  job.setOutputKeyClass(Text.class);
  job.setOutputValueClass(IntWritable.class);

  System.exit(job.waitForCompletion(true) ? 0 : 1);
 }
}

리스트 10에서 두 개의 매개변수를 취하는 main 메소드로 모두 함께 묶었다. 즉, 이는 지진 CSV 파일인 디렉토리와 결과 보고서가 작성되어야 하는 디렉토리(Hadoop은 이 디렉토리를 작성하는 것을 선호함)이다.

이러한 작은 프레임워크를 실행하려면 이러한 클래스를 jar로 해야 할 것이다. 또한 Hadoop에 opencsv 바이너리를 찾을 수 있는 위치를 알려야 할 것이다. 그 다음에 리스트 11과 같이 명령행을 통해 Hadoop을 실행할 수 있다.

$> export HADOOP_CLASSPATH=lib/opencsv-2.2.jar
$> hadoop jar target/quake.jar com.b50.hadoop.quake.EarthQuakesPerDayJob
   ~/temp/mreduce/in/ ~/temp/mreduce/out

이 코드를 실행하면, Hadoop이 그 작업 수행을 시작하면 화면에 많은 텍스트가 날라다니는 것을 확인할 것이다. 사용 중인 CSV 파일은 Hadoop이 처리하기 위해 빌드한 큰 개와 비교하면 강아지에 불과하다는 점을 유의하자. 처리 성능에 따라 Hadoop은 수 초 내에 이를 완료해야 한다.

완료하면 가상으로 편집기를 통해 출력 파일의 컨텐츠를 볼 수 있다. 또 다른 옵션은 리스트 12에서 수행한 것처럼 hadoop 명령을 직접 사용하는 것이다.

$> hadoop dfs -cat part-r-00000 
05-12-2010      43
06-12-2010      143
07-12-2010      112
08-12-2010      136
09-12-2010      178
10-12-2010      114
11-12-2010      114
12-12-2010      79

독자가 필자와 비슷하다면 리스트 12에서 확인할 첫 번째 내용은 일일 지진의 수 그 자체이다 — 12월 9일에 178만 있다! Hadoop이 필자가 수행하려는 바로 그것을 수행했다는 점도 인식하길 바란다. 필자의 범위 내 모든 날짜에 대해 지진 발생 수를 깔끔하게 표로 만들었다.

위로

또 다른 Mapper 쓰기

다음으로, 지진이 발생하는 위치를 알아내고, 어느 위치가 날짜 범위에서 대부분의 지진을 로그하는지 어떻게든 빠르게 측정하고자 한다. 자, 아마 추측한 대로, Hadoop을 통해 그렇게 간편하게 수행된다. 이 경우에 키는 날짜가 아니라 위치이다. 따라서, 새 Mapper 클래스를 쓴다.

public class EarthQuakeLocationMapper extends Mapper<LongWritable, Text, Text,
  IntWritable> {
 @Override
 protected void map(LongWritable key, Text value, Context context) throws IOException,
  InterruptedException {
  if (key.get() > 0) {
   String[] lines = new CSVParser().parseLine(value.toString());
   context.write(new Text(lines[9]), new IntWritable(1));
  }
 }
}

날짜를 확보하고 이를 변환하는 것이 아니라, 리스트 13에서 수행한 전부는 위치를 취하는 것이었으며, 이는 CSV 배열에서 최종 위치상의 항목이었다.

위치와 그 숫자의 거대한 목록이 아니라, 결과를 어느 7일 기간에나 10회 이상의 지진이 나타난 위치로 제한하려고 한다.

public class EarthQuakeLocationReducer extends Reducer<Text, IntWritable, Text,
  IntWritable> {
 @Override
 protected void reduce(Text key, Iterable<IntWritable> values, Context context)
  throws IOException, InterruptedException {
  int count = 0;
  for (IntWritable value : values) {
   count++;
  }
  if (count >= 10) {
   context.write(key, new IntWritable(count));
  }
 }
}

리스트 14에서 코드는 리스트 9에 있는 것과 매우 유사하다. 하지만 이 경우에 10개 이상의 합으로 출력을 제한했다. 그 다음으로, 새로운 답변을 얻기 위해 map과 reduce를 또 다른 Job 구현과 묶고, jar로 만들어 Hadoop을 정상으로 실행할 수 있다.

hadoop dfs 명령을 실행하면 다음과 같이 요청한 새 값을 표시한다.

$> hadoop dfs -cat part-r-00000 
Andreanof Islands, Aleutian Islands, Alaska     24
Arkansas        40
Baja California, Mexico 101
Central Alaska  74
Central California      68
Greater Los Angeles area, California    16
Island of Hawaii, Hawaii        16
Kenai Peninsula, Alaska 11
Nevada  15
Northern California     114
San Francisco Bay area, California      21
Southern Alaska 97
Southern California     115
Utah    19
western Montana 11

리스트 15에서 배울 내용은 무엇인가? 자, 먼저 멕시코에서 알래스카에 이르는 북미의 서부 해안은 불안정한 지역이다. 두 번째로, 아칸소는 명백히 단층선 근처에 위치하고 있으며, 이는 필자가 인식하지 못한 점이다. 마지막으로 독자가 북부 또는 남부 캘리포니아(많은 소프트웨어 개발자들이 거주함)에 산다면 독자 주변의 지반은 대략 매 13분마다 흔들린다.

위로

결론

Hadoop으로 데이터를 분석하는 것은 간편하고 효율적이므로, 데이터 분석을 위해 제공해야 하는 내용조차도 수박 겉핥기식으로 다루지 않았다. Hadoop은 실제로 map과 reduce를 실행하는 다양한 노드의 조정을 처리하는 분산된 방식으로 실행하도록 설계되었다. 예제의 목적을 위해 이 기사에서 보잘 것 없는 파일 하나로 하나의 JVM에서 Hadoop을 실행했다.

Hadoop은 보유하기에 그 자체로 탁월한 도구이며, 또한 이와 관련하여 하위 프로젝트에서부터 클라우드 기반 Hadoop 서비스에 이르기까지 전체적이며 성장하는 에코시스템도 있다. Hadoop 에코시스템은 프로젝트 배후에 풍부한 커뮤니티를 시연한다. 커뮤니티에서 파생된 많은 도구들은 전역 비즈니스 활동으로 대용량 데이터 분석의 실행 가능성을 보여준다. Hadoop을 통해 분산 데이터 마이닝과 분석은 Google과 Yahoo!를 포함하지만 이에 국한되지 않은 모든 종류의 소프트웨어 혁신자와 기업가들이 사용할 수 있다.

참고자료

교육

• Java development 2.0: 이 dW 시리즈에서는 Java 개발 환경을 다시 정의하는 각종 기술을 탐구한다. 최신 주제로는 MongoDB(2010년 9월), CouchDB(2009년 11월) 및 Objectify AppEngine(2010년 11월)이 있다.
  
  
• "Hadoop을 이용한 분산 데이터 처리, Part 1: 시작"(M. Tim Jones저, developerWorks, 2010년 5월): 이 기사는 — 시리즈의 첫 번째 — HDFS(Hadoop file system)와 일반적으로 사용되는 노드 유형을 비롯한 Hadoop 프레임워크에 대해 살펴본다. 단일 노드 Hadoop 클러스터를 설치 및 구성하는 방법을 학습한 후 MapReduce 애플리케이션에 대해 자세히 설명한다. 마지막으로 Hadoop의 핵심 웹 인터페이스를 사용하여 Hadoop을 모니터링 및 관리하는 방법에 대해 살펴본다. 또한 Part 2와 Part 3도 참조한다.
  
  
• "클라우드에서 MapReduce 및 로드 밸런싱 사용하기(Kirpal A. Venkatesh 외 저, developerWorks, 2010년 7월): Hadoop MapReduce 및 가상화로 노드 성능을 개선하는 방법을 배워보자.
  
  
• "A profile of Apache Hadoop MapReduce computing efficiency, Part 1"(Paul Burkhardt저, Cloudera Development Center, 2010년 12월): MapReduce 애플리케이션이 얼마나 효율적으로 컴퓨팅 자원을 사용하는지에 대한 두 개의 파트로 된 설명이다. 처음 반은 Hadoop MapReduce 애플리케이션을 평가하는 것과 관련되는 컴퓨팅 효율성의 개요이다.
  
  
• "Hadoop companies everywhere"(Alex Handy저, SD Times, 2009년 7월): 회사는 매일 데이터를 더 많이 생성하지만, 이들 중 많은 수가 비즈니스 인텔리전스를 이끌어내지 않는다. 이는 기회라고 쓰고 Handy라고 읽는다.
  
  
• 이런 기술 주제와 다른 기술 주제에 대한 서적 정보는 Java technology bookstore를 참조한다.
  
  
• developerWorks Java 기술 영역: Java 프로그래밍과 관련된 모든 주제를 다루는 여러 편의 기사를 찾아보자.
  
  

제품 및 기술 얻기

• Hadoop MapReduce 다운로드: Apache Software Foundation 프로젝트.
  
  
• opencsv 받기: SourceForge에서 다운로드한다.
  
  

토론

• developerWorks 커뮤니티에 참여하자. 개발자가 이끌고 있는 블로그, 포럼, 그룹 및 Wiki를 살펴보면서 다른 developerWorks 사용자와 의견을 나눌 수 있다.
  
  

필자소개

Andrew Glover는 Stelligent Incorporated의 사장이다. 회사들이 코드 품질을 일찍 그리고 자주 모니터할 수 있게 하는 효과적인 개발자 테스팅 전략과 지속적 통합 기법으로 소프트웨어 품질 문제를 해결하는 것을 돕고 있다. Andy의 저서 목록은 그의 블로그를 보라.

-- class 주석

/**
* <PRE>
* 보세운송 조회를 한다.
* </PRE>
* @author anhanho
* @version 1.0
* @since 13/10/2011
* @modified
* @modifier
*/

-- method 주석

/**
  * @description 행정몰수  게시 (5일 ) + 48시간을  지나면  행정몰수확정이 된다.
  * @param List arg0
  * @return void
  * @throws Exception
  */

junit 에 VM 설정과 eclips.ini 에 설정은 다름...

출처 : http://stackoverflow.com/questions/109383/how-to-sort-a-mapkey-value-on-the-values-in-java

It seems much easier than all of the foregoing. Use a TreeMap as follows:

public class Testing { 
 
    public static void main(String[] args) { 
 
        HashMap<String,Double> map = new HashMap<String,Double>(); 
        ValueComparator bvc =  new ValueComparator(map); 
        TreeMap<String,Double> sorted_map = new TreeMap<String,Double>(bvc); 
 
        map.put("A",99.5); 
        map.put("B",67.4); 
        map.put("C",67.4); 
        map.put("D",67.3); 
 
        System.out.println("unsorted map: "+map); 
 
        sorted_map.putAll(map); 
 
        System.out.println("results: "+sorted_map); 
    } 
} 
 
class ValueComparator implements Comparator<String> { 
 
    Map<String, Double> base; 
    public ValueComparator(Map<String, Double> base) { 
        this.base = base; 
    } 
 
    // Note: this comparator imposes orderings that are inconsistent with equals.     
    public int compare(String a, String b) { 
        if (base.get(a) >= base.get(b)) { 
            return -1; 
        } else { 
            return 1; 
        } // returning 0 would merge keys 
    } 
} 

Output:

    unsorted map: {D=67.3, A=99.5, B=67.4, C=67.4}
    results: {D=67.3, B=67.4, C=67.4, A=99.5}
    

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import javax.imageio.ImageIO;

public class CommonUtil {
 public CommonUtil(){
 }
 
 /**
  * 썸네일 만들기
  * @param width
  * @param height
  * @param loadFile
  * @param saveFile
  * @param zoom
  * @throws IOException
  */
 public static void createThumbnail(int width, int height, String loadFile, String saveFile, int zoom) throws IOException{
  File save = new File(saveFile.replaceAll("/", "\\"+File.separator));
  FileInputStream fis = new FileInputStream(loadFile.replaceAll("/", "\\"+File.separator));
  BufferedImage im = ImageIO.read(fis);
  
  if (zoom<=0) zoom = 1;
  
  BufferedImage thumb = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
  Graphics2D g2 = thumb.createGraphics();
  
  g2.drawImage(im, 0, 0, width, height, null);
  ImageIO.write(thumb, "jpg", save);
 }
 
 
 /**
  * 썸네일 삭제
  * @param thumbnail_path
  */
 public static void deleteThumbnail(String thumbnail_path){
  File file = new File(thumbnail_path);
  if(file.exists()){
   file.delete();
  }
 }
 
 public static void main(String args[]){
  String loadFile = "http://localhost:8080/2010/07/15/LZHABUhgGy1279183572640.JPG";
  String saveFile = "D://dev/test.jpg";
  int zoom = 5;
  
  try {
   CommonUtil.createThumbnail(124, 144, loadFile, saveFile, zoom);
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

출처 : http://pskppoppo.egloos.com/2994706

사용자의 로그정보가 필요해 아래와같이 간단하게 만들어봤다.

public void makeFreePaidLog(HttpServletRequest request, String academyCode, String date) throws IOException, Exception{
StringBuffer sb = new StringBuffer();
SimpleDateFormat formatter = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss.SSS");

Calendar cal = Calendar.getInstance();
String today = formatter.format(cal.getTime());

String str = "[" +today + "]";
sb.append("Browser Info = " + request.getHeader("User-AGENT") + " MIS_ID = " + SessionUtil.getMis_Id(request));
sb.append(", USER_NM = " + SessionUtil.getUserNm(request) + ", ACAD_CD = " + academyCode);
String log = str + sb.toString();

try{
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\FreePaidLog_"+date+".txt", true));
bw.write(log);
bw.newLine();
bw.flush();
bw.close();
}catch(IOException ie){
System.err.println("Error");
System.exit(1);
}
}

위에서 중요한 부분은 new FileWriter()하는부분. 뭐가 문제인지는 모르겠으나 FileWriter 객체 생성할때 다른 class나 새로운 객체를 생성하여 매개인자로 넣으면 에러가난다.

간단하긴 한걸까...

java.util.Calendar cal = java.util.Calendar.getInstance(); //일단 Calendar 객체

int year = 2011; //수능일 기준으로 잡아봤다.
int month = 11;
int date = 10;

long now_day = cal.getTimeInMillis(); //현재 시간

cal.set(year, month-1, date); //목표일을 cal에 set

long event_day = cal.getTimeInMillis(); //목표일에 대한 시간
long d_day = (event_day - now_day) / (60*60*24*1000);

일단 목표일이 현재 일보다는 커야한다는 조건이 붙어야 한다. 이걸 parameter 세개 받아서 며칠남았는지 딱딱 return 시켜주는 공통 method로 만들어 봐야하는데 지금 귀찮음.

사용자의 로그정보가 필요해 아래와같이 간단하게 만들어봤다.

public void makeFreePaidLog(HttpServletRequest request, String academyCode, String date) throws IOException, Exception{
StringBuffer sb = new StringBuffer();
SimpleDateFormat formatter = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss.SSS");

Calendar cal = Calendar.getInstance();
String today = formatter.format(cal.getTime());

String str = "[" +today + "]";
sb.append("Browser Info = " + request.getHeader("User-AGENT") + " MIS_ID = " + SessionUtil.getMis_Id(request));
sb.append(", USER_NM = " + SessionUtil.getUserNm(request) + ", ACAD_CD = " + academyCode);
String log = str + sb.toString();

try{
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\FreePaidLog_"+date+".txt", true));
bw.write(log);
bw.newLine();
bw.flush();
bw.close();
}catch(IOException ie){
System.err.println("Error");
System.exit(1);
}
}

위에서 중요한 부분은 new FileWriter()하는부분. 뭐가 문제인지는 모르겠으나 FileWriter 객체 생성할때 다른 class나 새로운 객체를 생성하여 매개인자로 넣으면 에러가난다.

출처 : http://joke00.tistory.com/69

자바 책을 훑어보던 중.
Exception 관련해서 assertion 부분이 나왔다. ( 왜.. 예전엔 미처 몰랐을까;;;;)

assertion 은 디버깅시에 익셉션 에러 검증 구문으로 인용하기 쉽다.
throws 나 try ~ catch 블럭과 동일한 역할을 합니다.

사용법
---------------------------------------------------------------------------------------------
assert [ true or false 를 나타내는검증구문] : [검증에서 false 발생시 출력할 내용]
---------------------------------------------------------------------------------------------

1. 이클립스를 열어 테스트를 하나 만듭니다.

2. 해당 프로젝트를 선택 후 마우스 오른쪽을 누르면 properties 를 눌러 Run/Debug Settings 를 선택합니다.
해당 프로젝트가 보이네요~ edit 를 누릅니다

3. Arguments 탭으로 이동후 VM arguments 를 입력합니다.
-ea 는 assertion 실행
-ea:클래스명 : 해당 클래스만 assetion 을 실행
-ea:... : 현재 패키지 내에 있는 클래스들만 assertion 실행
-ea<package명> : 해당 package 명 내의 클래스들만 assetion 실행

-da 로 했을 경우에는 반대로 해당되는 경우에만 assertion 을 실행시키지 않음

4. ctrl + f11 을 눌러 실행을 시킵니다.
아름과 같은 익셉션 구문과 함께 어디서 익셉션이 났는지를 알려준답니다 ^^

Quick Start

Have you downloaded? Good. Now let’s get your first compiled spreadsheet up and running. I’ll show you how to…

• create a spreadsheet defining a customized line item price computation,
• make AFC compile it to Java classes,
• use those classes in your application,
• look at the generated code, and
• save and reload the classes from a .jar file.

The Problem

This is a fictional example about finding the total price for a line item with

• a base article price,
• a count of items, and
• the customer category (for automatic rebates).

We will flesh out the following bit of code:

// Compile price finding factory and strategy implementation from spreadsheet:
EngineBuilder builder = SpreadsheetCompiler.newEngineBuilder();
builder.loadSpreadsheet( new File( PATH, "CustomPriceFormula.xls" ) );
builder.setFactoryClass( PriceFinderFactory.class );
builder.bindAllByName();
Engine engine = builder.compile();
PriceFinderFactory factory = (PriceFinderFactory) engine.getComputationFactory();

// Use it to compute a line item price:
LineItem item = getCurrentLineItem();
PriceFinder priceFinder = factory.newInstance( item );
BigDecimal price = priceFinder.getPrice();

The Spreadsheet

Here’s the spreadsheet-defined formula our user wants the application to use:

Please create this spreadsheet now and save it somewhere under the name CustomPriceFormula.xls.

The Project

Create a new Java project for this demo application now. Add to it references to the following libraries you obtained from the download:

build/formulacompiler-runtime.jar
build/formulacompiler-compiler.jar
build/formulacompiler-spreadsheet.jar
build/formulacompiler-spreadsheet-excel-xls.jar
build/formulacompiler-decompiler.jar
build/lib/asm-x.y.jar
build/lib/asm-commons-x.y.jar
build/lib/jxl.jar
build/lib/jode-decompiler.jar

Then create a main class in it. Unless your IDE can find and organize imports automatically, you might also want to add these to your main class:

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.math.BigDecimal;

import org.formulacompiler.compiler.CompilerException;
import org.formulacompiler.compiler.SaveableEngine;
import org.formulacompiler.decompiler.ByteCodeEngineSource;
import org.formulacompiler.decompiler.FormulaDecompiler;
import org.formulacompiler.runtime.Engine;
import org.formulacompiler.runtime.EngineException;
import org.formulacompiler.runtime.FormulaRuntime;
import org.formulacompiler.spreadsheet.EngineBuilder;
import org.formulacompiler.spreadsheet.SpreadsheetCompiler;

The Interfaces

In essence, what AFC compiles from the spreadsheet is a computation strategy implementation. So we need the customary factory and doer interfaces that go with a strategy:

public static interface PriceFinder {
  BigDecimal getPrice();
}

public static interface PriceFinderFactory {
  PriceFinder newInstance( LineItem item );
}

Paste these directly into your main class (they are nested classes in this example, but AFC is just as happy with top-level classes).

We’ll also need the line item, which provides input data to the computation:

public static class LineItem {
  public BigDecimal getArticlePrice() { return BigDecimal.valueOf( 112.00 ); } 
  public int getItemCount() { return 10; }
  public String getCustomerCategory() { return "B"; }
}

It’s obviously a dummy. Paste it into the main class as well, together with the following dummy getter:

private LineItem getCurrentLineItem() {
  return new LineItem();
}

The Compilation

We’re ready to compile now. Add the following two methods, that I’ll explain shortly:

private SaveableEngine compile() throws FileNotFoundException, IOException, CompilerException, EngineException
{
  EngineBuilder builder = SpreadsheetCompiler.newEngineBuilder();
  builder.loadSpreadsheet( new File( PATH, "CustomPriceFormula.xls" ) );
  builder.setFactoryClass( PriceFinderFactory.class );
  builder.bindAllByName();
  return builder.compile();
}

private PriceFinderFactory factoryFor( Engine engine )
{
  return (PriceFinderFactory) engine.getComputationFactory();
}

Also add a constant for the path where you saved the spreadsheet. In my code, it’s:

public static final File PATH = new File( "src/test/data/org/formulacompiler/tutorials" );

Let’s go through this now:

• First, we get a new engine builder. It gives us a simplified API onto AFC.

• We tell the builder to load the spreadsheet you created earlier on. AFC detects the appropriate loader to use by the file’s extension. It currently supports Microsoft Excel (.xls) and OpenOffice Calc (.ods), and maybe others – check the release notes for details.

• We inform the builder of our factory class. It can usually infer from this the input interface, LineItem, and the output interface, PriceFinder, by itself (if not, you can given them explicitly; you can then also omit the factory interface altogether).

• We tell the builder to bind spreadsheet cells to our interface methods by name. In short, any cell named after a method on the input interface, LineItem, gets its value from that method in the compiled formula. A cell named after a method on the output interface, PriceFinder, is used to implement that method. (The binder is smart about dropping the get prefix on method names and is not case sensitive.)

• But wait, we don’t have any cell names in this spreadsheet. What’s going on? AFC automatically creates cell names from row titles (string values in column A are applied as names for corresponding cells in column B) when a sheet has no cell names and you use bindAllByName().

• That’s it. We tell the builder to compile the thing. It returns a so-called engine (which we’ll later use to save, reload, and decompile), but the most important method on the engine is the one we use on our second method: getComputationFactory().

The Computation

We now look at how the resulting price finder is used. Since AFC compiles spreadsheets to regular JVM classes, there’s no magic at all when using a precompiled computation:

private BigDecimal compute( PriceFinderFactory factory )
{
  PriceFinder priceFinder = factory.newInstance( getCurrentLineItem() );
  return priceFinder.getPrice();
}

So let’s make this runnable:

public static void main( String[] args ) throws Exception
{
  QuickStart app = new QuickStart();
  SaveableEngine engine = app.compile();
  PriceFinderFactory factory = app.factoryFor( engine );
  BigDecimal price = app.compute( factory );
  System.out.println( "The result is " + price );
}

Go ahead. Run it.

The Code

Would you also like to know just what exactly the generated PriceFinder implementation does? You can. AFC wraps a nifty external library, Jode, to decompile generated code to plain Java source again for just this purpose. Let’s use this:

private void decompile( SaveableEngine engine ) throws Exception
{
  ByteCodeEngineSource source = FormulaDecompiler.decompile( engine );
  source.saveTo( new File( "temp/test/decompiled/quickstart" ) );
}

You can change the output folder, of course. Now add the following at the end of the main method:

app.decompile( engine );

Run it again. Then look into the output folder. You should find the following there. First, the generated computation:

package org.formulacompiler.gen;
import java.math.BigDecimal;

import org.formulacompiler.runtime.Computation;
import org.formulacompiler.runtime.FormulaException;
import org.formulacompiler.runtime.internal.Environment;
import org.formulacompiler.runtime.internal.RuntimeDouble_v2;
import org.formulacompiler.runtime.internal.Runtime_v2;
import org.formulacompiler.tutorials.QuickStart;

final class $Root implements Computation, QuickStart.PriceFinder
{
    private final QuickStart.LineItem $inputs;
    final Environment $environment;
    private String[] $constarr$0;
    
    $Root(QuickStart.LineItem lineitem, Environment environment) {
        $environment = environment;
        $inputs = lineitem;
    }
    
    final double get$0() {
        return (get$1() * get$2()
                * (1.0 - $idx$0(Runtime_v2.fun_MATCH_Ascending(get$3(),
                                                               $constarr$0(),
                                                               $environment)
                                - 1)));
    }
    
    public final BigDecimal getPrice() {
        return BigDecimal.valueOf(Runtime_v2.checkDouble(get$0()));
    }
    
    final String[] $constarr$0() {
        if ($constarr$0 == null)
            $constarr$0 = new String[] { "A", "B", "C", "D" };
        return $constarr$0;
    }
    
    final double $idx$0(int i) {
        switch (i) {
        case 0:
            return 0.06;
        case 1:
            return 0.04;
        case 2:
            return 0.01;
        case 3:
            return 0.0;
        default:
            throw new FormulaException
                      ("#VALUE/REF! because index is out of range in INDEX");
        }
    }
    
    final double get$1() {
        return RuntimeDouble_v2.numberToNum($inputs.getArticlePrice());
    }
    
    final double get$2() {
        return (double) $inputs.getItemCount();
    }
    
    final String get$3() {
        return Runtime_v2.stringFromString($inputs.getCustomerCategory());
    }
}

Second, it’s corresponding factory:

package org.formulacompiler.gen;
import org.formulacompiler.runtime.Computation;
import org.formulacompiler.runtime.ComputationFactory;
import org.formulacompiler.runtime.internal.Environment;
import org.formulacompiler.tutorials.QuickStart;

public final class $Factory
    implements ComputationFactory, QuickStart.PriceFinderFactory
{
    private final Environment $environment;
    
    public $Factory(Environment environment) {
        $environment = environment;
    }
    
    public final Computation newComputation(Object object) {
        return new $Root((QuickStart.LineItem) object, $environment);
    }
    
    public final QuickStart.PriceFinder newInstance
        (QuickStart.LineItem lineitem) {
        return new $Root(lineitem, $environment);
    }
}

The Runtime

Computations compiled by AFC are plain compiled Java classes. They rely only on a single small runtime library, formulacompiler-runtime.jar. So it’s good practice to simply save them to a .jar file and reuse them from there across application starts (or to even split the compiling application from the using application). However, they do require a special classloader. AFC therefore provides special methods to save and load engines properly.

First, let’s save our engine:

private void save( SaveableEngine engine ) throws Exception
{
  engine.saveTo( new FileOutputStream( "temp/test/CustomPriceFormula.jar" ) );
}

Loading it back is just as easy:

private Engine load() throws Exception
{
  return FormulaRuntime.loadEngine( new FileInputStream( "temp/test/CustomPriceFormula.jar" ) );
}

Again, add the following to the main method to make it runnable:

app.save( engine );

QuickStart app2 = new QuickStart();
Engine engine2 = app2.load();
PriceFinderFactory factory2 = app2.factoryFor( engine2 );
BigDecimal price2 = app2.compute( factory2 );
System.out.println( "The result is " + price2 );

Alright. Run it.

Summary

As promised, you just…

• created a spreadsheet defining a customized line item price computation,
• made AFC compile it to Java classes,
• used those classes in your application,
• looked at the generated code in Java source form, and
• saved and reloaded the classes from a .jar file.

Hopefully, you also played around with the spreadsheet, compiling different formulas. You really should.

Not bad. Now learn more about the goals, the design, the API, and the supported functions of AFC.

출처: http://realcool.egloos.com/3924002

엑셀의 함수를 자바로 구현할 일이 있어서 찾아본 결과

http://www.formulacompiler.org/doc/reference/index.htm

위의 사이트를 어렵게 찾았습니다.

위의 사이트에서 라이브러리 다운받으시고

필요한 엑셀함수를 호출해서 사용하면 됩니다.

하나만 예로 들어 만들어보면 다음과 같습니다.

엑셀의 chiinv를 예로 들면 다음과 같습니다.

import org.formulacompiler.runtime.internal.RuntimeDouble_v2;

/**
* 카이제곱분포
* @author realcool@empal.com
*
*/
public class Chiinv {
/**
* 카이제곱분포
* @param a
* @param b
* @return
*/
public double chiinv(double _x,double _degFreedom){
return RuntimeDouble_v2.fun_CHIINV(_x, _degFreedom);
}
final double NORMDIST(double input1,double input2,double input3,double input4) {
double d;
if (input3 <= 0.0) {
Runtime_v2.fun_ERROR("#NUM! because sigma <= 0 in NORMDIST");
d = (double) -1;
} else
d = (input4 != 0.0
? (Math.abs((input1 - input2) / input3
* 0.7071067811865476) < 0.7071067811865476
? (0.5
+ 0.5 * RuntimeDouble_v2.fun_ERF((input1 - input2)
/ input3
* 0.7071067811865476))
: (input1 - input2) / input3 * 0.7071067811865476 > 0.0
? 1.0 - 0.5 * (RuntimeDouble_v2.fun_ERFC
(Math.abs((input1 - input2) / input3
* 0.7071067811865476)))
: 0.5 * (RuntimeDouble_v2.fun_ERFC
(Math.abs((input1 - input2) / input3
* 0.7071067811865476))))
: (Math.exp((input1 - input2) * (input1 - input2)
/ (-2.0 * input3 * input3))
/ (2.5066282746310002 * input3)));
return d;
}
public static void main(String[] args){
Chiinv c = new Chiinv();
double d = c.chiinv(0.05, 2);
System.out.println(d);
}
}

Since AFC only supports Microsoft Excel spreadsheet semantics at the moment, this reference uses Excel as a baseline for expected behaviour of the supported functions.

Cells, Values, Names

Strings, numbers, dates, booleans; blank cells; cell names; ranges; numeric precision

Numeric Operators

%, *, +, -, /, <, <=, <>, =, >, >=, ^

Numeric Functions

ABS, ACOS, ACOSH, ASIN, ASINH, ATAN, ATAN2, ATANH, CEILING, COMBIN, COS, COSH, DEGREES, EVEN, EXP, FACT, FLOOR, GEOMEAN, HARMEAN, INT, LN, LOG, LOG10, MOD, ODD, PERMUT, PI, POWER, RADIANS, RAND, ROUND, ROUNDDOWN, ROUNDUP, SIGN, SIN, SINH, SQRT, TAN, TANH, TRUNC

Financial Functions

DB, DDB, FV, IRR, MIRR, NPER, NPV, PMT, PV, RATE, SLN, SYD, VDB

Statistical Functions

AVEDEV, BETADIST, BETAINV, BINOMDIST, CHIDIST, CHIINV, CHITEST, CONFIDENCE, CORREL, CRITBINOM, DEVSQ, EXPONDIST, FDIST, FINV, FISHER, FISHERINV, FORECAST, FTEST, GAMMADIST, GAMMAINV, GAMMALN, HYPGEOMDIST, INTERCEPT, KURT, LARGE, LOGINV, LOGNORMDIST, MEDIAN, MODE, NEGBINOMDIST, NORMDIST, NORMINV, NORMSDIST, NORMSINV, PEARSON, PERCENTILE, PERCENTRANK, POISSON, PROB, QUARTILE, RANK, RSQ, SKEW, SLOPE, SMALL, STANDARDIZE, STDEV, STDEVP, STDEVPA, STEYX, SUMX2MY2, SUMX2PY2, SUMXMY2, TDIST, TINV, TRIMMEAN, TTEST, VAR, VARA, VARP, WEIBULL, ZTEST

String Support

&, <, <=, <>, =, >, >=, CLEAN, CONCATENATE, EXACT, FIND, LEFT, LEN, LOWER, MATCH, MID, PROPER, REPLACE, REPT, RIGHT, SEARCH, SUBSTITUTE, TRIM, UPPER

Boolean Functions And IF

AND, IF, NOT, OR, true

Date Functions

DATE, DAY, DAYS360, HOUR, MINUTE, MONTH, NOW, SECOND, TIME, TODAY, WEEKDAY, YEAR

Conversion Functions

CHAR, CODE, DATEVALUE, DOLLAR, FIXED, N, ROMAN, T, TEXT, TIMEVALUE, VALUE

Type Functions

ISNONTEXT, ISNUMBER, ISTEXT

Aggregators

AVEDEV, AVERAGE, COUNT, COUNTA, COVAR, DEVSQ, KURT, MAX, MIN, PRODUCT, SKEW, STDEV, STDEVP, SUM, SUMIF, SUMSQ, VAR, VARP

Database Table Aggregators

COUNTIF, DAVERAGE, DCOUNT, DCOUNTA, DGET, DMAX, DMIN, DPRODUCT, DSTDEV, DSTDEVP, DSUM, DVAR, DVARP, SUMIF

Lookup Functions

CHOOSE, HLOOKUP, INDEX, LOOKUP, MATCH, VLOOKUP

Limitations

Things that are known to not work quite as expected yet.

Note On The Sample Expressions

To ensure its correctness, all the example expressions and their results have been cited from automated tests that are run with every release build.

이 글과 관련있는 글을 자동검색한 결과입니다 [?]

• 엑셀 함수들 by nixon

# by 수평선 | 2009/01/18 19:54 | 자바코드 | 트랙백 | 덧글(2)

트랙백 주소 : http://realcool.egloos.com/tb/3924002
☞ 내 이글루에 이 글과 관련된 글 쓰기 (트랙백 보내기) [도움말]

Commented by 노태광 at 2009/03/11 11:07

정말 좋은 자료를 찾았어요. 너무 감사드립니다.
한가지 여쭤보고 싶은게 있는데요.
NORMDIST 함수를 사용하고 싶은데. 라이브러리에 포함되어 있지 않은 것 같아서요.
제가 잘 몰라서 못찾는 것 같은데. 좀 알려주시면 고맙겠습니다.^^*

Commented by 수평선 at 2009/03/23 10:26

찾으시는 자료가 혹시 다음일거라 생각되네요..
package JSci.maths.statistics;

import JSci.maths.*;

/**
* The NormalDistribution class provides an object for encapsulating normal distributions.
* @version 1.1
* @author Jaco van Kooten
*/
public final class NormalDistribution extends ProbabilityDistribution implements NumericalConstants {
private double mean,variance;
private double pdfDenominator,cdfDenominator;

/**
* Constructs the standard normal distribution (zero mean and unity variance).
*/
public NormalDistribution() {
this(0.0,1.0);
}
/**
* Constructs a normal distribution.
* @param mu the mean.
* @param var the variance.
*/
public NormalDistribution(double mu,double var) {
mean=mu;
if(var<=0.0)
throw new OutOfRangeException("The variance should be (strictly) positive.");
variance=var;
pdfDenominator=SQRT2PI*Math.sqrt(variance);
cdfDenominator=SQRT2*Math.sqrt(variance);
}
/**
* Constructs a normal distribution from a data set.
* @param array a sample.
* @author Mark Hale
*/
public NormalDistribution(double array[]) {
double sumX=array[0];
double sumX2=array[0]*array[0];
for(int i=1;i<array.length;i++) {
sumX+=array[i];
sumX2+=array[i]*array[i];
}
mean=sumX/array.length;
variance=(sumX2 - array.length*mean*mean)/(array.length-1);
pdfDenominator=SQRT2PI*Math.sqrt(variance);
cdfDenominator=SQRT2*Math.sqrt(variance);
}
/**
* Returns the mean.
*/
public double getMean() {
return mean;
}
/**
* Returns the variance.
*/
public double getVariance() {
return variance;
}
/**
* Probability density function of a normal (Gaussian) distribution.
* @return the probability that a stochastic variable x has the value X, i.e. P(x=X).
*/
public double probability(double X) {
return Math.exp(-(X-mean)*(X-mean)/(2*variance))/pdfDenominator;
}
/**
* Cumulative normal distribution function.
* @return the probability that a stochastic variable x is less then X, i.e. P(x&lt;X).
*/
public double cumulative(double X) {
return SpecialMath.complementaryError(-(X-mean)/cdfDenominator)/2;
}
/**
* Inverse of the cumulative normal distribution function.
* @return the value X for which P(x&lt;X).
*/
public double inverse(double probability) {
checkRange(probability);
if(probability==0.0)
return -Double.MAX_VALUE;
if(probability==1.0)
return Double.MAX_VALUE;
if(probability==0.5)
return mean;
// To ensure numerical stability we need to rescale the distribution
double meanSave=mean,varSave=variance;
double pdfDSave=pdfDenominator,cdfDSave=cdfDenominator;
mean=0.0;
variance=1.0;
pdfDenominator=Math.sqrt(TWO_PI);
cdfDenominator=SQRT2;
double X=findRoot(probability, 0.0, -100.0, 100.0);
// Scale back
mean=meanSave;
variance=varSave;
pdfDenominator=pdfDSave;
cdfDenominator=cdfDSave;
return X*Math.sqrt(variance)+mean;
}
}

http://jsci.sourceforge.net/api/JSci/maths/statistics/NormalDistribution.html
위 주소입니다.
http://jsci.sourceforge.net/

소스다운로드 해서 분석하면 될것 같네요..

StackTraceElement STE = Thread.currentThread().getStackTrace()[1];

String className = STE.getClassName();
String methodName = STE.getMethodName());

출처 : http://5dol.tistory.com/182

우선 간단히 확인하면 아래처럼 나온다. jstat -옵션 -pid -시간 하면 된다.
ex) ~]jstat -gc 16543 1000

저건 pid 16543(java)를 1초에 한번씩 결과값을 보여달란거다. 

pid는 ps -efw | grep java로 알아내면 된다. 

~] jstat --help

JVM을 사용하여 디렉토리 프록시 서버에 대한 모니터링된 데이터 검색

디렉토리 프록시 서버는 JVM(Java Virtual Machine) 내에서 실행되고 JVM 시스템의 메모리에 따라 달라집니다. 디렉토리 프록시 서버가 올바르게 실행되고 있는지 확인하려면 JVM 시스템의 메모리 사용을 모니터링해야 합니다.

JVM 시스템의 매개 변수를 조정하는 방법에 대한 자세한 내용은 Sun Java System Directory Server Enterprise Edition 6.0 Deployment Planning Guide의 Hardware Sizing For Directory Proxy Server을 참조하십시오.

기본적으로 JVM 시스템의 힙 크기는 250MB입니다. 디렉토리 프록시 서버에 물리적 메모리가 충분하지 않은 경우 힙 크기는 250MB보다 작을 수 있습니다.

디렉토리 프록시 서버가 실행 중인 경우 JVM 시스템의 힙 크기를 모니터링하여 메모리가 부족해지지 않도록 할 수 있습니다. 이렇게 하려면 JDK(Java Development Kit)와 함께 제공되는 표준 도구를 사용합니다. 이러한 도구는 $JAVA_HOME/bin/jps 및 $JAVA_HOME/bin/jstat 디렉토리에 있습니다.

JVM의 힙 크기를 보려면

DSCC를 사용하여 이 작업을 수행할 수 없습니다. 이 절차에 설명된 것처럼 명령줄을 사용하십시오.

JVM의 힙 크기를 봅니다.

$ dpadm get-flags instance-path jvm-args jvm-args: -Xms250M -Xmx250M

디렉토리 프록시 서버가 실행 중인 경우 JVM의 힙 크기를 모니터링하려면

DSCC를 사용하여 이 작업을 수행할 수 없습니다. 이 절차에 설명된 것처럼 명령줄을 사용하십시오.

1. 디렉토리 프록시 서버 인스턴스의 PID를 봅니다.

   $ jps

2. JVM 시스템에 사용된 메모리를 봅니다.

   $ jstat -gcutil PID

   • 0 열이 거의 100%에 도달하면 JVM 시스템에 메모리가 부족한 것입니다.

   • FGC는 전체 가비지 컬렉션(GC) 이벤트 수입니다. 가비지 컬렉션은 광범위합니다.

   • GCT(Garbage Collection Time)는 GC에 사용된 시간입니다.

jar 파일 생성 시 MANIFEST.MF 작성

serialVersionUID 기본 알고리즘

public static String getHanStr(String number) {

                StringBuffer sb = new StringBuffer();
                String[] numArr = { "", "일", "이", "삼", "사", "오", "육", "칠", "팔", "구" };

                // 16자리 어레이로 만들기
                try{
                        int len = number.length();
                        if (len > 16){ throw new Exception("자릿수가 초과했습니다"); }
                        int[] snum = new int[16];
                        for (int i = (snum.length - (len)); i < snum.length; i++){
                                int k = i - (snum.length - len);
                                String a = String.valueOf(number.charAt(k));
                                snum[i] = Integer.parseInt(a);
                        }
                        for (int j = 0; j < 4; j++){
                                int k = (j * 4);
                                if (snum[k] + snum[k + 1] + snum[k + 2] + snum[k + 3] > 0){
                                        if (snum[k] > 0){
                                                sb.append(numArr[snum[k]]).append("천");
                                        }
                                        if (snum[k + 1] > 0){
                                                sb.append(numArr[snum[k + 1]]).append("백");
                                        }
                                        if (snum[k + 2] > 0){
                                                sb.append(numArr[snum[k + 2]]).append("십");
                                        }
                                        if (snum[k + 3] > 0){
                                                sb.append(numArr[snum[k + 3]]);
                                        }
                                        switch (j) {
                                                case 0:
                                                        sb.append("조");
                                                        break;
                                                case 1:
                                                        sb.append("억");
                                                        break;
                                                case 2:
                                                        sb.append("만");
                                                        break;
                                                case 3:
                                                        sb.append("원");
                                                        break;
                                        }
                                }
                        }
                        return sb.toString();
                }catch(NumberFormatException e){
                        return "";
                }catch(Exception e){
                        return "";
                }
        }

public class HttpRequestWithModifiableParameters extends HttpServletRequestWrapper {
 
    HashMap params;
    
    /**
     * @param request
     */
    public HttpRequestWithModifiableParameters(HttpServletRequest request) {
        super(request);
        this.params = new HashMap(request.getParameterMap());
    }
 
    /* (non-Javadoc)
     * @see javax.servlet.ServletRequest#getParameter(java.lang.String)
     */
    public String getParameter(String name) {
        String returnValue = null;
        String[] paramArray = getParameterValues(name);
        if (paramArray != null && paramArray.length > 0){
          returnValue = paramArray[0];   
        }
        return returnValue;
    }
    /* (non-Javadoc)
     * @see javax.servlet.ServletRequest#getParameterMap()
     */
    public Map getParameterMap() {
        return Collections.unmodifiableMap(params);
    }
    /* (non-Javadoc)
     * @see javax.servlet.ServletRequest#getParameterNames()
     */
    public Enumeration getParameterNames() {
        return Collections.enumeration(params.keySet());        
    }
    /* (non-Javadoc)
     * @see javax.servlet.ServletRequest#getParameterValues(java.lang.String)
     */
    public String[] getParameterValues(String name) {
    	String[] result = null;
    	String[] temp = (String[])params.get(name);
    	if (temp != null){
    		result = new String[temp.length];
    		System.arraycopy(temp, 0, result, 0, temp.length);    		
    	}
        return result;
    }
       
    
    /**
     * Sets the a single value for the parameter.  Overwrites any current values.
     * @param name Name of the parameter to set
     * @param value Value of the parameter.
     */
    public void setParameter(String name, String value){
      String[] oneParam = {value};
      setParameter(name, oneParam);
    }
    
    /**
     * Sets multiple values for a parameter.
     * Overwrites any current values.
     * @param name Name of the parameter to set
     * @param values String[] of values.
     */
    public void setParameter(String name, String[] values){
      params.put(name, values);   
    }
}