사용 이유

프로젝트가 어느정도 진척되면 docker-compose를 이용하여 redis, postgreSQL, 스프링 어플리케이션을 모두 묶어 CI/CD를 진행하기로 했기에, 로컬 DB를 이용할 수도 있지만 이 후 호환성 고려 및 docker에 조금이라도 더 친숙해지고자 docker를 이용하여 DB를 세팅하기로 결정.

세팅 전 확인

세팅 하기전 컨테이너에 바인딩할 포트를 확인해주세요.. 혹시라도 저처럼 체크하지 않고 그냥 설정할 경우 충돌이 생길 수 있습니다..

윈도우의 경우 아래의 명령어를 이용하여 5432 포트가 사용중인지 확인 후 사용중이라면 호스트의 포트를 변경하여 사용하시면 됩니다.

netstat -ano | findstr 포트번호

1. 도커 이미지 받아오기

docker pull postgres:{version}

자신의 터미널을 실행 후 사용하고자 하는 버전의 postgres의 이미지를 받아옵니다. 최신 버전의 경우 docker pull postgres:latest 사용

2. 컨테이너 실행

docker run -p {호스트 포트}:{컨테이너 포트} --name {컨테이너 이름} \ // 포트 및 컨테이너 이름 설정
-e POSTGRES_PASSWORD={db password} \ // 비밀번호
-d postgres // -d 옵션을 줘서 detached 모드로 사용

컨테이너를 지워도 데이터를 계속 유지시키고자 하면 volume을 생성 후 -v pgdata:/var/lib/postgresql/data 옵션을 추가

docker volume create pgtest

아래와 같은 형태로 실행

docker run -p 5432:5432 --name postgres-container -e POSTGRES_PASSWORD=1234 -e POSTGRES_DB=testdb -d -v pgtest:/var/lib/postgresql/data postgres

docker ps 명령어를 통해 실행 되었는지 확인

3. 컨테이너 접속

아래 명령어를 사용해 접속

docker exec -it <컨테이너 이름> /bin/bash  // -it 옵션을 사용해 배시 셸을 사용
psql -U postgres // default username인 postgres로 접속

접속이 완료되었으면 DB의 접근 권한을 세팅한다.

create role testuser with login password '1234';
alter user testuser with superuser;
\l // 데이터베이스 상태 확인

grant all privileges on database testdb to testuser;

application.yml 설정

spring:
  config:
    activate:
      on-profile: local

  datasource:
    url: jdbc:postgresql://0.0.0.0:5432/testdb
    username: testuser
    password: 1234
    driver-class-name: org.postgresql.Driver
  jpa:
    database: postgresql
    database-platform: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: create

    properties:
      hibernate:
        format_sql: true

테스트를 해보았는데..

에러 발생

PSQLException 에러 발생, 연결 실패. 그런데 문자열이 깨졌다? 에러 내용을 알아야 하는데, Intellij 유니코드 세팅, postgresql 컨테이너의 유니코드 세팅을 다시해도 마찬가지로 깨졌다.

팀원의 도움을 받아 열심히 구글링한 결과

org.springframework.beans.factory.BeanCreationException: 
Error creating bean with name 'entityManagerFactory' 
defined in class path resource[org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaConfiguration.class]: [PersistenceUnit: default] 
Unable to build Hibernate SessionFactory; 
nested exception is org.hibernate.exception.GenericJDBCException: Unable to open JDBC Connection for DDL execution
치명적오류: 호스트 "내 ip", 사용자 "testuser", 데이터베이스 "testdb", 
SSL 중지 연결에 대한 설정이 pg_hba.conf 파일에 없습니다.

다음과 같은 에러였다. 이를 해결하기 위해 열심히 구글링하여 pg_hba.conf, postgresql.conf 파일도 수정해보고, 여러번 도커를 다시 세팅해보아도 해결되지 않았고 한참을 고민하고 삽질한 끝에 원인을 찾았다.

이전에 학습할때 로컬환경에서 사용했던 postgres DB가 생각이 났고, 아래의 명령어를 사용하여 확인해본 결과 5432 포트로 서비스가 계속 실행되고 있었다.

netstat -ano | findstr 5432

이때문에 계속 로컬에 존재하지않는 db와 username로 연결하려고 하니 당연히 될리가 없었고, 문자열이 깨지는 것도 결국 로컬환경의 문제였다. 실행 전 체크해야 됐었던 부분인데 이런 부분 때문에 시간을 낭비하니 너무 아까웠음.. 로컬에서 postgresql이 설치된 경로에 아래 명령어를 사용해 서비스를 중지시키니 정상적으로 작동!

pg_ctl stop -mf -w -D ../data

pg_ctl에 대한 자세한 명령어는 이 곳 참조! https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=iyagi15&logNo=10141652237

설계 미스로 playlist 엔티티와 music 엔티티간 관계가 N:1로 설정되어 있었고, 원하는 실제 동작은 플레이리스트는 N개의 음악을 가지고, 음악 또한 M개의 플레이리스트를 가질 수 있도록 하는 것이기에 설계를 변경해야함

해결 방안

1. 다대다 매핑

   @Entity
   public class Playlist {
   
      @Id 
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      @Column(name = "playlist_id")
      private Long id;
   
      @ManyToMany
      @JoinTable(name = "playlist_music")
      private List<Music> musicList = new ArrayList<>();
   }

   @ManyToMany 어노테이션 사용 시 @JoinTable 어노테이션을 활용해 중간 테이블을 Hibernate가 생성해주지만, 중간 테이블에 PK, FK만 매핑해주기에 추후에 키 이외의 필요한 정보를 컬럼으로 넣어주고자 할 때 문제가 발생

2. 직접 중간 테이블 엔티티 생성하여 매핑 1:N, N:1 관계로 분리한 엔티티를 만들고, 이를 사용하여 매핑 playlist(1) - playlist_music(N) - music(1) 이 후 스펙이 변경될 것을 고려하여 2번을 선택

ERD

아래와 같은 구조로 ER-Diagram을 변경

코드

#Playlist entity
@EntityListeners(AuditingEntityListener.class)
@Entity
public class Playlist {
    ...
    @OneToMany(mappedBy = "playlist")
    private List<Music> musicList = new ArrayList<Music>();
    ...
}

@Entity
#중간 테이블
public class PlaylistMusic {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "playlist_music_id")
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "playlist_id")
    private Playlist playlist;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "music_id")
    private Music music;
}

설정한대로 playlist(1) - playlist_music(N) - music(1) 이 되도록 함

09:00 ~ 18:30 간 공대 6호관 610호에서 수업을 진행하였습니다.

PBL

• Mission 3

어제의 버전관리 시스템 구현 미션을 이어서 진행하였습니다.

구현

VersionService updateCheck()

프론트에서 실제 업데이트 동작을 위한 updateCheck 함수를 작성하였습니다.

# VersionService.java
 // 최신 버전 가져오기
    public Version getRecentVersion(Version version) {

        return versionRepository.findTopByOsInfoAndServiceNameOrderByServiceVersionDesc(version.getOsInfo(), version.getServiceName())
                .orElseThrow(() -> new IllegalArgumentException("해당 os의 최신 버전 찾기 실패"));
        // 체크
    }

    public UpdateCheckResponseDto updateCheck(String osInfo, String serviceName, String serviceVersion) {
        boolean isForcedUpdate = false;
        List<Version> versionList = versionRepository.findByIsDeleteFalseAndOsInfoAndServiceName(osInfo, serviceName)
                .orElseThrow(() -> new IllegalArgumentException("동일한 os와 서비스네임을 가진 서비스가 없음"));
        for (Version version : versionList) {
            if(compareVersion(serviceVersion, version.getServiceVersion())) {
                if(version.isUpdateType() == true) {
                    isForcedUpdate = true;
                    break;
                }
            }
        }

        Version recentVersion = Version.builder().build();
        // String serviceVersion, boolean isRecentVersion, boolean isForcedUpdate
        return new UpdateCheckResponseDto(serviceVersion, compareVersion(serviceVersion, recentVersion.getServiceVersion()), isForcedUpdate);
    }
    public Long getVersionCount() {
        return versionRepository.count();
    }



    public static boolean compareVersion(String serviceVersion, String compareVersion) {
        boolean isNeedsUpdate = false;
        String[] serviceVersionArr = serviceVersion.split(".");
        String[] compareVersionArr = compareVersion.split(".");
        int maxLen = Math.max(serviceVersionArr.length, compareVersionArr.length);
        for (int i = 0; i < maxLen; i++) {
            int x = Integer.parseInt(serviceVersionArr[i]);
            int y = Integer.parseInt(compareVersionArr[i]);
            if (x < y) {
                isNeedsUpdate = true;
            } else {
                isNeedsUpdate = false;
            }
        }
        return isNeedsUpdate;
    }

VersionRepository

명세가 변경되며 변경점이 많았고, 그 과정에서 문법적인 실수와 파라미터 매핑시 순서 실수 등으로 인해

#VersionRepository.java

    Optional<Version> findTopByOsInfoAndServiceNameOrderByServiceVersionDesc(String osInfo, String serviceName);
    List<Version> findByOsInfoAndServiceName(String osInfo, String serviceName);
//    @Query("select v from Version v where v.os_info= osInfo and v.service_name= serviceName and is_delete = false")
    Optional<List<Version>> findByIsDeleteFalseAndOsInfoAndServiceName(String osInfo, String serviceName);

오류 발생

Restful한 API 구현을 위해 기존에 PostMapping으로 구현되어 있던 Read 기능들을 GET Method를 사용하여 받아 오고자 GetMapping RequestParam을 사용하여 Dto를 매핑하였지만, JpaRepository 기능 사용 시 값을 제대로 받아오지 못하는 현상이 발생했습니다. 같은 값이 출력되었고 추가로 분석하여 차이점을 찾으려 했으나 시간이 부족해 실패하였고, 내일 멘토님께 질문을 해봐야겠습니다..

후기

처음 떠올렸던 기능에서 시간이 지나고 피드백을 받으며 스펙을 바꾸며 명세를 수 차례 변경하였습니다. 이 과정에서 제때 바뀐 명세를 반영하지 못하여 에러가 발생하며 시간이 버려지고, 결국 원래 명세하였던 기능 및 추가하고자 하는 기능들을 반영하지 못했습니다. 원래도 짧은 시간의 팀 프로젝트였지만 자바 자체의 문법에 익숙하지 않았고, 디버깅 능력 및 쿼리 작성 능력 부족 등 제 역량 부족으로 인해 더더욱 시간이 부족해져 아쉬웠던 프로젝트 였습니다. 이를 발판으로 하여 부족한 점을 보완하고자 합니다.

09:00 ~ 17:30 간 강원대학교 AI융합 라운지에서 수업을 진행하였습니다.

PBL

• Mission 3

명세

새로운 미션의 목표에 맞춰 getConfigAll API에 대한 명세를 수정하였고, 추가적인 API에 대한 명세를 아래과 같이 진행하였습니다.

• 기본 리스트 화면의 API인 getConfigAll

• Add : Version 정보를 Insert 합니다.

• 수정 : Version 정보를 Update 합니다.

• 삭제 : Version 정보를 Delete 합니다.

• Test : 해당 버전의 정보를 json String으로 정상적으로 출력하는지 확인하는 Test기능

구현

이번에는 기존 GetConfigAll과 versionAdd, Test기능 API 구현 및 스펙 수정, 코드의 리팩토링을 진행하였습니다.

GetConfigAll(A. 기본 리스트 화면)

임시로 표시하기위해 임의의 값를 파라미터로 넣어 사용하였는데, 프론트와 연동을 위해 Dto 및 컨트롤러를 수정하였습니다.

# VersionService

public Page<Version> getVersionList(Integer pageNumber, Integer pageSize) {
        PageRequest pageRequest = PageRequest.of(pageNumber, pageSize);
        return versionRepository.findAll(pageRequest);
    }

# VersionController
 @PostMapping("/getconfigall")
    public ResponseEntity<List<Version>> getConfigAll(@RequestBody VersionPageRequestDto requestDto) {
        return ResponseEntity.ok(versionService.getVersionList(requestDto.getPageNumber(), requestDto.getPageSize()).toList());
    }

VersionAdd (B. ADD)

HTTP Status code 201를 반환하기 위해 created로 리턴하였습니다.

# VersionService

    @PostMapping("/versionadd")
    public ResponseEntity<Version> versionAdd(@RequestBody AddVersionRequestDto requestDto,
                                             UriComponentsBuilder builder){
        // 컨텍스트 상대 경로 URI를 쉽게 만들게 해주는 UriComponentsBuilder를 컨트롤러 메서드의 인자로 지정
        Version version = Version.createVersion(requestDto);
        versionService.saveVersion(version);

        URI location = builder.path("/vercontrol/versionadd")
                .buildAndExpand(version.getId()).toUri();

        return ResponseEntity.created(location).body(version);
    }

getversion (E. Test)

PathVariable로 id를 받아와 해당 정보를 리턴

# VersionController

    @GetMapping("/getversion/{id}")
    public ResponseEntity<Version> getVersion(@PathVariable Long versionId) {
        return ResponseEntity.ok(versionService.findById(versionId));
    }

리팩토링

위 사진과 같이 기존 컨트롤러 단에서 builder를 호출하여 객체를 만드는 것이 OOP와 멀어지고 실제 유지보수에도 좋지 않다 판단하여 엔티티에 createVersion 함수를 추가하여 리팩토링 하였습니다.

# Version.java

    @Builder
    public static Version createVersion(VersionRequestDto versionRequestDto) {
        Version version = Version.builder()
                .osInfo(versionRequestDto.getOsInfo())
                .serviceVersion(versionRequestDto.getServiceVersion())
                .serviceName(versionRequestDto.getServiceName())
                .updateType(versionRequestDto.isUpdateType())
                .message(versionRequestDto.getMessage())
                .packageInfo(versionRequestDto.getPackageInfo())
                .build();

        return version;

    }

후기

프론트와 API 통신 과정에서 잘못된 명세 및 구현하며 수정된 부분으로 인해 명세와 달라져 시간이 지체된 부분이 있었는데, 정확한 명세와 명세에 따른 구현, 수정시 명세또한 수정되어야 한다는 점을 간과했던 것 같습니다. 프론트와 백엔드, 즉 팀원간 소통 및 협업이 부족하다 느껴 더 시간을 더 투자하여 진행하고자 합니다.

09:00 ~ 16:30 간 강원대학교 AI융합 라운지에서 수업을 진행하였습니다.

PBL

• Mission 2

명세

팀원분들과 API에 어떤 파라미터와 아웃풋 값이 필요할지 논의하여, 그 결과를 통해 getConfig, getConfigAll API에 대한 명세를 아래과 같이 진행하였습니다.

구현

아래와 같은 예시 화면이 안내되었습니다.

GetConfigAll

DB의 객체를 나누어 가져오는 방식에 대해 백엔드 팀원분과 토의하였고, 모두 가져와 나누자, 쿼리를 보내 가져오자, 프론트에서 처리하자(?) 등 다양한 의견이 나왔고, 그 중 가장 손쉬운 방법인 JPA Paging 방법을 발견하고 다음과 같이 구현하였다.

# VersionService

    public Page<Version> getVersionList(int count) {

        # PageRequest 임시로 0 설정 매개변수는 (page,size) 형태

        PageRequest pageRequest = PageRequest.of(0,count);
        return versionRepository.findAll(pageRequest);
    }

GetConfig

querydsl, @Query 어노테이션 사용 등 다양한 방법을 떠올리고 시도했지만, 코딩하던 중간에 배터리가 없어 방전되는 바람에 코드가 증발해서 다른 팀의 백엔드 팀원분께 도움을 요청했고, JPA의 findTopby와 OrderBy를 이용하여 구현하였습니다.

# VersionService

    public Version getRecentVersion(Version version) {
        #findTop N By 형태로 사용, 생략시 default값인 1이 들어감
        return versionRepository.findTopByOsInfoOrderByServiceVersionDesc(version.getOsInfo())
                .orElseThrow(() -> new IllegalArgumentException("해당 os의 최신 버전 찾기 실패"));
    }

오류 발생

프론트엔드와 백엔드 간 데이터를 주고받지 못하는 cors 문제가 발생하여 일단 테스트 진행을 위해 컨트롤러에 @CrossOrigin 어노테이션을 붙여 급한 불은 껐지만, 이렇게 모든 origin에 대해 허용해놓으면 보안상 문제가 될 것이라고 생각되서, 다시 수정할 예정입니다.

@RestController
@CrossOrigin
@RequestMapping("/vercontrol")
@RequiredArgsConstructor
public class VersionApiController {

후기

수업중 갑작스럽게 질문들을 받았는데, 바로 떠오르지 않아 대답을 못했습니다. 제가 알고있다고 생각한 개념이 사실은 완전히 체화되지 않은 지식이였고, 기술 면접 진행 시에도 대처능력을 기르기 위해 다시 한번 개념을 정리하고 재학습의 필요성을 느꼈습니다. 그리고 코드를 작성하다보니 바로바로 메소드들이 떠오르지않아 시간이 지체되고 중간에 실수도 하였습니다. 또한 오류 발생 시에도 어디서 문제가 발생했는지 찾고 대처하는데 시간이 많이 소요되어 스프링 프레임워크 자체에 대한 공부도 더 해야할 필요성을 느꼈습니다.

참조

JPA 페이징 https://velog.io/@conatuseus/JPA-Paging-%ED%8E%98%EC%9D%B4%EC%A7%80-%EB%82%98%EB%88%84%EA%B8%B0-o7jze1wqhj PageRequest https://docs.spring.io/spring-data/commons/docs/current/api/org/springframework/data/domain/PageRequest.html JPA Limit, order 처리하기 https://devfunny.tistory.com/571

09:00 ~ 15:30 간 강원대학교 공대 6호관 강의실에서 수업을 진행하였습니다.

📙 PBL (Project Based Learning) 수업

프로젝트 기반의 수업

• Scrum

  • 스크럼 회의의 분야를 크게 세가지로 나누어 진행

  • Tech, Domain, Business Modeling

• Mission 1. 버전 관리 시스템

📙 활동 기록

• 문장 정리 시퀀스 다이어그램 작성을 위해 먼저 카카오톡의 버전관리를 레퍼런스로 정하고 버전 관리 시스템의 기능들에 관해 팀원들과 어떤 기능이 필요한지 토론을 진행하였습니다. 토론 과정에서 버전관리에 관한 다양한 기능들을 딱 한 문장으로 정의하는 것에 어려움을 느꼈습니다. 떠오른 문장들을 다음과 같이 아젠다 -> 목적 -> 액션 -> 데이터 형태로 아래 사진과 같이 명세하였습니다. 명세하는 과정에서도 다른 아젠다와 목적이 같거나 혹은 같은 액션을 지닌 아젠다가 많아, 명세에 어려움을 겪었습니다.

정리한 아젠다중 하나인 버전 관리를 한다 라는 아젠다를 도식화 하기로 정한 후, 시퀀스 다이어그램 도식화 전 재 정리를 진행 하였습니다.

• 시퀀스 다이어그램 도식화 정리한 명세를 기반으로 시퀀스 다이어그램을 작성하였습니다. 모든 아젠다에 대해 도식화를 진행하지 못해 아쉬웠습니다.

후기

스크럼, 시퀀스 다이어그램 도식화 등 이론으로는 접해 보았지만, 기억이 잘 나지않거나 애매모호 하여, 실제로 프로젝트에 적용하는 부분에서 많은 시행착오와 어려움을 겪었습니다. 지금까지 팀 프로젝트를 진행하며 명세는 대부분 기능에 대한 로직 및 처리를 위한 단순 명세, ERD를 통한 스키마 설계에서 그쳤고, 대부분의 기능은 레퍼런스 혹은 구글링을 통해 단순 코딩으로 추가하였습니다. 이렇게 문서를 작성해보며 느낀 점은, 문서화의 중요성에 대해서는 알고 있었지만, 이론을 몸소 경험해 보니 제가 지금까지 프로젝트를 진행해 왔던 방법 보다는 실제 프로젝트 진행 시 문서를 작성하며 프로젝트를 진행하는 것이 유지보수면, 효율성 등 모든 면에서 뛰어남을 다시 한번 체감할 수 있었습니다.

참고

스크럼 https://medium.com/dtevangelist/scrum-dfc6523a3604 시퀀스 다이어그램 작성법 https://coding-factory.tistory.com/806

📙 프레젠테이션

Spring Security의 Authorization에 대해 프레젠테이션을 진행 팀원분과 이론적인 부분과 실제 사용 예시로 파트를 나누었고, 아래와 같이 antMatchers 예제, 실제 사용 예시, 그리고 OAuth에 대해 발표를 진행하였다.

📙 특강

현재 수준에서의 백엔드 주니어 개발자가 어떤 식으로 준비해 나가야 할지 방향성에 대한 조언과 기술 면접에서의 경험의 중요성 등에 대해 말씀해주셨다. 앞으로 취업을 위해 부족하다고 느꼈던 부분들(기술면접, 코테, 코딩 능력 등)을 채우기 위해 어떤식으로 시간을 투자할지 다시금 정리해야겠다는 생각을 가지게 해준 시간.

이론 교육 끝!

다음주 진행될 팀 프로젝트에 대비해 배웠던 내용들 정리 및 복습!

📙 실습

원래 JWT 발급시 TokenProvider에 refreshToken과 accessToken의 발급과 재발급 코드를 모두 때려박아서 사용했는데, 아래처럼 코드를 분리하니 책임이 분리되고 유지보수의 효율이 높아져 더욱 객체지향적인 코드가 되는것 같다.. 생각도 못한 코드

TokenService.java

@RequiredArgsConstructor
@Service
public class TokenService {

    private final TokenProvider tokenProvider;
    private final RefreshTokenService refreshTokenService;
    private final UserService userService;

    public String createNewAccessToken(String refreshToken) {
        // 토큰 유효성 검증
        if(tokenProvider.validToken(refreshToken)) {
            throw new IllegalArgumentException("unexpected token");
        }

        Long userId = refreshTokenService.findByRefreshToken(refreshToken).getUserId();
        User user = userService.findById(userId);

        return tokenProvider.generateToken(user, Duration.ofHours(2));
    }

}

RefreshTokenService.java

@RequiredArgsConstructor
@Service
public class RefreshTokenService {
    private final RefreshTokenRepository refreshTokenRepository;

    public RefreshToken findByRefreshToken(String refreshToken) {
        return refreshTokenRepository.findByRefreshToken(refreshToken)
                .orElseThrow(() -> new IllegalArgumentException("unexpected refreshtoken"));
    }

}

TokenApiController.java

@RequiredArgsConstructor
@RestController
public class TokenApiController {

    private final TokenService tokenService;

    @PostMapping("/api/latest/token")
    public ResponseEntity<CreateAccessTokenResponseDto> createNewAccessToken(@RequestBody CreateAccessTokenRequestDto createAccessTokenRequestDto) {
        String newAccessToken = tokenService.createNewAccessToken(createAccessTokenRequestDto.getRefreshToken());
        return ResponseEntity.status(HttpStatus.CREATED)
                .body(new CreateAccessTokenResponseDto(newAccessToken));
    }


}

📙 CI/CD

• AWS EC2 인스턴스 우분투 서버 생성 및 SSH를 통한 접속을 위한 세팅

  • 인스턴스가 껐다 켜졌을때를 위해 탄력적 IP주소도 세팅

• TCP 8080 포트 보안규칙 추가 (실제 진행시 편의를 위해 모든 범위 추가함)

• EC2 도커 환경 설정

• 우분투 내 환경 설정

  sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add
  sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
  sudo apt-get install docker-ce docker-ce-cli containerd.io
  sudo chmod 666 /var/run/docker.sock

• docker 이미지 세팅 후 키 생성 ssh-keygen -t rsa -b 4096 -C "[내 메일주소]" -f spring-cicd

• CI/CD를 위해 나온.pub 키 내용으로 ~/.ssh/authorized_keys2 생성

• Github Action 명세서 main.yml을 디렉토리 최상단/.github/workflows 디렉토리에 작성

  name: Java CI with Gradle
  

on: push: branches: [ main ]

jobs: build:

runs-on: ubuntu-latest

steps:
  - uses: actions/checkout@v2
  - name: Set up JDK 11
    uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: '<<<OPEN JDK 이름>>>'
  - name: Grant execute permission for gradlew
    run: chmod +x gradlew
  - name: Build with Gradle
    run: ./gradlew build -x test
  - name: Docker build
    run: |
      docker login -u ${{ secrets.DOCKER_HUB_USERNAME }} -p ${{ secrets.DOCKER_HUB_PASSWORD }}
      docker build -t spring-cicd . 
      docker tag spring-cicd <<<도커허브아이디>>>/spring-cicd:${GITHUB_SHA::7}
      docker push <<<도커허브아이디>>>/spring-cicd:${GITHUB_SHA::7}
  - name: Deploy
    uses: appleboy/ssh-action@master
    with:
      host: <<<AWS EC2 호스트>>>
      username: ubuntu
      key: ${{ secrets.KEY }}
      envs: GITHUB_SHA
      script: |
        docker pull <<<도커허브아이디>>>/spring-cicd:${GITHUB_SHA::7}
        docker tag <<<도커허브아이디>>>/spring-cicd:${GITHUB_SHA::7} spring-cicd
        docker stop server
        docker rm -f server
        docker run -d --name server -p 8080:8080 spring-cicd

- 깃허브에 푸시후 Actions 탭 확인
- done !
![](https://velog.velcdn.com/images/jwjin_dev/post/fddabc3f-a907-4d62-a40a-dff41838f105/image.png)

JWT (JSON Web Token)

• 유저를 인증하고 식별하기 위한 토큰 기반 인증

• 세션과 달리 서버가 아닌 클라이언트에 저장됨

• 인증, 인가에 필요한 모든 정보를 자체적으로 지님

JWT의 구조

• .을 구분자로 헤더, 내용, 서명 3가지의 암호화된 문자열로 이루어짐

• 헤더(Header)

  • 토큰의 타입과 해시 암호화 알고리즘에 대한 정보를 가짐

• 내용(Payload)

  • 토큰에 담을 정보가 들어있음
  • 클레임(Claims) 단위로 저장, 클레임은 키/값 쌍을 뜻함

• 서명(Signature)

  • 토큰의 유효성 검증 시 사용
  • 헤더와 정보의 암호화 값, 비밀 키 값을 지정한 암호화 알고리즘으로 서명하여 생성

Access Token, Refresh Token

• 단순 액세스 토큰만으로는 토큰 탈취 시 보안이 취약해지기 때문에, 이를 보완하기 위해 두개의 토큰으로 나눠서 사용

• Access Token

  • 사용자 권한 인증 및 권한 접근에 사용하는 토큰
  • 2~3시간 정도의 짧은 유효시간
  • DB에 저장되지 않음

• Refresh Token

  • 액세스 토큰 재발급을 위해 사용하는 토큰

  • 15일 정도의 긴 유효시간을 가짐

  • DB에 저장됨

    JwtProperties

    @Getter
    @Setter
    @Component
    @ConfigurationProperties("jwt") // 프로퍼티에 경로를 바인딩하여 해당 경로의 값 참조
    public class JwtProperties {
    private String issuer;
    private String secret;
    }

    TokenAuthenticationFilter

    @RequiredArgsConstructor
    public class TokenAuthenticationFilter extends OncePerRequestFilter {
    private final TokenProvider tokenProvider;
    private final static String HEADER_AUTHORIZATION = "Authorization";
    private final static String TOKEN_PREFIX = "Bearer ";
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
       // 요청 헤더의 authorization 키 값 조회
       String authorizationHeader = request.getHeader(HEADER_AUTHORIZATION);
    
       // 가져온 값에서 접두사 제거
       String token = getAccessToken(authorizationHeader);
    
       // 가져온 토큰값이 유효한지 확인, 유효하다면 인증 정보를 만든다
       if(tokenProvider.validToken(token))
       {
           Authentication authentication = tokenProvider.getAuthentication(token);
           SecurityContextHolder.getContext().setAuthentication(authentication);
       }
    
       filterChain.doFilter(request, response);
    }
    
    private String getAccessToken(String authorizationHeader) {
       if(authorizationHeader != null && authorizationHeader.startsWith(TOKEN_PREFIX))
       {
           return authorizationHeader.substring(TOKEN_PREFIX.length());
       }
    
       return null;
    }
    }

TokenProvider // RefreshToken 관련 리포지토리 및 서비스 생성하여 사용

@RequiredArgsConstructor
@Service // 토큰 생성 및 검증 서비스
public class TokenProvider {

    private final JwtProperties jwtProperties;
    private final RefreshTokenService refreshTokenService;

    public Tokeninfo generateToken(User user, Duration accessTokenExpiredAt, Duration refreshTokenExpiredAt) {
        Date now = new Date();
        String accessToken = makeAccessToken(new Date(now.getTime()+accessTokenExpiredAt.toMillis()), user);
        String refreshToken = makeRefreshToken(new Date(now.getTime()+refreshTokenExpiredAt.toMillis()), user);
        refreshTokenService.saveToken(user.getEmail(), refreshToken);

        return Tokeninfo.builder()
                .accessToken(accessToken)
                .refreshToken(refreshToken)
                .build();
    }

    // 다형성 ?
    public String makeAccessToken(Date expiry, User user){
        Date now = new Date();
        return Jwts.builder()
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE) // 헤더 타입 : JWT
                .setIssuer(jwtProperties.getIssuer())
                .setIssuedAt(now)
                .setExpiration(expiry)
                .setSubject(user.getEmail())
                .claim("id", user.getId())
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecret())
                .compact();
    }

    public String reissueAccessToken(User user, String refreshToken, Duration accessTokenExpiredAt){
        if(validRefreshToken(user, refreshToken))
        {
            Date now = new Date();;
            return makeAccessToken(new Date(now.getTime()+accessTokenExpiredAt.toMillis()), user);
        }
        return null;
    }

    public String makeRefreshToken(Date expiry, User user){
        Date now = new Date();
        String refreshToken = Jwts.builder()
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE) // 헤더 타입 : JWT
                .setIssuer(jwtProperties.getIssuer())
                .setIssuedAt(now)
                .setExpiration(expiry)
                .setSubject(user.getEmail())
                .claim("id", user.getId())
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecret())
                .compact();

        // 저장소에 저장

        return refreshToken;
    }

    public boolean validToken(String token) {
        try{
            Jwts.parser()
                    .setSigningKey(jwtProperties.getSecret())
                    .parseClaimsJws(token);

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public boolean validRefreshToken(User user, String refreshToken) {
        if(validToken(refreshToken)) {   
            String savedToken = refreshTokenService.findByEmail(user.getEmail()));
            if(savedToken == refreshToken) {
                return true;
            }
        }
        return false;
    }

    // 토큰 기반으로 인증 정보를 가져오는 작업
    public Authentication getAuthentication(String token) {
        Claims claims = getClaims(token);
        // Authentication -> principal, credentials, authorities
        // collections 보기
        Set<SimpleGrantedAuthority> authorities = Collections.singleton(new SimpleGrantedAuthority("ROLE_USER"))
        return new UsernamePasswordAuthenticationToken(
                new org.springframework.security.core.userdetails.User(
                        claims.getSubject(), "",authorities
                ), // principal
                token, // credentials
                authorities
        );
    }

    public Long getUserId(String token) {
        Claims claims = getClaims(token);

        return claims.get("id", Long.class);
    }
    private Claims getClaims(String token) {
        return Jwts.parser()
                .setSigningKey(jwtProperties.getSecret())
                .parseClaimsJws(token)
                .getBody();
    }

}

📙 이론

Thymeleaf

• 템플릿 엔진의 일종

• 순수 HTML을 최대한 유지 (네츄럴 템플릿)

• SSR 방식

  • 서버 사이드 렌더링(SSR) : 서버에서 사용자에게 보여줄 페이지를 모두 미리 구성한 뒤 페이지를 렌더링을 하는 방식
  • 클라이언트 사이드 렌더링(CSR) : 서버에서 전체 페이지(빈 페이지)를 최초 렌더링하고 사용자가 요청할 때마다 클라이언트 내(브라우저)에서 렌더링 하는 것을 의미

Spring Security

• 보안(인증과 권한, 인가 등)을 담당하는 스프링 하위 프레임워크

  • 인증(Authentication) : 식별 가능한 정보를 통해 사용자의 신원을 확인하는 절차

  • 인가(Authorization) : 인증된 사용자가 리소스에 접근 시 권한 부여

• 인증과 권한 처리를 필터들의 집합인 FilterChain 형태로 처리

• 다음과 같은 Flow로 동작

• UsernamePasswordAuthenticationFilter을 이용한 인증 과정

  • 인증 요청시 UsernamePasswordAuthenticationFilter 에서 Request의 username, password를 통해 UsernamePasswordAuthenticationToken 생성

  • AuthenticationManager의 구현체인 ProviderManager에게 인증 책임을 위임

  • ProviderManager는 해당 인증을 위한 Provider에게 인증 책임을 위임

  • 해당 Provider는 인증 절차를 수행하며, 빈으로 등록한 UserDetailsService로 부터 해당 정보를 가진 사용자의 정보를 받아와 인증 절차 수행.

  • 인증 성공 후 Principal(인증된 사용자 객체), Credentials(자격 증명), Authorities(접근 권한)등 을 담은 Authentication 객체를 생성

  • SecurityContextHolder 객체 안의 SecurityContext에 저장하여 전역적으로 사용

📙 실습

Spring Security 실습 (1)

WebSecurityConfig.java

@Configuration
@RequiredArgsConstructor
public class WebSecurityConfig {

    private final UserDetailsServiceImpl userDetailsServiceImpl;

    // 스프링 시큐리티 기능 비활성화 부분 설정
    @Bean
    public WebSecurityCustomizer configure() {
        return (web) -> web.ignoring()
                //.requestMatchers(toH2Console())
                .antMatchers("/static/**");
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
                .authorizeRequests()
                .antMatchers("/login", "/signup", "/user").permitAll()
                .anyRequest().authenticated()

                .and()
                .formLogin() // 폼 로그인 방식 사용
                .loginPage("/login")
                .defaultSuccessUrl("/articles")

                .and()
                .logout() // 로그아웃 설정
                .logoutSuccessUrl("/login")
                .invalidateHttpSession(true) // 찾아보기

                .and()
                .csrf().disable()
                .build();
    }

    // 인증 관리자 관련 설정
    @Bean
    public AuthenticationManager authenticationManager(HttpSecurity http, BCryptPasswordEncoder bCryptPasswordEncoder, UserDetailService userDetailService) throws Exception {
        return http
                .getSharedObject(AuthenticationManagerBuilder.class)
                .userDetailsService(userDetailService)
                .passwordEncoder(bCryptPasswordEncoder)
                .and()
                .build();

    }

    // 패스워드 인코더로 사용할 빈 등록
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

}

UserDetailsServiceImpl.java

• UserDetailsService의 구현체

@RequiredArgsConstructor
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    private final UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        System.out.println("email = " + email);
        System.out.println(userRepository.findByEmail(email).get().getPassword());

        return userRepository.findByEmail(email)
                .orElseThrow(() -> new IllegalArgumentException("not found email"));
    }
}

-- 진행 중

📙 이론

JPA (Java Persistence API)

• Java에서의 ORM 기술 표준으로 사용하는 인터페이스 모음

  • ORM (Obeject-Realational Mapping) 이란?
    • 객체와 RDB(Realational DataBase)의 데이터를 자동으로 매핑해주는 도구
    • 즉, 객체를 RDB의 테이블에 자동으로 영속화 해주는 것

• 인터페이스이기 때문에 구현체가 필요, 대표적으로 Hibernate가 있음

• 영속성 컨텍스트 (Persistence Context)

  • 엔티티를 영구 저장하는 환경
  • entitiyManagerFactory에서 생성된 EntityManager를 통해 엔티티를 조회하거나 엔티티를 보관하고 관리
  • EntityManager 생성시 논리적인 개념의 영속성 컨텍스트가 하나 만들어짐

• 영속성 컨텍스트 특징

  1. 1차 캐시

     • persist로 엔티티 영속시에 영속성 컨텍스트의 1차 캐시에 저장됨. 엔티티 접근 시 우선 1차 캐시에서 조회 후 없을 시 DB 조회를 진행함.
     • 특징
       • 같은 엔티티의 동일성 보장

  2. 쓰기 지연

     • persist로 엔티티를 영속시킬 시 바로 DB에 반영하지 않고 내부 저장소에 SQL를 저장해 두었다가 트랜잭션 커밋 시점에 한번에 처리

  3. 변경 감지(Dirty checking)

     • flush() 함수 호출시 저장된 엔티티의 스냅샷과 현재 엔티티를 비교하여 변경 사항이 있을 시 내부 저장소에 SQL을 저장해 두었다가 DB에 반영 후 커밋

  4. 지연 로딩, 즉시 로딩

     • 지연 로딩 : 연관관계가 매핑된 엔티티 조회시 해당 엔티티의 참조 객체를 사용하는 시점에 조회하는 방법

     • 즉시 로딩 : 연관관계가 매핑된 엔티티 조회시 해당 엔티티의 모든 객체를 조회하는 방법

JDBC (Java DataBase Connectivity)

• DB 접근을 위해 Java에서 제공하는 API

Spring Data JPA

• 스프링 프레임워크에서 JPA를 편리하게 사용할 수 있도록 지원하는 프로젝트

• SQL이 아닌 객체 중심으로 개발 -> 생산성 증대, 유지보수 난이도 낮음

• 기본적인 CRUD SQL를 작성하지 않아도 된다.

• JpaRepository<Entity, ID 자료형> 와 같은 형태로 레포지토리에 상속받아 사용

• Spring Data JPA의 작동구조는 다음과 같다.

📙 실습

Blog API 구축

Lombok 어노테이션 사용 및 JPA Auditing을 통한 자동 시간 매핑

# Article.java

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@EntityListeners(AuditingEntityListener.class) // Auditing 기능 추가
@Entity
public class Article {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", updatable = false)
    private Long id;

    @Column(name = "title", nullable = false)
    private String title;

    @Column(name = "content", nullable = false)
    private String content;

    @CreatedDate
    @Column(name = "created_at")
    private LocalDateTime createAt;

    @LastModifiedDate
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    @Builder
    public Article(String title, String content) {
        this.title = title;
        this.content = content;
    }

    public void update(String title, String content){
        this.title = title;
        this.content = content;
    }

}

main 함수에서 @EnableJpaAuditing 어노테이션을 붙여서 활성화를 시켜 주어야함.

# BeDay6Application.java

@EnableJpaAuditing
@SpringBootApplication
public class BeDay6Application {

    public static void main(String[] args) {
        SpringApplication.run(BeDay6Application.class, args);
    }

}

📙 이론

• AOP(Aspect Oriented Programming, 관점 지향 프로그래밍)

  • 코드에서 핵심적인 로직과 부가 기능을 분리하여 모듈화 하는 것

  • 이렇게 공통적으로 필요한 부가기능들을 사용 ex) 에러 핸들링, 로깅, 성능 측정 등

  • OOP(Object Oriented Programming, 객체 지향 프로그래밍) 을 더욱 발전시키기 위한 개념

📙 실습

• a. Member 도메인에 대한 CRUD 개발

  • 조건1. DB가 아닌 List 사용

  • 조건2. Grade enum 대신 String을 사용

  • Member -> Long id, String name, String grade

    

MemberController 코드는 다음과 같다

@RestController
@RequestMapping("/api")
public class MemberController {

    private final MemberService memberService;

    public MemberController(MemberService memberService) {
        this.memberService = memberService;
    }

    @PostMapping("/join")
    public ResponseEntity<String> join(@RequestBody Member member) {
        memberService.join(member);
        System.out.println("member.getId() = " + member.getId());
        return ResponseEntity.ok("가입 완료");
    }

    @GetMapping("/info/{id}")
    public ResponseEntity<Member> memberInfo(@PathVariable Long id) {
        Member member1 = memberService.findMember(id);
        System.out.println("member1 = " + member1);
        return ResponseEntity.ok(member1);
    }

    @PutMapping("/update/{id}")
    public ResponseEntity<String> update(@PathVariable Long id, @RequestBody Member member) {
        memberService.updateMember(id, member);
        return ResponseEntity.ok("수정 완료");
    }

    @DeleteMapping("/withdraw/{id}")
    public ResponseEntity<String> withdraw(@PathVariable Long id) {
        memberService.deleteMember(id);
        return ResponseEntity.ok("탈퇴 완료");
    }
}

• b. Postman으로 동작 확인

  위 컨트롤러에 매핑된 주소로 api 테스트

  회원 가입 @PostMapping("/join")

회원 정보 조회 @GetMapping("/info/{id}")

회원 정보 수정 @PutMapping("/update/{id}") 수정 후 조회

회원 정보 삭제 @DeleteMapping("/withdraw/{id}")

• c. bootJar로 빌드하고 수동 실행하여 정상적인 서비스 동작 확인

  

이하 위와 동일하게 Postman으로 테스트 진행 후 정상 동작 확인

• d. Docker 이미지로 만들고 dockerhub 저장소에 0.0.2 버전으로 push

• e. push한 0.0.2 버전을 pull하여 도커에 내려받고 컨테이너 방식으로 동작시킨 후 정상 서비스 동작 확인

이하 위와 동일하게 Postman으로 테스트 진행 후 정상 동작 확인

• f. 개인 github에 커밋, 푸시

https://github.com/jw-jin/codestates_BE

📙 이론

• 싱글톤
  • 객체의 인스턴스를 하나만 생성하여 사용하는 패턴
  • 메모리 낭비 방지 및 데이터 공유의 용이성
  • @Configuration, 스프링 빈은 싱글톤 스코프로 생성 (빈은 스코프 변경 가능)
• HTTP의 4가지 메소드
  • DispatcherServlet을 통해 컨트롤러에 매핑
  • GET -> Create
  • POST -> Read
  • PUT -> Update
  • DELETE -> Delete

• Docker

📙 실습

• CRUD 매핑만 진행한 RestController 구현

@RestController
@RequestMapping("/api/latest") // api 주소 매핑
public class TestController {
      // Create
      @PostMapping("/test")
      public ResponseEntity<String> create(@RequestBody Map<String, String> map) {
          // val1
          // val2
          System.out.println("map.val1 = " + map.get("val1"));
          System.out.println("map.val2 = " + map.get("val2"));
          return ResponseEntity.ok("CREATED");
      }

      // Read 
      @GetMapping("/test/{id}")
      public ResponseEntity<String> read(@PathVariable Long id) {
          System.out.println("id = " + id);

          return ResponseEntity.ok("Hello World KNU");
      }

      // Update
      @PutMapping("/test/{id}")
      public ResponseEntity<String> update(@PathVariable Long id, @RequestBody Map<String, String> map) {
          System.out.println("id = " + id);
          System.out.println("map.val1 = " + map.get("val1"));
          System.out.println("map.val2 = " + map.get("val2"));

          return ResponseEntity.ok("UPDATED");
      }

      // Delete
      @DeleteMapping("/test/{id}")
      public ResponseEntity<String> delete(@PathVariable Long id) {
          System.out.println("id = " + id);
          return ResponseEntity.ok("DELETED");
      }

• Docker를 이용한 스프링 프로젝트 배포

1. 스프링 프로젝트 빌드 - Gradle bootJar 를 통해 jar 파일 생성

2. 최상단 디렉토리에 아래와 같은 내용으로 Dockerfile 생성

   # base-image
   FROM openjdk:11
   # COPY에서 사용될 경로 변수
   ARG JAR_FILE=build/libs/*.jar
   # JAR 빌드 파일을 도커 컨테이너로 복사
   COPY ${JAR_FILE} app.jar
   # JAR 파일 실행
   ENTRYPOINT ["java","-jar","/app.jar"]

3. 아래 명령어로 빌드하여 도커 이미지 생성, 명령어 끝에 . 에 주의할 것

   $ docker build -t <이미지 이름:태그> . 

   

4. docker images, docker run 명령어를 통해 생성된 이미지 확인 및 컨테이너 생성

$ docker run <이미지 이름:태그>

5. dockerhub에 이미지 푸시를 위해 아래 명령어를 이용해 이미지 네이밍 변경

   $ docker tag <이미지 이름>:<태그> <dockerhub 사용자 이름>/<새 이미지 이름>:<새 태그>
   // 

6. 도커허브에 푸시

$ docker push <dockerhub 사용자 이름>/<새 이미지 이름>:<새 태그>

정상적으로 푸시 되었고, pull 명령어를 사용하여 이미지를 가져오면 된다.

📙 이론

• 클래스 -> 클래스, 인터페이스 -> 인터페이스 단일 상속 시 extends 키워드 사용

• 인터페이스 -> 클래스, 상속 시 implements 키워드 사용 (구현 필요)

• 관심사의 분리

  • 인터페이스와 로직의 분리
  • 역할을 명확하게 하여 낮은 결합도 달성

• 관심사의 분리 예제 ) Layered Architecture
  • 프레젠테이션 레이어 : Controller, Request 및 Response 처리
  • 서비스 레이어 : Service, 두 계층 사이 연결 역할, 비즈니스 로직 구현, 연결을 위한 인터페이스 제공
  • 퍼시스턴스 레이어: Repository, DB 연결 역할, 데이터 처리 및 객체화

📙 실습

• 서비스와 리파지토리의 연결성을 끊어낼 수 있는 방법 (관심사의 분리)

  아래 예제는 DB등 다른 저장소로 변경 시, 즉 기능 확장 시에 코드가 변경되므로 OCP를 위반, 또한 구현체를 인터페이스가 아닌 서비스 클래스가 직접 설정하므로, DIP를 위반

    public class MemberServiceImpl implements MemberService {
        private final MemberRepository memberRepository = new TempMemberRepository();
    }

외부에서 구현체의 의존관계 주입(DI)에 집중하는 AppConfig 클래스

    @Configuration
    public class AppConfig {
      @Bean
      public MemberService memberService() {
          return new MemberServiceImpl(memberRepository());
      }

      @Bean
      public MemberRepository memberRepository() {
          return new TempMemberRepository();
      }

구현체의 실행에 집중하는 변경된 MemberServiceImpl 클래스

  public class MemberServiceImpl implements MemberService {

    private final MemberRepository memberRepository;

    public MemberServiceImpl(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }
}

• 위의 변경 사항을 통해 Repository 변경 시 MemberServiceImpl의 코드를 수정 할 필요가 없으므로 OCP를 만족
• TempMemberRepository 와 같은 구현체를 의존하는 것이 아닌 MemberRepository 인터페이스를 의존하게 되므로 DIP를 만족

스프링 컨테이너(ApplicationContext)에 등록된 Bean을 가져와 다음과 같이 사용 (IoC)

    //AppConfig appConfig = new AppConfig();

    ApplicationContext applicationContext = 
            new AnnotationConfigApplicationContext(AppConfig.class);

    // DI, IoC
    MemberService memberService = 
            applicationContext.getBean("memberService", MemberService.class);

    Member member = new Member(1L,"A", Grade.MEMBER);
    memberService.join(member);

📙 Extra

• SOLID 원칙중 DIP, OCP

• DIP(Dependency Inversion Principle) : 의존 역전 원칙

  • 상위 모듈은 하위 모듈의 구현에 의존해서는 안 되며, 하위의 모듈이 상위 모듈에 정의한 추상화에 의존 해야한다는 원칙

  • 구현과 역할의 분리, 클래스(구현)에 의존하지 않고, 인터페이스(역할)에 의존

  • 인터페이스에 의존함으로서, 확장이 가능하고 변화에는 폐쇄적인 OCP도 만족

• OCP(Open Closed Principle) : 개방 폐쇄 원칙

  • 자신의 확장에는 열려있어야 하고, 주변의 변화에는 닫혀있어야 한다는 원칙

  • 요구사항 변경시 기존 요소는 수정이 일어나면 안되며, 확장을 통한 재사용이 가능해야함

지난 1일차는 OT 및 전반적인 웹 개발 및 웹 백엔드의 개념, 앞으로의 커리큘럼에 대해 말씀해주셨다.

2023-06-27 SW 직무역량 부트캠프 2일차 TIL

🧭 지난 과제

• 클래스, 인터페이스의 문법 구조와 쓰임새
• 다형성이란?

📙 이론

• 클래스, 인터페이스, 다형성

  • 클래스 : 객체를 추상화하여 객체를 생성할 수 있게해주는 설계
  • 인터페이스 : 다형성을 가진 추상 클래스
  • 다형성 : 하나의 객체가 여러 타입을 가질 수 있는 성질 ex) 인터페이스, 오버로딩, 오버라이딩 등등

• 웹 애플리케이션 동작 개념

  • 회원가입을 예로든 전반적인 HTTP 동작 과정의 flow와 CRUD
  • Java Servlet
    • HTTP 요청과 응답시 필요한 과정을 간소화 시켜주는 기술

📙 실습

• 순수 자바만으로 CRUD 구현

• 명세

• 제시해주신 명세에 따라 페어 프로그래밍으로 아래 구조로 구현을 진행

라이브 코딩을 진행하시면서, 인터페이스를 이용한 클래스 구현시의 예시를 드시며 다형성과 객체지향 프로그래밍, 스프링부트에서의 DIP, OCP, DI, IOC에 대해 엄청 강조하셨는데, 강의 전에 궁금해서 미리 찾아보았다.

• DIP(Dependency Inversion Principle) : 의존 역전 원칙

  • 상위 모듈은 하위 모듈의 구현에 의존해서는 안 된다. 하위의 모듈이 상위 모듈에 정의한 추상 타입에 의존 해야한다.

    Spring 예제로 보는 SOLID DIP 예시 : https://cheese10yun.github.io/spring-solid-dip/

• OCP(Open Closed Principle) : 개방 폐쇄 원칙

  • 자신의 확장에는 열려있어야 하고, 주변의 변화에는 닫혀있어야 한다.

    Spring 예제로 보는 SOLID OCP : https://cheese10yun.github.io/spring-solid-ocp/

• DI(Dependency Injection) : 의존성 주입

  • 객체를 직접 생성하는 게 아니라 외부에서 생성한 후 주입 시켜주는 방식.

• IoC((Inversion of Control) : 제어의 역전

  • 메소드나 객체의 호출작업을 개발자가 결정하는 것이 아니라, 외부에서 결정되는 것을 의미. DI, IoC 정리 : https://velog.io/@ohzzi/Spring-DIIoC-IoC-DI-%EA%B7%B8%EA%B2%8C-%EB%AD%94%EB%8D%B0

🤔 후기

지금까지 스프링부트에 대해 나름대로 공부하고 개발도 해보았지만, 내가 해온 코딩은 단순 코더에 가까웠구나 하는 생각이 들었고, 이론적인 부분에서 부족함을 느꼈다. 10일간의 짧은 과정이지만, 기술 면접에서도 잘할 수 있도록 이론적인 지식을 완성시키고자 한다.

연속 부분 수열 합의 개수

문제 설명

제한사항

🧭 접근

단순 반복으로 진행시 시간초과가 발생합니다. 따라서 이전에 구했던 연속 부분 수열의 값에 다음 인덱스의 값을 더해 중복된 계산을 하지 않도록 하였습니다.

✔ 풀이

1. 처음 길이 1의 연속 부분 수열을 반복문을 통해 초기화
2. 이전에 구했던 결과 배열의 마지막 5개에 다음 인덱스의 값 더하기
3. elements의 길이만큼 반복
4. set을 통해 배열의 중복 제거후 길이 리턴

   📙 소스 코드

def solution(elements):
    res = []
    for e in elements: # 길이가 1인 수열으로 배열 초기화
        res.append(e)

    for i in range(1,len(elements)): # 길이
        sum_list = []
        for j in range(len(elements),0,-1): # 인덱스
            sums = res[-j] + elements[-j+i]
            sum_list.append(sums)
        for e in sum_list:
            res.append(e)

    return len(set(res))

코딩테스트 연습 - 2021 KAKAO BLIND RECRUITMENT - 순위 검색

문제 설명

제한사항

🧭 접근

처음에는 단순 파싱을 통한 비교로 접근했지만, info 배열의 크기는 최대 5만, query 배열의 크기는 최대 10만이므로 query를 반복하여 검사할경우 50억번이 넘어가므로 효율성 테스트를 통과할 수 없었습니다. 따라서 info의 지원 정보를 파싱하고, 지원자가 포함될 수 있는 쿼리에 대한 조합을 만든 후, 지원점수를 제외한 나머지를 key, 점수를 value로 하는 딕셔너리를 만든 후, 쿼리에 해당하는 딕셔너리의 점수 리스트를 받아와 조건에 따라 카운트 하여 리턴합니다. 이 경우 단순 카운트시에도 시간 초과가 발생하므로, 이분 탐색 라이브러리인 bisect를 이용하여 카운팅을 진행하였습니다.

✔ 풀이

1. info 배열 파싱후, 점수를 제외한 조건을 item, 점수를 score로하여 포함될 수 있는 쿼리의 조합을 생성.
2. 생성된 쿼리를 join을 통해 문자열로 만들고, 이를 key로 하여 딕셔너리에 추가.
3. 이분 탐색을 위해 점수 리스트 정렬
4. query 에서 'and ', '-' 인 부분은 제거 후 공백을 기준으로 파싱하고, 딕셔너리에 생성된 키를 이용하여 점수 리스트를 가져오고, 이분 탐색을 통해 쿼리의 점수 기준 인덱스를 구한 후, 점수 리스트의 전체 길이에서 기준 인덱스를 빼면 기준 이상의 점수들의 갯수가 나온다.

   📙 소스 코드

from itertools import combinations
from bisect import bisect_left

def solution(info, query):

    ans = []
    info_dict = {} 

    for info_str in info:
        arr = info_str.split() # 공백 기준 정렬
        item = arr[:-1] # 점수 제외 나머지 조건
        score = int(arr[-1]) # 점수
        for i in range(0,5):
            for cb in combinations(item,i): # item 중 i개를 뽑아 조합 생성
                key = "".join(cb)
                if key in info_dict:
                    info_dict[key].append(score)
                else:
                    info_dict[key] = [score]

    for v in info_dict.values(): # 이진탐색을 위한 점수 정렬
        v.sort()

    ans = []
    for q in query:
        qarr = q.replace('and ','').replace('-','').split() # '-' 제거
        qitem = qarr[:-1]
        qscore = int(qarr[-1])
        qkey = ''.join(qitem)
        cnt = 0
        if qkey in info_dict:
            qres = info_dict[qkey]
            cnt = len(qres) - bisect_left(qres,qscore) 
        ans.append(cnt)

    return ans

🤔 느낀 점

프로그래머스 기준 레벨 2의 문제임에도 불구하고 생각보다 복잡했습니다. 접근 방법을 떠올리는게 쉽지 않았는데 만약 코테에 이런 문제 나왔으면 광탈했을거 같아요..

코딩테스트 연습 - 2022 KAKAO BLIND RECRUITMENT - 주차요금 계산

문제 설명

제한사항

🧭 접근

제한사항에 따라 동일한 차량이 또 입차하거나 없는 차량이 출차되는 경우, 입력 시각이 잘못된 경우 와 같이 잘못된 입력이 없으므로, 단순히 차량의 입차시 시간, 출차시 시간만을 계산하였다.

✔ 풀이

1. records 의 문자열을 시각, 차량번호, 내역 으로 파싱, 시각은 분 단위로 변환
2. 내역이 IN인경우 딕셔너리에 차량번호를 key로 하여 입차시간, 누적시간, 입차여부 저장, 내역이 OUT인 경우 현재시간과 입차시간을 비교하여 누적시간 증가 시킴
3. 종료시각까지 출차하지 않은 경우 종료시각과 입차시간 비교하여 누적시간 증가
4. 차량번호가 작은 순서대로 요금을 배열에 담아야 하므로 차량번호 기준으로 정렬 후, 누적시간이 기본시간보다 작거나 같은경우 기본요금, 초과인 경우 요금 계산식에 따라 계산 후 배열에 추가 후에 return

   📙 소스 코드

import math

def solution(fees, records):
    def_time = fees[0]; def_fee = fees[1]; over_time = fees[2]; over_fee = fees[3]
    table = {}

    for r in records:
        time, car_num, order = r.split() # 시간, 차량번호, 내역
        h, m = map(int,time.split(':'))
        t = (h*60) + m 
        if order == 'IN': 
            if car_num not in table:
                table[car_num] = [t,0,True] # 입차시간,누적시간,입차여부
            else:
                table[car_num][0] = t # 입차시간
                table[car_num][2] = True # 입차
        elif order == 'OUT':
            prev_t = table[car_num][0];
            use_time = t - prev_t # 현재시간 - 입차시간
            table[car_num][1] += use_time 
            table[car_num][2] = False # 출차


    last_time = (23*60) + 59
    # table 입차시간,누적시간,입차여부
    for key, t in table.items():
        if t[2] == True: # 종료까지 출차 안했을때
            table[key][1] += last_time-t[0]

    s_table = dict(sorted(table.items(),key=lambda x:x[0])) # 차량번호 기준 정렬
    res = []

    for t in s_table.values():
        if t[1] <= def_time:
            res.append(def_fee)
        else:
            fee = def_fee + math.ceil((t[1] - def_time) / over_time) * over_fee # 기본 요금 + 주차시간에 따른 요금 
            res.append(fee)


    return res

🤔 느낀 점

이러한 문자열 처리 문제들이 코딩테스트 1번으로 자주 나오는데, 이런 문제의 경우 제한사항을 다른 문제보다 꼼꼼히 확인한 후 풀어야겠다 느꼈고, 코드가 가독성이 많이 떨어짐.. 해결 방법을 찾아봐야겠다.

코딩테스트 연습 - 부대복귀

문제 설명

강철부대의 각 부대원이 여러 지역에 뿔뿔이 흩어져 특수 임무를 수행 중입니다. 지도에서 강철부대가 위치한 지역을 포함한 각 지역은 유일한 번호로 구분되며, 두 지역 간의 길을 통과하는 데 걸리는 시간은 모두 1로 동일합니다. 임무를 수행한 각 부대원은 지도 정보를 이용하여 최단시간에 부대로 복귀하고자 합니다. 다만 적군의 방해로 인해, 임무의 시작 때와 다르게 되돌아오는 경로가 없어져 복귀가 불가능한 부대원도 있을 수 있습니다.

강철부대가 위치한 지역을 포함한 총지역의 수 n, 두 지역을 왕복할 수 있는 길 정보를 담은 2차원 정수 배열 roads, 각 부대원이 위치한 서로 다른 지역들을 나타내는 정수 배열 sources, 강철부대의 지역 destination이 주어졌을 때, 주어진 sources의 원소 순서대로 강철부대로 복귀할 수 있는 최단시간을 담은 배열을 return하는 solution 함수를 완성해주세요. 복귀가 불가능한 경우 해당 부대원의 최단시간은 -1입니다.

제한사항

🧭 접근

탐색류 문제이므로 BFS를 사용하면 되겠다고 생각했는데, 일부 케이스에서 시간 초과가 발생했다. 시간복잡도를 줄이기위해 다각도로 접근해 보았는데, 도착지가 모두 같으므로 도착지를 출발지로 정해 한번의 탐색을 통해 모든 경로에 대한 소요 시간을 탐색하였다.

✔ 풀이

1. 양방향 탐색을 위한 그래프 만들기
2. BFS를 이용하여 탐색 및 방문 노드까지의 소요시간 추가
3. BFS를 이용하여 시작 -> 레버, 레버 -> 출구 까지의 거리 구하기

📙 소스 코드

from collections import deque

def bfs(graph, st):
    q = deque()
    visited = [0] * (ncnt+1)
    time = [0] * (ncnt+1)
    q.append(st)
    visited[st] = 1
    cnt = 0
    while q:
        nd = q.popleft()
        if nd in graph:
            for n in graph[nd]:
                if visited[n] == 0:
                    q.append(n)
                    visited[n] = 1
                    time[n] = time[nd] + 1

    return time

def solution(n, roads, sources, destination):

    global ncnt; ncnt = n # 전역변수 선언
    graph = {} # 양방향 그래프 추가
    for x,y in roads:
        if x in graph:
            graph[x].append(y)
        else:
            graph[x] = [y]
        if y in graph:
            graph[y].append(x)
        else:
            graph[y] = [x]
    # 도착점 부터 모든 경로에 대한 소요시간 배열
    time_arr = bfs(graph,destination) 


    res = []
    for s in sources:
        ti = time_arr[s] # 부대원 위치까지 걸린 시간
        # 출발, 도착지가 다른데 0인경우 방문 불가한곳
        if s != destination and ti == 0: 
            res.append(-1)
        else:
            res.append(ti)

    return res

🤔 느낀 점

시간복잡도가 초과될 시, 단순 코드 연산을 줄이는 것이 아니라 알고리즘을 다시 검토하는 것이 좋을 것 같다. 발상의 전환의 중요성 !

코딩테스트 연습 - 미로탈출

문제 설명

1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다. 통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다. 따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.

미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1을 return 해주세요.

제한사항

🧭 접근

탐색류 문제이므로, BFS를 사용하면 되겠다고 생각했다.

✔ 풀이

1. maps의 x,y 크기 및 필요한 인덱스 구하기
2. BFS 함수 작성
3. BFS를 이용하여 시작 -> 레버, 레버 -> 출구 까지의 거리 구하기

📙 소스 코드

from collections import deque

def bfs(maps,y,x,dy,dx):
    q = deque()
    q.append([y,x])
    cnt = 1
    time = 0
    movex = [0,0,-1,1] # 상 하 좌 우 
    movey = [-1,1,0,0]
    dis = [[0] * maxx for _ in range(maxy)] # 거리 배열
    visited = [[0] * maxx for _ in range(maxy)] 
    visited[y][x] = 1
    b_flag = 0
    while q:
        if b_flag == 1:
            break
        ny,nx = q.popleft()
        for i in range(4): # 4방향 이동
            mx = nx+movex[i]; my = ny+movey[i]
            # 인덱스 벗어날경우
            if mx < 0 or my < 0 or mx >= maxx or my >= maxy: 
                continue
            # 벽이나 이미 방문한 곳 일경우
            if maps[my][mx] == 'X' or visited[my][mx] == 1:
                continue
            q.append([my,mx])
            visited[my][mx] = 1
            dis[my][mx] = dis[ny][nx] + 1 # 시작점부터의 거리 계산
            if my == dy and mx == dx: # 목표 도달한경우 break
                b_flag = 1
                break


    if b_flag != 1: # 목표 도달 못한경우
        return -1
    return dis[dy][dx] # 목표까지의 거리 반환

def solution(maps):
   # S : 시작 지점 E : 출구 L : 레버 O : 통로 X : 벽
    global maxx
    global maxy
    maxx = len(maps[0]) # x 최고 인덱스
    maxy = len(maps) # y 최고 인덱스

    for i in range(maxy): # 시작점, 출구, 레버 인덱스 구하기
        for j in range(maxx):
            val = maps[i][j]
            if val == 'S':
                start = [i,j]
            elif val == 'E':
                exit = [i,j]
            elif val == 'L':
                lever = [i,j]
    # 시작 -> 레버
    res = bfs(maps,start[0],start[1],lever[0],lever[1]) 
    if res == -1:
        return -1
    # 레버 -> 출구
    res2 = bfs(maps,lever[0],lever[1],exit[0],exit[1])
    if res2 == -1:
        return -1

    return res + res2 # 거리 반환

🤔 느낀 점

탐색 문제류는 많이 풀어봐야 알고리즘을 빠르게 찾아 적용시킬 수 있고, 코드 작성 시간도 빨라지는 것 같다. 예전보다는 많이 빨라졌음 😁