HAMA 블로그

https://thrift.apache.org/

아파치 쓰리프트 프레임워크는 다양한 언어로 서비스되며 , 효율적인 코드생성엔진을 갖고 소프트웨어 스택을 묶으며 다음과 같은 다양한 언어들을 지원한다  C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml and Delphi and 기타등등.

시작하기 

• Apache Thrift 다운로드 

  To get started, download a copy of Thrift.

• Apache Thrift compiler 빌드/인스톨

  You will then need to build the Apache Thrift compiler and install it. See the installing Thrift guide for any help with this step.

•  .thrift 파일 작성 

  After the Thrift compiler is installed you will need to create a thrift file. This file is an interface definitionmade up of thrift types and Services. The services you define in this file are implemented by the server and are called by any clients. The Thrift compiler is used to generate your Thrift File into source code which is used by the different client libraries and the server you write. To generate the source from a thrift file run

              thrift --gen <language> <Thrift filename>
            

  The sample tutorial.thrift file used for all the client and server tutorials can be found here.

To learn more about Apache Thrift Read the Whitepaper

예제 

아파치 쓰리프트는 데이타타입 및 서비스 인터페이스를  간단한 정의파일안에 제공한다.파일을 통해 입력하면 

컴파일러는 교차언어간에 자연스럽게 통신할수있는  RPC 클라이언트/서버로  쉽게 사용되는 코드를 생성해준다. 

당신이 만든 객체를 이동하거나 직렬화 하기위해 행사코드를 쓰는 수고를 덜어주며, 원격메소드를 호출하여 당신이 

비지니스로직에만 집중할수있게한다.

다음 예제는 웹프런트엔드에 대해  유저객체를 저장하기위한 간단한 서비스를 보여준다.

쓰리프트 정의 파일 

service Calculator extends shared.SharedService {

  /**
   * 메소드 정의는 C 코드같다. 리턴타입 과 매개변수 , 예외를 가지고있다.
   * Note that argument
   * lists and exception lists are specified using the exact same syntax as
   * field lists in struct or exception definitions.
   */

   void ping(),

   i32 add(1:i32 num1, 2:i32 num2),

   i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),

   /**
    * 단방향 콜로써 요청한후에 리턴받는걸 무시한다.
    */
   oneway void zip()

파이썬 클라이언트 

 # Make socket
  transport = TSocket.TSocket('localhost', 9090)

  # Buffering is critical. Raw sockets are very slow
  transport = TTransport.TBufferedTransport(transport)

  # Wrap in a protocol
  protocol = TBinaryProtocol.TBinaryProtocol(transport)

  # Create a client to use the protocol encoder
  client = Calculator.Client(protocol)

  # Connect!
  transport.open()

  client.ping()
  print 'ping()'

  sum = client.add(1,1)
  print '1+1=%d' % (sum)

자바 서버 

Initialize the Server:

    try {
      TServerTransport serverTransport = new TServerSocket(9090);
      TServer server = new TSimpleServer(new Args(serverTransport).processor(processor));

      // Use this for a multithreaded server
      // TServer server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport).processor(processor));

      System.out.println("Starting the simple server...");
      server.serve();
    } catch (Exception e) {
      e.printStackTrace();
    }

This snippet was generated by Apache Thrift's source tree docs: tutorial/java/src/JavaServer.java

The CalculatorHandler:

public class CalculatorHandler implements Calculator.Iface {

  private HashMap<Integer,SharedStruct> log;

  public CalculatorHandler() {
    log = new HashMap<Integer, SharedStruct>();
  }

  public void ping() {
    System.out.println("ping()");
  }

  public int add(int n1, int n2) {
    System.out.println("add(" + n1 + "," + n2 + ")");
    return n1 + n2;
  }

  public int calculate(int logid, Work work) throws InvalidOperation {
    System.out.println("calculate(" + logid + ", {" + work.op + "," + work.num1 + "," + work.num2 + "})");
    int val = 0;
    switch (work.op) {
    case ADD:
      val = work.num1 + work.num2;
      break;
    case SUBTRACT:
      val = work.num1 - work.num2;
      break;
    case MULTIPLY:
      val = work.num1 * work.num2;
      break;
    case DIVIDE:
      if (work.num2 == 0) {
        InvalidOperation io = new InvalidOperation();
        io.what = work.op.getValue();
        io.why = "Cannot divide by 0";
        throw io;
      }
      val = work.num1 / work.num2;
      break;
    default:
      InvalidOperation io = new InvalidOperation();
      io.what = work.op.getValue();
      io.why = "Unknown operation";
      throw io;
    }

    SharedStruct entry = new SharedStruct();
    entry.key = logid;
    entry.value = Integer.toString(val);
    log.put(logid, entry);

    return val;
  }

  public SharedStruct getStruct(int key) {
    System.out.println("getStruct(" + key + ")");
    return log.get(key);
  }

  public void zip() {
    System.out.println("zip()");
  }

}

This snippet was generated by Apache Thrift's source tree docs: tutorial/java/src/CalculatorHandler.java\

큐 시스템을 이용한 NPUSH-GW 개선

네이버 NAVER LABS 배상용, 임영완, 조항수, 김민곤, 김종현

Apple의 APNS(Apple Push Notification Service)나 Google의 GCM(Google Cloud Messaging) 같은 푸시 메시지 플랫폼은 모바일 서비스를 개발하면서 대부분 한 번씩은 사용해 봤을 만한 핵심 기능입니다. 최근에는 운영체제와 플랫폼 사업자별로 푸시 메시지 플랫폼이 끊임없이 개발되고 있습니다. 다양한 플랫폼을 이용해 메시지를 전송하려면 서비스 개발자가 모든 플랫폼의 명세를 이해하고 구현해야 합니다. 이런 불편 사항을 해결하려 네이버는 다양한 푸시 메시지 플랫폼을 하나의 인터페이스로 사용할 수 있도록 푸시 게이트웨이 시스템(이하 NPUSH-GW)을 개발해서 운영하고 있습니다.

이 글에서는 고성능 오픈소스 큐 시스템인 Luxun을 이용해 자체 개발한 NQueue 시스템으로 NPUSH-GW의 안정성을 향상시킨 방법을 공유하겠습니다.

NPUSH-GW란?

NPUSH-GW는 네이버의 모바일 푸시 메시지 플랫폼인 NPUSH의 컴포넌트 중 하나로, 서비스에서 요청한 푸시 메시지를 다양한 외부 푸시 플랫폼으로 전송하는 시스템이다.

그림 1 큐 시스템 도입 전 NPUSH-GW 구성도

2011년 11월에 네이버톡과 연동한 것을 시작으로 LINE, 네이버 앱 등을 포함해 네이버 계열사에서 개발하는 모바일 앱 대부분이 NPUSH-GW를 이용하여 푸시 메시지를 전송한다. 3년 동안 운영하면서 Apple과 Google은 물론 다양한 외부 오픈 푸시 플랫폼에 메시지를 전송하도록 개발했다.

NPUSH-GW 초기 개발 요구 사항 및 구조

초기의 NPUSH-GW는 네이버 서비스에서 요청한 푸시 메시지를 외부 푸시 플랫폼으로 전달할 때까지 소요되는 체류 시간을 최소화하도록 설계하고 구현했다. 되도록 시스템을 단순하게 하고 서버 구성을 간소하게 하도록 외부의 별도 큐 시스템을 사용하지 않고 Java에서 제공하는 LinkedBlockingQueue와 ThreadPoolExecutor의 내부 Worker Queue를 이용해 비동기 메시지를 처리하도록 구현했다. NPUSH-GW 내부의 모든 발송 모듈은 서비스별, 푸시 플랫폼별로 분리되어 있고, 각 모듈이 하나의 서비스 또는 푸시 플랫폼의 발송을 전담하는 구조다.

그림 2 NPUSH-GW 기본 아키텍처

나머지는 

http://helloworld.naver.com/helloworld/textyle/1022966   가서 읽어보길 

Luxun

https://github.com/bulldog2011/luxun

1. serialize(직렬화) 란?  

 -> 메모리안의 어떠한 (추상적) 데이터구조를 연속된  bit  로  외부에 보내기위해 정렬하는것.

 2.  왜 직렬화를 해야하나? 

 -> 물리층 자체가  bit 니깐  /  가장 베이스적인 약속으로서 활용

 3. 위에서 외부란 ?

 -> 파일 / DB / 소켓을 통해 네트워크 외부등

4. 직렬화의 종류는 ?

 -> 데이터를 어떤식으로 구조화하냐에 따라서 달라짐. 예) 자바직렬화, 구글 프로토콜버퍼

 -> 프로토콜버퍼등은 데이터를 짧고 효율적이게 하는게 주목적.반면 자바직렬화는 낭비가 엄청남

5. 직렬화를 활용하는곳? 

-> 소켓통신, 자바객체를 파일에 저장 ( 파워포인트등의 내용을  파일(ppt) 로 저장할때도 객체직렬화)

6. 직렬화 예제  

다음은 int 형을 바이트배열로 직렬화하는 코드에요

C++ ) 

       inline static string intDATA(int  nData)
	{
		string value;
		value.clear();
		value.append("i");
		value.append((const char *)&nData, sizeof(nData));

		return value;
	}

        ...
        byte[] b = value.c_str();

nData 라는 int 형을 직렬화하는데, 일단 제일 앞에 1바이트로 "i" 문자열을 넣습니다.

그리고 int 형 데이터를 넣습니다. 나중에 저 string 에서  바이트배열로 뽑아내서 리모트로 보내면 

상대방은  1바이트를 읽어서  "i"  면  다음에 올 배열을  int 형으로 만들수있게 됩니다.  :-)

"d" 라면 다음에 올 바이트배열로 double 형을 만들어야할테지요.

Java )

ObjectOutputStream  out = new ObjectOutputStream(...);
out.writeInt(10);

 out 이라는 객체에 10이라는 int 형을 배열로 담고 있습니다.

 마찬가지로 double 형이라면 writeDouble 으로~

  writeInt 메소드의 내부에는 이렇게 되어있네요.

  public final synchronized void writeInt (int value) throws IOException
  {
      write ((byte) (0xff & (value >> 24)));
      write ((byte) (0xff & (value >> 16)));
      write ((byte) (0xff & (value >>  8)));
      write ((byte) (0xff & value));
  }

7. 직렬화 관련된 GOF 패턴 

현상태에 대한 스냅샷적인 저장  (메멘토패턴)

현 상태를 원격지로의 송신         (프록시패턴  // 프록시패턴하고 직접적인 관련은 없음)

4. 스프링 설정  :   어노테이션  vs   XML

MyBean.java 가  XML/어노테이션/자바 컨피그레이션을 통해   어떻게 객체로 만들어지는지 살펴보도록하자.

MyBean myBean = new MyBean(); 
myBean.setName("xmlBean");

AnotherBean anotherBean = new AnotherBean();
anotherBean.setMyBean(mybean);

AnotherBean [myBean=MyBean [name=xmlBean]]

AnotherBean [myBean=MyBean [name=AnnotationBean]]

AnotherBean [myBean=MyBean [name=JavaConfigBean]]

AnnotationConfigApplicationContext 분석 

위의 코드는 @Configuration 으로 <beans> 를 대신하고 
@bean 으로 자바코드에 의한 빈등록을 하게 해주는 예이다.

 AnnotationConfigApplicationContext  을 이용하여 설정 클래스를 입력받은후에 
 getBean 메소드를 통하여 내부의 특정 객체를 가져오는 소스이다.

AnnotationConfigApplicationContext  인사이드를 보도록 하자.

(분석중..) 

Reference 

3. 자바 리플렉션으로 어노테이션 다루기 

Class aClass = TheClass.class;
Annotation[] annotations = aClass.getAnnotations();

for(Annotation annotation : annotations){
    if(annotation instanceof MyAnnotation){
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("name: " + myAnnotation.name());
        System.out.println("value: " + myAnnotation.value());
    }
}

Class aClass = TheClass.class;
Annotation annotation = aClass.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation){
    MyAnnotation myAnnotation = (MyAnnotation) annotation;
    System.out.println("name: " + myAnnotation.name());
    System.out.println("value: " + myAnnotation.value());
}

public class TheClass {
  @MyAnnotation(name="someName",  value = "Hello World")
  public void doSomething(){}
}

Method method = ... //obtain method object
Annotation[] annotations = method.getDeclaredAnnotations();

for(Annotation annotation : annotations){
    if(annotation instanceof MyAnnotation){
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("name: " + myAnnotation.name());
        System.out.println("value: " + myAnnotation.value());
    }
}

Method method = ... // obtain method object
Annotation annotation = method.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation){
    MyAnnotation myAnnotation = (MyAnnotation) annotation;
    System.out.println("name: " + myAnnotation.name());
    System.out.println("value: " + myAnnotation.value());
}

public class TheClass {
  public static void doSomethingElse(
        @MyAnnotation(name="aName", value="aValue") String parameter){
  }
}

Method method = ... //obtain method object
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Class[] parameterTypes = method.getParameterTypes();

int i=0;
for(Annotation[] annotations : parameterAnnotations){
  Class parameterType = parameterTypes[i++];

  for(Annotation annotation : annotations){
    if(annotation instanceof MyAnnotation){
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("param: " + parameterType.getName());
        System.out.println("name : " + myAnnotation.name());
        System.out.println("value: " + myAnnotation.value());
    }
  }
}

public class TheClass {

  @MyAnnotation(name="someName",  value = "Hello World")
  public String myField = null;
}

Field field = ... //obtain field object
Annotation[] annotations = field.getDeclaredAnnotations();

for(Annotation annotation : annotations){
    if(annotation instanceof MyAnnotation){
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("name: " + myAnnotation.name());
        System.out.println("value: " + myAnnotation.value());
    }
}

Field field = ... // obtain method object
Annotation annotation = field.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation){
    MyAnnotation myAnnotation = (MyAnnotation) annotation;
    System.out.println("name: " + myAnnotation.name());
    System.out.println("value: " + myAnnotation.value());
}

Annotation & Reflection 예제 

* 메타 annotation type

1.@documented : 이 어노테이션을 자바독이나 유사한 도구로 문서화되어져야하는데 사용

하는 엘리먼트를 지칭

2.@Target : 어노테이션 타입이 수용할 수 있는 많은 프로그램 엘리먼트를 지칭

3.@Inherited : 자동으로 상속받는 어노테이션 타입을 지칭

4.@Retention : 어노테이션된 타입이 얼마나 지속되는가를 지칭


[메소드에 지정할 어노테이션 정보들을 정의해놓은 인터페이스] 

[어노테이션을 적용한 메소드들이 정의되어 있는 클래스 예] 

[Reflection을 사용하여 어노테이션 정보를 분석하는 클래스 :

테스트 클래스로 클래스의 모든 메소드를 로드하고, 그 메소드 중에 어노테이션 인터페이스

에 정의된 어노테이션을 마킹한 각 메소드에 한해서만 이하 작업을 수행.]

1.해당 메소드의 모든 어노테이션을 출력.

2.해당 메소드의 어노테이션 정보를 새 어노테이션 인터페이스 변수에 담고

그 변수에서 어노테이션 값이 사용자가 지정한 값을 가지고 있다면 해당메소드 출력.

Reference 

2. 자바 어노테이션 이야기

2-1. 왜 어노테이션인가?

자바 스펙에서 어노테이션은 다음에서 나타내 지고 있다 :

• JSR 175 A metadata facility for the Java programming Language
• JSR 250 Common Annotations for the Java Platform

2-2. 소개 

2-3. Consumers (소비자) 

어노테이션의 목적이 정확히 먼지, 어떻게 사용되는지 이해하는건 쉽지 않다, 그것들은 어떠한 기능적 로직을 가지고 있지 않으며 , 코드에 영향을 미치지 않는다.  어노테이션이 뭘 할까? 

이것을 위한 설명으로 난 어노테이션 컨슈머스라고 말하는게 있는데 ,  이것들은 시스템이나 서드파티 어플리케이션 (스프링같은) 으로서  어노테이션이 적용된  코드를 어노테이션 정보로부터 의존적인 여러가지 행동을 취한다.

예를들어 자바 빌트인 어노테이션경우에는 소비자는 자바가상머신(JVM) 이며 어노테이션이 적용된 코드를 실행한다.  사용자 정의 어노테이션의 경우의  예로는  JUnit, Spring 등이 있다.

그리고 소비자는 코드에서부터 어노테이션을 분석하기위해  자바 리플렉션을 이용한다. 

2-4. 유즈 케이스 

어노테이션은 다양한 목적으로 사용되는데 대표적으로는 

•  컴파일러를 위한 정보제공 :  Java 8 @FunctionalInterface , @supresswarnings
•  자동 문서 작성 :  generate reports automatically like Jenkins, Jira or Teamcity.
•  코드 자동 생성 :  A good example of this is the JAXB library.
•  런타임 프로세싱 : testing (Junit), dependency injection (Spring), logging (Log4J) ,data access (Hibernate) etc.

2-5. Java 8 에서 어노테이션 

Java 8 은 여러가지 훌륭한 기능을 가지고 왔는데 어노테이션 프레임워크도 발전되었다. 

다음 예예를 통해 확인해 보도록 하자.  

@Repeatable:  

Afterwards, we create the annotation itself and we mark it with the Meta annotation @Repeatable:

Finally we can see how to use it (repeatedly) in a given class:

If we would try to do the same with a non repeatable annotation:

We would get an error from the compiler like:

• Since Java 8 is also possible to use annotations within types. That is anywhere you can use a type, including the new operator, castings, implements and throws clauses. Type Annotations allow improved analysis of Java code and can ensure even stronger type checking. The following examples clarify this point:

All this was not possible until Java 8.

• @FunctionalInterface: this annotation indicates that the element annotated is going to be a functional interface. A functional interface is an interface that has just one abstract method (not a default one). The compiler will handle the annotated element as a functional interface and will produce an error if the element does not comply with the needed requirements. Here is an example of functional interface annotation:

This annotation can be applied to classes, interfaces, enums and annotations and it is retained by the JVM and available in Run time. Here is its declaration:

2-6. Retrieving   어노테이션 

자바 리플렉션 API 는 여러가지 메소드를 포함한다. 그 메소드들은 런타임에 클래스,메소드등으로부터  

어노테이션 정보를 얻을수있게 한다. 그것을 통해서 스프링같은 서드파티 프레임워크는 클래스들을 

조작할수있게 된다.

저런 모든 메소드들을 포함한 인터페이스는 AnnotatedElement 이며 대표적으로 다음과 같다.

• getAnnotations():  주어진 엘리먼트가 가지고있는 모든 어노테이션을 배열로 가져온다.
• isAnnotationPresent(annotation):  엘리먼트가 어노테이션을 가지고있는지 체크한다.
• getAnnotation(class): 파라미터로 넘겨진 엘리먼트에 대한 단일 어노테이션을 가져온다.

This class is implementing by java.lang.Class, java.lang.reflect.Method and java.lang.reflect.Field among others, so can be used basically with any kind of Java element.

Now we are going to see an example of how to read the annotations present in a class or method using the methods listed above:

We write a program that tries to read all the annotations present in a class and its methods (we use for this example the classes defined before):

The output of this program would be:

In the program above we can see the usage of the method getAnnotations() in order to retrieve all annotations for a given object (a method or a class). We also showed how to check if an specific annotation is present and to retrieve it in positive case using the methods isAnnotationPresent() and getAnnotation().

Reference 

선선한 토요일 아침에 뭐 할까 하다가 , 자바 어노테이션에 대해서 간략하게 정리해 놓아야겠다고 생각하고 

참고 싸이트들을 검색해보니, 오래된 기술이다 보니 역시나 좋은 글들이 많아서 .그것들을 번역/정리해 

보다보니 생각한것보다 엄청 길어져버렸다. ㅜㅜ

순서

1. 자바 어노테이션 기본 문법

Annotation 이름 

기본적으로 요렇게 생김

@Entity

@ <-- 요놈은 기본적으로 컴파일러에게 이게 어노테이션이다라고 알린다. 

@ 마크 다음에 오는 문자는  해당 어노테이션의 이름이고 여기서는  "Entity" !!!

Annotation 요소 (Element)

@Entity(tableName = "vehicles")

위에서는 tableName 이라는 이름의 요소를 하나 가지고있다는뜻이야. 값은 "vehicles" 이군. 

물론 아래와 같이 여러개의 요소를 가질수도있어.

@Entity(tableName = "vehicles", primaryKey = "id")

하나만 요소로 가질 경우 다음과 같이 짧게 줄여 쓸수도있지.

@InsertNew("yes")

Annotation 선언위치(Placement)

어노테이션은 클래스, 인터페이스, 메소드, 메소드 파라미터, 필드, 지역변수 위에 위치할수있어.

아래는 클래스 위에 선언되어있는 것이고

@Entity
public class Vehicle {
}

위에 말했다시피 @로 시작하고 이름은 Entity 야.  Entity 어노테이션은 그냥 내가 만든 어노테이션이고 현재 별 의미 없어. :-) 

아래 예는  모든 선언 위치에 어노테이션(주석)을 넣어봤어 함 봐바~  

(뭐 큰 역할을 하는건 아니지만 우리가 항상 사용하는 //  요런  주석으로써의 의미는 있다고 볼수있지  ) 

@Entity
public class Vehicle {

    @Persistent
    protected String vehicleName = null;


    @Getter
    public String getVehicleName() {
        return this.vehicleName;
    }

    public void setVehicleName(@Optional vehicleName) {
        this.vehicleName = vehicleName;
    }

    public List addVehicleNameToList(List names) {

        @Optional
        List localNames = names;

        if(localNames == null) {
            localNames = new ArrayList();
        }
        localNames.add(getVehicleName());

        return localNames;
    }

}

자바에서 기본적으로 제공되는 어노테이션 

• @Deprecated
• @Override
• @SuppressWarnings

@Deprecated

이 어노테이션은 , 해당 클래스/메소드 등은 더이상 지원하지 않으니 or  만들고 나니깐 별로 안좋은 

부분이 많거나, 더 좋은 해결법이 생겼으니 사용하지 마시라는 의미야. 그럼에도 불구하고 네가 그걸 

쓴다면 자바 컴파일러는 귀신같이 알아내서 경고 메세지를 날려줄것이지. 

(@Deprecated 주석때문에 컴파일러가 알아차릴수있는거라는 말) 

@Deprecated
public class MyComponent {

}

@Override

이 어노테이션은 슈퍼클래스에 대해 오버라이드 되었다는걸 알려줘. 따라서 만약 메서드가 

슈퍼클래스와 매칭되지 않았으면 에러를 날려주지. (컴파일러 만드는 사람들이 에러를 감지하기 

편하겠지?)  아래 예를 봅시다~

public class MySuperClass {

    public void doTheThing() {
        System.out.println("Do the thing");
    }
}


public class MySubClass extends MySuperClass{

    @Override
    public void doTheThing() {
        System.out.println("Do it differently");
    }
}

물론 이 어노테이션을 사용하는게 강제는 아니지만 , 사용하는게 좋을꺼야. 만약 슈퍼클래스가 

변경되었는데 그걸 모르고 자식클래스에서 오버라이딩한 클래스를 그대로 냅두면, 의도가 

깨져버리고 우리는 그 사실도 모른채 퇴근을 하겠지~  만약 @Override 를 선언해뒀다면 

바로 에러로 알려주고 네가 수정한후에 편한마음으로 컴백홈하게 도와줄꺼야

@SuppressWarnings 

이 어노테이션은 해당 메소드에 대해서 compiler suppress warnings (컴파일러 경고 억제?)을 

만들어. 예를들어 어떤 코드가 경고메세지를 수천개씩 쏟아내는데, 그게 보기싫을때 입막음 

시켜버리는거야 조용히~

@SuppressWarnings
public void methodWithWarning() {


}

개인용 어노테이션 만들기 

개인적으로 사용할 어노테이션을 만드는것이  가능하며 어노테이션은 클래스나 인터페이스처럼 

자신의 파일에 정의된다. 다음 예를 보자.

@interface MyAnnotation {

    String       value();
    String       name();
    int            age();
    String[]    newNames();

}

위의 어노테이션은 4개의 요소를 가지고있고 이름은 MyAnnotation  이다.

@interface 키워드를 주목하라  이것은 자바컴파일러에게 이놈이 어노테이션 정의라는걸 알려준다.

요소들은 인터페이스에서의 메서드 정의와 유사하다.  자바 기본요소들을 모두 사용할수있고 , 배열도 사용가능하다. (복잡객체사용은 불가능) 

 위에서 정의한 어노테이션을 사용해 보자.

@MyAnnotation(
    value="123",
    name="Jakob",
    age=37,
    newNames={"Jenkov", "Peterson"}
)
public class MyClass {


}

위에 보다시피 각각의 요소에 나만의 값을 지정했다. 후에 프레임워크에서  이 값을 파싱해서 필요한 정보를 알아낼것이다. 물론 님 스스로  리플렉션을 통해 저 어노테이션을 분석해서 사용할수도 있을테고~

* 저런 주석을 달아놓으면 나중에 클래스별로 그루핑을 할때 사용하거나 어떤 클래스/함수는 어떤것(URL 따위들) 과 매핑 같은것에 사용할수 있을거라는 생각을 잠시 해보자. 함수이름이 달라져도 어노테이션만 같으면 자동 매핑해줄수있지 않겠는가 

요소(Element)디폴트 값

요소에 기본값을 설정할수 있다. 아래 예를 보자.

@interface MyAnnotation {

    String   value() default "";

    String   name();
    int      age();
    String[] newNames();

}

디폴트값을 설정해두면 아래와 같이 사용할때 값을 넣지 않아도 된다. (아예 보이지도 않음) 

@MyAnnotation(
    name="Jakob",
    age=37,
    newNames={"Jenkov", "Peterson"}
)
public class MyClass {


}

@Retention    -  네이버 사전 :  (어떤 것을 잃지 않는) 보유[유지])

얼마나 오랫동안 어노테이션 정보가 유지되는지 설정할수있다. 

아래 예를 보자. 

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)

@interface MyAnnotation {

    String   value() default "";

}

@Target 

자신이 만든 어노테이션이 사용되게될 자바 요소를 지정할수있다. 아래 예를 보자.

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
public @interface MyAnnotation {

    String   value();
}

위처럼 만들면 메소드에서만 사용가능한 어노테이션을 정의할수있다.아래와 같이 타겟을 정할수있다.

• ElementType.ANNOTATION_TYPE
• ElementType.CONSTRUCTOR
• ElementType.FIELD
• ElementType.LOCAL_VARIABLE
• ElementType.METHOD
• ElementType.PACKAGE
• ElementType.PARAMETER
• ElementType.TYPE

@Inherited

The @Inherited 어노테이션은 이 어노테이션을 사용한 슈퍼클래스를 상속한 서브클래스에서도
해당 어노테이션을 갖도록 한다.

java.lang.annotation.Inherited

@Inherited
public @interface MyAnnotation {

}

@MyAnnotation
public class MySuperClass { ... }

public class MySubClass extends MySuperClass { ... }

MySubClass 클래스는 @MyAnnotation 을 상속한다. 

@Documented

@Documented 어노테이션이 지정된 대상의 JavaDoc 에 이 어노테이션의 존재를 표기하도록 지정.

java.lang.annotation.Documented

@Documented
public @interface MyAnnotation {

}

@MyAnnotation
public class MySuperClass { ... }

Reference 

서버분석 

아래과 같은 라이브러리가 필요합니다.

특이한건 스프링 boot 를 사용했다는건데, 이번 예제를 통해서 저도 처음 boot 를 접해보았는데 설정부분 및 REST 서비스를  굉장히 단순화 시켜 놓았더군요.

 XML  설정파일은 필요없고, 어노테이션을 통해서 설정을 해줍니다. 

(자바 코드를 통한 설정은 스프링 3.1에 거의 완성되었습니다.) 

중요한 2개의 자바 파일을 분석해 보겠습니다.(Application.java 에서 스프링을 실행시켜줍니다.)

1. WebSecurityConfiguration 

첫번째 소스를 분석하기전에 기본 지식을 쌓도록 합시다. 

(http://spring.io/blog/2013/07/03/spring-security-java-config-preview-web-security/ ) 

WebSecurityConfigurerAdapter 

@EnableWebSecurity 어노테이션과  WebSecurityConfigurerAdapter 은 웹기반 보안을 위해 함께 작동 하며  WebSecurityConfigurerAdapter 을 상속받아서 몇줄만 코딩하면 다음과 같은것을 할수있게된다.

• 우리의 어플리케이션에 어떤 URL 로 들어오던간에 사용자에게 인증을 요구할수있음.
• 사용자이름과 비밀번호 및 롤기반으로 사용자를 생성할수있다.
• HTTP Basic 과 폼기반 인증을 가능하게함.
• 스프링 시큐리티는 자동적으로 로그인페이지,인증실패 url 등을 제공한다.

@EnableWebSecurity
@Configuration
public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
  @Autowired
  public void configureGlobal(AuthenticationManagerBuilder auth) {
    auth
      .inMemoryAuthentication()
        .withUser("user")  // #1
          .password("password")
          .roles("USER")
          .and()
        .withUser("admin") // #2
          .password("password")
          .roles("ADMIN","USER");
  }

  @Override
  public void configure(WebSecurity web) throws Exception {
    web
      .ignoring()
         .antMatchers("/resources/**"); // #3
  }

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http
      .authorizeUrls()
        .antMatchers("/signup","/about").permitAll() // #4
        .antMatchers("/admin/**").hasRole("ADMIN") // #6
        .anyRequest().authenticated() // 7
        .and()
    .formLogin()  // #8
        .loginUrl("/login") // #9
        .permitAll(); // #5
  }
}

• #1  사용자 이름 “user” 에 대해서 유저ROLE로 인메모리 인증을 허락한다.
• #2  사용자 이름  “admin” 에 대해 관리자ROLE로  인메모리 인증을 부여한다.
• #3 “/resources/”  경로 호출은 인증 무시한다. XML 설정에서는 다음과 같다. http@security=none  
  
• #4 인증없는 사용자를 포함한 누구한테나  “/signup” and “/about”  경로는  허용한다.
• #5 “/login” and “/login?error” 경로는 누구한테나 허용
• #6 /admin/ 로 시작되는 경로는 반드시 관리자 ROLE 에게만 허용된다.
• #7 모든 남은 URLs 는 인증이 성공해야지만 접근가능하다.
• #8 자바 세팅을 통해 폼기반인증셋업. 인증은  /login 으로 username/password 가 POST 로 날라올때
      수행된다. 
• #9  명시적으로 GET /login 이 요청되었을때 로그인페이지를 보여지는게 요구되어진다. 

위의 것은 아래와 같은  기존의  XML based configuration 과 비슷하다.

<http security="none" pattern="/resources/**"/>
<http use-expressions="true">
  <intercept-url pattern="/logout" access="permitAll"/>
  <intercept-url pattern="/login" access="permitAll"/>
  <intercept-url pattern="/signup" access="permitAll"/>
  <intercept-url pattern="/about" access="permitAll"/>
  <intercept-url pattern="/**" access="hasRole('ROLE_USER')"/>  #7
  <logout
      logout-success-url="/login?logout"
      logout-url="/logout"
  />
  <form-login
      authentication-failure-url="/login?error"
      login-page="/login"
      login-processing-url="/login"
      password-parameter="password"
      username-parameter="username"
  />
</http>
<authentication-manager>
  <authentication-provider>
    <user-service>
      <user name="user"  #1
          password="password" 
          authorities="ROLE_USER"/>
      <user name="admin" #2
          password="password" 
          authorities="ROLE_USER,ROLE_ADMIN"/>
    </user-service>
  </authentication-provider>
</authentication-manager>

XML 설정과 몇가지 차이점 

• #1 , #2 에서 보면 자바설정에서는 ROLE_ 이 없다. 자동적으로 추가해주기때문이다.
• Java configuration has different defaults URLs and parameters. Keep this in mind when creating custom login pages. The result is that our URLs are more RESTful. Additionally, it is not quite so obvious we are using Spring Security which helps to prevent information leaks. For example:
  
  
• /spring_security_login 대신해서 GET /login 호출하면 로그인 페이지를 연다.
• /j_spring_security_check 대신해서 POST /login 를 호출하면 인증체크를 한다. 
• 사용자이름 기본 설정은  j_username 대신해서 username  이다.
• 패스워드 기본 설정은   j_password 대신해서  password 이다.
• 자바 설정은  여러가지 요청 URL 에 대하여 동일한 롤에 의해 쉽게  매핑할수있게 해준다. #4 참고 
• 자바설정은 여분의 쓸모없는 코드들을 제거한다 . intercept-url 같은 경우 중복이 심하다.
• When mapping HTTP requests using the hasRole method as we did in #6, we do not need to specify “ROLE_” as we would in XML. Again, this is so common of a convention that the hasRole method automatically adds “ROLE_” for you. If you did not want to automatically prefix with “ROLE_”, you could use the “access” method.