JPA

CategoryAPIController

//api패키지의 모든 컨트롤러는 RestController
//JSON을 리턴하는 메소드
@RestController
@RequiredArgsConstructor
@RequestMapping("/api")
//로그기록
@Slf4j
public class CategoryAPIController {
    private final CategoryService categoryService;
    //카테고리를 추가하기 위한 데이터를 JSON으로 입력받고 싶은 경우
    //JSON으로 입력데이터를 만들어서 요청하면 스프링이 DTO로 변환
    //작업이 완료되면 성공완료됐는지만 넘기기
    //@RequestBody ---> json데이터 -> DTO로 변환해서 매개변수에 전달
    //@RequestBody ---> 자바객체 -> json데이터로 변환해서 응답
    @PostMapping("/category/insert")
    public ResponseEntity<?> insert(@RequestBody CategoryRequestDTO inputdata){
        System.out.println(inputdata);
        categoryService.write(inputdata);
        //ResponseEntity는 상태코드와 응답데이터의 본문을 설정
        //성공응답을 200 응답을 생성하고 별도의 본문없이 응답을 반환 - ok메시지
       // return ResponseEntity.ok().build(); ->원래 이렇게하면됨 밑은 ok사인 찍고싶어서하는것
        return ResponseEntity.ok(HttpStatus.OK);
    }
    @GetMapping("/category/{categoryId}")
    public CategoryResponseDTO read(@PathVariable("categoryId") String catrgoryId){
        return categoryService.findById(Long.parseLong(catrgoryId));
    }

    //뷰가 없어서 처리결과를 JSON으로 만들어서 리턴 - Ajax요청결과
    //뷰로 response하는 경우는 String(뷰) 리턴하고 결과를 Model에 add시킨다.
    @GetMapping("/category/list")
    public List<CategoryResponseDTO> list(){
        return categoryService.findAll();
    }

    @GetMapping("/category/pagelist")
    public List<CategoryResponseDTO> pagelist(){
        return categoryService.pagingFindAll();
    }
}

CategoryRepository

//Repository인터페이스는 내부적으로 구현체를 스프링프레임워크에서 제공하므로 이 자체가 DAO의 역할을 할 수 있다.
//서비스단에서 Repository를 직접 호출해서 사용할 수 있다(프로젝트의 규모가 작은곳)
// view -> controller -> service -> repository

//규모가 큰 프로젝트 같은 경우 view -> controller -> service -> dao -> repository순서로 호출
public interface CategoryRepository extends JpaRepository<CategoryEntity,Long> {
    //로그인 - 컬럼이 id와 pass라 가정(and조건)
    //CategoryEntity findByIdAndPass(String id, String pass);
    List<CategoryEntity> findByCategoryNameContaining(String categoryName);
    //categoryName컬럼이 매개변수로 시작하는 경우 조회
    List<CategoryEntity> findByCategoryNameStartingWith(String categoryName);
    //위의 메소드와 동일한데 페이징처리를 하고싶은 경우
    Page<CategoryEntity> findByCategoryNameStartingWith(String categoryName, Pageable pageRequest);
    Slice<CategoryEntity> findByInfoStartingWith(String info, Pageable pageRequest);
}

CategoryDAOImpl

@Repository
@RequiredArgsConstructor
public class CategoryDAOImpl implements CategoryDAO{
    //스프링프레임워크가 CategoryRepository의 구현체를 만들어서 autowired한다.
    private final CategoryRepository repository;

    @Override
    public void write(CategoryEntity category) {
        //create
        repository.save(category);
    }

    @Override
    public List<CategoryEntity> findAll() {
        //List
        return repository.findAll();
    }

    @Override
    public List<CategoryEntity> pagingFindAll() {
        //페이징처리
        //1. Pageable객체만들기
        //2. repository의 페이징메소드 호출
        //3. 리턴되는 Page객체에서 List에 저장된 Entity추출하기

        //셋팅해야하는 값들을 매개변수로 전달받아서 셋팅 - pageNumber
        PageRequest pageRequest = PageRequest.of(0, 5, Sort.by(Sort.Direction.DESC, "categoryId"));
        Page<CategoryEntity> page =repository.findAll(pageRequest);
        System.out.println("-----------------------");
        System.out.println("전체레코드수=>"+page.getTotalElements());
        System.out.println("페이지수=>"+page.getTotalPages());
        System.out.println("조회한 레코드수=>"+page.getNumberOfElements());
        System.out.println("한페이지사이즈=>"+page.getSize());
        System.out.println("-----------------------");
        return page.getContent();
    }

    @Override
    public CategoryEntity findById(long categoryId) {
        //read
        return repository.findById(categoryId).get();
    }
}

CategoryServiceImpl

@Service
@RequiredArgsConstructor
public class CategoryServiceImpl implements CategoryService{
    private final CategoryDAO dao;
    @Override
    public void write(CategoryRequestDTO category) {
        //컨트롤러에서 넘겨받은 CategoryRequestDTO를 entity로 변환해서 넘기기
        //step01 - 생성자를 이용해서 직접 변경
        //CategoryEntity entity = new CategoryEntity(category.getCategoryName(),category.getInfo());
        ModelMapper mapper = new ModelMapper();
        //CategoryRequestDTO가 CategoryEntity로 자동변환
        CategoryEntity entity = mapper.map(category,CategoryEntity.class);
        dao.write(entity);
    }

    @Override
    public List<CategoryResponseDTO> findAll() {
        List<CategoryEntity> entityList = dao.findAll();
        //Entity를 뷰로 넘기면 안된다. entity를 DTO로 변환
        //step3 스트림으로 변환해서 작업
        //=> 스트림은 자바8부터 도입된 API로 컬렉션의 요소를 하나씩 참조해서 여러가지 변환작업이 가능하거나 람다식을 반복처리할 수 있도록 편리한 기능을 제공
        //1. 스트림으로 변환
        //2. 데이터가공 -중간연산
        //map() -> 스트림이 갖고있는 각 요소를 원하는 메소드나 생성자 등을 적용해서 변환할 수 있다.
        // 클래스명 :: 메소드명
        // 클래스명 :: new
        //=> :: 연산자를 통해 new를 참조하는 경우에는 해당 생성자가 미리 만들어져 있다는 것을 전제
        //3. 변환된 요소를 새로운 리스트로 만드는 작업
        List<CategoryResponseDTO> categoryList = entityList.stream()
                                                .map(CategoryResponseDTO :: new)
                                                .collect(Collectors.toList());
        return categoryList;
    }

    @Override
    public List<CategoryResponseDTO> pagingFindAll() {
        //dao의 메소드를 호출하고 데이터를 변환
        List<CategoryEntity> entityList = dao.pagingFindAll();
        //step4. 스트림으로 변환(ModelMapper를 이용)
        ModelMapper mapper = new ModelMapper();
        List<CategoryResponseDTO> categorylist = entityList.stream()
                .map(entity -> mapper.map(entity, CategoryResponseDTO.class))
                .collect(Collectors.toList());
        return categorylist;
    }

    @Override
    public CategoryResponseDTO findById(long categoryId) {
        //Entity를 DTO로 변환해서 넘기기
        //step2 builder를 활용해서 작업하기
        CategoryEntity entity = dao.findById(categoryId);

        return CategoryResponseDTO.builder()
                .categoryId(entity.getCategoryId())
                .categoryName(entity.getCategoryName())
                .info(entity.getInfo())
                .build();
    }
}

CategoryDAOImplTest

@SpringBootTest
@Transactional
@Rollback(value = false)
class CategoryDAOImplTest {
    @Autowired
    CategoryRepository repository;

    @Test
    public void test1(){
        CategoryEntity category1 = new CategoryEntity("셔츠","블라우스포함");
        CategoryEntity category2 = new CategoryEntity("가방","자체제작");
        CategoryEntity category3 = new CategoryEntity("팬츠","반바지포함");
        CategoryEntity category4 = new CategoryEntity("악세사리","목걸이, 리본포함");
        //한꺼번에 insert
        repository.saveAll(Lists.newArrayList(category1,category2,category3,category4));

    }

    @Test
    public void test2(){
        //update
        //1. 수정할레코드를 조회
        CategoryEntity category = repository.findById(2L).get();
        System.out.println(category);

        //2. setter메소드를 호출해서 변경
        category.setCategoryName("후드티");
        category.setInfo("스투시와 나이키");

        //3.save호출
        //save메소드는 객체를 새롭게 만들어서 작업하는 경우 insert문이 만들어지고
        //조회된 객체의 setter메소드를 호출해서 값을 변경하는 경우에는 update문이 만들어진다.
        //=>JPA내부에서 최초로 만들어진 객체의 이미지를 저장하고 있다가 변경되면 update호출
        repository.save(category);
    }

    @Test
    public void test3(){
        List<CategoryEntity> list = repository.findByCategoryNameContaining("가");
        System.out.println(list);
    }
}

https://docs.spring.io/spring-data/jpa/reference/jpa/query-methods.html

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.