Seotory

zsh, zplug과 oh-my-zsh 시작하기

Tue, 19 Dec 2017 14:19:39 +0900

최종 모습

zsh을 사용하게 된 계기

bash sh을 아주 잘쓰고 있었음
실수로 rm -rf ~를 입력
혼돈의 카오스
닷으로 시작하는 설정 파일들이 날라감 (.bash* 등등)
이렇게 된 이상 그 좋다던 zsh을 사용해보자.

셋업 환경

mac
iTerm2

zsh 설치하기

mac은 기본적으로 zsh이 깔린 듯 하다. 아래를 실행시켜 확인해본다.

zsh --version

만약 없다면 아래의 커맨드를 실행시켜 설치한다.

brew install zsh

설치가 끝났다면 chsh을 사용해서 기본 쉘을 바꾼다.

chsh -s `which zsh`

oh my zsh

사용 안함 (*update)

zplug 설치하기

일반적으로는 oh my zsh을 이용하여 사용하는 데에는 지장이 없을 것이다. 개인적으로 oh my zsh을 커버할 수 있는 프레임워크를 원했고 찾아보니 일본 냄새 풀풀 나는 zplug이라는게 있었다.

사실 이것 말고도 여러 가지가 있었으나 범용성이 떨어졌다. oh my zsh에 너무 의존적이거나 사용하기 불편하거나 느리거나 세 가지 중 하나여서 모든 zsh의 라이브러리를 커버할 수 있으면서 속도도 괜찮은 zplug를 선택하였다. zplug에서는 아래 목록을 사용할 수 있다. (사실상 거의 모든 것)

Zsh plugins/UNIX commands on GitHub and Bitbucket
Gist files (gist.github.com)
Externally managed plugins e.g., oh-my-zsh and prezto plugins/themes
Binary artifacts on GitHub Releases
Local plugins
etc. (you can add your own sources!)

그럼 이제 zplug을 설치해보자.

export ZPLUG_HOME=~/.zplug
git clone https://github.com/zplug/zplug $ZPLUG_HOME

설치는 끝났고 사용하는 법만 남았다. 기본적으로 oh my zsh에서 사용 가능한 플러그인과 테마가 모두 사용이 가능하다. 또한 외부테마도 사용할 수 있다. 필자는 spaceship이라는 어여쁜 외부 테마를 사용할 예정이다.

아래 내용을 copy 해서 ~/.zplugsetting 파일을 생성한다.

##################
# ZPLUG LOAD
##################
source ~/.zplug/init.zsh

##################
# ZPLUG START
##################
zplug "zsh-users/zsh-completions"
zplug "zsh-users/zsh-history-substring-search"
zplug "zsh-users/zsh-syntax-highlighting"
zplug "robbyrussell/oh-my-zsh", use:"lib/*.zsh"
zplug "plugins/git", from:oh-my-zsh
zplug "plugins/macos", from:oh-my-zsh, if:"[[ $OSTYPE == *darwin* ]]"
zplug "plugins/colorize", from:oh-my-zsh
zplug "plugins/docker", from:oh-my-zsh
# zplug "themes/robbyrussell", from:oh-my-zsh

# theme
zplug "denysdovhan/spaceship-zsh-theme", use:spaceship.zsh, from:github, as:theme

# install & load
zplug check || zplug install
zplug load

아래 커맨드를 실행시켜 라인을 추가한다.

echo ". $HOME/.zplugsetting" >> ~/.zshrc

아래 커맨드로 zplug를 적용시킨다.

source ~/.zshrc

zplug를 통해 oh my zsh의 플러그인과 github에 있는 외부테마가 콜라보를 이루며 잘 적용된다.

자세한 사용법은 zplug를 참조하는게 좋을것 같다. (아직 필자도 잘 모르기 때문에..)

폰트 깨짐 해결

막상 spaceship theme를 적용하면 터미널 내에서 폰트가 깨진다. https://github.com/powerline/fonts에 가면 터미널을 위한 특수 폰트가 준비되어 있다. 설치한다.

# clone
git clone https://github.com/powerline/fonts.git --depth=1
# install
cd fonts
./install.sh
# clean-up a bit
cd ..
rm -rf fonts

iTerm2 > Preferences > Profiles > Text 설정에 들어간다.
Font부분에서 Use a different for non-ASCII text에 체크한다.
Non-ASCII Font에서 Change Font를 클릭하고 Roboto Mono for Powerline을 선택한다.

해결완료.

iTerm2 꾸미기

http://iterm2colorschemes.com/, 감사하게도 이 사이트에 iTerm에 관련된 테마가 준비되어 있다. 다운 받고 압축을 풀면 schemes 폴더에 수많은 테마들이 존재하고 import를 통해 적용시키기만 하면 된다.

iTerm2 > Preferences > Profiles > Colors 설정에 들어간다.
우측 하단 Color Presets... 클릭
Imports... 클릭
schemes > ayu 테마 적용

적용완료.

모든 설정이 끝났다. 이제 zsh로 즐거운 터미널 생활을 해보자.

자바스크립트 화살표 함수 (array function)

Thu, 21 Sep 2017 10:56:01 +0900

array func은 아래와 같은 간단한 형태를 보면 매우 간단하나, 복잡한 구문을 보면 매우 어렵게 느껴진다. 쉬운 array func 부터 복잡한 array func까지 절차적으로 밟아보자.

array func

array func의 특징을 정리해보자면 아래와 같이 간략하게 정리할 수 있다.

function에 비해 구문이 짧다.
항상 익명이다.
this, arguments, super, new target을 바인딩하지 않는다.
생성자로 사용할 수 없다.

문법

array func은 비슷비슷 하지만 결과가 다른 부분이 많기 때문에 간단한 라인이라도 처음에는 꼼꼼하게 보는 것이 좋다.

기본 문법

여기서 리턴이 필요하면 명시적으로 return을 선언한다.

// 문법
(매개변수1, 매개변수2, 매개변수3, 매개변수n) => { 구문 }

// 리턴이 없는 예
let test = (a) => { console.log(a) }
let testVal = test(1); //console.log -> 1
console.log(testVal) // undefined

// 리턴이 있는 예
let test = (a, b, c) => { return a + b + c }
let testVal = test(1,2,3);
console.log(testVal) // 6

간결한 리턴 문법

오른쪽 구문에서 중괄호를 생략하면 array func에서는 자동으로 표현식을 리턴한다. 즉 return 생략이 가능하다.

// 문법
(매개변수1, 매개변수2, 매개변수3, 매개변수n) => 표현식

// 예
let test = (a, b, c) => a + b + c
let testVal = test(1,2,3);
console.log(testVal) // 6

매개변수가 하나인 경우 좌측 괄호 생략이 가능

// 문법
매개변수1 => 표현식
매개변수1 => { 구문 }

// 예
let test = a => a + 10
let testVal = test(1);
console.log(testVal) // 11

let test = a => { return a + 10 }
let testVal = test(1);
console.log(testVal) // 11

객체 리터럴을 반환하는 식에는 우측에 괄호를 감쌈

// 문법
매개변수1 => ({name: 매개변수1})

// 예
let test = a => ({aVal: a})
let testVal = test('에이');
console.log(testVal) // {aVal: "에이"}

매개변수에 기본값 셋팅이 가능

// 문법
(매개변수1 = 'default', 매개변수2) => { 표현식 }

// 예
let test = (a=10, b) => { return a + b }
let testVal = test(undefined, 5);
console.log(testVal); // 15

// 주의: undefined 대신 null을 입력하면 기본값을 넣지 않는다.
let testVal = test(null, 5);
console.log(testVal); // 5

매개변수는 펼침 연산자 사용 가능

// 문법
(...매개변수n) => { 표현식 }

// 예
let test = (...args) => { console.log(args) }
test(1,2,3,4,5) // console.log -> [1,2,3,4,5], return -> undefined

매개변수에 비구조화된 매개변수 또한 사용 가능

var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
// 중간과정 해석
// ([a, b] = [1, 2])  >>  a = 1, b = 2 할당
// {x: c} = {x: a + b}  >> a+b 를 선 계산 후 오른쪽 x 에 할당, 할당된 x 는 다시 왼쪽 x에 할당되면서 c = 3이 할당
// 즉 a=1, b=2, c=3 이 됨.
f();  // 6

function과 다른 점

가장 중요한 특징은 this, arguments가 자동으로 바인딩이 되지 않는다는 것이다. 보통 일반 func 같은 경우는 아래와 같다.

let scopeTest = {
    run: function () {
        console.log(this);
        console.log(arguments);
    }
}

scopeTest.run();
// console.log -> {run: ƒ}
// console.log -> [callee: ƒ, Symbol(Symbol.iterator): ƒ]

하지만 아래와 같이 array func을 이용하면 에러가 발생한다.

let scopeTest = {
    run: () => {
        console.log(this);
        console.log(arguments);
    }
}

scopeTest.run();
// console.log -> Window {stop: ƒ, open: ƒ, alert: ƒ, confirm: ƒ, prompt: ƒ, …}
// console.log -> Uncaught ReferenceError: arguments is not defined
// console.log ->    at Object.run (<anonymous>:4:21)
// console.log ->    at <anonymous>:8:11

사용예제

위에서 간략하게 array func의 사용법과 특징을 배웠으니 이번에는 예제를 통해 익혀보자. 처음 접하는 문법을 빠르게 익힐때에는 쉬운 문법부터 복잡한 문법까지 절차적으로 익혀가되 해당하는 문법을 완벽하게 이해하고 넘어가야 도움이 된다.

아래는 array func과 일반 func으로 번갈아가며 비교해본다.

기초

// array function
let resultlVal = () => { console.log('test'); }
// function
function resultVal() {
  console.log('test');
}

// array function
let resultlVal = (...args) => { console.log(args); }
// function
function resultVal(...args) {
  console.log(args);
}
  
// array function
let resultlVal = (...args) => args;
// function
function resultVal(...args) {
  return args;
}

함수 내 함수

1번 예제에서는 return 값이 없기 때문에 이 args.map에 대한 연산은 undefined의 배열이 된다.

// 1
// array function
let result = (...args) => val => args.map(a => {a + val})
// function
function result (...args) {
  return function(val) {
    return args.map(function(a) {
      a + val; 
    });
  }
}

// 2
// array function
let result = (...args) => val => args.map(a => a + val)
// function
function result (...args) {
  return function(val) {
    return args.map(function(a) {
      return a + val;
    });
  }
}

기타 array func 사용법

필자가 callback 패턴을 promise 패턴으로 바꾸는 방법 중 가장 자주 사용하는 방법은 아래와 같은 promiseWrapper함수 유틸을 만들고 사용하는 방법이다. 이 로직 역시 array func으로 아래와 같이 작성할 수 있다.

// array function
function promiseWrapper (func, ...args) { 
    return new Promise(resolve => func(...args, ...returnArgs => resolve(returnArgs)));
};
// function
function promiseWrapper (func, ...args) {
  return new Promise(function(resolve) {
    return func(...args, function(...returnArgs) {
      return resolve(returnArgs);
    })
  })
}

커링 (currying)

array func의 기본기를 알아보았으니 이번에는 커링도 한번 해보도록 하자. 커랑이란 간단하게 이야기하자면 함수의 인자를 고정시켜 적용하는 함수를 만드는 기법이다.

아래는 합을 구하는데 커링 기법을 이용한 것이다.

let sumCurry = fixNum => input => fixNum + input;

사실 위에 있는 예제들도 커링 기법이 적용된 예제들이 많다.

주의사항

줄바꿈 주의

화살표 함수는 파라메터와 화살표 사이에 개행 문자를 포함 할 수 없다.
```
// error
var func = ()
        => 1; // SyntaxError: expected expression, got '=>'
```

파싱순서 주의

let callback;

callback = callback || function() {}; // ok
callback = callback || () => {};      // SyntaxError: invalid arrow-function arguments
callback = callback || (() => {});    // ok

undefined 주의

let empty = () => {};
// empty = undefined

매개변수가 없을 시 주의

// => { statements } error
() => { statements }

java proxy pattern (프록시 패턴)

Sat, 09 Sep 2017 10:30:01 +0900

프록시는 실제로 액션을 취하는 객체를 대신해서 대리자 역할을 해준다. 프록시 패턴을 사용하게 되면 프록시 단계에서 권한을 부여할 수 있는 이점이 생기고 필요에 따라 객체를 생성시키거나 사용하기 때문에 메모리를 절약할 수 있는 이점도 생긴다. 프록시 패턴이 하는 일은 한마디로 자신이 보호하고 있는 객체에 대한 액세스 권한을 제어하는 것이다.

example

간단한 예제를 통해 좀 더 알아보도록 하자. 이 예제에서는 프록시를 사용함으로써 실제 인스턴스 사용 과정을 관여하고 메모리를 절약하는 방법을 예제로 나타내고 있다.

main class

실질적으로 사용되는 핵심 코드는 아래의 2가지이다. 하나는 인터페이스고 하나는 인터페이스를 상속받은 클래스이다. 이 상태에서 일반적으로 코딩을 하게 되면 무조건 CommandExcutorImpl를 호출하여 객체를 생성시키고 높은 cost의 runCommand 메소드 작업으로 인해 메모리 낭비가 예상된다.

public interface CommandExecutor {
    public void runCommand(String cmd) throws Exception ;
}

public class CommandExcutorImpl implements CommandExecutor {
    @Override
    public void runCommand(String cmd) throws IOException {
        // 뭔가 높은 cost의 작업이 필요함.
        Runtime.getRuntime().exec(cmd);
        System.out.println("cmd: " + cmd);
    }
}

proxy class

위의 단점을 보완하기 위에 프록시 클래스를 작성하였다. 일단 똑같은 인터페이스를 상속받음으로 인터페이스의 일관성을 유지한다. 그리고 생성자에서 CommandExcutorImpl 클래스를 인스턴화 시키고, 인스턴스화 된 executor 객체의 runCommand 메소드를 프록시 클래스의 runCommand 메소드에서 액세스를 결정한다.

public class CommandExecutorProxy implements CommandExcutor {
    private boolean isAdmin;
    private CommandExecutor executor;

    public CommandExecutorProxy(String user, String pwd) {
        if ( "seotory".equals(user) && "pw".equels(pwd) ) {
            isAdmin = true;
        }
        executor = new CommandExcutorImpl();
    }

    @Override
    public void runCommand(String cmd) throws Exception {
        if (isAdmin) {
            executor.runCommand(cmd);
        } else {
            if (cmd.trim().startsWith("rm")) {
                throw new Exception("rm is only admin");
            } else {
                executor.runCommand(cmd);
            }
        }
    }
}

testing

public class ProxyPatternTest {
    public static void main(String[] args) {
        CommandExcutor executor = new CommandExecutorProxy("seotory", "is_not_pw");
        try {
            executor.runCommand("ls -al");
            executor.runCommand("rm -rf *"); // proxy 클래스에 의해 에러가 날 것이다.
        } catch (e) {
            System.out.println("Exception Message: " + e.getMessage());
        }
    }
}

결과 output

cmd: ls -al
cmd: rm -rf *
Exception Message: rm is only admin

즉 위와 같이 프록시를 작성하면 인터페이스를 일관성있게 유지시키면서 액세스 권한을 부여할 수 있고 더불어 메모리 절약을 할 수 있게 된다.

적용 포인트

가상 프록시
높은 cost 객체 대신 스켈레톤 객체(인터페이스만 존재하고 실제로 인스턴스를 생성하지 않는 객체)를 사용하여 실질적으로 객체가 필요할때까지 높은 cost의 객체 생성을 지연시켜 메모리를 절약할 수 있다.
원격 프록시
서로 다른 머신에 있는 객체에 대해 제공할 수 있다(또는 객체를 사용할 수 있다). 일반적인 예는 JAVA의 RMI이다.
- http://www.informit.com/articles/article.aspx?p=1398608&seqNum=3
보호 프록시
객체에 대해 액세스 할 수있는 권한을 부여할 수 있다.
정교한 참조
프록시 객체에 정교한 작업을 부여할 수 있다. 예를들어 객체를 생성할 때 카운팅 기능을 추가적으로 작업할 수 있다.

패턴 비교

어뎁터 패턴
어뎁터 패턴은 실제 오브젝트와 다른 인터페이스를 제공하여 실제 오브젝트를 사용할 수 있도록 도와준다. 그러나 프록시 패턴은 실제 오브젝트와 동일한 인터페이스를 제공한다.
데코레이터 패턴
데코레이터 패턴은 런타임에 실제 객체에 동작을 추가한다. 그러나 프록시는 동작을 제어하지 않고 동작을 변경하지 않는다.

java composite pattern (컴포지트 패턴)

Sat, 09 Sep 2017 08:58:43 +0900

컴포지트 패턴이란 클래스의 구조적 디자인 패턴으로 단일 객체와 복합 객체를 동일하게 컨트롤 할 수 있게끔 도와주는 패턴이다. 컴포지트 패턴은 아래와 같이 3가지의 요소에 의해 이루어진다.

base component
base component는 composition(구성자)을 위한 인터페이스로 구성된다. 클라이언트 클래스에서는 base component의 인터페이스를 사용하여 작업하게 된다. interface 또는 abstract class 그리고 모든 클래스를 위한 약간의 공통 메소드 역시 포함된다.
leaf
base component를 구현하는 클래스요소로 이 클래스들을 쌓아올려 하나의 구성물을 만들게 된다. leaf 클래스에서는 base component 외에는 다른 컴포넌트를 섞지 않는다.
composite
다수의 leaf 클래스를 컨트롤 할 수 있는 클래스로 인터페이스는 base component부터 얻어 공통된 인터페이스로 작업을 할 수 있는 클래스이다.

example

간단히 삼각형, 원, 선의 객체 오브젝트를 생성하고 이 모든 객체를 빨강색으로 칠하는 작업을 컴포지트 패턴을 통해서 해보도록 한다.

base component

뼈대가 되는 클래스로 아래와 같이 draw 메소드를 가지는 인터페이스로 구성되었다. 컴포지트 패턴을 사용하기 위해서는 아래의 클래스를 구현하는 방법으로 진행된다.

public interface Shape {
    public void draw(String color);
}

leaf

위의 base component를 구현하여 만들어진 클래스들이다. leaf로 구성된 클래스를 이용하여 다수의 객체를 생성할 수 있다. 위에서 설명했듯이 base component 외에는 다른 메소드를 사용할 수 없다.

// 삼각형
public class Triangle implements Shape {
    @Override
    public void draw(String color) {
        System.out.print("triangle color: " + color);
    }
}

// 원
public class Circle implements Shape {
    @Override
    public void draw(String color) {
        System.out.print("circle color: " + color);
    }
}

// 라인
public class Line implements Shape {
    @Override
    public void draw(String color) {
        System.out.print("line color: " + color);
    }
}

composite

composite 클래스는 leaf의 객체 그룹을 컨트롤 하는 역활을 한다.

public class Drawing implements Shape {
    private List<Shape> shapes = new ArrayList<Shape>();

    @Override
    public void draw(String color) {
        for (Shape sh : shapes) {
            sh.draw(color);
        }
    }

    // 아래서부터는 헬퍼 성격의 메소드이다. 추가/제거/전체제거
    public void add (Shape s) {
        this.shapes.add(s);
    }

    public void remove (Shape s) {
        this.shapes.remove(s);
    }

    public void clear () {
        this.shapes.clear();
    }
}

중요한 점은 composite 클래스 역시 base component를 구현하여 interface를 leaf과 똑같이 한다는 점이다.

testing

이제 위의 클래스들을 이용하여 컴포지트 패턴을 사용해보고 이해해보도록 하자.

public class Test {
    public static void main(String[] args) {
        Shape t1 = new Triangel();
        Shape t2 = new Triangel();
        Shape c1 = new Circle();
        Shape l1 = new Line();

        Drawing drawing = new Drawing();
        drawing.add(t1);
        drawing.add(t2);
        drawing.add(c1);
        drawing.add(l1);
        drawing.draw("red");

        drawing.clear();

        drawing.add(t2);
        drawing.add(c1);
        drawing.draw("blue");
    }
}

결과 output

triangle color: red
triangle color: red
circle color: red
line color: red
triangle color: blue
circle color: blue

적용 포인트

컴포지트 패턴은 트리 같은 구조가 필요할 때 사용할 수 있다.
- 경험상 트리메뉴를 컴포지트 패턴을 이용해서 구성해 보는 것이 도움이 많이된다.
컴포지트 패턴은 단일 객체처럼 행동하는 다수의 객체(인터페이스가 똑같거나, 비슷한 객체)가 있는 경우 적용시킬 수 있다.

java adapter pattern (어뎁터 패턴)

Sun, 03 Sep 2017 18:20:43 +0900

adapter pattern은 관계가 없는 인터페이스들이 같이 일할 수 있도록 도와주는 디자인 패턴이다. 이 두 인터페이스를 이어주는 인터페이스를 adapter라 부른다. 아래 예제를 보면서 이해해보도록하자.

volt class

public class Volt {
    private int volts;

    public Volt(int v) {
        this.volts = v;
    }

    public int getVolts() {
        return this.volts;
    }

    public void setVolts(int volts) {
        this.volts = volts;
    }
}

socket class

public class Socket {
    public Volt getVolt() {
        return new Volt(120);
    }
}

adapter class

volt와 socket클래스를 만들었다. socket 클래스에서는 120v 만 얻을 수 있다. 실생활을 예로 들자면 120v로 부터 12v 와 3v도 얻고 싶다면 어탭터를 끼움으로 volt를 변환 할 수 있다. 마찬가지로 프로그래밍에서도 어뎁터 클래스를 통해서 원하는 volt를 얻을 수 있다. 아래와 같이 어뎁터 클래스를 작성한다.

public interface SocketAdapter {
    public Volt get120Volt();
    public Volt get12Volt();
    public Volt get3Volt();
}

이제 위의 어뎁터 클래스를 구현하는 클래스를 작성해보자. 어뎁터 클래스를 구현하는 방법은 2가지가 있다.

class adapter implementation

public class SocketClassAdapterImpl extends Socket implements SocketAdapter {
    public Volt get120Volt() {
        return getVolt();
    }

    public Volt get12Volt() {
        Volt v = getVolt();
        return convertVolt(v, 10);
    }

    public Volt get3Volt() {
        Volt v = getVolt();
        return convertVolt(v, 40);
    }

    public Volt convertVolt(Volt v, int i) {
        return new Volt(v.getVolts()/i);
    }
}

기본적으로 java에서는 다중 상속을 허용하지 않는다. extends와 implements를 동시에 사용함으로써 다중 상속을 흉내내었음에 주목하자. socket을 확장함으로써 socket의 메소드를 별도의 인스턴스 생성 없이 사용할 수 있다.

object adapter implementation

public class SocketObjectAdapterImpl implements SocketAdapter {

    private Socket sock = new Socket();

    public Volt get120Volt() {
        return sock.getVolt();
    }

    public Volt get12Volt() {
        Volt v = sock.getVolt();
        return convertVolt(v, 10);
    }

    public Volt get3Volt() {
        Volt v = sock.getVolt();
        return convertVolt(v, 40);
    }

    private Volt convertVolt(Volt v, int i) {
        return new Volt(v.getVolts()/i);
    }

}

두 번째 방법은 object adapter implementation이다. 위에서 사용되었던 extend 대신에 클래스 내부에서 socket인스턴스를 생성한 것이 가장 큰 차이점이다.

java builder pattern (빌더 패턴)

Sun, 03 Sep 2017 18:11:59 +0900

bulider pattern은 창조적 디자인 패턴이며 이것은 factory pattern 또는 abstract factory pattern과 매우 비슷하다. 이 패턴에 들어가기 전에 factory pattern과 abstract factory pattern들의 문제점(수 많은 attributes을 사용해야 패턴을 사용할 수 있는 점)에 대해 먼저 알아보자.

factory pattern과 abstract factory pattern에는 3가지 중대한 문제점이 있다.

수 많은 파라메터들이 클라이언트 클래스로 부터 전달 되는데 이것은 에러를 발생시키는 경우가 많다. 왜냐하면 거의 대부분의 경우 argument(인자)들의 type이 같고 클라이언트 쪽에서는 인자들을 정확히 유지시키기 어렵기 때문이다.
몇몇의 파라메터들은 값을 보낼때 선택적인데 factory pattern에서는 모든 인자를 전송해야 한다. 그리고 선택적인 파라메터들은 꼭 null을 입력해서 보내야한다.
만약 생성시키는 object가 무거운 경우(파라메터가 많은 경우) 만들기가 매우 복잡해지며, 이런 factory pattern의 복잡성으로 인해 결국 혼란스럽게 된다.

우리는 이런 문제점을 생성자(constructor)의 인자 갯수를 바꿈으로 해결할 수 있다. 하지만 이런 방식의 문제점은 모든 attribute들이 명시적으로 set 되지 않는 한 object의 상태는 일괄성이 없어지게될 것이다.

builder pattern은 선택적인 파라메터가 많을 경우 제공 상태를 일관성 있게 해주고, object를 생성시킬때 step-by-step으로 만들 수 있도록 제공해주며 최종에는 만들어진 object를 리턴한다.

작업순서

class 안에 중첩 static class를 생성시키고, 바깥쪽 class의 argument들을 안쪽 static class(builder class)로 옮긴다. 바깥쪽 class의 생성자는 private로 선언해서 직접적인 생성을 막는다.
builder class의 생성자를 public static으로 선언하고 필요한 파라메터들을 요청한다.
builder class에는 선택적 파라메터에 대한 setter method가 있어야한다. 그리고 선택적 인자를 설정한 후에도 같은 builder object를 리턴해야한다.
마지막으로로 클라이언트 프로그램이 요청하는 object를 받을 수 있도록 build method를 만드는데, build method에서는 바깥쪽 class의 생성자가 builder 클래스의 인자를 받을 수 있도록 제공한다.

아래가 builder class의 예제이다.

public class Product {

    // parameters..
    private String name;
    private int price;

    // optional parameter
    private boolean isSell;

    public String getName() {
        return this.name;
    }

    public int getPrice() {
        return this.price;
    }

    public boolean isSellEnabled() {
        return isSell;
    }

    // argument -> ProductBuilder instance.
    private Product(ProductBuilder builder) {
        this.name = builder.name;
        this.price = builder.price;
        this.isSell = builder.isSell;
    }

    public static class ProductBuilder {
        private String name;
        private int price;
        private boolean isSell;

        public ProductBuilder(String name, int price) {
            this.name = name;
            this.price = price;
        }

        public ProductBuilder setIsSellEnabled(boolean isSell) {
            this.isSell = isSell;
            return this;
        }

        public Product build() {
            return new Product(this);
        }

    }
}

사용 예제

public class main {
    public static void main (String[] args) {
        Product p1 = new Product.ProductBuilder("test상품", 10000).setIsSellEnabled(true).build();
    }
}

ProductBuilder가 중접 클래스로 부터 나온 생성자임에 주목하자.

nodejs cluster 프로세스에서 데이터 공유하기

Tue, 29 Aug 2017 17:17:54 +0900

nodejs의 cluster는 기본적으로 child_process의 기능을 바탕으로 만들어졌다. master process와 worker process는 프로세스간 통신할때 일반적으로 사용되는 IPC를 사용하여 서로 통신한다. 또한 cluster 모듈을 사용할 때 공식적으로 프로세스간에 공유하는 메모리는 없다. 따라서 같은 메모리 주소값을 참조해서 데이터를 사용하는 방법 역시 없다.

하지만 nodejs cluster로 서비스를 실제 운영하다보면, 프로세스간의 데이터 공유가 필요한 상황이 자주 찾아오게 된다. 일반적으로 해결하는 방법은 공용으로 쓸 수 있는 redis 같은 in memory db를 사용하는 방법이 있다.

일반적이진 않지만 지금부터 적어볼 IPC를 이용한 공유 방법도 있다. 이번에 프로젝트를 하면서 이 방법을 사용해 봤는데 소규모 프로젝트에서는 나쁘지 않은것 같다. 어려운 코드는 아니니 직접 작성해 보도록 한다.

how to work?

┌────────────┐       ┌────────────┐
│   Master   │   ↔   │   worker   │
└────────────┘       └────────────┘

위와 같이 clustering이 된 프로세스들이 있다고 가정해본다. 일단 위에서 말한데로 공유 메모리를 통해서 데이터를 받을 수는 없다. 그러나 아래와 같은 과정으로 코드를 작성하면 IPC 채널을 이용해서 각각의 프로세스에 같은 데이터를 전달시킬 수 있다.

공유가 필요한 데이터 setting 요청
master process로 해당 데이터 전송
master process에 데이터 저장
master process에서 모든 worker process로 데이터를 broadcast 시킴
broadcast로 데이터를 받은 worker process는 해당 데이터를 저장
각 프로세스 내에서 전달받은 데이터 사용

interface

나는 프로그래밍을 시작할 때 인터페이스를 습관적으로 제일 먼저 고려하는 편이다. 이유는 인터페이스가 잘 설계되면 나중에 프로그램의 크기가 커져도 코드의 내용은 얼마든지 바꿀 수 있기 때문이다. 이번에는 아래의 인터페이스를 목표로 코딩을 한다. 인터페이스의 내용은 매우 간단하다. set, get으로 데이터를 넣고 빼는 역활만 한다.

// 데이터 셋팅
globalVal.set('greeting', 'Hi!, from seotory');

// 데이터 사용
globalVal.get('greeting'); // Hi!, from seotory

// 필요에 따라 브로드캐스팅
globalVal.broadcast();

code

아래서부터는 위에서 적었던 방법과 interface 대로 구현한 코드이다. typescript로 작성되었다.

// globalVal.ts
import cluster from "cluster";

let globalData = {};

export function get ( name: string ) {
    return globalData[name];
}

// 1. 수정 요청 보냄
export function set ( name: string, val: any ) {
    globalData[name] = val;

    // 1-1. 워커인 경우 요청을 마스터로 보냄
    if ( cluster.isWorker ) {
        process.send({
            cmd: 'val:edit-request', 
            data: globalData
        });
    // 1-2. 마스터인 경우 바로 브로드캐스트. -> 3. 단계로 넘어감
    } else {
        broadcast();
    }
}

// 3. 데이터 전파
export function broadcast () {
    if ( cluster.isMaster ) {
        for (const id in cluster.workers) {
            let worker = cluster.workers[id];
            worker.send({
                cmd: 'val:edit',
                data: globalData
            });
        }
    } else {
        process.send({
            cmd: 'val:broadcast'
        });
    }
}

if ( cluster.isMaster ) {
    cluster.on('message', (worker, message) => {
        // 2. 수정 요청 받음
        if ( message.cmd === 'val:edit-request' ) {
            let keys = Object.keys( message.data );
            keys.forEach((key) => {
                globalData[key] = message.data[key];
            });
            broadcast();
        } else if ( message.cmd === 'val:broadcast' ) {
            broadcast();
        }
    });
} else {
    process.on('message', function (message) {
        // 4. 전파 받은 후 데이터 수정
        if ( message.cmd === 'val:edit' ) {
            globalData = message.data;
            console.log(`[${process.pid}:globalData:edit] ${JSON.stringify(globalData)}`);
        }
    });
}

globalVal.get()

이 메소드는 일반적으로 getter 역활을 하고 있다.

globalVal.set()

데이터 저장 및 동기화 요청을 하는 역활을 한다.

12라인에서 데이터 저장
worker process인 경우 16라인에서 master process로 데이터 전송
46라인에서 데이터 받음
48라인에서 모든 worker process에 데이터 전송
56라인에서 worker process가 데이터 받음
57라인에서 데이터 저장

warning

위의 globalVal.ts를 사용하기 전, 주의사항이 있다.

worker process 들의 globalData가 항상 같다는 보장은 없다. 동시에 set이 여러번 요청된 경우 IPC 채널의 속도에 따라 프로세스간 데이터가 틀어질 수 있다.
globalData 객체가 전파되는 것임으로 객체 사이즈가 커지면 채널통신 비용이 급격히 커진다.

적절한 사용처를 찾아보자면, 프로세스간에 공유가 필요한 환경변수 같은 데이터들을 set하고 특정 프로세스에서 환경변수가 변경되었을 경우 모든 프로세스의 환경변수를 바꾸는 등의 사용이 적절하다.

jekyll 개발모드로 사용 및 빌드하기

Thu, 10 Aug 2017 13:13:02 +0900

jekyll로 블로그를 하다보니 운영빌드와 개발빌드를 나눠서 하고 싶은 마음이 생겼다. 이전까지는 귀찮아서 그냥 사용했는데 디스커스(댓글) 어드민에서 댓글의 url을 확인했더니 blog.seotory.com 도메인과, localhost 도메인으로 분할되는 것을 보고 제대로 작업하기로 했다.

jekyll 공식문서에 가보면 환경변수(env)를 통해 빌드시 선택적으로 빌드할 수 있도록 지원해주고 있다. jekyll에서는 공식적으로 JEKYLL_ENV이라는 명칭으로 사용한다. JEKYLL_ENV 환경변수에 운영이면 production를 입력하고 개발이면 development를 입력한다. 이렇게 작성된 환경변수를 jekyll에서 사용한다.

이번 포스팅을 간략하게 정리하면 아래와 같은 내용이다.

환경변수를 다양하게 등록하고 사용하는 법
jekyll에서 환경변수를 사용하는 법
_config.yml을 개발모드로 사용하는 법
기타 팁

환경변수 설정 및 사용

환경변수를 셋팅하는 방법에는 매우 다양한 방법이 있다. 작업중인 노트북은 맥북임으로 맥 기준으로 설명하도록 하겠다.

export 사용

기본적으로는 터미널에서 export 명령어를 이용해 아래와 같이 환경변수 셋팅이 가능하다.

export JEKYLL_ENV=development

하지만 보통은 위와 같이 환경변수를 고정하여 사용하지 않고 필요시에만 잠깐 등록했다가 없애는 방법으로 사용을 한다. 위와 같은 방식으로 개발을 하다보면 나중에는 환경변수가 많아져서 관리가 너무 어려워지기 때문이다.

.bash_proflie 등록

다음으로 고려해봐야할 방법은 .bash_profile에 등록하는 방법이다. 이 파일은 터미널이 열리는 시점에 자동으로 읽히게 된다.

echo 'export JEKYLL_ENV=development' >> ~/.bash_profile

하지만 이 방법 또한 명확한 방법은 아니기 때문에 환경변수가 기억나지 않으면 다시 파일을 열어서 찾아봐야 한다는 단점이 있다.

프롬프트를 이용하여 사용

가장 추천하는 방식은 아래와 같은 방법이다.

JEKYLL_ENV=development jekyll serve

위와 같이 터미널에 입력하게 되면 자체적으로 JEKYLL_ENV 환경변수에 development 문자열을 입력하고 jekyll이라는 실행파일에 환경변수를 넣어서 실행시켜준다. 따로 os에 셋팅이나 기록을 하지 않아도 된다는 장점이 있어서 주로 이렇게 사용을 한다.

이 방법의 단점은 window에서는 작동하지 않는다는 점이다. window에서 사용하고 싶다면 npm의 cross-env 라이브러리를 글로벌로 설치해서 아래와 같이 사용하거나 비슷한 프로그램을 찾아서 이용하면 된다.

cross-env JEKYLL_ENV=development jekyll serve

direnv 이용

오늘 아웃사이더님의 블로그를 보니, 폴더별로 환경변수 관리를 해줄 수 있는 프로그램을 사용하고 있었다. direnv 사이트를 참고해서 환경변수를 셋팅한다.

jekyll에서 환경변수 사용하기

이제는 셋팅된 환경변수를 jekyll에서 사용해본다. 간단하게 아래와 같이 사용하면 된다.

{% if jekyll.environment == "production" %}
    <!-- 만약 운영 환경에서만 필요한 부분이라면.... -->
{% endif %}

jekyll로 만들어진 사이트는 대부분 github에 올라간다. 빌드를 아예 진행해서 올리면 상관없지만 빌드과정을 github에 위임했다면 github 내부적으로 JEKYLL_ENV 환경변수가 production로 셋팅되어 있음을 알아두는 편이 좋다.

_config.yml 개발모드 적용하기

개발빌드와 운영빌드시 _config.yml의 내용을 바꿔가며 빌드해야하는 경우가 생길것이다. 예를 들어 아래와 같이 _config.yml에 셋팅했다고 하자.

title: Seotory
# title: Seotory_test

그런데 개발빌드를 진행할 때에 Seotory_test를 title에 넣고 싶다면 아랫 줄의 주석을 풀고 빌드를 진행해야 한다. 그리고 나서 다시 운영에 올릴땐 역으로 주석을 처리해야한다. 매우 비효율적이다. 이런 문제들까지도 이미 jekyll에 고려가 되어 있다.

jekyll serve --config _config.yml,_config.dev.yml

jekyll을 빌드하여 올릴때 config 옵션을 사용할수 있는데 독특한 점은 여러 개의 config파일을 넣을 수 있다는 점이다. _config.dev.yml 파일을 동일 위치에 만들고 위와 같이 실행시키면 _config.yml파일 내용을 _config.dev.yml가 덮어씌운다. 이렇게 하면 _config.yml에 불필요한 데이터를 입력하지 않아도 된다.

기타 팁

마지막으로 위의 내용을 정리해서 사용할 수 있는 팁이 있다. 만약 ruby의 rake를 사용하고 있다면 아래와 같이 등록하고 jekyll의 길어지는 명령어를 짧게 관리할 수 있다.

namespace "build" do
  task :dev do
    system "cross-env JEKYLL_ENV=development jekyll serve --config _config.yml,_config.dev.yml --unpublished -t";
  end
  task :real do
    system "cross-env JEKYLL_ENV=production jekyll serve --config _config.yml -t";
  end
end

실행은 아래와 같이 하면 된다.

rake build:dev
rake build:real

javascript es6 class 및 mixin 사용해보기

Tue, 08 Aug 2017 10:25:59 +0900

es6가 나온지도 꽤 되었다. 많은 스펙들이 추가가 되었지만 가장 중요한 class에 대해서 정리를 해보자. 예전부터 느낀거지만 es5보다 편한 부분도 있고 불편한 부분도 있다. 중요한 점은 es6 또한 prototype 기반이며 단지 문법상의 변화만 있다는 점이다. 즉 이전 자바스크립트에서 prototype을 사용함으로 얻는 이점을 그대로 가지고있다.

class 기초 사용해보기

문법변화 차이를 느껴보기 위해 es5, es6 두 스펙으로 작성하였다.

기본 문법

// es5
function TestClass () {}
TestClass.prototype.print = function () {
    console.log('TestClass instance print method');
}
TestClass.staticMethod = function () {
    console.log('static method');
}

// es6
class TestClass {
    print () {
        console.log('TestClass instance print method');
    }
    static staticMethod () {
        console.log('static method');
    }
}

// test
TestClass.staticMethod();
var tc = new TestClass();
tc.print();

es6 class를 사용함으로써 가지는 이점을 가장 잘 나타내는 부분이 위의 코드이다.

class를 정확히 명시함으로 오해를 줄일 수 있다.
prototype에 대해 잘 몰라도 다른 언어처럼 작성이 가능하다.

생성자 (constructor)

// es5
function TestClass () {
    this.val = '값';
}

// es6
class TestClass {
    constructor() {
        this.val = '값';
    }
}

// test
var tc = new TestClass();
tc.val; // 값

es5에서는 함수 자체가 생성자 역활을 한다. 사실 함수 자체가 생성자 역활을 한다는것 자체가 애매모호하기 때문에 es6에서는 class 안에 constructor를 명시하여 작성하게끔 한다.

복합사용

위의 기본문법과 생성자를 묶어서 사용하면 아래와 같은 형태가 된다.

// es5
function Job(name) {
    this.name = name;
}
Job.prototype.work = function () {
    console.log(this.name + ' 일을 합니다.');
}

// es6
class Job {
    constructor (name) {
        this.name = name;
    }

    work () {
        console.log(this.name + ' 일을 합니다.');
    }
}

// test
var newJob = new Job('프로그래머');
newJob.work(); // 프로그래머 일을 합니다.

상속

일단 아래의 코드를 보고 이야기 해보자.

// es5
function Job(name) {
    this.name = name;
}
Job.prototype.work = function () {
    console.log(this.name + ' 일을 합니다.');
}

function Developer() {
    Job.call(this, '프로그래머');
}
Developer.prototype = Object.create(Job.prototype);
Developer.prototype.constructor = Developer;
Developer.prototype.coding = function () {
    console.log('코딩을 합니다.');
}

// es6
class Job {
    constructor (name) {
        this.name = name;
    }

    work () {
        console.log(this.name + ' 일을 합니다.');
    }
}
class Developer extends Job {
    constructor () {
        super('프로그래머');
    }
    coding () {
        console.log('코딩을 합니다.');
    }
}

// test
var itJob = new Developer();
itJob.work(); // 프로그래머 일을 합니다.
itJob.coding(); // 코딩을 합니다.

console.log(itJob instanceof Developer); // true
console.log(itJob instanceof Job); // true

es5 문법이 이해가 잘 안된다면 prototype에 대해 공부가 필요하다.

위의 코드는 매우 짧지만 javascript의 거의 모든것이 포함되어 있다. 따라서 es5에서 상속은 prototype 이해없이 보기에 매우 어렵다. es5는 원래 class를 지원하지 않기 때문에 this, prototype, scope 특성을 이용하여 강제로 상속관계를 만들어준다. Job이라는 함수를 Developer라는 함수에서 상속 받기 위해 불친절한 코딩들이 들어간다.

이런 어려운점 때문에 es6 class 문법이 빛을 발하는 순간은 바로 상속을 구현하는 경우이다. es5에서는 상속을 구현하기 위해서는 prototype 및 javascript의 특성을 정확히 알아야 제대로 구현할 수 있었다. 이 부분이 javascript를 익히는데 가장 큰 걸림돌이 되었다. es6에서는 다른 언어를 사용했던 개발자라면 바로 작업이 가능하게끔 문법적으로 잘 정리가 되어있음을 확인할 수 있다.

역으로 prototype 열성팬에게는 class 문법에 대한 불만들이 있다. es5에서는 여러가지 재료를 나두고 나만의 레시피를 만드는 느낌이라면 es6에서는 정해진 레시피로만 요리를 하는 느낌이다. es6의 class 문법에 대한 판단은 각자하면 되지만 개인적으로는 사용하기 좋은 문법으로 잘 정리되었다는 점에서 후한 점수를 주고 싶다.

class mixin (다중상속 흉내내기)

javascript es6 class에서 단일 extends는 가능하지만 다중 extends를 지원하지 않는다. 대신 mixin 패턴을 이용해서 다중 extends를 흉내 낼 수 있다. 이 방법은 MDN(Mozilla Developer Network) 사이트에 나와 있는 방법이기도 하다.

슈퍼클래스를 인자로 받아 확장하는 서브클래스를 작성하고 이 클래스를 다시 extends으로 상속하는 방법이다. 말로는 어려우니 아래 코드를 보면서 생각해보자.

var calculatorMixin = Base => class extends Base {
  calc() { }
};

var randomizerMixin = Base => class extends Base {
  randomize() { }
};

위의 코드는 es6에 새롭게 추가된 array function으로 작성되었다. 코드의 내용은 Base 클래스를 인자로 받아서 Base 클래스를 extends 한 클래스를 리턴 받는 것이다. 이 코드를 익숙한 코드로 바꾸면 아래와 같다. 같은 내용이다.

var calculatorMixin = function ( Base ) {
	return class extends Base {
  		calc() { }
	};
}

var randomizerMixin = function ( Base ) {
	return class extends Base {
  		randomize() { }
	};
}

이렇게 작성된 코드는 아래와 같이 사용할 수 있다.

class Foo { }
class Bar extends calculatorMixin(randomizerMixin(Foo)) { }

코드를 보고 감이 왔는지 모르겠다. Foo 클래스가 randomizerMixin, calculatorMixin 두 개의 함수를 통과하면서 extends를 통해 함수 내의 클래스들이 상속된다.

이번에는 mixin 패턴을 쉽게 사용하기 위해 꼼수를 사용해보자. 위의 코드를 그대로 두고 아래의 MixinBuilder, mix를 작성한다.

class MixinBuilder {  
    constructor(superclass) {
        this.superclass = superclass;
    }

    with(...mixins) { 
        return mixins.reduce((c, mixin) => mixin(c), this.superclass);
        // 위의 한줄은 아래의 코딩과 같은 내용이다.
        // return mixins.reduce(function(c, mixin){
        //     return mixin(c); // c -> this.superclass를 의미한다.
        // }, this.superclass) 
    }
}
let mix = (superclass) => new MixinBuilder(superclass);

작성된 코드는 아래와 같이 사용된다.

class Foo {}
class MyClass extends mix(Foo).with(calculatorMixin, randomizerMixin) { }

최초 작성했던 mixin 코드에서는 calculatorMixin(randomizerMixin(Foo)) 이런 방식으로 작성을 해야하지만 위의 코드를 이용하면 mix(Foo).with(calculatorMixin, randomizerMixin)이라는 보기 좋은 형태로 mixin을 사용할 수 있다.

MixinBuilder 클래스의 with 메소드는 함수내에서 reduce 연산을 한다. reduce는 javascript 코어 api 중에서도 조금 이해하기 어려운편이니 이곳을 참조한다. 쉽게 누적되어 연산된다고 생각하면 될것 같다. 결국 저 코드의 내용은 calculatorMixin(randomizerMixin(Foo))처럼 해석되어 동작한다.

MixinBuilder 클래스는 슈가코드이니, 필요가 없다면 최초 작성했던 코드대로 사용하면되고 만약 상속받아야할 클래스가 많다면 MixinBuilder 클래스를 사용하는 편이 깔끔할것 같다.

class 기타사항

es6 class에서는 호이스팅이 되지않는다.
표현식으로도 작성이 가능하다.

mac에 pyenv를 이용해 python 설치하기

Sun, 05 Mar 2017 11:10:36 +0900

mac에 python을 설치해본다. python의 공식 홈페이지에서 패키지를 다운받아서 설치하는 방법이 있겠으나, 매우 비추천하는 방식이다. 특히나 python은 2.X 대와 3.X 대의 라이브러리나 문법이 서로 호환이 안되므로 python 버젼관리를 도와주는 pyenv를 설치하여 관리하도록 한다.

homebrew 설치

homebrow를 우선 설치해서 pyenv의 설치를 돕도록 한다.

ruby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)”

pyenv 설치

homebrow를 설치했다면 아래의 명령어로 pyenv를 설치한다.

brew install pyenv

python 설치

아래의 명령어를 입력하면 설치가 가능한 목록이 출력된다.

$ pyenv install -l
Available versions:
1.3
2.3
3.7
4
4.1
4.2
4.3
4.4
4.5
4.6
5
5.1
5.2
5.3
  ...
6.0

원하는 버젼을 선택해서 설치한다.

pyenv install 2.7.12

pyenv global 셋팅

python 버젼을 전역(global)로 셋팅한다.

pyenv global 2.7.12

pyenv 적용

위의 셋팅을 하고나면 시스템에 적용을 해야하는데 이때는 아래와 같은 명령어를 이용한다.

eval "$(pyenv init -)"

해당 내용은 아래와 같은 sh을 실행시킨다.

export PATH="/Users/seotory/.pyenv/shims:${PATH}"
export PYENV_SHELL=bash
source '/usr/local/Cellar/pyenv/1.0.7/libexec/../completions/pyenv.bash'
command pyenv rehash 2>/dev/null
pyenv() {
  local command
  command="$1"
  if [ "$#" -gt 0 ]; then
    shift
  fi

  case "$command" in
  rehash|shell)
    eval "$(pyenv "sh-$command" "$@")";;
  *)
    command pyenv "$command" "$@";;
  esac
}

매번 위의 명령어를 적용시키고 싶지 않다면 아래와 같이 .bash_profile에 아예 등록을 시켜두도록 한다.

echo 'eval "$(pyenv init -)"' >> ~/.bash_profil

후에 .bash_profile을 실행시켜 시스템에 적용한다

. ~/.bash_profile

pyenv local 셋팅

pyenv를 이용하면 python의 전역 버젼 뿐만 아니라 특정 폴더에서 로컬 version을 가지고 실행이 가능하다. 테스트를 위해 3.6.0 버젼을 설치하여 아래와 같이 실행해본다.

$ mkdir python-test
$ cd python-test

$ pyenv install 3.6.0
$ pyenv versions
  system
* 2.7.12 (set by /Users/seotory/.pyenv/version)
  3.6.0

$ pyenv local 3.6.0
$ python -V
Python 3.6.0

$ cd ..
$ python -V
Python 2.7.12

python-test라는 폴더를 만들고 해당 폴더에는 3.6.0 버젼의 python을 사용하도록 했다. cd명령어를 사용해서 상위폴더와 비교해보니 python-test에서만 3.6.0 버젼이 사용됨을 확인되었다.

local 명령어를 사용할 경우 .python-version이라는 파일이 생기고 python이 실행될 때에 해당 파일의 내용을 확인하여 python의 실행 버젼이 변경된다.

pyenv 명령어 목록

pyenv에서는 아래와 같은 커맨드를 사용할 수 있다.

commands
completions
exec
global
help
hooks
init
install
local
prefix
rehash
root
shell
shims
uninstall
version
version-file
version-file-read
version-file-write
version-name
version-origin
versions
whence
which

git에서 vi 에러 메세지 해결하기

Thu, 02 Mar 2017 13:39:26 +0900

git 사용중에 아래와 같은 vi 관련 에러 메시지가 발생했다. 이 에러가 발생하면 git 명령어 처리가 제대로 작동하지 않는다.

error: There was a problem with the editor 'vi'.
Please supply the message using either -m or -F option.

다음과 같이 글로벌 옵션을 주어서 에러 메세지를 해결했다.

git config --global core.editor $(which vim)

참고로 관련 내용을 찾아보니 vim의 버그라는 이야기가 있었고, 또다른 해결책으로 vim을 재설치하는 방법이 있었다..

docker 컨테이너 내의 locale(로케일) 에러 해결

Tue, 28 Feb 2017 10:37:02 +0900

특정 docker image를 컨테이너로 만들고 접속해보니 아래와 같은 locale 에러 메세지가 발생했다. 무시하고 작업을 해도 되지만 매우 거슬려서 아래와 같이 추가 설정을 하였다.

bash: warning: setlocale: LC_CTYPE: cannot change locale (en_US.UTF-8): No such file or directory
bash: warning: setlocale: LC_COLLATE: cannot change locale (en_US.UTF-8): No such file or directory
bash: warning: setlocale: LC_MESSAGES: cannot change locale (en_US.UTF-8): No such file or directory
bash: warning: setlocale: LC_NUMERIC: cannot change locale (en_US.UTF-8): No such file or directory
bash: warning: setlocale: LC_TIME: cannot change locale (en_US.UTF-8): No such file or directory

locale 커멘드를 이용해서 현재 시스템에서 사용중인 로케일을 확인해본다.

[root@7b3a3ede1d74 /]# locale
locale: Cannot set LC_CTYPE to default locale: No such file or directory
locale: Cannot set LC_MESSAGES to default locale: No such file or directory
locale: Cannot set LC_ALL to default locale: No such file or directory
LANG=en_US.UTF-8
LC_CTYPE="en_US.UTF-8"
LC_NUMERIC="en_US.UTF-8"
LC_TIME="en_US.UTF-8"
LC_COLLATE="en_US.UTF-8"
LC_MONETARY="en_US.UTF-8"
LC_MESSAGES="en_US.UTF-8"
LC_PAPER="en_US.UTF-8"
LC_NAME="en_US.UTF-8"
LC_ADDRESS="en_US.UTF-8"
LC_TELEPHONE="en_US.UTF-8"
LC_MEASUREMENT="en_US.UTF-8"
LC_IDENTIFICATION="en_US.UTF-8"
LC_ALL=

locale -a 명령어를 사용해서 현재 시스템에서 사용가능한 로케일을 확인한다.

[root@7b3a3ede1d74 /]# locale -a
locale: Cannot set LC_CTYPE to default locale: No such file or directory
locale: Cannot set LC_MESSAGES to default locale: No such file or directory
locale: Cannot set LC_COLLATE to default locale: No such file or directory
C
POSIX

이 정보는 /usr/lib/locale/locale-archive에 있는 정보이다. 위와 비교해보니 en_US.UTF-8 로케일이 없는 것이 문제 상황으로 파악됬다.

로케일을 정의한 파일들은 /usr/share/i18n/locales 폴더 아래에 있고, charmap(캐릭터맵)에 대한 정보는 /usr/share/i18n/charmaps 폴더 아래에 있다. 이 두가지 정보가 localedef의 명령어로 컴파일 되며 컴파일 된 내용은 위에서 보았던 /usr/lib/locale/locale-archive 파일안으로 들어가게 된다.

Centos/Fedora에는 locale-gen가 없다. 대신에 localedef를 사용하면 된다.

아래와 같이 입력해서 필요한 로케일을 컴파일 시킨다.

localedef -v -c -i en_US -f UTF-8 en_US.UTF-8

option 설명

v: 일반적으로 무시되는 오류에 대한 추가 경고를 생성
c: 경고가 발생하더라도 출력 파일을 작성
i: 로케일의 정의 파일
f: charmap(캐릭터맵) 정의

중요한 옵션은 i, f 두 가지이다. 이 두개의 옵션으로 로케일 및 캐릭터 맵을 지정한다. 즉 이 두개가 합쳐져서 en_US.UTF-8이 되는 것이다. 다시 아래와 같이 locale -a를 입력한다.

[root@7b3a3ede1d74 /]# locale -a
C
en_US.utf8
POSIX

en_US.utf8이 추가되었고 에러도 사라졌다.

만약 localedef 명령어가 없다면 아래와 같이 설치한다.

yum reinstall glibc-common

java abstract factory pattern (추상 팩토리 패턴)

Sun, 28 Aug 2016 16:41:37 +0900

abstract factory pattern은 생산적인 디자인 패턴 중 하나로써 좀 더 factory를 좀 더 생산적으로 만들어 낼 수 있다는 점외에는 factory pattern과 매우 비슷하다.

여러분이 java의 factory design pattern에 익숙하다면, 보통은 어떠한 인풋에 대해 factory class안에서 if-else로 다른 sub-class를 반환하는 일련의 과정을 통해 목적을 달성할 것이다.

abstract factory pattern에서는 if-else 구문을 없애고, sub-class마다 factory class를 가지게 하고 Abstract Factory에서는 input factory class를 통해 해당 sub-class를 반환한다. 처음보기에는 factory pattern 과 혼동되지만, 구현된 것을 보면 정말 쉽게 factory pattern과 abstract factory pattern의 차이점을 할 수 있을것이다.

슈퍼 클래스와 서브 클래스

이번 포스트에서 전에 사용했던 product, ticket, computer 클래스를 똑같이 사용한다.

public abstract class Product {
    public abstract String getName();
    public abstract int getPrice();

    @Override
    public String toString() {
        return "product name : " + getName() + ", price :" + getPrice();
    }
}

public class Computer extends Product {
    private String name;
    private int price;

    public Computer (String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName() {
        return this.name;
    }
    @Override
    public int getPrice() {
        return this.price;
    }
}

public class Ticket extends Product {
    private String name;
    private int price;

    public Ticket (String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName() {
        return this.name;
    }
    @Override
    public int getPrice () {
        return this.price;
    }
}

팩토리 클랙스마다 각각의 서브 클래스

먼저 abstract factory interface(또는 abstract)가 필요하다.

public interface ProductAbstractFactory {
    public Product createProduct();
}

createProduct() method 는 super class 격인 Product 인스턴스를 반환한다. 이제 ProductAbstractFactory 인터페이스와 각각의 sub-class를 구현해보자.

sub-class를 위한 factory class를 아래와 같이 비슷하게 만들것이다.

public class ComputerFactory implements ProductAbstractFactory {
    private String name;
    private int price;
    public ComputerFactory(String name, int price) {
        this.name = name;
        this.price = price;
    }
    public Product createProduct() {
        return new Computer(name, price);
    }
}

각각의 sub-class는 비슷한 구조를 가진다.

public class TicketFactory implements ProductAbstractFactory {
    private String name;
    private int price;

    public TicketFactory (String name, int price) {
        this.name = name;
        this.price = price;
    }

    public Product createProduct() {
        return new Ticket(name, price);
    }
}

사용 클래스

이제 클라이언트 클래스에서 sub-class 생성 시점을 제공해주는 사용 클래스를 만들어보자.

public class ProductFactory {
    public static Product getProduct(ProductAbstractFactory product) {
        return product.createProduct();
    }
}

위의 클래스는 간단한 클래스이다. getComputer method는 인자로 Computer AbstractFactory를 받고 Product object 를 반환한다. 바로 이곳이 object 구현을 매우 깔끔하게 하는 중요한 포인트지점이다.

테스트 클래스

이제 테스트를 위한 class를 아래와 같이이 만들어보자.

public class main {
    public static void main(String[] args) {
        Product com = ProductFactory.getProduct(new ComputerFactory("com1", 2000));
        Product tk = ProductFactory.getProduct(new TicketFactory("공연", 100000));
        System.out.println( com.toString() );
        System.out.println( tk.toString() );
    }
}

abstract factory pattern 사용 장점

추상 팩토리 클래스 패턴은 인터페이스 보다는 구조체에 접근할 수 있는 코드를 제공한다.
추상 팩토리 클래스 패턴은 확장에 매우 용의한 패턴으로 쉽게 다른 서브 클래스들을 확장할 수 있다.
추상 팩토리 클래스 패턴은 기존 팩토리 패턴의 if-else 로직에서 벗어날 수 있게 해준다.

UML - class 다이어그램

위의 클래스들을 보기 쉽게 UML로 그려보면 아래와 같을 것이다.

java factory pattern (팩토리 패턴)

Sun, 28 Aug 2016 16:23:51 +0900

factory pattern은 유명한 디자인 패턴 중 하나이다. 이것 역시 JDK 및 우리가 잘 알고 있는 Spring, Struts 프레임워크에 많이 사용되고 있다.

super class와 여러개의 sub class가 있는 상황에서 input이 발생하면 하나의 sub class를 반환해야 할때 factory pattern이 사용된다. factory class는 client class로 부터 인스턴스를 생성하는 책임을 가져온다.

슈퍼 클래스

factory pattern에서 super class는 interface, abstract class 또는 일반적인 java class가 될 수 있다. 예제에서 super class 로 abstract class를 사용하는데, 테스팅을 위해 toString() method를 오버라이드 하기로 한다.

public abstract class Product {
    public abstract String getName();
    public abstract int getPrice();

    @Override
    public String toString() {
        return "product name : " + getName() + ", price :" + getPrice();
    }
}

서브 클래스

Product class를 상속받은 Computer와 Ticket class를 구현한다. 아래의 클래스들은 super class 하위의 sub class를 정의 한 것이다.

public class Computer extends Product {
    private String name;
    private int price;

    public Computer (String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName() {
        return this.name;
    }
    @Override
    public int getPrice() {
        return this.price;
    }

    public void toStrig () {
        System.out.println("항목 :: " + this.name + ", 가격 :: "+ this.price);
    }
}

public class Ticket extends Product {
    private String name;
    private int price;

    public Ticket (String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName() {
        return this.name;
    }
    @Override
    public int getPrice () {
        return this.price;
    }

    public void toStrig () {
        System.out.println("항목 :: " + this.name + ", 가격 :: "+ this.price);
    }

}

팩토리 클래스

이제 우리는 super class와 sub class를 사용할 준비가 되었다. factory class를 작성해보자.

public class ProductFactory {
    public static Product getProduct(String type, String name, int price) {
        if ( "ticket".equals(type) )
            return new Ticket(name, price);
        else if ( "computer".equals(type) )
            return new Computer(name, price);
        return null;
    }
}

factory class를 static으로 선언함으로써 singleton을 유지할 수가 있다.
input 파라메터에 의해 sub class 가 생성되어 리턴된다.

아래는 factory pattern을 활용한 테스트 코드이다.

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

        Product t1 = ProductFactory.getProduct("ticket", "한국여행", 300000);
        Product c1 = ProductFactory.getProduct("computer", "pc", 1500000);

        System.out.println(t1.toString());
        System.out.println(c1.toString());

    }
}

Factory pattern은 구현체 보다는 인터페이스 코드 접근에 좀더 용의하게 해준다.
Factory pattern은 클라이언트 클래스로부터 인스턴스를 구현하는 코드를 떼어내서, 코드를 더욱 탄탄하게 하고 결합도를 낮춘다.
Factory pattern은 구현과 클라이언트 클래스들의 상속을 통해 추상적인 개념을 제공한다.

centos에서 java version관리 (alternatives 사용)

Sun, 21 Aug 2016 11:09:55 +0900

개요

일반적으로 리눅스에서 자바를 셋팅하고 사용하다보면 버젼관리를 해야하는 경우가 반드시 생긴다. path 경로는 일반적으로 os가 부팅될때에 실행되는 파일들을 가지고 있다. 일반적으로 java를 설치했다면 /usr/bin/의 경로에 java가 실행파일로 운영이되고 있을 것이다. 이런경우 버젼을 올리거나 내리는 것이 매우 힘드므로 심볼릭 형태로 운영하도록 하자.

설치

java 7 & 8

모든 사용자를 위한 java를 설치할 예정이니, root 계정으로 로그인한다.

$ su -

java 8 다운로드 및 설치

# wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u60-b27/jdk-8u60-linux-x64.rpm"
# yum localinstall jdk-8u60-linux-x64.rpm

다운로드 및 설치가 끝났으니 설치 내용을 확인해보도록 하자.

# which java
/usr/bin/java
# cd /usr/bin/
# ls -al | grep java
lrwxrwxrwx    1 root root        22  8월 21 11:30 java -> /etc/alternatives/java
lrwxrwxrwx    1 root root        30  8월 21 11:30 java-rmi.cgi -> /etc/alternatives/java-rmi.cgi
lrwxrwxrwx    1 root root        23  8월 21 11:30 javac -> /etc/alternatives/javac
lrwxrwxrwx    1 root root        25  8월 21 11:30 javadoc -> /etc/alternatives/javadoc
lrwxrwxrwx    1 root root        32  8월 21 11:30 javafxpackager -> /etc/alternatives/javafxpackager
lrwxrwxrwx    1 root root        23  8월 21 11:30 javah -> /etc/alternatives/javah
lrwxrwxrwx    1 root root        23  8월 21 11:30 javap -> /etc/alternatives/javap
lrwxrwxrwx    1 root root        30  8월 21 11:30 javapackager -> /etc/alternatives/javapackager
lrwxrwxrwx    1 root root        24  8월 21 11:30 javaws -> /etc/alternatives/javaws

위에서 보다시피 yum localinstall을 이용하게 되면 /etc/alternatives/ 폴더 안에 실행파일이 들어가게 된다. 왜 alternatives 이 폴더에 들어가는지는 조금 있다가 설명하도록 한다.

java 7 다운로드 및 설치

# wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/7u79-b15/jre-7u79-linux-x64.rpm"
# yum localinstall jdk-7u79-linux-x64.rpm

java 7을 설치했으니 역시 확인해보도록 하자.

# which java
/usr/bin/java
# cd /usr/bin/
# ls -al | grep java
lrwxrwxrwx    1 root root        22  8월 21 11:30 java -> /etc/alternatives/java
lrwxrwxrwx    1 root root        30  8월 21 11:30 java-rmi.cgi -> /etc/alternatives/java-rmi.cgi
lrwxrwxrwx    1 root root        23  8월 21 11:30 javac -> /etc/alternatives/javac
lrwxrwxrwx    1 root root        25  8월 21 11:30 javadoc -> /etc/alternatives/javadoc
lrwxrwxrwx    1 root root        32  8월 21 11:30 javafxpackager -> /etc/alternatives/javafxpackager
lrwxrwxrwx    1 root root        23  8월 21 11:30 javah -> /etc/alternatives/javah
lrwxrwxrwx    1 root root        23  8월 21 11:30 javap -> /etc/alternatives/javap
lrwxrwxrwx    1 root root        30  8월 21 11:30 javapackager -> /etc/alternatives/javapackager
lrwxrwxrwx    1 root root        24  8월 21 11:30 javaws -> /etc/alternatives/javaws

역시나 alternatives 폴더에 실행파일들이 있다. 후에 java -version을 한번 입력해보자.

# java -version
java version "1.8.0_60"
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)

명령어를 입력해보면 java는 아직 이전에 설치했던 8 버젼을 가르키고 있다.

alternatives 명령어

위에서 이야기했던 /usr/bin/java가 /etc/alternatives/....를 가르키던 이유는, centos의 yum을 통해 java를 install하게 되면 버젼관리 대상으로 들어가기 때문이다. 그리고 centos는 버젼관리를 위한 명령어를 제공하는데 그것이 바로 alternatives라는 명령어이다.

명령어를 살펴보기 전에 /usr/bin/java의 심볼릭링크를 추적해보자.

# cd /usr/bin/
# ls -al | grep java
lrwxrwxrwx    1 root root        22  8월 21 11:30 java -> /etc/alternatives/java

# cd /etc/alternatives/
$ ls -al | grep java
lrwxrwxrwx   1 root root   34  8월 21 11:45 java -> /usr/java/jdk1.8.0_60/jre/bin/java

# cd /usr/java/
# ls -al
합계 12
drwxr-xr-x   4 root root   69  8월 21 11:39 .
drwxr-xr-x. 14 root root 4096  4월 11  2015 ..
lrwxrwxrwx   1 root root   16  8월 21 11:30 default -> /usr/java/latest
drwxr-xr-x   8 root root 4096  8월 21 11:39 jdk1.7.0_79
drwxr-xr-x   9 root root 4096  8월 21 11:29 jdk1.8.0_60
lrwxrwxrwx   1 root root   21  8월 21 11:30 latest -> /usr/java/jdk1.8.0_60

마지막까지 추적해서 들어가보면 /usr/java/ 폴더에 우리가 설치했던 java 7, 8 버젼이 설치되어 있음을 확인할 수 있다. 그렇다면 alternatives 명령어를 입력해서 뭔가 java 버젼을 바꿀 수 있을것 같다. 일단은 --help옵션을 줘서 내용을 살펴본다.

# alternatives --help
대체 버전 1.3.61 - Copyright (C) 2001 Red Hat, Inc.
GNU Public License하에서 이 프로그램을
자유롭게 재배포 할 수 있습니다.
사용법: alternatives --install <링크> <이름> <경로> <우선순위>
                    [--initscript <서비스>]
                    [--slave <링크> <이름> <경로>]*
       alternatives --remove <이름> <경로>
       alternatives --auto <이름>
       alternatives --config <이름>
       alternatives --display <이름>
       alternatives --set <이름> <경로>
       alternatives --list

--config 옵션을 활용해보도록 하자.

# alternatives --config java

2 개의 프로그램이 'java'를 제공합니다.

  선택    명령
-----------------------------------------------
*+ 1           /usr/java/jdk1.8.0_60/jre/bin/java

현재 선택[+]을 유지하려면 엔터키를 누르고, 아니면 선택 번호를 입력하십시오:

이상하게 jdk1.8 버젼만 나오고, jdk1.7버젼이 나오지 않는다. 이유는 alternatives에 java란 이름에 7버젼이 추가되어 있지 않기 때문이다. (yum localinstall을 이용하면 자동으로 추가가 될거라 생각했는데 되지 않았다.) 아래와 같이 --install 옵션을 이용해서 java의 이름으로 1.7버젼을 추가하도록 한다.

# alternatives --install /usr/bin/java java /usr/java/jdk1.7.0_79/jre/bin/java 100

다시 --config 옵션을 이용해서 확인해보자.

# alternatives --config java

2 개의 프로그램이 'java'를 제공합니다.

  선택    명령
-----------------------------------------------
*+ 1           /usr/java/jdk1.8.0_60/jre/bin/java
   2           /usr/java/jdk1.7.0_79/jre/bin/java

현재 선택[+]을 유지하려면 엔터키를 누르고, 아니면 선택 번호를 입력하십시오:

이제야 제대로 7, 8 두 버젼이 모두 보인다. 숫자키 2를 누르고 엔터를 친다음 java -version을 확인하면 정상적으로 java의 버젼이 바뀐 것을 확인 할 수있다.

# java -version
java version "1.7.0_79"
Java(TM) SE Runtime Environment (build 1.7.0_79-b15)
Java HotSpot(TM) 64-Bit Server VM (build 24.79-b02, mixed mode)

GNU/Linux의 일반적인 환경변수

Sun, 01 May 2016 12:01:18 +0900

GNU/Linux의 일반적인 환경변수들을 한 번 알아보자.

환경변수 확인

환경변수 확인에는 set, printenv, env와 같은 3가지 정도의 명령어가 있다.

set
```
$ set
```
printenv
```
$ printenv
```
printenv는 뒤에 옵션을 줄 수 있으나, env는 옵션을 줄 수가 없다.
```
printenv [OPTION]... [VARIABLE]...
```
env
```
$ env
```

자주 사용되는 환경변수

SHELL: 커맨드쉘 프로그램의 경로, 기본으로 bash shell을 이용한다 (/bin/bash)
TERM: 현재 터미널 프로그램의 정보
USER: 사용자의 이름
UID: 현재 사용자의 UID
LS_COLORS: 색 코드를 이용하여 커맨드 창에 색깔을 나타내는 환경변수이다.
MAIL: 사용자의 메일이 저장되는 위치
PATH: 프로그램을 실행시킬 때, 실질적으로 프로그램이 위치하고 있는 장소들을 모은 환경 변수
PWD: 현재 작업 디렉토리
LANG: 언어 설정을 위한 환경변수
HOME: 현재 사용자의 홈 디렉토리
OLDPWD: 이전 작업 디렉토리
PS1: 쉘 세션의 모양을 정의한다.
PS2: 명령어가 여러줄에 걸져 있을 경우 모양을 정의한다.
_: 가장 최근에 실행한 명령어
OSTYPE: os의 타입 (centos는 linux-gnu)
HISTFILESIZE: 히스토리 기록의 최대 라인 수

특정 프로세스의 환경 변수 확인법

특정 프로세스의 환경 번수를 확인하고 싶다면 아래와 같이 입력하면된다.

cat /proc/프로세스번호/environ

여기서 특정 프로세스의 번호를 알고 싶다면 ps, pstree등의 명령을 사용하여 확인할 수 있고 /proc/폴더의 하위폴더 중 숫자번호로 이루어진 폴더 역시 프로세스의 번호이다.

$ pstree -pa 1472
bash,1472
  └─pstree,1782 -pa 1472

$ cat /proc/1472/environ
TERM=xterm-colorHOME=/rootSHELL=/bin/bashUSER=rootLOGNAME=rootPATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/binXDG_SESSION_ID=2n

리눅스에서 std(standard streams)란

Sat, 16 Apr 2016 20:35:47 +0900

리눅스에서 프로그램이 구동시 프로그램과 실행환경 사이를 소통하기 위해서는 미리 연결된 data stream이 필요하다. 프로그램에 기본적으로 표준입력, 표준출력, 표준에러 3가지의 데이터 스트림(data stream)이 연결(connected)된다. 이 3가지의 I/O 커넥션을 스텐다드 스트림(standard streams) 즉 STD라고 말한다.

원래 I/O 는 물리적은 장치에 의해 발생하지만, STD에서 이야기하는 I/O는 이것보다 좀 더 추상적이다. 일반적으로 shell에서 명령어가 실행될 때 standard stream가 연결이 되고 pipe를 통해 standard stream은 서로 연결이 되기도 한다. 또한 부모 프로세스에서 자식 프로세스로 standard stream이 상속된다.

3가지의 데이터 스트림에는 고유 숫자가 붙여지며 이 번호는 변하지 않는다. STD란 standard의 약자이다.
표준입력(STDIN) stream number 0
표준출력(STDOUT) stream number 1
표준에러(STDERR) stream number 2

STDIN는 키보드를 통해 일어나고 동작 결과는 모니터에 STDOUT또는 STDERR로 출력한다.

표준입력(STDIN)

STDIN이란 프로그램 안으로 stream data가 들어가는 것이다. 별도의 리다이렉션이 없으면 키보드를 통해 STDIN을 받게된다.

$ ls -al

표준출력(STDOUT)

표준 출력이란 프로그램을 실행시켰을 경우 터미널로 나오는 결과(data)를 말한다.

$ ls -al
total 32
drwxr-xr-x  19 zion437  staff    646  4 16 20:45 .
drwx------+ 19 zion437  staff    646  4  2 17:52 ..
-rw-r--r--@  1 zion437  staff  10245  9 20  2015 .DS_Store
drwxr-xr-x   6 zion437  staff    204  1 17  2015 Angular
drwxr-xr-x   8 zion437  staff    272  4  6  2015 Cool
drwxr-xr-x  13 zion437  staff    442  1 10 12:07 TS
drwxr-xr-x  16 zion437  staff    544  9 22  2015 editor
drwxr-xr-x  10 zion437  staff    340  3 20 15:12 electron
drwxr-xr-x  25 zion437  staff    850  9 21  2014 jQeury
drwxr-xr-x   6 zion437  staff    204  8  9  2014 layout
drwxr-xr-x   9 zion437  staff    306  5 24  2015 project_moni
drwxr-xr-x   4 zion437  staff    136  9 30  2015 seotory-java
drwxr-xr-x  26 zion437  staff    884  4 16 19:28 seotory.github.com
drwxr-xr-x  13 zion437  staff    442  1 16 17:29 seotoryjs
drwxr-xr-x   7 zion437  staff    238  4 19  2015 skin
drwxr-xr-x  44 zion437  staff   1496  4 12  2015 spring
drwxr-xr-x  12 zion437  staff    408  9 22  2015 tBlog
-rw-r--r--   1 zion437  staff   1094  4 16 20:45 test.txt
drwxr-xr-x   7 zion437  staff    238  4 19  2015 youthgroup

표준에러(STDERR)

표준에러란 프로그램이 실행시에 발생하는 에러에 해당한다.

$ ls -al test.txt test.test
ls: test.test: No such file or directory
-rw-r--r--  1 zion437  staff  53  4 16 21:00 test.txt

2번째 라인에서 test.test 파일을 찾지 못하여 표준에러가 발생하였다.

리다이렉션을 이용해 표준입력, 표준출력, 표준에러 사용해보기

자 이제 위의 내용을 토대로 데이터 스트림을 파일로 기록을 해보자. 주로 >, >>, < 연산자를 사용하게 될 것이다.

리다이렉션 표준입력

표준입력을 커맨드창에서 이용하려면 < 연산자를 활용한다. wc는 라인의 수를 카운트하는 실행 명령어인데, 이 명령어를 활용해서 위에서 만들었던 test.txt 파일을 표준입력으로 전달해보자.

표준입력 활용

$ wc < test.txt 
      20     173    1094

표준입력 미활용

$ wc test.txt 
      20     173    1094 test.txt

1번과 2번의 결과를 보면 확인 할 수 있듯이 < 연산자를 넣지 않아도 결과가 똑같음을 알 수 있다. 결과가 똑같다고 해서 wc 의 작동 메커니즘이 똑같은 것은 아니다. 1번 같은 경우에는 wc 프로그램이 실행되면서 연결되었던 3개의 스트림(표준입력, 출력, 에러) 중에서 표준입력의 스트림이 이용되어 test.txt가 전송된다. 2번은 wc 프로그램 내부에서 test.txt 파일을 읽어들여 실행하게 된다.

리다이렉션 표준출력

먼저 표준에러가 없는 실행문에 대해 파일로 만들어 볼 것이다.

ls -al > test.txt

위의 명령어를 실행하면 터미널 창에서 데이터가 나오지 않는다. 이유는 데이터 스트림이 바로 test.txt로 이동되어 파일로 작성되었기 때문이다. test.txt 파일을 열어보자.

total 24
drwxr-xr-x  19 zion437  staff    646  4 16 20:45 .
drwx------+ 19 zion437  staff    646  4  2 17:52 ..
-rw-r--r--@  1 zion437  staff  10245  9 20  2015 .DS_Store
drwxr-xr-x   6 zion437  staff    204  1 17  2015 Angular
drwxr-xr-x   8 zion437  staff    272  4  6  2015 Cool
drwxr-xr-x  13 zion437  staff    442  1 10 12:07 TS
drwxr-xr-x  16 zion437  staff    544  9 22  2015 editor
drwxr-xr-x  10 zion437  staff    340  3 20 15:12 electron
drwxr-xr-x  25 zion437  staff    850  9 21  2014 jQeury
drwxr-xr-x   6 zion437  staff    204  8  9  2014 layout
drwxr-xr-x   9 zion437  staff    306  5 24  2015 project_moni
drwxr-xr-x   4 zion437  staff    136  9 30  2015 seotory-java
drwxr-xr-x  26 zion437  staff    884  4 16 19:28 seotory.github.com
drwxr-xr-x  13 zion437  staff    442  1 16 17:29 seotoryjs
drwxr-xr-x   7 zion437  staff    238  4 19  2015 skin
drwxr-xr-x  44 zion437  staff   1496  4 12  2015 spring
drwxr-xr-x  12 zion437  staff    408  9 22  2015 tBlog
-rw-r--r--   1 zion437  staff      0  4 16 21:04 test.txt
drwxr-xr-x   7 zion437  staff    238  4 19  2015 youthgroup

프로그램 실행 결과 데이터가 test.txt파일로 저장되었다. > 연산자는 데이터 스트림을 redirect시키는 역활을 한다.

주의할 점은 > 실행시 같은 파일로 지정하면 데이터가 다시 쓰이는게 아니라 모두 지워지게 된다. > 명령어가 시작 전에 대상파일을 0byte로 만들고 시작하기 때문이다.

리다이렉션 표준에러

터미널 창에서 아래와 같이 입력해보자.

ls -al test.test > test.txt
ls: test.test: No such file or directory

위와 같이 입력했다면 test.test 파일이 없어서 화면 상에 에러 메세지가 출력된다. 실제로 test.txt 파일을 vi로 열어보면 아무것도 없음을 확인 할 수 있다. 에러메세지도 test.txt 파일로 담길줄 알았는데 왜 담기지 않은 것일까. 이유는 > 연산자가 기본적으로 표준출력 번호 1번을 리다이렉트 시키기 때문이다.

즉 표준에러를 파일로 담기 위해서는 표준에러 stream number 2를 붙여서 아래와 같이 호출해야 한다.

ls -al test.test 2> test.txt

2>를 붙이면 test.txt 파일에 프로그램 실행 에러 메세지가 제대로 저장되는 것을 확인 할 수 있다.

» 사용해보기

>> 연산자는 > 연산자와는 조금 다른 역활을 한다.

ls -al > test.txt
wc test.txt >> test.txt

터미널에 위와 같이 입력해보자. vi를 통해 test.txt 파일을 열어보면 아래와 같은 내용을 확인 할 수 있다.

total 24
drwxr-xr-x  19 zion437  staff    646  4 24 11:58 .
drwx------+ 19 zion437  staff    646  4  2 17:52 ..
-rw-r--r--@  1 zion437  staff  10245  9 20  2015 .DS_Store
drwxr-xr-x   6 zion437  staff    204  1 17  2015 Angular
drwxr-xr-x   8 zion437  staff    272  4  6  2015 Cool
drwxr-xr-x  13 zion437  staff    442  1 10 12:07 TS
drwxr-xr-x  16 zion437  staff    544  9 22  2015 editor
drwxr-xr-x  10 zion437  staff    340  3 20 15:12 electron
drwxr-xr-x  25 zion437  staff    850  9 21  2014 jQeury
drwxr-xr-x   6 zion437  staff    204  8  9  2014 layout
drwxr-xr-x   9 zion437  staff    306  5 24  2015 project_moni
drwxr-xr-x   4 zion437  staff    136  9 30  2015 seotory-java
drwxr-xr-x  26 zion437  staff    884  4 16 19:28 seotory.github.com
drwxr-xr-x  13 zion437  staff    442  1 16 17:29 seotoryjs
drwxr-xr-x   7 zion437  staff    238  4 19  2015 skin
drwxr-xr-x  44 zion437  staff   1496  4 12  2015 spring
drwxr-xr-x  12 zion437  staff    408  9 22  2015 tBlog
-rw-r--r--   1 zion437  staff      0  4 24 12:13 test.txt
drwxr-xr-x   7 zion437  staff    238  4 19  2015 youthgroup
      20     173    1094 test.txt

마지막 줄에서 보면 알 수 있듯이 ls -al의 결과 밑에 wc test.txt 결과 값이 붙여 쓰여진다. >는 파일을 새롭게쓰고, >>는 파일 내용을 이어서 작성한다.

조합하여 사용하기

위에서 사용했던 리다이렉션 연산자들을 연속적으로 사용해서 아래와 같이 작성도 가능하다

ls -al > test.txt
wc < test.txt > test2.txt

두 번째 라인을 확인하면 <,> 연산자를 한 줄에 작성하여 입력하였다. 이렇게 작성하게 되면 먼저 wc < test.txt의 값을 구하고 후에 결과값을 test2.txt에 저장한다. test2.txt에는 아래와 같은 값이 저장되어 있을 것이다.

      20     173    1094

참고

javascript ajax 통신, jsonp 의 모든 것

Mon, 04 Apr 2016 19:09:44 +0900

jsonp 란?

전통적인 웹 브라우져에서는 same-origin policy (SOP) 정책에 따라 다른 도메인간의 request을 제한하고 있다. 그러나 <script/> 태그는 same-origin-policy (SOP) 정책에 속하지 않는다는 사실을 근거로, 서로 다른 도메인간의 javascript 호출을 위하여 jsonp (또는 json with padding) 이 사용되었다.

jsonp를 사용하기 위해서는 필수적으로 서버단에서 jsonp의 포맷을 따라야한다. 이것은 jsonp를 사용하기 위한 “규칙”이다.

jsonp 의 원리

jsonp의 원리를 설명하기 전에 먼저 json의 형태를 살펴보자. 아래는 일반적인 json의 코드이다.

{
    data : 'data1',
    data2 : 'data2',
    ary_data : ['1', '2', '3', '4']
}

javascript에서 “{ }” 문법은 객체 리터럴 이다. 즉 위의 코드는 객체를 정의하기 위한 코드이다. json은 객체를 정의하기 위한 문법이라고 볼 수 있다. 아래의 json response 를 받는 일반적인 jQuery ajax 을 살펴보자.

$.ajax({
    url : 'http://seotory.com/result.json',
    type : 'json'
}).done(funcntion(data){
    // data 는 json 포맷 타입을 받게 된다.
});

위의 코드에서 response로 받는 것은 json 포맷 -> 객체를 받는 것이다. 그러면 $.done() 함수 안에서 function(data){} 라는 익명 함수(callback 함수라고 볼 수 있음)가 data객체를 바탕으로 무엇인가 output 을 만들어 내게 된다. 이런 경우는 SOP 정책에 위배되지 않은 매우 일반적인 브라우져간 XMLHttpRequest 통신이라고 볼 수 있다.

하지만 http://seotory.com/test.js 에서 호출 하는 ajax 가 seotory.com/result.json 이 아닌 seotest.com/result.json 의 데이터를 한다면? SOP 정책에 걸려서 데이터를 가져오지 못할 것이다. 어떻게 호출해야 할까?

답은 이미 위에 적혀있다. <script/> 태그를 이용하는 것이다.

<script type="text/javascript" src="http://seotest.com/result.json"></script>

위의 코드를 html에 선언하면 정상적으로 json URL을 호출 할 것이다. 그러나 result.json 안에 있는 코드는 객체를 정의하는 코드이지 실행 코드가 아니다. 이 말인즉 위의 코드를 실행 코드로 바꿔주기만 하면 도메인이 달라도 SOP 정책을 벗어나 자유로운 javascript 함수 호출이 가능해 진다는 뜻이다. result.json 코드를 이제 아래와 같이 바꿔보자.

callback({
    data : 'data1',
    data2 : 'data2',
    ary_data : ['1', '2', '3', '4']
})

avascript 에서 “( )” 은 실행 구문이다. 즉 위의 코드는 callback() 이라는 함수를 실행 시키는 구문이다. 잘 보면 argument 로 객체 리터럴(result.json 의 내용)을 사용하고 있음을 볼 수 있다.

<script type="text/javascript" src="http://seotest.com/result.json"></script>
<script>
function callback( data ) {
    // data 는 result.json 의 데이터가 들어오게 된다.
}
</script>

위의 소스처럼 callback 이라는 함수를 만들면, seotest.com/result.json 는 선언된 callback 함수를 호출하게 될것이다. 다른 도메인이라고 할지라도 문제 없이 json 데이터를 사용하게 되는 것이다. 사실 jsonp는 이것이 다다.

jQuery jsonp

jQuery v.1.2 이상부터 jsonp 형태가 지원이 된다. jQuery 의 jsonp 은 위의 원리를 토대로 만들어졌다. 아래의 jQuery 소스를 보면window 영역에 callbackName 의 함수를 만드는 것을 확인 할 수 있다.

// Handle iff the expected data type is "jsonp" or we have a parameter to set
if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {

	// Get callback name, remembering preexisting value associated with it
	callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
		s.jsonpCallback() :
		s.jsonpCallback;

	// Insert callback into url or form data
	if ( jsonProp ) {
		s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
	} else if ( s.jsonp !== false ) {
		s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
	}

	// Use data converter to retrieve json after script execution
	s.converters["script json"] = function() {
		if ( !responseContainer ) {
			jQuery.error( callbackName + " was not called" );
		}
		return responseContainer[ 0 ];
	};

	// force json dataType
	s.dataTypes[ 0 ] = "json";

	// Install callback
	overwritten = window[ callbackName ];
	window[ callbackName ] = function() {
		responseContainer = arguments;
	};

	// Clean-up function (fires after converters)
	jqXHR.always(function() {
		// Restore preexisting value
		window[ callbackName ] = overwritten;

		// Save back as free
		if ( s[ callbackName ] ) {
			// make sure that re-using the options doesn't screw things around
			s.jsonpCallback = originalSettings.jsonpCallback;

			// save the callback name for future use
			oldCallbacks.push( callbackName );
		}

		// Call if it was a function and we have a response
		if ( responseContainer && jQuery.isFunction( overwritten ) ) {
			overwritten( responseContainer[ 0 ] );
		}

		responseContainer = overwritten = undefined;
	});

	// Delegate to script
	return "script";
}

jsonp 팁

가끔 jsonp를 사용하다가 보면 callback 함수를 지정하지 않아서 에러가 난다는 연락을 받을 때가 있다. (대부분 비정상적인 경우이며, 커뮤니케이션이 제대로 되지 않은 상태이다.) 이런 경우에는 response를 보낼때에 “callback({data})” 만 보내지 말고, try catch 문을 이용해서 보내면 에러를 방지 할 수 있다.

try {
    callback({
        data : 'data1',
        data2 : 'data2',
        ary_data : ['1', '2', '3', '4']
    })
} catch (e){}

다른 경우로 jQuery ajax jsonp 를 이용해 구현하였는데, 자동 단어 완성 같이 빠르게 XMLHttpRequest 통신을 할때에는 콜백 함수를 찾지 못해 에러(response 타이밍에 따라서 jQuery ajax 의 누수)가 나는 경우가 있다. 이 역시 위와 같은 방법으로 해결 할 수도 있고, 아래와 같이 window 영역에 호출될 callback 함수를 명시적으로 만들어서 해결하는 방법도 있다.

function callback () {
    // 전역 함수로 작성
}

core javascript 를 이용해서 jsonp 호출하기

위의 내용을 다 이해했다면 어렵지않다. 아래와 같이 jQuery를 사용하지 않더라도 jsonp를 호출 할 수있다.

function test () {
    var script = document.createElement("script");
    script.type = "text/javascript";
    script.src = "http://seotest.com/result.json";
    document.getElementsByTagName('head').appendChild(script);
}
function callback ( data ) {
    // data 객체 받아 옴
}
test();

참조

ruby에서 net/http를 이용한 json api call

Wed, 23 Mar 2016 08:59:59 +0900

ruby의 제공 모듈인 net/http를 이용하여 json api를 하려면 아래와 같이 작성하여 실행해보면된다. java와는 다르게 매우 쉽게 작성할 수 있다.

require 'net/http'
require 'json'

url = 'https://api.github.com/users/seotory'
uri = URI(url)
response = Net::HTTP.get(uri)

obj = JSON.parse(response)

p obj

위의 코드에서 url 부분을 바꾸면 테스트 해볼 수 있을 것이다.

https 호출인 경우 window 환경이라면 아래과 같은 error가 발생한다.

C:/Ruby22-x64/lib/ruby/2.2.0/net/http.rb:923:in `connect': SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed (OpenSSL::SSL::SSLError)

이유는 ruby의 기본 라이브러리인 net/http에서 TLS handshake 시 ssl 인증서가 유효한지 체크하지 않기 때문이다. ruby net/http 안쪽에서 openssl을 이용하고 있다. openssl은 SSL_CERT_FILE 이라는 환경변수를 이용하는데, 이 환경변수는 인증서의 위치를 가르킨다. 따라서 아래와 같이 SSL_CERT_FILE 셋팅하면 error를 해결할 수 있다.

http://curl.haxx.se/ca/cacert.pem 파일을 C:\RailsInstaller\ 폴더에 넣는다.
SSL_CERT_FILE=C:\RailsInstaller\cacert.pem 시스템 환경변수를 추가한다.

cacert.pem 파일이 ssl 인증서 내용을 포함하고 있다. 이 파일을 SSL_CERT_FILE 변수에서 가르키게 되면 에러가 해결된다.

참조

java singleton pattern (싱글톤 패턴)

Sat, 19 Mar 2016 21:04:16 +0900

예전 블로그에서도 singleton 에 대한 글을 쓴적이 있다. 그때는 매우 단순하게 적었으나 이번에는 조금 방대할 것이다. 단일 인스턴스를 다양하게 만들 수 있는 방법을 예제로 통해 한번 알아 보도록 하자.

singleton 이란?

프로그래밍 세계에 OOP 의 개념이 생기면서 객체 자체에 대한 많은 연구와 패턴(pattern)들이 생겨났다. singleton pattern은 인스턴스가 사용될 때에 똑같은 인스턴스를 만들어 내는 것이 아니라, 동일 인스턴스를 사용하게끔 하는 것이 기본 전략이다. 프로그램상에서 동일한 커넥션 객체를 만든다던지, 하나만 사용되야하는 객체를 만들때 매우 유용하다. singleton pattern은 4대 디자인 패턴에 들어갈 정도로 흔히 쓰이는 패턴이다. 물론 core java(java.lang.Runtime, java.awt.Desktop 등등)에서도 singleton pattern이 사용된다.

Eager initialization

아래가 가장 기본적인 singleton pattern이다. 전역 변수로 instance를 만드는데 private static을 이용한다. static이 붙은 클래스변수는 인스턴스화에 상관없이 사용이 가능하게 된다. 하지만 앞의 private 접근제어자로 인해 EagerInitialization.instance로의 접근은 불가능하다. 이런 상태에서 생성자를 private로 명시한다. 생성자를 private로 붙이게되면, new 키워드를 사용할 수 없게된다. 즉 다른 클래스에서 EagerInitialization instance = new EagerInitialization(); 이런 방법을 통한 인스턴스 생성은 불가능해진다. 결국 외부 클래스가 EagerInitialization 클래스의 인스턴스를 가질 수 있는 방법은 11번째 라인에 있는 getInstance() method를 사용하는 수 밖에 없다.

public class EagerInitialization {
	// private static 로 선언.
	private static EagerInitialization instance = new EagerInitialization();
	// 생성자
	private EagerInitialization () {
		System.out.println( "call EagerInitialization constructor." );
	}
	// 조회 method
	public static EagerInitialization getInstance () {
		return instance;
	}
	
	public void print () {
		System.out.println("It's print() method in EagerInitialization instance.");
		System.out.println("instance hashCode > " + instance.hashCode());
	}
}

위의 단순한 singleton pattern은 리소스가 작은 프로그램일때엔 고도화 대상이 아니다. 하지만 프로그램의 크기가 커져서 수 많은 클래스에서 위와 같은 singleton pattern을 사용한다고 가정해보자. 3번째 라인의 new EagerInitialization();으로 인해 클래스가 load 되는 시점에 인스턴스를 생성시키는데 이마저도 부담스러울 수가 있다. 또한 이 소스는 EagerInitialization 클래스가 인스턴스화 되는 시점에 어떠한 에러처리도 할 수가 없다.

static block initialization

public class StaticBlockInitalization {
	private static StaticBlockInitalization instance;
	private StaticBlockInitalization () {}
	
	static {
		try {
			System.out.println("instance create..");
			instance = new StaticBlockInitalization();
		} catch (Exception e) {
			throw new RuntimeException("Exception creating StaticBlockInitalization instance.");
		}
	}
	
	public static StaticBlockInitalization getInstance () {
		return instance;
	}
	
	public void print () {
		System.out.println("It's print() method in StaticBlockInitalization instance.");
		System.out.println("instance hashCode > " + instance.hashCode());
	}
	
}

static 초기화블럭을 이용하면 클래스가 로딩 될 때 최초 한번 실행하게 된다. 특히나 초기화블럭을 이용하면 logic을 담을 수 있기 때문에 복잡한 초기변수 셋팅이나 위와 같이 에러처리를 위한 구문을 담을 수 있다. 첫 번째 패턴보다 좋아보이지만 인스턴스가 사용되는 시점에 생성되는 것은 아니다.

lazy initialization

이제 클래스 인스턴스가 사용되는 시점에 인스턴스를 만드는 singleton pattern을 배워보도록 하자. 아래 소스의 lazy initialization pattern은 필요할때 인스턴스를 생성시키는 것이 핵심이다.

public class LazyInitialization {
	
	private static LazyInitialization instance;
	private LazyInitialization () {}
	
	public static LazyInitialization getInstance () {
		if ( instance == null )
			instance = new LazyInitialization();
		return instance;
	}
	
	public void print () {
		System.out.println("It's print() method in LazyInitialization instance.");
		System.out.println("instance hashCode > " + instance.hashCode());
	}
}

new LazyInitialization(); 가 어디에 선언되었는지 주목해보자. getInstance() method 안에서 사용되었다. if문을 이용해 instance가 null 인 경우에만 new를 사용해 객체를 생성하였다. 최초 사용시점에만 인스턴스화 시키기 때문에 프로그램이 메모리에 적재되는 시점에 부담이 많이 줄게된다. 하지만 여전히 문제는 남아있다. 만약 프로그램이 muilti thread 방식이라면 위와 같은 singleton pattern은 안전하지 않다. 동일 시점에 getInstance() method를 호출하면 인스턴스가 두번 생길 위험이 있다.

thread safe initalization

위에서 문제가 되었던 muilit thread문제를 해결하기 위해 synchronized(동기화)를 사용하여 singleton pattern을 구현한다. 여러 thread들이 동시에 접근해서 인스턴스를 생성시키는 위험은 없어졌다. 하지만 수 많은 thread 들이 getInstance() method 를 호출하게 되면 높은 cost 비용으로 인해 프로그램 전반에 성능저하가 일어난다.

public class ThreadSafeInitalization {
	
	private static ThreadSafeInitalization instance;
	private ThreadSafeInitalization () {}
	
	public static synchronized ThreadSafeInitalization getInstance () {
		if (instance == null)
			instance = new ThreadSafeInitalization();
		return instance;
	}
	
	public void print () {
		System.out.println("It's print() method in ThreadSafeInitalization instance.");
		System.out.println("instance hashCode > " + instance.hashCode());
	}
	
}

initialization on demand holder idiom

미국 메릴랜드 대학의 컴퓨터 과학 연구원인 Bill pugh 가 기존의 java singleton pattern이 가지고 있는 문제들을 해결 하기 위해 새로운 singleton pattern을 제시하였다. Initialization on demand holder idiom기법이다. 이것은 jvm 의 class loader의 매커니즘과 class의 load 시점을 이용하여 내부 class를 생성시킴으로 thread 간의 동기화 문제를 해결한다.

public class InitializationOnDemandHolderIdiom {
	
	private InitializationOnDemandHolderIdiom () {}
	private static class Singleton {
		private static final InitializationOnDemandHolderIdiom instance = new InitializationOnDemandHolderIdiom();
	}
	
	public static InitializationOnDemandHolderIdiom getInstance () {
		System.out.println("create instance");
		return Singleton.instance;
	}
}

initialization on demand holder idiom 역시 lazy initialization이 가능하며 모든 java 버젼과, jvm에서 사용이 가능하다. 현재 java 에서 singleton 을 생성시킨다고 하면 거의 위의 방법을 사용한다고 보면 된다.

enum initialization

Joshua Bloch가 작성한 effective java 책에서 enum singleton 방법이 소개 되었다.

public enum EnumInitialization {
	INSTANCE;
	static String test = "";
	public static EnumInitialization getInstance() {
		test = "test";
		return INSTANCE;
	}
}

enum 이 singleton pattern 으로 사용될 수 있는 이유는 아래와 같다.

INSTANCE 가 생성될 때, multi thread 로 부터 안전하다. (추가된 methed 들은 safed 하지 않을 수도 있다.)
단 한번의 인스턴스 생성을 보장한다.
사용이 간편하다.
enum value는 자바 프로그램 전역에서 접근이 가능하다.

using reflection to destroy singleton

위에서 여러 방법으로 singleton을 만들어 보았으니 이번엔 java의 reflection을 이용하여 singleton을 깨뜨려 보는법도 배워보자. 누군가 작성한 코드를 원본 수정없이 작업해야 할때 이용될 수 있을 것이다.

public class UsingReflectionToDestroySingleton {
	
	public static void main (String[] args) {
		EagerInitialization instance = EagerInitialization.getInstance();
		EagerInitialization instance2 = null;
		
		try {
			Constructor[] constructors = EagerInitialization.class.getDeclaredConstructors();
			for ( Constructor constructor : constructors ) {
				constructor.setAccessible(true);
				instance2 = (EagerInitialization)constructor.newInstance();
			}
		} catch (Exception e) {
			
		}
		
		System.out.println(instance.hashCode());
		System.out.println(instance2.hashCode());
		
	}
}

위의 코드를 실행해보면 아래 System.out.println();의 두 라인에서 찍히는 hachCode()값이 다른 것을 확인 할 수 있다. java의 reflection은 매우 강력하다. 설령 class 의 생성자가 private 일지라도 강제로 가져와서 새로운 인스턴스 생성이 가능하다. 결국 singleton pattern을 깨뜨리는 것이다. 이 외에도 reflection을 여러곳에서 사용할 수 있으니 알아두는 것이 좋다.