저작권 안내: 저작권자표시 Yes 상업적이용 No 컨텐츠변경 No

스프링5 입문

JSP 2.3

JPA 입문

DDD Start

인프런 객체 지향 입문 강의

관련 글


컨텍스트


주식 종목 별로 최근 10분 동안의 평균 가격을 구하려면 다음과 같이 group by 사용햇다.


select code, avg(cost) as avg from StockTick.win:time(10 min) group by code


컨텍스트를 만들면 group by를 사용하지 않고 이벤트를 분류해서 분류된 파티션 별로 결과를 만들어 낼 수 있다. 컨텍스트는 이벤트를 컨텍스트 파티션으로 분류해 주며, EPL에 컨텍스트를 적용하면, 한 개의 EPL을 컨텍스트 파티션 별로 적용할 수 있다. 따라서, 주식 코드 별로 컨텍스트 파티션을 생성하고, 이 컨텍스트를 이용해서 EPL을 실행하면 group by 등의 쿼리를 사용하지 않아도 종목 별로 평균이나 추이 등을 분석할 수 있다.


컨텍스트 만들고 사용하기


컨텍스트는 다음과 같은 문장을 이용해서 생성한다.


epService.getEPAdministrator().createEPL(

       "create context CodeSegment partition by code from StockTick");


위 코드는 StockTick 이벤트를 code 값으로 분류하는 CodeSegment라는 컨텍스트를 생성한다. 값으로 파티션을 생성하는 방식과 해시값으로 파티션을 생성하는 방식 등 몇 가지 종류의 컨텍스트를 제공하는데, 이에 대한 내용은 뒤에서 다시 정리해 본다.


파티션을 생성했다면, EPL에서 다음과 같이 context 절을 이용해서 컨텍스트를 적용할 수 있다.


EPStatement eps = epService.getEPAdministrator().createEPL(

        "context CodeSegment " +

        "select code, avg(cost) as avg from StockTick.win:time(3 sec) ");


위 코드는 CodeSegment 컨텍스트를 사용하는데, 이 경우 각 EPL은 code 값으로 분류된 파티션 별로 적용된다. 따라서, 위 EPL의 select는 각 code 별로 최근 3초 시간 윈도우의 평균 값을 생성한다.


컨텍스트 종류

  • 키 기반 컨텍스트
  • 해시 키반 컨텍스트
  • 카테고리 컨텍스트
  • 논오버래핑 컨텍스트
  • 오버래핑 컨텍스트


컨텍스트 종류: 키 기반 컨텍스트


키 기반 컨텍스트는 이벤트의 특정 프로퍼티를 이용해서 이벤트를 파티션으로 분류한다. partition by 를 이용해서 파티션 키를 지정한다.


create context CodeSegment partition by code from StockTick


두 개 이상의 키를 사용할 수도 있다.


create context AccessLogSegment partition by domain and sesessionId from AccessLog


여러 이벤트를 이용해서 컨텍스트를 생성할 수도 있다.


create context CodeSegment2 partition by 

compCode from Announcement, code from StockTick


위 컨텍스트는 StockTick 이벤트와 Announcement 이벤트를 이용해서 컨텍스트를 생성한다. 각 이벤트에서 지정한 프로퍼티 개수와 타입은 동일해야 한다. 위 컨텍스트 내에서 실행되는 EPL은 코드는 같은 회사 코드를 갖는 주가와 공시 이벤트를 묶어서 처리할 수 있게 된다. 예를 들어, 아래 EPL에서 StockTick 이벤트와 Announcement 이벤트는 이미 동일한 회사 코드를 갖고 있으므로, code와 compCode가 같은지 여부를 비교할 필요가 없다.


context CodeSegment

select s from Announcement.win:time(10 min) a, StockTick t

where t.rate > 10


컨텍스트 종류: 해시 기반 컨텍스트


해시 기반 컨텍스트는 지정한 프로퍼티의 해시 값을 이용해서 이벤트를 분류한다. 해시 기반 컨텍스트를 사용하려면 다음과 같이 coalesce by와 해시 함수를 함께 사용하면 된다.


create context CodeSegment coalesce by

consistent_hash_crc32(code) from StockTick granularity 32

preallocate


consistent_hash_crc32는 CRC 32 알고리즘을 이용해서 해시 코드를 생성한다. hash_code를 사용하면 자바의 해시 코드를 이용한다. granularity는 파티션의 최대 개수를 지정하며, preallocate를 사용하면 미리 파티션을 생성해 놓는다. 키 기반 컨텍스트와 마찬가지로 여러 이벤트를 이용해서 정의할 수 있다.


위 코드를 이용해서 생성한 해시 기반 컨텍스트는 하나의 파티션에 한 개 이상의 code가 존재하게 됨에 유의하자.


컨텍스트 종류: 카테고리 컨텍스트


카테고리 컨텍스트는 프로퍼티를 이용해서 카테고리를 생성하고 이를 기준으로 분류한다. 다음은 카테고리 컨텍스트의 생성 예를 보여주고 있다. "group 표현식 as 카테고리이름"을 이용해서 카테고리를 정의한다.


create context AccessLogCategory

group responseTime <= 1000 as normal,

group responseTime > 1000 and responseTime <= 2000 as slow,

group responseTime > 2000 as tooslow

from AccessLog


카테고리 기반 컨텍스트는 이벤트를 몇 개의 카테고리로 나눈다. 위 코드는 3개의 파티션을 생성하는데, 이벤트는 응답 시간에 따라 normal 파티션, slow 파티션, tooslow 파티션에 속하게 된다.


이 컨텍스트를 사용하는 EPL은 다음과 같이 context.label을 이용해서 카테고리 이름을 구할 수 있다.


context AccessLogCategory

select context.label from AccessLog


컨텍스트 종류: 논오버래핑 컨텍스트


논오버래핑 컨텍스트는 시작과 끝 조건에 따라 컨텍스트가 시작되거나 끝나는 컨텍스트이다. 컨텍스트가 시작되면 끝 조건 전까지 컨텍스트 파티션은 1개만 존재한다. 끝 조건을 충족해서 컨텍스트가 끝나면 파티션은 0개가 된다.


논오버래핑 컨텍스트는 start와 end를 이용해서 시작 조건과 끝 조건을 지정한다. 시작 조건과 끝 조건에는 이벤트, 패턴, 그론탭, 시간 간격 등이 올 수 있다. 다음은 레퍼런스 문서에 있는 몇 가지 예이다.

  • create context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *)
    크론탭 표현식을 이용한 시작/종료 시점을 지정한다. 9시에 컨텍스트를 시작하고 17시에 끝낸다.
  • create context PowerOutage start PowerOutageEvent end pattern [PowerOnEvent -> timer:interval(5 sec)]
    PowerOutageEvent가 발생하면 컨텍스트를 시작하고, PowerOnEvent 발생 후 5 초가 지나면 끝낸다.
  • create context Every15minutes start @now end after 15 min
    @now는 지금을 의미하는 어노테이션으로, 컨텍스트는 지금 시작해서 15분 후에 끝낸다. 컨텍스트가 종료되면 @now에 의해 다시 컨텍스트가 바로 시작.
시작 조건은 @now 또는 크론탭이나 이벤트 필터 등의 표현식이 온다.

EPL에서는 context.startTime과 context.endTime을 이용해서 컨텍스트의 시작 시작과 끝 시간을 구할 수 있다.

컨텍스트 종류: 오버래핑 컨텍스트


오버래핑 컨텍스트는 시작과 종료 조건을 지정하는 건 논오버래핑 컨텍스트와 같다. 차이점이 있다면, 오버래핑 컨텍스트는 시작 조건을 충족할 때 마다 새로운 컨텍스트 파티션을 생성한다는 점이다. initiated와 terminated를 이용해서 컨텍스트 시작과 종료 조건을 지정한다. 다음은 레퍼런스 문서에 있는 몇 가지 예이다.

  • create context CtxTrainEnter initiated TrainEventEnter as te terminated after 5 min
    TrainEventEnter 이벤트가 들어올 때 마다 새로운 컨텍스트를 시작하고, 5분이 지나면 해당 컨텍스트를 종료한다.
  • create context CtxEachMinute initiated @now and pattern [every timer:interval(1 min)] terminated after 1 min
    "@now and"는 컨텍스트를 즉각 시작하고, 시작 조건이 충족되면 새로운 컨텍스트를 시작한다. 위 EPL은 컨텍스트를 즉각 시작하고, (1분이 지나면 조건을 충족하므로) 매 1분이 지날 때 마다 컨텍스트를 시작한다. 각 컨텍스트는 1분 이후에 종료된다.
  • create context OrderContext initiated distinct(orderId) NewOrderEvent as newOrder terminated CloseOrderEvent(closeOrderid = newOrder.orderId)
    NewOrderEvent가 들어오면 컨텍스트를 시작한다. 단, orderId를 기준으로 컨텍스트가 이미 존재하면 새로운 컨텍스트는 시작되지 않는다.

컨텍스트 종료시 결과 생성하기


output을 사용하면 컨텍스트가 종료될 때 결과를 생성할 수 있다. 다음처럼 output - when terminated 구문을 사용하면 된다.


context CtxEachMinute select avg(temp) from sensorEvent output snapshot when terminiated



컨텍스트를 사용할 때의 장점


레퍼런스 문서에 따르면 컨텍스트 사용시 다음과 같은 장점이 있다고 한다.

  • 하나의 컨텍스트를 여러 EPL에 적용할 수 있으므로, 그룹핑하기 위한 중복 부분을 제거할 수 있다.
  • EPL을 더 읽기 쉽게 만들어준다.
  • 두 개 이상의 컨텍스트를 조합(중첩)할 수 있다.
  • 파티션이 시간 상 겹칠 수 있다.
  • 엔진이 컨텍스트 단위로 락을 관리하기 때문에 동시성을 높일 수 있다.


Posted by 최범균 madvirus

댓글을 달아 주세요

회원 정보 목록 화면과 회원 정보 상세 화면을 반복해서 왔다 갔다 하는 직원이 있다고 하자. 또, 특정 조건으로 회원 목록을 검색해서 1페이지, 2페이지, 3페이지 등 페이지 이동을 하는 직원이 있다고 하자. 이 두 경우 회원 정보를 지속적으로 조회하는 것으로서, 회원 정보를 몰래 수집하는 이상 행동으로 의심해 볼 수 있다. 이런 이상 행동에는 일정 패턴이 반복되는 경우가 많은데, 이런 상황을 발견할 때 유용하게 사용할 수 있는 것이 EPL 패턴이다.


관련 글:

EPL 패턴


EPL은 발생하는 이벤트들이 특정 패턴에 매칭되는지 찾아준다. 다음은 매우 간단한 EPL 패턴의 사용 예다.


EPStatement eps = epService.getEPAdministrator().createEPL(

        "select l from pattern[every l=List ]"

);

eps.addListener(new UpdateListener() {

    @Override

    public void update(EventBean[] newEvents, EventBean[] oldEvents) {

        MemberList l = (MemberList)newEvents[0].get("l"));

        ...

    }

});


위 코드에서 from 절 뒤에 "pattern [ 패턴 ]" 형식으로 패턴을 지정하고 있다. 위 패턴은 매우 단순한 패턴으로, 모든 List 이벤트에 대해 매칭되는 패턴이다. 위 EPL을 실행하면 List 이벤트가 발생할 때 마다 UpdateListener가 실행된다.


위 패턴은 "select l from List l" EPL과 동일한 결과를 발생시키는데, 실제 위와 같이 단순한 패턴을 사용하지는 않는다. EPL은 다양한 패턴 연산자와 구성 요소를 제공하고 있으며 이들을 조합해서 흥미로운 패턴을 만들어낼 수 있다.


패턴의 구성 Atom과 연산자


패턴을 구성하는 주요 Atom(EPL 레퍼런스 문서를 보면 Atom이라고 부름)에는 다음의 두 가지가 있다.


패턴 Atom 

이벤트 필터 Atom

이벤트: List

조건에 맞는 이벤트: List(userId = 'madvirus')

시간 기반 Atom

타이머: timer:interval(10 sec)

스케줄: timer:at(*, 6, *, *, *)


Atom에 대한 연산자는 다음의 4가지 종류가 존재한다.


종류

연산자

반복을 제어하는 연산자

every, [num], until 등

논리 연산자

and, or, not

이벤트의 발생 순서

 ->

표현식 유효 조건

where timer:within, where timer:withinmax, while 등 


연산자의 우선순위는 다음과 같다.

  1. 조건 접미사: where timer:within, where timer:withinmax, while
  2. 단항 연산자: every, not, every distinct
  3. 반복: [num], until
  4. and
  5. or
  6. 순서: ->

연산자 우선순위를 이해하지 않으면 패턴을 다른 의미로 읽거나 작성하게 되므로, 우선순위에 유의해서 패턴을 작성해야 한다.


이벤트 필터


다음 EPL을 보자.


select L from pattern [L=List]


위 EPL에서는 List는 이벤트를 위한 Atom 이다. 패턴에 명시한 이벤트를 참조하려면 '태그이름=이벤트Atom'의 형식으로 태그를 사용해야 한다. 위 코드에서는 'L'이 태그가 된다.


위 EPL을 실행하면 최초에 발생한 List 이벤트만 패칭되며, 이후 발생하는 List 이벤트에 대해서는 매칭되지 않는다. 따라서, List 타입 이벤트가 L1, L2, L3의 순서로 발생하면 L1 이벤트에 대해서만 UpdateListener를 통해 통지 받을 수 있다.


모든 List 이벤트에 대해 매칭되려면 every 연산자를 사용해야 한다.


select L from pattern [every L=List]


위 EPL은 모든 List 이벤트에 매칭된다.


특정 조건을 만족하는 이벤트를 걸러내고 싶다면 다음과 같이 필터 구문을 사용하면 된다.


select L from pattern [every L=List(uri='/member/list', userId='bkchoi')]


"->"를 이용한 발생 순서 매칭


-> 연산자는 매우 유용한 연산자이다. 이벤트의 발생 순서를 지정할 때 -> 연산자를 사용할 수 있다. 아래 패턴은 List 이벤트 다음에 Detail 이벤트가 발생한 경우 매칭된다.


select L, D from pattern [L=List -> D=Detail]


다음은 이벤트 순서와 위 패턴에 매칭되어 선택된 결과를 표시한 것이다.

  • L1, L2, D1, D2, L3, D3 : (L1, D1)

위 결과를 보면 첫 번째로 패턴에 매칭된 이벤트 집합(L1, D1)만 선택된 것을 알 수 있다. 


모든 이벤트 List 이벤트에 대해 매칭되도록 하려면 every 연산자를 사용하면 된다.


select L, D from pattern [every L=List -> D=Detail]


위 패턴은 모든 List 이벤트에 대해 뒤에 Detail이 오면 매칭된다. every 연산자가 -> 보다 우선순위가 높으므로 위 패턴은 [(every L=List) -> D=Detail]과 같다. 다음은 이벤트 흐름에 대해 매칭되어 선택되는 이벤트 집합을 표시한 것이다.

  • L1, L2, D1, D2, L3, D3 : (L1, D1), (L2, D1), (L3, D3)

위 매칭 결과를 보면 (L1, D1)과 (L2, D1)이 선택된 것을 알 수 있다. L1과 L2에 대해 D1이 모두 매칭됐는데, 겹치는 경우 매칭되지 않도록 하고 싶다면 다음과 같이 @SuppressOverlappingMatches 패턴 어노테이션을 사용한다.


select L, D from pattern @SuppressOverlappingMatches [every L=List -> D=Detail]


위 패턴을 사용하면 이벤트 발생 순서에 따라 다음과 같이 (L1, D1)만 선택되고, (L1, D1)과 겹쳐지는 (L2, D1)은 매칭되지 않는다.

  • L1, L2, D1, D2, L3, D3 : (L1, D1), (L3, D3)

-> 연산자를 사용할 때 주의할 점은 -> 연산자 앞 뒤에 지정한 이벤트가 반드시 바로 직후에 발생되야 하는 것은 아니라는 점이다. 예를 들어, 다음과 같은 패턴과 이벤트 순서를 생각해보자.

  • 패턴: select L, D from pattern [every L=List -> D=Detail]
  • 이벤트: L1, V1, D1, D2, L3, D3
이 경우 L1과 D1 사이에 다른 타입의 이벤트 V1이 발생했지만, L1 이벤트 이후에 D1 이벤트가 발생했으므로 (L1, D1) 이벤트 쌍이 매칭되어 선택된다. 즉, '->' 연산자는 바로 뒤에의 의미가 아니라 '이후에'라는 의미이다.


and와 or 연산자


and는 순서에 상관없이 두 표현식이 모두 true면 매칭된다. 예를 들어, 다음 패턴은 List 이벤트와 Detail 이벤트가 도착하면 매칭된다.


select L, D from pattern [L=List and D=Detail]


순서가 상관이 없기 때문에 다음의 두 순서로 이벤트가 들어와도 매칭되서 선택되는 이벤트는 L2, D1 이다. 한 번만 선택되는 이유는 패턴에 every가 없기 때문이다.

  • L2, D1, D2, L3, D3
  • D1, L2, L3, D3
동일 패턴을 사용하면서 다음의 순서로 이벤트가 발생하면 어떻게 될까?
  • L1, L2, D1, D2, L3, D3
이 경우 선택되는 이벤트 조합은 (L1, D1)이다.

아래와 같이 every를 붙이면 어덯게 될까? (every의 우선순위가 and 보다 높기 때문에 and 쪽에 괄호를 넣었다.)

select L, D from pattern [every (L=List and D=Detail)]


다음 순서로 이벤트가 발생할 경우,
  • L1, L2, D1, D2, L3, D3

매칭되는 결과 이벤트는 (L1, D1)과 (L3, D2) 이다.


or는 두 표현식 중 하나만 true면 된다. 즉, 아래 이벤트는 List 이벤트나 Detail 이벤트 중 하나만 발생해도 매칭된다. every가 붙어 있으므로 결과적으로 모든 List 이벤트와 Detail 이벤트가 매칭된다.

select L, D from pattern [every (L=List or D=Detail)]


not 연산자


not은 표현식이 false인 경우 true가 된다. 처음 Statement가 시작될 때에 "not 표현식"은 true 상태로 시작하며, 표현식이 true가 될 때 false가 된다. not은 단독으로 사용되기 보다는 and와 함께 사용된다. 예를 들어, 발권을 하한 뒤 상영관에 입장하기 전에, 표에 있는 할인 쿠폰으로 간신을 구매하지 않은 사용자를 찾고 싶다고 해 보자. 이는 다음과 같은 패턴으로 찾아낼 수 있다.


select i from pattern [

  every i=IssuedTicket -> (Entering(ticketId = i.id) and not UseTicketCoupon(couponId = i.couponId))

]


위 패턴은 모든 영화표발권(IssuedTicket) 이벤트에 대해 이후 같은 표에 대한 입장(Entering) 이벤트가 발생하고, 그 사이에 표의 쿠폰을 사용함(UseTicketCoupon) 이벤트가 발생하지 않으면 매칭된다. 따라서, 이 패턴으로 매칭된 IssuedTicket 이벤트를 이용해서 실시간으로 쿠폰이 사용되지 않은 표를 구매한 고객을 찾아낸다면, 고객에게 SMS를 이용해서 쿠폰 사용을 유도하는 프로모션을 진행할 수도 있을 것이다. (예를 들어, 같은 건물에 있는 커피숍에 가서 500원을 할인 받으라는 등의 프로모션)


Every 연산자


every 연산자는 동작 방식을 잘 이해해서 사용해야 한다. every 연산자를 어떻게 사용하느냐에 따라 패턴 매칭 결과가 달라지는데, 이에 대한 설명은 레퍼런스 문서에 잘 나와 있다. 그래서 레퍼런스 문서에 있는 내용을 발췌해서 아래 표로 정리해 본다.


* 이벤트가 A1, B1, C1, B2, A2, D1, A3, B3, E1, A4, F1, B4 순서로 발생했다고 가정

every 사용 예

설명

매칭 결과 

every (A -> B)

A 이벤트 발생 후, B 이벤트가 발생하면 매칭된다. 매칭된 후 새로운 매처(매칭 검사기)를 시작한다. A가 매칭된 후, 다음 B가 나올 때 까지 새로운 매처가 시작되지 않는다. 즉, A 이벤트 이후에 B 이벤트가 발생하기 전까지의 다른 A 이벤트는 매칭 대상에서 제외된다.

(A1, B1), (A2, B3),

(A4, B4)

every A -> B

(every A) -> B

모든 A에 대해, A 이벤트 발생 후 B 이벤트가 발생하면 매칭된다.

(A1, B1), (A2, B3),

(A3, B3), (A4, B4) 

A -> every B 

A -> (every B)

패턴 Statement가 시작된 뒤, 첫 번째 A 이벤트에 대해 모든 B가 매칭된다.

(A1, B1), (A1, B2),

(A1, B3), (A1, B4) 

(every A) -> (every B)

모든 A 이벤트에 대해, A 이벤트 발생 후 모든 B 이벤트에 매칭된다.

(A1, B1), (A1, B2),
(A1, B3), (A1, B4)
(A2, B3), (A2, B4)
(A3, B3), (A3, B4)
(A4, B4) 


반복 연산자


특정 표현식이 지정한 횟수만큼 반복되면 매칭되도록 하고 싶다면 반복 연산자를 사용하면 된다. 반복 연산자는 '[횟수]' 형식으로 사용한다. 아래 코드는 예이다.


EPStatement eps = epService.getEPAdministrator().createEPL(

        "select s from pattern [every [2] s=SlowResponse ]"

);


eps.addListener(new UpdateListener() {

    @Override

    public void update(EventBean[] newEvents, EventBean[] oldEvents) {

        for (EventBean eb : newEvents) {

            // 길이가 2인 배열

            SlowResponse[] responses = (SlowResponse[]) eb.get("s");

            ...

        }

    }

});


위 패턴을 사용하면 SlowResponse 이벤트가 2번 발생할 때 마다 매칭된다. 매칭 결과를 받는 리스너의 코드를 보면 "s"에 보관된 값이 SlowResponse 배열임을 알 수 있다.


반복 연산자와 not을 사용하면 다음과 같은 패턴을 만들 수도 있다.


select s, o from pattern [

     every [3] ( (s=SlowResponse or o=OvertimeResponse) and not NormalResponse)"

]


위 패턴은 SlowResponse나 OvertimeResponse가 3회 발생하고, 그 사이에 NormalResponse가 발생하지 않은 경우 매칭된다. 즉, 느린 응답이 연속해서 3회 발생하는 상황을 찾아내주는 패턴이다.


반복 연산자와 until


until 연산자는 until 뒤의 표현식이 충족될 때 매칭된다. 아래 패턴은 NormalResponse가 발생하기 전까지 SlowResponse 이벤트를 반복한다.


select s from pattern [ every (s=SlowResponse until NormalResponse) ]


NormalResponse 이벤트 발생 전에 SlowResponse 이벤트가 5번 발생하면 s는 SlowReponse 객체 5개를 갖는 배열이 할당된다.


범위를 갖는 반복 연산자는 다음과 같은 형식을 갖는다.

  • [3:8] - 최소 3번에서 최대 8번까지 반복
  • [3:] - 최소 3번 반복
  • [:8] - 최대 8번 반복
until과 범위를 갖는 반복 연산자를 함께 사용해도 된다. 다음은 예이다.


* S1 S2 N1 S3 S4 S5 N2 순서로 이벤트가 발생했다고 가정 (S:Slow, N:Normal)

 패턴 예

 결과

 every ([2:] s=SlowResponse until NormalResponse)

(S1, S2) *N1 발생 시점에 생성

(S3, S4, S5) *N2 발생 시점에 생성 

 every ([:3] s=SlowResponse until NormalResponse)

(S1, S2) *N1 발생 시점에 생성 

(S3, S4, S5) *N2 발생 시점에 생성

 every ([:2] s=SlowResponse until NormalResponse)

(S1, S2) *N1 발생 시점에 생성

(S3, S4) *N2 발생 시점에 생성

 every ([3:] s=SlowResponse until NormalResponse)

(S3, S4, S5) *N2 발생 시점에 생성


타이머 패턴 가드


where timer:within 가드는 표현식 뒤에 위치하며, 일정 시간 안에 표현식이 true가 되면 매칭되고 지정한 시간이 지나면 매칭되지 않는다. 다음은 타이머 가드의 사용 예이다.


select s from pattern [s=SlowResponse where timer:within(2 sec)]


위 패턴은 최초 2초 안에 SlowResponse 이벤트가 발생하는지 여부를 확인한다. 최초 2초 안에 이벤트가 발생하면 해당 SlowResponse 이벤트가 선택되고 타이머가 종료된다. 2초가 지나면 타이머가 종료되고 더 이상 패턴은 사용되지 않는다.


최근 2초간 발생한 SlowResponse 이벤트를 구하고 싶다면 다음과 같이 every 연산자를 함께 사용한다. 아래 패턴을 실행하면 2초 안에 SlowResponse가 이벤트가 발생할 때 마다 select 결과를 받게 된다.


select s from pattern [(every s=SlowResponse) where timer:within(2 sec)]


아래 코드는 어떤 의미일까?


select s from pattern [every ((s=SlowResponse -> SlowResponse) where timer:within(2 sec))]


위 코드는 최초 시작시 타이머가 시작되어 (SlowResponse -> SlowResponse)가 2초 이내에 발생하는지 여부를 확인한다. 타이머가 종료되면 every 연산자에 의해 새로운 타이머가 시작된다. 위 패턴을 사용했을 때 이벤트 발생 시점과 select 결과는 아래 그림과 같이 이뤄진다. 아래 그림에서 화살표는 타이머의 시작과 끝을 나타낸다.



위 그림과 동일한 시점에 이벤트가 발생했을 때, 아래 코드는 어떤 결과를 만들까?


select s from pattern [every s=SlowResponse -> SlowResponse where timer:within(2 sec)]

// 우선순위에 따라 evern s=SlowResponse -> (SlowResponse where timer:within(2 sec)) 와 동일


이 패턴은 모든 SlowResponse 이벤트가 발생한 후 2초 이내에 SlowResponse 이벤트가 발생하면 매칭된다.


아래 패턴은 어떨까?


select s from pattern [every s=SlowResponse -> (not NormalResponse where timer:within(2 sec)) ]


얼핏 생각하면 SlowResponse 이벤트 발생 후 2초 이내에 NormalResponse가 발생하지 않으면 매칭될 것 같지만, 실제로는 SlowResponse 이벤트가 발생하는 순간에 바로 매칭된다. 실제로 특정 이벤트가 발생하고 나서 일정 시간 안에 다른 이벤트가 발생하지 않는 패턴을 만들고 싶다면 다음에 설명할 time:interval Atom을 사용해야 한다.


시간 Atom


패턴의 Atom은 이벤트 필터 외에 시간 간격 Atom인 timer:interval 을 제공하고 있다. 다음은 time:interval을 사용한 패턴 예이다.

select o from pattern [
    every o=OrderForm -> timer:interval(10 min) and not OrderComplete(id=o.id)
]

위 코드는 OrderForm 이벤트가 발생한 후, 같은 id를 갖는 OrderComplete 이벤트가 10분 안에 발생하지 않으면 매칭된다. 즉, 주문 양식까지 들어왔는데 10분 동안 결제를 하지 않은 경우를 찾아내는 패턴이다.


Posted by 최범균 madvirus

댓글을 달아 주세요


이래 저래 데이터 처리 관련된 기술을 조사하던 중 Esper란 놈을 알게 되었다. 몇 가지 글을 읽어보니 기회가 되면 사용해보고 싶은 욕구가 생겼다. 나처럼 Esper에 관심있는 분들을 위한 퀵스타트 문서를 정리해 본다.


관련 시리즈:


Esper란?


Esper 사이트에 따르면 Esper란 다음과 같은 것이다.

Esper is a component for complex event processing (CEP) and event series analysis.

Esper는 실시간으로 발생하는 이벤트를 분석하고 처리하기 위한 컴포넌트로서, 다음과 같은 방식으로 동작한다.


외부에서 발생한 이벤트를 Esper 엔진에 전달하면, 이벤트를 분석한다. 이벤트를 분석할 때 EPL 이라는 언어를 사용하는데, 이 언어를 이용해서 조건에 맞는 이벤트를 찾고 처리한 결과를 데이터를 생성한다.


EPL 언어는 SQL과 유사한 구조를 갖고 있기 때문에 조금만 노력하면 금방 익힐 수 있을 것 같다. EPL과 SQL을 비교해 보면, SQL에 존재하는 데이터에 대해 쿼리를 실행하는 방식이라면 EPL은 실시간으로 발생되는 이벤트에 대해 쿼리를 실행하는 방식이라고 말 할 수 있다.


Esper 다운로드


Esper를 사용하려면 Esper를 다운로드 받고 필요한 jar 파일을 복사하면 된다. 그런데, Esper는 EPL 파싱을 위해 Antlr을 사용하고 로깅을 위해 Commons Logging을 사용하고 있기 때문에 실제로는 Esper 배포판뿐만 아니라 의존 모듈도 함께 다운로드 받아야 한다.


메이븐을 사용하고 있다면 다음과 같이 의존을 추가해주면 된다.


<dependencies>

<dependency>

<groupId>com.espertech</groupId>

<artifactId>esper</artifactId>

<version>4.11.0</version>

</dependency>

</dependencies>


간단한 예제 만들어보기


여기서 만들어 볼 예제는다음과 같은 간단한 예제이다.

  • 현재가가 전날 종가대비 10% 이상 오른 종목을 통지한다.

이벤트로 사용될 클래스


먼저 할 작업은 이벤트로 사용될 클래스를 작성하는 것이다.


public class StockTick {


    private String name;

    private String code;

    private int cost;

    private int fluctuation;

    private double rate;


    public StockTick(String name, String code, int cost, int fluctuation, double rate) {

        this.name = name;

        this.code = code;

        this.cost = cost;

        this.fluctuation = fluctuation;

        this.rate = rate;

    }


    public String getName() {

        return name;

    }


    public String getCode() {

        return code;

    }


    public int getCost() {

        return cost;

    }


    public int getFluctuation() {

        return fluctuation;

    }


    public double getRate() {

        return rate;

    }

}


위 코드는 한 종목의 이름, 코드, 현재주가, 전일비, 등낙율을 담고 있다.


조건을 충족하는 종목을 찾아주는 코드


아래 코드는 Esper를 이용해서 전날 종가보다 10% 이상 상승한 종목을 출력해주는 기능을 제공하는 클래스이다.


import com.espertech.esper.client.*;


public class StockFinder {

    private EPServiceProvider epService;

    private EPStatement eps;

    private StockFoundListener listener;


    public void setup() {

        Configuration config = new Configuration();

        // 1. StockTick 클래스를 Esper가 사용할 이벤트 타입으로 등록

        config.addEventType("StockTick", StockTick.class);


        // 2. config를 이용해서 EPService 생성

        epService = EPServiceProviderManager.getProvider("StockTick", config);


        // 3. epService를 이용해서 EPL 생성

        eps = epService.getEPAdministrator().createEPL(

                "select * from StockTick t where t.rate >= 10");


        // 4. EPL의 결과를 받는 리스너 등록

        eps.addListener(new UpdateListener() {

            @Override

            public void update(EventBean[] newEvents, EventBean[] oldEvents) {

                StockTick stockTick = (StockTick) newEvents[0].getUnderlying();

                if (listener != null) listener.found(stockTick);

            }

        });

    }


    public void setStockFoundListener(StockFoundListener listener) {

        this.listener = listener;

    }


    public void sendStockTick(StockTick tick) {

        // 5. EP런타임에 이벤트 전달

        epService.getEPRuntime().sendEvent(tick);

    }

}


// StockFoundListener

public interface StockFoundListener {

    public void found(StockTick stockTick);

}


위 코드에서 3번 항목의 EPL은 아래와 같은데, 이를 보면 SQL과 유사한 것을 알 수 있다.


select * from StockTick t where t.rate >= 10


참고로, 이 쿼리는 앞서 1번 과정에서 등록한 StockTick 이벤트에 대해 그 이벤트의 rate 값이 10 보다 크거나 같으면 선택하라는 의미이다.


EPL에 의해 선택된 이벤트에 접근할 때 사용되는 것이 리스너이다. Esper는 EPL에 의해 선택된 데이터를 등록된 UpdateListener에 전달한다. 위 코드의 경우 3번 과정의 EPL에서 생성한 결과를 4번에서 등록한 listener에 StockTick 객체를 전달하도록 했다.


초기화를 했다면 EPRuntime의 sendEvent() 메서드를 이용해서 이벤트를 Esper에 전달하면 된다. 위 코드의 경우 다른 부분에서 지속적으로 주가 데이터를 읽어와 StockTick 객체를 생성한 뒤에 StockFinder의 sendStockTick() 메서드를 이용해서 StockTick 객체를 Esper 런타임에 전달하게 될 것이다.


간단 테스트 코드


실제 원하는 대로 동작하는지 아주 간단한 테스트 코드를 만들어보자.


public class StockFinderTest {


    private final StockFinder stockFinder = new StockFinder();


    private StockTick lastFound = null;

    private StockFoundListener listener = new StockFoundListener() {

        @Override

        public void found(StockTick stockTick) {

            lastFound = stockTick;

        }

    };


    @Before

    public void setup() {

        stockFinder.setup();

        stockFinder.setStockFoundListener(listener);

    }


    @Test

    public void shouldFound() {

        StockTick tick1 = new StockTick("name", "code", 109, 9, 9.0);

        stockFinder.sendStockTick(tick1);

        assertThat(lastFound, nullValue());


        StockTick tick2 = new StockTick("name", "code", 110, 10, 10.0);

        stockFinder.sendStockTick(tick2);

        assertThat(lastFound, equalTo(tick2));

    }



위 코드에서 listener 필드는 StockFinderListener 구현 객체를 갖는데, 이 객체는 found() 메서드에 전달된 stockTick 객체를 lastFound 필드에 할당한다. 따라서, StockFinder가 10% 이상 상승한 종목을 찾아서 통지를 하면 lastFound 필드에 그 StockTick 객체가 할당된다.


테스트 메서드에서 tick1은 전날 종가 대비 등락율이 9%이므로 StockFinder는 통지하지 않는다. 따라서, lastFound는 null 이어야 한다. 반면에 tick2는 등락율이 10%이므로 StockFinder가 통지하게 되고, 이에 따라 lastFound 필드에 tick2 객체가 전달된다. 따라서, lastFound와 tick2는 같아야 한다.


아주 약간 흥미를 더한 코드 만들기


단순히 어제 종가 대비 10% 상승한 종목을 찾는 일은 Esper를 사용하지 않아도 쉽게 할 수 있는 일이다. 단순히 이런 걸 하려고 Esper를 사용하진 않을 것이다. 실제로 Esper는 복잡한 상황과 조건을 다룰 수 있는 EPL을 제공하고 있다. 예를 들어, 최근 5초 동안 주가가 5% 이상 상승한 종목을 알고 싶다면 다음과 같은 EPL을 사용할 수 있다.


select first(*) as tick1, last(*) as tick2 

from StockTick.win:time(5 seconds) 

group by code 

having first(*) != last(*) and (last(cost) - first(cost)) / first(cost) >= 0.05


위 EPL을 간단히 설명하면

  • 2줄: StockTick 이벤트를 최근 5초 기준으로
  • 3줄: code를 이용해서 그룹핑 하고,
  • 4줄: 그룹에서 최근 5초 이내 첫 번째와 마지막 이벤트가 다르고, 첫 번째 이벤트의 cost보다 마지막 이벤트의 cost가 5% 이상 값이 크면,
  • 1줄: 그룹의 첫 번째 이벤트와 마지막 이벤트를 선택한다
위 EPL로부터 결과를 받는 UpdateListener는 다음과 같은 코드를 이용해서 최근 5초 동안 5% 이상 상승한 종목을 구할 수 있다.

eps = epService.getEPAdministrator().createEPL(
        "select first(*) as tick1, last(*) as tick2 from StockTick.win:time(5 seconds) " +
        "group by code having first(*) != last(*) and (last(cost) - first(cost)) / first(cost) > 0.05"
);
eps.addListener(new UpdateListener() {
    @Override
    public void update(EventBean[] newEvents, EventBean[] oldEvents) {
        StockTick tick1 = (StockTick) newEvents[0].get("tick1");
        StockTick tick2 = (StockTick) newEvents[0].get("tick2");
        ... 필요한 작업
    }
});

StockTick의 code 값을 이용해서 그룹핑을 하는데, code값이 각각 "code1"과 "code2"인 StockEvent가 아래 그림고 같은 순서로 발생했다고 하자. (시간은 초, code1 및 code2는 해당 초에 발생한 이벤트의 cost 값, 결과는 UpdateListener에 전달된 tick1과 tick2의 값이다.



위 그림에서, 5초가 흐른 시점에 code 값이 "code2"인 StockEvent가 발생을 했고, 이 이벤트의 cose 값은 302 이다. 즉, 최초 2초가 흐름 시점에는 code1과 관련된 2개의 이벤트가 발생했고, 첫 번째 이벤트의 cost는 100, 마지막 이벤트의 cost는 109이므로 5% 이상 상승한 값이다. 그래서 UpdateListener는 0초에 발생한 이벤트와 2초에 발생한 이벤트를 각각 tick1과 tick2로 받는다.


이와 비슷한 방식으로 11초 기준으로 "code2" 관련 StockEvent가 발생하는데, 이 시점에 최근 5초 동안 "code2"의 시작 이벤트는 7초 시점의 305 이벤트이고, 마지막 이벤트는 11초 시점의 323 이벤트이다. 323은 305보다 5% 이상 큰 값이므로, 결과로 305 이벤트와 323 이벤트가 선택된다.

참고자료

Esper를 이용하면 두 종류의 이벤트를 병합한다거나 조인을 하거나 특정 패턴을 찾아내는 등 다양한 방식으로 이벤트를 처리할 수 있다. 또한, 필요에 따라 외부 데이터를 함께 사용할 수도 있다. 이런 다양한 정보를 얻는 가장 좋은 방법은 레퍼런스 문서를 읽어보는 것이다. Esper에 관심이 있다면, http://esper.codehaus.org/ 사이트에서 레퍼런스 문서를 구해 차분히 읽어 보면 도움을 얻을 것이다.



Posted by 최범균 madvirus

댓글을 달아 주세요

  1. 춥고배고파 2014.03.09 23:39 신고  댓글주소  수정/삭제  댓글쓰기

    StockFinderListener class 는 어디에 있는건가요?

  2. 춥고배고파 2014.03.10 22:11 신고  댓글주소  수정/삭제  댓글쓰기

    눈이 이상해서 그런지 찾지 못하겠네요 ㅠ..ㅠ

    • 최범균 madvirus 2014.03.11 08:59 신고  댓글주소  수정/삭제

      아,,, StockFinderListener는 인터페이스인데, 제가 그 인터페이스 코드 자체를 넣진 않았네요. StockFinderTest 클래스의 listener 필드에 다음과 같이 임의 객체를 생성하는 부분에서, StockFinderListener 인터페이슨느 found() 메서드 하나만 정의하고 있는 인터페이스입니다.

      private StockFinderListener listener = new StockFinderListener() {
      @Override
      public void found(StockTick stockTick) {
      lastFound = stockTick;
      }
      };

      즉, StockFinderListener는 다음과 같습니다.

      public interface StockFinderListener {
      public void found(StockTick stockTick);
      }

  3. 흠... 2014.03.12 16:52 신고  댓글주소  수정/삭제  댓글쓰기

    StockFoundListener클래스도 보이지 않네요! 어디에서 찾아야하나요~?