JSP
create.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<h2>책 등록하기</h2>
<!--
요청URI : /createPost
요청파라미터 : {title=개똥이의 모험, category=소설, price=12000}
요청방식 : post
get방식 : 주소표시줄에 요청파라미터가 노출됨
post방식 : 주소표시줄에 요청파라미터가 노출되지 않음. 주소창에 변화 없이
데이터만 서버로 전달 됨
-->
<form action="/createPost" method="post">
<p>제목 : <input type="text" name="title" required placeholder="제목" /></p>
<p>카테고리 : <input type="text" name="category" required placeholder="카테고리" /></p>
<p>가격 : <input type="number" name="price" required placeholder="가격" /></p>
<p>
<!-- <form>~</form> 태그 안에 내용이 서버로 전송됨
서버로 전달되는 항목들은 form 태그 안에 존재해야 함.
name 속성은 key로, value 속성을 value로 판단함
-->
<input type="submit" value="저장" />
<input type="button" value="목록" onclick="javascript:location.href='/list'" />
</p>
</form>
</body>
</html>detail.jsp
java를 통해서 데이터를 전해 받을 땐 ${} 태그를 통해 데이터를 받을 것 c태그를 통해 value값을 설정해 줄 필요가 없음
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>책 상세</title>
</head>
<script>
window.onload = function(){
let p1 = document.querySelector('#viewForm');
let p2 = document.querySelector('#editForm');
let edit = document.querySelector('#edit');
let del = document.querySelector('#del');
p2.hidden = true;
edit.addEventListener('click', function(e){
p1.hidden = true;
p2.hidden = false;
data.forEach(function(item){
console.log(item);
item.readonly = false;
})
})
del.addEventListener('click', function(e){
if(confirm("정말 현재 책을 삭제하시겠습니까?")){
location.href = "/delete?bookId=${vo.bookId}";
}
})
}
</script>
<body>
<!-- //// 일반모드 시작 //// -->
<div id="viewForm">
<h2>책 상세</h2>
<p>제목 : ${vo.title}</p>
<p>카테고리 : ${vo.category}</p>
<p>가격 ${vo.price}</p>
<!-- <form>~</form> 태그 안에 내용이 서버로 전송됨
서버로 전달되는 항목들은 form 태그 안에 존재해야 함.
name 속성은 key로, value 속성을 value로 판단함
-->
<p>
<input type="button" id="edit" value="수정">
<input type="button" id="del" value="삭제">
<input type="button" value="목록" onclick="javascript:location.href='/list'" />
</p>
</div>
<!-- //// 일반모드 끝 //// -->
<!-- //// 수정모드 시작 //// -->
<div id="editForm">
<h2>책 수정</h2>
<form action="/update" method="post">
<input type="hidden" name="bookId" value="${vo.bookId}">
<p>제목 : <input type="text" name="title" required placeholder="제목" value="${vo.title}"/></p>
<p>카테고리 : <input type="text" name="category" required placeholder="카테고리" value="${vo.category}" /></p>
<p>가격 : <input type="number" name="price" required placeholder="가격" value="${vo.price}"/></p>
<!-- <form>~</form> 태그 안에 내용이 서버로 전송됨
서버로 전달되는 항목들은 form 태그 안에 존재해야 함.
name 속성은 key로, value 속성을 value로 판단함
-->
<p>
<input type="submit" value="확인">
<input type="button" value="취소" onclick="location.href='/detail?bookId=${vo.bookId}'">
</p>
</form>
</div>
<!-- //// 수정모드 끝 //// -->
</body>
</html>list.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<!DOCTYPE html>
<html>
<head>
<script type="text/javascript" src="/resources/js/jquery.min.js"></script>
<title>Insert title here</title>
</head>
<body>
<h1>도서 목록</h1>
<a href="/create">도서 등록</a>
<table border="1">
<tr>
<th>번호</th>
<th>제목</th>
<th>카테고리</th>
<th>가격</th>
</tr>
<c:if test="${fn:length(list)==0}">
<tr>
<td colspan="4">등록된 도서가 없습니다</td>
</tr>
</c:if>
<c:forEach items="${list}" var="vo">
<tr>
<td>${vo.bookId}</td>
<td><a href="/detail?bookId=${vo.bookId}">${vo.title}</a></td>
<td>${vo.category}</td>
<td><fmt:formatNumber value="${vo.price}" type="number" pattern="#,###" /></td>
</tr>
</c:forEach>
</table>
</body>
</html>JAVA
BookController.java
- @RequestMapping을 통해 데이터 받을 방식을 전해줌 (servlet의 에노테이션과 유사)
- 페이지를 넘겨주는 방식 sendRedirect
- ModelAndView 를 리턴하는 메서드 생성하여 해당 객체를 생성하고
- 보낼 경로를 작성해준다
- mav객체이름.setViewName(경로);
- 이때 경로는 servlet-content에 있는 <beans의 prefix와 suffix에 따라 작성한다
더보기
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<!-- static folder설정(정적 폴더 설정)=>css, images, upload, js
서버에서 앞서 처리될 필요가 없는 정적 리소스 파일을 처리하는 역할 수행
웹 애플리케이션의 물리적 경로 이름을 설정하고 이 경로에 정적 리소스 파일들을 저장하면
소스 코드나 웹 브라우저의 주소창에서 해당 리소스의 경로를 사용하여 직접 접속할 수 있음
정적 리소스란 클라이언트에서 요청이 들어왔을 때 요청 리소스가 이미 만들어져 있어 그대로 응답하는 것
mapping : 웹 요청 경로 패턴을 설정. 컨텍스트 경로를 제외한 나머지 부분의 경로와 매핑
location : 웹 애플리케이션 내에서 실제 요청 경로의 패턴에 해당하는 자원 위치를 설정. 위치가 여러 곳이면 각 위치를 쉼표로 구분
-->
<!-- http://localhost/resources/ -->
<resources mapping="/resources/**" location="/resources/" />
<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<context:component-scan base-package="kr.or.ddit" />
</beans:beans>- 데이터 보내줌 request.setAttribute()
- mav객체이름.addObject("이름", 보낼 Object)
package kr.or.ddit.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import kr.or.ddit.service.BookService;
import kr.or.ddit.vo.BookVO;
import lombok.extern.slf4j.Slf4j;
/*
Controller 어노테이션
스프링 프레임워크에게 "이 클래스는 웹 브라우저의 요청(request)를
받아들이는 컨트롤러야" 라고 알려주는 것임.
스프링은 servlet-context.xml의 context:component-scan의 설정에 의해
이 클래스를 자바빈 객체로 등록(메모리에 바인딩).
*/
@Slf4j
@Controller
public class BookController {
@Autowired
BookService bookService;
// 책 입력 화면
/*
요청URI : /create
요청파라미터 : 없음
요청방식 : get
*/
/*
method 속성은 http 요청 메소드를 의미함. 일반적인 웹 페이지 개발에서 GEt 메소드는
데이터를 변경하지 않는 경우에, POST 메소드는 데이터가 변경될 경우 사용
책 생성 화면은 웹 브라우저에 화면을 보여줄 뿐 데이터의 변경이 일어나지 않으므로
GET 메소드를 사용함
*/
@RequestMapping(value="/create", method=RequestMethod.GET)
public ModelAndView create() {
/*
ModelAndView
1) Model : Controller가 반환할 데이터(String, int, List, Map, VO..)를 담당
2) View : 화면을 담당(뷰(View : JSP)의 경로)
*/
ModelAndView mav = new ModelAndView();
// <beans:property name="prefix" value="/WEB-INF/views/" />
// <beans:property name="suffix" value=".jsp" />
// prefix(접두어) : /WEB-INF/views/
// suffix(접미어) : .jsp
// /WEB-INF/views/ + book/create + .jsp
mav.setViewName("book/create");
//forwarding
return mav;
}
@RequestMapping(value="/list", method=RequestMethod.GET)
public ModelAndView list() {
ModelAndView mav = new ModelAndView();
mav.setViewName("book/list");
List<BookVO> list = this.bookService.list();
log.info("list->bookVOList : " + list);
//Model : 데이터
mav.addObject("list", list);
//forwarding
return mav;
}
/*
Spring에서 파라미터 명과 매개변수 명이 같으면 파라미터 값이 매개변수 값으로 할당됨
모든 파라미터는 문자. 그래서 price의 값도 숫자형 문자이다
*/
@RequestMapping(value="/createPost", method=RequestMethod.POST)
public ModelAndView createPost(String title, String category, String price, BookVO vo) {
log.info("title : "+title);
log.info("category : "+category);
log.info("price : "+price);
log.info("vo : "+vo);
/*
| 프리젠테이션 계층 | 서비스 계층 | 퍼시스턴스 계층 |
*Controller
뷰(JSP) -> Controller클래스 -> Service인터페이스
*Service *Repository
-> ServiceImpl클래스 -> DAO클래스 -> 매퍼XML -> DB
*/
// 테이블에 도서를 등록
int result = this.bookService.createPost(vo);
System.out.println("createPost -> result : "+result);
ModelAndView mav = new ModelAndView();
mav.setViewName("redirect: /list");
return mav;
}
@RequestMapping(value="/detail", method=RequestMethod.GET)
public ModelAndView detail(BookVO vo) {
ModelAndView mav = new ModelAndView();
mav.setViewName("book/detail");
log.info("vo : "+vo);
vo = this.bookService.detail(vo);
//Model : 데이터
mav.addObject("vo", vo);
//forwarding
return mav;
}
@RequestMapping(value="/update", method=RequestMethod.POST)
public ModelAndView update(BookVO vo) {
ModelAndView mav = new ModelAndView();
mav.setViewName("redirect:/detail?bookId="+vo.getBookId());
log.info("vo : "+vo);
int result = this.bookService.update(vo);
//forwarding
return mav;
}
@RequestMapping(value="/delete", method=RequestMethod.GET)
public ModelAndView delete(BookVO vo) {
ModelAndView mav = new ModelAndView();
mav.setViewName("redirect:/list");
int result = this.bookService.delete(vo);
//forwarding
return mav;
}
}BookVO.java
package kr.or.ddit.vo;
import java.util.Date;
import lombok.Data;
//자바빈 클래스
//1) 멤버변수(프로퍼티) 2) 기본생성자 3) getter/setter메소드
// lombok -> POJO(Plain Oriented Java Object)가 약해짐
@Data
public class BookVO {
private int bookId;
private String title;
private String category;
private int price;
private Date insertDate;
}BookService.java
package kr.or.ddit.service;
import java.util.List;
import kr.or.ddit.vo.BookVO;
public interface BookService {
public int createPost(BookVO vo);
public List<BookVO> list();
public BookVO detail(BookVO vo);
public int update(BookVO vo);
public int delete(BookVO vo);
}BookServiceImpl.java
package kr.or.ddit.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import kr.or.ddit.dao.BookDao;
import kr.or.ddit.service.BookService;
import kr.or.ddit.vo.BookVO;
//서비스 클래스 : 비즈니스 로직
//스프링 MVC 구조에서 Controller와 DAO를 연결하는 역할
/*
스프링 프레임워크는 개발자가 직접 클래스를 생성하는 것을 지양하고,
* 프링은 인터페이스를 좋아해. 자꾸자꾸 좋아지면 Impl은 어떡해
인터페이스를 통해 접근하는 것을 권장하고 있기 때문.(확장성)
그래서 서비스 레이어는 인터페이스(BookService)와 클래스(BookServiceImpl)를 함께 사용함
Impl : implement의 약자
*/
@Service
public class BookServiceImpl implements BookService{
@Autowired
BookDao dao;
@Override
public int createPost(BookVO vo) {
return this.dao.createPost(vo);
}
@Override
public List<BookVO> list() {
return this.dao.list();
}
@Override
public BookVO detail(BookVO vo) {
return this.dao.detail(vo);
}
@Override
public int update(BookVO vo) {
return this.dao.update(vo);
}
@Override
public int delete(BookVO vo) {
return this.dao.delete(vo);
}
}BookDao.java
package kr.or.ddit.dao;
import java.util.List;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import kr.or.ddit.vo.BookVO;
@Repository
public class BookDao {
@Autowired
SqlSessionTemplate sst;
//book_SQL.xml 파일의 namespace가 book이고, id가 insert인
//태그를 찾아 그 안에 들어있는 sql을 실행함
//bookVO=>{"bookId":"","title":"총알탄 개똥이","category":"소설","price":10000,"insertDate":""}
//insert,update,delete는 반영된 건수가 return됨
//insert성공 : 1이상, 실패면 0
public int createPost(BookVO vo) {
return this.sst.insert("book.createPost", vo);
}
public List<BookVO> list() {
return this.sst.selectList("book.list");
}
public BookVO detail(BookVO vo) {
return this.sst.selectOne("book.detail", vo);
}
public int delete(BookVO vo) {
return this.sst.delete("book.delete", vo);
}
public int update(BookVO vo) {
return this.sst.update("book.update", vo);
}
}
sql 연동
pom.xml 의존성 추가
<!-- Database 라이브러리 시작 -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<!-- XML로 쿼리를 작성하게 해주는 라이브러리 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<!-- 스프링과 mybatis를 연동하게 해주는 라이브러리 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<!-- 스프링에서 JDBC(Java DataBase Connectivitiy) -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
<!-- dbcp : database connection pool => 커넥션객체를 미리 만들어놓고 쓰고/반납
최근에는 hikaricp를 사용하는 경우도 있음
-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.7.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.bgee.log4jdbc-log4j2/log4jdbc-log4j2-jdbc4 -->
<!-- 로깅을 위한 라이브러리. 쿼리를 console이나 파일 로그로 볼 수 있음 -->
<dependency>
<groupId>org.bgee.log4jdbc-log4j2</groupId>
<artifactId>log4jdbc-log4j2-jdbc4</artifactId>
<version>1.16</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc6 -->
<!-- ojdbc6 : oracle java database connectivity 드라이버 -->
<dependency>
<groupId>com.oracle.database.jdbc</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.4</version>
</dependency>
<!-- Database 라이브러리 끝 -->더보기
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<!--
pom.xml
메이븐(maven)은 프로젝트를 생성하고 라이브러리를 관리하고 빌드하는 것까지 프로젝트의
라이프 사이클을 관리하는 소프트웨어.
즉, 자동으로 라이브러리를 사용할 수 있게 해줌
pom.xml이 수정되면 Maven빌드를 통해 변경된 Maven 내용을 프로젝트에 반영해야 함
-->
<modelVersion>4.0.0</modelVersion>
<groupId>kr.or</groupId>
<artifactId>ddit</artifactId>
<name>springProj</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.8</java-version>
<org.springframework-version>5.2.5.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<!--
1) 자바빈 클래스(VO)의 getter/setter메소드, toString 자동처리
2) log.info() 메소드로 sysout대신 로그를 console에 출력
1. 개요
메이븐을 사용하게 되면 POM 파일을 다뤄야 합니다.
POM은 Project Object Model의 약자인데...
pom.xml이라는 파일이 바로 POM 파일이고 이 파일을 통해 dependency라고 부르는 의존성 설정을 하게 됩니다...
그리고 각 dependency는 scope을 가지고 있어요...
종류는 compile, runtime, provided 등의 종류가 있지요...
2. compile
compile은 컴파일때 필요한 것입니다... 기본값이기 때문에 만일 scope 설정을 안하면 compile이 기본입니다...
3. runtime
runtime은 런타임때 필요한 것입니다. 컴파일할 때는 필요가 없지만 실행할 때는 필요한 것이지요.
JDBC 드라이버 같은게 되겠습니다.
4. provided
provided는 컴파일때 필요하긴 하지만 런타임때는 JDK 혹은 컨테이너가 제공하는 것입니다.
마지막 패키징 시 포함되지 않음
서블릿이나 JSP 관련 API 같은거죠.
즉 WAS에서 제공하는 servlet-api.jar를 사용하는 경우 (대부분이겠죠) 입니다.
만약 운영환경에서 servlet-api.jar 중복으로 인한 문제가 발생한다면 꼭 provided로 바꿔주셔야 합니다.
5. test
test는 조금 특별한데 테스트 코드를 컴파일할때 필요하지만 배포때는 제외가 됩니다. (따라서 굳이 운영 환경에 JUnit 의존성을 삭제할 필요가 없어요)
easymock, JUnit 같은거죠.
6. system
system은 provided와 유사하지만 JAR 파일을 직접 사용합니다...
이 때는 JAR 파일의 위치를 지정하는 systemPath 엘리먼트가 따라와야 해요...
-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
<scope>provided</scope>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
<!-- Database 라이브러리 시작 -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<!-- XML로 쿼리를 작성하게 해주는 라이브러리 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<!-- 스프링과 mybatis를 연동하게 해주는 라이브러리 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<!-- 스프링에서 JDBC(Java DataBase Connectivitiy) -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
<!-- dbcp : database connection pool => 커넥션객체를 미리 만들어놓고 쓰고/반납
최근에는 hikaricp를 사용하는 경우도 있음
-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.7.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.bgee.log4jdbc-log4j2/log4jdbc-log4j2-jdbc4 -->
<!-- 로깅을 위한 라이브러리. 쿼리를 console이나 파일 로그로 볼 수 있음 -->
<dependency>
<groupId>org.bgee.log4jdbc-log4j2</groupId>
<artifactId>log4jdbc-log4j2-jdbc4</artifactId>
<version>1.16</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc6 -->
<!-- ojdbc6 : oracle java database connectivity 드라이버 -->
<dependency>
<groupId>com.oracle.database.jdbc</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.4</version>
</dependency>
<!-- Database 라이브러리 끝 -->
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>root-context.xml
스프링 설정 파일
servlet-context.xml - 스프링 웹 설정 파일
root-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
<!--
root-context.xml : 스프링 설정 파일
서블릿과 필터가 공유할 수 있는 루트 스프링 컨테이너 설정으로, 공통 빈(Service, Repository(DAO), DB, Log 등)을 설정함.
공통빈을 설정하는 곳으로 주로 View 지원을 제외한 bean을 설정함
스프링 설정?
view와 관련되지 않은 객체를 정의
Service(기능), DAO(Repository : 저장소), DB등 비즈니스 로직과 관련된 설정
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName() = "oracle.jdbc.driver.OracleDriver";
-->
<!-- dataSource : 데이터베이스와 관련된 정보를 설정 -->
<!--
db : database(개념. 공유/저장/통합/운영). RDB(Relational DB.관계형DB)
dbms : database management system(DB관리시스템.오라클)
localhost=127.0.0.1=내ip주소
xe : express(OracleXE11g.r2) => SID(sequence ID)
-->
<!--
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName("oracle.jdbc.driver.OracleDriver");
dataSource.setUrl("jdbc:oracle:thin:@localhost:1521:xe");
-->
<bean id="uploadFolder" class="java.lang.String">
<constructor-arg value="C:\\eGovFrameDev-3.10.0-64bit\\workspace\\springProj\\src\\main\\webapp\\resources\\upload"></constructor-arg>
</bean>
<bean id="uploadFolderDirect" class="java.lang.String">
<constructor-arg value="C:\\eGovFrameDev-3.10.0-64bit\\workspace\\.metadata\\.plugins\\org.eclipse.wst.server.core\\tmp0\\wtpwebapps\\springProj\\resources\\upload"></constructor-arg>
</bean>
<bean id="dataSource"
class="org.apache.commons.dbcp2.BasicDataSource"
destroy-method="close">
<property name="driverClassName"
value="oracle.jdbc.driver.OracleDriver" />
<property name="url"
value="jdbc:oracle:thin:@localhost:1521:xe" />
<property name="username" value="jsptest" /> <!-- sql 사용자 명 -->
<property name="password" value="java" />
</bean>
<!-- 데이터베이스와 연결을 맺고 끊어질 때까지의
라이프 사이클을 관리해주는 sqlSession 객체를 생성
1) dataSource
2) 매퍼 xml의 위치 지정. / : src/main/resources/
SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
sqlSessionFactory.setDataSource(dataSource);
-->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations"
value="classpath:/sqlmap/**/*_SQL.xml" />
<property name="configLocation"
value="/WEB-INF/mybatisAlias/mybatisAlias.xml" />
</bean>
<!-- 데이터베이스에 개별적으로 쿼리를 실행시키는 객체.
이 객체를 통해 query를 실행함
-->
<bean id="sqlSessionTemplate"
class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory" />
</bean>
</beans>
<property name="mapperLocations" value="classpath:/sqlmap/**/*_SQL.xml" />
해당 값을 통해 해당 위치에 package생성
해당 위치에 blank_SQL.xml생성
blank_SQL.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="blank">
</mapper>TypeAlias추가
<property name="configLocation" value="/WEB-INF/mybatisAlias/mybatisAlias.xml" />
mybatisAlias.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--
[마이바티스] 스프링에서 "_"를 사용한 컬럼명을 사용 시(BOOK 테이블의 BOOK_ID)
카멜케이스로 읽어줌(bookId)
ex) 테이블 컬러명이 member_id인 경우 jsp화면단에서 이 값을 사용 시 memberId로 사용
-->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!-- 자주 사용하는 타입의 별칭을 세팅 -->
<typeAliases>
<typeAlias type="kr.or.ddit.vo.BookVO" alias="bookVO" />
</typeAliases>
</configuration>book_SQL.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="book">
<!-- MyBatis에서 제공해주는 데이터 입력을 나타내는 태그
- resultType : vo, hashMap, String, int
- resultMap : MyBatis의 resultMap 태그를 사용
-->
<insert id="createPost" parameterType="bookVo">
<!--
resultType : 쿼리를 실행한 결과의 타입(int, String)
order : 메인쿼리를 실행 시 타이밍(BEFORE(전), AFTER(후))
keyProperty : 실행 결과 데이터를 어디에 set할것인가?
-->
<selectKey resultType="int" order="BEFORE" keyProperty="bookId">
select nvl(max(book_id),0)+1 from book
</selectKey>
insert into book(BOOK_ID, TITLE, CATEGORY, PRICE, INSERT_DATE)
values(#{bookId}, #{title}, #{category}, #{price}, SYSDATE)
</insert>
<select id="list" resultType="bookVo">
select *
from book
order by book_id desc
</select>
<select id="detail" resultType="bookVo" parameterType="bookVo">
select *
from book
where book_id = #{bookId}
</select>
<update id="update" parameterType="bookVo">
update book
set title=#{title},
category=#{category},
price=#{price}
where book_id = #{bookId}
</update>
<delete id="delete" parameterType="bookVo">
delete book
where book_id = #{bookId}
</delete>
</mapper>'Spring' 카테고리의 다른 글
| [Spring] lprod CRUD (0) | 2024.07.22 |
|---|---|
| [Spring] 애노테이션 Annotation (0) | 2024.07.22 |
| [Spring] Spring MVC (0) | 2024.07.19 |
| [Spring] 프로젝트 생성 + 설정 (1) | 2024.07.19 |
| [Spring] OT (1) | 2024.07.18 |
