VS Code에서 Spring Initializr로 프로젝트 만들기

1. 명령 팔레트 열기
   • 윈도우: Ctrl + Shift + P
   • 맥: Cmd + Shift + P
2. Spring Initializr: Create a Gradle Project... (또는 Maven Project) 검색 후 선택
3. 엔터엔터 선택
   • Spring Boot 버전
   • Language: Java
   • Group Id, Artifact Id
   • Build Tool: Maven / Gradle
   • Dependencies: Spring Web, Spring Data JPA, H2 혹은 MySQL 등

💡 Spring Initializr에서 설정 다운로드

• 설정들을 웹에서 선택 > GENERATE 버튼 > ZIP 다운로드 > VS Code에서 실행

Maven

• Java 프로젝트용 빌드 도구
• 라이브러리(의존성) 관리, 컴파일, 패키징(JAR/WAR) 등을 자동으로 수행
• npm (JavaScript) = Maven (Java)

pom.xml

• Maven 프로젝트의 설정 파일
• ≈≈≈ package.json 와 비슷 (어떻게 빌드할지)
  ├── 프로젝트 정보 (이름, 버전 등)
  ├── 어떤 라이브러리를 쓸지 (dependencies)
  ├── 어떤 플러그인을 쓸지
  └── 빌드 방법 (빌드 라이프사이클 설정)

<!-- pom.xml 예시 일부 -->
<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <dependencies>
    <!-- 여기 안에 spring-boot-starter-web 같은 의존성들이 들어감 -->
  </dependencies>
</project>

의존성(라이브러리) 추가하는 방법

• VS Code > 명령 팔레트 > Maven: Add a Dependency... 사용 (편의 기능)
• pom.xml 직접 수정 (정석)
• Maven Central Repository 에서 검색 후 XML 코드 복사, pom.xml 붙여넣기

빌드 명령: mvn clean install

mvn clean install ≈≈≈ npm install + 빌드까지 한 번에 돌린 느낌
// clean -> 이전 빌드 삭제
// 새로 빌드
// install -> 프로젝트 컴파일 + 테스트 + 패키징(JAR 생성)
// 로컬 저장소에 배포

JavaScript Map vs Java HashMap

JavaScript: Map 기본 사용법

const userMap = new Map();

// 데이터 추가
userMap.set('name', '길동');
userMap.set('age', 19);

// 데이터 조회
userMap.get('name');  // '길동'

// 존재 확인 및 크기
userMap.has('name');  // true
userMap.size;         // 2

Java: HashMap 기본 사용법

Java 차이점: Map -> 인터페이스, HashMap -> Map을 구현한 클래스 -> 세트

// 타입 지정 + 구현체 선택 -> Map 타입인데  HashMap으로 만들겠다
Map<String, Object> userMap = new HashMap<>();
HashMap<String, Object> userMap = new HashMap<>();

// 데이터 추가
userMap.put("name", "길동");
userMap.put("age", 19);

// 데이터 조회
userMap.get("name");          // "길동"

// 존재 확인 및 크기
userMap.containsKey("name");  // true
userMap.size();               // 2 (메서드 호출)

메서드 비교

반복문 비교

JavaScript: forEach 사용

const users = new Map();
users.set('user1', { name: '철수', age: 30 });
users.set('user2', { name: '영희', age: 25 });

users.forEach((value, key) => {
  console.log(key, value);
});

Java: for-each 사용

Map<String, User> users = new HashMap<>();
users.put("user1", new User("철수", 30));
users.put("user2", new User("영희", 25));

for (String key : users.keySet()) {
  System.out.println(key + ": " + users.get(key));
}

Spring Repository 패턴

public class StudentRepository {
  // 필드: 클래스 안에 선언된 변수
  // ⚛️ React -> useRef / useState처럼 호출마다 사라지지 않고 유지됨
  private final Map<String, Student> studentMap = new HashMap<>();

  public void save(Student student) {
    studentMap.put(student.getName(), student);
  }
}

save 함수 실행 과정

// 1. Repository 필드 선언 (컴포넌트 상태처럼 유지됨)
private final StudentRepository studentRepository;

// 2. Student 객체 생성 (저장할 실제 데이터)
Student student = new Student(
  studentInfoDto.getName(), 
  studentInfoDto.getAge(), 
  studentInfoDto.getAddress()
);

// 3. Repository에 저장
studentRepository.save(student);

✅ 한 줄 정리:

JavaScript -> Map 하나로 끝
Java -------> Map: (설계도) + HashMap: (실제 구현체), <Key타입, Value타입> 필수

Spring Service DTO 실습: private final getter 정리

프론트엔드 → 백엔드 전환 !

📦 DTO: Data Transfer Object

application/dto/StudentDto.java (데이터 상자)

public class StudentDto {
    //  String(타입) name(변수명)
    private String name;        // 문자열 학생 이름 변수
    private int studentNumber;  // 숫자 학번 변수

    public String getName() { // getter/setter
        return name;
    }    
    public void setName(String name) {
        this.name = name;  // 검증 로직 추가 가능
    }

    // Entity와 필드 다를 수 있음 (보안용)
    // 예: Entity엔 password도 있지만 DTO엔 제외
}

private -> 이 변수는 나만 쓸 거야!

• 클래스 내부에서는 자유롭게 사용
• 외부에서는 직접 접근 불가 (getter/setter로만)
• 실수로 외부에서 함부로 바꾸는 것 방지 ✅

getter/setter 개념

public class StudentDto {
    private String name;  // ❌ 다른 파일에서 직접 접근 불가!

    // 👉 getter 함수: "name 값을 보여줘!"
    public String getName() {
        return name;
    }
}
StudentDto student = new StudentDto();
// student.name = "홍길동";  // ❌ 컴파일 에러!
String name = student.getName();  // ✅ 가능! getter로만 접근

⚛️ React

const [name, setName] = useState<string>("");  
name        // Getter 역할
setName()   // Setter 역할
const student = { name: "홍길동" };
console.log(student.name);  // ✅ 직접 접근 OK

Java: 직접 접근 불가 → 함수로만!
StudentDto student = new StudentDto();
student.getName()  // Getter ✅ 함수로만 접근
student.setName()  // Setter ✅ 함수로만 접근

application/service/StudentService.java

public class StudentService {
    // 접근제한 + 불변
    private final StudentRepository repo;

    public StudentDto create(StudentDto dto) {
        // 검증 로직
        if (dto.getName() == null) throw new IllegalArgumentException("이름 필수");

        Student entity = new Student(dto.getName(), dto.getStudentNumber());
        repo.save(entity);
        return new StudentDto(entity); // DTO 변환
    }
}

final -> 절대 바꾸지 않아!

• 클래스 내부에서는 자유롭게 사용
• 외부에서는 직접 접근 불가 (getter/setter로만)
• 실수로 외부에서 함부로 바꾸는 것 방지 ✅

private vs final 차이 비교

final -> 값 바꾸기 방지
private -> 직접 접근 방지

public (없거나 public일 때)

외부에서 직접 접근 가능!

public class StudentDto {
    public String name;        // ✅ 직접 접근 가능
    public int studentNumber;  // ✅ 직접 접근 가능
}

StudentDto student = new StudentDto();
student.name = "홍길동";          // ✅ OK!
System.out.println(student.name); // ✅ OK!

✅ 한 줄 정리:

private -------> 안 보여줄래 (캡슐화)
final ---------> 바꾸지 않을래 (불변성)
getter/setter -> 필요할 때만 보여줄래
Service -------> 검증 + 비즈니스 로직 처리

Spring Service와 DTO 역할: 계층별 폴더 구조 정리

Service와 DTO 핵심 역할

Service

• 업무 규칙, 비즈니스 흐름 담당
• 예외처리, 데이터 저장/조회, 입력값 검증 로직

DTO (Data Transfer Object)

• "데이터 상자" 역할
• 계층 간 데이터 운반 (Controller ↔ Service)
• Entity와 분리해 보안/성능 최적화

📂 권장 폴더 구조

src/main/java/com/example/
│
├── application/ # 유즈케이스 (기능별 로직)
│ ├── service/ # Service (선생님: 어떻게 처리할지 담당)
│ └── dto/ # DTO (이름,나이,번호 정보만 전달)
│
├── domain/ # 도메인 규칙, Entity (학교)
│ └── entity/ # 이름/번호로 구분되는 핵심 데이터 (사람,반)
└── repository/ # 데이터 저장/조회 (DB 접근)