dongs

[OS] 프로세스 상태

hdk325 — Thu, 6 Apr 2023 11:45:26 +0900

프로세스 상태 (Process State)

http://faculty.cooper.edu/smyth/cs111/os/os1.htm

new (생성 상태)

프로세스를 생성 중인 상태. PCB를 할당받은 상태

ready (준비 상태)

자신의 차례를 기다리고 있는 상태.

많은 프로세스들이 ready상태에서 자신의 차례를 기다린다. 이때 os는 실행 상태로 전환할 프로세스를 선택하는데 이 작업을 스케줄링이라 한다. CPU의 할당을 받으면 실행 상태가 되는데 준비 상태인 프로세스가 실행 상태로 전환되는 것을 디스패치(Dispatch)라고 한다.

running (실행 상태)

CPU의 할당을 받아서 실행하는 상태.

waiting (대기 상태)

입출력 작업이나 다른 이벤트가 발생하여 완료 인터럽트를 받을 때까지 기다리는 상태

running -> ready
- cpu를 할당받아 실행 중인 running 상태에서 할당받은 시간을 모두 사용하고 timer interrupt가 발생하면 ready 상태가 되어 다시 자신의 순서를 기다린다.

running -> waiting
- 실행 중인 프로세스가 입출력 작업을 기다리거나 다른 이벤트가 완료될 때까지 기다리는 경우 waiting 상태가 된다.

waiting -> ready
- 입출력 작업이 끝나서 완료 interrupt가 발생하면 ready 상태가 되어 자신의 순서를 기다린다.

terminated (종료 상태)

프로세스가 종료된 상태. 프로세스가 사용한 PCB와 메모리를 정리한다.

[Querydsl] Querydsl 동적으로 정렬하는 방법

hdk325 — Mon, 6 Mar 2023 21:04:47 +0900

게시글 조회 화면에서 검색타입, 정렬 방법에 따라 다른 결과를 반환해야 하는 기능을 구현하고 있었다.

단순한 검색 기능이면 스프링 데이터 JPA로 JPQL을 사용했겠지만, 이번 기능은 고려해야 할 부분이 많았기 때문에 Querydsl을 사용해서 구현해 보기로 했다.

where문 작성의 경우 BooleanExpression과 BooleanBuilder를 사용해서 간단하게 작성할 수 있었는데, 정렬 조건에 따른 작성을 어떻게 해야 하는지가 문제였다.

처음엔 service단에서 sort값에 따라 처리하도록 아래와 같이 작성했었다.

//PostService
public Page<Post> findPosts(int page, int size, PostSearchDto postSearchDto, String sort) {
    PageRequest pageRequest = PageRequest.of(page, size);
    if (sort != null && sort.equals("Likes")) {
        return postRepository.getPostsSortByLikes(postSearchDto, pageRequest);
    } else {
        return postRepository.getPostsSortByNewest(postSearchDto, pageRequest);
    }
}

//PostRepositoryImpl

//최신순
@Override
public Page<Post> getPostsSortByNewest(PostSearchDto postSearchDto, Pageable pageable) {

    List<Post> results = queryFactory
            .select(post)
            .from(post)
            .leftJoin(post.pet, pet)
            .where(codeEq(postSearchDto.getCode()), typeEq(postSearchDto))
            .orderBy(post.id.desc())
            .offset(pageable.getOffset())
            .limit(pageable.getPageSize())
            .fetch();
	//...
}

//좋아요 순
@Override
public Page<Post> getPostsSortByLikes(PostSearchDto postSearchDto, Pageable pageable) {
    List<Post> results = queryFactory
            .select(post)
            .from(post)
            .leftJoin(post.pet, pet)
            .where(codeEq(postSearchDto.getCode()), typeEq(postSearchDto))
            .orderBy(post.likesCnt.desc())
            .orderBy(post.id.desc())
            .offset(pageable.getOffset())
            .limit(pageable.getPageSize())
            .fetch();
    //...
}

댓글 순까지 작성하면 orderBy를 제외한 다른 절들은 똑같은데 orderBy 때문에 3개의 메서드가 작성되는 게 별로였고 추후에 조건이 추가된다면 또 메서드를 만들어야 한다.

OrderSpecifier

Querydsl은 동적으로 정렬조건을 적용할 수 있게 OrderSpecifier를 제공한다.

@Override
public Page<Post> getPosts(PostSearchDto postSearchDto, Pageable pageable, String sort) {
    List<Post> results = queryFactory
            .select(post)
            .from(post)
            .leftJoin(post.pet, pet).fetchJoin()
            .leftJoin(post.postComments, postComment)
            .where(codeEq(postSearchDto.getCode()), typeEq(postSearchDto))
            .orderBy(getOrderSpecifier(sort).stream().toArray(OrderSpecifier[]::new))
            .groupBy(post.id)
            .offset(pageable.getOffset())
            .limit(pageable.getPageSize())
            .fetch();
    
    //...
}

private List<OrderSpecifier> getOrderSpecifier(String sort) {
    List<OrderSpecifier> orders = new ArrayList<>();
    if (StringUtils.hasText(sort)) {
        Order direction = Order.DESC;
        switch (sort) {
            case "likes":
                orders.add(new OrderSpecifier(direction, post.likesCnt));
                orders.add(new OrderSpecifier(direction, post.id));
                break;
            case "comments":
                orders.add(new OrderSpecifier(direction, postComment.id.count()));
                orders.add(new OrderSpecifier(direction, post.id));
                break;
            case "newest":
                orders.add(new OrderSpecifier(direction, post.id));
                break;
            default:
                throw new BusinessLogicException(ExceptionCode.INVALID_SORT_TYPE);
        }
    }
    return orders;
}

위와 같이 List에 정렬 조건별로 OrderSpecifier를 추가해서 반환하는 메서드를 만들어 사용하면 정렬 조건이 추후에 조건이 바뀌거나 추가되어도 쉽게 적용이 가능하다.

참고 블로그

https://dingdingmin-back-end-developer.tistory.com/entry/Springboot-JPA-Querydsl-%EB%8F%99%EC%A0%81-%EC%A0%95%EB%A0%AC-OrderSpecifier

Springboot JPA Querydsl 동적 정렬 OrderSpecifier

SQL 동적 정렬이란? 하나의 API에서 정렬 조건을 동적으로 변경해, 정렬 혹은 정렬 + 페이징을 진행하는 것을 의미합니다. 예시를 보며, 필요한 상황이 언제이며, 어떻게 해결하는지 알아가 보겠습

dingdingmin-back-end-developer.tistory.com

[Spring] HttpServletRequest 요청마다 같은 주소값을 반환하는 이유

hdk325 — Sat, 25 Feb 2023 16:48:08 +0900

부트캠프가 끝나고 예전에 수강했던 김영한님의 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술을 다시 듣고 있었다.

서블릿 부분을 보던 중 의아한 부분이 있었다.

스프링의 내장 톰캣 서버는 서블릿들을 스캔하여 서블릿 컨테이너에 싱글톤으로 관리하면서 요청마다 WAS는 Request, Response 객체를 새로 만들어서 서블릿 객체를 호출한다. 즉, 요청마다 request와 response객체는 요청마다 다른 객체가 만들어져서 servlet을 호출한다고 이해했다.

위와 같이 코드를 작성하고 요청 결과를 확인하다가 request, response가 같은 객체를 사용하고 있는 것을 확인했다.

강의에서는 요청마다 request, response를 생성해서 servlet을 호출한다고 했는데 같은 객체를 사용하길래 궁금해서 찾아본 결과 나와 같이 궁금했던 사람이 질문한 글을 발견했다.

https://www.inflearn.com/questions/307198/http-%EC%9A%94%EC%B2%AD%EC%9D%84-%EB%B3%B4%EB%82%BC%EB%95%8C%EB%A7%88%EB%8B%A4-request-response-%EA%B0%9D%EC%B2%B4%EC%9D%98-%EC%A3%BC%EC%86%8C%EA%B0%92%EC%9D%B4-%EB%B3%80%ED%95%98%EC%A7%80-%EC%95%8A%EB%8A%94-%EC%9D%B4%EC%9C%A0

정리하면 톰캣의 RequestFacade객체는 최적화를 위해 객체를 계속 생성하지 않고 요청이 끝나면 Facade객체를 초기화하고 다른 요청이 오면 재사용한다고 한다.

sleep을 적용하고 요청을 반복하면 사용되는 객체가 다른 것을 확인할 수 있다.

[Spring] RequestContextHolder를 통해 HttpServletRequest, Response 가져오기

hdk325 — Fri, 17 Feb 2023 15:48:50 +0900

스프링 HttpServletRequest, HttpServletResponse는 RequestContextHolder를 통해 가져오기

ServletRequestAttributes servletContainer = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

HttpServletResponse response = servletContainer.getResponse();
HttpServletRequest request = servletContainer.getRequest();

[Spring] 같은 타입의 빈 문제 해결 방법(@Primary, @Qualifier)

hdk325 — Wed, 15 Feb 2023 21:57:16 +0900

스프링은 빈과 연관된 의존관계를 주입할 때 스프링 컨테이너에서 해당 빈을 조회해서 의존관계를 주입한다.

만약, 같은 타입의 빈이 두 개 이상 존재하면 스프링은 의존관계를 주입할 때 어떤 빈을 주입해야 할지 모르기 때문에 애플리케이션은 실행되지 않는다.

Animal 인터페이스와 이를 구현한 Cat, Dog 클래스가 있고 AnimalService에서 Animal을 주입받는다고 가정하면 콘솔에 다음과 같이 나온다.

Animal

package hello.core.animal;

public interface Animal {}

Cat

package hello.core.animal;

import org.springframework.stereotype.Component;

@Component
public class Cat implements Animal{
}

Dog

package hello.core.animal;


import org.springframework.stereotype.Component;

@Component
public class Dog implements Animal{
}

AnimalService

package hello.core.animal;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class AnimalService {
    
    private final Animal animal;
    
}

***************************
APPLICATION FAILED TO START
***************************

Description:

Parameter 0 of constructor in hello.core.animal.AnimalService required a single bean, but 2 were found:
	- cat: defined in file [~\Cat.class]
	- dog: defined in file [~\Dog.class]


Action:

Consider marking one of the beans as @Primary, 
updating the consumer to accept multiple beans,or 
using @Qualifier to identify the bean that should be consumed


Process finished with exit code 1

위와 같이 3가지 방법을 사용하라고 한다.

1. @Primary

@Primary는 우선순위를 지정하는 어노테이션이다.

의존관계 주입 시 여러 개의 빈이 매칭되면 @Primay를 적용한 빈이 우선권을 갖게 된다.

@Primary
@Component
public class Dog implements Animal{
}

2. @Qualifier

@Qualifier는 추가 구분자를 붙여주는 방법이다. 별명처럼 추가적인 방법을 제공하는 것일 뿐 빈 이름을 변경하는 것이 아니다.

@Service
//@RequiredArgsConstructor
//롬복 사용시 @Qualifier를 사용하기 위해선 추가적인 설정이 필요하기 때문에 주석 처리
public class AnimalService {

    private final Animal animal;

    public AnimalService(@Qualifier("dogdog") Animal animal) {
        this.animal = animal;
    }
}

3. 여러 개의 빈을 한 번에 받기(updating the consumer to accept multiple beans)

의도적으로 여러 개의 빈이 필요할 때 사용한다.

스프링에서는 Collection 주입을 지원해 주기 때문에 같은 타입의 여러 빈이 존재하거나 필드나 파라미터 변수의 타입이 Collection, List, Map 일 경우 컬렉션으로 넘겨주어 한 번에 의존 관계를 맺게 해 준다.

@Slf4j
@Service
@RequiredArgsConstructor
public class AnimalService {

    private final Map<String,Animal> animal;

    @PostConstruct
    public void init() {
        log.info("animal = {}", animal);
    }
}

//animal = {cat=hello.core.animal.Cat@29138d3a, dog=hello.core.animal.Dog@5cbe2654}

참고 자료 : 김영한님 스프링 핵심 원리 - 기본편

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard

[Spring] 스프링 컨테이너와 빈

hdk325 — Mon, 13 Feb 2023 14:44:28 +0900

스프링 컨테이너 (Spring Container)

스프링 컨테이너는 애플리케이션 내부에서 사용되는 객체들을 관리한다.
정확히는 애플리케이션 빈의 생명주기를 관리하는데 빈 생성, 관리, 제거 등의 역할을 담당하는 곳이다. 객체들의 의존성 또한 관리해주기 때문에 개발자는 모듈 간 의존 및 결합으로 인해 발생하는 문제로부터 자유로워지고 핵심 로직에 집중할 수 있게 된다.

컨테이너는 BeanFactory와 BeanFacotry를 상속받아 사용하는 ApplicationContext가 있다.

ApplicationContext가 BeanFactory의 기능에 더해 부가적으로 국제화, 환경변수 등 여러 기능을 제공하기 때문에 대부분의 경우에는 ApplicationContext를 사용한다.

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
        
        }

스프링 컨테이너를 사용할 땐 AnnotationConext 인터페이스를 구현한 AnnotationConfigApplicationConext를 사용하고 파라미터로 @Configuration 애너테이션이 붙은 구성 정보 클래스를 넣어준다

@Configuration
public class AppConfig {
    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository());
    }
    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }
    @Bean
    public OrderService orderService() {
        return new OrderServiceImpl(memberRepository(),discountPolicy());
    }
    @Bean
    public DiscountPolicy discountPolicy() {
        return new RateDiscountPolicy();
    }
}


ApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

스프링 컨테이너의 생성 과정

1. 스프링 컨테이너 생성

new AnnotationConfigApplicationConext(AppConfig.class)처럼 파라미터로 구성 정보 클래스를 넣어준다.

2. 스프링 빈 등록

컨테이너는 파라미터로 넘어온 클래스들을 실행시켜 빈들을 컨테이너에 등록한다.

이때 빈 이름은 @Bean 애너테이션이 붙은 메서드의 이름으로 저장된다.

3. 스프링 빈 의존관계 설정

컨테이너는 설정 정보를 참고해서 의존관계 주입을 수행한다.

스프링 빈 (Spring Bean)

빈은 스프링 컨테이너에 의해 관리되는 재사용 소프트웨어 컴포넌트이다.

즉, @Bean 애너테이션이 적힌 메서드를 모두 호출해서 스프링 컨테이너에 저장되는 객체들을 말한다.

빈 관련 메서드

1. ac.getBeanDefinitionNames() : 컨테이너에 등록된 모든 빈 이름 조회
2. ac.getBean() : 빈 이름으로 빈 객체 조회 (빈 이름, 타입), (타입)
-> 조회할 빈이 없으면 예외가 발생한다. (NoSuchBeanDefinitionException)
3. ac.getRole() : 스프링 내부에서 사용하는 빈과 자체적으로 등록한 빈 구별할 수 있는 메서드
3 - 1. BeanDefinition.ROLE_APPLICATION : 개발자가 정의한 빈
3 - 2. BeanDefinition.ROLE_INFRASTRUCTURE : 스프링 내부적으로 사용하는 빈

참고 자료 : 김영한님 스프링 핵심 원리 - 기본편

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard

SEB_BE - Main Project 회고

hdk325 — Mon, 6 Feb 2023 11:20:33 +0900

약 4주(23/01/03 ~ 23/02/03) 간의 메인 프로젝트가 끝났다!

http://blog.naver.com/rhkdtls8092/220260842686

메인 프로젝트를 시작하기 전 ZEP에서 팀원을 구하는 모습은 마치 옛날의 메xx 자유시장 같은 모습이었다.

애견 관심 있으신 분들 찾아요@@@@

지금 팀의 팀장님의 글이 눈에 띄어 바로 말씀드리고 팀에 합류했다. 팀 당 FE 3 / BE 3 기준이었는데 합류하자마자 자리가 꽉 차서 조금만 고민했으면 합류하지 못할 뻔했다.. 이렇게 모인 팀원들은 다 강아지를 키우거나 키운 경험이 있었고 그렇게 팀 이름은 동물 특공대가 되었다.

정규시간 외에도 작업 내용을 공유하면서 늦은 시간까지 회의해도 힘들지 않았고 이보다 더 좋은 프론트 분들이 계실까 싶을 정도의 페이지를 만들어주신 분들과 마음 잘 맞는 백엔드 분들 덕분에 4주가 재밌고 빠르게 지나갔다.

지도 Modal 부분

아무것도 없는 단계에서 기획부터 구현까지 해야 하는 메인 프로젝트를 통해 일단 하면 어떻게든 된다! 라는 자신감 같은 것이 생겼고 데모데이 때는 다른 팀들이 만든 결과물을 보면서 이런 기능도 넣었네 나도 다른 프로젝트에 사용해 보고 싶다는 생각을 하는 시간이 되었다.

수료 후에도 힘내서 달려보자!

동물특공대 노션 페이지

https://codestates.notion.site/b2495985e7ed43c2b497f03517018556

동물 특공대

✉️ commit message

codestates.notion.site

PAWPWA 배포 사이트

http://pawpaw.com.s3-website.ap-northeast-2.amazonaws.com

PAWPAW 깃 허브

https://github.com/khd325/PAWPAW

GitHub - khd325/PAWPAW

Contribute to khd325/PAWPAW development by creating an account on GitHub.

github.com

[Security] JJWT 라이브러리 Jwts.builder().setSubject null 문제

hdk325 — Mon, 9 Jan 2023 01:22:58 +0900

JWT와 redis를 이용해서 토큰 재발급 로직을 작성하다 만난 에러

public void reIssue(AuthRequestDto.ReIssue reIssue, HttpServletResponse response) {
        //Refresh Token 검증
        if (!jwtTokenProvider.validateToken(reIssue.getRefreshToken())) {
            throw new BusinessLogicException(ExceptionCode.INVALID_TOKEN);
        }

        String accessToken = jwtTokenProvider.resolveToken(reIssue.getAccessToken());

        //AccessToken으로 Authentication 생성
        Authentication authentication = jwtTokenProvider.getAuthentication(accessToken);
        
        //...
}


public Authentication getAuthentication(String accessToken) {
        //...
        UserDetails principal = new User(claims.getSubject(), "", authorities);

        return new UsernamePasswordAuthenticationToken(principal, "", authorities);
    }

public AuthResponseDto.TokenInfo generateToken(Map<String,Object> claims, String subject) {


        //..

        System.out.println(subject);
        String accessToken = Jwts.builder()
                .setSubject(subject)
                .setClaims(claims)
                .setExpiration(accessTokenExpiresIn)
                .signWith(key)
                .compact();
                
        //...
}

위와 같은 로직으로 작성했는데 로그인 요청에 대한 처리로 AccessToken과 RefreshToken은 정상발급 되는데 재발급 요청에선 다음과 같은 에러가 찍히면서 authentication객체가 만들어지지 않았다.

java.lang.IllegalArgumentException: Cannot pass null or empty values to constructor

디버깅을 해보니 토큰을 발행할 때 setsubject가 적용되지 않았고 토큰 claims에 subject가 없어서 authentication 객체를 만들지 못했었다.

해결방법은 간단했다.

Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)

setClaims를 setSubject보다 먼저 적용하면 된다.

https://github.com/jwtk/jjwt/issues/179

[Network] nginx reverse proxy, redirect 적용

hdk325 — Wed, 21 Dec 2022 20:26:26 +0900

환경 : ec2 (ubuntu 18.04), spring boot, nginx/1.14.0(ubuntu), certbot으로 domain https 인증서 발급

certbot https 인증서 발급 참고 블로그

https://junho85.pe.kr/2048

- sudo mkdir /var/log/nginx/proxy/ # log, error 파일용 디렉토리

- sudo vi /etc/nginx/proxy_params 아래 코드 작성

proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-NginX-Proxy true;

client_max_body_size 256M;
client_body_buffer_size 1m;

proxy_buffering on;
proxy_buffers 256 16k;
proxy_buffer_size 128k;
proxy_busy_buffers_size 256k;

proxy_temp_file_write_size 256k;
proxy_max_temp_file_size 1024m;

proxy_connect_timeout 300;
proxy_send_timeout 300;
proxy_read_timeout 300;
proxy_intercept_errors on;

sudi vi /etc/nginx/nginx.conf 안에
http {
server_names hash_bucke_size64; #주석 제거
}

- sudo vi /etc/nginx/sites-available/{domain} 아래 코드 작성 {domain} : example.co.kr(com, site, ...)

server {
    listen 80;

    server_name {domain} www.{domain};

    access_log /var/log/nginx/proxy/access.log;
    error_log /var/log/nginx/proxy/error.log;
    return 301 https://{domain}$request_uri; # 80번 포트요청은 443으로 redirect
}

server {
    listen 443 ssl;

    server_name {domain};

    ssl_certificate /etc/letsencrypt/live/{domain}/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/{domain}/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

    access_log /var/log/nginx/proxy/access.log;
    error_log /var/log/nginx/proxy/error.log;

    location / {
        include /etc/nginx/proxy_params;
        proxy_pass http://localhost:8080; #요청
    }
}

sudo ln -s /etc/nginx/sites-available/{domain} /etc/nginx/sites-enabled/ 명령어로 심 링크 설정

sudo rm /etc/nginx/sites-available/default

sudo rm /etc/nginx/sites-enabled/default

sudo nginx -t

sudo service nginx reload 후 jar 파일 실행

참고

https://community.letsencrypt.org/t/nginx-certbot-redirect-https-www-to-https/142678

https://velog.io/@u-nij/Spring-Boot-Nginx-%EC%97%B0%EB%8F%99%ED%95%B4%EC%84%9C-%EB%B0%B0%ED%8F%AC%ED%95%98%EA%B8%B0

[Security] Spring Security 인증 처리 과정

hdk325 — Thu, 1 Dec 2022 00:12:28 +0900

Spring Security 인증 처리 과정

https://www.javainuse.com/webseries/spring-security-jwt/chap3

- 로그인 요청

- AuthenticationFilter에서 username과 password로 Authentication(인증되지 않은) 객체 생성

- Authentication 객체를 AuthenticationManager에 전달

AuthenticationManager는 인증 처리 역할을 하는 인터페이스, 인증을 위한 실질적인 관리는 AuthenticationManager를 구현하는 클래스 (ProviderManager) 를 통해 이루어짐

- ProviderManager로부터 전달받은 Authentication을 AuthenticationProvider는 UserDetailsService를 이용해 UserDetails 조회

- AuthenticationProvider는 전달받은 UserDetails를 이용해서 검증하고 검증에 성공하면 인증된 Authentication 생성

- AuthenticationFilter까지 전달된 Authentication은 SecurityContext에 저장

인증 컴포넌트

1. UsernamePasswordAuthenticationFilter

request를 제일 먼저 만나는 컴포넌트, AbstractAuthenticationProcessingFilter 상속

public class UsernamePasswordAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

	//...

	public UsernamePasswordAuthenticationFilter(AuthenticationManager authenticationManager) {
		super(DEFAULT_ANT_PATH_REQUEST_MATCHER, authenticationManager);
	}

	@Override
	public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
			throws AuthenticationException {
		if (this.postOnly && !request.getMethod().equals("POST")) {
			throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
		}
		String username = obtainUsername(request);
		username = (username != null) ? username.trim() : "";
		String password = obtainPassword(request);
		password = (password != null) ? password : "";
		UsernamePasswordAuthenticationToken authRequest = UsernamePasswordAuthenticationToken.unauthenticated(username,
				password);
		// Allow subclasses to set the "details" property
		setDetails(request, authRequest);
		return this.getAuthenticationManager().authenticate(authRequest);
	}

attemptAuthentication 메서드에서 usernamePasswordAuthenticationToken 생성 (인증에 사용되는 토큰)

토큰을 생성하고 AuthenticationManager의 authenticate 메서드를 호출해서 인증 처리 위임

2. AuthenticationManager

인증 처리를 총괄하는 인터페이스

public interface AuthenticationManager {
   Authentication authenticate(Authentication authentication) throws AuthenticationException;
}

3. ProviderManager

적절한 AuthenticationProvider를 찾아서 AuthenticationProvider에 인증 처리 위임

public class ProviderManager implements AuthenticationManager, MessageSourceAware, InitializingBean {
	//...
    
	public ProviderManager(List<AuthenticationProvider> providers, AuthenticationManager parent) {
		Assert.notNull(providers, "providers list cannot be null");
		this.providers = providers;
		this.parent = parent;
		checkState();
	}

	//...
    
	@Override
	public Authentication authenticate(Authentication authentication) throws AuthenticationException {
		Class<? extends Authentication> toTest = authentication.getClass();
		AuthenticationException lastException = null;
		AuthenticationException parentException = null;
		Authentication result = null;
		Authentication parentResult = null;
		int currentPosition = 0;
		int size = this.providers.size();
		for (AuthenticationProvider provider : getProviders()) {
			if (!provider.supports(toTest)) {
				continue;
			}
			if (logger.isTraceEnabled()) {
				logger.trace(LogMessage.format("Authenticating request with %s (%d/%d)",
						provider.getClass().getSimpleName(), ++currentPosition, size));
			}
			try {
				result = provider.authenticate(authentication);
				if (result != null) {
					copyDetails(authentication, result);
					break;
				}
			}
			catch (AccountStatusException | InternalAuthenticationServiceException ex) {
				prepareException(ex, authentication);
				// SEC-546: Avoid polling additional providers if auth failure is due to
				// invalid account status
				throw ex;
			}
			catch (AuthenticationException ex) {
				lastException = ex;
			}
		}
		if (result == null && this.parent != null) {
			try {
				parentResult = this.parent.authenticate(authentication);
				result = parentResult;
			}
			catch (ProviderNotFoundException ex) {

			}
			catch (AuthenticationException ex) {
				parentException = ex;
				lastException = ex;
			}
		}
		if (result != null) {
			if (this.eraseCredentialsAfterAuthentication && (result instanceof CredentialsContainer)) {
				((CredentialsContainer) result).eraseCredentials();
			}
			if (parentResult == null) {
				this.eventPublisher.publishAuthenticationSuccess(result);
			}

			return result;
		}

		//...
	}

	//...

}

4. AuthenticationProvider

UserDetailsService로부터 전달받은 UserDetails를 이용해서 인증 처리

public class DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {
	//...

	@Override
	@SuppressWarnings("deprecation")
	protected void additionalAuthenticationChecks(UserDetails userDetails,
			UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
		if (authentication.getCredentials() == null) {
			this.logger.debug("Failed to authenticate since no credentials provided");
			throw new BadCredentialsException(this.messages
					.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
		}
		String presentedPassword = authentication.getCredentials().toString();
		if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
			this.logger.debug("Failed to authenticate since password does not match stored value");
			throw new BadCredentialsException(this.messages
					.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
		}
	}

	//...

	@Override
	protected final UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication)
			throws AuthenticationException {
		prepareTimingAttackProtection();
		try {
			UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
			if (loadedUser == null) {
				throw new InternalAuthenticationServiceException(
						"UserDetailsService returned null, which is an interface contract violation");
			}
			return loadedUser;
		}
		catch (UsernameNotFoundException ex) {
			mitigateAgainstTimingAttack(authentication);
			throw ex;
		}
		catch (InternalAuthenticationServiceException ex) {
			throw ex;
		}
		catch (Exception ex) {
			throw new InternalAuthenticationServiceException(ex.getMessage(), ex);
		}
	}

	//...

}

additionalAuthenticationChecks 메서드에서 password 검증

retrieveUser 메서드는 UserDetails를 조회하고 인증에 성공하면 반환