프로젝트를 위한 CRUD 공부

package com.example.demo.controller;

import com.example.demo.model.trade.Trade;
import com.example.demo.service.TradeService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/trades")
@RequiredArgsConstructor
public class TradeController {

    private final TradeService tradeService;

    @PostMapping
    public Trade createTrade(@RequestBody Trade trade) {
        return tradeService.saveTrade(trade);
    }

    @GetMapping("/{id}")
    public Trade findTradeById(@PathVariable Long id) {
        return tradeService.findTradeById(id).orElseThrow(RuntimeException::new);
    }

    @GetMapping
    public List<Trade> getAllTrades() {
        return tradeService.findAllTrades();
    }
}

package com.example.demo.controller;

import com.example.demo.model.userData.User;
import com.example.demo.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

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

    private final UserService userService;

    @PostMapping("/register")
    public User registerUser(@RequestBody User user) {
        return userService.registerUser(user);
    }

    @GetMapping("/findByEmail")
    public User findUserByEmail(@RequestParam String email) {
        return userService.findUserByEmail(email).orElseThrow(() -> new RuntimeException("유저를 찾을 수 없다."));
    }

    @GetMapping("/{id}")
    public User findUserById(@PathVariable Long id) {
        return userService.findUserById(id).orElseThrow(() -> new RuntimeException("유저를 찾을 수 없습니다."));
    }

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

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

package com.example.demo.model.Investment;

import org.springframework.data.jpa.repository.JpaRepository;

public interface InvestmentProductRepository extends JpaRepository<InvestmentProducts, Long> {
}

package com.example.demo.model.Investment;

import com.example.demo.model.trade.ProductsType;
import jakarta.persistence.ElementCollection;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.Getter;
import lombok.Setter;

import java.util.List;

@Getter
@Setter
@Table(name = "InvestmentProducts")
@Entity
public class InvestmentProducts {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long productsId;

    private String productsName;

    @Enumerated(EnumType.STRING)
    private ProductsType productsType;

    private double currentPrice;

    @ElementCollection
    private List<Double> pastPrices;
}

package com.example.demo.model.trade;

import com.example.demo.model.Investment.InvestmentProducts;
import com.example.demo.model.userData.User;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import lombok.Getter;
import lombok.Setter;

import java.time.LocalDateTime;

@Getter
@Setter
@Entity
public class Trade {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;

    @ManyToOne
    @JoinColumn(name = "product_id")
    private InvestmentProducts product;

    private LocalDateTime tradeDate;
    private String transactionType;
    private double transactionAmount;
    private int quantity;
}

package com.example.demo.model.trade;

import org.springframework.data.jpa.repository.JpaRepository;

public interface TradeRepository extends JpaRepository<Trade, Long> {
}

package com.example.demo.model.userData;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.time.LocalDate;

@Getter
@Setter
@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long userId;
    private String name;
    private String email;
    private String password;
    private LocalDate joinDate;
}

package com.example.demo.model.userData;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

package com.example.demo.service;

import com.example.demo.model.Investment.InvestmentProductRepository;
import com.example.demo.model.Investment.InvestmentProducts;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
@RequiredArgsConstructor
public class InvestmentProductService {

    private final InvestmentProductRepository investmentProductRepository;

    public InvestmentProducts saveProduct(InvestmentProducts product) {
        return investmentProductRepository.save(product);
    }

    public Optional<InvestmentProducts> findProductById(Long productId) {
        return investmentProductRepository.findById(productId);
    }

    public void deleteProductById(Long productId) {
        investmentProductRepository.deleteById(productId);
    }
}

package com.example.demo.service;

import com.example.demo.model.trade.Trade;
import com.example.demo.model.trade.TradeRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;


@Service
@RequiredArgsConstructor
public class TradeService {
    private final TradeRepository tradeRepository;

    public Trade saveTrade(Trade trade) {
        return tradeRepository.save(trade);
    }

    public Optional<Trade> findTradeById(Long id) {
        return tradeRepository.findById(id);
    }

    public List<Trade> findAllTrades() {
        return tradeRepository.findAll();
    }
}

package com.example.demo.service;

import com.example.demo.model.userData.User;
import com.example.demo.model.userData.UserRepository;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    public User registerUser(User user) {
        user.setJoinDate(LocalDate.from(LocalDateTime.now()));
        return userRepository.save(user);
    }

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

    public Optional<User> findUserById(Long userId) {
        return userRepository.findById(userId);
    }

    public Optional<User> findUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }

    public void deleteUserById(Long userId) {
        userRepository.deleteById(userId);
    }

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

각종 애노테이션과 JPA 메서드를 활용해서 진행했다. 
어떤 식으로 진행해야하며 스프링에 대한 감을 잡기 위해 진행했다.