izbean Dev Story

[Netty] EchoServer, EchoClient 생성해보기

2021-11-25T00:00:00+00:00

1. 들어가며

이번에는 이전 Netty로 DiscardServer 를 작성 해본것에 조금 더 응용하여 EchoServer와 EchoClient를 구현 해보겠습니다.

2. EchoServer

package echo;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class EchoServer {

    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);                        // [1]
        EventLoopGroup workerGroup = new NioEventLoopGroup();                                  // [2]

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {        // [3]
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new EchoServerHandler());
                        }
                    });

            ChannelFuture future = bootstrap.bind(8888);                             // [4]
            future.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

}

[1]: 실제 요청만 받아줄 EventLoopGroup 1개를 선언해줍니다.

[2]: bossGroup에서 요청 받은 것을 처리해 주는 workerGroup을 선언해줍니다. NioEventLoopGroup을 객체 생성 할때 아무 값도 넣지 않는경우. NettyRuntime.*availableProcessors*() * 2) 의 갯수로 스레드가 생성이 됩니다.

[3]: workerGroup에 Channel이 초기화 될 경우 EchoServerHandler라는 Class를 생성하며 Channel의 Pipeline에 추가합니다.

[4]: 8888 포트로 Socket 접속 할 수 있도록, ServerBootstarp에 포트를 바인딩 시켜줍니다.

3. EchoServerHandler

package echo;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;

public class EchoServerHandler extends SimpleChannelInboundHandler<Object> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        String clientMessage = ((ByteBuf) msg).retain().toString(Charset.defaultCharset());         // [1]
        System.out.printf("클라이언트 메세지: %s%n", clientMessage);

        ctx.writeAndFlush(msg);                                                                     // [2]
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

[1]: EchoClient에서 수신받은 ByteBuf의 사용 횟수를 retain메서드를 통하여 1번더 증가시켜줍니다.

[2]: EchoClient에서 수신받은 메세지를 그대로 다시 전달 해줍니다.

ChannelRead0 Method의 경우 채널에 입력이 들어 왔을때 수행되는 메서드 입니다.

4. EchoClient

package echo;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class EchoClient {

    public static void main(String[] args) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();                                          // [1]
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new EchoClientHandler());                      // [2]
                        }
                    });

            ChannelFuture future = bootstrap.connect("localhost" , 8888).sync ();       // [3]
            future.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }

[1]: SocketClient측에선 ServerBootstrap객체가 아닌, Bootstrap객체로 소켓 서버에 접근 해야 합니다.

[2]: EchoClient의 Channel이 초기화 되었을때 Handler를 Pipeline에 추가해 줍니다.

[3]: EchoServer의 접속 정보를 EchoClient를 실행할때 Connect 할 수 있도록 접속 정보를 입력해줍니다.

5. EchoClientHandler

package echo;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

public class EchoClientHandler extends SimpleChannelInboundHandler<Object> {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {                // [1]
        String message = "Echo";
        ByteBuf byteBuf = Unpooled.buffer();
        byteBuf.writeBytes(message.getBytes(StandardCharsets.UTF_8));
        ctx.writeAndFlush(byteBuf);                                                        
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        String serverMessage = ((ByteBuf) msg).toString(Charset.defaultCharset());
        System.out.println(serverMessage);                                                 // [2]
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {          // [3]
        System.out.println("클라이언트를 종료할게요.");
        ctx.close();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}

[1]: EchoClient의 Channel이 활성화 되었을때 Echo라는 메세지를 ByteBuf에 담아서 EchoServer로 전달 시킵니다.

[2]: EchoServer에서 전달받은 메세지를 system.out.println으로 콘솔에 출력합니다.

[3]: channelRead0 메서드 실행 후 실행 되는 이벤트이며 종료 안내 메세지를 띄우고 Channel을 종료시킵니다.

6. 실행 결과

EchoServer

EchoClient

7. 마치며

이번에는 EchoServer, EchoClient를 작성하여 실행해보았는데요, 다음 글엔 왜 ByteBuf를 사용하는지 channelActive, channelRead0 등의 이벤트가 발생하는 시점이 언제인지, Netty 아키텍쳐를 웹 채팅을 구현하며 같이 다른 게시글로 작성 해 보겠습니다.

[Netty] Discard 서버 생성해보기

2021-11-24T00:00:00+00:00

💡 작성자는 모든 과정을 IntelliJ 로 진행 하였습니다.

1. Project 생성하기

빌드 도구 설정

New Project → Gradle 선택 → SDK와 사용 언어 선택 후 Next를 눌러주세요.

💡 꼭 Gradle로 선택 하지 않아도 되고, Java나 Maven을 사용 하셔도 됩니다.

프로젝트 명 설정

Project Name을 설정 해주고 Finish를 눌러주세요.

Netty 패키지 의존성 추가

아래 링크에 접속해서 패키지 확인 후 build.gradle에서 implementation 시켜주세요.

https://mvnrepository.com/artifact/io.netty/netty-all

2. DiscardServer 클래스 생성하기

package discard;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class DiscardServer {

    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception { // [4]
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new DiscardServerHandler());
                        }
                    });

            ChannelFuture future = serverBootstrap.bind(8888);
            future.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}

3. DiscardServerHandler 클래스 생성하기

package ex1.discard;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class DiscardServerHandler extends SimpleChannelInboundHandler<Object> {

    @Override
    public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
				// 아무 행동도 하지 않음.
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

4. 연결 해보기

5. 마치며

이번엔 단순히 SocketServer를 오픈 했지만 그 외 특별한 동작은 없는 DiscardServer에 대해 작성을 해보았고, 다음번엔 EchoServer, EchoClient에 대해서 작성해보겠습니다.

EntityManagerFactory 와 EntityManager

2021-11-15T00:00:00+00:00

EntityManagerFactory

EntityManager를 생성하는 Class다. Thread-safe 하며 생성 비용이 많이 들기 때문에, 보통 DB 하나당 하나의 EntityManagerFactory를 생성한다.

EntityManagerFactory factory = Persistence.createEntityManagerFactory("jdbcName");

EntityManager

Entity 들을 영속성 컨텍스트에 두어 관리하는 Class이다.

Entitymanager entityManager = factory.createEntityManager();

영속성 컨텍스트(Persistence Context)

간략하게 말해 Entity 를 영구히 저장하는 환경이다. EntityManager가 닫히거나, 초기화 되기 전까지 영속된 Entity를 관리한다.

entityManager.persist(entity);

persist 메서드를 통해 EntityManager에 entity를 영속 시키게 되면, 그때부터 EntityManager가 영속 시킨 Entity 를 관리한다.

1차 캐시

Map<Key, Value>로 1차 캐시에 저장 된다.
- Key: @Id로 선언한 필드 값(PK)
- Value: 해당 Id에 해당하는 Entity
entityManager.find()를 하면 1차 캐시를 먼저 조회한다.
해당 Entity가 1차 캐시에 존재 하다면 바로 반환한다. 없을 경우 DB에서 조회해서 1차 캐시에 저장한다.

동일성 보장

영속 Entity를 “==” 연산자로 비교 했을때 true임을 보장한다.

쓰기 지연

한번의 EntityTransaction을 Commit 할때 쓰기 지연 SQL 저장소의 SQL들을 한번에 DB에 보낸다.
flush를 통해 쓰기 지연 저장소에 있는 SQL들을 DB로 날릴 수 있다.

변경 감지

Post post = entityManager.find(Post.class, "post1");

post.setTitle("제목수정");
post.setContents("컨텐츠수정");

post.commit();

가져온 Entity의 정보와 캐시 되어 있는 Entity의 상태와 비교하여 다르다면 Update 쿼리 수행

Entity Life Cycle

비 영속

Entity 객체를 생성 했지만, 영속 시키지 않은 상태.

// Bulider 패턴 객체 생성 예제.
Post post = Post.builder().title("제목").contents("내용").build();

영속

EntityManager를 통해서 영속성 컨텍스트에 저장한 상태.

entityManager.persist(post);

transaction commit 시점에 영속성 컨텍스트에 저장된 정보들이 DB로 전송된다.

준영속

영속성 컨텍스트 1차 캐시에서 제거 되고 쓰기 지연 SQL 저장소에 있던 해당 Entity 관련 SQL이 모두 제거 된다.

entityManager.detach(post);
entityManager.close();
entityManager.clear();

detach: Entity를 준 영속 상태로 변경.
clear: 영속성 컨텍스트에 담겨져 있는 모든 것을 초기화 한다.
close: 영속성 컨텍스트 종료.

삭제

Entity 를 영속성 컨텍스트와 데이터베이스에서 삭제한다.

entityManager.remove(post);

@Transactional?

2021-11-12T00:00:00+00:00

Spring에서 isolation level, 특정 Exception 발생시 Rollback, propagation, readonly 같은 Transaction 단위의 속성에 대해 설정 할 수 있는 annotation 이다.

Transaction?

사전적 의미로 데이터베이스의 상태 변화를 의미하는 말이다,

Transaction은 기본적으로 아래의 4가지 속성을 가지고 있다.

원자성: 한 Transaction 내에 실행한 작업들은 하나의 단위로 처리한다.
일관성: 일관성 있는 데이터 베이스 상태를 유지한다.
격리성: 동시에 실행되는 Transaction 이 서로에게 영향을 못 미치도록 격리 수준을 설정 해야 한다.
영속성: Transaction이 정상 처리 되었다면 결과가 항상 저장 되어야 한다.

Transaction Object

Spring Framework에서는 Transaction 객체를 통해 begin, commit을 자동 수행 해주고 unchecked Exception 발생 시 해당 Transaction의 Rollback을 지원해준다.

Transaction 객체 속성

Spring Framework를 사용하면 Transaction 객체의 begin, commit을 자동 수행 해준다.

@Transactional annotation을 사용하여 Transaction 단위를 관리 할 수 있다. 해당 annotation에는 아래 다섯가지 속성을 설정 할 수 있다.

isolation
propagation
noRollbackFor
rollbackFor
readOnly

1. isolation

@Transaction(isolation=Isolation.{속성})
public void transaction(TransactionRequestDto transaction) {
		// business logic.
}

속성
- DEFAULT
  
  현재 Service DB Connection에 설정 되어 있는 DB Isolation level을 설정한다.
- READ_UNCOMMITED
  - level 0
  - Commit 되지 않은 데이터에 대해 읽기 허용
  문제점: Dirty Read
- READ_COMMITED
  - level 1
  - Commit 된 데이터에 대해 읽기 허용
  문제점: Unrepeatable Read
- REPEATEABLE_READ
  - level 2
  - Transaction 내에서 다른 Transaction이 데이터를 변경(수정) 하더라도, Transaction 시작 시점의 데이터를 보여준다.
  문제점: Phantom Read
- SERIALIZABLE
  - level 3
  - 선행 Transaction이 테이블을 읽은 경우 다른 Transaction이 데이터 변경, 삭제, 추가 작업을 하지 못하게 막는다.
문제점
- Dirty Read
  
  Transaction 1이 수정 중인 데이터를 Transaction 2에서 접근 할 수 있다. 만약 Transaction 1에서 작업이 실패하여 Rollback 되었다면 Transaction 2의 데이터는 잘못된 데이터라고 볼 수 있다.
- Unrepeatable Read
  
  Transaction 2가 반복 조회 중에 Transaction 1이 정보를 수정하고 Commit 한다면, Transaction 2가 조회 했을 때 수정 된 데이터가 조회 된다.
- Phantom Read
  
  Transaction 2가 반복 조회 중에 Transaction 1이 정보를 수정하고 Commit 하여도 Transaction 2가 조회 되는 데이터는 Transaction 발생 시점 데이터와 동일하지만 실제 데이터와 다른 결과가 조회 될 수 있다.
Transaction 격리 수준의 필요성

레벨이 높을수록 무결성을 유지 할 수 있지만, 무조건 적 상위 레벨 사용 시 데이터 Lock 으로 인해 Transaction이 순차적으로 처리 되며 성능 저하를 일으킬 수 있다. 그렇다고 해서 무조건 적 하위 레벨 사용 시 잘못된 값을 조회하거나 처리 할 여지가 있다. 따라서 서비스 의도에 따라 효율적인 방법을 찾아 상황에 맞게 사용하자.

2. propagation

@Transaction(propagation=Propagation.{속성})
public void transaction(TransactionRequestDto transaction) {
		// business logic.
}

속성
- REQUIRED(Default)
  
  이미 진행 중인 Transaction이 있다면 해당 Transaction 속성을 따르고, 없다면 새로운 Transaction을 생성한다.
- REQUIRES_NEW
  
  항상 새로운 Transaction 을 생성한다. 이미 진행 중인 Transaction이 있다면 잠깐 보류 한 뒤 생성 한 Transaction 을 먼저 진행한다.
- SUPPORT
  
  이미 진행 중인 Transaction이 있다면 해당 Transaction 속성을 따르고, 없다면 새로운 Transaction을 생성하지 않는다.
- NOT_SUPPORT
  
  이미 진행 중인 Transaction이 있다면 잠깐 보류 한 뒤, Transaction 없이 작업을 수행 한다.
- MANDATORY
  
  이미 진행 중인 Transaction이 있어야 작업을 수행하고 없다면 Exception 을 발생 시킨다.
- NEVER
  
  Transaction 이 진행 중이지 않을 때 작업을 수행한다. Transaction 이 있다면 Exception 을 발생 시킨다.
- NESTED
  
  진행 중인 Transaction이 있다면 중첩되어 새로운 Transaction이 실행 되며, 존재하지 않으면 REQUIRED와 동일하게 수행 된다.

3. noRollbackFor

@Transaction(noRollbackFor={class}.class)
public void transaction(TransactionRequestDto transaction) {
		// business logic.
}

noRollbackFor 속성에 설정 된 Exception 일 경우 Exception 발생 시에도 Rollback하지 않음.

4. rollbackFor

@Transaction(rollbackFor={class}.class)
public void transaction(TransactionRequestDto transaction) {
		// business logic.
}

rollbackFor 속성에 설정 된 Exception 일 경우 Checked Exception 이어도 Rollback을 진행한다.

5. timeout

@Transaction(timeout={second})
public void transaction(TransactionRequestDto transaction) {
		// business logic.
}

지정된 초 단위 내에 Transaction이 수행 되지 않을 경우 rollback 한다.

Default 값인 -1 일 경우 no timeout

6. readOnly

@Transaction(readOnly={true, false})
public void transaction(TransactionRequestDto transaction) {
		// business logic.
}

값이 true일 때 INSERT, UPDATE, DELETE 요청일 경우 Exception을 발생 시킨다.

사용 이유
- 해당 설정을 사용하면 데이터에 Lock을 적용 할 필요가 없고 접근 할 수 있는 데이터가 변경 되지 않기 때문에, 일관적인 데이터를 가져올 수 있다.
- Transaction ID를 부여하지 않기 때문에 ID 설정에 대한 오버헤드가 발생 하지 않기 때문에 성능의 이점을 볼 수 있다.