spring boot이용해서 EmployeeManager 사이트 구현하기

김영한 강의를 들으면서 이론적인 내용에 대한 정리를 하고 있었는데, 정리를 해도 본인이 직접 부딪혀 보지 않으면 얻어가는 게 많이 없을 것 같아서 직접 간단하게 구현해 볼 수 있는 '직원관리 사이트'를 만들어 보았다

백엔드는 spring boot, 프론트엔드는 angular+bootstrap을 사용하였다

 

0. 파일구조

1.spring 

나는 MongoDB밖에 사용해 본 적이 없었는데 spring boot generate 할 때 설정을 처음부터 mysql로 해버려서 MYSQL에 대해 배워보는 겸 MYSQL로 DB연결을 했다

<DB생성하기>

1.root계정으로 들어가기

2.명령어 입력하기

CREATE DATABASE 데이터베이스이름 default CHARACTER SET UTF8;

<DB 보기>

show databases;

<DB 사용하기>

USE <데이터베이스명>;

spring boot에서 사용하려면 

application.properties 파일에

#MySQL configuration
spring.datasource.url=jdbc:mysql://localhost:3306/employeemanager(DB이름)
spring.datasource.username=root
spring.datasource.password=<비번>
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

코드 설정을 해주어야 한다

 

1-1) Model/Employee

한 직원이 가져야 하는 interface는

id(update 되면 안 됨), name, email, jobtitle, phone, imageUrl, employeeCode(update 되면 안 됨)가 있다

이에 대한 getter, setter함수를 사용하였다

여기서 처음으로 java.io.Serializable을 사용해서 '직렬화'에 대한 개념을 접하였다

• 생성한 객체를 파일로 저장할 일이 있을 때
• 저장한 객체를 읽을 일이 생길 수도 있을 때
• 다른 서버에서 생성한 객체를 받을 일

이런 상황에서 직렬화를 사용한다 한다. 따라서 우리가 만든 클래스가 파일에 읽거나 쓸 수 있도록 하거나, 다른 서버로 보내거나 받을 수 있도록 하려면 반드시 이 인터페이스를 구현해야 한다고 한다!

package tech.getarrays.employeeManager.model;

import jakarta.persistence.*;

import java.io.Serializable; //helps transform this java class into different types of stream

@Entity
public class Employee implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(nullable = false,updatable = false)
    private Long id; //shouldn't be updated
    private String name;
    private String email;
    private String jobTitle;
    private String phone;
    private String imageUrl;
    @Column(nullable = false,updatable = false)
    private String employeeCode; //shouldn't be updated

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getJobTitle() {
        return jobTitle;
    }

    public void setJobTitle(String jobTitle) {
        this.jobTitle = jobTitle;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getImageUrl() {
        return imageUrl;
    }

    public void setImageUrl(String imageUrl) {
        this.imageUrl = imageUrl;
    }

    public String getEmployeeCode() {
        return employeeCode;
    }

    public void setEmployeeCode(String employeeCode) {
        this.employeeCode = employeeCode;
    }
}

1-2) Repo/EmployeeRepo

JpaRepository를 상속하는 것부터 이러한 기능들을 제공받는다

메소드	기능
save()	레코드 저장 (insert, update)
findOne()	primary key로 레코드 한건 찾기
findAll()	전체 레코드 불러오기. 정렬(sort), 페이징(pageable) 가능
count()	레코드 갯수
delete()	레코드 삭제

 

package tech.getarrays.employeeManager.repo;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.transaction.annotation.Transactional;
import tech.getarrays.employeeManager.model.Employee;

import java.util.Optional;

@Transactional
public interface EmployeeRepo extends JpaRepository<Employee, Long> {


    void deleteEmployeeById(Long id);

    //query Method
    Optional<Employee> findEmployeeById(Long id);
}

내가 사용한 deleteEmployeeById나 findEmployeeById는 JPA에서 기본적으로 제공하는 것이 아닌 내가 이 프로젝트에서 필요한 기능을 추가한 것이다

 

여기서 Optional <Employee>를 붙이는 이유:

Optional은 고통스러운 null 처리를 도와주는 Wrapper 클래스이다.

 

1-3) Service/employeeService

 

package tech.getarrays.employeeManager.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tech.getarrays.employeeManager.exception.UserNotFoundException;
import tech.getarrays.employeeManager.model.Employee;
import tech.getarrays.employeeManager.repo.EmployeeRepo;

import java.util.List;
import java.util.UUID;

@Transactional
@Service
public class EmployeeService {
    private final EmployeeRepo employeeRepo;

    @Autowired
    public EmployeeService(EmployeeRepo employeeRepo) {
        this.employeeRepo = employeeRepo;
    }

    public Employee addEmployee(Employee employee){
        employee.setEmployeeCode(UUID.randomUUID().toString());
        return employeeRepo.save(employee);
    }

    public List<Employee> findAllEmployees(){
        return employeeRepo.findAll();
    }

    public Employee updateEmployee(Employee employee){
        return employeeRepo.save(employee);
    }

    public Employee findEmployeeById(Long id){
        return employeeRepo.findEmployeeById(id).orElseThrow(()->new UserNotFoundException("User bt id"+ id+"was not found"));
    }

    public void deleteEmployee(Long id){
        employeeRepo.deleteEmployeeById(id);
    }


}

1-4) EmployeeResource

import tech.getarrays.employeeManager.model.Employee;
import tech.getarrays.employeeManager.service.EmployeeService;

import java.util.List;

@RestController
@RequestMapping("/employee")
public class EmployeeResource {
    private final EmployeeService employeeService;

    public EmployeeResource(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @GetMapping("/all")
    public ResponseEntity<List<Employee>> getAllEmployees(){
        List<Employee> employees = employeeService.findAllEmployees();
        return new ResponseEntity<>(employees, HttpStatus.OK);
    }

    @GetMapping("/find/{id}")
    public ResponseEntity<Employee> getEmployeeById(@PathVariable("id") Long id){
        Employee employee = employeeService.findEmployeeById(id);
        return new ResponseEntity<>(employee, HttpStatus.OK);
    }

    @PostMapping("/add")
    public ResponseEntity<Employee> addEmployee(@RequestBody Employee employee){
        Employee newEmployee = employeeService.addEmployee(employee);
        return new ResponseEntity<>(newEmployee, HttpStatus.CREATED);
    }

    @PutMapping("/update")
    public ResponseEntity<Employee> updateEmployee(@RequestBody Employee employee){
        Employee updateEmployee= employeeService.addEmployee(employee);
        return new ResponseEntity<>(updateEmployee, HttpStatus.CREATED);
    }

    @DeleteMapping ("/delete/{id}")
    public ResponseEntity<Employee> deleteEmployee(@PathVariable("id") Long id){
        employeeService.deleteEmployee(id);
        return new ResponseEntity<>(HttpStatus.OK);
    }


}

 

직접 코드를 짜보고 postman이용해서 확인까지 해보니까 spring이 적어도 어떻게 돌아가는지는 알 수 있었던 공부였다.