[Spring] mySql + JPA CRUD

인텔리J 유료버전 기준으로 작성된 글 입니다
Java Version 11

 

[Spring] 스프링 부트 시작하기. Hello, World!
[Spring] form 태그와 JSON 형식을 이용한 요청
[Spring] Spring mySql 연결 + JPA
과 이어지는 내용입니다.

 

설정

저번 포스팅에서 DB와 연결만 해놓고 서비스 로직을 작성할 어떠한 설정도 하지 않았다.
이제 해야됨.

Repository

repository 부터 생성을 해보자.

 

package com.example.helloworld.repository;

import java.util.List;

import com.example.helloworld.domain.User;

public interface UserRepository {
    User save(User user);
    List<User> findUsers();
    Optional<User> findUserByUserId(Long idx);
    Optional<User> changeUserPw(Long idx);
    void deleteUser(Long idx);
}

 

우선 인터페이스를 만든다.

그리고 implements 해서 repository를 생성해주자.

 

public class Repository implements UserRepository{

    @Override
    public User save(User user) {
        return null;
    }

    @Override
    public List<User> findUsers() {
        return null;
    }

    @Override
    public Optional<User> findUserByUserId(Long idx) {
        return Optional.empty();
    }

    @Override
    public User changeUserPw(Long idx, String pw) {
        return Optional.empty();
    }

    @Override
    public void deleteUser(Long idx) {

    }
}

 

메서드 자동 완성기능을 이용하면 아주 편-안 하다.
그리고 얘한테 Entity Manager(이하 em)을 달아 줘야한다.

 

    private final EntityManager em;

    public Repository(EntityManager em) {
        this.em = em;
    }

 

필드와 생성자를 추가해주자.
여기 까지 해주면 된다.

 

UserService

서비스 로직을 담당할 UserService 클래스를 생성할 거다.
Service package를 생성하고, 하위에 UserService 클래스를 생성해주자.

 

@Transactional
public class UserService {

    private final UserRepository userRepository;

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

    public User join(User user) {
        return userRepository.save(user);
    }

    public List<User> getUserList() {
        return userRepository.findUsers();
    }

    public User getUserByIdx(Long idx) {
        return userRepository.findUserByUserIdx(idx).get();
    }

    public User updatePassword(Long idx, String pw) {
        return userRepository.changeUserPw(idx, pw).get();
    }

    public void quit(Long idx) {
        userRepository.deleteUser(idx);
    }
}

 

원래 Optional 저렇게 쓰면 안되는데, 저건 나중에 예외처리 포스팅하면서 수정하려한다.

 

Controller

기존의 코드에서 필드와 생성자를 추가해주자.

 

    private final UserService userService;

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

 

그리고 method 들도 추가를 해줘야한다.

 

    @ResponseBody
    @PostMapping("/join")
    public User join(@RequestBody UserDto userDto) {
        User user = new User(userDto.getUserId(), userDto.getUserPw());
        return userService.join(user);
    }

    @ResponseBody
    @GetMapping("/getUsers")
    public List<User> getUsers() {
        return userService.getUserList();
    }

    @ResponseBody
    @GetMapping("/getUser")
    public User findUser(@RequestParam Long idx) {
        return userService.getUserByIdx(idx);
    }

    @ResponseBody
    @PatchMapping("/changePw")
    public User changePw(@RequestBody PwDto pwDto) {
        return userService.updatePassword(pwDto.getIdx(), pwDto.getPw());
    }

    @ResponseBody
    @DeleteMapping("quit")
    public boolean quit(@RequestParam Long idx) {
        userService.quit(idx);
        return true;
    }

 

SpringConfig

마지막으로 설정 파일 하나만 만들면 된다.

Application 옆에 SpringConfig 라는 클래스 하나 생성해주자.

 

@Configuration
public class SpringConfig {

    private EntityManager em;

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

    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new Repository(em);
    }
}

 

여기까지 해주면 길고긴 세팅은 끝났다.
근데 뭐 설정파일 이라할건 하나 밖에 없긴하다.. ㅎ

 

JPA CRUD

이제 다시 Repository로 돌아와서,
jpa를 이용하여 CRUD를 해보자.

 

Create

   @Override
    public User save(User user) {
        em.persist(user);
        return user;
    }

필드에 선언 되어 있는 em을 이용해 DB와 통신을 한다.
기존에 사용했던 ORM들은 save를 메소드 명으로 사용했었는데,
얘는 persist다.

무튼 이렇게 해놓고,
postMan 으로 아래와 같이 요청을 보내면,

위와 같이 쿼리가 동작한다.

mySql에 접속해서 확인을 해보면,

 

데이터가 잘 입력된 것을 확인 할 수 있다.

Read

 

    @Override
    public List<User> findUsers() {
        return em.createQuery("SELECT u from User u", User.class)
                .getResultList();
    }

    @Override
    public Optional<User> findUserByUserIdx(Long idx) {
        User user = em.find(User.class, idx);
        return Optional.ofNullable(user);
    }

 

Spring-data-jpa 가 아닌 순수 jpa 방식으로 연습을 하고 있어서, jpql을 쓰는게 좀 귀찮긴하다.
그래도 동작은 잘 된다.
아래는 postMan 실행 결과.

 

 

Update

update 도 마찬가지로 인자값을 받아서 jpql을 작성한 뒤에,
excute를 통해 실행시켜 주면 된다.
변경된 값을 리턴 해주도록 작성 하였다.

 

    @Override
    public Optional<User> changeUserPw(Long idx, String pw) {
        em.createQuery("UPDATE User u SET u.userPw = :pw WHERE u.idx = :idx")
                .setParameter("pw", pw)
                .setParameter("idx", idx)
                .executeUpdate();
        return findUserByUserIdx(idx);
    }

 

postMan을 통해 실행해보면,

위와 같은 결과가 나오는 것을 확인 할 수 있다.

 

Delete

위의 방식과 동일하다.

 

    @Override
    public void deleteUser(Long idx) {
        em.createQuery("DELETE User u WHERE u.idx = :idx")
                .setParameter("idx", idx)
                .executeUpdate();
    }

 

마찬가지로 postMan을 통해 실행히보면,

 

해당 데이터가 삭제된 것을 확인 할 수 있다.