CRUD (create, read, update, delete)

휴먼코딩 2024. 6. 26. 19:43

2024. 6. 26. 19:43

CRUD는 데이터베이스에 관련된 기본적인 작업을 의미한다.

C: Create (생성)

R: Read (읽기)

U: Update (갱신)

D: Delete (삭제)

이 네 가지 작업은 DB에서 데이터를 관리하는데 사용된다.

1. Create (생성)

데이터베이스에 새로운 데이터를 추가한다.
INSERT 쿼리를 사용하여 새로운 정보를 DB 테이블에 삽입한다.
예를 들어, 사용자가 회원 가입을 하면 사용자 정보를 데이터베이스에 추가한다.

2. Read (읽기)

데이터베이스에 저장된 데이터를 조회하고 읽는다.
SELECT 쿼리를 사용하여 데이터베이스 테이블에서 데이터를 가져온다.
예를 들어, 웹 애플리케이션에서 사용자가 자신의 프로필 정보를 보거나 게시판 글 목록을 조회한다.

3. Update (갱신)

데이터베이스에 저장된 기존 데이터를 수정하거나 업데이트한다.
UPDATE 쿼리를 사용하여 특정 정보의 필드 값을 변경한다.
예를 들어, 사용자가 자신의 프로필 정보를 수정하면 데이터베이스에 저장된 정보를 업데이트한다.

4. Delete (삭제)

데이터베이스에서 저장된 데이터를 삭제한다.
DELETE 쿼리를 사용하여 특정 레코드를 데이터베이스에서 제거한다.
예를 들어, 사용자가 회원 탈퇴를 요청하면 데이터베이스에서 사용자 정보를 삭제한다.

실제 사용법

spring boot에서는 spring MVC와 다르게 DAO 클래스가 없어도 된다. (controller, service, dao, mapper)

repository 인터페이스 (mapper)을 정의하면 spring boot가 자동으로 구현해준다.

1. Gradle 프로젝트 설정

build.gradle

Gradle 프로젝트의 build.gradle 파일에 필요한 의존성을 추가한다.

예시에서는 내가 주로 사용하는 db인 psql을 추가했다.

plugins {
    id 'org.springframework.boot' version '2.5.1'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.0'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.postgresql:postgresql:42.2.23'
    implementation 'org.springframework.boot:spring-boot-starter-test'
    runtimeOnly 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

2. 데이터베이스 설정

application.properties

PostgreSQL 데이터베이스 연결 정보를 설정한다.

spring.datasource.url=jdbc:postgresql://localhost:5432/mydatabase
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

3. Entity 클래스 생성

데이터베이스의 특정 테이블과 매핑되는 엔티티 클래스를 생성한다.

package com.example.demo.model;

public class User {
    private Long id;
    private String username;
    private String email;
    // getters and setters
}

4. MyBatis Mapper 인터페이스 작성

MyBatis Mapper 인터페이스를 생성하여 CRUD 작업을 정의한다.

예시)

package com.example.demo.repository;

import com.example.demo.model.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface UserRepository {

    @Select("SELECT * FROM users")
    List<User> findAll();

    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(Long id);

	@Insert("INSERT INTO users(username, email) VALUES (#{username}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void save(User user);
    
    @Update("UPDATE users SET username = #{username}, email = #{email} WHERE id = #{id}")
    void update(User user);

    @Delete("DELETE FROM users WHERE id = #{id}")
    void delete(Long id);
}

    @Select("SELECT * FROM users")
    List<User> findAll();

@Select("SELECT * FROM users")

users 테이블 안의 모든 정보를 데이터베이스에서 조회한다.
반환 타입은 List<User>로 모든 사용자 목록을 담고 있다.

 @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(Long id);

@Select("SELECT * FROM users WHERE id = #{id}")

주어진 id에 해당하는 사용자를 조회한다.
#{id}는 파라미터 바인딩을 의미하며 매개변수 id에 해당하는 값을 사용한다.
반환 타입은 User 객체로 해당 id에 대한 사용자 정보를 담고 있다.

파라미터 바인딩: 전달된 id 값이 실제 SQL 쿼리에서 #{id} 자리에 들어가

해당 ID에 해당하는 사용자를 조회할 수 있게 해준다.

 @Insert("INSERT INTO users(username, email) VALUES (#{username}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void save(User user);

@Insert 어노테이션은 MyBatis에서 사용되며, 해당 메서드가 데이터베이스에 새로운 레코드를 삽입할 때 사용된다.
@Options 어노테이션은 @Insert` 어노테이션과 함께 사용되어 기본키(Generated Key) 값을 가져온다.

1. @Insert("INSERT INTO users(username, email) VALUES (#{username}, #{email})")
      - @Insert 어노테이션으로 해당 메서드가 INSERT SQL 쿼리를 실행한다는 것을 선언한다.
- INSERT INTO users(username, email) VALUES (#{username}, #{email}) 는 실행할 SQL 쿼리를 지정한다.
- #{username}`과 `#{email}`은 사용자 객체(User user)의 필드 값을 파라미터 바인딩으로 가져온 것이다.

2. @Options(useGeneratedKeys = true, keyProperty = "id")
     - @Options 어노테이션은 INSERT 쿼리에서 기본키(Generated Key) 값을 어떻게 처리할지 설정한다.
     - useGeneratedKeys = true: 자동 생성된 키를 사용한다.
     - keyProperty = "id": 자동 생성된 키 값을 저장할 사용자 객체의 프로퍼티를 지정한다.

여기서는 User 객체의 id 필드에 자동 생성된 키 값을 할당한다.

save 메서드는 User 객체를 받아서 데이터베이스에 새로운 정보를 삽입하며,
이 과정에서 데이터베이스에서 생성된 `id` 값을 가져와 `User` 객체의 `id` 필드에 할당한다.

    @Update("UPDATE users SET username = #{username}, email = #{email} WHERE id = #{id}")
    void update(User user);

@Update("UPDATE users SET username = #{username}, email = #{email} WHERE id = #{id}")

주어진 id에 해당하는 사용자의 정보를 업데이트한다.
#{username}, #{email}, #{id}는 각각 user 객체의 프로퍼티에 해당하는 값을 넣는다.
반환 타입을 void로 설정해 데이터베이스의 상태 변경을 반환한다.

    @Delete("DELETE FROM users WHERE id = #{id}")
    void delete(Long id);

@Delete("DELETE FROM users WHERE id = #{id}")

주어진 id에 해당하는 사용자를 데이터베이스에서 삭제한다.
#{id}는 메서드의 매개변수 id에 해당하는 값이 사용된다.
반환 타입을 void로 설정해 데이터베이스의 상태 변경을 반환한다.

5. Service 및 Controller 작성

UserService.java

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id);
    }

    public void createUser(User user) {
        userRepository.save(user);
    }

    public void updateUser(User user) {
        userRepository.update(user);
    }

    public void deleteUser(Long id) {
        userRepository.delete(id);
    }
}

public List<User> getAllUsers() {
    return userRepository.findAll();
}

동작: UserRepository 인터페이스의 findAll() 메서드를 호출하여 모든 사용자 정보를 조회한다.

반환값: 사용자 정보를 담고 있는 리스트(List<User>)를 반환한다.

사용 예시: 모든 사용자 정보를 조회한다.

    public User getUserById(Long id) {
        return userRepository.findById(id);
    }

동작: userRepository.findById(id); 를 호출하여 db에서 해당 id에 해당하는 사용자 정보를 조회한다.

반환값: 조회된 사용자 정보 (User 객체)를 반환한다.

사용 예시: 사용자의 id를 전달하면 해당 사용자의 정보를 반환받을 수 있다.

public void createUser(User user) {
   userRepository.save(user);
}

동작: 매개변수로 전달된 user 객체를 DB에 저장한다. DB에 저장이 완료되면 해당 사용자 객체 (user)는 데이터베이스에 추가된다.

반환값: void 반환값이기 때문에 반환할 값이 없다. 단순히 생성 작업만 한다.

사용 예시: 1. createUser 메서드는 userRepository.save(user)을 호출하여 객체를 DB에 저장한다.

2. 저장 후 추가적인 비즈니스 로직을 수행 가능하다.

public void updateUser(User user) {
        userRepository.update(user);
}

동작: 매개변수로 전달된 user 객체를 DB에 업데이트한다. 사용자 객체의 상태가 데이터베이스에 반영된다.

해당 객체의 ID를 기반으로 DB에서 기존 정보를 찾아 업데이트 한다.

반환값: void 반환값이기 때문에 반환할 값이 없다.

사용 예시: 1. userRepository.save(user)을 호출하여 사용자 객체의 정보를 DB에 업데이트 한다

2. 업데이트 후, 추가적인 비즈니스 로직을 수행 가능하다.

public void deleteUser(Long id) {
     userRepository.deleteById(id);
}

동작: userRepository.deleteById(id) 메서드를 호출하여 주어진 ID에 해당하는 사용자 엔티티를

DB에서 삭제한다.

반환값: void 반환값이기 때문에 반환할 값이 없다.

사용 예시: 1. userRepository.deleteById(id)를 호출하여 주어진 ID에 해당하는 사용자를 DB에서 삭제한다.

2. 삭제 후, 추가적인 비즈니스 로직을 수행 가능하다.

UserController.java

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public void createUser(@RequestBody User user) {
        userService.createUser(user);
    }

    @PutMapping("/{id}")
    public void updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

동작: 모든 사용자 목록을 조회한다

반환값: List<User> 모든 사용자의 리스트를 반환한다.

사용 예시: 클라이언트가 /api/users에 Get 요청을 보내면, 서비스에서 모든 사용자 목록을 조회하여 반환

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

동작: 주어진 ID에 해당하는 사용자를 조회한다.

반환값: User : 주어진 ID에 해당하는 사용자 객체를 반환한다.

사용 예시: 클라이언트가 /api/users/{id} 에 GET 요청을 보내면 서비스에서 해당 ID에 해당하는 사용자를 조회하여 반환한다.

    @PostMapping
    public void createUser(@RequestBody User user) {
        userService.createUser(user);
    }

동작: 새로운 사용자를 생성한다.

반환값: void 이므로 새로운 사용자 생성 후 반환할 값이 없다.

사용 예시: 클라이언트가 /api/users에 POST 요청을 보내면 전송된 사용자 데이터를 기반으로 새로운 사용자를 생성한다.

    @PutMapping("/{id}")
    public void updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userService.updateUser(user);
    }

동작: 주어진 ID에 해당하는 사용자를 업데이트 한다.

반환값: void 이므로 업데이트 된 후 반환할 값이 없다.

사용 예시: 클라이언트가 /api/users/{id} 엔드포인트에 PUT 요청을 보내면 전송된 사용자 데이터 기반으로 해당 ID에 해당하는 사용자 정보를 업데이트한다.

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }

동작: 주어진 ID에 해당하는 사용자를 삭제한다

반환값: void이므로 삭제 후 반환할 값이 없다.

사용 예시: 클라이언트가 /api/users/{id}에 delete 요청을 보내면 해당 ID에 해당하는 사용자를 삭제한다.

= /api/users/{id} 는 RESTful API에서 사용되는 URL의 일종이다. URL은 웹 리소스를 식별하는 고유한 경로이며

RESTful API에서는 이를 사용하여 클라이언트가 서버에 요청을 보낼때 필요한 경로를 지정한다.

api: API의 기본경로이다.

users: 사용자 관련 리소스를 다루는 곳이다.

id: 경로 변수로 실제 사용자의 ID값이 쓰이는 곳이다. 클라이언트가 특정 사용자의 ID를 지정하여 요청할 수 있다.

각 메서드는 HTTP 메서드 (GET, POST, PUT, DELETE)에 따라 작업을 수행하며

서비스 계층의 UserService를 호출하여 비즈니스 로직을 수행한다.

클라이언트는 HTTP요청을 통해 데이터를 전송하고, 각 메서드는 해당 요청을 처리하여 데이터를 조작하는 작업을 수행한다.

'CS > DATABASE' 카테고리의 다른 글

Apache Kafka (0)	2024.08.14
기본키와 외래키 (1)	2024.08.13
h2 데이터베이스 사용법 (0)	2024.08.01
INNER JOIN & OUTER JOIN (0)	2024.07.09
데이터 베이스의 개념 (0)	2024.01.08

인간 코딩(오류판)