//안전하지 않다
public boolean startsWithA(String str){
    return str.startsWith("A");
}

1. str이 null일 경우 Exception을 낸다.

   public boolean startsWithA1(String str){
    if(str == null) {
     throw new IllegalArgumentException("null이 들어왔습니다");
     }
     return str.startsWith("A");
   }

2. str이 null일 경우 null을 반환한다.

   public Boolean startsWithA2(String str){
    if(str == null) {
        return null;
    }
    return str.startsWith("A");
   }

3. str이 null일 경우 false를 반환한다.

   public boolean startsWithA3(String str){
    if(str == null) {
        return false;
    }
    return str.startsWith("A");
   }

Safe Call과 Elvis 연산자

//safe call
val str: String? = "ABC"
str.length //불가능
str?.length //가능

널 아님 단언!!

nullable type이지만, 아무리 생각해도 null이 될 수 없는 경우

fun startsWtih(str: String?): Boolean {
    return str!!.staartsWith("A")
}

코틀린이 플랫폼타입 즉 다른 언어의 타입 중 null 관련 정보를 알 수 없는 타입 Runtime 시 Exception이 날 수 있다

kotlin
var number1 = 10L  가변
val number2 = 10L  불변

java와 다르게 long과 Long을 걱정할 필요없다.즉, 프로그래머가 boxing / unboxing을 고려하지 않아도 되도록 Kotlin이 알아서 처리 해준다.

var number: Long? = 1_000L
number4 = null

java처럼 Long을 쓰게 되면 값이 null이 들어갈 수 있다는 건데 kotlin에서는 null이 들어가는걸 알려주기 위해서는 ? 와 null을 추가해준다

kotlin
var person = Person("조현재");

코틀린에서는 객체 인스턴스화를 할 때는 new를 붙이지 않아야 한다.

코틀린에서 변수를 다루는 방법 최종 정리
모든 변수는 var / val을 붙여 주어야한다. -var: 변경 가능하다 / val: 변경 불가능하다(read-only) 타입을 명시적으로 작성하지 않아도, 타입이 추론된다. Primitive Type과 Reference Type 을 구분하지 않아도 된다. Null이 들어갈 수 있는 변수는 타입 뒤에 ? 를 붙여주어야한다. -아예 다른 타입으로 간주된다. 객체를 인스턴스화 할 때 new를 붙이지 않아야 한다.

1. web.php: 이 파일은 웹 인터페이스를 통해 들어오는 HTTP 요청을 처리하는 라우트를 정의하는 곳 이 파일에 정의된 라우트는 Laravel의 웹 미들웨어 그룹에 의해 처리되며, 이 그룹에는 세션 상태 유지, CSRF 보호 등의 미들웨어가 포함되어 있다. 웹 페이지를 반환하는 라우트를 web.php에 정의하게 된다.

2. api.php: 이 파일은 API를 통해 들어오는 HTTP 요청을 처리하는 라우트를 정의하는 곳이다. 이 파일에 정의된 라우트는 API 미들웨어 그룹에 의해 처리되며, 이 그룹에는 레이트 제한, 상태 없음 등의 미들웨어가 포함되어 있다. API 응답을 반환하는 라우트를 api.php에 정의하게 된다.

따라서, 웹 인터페이스에서 제공하려면 web.php에 라우트를 정의하고, API를 통해 제공하려면 api.php에 라우트를 정의해야 한다.

다시 말해, 클라이언트가 웹 브라우저를 통해 다운로드 요청을 보낼 경우 web.php에 라우트를 정의해야 하고, HTTP 클라이언트(예: Postman, curl 등)나 다른 서버를 통해 다운로드 요청을 보낼 경우 api.php에 라우트를 정의해야 합니다.

1. 클래스와 메서드

PHP에서 클래스는 class 키워드를 사용하고, 메서드는 public, private, protected와 같은 접근 제한자를 사용한다. Java와 동일한 방식

2. 네임스페이스

PHP에서 네임스페이스는 namespace 키워드로 선언한다. 이는 Java의 package와 유사

3. 객체 생성 및 메서드 호출

PHP에서 객체를 생성할 때 new 키워드를 사용하며, 객체의 메서드는 > 연산자를 사용하여 호출한다. Java에서는 . 연산자를 사용한다. 예를 들어, $post = new Post();는 Java에서 Post post = new Post();와 유사

4. 정적 메서드 호출

PHP에서 정적 메서드는 :: 연산자를 사용하여 호출한다. Java에서는 . 연산자를 사용한다. 예를 들어, User::where('userId', $userId)는 Java에서

public class UserUtil {
    public static boolean isUserIdEmpty(String userId) {
        return (userId == null || StringUtils.isEmpty(userId));
    }
}

와 유사

5. 변수 선언

PHP에서 변수는 $ 기호로 시작. Java에서는 변수 타입을 명시해야 하지만, PHP에서는 필요하지 않다.

6. 라우팅 (Routing)

Laravel에서 라우팅은 웹 요청을 애플리케이션에서 처리할 수 있는 메서드와 연결한다. 이는 Java에서 Spring 프레임워크의 @RequestMapping이나 @GetMapping, @PostMapping 등의 어노테이션과 비슷한 기능을 한다.

Laravel의 
Route::post('register', [JWTController::class, 'register']);

java의
@PostMapping("/register")
public ResponseEntity<?> register(@RequestBody RegisterRequest registerRequest) {
    // ...
}

매개변수

public function update(Request $request, Post $post)

(Request $request, Post $post) 부분은 이 메서드의 매개변수를 정의

1. Request $request: 이 매개변수는 클라이언트로부터의 HTTP 요청 정보를 담고 있는 Request 객체입니다. 이 객체를 사용하여 요청에 포함된 데이터를 가져올 수 있습니다. 예를 들어, $request->title과 $request->content는 클라이언트가 전송한 게시물의 제목과 내용이다

2. Post $post: 이 매개변수는 업데이트할 게시물 객체입니다. 이 객체는 Laravel 의 Route Model Binding 기능을 사용하여 URL에서 전달된 게시물 ID에 해당하는 게시물 객체를 자동으로 검색하고 주입한다.

   즉, 이 메서드가 호출되기 전에 이미 데이터베이스에서 게시물 객체가 조회하고 이 객체를 사용하여 게시물의 속성을 업데이트하고 저장할 수 있다.

Java의 Spring Boot와 비교

1. Request $request: 이것은 Spring Boot에서 @RequestBody 어노테이션을 사용하여 클라이언트로부터의 요청 본문(JSON)을 객체로 변환하는 것과 유사하다.

   예를 들어, public ResponseEntity<?> update(@RequestBody UpdateRequest updateRequest)와 같은 메서드에서 UpdateRequest 객체는 클라이언트로부터의 요청 데이터를 담고 있다.

2. Post $post: 이것은 Spring Boot에서 @PathVariable 어노테이션을 사용하여 URL에서 전달된 변수를 가져오는 것과 유사하다.

   하지만, Spring Boot에서는 URL에서 가져온 변수를 사용하여 직접 데이터베이스에서 게시물을 조회해야 한다.

   예를 들어, public ResponseEntity<?> update(@PathVariable Long postId)에서 postId는 URL에서 전달된 게시물 ID이다.

전자적으로 저장되고 사용되는 관련있는 데이터들의 조직화된 집합

DBMS

-database management systems 사용자에게 DB를 정의하고 만들고 관리하는 기능을 제공하는 소프트웨어 시스템 -DB를 정의하다 보면 부가적인 데이터가 발생한다

부가적인 데이터 : metadata

metadata

-database를 정의하거나 기술하는 data -e.g)데이터 유형, 구조 제약조건, 보안, 저장, 인덱스, 사용자 그룹 등등 -metadata 또한 DMBS를 통해 저장/관리 된다

database system

-database + DBMS + 연관된 applications -줄여서 database라고도 부름

data models(모델링)

-DB의 구조를 기술하는데 사용될 수 있는 개념들이 모인 집합 -DB구조를 추상화해서 표현할 수 있는 수단을 제공한다 db의 구조를 원하는 형태로 혹은 원하는 추상화 수준으로 모델링 하기위해서는 model이 필요하다

data models의 분류

-conceptual(or high-level) data models

• 일반 사용들이 쉽게 이해할 수 있는 개념들로 이뤄진 모델(추상화 수준이 가장 높음)
• 비즈니스 요구사항을 추상화하여 기술할 때 사용 ex) entity-relationship model( ER diagram)

-logical(or representational) data models

• 이해하기 어렵지 않으면서도 디테일하게 DB를 구조화 할 수 있는 개념들을 제공
• 데이터가 컴퓨터에 저장될 때의 구조와 크게 다르지 않게 DB구조화를 가능하게 함
• 특정 DBMS나 storage에 종속되지 않는 수준에서 DB를 구조화 할 수 있는 모델 ex) relational data model, object data model, object-relational data model

-physical(or low-level) data models

• 컴퓨터에 데이터가 어떻게 파일 형태로 저장되는지를 기술 할 수 있는 수단을 제공
• data format, data orderings, access path 등등
• • access path: 데이터 검색을 빠르게 하기 위한 구조체 e.g) index

database schema

-data model을 바탕으로 database의 구조를 기술한 것 -schema는 database를 설계할 때 정해지며 한번 정해진 후에는 자주 바뀌지 않는다

database state

-database에 있는 실제 데이터는 꽤 자주 바뀔 수 있다 -특정 시점에 database에 있는 데이터를 database state 혹은 snapshot이라고 한다 -혹은 database에 있는 현재 instances의 집합이라고도 한다

three-schema architecture

-database system을 구축하는 architecture 중의 하나 -user application으로 부터 물리적인(physical) database를 분리시키는 목적 -세 가지 level이 존재하며 각각의 level마다 schema가 정의되어 있다

• external schemas(or user views) at external(or view) level

• 실제 사용자가 바라보는 스키마

• 특정 유저들이 필요로 하는 데이터만 표현

• 그 외 알려줄 필요가 없는 데이터는 숨김

• logical data model을 통해 표현

• conceptual schemas at conceptual level

• 원래는 external schemas와 internal schemas만 있었는데 문제점이 생겼는데 internal schemas가 유저에 맞춰 조금씩 다른 internal schema가 생기면서 데이터 불일치가 발생하게 되어 생김

• 전체 database에 대한 구조를 기술 즉, internal schema를 한번 추상화 하여 표현

• 물리적인 저장 구조에 관한 내용은 숨김

• entities, data types, relationships, user operations, constraints에 집중

• logical data model을 통해 기술

• internal schemas at internal level

• 실제로 물리적인 저장장치에 가장 가깝게 위치

• 물리적으로 데이터가 어떻게 저장되는지 physical data model을 통해 표현

• data storage, data structure, access path 등등 실체가 있는 내용 기술

결론적으로 three-schema architecture는 안정적인 데이터베이스를 운영하기 위해서 사용한다. 각 레벨을 독립시켜서 어느 레벨에서의 변화가 상위 레벨에 영향을 주지 않기 위함. 대부분의 DMBS가 three level을 완벽하게 혹은 명시적으로 나누지는 않는다. 데이터가 존재하는 곳은 internal level에만 있다.

database language

• data definition language(DDL)

• conceptual schema를 정의하기 위해 사용되는 언어

• internal schema까지 정의할 수 있는 경우도 있음

• storage definition language(SDL)

• internal schema를 정의하는 용도로 사용되는 언어

• 요즘은 특히 relational DBMS에서는 SDL이 거의 없고 파라미터 등의 설정으로 대체됨

• view definition language(VDL)

• external schemas를 정의하기 위해 사용되는 언어

• 대부분의 DMBS에서는 DDL이 VDL 역할까지 수행

• data manipulation language(DML)

• database에 있는 data를 활용하기 위한 언어

• data 추가, 삭제, 수정, 검색 등등의 기능을 제공하는 언어

오늘날의 DBMS는 DML, VDL, DDL이 따로 존재하기 보다는 통합된 언어로 존재 -대표적인 예가 relational database language: SQL

스프링을 기반으로 실무 환경에 사용 가능한 수준의 독립실행형 애플리케이션을 복잡한 고민 없이 빠르게 작성할 수 있게 도와주는 여러가지 도구의 모음이다. ☞ 스프링 ≠ 스프링부트

스프링부트를 왜 쓰는가?

• 매우 빠르고 광범위한 영역의 스프링 개발 경험을 제공
• 강한 주장을 가지고 즉시 적용 가능한 기술 조합을 제공
• 프로젝트에 필요로하는 다양한 비기능적인 기술 (내장형서버, 보안, 메트릭, 상태체크, 외부설정 방식 등)
• 코드 생성이나 XML 설정을 필요로 하지 않음

Containerless 웹 개발 아키텍처란?

우선 Container가 무엇인지 알아보자 Container란? Servlet Container는 일반적으로 Servlet을 관리하며 WEB CLIENT의 WEB REQUEST가 들어오는걸 담당 Servlet로 안내해주는 역할을 한다. (Serverless랑 비슷) Spring은 IOC Container이다. 위와 같은 ServletContainer에서 web.xml, war, deploy 등등 설정의 수고 없이 Containerless가 되면 Srping Container 설정이 알아서 된다. 물론 커스텀 할 수 있다. SpringBoot를 이용하면 전체가 다 실행이 된다 그래서 독립실행형 어플리케이션이란걸 알 수 있다.

1장. 깨끗한 코드

• 제 3자가 읽기 쉽고 고치기 쉬운 코드
• 저자라 생각하고 독자와 잘 소통하는 코드

첫 장에서는 나만 알아보는 코드가 아닌 다른 사람도 읽거나 작업해도 바로 이해할 수 있는 코드를 짜라고 조언한다.

2장. 의미있는 이름

의도를 분명히 밝혀라

public List<int[]> getThem(){
    List<int[]> list1 = new ArrayList<int[]>();
    for (int[] x : theList)
        if (x[0] == 4)
            list1.add(x);
    return list1;        

}

위 코드를 보면 무슨 일을 하는지 짐작하기 힘들다. 코드의 단순성이 아니라 코드의 함축성이다

위 코드 샘플엔 밑에 정보가 드러나지 않는다.

1. theList에 무엇이 들었는가?
2. theList에서 0번째 값이 어째서 중요한가?
3. 값 4는 무슨 의미인가?
4. 함수가 반환하는 리스트 list1 을 어떻게 사용하는가?

public List<int[]> getFlaggedCells(){
    List<int[]> flaggedCells = new ArrayList<int[]>();
    for (int[] cell : gameBoard)
      if (cell[STATUS_VALUE] == FLAGGED)
        flaggedCells.add(cell);
    return flaggedCells;
}    

• JDK에 포함된 Validation API
• Hibernate library에 포함된 Hibernate Validation

  import javax.validation.constraints.*;

  controller
  

@PostMapping("/") public ResponseEntity<> create(@Valid @RequestBody User user){ return ResponseEntity.status(HttpStatus.CREATED).body(responseUser);}

```java
@RestController
@ControllerAdvice
public class CustomizedResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    //유효성 검사에 문제가 생겼을 때 화면에 오류 메세지를 출력하기 위한
    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(
            MethodArgumentNotValidException ex,
            HttpHeaders headers, HttpStatus status,
            WebRequest request) {
        ExceptionResponse exceptionResponse = new ExceptionResponse(new Date(),
                ex.getMessage(), ex.getBindingResult().toString());
        return new ResponseEntity(exceptionResponse, HttpStatus.BAD_REQUEST);
    }

}

Internationalization

다국어 처리

@Bean
public LocaleResolver localeResolver(){
    SessionLocaleResolver localeResolver = new SessionLocaleResolver();
    localeResolver.setDefaultLocale(Locale.KOREA);
    return localeResolver;
}

application.yml

spring:
  messages:
    basename: messages //다국어 파일의 이름을 "messages" 로 하겠다는 의미

resources에 위에 적은 이름으로 *messages.properties greeting.message=안녕하세요 *messages_en.properties greeting.message=Hello *messages_fr.properties greeting.message=Bonjour

//메세지소스를 반환하기 위해서
import org.springframework.context.MessageSource;
private final MessageSource messageSource;

@GetMapping("/hello")
public String hello(@RequestHeader(name="Accept-Language", required=false) Locale locale){
    return messageSource.getMessage("greeting.message",null,locale);
}

XML format으로 반환하기

<dependency>
    <groupId>com.faster xml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.10.2</version>
</dependency>

Filtering

중요한 데이터를 클라이언트가 바로 받아볼 수 있는 것이 아니라 이런 데이터 값을 제어하는 방법

방법 1.

@JsonIgnore
private String password;

@JsonIgnore
private String ssn;

방법 2.

@JsonIgnoreProperties(value={"password", "ssn"})
public class User{
    ...
    private String password;
    private String ssn;
}

개별 사용자 조회 Filtering방법

@JsonFilter("UserInfo")
public class User{
    ...
}

관리자 유저컨트롤러

*개인 사용자 보기

@GetMapping("/admin/users/{id}")
public MappingJacksonValue retreveUser(@PathVariable int id){
    SimpleBeanPropertyFilter filter = simpleBeanPropertyFilter.filterOutAllExcept("id", "name" "joinDate" "ssn");
    FilterProvider filters = new SimpleFilterProvider().addFilter("UserInfo", filter);
    MappingJacksonValue mapping = new MappingJacksonValue(user);
    mapping.setFilters(filters);

      return mapping;
}    

*유저 리스트

@GetMapping("/admin/users")
public MappingJacksonValue retrieveAllUsers(){
    List<User users = service.findAll();

    SimpleBeanPropertyFilter filter = simpleBeanPropertyFilter.filterOutAllExcept("id", "name" "joinDate" "ssn");
    FilterProvider filters = new SimpleFilterProvider().addFilter("UserInfo", filter);
    MappingJacksonValue mapping = new MappingJacksonValue(users);
    mapping.setFilters(filters);

      return mapping;

}

Version관리

UserV1 class

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonFilter("UserInfo")
public class UserV1{
    private Integer id;
    @Size(min=2, message = "이름은 두글자 이상 입력해주세요.")
    private String name;

    @Past
    private Date joinDate;

    private String ssn;

UserV2 class

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonFilter("UserInfoV2")
public class UserV2 extends UserV1 {
    private String grade;
}

@GetMapping("/admin/v2/users/{id}")
public MappingJacksonValue retreveUserV2(@PathVariable int id){

    //user -> user2
    UserV2 userV2 = new UserV2();
    BeanUtils.copyProperties(userV1, userV2);
    userV2.setGrade("VIP");


SimpleBeanPropertyFilter filter = simpleBeanPropertyFilter.filterOutAllExcept("id", "name" "joinDate" "ssn", "grade");
    FilterProvider filters = new SimpleFilterProvider().addFilter("UserInfoV2", filter);
    MappingJacksonValue mapping = new MappingJacksonValue(user);
    mapping.setFilters(filters);

      return mapping;
}    

Request Parameter와 Header를 이용한 API Version관리

*Request Parameter

@GetMapping(value= "/users/{id}", params = "version=1")
public MappingJacksonValue retreveUserV1(@PathVariable int id){...}

@GetMapping(value= "/users/{id}", params = "version=2")
public MappingJacksonValue retreveUserV2(@PathVariable int id){...}

*Header

@GetMapping(value = "/users/{id}", headers="X-API-VERSION=1")
public MappingJacksonValue retreveUserV1(@PathVariable int id){...}

mine

@GetMapping(value="/users/{id}", produces = "application/vnd.company.appv1+json")
public MappingJacsonvalue retreveUserV1(@PathVariable int id){...}

![](https://velog.velcdn.com/images/ssan_to__/post/8c9fb625-2ad7-48f7-b57b-1ea062ab34f6/image.png)

큐와 유사하지만 우선순위가 높은 아이템이 먼저 처리됨 -insert : 집어넣는다(우선순위 정보도 같이) -delete : 가장 우선 순위가 높은 아이템을 빼낸다. -peek : delete와 유사하지만 우선순위 큐에서는 제거하지 않는다.

Heap

주로 이진트리(binary tree)기반으로 구현 / 힙은 max heap과 min heap -insert : 집어넣는다(아이템 key값도 같이) -delete : maxheap이라면 key값이 가장 큰 아이템을 반환 minheap이라면 key값이 가장 작은 아이템을 반환 -peek : delete와 유사하지만 실제로 heap에서 꺼내지 않는다

트리 :부모-자녀처럼 계층적인 형태를 가지는 구조 이진트리 : 부모가 자녀를 최대 두개만 가질 수 있는 트리

max heap : 부모 노드의 키(key)가 자식 노드(들)의 키(key)보다 크거나 같은 트리 min heap : 부모 노드의 키(key)가 자식 노드(들)의 키(key)보다 작거나 같은 트리

Priority queue 와 Heap의 관계 힙(heap)의 키(key)를 우선순위(priority)로 사용한다면 힙은 우선순위 큐(priority queue)의 구현체가 된다.

Priority queue = ADT (After data type) -실제로 구현을 설명하지 않음 -어떤 동작들이 있는지 개념적인것만 설명 Heap = data structure -구현까지 있는거

그래서 결국 Heap을 Priority queue에 구현체라고 많이들 표현함 사실 Priority queue에는 많은 구현체들이 있지만 Heap이 제일 성능이 좋기때문에 대부분 많이 쓰기 때문에 'Priority queue랑 Heap이랑 똑같다' 라는 인식이 조금 생겼지만 엄밀히 놓고 보면 서로 다른 개념이다.

사용사례

-프로세스 스케줄링(process scheduling) -heap sort(힙 정렬)

※힙(heap) 메모리의 힙은 위에 적힌 힙과는 관련 없음

-추상자료형 -개념적으로 어떤 동작이 있는지만 정의 -구현에 대해서는 다루지 않음

DS(data structure)

-자료구조 -ADT에서 정의된 동작을 실제로 구현한 것

스택(stack)

LIFO(Last In First Out) 형태로 데이터를 저장하는 구조 -push : 넣기 -pop : 빼내기 -peek : 아이템을 빼내지는 않지만 가장 최상단에 있는게 뭔지 알 수 있는거

사용사례 : stack memory & stack frame

큐(queue)

FIFO(First In First Out) 형태로 데이터를 저장하는 구조 -enqueue : 큐에 아이템 넣기 -dequeue : 큐에서 아이템 빼기 -peek : 아이템을 빼내지는 않지만 아이템의 값을 알 수 있는거

사용사례 : producer / consumer architecture ※항상 FIFO를 의미하지는 않는다. 문서를 잘 보고 파악해야한다. 뭔가를 저장하고 있는 대기열같은 느낌일 수도 있음

Error

StackOverflowError

스택 메모리 공간을 다 썼을 때 발생하는 에러 -재귀함수(recursive function)에서 탈출 못해서 발생(탈출 조건을 안 썼을 경우)

def recur_fibo(n):
    if n <=1:
        return n
    else:
        return(recur_fibo(n-1) + recur_fibo(n-2))

OutOfMemoryError

Java의 힙(heap) 메모리를 다 썻을 때 발생 -heap: 객체가 거주하는 메모리 영역 큐에 데이터가 계속 쌓이기만 해서 메모리를 다 잡아먹을 경우 이를 해결하기 위해서는 큐 사이즈를 조정

큐가 다 찼을 때는 어떻게 해야할까? -예외(exception) 던지기 -특별한 값(null or false)을 반환 -성공할 때까지 영원히 스레드 블락(block) -제한된 시간만 블락되고 그래도 안되면 포기

실제로 java에서 이런 4가지 방식을 구현한 몇몇 클래스들이 있는데 그 중 하나가 LinkedBlockingQueue

Time Complexity ●시간 복잡도를 이용하면 작성한 코드가 시간이 대략 얼마나 걸릴지 예상할 수 있다. ●표기법으로 대문자 O를 사용한다. (다양한 시간 복잡도가 많지만, 보통 Big-O만 사용한다.) ●영어로는 Big O Notation ●Big O Notation에서 상수는 버린다. ●두 가지 항이 있을 때, 변수가 같으면 큰 것만 빼고 다 버린다. ●입력의 크기 N에 대해서 시간이 얼마나 걸릴지 나타내는 방법 즉, 최악의 경우에 시간이 얼마나 걸릴지 알 수 있다. ●시간복잡도는 소스를 보고 계산할 수 있도 있고, 소스를 작성하기 전에 먼저 계산해볼 수 있다. ●문제를 풀기 전에 먼저 생각한 방법의 시간 복잡도를 계산해보고 이게 시간 안에 수행될 것 같은 경우에만 구현하는 것이 좋다.

시간복잡도예시

총 N명의 사람이 식당에 방문했다. 식당에는 메뉴가 M가 있고, 메뉴판이 1개 있다. 사람 1명이 메뉴판을 읽는데 걸리는 시간은 O(M)이다. 주문한 모든 메뉴는 동시에 나왔고, 각 사람 i가 식사를 하는데 걸리는 시간은 $$A_{i}$$이다. 각 사람이 계산을 하는데 걸리는 시간은 O(P)이다.

각 사람이 메뉴판에 있는 모든 메뉴를 읽는 시간 복잡도는 O(NM) 모든 사람이 식사를 마치는데 걸리는 시간 = O(max($$A_{i}$$)) 식사를 모두 마친 다음 한 줄로 서서 각자 계산을 하는 시간 복잡도는 = O(NP)

N번 O(N)

int sum = 0;
for(int i =1; i<=N; i++){
    sum += i;
}

$$O(N^2)$$

int sum =0;
for(int i=1; i<N; i++){
    for(int j=1; j<=N; j++){
        if(i==j){
            sum += j;
        }
    }
}

O(1)

int sum = 0;
sum = N*(N+1)/2;

O(1) O(N) $$O(N^2)$$ 여기에 값을 넣었을때 1억이 나오면 보통 1초 나온다고 본다. N=<10만 O(1) =>1 O(N) => 10만 $$O(N^2)$$ => 100억 /100초

메모리

●보통 가장 많은 공간을 사용하는 것은 보통 배열이다. ●배열이 사용한 공간: 배열의 크기 X 자료형의 크기 B ●보통 배열의 크기가 크면 시간 초과를 받는 경우가 많다. ●불필요한 공간이 없다면, 대부분 메모리 제한은 알아서 지켜진다.

입/출력

JAVA ●Java는 입력은 Scanner, 출력은 System.out을 사용한다. ●Scanner sc = new Scanner(System.in); ●입력이 많은 경우에는 속도가 느리기 때문에, BufferedReader를 사용한다. ●BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); ●출력이 많은 경우에는 StringBuilder를 사용해서 한 문자열로 만들어서 출력을 한 번만 사용하거나 BufferedWrtier를 사용한다.

OSI 7계층

TCP헤더

Http헤더

A와 B가 서로 전송할 수 있다.

stateless 상태지속x

A가 요청하면 B가 응답할 수 있다. 그리고 응답이 되면 선이 끊긴다.

웹서버는?

stateless -> 상태 지속할 필요가 없음

웹 인증 시 어려운 이유

웹서버 자체가 stateless라서 인증 시 응답이 완료되면 선이 끊긴다. 그러면서 새로운 요청이 왔을때는 인증되지 않은 사람으로 판단한다.

세션

논리적으로 stateful

암호화 작업 인크립션

인크립션 데이터를 복호화 디크립션

인크립션 디크립션 key를 같은걸 쓰는걸 대칭키값 쓰는걸

다르게 쓰는걸 비대칭 RSA

대칭키

Config-service -bootstrap.yml

encrypt:
  key: abcdefghijklmopqrstuvwyz0123456789

user-service에 bootstrap.yml 추가

spring:
  cloud:
    config:
      uri: http://127.0.0.1:8888
      name: user-service

config파일에 bootstrap.yml

encrypt:
  key: abcdefghijklmopqrstuvwyz0123456789

server:
  port: 8888

spring:
  application:
    name: config-service
  rabbitmq: #rabbitmq 설정 추가
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
  profiles:
    active: native
  cloud:
    config:
      server:
        native:
          search-locations: file://#yaml 파일이 있는 폴더 위치를 넣어주면 된다.

이렇게 옮겨두면 복호화 되는걸 알 수 있다.

비대칭

암호화할때는 privateKey 암호 풀때는 publicKey

apiEncryptionKey

trustServer.cer

인증서파일을 다시 jks파일로

똑같이 복호화 시켜주면된다.

RabbitMQ를 사용하기 위해서는 Erlang 설치을 먼저 설치해야한다.

Erlang 홈페이지 windows installer를 눌러 설치

개인 환경변수를 Path에 넣어주고 RabbitMQ설치하면 된다.

RabbitMQ 홈페이지 window용으로 Chocolatey package 나 Windows Installer 다운

다음 서비스에서 RabbitMQ가 들어가 있는지 확인 후 바로 환경 변수도 등록

마지막으로 Management Plugin을 설치해주면 더 편하게 사용 가능한데 C:\Program Files\RabbitMQ Server\rabbitmq_server-3.11.8\sbin에서 powershell을 열고

rabbitmq-plugins enable rabbitmq_management

웹페이지 접근 가능해짐 로그인 정보 : guest/guest

userservice / gateway / config 가 RabbitMQ의 client역할로서 다 등록을 해줄것이다 RabbitMQ에 변경사항이 생기면 해당하는 변경사항을 AMQP이라는 프로토콜로 받기 위한 클라이언트 역할이라고 보면 된다.

프로젝트 적용

config server

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

config server에 각 actuator, bus amqp, bootstrap의 의존성을 추가한다.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

config application

server:
  port: 8888

spring:
  application:
    name: config-service
  rabbitmq: #rabbitmq 설정 추가
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
  cloud:
    config:
      server:
        native:
          search-locations: file://${user.home}/Desktop/Program/0_workspace/0_project/individual/ecommerce
        git:
          uri: file://C:/Users/82107/Desktop/Program/0_workspace/0_project/individual/ecommerce

management: #actuator 설정
  endpoint:
    web:
      exposure:
        include: health, busrefresh

user-service gateway에도 추가

  rabbitmq: #rabbitmq 설정 추가
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

management: #actuator 설정
  endpoints:
    web:
      exposure:
        include: refresh, health, beans, busrefresh

userservice bootstrap.yml를

spring:
  cloud:
    config:
      uri: http://112.1.1.2:8888
      name: config-service

추가

busrefresh postman으로 post실행하면 http상태코드가 204로 반환되는걸 알 수있다.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

bootstramp.yml파일

spring:
  cloud:
    config:
      uri: http://112.1.1.2:8888
      name: ecommerce #파일명 yml

application.yml파일

management:
  endpoints:
    web:
      exposure:
        include: refresh, health, beans, httptrace

httptrace을 쓰기 위해서는 설정을 추가해줘야한다.

GatewayApplication에 bean추가

@Bean
    public HttpTraceRepository httpTraceRepository(){
        return new InMemoryHttpTraceRepository();
    }

application.yml 추가

- id: user-service
  uri: lb://USER-SERVICE
  predicates:
    - Path=/order-service/actuator/**
    - Method=GET,POST
  filters:
    - RemoveRequestHeader=Cookie
    - RewritePath=/user-service(?<segment>.*), /$\{segment}

application file을 여러개 생성 시

이름을 서로 정보를 다르게 해보자

token:
  expiration_time: 86400000
  secret: user_token_dev

token:
  expiration_time: 86400000
  secret: user_token_prod

근데 이렇게 하면 두개의 정보가 다르기에 jwt가 판단한다.

git repo & native file repo

githb github 주소 로 이어지는것도 가능 합니다. github repository 값을 넣어 가능 합니다.
profiles:
   active: native #cloud.config.server.native 와 같이 연계되어 사용한다.
native:
  search-locations:  yaml 파일이 있는 폴더 위치를 넣어주면 된다.

각각의 구성정보파일 application.yml파일 정보가 바뀌면 다시 빌드하고 해야하는데 그걸 개선하기 위해 외부에 있는 시스템을 통해서 구성파일 정보를 관리할 수 있는 기능

git을 통해서

$ ~/Desktop/work/git-local-repo 디렉토리 생성
$ cd init
ecmmerce.yml 파일 생성
$ git add ecommerce.yml
$ git commit -m "upload an application yaml file"

후 code ecommerce.yml 치면 vs가 켜지는데

기존 yml파일에 있던 중복되던 내용을

token:
  expiration_time: 86400000
  secret: user_token

Config Server 생성

프로젝트 Spring Cloud Config - Config server만 선택 후 생성

@SpringBootApplication
@EnableConfigServer
public class ConfigServiceApplication {

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

바로 @EnableConfigServer를 써주면서 Config 서버로 구동시켜준다

server:
  port: 8888

spring:
  application:
    name: config-service
  cloud:
    config:
      server:
        git:
          uri: file://{등록한 y폴더경로}/ecommerce

http://112.1.1.2:8888/ecommerce/default 입력하면

// 20230201234421
// http://112.1.1.2:8888/ecommerce/default
{
  "name": "ecommerce",
  "profiles": [
    "default"
  ],
  "label": null,
  "version": "e95f07fb2851a044c0db619517a279b877c69ce9",
  "state": null,
  "propertySources": [
    {
      "name": "file://C:/l/ecommerce/ecommerce.yml",
      "source": {
        "token.expiration_time": 86400000,
        "token.secret": "user_token",
        "gateway.ip": "112.1.1.2"
      }
    }
  ]
}

겹치는 user Service에서 yml파일 주석 처리 후

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

bootstrap.yml

spring:
  cloud:
    config:
      uri: http://112.1.1.2:8888
      name: ecommerce #파일명 yml

pom.xml과 application.yml과 동일한 위치의 resources 폴더 아래에 bootstrap.yml 파일을 생성한 후 우리가 실행한 서버의 uri와 접근할 name을 적어준다.

내용을 확인하고자 기존에 있던 usercontroller에 health_check부분을 수정

    @GetMapping("/health_check")
    public String status(){
        return String.format("유저 서비스"
                + ", port(local.server.port) = " + env.getProperty("local.server.port")
                + ", port(server.port) = " + env.getProperty("server.port")
                + ", token secret = " + env.getProperty("token.secret")
                + ", token expiration time = " + env.getProperty("token.expiration_time")
        );
    }

ecommerce 정보들을 가져오는걸 볼 수 있다

여기서 이런 설정들이 변경이 자주 있을텐데 이런 방법을 가져오는데는 3가지 방법이 있는데

＊서버 재기동

• Actuator refresh
• Spring cloud bus 사용 세가지있다

Actuator refresh

솔직히 서버 재기동을 하기에는 너무 번거로움이 많다 그래서 제외하고 바로 Actuator refresh부터 해보았다.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

@Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        AuthenticationManager authenticationManager = getAuthenticationFilter(http);

        http.csrf().disable();
        http.authorizeRequests()
                .antMatchers("/actuator/**").permitAll() //actuator는 모두 허용
                .antMatchers("/error/**").permitAll()
   //             .antMatchers("/**").hasIpAddress("112.1.1.2")
                .and()
                .authenticationManager(authenticationManager)
                .addFilter(getAuthenticationFilter(authenticationManager));

        //h2 console error 해결을 위해
        http.headers().frameOptions().disable();

        return http.build();

application.yml

management:
  endpoints:
    web:
      exposure:
        include: refresh, health, beans

#refresh: 현재 마이크로서비스에 있는 config-service에서 가져와야하는 정보를 refresh하겠다

등록후 health나 beans는 web으로 가능하지만 refresh는 안된다 POSTMAN에서 POST http://112.1.1.2:52750/actuator/refresh 를 보내 변경하는 식으로 해야한다.

다시 VS로 돌아가서 yml파일 정보를 바꾼 후 $ git add ecommerce.yml $ git commit -m "changed values"

로 정보를 바꾼 후 http://112.1.1.2:52750/actuator/refresh postman으로 실행하면 서버 재가동 없이 정보가 바뀌는걸 알 수 있다.

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,
                                            Authentication authResult) throws IOException, ServletException {
        log.debug(((User)authResult.getPrincipal()).getUsername());

        String userName = ((User)authResult.getPrincipal()).getUsername();
        UserDto userDetails = userService.getUserDetailsByEmail(userName);

    }

기존의 log만 찍었던 로직을 다음과 같이 입력 받은 userName 값으로 userId값을 받아올 수 있도록 변경한다.

여기서 userService에서 getUserDetailsByEmail(userName)이 정의 되지 않았기 때문에 정의해줘야한다 생성자에 UserService와 Enviroment값을 매개변수로 설정했기 때문에 WebSecurity에서 생성자로 Filter를 생성하는 부분에도 값을 넣어줘야한다.

    private AuthenticationFilter getAuthenticationFilter(AuthenticationManager authenticationManager) {
        return new AuthenticationFilter(authenticationManager, userService, env);
    }

UserServiceImpl에서

    @Override
    public UserDto getUserDetailsByEmail(String email) {

        UserEntity userEntity = userRepository.findByEmail(email);

        if(userEntity == null)
            throw new UsernameNotFoundException(email);

        return new ModelMapper().map(userEntity, UserDto.class);
    }

Jwt 추가

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

application.yml

token:
  expiration_time: 86400000 #ms단위 하루설정
  secret: user_token

toeken을 이용해준다

//로그인 성공했을 때 로직
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,
                                            Authentication authResult) throws IOException, ServletException {
        log.debug(((User)authResult.getPrincipal()).getUsername());
        String userName = ((User)authResult.getPrincipal()).getUsername();
        UserDto userDetails = userService.getUserDetailsByEmail(userName);

        String token = Jwts.builder()
                .setSubject(userDetails.getUserId()) //token 내용
                .setExpiration(new Date(System.currentTimeMillis() +
                        Long.parseLong(env.getProperty("token.expiration_time")))) //파기 날짜
                .signWith(SignatureAlgorithm.HS512, env.getProperty("token.secret")) //token 생성 알고리즘과 키 값
                .compact();

        response.addHeader("token", token);
        response.addHeader("userId", userDetails.getUserId()); //원래는 반환하지 않는 데이터이지만 확인용

    }

또한 userservice에서 jwt를 통해 토큰을 발급 받는 기능을 추가했으니 gateway에도 jwt dependency추가해준다.

@Component
@Slf4j
public class AuthorizationHeaderFilter extends AbstractGatewayFilterFactory<AuthorizationHeaderFilter.Config> {

    private Environment env;

    //생성시 Config class를 상속받은 Factory로 넘겨줘야해서 lombok을 사용하지 않고 다음과 같이 처리
    public AuthorizationHeaderFilter(Environment env) {
        super(Config.class);
        this.env = env;
    }

    public static  class Config{}

    //login -> token -> users (with token) -> header(include token)
    @Override
    public GatewayFilter apply(Config config) {
        return ((exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();

            //header에 HttpHeaders.AUTHORIZATION 값이 존재하는지 확인
            if(!request.getHeaders().containsKey(HttpHeaders.AUTHORIZATION)){
                return onError(exchange, "no authorization header", HttpStatus.UNAUTHORIZED);
            }

            String authorizationHeader = request.getHeaders().get(HttpHeaders.AUTHORIZATION).get(0);//배열이라서
            String jwt = authorizationHeader.replace("Bearer", "");

            if(!isJwtValid(jwt)){
                return onError(exchange, "JWT Token is not valid", HttpStatus.UNAUTHORIZED);
            }

            return chain.filter(exchange);
        });

    }

    //token이 유효한지 확인
    private boolean isJwtValid(String jwt) {
        boolean returnValue = true;

        String subject = null;

        try {
            subject = Jwts.parser().setSigningKey(env.getProperty("token.secret"))
                    .parseClaimsJws(jwt).getBody()
                    .getSubject();
            //token의 내용을 가져옴
            //jws로 파싱하고 그 앞에서 subject값
        } catch (Exception ex){
            returnValue = false;
        }

        if(subject == null || subject.equals("")){
            returnValue = false;
        }

        return returnValue;
    }

    //에러 발생시 에러 값을 response
    //Mono, Flux -> Spring WebFlux / 데이터 단위 단일=Mono, 복수=Flux
    private Mono<Void> onError(ServerWebExchange exchange,
                               String err,
                               HttpStatus httpStatus) {

        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(httpStatus);

        log.error(err);
        return response.setComplete();

    }


}

그리고 yml에 AuthorizationHeaderFilter 설정해준다

        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user-service/login
            - Method=POST
          filters:
            - RemoveRequestHeader=Cookie
            - RewritePath=/user-service/(?<segment>.*), /$\{segment}
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user-service/users
            - Method=POST
          filters:
            - RemoveRequestHeader=Cookie
            - RewritePath=/user-service/(?<segment>.*), /$\{segment}
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user-service/**
            - Method=GET
          filters:
            - RemoveRequestHeader=Cookie
            - RewritePath=/user-service/(?<segment>.*), /$\{segment}
            - AuthorizationHeaderFilter

user-service중 GET방식에 AuthorizationHeaderFilter filter를 추가

Authenticate 필요X post-> /user-service/users (회원가입) post-> /user-service/login (로그인) Authenticate 필요O GET-> /user-service/users (회원정보)

Bearer Token에 발급 받은 토큰을 입력 후 진행 과정을 디버그로 확인해보자

AuthorizationHeaderFilter의 apply()로 요청이 들어가고

//header에 HttpHeaders.AUTHORIZATION 값이 존재하는지 확인
            if(!request.getHeaders().containsKey(HttpHeaders.AUTHORIZATION)){
                return onError(exchange, "no authorization header", HttpStatus.UNAUTHORIZED);
            }

이걸로 인해 Header에 Authorization : value 가 존재하는지 확인 value에 Bearer + token으로 값이 넘어오는데 해당 값을 replace()로 처리해주고 isJwtValid()를 통해 유효성을 체크

AuthenticationFilter 파일에서 두개의 브레이크 포인트를 찍었다. attemptAuthentication 인증 요청시 요청이 되는지, successfulAuthentication 로그인 성공시 로그가 찍히는지 확인을 위해서 찍었다.

postman으로 로그인 시도하면

첫 번째 디버그 포인트 으로 먼저 인증 요청 부분인 AuthenticationFilter의 attemptAuthentication로 실행이 된다. request를 통해 RequestLogin 객체를 만들고 그 객체를 UsernamePasswordAuthenticationToken을 통해 세번째 디버그포인트인 loadUserByUsername 전달

userEntity에서 정보 실제 존재여부 확인 후 없을 시엔 exception을 터트리고 있을경우 다시 User객체로 반환한다

이럼 이전에 실행했던 retrieveUser의 catch에 걸리게 되고 var4로 UsernameNotFoundException Exception authenticate에서도 catch에 걸리게 되고 debug로 로그를 찍고 BadCredentialsException Exception을 생성하여 그후에는 AuthenticationException을 ProviderManager의 authenticate 메서드에서 던지게 된다. 그리고 계속 filter를 타고 처리가 되어지는데 결국 401이 뜨고 만다.