DEV Community: NeNoVen

oauth-authorization-server

NeNoVen — Wed, 29 Nov 2023 00:10:20 +0000

1. api-client , resource server

https://www.baeldung.com/spring-security-oauth-auth-server

baeldung gihub

https://github.com/Baeldung/spring-security-oauth/tree/master/oauth-authorization-server

2. api-client server 소스분석

2.1 yml 설정

server:
  port: 8080

spring:
  security:
    oauth2:
      client:
        registration:
          articles-client-oidc: #클라이언트 인증
            provider: spring
            client-id: articles-client
            client-secret: secret
            authorization-grant-type: authorization_code
            redirect-uri: "http://127.0.0.1:8080/login/oauth2/code/{registrationId}"
            scope: openid
            client-name: articles-client-oidc
          articles-client-authorization-code: #클라이언트 코드로 액세스 토큰 요청시 사용
            provider: spring
            client-id: articles-client
            client-secret: secret
            authorization-grant-type: authorization_code
            redirect-uri: "http://127.0.0.1:8080/authorized"
            scope: articles.read
            client-name: articles-client-authorization-code
        provider:
          spring:
            issuer-uri: http://auth-server:9000

2.1.1 요청 응답 흐름 (시퀀스)

사용자 로그인 요청: 사용자가 애플리케이션에 로그인을 시도합니다.
리다이렉션: 클라이언트 애플리케이션은 사용자를 인증 서버의 로그인 페이지로 리다이렉션합니다. 이 때 client-id, redirect-uri, scope 등의 정보가 포함됩니다. 이 정보는 registration 섹션에서 정의됩니다.
사용자 인증: 사용자는 인증 서버에서 로그인을 진행합니다. 이 과정에서 issuer-uri (인증 서버 주소)가 사용됩니다.
인증 코드 발급: 로그인이 성공하면 인증 서버는 redirect-uri로 사용자를 다시 리다이렉션하며, 이 때 인증 코드를 함께 전달합니다.
인증 코드를 토큰으로 교환: 클라이언트 애플리케이션은 받은 인증 코드를 사용하여 인증 서버에 토큰을 요청합니다. 여기서 client-id 및 client-secret이 사용됩니다.
토큰 응답: 인증 서버는 클라이언트에게 액세스 토큰(및 필요시 리프레시 토큰)을 발급합니다.
리소스 서버 접근: 클라이언트는 받은 토큰을 사용하여 보호된 리소스에 액세스합니다. 예를 들어, scope: articles.read를 사용하여 특정 API에 접근할 수 있습니다.

2.1.2 설정 파일 내의 역할

client-id 및 client-secret: 클라이언트의 신원을 인증 서버에 증명하는데 사용됩니다.
redirect-uri: 사용자가 인증 후 리다이렉션될 URI입니다. 인증 코드를 받는 데 사용됩니다.
scope: 클라이언트가 요청할 수 있는 권한의 범위를 정의합니다.
issuer-uri: 인증 서버의 주소입니다. 사용자 인증 및 토큰 발급에 사용됩니다.

2.1.3 상세설명

articles-client-oidc: 최초 클라이언트 인증
- 이 설정은 사용자가 최초로 로그인할 때 사용됩니다.
- 사용자가 애플리케이션에 로그인을 요청하면, 애플리케이션은 사용자를 OAuth 2.0 인증 서버의 로그인 페이지로 리다이렉션합니다.
- articles-client-oidc 설정에 포함된 client-id, client-secret, redirect-uri, scope 등의 정보가 이 과정에서 사용됩니다.
- 사용자가 인증 서버에서 성공적으로 인증을 완료하면, 인증 서버는 redirect-uri로 사용자를 리디렉션하고 인증 코드를 제공합니다.
articles-client-authorization-code: 리소스 서버에 대한 요청
- 인증 코드를 받은 후, 애플리케이션은 이 코드를 사용하여 인증 서버에 액세스 토큰을 요청합니다. 이 때 articles-client-authorization-code 설정이 사용됩니다.
- client-id, client-secret는 이 과정에서 토큰 교환을 위해 사용되며, redirect-uri는 이전 단계에서 인증 코드를 받기 위해 사용된 주소입니다.
- 애플리케이션이 액세스 토큰을 받으면, 이 토큰을 사용하여 보호된 리소스에 접근할 수 있습니다. 이 경우 scope: articles.read에 따라 특정 리소스에 대한 액세스 권한이 부여됩니다.

요약하자면, articles-client-oidc 설정은 사용자 인증을 위한 초기 로그인 과정에 사용되며, articles-client-authorization-code 설정은 인증된 사용자가 보호된 리소스에 접근하기 위해 필요한 액세스 토큰을 얻는 과정에 사용

2.2 소스

@EnableWebSecurity
public class SecurityConfig {

    @Bean
    SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
          .authorizeRequests(authorizeRequests ->
            authorizeRequests.anyRequest().authenticated()
          )
          .oauth2Login(oauth2Login ->
            oauth2Login.loginPage("/oauth2/authorization/articles-client-oidc"))
          .oauth2Client(withDefaults());
        return http.build();
    }
}

oauth2Login.loginPage("/oauth2/authorization/articles-client-oidc"))

해당 페이지는 클라이언트 서버에서 제공되는 페이지이며, security5에 제공되는 페이지로 사용된거.

@RestController
public class ArticlesController {

    private WebClient webClient;

    @GetMapping(value = "/articles")
    public String[] getArticles(
      @RegisteredOAuth2AuthorizedClient("articles-client-authorization-code") OAuth2AuthorizedClient authorizedClient
    ) {
        return this.webClient
          .get()
          .uri("http://127.0.0.1:8090/articles")
          .attributes(oauth2AuthorizedClient(authorizedClient))
          .retrieve()
          .bodyToMono(String[].class)
          .block();
    }
}

OAuth2AuthorizedClient 클래스 형식의 요청에서 OAuth 인증 토큰을 가져옵니다 .

이는 적절한 식별과 함께 @RegisterdOAuth2AuthorizedClient 주석을 사용하여 Spring에 의해 자동으로 바인딩됩니다 . 우리의 경우 이전에 .yml 파일 에서 구성한 article-client-authorizaiton-code 에서 가져왔습니다

3. 테스트 호출

브라우저에서 호출 http://127.0.0.1:8080/articles

인증 url 로 리다이렉션 http://auth-server:9000/login

4. 리소스 서버

보안구성 - 인증서버 설정

인증서버에 설정한 ProviderSettings 값을 issuer-uri 로 설정

spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: http://auth-server:9000

웹보안 구성 설정 : 리소스에 대한 권한 설정( 읽기, 모든 요청에 대한 승인요청)

@EnableWebSecurity
public class ResourceServerConfig {

    @Bean
    SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.mvcMatcher("/articles/**")
          .authorizeRequests() //1.요청에 대한 인증을 시작합니다. 이 단계에서는 이후에 정의될 인증 규칙들이 적용됩니다
          .mvcMatchers("/articles/**")//2.특정 경로(/articles/**)에 대한 추가적인 규칙을 정의. 
                                                                            // 해당 경로에 대한 보안 규칙을 세분화
          .access("hasAuthority('SCOPE_articles.read')")//3./articles/** 경로에 대한 접근을 제어
                    // 'SCOPE_articles.read' 권한을 가지고 있어야만 해당 경로에 접근 가능
                    // 이 권한은 일반적으로 OAuth 2.0 토큰에 정의된 스코프에서 파생됩니다.
          .and()
          .oauth2ResourceServer() //3. OAuth 2.0 리소스 서버를 활성화하고 JWT (JSON Web Token)를 사용하여 인증을 수행
          .jwt(); //  들어오는 요청이 올바른 JWT를 포함하고 있는지 검증하여 해당 요청이 유효한지 확인
        return http.build();
    }
}

5. 인증서버

@Configuration
@Import(OAuth2AuthorizationServerConfiguration.class)
public class AuthorizationServerConfig {
    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
          .clientId("articles-client")
          .clientSecret("{noop}secret")
          .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
          .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
          .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
          .redirectUri("http://127.0.0.1:8080/login/oauth2/code/articles-client-oidc")
          .redirectUri("http://127.0.0.1:8080/authorized")
          .scope(OidcScopes.OPENID)
          .scope("articles.read")
          .build();
        return new InMemoryRegisteredClientRepository(registeredClient);
    }
}

RegisteredClient.withId(UUID.randomUUID().toString()): 클라이언트 ID를 생성합니다. 여기서는 고유한 UUID를 사용합니다.
.clientId("articles-client"): OAuth 클라이언트의 식별자로 "articles-client"를 지정합니다. Spring은 이를 사용하여 리소스에 액세스하려는 클라이언트를 식별합니다.
.clientSecret("{noop}secret"): 클라이언트의 비밀번호를 설정합니다. {noop}은 패스워드 인코더가 사용되지 않음을 의미합니다.
.clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC): 클라이언트 인증 방식을 CLIENT_SECRET_BASIC으로 설정합니다. 이는 클라이언트 ID와 비밀번호를 사용하여 인증을 수행하는 방식입니다.
.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE) (인증 부여 유형): 인증 코드 부여 유형을 지원합니다. 이는 OAuth 2.0의 표준 플로우 중 하나입니다.
.authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN) (인증 부여 유형): 리프레시 토큰 부여 유형을 지원합니다. 이를 통해 클라이언트는 액세스 토큰을 갱신할 수 있습니다.
.redirectUri("http://127.0.0.1:8080/login/oauth2/code/articles-client-oidc"): OAuth 인증 후 사용자를 리디렉션할 URI를 설정합니다.
.redirectUri("http://127.0.0.1:8080/authorized"): 추가적인 리디렉션 URI를 설정합니다.
.scope(OidcScopes.OPENID): OpenID Connect 스코프를 사용합니다.
.scope("articles.read"): 사용자 정의 스코프인 "articles.read"를 설정합니다. 이 스코프는 클라이언트가 특정 자원에 접근할 수 있도록 허용합니다.
.build(): RegisteredClient 구성을 완성합니다.

5.1 상세

.redirectUri 설정에 대해 설명드리겠습니다. 이 설정은 OAuth 2.0 인증 프로세스에서 매우 중요한 부분입니다.

5.1.1. 인증 코드 흐름 (Authorization Code Flow):
- .redirectUri("http://127.0.0.1:8080/login/oauth2/code/articles-client-oidc"): 이 리디렉션 URI는 일반적으로 인증 코드 흐름에 사용됩니다. 사용자가 OAuth 인증을 시작하면, 사용자는 이 URI로 리디렉션됩니다. 여기서 사용자는 로그인하고 동의를 제공한 후, 인증 서버는 이 URI로 인증 코드를 리디렉션합니다. 이 인증 코드는 나중에 액세스 토큰을 얻는 데 사용됩니다.
5.1.2. 액세스 토큰 요청:
- .redirectUri("http://127.0.0.1:8080/authorized"): 이 URI는 액세스 토큰을 받기 위한 추가적인 리디렉션 포인트로 사용될 수 있습니다. 사용자가 인증 코드를 사용하여 액세스 토큰을 요청할 때, 인증 서버는 이 URI로 사용자를 리디렉션할 수 있습니다.

리디렉션 URI의 순서는 일반적으로 중요하지 않습니다. 중요한 것은 클라이언트 애플리케이션이 이 URI들 중 하나를 사용하여 인증 서버에 리디렉션을 요청하는 것입니다. 클라이언트 애플리케이션이 인증 요청 시에 사용하는 redirect_uri 매개변수의 값은 등록된 리디렉션 URI 중 하나와 정확히 일치해야 합니다.

요약하자면, .redirectUri("http://127.0.0.1:8080/login/oauth2/code/articles-client-oidc")는 사용자가 로그인하고 인증 서버가 인증 코드를 반환하는 데 사용되며, .redirectUri("http://127.0.0.1:8080/authorized")는 추가적인 리디렉션 옵션으로, 특정 상황에서 사용될 수 있습니다. 이 두 URI는 인증 프로세스의 다른 단계에서 사용되며, 그 순서는 특별한 의미를 가지지 않습니다.

5.2 구성

기본 OAuth 보안을 적용하고 기본 양식 로그인 페이지를 생성하도록 Bean을 구성

@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public SecurityFilterChain authServerSecurityFilterChain(HttpSecurity http) throws Exception {
    OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);
    return http.formLogin(Customizer.withDefaults()).build();
}

각 인증 서버에는 보안 도메인 간의 적절한 경계를 유지하기 위해 토큰에 대한 서명 키가 필요합니다. 2048바이트 RSA 키를 생성해 보겠습니다.

@Bean
public JWKSource<SecurityContext> jwkSource() {
    RSAKey rsaKey = generateRsa();
    JWKSet jwkSet = new JWKSet(rsaKey);
    return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
}

private static RSAKey generateRsa() {
    KeyPair keyPair = generateRsaKey();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    return new RSAKey.Builder(publicKey)
      .privateKey(privateKey)
      .keyID(UUID.randomUUID().toString())
      .build();
}

private static KeyPair generateRsaKey() {
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
    keyPairGenerator.initialize(2048);
    return keyPairGenerator.generateKeyPair();
}

서명 키를 제외하고 각 인증 서버에는 고유한 발급자 URL도 있어야 합니다. ProviderSettings 빈을 생성하여 포트 9000 에서 http://auth-server 에 대한 localhost 별칭으로 설정하겠습니다 .

@Bean
public ProviderSettings providerSettings() {
    return ProviderSettings.builder()
      .issuer("http://auth-server:9000")
      .build();
}

또한 /etc/hosts 파일에 " 127.0.0.1 auth-server " 항목을 추가하겠습니다 . 이를 통해 로컬 컴퓨터에서 클라이언트와 인증 서버를 실행할 수 있으며 둘 사이의 세션 쿠키 덮어쓰기 문제를 피할 수 있습니다.

그런 다음 @EnableWebSecurity 주석이 달린 구성 클래스 를 사용하여 Spring 웹 보안 모듈을 활성화합니다

@EnableWebSecurity
public class DefaultSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests(authorizeRequests ->
          authorizeRequests.anyRequest().authenticated()
        )
          .formLogin(withDefaults());
        return http.build();
    }

    // ...
}

모든 요청에 대해 인증을 요구하기 위해 AuthorizeRequests.anyRequest().authenticated()를 호출
formLogin(defaults()) 메서드 를 호출하여 양식 기반 인증을 제공하고

테스트에 사용할 예제 사용자 집합을 정의

@Bean
UserDetailsService users() {
    UserDetails user = User.withDefaultPasswordEncoder()
      .username("admin")
      .password("password")
      .build();
    return new InMemoryUserDetailsManager(user);
}

ChatGPT Plugin

NeNoVen — Wed, 08 Nov 2023 05:37:43 +0000

ChatGPT 메인 페이지에서 [ Settings ] → [ Beta Features ]를 선택하여 Plugins 활성화
메인 페이지로 돌아가서 New Chat 클릭
ChatGPT 모델을 GPT-4로 바꾸고, Plugins 선택
"No plugins enabled (유효한 플러그인 없음)"이라는 메시지가 나오면 해당 버튼을 클릭하고 Plugin store 클릭
"About Plugins"를 읽은 후, "OK" 클릭
필요한 플러그인을 선택하고 "Install" 클릭

스프링 부트에서 제공하는 주요한 빈의 범위(scope)

NeNoVen — Wed, 08 Nov 2023 02:05:43 +0000

Singleton: 이는 기본적으로 스프링 빈의 범위입니다. 스프링 컨테이너에서 해당 빈의 인스턴스를 오직 하나만 생성하며, 이 인스턴스를 여러 곳에서 공유하여 사용합니다. 예제

import org.springframework.stereotype.Component;

@Component
public class SingletonScopeBean {
    private final long instanceId;

    public SingletonScopeBean() {
        this.instanceId = System.nanoTime(); // Unique ID for each instance
    }

    public long getInstanceId() {
        return instanceId;
    }
}

다음은 이 Singleton 빈을 사용하는 서비스 클래스의 예제입니다:

javaCopy code
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    private final SingletonScopeBean singletonScopeBean;

    @Autowired
    public MyService(SingletonScopeBean singletonScopeBean) {
        this.singletonScopeBean = singletonScopeBean;
    }

    public long getSingletonScopeBeanId() {
        return singletonScopeBean.getInstanceId();
    }
}

이제 이 두 클래스를 사용하여 스레드 아이디를 통해 Singleton 범위의 동작을 확인할 수 있습니다:

javaCopy code
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SingletonScopeExampleApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SingletonScopeExampleApplication.class, args);

        MyService myService1 = context.getBean(MyService.class);
        MyService myService2 = context.getBean(MyService.class);

        // 스레드 아이디를 통해 Singleton 빈이 동일한 인스턴스인지 확인
        System.out.println("Singleton Bean 1 ID: " + myService1.getSingletonScopeBeanId());
        System.out.println("Singleton Bean 2 ID: " + myService2.getSingletonScopeBeanId());

        // 두 서비스 인스턴스가 같은 Singleton 빈을 공유하므로 동일한 ID가 출력됩니다.

        context.close();
    }
}

위의 코드는 스레드 아이디를 사용하여 Singleton 범위에서 동일한 인스턴스가 공유되는 것을 보여주는 예제입니다. 이 코드를 실행하면 myService1과 myService2가 같은 SingletonScopeBean 인스턴스를 사용함을 확인할 수 있습니다.

Prototype: 이 범위를 가지는 빈은 매번 요청할 때마다 새로운 인스턴스가 생성됩니다. 즉, 요청할 때마다 독립적인 빈 인스턴스가 제공됩니다.

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("request")
public class RequestScopedBean {
    private final long instanceId;

    public RequestScopedBean() {
        this.instanceId = System.nanoTime(); // Unique ID for each instance
    }

    public long getInstanceId() {
        return instanceId;
    }
}

다음, 웹 컨트롤러를 만듭니다. 이 컨트롤러는 HTTP 요청을 처리하고 Request 범위 빈을 사용하여 인스턴스 아이디를 출력합니다:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class MyController {
    private final RequestScopedBean requestScopedBean;

    @Autowired
    public MyController(RequestScopedBean requestScopedBean) {
        this.requestScopedBean = requestScopedBean;
    }

    @GetMapping("/example")
    public String example(Model model) {
        // Request 범위 빈의 인스턴스 아이디를 가져와서 모델에 추가
        long instanceId = requestScopedBean.getInstanceId();
        model.addAttribute("instanceId", instanceId);

        return "example";
    }
}

마지막으로, 템플릿 엔진을 사용하여 결과를 렌더링할 "example.html" 템플릿을 만듭니다:

htmlCopy code
<!DOCTYPE html>
<html>
<head>
    <title>Request Scope Example</title>
</head>
<body>
    <h1>Request Scope Example</h1>
    <p>Instance ID: <span th:text="${instanceId}"></span></p>
</body>
</html>

이제 스프링 부트 애플리케이션을 실행하고 "/example" 경로로 HTTP 요청을 보내면, 매 요청마다 Request 범위 빈의 새로운 인스턴스 아이디가 출력됩니다. 이를 통해 Request 범위 빈이 각 HTTP 요청에 대해 새로운 인스턴스를 생성함을 확인할 수 있습니다.

Request: 웹 애플리케이션에서 사용되는 범위로, 각각의 HTTP 요청마다 새로운 빈 인스턴스가 생성됩니다. 주로 웹 요청의 처리 과정에서 사용되며, 해당 요청의 범위 내에서만 빈 인스턴스가 유지됩니다.


import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("request")
public class RequestScopedBean {
    private final String requestIdentifier;

    public RequestScopedBean(HttpServletRequest request) {
        this.requestIdentifier = "Request ID: " + System.identityHashCode(request);
    }

    public String getRequestIdentifier() {
        return requestIdentifier;
    }
}

다음으로, 웹 컨트롤러를 만듭니다. 이 컨트롤러는 HTTP 요청을 처리하고 Request 범위 빈을 사용하여 요청 식별자를 출력합니다:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import javax.servlet.http.HttpServletRequest;

@Controller
public class MyController {
    private final RequestScopedBean requestScopedBean;

    @Autowired
    public MyController(RequestScopedBean requestScopedBean) {
        this.requestScopedBean = requestScopedBean;
    }

    @GetMapping("/example")
    public String example(Model model) {
        // Request 범위 빈의 요청 식별자를 가져와서 모델에 추가
        String requestIdentifier = requestScopedBean.getRequestIdentifier();
        model.addAttribute("requestIdentifier", requestIdentifier);

        return "example";
    }
}

마지막으로, 템플릿 엔진을 사용하여 결과를 렌더링할 "example.html" 템플릿을 만듭니다 (이전 예제와 동일):


<!DOCTYPE html>
<html>
<head>
    <title>Request Scope Example</title>
</head>
<body>
    <h1>Request Scope Example</h1>
    <p th:text="${requestIdentifier}"></p>
</body>
</html>

이제 스프링 부트 애플리케이션을 실행하고 "/example" 경로로 HTTP 요청을 보내면, 매 요청마다 Request 범위 빈의 새로운 요청 식별자가 출력됩니다. 이를 통해 Request 범위 빈이 각 HTTP 요청에 대해 새로운 인스턴스를 생성함을 확인할 수 있습니다.

Session: 이 역시 웹 애플리케이션에서 사용되며, 각각의 세션마다 새로운 빈 인스턴스가 생성됩니다. 세션 범위 빈은 한 세션 내에서만 유지되며, 세션이 종료될 때 함께 소멸됩니다.


import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpSession;

@Component
@Scope("session")
public class SessionScopedBean {
    private final String sessionId;

    public SessionScopedBean(HttpSession session) {
        this.sessionId = session.getId();
    }

    public String getSessionId() {
        return sessionId;
    }
}

다음으로, 웹 컨트롤러를 만듭니다. 이 컨트롤러는 HTTP 세션을 처리하고 Session 범위 빈을 사용하여 세션 ID를 출력합니다:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import javax.servlet.http.HttpSession;

@Controller
public class MyController {
    private final SessionScopedBean sessionScopedBean;

    @Autowired
    public MyController(SessionScopedBean sessionScopedBean) {
        this.sessionScopedBean = sessionScopedBean;
    }

    @GetMapping("/example")
    public String example(HttpSession httpSession, Model model) {
        // Session 범위 빈의 세션 ID를 가져와서 모델에 추가
        String sessionId = sessionScopedBean.getSessionId();
        model.addAttribute("sessionId", sessionId);

        return "example";
    }
}

마지막으로, 템플릿 엔진을 사용하여 결과를 렌더링할 "example.html" 템플릿을 만듭니다 (이전 예제와 동일):


<!DOCTYPE html>
<html>
<head>
    <title>Session Scope Example</title>
</head>
<body>
    <h1>Session Scope Example</h1>
    <p>Session ID: <span th:text="${sessionId}"></span></p>
</body>
</html>

이제 스프링 부트 애플리케이션을 실행하고 "/example" 경로로 HTTP 요청을 보내면, 웹 세션마다 Session 범위 빈의 새로운 세션 ID가 출력됩니다. 이를 통해 Session 범위 빈이 각 세션에 대해 새로운 인스턴스를 생성함을 확인할 수 있습니다.

Global Session: 주로 포털 애플리케이션과 같이 여러 웹 애플리케이션을 포함하는 경우에 사용됩니다. 이 범위는 모든 웹 애플리케이션에 걸쳐 하나의 세션을 공유할 때 사용됩니다.


import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.portlet.PortletRequest;
import javax.portlet.PortletSession;

@Component
@Scope("globalSession")
public class GlobalSessionScopedBean {
    private final String sessionId;

    public GlobalSessionScopedBean(PortletRequest request) {
        PortletSession session = request.getPortletSession(true);
        this.sessionId = session.getId();
    }

    public String getSessionId() {
        return sessionId;
    }
}

다음으로, 웹 컨트롤러를 만듭니다. 이 컨트롤러는 세션을 처리하고 Global Session 범위 빈을 사용하여 세션 ID를 출력합니다:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import javax.portlet.PortletRequest;

@Controller
public class MyController {
    private final GlobalSessionScopedBean globalSessionScopedBean;

    @Autowired
    public MyController(GlobalSessionScopedBean globalSessionScopedBean) {
        this.globalSessionScopedBean = globalSessionScopedBean;
    }

    @GetMapping("/example")
    public String example(PortletRequest portletRequest, Model model) {
        // Global Session 범위 빈의 세션 ID를 가져와서 모델에 추가
        String sessionId = globalSessionScopedBean.getSessionId();
        model.addAttribute("sessionId", sessionId);

        return "example";
    }
}

마지막으로, 템플릿 엔진을 사용하여 결과를 렌더링할 "example.html" 템플릿을 만듭니다 (이전 예제와 동일):


<!DOCTYPE html>
<html>
<head>
    <title>Global Session Example</title>
</head>
<body>
    <h1>Global Session Example</h1>
    <p th:text="${sessionId}"></p>
</body>
</html>

이제 스프링 부트 애플리케이션을 실행하고 "/example" 경로로 HTTP 요청을 보내면, 모든 웹 애플리케이션에 걸쳐 하나의 세션을 공유하는 Global Session 범위 빈의 세션 ID가 출력됩니다. 이를 통해 Global Session 범위 빈이 모든 웹 애플리케이션에서 하나의 세션을 공유함을 확인할 수 있습니다.

Redis storage 활용

NeNoVen — Fri, 20 Oct 2023 01:59:04 +0000

SNS 에서 활용 예시

개요

Redis는 고성능 읽기 및 쓰기 기능을 제공하여 소셜 앱에 기대되는 기능을 지원하므로 소규모 팀이 빠르게 출시하고 반복할 수 있습니다.
Redis는 주요 소셜 네트워크 규모로 확장되지 않을 수 있지만 상당한 사용자 증가를 통해 앱의 첫 번째 버전을 강화할 수 있습니다.

구성

먼저 Spring Boot 프로젝트를 설정하고 필요한 종속성을 추가합니다. spring-boot-starter-data-redis를 사용하여 Redis를 통합합니다. 이렇게하면 Redis 서버와의 연결 및 상호 작용이 가능합니다.

1. User Profile

각 사용자 프로필을 Redis 해시로 나타낼 수 있습니다. 여기서 키는 사용자 ID이고 해시 필드에는 프로필 속성이 포함됩니다.
관계형 모델과 비교하여 Redis Hash는 나중에 데이터베이스 스키마를 수정하지 않고도 새 프로필 속성을 쉽게 추가할 수 있는 유연성을 제공합니다. 데이터베이스 스키마 변경을 거칠 필요가 없기 때문에 사용자 프로필에 더 많은 속성을 검색하고 추가하는 방법을 정의하기만 하면 됩니다.

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class UserProfileService {
    private final String USER_PROFILE_KEY = "user:%s";

    private final RedisTemplate<String, String> redisTemplate;
    private final HashOperations<String, String, String> hashOperations;

    public UserProfileService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.hashOperations = redisTemplate.opsForHash();
    }

    public void saveUserProfile(String userId, String name, String location, String interests) {
        String key = String.format(USER_PROFILE_KEY, userId);
        hashOperations.put(key, "name", name);
        hashOperations.put(key, "location", location);
        hashOperations.put(key, "interests", interests);
    }

    public UserProfile getUserProfile(String userId) {
        String key = String.format(USER_PROFILE_KEY, userId);
        String name = hashOperations.get(key, "name");
        String location = hashOperations.get(key, "location");
        String interests = hashOperations.get(key, "interests");
        return new UserProfile(name, location, interests);
    }
}

2. User Relationships

Redis는 내장된 Set 데이터 구조를 사용하여 사용자 관계를 표현하는 보다 자연스러운 방법을 제공합니다.
Redis에서는 사용자 ID를 키로 사용하여 사용자의 친구 ID를 Set에 직접 저장할 수 있습니다. 사용자의 친구를 검색하는 것은 ZSet의 구성원을 반환하는 것만큼 간단합니다.

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.stereotype.Service;

@Service
public class UserRelationshipService {
    private final String USER_FRIENDS_KEY = "user:friends:%s";

    private final RedisTemplate<String, String> redisTemplate;
    private final SetOperations<String, String> setOperations;

    public UserRelationshipService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.setOperations = redisTemplate.opsForSet();
    }

    public void addFriend(String userId, String friendUserId) {
        String key = String.format(USER_FRIENDS_KEY, userId);
        setOperations.add(key, friendUserId);
    }

    public boolean areFriends(String userId, String friendUserId) {
        String key1 = String.format(USER_FRIENDS_KEY, userId);
        String key2 = String.format(USER_FRIENDS_KEY, friendUserId);
        return setOperations.isMember(key1, friendUserId) && setOperations.isMember(key2, userId);
    }
}

3. Posts

사용자에 대해 타임스탬프별로 정렬된 정렬 세트에 post_ids를 저장할 수 있습니다. 키는 사용자 ID가 될 수 있으며 각각의 새로운 post_id는 Set의 멤버로 추가됩니다. 게시물 콘텐츠 자체는 post_id를 해시 키로 사용하여 해시에 별도로 저장됩니다.
사용자가 새 게시물을 생성하면 새 post_id가 생성되고, 게시물 콘텐츠를 나타내는 해시가 생성되며, 사용자의 게시물 정렬 집합에 post_id가 추가됩니다. 이는 게시 타임라인을 모델링하는 자연스러운 방법을 제공합니다. 새로운 post_ids가 Set의 꼬리에 추가되고 post_ids의 ZRANGE를 사용하여 시간순으로 정렬된 게시물을 페이지로 이동할 수 있습니다.

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.stereotype.Service;

@Service
public class UserPostService {
    private final String USER_POSTS_KEY = "user:posts:%s";
    private final String POSTS_HASH_KEY = "post:%s";

    private final RedisTemplate<String, String> redisTemplate;
    private final ZSetOperations<String, String> zSetOperations;
    private final HashOperations<String, String, String> hashOperations;

    public UserPostService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.zSetOperations = redisTemplate.opsForZSet();
        this.hashOperations = redisTemplate.opsForHash();
    }

    public void createPost(String userId, String postId, String message) {
        String userPostsKey = String.format(USER_POSTS_KEY, userId);
        String postHashKey = String.format(POSTS_HASH_KEY, postId);

        zSetOperations.add(userPostsKey, postId, System.currentTimeMillis());
        hashOperations.put(postHashKey, "user_id", userId);
        hashOperations.put(postHashKey, "timestamp", String.valueOf(System.currentTimeMillis()));
        hashOperations.put(postHashKey, "message", message);
    }

    public List<UserPost> getUserPosts(String userId) {
        String userPostsKey = String.format(USER_POSTS_KEY, userId);
        Set<String> postIds = zSetOperations.reverseRange(userPostsKey, 0, -1);
        List<UserPost> userPosts = new ArrayList<>();

        for (String postId : postIds) {
            String postHashKey = String.format(POSTS_HASH_KEY, postId);
            String message = hashOperations.get(postHashKey, "message");
            String timestamp = hashOperations.get(postHashKey, "timestamp");
            userPosts.add(new UserPost(postId, message, Long.parseLong(timestamp)));
        }

        return userPosts;
    }
}

Vite

NeNoVen — Tue, 17 Oct 2023 09:08:01 +0000

Vite 프랑스어로 "빠르다" 라는 뜻을 가진 단어.
차세대 프론트엔드 개발 도구.
이름처럼 빌드와 개발 서버 구동 시간이 매우 빠름.

Webpack, Parcel 등과 비교하면 10배 이상의 빠른 속도.

Vite를 이용해 리액트 프로젝트 생성하는 방법.

nom init vite 프로젝트명 -- --template react
yarn create vite 프로젝트명 -- --template react

타입스크립트

npm init vite 프로젝트명 -- --template react-ts
yarn create vite 프로젝트명 -- --template react-ts

디렉토리 구조

src : 자바스크립트와 타입스크립트 코드를 작성하는 디렉토리. 진입 파일은 main.tsx or main.jsx
public : 정적 파일과 리소스를 이곳에 작성.
dist : 빌드 후 생성된 산출물이 저장되는 디렉토리.

빌드 명령어

npm run build
yarn build

개발 서버 시작 명령어

npm run dev
yarn dev

Production Release

NeNoVen — Tue, 17 Oct 2023 00:47:04 +0000

1단계: 프로세스는 제품 소유자가 요구 사항에 따라 사용자 스토리를 작성하는 것으로 시작됩니다.

2단계: 개발팀은 백로그에서 사용자 스토리를 선택하여 2주 개발 주기의 스프린트에 투입합니다.

3단계: 개발자는 소스 코드를 코드 저장소 Git에 커밋합니다.

4단계: Jenkins에서 빌드가 트리거됩니다. 소스 코드는 SonarQube의 단위 테스트, 코드 적용 범위 임계값 및 게이트를 통과해야 합니다.

5단계: 빌드가 성공하면 빌드가 아티팩트에 저장됩니다. 그런 다음 빌드가 개발 환경에 배포됩니다.

6단계: 다양한 기능을 작업하는 여러 개발팀이 있을 수 있습니다. 기능은 독립적으로 테스트되어야 하므로 QA1 및 QA2에 배포됩니다.

7단계: QA 팀은 새로운 QA 환경을 선택하고 QA 테스트, 회귀 테스트, 성능 테스트를 수행합니다.

8단계: QA 빌드가 QA 팀의 검증을 통과하면 UAT 환경에 배포됩니다.

9단계: UAT 테스트가 성공하면 빌드가 릴리스 후보가 되고 일정에 따라 프로덕션 환경에 배포됩니다.

10단계: SRE(사이트 안정성 엔지니어링) 팀이 제품 모니터링을 담당합니다.

LLM > LMM (GPT-4V) 대형멀티모달

NeNoVen — Mon, 16 Oct 2023 02:28:00 +0000

GPT-4V(ision) 다중 모드 모델

입력(텍스트 및 이미지)의 다양한 "양식"을 수용하고 해당 입력을 기반으로 결과를 반환할 수 있음을 의미

GPT-4V는 9월 24일부터 출시 OpenAI ChatGPT iOS 앱과 웹 인터페이스 모두에서 사용가능

도구를 사용하려면 GPT-4 구독

테스트

시각적 질문 답변
광학 문자 인식(OCR)
수학 OCR
객체 감지
보안 문자

제한및안전

이미지에 텍스트나 문자가 누락되었습니다.
누락된 수학 기호
공간적 위치와 색상을 인식하지 못함

비전

GPT-4V는 기계 학습 및 자연어 처리 분야에서 주목할만한 움직임입니다. GPT-4V를 사용하면 자연어로 이미지에 대해 질문하고 후속 질문을 할 수 있으며 모델은 질문을 시도합니다.

GPT-4V는 다양한 일반 이미지 질문에서 좋은 성적을 거두었으며 테스트한 일부 이미지에서 상황에 대한 인식을 보여주었습니다. 예를 들어, GPT-4V는 영화가 무엇인지 텍스트로 알려주지 않고도 이미지에 등장하는 영화에 대한 질문에 성공적으로 답할 수 있었습니다.

일반적인 질문 답변의 경우 GPT-4V가 매우 흥미롭습니다. 과거에는 이러한 목적을 위해 모델이 존재했지만 답변이 유창하지 못한 경우가 많았습니다. GPT-4V는 이미지에 대한 질문에 답변하고 후속 질문을 심층적으로 수행할 수 있습니다.

GPT-4V를 사용하면 2단계 프로세스를 만들지 않고도 이미지에 대해 질문할 수 있습니다(즉, 분류한 다음 그 결과를 사용하여 GPT와 같은 언어 모델에 질문하는 것). GPT-4V가 이해할 수 있는 것에는 제한이 있을 수 있으므로 모델의 성능을 이해하기 위해 사용 사례를 테스트하는 것이 중요합니다.

하지만 GPT-4V에는 한계가 있습니다. 모델이 "환각"을 하여 부정확한 정보를 반환했습니다. 이는 질문에 답하기 위해 언어 모델을 사용할 때 위험합니다. 게다가 모델은 객체 감지를 위한 경계 상자를 정확하게 반환할 수 없었으며 이는 현재 이 사용 사례에 적합하지 않음을 나타냅니다.

우리는 또한 GPT-4V가 사람에 관한 질문에 대답할 수 없다는 사실도 관찰했습니다. 테일러 스위프트의 사진을 제시하고 사진 속 인물이 누구인지 묻자 모델은 답변을 거부했다. OpenAI는 이를 게시된 시스템 카드에서 예상되는 동작으로 정의합니다.

CAP 이론

NeNoVen — Mon, 16 Oct 2023 00:32:03 +0000

C: 일관성

어떤 노드에서 접근을해도 동시에 동일한 내용을 제공

A: 가용성

사용자의 요청에 항상 응답하는 것.

P: 분할 허용성 (네트워크)

네트워크 파티션이 있어도 시스템이 계속 작동하는 능력

분할 허용시…

일관성과 가용성을 적절한 가중치 배분이 중요

case 1. 은행의 경우

atm 2대로 가정을 하면,

하이브리드 구성

잔액조회만 가능, 소규모 출금만 가능

case2. 구글독스 CAP 전략

구글독스의 충돌전략은 가용성과 분할 허용성을 우선시합니다. 즉, 사용자가 문서를 항상 사용할 수 있고, 시스템이 분할되어 있어도 작동하도록 설계되었습니다.

구글독스의 충돌전략은 다음과 같이 CAP에 구성되어 있습니다.

일관성: 구글독스는 버전 관리 시스템을 사용하여 문서의 이전 버전을 저장합니다. 충돌이 발생하면 사용자는 이전 버전에서 선택할 수 있습니다. 따라서 구글독스는 일관성을 일부 희생합니다.
가용성: 구글독스는 문서를 여러 서버에 분산하여 저장합니다. 따라서 시스템이 분할되어 있어도 문서에 액세스할 수 있습니다.
분할 허용성: 구글독스는 문서에 대한 변경 사항을 추적하여 충돌을 감지합니다. 충돌이 감지되면 사용자에게 경고하고 해결 방법을 제안합니다. 따라서 구글독스는 분할 허용성을 달성합니다.

구글독스의 충돌전략은 사용자 친화적이고 효과적이지만, 일부 상황에서는 일관성이 약화될 수 있습니다. 예를 들어, 두 사용자가 동시에 동일한 단어를 수정한 경우, 충돌이 발생하여 사용자가 이전 버전으로 돌아가야 할 수 있습니다.

case 1. 은행의 경우

atm 2대로 가정을 하면,

하이브리드 구성

잔액조회만 가능, 소규모 출금만 가능

case2. 구글독스 CAP 전략

구글독스의 충돌전략은 다음과 같이 CAP에 구성되어 있습니다.

일관성: 구글독스는 버전 관리 시스템을 사용하여 문서의 이전 버전을 저장합니다. 충돌이 발생하면 사용자는 이전 버전에서 선택할 수 있습니다. 따라서 구글독스는 일관성을 일부 희생합니다.
가용성: 구글독스는 문서를 여러 서버에 분산하여 저장합니다. 따라서 시스템이 분할되어 있어도 문서에 액세스할 수 있습니다.
분할 허용성: 구글독스는 문서에 대한 변경 사항을 추적하여 충돌을 감지합니다. 충돌이 감지되면 사용자에게 경고하고 해결 방법을 제안합니다. 따라서 구글독스는 분할 허용성을 달성합니다.

case3. 다양한 케이스

CAP 전략은 분산 시스템에서 중요한 고려 사항입니다. 다양한 케이스에 따라 다음과 같은 다양한 CAP 전략을 사용할 수 있습니다.

일관성을 우선시하는 경우:
- 원자성(Atomicity): 모든 작업이 성공하거나 실패하도록 합니다.
- 멱등성(Idempotence): 작업을 여러 번 실행해도 동일한 결과를 얻도록 합니다.
- 지연된 일관성(Eventual consistency): 시간이 지남에 따라 데이터가 일관되도록 합니다.
가용성을 우선시하는 경우:
- 캐싱(Caching): 데이터를 임시로 저장하여 성능을 향상시킵니다.
- 복제(Replication): 데이터를 여러 서버에 복제하여 가용성을 향상시킵니다.
- 투명성(Transparency): 사용자에게 시스템이 분산되어 있다는 사실을 숨깁니다.
분할 허용성을 우선시하는 경우:
- 파티셔닝(Partitioning): 데이터를 여러 서버에 분산하여 분할을 허용합니다.
- 동기화(Synchronization): 분할된 서버 간에 데이터를 동기화합니다.
- 재시도(Retry): 실패한 작업을 다시 시도합니다.

다음은 CAP 전략을 적용한 몇 가지 구체적인 예입니다.

온라인 쇼핑몰: 주문 처리 시스템은 가용성을 우선시합니다. 시스템이 분할되어 있어도 사용자는 주문을 할 수 있어야 합니다. 따라서 시스템은 주문 데이터를 여러 서버에 복제하고, 사용자가 주문할 때마다 가장 가까운 서버에 요청을 보냅니다.
금융 서비스: 결제 시스템은 일관성을 우선시합니다. 모든 거래는 동일한 결과를 가져야 합니다. 따라서 시스템은 트랜잭션을 원자적으로 실행하고, 트랜잭션이 실패하면 모든 변경 사항을 되돌립니다.
게임: 게임 서버는 분할 허용성을 우선시합니다. 게임 서버가 분할되어 있어도 플레이어는 게임을 계속할 수 있어야 합니다. 따라서 시스템은 게임 상태를 여러 서버에 복제하고, 플레이어가 게임을 할 때마다 가장 가까운 서버에 연결합니다.

CAP 전략은 분산 시스템을 설계 및 구현할 때 중요한 고려 사항입니다. 시스템의 요구 사항을 평가하고 적절한 CAP 전략을 선택해야 합니다.

gRPC 장단점 요약

NeNoVen — Fri, 13 Oct 2023 00:49:18 +0000

장점

json보다 5배 빠름. 여러 빅테크 기업에서 사용하고있음
protoBuf를 사용하여 속도가 매우빠름
다양한언어 지원됨
msa 에서 외부 서비스간 호출시 유용

단점

브라우저 지원안됨, 로우레벨 언어에서만 사용가능
널리 쓰이지 못함

비동기 논블록킹 &비동기 처리 후 결과값 대기(waitForAsync)

NeNoVen — Thu, 12 Oct 2023 00:15:56 +0000

비동기-논블록킹 (어노테이션 기반)
- 신규 스레드로 callback 처리까지 ( 진정한 비동기-논블록킹)

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Async {
}

public class AsyncBeanProcessor {

    private ExecutorService executorService;
    private ExecutorService responseExecutorService;

    public AsyncBeanProcessor(int threadPoolSize) {
        executorService = Executors.newFixedThreadPool(threadPoolSize); // 비동기 작업용 스레드 풀 생성
        responseExecutorService = Executors.newCachedThreadPool(); // 응답 처리용 스레드 풀 생성
    }

    public void processAsyncMethods(Object bean) {
        Class<?> clazz = bean.getClass();
        for (java.lang.reflect.Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(Async.class)) {
                executorService.submit(() -> {
                    try {
                        Object result = method.invoke(bean); // 비동기로 어노테이션이 붙은 메소드 실행
                        if (result instanceof ResponseBean) {
                            ResponseBean responseBean = (ResponseBean) result;
                            responseBean.waitForAsync(); // 응답이 오기를 대기
                            responseExecutorService.submit(() -> processResponse(responseBean)); // 응답 처리
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
        }
    }

    private void processResponse(ResponseBean responseBean) {
        // 응답 처리 로직 구현
        System.out.println("비동기 작업 응답: " + responseBean.getResponse());
    }

    public void shutdown() {
        executorService.shutdown(); // 비동기 작업용 스레드 풀 종료
        responseExecutorService.shutdown(); // 응답 처리용 스레드 풀 종료
    }
}

public class ResponseBean {

    private Object response;
    private CountDownLatch latch;

    public ResponseBean() {
        latch = new CountDownLatch(1);
    }

    public void setResponse(Object response) {
        this.response = response;
        latch.countDown(); // 응답이 설정되었음을 알림
    }

    public Object getResponse() {
        return response;
    }

    public void waitForAsync() throws InterruptedException {
        latch.await(); // 응답이 올 때까지 대기
    }
}

위의 코드에서 AsyncBeanProcessor 클래스에서는 비동기 작업이 완료된 후 ResponseBean 객체를 반환하면, 해당 객체의 waitForAsync 메소드를 호출하여 결과 응답이 올 때까지 대기합니다. 대기 중인 스레드는 CountDownLatch를 사용하여 동기화합니다.

ResponseBean 클래스는 비동기 작업의 결과 응답을 저장하는 역할을 합니다. setResponse 메소드를 통해 응답을 설정하고, waitForAsync 메소드를 호출하여 응답이 올 때까지 대기할 수 있습니다.

변경된 코드를 사용하여 비동기 작업 및 응답 처리를 수행할 수 있습니다. 예를 들어:

public class MyService {

@Async
public ResponseBean performAsyncTask() {
    ResponseBean responseBean = new ResponseBean();

    // 비동기로 실행될 작업 내용
    System.out.println("비동기 작업 실행");
    // ...

    // 작업 완료 후 응답 설정
    responseBean.setResponse("작업 완료");

    return responseBean;
}

public void someOtherMethod() {
    // ...
}

}

위의 MyService 클래스에서 performAsyncTask 메소드는 비동기 작업을 수행하고 작업이 완료되면 ResponseBean 객체에 응답을 설정합니다.

다음은 변경된 MyApp 클래스의 예시입니다:

public class MyApp {

public static void main(String[] args) {
    MyService myService = new MyService();
    AsyncBeanProcessor beanProcessor = new AsyncBeanProcessor(10); // 스레드 풀 크기 지정

    beanProcessor.processAsyncMethods(myService);

    // 어플리케이션 종료 시 Executor 종료
    Runtime.getRuntime().addShutdownHook(new Thread(beanProcessor::shutdown));
}

}

이렇게 변경된 코드로 비동기 작업을 요청하고, waitForAsync 메소드를 호출하여 결과 응답이 올 때까지 스레드가 대기하는 방식으로 처리할 수 있습니다.

비동기-논블록킹 (어노테이션 기반)
- 응답 waitForAsync 호출시 , 주 스레드 동기 방식으로 대기

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Async {
}

public class AsyncBeanProcessor {

    private ExecutorService executorService;

    public AsyncBeanProcessor(int threadPoolSize) {
        executorService = Executors.newFixedThreadPool(threadPoolSize); // 비동기 작업용 스레드 풀 생성
    }

    public void processAsyncMethods(Object bean) {
        Class<?> clazz = bean.getClass();
        for (java.lang.reflect.Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(Async.class)) {
                executorService.submit(() -> {
                    try {
                        Object result = method.invoke(bean); // 비동기로 어노테이션이 붙은 메소드 실행
                        if (result instanceof ResponseBean) {
                            ResponseBean responseBean = (ResponseBean) result;
                            responseBean.waitForAsync(); // 응답이 오기를 대기
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
        }
    }

    public void shutdown() {
        executorService.shutdown(); // 비동기 작업용 스레드 풀 종료
    }
}

public class ResponseBean {

    private Object response;
    private final Object lock = new Object();

    public void setResponse(Object response) {
        this.response = response;
        synchronized (lock) {
            lock.notify(); // 대기 중인 스레드를 깨움
        }
    }

    public Object getResponse() {
        return response;
    }

    public void waitForAsync() throws InterruptedException {
        synchronized (lock) {
            lock.wait(); // 응답이 올 때까지 호출한 스레드를 대기
        }
    }
}

위의 코드에서 ResponseBean 클래스는 waitForAsync 메소드가 호출된 스레드를 대기시키고, setResponse 메소드가 호출되면 대기 중인 스레드를 깨웁니다. 이를 위해 lock 객체와 synchronized 블록을 사용하여 동기화합니다.

이제 수정된 코드로 비동기 작업을 요청하고, waitForAsync 메소드를 호출하여 결과 응답이 올 때까지 호출한 스레드가 대기하는 방식으로 처리할 수 있습니다.

Jmeter 테스트

NeNoVen — Tue, 10 Oct 2023 00:49:13 +0000

로컬에서 분산 테스트를 위한 설정(마스터)

Jmeter.properties 수정

# 슬레이브 설정
# Remot Hosts - comma delimited
remote_hosts=localhost:1099,localhost:1100 # ip or domain

로컬에서 분산 테스트를 위한 설정(슬레이브)

jmeter-server.bat 복사하여 jmeter-server1.bat,jmeter-server2.bat 생성
jmeter-server1.bat, jmeter-server2.bat 수정

# 1번 슬레이브
@echo off
set SERVER_PORT=1099

# 2번 슬레이브
@echo off
set SERVER_PORT=1100

로컬에서 실행 (마스터)

# 로컬 테스트
$ jmeter -n -t 스크립트명.jmx -R localhost:1099,localhost:1100

스크립트구성

Thread Group 우클릭 >Sampler>HTTP Request 추가

Http Request 우클릭 > Add> Listener> Summary Report, View Results Tree 추가

Redis 빠른이유

NeNoVen — Mon, 09 Oct 2023 02:36:11 +0000

이유

in memory 데이터베이스 : Ram 을 사용한다. disk 가 아니다. disk 보다 약 1000배 정도 빠르다.
disk DB 와 비교해 코드상에서 구현하기 쉽다.
싱글스레드 사용한다. 멀티스레드의 컨텍스트 교환 비용을 지불하지않아도 된다.
IO 멀티플렉싱 으로 단일스레드의 단점을 극복 a. 요청이 스레드의 완료시점까지 기다리지않아도됨. b. 단일 스레드가 여러개의 소케 연결을 동시에 기다릴수있음. c. 수천개의 연결이 있는 경우 일반적으로 select 나 폴링을 통해서 요청을 처리할경우에는 성능이 좋지않음.

단점

data set 이 disk i/o 보다 작다
최신 고스펙 하드웨어 환경에서 (멀티코어) 모든 코어를 활용 못한다. a. 보완 : 단일서버에 여러개의 redis 인스턴스를 사용해 보완한다.
하위 수준의 여러가지 데이터 구조를 활용가능

Persistence 지속성 을위한 옵션

AOF append only file 로그퍼일처럼 생성에 관한 내용을 기록
Rdb 관계형 디비에 일정주기로 스냅샵
AOF Rdb 를 적절하게사용
No persistence 짧은 주기 캐시로 그냥 사용, 지속성을 사용하지않음