3.1. SELECT ~ FROM ~ WHERE

1. SELECT

• 구축이 완료된 테이블에서 데이터를 추출하는 기능을 한다.

2. WHERE (조건식)

• 조건을 지정해 필요한 행만 선택한다.

(1) 조건식 예시

SELECT mem_id, mem_name FROM member WHERE height <= 162;

(2) AND / OR

SELECT mem_id, mem_name FROM member WHERE height <= 162 AND mem_number > 6;
SELECT mem_id, mem_name FROM member WHERE height <= 162 OR mem_number > 6;

(3) BETWEEN AND (숫자 범위)

SELECT mem_id, mem_name FROM member WHERE height BETWEEN 163 AND 165;

(4) IN (문자열 집합)

• 문자열 조건을 묶을 때 사용

SELECT mem_id, mem_name FROM member WHERE addr IN ('경기', '전남', '경남');

(5) LIKE (문자 비교)

• 특정 문자를 포함하거나 시작하는 데이터를 찾는다.

SELECT * FROM member WHERE mem_name LIKE '우%';

정규식 참고

3. 데이터베이스 지정 (.)

• 현재 접속 중인 DB가 아니어도 “DB명.테이블명”으로 접근 가능

USE sys;
SELECT * FROM market_db.member WHERE mem_name = '블랙핑크';

4. 지정한 열만 조회

• *는 모든 열을 의미하므로, 필요 열만 선택 가능

USE market_db;
SELECT addr, height, debut_date FROM member;

• 열 순서에 따라 출력 결과 순서가 달라진다.

5. 별칭 (Alias)

• 열 이름에 별칭을 부여해 출력 시 보기 좋게 만든다.

SELECT height AS '키', debut_date AS '데뷔 날짜', addr FROM member;

기타 명령어 요약

DROP DATABASE IF EXISTS market_db; -- 존재하면 삭제
CREATE DATABASE market_db;         -- DB 생성
USE market_db;                     -- DB 선택
CREATE TABLE member (...);         -- 테이블 생성

3.2. SELECT 심화

1. SELECT 절의 순서

SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY → LIMIT (순서가 틀리면 문법 오류 발생)

2. ORDER BY (정렬)

• 결과를 정렬하여 보여준다. (데이터 자체는 변경되지 않음)

SELECT * FROM member ORDER BY debut_date DESC, mem_id ASC;

3. LIMIT (출력 개수 제한)

LIMIT 3;      -- 위에서 3개 행만 출력
LIMIT 3, 2;   -- 3행부터 2개 출력

4. DISTINCT (중복 제거)

SELECT DISTINCT addr FROM member;

5. GROUP BY (그룹별 집계)

(1) 집계 함수

(2) 예시

SELECT mem_id, AVG(amount) AS '평균 구매 개수'
FROM buy
GROUP BY mem_id;

6. HAVING

• GROUP BY의 결과에 조건을 걸 때 사용 (집계 함수 사용 가능)

SELECT mem_id, SUM(amount) AS '총 구매량'
FROM buy
GROUP BY mem_id
HAVING SUM(amount) >= 10;

3.3. 데이터 변경을 위한 SQL

1. INSERT INTO

(1) 기본 삽입

CREATE TABLE hongong1 (toy_id INT, toy_name CHAR(4), age INT);
INSERT INTO hongong1 VALUES (1, '우디', 25);

(2) 열 지정 삽입

INSERT INTO hongong1 (toy_id, toy_name, age)
VALUES (3, '제시', 20);

2. AUTO_INCREMENT, ALTER TABLE

• 자동 증가 번호 지정
• 시작 번호 및 증가 간격 설정 가능

CREATE TABLE hongong2 (
    toy_id INT AUTO_INCREMENT PRIMARY KEY,
    toy_name CHAR(4),
    age INT
);

INSERT INTO hongong2 VALUES (NULL, '보핍', 25);
INSERT INTO hongong2 VALUES (NULL, '렉스', 21);

SELECT LAST_INSERT_ID(); -- 마지막 입력된 ID 확인
ALTER TABLE hongong2 AUTO_INCREMENT = 100;
SET @@auto_increment_increment = 3;

3. INSERT INTO ~ SELECT

• 다른 테이블의 데이터를 한 번에 복사 삽입

CREATE TABLE city_popul (city_name CHAR(35), population INT);
INSERT INTO city_popul
SELECT Name, Population FROM world.city;

4. UPDATE

UPDATE city_popul
SET city_name = '뉴욕', population = 0
WHERE city_name = 'New York';

UPDATE city_popul
SET population = population / 10000;

5. DELETE

DELETE FROM city_popul
WHERE city_name LIKE 'New%'
LIMIT 5;

참고 명령

DESC world.city; -- 테이블 구조 확인

4장. 자료형과 변수

4.1. 숫자형 (INT)

단순 숫자 외 “전화번호” 등은 문자형(CHAR/VARCHAR) 사용

4.2. 문자형

4.3. 긴 문자열 및 바이너리

4.4. 실수형

4.5. 날짜형

4.6. 변수의 사용

• 변수는 임시저장 (Workbench 종료 시 사라짐)

SET @변수이름 = 값;
SELECT @변수이름;

PREPARE / EXECUTE

• LIMIT 내에서는 변수를 직접 사용할 수 없으므로, PREPARE 구문으로 대체

SET @limit_cnt = 5;
PREPARE stmt FROM 'SELECT * FROM member LIMIT ?';
EXECUTE stmt USING @limit_cnt;

4.7. 데이터 형변환

동일한 기능이며 문법만 다름

4.8. 문자열 결

합

SELECT CONCAT('아이유', '님') AS 결과;

5장. 조인 (JOIN)

5.1. 개념

• 두 개 이상의 테이블을 연결하여 하나의 결과로 묶는 기능

5.2. 내부 조인 (INNER JOIN)

• 두 테이블이 일대다(PK-FK) 관계일 때 사용

SELECT 조회할_열
FROM 외래키_테이블 A
INNER JOIN 기본키_테이블 B
ON A.fk_column = B.pk_column
WHERE 조건;

5.3. 외부 조인 (OUTER JOIN)

SELECT 열_목록
FROM 첫번째_테이블
LEFT OUTER JOIN 두번째_테이블
ON 조건
WHERE 검색조건;

• LEFT / RIGHT / FULL OUTER JOIN 형태로 사용

5.4. 상호 조인 (CROSS JOIN)

• 두 테이블의 모든 행 조합을 반환 (빅데이터용)

5.5. 자체 조인 (SELF JOIN)

• 자기 자신과 조인 — 별칭을 이용해 구분

SELECT *
FROM emp_table A
INNER JOIN emp_table B
ON A.member = B.manager;

참고

DROP TABLE IF EXISTS 테이블명;  -- 존재 시 삭제
SELECT CURRENT_DATE();         -- 현재 날짜
SELECT DATEDIFF('2025-12-31', '2025-01-01'); -- 날짜 차이 계산

1강. 데이터베이스 알아보기

1.1. 기본 개념

• 데이터베이스(DB, DataBase): 데이터를 체계적으로 모아 놓은 집합

• DBMS (DataBase Management System): 데이터베이스를 관리·운용하는 소프트웨어

  • 조건:

    • 대용량 데이터 관리 가능 (엑셀은 한계 있음)
    • 데이터 공유 가능 (여러 명이 동시에 접근 가능)

  • 종류: MySQL, MongoDB, Oracle 등

• SQL (Structured Query Language): DBMS에서 데이터를 구축, 관리, 활용하기 위해 사용하는 언어

1.2. DBMS 종류

1. 계층형 DBMS: 트리 형태 구조, 상하 관계 존재

2. 망형 DBMS: 계층 구조를 벗어나 여러 노드와 상호작용 가능

3. 관계형 DBMS(RDBMS)

   • 최소 단위는 테이블
   • 테이블은 행(row)과 열(column)로 구성
   • 예: MySQL, Oracle

4. 객체지향형 DBMS

5. 객체관계형 DBMS

1.3. DBMS에서 사용되는 언어

• SQL은 국제표준화기구에서 표준으로 지정됨
• 각 DBMS마다 고유 확장이 존재

1.4. MySQL 설치

• Workbench: 서버 자체는 눈에 보이지 않음
• SQL 문을 작성하고 실행하여 데이터베이스를 관리

2강. 실전용 SQL 미리 맛보기

2.1. 데이터베이스 모델링

• 데이터베이스 모델링: 테이블 구조를 설계하는 과정

• 프로젝트: 현실 세계 업무를 시스템으로 구현하는 과정

• 폭포수 모델:

  프로젝트 계획 → 업무 분석 → 시스템 설계 → 프로그램 구현 → 테스트 → 유지보수

데이터베이스 구성

• DBMS(MySQL) → 데이터베이스(폴더) → 테이블(파일)

• 행(row): 실제 데이터 단위

• 기본키(Primary Key): 각 행을 구분하는 유일한 값

  • 중복 불가, NULL 불가
  • 테이블 당 하나만 지정 가능

• 데이터 형식: 열에 지정, 문자, 숫자 등

2.2. 데이터베이스 구축 절차

1. 데이터베이스 만들기

CREATE SCHEMA shop_db;

2. 테이블 설계

CREATE TABLE shop_db.member (
  member_id CHAR(8) NOT NULL,
  member_name CHAR(5) NOT NULL,
  member_addr CHAR(20) NULL,
  PRIMARY KEY (member_id)
);

CREATE TABLE shop_db.product (
  product_name CHAR(10) NOT NULL,
  cost INT NOT NULL,
  make_date DATE NULL,
  company CHAR(5) NULL,
  amount INT NULL,
  PRIMARY KEY (product_name)
);

3. 데이터 입력

INSERT INTO shop_db.member (member_id, member_name, member_addr) VALUES
('tess', '나훈아', '경기 부천시 중동'),
('hero', '임영웅', '서울 은평구 증산동'),
('iyou', '아이유', '인천 남구 주안동'),
('jyp', '박진영', '경기 고양시 장향동');

INSERT INTO shop_db.product (product_name, cost, make_date, company, amount) VALUES
('바나나', 1500, '2021-07-01', '델몬트', 17),
('카스', 2500, '2022-03-01', 'OB', 3),
('삼각김밥', 800, '2023-09-01', 'CJ', 22);

4. 데이터 수정

UPDATE shop_db.member
SET member_addr = '영국 런던 먹자골목'
WHERE member_id = 'carry';

5. 데이터 삭제

DELETE FROM shop_db.member
WHERE member_id = 'carry';

6. 데이터 조회

SELECT * FROM member;
SELECT member_name, member_addr FROM member;
SELECT * FROM member WHERE member_name = '아이유';

2.3. 데이터베이스 개체

1. 테이블(Table): 데이터 저장 기본 단위

2. 인덱스(Index): 조회 속도 향상

CREATE INDEX idx_member_name ON member(member_name);

3. 뷰(View): 가상의 테이블, 실제 데이터는 없음

CREATE VIEW member_views AS
SELECT * FROM member;

4. 스토어드 프로시저(Stored Procedure)

DELIMITER //
CREATE PROCEDURE myProc()
BEGIN
    SELECT * FROM member WHERE member_name = '나훈아';
    SELECT * FROM product WHERE product_name = '삼각김밥';
END //
DELIMITER ;

CALL myProc();

5. 트리거(Trigger), 함수(Function), 커서(Cursor)

• 트리거: 특정 이벤트 발생 시 자동 실행
• 함수: 재사용 가능한 SQL 코드 블록
• 커서: SELECT 결과를 한 행씩 처리

정리

1. 데이터베이스

1.1. 기본 개념

1. 데이터베이스
2. DBMS
3. SQL

1.2. DBMS의 종류

1. 계층형 DBMS
2. 망형 DBMS
3. 관계형 DBMS (RDBMS - MySQL, Oracle)
4. 객체지향형 DBMS
5. 객체관계형 DBMS

2. SQL

2.1. 데이터베이스

1. 기본 개념2

1. 데이터베이스 모델링
2. 프로젝트
3. 폭포수 모델

2. 전체 데이터베이스 구상도

1. 행
2. Primary key
3. 데이터 형식

2.2. 데이터베이스

1. 데이터베이스 구축 절차

1. 데이터베이스 구축

CREATE SCHEMA '데이터베이스 이름'; 
-- CREATE DATABASE로 생성해도 된다.

2. 테이블 구축

CREATE TABLE '데이터베이스 이름'.'테이블 이름' (
  -- 구축 내용
  PRIMARY KEY('기본키 컬럼명')
);

3. 데이터 입력/수정/삭제

2.3. 데이터베이스 개체 (여러 형태)

1. 테이블
2. 인덱스

CREATE INDEX 인덱스_이름 ON 테이블_이름(인덱스로_만들_열_요소);

3. 뷰(View)

CREATE VIEW 뷰_이름 AS SELECT * FROM 테이블;

4. 스토어드 프로시저(Stored Procedure)

DELIMITER //
CREATE PROCEDURE 프로시저_이름()
BEGIN
  -- 프로시저 내용
END //
DELIMITER ;

5. 트리거, 함수, 커서

Spring Security + Google OAuth2 로그인 구현(3)

본 프로젝트는 최주호 님의 「스프링부트 시큐리티 & JWT」 강의를 참고하여 진행하였습니다.

최주호 님의 「스프링부트 시큐리티 & JWT」 강의 git 주소 https://github.com/codingspecialist/-Springboot-Security-OAuth2.0-V3

버전 업데이트 이후 수정본으로 진행하는 git 주소 https://github.com/Solkot/Security_Oauth -> branch마다 저장하면서 진행하고 있습니다. OAuth 전의 과정의 경우 Profile branch에 저장되어 있습니다.

1. 의존성 추가

spring-boot-starter-oauth2-client 의존성을 pom.xml 또는 build.gradle에 추가합니다.

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

이 라이브러리가 있어야 Spring Security가 OAuth2 인증 플로우를 자동으로 처리할 수 있습니다.

2. Google API Console에서 OAuth 프로젝트 생성

1. Google Cloud Console 접속

   1.1. 콘솔로 접속

2. 새 프로젝트 생성

3. OAuth 동의 화면 구성 → 사용자 유형 선택 (외부/내부)

4. OAuth 클라이언트 ID 생성

   • 애플리케이션 유형: 웹 애플리케이션
   • 승인된 리디렉션 URI에 다음 추가

http://localhost:8080/login/oauth2/code/google

4.1. 고정된 기본 리디렉션 URI 패턴(/login/oauth2/code/{registrationId})

Spring Security는 OAuth2 로그인 플로우를 처리하기 위해 리디렉션 URI를 내부적으로 고정된 규칙으로 관리합니다.

{baseUrl}/login/oauth2/code/{registrationId}

5. 클라이언트 ID / 클라이언트 비밀번호 복사 baseUrl: 우리 애플리케이션의 루트 주소 (예: http://localhost:8080 )

registrationId: application.yml에 정의한 OAuth2 클라이언트 이름(google, naver 등), 이후 3에서 설정합니다. 4.2. 고정된 기본 리디렉션 URI 패턴(변경)

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            redirect-uri: "{baseUrl}/oauth2/callback/{registrationId}"

로 바꿀 순 있다.

3. application.yml 설정

client-id, client-secret은 GitHub에 업로드되지 않도록 .gitignore 관리 주의, 아니면 직접 들어가서 지우기

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: your-client-id
            client-secret: your-client-secret
            scope:
              - email
              - profile

이 설정으로 Spring Security가 구글 OAuth2 클라이언트로 동작할 수 있게 됩니다.

client-id와 client-secret은 Google cloud API에서 생성된 프로젝트를 보고 채워주면 된다.

4. 로그인 폼에 OAuth 로그인 버튼 추가

loginForm.mustache (또는 HTML)에서 다음과 같이 Google 로그인 링크를 추가합니다.

<a href="/oauth2/authorization/google">Google로 로그인</a>

하지만! 아직 .oauth2Login() 설정이 Security 필터 체인에 없기 때문에 /oauth2/authorization/google로 접근 시 404 에러가 발생합니다.

5. Security 필터 체인 설정

이제 OAuth2 인증 요청을 처리할 수 있도록 필터를 등록해야 합니다.

 @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(AbstractHttpConfigurer::disable)
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/user/**").authenticated()
                        .requestMatchers("/manager/**").hasAnyRole("ADMIN", "MANAGER") //ROLE_ADMIN에서 이제 ROLE_ 같은 접두사는 자동으로 붙기 때문에 사용 X
                        .requestMatchers("/admin/**").hasRole("ADMIN")
                        .anyRequest().permitAll()
                )
                .formLogin(form -> form
                        .loginPage("/loginForm")
                        .loginProcessingUrl("/login")// /login 주소가 호출이 되면 시큐리티가 낚아채서 대신 로그인을 진행해줍니다.
                        .defaultSuccessUrl("/") //로그인 성공 후 이동할 기본 URL 지정
                        .permitAll() // 로그인 페이지와 로그인 요청 URL은 누구나 접근 가능하도록 허용
                ).oauth2Login(oauth2 -> oauth2
                        .loginPage("/loginForm") // OAuth2 로그인도 같은 커스텀 로그인 페이지 사용
                        //구글 로그인이 완료된 후에 후처리가 필요, Tip 코드 X(액세스 토큰 + 사용자 프로필 정보)
                        .userInfoEndpoint(userInfo -> userInfo
                                .userService(principalOauth2UserService)
                        )
                        .defaultSuccessUrl("/")
                );

        return http.build();
    }

이제 /oauth2/authorization/google 요청이 정상적으로 동작하며, Spring Security가 구글 → 인증 코드(code) → 액세스 토큰 → 사용자 정보(OAuth2User) 로 이어지는 과정을 자동으로 처리합니다.

6. Spring Security의 OAuth2 기본 동작

1. 사용자가 /oauth2/authorization/google 클릭
2. Google 로그인 페이지로 리디렉션
3. 로그인 성공 후 Google이 인가 코드(code) 를 리디렉션 URI로 전달
4. Spring Security가 인가 코드를 받고 → Google로 액세스 토큰 요청
5. Google로부터 사용자 정보(userinfo) 를 받아와 OAuth2User 객체 생성
6. OAuth2User를 SecurityContext에 저장 → 인증 완료

하지만 이건 “최소한의 인증 처리”만 해줍니다. DB 저장, 권한 매핑, 기존 회원 연동은 개발자가 직접 구현해야 합니다.

7. PrincipalOauth2UserService 추가

OAuth2 로그인 시 받은 사용자 정보를 우리 서비스의 회원 시스템(DB)에 연동하려면 PrincipalOauth2UserService를 구현해야 합니다. UserDetailsService라고 생각하시면 됩니다. 과정은 유사합니다.

@Service
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    @Autowired
    private UserRepository userRepository; //해당 아이디로 로그인이 되어있는지 확인

    //구글로부터 받은 userRequest 데이터에 대한 후처리 되는 함수
    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        System.out.println("userRequest : " + userRequest);
        System.out.println("getClientRegistration: "+ userRequest.getClientRegistration()); // registrationId로 어떤 OAuth로 로그인했는지 확인 가능
        System.out.println("getAccessToken: "+userRequest.getAccessToken().getTokenValue());
        //System.out.println("getAttributes: "+super.loadUser(userRequest).getAttributes());

        OAuth2User oauth2User =  super.loadUser(userRequest);
        // 구글 로그인 버튼 클릭 -> 구글로그인창 -> 로그인 완료 -> code를 리턴(OAuth-Client라이브러리) -> AccessToken 요청
        //UserRequest 정보 -> 회원프로필 받아야함(loadUser함수 호출) ->구글로 부터 회원프로필 받아준다.
        System.out.println("getAttributes: "+oauth2User.getAttributes());

        String provider = userRequest.getClientRegistration().getClientId(); //google
        String providerId = oauth2User.getAttribute("sub");
        String username = provider + "_" + providerId; //google_...(sub)
        String password = bCryptPasswordEncoder.encode("비밀번호"); //의미 없음, 인증 받는 곳에서 인증 후 준 코드를 사용하기 때문
        String email = oauth2User.getAttribute("email");
        String role = "ROLE_USER";

        User userEntity = userRepository.findByUsername(username);

        if(userEntity == null){
            System.out.println("구글 로그인이 최초입니다.");
            userEntity = User.builder()
                    .username(username)
                    .password(password)
                    .email(email)
                    .role(role)
                    .provider(provider)
                    .providerId(providerId)
                    .build();

            userRepository.save(userEntity);
        }//User가 없을 경우만 생성, 이후는 중복적인 생성을 못하게 차단
        else{
            System.out.println("구글 로그인을 이미 한 적이 있습니다. 당신은 자동회원가입이 되어 있습니다.");
        }

        //return super.loadUser(userRequest);
        return new PrincipalDetails(userEntity, oauth2User.getAttributes()); //이 정보가 대신해서 Authetication 객체 안으로 들어간다.
        //UserDetails와 OAuth2User을 implements한 PrincipalDetails를 대신 Authentication에 넣음
    }
}

8. PrincipalDetails 확장 (UserDetails + OAuth2User)

기존에는 UserDetails만 구현했지만, 이제 OAuth2User까지 통합해야 하므로 두 인터페이스를 모두 구현합니다.

public class PrincipalDetails implements UserDetails, OAuth2User {

    private User user;
    private Map<String, Object> attributes; // OAuth2 정보

    // 일반 로그인용 생성자
    public PrincipalDetails(User user) {
        this.user = user;
    }

    // OAuth2 로그인용 생성자
    public PrincipalDetails(User user, Map<String, Object> attributes) {
        this.user = user;
        this.attributes = attributes;
    }

    @Override
    public Map<String, Object> getAttributes() {
        return attributes;
    }

    @Override
    public String getName() {
        return user.getUsername();
    }

    // UserDetails의 메서드들도 그대로 구현 (getPassword, getAuthorities 등)
}

이제 OAuth2 로그인 시에도 동일한 PrincipalDetails 객체를 사용하여 인증 정보를 Authentication에 담을 수 있습니다.

8.1. UserDetails와 OAuth2User를 오버라이딩 한 이유

1. OAuth와 UserDetails를 Principal details 타입으로 묶기 위해서
2. OAuth로 로그인 했을떄 회원가입을 강제로 진행시키기 위해서

9. 인증 정보 확인 (Controller)

로그인 성공 후, 현재 인증 객체를 확인해봅니다.

@GetMapping("/")
public String index(Authentication authentication,
                    @AuthenticationPrincipal PrincipalDetails principalDetails) {

    System.out.println("Authentication: " + authentication.getPrincipal());
    System.out.println("UserDetails: " + principalDetails.getUsername());
    return "index";
}

10. 전체 흐름 정리

마무리

Spring Security의 OAuth2 로그인은 “기본 인증 흐름”은 자동, “회원 정보 연동”은 직접 커스터마이징하는 구조입니다.

Spring Security의 기본 OAuth2 로그인은 사용자의 정보를 받아와 OAuth2User 객체를 생성해서 SecurityContext에 저장해서 로그인을 유지하는 것까지는 됩니다.

하지만 아직 사용자 정보(DB)와 연결되지 않았기에 우리 서비스 입장에서는 "이 사용자가 우리 회원인지", "권한이 뭔지"를 모릅니다.

그렇기에

1. OAuth2UserService에서 사용자 정보 받아와 DB에서 해당 이메일로 회원 조회
2. 아이디가 없으면 새로 가입시켜주고 DB에서 조회된 User 엔티티를 기반으로 PrincipalDetails 생성
3. Authentication 객체에 PrincipalDetails를 직접 넣어서 SecurityContextHolder에 저장

하는 PrincipalDetails의 일관성을 유지시키는 작업이 필요하다. pring Security의 인증 체계 안으로 OAuth2 사용자를 완전히 편입시키는 과정으로 일반 로그인과 OAuth2 로그인이 같은 PrincipalDetails 기반으로 동작할 수 있다.

본 프로젝트는 최주호 님의 「스프링부트 시큐리티 & JWT」 강의를 참고하여 진행하였습니다.

최주호 님의 「스프링부트 시큐리티 & JWT」 강의 git 주소 https://github.com/codingspecialist/-Springboot-Security-OAuth2.0-V3

버전 업데이트 이후 수정본으로 진행하는 git 주소 https://github.com/Solkot/Security_Oauth -> branch마다 저장하면서 진행하고 있습니다. OAuth 전의 과정의 경우 Profile branch에 저장되어 있습니다.

1. loginPage vs loginProcessingUrl

public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(AbstractHttpConfigurer::disable)
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/user/**").authenticated()
                        .requestMatchers("/manager/**").hasAnyRole("ADMIN", "MANAGER") //ROLE_ADMIN에서 이제 ROLE_ 같은 접두사는 자동으로 붙기 때문에 사용 X
                        .requestMatchers("/admin/**").hasRole("ADMIN")
                        .anyRequest().permitAll()
                )
                .formLogin(form -> form
                        .loginPage("/loginForm")
                        .loginProcessingUrl("/login")// /login 주소가 호출이 되면 시큐리티가 낚아채서 대신 로그인을 진행해줍니다.
                        .defaultSuccessUrl("/") //로그인 성공 후 이동할 기본 URL 지정
                        .permitAll() // 로그인 페이지와 로그인 요청 URL은 누구나 접근 가능하도록 허용
                ));
                return http.build();}

주석에 달아놓긴 하였으나 실제로 어떻게 차이나는지 저도 궁금해서 찾아보았습니다.

1.1. .loginPage("/loginForm")

사용자가 로그인이 필요한 페이지에 접근했을 때, 즉 권한이 필요하다고 생각하는 페이지에 접근했을때 스프링 시큐리가 로그인 페이지로 리다이렉트시켜 이동시키는 경로입니다.

즉, "로그인 폼이 있는 페이지" 입니다.

1.2. .loginProcessingUrl("/login")

사용자가 로그인 폼에서 아이디, 비밀번호를 입력하고 전송할 때 (POST) 이 경로로 요청이 들어오면 Spring Security가 자동으로 가로채서 로그인 인증을 수행합니다.

즉, "로그인 검증을 실행하는 백엔드 처리 URL" 이라고 생각하면 됩니다.

<form action="/login" method="post">
  <input type="text" name="username" />
  <input type="password" name="password" />
  <button type="submit">로그인</button>
</form>

action="/login"이면 사용자가 로그인 버튼을 눌렀을 때, /login으로 POST 요청 발생, UsernamePasswordAuthenticationFilter가 이 요청을 가로채고 인증 처리를 합니다.

따라서 따로 컨트롤러에 /login 매핑을 직접 만들 필요가 없습니다.

2. 로그인 과정

로그인 과정은 위와 같다.

간단하게 보자면 User -> UserDetails -> Authetication -> SecruitySession이라고 보면 된다.

추가적으로 설명을 덧붙이자면 아래에 나와있다.

2.1. 로그인 요청

사용자가 로그인 폼에서 아이디·비밀번호를 입력하고 /login 요청을 전송

2.2. 필터 가로채기

스프링 시큐리티가 자동으로 등록한 UsernamePasswordAuthenticationFilter가 이미 존재하고, 그 필터가 /loginProcessingUrl()로 지정된 주소(/login) 요청을 자동으로 가로채서 로그인 처리를 합니다.

2.3. 사용자 조회

2.3.1. 인증 토큰 생성

UsernamePasswordAuthenticationToken, 필터가 username/password를 꺼내서 인증용 토큰 객체를 만든다. 임시용 토큰이라서 아직 인증은 되지 않은 상태

2.3.2. 인증 위임

AuthenticationManager, 토큰을 AuthenticationManager로 넘기면, 내부에서 UserDetailsService가 실행되어 loadUserByUsername을 통해 DB에서 사용자 정보를 조회

2.4. 사용자 정보 변환

2.4.1. User -> UserDetails

DB의 사용자 엔티티(User)를 시큐리티에서 사용할 수 있는 형태(UserDetails)로 변환

2.4.2. User vs UserDetails

물론 Authentication 객체에 넘기려면 UserDetails 객체로 넘겨야 하는 이유도 있지만, 우리가 받는 정보에는 날 것의 정보가 들어가 있어, 필요한 정보만 가져가야만 보안에도 유리하다. 그렇기에 User에서 로그인에 필요한 최소 정보만 갖는 UserDetails를 사용한다.

2.5. 비밀번호 검증

PasswordEncoder, 요청한 비밀번호(평문)와 DB의 암호화된 비밀번호(BCryptPasswordEncoder)를 비교한다. 굳이 loadUserByUsername()에서 비밀번호를 확인하지 않고, 나중에 검증하는 이유는 "단일 책임 원칙"을 지키기 위해서라고 생각한다.

2.6. 인증 성공

인증에 성공하면 Authentication 객체(인증된 사용자 정보, 권한 포함)를 생성한다.

2.7. 세션 저장

SecurityContext에 Authentication을 저장해야 이후에도 로그인 유지가 가능하다.

2.8. 보안 어노테이션

이후 추가적으로 설명하지만 어노테이션을 통해 쉽게 웹페이지마다의 권한을 설정한다고 보면 된다.

3. Authentication, @AuthenticationPrincipal

@GetMapping("/test/login")
    public @ResponseBody String testLogin(Authentication authentication, //DI -> downcasting -> userObject //DI(의존성 주입)
                                          @AuthenticationPrincipal PrincipalDetails userDetails) { //DI -> getUser, 원랴는 UserDetails를 받기에 PrincipalDetails로도 받을 수 있음
        System.out.println("/test/login==");
        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal(); //원래는 UserDetail로 DownCasting해서 받아야 하지만, PrincipalDetails이 UserDetail을 implementation하기에 가능
        System.out.println("authentication : "+ principalDetails.getUser());
        System.out.println("userDetails: "+ userDetails.getUser());
        return "세션 정보 확인하기";
    }

Authentication은 UserDetails를 받는만큼 클라이언트의 정보를 확인할 수 있다.

Authentication은 스프링 시큐리티의 핵심 인증 객체입니다. 로그인에 성공하면 SecurityContextHolder에 저장되고 로그인이 계속 유지된다.

Authentication은 다운캐스팅을 통해 정보를 확인할 수 있지만, @AuthenticationPrincipal은 그럴 필요가 없다.

왜 그런지는 추가적으로 조사해본 결과

즉, Authentication이 더 여러 정보를 가지고 있지만, 로그인한 사용자 정보만 간단히 조회하려면 @AuthenticationPrincipal이 사용하기 편리하다.

4. @EnableMethodSecurity

4.1. @EnableGlobalMethodSecurity

Spring Security 6.x부터는 @EnableGlobalMethodSecurity가 Deprecated(사용 중단) 되었고, 대신 @EnableMethodSecurity를 사용한다.

기본적으로 스프링 필터에 @EnableMethodSecurity를 사용한다.

4.2. securedEnabled, @Secured

@Secured 에노테이션을 사용할 수 있다. @Secured의 경우 조건식은 불가능해 권한을 한 가지 걸 수 있다.

4.3. prePostEnabled, @PreAuthorize, @PostAuthorize

@PreAuthorize, @PostAuthorize 애노테이션을 사용할 수 있다. @PreAuthorize, @PostAuthorize의 경우 조건식을 통해 다양한 조건을 사용할 수 있으며, 조건식이 존재한다.

4.4. @Secured vs @PreAuthoriz

단순한 Role 체크만 필요할 때는 @Secured가 더 직관적이기에 사용한다.

5. Trouble Shooting

5.1. @EnableGlobalMethodSecurity -> @EnableMethodSecurity

Spring Security 6.x부터는 @EnableGlobalMethodSecurity가 Deprecated(사용 중단) 되었고, 대신 @EnableMethodSecurity를 사용한다.

6. 마무리

이로써 Spring Boot Security + JWT 프로젝트의 기본 로그인 과정이 완료되었습니다. 다음 단계에서는 OAuth-goole 과정을 진행할 예정입니다.

본 프로젝트는 최주호 님의 「스프링부트 시큐리티 & JWT」 강의를 참고하여 진행하였습니다.

최주호 님의 「스프링부트 시큐리티 & JWT」 강의 git 주소 https://github.com/codingspecialist/-Springboot-Security-OAuth2.0-V3

버전 업데이트 이후 수정본으로 진행하는 git 주소 https://github.com/Solkot/Security_Oauth -> branch마다 저장하면서 진행하고 있습니다. OAuth 전의 과정의 경우 Profile branch에 저장되어 있습니다.

1. 환경설정 (Spring Initializer)

1.1 Spring Initializer 설정

• 사이트 접속: https://start.spring.io/

• Project: Maven

• Language: Java

• Spring Boot Version: (최신 안정 버전)

• Dependencies:

  • Spring Security
  • Spring Web
  • Mustache
  • Lombok

2. Git 설정

터미널로 들어가서 진행하시면 됩니다.

2.1 Git 초기화

git init

2.2 사용자 정보 설정

이미 설정되어 있다면 생략하셔도 됩니다.

git config user.email "이메일 주소"
git config user.name "사용자 이름"

2.3 브랜치 이름 변경

기본 브랜치를 master → main으로 변경합니다.

git branch -M main

2.4 GitHub 저장소 생성

GitHub에서 새 repository를 만듭니다. (예: spring-security-jwt)

2.5 파일 추가 및 커밋

git add .
git commit -m "프로젝트 초기 설정 완료"

3. Mustache 설정 (MVC)

Spring Boot에서는 Mustache 템플릿 엔진을 사용하여 MVC 구조의 View를 구성할 수 있습니다. 기본적으로 src/main/resources/templates 경로에서 .mustache 파일을 자동 인식합니다.

src
 └─ main
    ├─ java
    ├─ resources
    │  ├─ static
    │  └─ templates
    │     └─ index.mustache

해당 위치에 index.html이 와서 mustache로 오도록 진행합니다. Mustache는 서버 사이드 템플릿 엔진으로서, 웹 애플리케이션에서 동적으로 HTML을 생성하는 데 사용됩니다. 물론, Thymleaf나 Mybatis 등 여러가지 엔진이 있어 원하시는 것으로 진행하셔도 무방합니다.

4. SpringFilter chain 적용 전 후

4.1. SpringFilter 적용 전

SpringFilter 적용 전에는 Spring Security에서 제공해주는 창을 및 비밀번호를 통해 인증이 가능하다. 로그아웃의 경우 localhost:8080/logout 을 통해 가능하다.

4.2. SpringFilter 적용 후

SpringFilter가 적용되면 스프링 시큐리티 필터가 필터체인에 등록되고 이전에 제공되었던 것은 해제된다.

5. Trouble Shooting

5.1 WebSecurityConfigurerAdapter → SecurityFilterChain

• WebSecurityConfigurerAdapter는 Spring Security 5.x 시절에 사용되던 방식으로, 현재는 deprecated(사용 권장되지 않음) 상태입니다.
• 대신 SecurityFilterChain 방식으로 변경되었으며, 메서드 체인 기반에서 람다 형식으로 작성하는 것이 권장됩니다.
  • anyMatchers -> requestMatchers
  • .access(hasRole("")) -> .hasRole("") (단수일 경우) .hasAnyRole("", "") (복수일 경우)
  • .formLogin의 경우도 내부 요소는 람다로 따로 처리하도록 변경

예시:

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(AbstractHttpConfigurer::disable)
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/user/**").authenticated()
                        .requestMatchers("/manager/**").hasAnyRole("ADMIN", "MANAGER") //ROLE_ADMIN에서 이제 ROLE_ 같은 접두사는 자동으로 붙기 때문에 사용 X
                        .requestMatchers("/admin/**").hasRole("ADMIN")
                        .anyRequest().permitAll()
                )
                .formLogin(form -> form
                        .loginPage("/login")
                        .permitAll() // 로그인 페이지와 로그인 요청 URL은 누구나 접근 가능하도록 허용

5.2 Lombok 문제 해결

• Lombok 의존성을 추가했음에도 User 엔티티 작성 시 인식 오류가 발생할 수 있습니다.
• IDE에서 annotation processor 설정을 켜거나, 최신 버전 Lombok 의존성을 명시적으로 추가하면 해결됩니다.

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version> <!-- 최신 버전 사용 권장 -->
    <scope>provided</scope>
</dependency>

6. 마무리

이로써 Spring Boot Security + JWT 프로젝트의 기본 환경 구성이 완료되었습니다. 다음 단계에서는 시큐리티 권한 처리를 진행할 예정입니다.

3.0. 서론

• 이번 장에서는 람다 표현식을 어떻게 만들고, 사용하는지, 그리고 어떻게 코드를 간결하게 만들 수 있는지를 설명한다.
• 더불어 자바 8 API에 추가된 중요한 인터페이스와 형식 추론 기능을 확인하고, 메서드 참조와 같은 기법도 다룬다.
• 목표는 간결하고 유연한 코드를 작성하는 방법을 단계적으로 이해하는 것이다.

3.1. 람다란 무엇인가?

람다 표현식은 메서드로 전달할 수 있는 익명 함수를 단순화한 것이다.

3.1.1. 람다 특징

1. 익명성 : 메서드와 달리 이름이 없다.
2. 함수적 성격 : 클래스에 종속되지 않으며, 파라미터 리스트·바디·반환 형식·예외 리스트를 포함한다.
3. 전달 가능 : 메서드 인수로 전달하거나 변수에 저장할 수 있다.
4. 간결성 : 익명 클래스를 구현할 때보다 코드가 훨씬 간단하다.

3.1.2. 람다 구성 요소

1. 파라미터 리스트 : 입력 값 정의
2. 화살표(->) : 파라미터와 바디를 구분
3. 람다 바디 : 실행할 동작, 또는 반환 값

3.1.3. 람다 예제

() -> {}
() -> "Real"
() -> { return "Mario"; }

• return은 단일 표현식일 경우 생략 가능.
• 블록 {}을 사용할 경우 반드시 return을 명시해야 한다.

3.2. 어디에, 어떻게 람다를 사용할까?

람다는 함수형 인터페이스라는 문맥에서만 사용할 수 있다.

3.2.1. 함수형 인터페이스

• 추상 메서드가 단 하나만 있는 인터페이스를 말한다.
• 디폴트 메서드가 여러 개 있어도 상관없다.
• @FunctionalInterface 어노테이션을 붙이면 함수형 인터페이스임을 명시할 수 있으며, 규칙 위반 시 컴파일 오류가 발생한다.

3.2.2. 함수 디스크립터와 시그니처

• 함수 시그니처 : 자바 코드 차원, "메서드 이름 + 매개변수 타입 목록"
• 함수 디스크립터 : JVM 바이트코드 차원, "매개변수 타입 + 반환 타입"
• 함수형 인터페이스의 추상 메서드 시그니처는 곧 람다 표현식의 시그니처이다.

3.3. 실행 어라운드 패턴

3.3.0. 개요

자원 처리(예: 파일 입출력, DB 연결)는

• 자원 열기 → 작업 수행 → 자원 닫기 구조를 반복한다. 이러한 구조를 실행 어라운드 패턴이라고 한다.

3.3.1. 단계별 전개

1. 1단계 – 동작 파라미터화 기억

   • 공통되는 준비와 정리 코드를 재사용하고, 실제 작업 코드만 파라미터화.

2. 2단계 – 함수형 인터페이스 활용

   • 추상 메서드 시그니처에 맞는 인터페이스 정의 후 람다 전달.

3. 3단계 – 동작 실행

   • 전달받은 람다를 실행. 원래는 익명 클래스를 통해 구현 가능.

4. 4단계 – 람다 전달

   • 익명 클래스 대신 람다로 작성해 코드 간소화.

3.4. 함수형 인터페이스 사용

자바 8은 java.util.function 패키지에 다양한 함수형 인터페이스를 제공한다.

3.4.1. Predicate

• 입력 T를 받아 불리언을 반환.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
public <T> List<T> filter(List<T> list, Predicate<T> p) { ... }

3.4.2. Consumer

• 입력 T를 받아 소비하고 반환 값 없음.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
public <T> void forEach(List<T> list, Consumer<T> c) { ... }

3.4.3. Function<T,R>

• 입력 T를 받아 R을 반환.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
public <T,R> List<R> map(List<T> list, Function<T,R> f) { ... }

3.4.4. 기본형 특화

• 제네릭은 참조형만 사용 가능 → 기본형은 박싱/언박싱 발생.
• 박싱된 값은 힙 메모리에 저장 → 비용 발생.
• 자바는 IntPredicate, DoubleFunction 등 기본형 특화 인터페이스 제공.

3.5. 형식 검사, 형식 추론, 제약

• 컴파일러는 람다의 타입을 추론한다.
• 단, 외부 변수를 사용할 때는 final 혹은 사실상 final이어야 한다.
• 이는 메모리 안전성 때문. (지역 변수는 스택에, 람다는 힙에 저장되므로 수명 차이 발생)

3.6. 람다 캡처링과 클로저

3.6.1. 람다 캡처링

람다는 바깥 스코프에 정의된 변수를 자유 변수(free variable)로 참조할 수 있다. 이 과정을 람다 캡처링이라고 한다.

하지만, 자바에서는 지역 변수 캡처에 제약이 있다.

• 지역 변수는 final 또는 사실상 final(값이 변하지 않는)이어야 한다.

• 이는 메모리 안전성 때문이다.

  • 지역 변수는 메서드가 종료되면 스택 프레임과 함께 사라지지만,
  • 람다는 힙에 저장될 수 있어 수명이 길다.
  • 따라서 값이 바뀌면 동기화 문제나 예기치 못한 오류가 발생할 수 있다.

예시 1: final 또는 사실상 final 지역 변수

public class LambdaCaptureExample {
    public static void main(String[] args) {
        String greeting = "Hello"; // 사실상 final (값을 변경하지 않음)

        Runnable r = () -> System.out.println(greeting + ", Lambda!");
        r.run(); // 출력: Hello, Lambda!
    }
}

• greeting은 한 번만 초기화되고 이후 변경되지 않으므로 사실상 final이다.
• 따라서 람다에서 안전하게 캡처 가능하다.

예시 2: 지역 변수 변경 시 컴파일 오류

public class LambdaCaptureExample {
    public static void main(String[] args) {
        String message = "Hi";

        Runnable r = () -> System.out.println(message);

        // message = "Hello"; // 컴파일 오류: 변수는 final 또는 사실상 final이어야 함

        r.run();
    }
}

• message를 람다에서 사용한 후 값을 바꾸려고 하면 컴파일 오류가 발생한다.

예시 3: 클래스 필드와 정적 변수는 변경 가능

public class LambdaCaptureExample {
    private String instanceVar = "Instance";
    private static String staticVar = "Static";

    public void test() {
        Runnable r = () -> {
            System.out.println(instanceVar); // 인스턴스 변수 캡처 가능
            System.out.println(staticVar);   // 정적 변수도 캡처 가능
        };

        r.run();
    }

    public static void main(String[] args) {
        new LambdaCaptureExample().test();
    }
}

• 클래스 필드(instanceVar)와 정적 변수(staticVar)는 힙/메서드 영역에 저장되므로 자유롭게 변경 가능하다.
• 따라서 지역 변수와 달리 final 제약이 없다.

3.6.2. 클로저

클로저(Closure)란 함수가 선언될 당시의 환경(변수 값 포함)을 함께 저장하는 개념이다. 람다는 클로저의 성격을 가지며, 실행 시점에도 선언 당시의 변수를 사용할 수 있다.

예시 4: 클로저 개념 확인

import java.util.function.Function;

public class ClosureExample {
    public static void main(String[] args) {
        int factor = 2;

        Function<Integer, Integer> multiplier = (x) -> x * factor;

        System.out.println(multiplier.apply(5)); // 출력: 10
    }
}

• factor는 람다 외부에서 정의된 지역 변수지만, 람다 안에서 참조 가능하다.
• 이 경우 multiplier는 factor를 캡처하여 클로저 역할을 한다.

예시 5: 클로저와 지역 변수 변경 문제

import java.util.function.Supplier;

public class ClosureExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");

        Supplier<String> supplier = () -> sb.toString();

        sb.append(" World"); // 변경 가능 (참조형 객체)

        System.out.println(supplier.get()); // 출력: Hello World
    }
}

• 객체 참조(StringBuilder)는 final로 선언된 것이 아니라 객체 내부 상태를 바꾼 것이므로 허용된다.
• 즉, "변수 참조"는 final이어야 하지만, "객체 내부 값"은 변경 가능하다.

요약

1. 람다는 바깥 스코프의 변수를 자유롭게 참조할 수 있으며, 이를 람다 캡처링이라 한다.
2. 지역 변수는 final 혹은 사실상 final이어야 한다.
3. 인스턴스 변수와 정적 변수는 자유롭게 변경 가능하다.
4. 람다는 선언 당시의 환경을 저장하여 실행 시점까지 활용할 수 있는데, 이를 클로저라고 한다.
5. 참조형 객체의 내부 상태는 변경 가능하므로 주의해야 한다.

Chapter 2. 동작 파라미터화 코드 전달하기

2.0. 서론

• 동작 파라미터화(Behavior Parameterization) : 아직 실행 방법을 결정하지 않은 코드 블록을 의미한다.
• 이 코드 블록은 나중에 프로그램에서 호출되어 실행을 지연시킬 수 있다.

2.1. 변화하는 요구사항에 대응하기

2.1.1. 첫 번째 시도 : 녹색 사과 필터링

public static List<Apple> filterGreenApples(List<Apple> inventory) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if ("green".equals(apple.getColor())) {
            result.add(apple);
        }
    }
    return result;
}

• 단순히 if 조건문으로 필터링.
• 그러나 요구사항이 변하면(예: 색상별 필터링, 무게 조건 추가 등) 쉽게 대응 불가.

2.1.2. 두 번째 시도 : 색을 파라미터화

public static List<Apple> filterApplesByColor(List<Apple> inventory, String color) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if (color.equals(apple.getColor())) {
            result.add(apple);
        }
    }
    return result;
}

• **색상(color)**을 매개변수로 전달 → 다양한 색상 필터 가능.
• 하지만 무게 기준 등 다른 속성을 필터링할 때는 또 다른 메서드가 필요 → 코드 중복 발생 (DRY 원칙 위배).

2.1.3. 세 번째 시도 : 모든 속성을 조건으로

public static List<Apple> filterApples(List<Apple> inventory, String color, int weight, boolean flag) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if ((flag && color.equals(apple.getColor())) ||
            (!flag && apple.getWeight() > weight)) {
            result.add(apple);
        }
    }
    return result;
}

• 하나의 거대한 필터 메서드를 만들어 모든 조건 처리.
• 하지만 결국 중복 메서드 또는 복잡한 하나의 메서드 → 유지보수 어려움.
• 해결책: 동작 파라미터화.

2.2. 동작 파라미터화

2.2.0. 서론

• 단순히 매개변수를 늘리는 방식이 아닌, 요구사항 변화에 유연하게 대응할 방법 필요.

• Predicate 인터페이스

  • 조건을 추상화 → true / false 반환.

• 전략 디자인 패턴

  • 알고리즘(전략)을 캡슐화하고, 런타임에 선택 가능.

• 따라서, 메서드는 다양한 동작(전략)을 인수로 받아 내부적으로 실행 가능해야 함.

2.2.1. 네 번째 시도 : 추상적 조건으로 필터링

public interface ApplePredicate {
    boolean test(Apple apple);
}

public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate p) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if (p.test(apple)) {
            result.add(apple);
        }
    }
    return result;
}

• **인터페이스(ApplePredicate)**를 정의하고, 이를 구현하는 객체를 전달.
• 메서드의 조건을 외부에서 결정 → 다양한 동작을 전달 가능.
• 즉, 코드 자체를 전달할 수 있게 됨.

2.3. 복잡한 과정 간소화

2.3.0. 서론

• 매번 클래스를 구현 → 인스턴스 생성은 복잡하고 번거로움.
• 자바는 이를 간단히 하기 위해 익명 클래스를 제공.

2.3.1. 익명 클래스

List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
    @Override
    public boolean test(Apple apple) {
        return "red".equals(apple.getColor());
    }
});

• 클래스 선언 + 인스턴스 생성을 동시에 처리.
• 하지만 코드가 여전히 장황하고 가독성이 떨어짐.

2.3.2. 다섯 번째 시도 : 람다 표현식

List<Apple> redApples = filterApples(inventory, apple -> "red".equals(apple.getColor()));

• 자바 8부터는 람다 표현식 지원 → 코드 간결화.

2.3.3. 여섯 번째 시도 : 리스트 형식으로 추상화

public static <T> List<T> filter(List<T> list, Predicate<T> p) {
    List<T> result = new ArrayList<>();
    for (T e : list) {
        if (p.test(e)) {
            result.add(e);
        }
    }
    return result;
}

• 제네릭 메서드 적용 → 다양한 객체 타입에 대해 사용 가능.

2.4. 실전 예제

2.4.1. Comparator로 정렬하기

inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));

• 요구사항에 맞는 Comparator를 전달 → 정렬 동작 유연화.

2.4.2. Runnable로 코드 블록 실행하기

Thread t = new Thread(() -> System.out.println("Hello from another thread!"));
t.start();

• Runnable에 람다 전달 → 스레드 실행 단순화.

2.4.3. GUI 이벤트 처리하기

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Integer> result = executor.submit(() -> 42);

• ExecutorService + Callable

  • 테스크 제출과 실행 과정 분리.
  • 결과값을 비동기적으로 저장 가능.

2.5. 마치며

1. 동작 파라미터화 → 메서드 인수로 다양한 동작을 전달할 수 있음.
2. 변화하는 요구사항에 더 잘 대응 → 유지보수 비용 절감.
3. 자바 8 이전: 익명 클래스 사용 → 코드 장황. 자바 8 이후: 람다 표현식으로 간결화.
4. 자바 API는 정렬, 스레드, 이벤트 처리 등에서 동작 파라미터화를 폭넓게 활용.

Spring Security

1. 커스텀 로그인 & UserDetailsService

1.1. SecurityConfig 확장

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
            .antMatchers("/user/**").authenticated()
            .antMatchers("/manager/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_MANAGER')")
            .antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')")
            .anyRequest().permitAll()
        .and()
        .formLogin()
            .loginPage("/loginForm")          // 사용자 정의 로그인 페이지
            .loginProcessingUrl("/login")     // login 요청을 시큐리티가 낚아채서 로그인 처리
            .defaultSuccessUrl("/");          // 로그인 성공 시 이동 경로
}

핵심: loginProcessingUrl("/login") 등록 시 컨트롤러에 /login을 직접 만들 필요가 없다. Spring Security 필터가 낚아채서 AuthenticationManager를 통해 인증 진행.

1.2. 인증 객체 구조

• Security가 로그인 성공 시 만드는 세션 구조:

  Security Session
   └── Authentication (인증 객체)
        └── UserDetails (PrincipalDetails)

1.3. PrincipalDetails (UserDetails 구현체)

public class PrincipalDetails implements UserDetails {
    private User user;

    public PrincipalDetails(User user) { this.user = user; }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> collect = new ArrayList<>();
        collect.add(() -> user.getRole()); // 권한 반환
        return collect;
    }

    @Override public String getPassword() { return user.getPassword(); }
    @Override public String getUsername() { return user.getUsername(); }
    @Override public boolean isAccountNonExpired() { return true; }
    @Override public boolean isAccountNonLocked() { return true; }
    @Override public boolean isCredentialsNonExpired() { return true; }
    @Override public boolean isEnabled() { return true; }
}

UserDetails 인터페이스를 구현하여 User 엔티티를 시큐리티가 인식할 수 있는 객체로 변환.

1.4. PrincipalDetailsService (UserDetailsService 구현체)

@Service
public class PrincipalDetailsService implements UserDetailsService {
    @Autowired private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User userEntity = userRepository.findByUsername(username);
        if (userEntity != null) {
            return new PrincipalDetails(userEntity);
        }
        return null;
    }
}

시큐리티가 /login 요청을 받으면 내부적으로 loadUserByUsername 실행 → DB 조회 후 PrincipalDetails 반환.

1.5. UserRepository 확장

public interface UserRepository extends JpaRepository<User, Integer> {
    User findByUsername(String username); 
}

규칙 기반 메서드 생성: findByUsername → select * from user where username=?

2. 메서드 단위 권한 처리

2.1. @Secured

• 특정 메서드에 단일 권한만 허용

@EnableGlobalMethodSecurity(securedEnabled = true) // 활성화
@Secured("ROLE_ADMIN") 
public String adminOnly() { return "admin"; }

2.2. @PreAuthorize

• 두 개 이상의 권한 허용 가능

@EnableGlobalMethodSecurity(prePostEnabled = true) // 활성화
@PreAuthorize("hasRole('ROLE_MANAGER') or hasRole('ROLE_ADMIN')")
public String managerOrAdmin() { return "manager"; }

@Secured = 단일 권한, @PreAuthorize = 다중 권한 제어.

3. OAuth2 로그인 준비 (구글 예시)

3.1. 구글 API Console 설정

• 새 프로젝트 생성 → OAuth 동의 화면 외부 설정

• OAuth 클라이언트 ID 발급 (웹 애플리케이션 선택)

• 승인된 리다이렉션 URI:

  http://localhost:8080/login/oauth2/code/google

• 클라이언트 ID & Secret 발급

3.2. dependency 추가

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

3.3. application.yml 설정

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: 발급받은-client-id
            client-secret: 발급받은-client-secret
            scope:
              - email
              - profile

3.4. 로그인 링크 추가

<a href="/oauth2/authorization/google">구글 로그인</a>

/oauth2/authorization/google 경로는 Spring Security OAuth2 Client가 자동 제공.

3.5. SecurityConfig 확장

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
            .antMatchers("/user/**").authenticated()
            .antMatchers("/manager/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_MANAGER')")
            .antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')")
            .anyRequest().permitAll()
        .and()
        .formLogin()
            .loginPage("/loginForm")
            .loginProcessingUrl("/login")
            .defaultSuccessUrl("/")
        .and()
        .oauth2Login()
            .loginPage("/loginForm"); // OAuth2 로그인도 동일한 loginForm 페이지 사용
}

1. Spring Security 기본 동작

• 의존성 추가 시 기본 보안 정책 Spring Security를 의존성에 추가하면 기본적으로 모든 요청이 차단되며, 서버의 모든 페이지 접근은 인증(로그인)이 필요하다. 따라서 SecurityConfig를 커스터마이징해야 원하는 접근 정책을 설정할 수 있음.

2. SecurityConfig (보안 설정)

• @EnableWebSecurity : Spring Security 활성화

• extends WebSecurityConfigurerAdapter : 보안 설정을 재정의할 수 있음

• 주요 설정 예시:

  http.csrf().disable() // CSRF 토큰 검증 비활성화 (개발 초기에 주로 사용)
      .authorizeRequests()
          .antMatchers("/user/**").authenticated() // 인증만 되면 접근 가능
          .antMatchers("/manager/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_MANAGER')")
          .antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')")
          .anyRequest().permitAll() // 그 외는 모두 허용
      .and()
      .formLogin()
          .loginPage("/loginForm"); // 인증 안 된 사용자는 loginForm 페이지로 이동

이렇게 하면 user, manager, admin 경로는 각각 로그인 및 권한이 있어야 접근 가능하고, 나머지(예: index)는 누구나 접근 가능하다.

3. 회원가입 & 로그인 페이지

• loginForm: 로그인 전 보여줄 화면 (기본 /login을 커스터마이징)
• joinForm: 회원가입 폼
• 사용자가 joinForm에서 입력한 데이터를 DB에 저장하여 회원 계정을 생성한다.

4. User 엔티티 설계

• JPA 기반 User 테이블

  @Entity
  public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
  
      private String username;
      private String password;
      private String email;
      private String role; // ROLE_USER, ROLE_ADMIN 등
  
      @CreationTimestamp
      private Timestamp createDate;
  }

• 권한은 ROLE_ prefix를 붙이는 것이 Spring Security 규칙.

5. UserRepository 생성

• JpaRepository<User, Integer> 상속

• 기본 CRUD 사용 가능

  public interface UserRepository extends JpaRepository<User, Integer> {}

6. 회원가입 로직

• 비밀번호 암호화 필요 → BCryptPasswordEncoder 사용

• @Bean 등록하여 IoC 컨테이너에 관리

  @Bean
  public BCryptPasswordEncoder encodePwd() {
      return new BCryptPasswordEncoder();
  }

• 회원가입 시 비밀번호 암호화 후 저장

  @PostMapping("/join")
  public String join(User user) {
      String rawPassword = user.getPassword();
      String encPassword = bCryptPasswordEncoder.encode(rawPassword);
      user.setPassword(encPassword);
      user.setRole("ROLE_USER");
      userRepository.save(user);
      return "redirect:/loginForm"; // 회원가입 완료 후 로그인 페이지로 이동
  }

중요: Spring Security는 로그인 시 입력된 패스워드를 DB에 저장된 암호화된 패스워드와 자동으로 비교하기 때문에, 반드시 BCryptPasswordEncoder로 인코딩해야 로그인 성공 가능.

7. 로그인 처리

• /loginForm → 로그인 화면
• 로그인 요청은 Spring Security가 가로채서 처리함 (컨트롤러에서 직접 처리할 필요 없음)
• UsernamePasswordAuthenticationFilter가 동작하며, DB의 사용자 정보와 비교 후 인증 처리

8. 정리된 흐름

1. 사용자 요청

   • /loginForm → 로그인 화면
   • /joinForm → 회원가입 화면

2. 회원가입

   • 비밀번호를 BCryptPasswordEncoder로 암호화 후 DB 저장
   • 권한은 기본적으로 ROLE_USER

3. 로그인

   • Security가 /login POST 요청을 낚아채 인증 수행
   • DB의 username, password와 입력값 비교

4. 접근 제어

   • user/** → 로그인 필요
   • manager/** → ROLE_ADMIN, ROLE_MANAGER 필요
   • admin/** → ROLE_ADMIN 필요
   • 나머지는 모두 접근 가능

Spring Security는 기본적으로 모든 요청을 차단하지만, SecurityConfig를 통해 인증/권한 정책을 설정할 수 있고, 회원가입 시 반드시 비밀번호를 암호화해야 로그인 인증이 정상적으로 동작한다.

1. 사용 이유

• Git은 버전 관리 시스템이므로 언제든 이전 상태로 되돌릴 수 있습니다.

• 상황에 맞게 선택:

  • git restore → 파일 하나 복구
  • git revert → 특정 commit 취소
  • git reset → 특정 commit 시점으로 시간 되돌리기
  • git switch / git checkout → 다른 branch나 commit으로 이동

2. git restore (파일 복구)

• 파일을 최근 commit 상태 또는 특정 commit 상태로 되돌릴 수 있음.

# 최근 commit 상태로 되돌리기
git restore 파일명  

# 특정 commit 시점으로 복구
git restore --source 커밋아이디 파일명  

# staging 취소
git restore --staged 파일명  

3. git revert (commit 취소)

• 특정 commit의 변경 사항만 안전하게 되돌림.
• 새로운 commit을 생성하므로 협업 환경에서 많이 사용.

# 특정 commit 취소
git revert 커밋아이디  

# 여러 commit 한 번에 취소
git revert 커밋아이디1 커밋아이디2  

# 가장 최근 commit 취소
git revert HEAD  

• merge commit도 revert 가능 (merge 취소 효과).

• 실행 시 Vim 에디터가 열리면:

  • i → 메시지 수정
  • esc → :wq 입력 후 종료

4. git reset (시간 되돌리기)

• 특정 commit 시점으로 "아예" 되돌림.
• 협업 환경에서는 매우 위험 → 개인 로컬에서만 사용 권장.

# 완전히 과거 시점으로 되돌림 (작업폴더도 reset)
git reset --hard 커밋아이디  

# staging area 유지
git reset --soft 커밋아이디  

# staging 해제 (작업 내용은 유지)
git reset --mixed 커밋아이디  

5. branch 단위 되돌리기

• commit이 아니라 branch 단위로 과거 시점으로 돌아가고 싶을 때 사용.

# 특정 commit 시점으로 이동 (detached HEAD 상태)
git checkout 커밋아이디  
# or 최신 방식
git switch --detach 커밋아이디  

# 다시 main 브랜치로 돌아오기
git switch main  

• detached HEAD 상태에서 수정 후 commit 하면, 임시 branch처럼 동작하므로 필요 시 새 branch 생성:

git switch -c 새브랜치명

6. 주의사항

• git reset은 협업 저장소에서 금지
• untracked 파일(git add 안 한 파일)은 reset으로 삭제되지 않음
• untracked 파일까지 삭제하려면:

git clean -fd

요약:

• 파일만 되돌릴 때 → restore
• commit 취소 → revert
• 과거 시점으로 완전 리셋 → reset
• 브랜치/commit 이동 → switch/checkout

1.1. Repository

• Git이 파일 버전을 저장하는 장소.
• .git 폴더가 로컬 저장소(repository).
• 내 컴퓨터에 만든 git 저장소를 의미.

1.2. GitHub

• 온라인 원격 저장소 서비스.
• 로컬 저장소를 원격에 업로드 가능.
• 협업(코드 공유, 협력 개발)에 필수.

1.3. 사용 방법

# 로컬 저장소 생성
git init  

# 기본 브랜치 이름 변경 (master → main)
git branch -M main  

# 로컬 저장소 → 원격 저장소 push
git push -u https://github.com/username/repo.git main  

• -u: 원격 주소 저장, 이후 git push만 입력해도 가능.

1.4. Git 변수 생성 (remote)

# 원격 저장소 주소를 변수(origin)에 저장
git remote add origin https://github.com/username/repo.git  

# 변수 확인
git remote -v  

# push 시 활용
git push -u origin main

1.5. 원격 저장소 내려받기 (clone)

git clone https://github.com/username/repo.git

• 협업 시에는 git init 필요 없음.

1.6. .gitignore

• 불필요한 파일을 원격에 올리지 않도록 설정.

# .gitignore 예시
*.log
node_modules/
.env

2. git clone, pull

2.1. git clone

• 원격 저장소를 복제해서 새로운 작업 환경 생성.

git clone https://github.com/username/repo.git

• 특정 브랜치만 가져오기:

git clone -b feature-branch https://github.com/username/repo.git

2.2. git pull

• 원격 저장소의 최신 변경 내용을 가져와 로컬에 병합.

git pull origin main

• 동작 원리: git fetch + git merge.

2.3. 주의사항

• 원격과 로컬이 다른 경우 git push가 불가.
• 반드시 git pull → git push 순서로 진행.
• 충돌(conflict) 발생 시 수동 해결 필요.

3. Pull Request

3.1. 원격 저장소 브랜치 생성

# 로컬에서 만든 브랜치 push
git push origin feature-branch

• GitHub 웹에서 브랜치 생성도 가능.

3.2. Pull Request (PR)

• 팀 협업 시 코드 병합 전 검토 과정.
• 브랜치 변경사항 → main 병합 요청.

옵션

1. Create a merge commit : 일반 merge (3-way merge).
2. Squash and merge : commit 내역 압축 → main에 1개 commit.
3. Rebase and merge : 브랜치 이력을 main 최신 commit으로 rebase 후 병합.

3.3. 주의사항

• git reset --hard + git push -f로 강제 되돌리기 가능하나, 협업 환경에서는 위험.
• GitHub에서 Revert 버튼 사용 시 "되돌리는 commit"이 생성됨.

4. Git Flow / Trunk-based 전략

4.1. Git 브랜치 전략

• 대표적인 방법론:

  • Git Flow
  • GitHub Flow
  • GitLab Flow
  • Trunk-based Development

4.2. 장점

• 브랜치 관리 용이.
• 팀원이 많아도 개발 절차가 체계적.
• 협업 시 충돌 최소화.

1. 브랜치의 필요성

• 개발 도중 새로운 기능을 추가해야 할 때, 기존 코드를 안전하게 유지하면서 개발 가능.

• 해결 방법: 프로젝트의 복사본 생성 → 새로운 기능 개발 → 원본에 합치기

  • Git에서는 이를 branch 기능으로 쉽게 수행.

2. Git Branch

2.1 브랜치 생성 및 이동

git branch 브랜치이름       # 브랜치 생성
git switch 브랜치이름       # 브랜치 이동

• 기존에는 git checkout 브랜치이름 사용
• 메인 브랜치로 돌아갈 때:

git switch main   # 또는 master, 설정에 따라 다름

2.2 브랜치 상태 확인

git status

• 현재 위치한 브랜치 확인 가능.

2.3 브랜치 그래프 확인

git log --graph --oneline --all

• 브랜치와 커밋 내역을 그래프 형태로 한눈에 확인.

2.4 HEAD

• HEAD : 현재 작업 위치(브랜치)를 의미.

3. 브랜치 병합(Merge)

3.1 기본 Merge

git switch main           # 메인 브랜치로 이동
git merge 브랜치이름       # 브랜치 병합

• 브랜치에서 개발한 내용을 메인 브랜치에 합침.

• 충돌 발생 시 (merge conflict) 주의:

  1. 충돌 파일 열기 → <<<<, ====, >>>> 제거 후 원하는 코드 유지
  2. 수정 완료 후:

git add 파일명
git commit -m "merge conflict 해결"

3.2 협업 시 브랜치 활용

• 여러 명이 동시에 같은 프로젝트를 수정할 때 유용.

• 개발 흐름:

  1. 새로운 기능 → 브랜치 생성 → 개발
  2. 테스트 후 → main 브랜치에 Merge

4. Merge 방식

4.1 3-way Merge

• 브랜치와 기준 브랜치 모두 신규 커밋이 있는 경우 자동 생성되는 새로운 커밋.
• Git의 기본 Merge 방식.

4.2 Fast-forward Merge

• 기준 브랜치에 신규 커밋이 없는 경우 발생.
• Git이 브랜치를 단순히 이어서 병합.

git merge 브랜치명       # Fast-forward merge 자동 수행
git merge --no-ff 브랜치명  # 강제로 3-way merge

4.3 브랜치 삭제

git branch -d 브랜치이름    # 병합 완료 브랜치 삭제
git branch -D 브랜치이름    # 병합되지 않은 브랜치 강제 삭제

5. Rebase & Merge

5.1 Rebase

• 브랜치의 시작점을 다른 커밋으로 옮기는 작업.
• 활용 예:

git switch 신규브랜치
git rebase main
git switch main
git merge 신규브랜치

• 장점: 커밋 내역을 한 줄로 정리 → Fast-forward Merge
• 단점: 브랜치 차이가 크면 충돌 발생 가능.

5.2 Squash & Merge

• 브랜치의 여러 커밋을 하나의 커밋으로 합쳐 main 브랜치에 적용.
• 장점: main 브랜치 커밋 내역 깔끔, 3-way merge보다 단순.

git merge --squash 브랜치명
git commit -m "새 기능 통합"

요약

• 브랜치(branch) : 프로젝트 복사본 생성 → 안전하게 개발 → 메인에 병합

• Merge 방식

  1. 3-way merge : 기본, 양쪽 모두 신규 커밋 존재
  2. Fast-forward merge : 기준 브랜치 신규 커밋 없음
  3. Rebase & merge : 커밋 이력 정리 + 강제 fast-forward
  4. Squash & merge : 브랜치 커밋을 하나로 합쳐 병합

• 협업 시 브랜치를 활용하면 안정적이고 효율적인 개발 가능

1. Git의 필요성

• 단순히 파일을 저장만 해서는 과거 상태로 되돌릴 수 없음.

• 해결 방법:

  1. 매일 파일 복사본을 만들어 보관
  2. 버전 관리 시스템(Git) 사용

Git의 Commit 기능을 활용하면 파일의 현재 상태(스냅샷)를 기록할 수 있으며, 다음과 같은 장점이 있다.

• 과거 특정 시점으로 되돌리기 가능
• 과거 작업 내역 확인 가능
• 안정적인 버전 관리 제공

2. Git 시작하기

2.1 설치 확인

git --version

2.2 사용자 정보 등록

git config --global user.email "사용자이메일@도메인.com"
git config --global user.name "사용자이름"

• 컴퓨터에서 Git을 처음 사용할 때 등록해야 함.
• "누가 Commit했는지" 구분하기 위한 기본 정보 설정.

3. Git 기본 명령어

3.1 저장소 초기화

git init

• 현재 폴더를 Git 저장소로 초기화.

3.2 파일 추적 및 Staging

git add 파일명
git add app.txt app2.txt   # 여러 개 파일
git add .                  # 하위 폴더 전체

• git add : 특정 파일을 **Staging Area(임시 저장소)**에 등록.

3.3 Commit

git commit -m "작업 내용 설명"

• git add 후 최종적으로 저장소에 기록.
• add와 commit을 나눈 이유: 필요 없는 파일은 Commit에서 제외할 수 있기 때문.

3.4 상태 확인

git status

• 어떤 파일이 Staging 되었는지, 수정 여부 확인 가능.

3.5 Commit 내역 확인

git log --all --oneline

• 모든 Commit 내역을 간단히 확인 가능.

3.6 Git의 구조

작업 디렉토리 → Staging Area → Local Repository

• 작업 디렉토리: 실제 파일이 위치
• Staging Area: git add 된 파일들이 모여있는 공간
• Repository: git commit으로 기록된 파일들의 이력 저장소

4. 변경 사항 확인

4.1 git diff

git diff

• 최근 Commit과 현재 파일의 차이점 확인.

단점

• 변경점이 많으면 가독성이 떨어짐
• 단순 Enter, 공백 차이까지 표시됨

조작 키:

• j / k: 스크롤 이동
• q: 종료

4.2 git difftool

git difftool
git difftool 커밋ID
git difftool 커밋ID1 커밋ID2

• 차이점을 시각적으로 보여주는 도구 실행.
• 특정 Commit과 비교하거나, 두 Commit 간 비교 가능.

Vim 조작 키

• h, j, k, l: 방향 이동
• :q, :qa: 종료

5. 추가 도구

• Git Graph (VS Code 확장)

  • Git 기록을 시각적으로 확인할 수 있는 도구
  • 복잡한 git log 없이도 Commit 이력과 브랜치를 쉽게 확인 가능

• Git은 스냅샷 기반 버전 관리 도구

• 핵심 명령어 흐름:

  1. git init (저장소 생성)
  2. git add (Staging Area 등록)
  3. git commit (Repository 저장)

• 변경 사항은 git diff, git difftool로 확인

• VS Code 등에서 Git Graph를 활용하면 가시성 향상

19.1. 네트워크 기초

1) 네트워크, LAN, WAN

• 네트워크: 여러 컴퓨터를 통신 회선으로 연결한 것
• LAN(Local Area Network): 특정 영역(가정, 회사, 건물 등)에 존재하는 컴퓨터 연결
• WAN(Wide Area Network): 여러 LAN을 연결한 것

2) 서버와 클라이언트

• 서버(Server): 서비스를 제공하는 프로그램
• 클라이언트(Client): 서비스를 요청하는 프로그램

3) IP 주소

• 컴퓨터(네트워크 어댑터)의 고유 주소
• 프로그램은 DNS를 통해 도메인 이름을 IP로 변환 후 통신
• 예: 웹 브라우저는 클라이언트로서 DNS에서 IP 조회 후 웹 서버와 통신

4) Port 번호

• 하나의 컴퓨터(IP)에서 여러 서버 프로그램을 구분하기 위해 사용
• 서버는 Port 번호에 바인딩, 클라이언트는 OS가 부여한 동적 포트를 사용

19.2. IP 주소 얻기

자바에서는 java.net.InetAddress 클래스를 사용.

// 로컬 IP 주소 얻기
InetAddress local = InetAddress.getLocalHost();
System.out.println(local.getHostAddress());

// 도메인으로 IP 얻기
InetAddress naver = InetAddress.getByName("www.naver.com");
System.out.println(naver.getHostAddress());

// 하나의 도메인에 여러 IP 등록된 경우
InetAddress[] iaArr = InetAddress.getAllByName("www.google.com");
for (InetAddress ip : iaArr) {
    System.out.println(ip.getHostAddress());
}

19.3. TCP 네트워킹

1) TCP 특징

• 연결형 프로토콜 → 송수신자가 연결된 상태에서 통신
• 데이터가 순서대로 전달되고 손실 없음
• 흔히 TCP/IP라고 부름

2) 자바 TCP 클래스

• ServerSocket: 서버에서 클라이언트 연결 수락
• Socket: 클라이언트 연결 요청 및 양방향 통신

3) TCP 서버 예제

import java.net.*;
import java.io.*;

public class TcpServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(50001)) {
            System.out.println("[서버] 시작됨");

            Socket socket = serverSocket.accept(); // 연결 대기
            InetSocketAddress isa = (InetSocketAddress) socket.getRemoteSocketAddress();
            System.out.println("[서버] 연결됨: " + isa.getHostName());

            // 데이터 수신
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            String message = dis.readUTF();
            System.out.println("[서버] 받은 메시지: " + message);

            // 데이터 전송
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            dos.writeUTF("Hello Client");
            dos.flush();

            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4) TCP 클라이언트 예제

import java.net.*;
import java.io.*;

public class TcpClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 50001)) {
            System.out.println("[클라이언트] 연결 성공");

            // 데이터 전송
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            dos.writeUTF("Hello Server");
            dos.flush();

            // 데이터 수신
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            String response = dis.readUTF();
            System.out.println("[클라이언트] 받은 메시지: " + response);

        } catch (UnknownHostException e) {
            System.out.println("잘못된 IP 주소");
        } catch (IOException e) {
            System.out.println("연결 실패");
        }
    }
}

5) 전체 과정 요약 (TCP)

• 서버

  1. ServerSocket 생성 및 포트 바인딩
  2. accept()로 클라이언트 요청 수락
  3. Socket 통해 데이터 송수신
  4. close()로 연결 종료

• 클라이언트

  1. Socket 생성 (서버 IP + Port)
  2. 서버 연결 요청
  3. Socket 통해 데이터 송수신
  4. close()로 연결 종료

19.4. UDP 네트워킹

특징

• 비연결형 프로토콜 → 연결 과정 없음
• 속도는 빠르지만 순서 보장 안 되고 손실 가능성 있음
• 게임, 동영상 스트리밍 등 실시간성이 중요한 곳에서 사용

자바 UDP 클래스

• DatagramSocket: 송수신에 사용
• DatagramPacket: 전송할 데이터 캡슐화

UDP 예제

// UDP 서버
import java.net.*;

public class UdpServer {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(50001);
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);

        System.out.println("[서버] 수신 대기");
        socket.receive(packet);

        String msg = new String(packet.getData(), 0, packet.getLength(), "UTF-8");
        System.out.println("[서버] 받은 메시지: " + msg);

        socket.close();
    }
}

// UDP 클라이언트
import java.net.*;

public class UdpClient {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket();
        byte[] buf = "Hello UDP".getBytes("UTF-8");

        DatagramPacket packet = new DatagramPacket(
            buf, buf.length, new InetSocketAddress("localhost", 50001));

        socket.send(packet);
        socket.close();
    }
}

• TCP: 연결형, 신뢰성 보장, 순서 유지 → ServerSocket, Socket
• UDP: 비연결형, 속도 우선, 손실 가능 → DatagramSocket, DatagramPacket
• IP 주소: 네트워크 어댑터 단위 고유 주소 (DNS로 변환 가능)
• Port 번호: 하나의 IP에서 여러 서버 프로그램 구분

Chapter 17. 스트림 요소 처리

17.1. 스트림이란?

1. 정의

• 컬렉션 및 배열의 요소를 반복 처리하기 위해 기존에는 for문이나 Iterator를 사용
• Java 8부터는 스트림(Stream)을 이용해 반복 처리 가능
• "스트림"은 데이터 요소들이 하나씩 흘러가며 처리된다는 의미

2. 특징

• 내부 반복자: 처리 속도가 빠르고 병렬 처리에 효율적
• 람다식 지원: 다양한 요소 처리를 간단히 정의 가능
• 파이프라인 구조: 중간 처리와 최종 처리를 연결하여 구성 가능

17.2. 내부 반복자

1. 외부 반복자

• for문, Iterator → 외부에서 직접 요소를 꺼내와 처리
• 개발자가 데이터 추출과 처리 코드를 모두 작성해야 함

2. 내부 반복자

• 스트림은 내부 반복자 방식 사용
• 데이터 처리 방법(람다식)을 컬렉션 내부로 전달하여 내부적으로 반복 처리
• 멀티코어 CPU 활용: 요소를 분배해 병렬 처리 가능
• 따라서 외부 반복자보다 효율적

17.3. 중간 처리와 최종 처리

• 스트림은 여러 단계로 연결 가능 → 이를 스트림 파이프라인이라 함

• 중간 처리: 필터링, 매핑, 정렬 등

• 최종 처리: 반복, 집계(카운트, 합계, 평균 등)

  주의: 최종 처리가 없으면 스트림은 동작하지 않음

• 메소드 체이닝 패턴을 이용하면 코드가 간결해짐

17.4. 리소스로부터 스트림 얻기

1. 스트림 종류

• java.util.stream 패키지 제공
• 부모 인터페이스: BaseStream
• 주요 자식 인터페이스: Stream, IntStream, LongStream, DoubleStream

2. 생성 방법

(1) 컬렉션에서 얻기

Stream<Product> stream = list.stream();
stream.forEach(p -> System.out.println(p));

• Collection.stream()
• Collection.parallelStream()

(2) 배열에서 얻기

• Arrays.stream(T[])
• Stream.of(T[])

String[] arr = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(arr);

(3) 숫자 범위에서 얻기

• IntStream.range(start, end) → end 불포함
• IntStream.rangeClosed(start, end) → end 포함

IntStream.range(1, 5).forEach(System.out::print);   // 1234
IntStream.rangeClosed(1, 5).forEach(System.out::print); // 12345

(4) 파일에서 얻기

Path path = Paths.get("data.txt");
Stream<String> stream = Files.lines(path, Charset.defaultCharset());
stream.forEach(System.out::println);
stream.close();

(5) 기타

• Files.list(Path) → 디렉토리 내 경로 스트림
• Random.ints(), Random.longs(), Random.doubles() → 랜덤 수 스트림

17.5. 요소 걸러내기 (Filtering)

주요 메소드

1. distinct(): 중복 제거

2. filter(): 조건에 맞는 요소만 걸러냄

   • Stream.filter(Predicate<T>)
   • IntStream.filter(IntPredicate)
   • LongStream.filter(LongPredicate)
   • DoubleStream.filter(DoublePredicate)

함수형 인터페이스 (람다식 사용 가능)

• Predicate<T>: boolean test(T t)
• IntPredicate: boolean test(int value)
• LongPredicate: boolean test(long value)
• DoublePredicate: boolean test(double value)

17.6. 요소 변환 (Mapping)

• 스트림 요소를 다른 형태로 변환하는 중간 처리 기능

1. 요소 → 다른 요소

• map(Function<T,R>)
• mapToInt(ToIntFunction<T>)
• mapToLong(ToLongFunction<T>)
• mapToDouble(ToDoubleFunction<T>)

2. 기본 타입 변환

• asLongStream() → int → long
• asDoubleStream() → int/long → double
• boxed() → 기본 타입 → Wrapper 클래스

3. 다중 요소 변환 (flatMap)

• 하나의 요소를 여러 개의 요소로 변환

List<String> list = Arrays.asList("a b c", "d e f");
list.stream()
    .flatMap(str -> Arrays.stream(str.split(" ")))
    .forEach(System.out::println);

17.7. 요소 정렬 (Sorting)

1. 주요 메소드

• Stream<T> sorted() → 기본 Comparable 기준 정렬
• Stream<T> sorted(Comparator<T>) → 지정된 Comparator 기준 정렬
• IntStream.sorted(), LongStream.sorted(), DoubleStream.sorted() → 오름차순 정렬

2. 객체 정렬

• 객체가 Comparable을 구현해야 sorted() 사용 가능
• 내림차순 정렬: Comparator.reverseOrder()

3. Comparator 이용

studentList.stream()
    .sorted((s1, s2) -> Integer.compare(s1.getScore(), s2.getScore()))
    .forEach(System.out::println);

17.8. 요소를 하나씩 처리 (루핑)

• 최종 처리 기능 중 하나는 루핑(looping)
• 단순히 요소를 반복해서 처리할 때 사용

메소드

• forEach(Consumer<T> action) → 스트림의 모든 요소를 순차적으로 처리
• forEachOrdered(Consumer<T> action) → 병렬 스트림 사용 시에도 순서를 보장

List<String> list = Arrays.asList("a", "b", "c");
list.stream().forEach(System.out::println);

17.9. 요소 조건 만족 여부 (매칭)

• 스트림의 요소들이 특정 조건을 만족하는지 여부를 검사

메소드

• boolean allMatch(Predicate<T>) → 모든 요소가 조건을 만족하면 true
• boolean anyMatch(Predicate<T>) → 하나라도 조건을 만족하면 true
• boolean noneMatch(Predicate<T>) → 모든 요소가 조건을 만족하지 않으면 true

List<Integer> list = Arrays.asList(2, 4, 6);
boolean result = list.stream().allMatch(n -> n % 2 == 0);
System.out.println(result); // true

17.10. 요소 기본 집계

• 집계(Aggregate): 스트림의 최종 처리 기능 중 하나
• 카운팅, 합계, 평균, 최대값, 최소값 등을 구함

메소드

• long count()
• Optional<T> max(Comparator<T>)
• Optional<T> min(Comparator<T>)
• OptionalDouble average()
• sum() (IntStream, LongStream, DoubleStream 전용)

IntStream stream = IntStream.of(1, 2, 3, 4, 5);
int sum = stream.sum();
System.out.println(sum); // 15

17.11. 요소 커스텀 집계 (reduce)

• reduce() 메소드를 이용해 직접 정의한 방법으로 집계 가능

메소드 형태

• Optional<T> reduce(BinaryOperator<T> accumulator)
• T reduce(T identity, BinaryOperator<T> accumulator)

예제

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

// 합계 구하기 (초기값 0)
int sum = list.stream()
              .reduce(0, (a, b) -> a + b);
System.out.println(sum); // 15

17.12. 요소 수집 (collect)

• 스트림 요소들을 원하는 자료구조로 수집할 때 사용

주요 메소드

• Collectors.toList()
• Collectors.toSet()
• Collectors.toMap(keyMapper, valueMapper)
• Collectors.joining(delimiter)
• Collectors.groupingBy(Function<T,K>) → 그룹핑
• Collectors.partitioningBy(Predicate<T>) → 조건에 따라 분할

예제

List<String> names = Arrays.asList("Kim", "Lee", "Park");

// 리스트로 수집
List<String> result = names.stream()
                           .filter(n -> n.length() >= 3)
                           .collect(Collectors.toList());

System.out.println(result); // [Kim, Lee, Park]

17.13. 요소 병렬 처리

• 스트림은 내부적으로 ForkJoinPool을 사용하여 병렬 처리 지원
• 데이터가 많고 CPU 코어가 여러 개일 경우 성능 향상 가능

병렬 처리 방법

• parallelStream() → 컬렉션에서 병렬 스트림 생성
• stream().parallel() → 기존 스트림을 병렬 스트림으로 변환

List<String> list = Arrays.asList("a", "b", "c", "d");

// 병렬 처리 (순서 보장 안 됨)
list.parallelStream().forEach(System.out::println);

// 순서 보장 병렬 처리
list.parallelStream().forEachOrdered(System.out::println);

• 루핑: forEach, forEachOrdered
• 매칭: allMatch, anyMatch, noneMatch
• 기본 집계: count, sum, average, max, min
• 커스텀 집계: reduce()
• 수집: collect(), Collectors API 활용
• 병렬 처리: parallelStream(), parallel()

Chapter 16. 람다식

16.1. 람다식이란?

1. 함수형 프로그래밍

• 정의: 함수를 정의하고 이 함수를 데이터 처리부에 전달하여 데이터를 처리하는 기법
• 데이터 처리부는 데이터만 보유하고 있으며, 처리 방법은 외부에서 제공된 함수에 의존
• 데이터 처리의 다형성: 제공되는 함수에 따라 처리 결과가 달라지는 것이 특징

2. 람다식

• 자바는 람다식을 **익명 구현 객체(인터페이스 구현 객체)**로 변환
• 따라서 람다식은 인터페이스 타입의 매개변수로 대입될 수 있음

3. 함수형 인터페이스

• 인터페이스에 추상 메소드가 단 하나만 존재할 경우, 이를 함수형 인터페이스라고 함
• 함수형 인터페이스는 람다식으로 표현 가능

4. @FunctionalInterface

• 인터페이스가 함수형 인터페이스임을 보장하기 위해 @FunctionalInterface 어노테이션을 사용
• 선택 사항이지만, 컴파일 시 추상 메소드가 하나인지 검사하여 정확한 함수형 인터페이스 작성 가능

// 예시
(x, y) -> { 처리 내용 }

참고: 객체를 하나 더 만드는 이유는 main에서 직접 구현 객체를 생성하지 않고, 별도의 객체에서 구현 객체를 받아 람다식을 구현하기 위함이다.

16.2. 매개변수가 없는 람다식

작성 방식

1. 여러 실행문

   () -> { 실행문1; 실행문2; }

2. 실행문이 하나일 경우

   () -> 실행문

예시

() -> System.out.println("Hello Lambda");

16.3. 매개변수가 있는 람다식

• 매개변수 선언 시 타입은 생략 가능
• var 사용도 가능하지만 일반적으로는 타입 생략 방식을 사용

작성 방식

1. 타입 명시

   (타입 매개변수, ...) -> 실행문
   (타입 매개변수, ...) -> { 실행문; 실행문; }

2. var 사용

   (var 매개변수, ...) -> 실행문
   (var 매개변수, ...) -> { 실행문; 실행문; }

3. 타입 생략

   (매개변수, ...) -> 실행문
   (매개변수, ...) -> { 실행문; 실행문; }

4. 매개변수가 하나일 경우 괄호 생략 가능

   매개변수 -> 실행문

예시

word -> System.out.println(word);

16.4. 리턴값이 있는 람다식

• 함수형 인터페이스의 추상 메소드에 리턴값이 있을 경우 사용

작성 방식

1. 여러 실행문

   (매개변수, ...) -> { 실행문; return 값; }

2. return 문 하나만 있을 경우

   (매개변수, ...) -> 값

• return 문 하나만 있으면 중괄호와 return 키워드 생략 가능

예시

(x, y) -> sum(x, y)

16.5. 메소드 참조

• 정의: 메소드를 직접 참조하여 불필요한 매개변수를 제거하는 기법

예시

(left, right) -> Math.max(left, right)

Math::max

1. 정적 메소드와 인스턴스 메소드 참조

• 정적 메소드 참조

  클래스 :: 메소드
  Computer :: staticMethod

• 인스턴스 메소드 참조

  참조변수 :: 메소드
  com :: instanceMethod

2. 매개변수의 메소드 참조

(a, b) -> a.instanceMethod(b)

클래스 :: instanceMethod

16.6. 생성자 참조

• 생성자를 참조한다는 것은 객체를 생성하는 것을 의미
• 람다식이 단순히 객체 생성만 한다면, 생성자 참조로 대체 가능

예시

(a, b) -> { return new 클래스(a, b); }

클래스 :: new

• 생성자가 오버로딩된 경우, 함수형 인터페이스의 추상 메소드 매개변수 개수와 타입에 맞는 생성자가 실행됨

Chapter 15. 컬렉션 자료구조

15.1. 컬렉션 프레임워크

자바 컬렉션 프레임워크는 객체를 효율적으로 저장·검색·삭제할 수 있도록 자료구조를 제공한다. 핵심 인터페이스는 Collection과 Map이다.

1. Collection

• List (ArrayList, Vector, LinkedList) : 저장 순서를 유지, 중복 저장 가능
• Set (HashSet, TreeSet) : 저장 순서 유지 안 함, 중복 저장 불가

2. Map

• (HashMap, Hashtable, TreeMap, Properties) : 키-값(Entry)으로 저장, 키는 중복 저장 불가, 값은 중복 가능

15.2. List Collection

특징

• 객체 저장 시 인덱스가 부여된다.
• 인덱스로 검색·삭제 가능.
• 객체의 번지를 저장하므로 같은 객체를 중복 저장할 수 있다.
• null 저장 가능.

주요 메소드

• 추가

  • boolean add(E e) : 맨 끝에 추가
  • void add(int index, E element) : 인덱스에 추가
  • E set(int index, E element) : 지정 인덱스의 객체를 변경

• 검색

  • boolean contains(Object o) : 포함 여부
  • boolean isEmpty() : 비었는지 확인
  • int size() : 저장된 객체 수
  • E get(int index) : 인덱스의 객체 반환

• 삭제

  • void clear() : 전체 삭제
  • E remove(int index) : 인덱스의 객체 삭제
  • boolean remove(Object o) : 해당 객체 삭제

1) ArrayList

• 크기 제한 없이 객체 저장 가능.
• 삭제 시 뒤의 모든 인덱스를 앞으로 당김 → 삽입/삭제가 빈번하면 성능 저하.
• 선언 예시:

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
System.out.println(list.get(0)); // A

2) Vector

• 내부 구조는 ArrayList와 동일.
• 동기화(synchronized) 되어 있어 멀티스레드 환경에서 안전.

List<Integer> vector = new Vector<>();
vector.add(1);
vector.add(2);
System.out.println(vector.size()); // 2

3) LinkedList

• 인접 객체를 체인(링크) 형태로 연결.
• 삽입/삭제 시 인덱스 이동이 없어 빠르다.

List<String> linkedList = new LinkedList<>();
linkedList.add("X");
linkedList.add("Y");
linkedList.remove("X");
System.out.println(linkedList); // [Y]

15.3. Set 컬렉션

특징

• 저장 순서 유지 안 됨.
• 중복 저장 불가, null은 1개 가능.
• 구현체: HashSet, LinkedHashSet, TreeSet.

주요 메소드

• 추가

  • boolean add(E e) : 성공 시 true, 중복 시 false

• 검색

  • boolean contains(Object o)
  • boolean isEmpty()
  • int size()
  • Iterator<E> iterator() : 반복자 획득

• 삭제

  • void clear()
  • boolean remove(Object o)

1) HashSet

• hashCode() 값과 equals() 값이 같으면 같은 객체로 간주.

Set<String> set = new HashSet<>();
set.add("Java");
set.add("Java"); // 중복 저장 안 됨
System.out.println(set.size()); // 1

2) Iterator

• Set은 인덱스로 접근 불가 → 반복자 사용

Set<String> set = new HashSet<>();
set.add("A");
set.add("B");

Iterator<String> iter = set.iterator();
while (iter.hasNext()) {
    String element = iter.next();
    System.out.println(element);
}

Iterator 메소드

• boolean hasNext() : 다음 요소 존재 여부
• E next() : 다음 요소 반환
• void remove() : 최근 반환한 객체 삭제

15.4. Map 컬렉션

특징

• Key-Value 쌍(Entry) 형태 저장.
• 키 중복 불가, 값 중복 가능.
• 같은 키로 저장하면 기존 값이 덮어쓰기 됨.

주요 메소드

• 추가

  • V put(K key, V value)

• 검색

  • boolean containsKey(Object key)
  • boolean containsValue(Object value)
  • boolean isEmpty()
  • int size()
  • Set<Map.Entry<K,V>> entrySet()
  • Set<K> keySet()
  • Collection<V> values()

• 삭제

  • void clear()
  • V remove(Object key)

1) HashMap

• hashCode()와 equals() 기준으로 동일 키 여부 판단.

Map<Integer, String> map = new HashMap<>();
map.put(1, "Java");
map.put(2, "Python");
System.out.println(map.get(1)); // Java

2) Hashtable

• HashMap과 구조 동일.
• 동기화된 메소드 제공 → 멀티스레드 환경에서 안전.

Map<String, String> table = new Hashtable<>();
table.put("id", "admin");
System.out.println(table.containsKey("id")); // true

3) Properties

• Hashtable의 하위 클래스.
• 문자열(Key-Value) 쌍만 저장.
• 주로 설정 파일(.properties) 로 사용됨.

Properties props = new Properties();
props.setProperty("username", "admin");
props.setProperty("password", "1234");

System.out.println(props.getProperty("username")); // admin

15.5. 검색 기능을 강화시킨 컬렉션

1) TreeSet

• 이진 트리 기반의 Set 컬렉션.
• 객체를 저장하면 자동 정렬된다. (기본은 오름차순)

TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);

System.out.println(treeSet); // [1, 2, 3]

2) TreeMap

• 이진 트리 기반의 Map 컬렉션.
• TreeSet과 달리 키-값(Entry) 를 저장.
• 저장 시 키를 기준으로 자동 정렬됨.

TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(2, "B");
treeMap.put(1, "A");
treeMap.put(3, "C");

System.out.println(treeMap); // {1=A, 2=B, 3=C}

3) Comparable & Comparator

• TreeSet과 TreeMap에 저장되는 객체는 자동 정렬되며, 정렬 기준은 객체가 Comparable 인터페이스를 구현해야 한다.
• 정렬 기준을 외부에서 부여하려면 Comparator 구현 객체를 제공한다.

(1) Comparable

• 객체 자체에 **비교 기준(자연 순서)**을 구현.

• int compareTo(T o)

  • 같으면 0
  • 작으면 음수
  • 크면 양수

public class Person implements Comparable<Person> {
    int age;
    public Person(int age) { this.age = age; }

    @Override
    public int compareTo(Person o) {
        return Integer.compare(this.age, o.age);
    }
}

(2) Comparator

• Comparable을 구현하지 않은 객체라도, 외부 비교자(Comparator) 를 제공하면 정렬 가능.

• int compare(T o1, T o2)

  • 같으면 0
  • 앞에 오게 하려면 음수
  • 뒤에 오게 하려면 양수

public class Fruit {
    int price;
    public Fruit(int price) { this.price = price; }
}

public class FruitComparator implements Comparator<Fruit> {
    @Override
    public int compare(Fruit o1, Fruit o2) {
        return Integer.compare(o1.price, o2.price);
    }
}

// 사용 예시
TreeSet<Fruit> set = new TreeSet<>(new FruitComparator());
set.add(new Fruit(3000));
set.add(new Fruit(1000));
set.add(new Fruit(2000));

15.6. LIFO, FIFO 컬렉션

자바는 스택(LIFO) 과 큐(FIFO) 자료구조를 제공한다.

1) Stack

• Stack 클래스는 LIFO(후입선출) 자료구조.

Stack<String> stack = new Stack<>();
stack.push("A");
stack.push("B");
System.out.println(stack.pop());  // B
System.out.println(stack.peek()); // A

주요 메소드

• E push(E item) : 객체 저장
• E pop() : 맨 위 객체 꺼내기
• E peek() : 맨 위 객체 확인 (삭제 안 함)
• boolean isEmpty() : 비었는지 여부
• void clear() : 전체 삭제

2) Queue

• Queue 인터페이스는 FIFO(선입선출) 구조.
• 주로 LinkedList가 구현체로 사용된다.

Queue<String> queue = new LinkedList<>();
queue.offer("A");
queue.offer("B");
System.out.println(queue.poll()); // A
System.out.println(queue.poll()); // B

주요 메소드

• boolean offer(E e) : 객체 삽입
• E poll() : 객체 꺼내기

15.7. 동기화된 컬렉션

• 대부분의 컬렉션(ArrayList, HashSet, HashMap)은 동기화 미지원 → 멀티스레드 환경에서 안전하지 않음.
• Vector, Hashtable은 동기화 지원.
• 필요 시 Collections.synchronizedXXX() 메소드로 동기화된 컬렉션을 생성 가능.

// 동기화된 List
List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());

// 동기화된 Set
Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());

// 동기화된 Map
Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());

15.8. 수정할 수 없는 컬렉션

• 불변(immutable) 컬렉션 → 요소 추가/삭제 불가.
• 데이터 변경이 필요 없는 경우 안전하게 사용 가능.

1) of() 메소드

List<String> list = List.of("A", "B", "C");
Set<Integer> set = Set.of(1, 2, 3);
Map<Integer, String> map = Map.of(1, "One", 2, "Two");

2) copyOf() 메소드

• 기존 컬렉션을 복사하여 불변 컬렉션 생성.

List<String> origin = new ArrayList<>();
origin.add("X");
List<String> immutableList = List.copyOf(origin);

3) 배열로 생성

String[] arr = {"A", "B", "C"};
List<String> immutableList = Arrays.asList(arr);

Chapter 14. 멀티스레드

14.1 멀티 스레드 개념

• 프로세스(Process): 운영체제가 실행 중인 프로그램.
• 멀티태스킹(Multi-Tasking): 두 개 이상의 작업을 동시에 처리하는 것. (반드시 멀티 프로세스일 필요는 없음)
• 스레드(Thread): 코드 실행의 최소 단위(흐름).

멀티 프로세스 vs 멀티 스레드

• 멀티 프로세스: 독립적 실행. 하나가 오류 나도 다른 프로세스에 영향 없음.
• 멀티 스레드: 프로세스 내부에서 동작. 하나의 스레드 예외 발생 시 전체 프로세스 종료 위험.
• 활용 예시: 서버에서 다수의 클라이언트 요청 처리.

14.2 메인 스레드

• 모든 자바 프로그램은 메인 스레드(main 메소드)에서 시작.
• main() 코드 실행 후 return을 만나면 종료.

싱글 스레드 vs 멀티 스레드

• 싱글 스레드: 메인 스레드 종료 = 프로세스 종료.
• 멀티 스레드: 메인 스레드가 종료돼도 다른 스레드가 실행 중이면 프로세스는 종료되지 않음.

public class MainThreadExample {
    public static void main(String[] args) {
        Thread worker = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("작업 스레드 실행 중: " + i);
                try { Thread.sleep(500); } catch (InterruptedException e) {}
            }
        });
        worker.start();
        System.out.println("메인 스레드 종료"); // 메인 스레드가 끝나도 worker가 남아있음
    }
}

14.3 작업 스레드 생성과 실행

• 멀티스레드로 동작하는 프로그램을 개발하려면, 먼저 몇 개의 작업을 병렬로 실행할지 결정하고 작업별로 스레드를 생성해야 한다.

• 자바 프로그램은 항상 메인 스레드가 존재하므로, 메인 작업 이외에 실행할 추가 작업의 수만큼 스레드를 생성하면 된다.

• 자바에서는 작업 스레드도 객체로 관리되므로, 스레드를 정의하려면 Runnable을 구현하거나 Thread를 상속하는 등의 클래스(혹은 익명 구현)가 필요하다.

  1. Thread + Runnable 사용

class Task implements Runnable {
    @Override
    public void run() {
        System.out.println("작업 스레드 실행!");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        Runnable task = new Task();
        Thread thread = new Thread(task);
        thread.start(); // run() 직접 호출이 아니라 start()로 실행
    }
}

익명 클래스 활용:

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 Runnable 실행!");
    }
});
thread.start();

람다식 활용 (자주 사용됨):

Thread thread = new Thread(() -> {
    System.out.println("람다식으로 실행!");
});
thread.start();

2. Thread 클래스 상속

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread 상속 실행!");
    }
}

public class ExtendThreadExample {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

14.4 스레드 이름

• 기본 이름: main, Thread-0, Thread-1 …
• 이름 변경: setName("이름")
• 현재 실행 스레드 확인: Thread.currentThread()

public class ThreadNameExample {
    public static void main(String[] args) {
        Thread mainThread = Thread.currentThread();
        System.out.println("메인 스레드 이름: " + mainThread.getName());

        Thread worker = new Thread(() -> {
            System.out.println("작업 스레드 실행: " +
                Thread.currentThread().getName());
        });
        worker.setName("Worker-1");
        worker.start();
    }
}

14.5 스레드 상태

스레드의 주요 상태:

• NEW → 객체 생성됨 (new Thread())
• RUNNABLE(실행 대기) → start() 호출 시 진입
• RUNNING(실행) → CPU 점유 시
• WAITING/ TIMED_WAITING(일시 정지) → sleep(), join(), wait()
• TERMINATED(종료) → run() 종료

상태 전환 메소드

• 일시 정지

  • sleep(long millis) → 지정 시간 동안 정지 후 자동 대기 상태
  • join() → 특정 스레드 종료까지 대기
  • wait() → 동기화 블록 내 정지

• 재실행

  • interrupt() → InterruptedException 발생시켜 복귀
  • notify(), notifyAll() → wait() 상태 해제

• 양보

  • yield() → 실행 상태 → 실행 대기 상태 전환

예제: sleep() & join()

public class JoinExample {
    public static void main(String[] args) {
        Thread sumThread = new Thread(() -> {
            int sum = 0;
            for (int i = 1; i <= 5; i++) {
                sum += i;
                try { Thread.sleep(500); } catch (InterruptedException e) {}
            }
            System.out.println("합계: " + sum);
        });

        sumThread.start();
        try {
            sumThread.join(); // sumThread가 끝날 때까지 main 대기
        } catch (InterruptedException e) {}

        System.out.println("메인 스레드 종료");
    }
}

14.6 스레드 동기화 (synchronized)

• 여러 스레드가 하나의 공유 객체를 동시에 접근하면 데이터 불일치 문제가 발생할 수 있음.
• 이를 방지하기 위해 한 스레드가 작업하는 동안 다른 스레드가 접근하지 못하도록 객체 잠금(lock) 필요.
• 자바는 synchronized 키워드로 동기화 메소드 또는 동기화 블록을 제공.

동기화 메소드

public class SharedCounter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SyncMethodExample {
    public static void main(String[] args) throws InterruptedException {
        SharedCounter counter = new SharedCounter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start(); t2.start();
        t1.join(); t2.join();

        System.out.println("최종 카운트: " + counter.getCount()); // 항상 2000
    }
}

동기화 블록

public void add(int value) {
    // 여러 스레드가 접근 가능한 영역
    synchronized (this) {
        // 단 하나의 스레드만 실행 가능
        count += value;
    }
    // 다시 여러 스레드 접근 가능
}

wait() & notify() 활용 (교대 작업)

• wait(): 현재 스레드를 일시 정지 상태로 보냄.
• notify(): 대기 중인 다른 스레드 하나를 깨움.
• 반드시 동기화 블록 내에서 사용해야 함.

class WorkObject {
    public synchronized void methodA() {
        System.out.println("ThreadA 실행");
        notify();  // 상대 스레드 깨움
        try { wait(); } catch (InterruptedException e) {}
    }
    public synchronized void methodB() {
        System.out.println("ThreadB 실행");
        notify();
        try { wait(); } catch (InterruptedException e) {}
    }
}

public class WaitNotifyExample {
    public static void main(String[] args) {
        WorkObject work = new WorkObject();

        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 5; i++) work.methodA();
        });

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 5; i++) work.methodB();
        });

        threadA.start();
        threadB.start();
    }
}

14.7 스레드 안전 종료

스레드는 run() 종료 시 자동으로 끝남. 하지만 즉시 멈춰야 할 경우 안전 종료가 필요. stop() 메소드는 위험하므로 사용하지 않음.

방법 1: 조건 변수 활용

public class SafeStopThread extends Thread {
    private volatile boolean stop = false;

    public void setStop(boolean stop) {
        this.stop = stop;
    }

    @Override
    public void run() {
        while (!stop) {
            System.out.println("스레드 실행 중...");
        }
        System.out.println("자원 정리 후 종료");
    }

    public static void main(String[] args) throws InterruptedException {
        SafeStopThread thread = new SafeStopThread();
        thread.start();
        Thread.sleep(1000);
        thread.setStop(true);
    }
}

방법 2: interrupt() 활용

public class InterruptExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                while (true) {
                    System.out.println("작업 중...");
                    Thread.sleep(200); // 일시 정지 상태
                }
            } catch (InterruptedException e) {
                System.out.println("인터럽트 발생, 안전 종료");
            }
        });

        thread.start();
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        thread.interrupt(); // 강제 종료 유도
    }
}

14.8 데몬 스레드

• 데몬 스레드는 주 스레드의 작업을 보조하는 역할을 수행하며, 주 스레드가 종료되면 데몬 스레드도 자동으로 종료된다.
• 스레드를 데몬으로 만들려면, 해당 스레드 객체에 setDaemon(true)를 호출하면 된다.
• 데몬 스레드는 모든 작업 스레드가 종료되면 강제로 종료되며, 주로 백그라운드 작업에 활용된다.
• 스레드를 생성한 후 데몬 스레드로 선언하여 실행하면 된다.

public class DaemonExample {
    public static void main(String[] args) {
        Thread autoSave = new Thread(() -> {
            while (true) {
                System.out.println("자동 저장 실행...");
                try { Thread.sleep(500); } catch (InterruptedException e) {}
            }
        });
        autoSave.setDaemon(true); // 데몬 스레드 지정
        autoSave.start();

        try { Thread.sleep(2000); } catch (InterruptedException e) {}
        System.out.println("메인 종료 → 데몬 스레드도 종료됨");
    }
}

14.9 스레드 풀 (Thread Pool)

• 병렬 작업으로 인해 스레드가 과도하게 생성되는 것을 방지하기 위해 스레드 풀을 사용하는 것이 좋다.
• 스레드 풀은 작업 처리를 위해 제한된 개수의 스레드를 유지하고, 작업 큐에 들어오는 작업을 스레드가 하나씩 처리하는 방식으로 운영된다.
• 작업 처리가 끝난 스레드는 다시 큐에서 새로운 작업을 가져와 처리한다.

1. 스레드 풀 생성

• 자바는 java.util.concurrent 패키지에서 ExecutorService 인터페이스와 Executors 클래스를 제공하여 스레드 풀을 쉽게 생성할 수 있다.
• Executors의 정적 메소드를 사용하면 간단히 ExecutorService 구현 객체를 만들 수 있다.

newCachedThreadPool()

• 초기 스레드 수와 코어 수는 0이며, 작업 개수가 많아지면 필요한 만큼 새 스레드를 생성하여 처리한다.
• 60초 동안 작업이 없으면 해당 스레드를 풀에서 제거한다.

newFixedThreadPool(n)

• 초기 스레드 수는 0이며, 최대 n개의 스레드를 생성하여 작업을 처리한다.
• 생성된 스레드는 제거되지 않고 계속 유지된다.

2. 스레드 풀 종료

• 스레드 풀의 스레드는 기본적으로 데몬 스레드가 아니므로, main 스레드가 종료되어도 작업이 남아있으면 계속 실행 상태로 남는다.
• 따라서 스레드 풀을 종료하려면 ExecutorService의 다음 메소드 중 하나를 호출해야 한다.

1. shutdown() : 현재 처리 중인 작업과 큐에 대기 중인 모든 작업을 마친 후 스레드 풀 종료
2. shutdownNow() : 현재 실행 중인 작업을 인터럽트하여 강제로 종료하고, 큐에 남아 있는 미처리 작업 목록을 반환

• 남아 있는 작업을 마무리한 후 종료하려면 shutdown()을, 강제 종료할 경우에는 shutdownNow()를 호출하면 된다.

3. 작업 생성과 처리 요청

• 하나의 작업은 Runnable 또는 Callable 구현 객체로 표현할 수 있다.
• Runnable은 작업 완료 후 반환값이 없으며, Callable은 작업 완료 후 결과 값을 반환한다.
• Callable의 반환 타입은 Callable<T>에서 지정한 T 타입과 동일해야 한다.
• 작업 처리 요청이란, ExecutorService의 작업 큐에 Runnable 또는 Callable 객체를 넣는 행위를 의미한다.

스레드 풀 예제

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // Runnable 작업 제출
        executor.execute(() -> {
            System.out.println("Runnable 작업 실행: " + Thread.currentThread().getName());
        });

        // Callable 작업 제출
        Future<Integer> future = executor.submit(() -> {
            int sum = 0;
            for (int i = 1; i <= 5; i++) sum += i;
            return sum;
        });

        try {
            System.out.println("Callable 결과: " + future.get());
        } catch (Exception e) { e.printStackTrace(); }

        executor.shutdown(); // 남은 작업 끝내고 종료
    }
}

Chapter 13. 제네릭 (Generics)

13.1. 제네릭 기본 개념

• 제네릭(Generic): 아직 결정되지 않은 타입을 파라미터로 처리하고, 실제 사용할 때 구체적인 타입으로 대체하는 기능.

• 타입 파라미터 기호: <T>

  • T는 타입 변수(Type Parameter) → 객체 생성 시점에 실제 타입으로 치환됨.

• 타입 파라미터는 클래스/인터페이스만 가능 (기본 타입 불가).

  • 기본 타입을 사용하려면 래퍼 클래스(Integer, Double …) 를 활용해야 함.

// 제네릭 클래스 정의
public class Box<T> {
    public T content;
}

// 사용 예제
Box<String> strBox = new Box<>();
strBox.content = "Hello Generics";

Box<Integer> intBox = new Box<>();
intBox.content = 100;

13.2. 제네릭 타입

• 제네릭 타입(Generic Type): 결정되지 않은 타입을 파라미터로 가지는 클래스/인터페이스.

• 문법:

  class 클래스명<T, U, ...> { ... }
  interface 인터페이스명<T, U, ...> { ... }

• 타입을 지정하지 않으면 기본적으로 Object로 취급됨.

// 제네릭 클래스
public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value){
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}

// 사용
Pair<String, Integer> student = new Pair<>("Alice", 90);
System.out.println(student.getKey() + " : " + student.getValue());

13.3. 제네릭 메소드

• 제네릭 메소드(Generic Method): 메소드 자체가 타입 파라미터를 가짐.
• 선언부에 <T> 와 같은 타입 매개변수 명시.

// 제네릭 메소드
public class Util {
    public static <T> Box<T> boxing(T t) {
        Box<T> box = new Box<>();
        box.content = t;
        return box;
    }
}

// 사용
Box<String> strBox = Util.boxing("Hello");
Box<Integer> intBox = Util.boxing(123);

13.4. 제한된 타입 파라미터 (Bounded Type Parameter)

• 특정 타입 또는 그 하위 타입만 대체 가능하도록 제한.
• 문법: <T extends 상위타입>

public class CompareUtil {
    public static <T extends Number> boolean compare(T t1, T t2) {
        return t1.doubleValue() == t2.doubleValue();
    }
}

// 사용
System.out.println(CompareUtil.compare(10, 10));       // true
System.out.println(CompareUtil.compare(3.14, 3.14));   // true
// System.out.println(CompareUtil.compare("a", "b"));  // 오류 (Number 타입 아님)

13.5. 와일드카드 타입 파라미터

• ? (와일드카드): 범위 내 모든 타입 가능.

• 용도: 제네릭 타입을 매개값이나 리턴 타입으로 사용할 때 유연성 확보.

• 세 가지 방식:

  1. <?> : 모든 타입 허용
  2. <? extends 상위타입> : 상위 타입 및 하위 클래스 허용
  3. <? super 하위타입> : 하위 타입 및 상위 클래스 허용

public static void printList(List<?> list) {
    for(Object obj : list) {
        System.out.println(obj);
    }
}

List<String> strList = Arrays.asList("A", "B", "C");
List<Integer> intList = Arrays.asList(1, 2, 3);

printList(strList); // 가능
printList(intList); // 가능

Chapter 12. java.base 모듈

12.1. API 도큐먼트

• API 도큐먼트: 자바 라이브러리를 쉽게 찾고 사용하는 방법 제공

• 주요 구성

  1. 클래스 선언부 확인

  2. 멤버 보기 (SUMMARY)

     • NESTED: 중첩 클래스/인터페이스
     • FIELD: 필드 목록
     • CONSTR: 생성자 목록
     • METHOD: 메소드 목록

  3. 메소드 필터

     • All Methods, Static Methods, Instance Methods, Concrete Methods, Deprecated Methods

12.2. java.base 모듈

• 모든 모듈이 의존하는 기본 모듈 (requires 없이 사용 가능)

• 주요 패키지

  • java.lang : 기본 클래스 (System, String, Integer …)
  • java.util : 자료구조, 유틸 (Scanner, Collections …)
  • java.text : 날짜/숫자 포맷
  • java.time : 날짜/시간 처리
  • java.io : 입출력 스트림
  • java.net : 네트워크 통신
  • java.nio : 버퍼 및 NIO 입출력

12.3. Object 클래스

• 모든 클래스의 최상위 부모

• 주요 메소드

  • equals(Object obj) : 객체 동등 비교
  • hashCode() : 객체 해시코드 반환
  • toString() : 객체 문자열 정보

class Student {
    int no;
    String name;

    // equals 재정의
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student s) {
            return no == s.no && name.equals(s.name);
        }
        return false;
    }

    // hashCode 재정의
    @Override
    public int hashCode() {
        return no + name.hashCode();
    }

    // toString 재정의
    @Override
    public String toString() {
        return "학생번호: " + no + ", 이름: " + name;
    }
}

• 레코드 (Java 14~)

public record Person(String name, int age) {}

자동으로 private final 필드, 생성자, getter, equals, hashCode, toString 생성

• Lombok 예시

import lombok.Data;

@Data
public class User {
    private String id;
    private String name;
}

12.4. System 클래스

• 운영체제 일부 기능 접근

• 주요 필드: System.out, System.err, System.in

• 주요 메소드:

  • exit(int status) : 프로세스 종료 (0=정상)
  • currentTimeMillis(), nanoTime() : 시간 측정
  • getProperty(), getenv() : 시스템 속성/환경 변수 조회

System.out.println(System.currentTimeMillis());
System.out.println(System.nanoTime());

System.out.println(System.getProperty("os.name"));
System.out.println(System.getenv("PATH"));

• 키보드 입력

int key = System.in.read();
System.out.println("입력된 키 코드: " + key);

12.5. 문자열 클래스

1. String

byte[] arr = "안녕".getBytes("UTF-8");
String str = new String(arr, "UTF-8");

2. StringBuilder (문자열 수정에 유리)

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
sb.insert(5, " Java");
System.out.println(sb.toString());

3. StringTokenizer (구분자 기반 분리)

String text = "apple,banana,grape";
StringTokenizer st = new StringTokenizer(text, ",");
while (st.hasMoreTokens()) {
    System.out.println(st.nextToken());
}

12.6. 포장 클래스

• 기본 타입을 객체로 감싸는 클래스 (Integer, Double 등)
• 박싱 / 언박싱

Integer obj = 100;   // 박싱
int value = obj;     // 언박싱

• 문자열 → 기본 타입 변환

int num = Integer.parseInt("123");
double d = Double.parseDouble("3.14");

• 비교 주의

Integer a = new Integer(100);
Integer b = new Integer(100);

System.out.println(a == b);       // false (주소 비교)
System.out.println(a.equals(b));  // true  (값 비교)

12.7. 수학 클래스 (Math & Random)

• Math 클래스의 메서드는 모두 정적(static) → 객체 생성 없이 바로 사용 가능.

• 주요 메서드:

  • abs(x), ceil(x), floor(x), max(a,b), min(a,b), random(), round(x)

System.out.println(Math.abs(-10));    // 10
System.out.println(Math.ceil(3.2));   // 4.0
System.out.println(Math.floor(3.7));  // 3.0
System.out.println(Math.max(5, 9));   // 9
System.out.println(Math.random());    // 0.0 <= ~ < 1.0

java.util.Random

• 난수 생성을 위한 클래스

• 생성자

  • new Random() : 현재 시간 기반 seed
  • new Random(long seed) : 지정된 seed

• 주요 메서드

  • nextBoolean()
  • nextDouble()
  • nextInt()
  • nextInt(int n) : 0 ≤ 값 < n

Random rand = new Random();
System.out.println(rand.nextBoolean()); // true/false
System.out.println(rand.nextInt(10));   // 0~9

12.8. 날짜와 시간 클래스

Date

Date now = new Date();
System.out.println(now.toString()); // 기본 형식 출력

SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
System.out.println(sdf.format(now)); // 원하는 형식 출력

Calendar

Calendar now = Calendar.getInstance();
int year = now.get(Calendar.YEAR);
int month = now.get(Calendar.MONTH) + 1;
int day = now.get(Calendar.DAY_OF_MONTH);

• 다른 시간대(Calendar)

TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");
Calendar laTime = Calendar.getInstance(tz);

LocalDateTime (java.time 패키지)

• 조작 : plusXxx(), minusXxx()
• 비교 : isAfter(), isBefore(), isEqual()
• 생성 : now(), of(year, month, day, hour, min, sec)

LocalDateTime now = LocalDateTime.now();
LocalDateTime future = now.plusDays(5);

System.out.println(now.isBefore(future)); // true

12.9. 형식 클래스

• 숫자 형식화

DecimalFormat df = new DecimalFormat("#,###.0");
System.out.println(df.format(1234567.89)); // 1,234,567.9

• 날짜 형식화

SimpleDateFormat sdf = new SimpleDateFormat("yyyy년 MM월 dd일");
System.out.println(sdf.format(new Date()));

12.10. 정규 표현식 클래스

• 문자열 검증에 사용

boolean result = Pattern.matches("[0-9]{3}-[0-9]{4}", "123-4567");
System.out.println(result); // true

12.11. 리플렉션 (Reflection)

• 클래스, 인터페이스의 메타 정보(패키지, 필드, 메서드 등) 에 접근하고 조작 가능.

Class 객체 얻기

Class clazz1 = Car.class;
Class clazz2 = Class.forName("com.example.Car");
Car car = new Car();
Class clazz3 = car.getClass();

메타 정보 확인

System.out.println(clazz1.getPackage().getName());   // 패키지명
System.out.println(clazz1.getSimpleName());          // 클래스명
System.out.println(clazz1.getName());                // 전체 경로

생성자/메서드 정보

Method[] methods = clazz1.getDeclaredMethods();
for(Method method : methods){
    System.out.println(method.getName());
}

리소스 경로 얻기

String path = clazz1.getResource("config.xml").getPath();
InputStream is = clazz1.getResourceAsStream("config.xml");

12.12. 어노테이션 (Annotation)

• 코드의 메타데이터를 제공 (@ 기호 사용)

정의 및 용도

1. 컴파일 정보 전달 (@Override)
2. 빌드 시 코드 생성
3. 실행 시 기능 처리

작성

public @interface MyAnnotation {
    String value();
    int number() default 1;
}

적용 대상 (@Target)

@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnnotation {}

유지 정책 (@Retention)

• SOURCE / CLASS / RUNTIME

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {}

어노테이션 활용

Method[] methods = Service.class.getDeclaredMethods();
for(Method method : methods){
    if(method.isAnnotationPresent(PrintAnnotation.class)){
        PrintAnnotation pa = method.getAnnotation(PrintAnnotation.class);
        System.out.println(pa.value());
    }
}