이번에는 회원가입 로직을 구현해 보겠습니다.

• 사용 스택
  • h2 데이터베이스
  • Spring Data JPA → mybatis

1. DB 연결

회원가입 로직을 구현하기 전에 DB를 먼저 연결하겠습니다.

영상에서는 AWS에 DB 서버를 만들어서 사용하셨는데 저는 로컬에서만 간단하게 개발하고 싶어 h2 데이터베이스를 사용했습니다. [h2 데이터베이스 연결하는 방법] 데이터베이스 연결하는 방법은 링크 참고 부탁드립니다.

1️⃣ 설정 추가하기

/* application.yml */
spring:
  application:
    name: login

  h2:
    console:
      enabled: true
      path: /h2-console

  datasource:
    url: jdbc:h2:tcp://localhost/~/test
    driver-class-name: org.h2.Driver
    username: sa
    password:

mybatis:
  mapper-locations: classpath:/mapper/*.xml    # xml 파일이 있는 경로
  type-aliases-package: com.example.login.model # dto 클래스가 존재하는 경로

/* build.gradle */
dependencies {
    ...
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3'
    runtimeOnly 'com.h2database:h2'             // h2 Driver
}

2️⃣ SecurityConfig 클래스에서 회원가입 url 허용해주기

회원가입 api url (ex: ”/joinProc”)를 모든 사용자에게 허용해 줍니다.

/* SecuriryConfig */
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

    RequestMatcher h2ConsoleMatcher = PathRequest.toH2Console();

    http
            .authorizeHttpRequests((auth) -> auth
                    .requestMatchers("/", "/login", "/joinProc").permitAll()
                …
    …
}

3️⃣ MyBatisConfig 클래스 설정 추가

/* MyBatisConfig 클래스 생성 */
@Configuration
@MapperScan(basePackages = "com.example.login.mapper")
public class MyBatisConfig {
    // 비어있는 상태로 두면 됩니다.
}

2. 비밀번호 암호화를 위한 Security Config 추가

/* SecurityConfig.java */
@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {
    return new BCryptPasswordEncoder();
}

Spring Security는 회원가입, 사용자 인증(로그인) 시 비밀번호에 대해 단방향 해시 암호화를 진행하여 저장되어 있는 비밀번호와 대조합니다.

Spring Security는 암호화를 위해 BCryptPasswordEncoder 클래스를 제공하고 해당 방식으로 처리할 것을 권장합니다.

3. 회원가입 로직

프로젝트의 전반적인 구조는 [유미개발자님 블로그]를 참고하여 개발하였습니다.

이 글에서 소스 코드를 줄줄이 적기에는 너무 내용이 길어지는 것 같아 핵심 코드나 공부한 코드들만 작성하도록 하겠습니다.😅

전체적인 소스 코드는 [깃허브]를 참고해 주시면 감사하겠습니다!

1️⃣ Controller, Service, Mapper 클래스 및 인터페이스 생성하기 본 글의 핵심인 비밀번호 암호화에 대한 내용을 작성해야 하기 때문에 Service단 코드만 작성하겠습니다.

위의 SecurityConfig 클래스에서 Bean으로 등록한 BCryptPasswordEncoder 클래스를 가져와 DI 시켜주고

encode() 메서드를 통해 비밀번호를 암호화시켜 DB에 저장하겠습니다.

/* JoinService */
@Service
public class JoinService {

    @Autowired
    private JoinMapper mapper;

    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    public void joinProcess(UserInfo userInfo) throws Exception{

        // 동일한 계정이 존재하는지 체크하는 로직
        int count = mapper.countDuplicateId(userInfo);
        if(count > 0) {
            return "DUPLICATE_ID";
        }
        userInfo.setRole("ROLE_USER");
        userInfo.setPassword(bCryptPasswordEncoder.encode(userInfo.getPassword()));     // 비밀번호 암호화를 위한 로직 추가

        mapper.save(userInfo);
        return "OK";
    }

}

해시 암호화를 하여 DB에 값을 저장하게 되면 아래처럼 값이 들어가게 됩니다.

2️⃣ xml 파일 생성하기 저는 프로젝트/src/resources/mapper/*.xml 경로로 생성하였습니다. [깃 확인]
Mapper 기본 코드만 남겨놓겠습니다. 추가로는 필요하신 쿼리를 작성하시면 될 것 같습니다.

/* JoinMapper */
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.login.mapper.JoinMapper">    // mapper 경로 맞춰주기

    /* 필요하신 쿼리 작성하시면 됩니다. */
</mapper>

4. 결과확인

UI가 필요하신 분들은 [로그인 기능 구현] 여기 깃 코드 사용하시면 될 것 같습니다.

Spring Security 공부를 위해 로그인 기능을 구현하는 것이기에 프론트보다는 백엔드에 초점을 맞추어 작성 하도록 하겠습니다.

프로젝트 세팅을 하지 않으신 분들은 [React+SpringBoot 프로젝트 생성하기] 블로그를 먼저 보고 와주시길 바랍니다.

[ Spring Security란? ]

Security를 사용하기 전에 간략하게 무엇인지를 알아보자면 Spring Security는 Spring 기반의 애플리케이션의 보안(인증과 권한, 인가 등)을 담당하는 스프링 하위 프레임워크이다. Spring Security는 '인증'과 '권한'에 대한 부분을 Filter 흐름에 따라 처리하고 있다. Filter는 Dispatcher Servlet으로 가기 전에 적용되므로 가장 먼저 URL 요청을 받는다.

Spring Security는 보안과 관련해서 체계적으로 많은 옵션을 제공해주기 때문에 개발자 입장에서는 일일이 보안관련 로직을 작성하지 않아도 된다는 장점이 있다.

• 인증(Authentication): 해당 사용자가 본인이 맞는지를 확인하는 절차
• 인가(Authorization): 인증된 사용자가 요청한 자원에 접근 가능한지를 결정하는 절차 

참고

스프링은 버전에 따라 구현 방식이 조금씩 변경되는데 시큐리티의 경우 특히 세부 버전별로 구현 방법이 많이 다르기 때문에 버전마다 구현 특징을 확인해야 한다고 합니다. [참고], [Spring Security GitHub Releases Note]

1️⃣ Spring Security 사용하기 (의존성 추가)

Security를 사용하기 위해서는 build.gradle 파일에 의존성을 먼저 추가하여야 합니다.

dependencies {
    ...
    implementation 'org.springframework.boot:spring-boot-starter-security'    // Spring Security
    ...
}

2️⃣ Config 클래스 설정

의존성을 추가하면 Spring Security를 사용할 수 있습니다. Security를 사용하기 위한 SecurityConfig 클래스를 생성합니다.

사용하는 메서드명(ex: filterChain)은 원하시는 이름으로 정하고 리턴 타입은 SecurityFilterChain 으로 하셔야 합니다.

• @Configuration

  • 스프링 프레임워크에서 사용되는 어노테이션 중 하나로, 해당 클래스를 스프링의 설정 클래스로 지정하는 역할을 합니다.
  • 해당 어노테이션이 적용된 클래스는 스프링의 설정 정보를 포함하고 있는 클래스로 간주됩니다.

• @EnableWebSecurity

  • Spring Security를 사용하여 웹 보안을 구성할 때 사용하는 어노테이션입니다. 이 어노테이션을 사용하면 Spring Security와 관련된 구성을 할 수 있습니다.
  • Spring Security의 기능을 활성화하고, 주로 WebSecurityConfigurerAdapter 클래스를 상속받아 사용합니다.

    /* 과거에는 이렇게 구현하였지만 */
    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
      ...
    }
    /* 
    Spring Boot 3.0 이상
    Spring Security 6 이상에서는 WebSecurityConfigurerAdapter는 사용 불가 */
    @Configuration
    @EnableWebSecurity
    public class SecurityConfig {
      ...
    }

  • 해당 어노테이션을 사용하면 아래와 같은 작업을 수행할 수 있습니다.
    • HttpSecurity 객체를 사용하여 HTTP 요청에 대한 보안 구성을 설정할 수 있습니다.
      • WebSecurityConfigurerAdapter 클래스를 상속받은 설정 클래스를 등록할 수 있습니다.
  • [@EnabledWebSecurity 파헤치기] → 관련된 내용 공부해서 추후에 정리해 보겠습니다~!

• HttpSecurity http
  • Spring Security 의 HTTP 보안 설정을 구성하기 위한 클래스입니다.
  • 주로 URL 패턴에 따라 접근을 제한하거나, 인증 및 인가에 대한 규칙을 설정합니다.
  • WebSecurityConfigurerAdapter 를 확장하여 사용하며, configure(HttpSecurity http) 메소드를 오버라이드하여 필요한 정보를 추가합니다.
  • http 에서 사용하는 메서드들은 람다 형태로 사용하시면 됩니다.
  • 참고

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        // 인가
        http
                .authorizeHttpRequests((auth) -> auth
                        .requestMatchers("/", "/login").permitAll()
                        .requestMatchers("/getUserInfo").hasRole("ADMIN")
                        .anyRequest().authenticated()
                );
        // 인증     
        http
                .formLogin((auth) -> auth.loginPage("/login")       // 권한이 없는 admin과 같은 경로로 사용자가 요청했을 때 오류 페이지가 아닌 작성한 "경로"로 Spring Security가 리다이랙트 시켜줌
                        .loginProcessingUrl("/loginProc")           // 해당 경로로 요청이 들어오면 Security가 로그인 처리를 진행
                        .defaultSuccessUrl("/login", true)
                        .permitAll()                                // 로그인 처리를 한다는게 permitAll() 권한을 준다는 것 같음
                );

        http
                .csrf((auth) -> auth.disable());                    // POST방식으로 요청을 진행할 때 CSRF(사이트 위변조 방지 설정) 토큰을 보내야 로그인 처리를 가능하게 함, 이러한 설정은 Spring Security에서 설정되어 있음
                                                                    // 개발환경에서는 토큰을 사용하는 것이 불편하므로 disable 처리, 추후에 inable 처리하도록 수정

        return http.build();
    }
}

• requestMatchers(경로): "경로"에 대한 권한을 설정할 수 있다.
• permitAll(): 모든 사용자에게 접근 가능하도록 설정
• hasRole(권한): "권한"이 있는 사용자만이 requestMatchers(경로)에 설정된 경로에 접근할 수 있다.
• hasAnyRole(권한1, 권한2, ...): 여러 "권한"에 대해 접근을 제어할 수 있다.
• anyRequest(): 위에서 처리하지 못한 나머지 경로에 대한 권한 제어를 처리할 수 있음.
• authenticated(): 로그인한 사용자만이 접근할 수 있도록 denyAll(): 모든 사용자의 접근을 제한함

requestMatchers()를 이용해 경로에 대한 접근을 제한할 때 순서가 중요하다. 많은 권한에 대한 제한은 가장 마지막에 작성하는 것이 올바르다.

🟩 Spring Security를 이용한 "인가" 처리

http
                .authorizeHttpRequests((auth) -> auth
                        .requestMatchers("/", "/login").permitAll()
                        .requestMatchers("/getUserInfo").hasRole("ADMIN")
                        .anyRequest().authenticated()
                );

• requestMatchers("/", "/login").permitAll() 사용자의 request가 "/", "login" 경로일 경우 permitAll()(=모든 사용자가 접근이 가능하도록) 처리
• requestMatchers("/getUserInfo").hasRole("ADMIN") 사용자의 request가 "/getUserInfo" 경로일 경우 "ADMIN" 권한을 가진 사용자만 허용해준다.

🟩 Spring Security를 이용한 "인증" 처리

http
                .formLogin((auth) -> auth.loginPage("/login")       
                        .loginProcessingUrl("/loginProc")   
                        .defaultSuccessUrl("/login", true)
                        .permitAll()                         
                );

• formLogin(): 폼 기반 로그인 사용
  • Spring Security에 폼 기반 로그인을 사용하겠다고 알려주는 설정
  • 기본적으로 Spring Security는 자체 로그인 폼을 제공하는데, 이 설정을 통해 커스텀 로그인 페이지를 지정할 수 있습니다.
• loginPage("/login")
  • 사용자가 인증이 필요한 페이지(예: /admin)에 접근했을 때, 로그인되지 않은 상태라면 Spring Security가 자동으로 /login 페이지로 리다이렉트합니다.
  • 즉, "/login"은 사용자가 로그인할 수 있도록 직접 만든 로그인 화면의 경로입니다.
• loginProcessingUrl("/loginProc")
  • 사용자가 '/loginProc 요청을 보내면 Spring Security가 해당 요청을 가로채 로그인 처리를 수행
• defaultSuccessUrl("/login", true)
  • 로그인 인증이 성공하고 난 후, Spring Security가 성공 후 "/login" 경로로 리다이랙트를 시도함
  • 파라미터로 사용되는 경로는 백엔드에서 실제로 존재하는 url 이어야 합니다. (존재하지 않는다면 404 에러가 발생할 수 있습니다..)
  • AJAX 기반 로그인 처리 방법으로 처리하게 되면 해당 코드는 작성이 필요 없다고 합니다.

이처럼 Spring Security를 이용해 "인증", "인가"에 대한 처리를 할 수 있습니다.

저는 [개발자 유미 유튜브] 를 참고하여 Spring Security 공부를 진행하고 있습니다. 영상에서는 SpringBoot 프로젝트만을 이용해서 알려주시기 때문에 제 코드와는 다른 부분이 있을 수 있습니다.

추가적인 이해나 설명이 더 필요하신 분들은 유튜브 들어가서 확인해 보시면 좋을 것 같습니다~!

기획부터 DB설계, 디자인, 개발, 배포 등등.. 아직 혼자 프로젝트를 개발해 본적이 없는 저에겐 너무 막막하달까..

그래서 회사 선임분께 조언을 구하니 “처음부터 프로젝트 전부 다 개발하지말고 기능 하나씩 해봐~ 로그인 해보면 좋겠네”라고 해주셔서

역시.. 시니어는 다르군..

그래서~ 프로젝트 개발하기 전에 기능들을 하나씩 개발해보려 합니다~!

먼저 로그인 기능을 구현하면서 Spring Security 프레임워크를 공부해 보겠습니다! [구현중인 프로젝트 깃 주소]

🌱 프로젝트 생성하기

시작이 반이다..

• React: 19버전
• SpringBoot: 3.5.0
• Java: 21
• IDE: VScode, IntelliJ

1️⃣ React 프로젝트 생성하기

리액트 프로젝트는 아시다시피 간단하게 생성이 가능합니다. 최근에는 npm 명령어말고 다른 방법으로도 생성한다고 하니 검색해 보시면 좋을 것 같습니다.

프로젝트를 생성할 경로에 가서 명령어를 쳐줍니다. npx create-react-app frontend

그랬더니 저는 이런 명령어가 떠서

You are running `create-react-app` 5.0.1, which is behind the latest release (5.1.0).

We recommend always using the latest version of create-react-app if possible.

The latest instructions for creating a new app can be found here:
https://create-react-app.dev/docs/getting-started/

확인해 보니 현재 사용 중인 create-react-app(CRA)의 버전이 최신이 아니라고 안내해 주는 것이라고 합니다.

그래서 아래 명령어로 프로젝트를 생성하였습니다. npx create-react-app@latest frontend

프로젝트를 생성한 후 npm start를 해서 올바르게 프로젝트가 동작하는지 확인합니다.

2️⃣ SpringBoot 프로젝트 생성하기

다음으로 SpringBoot 프로젝트를 생성해 줍니다.

부트 프로젝트에 대한 설명을 잘해주신 블로거가 있어서 참고하시면 좋을 것 같습니다. [프로젝트 생성 참고]

프로젝트를 생성하고 설정 부분은 일전에 작성했던 내용을 참고하였습니다. [프로젝트 설정 참고]

설정을 마치고 빌드 후 각자의 Application.java 파일을 실행하여 올바르게 실행되는지 확인합니다.

뭔가 잘못된 것처럼 보이지만 단순히 정적 리소스 경로에 index.html과 같은 파일이 없어서 나타나는 화면입니다. 걱정없이 기기

3️⃣ CORS 설정하기

React, SpringBoot 프로젝트를 각각 생성하였다면 두 프로젝트를 연동시켜야 합니다.

이때 반드시 넣어줘야 하는게 CORS 설정입니다. 하나의 로컬에서 두 개의 서버를 구동시킬 때 서로의 포트에 접근하기 위해서 설정을 해야한다..? [CORS 설정하기 참고]

위 CORS 설정하기 참고 블로그에 4번 CORS 설정하기를 보면 WebMvcConfigurer 인터페이스를 구현하는 부분이 나오는데 해당 부분이 이해가 잘 가지 않아 GPT와 [WebMvcConfigurer 구현 참고] 블로그를 참고하였습니다.

• +추가 이야기

블로그를 참고하면서 예제를 하나씩 만들어보기 귀찮을 것 같은 분들을 위해 간략하게 CORS 설정하는 방법을 알려드리겠습니다.

먼저 frontend, backend 폴더 구조를 참고해 주세요~!

# backend
login/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── login/
│   │   │        ├── config
│   │   │        │    ├── WebConfig.java
│   │   │        ├── controller
│   │   │        │    ├── LoginController.java
│   │   │        ├── model
│   │   │        │    ├── UserInfo.java
│   │   │       └── LoginApplication.java
│   │   └── resources/
│   │       └── application.yml
├── build.gradle
├── settings.gradle

# frontend
frontend/
├── node_modules
├── public
├── src
│   ├── components
│   │   ├── views
│   │   │   └── home
│   │   │        ├── MainHome.js
│   ├── App.js
├── package.json

1.리액트 포트 설정: 3000 리액트 앱이 3000 포트로 실행되도록 지정합니다. 기본적으로 리액트는 3000 포트를 사용해서 실행합니다. 다른 포트를 원할 경우 아래 설정으로 변경할 수 있습니다.

/* package.json */
"scripts": {
    "start": "PORT=3000 react-scripts start",
      ...
}

2. 자바(SpringBoot) 포트 설정: 8085

   # application.yml
   server:
   port: 8085
   servlet:
    context-path: /login  # 애플리케이션 기본 경로를 '/login'으로 고정, 모든 URL 경로가 '/login'으로 지정됨
   

spring: application: name: login

<br />

3. proxy 설정
찾아본 내용으로는 `package.json`에서 주석을 다는 방법이 따로 존재하진 않고, 아래처럼 `__...`과 같은 방식으로 주석을 처리한다고 하여 한 번 해봤습니다 :)
``` json
/* package.json */
"__comment2": "프론트 개발환경에서 API 요청을 백엔드(SpringBoot)로 우회(Proxy)시키기 위한 설정",
"proxy": "http://localhost:8085",

4. CORS 설정

CORS(Cross-Origin Resource Sharing) 설정을 통해 프론트 http://localhost:3000에서 백엔드에 요청할 수 있도록 허용해 주었습니다. 해당 설정은 다른 도메인(포트)에서 API에 접근할 때 필요합니다.

WebConfig.java 클래스 생성

/*
    SpringBoot는 기본적으로 @SpringBootApplication 어노테이션이 붙은 클래스가 위치한 패키지와 그 하위 패키지들을 스캔하여
    @Configuration, @Component, @Service, @Repository 등의 어노테이션이 붙은 클래스를 자동으로 감지하고 설정합니다.
*/
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")             // 모든 경로에 대해
                .allowedOrigins("http://localhost:3000")  // 허용할 출처(React 개발 서버)
                .allowedMethods("GET", "POST", "PUT", "DELETE")  // 허용할 HTTP 메서드
                .allowedHeaders("*")                             // 허용할 헤더
                .allowCredentials(true);                         // 쿠키, 인증 정보 허용 여부
    }
}

5. 코드 추가

MainHome.js 컴포넌트 생성

import React, { useEffect, useState } from 'react'

const MainHome = () => {

    const [data, setData] = useState({});

    useEffect(() => {
        const fetchData = async () => {
            try {
                const response = await fetch('/login/getUserInfo');      // GET요청
                const data = await response.json();
                console.log("### 데이터 확인 ### \n", data);
                setData(data);
            } catch (error) {
                console.log("FETCH ERROR ", error);
            }
        };
        fetchData();
    }, []);

    return (
        <div>
            <h1>등록된 회원정보</h1>
            {data && (
                <div>
                    <p>Email: {data.email}</p>
                    <p>Name: {data.name}</p>
                </div>
            )}
        </div>
    )
};

export default MainHome;

MainHome 컴포넌트를 호출하도록 App.js 수정

import './App.css';
import MainHome from './components/views/home/MainHome';


function App() {
  return (
    <div className="App">
        <MainHome />      
    </div>
  );
}

export default App;

LoginController.java, UserInfo 클래스 생성

package com.example.login.controller;

import com.example.login.model.UserInfo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
//@RequestMapping()
public class LoginController {

    @GetMapping("/getUserInfo")
    public Object getUserInfo() {
        UserInfo userInfo = new UserInfo();
        // ##### 예제 데이터 반환 #####
        userInfo.setEmail("YoonHan0@naver.com");
        userInfo.setName("한영윤");

        return userInfo;
    }
}

6. 결과확인 Boot 서버를 실행한 후 → React 서버를 실행하게 되면 결과를 확인할 수 있습니다.

아직 DB까지는 연결하지 않았지만 개발을 진행하면서 DB 연결은 [DB연결 참고]블로그의 3번 데이터베이스 생성 부분을 참고할 예정입니다.

JPA 사용 전 Member 테이블 생성

/* MEMBER 테이블 생성하기 */
drop table if exists member CASCADE;
create table member
(
    id   bigint generated by default as identity,
    name varchar(255),
    primary key (id)
);

쿼리를 실행란에서 실행하면 MEMBER 테이블이 생성됩니다. 쿼리 전체를 드레그한 후 ctrl+Enter 단축키로 쿼리 실행이 가능합니다.

🚀 JPA

• JPA는 기존의 반복적인 코드는 물론이고, 기본적인 SQL도 직접 만들어서 실행시켜 준다.

• JPA를 사용하면 SQL과 데이터 중심의 설계에서 객체 중심의 설계로 패러다임을 전환할 수 있다.

  /* JDBC Template 코드 */
  @Override
  public List<Member> findAll() {
      return jdbcTemplate.query("SELECT * FROM MEMBER", memberRowMapper());
  }
  
  /* -------------------- */
  
  /* JPA 코드 */
  // from절을 보면 테이블이 아닌 Entity 객체를 대상으로 사용
  @Override
  public List<Member> findAll() {
      return em.createQuery("SELECT m FROM Member m", Member.class).getResultList();
  }

• 개발 생산성을 크게 높일 수 있다.

👨‍💻 JPA를 사용해보자

1. build.gradle 파일에 JPA 라이브러리 추가

dependencies {
    ...
    // implementation 'org.springframework.boot:spring-boot-starter-jdbc'   주석 처리 
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}

spring-boot-starter-data-jpa는 내부에 jdbc 관련 라이브러리를 포함하기 때문에 사용했던 jdbc 라이브러리는 제거해도 됩니다.

2. application.properties 파일에 JPA 설정 추가

...
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

• show-sql: JPA가 생생하는 SQL을 출력합니다.
• ddl-auto: JPA는 테이블을 자동으로 생성하는 기능을 제공하는데 none을 사용하여 해당 기능을 사용하지 않습니다.
  • create를 사용하면 엔티티 정보를 바탕으로 테이블도 직접 생성해줍니다.

3. JPA 엔티티 맵핑

• Member 클래스

    @Entity
    public class Member {
  
        @Id @GeneratedValue(strategy = GenerationType.IDENTITY)     // IDENTITY 전략: 디비에 값을 넣을 때 자동으로 채번을 해주는 (ex/auto Increament) 것을 말한다.
        private Long id;
  
        // @Column(name = "userName") // 컬럼명이 userName이라면 이렇게 맵핑할 수 있음
        private String name;
  
        public Long getId() {
            return id;
        }
  
        public String getName() {
            return name;
        }
  
        public void setId(Long id) {
            this.id = id;
        }
  
        public void setName(String name) {
            this.name = name;
        }
    }

• JpaMemberRepository 클래스

  • JPA는 EntityManager로 모두 동작을 함

  • gradle 파일에 jpa dependency 를 추가하게 되면 Spring이 현재 DB와 연결해서 EntityManager를 생성해줌

  • 개발자는 생성된 EntityManager를 injection 받기만 하면 됨

        public class JpaMemberRepository implements MemberRepository {
    
          private final EntityManager em;
          /*
          * JPA는 EntityManager로 모두 동작을 함
          * gradle 파일에 jpa dependency 를 추가하게 되면 Spring이 현재 DB와 연결해서 EntityManager를 생성해줌
          * 우리는 생성된 EntityManager를 injection 받기만 하면 된다~!
          * */
    
          public JpaMemberRepository(EntityManager em) {
              this.em = em;
          }
    
          @Override
          public Member save(Member member) {
              em.persist(member);
              return member;
          }
    
          @Override
          public Optional<Member> findById(Long id) {
              Member member = em.find(Member.class, id);
              return Optional.ofNullable(member);
          }
    
          @Override
          public Optional<Member> findByName(String name) {
              List<Member> result = em.createQuery("select m from Member m where m.name = :name", Member.class)
                      .setParameter("name", name)
                      .getResultList();
    
              return result.stream().findAny();
          }
    
          @Override
          public List<Member> findAll() {
              List<Member> result = em.createQuery("select m from Member m", Member.class).getResultList();       // 테이블이 아닌 Entity 객체를 대상으로 사용
              return result;
          }
    }

4. 서비스 계층에 트랜잭션 추가

@Transactional
public class MemberService {
    ...
}

• org.springframework.transaction.annotation.Transactional 를 사용하자
• JPA를 통한 모든 데이터 변경은 트랜잭션 안에서 실행하여야 한다.

5. 스프링 설정 파일 변경 (SpringConfig)

@Configuration
public class SpringConfig {

//    private DataSource dataSource;
//
//    @Autowired
//    public SpringConfig(DataSource dataSource) { this.dataSource = dataSource; }

    private EntityManager em;

    @Autowired
    public SpringConfig(EntityManager em) {
        this.em = em;
    }

    ...

    @Bean
    public MemberRepository memberRepository() {
//        return new MemoryMemberRepository();
//        return new JdbcTemplateMemberRepository(dataSource);
        return new JpaMemberRepository(em);
    }

    /* Spring이 실행되면 MemberService, MemberRepository를 bean으로 등록하고, 위에 작성된 것처럼 MemberService에 memberRepository를 주입해준다. */
}

6. 결과화면

위까지 마무리하게 되면 드디어 DB를 사용하여 데이터를 다룰 수 있게 됩니다.

1. Spring 프로젝트를 실행하고
2. h2 데이터베이스도 실행합니다.

1️⃣ 메인화면

2️⃣ 회원가입

3️⃣ 회원목록

위에서 JPA 엔티티 Member 클래스를 만들면서

@Id @GeneratedValue(strategy = GenerationType.IDENTITY)     // IDENTITY 전략: 디비에 값을 넣을 때 자동으로 채번을 해주는 (ex/auto Increament) 것을 말한다.
private Long id;

id 필드에 auto Increament 설정을 하였기 때문에 자동으로 채번이 되는 것을 확인할 수 있습니다.

DB에도 데이터가 쌓이는 것을 확인할 수 있습니다.

실제로 현업에서 로컬 테스트를 위해서 H2 데이터베이스를 사용한다고 하더라구요🙃

🧑‍💻 H2 데이터베이스 설치

개발이나 테스트 용도로 가볍고 편리한 DB, 웹 화면 제공
다운로드

• 다운로드 및 설치

• h2 데이터베이스 버전은 스프링 부트 버전에 맞춘다.

• 다운로드한 h2 폴더 내부에 bin 폴더에 h2.sh 파일이 존재 (h2/bin/)

• 권한 주기: chmod 755 h2.sh

• 실행: ./h2.sh

  실행 시 발생할 수 있는 오류

  오류 내용을 보면 Java 버전이 잘못됐다는 오류인데 (55 = Java 11, 52 = Java 8) 참고

    vi h2.sh    # shell 파일을 열어서

    # --- java -cp "$dir/h2-2.3.232.jar... 구문 상단에 작성해야 합니다. ---
    export JAVA_HOME=실행할 때 사용하고 싶은 JAVA 버전의 경로    # ex) /opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home    
    export PATH=$JAVA_HOME/bin:$PATH
    # ---------------------------------------------------------------

쉘 파일을 닫고 다시 실행 ./h2.sh

• 데이터베이스 파일 생성 방법

  

  1. JDBC URL: jdbc:h2:~/test (최초 한번) → 연결

  2. '~/test.mv.db 파일 생성 확인

     
     • 이후부터는 JDBC URL 입력란에 jdbc:h2: tcp://localhost/~/test로 수정해서 접속

✅ H2 데이터베이스 사용하기

build.gradle 파일에 jdbc, h2 데이터베이스 관련 라이브러리 추가

dependencies {
    ...
    implementation 'org.springframework.boot:spring-boot-starter-jdbc' /* JAVA에서 DB랑 연결을 하기 위해서는 반드시 JDBC가 필요하다. */ 
    runtimeOnly 'com.h2database:h2'     /* DB에서 필요한 클라이언트를 h2를 사용한다. */
}

스프링 부트 데이터베이스 연결 설정 추가

  <!-- resources/application.properties */ -->
  spring.datasource.url=jdbc:h2:tcp://localhost/~/test    <!-- spring.datasource.url=jdbc:h2:~/test(최초 한 번) -->
  spring. datasource.driver-class-name=org.h2.Driver
  spring.datasource.username=sa

DB 접속 정보를 Spring Boot에게 제공해서 Spring이 접속에 필요한 처리를 해주도록 하는 로직

공부한 내용을 바탕으로 간단한 예제를 만들어 보겠습니다 :)
회원가입을 하고 회원 목록을 확인할 수 있는 간단한 프로그램입니다.

🖥️ 결과화면

메인화면

회원가입 화면

회원 목록 화면

⚙️ 기능 구현

1. ("/") 경로에 접근했을 때 출력될 메인 화면 개발

1. home.html 파일 생성

   <!DOCTYPE HTML>
   <html xmlns:th="http://www.thymeleaf.org">
   <body>
   
   <div class="container">
     <div>
         <h1>Hello Spring</h1>
         <p>회원 기능</p>
         <p>
             <a href="/members/new">회원 가입</a>
             <a href="/members">회원 목록</a>
         </p>
     </div>
   </div> <!-- container -->
   </body>
   </html>

2. 웹 브라우저에서 localhost:8080으로 요청이 왔을 때 맵핑될 메서드 구현

   /* MemberController */
   @Controller
   public class MemberController {
   
    @GetMapping("/")
    public String home() {
        return "home";
    }
   }

2. ("/member/new") 경로에 접근했을 때 출력될 회원가입 화면 개발

1. 화면에 그려줄 파일 생성 resourcces/templates/members/createMemberForm.html 생성

    <!-- ... -->
    <form action="/members/new" method="post">
        <div class="form-group">
            <label for="name">이름</label>
            <input type="text" id="name" name="name" placeholder="이름을 입력하세요.">
        </div>
        <button type="submit">등록</button>
    </form>
    <!-- ... -->

2. form 태그에서 처리하는 데이터 받아줄 model 생성 MemberForm 생성

    public class MemberForm {
        private String name;        // 이름을 입력하면 해당 name 필드에 값이 저장되게 됩니다.
   
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }

3. MemberController 메서드 추가

   
   @Controller
   public class MemberController {
   
     private final MemberService memberService;
   
     @Autowired  // 의존성 주입 : DI, 연결하는 로직
     public MemberController(MemberService memberService) {
         this.memberService = memberService;
     }
   
     // `/members/new` 경로로 들어오게 되면 viewResolver가 방금 만든 createMemberForm.html을 화면에 그려줌
     @GetMapping("/members/new")
     public String createForm() {
         return "members/createMemberForm"; 
     }
   
     // createMemberForm 화면에서 "등록" 버튼 클릭 시 post 방식으로 호출되면서 create 메서드 호출
     // 파라미터로 MemberForm 클래스를 받으면서 html파일에서 submit한 name 데이터가 MemberForm 클래스의 name 필드로 받아짐
     @PostMapping("/members/new")
     public String create(MemberForm form) {
         Member member = new Member();
         member.setName(form.getName());
   
         System.out.println(form.getName()); // 입력한 데이터 확인
         memberService.join(member);
   
         return "redirect:/";
     }
   }

4. MemberService 메서드 구현

   
   /* Service는 비지니스적으로 함수명을 작성하던지 해야합니다. 
   :. Service가 비지니스 처리를 하는 곳이기도 하고 추후에 어떤 문제가 생겨서 오류를 찾을 때도 찾기 편하기 때문에 */
   @Service
   public class MemberService {
   
      private final MemberRepository memberRepository;
   
      // 클래스 내에 생성자가 하나만 있으면 @Autowired 생략 가능(Spring 4.3 이상)
      public MemberService(MemberRepository memberRepository) {
           this.memberRepository = memberRepository;
      }
      /**
      * > 회원가입
      * 같은 이름이 있는 중복 회원X
      */
      public Long join(Member member) {
           // 요즘에는 null로 반환될 수 있을법한 로직에는 "변수 != null" 이렇게 처리하지 않고 Optional로 감싸서 처리
           // ex) Optional<Member> result = memberRepository.findByName(member.getName());
           validateDuplicateMember(member);    // 중복 회원 검증
           memberRepository.save(member);
   
           return member.getId();
      }
      /* 회원명으로 중복체크하는 메서드 */
      private void validateDuplicateMember(Member member) {
          // isPresent(): Optional이 값을 포함하고 있는지 확인만 하는 메서드, if인데 is로 오타가 나서 오류가 났었음..
          // ifPresent()는 Optional에 값이 존재하면 람다식을 실행하는 메서드이므로, 여기서 예외를 던지는 로직을 넣을 수 있습니다.
          memberRepository.findByName(member.getName())
                .ifPresent(m -> {
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                });
      }
   }

5. MemberRepository 생성
   인터페이스를 활용하여 여러 클래스가 동일한 메서드를 구현하도록 강제하여 일관성을 유지할 수 있음

   public interface MemberRepository {
       Member save(Member member);
       Optional<Member> findById(Long id);
       Optional<Member> findByName(String name);
       List<Member> findAll();
   }

6. 구현부 MemoryMemberRepository 생성
   데이터베이스를 연결하기 전이므로 메모리에 데이터를 저장하고 조회하는 방식으로 진행하겠습니다.

   /* MemberRepository 인터페이스를 구현하는 클래스 */
   @Repository
   public class MemoryMemberRepository implements MemberRepository{
   
       private static Map<Long, Member> store = new HashMap<>();    // 메모리 기반 데이터 저장소로 활용
       private static long sequence = 0L;
   
       @Override
       public Member save(Member member) {
           member.setId(++sequence);
           store.put(member.getId(), member);
           return member;
       }
   
       @Override
       public Optional<Member> findByName(String name) {
           return store.values().stream()
               .filter(member -> member.getName().equals(name))
               .findAny();
       }
   }

2. ("/members") 경로에 접근했을 때 출력될 회원목록 화면 개발

1. 화면에 회원 목록을 그려줄 파일 생성 memberList.html

   <!DOCTYPE HTML>
   <html xmlns:th="http://www.thymeleaf.org">
   <body>
   
   <div class="container">
       <div>
           <table>
               <thead>
               <tr>
                   <th>#</th>
                   <th>이름</th>
               </tr>
               </thead>
               <tbody>
               <tr th:each="member : ${members}">   <!-- thymeleaf 문법 -->
                   <td th:text="${member.id}"></td>
                   <td th:text="${member.name}"></td>
               </tr>
               </tbody>
           </table>
       </div>
   </div> <!-- container -->
   </body>
   </html>

2. MemberController에 메서드 추가

   @GetMapping("/members")      // home.html의 경로 <a href="/members">회원 목록</a>
    public String list(Model model) {
        List<Member> members = memberService.findMembers();
        model.addAttribute("members", members);     // key: members, value: members(변수)
   
        return "members/memberList";
    }

3. MemberService 클래스의 findMembers() 메서드 구현

    /* 전체 회원 조회 */
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

4. MemoryMemberRepository 클래스의 findAll() 메서드 구현

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values());     // 메모리에 저장된 데이터 반환 
    }

여기까지 완료되면 예제 프로그램을 개발하게 됩니다 :)
코드 중간중간에 나오는 의존성 주입, @Controller, @Service, @Repository, 인터페이스와 같은 내용들은
링크를 참고해서 공부해 주시면 감사하겠습니다 👍

이미지 출처: 인프런 강의(스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술)

Spring을 사용한 일반적인 웹 애플리케이션은 역할별로 계층을 나누어 구조화되어 있습니다.
이렇게 계층을 나누면 유지보수성이 좋아지고, 확장성이 뛰어나며, 코드의 가독성이 향상됩니다.

🏗️ 계층별 역할 정리

1. Controller (컨트롤러)

"사용자 요청을 받아서 처리하는 역할"

• 웹 MVC의 컨트롤러 역할, 사용자가 웹에서 요청을 보내면, 컨트롤러가 그 요청을 받아 적절한 로직을 호출
• @Controller 또는 @RestController 어노테이션을 사용
• Service 계층을 호출해서 필요한 로직을 수행한 후, 결과를 반환

2. Service (서비스)

"비즈니스 로직 구현하는 핵심 계층"

• 데이터를 조작하거나, 여러 개의 리포지토리를 호출하는 등 핵심적인 로직을 처리
• @Service 어노테이션을 사용
• Controller와 Repository 사이에서 중간 역할을 수행

3. Repository (리포지토리)

"데이터베이스 접근, 도메인 객체를 DB에 저장하고 관리하는 계층"

• 데이터 저장, 조회, 수정, 삭제 등의 기능을 수행
• JPA, MyBatis, JDBC 등의 기술을 사용할 수 있음
• @Repository 어노테이션을 사용 (Spring Data JPA를 사용하면 생략 가능)

4. Domain (도메인)

"비즈니스 도메인 객체"

• 일반적으로 데이터베이스에 저장되는 회원, 주문, 상품, 쿠폰 등과 같은 개념
• JPA를 사용한다면 @Entity 어노테이션을 사용하여 JPA가 관리하도록 설정 가능
• 도메인 객체는 비즈니스 규칙을 포함할 수도 있음 (예: 할인 정책)

위 계층을 기반으로 간단한 회원관리 예제를 만들어 보겠습니다.

개발을 하기 전 전체적인 프로젝트 구조는 아래와 같습니다 :)

📁 프로젝트 구조

├── 📂 backend         
│   ├── 📂 src
│   │   ├── 📂 main
│   │   │   ├── 📂 java/com/hello/hello_spring  
│   │   │   │   ├── 📂 controller    # API 컨트롤러
│   │   │   │   │   ├── 📜 MemberController.java
│   │   │   │   │   ├── 📜 HomeController.java  
│   │   │   │   ├── 📂 service       # 비즈니스 로직
│   │   │   │   │   ├── 📜 MemberService.java  
│   │   │   │   ├── 📂 domain        # 비즈니스 도메인 객체
│   │   │   │   │   ├── 📜 Member.java
│   │   │   │   ├── 📂 repository    # 데이터 액세스 계층
│   │   │   │   │   ├── 📜 MemberRepository.java         # 인터페이스
│   │   │   │   │   ├── 📜 MemoryMemberRepository.java   # 구현체
│   │   │   │   ├── 📜 HelloSpringApplication.java  # Spring Boot 실행 파일
│   │   ├── 📂 test  # 테스트 코드
│   ├── 📜 build.gradle
│   │
│   ├── ...

⚙️ 동작방식

이미지 출처: 인프런 강의(스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술)

1. 사용자가 웹 브라우저에서 request를 보냄
2. 톰켓 서버가 Controller에 해당 URL이 있는지 확인
3. 매핑된 메서드에 @ResponseBody 어노테이션이 붙어 있으면 → ViewResolver가 아닌 HttpMessageConverter로 데이터 전송
4. 반환되는 데이터 타입에 따라 처리 방식이 달라지게 되는데,
   • 문자 형태이면
     • StringConverter가 처리 (StringHttpMessageConverter)
     • 문자 형태 그대로 웹 브라우저로 반환
   • 객체 형태이면
     • JsonConverter가 처리 (MappingJackson2HttpMessageConverter)
     • 객체 → JSON 형태로 변경하여 웹 브라우저로 반환

ResponseBody 사용

• Http Response Body에 직접 데이터를 반환
• 템플릿을 사용하지 않고, 데이터 자체를 응답하는 방식 (ViewResolver 대신에 HttpMessageConverter가 동작)
• 기본 문자처리: StringHttpMessageConverter
• 기본 객체처리: MappingJacson2HttpMessageConverter
• byte 처리 등등 기타 여러 HttpMessageConverter가 등록되어 있음

📦 기본 동작하는 HttpMessageConverters

🛠️ 테스트 방법

1. Controller에 코드 추가(HelloController.java)

   /* 1. API 방식 (반환 형식이 문자일 때) */
   @GetMapping("hello-string")
   @ResponseBody       // HTML이 아닌 HTTP에서 Head/Body의 그 body 부분에 내가 직접 값을 넣어주겠다~ 라는 의미
   public String helloString(@RequestParam("name") String name) {
    return "hello " + name;
   }
   

/* 2. API 방식 (반환 형식이 JSON일 때) */ @GetMapping("hello-api") @ResponseBody public Hello helloApi(@RequestParam("name") String name) { Hello hello = new Hello(); hello.setName(name); return hello; }

static public class Hello { private String name;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

}

2. 프로젝트 실행 후, 반환 형식이 문자일 때를 먼저 테스트 해보자면 `http://localhost:8080/hello-string?name=원하는이름` 호출
3. 결과확인
![Image](https://github.com/user-attachments/assets/420db34c-feff-46c5-a562-d693f329916a)

4. 반환 형식이 객체일 때 테스트를 해보면, `http://localhost:8080/hello-api?name=원하는이름` 호출
5. 결과확인
![Image](https://github.com/user-attachments/assets/af003b62-9fa6-4030-a4cf-d50d24bbdb25)

<br />

### ❌ 테스트 중 발생했던 오류
Spring 강의에서는 아래와 같이 코드를 작성했었는데 *( class 앞에 public 없이 )*

``` java
/* hello.hello_spring.controller.HelloController.java */

static class Hello {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

hello 객체가 반환되는 부분에서 실행은 되지만
Class 'Hello' is exposed outside its defined visibility scope와 같은 오류가 발생할 수 있다.

💡 오류가 발생하는 이유는

Spring이 객체를 JSON으로 변환할 때 클래스의 접근 제한자를 엄격하게 체크하기 때문이라고 한다.

Spring에서 @ResponseBody를 사용하면 객체(Hello)를 JSON으로 변환하는 과정이 필요한데,
이 변환을 담당하는게 위에서 말한 Jackson이라는 라이브러리이다.

Jackson은 객체를 JSON으로 변환할 때,

1. 기본 생성자가 존재하는지 확인
2. 필드에 접근할 수 있는 Getter 메서드가 있는지 확인
3. 클래스가 직렬화 가능하고, 접근할 수 있는 범위인지 확인을 한다.

Spring은 기본적으로 객체를 반환할 때 JSON 형태로 반환한다고 한다. xml형태도 있지만

💭 같이 공부해 볼 개념

✅ JSON이란?

Java Script Object Notation의 약자이다.
데이터를 쉽게 교환하고 저장하기 위한 텍스트 기반의 데이터 교환 표준이다.

기본 형태

{ key : value }

JSON의 형태는 키(key), 값(value)의 쌍으로 이루어진 구조이다. 참고

✅ 자바빈 프로퍼티란?

Spring 프레임워크에서는 자바빈 프로퍼티를 활용하여 객체의 상태를 캡슐화하고, 쉽게 접근하고 조작할 수 있는 기능을 제공한다. 참고

자바빈 프로퍼티는

• 객체의 필드에 접근하기 위한 Getter, Setter 메서드를 통칭하는 용어이다.

• Spring에서는 자바빈 프로퍼티를 활용하여 객체의 상태를 캡슐화하고, 외부에서 안전하게 필드에 접근하고 조작할 수 있도록 지원한다.

• 자바빈 프로퍼티의 역할로는

  • 캡슐화
  • 접근 제어
  • 데이터 바인딩
  
  

✅ JsonConverter? MappingJackson2HttpMessageConverter?는 같은 것일까?

• JsonConverter는 일반적인 개념 또는 약칭이고,
• MappingJackson2HttpMessageConverter는 Spring이 실제로 사용하는 구현체 클래스입니다.
• StringConverter와 StringHttpMessageConverter도 같은 개념입니다.

MVC는 Model, View, Controller의 약자로, 애플리케이션을 구성하는 주요 역할을 분리한 아키텍처 패턴입니다.

패턴을 가지고 역할을 나누는 이유

• 관심사의 분리(Separation of Concerns, SoC)

  각각의 역할을 독립적으로 나누어, 코드 간의 영향도를 줄이는 것이 핵심입니다.
  
  

예를 들어

• UI(화면 표시) → 사용자 인터페이스 관련 코드만 다룸
• 비즈니스 로직 → 데이터 처리, 계산, 규칙 적용 등 핵심 로직 담당
• 데이터 접근 → DB와의 연결 및 데이터 저장 처리
  
  

✅ 장점

• 유지보수성 증가
• 재사용성 증가
• 테스트 용이성 증가 ...

⚙️ 동작방식

이미지 출처: 인프런 강의(스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술)

1. 사용자가 웹 브라우저에서 localhost:8080/hello-mvc와 같은 요청을 보냄
2. 톰캣이 요청을 받고, Controller에 매핑된 경로가 있는지 확인
3. ✅ 경로가 있다면 → return "템플릿 이름"으로 반환
4. ViewResolver가 해당 템플릿 파일을 찾아 HTML로 변환
5. 변환된 HTML이 브라우저에 출력됨

🛠️ 테스트 방법

1. 파일 생성(hello-template.html)

   <!-- src/main/resources/templages/ 아래에 파일 생성 -->
   <!DOCTYPE html>
   <html xmlns:th="http://www.thymeleaf.org">
   <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>Hello Template</title>
   </head>
   <body>
   <p th:text="'hello '+ ${name}">hello Empty</p>    <!-- 해당 코드는 Thymeleaf 문법인데 아래 참고 항목 링크 확인 부탁드립니다. -->
   </body>
   </html>

2. controller 패키지 생성 및 파일 생성 ```java /*
   1. 프로젝트 아래에 controller 패키지 생성
   2. 'HelloController'라는 이름으로 클래스 생성

*/

3. `Controller`에 코드 추가(HelloController.java)
```java
/* 2. 템플릿 엔진 방식 */
@GetMapping("hello-mvc")
public String helloMvc(@RequestParam(value = "name", required = true) String name, Model model) {
    model.addAttribute("name", name);
    return "hello-template";
}

4. 브라우저에서 localhost:8080/hello-mvc?name=원하는이름 호출
5. 결과확인
   

참고 Thymeleaf 사용법 정리

서비스 회사에서 근무하면서 유지보수 업무를 주로 맡다 보니, 점점 전체적인 흐름을 읽는 능력이 부족해지고 있다는 걸 느끼게 되었습니다.🥲

이런 고민을 해결하기 위해, 직접 하나의 프로젝트를 개발해보면 좋겠다는 생각이 들어 시작하게 되었습니다. 하나씩 차근차근, 우선 Spring부터 공부해보려고 합니다! 😊

정확히는 SpringBoot 프로젝트를 생성하여 개발 및 공부를 진행할 것인데 SpringBoot도 결국 Spring을 손쉽게 사용할 수 있게 해주는 도구이고, 본질은 Spring 프레임워크이기 때문에 Spring 공부하기로 제목을 지었습니다.

"인프런 강의"를 참고해서 작성하였습니다 :)

먼저 프로젝트를 만들고, 설정하는 것부터 시작하는데

제가 강의를 들으며 "깃허브_Spring Project 시작"에 정리한 내용이 있으니 같이 공부하실 분들은 참고해서 설정 부탁드립니다

세팅을 마치고 나면, 먼저 Spring 웹 개발 기초에 대해서 공부하게 됩니다.

스프링 웹 개발은 크게 3가지로 나눌 수 있는데

• 정적컨텐츠 (Static Content)
• MVC와 템플릿 엔진 (Spring MVC + Template Engine)
• API

정적컨텐츠 방식 먼저 공부를 해보자면

🚀 Static Content

말그대로 정적인 페이지를 사용자에게 보여주는 방식이다.

⚙️ 동작방식

이미지 출처: 인프런 강의(스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술)

웹 브라우저에서 localhost:8080/hello-static.html과 같은 요청이 오면 톰캣이 먼저 받습니다.

톰캣은 해당 요청이 Controller에 매핑된 경로인지 확인합니다.

• ✅ 경로가 존재하면, 해당 경로에 맞는 처리를 반환합니다. (뒤에서 학습할 내용이므로 자세한 설명은 뒤에서 하도록 하겠습니다.)
• ❌ 경로가 존재하지 않으면, resources/static/ 디렉터리에서 요청된 파일을 찾습니다. Spring 공식문서

🛠️ 테스트 방법

1. 파일생성(hello-static.html)

   <!-- src/main/resources/static/ 아래의 경로에 파일 생성 -->
   <!DOCTYPE html>
   <html lang="ko">
   <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>static content</title>
   </head>
   <body>
   정적 컨텐츠입니다.
   </body>
   </html>

2. 프로젝트 실행
3. localhost:8080/hello-static.html 경로로 이동
4. 결과확인

언제 사용할까?

• 단순한 웹 페이지 (예: 소개 페이지, 공지사항, 문서 등)를 제공할 때
• 프론트엔드에서 자체적으로 동작하는 정적 리소스 (JS, CSS)를 제공할 때

썸네일 이미지 출처: 스프링 공식 홈페이지

Uncaught TypeError: Cannot read properties of undefined (reading 'setState') .... 이런 에러를 만나게 되었다..?

undefined의 property를 읽을 수 없다는 거 같은데... 오류가 나는 코드를 보니 this.setState({ … }); 처리하는 부분이 있었고, 이 부분에서 this가 컴포넌트를 가르키고 있지 않는 것을 확인할 수 있었다

this.setState({…}) 를 할 때 this 가 컴포넌트를 가르키고 있지 않았던 것

아래 코드 부분입니다 !

위의 코드처럼 객체의 메서드로 일반 함수를 만들어 this를 찍어서 사용하면 그 객체(=getMainButtons)를 가르키게 된다.

해결방법은

일반 함수 형태로 선언되어 있는 getMainButtons() 를 화살표 함수 형태로 만들어주면 된다.

가려져 있지만..

getMainButtons() { … }    ->    getMainButtons: () => { … }
// 이렇게 수정하면 해결이 됩니다. 

this에 대해서 어렴풋이 알고는 있었지만 확실히 알아보기 위해서 예시를 만들어서 테스트 해보았습니다.

일반 함수와 화살표 함수가 가리키는 this는 어떻게 다를까?

이 부분을 알아보려면 켄텍스트 라는 개념을 알아야 합니다.

• 컨텍스트 or 실행컨텍스트란?

  프로그래밍에서 특정 코드 블록이나 함수가 실행될 때, 그 코드가 어떤 환경에서 실행되고 있는지를 나타내는 개념.

참고... https://heycoding.tistory.com/86

함수 컨텍스트

함수가 호출될 때 생성되는 컨텍스트.

• 일반 함수의 경우, 호출된 방식에 따라 this가 다르게 설정됨.
  객체의 메서드로 호출되면 this는 그 객체를 가르키고, 일반 함수로 호출되면 전역 객체를 가리키거나 undefined가 됨.

/* ----------- 객체의 메서드로 호출되는 예시 --------- */
const person = {
  name: 'Han0',
  greet: function() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

// 메서드로 호출
person.greet(); // 출력: Hello, my name is Han0

• 화살표 함수의 경우, 자신이 정의된 위치의 컨텍스트를 그대로 사용. 화살표 함수가 정의된 곳의 this를 참조함.
  화살표 함수(=greet)가 정의된 곳(=person)의 this를 참조하게 됩니다.

/* ----------- 객체의 메서드로 호출되는 예시 --------- */
this.name = '한영'
const person = {
  name: 'YoonHan0',
  greet: () => {
    console.log(`Hello, my name is ${this.name}`);
  }
};

// 메서드로 호출
person.greet(); // 출력: Hello, my name is 한영

아래에는 일반 함수, 화살표 함수를 비교하기 위해 만들어본 예시입니다 !

import React, { Component } from 'react';

class MyComponent extends Component {
  constructor(props) {
    super(props);

    // 일반 함수 바인딩
    this.handleIncrement = this.handleIncrement.bind(this);
    /* bind 하지 않으면
    Uncaught TypeError: Cannot read properties of undefined (reading 'setState') .... 에러 발생
     */
  }
  state = {
    count: 0,
  }

  // 일반 함수
  // 일반 함수는 호출되는 컨텍스트에 따라 this가 결정됨
  handleIncrement() {
    // 여기서 this는 undefined가 될 수 있습니다.
    console.log(this); // undefined (strict mode에서)
    this.setState({ count: this.state.count + 1 });
  }

  // 화살표 함수
  // 화살표 함수는 자신이 정의된 컨텍스트의 this를 그대로 사용
  handleDecrement = () => {
    // 여기서 this는 MyComponent 인스턴스를 가리킵니다.
    console.log(this); // MyComponent { ... }
    this.setState({ count: this.state.count - 1 });
  };

  // 위의 일반 함수, 화살표 함수를 테스트하는 함수
  testFunc = () => {
    this.name = '한영';
    const person = {
      name: 'Han0',
      greet: function () {
        console.log(`Hello, my name is ${this.name}`);
      }
      /*
      greet: () => {
        console.log(`Hello, my name is ${this.name}`);
      }
      */
    };
    person.greet();
  }

  render() {
    return (
      <div>
        <h1>Count: {this.state.count}</h1>
        <button onClick={this.handleIncrement}>Increment</button>
        <button onClick={this.handleDecrement}>Decrement</button>
        <button onClick={this.testFunc}>HELLO</button>
      </div>
    );
  }
}

export default MyComponent;

이미지 출처

https://velog.io/@rlacksals96/CS-Javascript-This

이번 건은 꽤 간단하게 해결할 수 있었어서 해결 방법을 간략하게 정리해 보겠습니다!

우선, 간략하게 로직 먼저 알려드리자면

권한 설정을 하는 기능에서 사원 여러 명을 선택한 후, 권한을 일괄 등록하는 기능을 구현하였습니다.

1. 사원정보를 넘겨받고
2. 해당 사원이 권한 관리테이블 (이하 Table A) 에 존재하는지 확인
3. 존재한다면 Table A에 UPDATE / 존재하지 않는다면 Table A에 INSERT

✅ 기존 로직

사원정보(ex/5000명)를 한 건씩 API를 호출하여 존재하는지 확인하고 UPDATE or INSERT 처리

• 문제점 사원 정보가 늘어나면 늘어날수록 속도 저하가 심해짐

✅ 개선방안

• 개선방안 1

1. 사원정보(ex/5000명)을 List 형태로 한 번에 넘겨서
2. for문을 돌면서 한 건씩 권한 확인
3. 확인 후 UPDATE or INSERT 처리

• 개선방안 2

1. 사원정보(ex/5000명)을 List 형태로 한 번에 넘겨서
2. Bulk Duplicate 사용하여 한 번에 처리 (Bulk Duplicate 가 올바른 용어인지는 잘 모르겠습니다..ㅎ)

✅ 사용한 해결방법

개선방안 2번으로 해결을 하였습니다.

<!-- 
    empList: 사원코드, 권한정보들이 담긴 데이터 
-->
INSERT INTO TABLE_A
            (
                <!-- 
                INSERT or UPDATE 할 컬럼,
                여기 있는 컬럼들과 UPDATE문에 해당하는 부분에서 차이가 나는 컬럼이 해당 테이블에 식별자가 되어 테이블에 동일한 데이터가 존재한다면 UPDATE
                존재하지 않는다면 INSERT 하게 됩니다!
                이 예시에서는 EMPLOYEE_CODE가 식별자가 됨 
                -->
                EMPLOYEE_CODE,
                A1,
                A2,
                A3,
                A4,
                A5
            )
            VALUES
            <foreach collection="empList" item="item" separator=",">
                (              
                      #{item.empCode},
                      #{a1},
                      #{a2},
                      #{a3},
                      #{a4},
                      #{a5}
                )
            </foreach>
            ON DUPLICATE KEY UPDATE
                <!-- TABLE_A에 동일한 값(사원코드)이 존재할 때 UPDATE 하는 부분 -->
                A1 = #{a1}
                A2 = #{a2}
                A3 = #{a3}
                A4 = #{a4}
                A5 = #{a5}

사원수를 6000명 정도로 했을 때 위 방법으로도 시간이 많이 단축되었지만

다른 방법이 있나 찾다보니 1,000건, 10,000건 이상정도 되는 데이터를 Bulk INSERT 할 때는 일정 건수로 분할하여 삽입 하는 방법도 있다고 하더라고요

그래서 최종 해결방안은 !

✅ 500건씩 쪼개서 Bulk Duplicate 하는 방법

• batchSize 만큼 쪼갠 후, 배열로 리턴해주는 메서드

  public <T> List<List<T>> partitionList(List<T> list, int batchSize) {
      List<List<T>> partitions = new ArrayList<>();
      for (int i = 0; i < list.size(); i += batchSize) {
          int endIndex = Math.min(i + batchSize, list.size());
          partitions.add(list.subList(i, endIndex));
      }
      return partitions;
  }

• 500건 이상일 때 아래처럼 처리

  // param.getList() -> 사원리스트 로 수정
  // RSelectEmp -> 사원정보를 담은 모델 클래스
  

// 사원리스트가 500건 이상일 때 | 500개 쪼개어 Bulk Duplicate if(param.getList().size() > 500) {
List<List> empList = this.partitionList(param.getList(), 500);

for(int i=0; i<empList.size(); i++) {
    param.setList(empList.get(i));
    mapper.bulkDuplicate(param);
}

} else { mapper.bulkDuplicate(param);
}

```

결과확인

* 테스트결과는 컴퓨터 사양에 따라 달라질 수 있습니다.

* bulk insert를 이용하여 10,000건 이상 삽입 시 성능이 좋지 않을경우에는 위 방법처럼 일정 건수로 분할하여 삽입하거나 엑셀파일로 export한 후 DBMS에서 엑셀파일을 읽는 방식으로 진행하는 방안도 존재합니다.

이미지 출처

황정민아저씨 - https://www.digitaltoday.co.kr/news/articleView.html?idxno=69324

개념 정리를 하고, 실제로 Bean을 등록해 보겠습니다 !

개념정리

• IoC란?
• IoC(Inversion of Control)*이란 제어의 역전이라고 하며, 객체의 생성, 생명주기의 관리까지 모든 객체에 대한 제어권이 개발자에게 있는 것이 아닌 프레임워크(ex/ Spring)에 있다는 개념이다.

1. IoC가 아닌 경우 개발 시 필요할 때마다 새로운 객체를 생성해서 사용함

2. IoC인 경우 자주 사용하는 객체를 미리 만들어두고 필요할 때마다 가져와서 사용함

IoC를 사용하는 이유

새로운 객체를 생성하고 해제하는 작업 ( = 메모리에 데이터를 올려 사용하고 내리고하는 작업 )은 시간이 오래 걸릴 수 있다.

때문에 자주 사용하는 객체를 미리 만들어두고 필요할 때마다 가져다 사용하면 성능 향상에 도움이 된다.

이러한 IoC를 구현하기 위해서 DL, DI 개념이 나오게 되는데,

• DL (Dependency Lookup) ( 의존성 검색 ) 컨테이너(객체를 관리하는)에서 개발자에게 객체를 전달하는 기능

• DI (Dependency Injection) ( 의존성 주입 ) 객체들은 따로 따로 존재하는 것이 아닌 서로 서로 의존 관계를 가지고 있다라는 개념 ( 소스 상에서의 "참조" )

Ioc 관련 용어 정리

• Managed Bean ( = Bean, Bean 객체 )
  • Spring Container에 의해 관리되는 객체
  • 스프링 설정 파일( src/main/resoruces ) 에 등록되어 사용
  • 자동 등록 기능 사용 가능 ( = Component Auto Scanning, 어노테이션 )

• Spring Container
  • 관리되어지는 빈이 모여 있는 곳
  • IoC Container, Spring Context, Application Context 등으로 불림

실제로 Bean을 등록해서 사용해 보겠습니다

아래와 같은 순서로 진행하려고 합니다.

이클립스에서 진행합니다 !

• Maven Project 만들기
• 객체를 이용하여 예제 만들기
• Bean 객체를 등록하여 예제 만들기

1. Maven Project 만들기

1. Dynamic Web Project 생성

• Project Name: beanRegister-practice
• Project 구조

  src/main/java
  src/main/resources
  src/test/java
  src/test/resources

2. Maven 프로젝트로 변경 프로젝트에서 오른쪽 마우스 > Configure > Convert to Maven Project

2. 패키지 생성 및 dependency 추가

• src/main/java 에 패키지 추가 ( ex/ kr.co.acomp )
• Maven Project 로 변경 후 생성된 pom.xml 파일에 dependency 추가
• 패키지 내에 클래스 생성
  • HelloDAO.java
  • HelloMain.java

<!-- pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>kr.co.acomp</groupId>
  <artifactId>beanRegister-practice</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <release>17</release>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.2.3</version>
      </plugin>
    </plugins>
  </build>

  <dependencies>
       <!-- spring-core -->
      <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.5</version>
    </dependency>
      <!-- spring-context -->
      <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.5</version>
    </dependency>
  </dependencies>

</project>

3. 객체를 이용한 예제

/* HelloDAO.java */
package kr.co.acomp.hello;

public class HelloDAO {

    public int addTwoNumber(int a, int b) {
        return a + b;
    }
}

/* HelloMain.java */
package kr.co.acomp.hello;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloMain {

    public static void main(String[] args) {

        /* [] 객체를 생성해서 사용하는 방식 */
        HelloDAO dao = new HelloDAO();
        int result = dao.addTwoNumber(3, 5);

        System.out.println(result);        // 결과 8 출력
    }
}

4. Bean을 등록한 후 예제 만들기

• src/main/resources 에 spring-context.xml 생성
• Bean 등록
• HelloMain.java 소스 수정

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- [] id: bean id, class: Bean으로 등록할 클래스 파일 -->
    <bean id="helloDAO" class="kr.co.acomp.hello.HelloDAO" />

</beans>

package kr.co.acomp.hello;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloMain {

    public static void main(String[] args) {

        // parameter (Bean 설정파일이름)
        /* [] Bean 컨테이너, Spring container가 로딩됨(생성), Bean이 생성이 됨 */
        AbstractApplicationContext ctx =  
                new ClassPathXmlApplicationContext("/spring-context.xml");

        // parameter (Bean ID, Class Type)
        // getBean()이 Dependency Lookup을 지원, 매번 생성하는 것이 아닌 기존에 있는(=Spring Container에 있는) 객체를 전달, 훨씬 가벼움
        HelloDAO dao = ctx.getBean("helloDAO", HelloDAO.class);
        int result = dao.addTwoNumber(3, 5);

        System.out.println(result);        // 결과 8 출력
    }
    // 기존에는 "}" 이후에 객체가 사라지게 되는데 DL을 하게 되면 객체가 사라지는 것이 아니라 컨테이너로 반환되는 것임 -> 성능 향상
}

마치며

Spring Container에 Bean을 등록하여 사용하면 객체가 필요할 때마다 생성해서 사용하는 것이 아닌 Container에 존재하는 객체를 가지고 와서 사용하므로 성능 측면에서 상당한 이점이 있다고 합니다.

요청이 빈번한 Web Application 에서는 컨테이너를 사용하지 않으면 관리가 힘들다고 하니 개발하시면서 꼭 사용해 보시면 좋겠습니다 !

이미지 출처

심슨 - https://blog.naver.com/sysl9556/221225617255

가끔 '분명히 맞는데 왜 이상하게 나오지..?' 싶을 때가 있어서 찾아보다 알게된 내용들입니다!

📒부동소수점과 고정소수점

• 부동소수점: 좌표 등 약간의 오차가 중요하지 않은 데이터에서 사용

  • 모든 숫자를 1.xxxxxx 형식으로 나타낸다.
  • 첫 번째 비트는 양수, 음수를 구분하는데 사용한다.
  • 그 다음 8비트로 소수점이 몇 칸 움직일 지를 나타낸다. (127과의 차이)
  • 나머지 23자리에 소수점이 움직인 결과에서 소수점 뒤로 오는 부분들을 채워넣는다.

• 고정소수점: 금액 등 정확한 값이 필요한 경우에 사용

  • bit를 반으로 나눠서 절반은 정수, 절반은 소수 부분에 할당한다.
  • 정수 부분이 큰 숫자, 소수 부분이 정밀한 숫자를 나타낼 수 없다.
  • 정수 부분을 늘리면 소수 부분이 줄어들고, 소수 부분을 늘리면 정수 부분이 줄어들게 된다.

✅ 부동소수점 방식에서 오차가 발생하는 이유

0.1 + 1.1 == 1.2 => false 인 이유

컴퓨터가 숫자를 저장할 때 한 숫자당 32bit의 공간을 마련함

소수를 저장할 때 (IEEE 형식)

• 첫 번째칸은 음수, 양수 여부
• 8칸은 정수 부분을 2진법으로 변환해서 저장
• 나머지 23칸에 소수 부분을 2진법으로 변환해서 저장

일반적으로 0.125와 같은 숫자를 2진수로 변환하면 0.001 과 같이 깔끔하게 딱 떨어져서 변환 가능하지만

0.1 과 같이 깔끔하게 변환되지 않고 0.000110011001001 …. 과 같이 1001이 무한히 이어지는 순환소수가 되는 경우가 있는데

숫자를 저장할 때 32bit를 넘어가면 뒷 부분을 자르고 메모리에 숫자를 저장하게 됩니다.

-> 그래서 자른 부분만큼 오차가 발생함

✅ 해결방법

1. 소수를 정수로 변환해서 계산
   • 10ⁿ(n=소수점 최대 길이) 만큼 곱해줘서 정수로 만들고, 계산 후 마지막에 다시 10ⁿ만큼 나누는 방법입니다.

2. decimal.js 라이브러리 사용

    // npm decimal 을 통한 라이브러리 설치
   
    let number = 0.1;
    let transNumber = new Decimal(number).add(1.1).toString();
    let errorNumber = number + 1.1;
    console.log("> 라이브러리 사용해서 부동소수점 확인 ", transNumber == 1.2);
    console.log("> 일반 연산 부동소수점 확인 ", errorNumber == 1.2);

   

3. double 자료형 사용 -> 메모리 공간을 2배 차지함(64bit)

학교에서 전공 수업으로 이론만 배우고 간단한 실습만 해봤던 프로시저들..🙃

출처: 구글이미지(https://bart-park.tistory.com/1)

작업하면서 모르는 내용이 많아 공부하면서 조금씩 정리해봤습니다 !

프로시저 (PROCEDURE)

• 특정 작업을 수행하는 SQL BLOCK.
• 쿼리문을 하나의 메서드 형식으로 만들고 어떤 동작을 일괄적으로 처리하는 용도로 쓰인다.

👨‍💻 프로시저를 사용하는 이유 레거시인 만큼 기존에 회사에서 일을 하셨던 분들의 의도를 완전히 파악할 수는 없겠지만 프로시저의 장점과 관련이 있을 것 같습니다 !

1. 하나의 요청으로 여러 SQL문을 실행시킬 수 있기때문에 네트워크 부하를 줄일 수 있다.
2. API처럼 여러 애플리케이션과 공유가 가능하다
3. 특정한 기능을 변경 시 프로시저만 변경하면 되기에 기능 변경이 편리하다.

🧐 그러면 이런 장점들이 있는데 왜 제거해야 할까?

• 프로시저가 앱의 어디에 사용되는 지 확인이 어렵기에 유지보수가 어렵다.

  • 프로시저 내부의 동작을 확인하기 어려워 유지보수에 어려움이 있음.

• 문자나 숫자 연산에 프로시저를 사용하면 오히려 C나 JAVA보다 처리 성능이 느리다.

이러한 단점이 존재해서 제거를 하게되는 것 같습니다. 😟

✅ cursor

• 커서란? 특정 SQL 문장을 처리한 결과를 담고 있는 영역을 가리키는 일종의 포인터입니다. 커서를 사용하면 처리된 SQL 문장의 결과 집합에 접근할 수 있습니다.

ex> 커서 정의

DECLARE CURSOR_NAME_EX1 CURSOR FOR
        SELECT CODE, NAME
        FROM TABLE_A 
        WHERE A.CO_CODE = V_CO_CODE
        AND A.EMP_CODE = V_EMP_CODE; 

커서를 실행하면 해당 SELECT 쿼리가 실행되어 결과 집합이 메모리에 로드됩니다. 그 후 커서는 결과 집합을 가리키는 위치를 관리하면서 각 행을 차례로 가져옵니다. 각 행을 가져올 때마다, 커서는 그 행에 대한 데이터에 접근할 수 있게 됩니다.

• 동작하는 방식 (사용하는 방식)

  OPEN CURSOR_NAME_EX1;
  
    CUR_LOOP : LOOP
    FETCH CURSOR_NAME_EX1 INTO CODE, NAME; 
    …
    ….
  

END LOOP; CLOSE CURSOR_NAME_EX1;

커서가 결과 집합의 한 행씩 접근하여 원하는(작성한) 로직을 처리할 수 있다.

<br>

---

### ✅ select into

CODE, NAME 컬럼을 가지고 있는 TABLE_A가 기존에 존재한다고 했을 때

|CODE|NAME|
|:-----------|:-----------|
|code1|name1|
|code2|name2|
|code3|name3|
|...|...|

``` sql
-- 새로운 테이블 생성 및 데이터 복사
SELECT *
INTO TABLE_A_COPY
FROM TABLE_A;

-- TABLE_A_COPY 테이블의 내용 확인
SELECT * FROM TABLE_A_COPY;

CODE | NAME
----------------------------
code1 | name1
code2 | name2
code3 | name3
…
…

✅ set = ‘ … ’

프로시저 내에서 정의한 지역변수에 원하는 값을 할당할 수 있습니다.

SET 이라는 명령어를 사용하여 변수에 값을 할당 ex> SET MY_NAME = ‘Yoon Han Young’;

✅ || 의 의미

|| 연산자는 문자열을 연결하는 연산자

DECLARE V_FIRST_NAME VARCHAR(50) = ‘Yoon’;
DECLARE V_LAST_NAME VARCHAR(50) = ‘Han Young’;
DECLARE V_FULL_NAME VARCHAR(100);

SET V_FULL_NAME = V_FIRST_NAME || ' ' || V_LAST_NAME;
PRINT V_FULL_NAME;    — 결과값 Yoon Han Young

✅ 활용

커서 내부의 SELECT 결과 집합이 아래와 같을 때

cursor와 SET, || 연산자를 이용하여 원하는 변수에 문자를 중첩시킬 수 있습니다.

ex>
DECLARE V_ACCT_CD    VARCHAR(10);    -- 변수 생성

-- 커서 정의
DECLARE CURSOR_NAME_EX1 CURSOR FOR
        SELECT CODE, NAME
        FROM TABLE_A 
        WHERE A.CO_CODE = V_CO_CODE
        AND A.EMP_CODE = V_EMP_CODE;

-- 커서 open
OPEN CURSOR_NAME_EX1;

    CUR_LOOP : LOOP
    FETCH CURSOR_NAME_EX1 INTO CODE, NAME; 

    -- 문자열 중첩
    SET V_CODE = ‘and TABLE_A.CODE in (‘’’ || CODE || ‘’’)’;
    …
    …

END LOOP;
CLOSE      CURSOR_NAME_EX1;



/* 
V_CODE 에는 'and TABLE_A.CODE in (‘code1’, ‘code2’, ‘code3’, …)' 
이라는 문자열이 쌓이게 됨
*/

• yarn 설치 https://jerryjerryjerry.tistory.com/80

• vscode 폰트 https://velog.io/@woo0_hooo/vscode-%EC%97%90-%ED%8F%B0%ED%8A%B8-%EC%A0%81%EC%9A%A9%ED%95%B4%EC%84%9C-%EC%BD%94%EB%94%A9%ED%95%98%EA%B3%A0-%EC%8B%B6%EA%B2%8C-%EB%A7%8C%EB%93%A4%EA%B8%B0

• 이클립스 Tomcat 설정 https://dev-handbook.tistory.com/32

• 이클립스 Tomcat 환경 만들기 https://cepojyze.tistory.com/19

1. App.js

컴포넌트에 해당하는 코드인 App.js 를 확인해보면

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';

class App extends Component {
  render() {
    return (
      <div className="App">
        <header className="App-header">
          <img src={logo} className="App-logo" alt="logo" />
          <h1 className="App-title">Welcome to React</h1>
        </header>
        <p className="App-intro">
          To get started, edit <code>src/App.js</code> and save to reload.
        </p>
      </div>
    );
  }
}

export default App;

이렇게 구성이 되어있다.

코드를 순서대로 살펴보면

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';

import 한다는 것은 무엇을 불러온다는 뜻이다. 이렇게, import 를 한다는 것은 우리가 webpack 을 사용하기에 가능한 작업이다. 이렇게 불러오고나면 나중에 프로젝트를 빌드하게 됐을 때 webpack 에서 파일의 확장자에 따라 다른 작업을 하게 되는데,

• CSS 파일은 프로젝트에서 사용한 프로젝트를 한 파일에 모두 결합해주는 작업을 진행한다.
• JS 파일은 모든 코드들이 제대로 로딩되게끔 순서를 설정하고 하나의 파일로 합쳐주는 작업을 진행
• svg 와 같은 사전에 따로 설정을 하지 않은 확장자의 경우, 그냥 파일로서 불러온 다음에 나중에 특정 경로에 사본을 만들어 주고, 해당 사본의 경로를 텍스트로 받아오게 된다.

2. index.js

import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App';
import registerServiceWorker from './registerServiceWorker';

ReactDOM.render(<App />, document.getElementById('root'));
registerServiceWorker();

우리가 만든 App.js 를 import 를 이용해서 불러와 준다.

그리고 브라우저 상에 우리의 React Component 를 보여주기 위해서는 ReactDOM.render 함수를 사용한다. 첫 번째 파라미터는 렌더링 할 결과물이고, 두 번째 파라미터는 컴포넌트를 어떤 DOM 에 그릴지를 정한다.

코드를 보면 id 가 root 인 DOM 을 찾아서 그리도록 되어 있는데 해당 DOM 은 public/index.html 파일에서 찾을 수 있다.

// public/index.html
<div id="root"></div>

해당 DOM을 찾아서 렌더링을 한다.

3. JSX

HTML 과 비슷한 문법으로 작성하면 이를 React.createElement 를 사용하는 자바스크립트 형태로 변환시켜준다.

• JSX 안에 자바스크립트 값 사용하기

  import React, { Component } from 'react';
  

class App extends Component { render() { const name = 'react'; return (

export default App;

<br />

- 조건부 렌더링
``` javascript
import React, { Component } from 'react';

class App extends Component {

  printHandler = () => (<div>맞다야아아~!@~!@</div>)

  render() {
    const name = "react!";
    return (
      <div className="App">
        {/* 주석은 이렇게 한다아! */}
        Hello {name}
        {
          1 + 1 === 2
          ? (<div>맞아요!</div>)
          : (<div>틀려요!!!!</div>)
        }
        {
          1 + 1 === 2 && this.printHandler()
        }
      </div>
    );
  }
}

export default App;

간단한 조건들은 JSX 안에서 처리해도 되지만 복잡한 조건들은 웬만하면 JSX 밖에서 로직을 작성하는 것이 좋다!

왜냐하면 render() 함수가 렌더링될 때마다 함수가 생성되기 때문에 성능에 영향을 미칠 수 있다!

기초 학습

• ref 를 사용하는 이유
  React 에서는 일반적으로 직접 document.xxx 를 이용하여 DOM 에 직접 접근하는 것을 권장하지 않는다. 왜냐하면 React 는 Virtual DOM 을 사용하여 DOM 조적을 추상화하고 컴포넌트 상태를 업데이트하며 UI 를 관리하는데, 직접 DOM 에 접근하면 거기서 나오는 이점이 사라지기 때문이다.
  그래서 특정 DOM 요소에 접근해야 할 경우 `ref` 속성을 사용하면 된다.

class TestComponent extends Component {
    constructor(props) {
        super(props);
        this.inputRef = React.createRef(); // React.createRef()로 생성
    }

    render() {
           return(
            <input type="text" ref={this.inputRef} />;
        )
    }
}

1. for...in 의 사용방법

• for...in 사용법 - Object 위의 예제처럼 obj1 라는 객체를 생성하여 for...in 문법을 사용하면 temp 로 key 값에 접근할 수 있고, obj1[temp] 와 같은 대괄호 표기법을 이용하여 value 값에 접근할 수 있다.

• for...in 사용법 - Array 위의 예제처럼 arr1 이라는 배열을 생성하여 for...in 문법을 사용하면 temp 로 배열의 index에 접근할 수 있고, arr1[temp] 를 이용하여 배열의 value 에 접근할 수 있다.

2. for...of 의 사용방법

• for...of 의 사용법 - Object 이처럼 for...of 는 iterable(순회 가능한) 객체만을 사용할 수 있다.

• for...of 의 사용법 - Array arr1 이라는 배열을 생성한 후 for...of 문법을 사용하여 배열을 순회하며 value 값에 접근할 수 있다.

대괄호 표기법

JavaScript 에서 객체의 속성에 접근하거나 값을 설정할 때 사용하는 방법 중 하나이다.

• 객체 속성에 접근하는 방법

  const obj = {
  name: "Yoon",
  age: 26,
  }
  

const propertyName = "name"; console.log(obj[propertyName]); // Yoon

<br />

- 객체의 속성 값을 설정하는 방법
``` javascript
const obj = {};
const propertyName = "name";
obj[propertyName] = "Yoon";

console.log(obj.name);        // Yoon

화살표 함수와 일반 함수의 차이점(this 바인딩, 호이스팅)

this 바인딩

• 화살표 함수 화살표 함수는 자체적인 this 를 가지지 않고, 함수가 정의된 스코프의 this 를 상속 받는다. 이를 "렉시컬 스코프 바인딩"이라고 한다. 따라서 화살표 함수 내에서 this 를 사용하면 함수를 정의한 컨텍스트의 this 를 참조하게 된다.

호이스팅

• https://velopert.com/3612

React Virtual DOM 왜 쓰냐?!

'데이터가 바뀌면 그냥 뷰를 날려버리고 새로 만들어버리면 어떨까?!' React가 시작하게 된 생각이다.

그렇지만 브라우저가 게임 엔진도 아니고, DOM 기반으로 동작하는 이 페이지는 그때 그때 새로 뷰를 만들어버리고 하면 성능에 엄청난 문제가 생긴다!

그래서 Virtual DOM을 사용한다!!!

Virtual DOM

Virtual DOM은 가상의 DOM이다. 변화가 일어나면, 실제로 브라우저의 DOM 에 새로운 것을 넣는 것이 아니라, JS로 이루어진 가상 DOM 에 한 번 렌더링하고, 기존의 DOM 과 비교를 한 다음에 변화가 필요한 곳에만 업데이트를 해주는 것이다.

Virtual DOM 은 DOM 변화를 최소화 시켜주는 역할을 한다. 이 횟수를 최소화 시키는 것은 성능적으로 매우 중요한 이슈이다!!!

*3rd party libary

• 프로그래밍에서 3rd party란 프로그래밍을 도와주는 pulg_in 이나 libary 를 만드는 회사를 말한다.
• 서드 파티 라이브러리란 | 개인 개발자나 프로젝트 팀, 혹은 업체 등에서 개발하는 라이브러리를 말한다.
• 리액트에는 공식적인 라이브러리는 없지만 3rd party libary 가 존재한다.

리액트의 몰랐던 장점...?

React 라이브러리는 뷰 쪽만 관리하게 되고, 나머지 기능은 3rd party 라이브러리가 담당하게 함으로서, React는 리액트 라이브러리로서 더욱 성숙해질 수가 있을 것이다!

# nvm 다운로드
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash

# nvm 다운로드 확인
nvm list

# 에러가 뜬다면
export NVM_DIR="$HOME/.nvm"  
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

# 순서대로 입력해서 다시 nvm list 확인
nvm list

# 원하는 버전의 nvm 설치
nvm install 16.20.2

# 확인
nvm list

# 기존의 yarn 삭제
npm uninstall -g yarn

# yarn 설치
npm install -g yarn

# 작업 경로로 가서 node-modules 삭제
rm -rf node_modules

# yarn or yarn install!!!!!!!!!!
yarn install