Spring에서의 JPA 🔥

JOY🌱·2023년 4월 12일

🐸 JPA

목록 보기

7/8

🙋‍ Spring에서 JPA를 활용해보자 !

GitHub

📌 기본 셋팅

👉 application.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();
	}
}

👀 templates (views)

👉 main.html

	<h1 align="center">🍝🍩 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/regist'">메뉴 등록하기</button>
	<button onclick="location.href='/menu/modify'">메뉴 수정하기</button>
	<button onclick="location.href='/menu/remove'">메뉴 삭제하기</button>
	<button onclick="searchMenu()">메뉴 검색하기</button>
	<button onclick="location.href='/menu/recommend'">오늘의 메뉴 추천받기</button>
	</div>
	
	<script>
		/* 입력된 키워드로 검색한 결과를 화면에 조회시키기 */
		function searchMenu() {
			
			const keyword = prompt('키워드를 입력해주세요 🥳')
			
			if(keyword !== null && keyword.trim().length !== 0) {
				console.log(keyword);
				window.location.href = "/menu/search?keyword=" + keyword;
			} else {
				alert('키워드를 입력해주세요 🤥')
			}
		}
	</script>

👉 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>
	
	<script>
	/* 신규 메뉴 등록 or 메뉴 삭제 후, 해당 페이지로 redirect 되기 전 alert 띄우기 */
	if(window.location.hash === '#menu-regist' || window.location.hash === '#menu-remove'){
	    alert('[[${message}]]'); // message 변수는 컨트롤러에서 전달한 Flash Attribute
	}
	</script>

👉 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 align="center" action="/menu/remove" method="post">
		<label>삭제할 메뉴 : </label>
		<select name="menuCode" id="menuCode"></select><br>
		<input type="submit" value="전송">
	</form>

	<script>
		/* 비동기 통신(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].menuName}</option>`;
						// 조회된 메뉴의 이름을 화면에 노출시키고 그 메뉴가 선택(<option>)되면 value는 해당 메뉴의 코드
					}
					/* 그 값을 <select>에 insert하여 화면에 노출되도록 함 */
					document.querySelector("#menuCode").insertAdjacentHTML('beforeend', html);
					
				},
				error : function(xhr) {
					console.log(xhr);
				}
			});
		})
	</script>

👀 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

@PathVariable @ResponseBody RedirectAttributes addFlashAttribute() shuffle() subList()

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

	private MenuService menuService;
	
	public MenuController(MenuService menuService) {
		this.menuService = menuService;
	}

	/* 메뉴 코드로 해당 메뉴 조회하기 */
	@GetMapping("/{menuCode}")
	public String findMenuByCode(@PathVariable int menuCode, Model model) {
		
		MenuDTO menu = menuService.findMenuByCode(menuCode);
//		System.out.println("menu : " + menu);
		
		model.addAttribute("menu", menu);
		
		return "menu/one";
	}

	/* 모든 메뉴 리스트 조회하기 */
	@GetMapping("/list")
	public String findAllMenu(Model model) {
		
		List<MenuDTO> menuList = menuService.findAllMenu();
		
		model.addAttribute("menuList", menuList);
		
		return "menu/list";
	}

	/* '메뉴 등록하기'를 위한 화면 전환 */
	@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(@ModelAttribute MenuDTO newMenu, RedirectAttributes rttr) { /* @ModelAttribute는 생략되어도 정상 동작하지만 명시 */
		
		menuService.registNewMenu(newMenu);
		
		rttr.addFlashAttribute("message", "메뉴 등록 성공! 등록된 메뉴를 확인하세요 🥳");
		
		return "redirect:/menu/list#menu-regist";
	}

	/* 메뉴 수정하기 */
	@GetMapping("/modify")
	public void modifyPage() {}
	
	@PostMapping("/modify")
	public String menuModify(@ModelAttribute MenuDTO menu, RedirectAttributes rttr) {
		
		menuService.modifyMenu(menu);
		
		rttr.addFlashAttribute("message", "메뉴 수정 성공! 수정된 메뉴를 확인하세요 😍");
		
		/* 수정된 메뉴의 상세페이지로 이동 */
		return "redirect:/menu/" + menu.getMenuCode() + "#menu-modify";
	}

	/* 메뉴 삭제하기 */
	@GetMapping("/remove")
	public void removePage() {}
	
	/* 메뉴 리스트를 조회하는 비동기 통신(ajax) */
	@GetMapping(value="menu", produces="application/json; charset=UTF-8")
	@ResponseBody /* 반환하는 값이 곧 응답되는 값의 바디 */
	public List<MenuDTO> findMenuList() {
		
		return menuService.findAllMenu();
	}
	
	@PostMapping("/remove")
	public String menuRemove(@ModelAttribute MenuDTO menu, RedirectAttributes rttr) {
		
		menuService.removeMenu(menu);
		
		rttr.addFlashAttribute("message", "메뉴 삭제 성공! 👋");
		
		return "redirect:/menu/list#menu-remove";
	}

	/* 메뉴 검색하기 */
	@GetMapping("/search")
	public String searchedPage(@RequestParam(value="keyword", required=false) String keyword, Model model) {
		
		List<MenuDTO> menuList = menuService.searchMenu(keyword);
		
		model.addAttribute("menuList", menuList);
		
		return "/menu/list";
	}

	/* 오늘의 메뉴 추천받기 */
	@GetMapping("/recommend")
	public String recommendPage(Model model) {
		
		List<MenuDTO> menuList = menuService.findAllMenu();
		
		Collections.shuffle(menuList); // shuffle() 메소드로 menuList 안에 있는 값 랜덤으로 재배치
		List<MenuDTO> recommendedMenulist = menuList.subList(0, 5); // subList() 메소드로 0부터 4번 인덱스까지만 추출
		
		model.addAttribute("menuList", recommendedMenulist);
		
		return "/menu/list";
	}
}

👀 Service

@PersistenceContext : 스프링 부트가 영속성 컨텍스트를 관리하는 엔티티 매니저를 주입하는 어노테이션
modelMapper.map() stream().map() collect(Collectors.toList())

👉 MenuService

@Service
public class MenuService {

	private MenuRepository menuRepository;	// MenuRepository를 참조하기 위해 필드 선언 및 생성자를 통한 의존성 주입
	private ModelMapper modelMapper;		// ModelMapper를 참조하기 위해 필드 선언 및 생성자를 통한 의존성 주입
	
	@PersistenceContext // 스프링 부트가 영속성 컨텍스트를 관리하는 엔티티 매니저를 주입하는 어노테이션
	private EntityManager entityManager;
	
	public MenuService(MenuRepository menuRepository, ModelMapper modelMapper) {
		this.menuRepository = menuRepository;
		this.modelMapper = modelMapper;
	}

	/* 영속성 객체(엔티티)를 그대로 사용하면 데이터가 훼손 될 가능성이 있으므로 비영속 객체로 변경하여 반환 */
	/* MenuDTO : 엔티티가 아닌 데이터를 묶어서 보낼 수 있는 객체 */
	/* 메뉴 코드로 해당 메뉴 조회하기 */
	public MenuDTO findMenuByCode(int menuCode) {
		
		/* Menu -> MenuDTO(비영속 객체)로 변환할 수 있는 ModelMapper 라이브러리 의존성 추가 후 사용 */
		return modelMapper.map(menuRepository.findMenuByCode(entityManager, menuCode), MenuDTO.class);
		// modelMapper.map(변환하고자하는 대상의 엔티티 객체, 변환하고자하는 타입);
	}

	/* 모든 메뉴 리스트 조회하기 */
	public List<MenuDTO> findAllMenu() {
		
		/* List<Menu> Menu 객체가 여러 개 있으므로 Stream화 시켜 MenuDTO */
		List<Menu> menuList = menuRepository.findAllMenu(entityManager);
		
		return menuList.stream().map(menu -> modelMapper.map(menu, MenuDTO.class)).collect(Collectors.toList());
		/* menu : Menu 엔티티 객체들
		 * stream의 map()은 괄호 안의 동작을 하나하나 수행하고 나서 가공된 결과를 반환 
		 * collect(Collectors.toList() : 다시 stream을 List 형태로 변환 */
		
		/* 
		 * [코드 해석]
		 * 1. menuList라는 List<Menu> 타입을 stream화 하여 map() 사용
		 * 2. menu라는 Menu 엔티티 객체들을 modelMapper의 map()메소드를 통해 MenuDTO 타입으로 변환
		 * 3. 다시 stream을 List형태로 변환
		 */
	}

	/* 모든 카테고리 리스트 조회하기 */
	public List<CategoryDTO> findAllCategory() {
		
		List<Category> categoryList = menuRepository.findAllCategory(entityManager);
		
		return categoryList.stream().map(category -> modelMapper.map(category, CategoryDTO.class)).collect(Collectors.toList());
	}

	/* 스프링에서는 트랜잭션 처리를 지원
	 * 어노테이션으로 @Transactional을 선언하는 선언적 트랜잭션이 보편적인 방식
	 * 클래스 레벨과 메소드 레벨에 작성될 수 있고 클래스 레벨에 작성 시 하위 모든 메소드에 적용
	 * 어노테이션이 선언되면 메소드 호출 시 자동으로 프록시 객체(가로채는 객체)가 생성되며 해당 프록시 객체는 정상 수행 여부에 따라
	 * commit, rollback 처리를 함 */
	
	/* 메뉴 등록하기 */
	@Transactional
	public void registNewMenu(MenuDTO newMenu) {
		
		/* 이전 방식과는 반대로 MenuDTO를 Menu형태로 변경하여 Menu타입으로 전달 */
		menuRepository.registNewMenu(entityManager, modelMapper.map(newMenu, Menu.class));
	}

	/* 메뉴 수정하기 */
	@Transactional
	public void modifyMenu(MenuDTO menu) {
		
		menuRepository.modifyMenu(entityManager, modelMapper.map(menu, Menu.class));
	}

	/* 메뉴 삭제하기 */
	@Transactional
	public void removeMenu(MenuDTO menu) {
		
		menuRepository.removeMenu(entityManager, modelMapper.map(menu, Menu.class));
	}

	/* 메뉴 검색하기 */
	public List<MenuDTO> searchMenu(String keyword) {
		
		List<Menu> menuList = menuRepository.searchMenu(entityManager, keyword);
		
		return menuList.stream().map(menu -> modelMapper.map(menu, MenuDTO.class)).collect(Collectors.toList());
	}
}

👀 Repository

find() persist() remove() createQuery() getResultList() setParameter()

👉 MenuRepository

@Repository
public class MenuRepository {

	/* 메뉴 코드로 해당 메뉴 조회하기 */
	public Menu findMenuByCode(EntityManager entityManager, int menuCode) {
		
		/* find()는 테이블의 PK를 통해 해당 데이터를 가져오는 메소드이므로 여기서도 EntityManager를 활용하여 가져옴 */
		return entityManager.find(Menu.class, menuCode);
	}

	/* 모든 메뉴 리스트 조회하기 */
	public List<Menu> findAllMenu(EntityManager entityManager) {
		
		String jpql = "SELECT m FROM Menu AS m ORDER BY m.menuCode ASC";
		
		return entityManager.createQuery(jpql, Menu.class).getResultList();
	}

	/* '메뉴 등록하기'에서 필요한 카테고리 리스트 조회하기(ajax) */
	public List<Category> findAllCategory(EntityManager entityManager) {
		
		String jpql = "SELECT c FROM Category AS c ORDER BY c.categoryCode ASC";
				
		return entityManager.createQuery(jpql, Category.class).getResultList();
	}
	
	/* 메뉴 등록하기 */
	public void registNewMenu(EntityManager entityManager, Menu menu) {
		
		/* entityManager야, 영속성 컨텍스트에 menu를 저장하고 관리해주렴! */
		entityManager.persist(menu);
	}

	/* 메뉴 수정하기 */
	public void modifyMenu(EntityManager entityManager, Menu menu) {
		
		/* menu : 클라이언트로부터 입력받은 menuCode, menuName, menuPrice, categoryCode, orderableStatus가 넘어옴 */
		System.out.println(menu);
		
		/* 전달 받은 메뉴 정보를 통해 해당 엔티티를 먼저 조회 */
		Menu selectedMenu = entityManager.find(Menu.class, menu.getMenuCode());
		
		/* 조회된 메뉴 객체를 수정 */
		selectedMenu.setMenuName(menu.getMenuName());
		selectedMenu.setMenuPrice(menu.getMenuPrice());
		selectedMenu.setCategoryCode(menu.getCategoryCode());
		selectedMenu.setOrderableStatus(menu.getOrderableStatus());
	}

	/* 메뉴 삭제하기 */
	public void removeMenu(EntityManager entityManager, Menu menu) {
		
		/* 전달 받은 메뉴 정보를 통해 해당 엔티티를 먼저 조회 */
		Menu selectedMenu = entityManager.find(Menu.class, menu.getMenuCode());
		
		entityManager.remove(selectedMenu);
	}

	/* 메뉴 검색하기 */
	public List<Menu> searchMenu(EntityManager entityManager, String keyword) {
		
		String jpql = "SELECT m FROM Menu AS m WHERE m.menuName LIKE :keyword ORDER BY m.menuCode ASC";
		
		return entityManager.createQuery(jpql, Menu.class).setParameter("keyword", "%"+keyword+"%").getResultList();
	}
}

JOY🌱

Tiny little habits make me

이전 포스트

네이티브 쿼리 (Native Query)

다음 포스트