꿀봉자바 [Developer]

[Linux] JVM 상태 모니터링 및 GC 정보 확인 ( jstat 명령어 )

예은파파 — Thu, 25 Jan 2024 17:03:27 +0900

JDK 1.6부터 함께 제공되기 시작한 모니터링 및 분석 툴.

보통 JVM 튜닝을 하기 위하여 JVM 상태를 모니터링하고 GC(Garbage Collection) 정보를 확인한다.

jstat에서 사용할 수 있는 옵션

Option	Description
-class	클래스 로더의 동작에 대한 통계
-compiler	HotSpot의 JIT 컴파일러에 대한 통계
-gc	GC된 heap의 동작에 대한 통계
-gccapacity	세대마다의 용량과 대응하는 영역 통계
-gccause	GC 통계 데이터(-gcutil 옵션)와 직전 및 현재의 GC 이벤트의 원인
-gcnew	New 세대 동작에 대한 통계
-gcnewcapacity	New 세대의 사이즈와 대응하는 영역에 대한 통계
-gcold	Old 세대 및 Permanent 세대의 동작에 관한 통계
-gcoldcapacity	Old 세대의 사이즈에 관한 통계
-gcpermcapacity	Permanent 세대의 사이즈에 대한 통계
-gcutil	GC 통계 데이터
-printcompilation	HotSpot 컴파일러의 통계 데이터

jstat -gcutil -t {pid} {interval} {repeat count}

S0 : Survivor 영역 0의 사용율
S1 : Survivor 영역 1의 사용율
E : Eden 영역의 사용율
O : Old 영역의 사용율
P : Permanent 영역의 사용율
YGC : Young 세대의 GC 이벤트 수
YGCT : Young 세대의 GC 시간
FGC : Full GC 이벤트 수
FGCT : Full GC 시간
GCT : GC 총 시간

2. jstat -gccapacity -t {pid} {interval} {repeat count}

NGCMN : New 세대의 최소 크기 (KB)
NGCMX : New 세대의 최대 크기 (KB)
S0C : Survivor 영역 0의 크기
S1C : Survivor 영역 1의 크기
EC : Eden 영역의 크기
OGCMN : Old 세대의 최소 크기
OGCMX : Old 세대의 최대 크기
OGC : Old 세대의 현재 크기
OC : Old 영역의 현재 크기

3. 구동중인 JAVA application Heap momory 사용량 확인

watch -n 2 'jstat -gc 20206 | awk '\''NR>1 { print "Used Heap: " ($6+$8+$4)/1024 " MB" }'\'''

[Linux] Socket 상태 조회 ( Socket Statistics )

예은파파 — Wed, 24 Jan 2024 17:19:07 +0900

리눅스에서 네트워크 상태를 확인하기 위해 흔히 사용하는 명령어로 netstat 명령어가 존재하나

최근 리눅스 배포판은 netstat 보다 새로운 명령어인 ss 사용을 권장하고 있음.

ss는 옵션 없이 사용하면 listening socket을 제외하고 현재 연결되어 있는 모든 소켓(TCP/UDP/Unix)을 표시.

ss는 다양한 옵션을 제공한다. 자주 사용되는 옵션은 다음과 같다.

ss [options] [ filters ]

Option	Description
a	전체 포트 보기 ( listening socket 포함 )
t	TCP 포트 보기
u	UDP 포트 보기
x	유닉스 포트 보기
l	Listening 상태의 포트 보기
p	프로세스명 표시하기
n	출력화면의 호스트명, 포트 사용자명 보기

Filter	Description
sport	송신 포트 번호 또는 프로토콜 명
dport	수신 포트 번호 또는 프로토콜 명

ss 명령어의 출력은 다양한 열과 행으로 구성되어 있다.

주요 열에는 "State" (상태), "Recv-Q" (수신 큐), "Send-Q" (송신 큐), "Local Address" (로컬 주소), "Foreign Address" (원격 주소), "PID/Program name" (프로세스 ID/프로그램 이름) 등이 포함

State : 소켓의 현재 상태. 여기에는 "ESTAB" (연결), "TIME-WAIT"(연결 종료 후 대기) 등이 있음.
Recv-Q : 수신 대기 큐의 크기, 이 값이 0이면 현재 데이터를 받고 있지 않음을 의미.수신 대기 큐에 있는 패킷들은 아직 응용프로그램에 의해 처리되지 않고 대기 중인 상태
Send-Q : 송신 대기 큐의 크기, 이 값이 0이면 현재 데이터를 보내고 있지 않음을 의미. 데이터를 네트워크로 보내기 위해 대기하는 데이터의 양
Local Address : 로컬 주소와 포트 번호
Peer Address : 원격 주소와 포트 번호

Recv-Q, Send-Q의 값이 점차 증가 한다면 해당 소켓에 대한 처리가 따라오지 못하거나 병목현상이 발생되고 있을 수 있고 이는 네트워크 대역폭의 이유 또는 응용프로그램 수신 부문에서 병목이 발생하고 있음을 뜻함.

nstat -az TcpExtTCPRcvCollapsed TcpExtRcvPruned

- nstat 유틸리티를 이용하여 TcpExtTCPRcvCollapsed 및 TcpExtRcvPruned 카운트를 조회

이 후 잠시 기다렸다가 다시 실행하였을 때, 카운터 값이 첫 번째 실행에 비해 증가한 경우 튜닝이 필요

위 명령어들을 통해 socket buffer

마지막으로 데몬 형태로 주기적으로 네트워크 상태를 체크하여 파일로 적재하는 예제 명령어

nohup bash -c 'while true; do echo -e "$(date)\n$(ss -ntl | grep -e "12000" -e "Send-Q")\n" >> output.log; sleep 10; done' > /dev/null 2>&1 &

[Java] Time Orderd UUID

예은파파 — Wed, 23 Feb 2022 15:59:14 +0900

UUID를 Primary Key로 썼을 경우

MariaDB InnoDB 테이블의 Primary Key는 Clustered 인덱스로 물리적으로 순서대로 유지가 가능
UUID의 값은 unique하긴 하나 랜덤하게 발생되는 값으로, Primary Key 컬럼일 경우 Clustered Index로 재배열하게 되어, InnoDB 스트로지 엔진의 부하가 발생.

해결방안

UUID를 랜덤하게 생성하되 이 값을 sequencial 하게 생성하여, DB 입장에서 새로운 데이터가 들어오더라도 indexing으로 인해 드는 리소스가 랜덤값보다 현저히 감소.
Java UUID Generator (JUG) Library 사용 ( 아래 dependecy 추가 )

<dependency>
	<groupId>com.fasterxml.uuid</groupId>
	<artifactId>java-uuid-generator</artifactId>
	<version>4.0.1</version>
</dependency>

TimeBasedGenerator gen = Generators.timeBasedGenerator(EthernetAddress.fromInterface());
UUID uuid = gen.generate();
UUID anotherUuid = gen.generate();
		
System.out.println( uuid );
System.out.println( anotherUuid );

----------------------------------------------------------------------------------------------
결과 
d8a551a6-9475-11ec-8083-00d86126fd1a
d8a551a7-9475-11ec-8083-00d86126fd1a

/dev/null 2>&1 와 nohup, & 의미

예은파파 — Wed, 25 Aug 2021 14:05:41 +0900

shell(#mode)에서 간단하게 명령어를 통해 테스트를 진행하면서 "/dev/null 2>&1"의 의미를 알아봅니다.

아래 명령어는 표준 출력을 /dev/null로 redirection 하라는 의미로 표준출력을 버리라는 의미입니다.

$ rm test > /dev/null

하지만, test라는 file이 존재하지 않는 경우 아래와 같은 표준에러가 출력됩니다.

$ rm test > /dev/null
rm: cannot remove 'test': No such file or directory

방금 언급했지만, 이것은 "표준출력"이 아닌 "표준에러"이기 때문에 화면에 출력이 된것입니다.
다시 강조하면 위에 예제는 /dev/null 로 redirection 을 통해 화면 출력을 하지 않는것은 표준출력에 한해서 해당됩니다.

자 그렇다면, 표준에러를 버리고 싶다면 아래와 같이 사용하도록 합시다,

$ rm test > /dev/null 2>&1

2>&1 는 표준에러를 표준출력으로 redirection 하라는 의미입니다.

0 : 표준입력
1 : 표준출력
2 : 표준에러

정리하면 "rm test"의 표준출력을 /dev/null로 버리는데, 표준에러는 표준출력으로 redirection 합니다.
결국 결과는 표준출력이 되기 때문에 /dev/null로 버려지고, 화면에 결과가 뿌려지지 않게 되는 것입니다.

/dev/null과 2>&1를 같이 사용하지 않는 경우 위의 예제는 결국 표준출력되기 때문에 화면에 에러 내용이 출력됩니다.

한편 표준출력과 표준에러를 분리해서 파일로 저장하고 싶을 때는 아래와 같은 형식을 사용할 수 있습니다.

$ foo.sh 1>output.log 2>error.log

-----------------------------------------------------------------------------------------------------------------------------------

nohup이란? 리눅스, 유닉스에서 쉘스크립트 파일( *.sh)을 데몬 형태로 실행시키는 프로그램

터미널 세션이 끊겨도 실행을 멈추지 않고 동작하도록 함.

& 이란? 프로세스를 실행할 때 백그라운드에서 동작하도록 만드는 명령어

nohup으로 실행할 쉘 스크립트파일(*.sh)은 현재 퍼미션이 755 이상 상태여야 가능. ( e.g. chmod 755 shell.sh )

실행 방법

$ nohup shell.sh &
$ nohup -- ./shell.sh &

종료 방법

"ps -ef | grep #{shell스크립트 파일명}"
kill -9 #{shell pid}

출처사이트 : https://jybaek.tistory.com/115, https://brownbears.tistory.com/164

[Java] JMX를 통한 자원 모니터링

예은파파 — Fri, 11 Jun 2021 14:12:41 +0900

JMX 확장 라이브러리를 이용한 Jconsole, Jvisualvm 기반으로 서버 실시간 자원 모니터링.

( Thread dump도 지원한다. )

Java 실행하는 쉘 스크립트를 이용하여 JMX port 오픈하는 방법

DEBUG_OPT="-Dcom.sun.management.jmxremote -Dcohttp://m.sun.management.jmxremote.port= #{JMX PORT} -Dcohttp://m.sun.management.jmxremote.rmi.port= #{JMX PORT} -Dcohttp://m.sun.management.jmxremote.local.only=false -Dcom.sun.management.jmxremote.authenticate=false -Dcohttp://m.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=#{SERVER IP}"

C:\Program Files\Java\jdk1.8.0_201\bin\Jvisualvm.exe 실행

[Linux] TCPDUMP 사용법

예은파파 — Sat, 6 Feb 2021 22:35:39 +0900

LINUX TCPDUMP 사용법

TCPDUMP는 주어진 조건식을 만족하는 네트워크 인터페이스를 거치는 패킷들의 헤더를 출력해 주는 유틸

( 설치되어 있지 않을 경우, yum install tcpdump 명령어를 이용하여 설치 )

명령어 : tcpdump [option] [expression] [host]

( tcpdump -i any -w test.pcap -C 16 -s 1500 -z root port 11200

Option

-i device : 어느 인터페이스를 경유하는 패킷들을 잡을지 지정한다.
지정되지 않으면 시스템의 인터페이스 리스트를 확인하여 가장 낮은 번호를 가진 인터페이스를 선택
( loopback은 제외 )
-w : capture packet을 분석하여 출력하는 대신에 파일로 저장한다.
-c number : 입력한 수의 패킷을 받은 후 종료한다. ( capture할 갯 수 )
-s length : 패킷들로부터 추출하는 샘플을 default 값인 68 byte외의 값으로 설정할 때 사용.

https://dany-it.tistory.com/100

[Network] WireShark 필터 명령어 방법

예은파파 — Sat, 6 Feb 2021 21:40:01 +0900

WireShark 필터 주요 기능

이더넷 통신 모듈간 문제가 발생 했을 경우, 어떠한 에러가 발생하고 있으며, 클라이언트 / 서버 간 잘못된 동작을 파악하기 위함

1. MAC ID 필터링

- Source & Destination둘다 : eth.addr = 00:12:34:56:78:9A

- Source : eth.src == 00:12:34:56:78:9A

- Destination: eth.dst == 00:12:34:56:78:9A

2. IP 필터링

- Source & Destination 둘다 : ip.addr == 13.107.4.50

- Source : ip.src == 13.107.4.50

- Destination : ip.dst == 13.107.4.50

3. PORT 필터링 (TCP,UDP 동일)

- Source & Destination 둘다 : tcp.port == 8443

- Source : tcp.srcport == 8443

- Destination : tcp.dstport == 8443

4. 명령어 혼합 사용

ex) IP가 13.107.4.50 이며 PORT가 8443인 경우

- ip.addr == 13.107.4.50 and tcp.port == 8443

- ip.addr == 192.168.2.100 and not tcp.port in {11200 8443}

ex) IP가 13.107.4.50 이거나, PORT가 8443인 경우

- ip.addr == 13.107.4.50 or tcp.port == 8443

[Java] 공개키(Public Key) 와 개인키(Priviate Key)

예은파파 — Thu, 10 Dec 2020 22:45:02 +0900

대칭키와 비대칭키란?

대칭키는 암호화 / 복호화 시에 사용하는 키가 동일한 방식으로 1개의 키만 사용한다.
전자문서(비밀편지)가 대칭키(열쇠)로 암호화 되면 똑같은 대칭키를 가지고 있는 상대방만이 이 전자문서를 복호화 할 수 있으며, 누군가가 암호화된 전자문서를 입수 하여도 이를 복호화하지 못하기 때문에 입수한 사람에게는 아무 의미가 없는 문서이다.

비대칭키는 사용하는 키와 복호화 할 때 사용하는 키가 다른 경우를 말한다. 타인에게 절대 노출되어서는 안되는 비밀키(개인키), 비밀키를 토대로 만든 공개키가 쌍을 이룬 형태이다. 2개의 키를 사용한다.
공개키 - 사람들에게 공개된 키이며 정보를 암호화 할 수 있다.
비밀키 - 사용자만 알고 있는 암호를 풀 수 있는 키

Java RSA 암호화/복호화 Util 구현

public class RSAUtil {

    /**
     * 1024비트 RSA 키쌍을 생성
     */
    public static KeyPair genRSAKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");
        gen.initialize(1024, new SecureRandom());
        return gen.genKeyPair();
    }

    /**
     * Public Key로 RSA 암호화를 수행
     */
    public static String encryptRSA(String plainText, PublicKey publicKey)
            throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException,
            BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        byte[] bytePlain = cipher.doFinal(plainText.getBytes());
        return Base64.getEncoder().encodeToString(bytePlain);
    }

    /**
     * Private Key로 RSA 복호화를 수행
     */
    public static String decryptRSA(String encrypted, PrivateKey privateKey)
            throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException,
            BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException {
        Cipher cipher = Cipher.getInstance("RSA");
        byte[] byteEncrypted = Base64.getDecoder().decode(encrypted.getBytes());

        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytePlain = cipher.doFinal(byteEncrypted);
        return new String(bytePlain, "utf-8");
    }

    public static PublicKey getPublicKeyFromBase64Encrypted(String base64PublicKey)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] decodedBase64PubKey = Base64.getDecoder().decode(base64PublicKey);

        return KeyFactory.getInstance("RSA")
                .generatePublic(new X509EncodedKeySpec(decodedBase64PubKey));
    }

    public static PrivateKey getPrivateKeyFromBase64Encrypted(String base64PrivateKey)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] decodedBase64PrivateKey = Base64.getDecoder().decode(base64PrivateKey);

        return KeyFactory.getInstance("RSA")
                .generatePrivate(new PKCS8EncodedKeySpec(decodedBase64PrivateKey));
    }
}

Java RSA Util을 이용한 Test Client

public class RSAUtilTest {

    public static void main(String[] args) throws Exception {
		
        // RSA 키쌍을 생성
        KeyPair keyPair = RSAUtil.genRSAKeyPair();

        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        String plainText = "RSA Encryption test";

        // Base64 인코딩된 암호화 문자열
        String encrypted = RSAUtil.encryptRSA(plainText, publicKey);

        // 복호화
        String decrypted = RSAUtil.decryptRSA(encrypted, privateKey);

        // 공개키를 Base64 인코딩한 문자일을 만듦
        byte[] bytePublicKey = publicKey.getEncoded();
        String base64PublicKey = Base64.getEncoder().encodeToString(bytePublicKey);

        // 개인키를 Base64 인코딩한 문자열을 만듦
        byte[] bytePrivateKey = privateKey.getEncoded();
        String base64PrivateKey = Base64.getEncoder().encodeToString(bytePrivateKey);

        // base64 암호화한 String 에서 Public Key 를 다시생성한후 암호화 테스트를 진행
        PublicKey rePublicKey = RSAUtil.getPublicKeyFromBase64Encrypted(base64PublicKey);
        String encryptedRe = RSAUtil.encryptRSA(plainText, rePublicKey);
        String decryptedRe = RSAUtil.decryptRSA(encryptedRe, privateKey);

        // base64 암호화한 String 에서 Private Key 를 다시생성한후 복호화 테스트를 진행
        PrivateKey privateKeyRe = RSAUtil.getPrivateKeyFromBase64Encrypted(base64PrivateKey);
        String decryptedReRe = RSAUtil.decryptRSA(encryptedRe, privateKeyRe);
	        
    }
}

[Java] 암호 알고리즘 / 운용 모드 / Padding

예은파파 — Sat, 28 Nov 2020 15:50:46 +0900

암호 알고리즘

자바에서는 대칭키 알고리즘을 사용하여 데이터를 암호화/복호화 시에 javax.crypto.Cipher 클래스를 사용한다,
클래스의 인스턴스는 정적 메서드인 Cipher.getInstance() 를 호출하여 생성할 수 있는데, 이 때 호출 시 사용할 알고리즘, 운용 모드, 패딩 방식을 인자 값으로 넘겨줘야 한다.

혼돈과 확산을 달성하기 위해 Substitution 과 Permutation을 이용한다. Subsititution은 문자를 다른 문자로 바꾸는 것이고, Permutation은 문자들의 순서를 바꾸는 것이다. Substituition과 Permutation을 한번 수행하는 것이 암호 알고리즘의 기본 수행 단위 이다. 암호문은 이를 여러번 수행할수록 안전하다. Substitution-Permutation을 연속으로 수행하도록 이어 놓은 것을 SPN(Subsititution Permutation Network)이라고 한다.

SPN을 이용하는 대표적인 암호 알고리즘으로 AES가 있다. SPN을 이용하는 알고리즘은 보통 데이터를 블록 단위로 처리한다. AES의 경우 블록의 크기는 128비트(16바이트)이다. 그런데 모든 데이터가 16바이트 크기를 가질 수 없으므로, 데이터를 블록 단위로 나누어 처리하고 합치는 과정이 필요하다.

운용 모드

데이터를 블록으로 나누어 처리하고 합치는 것, 이것이 암호화해서 운용 모드가 하는 역할이다. 대표적인 운용 모드로는 ECB(Electronic Code Book) 와 CBC(Cipher Block Chaining)가 있다.

- ECB(Electronic Code Book)

Electronic Code Book

ECB는 단순히 블록 단위로 처리한 결과를 이어 붙이는 방식으로 같은 값을 갖는 원문 블록은 같은 암호 블록을 출력하기 때문에 원문의 패턴이 그대로 드러난다, 이는 암호문에서 원문을 유추할 수 있음을 의미하기 때문에 ECB는 확산의 성질을 달성하지 못한다고 볼 수 있다.

- CBC(Cipher Block Chaining)

Cipher Block Chaining

CBC는 원문 블록을 그대로 암호화하지 않고, 직전에 암호화된 블록과 XOR 연산을 한 다음에 암호화를 수행한다. 그렇기 때문에 같은 내용을 갖는 원문 블록이라도 전혀 다른 암호문을 갖게 된다. 그런데 첫번째 블록은 직전 암호문이 없으므로 XOR 연산 대상이 없다. 이를 위해 CBC모드는 초기화 백터(Initialization Vector)를 입력 받는다. 초기화 벡터는 원문 블록을 XOR하는데 쓰이기 때문에 당연히 블록 사이즈와 동일한 크기여야 한다.

CBC모드는 직전 블록이 다음 블록의 암호화에 관여하므로 일부 블록만 복호화하고 싶어도 전체를 복호화해야 한다.

반면 ECB는 전체를 복호화 하지 않고 일부만 복호화하는 것이 가능하다.

패딩(Padding)

AES와 같은 16바이트 크기의 블록 암호 알고리즘을 사용하는데 원문의 크기가 16바이트의 배수가 아닐 경우, 마지막 블록은 16바이트보다 작은 크기가 된다. 이 때 마지막 블록의 빈 부분을 채워주는 방식을 패딩이라고 한다. 가장 유명한 패딩 방식인 PKCS5 / PKCS7이 있다.

특정 암호화 알고리즘에서는(AES,DES 등) 입력문자열이 특정 바이트의 배수가 되어야 하는 상황에 Padding을 사용.

블럭사이즈가 8바이트로 설정해 놓은 상태에서 5바이트의 평문이 입력될 경우,

[AA A1 A2 A3 A4 _ _ _] 이런식으로 블럭이 채워지게 되는데, 블럭사이즈인 8바이트 3바이트가 모자란 상태 패딩을 수행하게되면 [AA A1 A2 A3 A4 03 03 03] 모자란 바이트의 수로 채워주게 된다. 이러한 방식을 PKCS 방식이라고 한다.

참고 링크

http://happinessoncode.com/2019/04/06/java-cipher-algorithm-mode-padding/

Java Cipher - 알고리즘, 운용 모드, 패딩의 이해

자바에서는 대칭키 알고리즘을 사용하여 데이터를 암호화/복호화할 때 javax.crypto.Cipher 클래스를 사용한다. 이 클래스의 인스턴스는 정적 메서드인 Cipher.getInstance()를 호출하여 가져올 수 있는데,

happinessoncode.com

[Design Pattern] Chain of Responsibility Pattern

예은파파 — Mon, 23 Nov 2020 23:05:57 +0900

책임 연쇄 패턴( Chain of Responsibility Pattern )

명령 객체와 일련의 처리 객체를 포함하는 패턴
각각의 처리 객체는 명령 객체를 처리할 수 있는 연산의 집합이며 체인 안의 처리 객체가 핸들링 할 수 없는 명령은 다음 처리 객체로 넘겨진다.
체인에 들어가는 객체를 바꾸거나 순서를 바꿈으로서 역할을 동적으로 추가/제거 및 상황에 따라 동적으로 핸들러를 추가하거나 제거 할 수 있으며 이러한 변화가 전체 구조에 아무런 영향을 주지 않도록 클래스들 간의 낮은 결합도로 구현되어있다.
명령에 대한 처리가 반드시 수행된다는 보장이 안되므로 반드시 명령이 처리 될 수 있도록 적절한 체인의 순서 구현 필요

Chain of Responsibility 클래스 구조

※ Sample Code

public abstract class Middleware {

    private Middleware next; 
	
    /**
     * Builds chains of middleware objects.
     */
    public Middleware linkWith(Middleware next) {
    	
        this.next = next;
        return next;
    }

    /**
     * Subclasses will implement this method with concrete checks.
     */
    public abstract boolean check(String email, String password);

    /**
     * Runs check on the next object in chain or ends traversing if we're in
     * last object in chain.
     */
    protected boolean checkNext(String email, String password) {
    	
        if (next == null) {
            return true;
        }
        
        return next.check(email, password);
    }
}

▲ 추상클래스 선언 ( java 8 이상부터는 interface의 default method로 구현해도 될 듯 하다. )

public class ThrottlingMiddleware extends Middleware {

    private int requestPerMinute;
    private int request;
    private long currentTime;

    public ThrottlingMiddleware( int requestPerMinute ) {
    	
        this.requestPerMinute = requestPerMinute;
        this.currentTime = System.currentTimeMillis();
    }

    /**
     * Please, not that checkNext() call can be inserted both in the beginning
     * of this method and in the end.
     *
     * This gives much more flexibility than a simple loop over all middleware
     * objects. For instance, an element of a chain can change the order of
     * checks by running its check after all other checks.
     */
    @Override
    public boolean check(String email, String password) {
    	
        if (System.currentTimeMillis() > currentTime + 60_000) {
        	
            request = 0;
            currentTime = System.currentTimeMillis();
        }

        request++;
        
        if (request > requestPerMinute) {
        	
            System.out.println("Request limit exceeded!");
            Thread.currentThread().stop();
        }
        
        return checkNext(email, password);
    }
}

public class UserExistsMiddleware extends Middleware {

    private Server server;

    public UserExistsMiddleware(Server server) {
    	
        this.server = server;
    }

    @Override
    public boolean check(String email, String password) {
    	
        if (!server.hasEmail(email)) {
            System.out.println("This email is not registered!");
            return false;
        }
        
        if (!server.isValidPassword(email, password)) {
            System.out.println("Wrong password!");
            return false;
        }
        
        return checkNext(email, password);
    }
}

▲ 사용자가 입력한 email / passowrd의 인증 프로세스

public class RoleCheckMiddleware extends Middleware {

    @Override
    public boolean check(String email, String password) {
		
        if (email.equals("admin@example.com")) {
            System.out.println("Hello, admin!");
            return true;
        }
        
        System.out.println("Hello, user!");
        return checkNext(email, password);
    }
}

▲ 사용자 인증이 끝난 뒤 역할 확인 프로세스

public class Server {

    private Map<String, String> users = new HashMap<>();
    private Middleware middleware;

    /**
     * Client passes a chain of object to server. This improves flexibility and
     * makes testing the server class easier.
     */
    public void setMiddleware(Middleware middleware) {
    
        this.middleware = middleware;
    }

    /**
     * Server gets email and password from client and sends the authorization
     * request to the chain.
     */
    public boolean logIn(String email, String password) {
    
        if (middleware.check(email, password)) {
            System.out.println("Authorization have been successful!");

            // Do something useful here for authorized users.

            return true;
        }
        return false;
    }

    public void register(String email, String password) {
    
        users.put(email, password);
    }

    public boolean hasEmail(String email) {
        return users.containsKey(email);
    }

    public boolean isValidPassword(String email, String password) {
        return users.get(email).equals(password);
    }
}

▲ 사용자의 로그인 정보를 가지고 있는 클래스

public class Client {

	private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
	private static Server server;

	private static void init() {
		
		server = new Server();
		server.register("admin@example.com", "admin_pass");
		server.register("user@example.com", "user_pass");

		// All checks are linked. Client can build various chains using the same
		// components.
		Middleware middleware = new ThrottlingMiddleware(2);
		middleware.linkWith(new UserExistsMiddleware(server)).linkWith(new RoleCheckMiddleware());

		// Server gets a chain from client code.
		server.setMiddleware(middleware);
	}

	public static void main(String[] args) throws IOException {
		
		init();

		boolean success;
		
		do {
			
			System.out.print("Enter email: ");
			String email = reader.readLine();
			System.out.print("Input password: ");
			String password = reader.readLine();
			success = server.logIn(email, password);
			
		} while (!success);
	}
}

▶ 실행 결과