Spring Data JPA 🔥

JOY🌱·2023년 4월 14일

🐸 JPA

목록 보기

8/8

📌 기본 셋팅

👉 applicaiton.yml

# server port config
server:
  port: 8001
  
# DB config
spring:
  datasource:
    driver-class-name: oracle.jdbc.driver.OracleDriver
    url: jdbc:oracle:thin:@localhost:1521:xe
    username: C##GREEDY
    password: GREEDY
    
# JPA config
  jpa:
    generate-ddl: false       # create table을 할 때만 true(기본값)
    show-sql: true            # JPA가 수행하는 SQL구문을 콘솔에서 확인 가능
    database: oracle
    properties:
      hibernate:
        '[format_sql]': true  # SQL을 개행하여 보기좋게 출력

👉 pom.xml

<!-- Menu(영속성 객체) -> MenuDTO(비영속성 객체)로 변환할 수 있는 ModelMapper 라이브러리 -->
<!-- https://mvnrepository.com/artifact/org.modelmapper/modelmapper -->
	<dependency>
		<groupId>org.modelmapper</groupId>
		<artifactId>modelmapper</artifactId>
		<version>3.1.1</version>
	</dependency>

👉 BeanConfiguration

@Configuration
public class BeanConfiguration {

	/* ModelMapper라이브러리 추가 후, ModelMapper객체를 사용하기 위해 Bean 등록 */
	@Bean
	public ModelMapper modelMapper() {
		
		return new ModelMapper();
	}
}

👉 PagingButtonInfo

public class PagingButtonInfo {
	
	private int currentPage;
	private int startPage;
	private int endPage;
	
	/* 기본 셋팅 */

}

👉 Pagenation

public class Pagenation {
	
	public static PagingButtonInfo getPagingButtonInfo(Page page) {
		
		int currentPage = page.getNumber() + 1;	 /* 인덱스 기준이므로 +1 */
		int defaultButtonCount = 10;
		int startPage;
		int endPage;
		
		startPage = (int) (Math.ceil((double) currentPage / defaultButtonCount) - 1) * defaultButtonCount + 1;
		endPage = startPage + defaultButtonCount - 1;
		
		/* 내가 가진 총 페이지 수가 4일 경우, endPage(10)보다 작으므로 endPage를 4로 변경하는 로직 */
		if(page.getTotalPages() < endPage)
			endPage = page.getTotalPages();
		
		if(page.getTotalPages() == 0 && endPage == 0)
			endPage = startPage;
		
		return new PagingButtonInfo(currentPage, startPage, endPage);
	}
    
}

👀 Templates (views)

👉 main.html

<h1 align="center">🌭🍤 WELCOME TO GREEDY RESTAURANT 🍳🍕</h1>
	
	<div align="center">
	<button onclick="location.href='/menu/81'">81번 메뉴 보기</button>
	<button onclick="location.href='/menu/list'">메뉴판 보기</button>
	<button onclick="location.href='/menu/querymethod'">쿼리메소드 테스트</button>
	<button onclick="location.href='/menu/regist'">메뉴 등록하기</button>
	<button onclick="location.href='/menu/modify'">메뉴 수정하기</button>
	<button onclick="location.href='/menu/delete'">메뉴 삭제하기</button>
	</div>

👉 one.html

<h1 align="center">✨ 메뉴 ✨</h1>

	<table align="center" border="1">
		<tr>
			<th>메뉴번호</th>
			<th>메뉴명</th>
			<th>메뉴가격</th>
			<th>카테고리코드</th>
			<th>판매상태</th>
		</tr>
		<tr>
			<td th:text="${ menu.menuCode }"></td>
			<td th:text="${ menu.menuName }"></td>
			<td th:text="${ menu.menuPrice }"></td>
			<td th:text="${ menu.categoryCode }"></td>
			<td th:text="${ menu.orderableStatus }"></td>
		</tr>
	</table>
	
	<script>
	/* 메뉴 수정 후, 해당 페이지로 redirect 되기 전 alert 띄우기 */
	if(window.location.hash === '#menu-modify'){
	    alert('[[${message}]]'); // message 변수는 컨트롤러에서 전달한 Flash Attribute
	}
	</script>

👉 list.html

<h1 align="center">✨ 메뉴판 ✨</h1>

	<table align="center" border="1">
		<tr>
			<th>메뉴번호</th>
			<th>메뉴명</th>
			<th>메뉴가격</th>
			<th>카테고리코드</th>
			<th>판매상태</th>
		</tr>
		<tr th:each="menu : ${ menuList }">
			<td th:text="${ menu.menuCode }"></td>
			<td th:text="${ menu.menuName }"></td>
			<td th:text="${ menu.menuPrice }"></td>
			<td th:text="${ menu.categoryCode }"></td>
			<td th:text="${ menu.orderableStatus }"></td>
		</tr>
	</table>
	
	<div align="center" id="paging" >
		
		<!-- 맨 앞으로 이동 -->
		<button th:onclick="'location.href=\'/menu/list?page=' + @{${paging.startPage}} + '\''">◀◀</button>
		
		<!-- 이전 페이지로 이동 -->
		<button th:onclick="'location.href=\'/menu/list?page=' + @{${paging.currentPage - 1}} + '\''"
				th:disabled="${ menuList.first }">◀</button>
		
		<!-- 숫자 버튼 -->
		<th:block th:each="page : ${ #numbers.sequence(paging.startPage, paging.endPage)}">
			<button th:onclick="'location.href=\'/menu/list?page=' + @{${page}} + '\''"
					th:text="${ page }"
					th:disabled="${ paging.currentPage eq page }">
			</button>
		</th:block>
		
		<!-- 다음 페이지로 이동 -->
		<button th:onclick="'location.href=\'/menu/list?page=' + @{${paging.currentPage + 1}} + '\''"
				th:disabled="${ menuList.last }">▶</button>
		
		<!-- 맨 끝으로 이동 -->
		<button th:onclick="'location.href=\'/menu/list?page=' + @{${paging.endPage}} + '\''">▶▶</button>
	</div>
	
	
	<script>
	/* 신규 메뉴 등록 or 메뉴 삭제 후, 해당 페이지로 redirect 되기 전 alert 띄우기 */
	if(window.location.hash === '#menu-regist' || window.location.hash === '#menu-remove'){
	    alert('[[${message}]]'); // message 변수는 컨트롤러에서 전달한 Flash Attribute
	}
	</script>

👉 list2.html

<h1 align="center">✨ <span th:text="${ #numbers.formatInteger(menuPrice, 3, 'COMMA') }"></span>원 초과인 메뉴들 ✨</h1>

	<table align="center" border="1">
		<tr>
			<th>메뉴번호</th>
			<th>메뉴명</th>
			<th>메뉴가격</th>
			<th>카테고리코드</th>
			<th>판매상태</th>
		</tr>
		<tr th:each="menu : ${ menuList }">
			<td th:text="${ menu.menuCode }"></td>
			<td th:text="${ menu.menuName }"></td>
			<td th:text="${ menu.menuPrice }"></td>
			<td th:text="${ menu.categoryCode }"></td>
			<td th:text="${ menu.orderableStatus }"></td>
		</tr>
	</table>

👉 querymethod.html

<h3>입력 가격을 초과하는 메뉴의 목록 조회</h3>
<form action="/menu/test1">
		
	<input type="number" name="menuPrice">원 초과의 메뉴 목록 조회<br>
	<input type="submit" value="조회">
		
</form>

👉 regist.html

<h3 align="center">신규 메뉴 등록</h3>
	
<form align="center" action="/menu/regist" method="post">
	<label>메뉴 이름 : </label><input type="text" name="menuName"><br>
	<label>메뉴 가격 : </label><input type="number" name="menuPrice"><br>
	<label>카테고리 : </label>
	<select name="categoryCode" id="categoryCode">
		<!-- 
			카테고리 내용이 변화할 수 있다면 조회 해서 처리해야 하며
			여기에서는 ajax로 처리
		-->
	</select><br>
	<label>판매 상태 : </label>
	<select name="orderableStatus">
		<option value="Y">판매가능</option>
		<option value="N">판매불가</option>
	</select><br>
	<input type="submit" value="전송">
</form>

<script>
	/* 비동기 통신(ajax)을 통해 모든 카테고리 리스트 조회 */
	$(function(){
		$.ajax({
			url : '/menu/category',
			success : function(data) {
				console.log(data);
					
				let html = '';
				/* data라는 조회된 배열을 반복하여 합산시키기 */
				for(let index in data) {
					html += `<option value='${data[index].categoryCode}'>${data[index].categoryName}</option>`;
					// 조회된 카테고리의 이름을 화면에 노출시키고 그 카테고리가 선택(<option>)되면 value는 해당 카테고리의 코드
				}
				/* 그 값을 <select>에 insert하여 화면에 노출되도록 함 */
				document.querySelector("#categoryCode").insertAdjacentHTML('beforeend', html);
					
			},
			error : function(xhr) {
				console.log(xhr);
			}
		});
	})
</script>

👉 modify.html

	<h3 align="center">메뉴 수정</h3>
	
	<form align="center" action="/menu/modify" method="post">
		<label>수정할 메뉴 : </label>
		<select name="menuCode" id="menuCode"></select><br>
		<label>새로운 메뉴 이름 : </label>
		<input type="text" name="menuName"><br>
		<label>새로운 메뉴 가격 : </label>
		<input type="number" name="menuPrice"><br>
		<label>새로운 메뉴의 카테고리 : </label>
		<select name="categoryCode" id="categoryCode"></select><br>
		<label>판매 상태 : </label>
		<select name="orderableStatus">
			<option value="Y">판매가능</option>
			<option value="N">판매불가</option>
		</select><br>
		<input type="submit" value="전송">
	</form>
	
	<script>
		/* 비동기 통신(ajax)을 통해 모든 카테고리 리스트 조회 */
		$(function(){
			$.ajax({
				url : '/menu/category',
				success : function(data) {
					console.log(data);
					
					let html = '';
					/* data라는 조회된 배열을 반복하여 합산시키기 */
					for(let index in data) {
						html += `<option value='${data[index].categoryCode}'>${data[index].categoryName}</option>`;
						// 조회된 카테고리의 이름을 화면에 노출시키고 그 카테고리가 선택(<option>)되면 value는 해당 카테고리의 코드
					}
					/* 그 값을 <select>에 insert하여 화면에 노출되도록 함 */
					document.querySelector("#categoryCode").insertAdjacentHTML('beforeend', html);
					
				},
				error : function(xhr) {
					console.log(xhr);
				}
			});
		})
		
		/* 비동기 통신(ajax)을 통해 모든 메뉴 리스트 조회 */
		$(function(){
			$.ajax({
				url : '/menu/menu',
				success : function(data) {
					console.log(data);
					
					let html = '';
					/* data라는 조회된 배열을 반복하여 합산시키기 */
					for(let index in data) {
						html += `<option value='${data[index].menuCode}'>[${data[index].menuCode}] ${data[index].menuName}</option>`;
						// 조회된 메뉴코드와 이름을 화면에 노출시키고 그 메뉴가 선택(<option>)되면 value는 해당 메뉴의 코드
					}
					/* 그 값을 <select>에 insert하여 화면에 노출되도록 함 */
					document.querySelector("#menuCode").insertAdjacentHTML('beforeend', html);
					
				},
				error : function(xhr) {
					console.log(xhr);
				}
			});
		})
	</script>

👉 delete.html

	<h3 align="center">메뉴 삭제</h3>
	
	<form action="/menu/delete" method="post">
		<label>삭제할 메뉴의 번호 : </label>
		<input type="number" name="menuCode"><br>
		<input type="submit" value="전송">
	</form>

👀 Entity

👉 Category

@Entity
@Table(name="TBL_CATEGORY")
public class Category {

	@Id
	@Column(name="CATEGORY_CODE")
	private int categoryCode;
	
	@Column(name="CATEGORY_NAME")
	private String categoryName;
	
	@Column(name="REF_CATEGORY_CODE")
	private Integer refCategoryCode;
    
    /* 기본 셋팅 */
    
}

@Entity
@Table(name="TBL_MENU")
@SequenceGenerator(						
		name="SEQ_MENU_CODE_GENERATOR",	
		sequenceName="SEQ_MENU_CODE",	
		initialValue=100,				
		allocationSize=1				
)
public class Menu {
	
	@Id							
	@Column(name="MENU_CODE")	
	@GeneratedValue(								
			strategy=GenerationType.SEQUENCE,		
			generator="SEQ_MENU_CODE_GENERATOR"		
	)
	private int menuCode;
	@Column(name="MENU_NAME")
	private String menuName;
	@Column(name="MENU_PRICE")
	private int menuPrice;
	@Column(name="CATEGORY_CODE")
	private int categoryCode;
	@Column(name="ORDERABLE_STATUS")
	private String orderableStatus;
    
    /* 기본 셋팅 */
    
}

👀 DTO

👉 CategoryDTO

public class CategoryDTO {

	private int categoryCode;
	private String categoryName;
	private Integer refCategoryCode;
    
    /* 기본 셋팅 */
    
}

👉 MenuDTO

public class MenuDTO {
	
	private int menuCode;
	private String menuName;
	private int menuPrice;
	private int categoryCode;
	private String orderableStatus;
    
	/* 기본 셋팅 */

}

👀 Controller

👉 MainController

@Controller
public class MainController {

	@GetMapping(value = {"/", "/main"})
	public String main() {
		
		return "main/main";
	}
	
}

👉 MenuController

@Controller
@RequestMapping("/menu")
@Slf4j
public class MenuController {

	private final MenuService menuService;
	
	public MenuController(MenuService menuService) {
		this.menuService = menuService;
	}
	
	@GetMapping("/{menuCode}")
	public String findMenuByCode(@PathVariable int menuCode, Model model) {
		
		MenuDTO menu = menuService.findMenuByCode(menuCode);
		
		model.addAttribute("menu", menu);
		
		return "menu/one";
	}
	
	/* 페이징 처리 전 */
//	@GetMapping("list")
//	public String findMenuList(Model model) {
//		
//		List<MenuDTO> menuList = menuService.findMenuList();
//		model.addAttribute("menuList", menuList);
//		
//		return "menu/list";
//	}
	
	/* 페이징 처리 후 */
	@GetMapping("list")
	public String findMenuList(@PageableDefault Pageable pageable, Model model) {
		
		/* page -> number, size, sort 파라미터가 Pageable 객체에 담김 */
		log.info("pageable : {}", pageable);
		
		Page<MenuDTO> menuList = menuService.findMenuList(pageable); // 반환값, 매개변수 타입이 페이징 처리 전과 다름
		
		log.info("조회한 내용 목록 : {}", menuList.getContent());
		log.info("총 페이지 수 : {}", menuList.getTotalPages());
		log.info("총 메뉴 수 : {}", menuList.getTotalElements());
		log.info("해당 페이지에 표시 될 요소 수 : {}", menuList.getSize());
		log.info("해당 페이지의 실제 요소 수 : {}", menuList.getNumberOfElements());
		log.info("첫 페이지 여부 : {}", menuList.isFirst());
		log.info("마지막 페이지 여부 : {}", menuList.isLast());
		log.info("정렬 방식 : {}", menuList.getSort());
		log.info("여러 페이지 중 현재 인덱스 : {}", menuList.getNumber());
		
		/* StartPage와 EndPage를 계산하기 위한 로직(common패키지에 Pagenation, PagingButtonInfo 필요) */
		PagingButtonInfo paging = Pagenation.getPagingButtonInfo(menuList);
		
		model.addAttribute("paging", paging);
		model.addAttribute("menuList", menuList);
		
		
		return "menu/list";
	}
	
	/* 쿼리 메소드의 사용 */
	@GetMapping("/querymethod")
	public void queryMethodPage() {}
	
	@GetMapping("/test1")
	public String menuTest1(@RequestParam Integer menuPrice, Model model) { /* name 속성과 일치시키기 */
		
		List<MenuDTO> menuList = menuService.menuTest1(menuPrice);
		
		model.addAttribute("menuList", menuList);
		model.addAttribute("menuPrice", menuPrice);
		
		return "menu/list2";
	} 
	
	/* 메뉴 등록하기 (jpql, native query 사용) */
	@GetMapping("/regist")
	public void registPage() {}
	
	/* 카테고리 리스트를 조회하는 비동기 통신(ajax) */
	@GetMapping(value="category", produces="application/json; charset=UTF-8")
	@ResponseBody /* 반환하는 값이 곧 응답되는 값의 바디 */
	public List<CategoryDTO> findCategoryList() {
		
		return menuService.findAllCategory();
	}
	
	@PostMapping("/regist")
	public String registNewMenu(MenuDTO newMenu, RedirectAttributes rttr) {
		
		menuService.registNewMenu(newMenu);
		
		rttr.addFlashAttribute("message", "메뉴 등록 성공! 등록된 메뉴를 확인하세요 🥳");
		
		return "redirect:/menu/list#menu-regist";
	}
	
	/* 메뉴 수정하기 */
	@GetMapping("/modify")
	public void modifyPage() {}
	
	/* 메뉴 리스트를 조회하는 비동기 통신(ajax) */
	@GetMapping(value="menu", produces="application/json; charset=UTF-8")
	@ResponseBody /* 반환하는 값이 곧 응답되는 값의 바디 */
	public List<MenuDTO> findMenuList() {
		
		return menuService.findMenuList();
	}
	
	@PostMapping("/modify")
	public String menuModify(@ModelAttribute MenuDTO menu, RedirectAttributes rttr) {
		
		menuService.modifyMenu(menu);
		
		rttr.addFlashAttribute("message", "메뉴 수정 성공! 수정된 메뉴를 확인하세요 😍");
		
		/* 수정된 메뉴의 상세페이지로 이동 */
		return "redirect:/menu/" + menu.getMenuCode() + "#menu-modify";
	}
	
	/* 메뉴 삭제하기 */
	@GetMapping("/delete")
	public void deletePage() {}
	
	@PostMapping("/delete")
	public String deleteMenu(@RequestParam Integer menuCode, RedirectAttributes rttr) {
		
		menuService.deleteMenu(menuCode);
		
		rttr.addFlashAttribute("message", "메뉴 삭제 성공! 👀");
		
		return "redirect:/menu/list#menu-remove";
	}
	
}

👀 Service

👉 MenuService

@Service
public class MenuService {
	
	private final CategoryRepository categoryRepository;
	private final MenuRepository menuRepository;
	private final ModelMapper modelMapper;
	
	public MenuService(CategoryRepository categoryRepository, MenuRepository menuRepository, ModelMapper modelMapper) {
		this.categoryRepository = categoryRepository;
		this.menuRepository = menuRepository;
		this.modelMapper = modelMapper;
	}
	
	/* 1. findById (특정 메뉴 보기) */
	public MenuDTO findMenuByCode(int menuCode) {
		
		/* findById 메소드는 이미 구현되어 있으므로 인터페이스에 따로 정의할 필요 X 
		 * findById의 반환값을 Optional 타입. Optional 타입은 NPE를 방지하기 위한 다양한 기능이 존재
		 * 해당 id로 조회되지 못 했을 경우, IllegalArgumentException 발생시킴 */
		Menu menu = menuRepository.findById(menuCode).orElseThrow(IllegalArgumentException::new); 
		// 반환형인 Optional<T>은 조회가 안되었을 경우(null일 경우)를 커버해주기 위한 데이터타입 (NPE 방지)
		// [코드해석] menuCode가 null일 경우, orElseThrow()메소드를 통해 IllegalArgumentException을 발생시킴
		
		/* modelMapper를 사용하여 entity를 DTO로 변환하여 반환 */
		return modelMapper.map(menu, MenuDTO.class);
	}
	
	/* 2. findAll (메뉴판 보기) */
	public List<MenuDTO> findMenuList() {
		
		/* findAll 메소드는 이미 구현되어 있으므로 인터페이스에 따로 정의할 필요 X 
		 * Sort(정렬) 기준을 전달하며 조회할 수도 있음 */
		List<Menu> menuList = menuRepository.findAll(Sort.by("menuCode").descending()); /* Sort.by().descending() : 내림차순(최신순)으로 정렬된 형태로 가져옴 */
		
		/* List<MenuDTO>으로 변환시키는 코드 */
		return menuList.stream().map(menu -> modelMapper.map(menu, MenuDTO.class)).collect(Collectors.toList());
	}

	/* 3. Page -> 페이징 처리 후 */
	public Page<MenuDTO> findMenuList(Pageable pageable) {

		/* page 파라미터가 Pageable의 number 값으로 넘어오는데, 해당 값 조회 시에는 인덱스 기준이 되어야 하기 때문에 -1 처리가 필요 */
		pageable = PageRequest.of(pageable.getPageNumber() <= 0 ? 0 : pageable.getPageNumber() -1, 	// 몇 번째 페이지인지?
								  pageable.getPageSize(),											// 몇 개씩 보여줄건지?
								  Sort.by("menuCode").descending());								// 정렬 기준
		
		Page<Menu> menuList = menuRepository.findAll(pageable);
		
		/* Page는 map()을 가지고 있어 간략하게 작성 가능 (Stream으로 변환 필요 X) */
		return menuList.map(menu -> modelMapper.map(menu, MenuDTO.class));
	}

	/* 4. QueryMethod */
	public List<MenuDTO> menuTest1(Integer menuPrice) {
		
//		List<Menu> menuList = menuRepository.findByMenuPriceGreaterThan(menuPrice);
//		List<Menu> menuList = menuRepository.findByMenuPriceGreaterThanOrderByMenuPrice(menuPrice);
		List<Menu> menuList = menuRepository.findByMenuPriceGreaterThan(menuPrice, Sort.by("menuPrice"));
		
		return menuList.stream().map(menu -> modelMapper.map(menu, MenuDTO.class)).collect(Collectors.toList());
	}

	/* 5. JPQL / native query (카테고리 리스트 조회) */
	public List<CategoryDTO> findAllCategory() {

		List<Category> categoryList = categoryRepository.findAllCategory();
		
		return categoryList.stream().map(category -> modelMapper.map(category, CategoryDTO.class)).collect(Collectors.toList());
	}

	/* 6. save (메뉴 등록하기) */
	@Transactional
	public void registNewMenu(MenuDTO newMenu) {
		
		/* CrudRepository에 미리 정의되어있는 save() 메소드를 통해 하나의 엔티티를 저장 가능 (persist와 동일) */
		menuRepository.save(modelMapper.map(newMenu, Menu.class));
		
	}

	/* 7. findById (메뉴 수정하기-엔티티 조회 후 값 변경) */
	@Transactional
	public void modifyMenu(MenuDTO menu) {
		
		Menu foundMenu = menuRepository.findById(menu.getMenuCode()).orElseThrow(IllegalArgumentException::new);
		
		foundMenu.setMenuName(menu.getMenuName());
		foundMenu.setMenuPrice(menu.getMenuPrice());
		foundMenu.setCategoryCode(menu.getCategoryCode());
		foundMenu.setOrderableStatus(menu.getOrderableStatus());
		
	}

	/* 8. delete (메뉴 삭제하기) */
	@Transactional
	public void deleteMenu(Integer menuCode) {
		
		menuRepository.deleteById(menuCode);
		
	}

}

👀 Repository

👉 MenuRepository

public interface CategoryRepository extends JpaRepository<Category, Integer> {

	/* findAll 메소드를 사용할 수 있지만 여기서는 직접 jpql / native query를 작성해야하는 경우의 설정을 확인 */
	
	/* jpql을 작성 시에는 value만 작성해도 되나, native query 작성 시에는 반드시 nativeQuery=true 속성을 정의해야함 */
	@Query(value="SELECT CATEGORY_CODE, CATEGORY_NAME, REF_CATEGORY_CODE FROM TBL_CATEGORY ORDER BY CATEGORY_CODE ASC"
			, nativeQuery=true)
	public List<Category> findAllCategory(); /* 해당 메소드 호출 시, 위의 쿼리문 실행 */
	
}

👉 CategoryRepository

/* JpaRepository를 상속할 경우, @Repository 어노테이션이 없어도 빈 스캐닝 됨 */
public interface MenuRepository extends JpaRepository<Menu, Integer> { /* 사용할 엔티티(Menu)를 제네릭에 선언 후 import */

	/* 상속한 JpaRepository에 구현이 되어있는 것을 사용할 때는 작성할 코드 X 
	 * But, JpaRepository를 상속 받아 사용하는 메소드 외의 메소드는 직접 정의 */
	
	/* 전달 받은 가격을 초과하는 메뉴의 목록을 조회하는 메소드 */
	List<Menu> findByMenuPriceGreaterThan(Integer menuPrice);

	/* 전달 받은 가격을 초과하는 메뉴의 목록을 '가격 순'으로 조회하는 메소드 */
	List<Menu> findByMenuPriceGreaterThanOrderByMenuPrice(Integer menuPrice);
	
	/* 전달 받은 가격을 초과하는 메뉴의 목록을 '전달 받는 정렬 기준(sort)'으로 조회하는 메소드 */
	List<Menu> findByMenuPriceGreaterThan(Integer menuPrice, Sort sort);

}

JOY🌱

Tiny little habits make me

이전 포스트

Spring Data JPA 🔥

🐸 JPA

📌 기본 셋팅

👉 applicaiton.yml

👉 pom.xml

👉 BeanConfiguration

👉 PagingButtonInfo

👉 Pagenation

👀 Templates (views)

👉 main.html

👉 one.html

👉 list.html

👉 list2.html

👉 querymethod.html

👉 regist.html

👉 modify.html

👉 delete.html

👀 Entity

👉 Category

👉 Menu

👀 DTO

👉 CategoryDTO

👉 MenuDTO

👀 Controller

👉 MainController

👉 MenuController

👀 Service

👉 MenuService

👀 Repository

👉 MenuRepository

👉 CategoryRepository

Spring에서의 JPA 🔥

0개의 댓글