아이디어

i번 손님이 주문한 단품메뉴조합(orders[i])에서 2개 메뉴로 구성할 수 있는 가짓수는 nC2개 라고 할 수 있다. 각 손님의 nC2개 경우의 수를 모두 구하고, 가장 자주 나온 경우를 구하면 가장 많이 함께 주문한 단품메뉴들을 구할 수 있다.

1. R = 각 course, 메뉴 구성 개수이다.
2. 각 orders(String이다.) 에서 R개를 뽑아 새로운 subString을 만든다.
3. 모든 orders에 대해 subString을 구했을 때, 가장 많이 나온 subString이 답이 된다.
4. 각 R에 대해 모두 진행한다.

풀이코드

import java.util.*;
class Solution {
    static int maxVal ;
    static Map<String,Integer> map = new HashMap<>();

    public String[] solution(String[] orders, int[] course) {

         ArrayList<String> result = new ArrayList<>();

    //1. 전체 orders 알파벳 오름차순으로 정렬
        for(int i=0;i<orders.length;i++){
            char[] chars = orders[i].toCharArray();
            Arrays.sort(chars);
            orders[i] = String.valueOf(chars);
        }
    // 2. 전체 course(R번)
        for(int j=0;j<course.length;j++){
            maxVal=1;
            map.clear();
            // 각 orders 에서 R개 뽑은 경우의 수 찾기
            for(int i=0;i<orders.length;i++){
                char[] chars = orders[i].toCharArray();
                boolean[] visit = new boolean[chars.length];
                comb1(chars,visit,0,chars.length,course[j]);
            }
            //주문이 2번이상인 경우에만
            if(maxVal>1){
                for(Map.Entry<String,Integer> entry : map.entrySet()){
               //최댓값을 결과 list에 저장
                    if(entry.getValue() == maxVal){
                        result.add(entry.getKey());
                    }
                }
            }

        }


        String[] answer = new String[result.size()];
        for(int k=0;k<result.size();k++){
            answer[k] = result.get(k);
        }
        Arrays.sort(answer); //결과 list sortting
        return answer;
    }


//nCr 구하기
    void comb1(char[] arr, boolean[] visited, int start, int n, int r) {
        if(r == 0) {
            //arr에서 현재 visit에 해당하는 부분을 조합.
            makeStr(arr,visited);
            return;
        } else {
            for(int i = start; i < n; i++) {
                visited[i] = true;
                comb1(arr, visited, i + 1, n, r - 1);
                visited[i] = false;
            }
        }
    }

     void makeStr(char[] arr, boolean[] visit){
        String newStr="";
        for(int i=0;i<arr.length;i++){
            if(visit[i]==true){
                newStr+=arr[i];
            }
        }
    //새로 만든 조합이 이미 map에 있을경우
        if(map.containsKey(newStr)){
            int current = map.get(newStr);
            map.put(newStr,current+1);
            if(current+1>maxVal) //maxVal 저장하기.
                maxVal= current+1;
        }else{
            map.put(newStr,1);
        }
    }
}

SOP란

CORS 에러는 SOP라는 브라우저의 원칙으로 인해 발생한다. SOP는 Same Origin Policy로, 동일 출처가 아닌 경우 발생한다. 여기서 동일 출처는 프로토콜,호스트,포트가 동일한 경우이다.

SOP가 필요한 이유

그렇다면 동일 출처가 아닌 경우 브라우저가 접근을 차단하는 이유는 뭘까?

사용자가 웹사이트에 접근할 때는 브라우저의 쿠키에 로그인 세션 토큰을 남기게 된다. 해당 토큰을 사용해 사용자는 매번 로그인할 필요없이 서비스를 이용할 수 있다. 웹사이트는 토큰을 받아 파싱, 해석하여 로그인되었음을 인지한다.

그러나 로그인 토큰이 남아있는 브라우저에서, 사용자가 악성사이트에 접속한 경우, 악성사이트는 사용자 브라우저의 토큰에 접근할 수 있다. 악성사이트가 이 토큰으로 네이버와 같은 웹사이트에 로그인을 요청할 경우, 사용자는 악의적인 상황에 놓일 수 있다.(탈탈,, 털려)

이런 상황에서 브라우저는 SOP에 따라 이런 악의적 상황을 막습니다. 브라우저는 악성 사이트의 요청서버와, 요청받고 응답을 주는 응답서버의 출처가 다른걸 보고 CORS에러를 내립니다.

웹사이트 서버에서 악성사이트를 허가해주지 않는 이상, 악성사이트는 CORS에러로 정상적으로 로그인할 수 없습니다.

따라서 사용자가 보는 피해를 방지할 수 있습니다.

• 간단 정리

  👿 악의적인 상황

1. 내가 A 사이트에 로그인하면 브라우저에 ID등 세션정보(토큰)를 쿠키에 저장함
2. 그 상황에서 우연히 특정 악성 사이트에 접근하게된다.
3. 악성사이트는 브라우저에게 시켜 내 쿠키를 읽어 토큰을 갈취함
4. 악성사이트에서 A 사이트에 내 세션 토큰으로 요청해 로그인하고 나쁜짓함

😇 브라우저의 SOP에 의한 해결

1. 악성사이트에 대한 A사이트의 응답을 분석한다.
2. 두 사이트의 출처가 다르다면 악성사이트에게 CORS 에러 내림
3. 악성사이트는 나쁜짓 못한다.

CORS란

CORS란 Cross origin resource sharing으로, 이런 sop로 발생하는 에러를 해결해주는 일종의 방법입니다.

sop로 사용자를 보호할 수 있지만, 서버는 점차 확장되고, 때로는 다른 회사의 서버부를 이용해야(API 사용 등등) 하는 상황이 자주 발생합니다. 따라서 조건에 따라 이런 다른 출처를 허가해줘야 합니다.

CORS의 흐름

1. 단순요청

요청만으로 서버에 영향을 주지 않는 단순요청의 경우,

1. 서버에게 본요청을 전달한다.
2. 서버가 OK랑 Access-Control-Allow-Origin를 보낸 경우 응답을 전달한다.
3. Access-Control-Allow-Origin이 안오면 본요청이 fail되고 브라우저는 CORS에러를 발생시킨다.

2. 예비요청이 있는 경우

단순요청이 아닌경우, 예비요청을 통해 허가를 받은 후, 본 요청을 할 수 있습니다.

1. OPTIONS 메소드로 Origin(호스트 uri)을 실어서 보낸다. (예비 요청)
2. 서버가 요청을 허가할 경우 OK랑 Access-Control-Allow-Origin을 보낸다.
3. 브라우저는 서버의 허가를 확인 후 본 요청을 보내게 된다.

CORS의 해결

CORS는 크게 두 부분으로 해결할 수 있습니다.

1. 프론트엔드의 웹서버에서 요청을 받아서 백엔드서버로 요청을 보내는 것
2. 백엔드 서버에서 자체적으로 요청을 허가해주는 것

1. 프론트엔드에서 프록시 이용

우선 cors에러는 브라우저를 통과하며 발생합니다. 따라서 온전한 서버끼리의 통신에서는 발생하지 않습니다. 프론트엔드 단의 웹서버에서 요청을 프록시 형태로 감싸 백엔드 서버로 바로 요청할 경우, 에러가 발생하지 않습니다.

2. 백엔드 서버에서 허가

백엔드 서버에서 Access-Control-Allow-Origin 응답을 설정하게 하여, 임의로 허가를 내려줄 수 있습니다.

• 스프링 서버 전역적으로 CORS 설정

static class AppConfig implements WebMvcConfigurer {
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/api/**")
                    .allowedMethods("GET", "POST") //메소드 지정 가능
                    .allowedOrigins("*"); //와일드 카드: 전체 다 허락
        }
    }   

• 특정 컨트롤러나 메소드에 개별적 CORS 설정

@Controller
//특정 컨트롤러에만 CORS 적용하고 싶을때.
@CrossOrigin(origins = "*", methods = RequestMethod.GET) 
public class customController {

    @GetMapping("/url")  
    //특정 메소드에만 CORS 적용 가능
    @CrossOrigin(origins = "*", methods = RequestMethod.GET) 
    @ResponseBody
    public List< > findAll(){
        return service.getAll();
    }

}

참고자료

1. CORS 흐름 관련 자료

2. 더 자세한 CORS 해결 방법

화면에 그리는 내용을 서버가 아닌 브라우저에서 처리하는 방식.

• SPA의 진행방식 사용자의 클릭 -> 화면에 그려져야할 html 을 한번만 로딩 -> ajax를 이용해서 back단에서 서버에 http 요청을 보냄 -> 서버가 json으로 응답 -> 클라가 받아서 처리(DOM 조작을 통해 렌더링) 서버는 확실히 프론트와 더 분리가 가능해짐.

HTTP (stateless 때문에) 사용자 정보를 알리기 위해 쿠키에 sessionId를 함께 실어 보냄. 세션은 서버에서 관리하고, 쿠키로 세션 정보를 주고 받음

• SPA
  • 세션에 메뉴정보나, 설정 정보를 담으면 세션이 점점 커진다.
    • 이런 정보(사용자 데이터 모델의 일부)는 브라우저의 local storage에 담는다.
    • 그래서 정보 변경등 필요할때 데이터를 요청이 가능하다.

CORS(Cross Origin Resource Sharing)

1. 상황

하나의 web application은 여러개의 호스트와 다양한 리소스에 접근하게됨.
사용자를 악의적인 행위에서 보호하기 위해 
브라우저는 동일 출처에서만 리소스 접근을 허용하도록 함.
따라서 다양한 리소스에 접근하게 해주는게 CORS

👿 악의적인 상황이란?

1. 내가 A 사이트에 로그인하면 브라우저에 ID등 세션정보(토큰)를 쿠키에 저장함
2. 그 상황에서 우연히 특정 악성 사이트에 접근하게된다.
3. 악성사이트는 브라우저에게 시켜 내 쿠키를 읽어 토큰을 갈취함
4. 악성사이트에서 A 사이트에 내 세션 토큰으로 요청해 로그인하고 나쁜짓함 

2. SOP와 CORS

• Same Origin(동일한 출처): 프로토콜, 호스트,포트가 동일한 경우.

• 동일출처가 아닐 때 에러발생 -> SOP(same Origin Policy)가 막음. -> CORS가 이를 해결

• CORS: http 헤더를 이용해서 application의 다른 출처 리소스에 접근하게 하는 메커니즘. -> 어떤 기준을 충족시키면 리소스 공유가 되도록 함.

3.CORS 흐름

• 예비요청(preflight)을 보내냐에 따라 CORS 흐름이 달라짐.

• 단순요청이 아닐때는 예비요청을 보냄

• 단순요청의 경우: 단순요청의 기준들을 모두 만족하는 경우

• 예비요청이 있는 경우

  • OPTION 메소드로 보내고
    • Origin(호스트 uri)을 실어서 보냄
    • 서버가 Origin의 요청을 허가할 경우 답변으로 OK랑 Access-Control-Allow-Origin: (어쩌구)를 보낸다
    • 허용을 확인후 본 요청을 보내게 된다.

• 예비요청이 없는 경우

  • 단순요청(본요청)을 보낸다.
    • 서버가 OK랑 Access-Control-Allow-Origin를 보낸다
    • Access-Control-Allow-Origin이 안오면 본요청이 fail된다.

4. CORS 지원방식

CORS 방식 1. 프론트엔드의 프록시 이용

• url에 대한 요청을 프론트엔드 웹서버에 보내고
• 웹서버가 요청을 정제해 back단에서 백엔드 스프링서버에 http 요청을 보내고 받아 처리한다.

CORS 방식 2. 스프링 서버 전역적으로 CORS 설정

static class AppConfig implements WebMvcConfigurer, ApplicationContextAware {
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/api/**")
                    .allowedMethods("GET", "POST") //메소드 지정 가능
                    .allowedOrigins("*"); //전체 다 허락
        }
    }   

CORS 방식 3. 특정 컨트롤러나 메소드에 개별적 CORS 설정

@Controller
//특정 컨트롤러에만 CORS 적용하고 싶을때.
@CrossOrigin(origins = "*", methods = RequestMethod.GET) 
public class customController {

    @GetMapping("/url")  
    //특정 메소드에만 CORS 적용 가능
    @CrossOrigin(origins = "*", methods = RequestMethod.GET) 
    @ResponseBody
    public List< > findAll(){
        return service.getAll();
    }

}

** 도메인과 DTO

• http 리퀘스트가 안받아진다고 도메인을 건들지 말것.
• 도메인은 도메인의 룰을 유지 해줘야함.
• request를 처리할 DTO를 만들어서 처리해주자.
• 비즈니스 도메인의 룰(validation 등)은 모두 도메인 클래스에 넣을것
• DTO의 validation 룰은 컨트롤러 요청에 맞춰 정한다.

1. form 담긴 html 파일

   <-- 1. POST로 해당 url에 요청 -->
   <form th:action="@{/customers/new}" method="post"> 
        <div class="mb-3">  
            <label for="exampleInputEmail1" class="form-label">Email address</label>
          <-- 2. input name을 설정해줄 것. -->
            <input type="email" name="email" class="form-control" id="exampleInputEmail1" aria-describedby="emailHelp">
        </div>
        <div class="mb-3">
            <label for="exampleInputPassword1" class="form-label">Name</label>
            <input type="text" name="name" class="form-control" id="exampleInputPassword1">
        </div>
        <div class="mb-3 form-check">
            <input type="checkbox" class="form-check-input" id="exampleCheck1">
            <label class="form-check-label" for="exampleCheck1">Check me out</label>
        </div>
        <button type="submit" class="btn btn-primary">Submit</button>
    </form>

2. Controller에 POST 핸들러 작성해주기

    @PostMapping("/customers/new")
    public String addNewCustomer(CreateCustomerRequest createCustomerRequest){
        customerService.createCustomer(createCustomerRequest.email(), createCustomerRequest.name());
        return "redirect:/customers";
    }

CreateCustomerRequest에서는 1번의 폼에서 전달해준 input의 name에 해당하는 요소를 받아 처리한다.

public record CreateCustomerRequest(String email, String name) {
}

• 파라미터를 url로 전달했을 때

  • @PathVariable("custoemrId") : path에 있는 변수 찾아 매핑해줌.

    @GetMapping("/customers/{customerId}")
    public String findCustomer(@PathVariable("custoemrId") UUID customerId, Model model){
      var maybeCustomer = customerService.getCustomer(customerId);
      if(maybeCustomer.isPresent()){
          model.addAttribute("customer",maybeCustomer.get());
          return "views/customer-details";
      }else{
          return "views/404";
      }
    
    }

• 정리

  • 컨트롤러에서 DTO(CreateCustomerRequest 같은)를 통해 데이터를 받아온다.
  • validation,http 확인 등의 작업을 수행한다.
  • 그 후 받아온 데이터를 실제 로직은 서비스와 entity에서 하도록 넘겨준다.

2. WebApplicationContext

1. 여러 서블릿이 공유가 가능한 내용을 Servlet Context에 저장 모든 서블릿들이 접근 가능한 루트 서블릿이 서블릿 WebApplicationContext: ApplicationContext를 상속받음. 거기에 Servlet Context접근하는 기능이 추가 되어 있음.

   Servlet Context: 여러 서블릿이 공유가 가능한 정보를 담고 있음.

   • 여러 dispatcher servlet에서도 접근이 가능함.
   • 여러 dispatcher servlet이 만들어지면 여러 WebApplicationContext이 만들어짐.
   • 각 Context는 어떤 관계를 가지는가? 모든 context에 접근 가능한 Bean이 없을까?

   • 모든 ApplicationContext들이 접근 가능한 root ApplicationContext이 필요함.

   root ApplicationContext

   • Servlet Context가 만들어질때 root ApplicationContext가 생김.
   • Servlet Context에 attribute로 들어가있음.
   • 그 후 생겨난 servlet들은 Servlet Context에 접근해 root ApplicationContext를 사용하게됨.

• 로더, 리스너 내용

• 서블릿 어플리케이션 구조부분

2. 실습

• 처음에 Dispatcher Servelet의 WebApplicationContext의 parent는 없다.

• 모든 빈들이 WebApplicationContext 컨테이너에 다 등록되어 있다.

• root ApplicationContext을 만들고, 거기에 서비스랑 데이터 access 관련된 빈들을 등록하고 관리할것임.

• dispatcher servelet 의 WebApplicationContext에는 mvc 관련된 빈만 등록하도록 하고 루트랑 부모 자식으로 연결되도록.

@EnableWebMvc
    @Configuration

    //컨트롤러에 해당하는 빈만 스캔하겠다.
    @ComponentScan(basePackages = "org.prgrms.kdt.customer",
            includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = CustomerController.class),
            useDefaultFilters = false

    )
    static class AppConfig implements WebMvcConfigurer, ApplicationContextAware {
          //스프링의 app context
        ApplicationContext applicationContext;
        @Override
        public void configureViewResolvers(ViewResolverRegistry registry) {
            registry.jsp().viewNames("jsp/*");          
        }

        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            registry.addResourceHandler("/resources/**")
                    .addResourceLocations("/resources/");
        }
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
        }
    }


    //컨트롤러 제외하고 다른 빈들(서비스, 데이터관련)만 스캔하겠다.
    @Configuration
    @ComponentScan(basePackages = "org.prgrms.kdt.customer",
            excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = CustomerController.class)
    )
    @EnableTransactionManagement
    static class RootConfig{
        @Bean
        public DataSource dataSource(){
          return  DataSourceBuilder.create().build();
        }
        //그 외 트랜잭션 및 jdbcTemplate 관련 Bean 설정
    }

     @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        //1.RootConfig로 root컨텍스트 만들어주기
        var rootApplicationContext = new AnnotationConfigWebApplicationContext();
        rootApplicationContext.register(RootConfig.class);
        //2. 로드 리스너 설정해주기 -> 부모 자식 연결해줌
        var loaderListener =new ContextLoaderListener(rootApplicationContext);
        servletContext.addListener(loaderListener);

    //3. DispatcherServlet은 AppConfig로 만들어주기
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.register(AppConfig.class);
        var dispatcherServlet= new DispatcherServlet(applicationContext);

        logger.info("Starting Server...");
        ServletRegistration.Dynamic servletRegistration = servletContext.addServlet("test", dispatcherServlet);
        servletRegistration.addMapping("/");
        servletRegistration.setLoadOnStartup(1);
    }

3. setLoadOnStartup

디폴트 값이 -1로 정의되어 있음.

3. REST API

• REST(Representational Transfer): 웹 상의 자료를 HTTP위에서 SOAP이나 쿠키를 통한 세션 트랙킹 같은 별도의 전송 계층 없이 전송하기 위한 아주 간단한 인터페이스

• API(application programming interface) :

REST API : REST 아키텍쳐 스타일을 따르는 API

REST 아키텍쳐 스타일 균일한 인터페이스 : URI로 지정한 리소스에 대한 조작을 통일되고 한정적인 인터페이스로 수행하는 아키텍처 스타일

SOAP : 단 하나의 url에 요청을 xml에 기술하고 전달

LV 1: 하나의 리소스에 대해 다양한 형태로 표현이 가능하다 LV 2: http 메서드(get,post,put,delete)를 도입하는 것 LV 3: HATEOAS(Hypermedia as the Engine of Application State)

• 리소스와 함께 link에 해당 리소스로 할 수 있는 행위들을 제공

API 설계

• URI는 자원을 표현, 명사를 사용
• 자원을 가지고 할 행위는 http 메서드를 사용
• 슬래시는 계층관계를 나타냄
• URI 마지막에 슬래시를 포함하지 않기
• 하이픈으로 URI 가독성을 높이기

실습 스프링에서 레스트api 개발을 위해 annotation 제공

1. RequestBody 전달받은 요청 메시지를 원하는 형태로 변환.
2. ResponseBody 우리가 결과낸 모델클래스가 response로 변환.
3. RestController Controller + ResponseBody RestController를 적용하면 하위 모든 메서드에 respnse Body가 생긴다.

Dispatch Servlet의 요청을 받아 핸들러매핑으로 핸들러 찾고, 핸들러 어댑터가 argument Resolver를 사용해서 적절히 변형해 핸들러에 전달 @RequestBody,@ResponseBody, HttpEntity를 리턴할경우, HTTP 메시지 컨버터가 동작해 결과 모델을 HTTP 메시지로 변환한다.

1. 설정하지 않으면 디폴트 메시지 컨버터가 작동해 JSON으로 변환해 출력
2. initializer에서 디폴트 메시지 컨버터를 아예 변경

   public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            //디폴트 메시지 컨버터가 싹 바뀐다.
            var messageConverter = new MarshallingHttpMessageConverter();
            var xStreamMarshaller = new XStreamMarshaller();
            messageConverter.setMarshaller(xStreamMarshaller);
            messageConverter.setUnmarshaller(xStreamMarshaller);
            converters.add(messageConverter);
        }

3. initializer에서 디폴트 메시지 컨버터를 경우에 따라 다르도록 확장

    @Override
        public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
            //디폴트 메시지 컨버터에서 확장하는 방식으로 사용가능

            //1.xml 방식으로 컨버팅하도록 추가
            var messageConverter = new MarshallingHttpMessageConverter();
            var xStreamMarshaller = new XStreamMarshaller();
            messageConverter.setMarshaller(xStreamMarshaller);
            messageConverter.setUnmarshaller(xStreamMarshaller);
            converters.add(0, messageConverter);


            //2. 날짜의 경우 변환해주는 다른 메시지 컨버터를 추가
            var javaTimeModule = new JavaTimeModule();
            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ISO_DATE_TIME));
            var modules = Jackson2ObjectMapperBuilder.json().modules(javaTimeModule);
            converters.add(1, new MappingJackson2HttpMessageConverter(modules.build()));

        }

1. SpringMVC

1. Dispatch Servlet

• 하나의 서블렛(front controller)이 모든 요청을 받아서 다른 컨트롤러를 호출시키는 형태
  • 개발자는 컨트롤러를 작성하고, 스프링 Dispatch Servlet이 작성한 컨트롤러를 호출함.
• Dispatcher Servlet은 단하나의 서블릿이 된다.
• 어떤 컨트롤러를 처리할지, 예외 어떻게 처리할 지 결정하게 된다.

  2. 스프링 MVC 요청 처리과정

1. 사용자 요청이 들어온다.
2. Dispatcher Servlet이 요청에 맞는 컨트롤러를 찾아 요청을 위임
3. 해당 컨트롤러는 서비스를 호출하여, 화면에 전달할 모델을 만든다.
4. 컨트롤러는 만든 모델과 뷰를 Dispatcher Servlet에 전달한다.
5. Dispatcher Servlet은 받은 모델과 뷰로 그에 적합한 컨텐츠를 제작
6. 제작한 컨텐츠를 HTTP 응답으로 사용자에게 보낸다

구현방법-----

1. 웹 application initializer 할때 Dispatcher Servlet을 등록하여 사용

3. 핸들러매핑과 ViewResolver

• 핸들러 매핑 Handler Mapping: 요청의 URL 기준으로 어떤 핸들러에게 위임할지 결정

• 핸들러 호출 시 파라미터 매핑 Handler adapter: 핸들러의 메서드 파라미터에 맞는 정보로 변환해준다. ① Dispatcher Servlet이 모든 HTTP서블릿 리퀘스트 오브젝트를 받고 ② 어댑터로 변환해서 적절한 파라미터를 핸들러에게 전달.

• ViewResolver 뷰는 어떻게 처리되는가

1. Dispatcher Servlet이 컨트롤러에 GET요청 위임
2. 컨트롤러가 뷰(뷰이름) - 모델을 반환
3. ViewResolver에서 name에 해당하는 view를 찾아 반환
   • InternalResource ViewResolver : 최하단의 ViewResolver, JSP를 처리

• 전체적인 스프링 MVC 흐름

1. 요청이 오면 Dispatcher Servlet이 받는다
2. 핸들러 매핑에 의해 핸들러(컨트롤러) 선택
3. 핸들러 어댑터가 핸들러에 맞게 파라미터 변환
4. 핸들러가 파라미터 받아 서비스 수행, 결과로 모델과 뷰네임 생성.
5. view name이 Dispatcher Servlet에 전달된다.
6. Dispatcher Servlet이 ViewResolver에 뷰네임, 모델을 전달
   • ViewResolver가 특정한 View를 찾아줌(JSP 등등)

4번을 제외한 과정을 스프링부트가 대신 해준다.

2. SpringMVC 실습

JSP 거의 쓰지 않는다..! 백엔드 공부할때 JSP에 너무 시간을 쏟지 않기

1.dispatcherServlet 만들고 설정

@EnableWebMvc : 스프링 mvc가 필요한 빈들이 자동으로 등록됨

    @EnableWebMvc
    @Configuration
    @ComponentScan(basePackages = "org.prgrms.kdt.customer")
    @EnableTransactionManagement
    static class AppConfig implements WebMvcConfigurer {
        @Override
        public void configureViewResolvers(ViewResolverRegistry registry) {
            registry.jsp(); //리퀘스트.jsp 로 연결!
        }
}
@Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.register(AppConfig.class);
        var dispatcherServlet= new DispatcherServlet(applicationContext);


        logger.info("Starting Server...");
        ServletRegistration.Dynamic servletRegistration = servletContext.addServlet("test", dispatcherServlet);
        servletRegistration.addMapping("/*");
        servletRegistration.setLoadOnStartup(1);
    }

2. jsp 파일 설정하기

<c:forEach var="i" begin="1" end="10" step="1">${i}<br></c:forEach>


<c:forEach var="customer" items="${customers}">${customer.customerId}<br></c:forEach>


 <table class="table">
        <thead>
        <tr>
            <th scope="col">ID</th>
            <th scope="col">Name</th>
            <th scope="col">Email</th>
            <th scope="col">CreatedAt</th>
            <th scope="col">LastLoginAt</th>
        </tr>
        </thead>
        <tbody>
    <c:forEach var="customer" items="${customers}">${customer.customerId}
        <tr>
            <th scope="row">${customer.customerId}</th>
            <td>${customer.name}</td>
            <td>${customer.email}</td>
            <td>${customer.createdAt}</td>
            <td>${customer.lastLoginAt}</td>
        </tr>
    </c:forEach>
        </tbody>
    </table>

3. 정적리소스 처리

톰캣의 web.xml에 있는디폴트 서블릿을 통해 리소스를 가져오게 된다.

 static class AppConfig implements WebMvcConfigurer {
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //   ' /resources/** ' 에 관한 리소스에 대한 요청이 오면 
            registry.addResourceHandler("/resources/**")

                    .addResourceLocations("/resources/");
                     //   ' /resources/ ' 의 위치에서 리소스를 찾는다.
                    .setCachePeriod(60) //캐시설정
                    .resourceChain(true) //리소스 체인 걸기
                    .addResolver(new EncodedResourceResolver());//gzip으로 압축된 리소스 먼저 찾음
        }
 }

• 요청부분 예시

  <img src="<c:url value="/resources/bg.jpg"/>" class="img-fluid">

  4. Thymeleaf 활용

  자바 템플릿 엔진이다. HTML로 작성된 파일을 파싱해서 뷰를 제공.

1. 타임 리프추가

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

   java

2. 사용하기 전에

3. 문법

1) 웹 구성요소들

 **URI: 웹의 많은 리소스를 식별하기 위한 식별자.**

 상대경로: 내 위치 기준이동 (앞에 슬래시 없음.)
 절대경로: 
 -> 배포될때 리소스 위치가 달라지면서 변경될 수 있다.(찾을수 없을 수 있다.)
 -> URI에 아스키만 사용가능, 인코딩-디코딩 신경써야함.




 https://velog.io/@hoit_98/TIL-20210827

 URI 스케마 : https
 호스트명 : velog.io
 패스: @hoit_98/TIL-20210827

HTTP: 리소스를 접근하고 수정하게 해준다. URI로 조작대상을 지정해서 Hyper Text Transfer Protocol : 하이퍼 텍스트 문서를 교환하기 위해 만들어진 통신 규약

-- (요청/request) -- >
클라이언트 웹 브라우저 OS 호스트서버 < -- (응답/response) --

• 주요 특징

  • TCP/IP 기반
  • 요청/응답형 프로토콜
  • 동기형 프로토콜 : 요청이 있으면 반드시 응답이 있는
  • 스테이트리스 : 요청을 보내고 나면 그 요청에 대한 상태는 날아갑니다. 매번 요청을 보낼때마다 상태 정보를 같이 실어서 보내줘야한다. (예 토큰/ 쿠키 전달)

• 8개의 메서드 가짐 get, post, put, delete, head, options, trace, connect

* | CRUD 명 | 의미 | 메서드 | | ------- | ---- | -------- | | create | 작성 | post/put | | read | 읽기 | get | | update | 갱신 | put | | delete | 삭제 | delete |

HTML(h) : 연결성을 가진 마크업 언어 hyper Text : 텍스트 안에 링크가 있어 다른정보와 연결성이 있는거.

URI -> 프로토콜 :

웹 특징

• 하이퍼미디어 시스템
• 분산 시스템 : 복수의 컴퓨터가 처리함. 전세계의 브라우저가 다양한 각서버에 접속하여 처리하는 방식.

2) 웹 아키텍쳐

아키텍쳐 : 시스템 구성과, 동작원리, 시스템 구성환경을 설명하는 설계도
웹 어플리케이션 아키텍쳐 : 웹 어플을 구성하는 시스템들간의 상호작용과 동작원리들.

백엔드에서 리소스, DB를 읽어 프론트엔드에 reponse 전달
프론트엔드에서 렌더링 시킨 웹브라우저를 사용자에게 제공.

   1. DNS: 브라우저에서 들어온 URI 요청에 해당하는 ip를 찾아 제공

   2. Load Balancer: 서버에 들어온 요청을 분산시켜줌(scale out)
   -> 여러대의 컴퓨터, 어떻게 분배시켜줄지(알아서 인스턴스에 분배?)

   3. 웹서버: 자바, 파이썬 등으로 코드 실행, 여러 개의 서버로 분산가능 -> OLTP

   4. DB: jdbc 등을 활용, 데이터베이스의 데이터 제공

   5. 캐싱: 똑같은 정보요청이 빈번할때, 비효율적인 db 접근을 줄이고 캐싱한 정보를 가져오게함.
   ->redis(가벼운 db를 캐싱 서버로 사용)

   6a. Job Queue: 오래걸리는 작업을 넣어둔다.

   6b. Job Server: job queue에서 할일을 전문으로 하는 서버에 압축해놓고 완료되면 웹서버에게 알린다.

   7. 텍스트 서치에 많은 리소스가 쓰이므로 서치용 서비스 분리 가능

   8. 분산된 서버에 해당하는 여러개의 서비스 존재할 수 있음

   9a.Data firehorse: 클라우드나 Data wareHouse의 데이터를 불러오고 저장
   ->kafka: 데이터를 받아서 분배
   9b.Data wareHouse: 분석용이나 따로 사용하려 데이터웨어하우스에 저장

   10.클라우드 저장소 : S3등의 클라우드에 이미지 등을 CDN을 통해 고객이 빠르게 접근할 수 있게 해줌.

   11. CDN : 각 전세계에 캐시서버등을 분산해놓고, 근접한 요청을 처리하도록함.
   ->클라우드 프론트

2. Servlet

1. 웹서버

   HTTP 웹서버 : HTTP 프로토콜을 지원하는 서버/ 정적컨텐츠만제공 웹 애플리케이션 서버와 차이 : 동적 컨텐츠를 지원하느냐

   WAS

   • db 조회, 비즈니스 로직처리를 하게됨.
   • 자바 코드를 실행해 비즈니스 로직을 처리해 동적 컨텐츠를 처리.
   • jsp나 서블릿을 구동할수 있다.(동적 처리)
   • 일반적인 웹서버 역할도 수행가능(정적 처리) 만든 웹어플리케이션(.war) -> WAS(톰캣, 제티 등)에 deploy

   nginx -> 웹서버, 로드밸런싱(돌려막기) 웹서버를 분리해서 기능을 앞단에 해서 클라이언트와 소통, 웹서버 뒤 방화벽 뒤에 WAS 구동시켜 동적인 컨텐츠(인증, 인가 등)를 가져온다. DB에는 WAS에서만 접근되도록한다 https://velog.io/@change/WEB%EC%84%9C%EB%B2%84-WAS-%EB%B6%84%EB%A6%AC-%EC%9D%B4%EC%9C%A0

   ---

   서블릿: 클라이언트의 요청을 받아 서비스단에 필요한 것을 요청. 서버 역할(요청수행, 응답)을 하는 컴포넌트. 서블릿은 스펙에 맞게 웹 애플리케이션을 개발 -> WAS에 돌려 구동

   WAS JSP를 사용하여 랜터링 -> 정적컨텐츠 생성

   ---

   MVC 패턴 관심을 모델, 뷰, 컨트롤러로 분리 모델: 데이터처리(POJO로 데이터만 담고 있는다) / JAVA Bean(자바 객체) 뷰: 화면(보여지는 것 처리) / JSP 컨트롤러: 로직(모델-뷰를 연결해 사용자 요청처리) / Filter나 Servlet

3. Servlet LifeCycle

웹서버 요청 -> WAS에 요청 웹 컨테이너에서 실행하며 여러 쓰레드 생성 -> 서블릿의 서비스를 요청

서블릿 : init 된 후 종료될때 까지 사용 init() -> 각 쓰레드에서 요청된 서블릿의 서비스(do get/ do Post)를 수행 -> destroy

각 리퀘스트에서 매번 새 서블릿 인스턴스를 생성하는 것(X) 매번 새 쓰레드에서 한 서블릿의 서비스가 요청되는것(O) -> 따라서 서블릿 안에서 어떤 필드값을 수정, 저장 하면 다른 쓰레드에서도 그 값을 참조할 수 있게됨. -> 다른요청과 기존 요청과 뒤섞이는 일이 발생한다. => !!! 메서드 안에서 변수를 만들고 처리해야 함 !!!

4. Servlet, WAS 실습

*구현한 테스트 서블렛 *

public class TestServlet extends HttpServlet {
    private static final Logger logger = LoggerFactory.getLogger(TestServlet.class);

    @Override
    public void init() throws ServletException {
        super.init();
        logger.info("Init Servlet");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String requestURI = req.getRequestURI();
        logger.info("Got request from {}",requestURI);

        var writer=resp.getWriter();
        writer.println("hello servlet!!");
    }
}

1. web.xml 을 이용

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <servlet>
        <servlet-name>test</servlet-name>
        <servlet-class>org.prgrms.kdt.servlet.TestServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>test</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

2. annotation을 이용
   • 구현한 test 서블릿 위에 @WebServlet을 달아준다.

@WebServlet(value = "/*", loadOnStartup = 1)
public class TestServlet extends HttpServlet {
    private static final Logger logger = LoggerFactory.getLogger(TestServlet.class);
}

3. 스프링에서 제공해주는 인터페이스를 구현
   • WebApplicationInitializer

public class KdtWebApplicationInitializer implements WebApplicationInitializer {
    private static final Logger logger = LoggerFactory.getLogger(KdtWebApplicationInitializer.class);

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        //WAS 실행 선행 후행으로 작업해줘야할때 사용할 수 있음.
        logger.info("Starting Server...");
        ServletRegistration.Dynamic servletRegistration = servletContext.addServlet("test", new TestServlet());
        servletRegistration.addMapping("/*");
        servletRegistration.setLoadOnStartup(1);
    }
}

*세 방법 모두 톰캣인 WAS 에 war를 배포하는 방식 *

-> 오래된 방식이라 요즘은 내장 톰켓을 사용해 jar로 패키징.

1. Spring의 트랜젝션관리

AOP : CrossCuttingConcern을 해결해주는 방법. 부가기능 : 로깅, 보안 등 각 레이어에 걸쳐서 적용할 부가적 기능 AOP -> 레이어의 핵심기능(관심사)과 부가기능을 분리하게 해줌

각 비즈니스 로직 앞-뒤에 끼어들어갈 부가기능을 어떻게 추가할 수 있을까.

• 컴파일시점 AspectJ 같은 AOP 프레임워크가 소스코드를 컴파일 전에 부가기능을 소스에 삽입하는방식

• 클래스 로딩시점 클래스 로딩할때 바이트 코드에다가 부가기능을 삽입한다.

• ** 런타임 시점 스프링에서 제공하는 AOP 방식. 사용할 객체의 프록시를 이용해서 프록시가 본 비지니스전에 부가기능을 호출해서 사용하는 방식.**

스프링 AOP 프록시 두가지 방식 -JDK 다이내믹 프록시(인터페이스 기반) :인터페이스를 구현한 객체가 프록시의 타겟이 된다. -CGLib 프록시(클래스 기반)

2. Spring Proxies

프록시는 일을 대신 해주는 패턴이었다.

프록시는 클라이언트의 요청을 받아서 적정한 선,후 처리후 타겟을 반환해준다.

즉. 프록시는 타겟을 감싸서 타겟의 요청을 대신 받아준다.

참고 블로그 - 그림참고

//JDK 프록시 사용예시 

//타겟 클래스 (실제)
class CalculatorImpl implements Calculator{

    @Override
    public int add(int a, int b) {
        return a+b;
    }
}

interface Calculator{
    int add(int a, int b);
}

//핸들러, 프록시가 할일 정의
class LoggingInvocationHandler implements InvocationHandler {

    private static final Logger log = LoggerFactory.getLogger(LoggingInvocationHandler.class);
    private final Object target;

    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        //부가 기능(로그) 먼저 실행
        log.info("{} executed",method.getName());
        //주요 기능 , 즉 진짜 일을하는 객체를 반환
        return method.invoke(target,objects);
    }
}



public class JdkProxyTest {
       public static void main(String[] args) {

        var calculator = new CalculatorImpl();
        var proxyInstance = (Calculator) Proxy.newProxyInstance(
                LoggingInvocationHandler.class.getClassLoader(),
                new Class[]{Calculator.class},
                new LoggingInvocationHandler(calculator));

        var add = proxyInstance.add(1,2);

    }
}

스프링 aop 사용하기

1. AOP 디펜던시 추가

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

2. aspectJ 어노테이션을 이용해 aop기능을 사용

어노테이션을 읽고, 실제 스프링 AOP 방식으로 aspect(뒤에나옴)를 적용하게 해준다.
프록시로 구현되어 런타임에 적용되고
xml은 오래된 방식이라 aspectJ의 어노테이션 방식이 권장됨.

[추가 조사]

• 위빙(뒤에 나옴) 과정에서 프록시객체가 생성된다.

  이 프록시 객체가 생성됨으로써 특정 조인포인트에 어드바이스가 적용된다.

• 참고 블로그

3. Spring AoP 주요용어

타겟 (핵심기능을 가지고있는 모듈, 부가기능이 적용될 대상)

조인포인트 (부가기능이 적용될 수 있는 수많은 포인트(메서드)들 )

포인트 컷(어느 조인포인트를 선택할지 선별하는 정규표현식 : 기준)

에스펙트 : 어드바이스 + 포인트 컷, 부가기능의 set. -> 부가기능(로깅기능)을 포함한 타겟. -> 어떤 내용을 어디에 적용할지. => 스프링에서는 이 aspect를 빈으로 등록해서 사용

어드바이스(적용될 부가기능의 내용) :Before, After,Around,After Returning, After Throwing ->어떤 조인포인트에서, 이 작업을 Before에 할지 언제할지 결정

위빙(부가기능이 적용되는 과정) == 타겟의 조인 포인트에 어드바이즈를 적용하는 과정. -> 타겟의 특정메소드를 선정해서, 어떠한 방식을 통해, 어드바이스를 적용하는게 위빙이다.

4. Spring AoP 실습

 //지정자: 타겟의 여러 조인트 포인트중에서 어드바이스를 어떻게 적용시킬지 AOP에게 알려주는 키워드들
    //@Around("execution()") -> 메서드를 실행하는 시점에 내용을 적용하겠다.

    //public 메소드에 접근할때, 리턴 타입이 뭐든(*)
    //org.prgrms.kdt..* 해당 위치 뭐든
    //(..) 파라미터 뭐든
    //@Around("org.prgrms.kdt.aop.CommonPointCut.repositoryInsertMethodPointCut()")
    @Around("@annotation(org.prgrms.kdt.aop.TrackTime)") // 해당 에노테이션에서 부가기능을 실행하겠다.
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Before method called. {}", joinPoint.getSignature().toString());
        var startTime = System.nanoTime();
        var result = joinPoint.proceed();
        var endTime = System.nanoTime() - startTime;
        log.info("After method call with return result -> {} and time taken {} nanoseconds", result,endTime);
        return result;
    }

어드바이스들 
1. execute
2. within : 특정 클래스를 쓸 수 있음

어드바이스들을 미리 지정하고 메소드명으로 소환이 가능한 @PointCut을 쓸 수 있음.

5.Spring 트랜잭션 실습

트랜잭션 -> ACID을 유지
중간에 망가지면 -> 롤백.
성공적으로 마무리되면 중간 과정을 커밋.

6.Spring 트랜잭션 매니저 실습

트랜잭션 매니저 : 
->
트랜잭션 템플릿

7.Transactional

지금까지직접 트랜잭션 매니저, 템플릿 가지고 우리가 호출해가면서 씀. (programatic 한 트랜잭션 매니징)

-> 스프링에서는 @Tranactional을 통해 선언적 트랜잭션 관리가 가능

//에러가 나면 롤백한다 -> 이런건 사실상 부가기능임. 주요로직이 아니다. @Transactional이 트랜잭션관리 -> 이는 사실 aop 기술이 적용되고 그 안엔 프록시가 작동한다. 여러 db sql 을 실행하는 서비스 단에 적용해서 뭔가 잘못되면 전체 롤백이 가능하도록함.

@Trasactional 어노테이션을 달면? (아직 몰라도될듯) 1.@Trasactional을 적용한 메서드가 있는 클래스 타입의 프록시가 생성됨 2. 위처럼 스프링 AOP에 의해서 자동으로 생성된 프록시에 3. 트랜잭션 관련 기능들이(부가기능) 앞뒤로 붙게된다.

@EnableTransactionManagement -> 실행하는 스프링프로젝트에 달아줘야 트랜잭션 관리 가능

8.트랜잭션 전파와 격리

1. 트랜잭션 전파

트랜잭션 전파 : 트랜잭션이 처리되는 과정 중에, 또다른 트랜잭션이 진행되는 것. 롤백이 이어지는 상황이 있을 수 있다. @Trasactional(propagation= )

2. 트랜젝션 격리

@Trasactional(isolation = ) 트랜잭션이 이뤄지면서 다른 트랜잭션도 이뤄질 수 있다. 따라서 이런 트랜잭션 사이가 지독하게 엮이는 일이 생길 수 있다.
-> 그러면 아직 커밋도 안된 값이 다른데서 읽힌다거나.. 제법 복잡해진다.

그래서 이런 트랜잭션이 얼마나 다른 트랜잭션에 독립적인지. 독립성의 단계를 나눈게 Trasaction isolation 레벨이다.

READ_UNCOMMITTED : 커밋 안된것도 읽음 READ_COMMITTED : 커밋된 내용만 읽음 REPEATABLE_READ : 한 트랜잭션에서 먼저 읽어진 데이터의 경우에 다른 트랜잭션에서 변경,삭제되는 걸 방지한다. SERIALIZABLE: 한 트랜잭션에서 먼저 읽어진 데이터의 경우에 다른 트랜잭션에서 새로 insert되는 것을 방지한다/ 막는다.

dirty read : (수정중인 데이터를 읽을 수 있는가?) 커밋되지 않은 것도 읽으므로, 롤백되어도 이미 읽어버린 후라서 돌이킬수없음. 지저분하게 읽게됨

non-repeatable read : 한트랜잭션에서 앞-뒤로 같은 쿼리값을 읽는데 중간에 다른 트랜잭션에서 값을 바꾸면 앞-뒤 쿼리의 결과가 다름. 일관성 없는 읽기.

phantom reads : 한트랜잭션에서 앞-뒤로 같은 쿼리값을 읽는데 중간에 다른 트랜잭션에서 값을 insert하면 앞-뒤 쿼리의 결과가 다름. 갑자기 뭐가 새로 생김. 없었는데? 있었습니다.

@Trasactional(isolation = )로 수준을 설정해줄 수 있다.

• default: 사용하는 DB에서 설정한 아이솔레이션 레벨을 쓰겠다. (mysql : SELECT @@SESSION.transaction_isolation 쿼리로 확인이 가능)

이상하게도 자꾸 리눅스 용량이 부족한 현상이 있었다. 어떤 부분이 용량을 차지하는지 궁금해 찾게되었다.

1. root 로 이동해준다.

   [root@(아이피) ~]# cd /

2. 아래 명령어로 하위 디렉토리 path를 입력하여 크기를 확인한다.

   du -sh /폴더경로/*

   ``` [root@(아이피) /]# du -sh ./*
3. 1M ./bin 26M ./boot
4. 0K ./cgroup 140K ./dev 38M ./etc
5. 9G ./home 179M ./lib 19M ./lib64
6. 8G ./logs
7. 0K ./srv 0 ./sys 132K ./tmp
8. 0K ./tmpt
9. 6G ./usr 27G ./var

``` (var 파일이 굉장히 큰것을 확인 후, 이상 로그 발생부를 찾았다)

왜 임베디드 DB 쓰는가

 DB등의 외부환경이 테스트 성공 실패에 영향을 주면 테스트에 대한 자동화 불가능.
 -> 개발중에 고정적으로 사용할수있는 내부 DB가 필요함.
 -> 임베디드 DB 사용

임베디드 DB의 사용

EmbeddedDatabase 자체가 datasource를 extend한다. 따라서 DB연결 후 datasource 형태로 반환가능.

//H2 사용할때
EmbeddedDatabase db = new EmbeddedDatabaseBuilder()
.generateUniqueName(true)
.setType(H2) //  H2 Db를 통해 
.setScriptEncoding("UTF-8")
.ignoreFailedDrops(true) 
.addScript("schema.sql")//add script: 스크립트 읽어서 초기설정
.build()

오픈소스 임베디드 DB의 사용

근데, SQL 자체가 벤더사(MYSQL, POSTQL 등)에 따라 쿼리에 쓰이는 function이 다르기 때문에(ex. UUID_TO_BIN) mysql에 맞춘 쿼리에는 H2 DB 가 동작 안할수도있다.

-> 벤더사에 맞는 임베디드 DB(embedded-mysql 등) 사용이 필요할 수 있다. (대체로 오픈소스로 사용할수있다.)

=> 따라서 그런 function 필요없도록 쿼리 작성하거나, 안된다면 적절한 임베디드 db 오픈소스를 활용해서 동작시킬 수 있다.

//1.Config 등의 메소드에 사용할 데이터소스를 반환
var dataSource = DataSourceBuilder.create()
                    .url("jdbc:mysql://localhost:2215/test-order_mgmt")
                    .username("test")
                    .password("test1234!")
                    .type(HikariDataSource.class)
                    .build();

@BeforeAll
    void setUp(){
        //1. 임베디드 mysql에 관해 설정
        var  mysqldConfig= aMysqldConfig(v8_0_11)
                .withCharset(UTF8)
                .withPort(2215)
                .withUser("test", "test1234!")
                .withTimeZone("Asia/Seoul")
                .build();
        EmbeddedMysql embeddedMysql = anEmbeddedMysql(mysqldConfig)
                .addSchema("test-order_mgmt",classPathScript("schema.sql"))
                .start();
    }

mysql 임베디드 DB 오픈소스 링크

2.NamedParameterJdbcTemplate

NamedParameterJdbcTemplate란?

스프링이 NamedParameterJdbcTemplate를 제공 -> 템플릿의 ?와 숫자 인덱스 기반(일반 JdbcTemplate) 아닌 -> 이름 기반의 파라미터를 설정하게 해주는 템플릿

JdbcTemplate을 가지고 있고, 그 파라미터 부분을 조정해서 제공.

• 해시맵을 제공하고, 그 해시맵의 키값을 사용

Exception 처리

잘못된 sql 접근 -> sqlException에서 얻는 코드값이 벤더사마다 다름. -> 스프링이 DataAccessException을 제공, 다양한 데이터접근 에러를 포함(DuplicateKeyException 등)하고 있음. -> 타입화된 에러를 활용할 수 있음

    try {
            customerNamedJdbcRepository.insert(newCustomer);
        }catch (BadSqlGrammarException e){
            //원래는 각 에러코드마다 처리해야함.
            // BadSqlGrammarException처럼 타입화된 에러를 활용해 이를 쉽게 처리가능
            logger.error("got BadSqlGrammarException errorcode ->{}",e.getSQLException().getErrorCode());
        }

트랜잭션

트랜잭션 -> ACID을 유지 중간에 망가지면 -> 롤백. 성공적으로 마무리되면 중간 과정을 커밋.

connection.setAutoCommit(false);
connection.setAutoCommit(true);
connection.rollback();

 매번 커넥션 생성, 소멸시 리소스가 많이 소모됩니다. 
 -> 커넥션 풀이 등장, datasource를 통해서 커넥션을 받고 반납할 수 있음!

 커넥션 미리 만들어 놓고 풀에 저장해뒀다가 
 필요할때마다 커넥션을 가져와서 쓰고 다시 반환

 커넥션 풀을 데이터소스에 의해서 가져와지고 반납된다.
 따라서 커넥션 클로즈를 하는거는 사실 데이터 소스에 커넥션을 반환하는거당

 *여러 데이터 소스 구현 라이브러리 있음
 1. 스프링제공 : simpleDriverDataSource -> 사실 커넥션풀 개념은 아니고 그냥 열고 닫음
 2. 아파치의 DBCP
 3. HikariCP

2.DataSource - HikariCP

빠르고 안정적인 DBCP
spring-boot-starter-jdbc 디펜던시 설정시 함께 들어온다.

3.DataSource - CustomerRepository(1, 2)

//DataSorce를 HikariDataSource 타입을 제작해서 주입받아 사용하기!
@Configuration
    @ComponentScan(basePackages = {"org.prgrms.kdt.customer"})
    static class config{
        @Bean
        public DataSource dataSource(){
            var dataSource = DataSourceBuilder.create()
                    .url("jdbc:mysql://localhost/database이름")
                    .username("사용자이름")
                    .password("사용 비밀번호")
                    .type(HikariDataSource.class)
                    .build();


            return dataSource;
        }
    }

    @Autowired
    CustomerJdbcRepository customerJdbcRepository;

    @Autowired
    DataSource dataSource;

3. TestInstance Lifecycle

원래 @BeforeAll은 static 메소드. 따라서 그 안에서 인스턴스 변수에 접근이 안된다. -> @TestInstance(TestInstance.Lifecycle.PER_CLASS) // 클래스 단위로 인스턴스 하나 생성. -> 따라서 @BeforeAll이 static 아니여도 되고, 내부 필드들을 가지고 작업도 가능하다

[추가 조사] JUnit 에서는 @Test 가 붙은 테스트 메서드를 실행시킬 때, 각각 클래스를 새로 로딩 한다. 왜냐면 -> @TestInstance(TestInstance.Lifecycle.PER_METHOD)가 디폴트라서 메소드 별로 로딩한다. 그래서 BeforeAll이 스태틱이여야 한다. BeforeAll이 전체 테스트 이전에 한번만 실행되므로 각 테스트 메소드의 인스턴스가 생성되지 않았더라도, 호출되어야 하기 때문.

참고: 링크

순서대로 테스트 진행

클래스 단위로 실행할 테스트에서 순서를 정해 진행하지 않으면 오류가 발생할 수 있다. 이때 테스트 클래스에 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)를 달아서 순서대로 실행하게 할 수 있다.

@order(숫자) : 숫자 순서대로(오름차순) 테스트 실행

4. JDBC Template

커넥션 맺는 부분과 예외처리 하는부분이 계속 반복된다.
이 반복되는 부분과 변경되는 부분을 템플릿 콜백 패턴을 이용해서 
JDBC 템플릿 패턴을 제공.

JDBC 템플릿: 변경이 필요한 제공해서 간결한 코드를 쓰게 해준다.

jdbcTemplate.query("select * from customers", customerRowMapper);

1. .query() 가 실행되는 방식

2. .update() 가 실행되는 방식

생성자 주입이 좋다! -> 초기화때 모든 의존관계가 생기니까 안전해! -> 엄청 엮인 애는 파라미터가 엄청 많을테니까, 눈을 의심해서 두번 확인할 수 있음

Autowired(자동으로 주입되는게) 2개면 스프링이 몰라요 -> @Primary 를 붙여줘서 우선순위 주거나 -> @Qaulifier 해가지고 사용하는 쪽에서 쓸 컴포넌트 정할수 있당

4.BeanScope : 빈이 어떤 범위로 만들어질까 싱글톤이 기본 - > 자동으로 같은 빈 = 같은 객체로 생성. 프로토타입으로 -> 같은 빈이 다른 객체로 생성됨. -> 싱글톤으로 쓰는게 좋다. 왱?

4. Life Cycle 객체의 생명주기 생명 생성이 되면 -> postConstruct, afterPropertySet,initmethod(Bean에 임의로 구현한) 순으로 콜백을 거칠 수 있음 소멸되면 -> PreDestroy ,destroy, 순으로 콜백 거칠 수 있슴

오늘의 한마디

오늘 강의 재밌당! 주말에 한번 더 보는게 좋겠엉 학부때 암것도 모른채로 들었던 내용인데 관심생기고 보는 느낌은 다르다.

이게 뭐지

1. Record 키워드(java 14)

2. reduce function

3. orElseThrow

4. Transitive Dependencies

   배우고 느낀것

5. 느슨한 결합도를 위해서 -> 런타임 의존성 고려

6. 지금 내가 생각하는 소프트웨어의 Build

   - 내가 필요한 라이브러리 받아서 쓰게 해줌
   - 컴파일해서 돌려볼 수 있게 만들어줌
   - 아 맞다 릴리즈할때는 버전도 관리하게 해주는거 같았는데
   - 아직은 이정도밖에 모르겠다. 근데 그래도 없으면 안된다 나혼자 라이브러리 설치하는 일은 겪고 싶지 않아.

   3. EJB 가 뭔디? Auto Configuration 뭔디 ;;

내가 이해한 IoC(Inversion of control)

 - 생성된 객체에 따라서 프레임워크가 그 객체가 사용할 객체나 메소드들을 결정한다.
 - 나는 그냥 원하는 주문을 만들었을 뿐인데, 그에 해당하는 방식대로 할인이 된다.

일기장

😥 코딩하는건 재밌는뎅 알아야될게 넘넘 많아서 약간 막막허다 책읽는 건 좋은데 30층 짜리 책장으로 둘러싸여가지고 당황스럽다고 해야되나...? 근데 뭐 사실 할 수 있는거는 하나씩 꺼내읽는거 밖엔 없다 아직 ㅎ 그냥 주어진대로 내가 재미있는대로 내가 필요한 대로 한달은 그렇게 해볼란당

내가 느낀거 배운거

1. 예전에 암것도 모르고 트랜잭션으로 데이터 insert 시간 줄인적이 있는데, 트랜잭션이 이런거고나... 좀 더 알아볼필요가 있을덧

2. SQL 키트 풀면서 0~23 까지 가상테이블을 만들일이 있었당. 이거를 그렇게 Recursive 키워드로 푸는게 좋은지? 아니면 프로시저를 쓰면 어떤징 궁금하다아

근데 또 날짜함수안에는 작은따옴표 안에 써줘야해서 헷갈린다. PR 날릴때 같이 질문하고 다시 정리해야지

오늘 배운거, 느낀거

강의에서 자기 그릇을 한정짓지 말라고 하셨당 너무 내가 자주 생각하는 일 같아서 찔렸다..ㅎ 뭔지 모르게 힘이 되서 눈물이 찔금날뻔..

1) select문

    1) count(NULL) -> 더하기 수행 안함

        2)
            CASE WHEN(조건) THEN 값
            ELSE 값

        3) DISTINC는 뒤에 따라오는 모든 필드에 적용이 된대~!

오늘 깨달은 거, 생각한 거

1. ORDER BY 1, GROUP BY 1 하면 SELECT 문의 첫번째꺼 기준으로 된다.

-> 두 번 반복해 쓸 필요가 없어서 편리하다. -> 뭐가 더 좋을까? 직관적으로는 두번쓰는게 낫나?

열심히 사는 사람들을 보면서 감명도 받고 불안감도 같이 느끼기도 한다. 그래도 답은 일단 하는 거 같다. 월말엔 많이 변해있으면 좋겠당..

​ 문법적 규칙을 클래스화 하여, 일련의 규칙을 통해 언어/문법을 해석하는 패턴이다.

😊 사용되는 곳

​ SQL 문은 SELECT (어쩌구) FROM (저쩌구) WHERE (이러쿵저러쿵) 과 같이

​ 특정 문법을 지키면 MYSQL에서 알아서 쿼리결과를 짠 하고 내줍니다.

​ 덕분에 개발자들은 손쉽게 DB에서 결과를 얻게 됩니다.

​ 이렇듯 간단한 문법적 규칙(대체로 문자열을 해석하는)을 클래스화해서 사용자가 원하는 답을 얻게 해주는 패턴이 Interpreter 패턴입니다.

​ 주로 SQL 해석, shell 명령어 해석기 등에 사용하는 패턴입니다.

🤔 구현을 어떻게 할까 (구현 예시)

​ Interpreter 패턴으로 후위 표기법 을 구현해보겠습니다.

​ 후위 표기법에서는 1+2 를 1 2 + 로 표현합니다.

​ (3 + 5) * (4 + 2) => 3 5 + 4 2 + *

​ 우리가 "a b +" 를 요청해도, "w x z - +" 를 요청해도

​ 문법 해석기가 알아서 해석해서 결과를 줄 수 있어야 합니다.

1. 우리가 "w x z - +"라는 문장을 Evaluator라는 문법해석기에 넣을 겁니다.
2. Evaluator는 문장을 해석해 저 문장대로 계산이 가능한 계산기를 출력해줍니다.
3. 그 계산기에 사용자가 원하는대로 문자=10(w=10) 과 같이 입력을 넣어주면
4. 우리는 답 37을 얻을 수 있습니다.

📜 코드로 살펴볼까요!

1. 연산자들

• 연산자 interface

import java.util.Map;

//우리가 만들 연산자들
public interface Expression {
    //어떻게 해석할지 구현
    public int interpret(Map<String, Expression> variables);
}

• Plus 연산자 구현

  //Plus 연산자 구현
  public class Plus implements Expression{
   //+의 왼쪽에 올 표현(숫자일 수도 있고 이미 연산된 결과일 수 있음)
   Expression leftOperand;
    //+의 오른쪽에 올 표현
   Expression rightOperand;
  
   public Plus(Expression leftOperand, Expression rightOperand) {
       this.leftOperand = leftOperand;
       this.rightOperand = rightOperand;
   }
  
   @Override
   public int interpret(Map variables) {
       //왼쪽과 오른쪽의 결과를 더해서 반환
       return leftOperand.interpret(variables)+rightOperand.interpret(variables);
   }
  }

  • Minus 연산자 구현

    //Minus 연산자 구현
    public class Minus implements Expression{
    //-의 왼쪽에 올 표현(숫자일 수도 있고 이미 연산된 결과일 수 있음)
    Expression leftOperand;
    //-의 왼쪽에 올 표현(숫자일 수도 있고 이미 연산된 결과일 수 있음)
    Expression rightOperand;
    
    public Minus(Expression leftOperand, Expression rightOperand) {
       this.leftOperand = leftOperand;
       this.rightOperand = rightOperand;
    }
    
    @Override
    public int interpret(Map variables) {
        //왼쪽에서 오른쪽의 결과를 빼서 반환
       return leftOperand.interpret(variables)-rightOperand.interpret(variables);
    }
    }

  • Variable(알파벳에 해당) 연산자 구현

    public class Variable implements Expression{
    private String alphabet;
    
    public Variable(String alphabet) {
       this.alphabet = alphabet;
    }
    
    @Override
    public int interpret(Map<String, Expression> variables) {
       // 사용자가 입력한 Map에 alphabet이 있으면 그 알파벳에 해당하는 숫자 반환
       // 없으면 0 반환 
       if(variables.get(alphabet) == null)
           return 0;
       return variables.get(alphabet).interpret(variables);
    }
    }

• Number(사용자가 입력한 숫자) 연산자 구현

  public class Number implements Expression{
    private int num;
  
    public Number(int num) {
        this.num = num;
    }
  
    @Override
    public int interpret(Map variables) {
        return num; //숫자를 반환
    }
  }

  2. 문법에 따라 연산 제조
  • Evaluator(해석기) 구현
  • 후위 연산법은 스택을 통해 구현합니다.(참고 : 후위 표기법)

    import java.util.Map;
    import java.util.Stack;

    public class Evaluator implements Expression{
        private Expression syntax; //만들 최종 해석

        public Evaluator(String expression){
            //expression을 입력받음
            Stack<Expression> stack = new Stack<Expression>();

            for(String strToken : expression.split(" ")){
                if(strToken.equals("+")){
                    Expression expressionPlus = new Plus(stack.pop(),stack.pop());
                    stack.push(expressionPlus);
                }else if(strToken.equals("-")){
                    Expression expressionMinus = new Minus(stack.pop(),stack.pop());
                    stack.push(expressionMinus);
                }else {
                    stack.push(new Variable(strToken));
                }
            }
            //해석 결과로 나온 계산기 
            syntax = stack.pop();
        }

        //사용자가 입력한 숫자로 계산기에 계산돌리기
        @Override
        public int interpret(Map<String, Expression> variables) {
            return syntax.interpret(variables);
        }
    }

3. 메인

    import java.util.HashMap;
    import java.util.Map;

    public class Main {
        public static void main(String[] args) {
            //해석을 원하는 문장
            String expression ="w x z - +";

            //문장에 따른 해석기를 제작
            Evaluator sentence = new Evaluator(expression);

            //사용자가 w = 5, x = 10, z =42 를 입력
            Map<String, Expression> variables = new HashMap<String, Expression> ();
            variables.put("w",new Number(5));
            variables.put("x",new Number(10));
            variables.put("z",new Number(42));

            //해석기에 입력을 넣고 결과 얻기
            int result = sentence.interpret(variables);
            System.out.println(result);
        }

    }

💻 결과

"w x z - +"

(z-x) + w == (42-10) + 5

37

💕 참고한 링크들

1. 기본적인 Interpreter 패턴이해

   https://beomseok95.tistory.com/288

2. 구체적인 Interpreter 패턴 구현(후위 표기법 구현)

   https://hamait.tistory.com/199

​ 인스턴스를 가능한 한 공유해서 사용함으로써 메모리를 절약하는 패턴

👿 문제상황

​ 마인크래프트 게임에 나무를 설치하고 싶습니다.

​ 나무는 색(color)을 정할 수 있고, 특정 위치(x, y)에 세울 수 있습니다.

​ 만약 내가 마크에 미쳐서 나무 10000개를 맵에 심는다고 할 때,

​ 나무 한 그루에 들어가는 데이터는

​ color : 4Byte , x: 4byte, y:4byte 라고 합시다.

​ 모든 나무를 심을 때마다 객체를 생성한다면, 나무 10,000개에는 120,000byte 가 듭니다.

​ 더 마크에 열광하는 사람들은 더 많은 나무를 세울텐데,, 나~중에는 메모리가 터질수도 있습니다.

😇 어떻게 해결할까

​ 모든 나무의 x, y는 다르지만 나무 색은 항상 바뀔 필요는 없죠? 거의 같고 가끔 색 바꾸게 됩니다.

​ 그러면 나무를 계속 새로 만들지 말고,, 저장해놨다가 가져다 쓰는 식으로 한다면??

​ 그러면 새로운 색상의 나무가 추가될 때만 새 객체를 생성한다면

​ 나무가 10000개 여도 12 * (새로운 색상을 추가한 횟수) byte 이렇게 변하겠네요!

​ 내가 만약 색을 2개만 쓴다면 24byte 이니까 이전보다 119976byte 가량 절약할 수 있습니다!

​ 나무 수가 많을 수록 더 절약할 수 있겠네요!

​ 이렇게 인스턴스를 가능한대로 공유시켜서 쓸데없는 new를 통한 메모리 낭비를 줄이는것이 Flyweight 패턴입니다!

🤔 구현을 어떻게 할까

​ 플라이웨이트 패턴을 구현하기 위해 아래 3가지가 필요합니다.

1. 실제 공유될 객체 (나무)

2. 객체의 인스턴스를 생성하고 공유해주는 팩토리(Factory)

   -> 같은 색의 나무가 없다면 새로 생성하고, 있다면 그 색의 나무를 반환해줍니다.

3. 패턴을 사용할 고객, 클라이언트

   -> 우리는 그냥 2번에게 OO색 나무를 요청하고, 받아서 X,Y를 설정하고 설치하면 됩니다.

📜 코드로 살펴볼까요!

1. 공유할 Tree 객체

   public class Tree {
   
    // 나무는 아래와 같이 3개 정보를 가지고 있습니다.
    private String color;
    private int x;
    private int y;
   
    //색상으로만 생성자를 만들어줄게요.
    public Tree(String color) {
        this.color = color;
    }
   
    public void setX(int x) {
        this.x = x;
    }
   
    public void setY(int y) {
        this.y = y;
    }
   
    //나무를 심을 때
    public void install(){
        System.out.println("x:"+x+" y:"+y+" 위치에 "+color+"색 나무를 설치했습니다!");
    }
   }

2. Tree를 제공해줄 TreeFactory

   public class TreeFactory {
   //HashMap 자료구조를 활용해서 만들어진 나무들을 관리해볼게요
   public static final HashMap<String, Tree> treeMap = new HashMap<>();
   
   

public static Tree getTree(String treeColor){
    //Map에 입력받은 색상의 나무가 있는지 찾습니다. 있으면 그 객체를 제공합니다.
    Tree tree = (Tree)treeMap.get(treeColor); 

   //만약 아직 같은 색상의 나무가 Map에 없다면 새로 객체를 생성해 제공합니다.
    if(tree == null){
        tree = new Tree(treeColor);
        treeMap.put(treeColor, tree);
        System.out.println("새 객체 생성");
    }

    return tree;
}

}

 3. 사용할 고객
```java
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("원하는 색을 입력해주세요 :)");
        for(int i=0;i<10;i++){
            //나무 색 입력받기
            String input = scanner.nextLine();
            //팩토리에서 나무 하나 공급받기
            Tree tree = (Tree)TreeFactory.getTree(input);
            //나무 x,y 설정하고
            tree.setX((int) (Math.random()*100));
            tree.setY((int) (Math.random()*100));
            //나무 설치하기
            tree.install();
        }

    }
}

💻 결과

다른 색상이 들어올 때만 새로운 객체를 생성합니다!

원하는 색을 입력해주세요 :)
초록
새로운 객체 생성
x:47 y:55 위치에 초록색 나무를 설치했습니다!
연두
새로운 객체 생성
x:86 y:33 위치에 연두색 나무를 설치했습니다!
초록
x:62 y:30 위치에 초록색 나무를 설치했습니다!
초록
x:83 y:21 위치에 초록색 나무를 설치했습니다!
초록
x:47 y:46 위치에 초록색 나무를 설치했습니다!
연두
x:49 y:59 위치에 연두색 나무를 설치했습니다!
연두
x:10 y:38 위치에 연두색 나무를 설치했습니다!
카키
새로운 객체 생성
x:78 y:39 위치에 카키색 나무를 설치했습니다!
카키
x:21 y:41 위치에 카키색 나무를 설치했습니다!
카키
x:58 y:26 위치에 카키색 나무를 설치했습니다!

❓ 싱글톤 패턴과 다른게 뭐죠?

• 싱글톤 역시 객체를 하나만 생성하고 활용하는 패턴입니다. 둘의 다른 점은 뭘까요? 우리의 나무 예시를 생각해볼까요?

  우리가 제작한 Flyweight 패턴에서, 나무는 색깔이 바뀔 때 새로운 객체를 생성합니다. 색상 별로 하나씩, 결과적으로는 여러개의 나무가 생깁니다. 또한 만들어진 객체의 색상은 바꿀 수 없는 일입니다. 따라서 하나씩 여러종류를 가질 수 있습니다.

  그러나 싱글톤 패턴이라면, 나무 클래스에 단 한개의 나무만 만들수 있습니다. 따라서 싱글톤 패턴을 사용한다면, 만들어진 단 하나의 객체(나무)의 색깔을 바꿔야만합니다. 싱글톤은 이렇듯 하나의 클래스에 단 하나의 인스턴스를 생성하고, 대신 변수를 필요시 변경해가며 쓸 수 있다는 차이가 있습니다. 따라서 싱글톤 패턴은 종류 상관없이 단 하나만 가질 수 있습니다.

😎 멋진 사실

사실 플라이웨이트 패턴은 Java의 String Constant Pool에 적용됩니다...!

자바의 String은 만들어질때 String Constant Pool에 저장되어

같은 문자열이 pool에 있다면 이를 불러오는 방식으로 되어있습니다!

(관련 내용을 정리했던 제 블로그 글 : 링크 )

따라서 String class는 Flyweight 패턴을 적용하여 메모리를 절약할 수 있습니다!!

💕 참고한 링크들

1. 기본적인 패턴 설명 + 용량 절약에 대한 내용(리팩토링 그루)

   https://refactoring.guru/design-patterns/flyweight

2. 플라이웨이트 패턴의 자바 구현 예제

   https://lee1535.tistory.com/106

3. 플라이웨이트 패턴과 String Constant Pool에 대한 내용

   https://it-mesung.tistory.com/183

4. 나무 예제에 대한 자세한 내용

   https://m.blog.naver.com/2feelus/220669069127

5. 싱글톤과의 비교 https://medium.com/remember/flyweight-pattern-f02c771a72fb

​ 객체간의 상호작용을 캡슐화하여 하나의 중재자 클래스가 이를 처리하고 분산시켜주는 패턴이다.

👿 문제상황

 회원가입을 기능을 만드려고 합니다. 아래 두 가지 기능을 넣고 싶습니다.    

1. 빈칸이 있는 채로 버튼을 누르면 채워달라고 경고문을 텍스트로 출력하고 싶습니다.
2. 빈칸이 없는 채로 버튼을 누르면 회원 가입이 완료 됐다는 이미지를 띄우고 싶습니다.

문제 1) 우리는 버튼기능에 빈칸이 있는 경우, 없는 경우 각자 다르게 구현해야 합니다. 그 안에 텍스트박스에 대한 내용, 이미지 로딩에 대한 내용을 모두 연관지어야 합니다.

문제 2) 해당 버튼의 로직은 다른 페이지에서는 재활용하기 어렵습니다. 왜냐면 위 두 기능과 연관되기 때문입니다.

😇 어떻게 해결할까

​ 그렇다면 버튼 클릭이라는 이벤트를 전달받아 경고문 텍스트박스와 이미지 로더에 따로 그 이벤트를 전달하면 어떨까요?

버튼은 버튼 클릭만, 텍스트박스는 텍스트만, 이미지로더는 이미지로딩 기능만 담당하면 됩니다!

그래서 다른 페이지에서도 버튼, 경고문, 이미지로더를 각자 사용할 수 있습니다.

이렇게 버튼, 텍스트박스, 이미지 로더가 각자 자기 역할만 수행할 수 있도록, 그 사이의 상호작용을 전달하고 조절해주도록 중재자를 설정해주는 것이 Mediator 패턴입니다!

​

🤔 구현을 어떻게 할까

1. 컴포넌트들 구현

   • 버튼 - 클릭 이벤트 발생시키고 메디에이터에 노티
   • 텍스트 - 텍스트 띄움
   • 이미지- 이미지 로딩하고 띄움)

2. Mediator (조정해주기)

   • 클릭 이벤트 받음

   • 클릭 이벤트 발생시 경우 처리 -> 텍스트나 이미지에 일 시키기

📜 코드로 살펴볼까요!

1. Mediator

   //Mediator 인터페이스 선언 
   //Mediator 인터페이스 선언 
   // - 모든 Mediator는 전달 받는 기능인 notify가 필요하다고 구현
   public interface Mediator {
    void notify(Component sender, String event);
   }
   

//회원가입에서 사용될 Mediator public class ConcreteMediator implements Mediator{ private Button button; private TextBox textBox; private ImageLoader imageLoader;

//Mediator에서 사용할 컴포넌트를 연결, 컴포넌트들에 Mediator를 연결
public ConcreteMediator(Button button, TextBox textBox, ImageLoader imageLoader) {
    this.button = button;
    this.button.setMediator(this);

    this.textBox = textBox;
    this.textBox.setMediator(this);

    this.imageLoader = imageLoader;
    this.imageLoader.setMediator(this);
}

//각 컴포넌트들에게 noti가 왔을 때 처리해줄 내용
@Override
public void notify(Component sender, String event) {
    if(sender== button && event == "click"){ //버튼 클릭이벤트 발생시
        if(textBox.getText()=="")){//텍스트 비어있는지 확인
            textBox.warning();//비어있으면 경고
        }else{
            imageLoader.ImageLoad();//있으면 이미지 로드
        }
    }
}

}

2. 컴포넌트들
```java
//컴포넌트 부모 클래스
public class Component {
    protected Mediator mediator;

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
}


//버튼 -> 클릭 이벤트 발생
public class Button extends Component {
    @Override
    public void setMediator(Mediator mediator) {
        super.setMediator(mediator);
    }

    public void click(){
        System.out.println("[버튼 클릭] \n");
        super.mediator.notify(this,"click");
    }
}

//이미지 로더 -> 이미지 로드 후 이미지 띄움
public class ImageLoader extends Component{

    @Override
    public void setMediator(Mediator mediator) {
        super.setMediator(mediator);
    }

    public void ImageLoad(){
        System.out.println("이미지 로딩 \n");
        System.out.println("=========img========");
        System.out.println("\n");
        System.out.println("회원 가입을 축하드립니다!");
        System.out.println("\n");
        System.out.println("====================");
    }
}

//텍스트 박스 -> 인풋 또는 경고문만 출력
public class TextBox extends Component{
    String text;
    @Override
    public void setMediator(Mediator mediator) {
        super.setMediator(mediator);
    }

    public String getText() {
        return text;
    }

    public void warning(){
        System.out.println("=========TEXT========");
        System.out.println("공란을 채워주세요.");
        System.out.println("=====================\n");
    }

    public void input(String input){
        text = input;
        System.out.println("=========TEXT========");
        System.out.println(input);
        System.out.println("====================\n");
    }
}

   //컴포넌트 부모 클래스
   public class Component {
       protected Mediator mediator;

       public void setMediator(Mediator mediator) {
           this.mediator = mediator;
       }
   }


   //버튼 -> 클릭 이벤트 발생
   public class Button extends Component {
       @Override
       public void setMediator(Mediator mediator) {
           super.setMediator(mediator);
       }

       public void click(){
           System.out.println("[버튼 클릭] \n");
           super.mediator.notify(this,"click");
       }
   }

   //이미지 로더 -> 이미지 로드 후 이미지 띄움
   public class ImageLoader extends Component{

       @Override
       public void setMediator(Mediator mediator) {
           super.setMediator(mediator);
       }

       public void ImageLoad(){
           System.out.println("이미지 로딩 \n");
           System.out.println("=========img========");
           System.out.println("\n");
           System.out.println("회원 가입을 축하드립니다!");
           System.out.println("\n");
           System.out.println("====================");
       }
   }

   //텍스트 박스 -> 인풋 또는 경고문만 출력
   public class TextBox extends Component{
       String text;
       @Override
       public void setMediator(Mediator mediator) {
           super.setMediator(mediator);
       }

       public String getText() {
           return text;
       }

       public void warning(){
           System.out.println("=========TEXT========");
           System.out.println("공란을 채워주세요.");
           System.out.println("=====================\n");
       }

       public void input(String input){
           text = input;
           System.out.println("=========TEXT========");
           System.out.println(input);
           System.out.println("====================\n");
       }
   }

3. Main

   import java.util.Scanner;
   

public class Main { public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);
    Button button = new Button();
    TextBox textBox = new TextBox();
    ImageLoader imageLoader = new ImageLoader();
    Mediator mediator = new ConcreteMediator(button,textBox,imageLoader);

    //정보 입력받기
    System.out.println("=====회원가입========");
    System.out.println("아이디 입력 : ");
    String input = scanner.nextLine();
    //텍스트 박스에 입력
    textBox.input(input);
    //버튼 클릭하기
    button.click();
}

}

### 💻 결과


 1. 입력 없을 때
```shell
=====회원가입========
아이디 입력 : 

=========TEXT========

====================

[버튼 클릭]

=========TEXT========
공란을 채워주세요.
==================== 

2. 입력 있을 때

   =====회원가입========
   아이디 입력 : 
   Loopy
   =========TEXT========
   Loopy
   ====================
   

[버튼 클릭]

이미지 로딩

=========img========

회원 가입을 축하드립니다!

====================

------

### 💕 참고한 링크들

1. 기본적인 패턴 설명 (리팩토링 그루)
https://refactoring.guru/design-patterns/mediator

2. 리팩토링 그루 해석글, 컴포넌트 예시

   https://joycestudios.tistory.com/44

3. 더 상세한 컴포넌트 예시(체크박스, 버튼, 텍스트박스로 로그인 dialog 구현)

   https://ocwokocw.tistory.com/m/111

4. 디자인 패턴 설명 영상(얄코)

   https://www.youtube.com/watch?v=q3_WXP9pPUQ

1. MYSQL의 Scale-Out

   • Master(읽,쓰,수정 다 가능)- Slave(읽기만 가능) 구성
   • Slave를 늘려 Scale-Out

2. Docker

   • 프로그램이랑 필요한 기타 소프트웨어를 하나의 패키지로 만드는 플랫폼

   • Docket Image : 패키지를 소프트웨어 파일 시스템 형태로 만든거 Docker Container : docker image를 실행시킨것

   • docker 사용 docker 설치 -> docker Registry(docker hub)에서 image 다운로드 -> 실행 -> docker 컨테이너 생성, 사용

   • 내 OS에 영향 안주고 소프트웨어 동작하게 해줌

Q. 궁금한 점

• 데이터의 정합성 데이터가 모순없이 일관되게 일치해야한다.(데이터들의 값이 서로 일치해야 한다.) -> 다른 테이블에 같은 값이 들어가는 경우, foregin key 등을 사용해서 둘을 명확히 일치 시켜줘야 함으로 이해

• Persistence Layer

• Star schema: 데이터를 논리적 단위로 나눠 저장하고 필요시 조인하는 방식

• Denormalized schema: 데이터를 나누지 않고 그냥 원하는 데이터들을 모아서 때려 넣고 이를 반복하는 방식 ->스토리지 낭비는 좀 있지만 조인이 필요없음