[java] CSVWriter사용하기 (그리고 쌍따옴표 없애기)

CSV는 참으로 많은 곳에서 사용한다. 데이터를 저장할 때 사용하는 아주 기본적인 포맷이 아닌가 싶다.
CSV에서 오는 간결함은 그것을 만드는 사람마저 간결함을 추구하게 하는 힘이 있다.
콤마으로 나눠진 값들(CSV, Comma Separated Values)은 그 간결함 속에서 더욱 확장되어왔다.

자바에서는 CSV를 만들기 위한 Writer를 따로 만들어주고 있지 않지만, 사람들이 애용하는 라이브러리는 존재한다.
그중 하나 opencsv을 사용해보자.

/** CSVWriter 사용해보기**/
public class CSVTest {
  static List makeFileValues() {
    List list = new ArrayList();
    for(int i = 0; i < 10 ; i++) {
      list.add(new String[] { String.valueOf(i), String.valueOf(i+i), String.valueOf(i+i+i)});
    }
    return  list;
  }
}

실행해보자.

public static void main(String[] args) throws IOException {
  String Path = "C:/ynam/";
  String Name = "CSVTEST";
  
  try (CSVWriter writer = new CSVWriter(new FileWriter(Path+Name + ".csv"))){
    writer.writeAll(makeFileValues());
  }
}

실행해보자.

"0","0","0"
"1","2","3"
"2","4","6"
"3","6","9"
"4","8","12"
"5","10","15"
"6","12","18"
"7","14","21"
"8","16","24"
"9","18","27"

이렇게 나왔다.
이 현상은 사실 우리 회사에서 벌어지던 일이었다. 이 따옴표가 문제는 아니다. 하지만 이 내용을 그대로 다시 디비에 넣고 다시 빼낸다면?

"""0""","""0""","""0"""
"""1""","""2""","""3"""
"""2""","""4""","""6"""
"""3""","""6""","""9"""
"""4""","""8""","""12"""
"""5""","""10""","""15"""
"""6""","""12""","""18"""
"""7""","""14""","""21"""
"""8""","""16""","""24"""
"""9""","""18""","""27"""

처음부터 우리가 원하는 그 값 자체만을 담고 싶다면? 생성자에 추가하나만 하면 된다.

CSVWriter writer = new CSVWriter(new FileWriter(Path+Name + ".csv"))

여기를

CSVWriter writer = new CSVWriter(new FileWriter(Path+Name + ".csv"), ',', CSVWriter.NO_QUOTE_CHARACTER)

이렇게 바꾸고 다시 해보자.

  public static void main(String[] args) throws IOException {
    String Path = "C:/ynam/";
    String Name = "CSVTEST_without_qoute";
  
    try (CSVWriter writer = new CSVWriter(new FileWriter(Path+Name + ".csv"), ',', CSVWriter.NO_QUOTE_CHARACTER)){
      writer.writeAll(makeFileValues());
    }
}

자 실행해보면 어떻게 나올까

0,0,0
1,2,3
2,4,6
3,6,9
4,8,12
5,10,15
6,12,18
7,14,21
8,16,24
9,18,27

단순하다.

[java] List에서 int[] 로 바꾸는 방법 (on java8)

List에서 int[]로 바꾸는 손쉬운 방법은 없었다. Arrays의 toArray()는 Object[]를 반환하기 때문에 불가능했고
toArray(T[] ...) 얘도 primitive type인 int[]를 담을 순 없었다.

하지만 Java8에서는 쉽게 변환할 수 있다.

List list = new ArrayList<>();
...
int[] i_arr = list.stream().mapToInt(i -> i).toArray();

어떻게 이렇게 쉽게 되는 걸까?
list.stream()은 게다가 아직 Integer이다. 무슨 일이 벌어진 걸까?
java8부터 primitive type을 다룰 수 있는 IntStream이라는 것이 있다.
우리는 이놈으로 바꿔야만 한다. 그래서 사용하는 것이 mapToInt이다 얘는 IntStream을 리턴한다.
mapToInt이라는 이름처럼 요소 하나하나를 매개변수 안에 있는 로직대로 이행한 후 IntStream으로 리턴하는 듯하다.

그래서 실제로는 이렇게 되야 한다.

mapToInt((Integer i) -> i.intValue()) or mapToInt(Integer::intValue())

Integer에 있는 메소드 intValue로 int로 변환하는 함수를 넣는 것이 정상이다. 그런데 왜 그냥 아무짓도 안해도 에러가 안나고 잘 되는 걸까?
바로 언박싱을 이용하는 것인데, 리턴값은 int로 정해져있고 컴파일러가 그걸 확인할 것이다.

만약 자바8을 쓸 수 없다면?
Guava를 사용하면 되겠다.

[java][design pattern] 더블 디스패치 패턴은 언제 쓰일까?

더블디스패치 패턴은 대체 왜 쓰이는 걸까?
자바는 싱글디스패치만을 지원한다고 한다.
그 말은 더블디스패치를 사용하려면 패턴으로 메꿔야 한다는 말인가보다.
예전에는 싱글디스패치만으로도 만족하고 살았지만 다른 많은 언어들이 실행시키는 인스턴스와 매개변수 둘 다 타입체크를 하여 멋져졌다 하니.
우리도 패턴으로 그것이 가능함을 보여야 하지 않겠나 해서 만들어 진 것이 아닌가 하는 상상을 해본다.

일단 만들어보자. 이제부터 할 일은 이렇게 된다.

인터페이스 둘을 만든다. (Format, Post)

인터페이스를 구현한다. (Post - Mail,SMS / Format - JPG,XML)

이 두 인터페이스를 연결한다.

실행해본다.

일단 왜 더블디스패치가 없이 만들면 어떻게 되는지 보자.

1. 인터페이스 둘을 만든다.
interface Format {}
interface Post {}

2. 인터페리스를 구현한다. (총 4개)
public class JPG implements Format { }
public class XML implements Format { }

public class Mail implements Post { }
public class SMS implements Post { }

이제 인터페이스에 필요한 내용들 추가하고 구현도 해서 이 두 인터페이스를 연결하자.
Post인터페이스는 JPG / XML에 따라 보내는 방식이 다를 수 있다. 그래서 그 타입에 따라 다른 일을 하도록하자.

public interface Post {
  void send(Format format);
  void send(JPG jpg);
  void send(XML xml);
}

게다가 SMS/MAIL에 따라 다를 것이다.

public class Mail implements Post {

  @Override
  public void send(Format format) {
    throw new RuntimeException("Mail.send(Format format) :: 타입을 알 수 없습니다.");
  }

  @Override
  public void send(JPG jpg) {
    System.out.println("Mail.send(JPG jpg)");
  }

  @Override
  public void send(XML xml) {
    System.out.println("Mail.send(XML xml)");
  }

}

public class SMS implements Post {

  @Override
  public void send(Format format) {
    throw new RuntimeException("SMS.send(Format format) :: 타입을 알 수 없습니다.");
  }

  @Override
  public void send(JPG jpg) {
    System.out.println("SMS.send(JPG jpg)");
  }

  @Override
  public void send(XML xml) {
    System.out.println("SMS.send(XML xml)");
  }

}

다 되었다. 실행해보자.

public class Test {
  public static void main(String[] args) {
    Post post = new Mail();
    Format format = new JPG();
    post.send(new JPG());
    post.send(format);
  }
}

잘 될까?

Mail.send(JPG jpg)
Exception in thread "main" java.lang.RuntimeException: Mail.send(Format format) :: 타입을 알 수 없습니다.
 at designpattern.doubledispatch.post.Mail.send(Mail.java:11)
 at designpattern.doubledispatch.Test.main(Test.java:13)

하나는 잘 되었고, 다른 하나는 잘 되지 않았다. 왜냐하면 메소드 오버로딩은 정적 디스패치(static dispatch)를 한다. 이 말은 런타임에 타입을 동적으로 체크하는 것이 아니라 미리 컴파일 이전에 타입을 미리 제대로 정해 놔야 한다는 말이다.
에러가 난 곳은 정확한 타입(JPG)를 넣은 것이 아니라. Format이라는 인터페이스를 넣었다. 이것이 문제가 되는 것
그러면 어떻게 해야 할까?
일단 자바에서는 매개변수 타입체크를 동적으로 하지않는다고 하니까 타입체크를 두 번 하도록 해보자.
지금부터 할일은

1. Post 인터페이스를 매개변수가 Format인 것만 남기고 삭제한다. (어짜피 이걸로 타입체크를 못함)
2. Format 인터페이스에 Mail,SMS(Post의 구현체 전부)를 각각 매개변수로 하여 void send(T t)형식의 메소드를 추가한다
3. Post의 구현체에서 해당 메소드를 호출한다.
4. 실제로 로직을 실행하는 곳은 Format의 구현체들에서 각각 구현한다.

말이 잘 전달되지 않은 것 같은데 일단 코드를 한 번 짜보자.

// 1. 매개변수가 Format 인것 빼고 다 삭제
public interface Post {
  void send(Format format);
}
// 2. Mail,SMS를 각각 매개변수로 send라는 메소드를 추가
public interface Format {
  /*
   * 여기에서 타입체크를 하는 것이다. 원래는 Post에서 했지만
   * 한 번 더 하기 위해, Format에서 한다.
   * 
   */
  void send(Mail mail);
  void send(SMS sms);
}

이제 인터페이스를 바꿨으니 구현체들을 바꿔보자.

// 3. 새로 만든 메소드 호출
public class Mail implements Post {

  @Override
  public void send(Format format) {
    format.send(this); // 여기서 이미 this는 타입체킹이 되어있음.
  }
}

public class SMS implements Post {

  @Override
  public void send(Format format) {
    format.send(this);
  }

}

이제 실제 로직이 들어있는 곳을 보자.

// 4. 실제 로직이 있는 곳 변경
public class JPG implements Format {

  @Override
  public void send(Mail mail) {
    System.out.println("mail send JPG");
  }

  @Override
  public void send(SMS sms) {
    System.out.println("SMS send JPG");
  }

}

public class XML implements Format {

  @Override
  public void send(Mail mail) {
    System.out.println("mail send XML");
  }

  @Override
  public void send(SMS sms) {
    System.out.println("SMS send XML");
  }

}

한번 실행해보자.

public class Test {
  public static void main(String[] args) {
    Post post = new Mail();
    Format format = new JPG();
    post.send(new JPG());
    post.send(format);
  }
}

과연 결과는??

mail send JPG
mail send JPG

성공이다. 이 패턴은 비지터 패턴과 아주 유사하다고 하는데, 비지터 패턴은 내 생각에는 클래스를 변경하지 않고 새로운 로직을 추가하기 위해 필요한 패턴인 것 같고
더블디스패치패턴은 좀 더 일반적인 기술같다. 양쪽의 타입을 제대로 체크하기 위해 만든 기술인듯하다.

[java] interface constant는 왜 쓰면 안될까?

가끔 이런 생각을 해보기도 한다.
귀찮은데 그냥 상수도 인터페이스로 넣어서 쓰면 안되나?
아니면 implements로 상수를 전부 가져와서 이름만으로 써도 되지 않을까?
아래의 예시가 왜 쓰면 안되는지 도움이 될 것 같다. 우선 클래스 안에 있는 상수들을 보자.

public class ClassCons {
 public static final double CONS = 0.0;
 public static final String CONS1 = "22";
 public static final int CONS2 = 1;
}

이제 이것들을 인터페이스 상수로 바꿔보자.

interface InterCons {
 double CONS = 0.0;
 String CONS1 = "22";
 int CONS2 = 1;
}

인터페이스는 어짜피 public이다. 그러니 public이 필요없다. 바뀌지 않을 것이니 final도 필요없다.
마치 짧아진 코드를 보며 내가 뭔가 해낸(?)사람 처럼 느낄 수도 있지만 아님을 바로 깨달을 수 있다.

public class BadIdea implements InterCons{
 public BadIdea() {
  System.out.println(CONS);
  System.out.println(CONS1);
  System.out.println(CONS2);
 }
 public static void main(String[] args) {
  BadIdea badIdea = new BadIdea();
 }
}

이 내용은 위에서 만든 인터페이스 상수를 가져온 것이다. 과연 이렇게 하면 잘 될까?

0.0
22
1

예상한 대로 나왔다. 하지만 이렇게 한다면?

public class BadIdea implements InterCons{
 private int CONS = 100;
 public BadIdea() {
  System.out.println(CONS);
  System.out.println(CONS1);
  System.out.println(CONS2);
 }
 public static void main(String[] args) {
  BadIdea badIdea = new BadIdea();
 }
}

다시 실행해보자.

100
22
1

값이 바뀌어 있다. 이 말은 인터페이스 상수를 가져오는 순간 해당 클래스와 그 서브 클래스들이 상수들로 더러워(?)진다는 것을 말한다.
자칫하면 값들이 꼬일 수 있다. 에러도 잘 보이지 않을 거고 디버깅에도 애를 먹을 수도 있겠다.

[java] volatile이란 뭘까?

Dzone에서 volatile내용을 보고 있다가 좀 적어놔야 할 것같아서 적는다.
자바의 keyword 중에 하나인 volatile은 대체 정확히 어떨 때 쓰는 것일까?
애초에 volatile은 뭘까?
volatile은 휘발성 이란 의미를 가지고 있다. 잘 날아간다는 말이니까. 금방금방 그 값이 사라진다고 말 할수도 있고, 그 값이 의미없어진다고도 말 할수 있겠다.
volatile은 값을 읽고, 쓰는 것에 대한 원자성(Atomic)을 유지해주는 것 같다.

왜 이게 필요한가 하면 멀티스레드 환경에서 스레드 각각이 변수들의 값을 캐싱해서 사용한다는 것때문이다. 덕분에 값을 조회할 때마다 실제 값을 조회할 필요가 없이 사용할 수 있지만 만약 공유하는 값이 있고 그 값이 자주 변한다면 문제가 생길 수 있지 않을까?
그때 volatile을 사용하면 되지 않을까 싶다.

public class VolatileTest {
  private static volatile int count = 0;
//private static int count = 0;
  public static void main(String[] args) {
    new IwillGetIt().start();
    new IwillChangeIt().start();
  }  
  
  static class IwillGetIt extends Thread {
    @Override
    public void run() {
      int my_local = count;
      while (my_local < 5) {
        if (my_local != count){
          System.out.println("바꼈다!!! : " + count);
   my_local = count;
 }
      }
    }
  } 
  static class IwillChangeIt extends Thread {
    @Override
    public void run() {
      int my_local = count;
      while (my_local < 5 ) {
        System.out.println("값을 증가 시킴 : " + (++my_local));
        count = my_local;
        try {
          Thread.sleep(2000);
        } catch (InterruptedException e) {
   e.printStackTrace();
 }
      }
    }
  }
}

어떻게 될까? 위의 내용은 volatile을 넣은 것이다. count라는 값은 두개의 스레드가 공유를 한다. 서로 IwiilChangeIt은 바꾸는 아이고 IwillGetIt은 바꾸는 현장을 포착하는 아이다.

값을 증가 시킴 : 1
바꼈다!!! : 1
값을 증가 시킴 : 2
바꼈다!!! : 2
값을 증가 시킴 : 3
바꼈다!!! : 3
값을 증가 시킴 : 4
바꼈다!!! : 4
값을 증가 시킴 : 5
바꼈다!!! : 5

그렇다면 이 상태에서 저 위에 volatile이 없는 녀석의 주석을 풀고, volatile이 있는 녀석은 주석을 걸어보고 다시 실행하자.

값을 증가 시킴 : 1
바꼈다!!! : 1
값을 증가 시킴 : 2
값을 증가 시킴 : 3
값을 증가 시킴 : 4
값을 증가 시킴 : 5

그렇다면 volatile은 항상 쓰는 것이 스마트한 것일까?
난 잘 모르겠지만 그렇게는 쓰지 않는 것이 좋을 것 같다. 왜냐하면?
1. volatile은 변수에게 특권을 주는 것과 같다. 그 특권을 남발하면 안된다.
2. volatile을 모든 변수에게 주면 코드가 지저분하다.
3. 1번과 일맥상통한 것인데 volatile을 죄다 쓰면 누가 진짜 필요한 volatile인지 누가 알 수 있을까. 왜 이렇게 썼는지 고민하고 있지 않을까?
4. 성능의 이슈는 없을까? 하지만 이건 아직 내가 신경쓸 것은 아닌 듯 하다.

[JavaScript] 자바스크립트에서 private변수 사용하기

자바스크립트에서는 private을 넣는다고 private 변수가 되지 않는다.

var my obj = {
  myprop: 1,
  getProp: function() { return this.prop; }
}
console.log(myobj.myprop);
1
console.log(myobj.getProp()); 
1

다른 방법으로도 한번 만들어보자.

function G() {
  this.name '지';
  this.age = function() { return 1; }
}
var g = new G();
console.log(g.name);
'지'
console.log(g.age());
1

Solution

자바스크립트는 별도의 syntax가 없어도 private변수를 만들 수 있다.

function new_G() {
  var name = 'G의 숨은 뜻은 지메일'; // private
  this.getName = function() { return name; };
}
var secret_g = new new_G();
console.log(secret_g.name);
undefined
console.log(secret_g.getName());
'G의 숨은 뜻은 지메일'

생성자가 함수의 클로저를 만들고 그 클로저 스코프 안에 속하는 변수들을 만든다. closure scope는 생성자 외부로 노출되지 않는다.

[java][thread] join을 이용하여 thread가 끝났는지 확인하기

join()을 이용하여 thread가 끝났는지 확인하자.

오늘 이런 형태의 소스를 보았다. (아래 내용은 예시)

RunnableClass01 rc01 = new RunnableClass01();
RunnableClass02 rc02 = new RunnableClass02();
RunnableClass03 rc03 = new RunnableClass03();

Thread th01 = new Thread(rc01);
Thread th02 = new Thread(rc02);
Thread th03 = new Thread(rc03);

th01.start();
th02.start();
th03.start();

DB.updateThreadEndsTime(); // 이것이 문제

대충 이런식이었는데... 쓰레드는 끝나지도 않았지만 시작하자마자 스레드가 끝났다는 로직을 실행시킨다.
전체 소스를 보지 않은 나의 탓이 크지만
쓰레드가 완료되었다는 시간을 처리하는 로직은 '당연히' 쓰레드가 전부 끝났을 때 업데이트 할 것이라는 가정이 있었기에 로직 수정 후 낭패를 보았다.
그 후 나는 동료에게 물었다.
"왜 이렇게 해야 하죠? 쓰레드가 끝나고 완료 업데이트를 하면 안되나요?"
"쓰레드는 원래 그래요. 서로 독립적으로 실행되기 때문이죠."
나는 단순하게 join()을 사용해서 그것이 가능함을 보이려 했다.

RunnableClass01 rc01 = new RunnableClass01();
RunnableClass02 rc02 = new RunnableClass01();
RunnableClass03 rc03 = new RunnableClass01();

Thread th01 = new Thread(rc01);
Thread th02 = new Thread(rc02);
Thread th03 = new Thread(rc03);

th01.start();
th02.start();
th03.start();

try {
  th01.join();
  th02.join();
  th03.join();
}catch (Exception e) { }

DB.updateThreadEndsTime(); // 이제 스레드 전부 완료되면 된다.

"이러면 쓰레드 하나가 끝나면 다른 하나가 시작되는 것 아녜요?"
나는 말했다.
"아닙니다. 시작은 같이 하고 끝나는 것만 동기되는 거예요.
어짜피 다 끝나야 완료처리 되야 하는 거니까 다 끝나야 일을 하는것이 맞다고 생각해요." 이렇게 끝났다. 하지만 여기서 하나 더 수정을 해야겠다.

Thread th01 = new Thread(new RunnableClass01());
Thread th02 = new Thread(new RunnableClass02());
Thread th03 = new Thread(new RunnableClass03());

th01.start();
th02.start();
th03.start();

try {
  th01.join();
  th02.join();
  th03.join();
} catch (Exception e) { }

DB.updateThreadEndsTime(); // 이제 스레드 전부 완료되면 된다.

물론 다른 방법도 많겠지만, 실력의 부족과 상황이 여의치 않아 이렇게 단순하게 바꾸는 것 만으로도
로직의 큰 변화가 왔다.
join(), wait(), notify() 같은 것은 기본적으로 알아야할 기능 같다.

[시간의향기]를 읽고

전작 [피로사회]를 수년 전에 읽었었다. 대학교 시절 독서토론을 하면서 이 강렬한 내용을 보면서 모두가 놀랬었다. 아주 짧은 글인데 한 장 한 장 넘기는 종이가 무겁다. 들어 올리다가도 이내 내리고 다시 읽는다. 글 자체에 대한 이해가 힘들었다. 원래 책을 읽으면서 이해가 안되면 책 탓을 하지만, 이 책은 나의 탓이라는 주문을 걸면서 인터넷으로 단어들을 검색하며 읽고 또 읽었다.

그 후 한병철이라는 철학가의 다른 책을 꼭 읽기로 했었는데, 이제야 [시간의 향기]라는 책을 구매했다. 역시나 시집보다 작은 책임에도 내 마음은 '언제 이 다 읽나' 하는 무거운 마음이 들었다. 한 장 넘기다가 다시 돌아오고, 한 문장 한 문장 곱씹다가 책을 완독했지만, 작가가 말하는 세계관을 완벽하게 이해하지 못했다. 분명 나의 부족함이라 생각하기에 나중에 좀 더 시간이 지나서 다시 읽기로 하며 책을 덮었다.

[시간의 향기] 내용

세상은 너무 빨라서 이제는 역사가 만들어지지 않고 있다. 세상이 너무 빠르게 나아가기 때문에 우리는 따라잡기 바쁘다. 우리는 숨이 턱밑까지 차오르게 하는 속도 때문에 시간의 향기를 맡을 수 없다.

느리게 걷기나 느린 삶을 추구하려는 것, 이런 것들은 이 빠른 세상 속에서 살아남기 위한 치료법이 아닌 증상일 뿐이다. 우리는 빠르게 나아가는 시간을 잡을 방법이 없는 것 같다. 시간은 적당히 느려야 세상에 그 발자취가 새겨지고 우리는 그것을 기억하게 되고 되짚고 반성하고 진화한다. 그리고 세상이 빨라졌다고 우리 인생이 편해진 것은 아니다. 이것이 우리 마음의 조급함을 대신해주지 않는다. 우리는 그 속도를 따라잡으려 애쓰고, 그 위에 올라타 더 조급해진다.

우리가 가는 길의 향기, 시간의 향기를 맡을 세도 없이 우리는 이곳저곳으로 갈 뿐이다. 우리는 멈춰야 하며, 아무것도 하지 않음으로 바로 보아야 한다. 그리고 사색해야 한다.

노동은 자유롭게 만들지 않는다. 일의 명령은 새로운 노예사회를 낳는다.

노동을 멈추고 사색하는 삶은 가지자.

[타르튀프]를 읽고

열린책들 세계문학서적 중에 아주 특이한 이름의 책을 보았다. [타르튀프]라는 글인데 이 책이 나를 이끈 이유는 머리말을 읽고 나서였다. 글쓴이 몰리에르는 신에 대한 내용도 과감히 희극의 소재로 사용해왔는데, 권력자들을 소재로 사용할 때부터, 그의 서적이 불온서적이 되며, 무대에 올릴 수 없는 등 갖가지 제약을 받게 된다. 머리말에는 그들에 대한 작가의 절제된 분노를 느낄 수 있는데, 그것은 권력자들을 향한 질타였다.
 

[타르튀프]는 이 책에 실려있는 세 편의 희극 중 하나이다. 아주 옛날에 쓴 희극임에도 호흡이 현대와 맞다. 아주 빠르다 못해 가파른 느낌이 준다.분명 그 당시에는 쉴세 없이 웃다보니 막이 내려오는 느낌이 있었으리라.

권력자들은 자신들의 악행을 비난하는 것은 참지만
놀림감이 되는 것은 참지 못한다.

이 바로 위에 있는 글은 [타르튀프]의 머리말에 나오는 문장 중 하나이다. 희극의 중요성은 웃음 속에 감춰진 무엇이라는 것. 웃음으로 밖에 해소할 수 없는 그 무엇을 아주 잘 다룬 작품이었다. 특히 귀족들의 위선된 행동을 풍자한 [타르튀프]라는 희극은 참으로 많은 생각을 하게 해준다.



권력자에게 칼을 휘두를 수 없지만, 그들을 깍아 내릴 수는 있다.
그들을 저 위에 있지 않으며, 우리와 같은 사람이고, 때론 우리보다 아래 있다. 그들이 가진 권능, 신의 축복은 그들이 대단해서가 아니며, 사실 그들이 가진 권능은 신이 준 것이 아닌 우리의 두려움과 그들의 힘에서 나온다. 그들을 희극으로 놀림감으로 만들어 우리 앞에 세우고 심판하도록 하자.


내가 느낀 감상이다. 하지만 몰리에르는 지속적인 압박에 지쳤는지 [타르튀프]의 마지막 희극 [인간 혐오자]에 그의 안타까움, 외로움이 느껴진다.

 

타르튀프 위키

[linux] ssh은 되는데 sftp가 안되는 경우

sftp root@123.123.123.123
root@123.123.123.123's password:
subsystem request failed on channel 0
Connection closed

그런데 ssh은 잘 들어가진다면?
뭔가 설정을 잘못되어 있을 수 있다. 일단 이걸 열어보자.

#vi /etc/ssh/sshd_config

그리고 sftp를 찾아보자. /sftp-server로 해당 내용을 검색하니 맨 마지막에 내용이 있다.
없으면 넣어주도록 하자.

#override default of no subsystems
Subsystem    sftp    /usr/libexec/sftp-server

이런게 적혀 있어야 한다. 그런데 왜 안되었을까.
해당 패스에 가보기로 하였다.

#/usr/libexec/openssh/s
sftp-server    ssh-keycat    ssh-keysign    sh-pkcs11-helper
#/usr/libexec/openssh/s

뭔가 특이점이 보이는가? 패스가 틀려 있어서 sftp가 안되었던것!! 어서 바꿔주고 재시작을 해보자.

# service sshd restart

이제 잘 될겁니다.ㅎㅎ

[java][junit] private인 메소드는 어떻게 테스트를 해야 하나요?

오늘 JUNIT테스트 케이스를 작성하려고 하는데 이상한 것을 봤습니다.
바로 제가 테스트할 메소드가 JUNIT 테스트 케이스 안에 들어있는 것이었습니다.
상황이 뭐냐하면
다른 누군가가 해당 메소드가 privat으로 되어 있었기 때문에 JUNIT에서 불러 올 수 없었던 것이지요. 그래서 똑같은 메소드를 만들어서 테스트를 했던 것입니다.
문제는 이 테스트가 나중에 쓸모 없어진다는 것같아요.
테스트를 나중에 돌려도 잘된다고 나오겠죠. 버그가 있어도
그러면 JUNIT은 어떻게 테스트를 해야 하는거지?
간접적인 테스트를 하는 것이 방법일 것 같아요. private메소드를 사용하는 public 메소드는 최소한 하나는 있을 것이니 그것을 이용해서 테스트를 하는 것입니다.
하지만 그것으로 부족하다고 느끼시다면?
방법이 있습니다. 리플렉션을 사용하는 방법이죠.
코드를 보겠습니다.

import java.util.List;

public class A {
	private String name;
	public A (String name) { this.name = name; }
	
	private String dosthPrivate(int a, String b, List list) {
	  return "name: " + this.name + 
            ", a: " + a + ", b: " + b + ", List: " + list;
	}
}

현재 위에 있는 dosthPrivate은 실행할 방법이 없습니다.
JUnit으로 테스트를 하려면 어떻게 해야 할까요??
이제 테스트 코드를 보도록 합니다.

public class ATest {
  A a = new A("TEST");
  @Test
  public void test() throws Exception{
  Method method = 
    A.class.getDeclaredMethod("dosthPrivate", int.class, 
                              String.class, List.class);
    method.setAccessible(true);
    String result = String.class.cast(method.invoke
      (a, 1, "BBB", new ArrayList(Arrays.asList(1,2,3,5,8,13,21))));
    assertThat(result, CoreMatchers.is
      ("name: TEST, a: 1, b: BBB, List: [1, 2, 3, 5, 8, 13, 21]"));
  }
}

아주 간단하죠?
네
아주 간단합니다.

[clojure] Udemy 클로저 강의를 듣고

이 언어는 나에게 많은 시련을 준 언어이다.
물론 자바를 처음 배울 때 처럼 아침부터 저녁까지 공부한 것은 아니지만 참으로 나의 머리의 한계를 시험하는 언어였다.
클로저를 처음 배우려고 했던 이유는 폴 그레니엄 때문이었다. 내가 일단 이 사람을 어떻게 접하게 되었는지를 적어야 겠다.
나는 문예창작학과로써 서울에 올라온 이후 항상 서점에 갔다.
삼성동에서 학원을 다닐 때에는 코엑스 지하 1층에 있는 영풍문고를 갔다. 매일매일 저녁을 먹지 않고 혹은 저녁 9시에 학원이 끝났을 때, 나는 영풍문고에서 나의 무지 혹은 나의 미래에 대한 불안감, 거기서 오는 허기짐을 문고에서 채웠다.
아무것도 모르면서 계속 읽었다.
그 중에 [해커와화가]라는 책이 있었다.
제1장을 읽고, 다음장을 읽으려 할 때, 문고가 닫는다는 알림과 음악이 흘러나오기 시작했다. 나는 그 책을 사서 집으로 가져가 전부 읽었다.
그의 주장에는 확신이 있었고, 또 그 확신이 허세가 아니라는 것을 이 책 하나만으로 짐작할 수 있었다.
나는 그의 홈페이지를 들어가보았다. 그는 리스프형 언어 Arc를 소개하고 있었다.
리스프형이 무엇인지 궁금하여 lisp에 대해 찾아보기 시작했다.
그리고 scheme를 한 번 사용해보았다.
common lisp도 한 번 만져보았다. (정말... 만져만 보았다)
내가 클로저를 공부한 이유는 다름이 아니라. 내가 보기에 한국 책이나, 외국 원서나 clojure에 대한 책이 더 많아 보였기 때문이다.
꽤나 많은 책을 보았지만 아직도 clojure에 대해 익숙하지 않다. 내가 일로써 사용하지 않아서 그런 것 같기도 하다.
아직 나는 클로저에서 async에 대해서는 전혀 모른다.(구경만했을뿐...)
병렬프로그래밍이라하면 atom, refer 정도 사용할 뿐일 듯 싶다.
한국 책이던, 외국 책이던 정보가 부족한 것은 참으로 안타까운 듯 싶다. 그래서 사람들이 클로저를 사용하는 듯 싶다.
그나마... 자바와 연결이 되어 있어서, nslookup이라던가. 여러 네트워크 프로그래밍에 자바의 메소드를 사용하는 경우가 있는 것같다.
나는 이제 클로저에서 벽에 부딪힌 느낌이다. 뭐 아는 것도 없는데 벽이라니... 그래서 기초라도 제대로 다지자고 Udemy에 있는 강의를 구매했다.

나름 괜찮았던 것 같다. 하지만 더 많은 정보가 있으면 좋을 텐데... 일단 리스프형 언어에 대해서도 아직 이해가 부족한 상태에서 미지의 세계로 나아가려니 참으로 답답하지 짝이없다.


그래도 고민으로 끝나지않고 계속 나아갈 것이다. 이 길이 망하는 길이라 할지라도
배움은 새로운 곳을 나아가기 위한 것이 아니라
같은 곳에서 새로운 것을 바라보기 위한 것이라 믿으니까.
어느날 다시 되돌아와도...
난 달라져 있으리라

[java][byte] 0xff 누구냐 넌!

제목에만 적어놓고 언젠가 적어야지 적어야지 했던 글을 이제야 적는다.
자바를 사용할 때 가끔 0xff를 사용해야 할 때가 있다. 없다고? 음... 그렇다면 당신 대신 누군가 해준 것이니 모른다는 것에 감사하시길...

혹시 unsigned int와 singed int를 아는지? 아아 아주 단순한 문제이니 대답을 해주겠다.
unsigned int : 사인(부호)이 안되어있는 int값
signed int : 사인(부호)이 있는 int값
좀 더 자세히 말하면 부호가 있는 int값과 없는 값 둘로 나뉜다. 그렇다면 자바에서 사용하는 int는 무슨 값일까?

???
모를 수도 있고 알 수도 있다. 비전공자인 나로썬 뭔말인가 싶었다. 하지만 다 정보처리기사에 나오니 걱정하지말라. 누가 물으면 이렇게 말해라.
'그거 정보처리기사에서 다 공부했죠.'
자바에는 int건 byte건 unsigned란 없다. signed만을 (이렇게 해서 설계를 잘했다고 하는 강의도 본 적이 있는데 난 허접이라 잘 모르겠다.) 사용한다. 맞다. 부호가 있는 숫자를 사용한단 말이다. 부호가 없는 int는 사용하지 않는다. 뭐야? 그럼 우리가 알 필요가 없잖아??

유감스럽게도 아니다

왜냐하면 세상은 unsigned int로 이루어진 것들이 꽤나 있기 때문이다. 일단 그렇게 사용하던 코드들이 있고 가장 중요한 것은 이 값은 바이트 타입으로 받았을 때이다.
한 번 바이트 타입으로 127 이상으로 값을 넣어보자.

public static void main(String[] args) {
  byte[] a = new byte[] {127, 0, 0, 1};
  byte[] b = new byte[] {128, 0, 0, 1};
}

a는 되고 b는 안된다. 삶과 죽음은 종이한장 차이라더니, 1의 차이가 프로그램을 아예 실행할 수 없게 만들고 있다.
왜그럴까?
바로 자바는 항상 부호가 있는 숫자이기 때문이다.
바이트는 8비트다. 8비트이면 256개를 표현할 수 있는데, 왜 128이 안된다는 것일까?
잘 생각하자 우리는 부호가 있는 값을 이용한다.
256을 반으로 뚝 잘라라


128 | 128 오!! 되잖아!!! 라고 말 할 줄 알았다. 여기서 한 놈은 1을 빼야한다.
왜? 0을 누군가는 표기해야 하니까.
지금은 그래서 0000 0000 이놈이 0을 표현하게 되는데 이 0이 누구꺼냐는 거다.
결론을 말하면 자바 바이트 타입은 -128 ~ 127 이렇게 표현할 수 있다. 그러니 128은 표현할 수 없는 존재가 되는 것이다.

public static void main(String[] args) {
  byte[] b = new byte[] {(byte)128 , 0, 0, 1};
  System.out.println( (byte) 128 );
}

이거 마이너스가 뜬다. 왜냐하면, 128은 int다. 그걸 바이트로 내가 지금 강제로 형변환을 했다. 128은 2의 7승이다. 그 말은 1000 0000 이다.

일단 맨 앞에 1이 있으면 부호가 음수이다.

public static void main(String[] args) {
  byte[] b = new byte[] {(byte)128 , 0, 0, 1};
  System.out.println( (byte) 128 );
  System.out.println((byte) 128 & 0xff);
}

바로 우리가 알아봐야 할 0xff 누구냐넌! 이놈은 이렇게 생겼다. 쟤는 16진수라는 거다.
잠깐 나가지말고 들어보라. 정말 별거 아니니까!!!
0x는 16진수 앞에 붙는 기호라고 하고.
f는 15을 뜻한다.
f가 두개다. 이것 이런 말이다. 15*16^1 + 15*16^0 이거 한번 계산기를 돌려보자.

System.out.println(15*16 + 15*1);

이건 255가 나온다. 255? 어디서 많이 들어 본 것 같지 않은지? 맞다. 우리 네트워크 설정할 때 많이 사용한다. 바로 그 때!!!! 사용되고 있을 지도 모르는 놈이 0xff이다.

여튼 이놈을 이용해서 &(and)연산을 하면 부호가 없는 없는 그냥 숫자가 나올 것이다. (왜?)
잘 생각해보자. 255는 일단 부호가 있는 숫자에서 255라는 숫자가 나온것이다.
그러면 잘 생각해보자.
기호가 없는 255는 1111 1111 이다. 기호가 있는 255는? 무조건 앞이 0이다. 게다가 255는 int라니까? 부호가 있는 32비트다. 32비트!!!
0000 0000 0000 0000 0000 0000 1111 1111
0xff의 정체이다. 자 그런데 어떻게 저 (byte) 128 & 0xff 가 어떻게 되는거지?
자!! 이제 얼마 안남았다.

1111 1111 1111 1111 1111 1111 1111 1111 1000 0000
0000 0000 0000 0000 0000 0000 0000 0000 1111 1111 (and) 연산 실시
----------------------------------
0000 0000 0000 0000 0000 0000 0000 0000 1000 0000

이러면 이제, 부호가 마이너스가 아니라! 부호가 플러스인 128라는 숫자가 된다.
휴... 금방 끝날 줄 알았는데... 하... 힘들었다.


이 글이 정말 서툴지만 누군가에게는 많은 정보가 되길 바랍니다. 그리고 잘못 적은 내용을 지적해주신 분께 감사의 뜻을 전합니다. ^^