1. 자바 버전을 맞춰준다.
1) 이클립스/STS에서 Java Build Path를 변경.
2) pom.xml 수정
<properties>
<java-version>1.8</java-version>
<org.springframework-version>4.2.5.RELEASE</org.springframework-version>
<org.aspectj-version>1.8.9</org.aspectj-version>
<org.slf4j-version>1.7.21</org.slf4j-version>
</properties>
2. 데이터 베이스를 사용 위해 오라클 JDBC 관련 모듈을 받게 설정 변경
1) pom.xml 수정
<!-- ojdbc6 설정 추가 -->
<repositories>
<repository>
<id>codelds</id>
<url>http://code.lds.org/nexus/content/groups/main-repo</url>
</repository>
</repositories>
<!-- Spring jdbc 모듈 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<!-- Oracle 11g 라이브러리 사용 -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.3</version>
</dependency>
Test 위쪽에 배치
다른 코드들을 보면 버전이 이렇게 입력되어 있다. (웹용 이름)
<version>${org.springframework-version}</version>
그렇다면 위에 삽입한 것들도 version 부분을 콘솔 버전이 아닌 웹에 맞춰 version 부분을 변경해야 한다.
변경 후 Maven Dependencies에서 spring-jdbc와 ojdbc6가 제대로 추가되었는지 확인한다.
3. 설정 파일 수정
1) 스프링에서 웹 형식으로 프로젝트를 생성하면 설정 파일을 자동으로 2개를 만들어준다.
위치는 src/main/webapp/WEB-INF/spring/appServlet/
servlet-context.xml : 웹과 관련된 설정은 모두 여기에서 담당
root-context.xml : 웹 이외의 설정은 모두 여기에서 담당
DB 연동은 웹이 아니라 웹 이외의 설정인 root-context.xml에서 해준다.
2) root-context.xml 수정: 오라클 DB 테이블 연동 설정, Jdbc 탬플릿 객체 생성
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
<!-- Data Source : Oracle DB 테이블 연동 설정 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"></property>
<property name="username" value="hr"></property>
<property name="password" value="tiger"></property>
</bean>
DataSource 인터페이스를 구현하는 클래스의 빈 객체를 생성한다.
값을 별도의 파일로 저장 후 표현언어로 불러올 수도 있으나 여기에서 위와 같이 value에 직접 입력해도 된다.
별도 파일로 저장한 경우 : ex) src/main/resources/config/ 안에 jdbc.properties
(jdbc 속성을 저장한 파일을 대상으로 빈 생성하는 방법 참조)
<!-- JdbcTemplate 객체 생성 -->
<bean id="" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg ref="dataSource" />
</bean>
</beans>
4. index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>쇼핑몰</title>
</head>
<body>
<h2>상품구매 쇼핑몰</h2>
<a href="main.do">메인화면</a>
</body>
</html>
이제 .do를 넣으면 스프링 스킴으로 동작할 수 있게끔 설정을 해줘야 한다.
5. URL 패턴 수정: web.xml
1) .do를 넣으면 스프링 스킴으로 동작할 수 있게끔 url 패턴을 / 에서 .do로 바꿔준다.
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
2) 파라미터에서 한글 깨지지 않게 필터 처리 설정을 넣어준다.
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
6. 컨트롤러 구성
컨트롤러는 디스패쳐 서블릿이 수행하며, 핸들러 매핑에게 어떤 요청을 수행할 지를 묻는 곳이다.
첫 요청인 main.do를 처리할 컨트롤러를 만들어준다. (위치는 src/main/java 밑)
여러개의 컨트롤러를 만들 때에 대비하여 컨트롤러 패키지를 별도로 만들어주면 좋다.
1) 컨트롤러 사용을 위하여 웹 설정 파일 servlet-context.xml 수정
<annotation-driven />
<context:component-scan base-package="mvc.jdbc.shop" />
이 2개를 이용하면 어노테이션을 생성하여 핸들러 매핑을 편리하게 쓸 수 있으나 스프링의 기본 방식을 연습하도록 한다.
기본 핸들러 매핑 방식에는
방법 1) BeanNameUrlHandlerMapping : 기본적인 동작 방식. bean의 이름과 url을 mapping
방법 2) SimpleUrlHandlerMapping : - url pattern들을 properties로 등록해 처리
이 두 종류가 있는데 여기에서는 가독성이 좋아 선호되는 심플 URL 핸들러 매핑을 써본다.
<!-- 1. SimpleUrlHandlerMapping -->
<beans:bean id="" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<beans:property name="mappings">
<beans:value>/main.do = shoppingController</beans:value>
</beans:property>
</beans:bean>
<beans:bean id="shoppingController" class="mvc.jdbc.controller.ShoppingController"></beans:bean>
2) 컨트롤러 구성
- 여기에서는 스프링의 기본 방식인 ModelAndView 반환 방식으로 메서드를 설정한다.
- 핸들러 매핑 방식으로 하면서도 최소한의 어노테이션 구성은 사용하자.
(요청 할 때마다 클래스 따로 다 정의해야 하므로)
package mvc.jdbc.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
public class ShoppingController {
@RequestMapping(value="/main.do")
public ModelAndView main() {
return new ModelAndView();
}
}
여기에서 main.do 요청이 왔을 때 처리할 내용은 상품 목록을 출력하는 기능을 구현해보도록 한다.
MVC 패턴대로 서비스 모듈을 별도로 구성해서 처리를 해준다.
서비스나 DAO는 결합성을 약화시키기 위해 인터페이스를 구현하는 것이 일반적이다.
7. 서비스 영역
1) 서비스 인터페이스 구현 (미완성)
package mvc.jdbc.service;
public interface GoodsItem {
List getItemList();
}
그런데 가져올 데이터가 아직 없으므로 일단 DB부터 구축하자.
데이터 목록의 상품을 불러오기 위해 resource에 webapp의 resource나 src/main/resource에 sql 폴더를 만들어 다음과 같이 sql 파일을 만들자.
drop table goodsitem purge; -- purge는 흔적을 남기지 않고 완전히 테이블을 삭제
drop table goodsitem purge;
create table goodsItem(
item_id int primary key,
item_name varchar2(20) not null,
item_price int not null,
item_des varchar2(200),
item_pic varchar2(20)
);
insert into goodsItem values(1, '냉장고', 800000, 'S사 최고 사양 품질', 'img01.jpg');
insert into goodsItem values(2, '세탁기', 650000, 'L사 최고 판매율', 'img02.jpg');
insert into goodsItem values(3, 'HDTV', 12000000, 'S사 최고 판매율', 'img03.jpg');
insert into goodsItem values(4, '세척기', 800000, 'L사 최고 사양 품질', 'img04.jpg');
insert into goodsItem values(5, '전자레인지', 800000, 'D사 최고 사양 품질', 'img05.jpg');
select * from goodsItem;
이미지는 webapp/resources에 img 폴더를 넣어 담아주자.
위의 데이터 빈 처리를 위한 자바빈 클래스를 정의할 차례다.
2) 데이터 빈 클래스 정의
package mvc.jdbc.dto;
public class ItemBean {
private int item_id;
private String item_name;
private int item_price;
private String item_des;
private String item_pic;
public int getItem_id() {
return item_id;
}
public void setItem_id(int item_id) {
this.item_id = item_id;
}
public String getItem_name() {
return item_name;
}
public void setItem_name(String item_name) {
this.item_name = item_name;
}
public int getItem_price() {
return item_price;
}
public void setItem_price(int item_price) {
this.item_price = item_price;
}
public String getItem_des() {
return item_des;
}
public void setItem_des(String item_des) {
this.item_des = item_des;
}
public String getItem_pic() {
return item_pic;
}
public void setItem_pic(String item_pic) {
this.item_pic = item_pic;
}
}
이제 서비스 영역의 인터페이스에서 자바빈을 가져오게 해야 한다.
위의 자바빈(ItemBean 클래스) 타입으로 자료형을 선언해주자.
7. 서비스 영역
1) 서비스 인터페이스 구현 (완성)
package mvc.jdbc.service;
import java.util.List;
import mvc.jdbc.dto.ItemBean;
public interface GoodsItem {
List<ItemBean> getItemList();
}
다음 위의 인터페이스를 구현하는 서비스 영역의 클래스를 만든다.
2) 위의 인터페이스를 구현하는 서비스 클래스 (미완성)
package mvc.jdbc.service;
import java.util.List;
import mvc.jdbc.dto.ItemBean;
public class GoodsItemImpl implements GoodsItem {
@Override
public List<ItemBean> getItemList() {
// TODO Auto-generated method stub
return null;
}
}
서비스 영역에서는 실질적인 DB 연동을 위한 DAO 파트를 가져와야 한다.
따라서 실제로 DB와 연동되는 DAO 클래스를 만들고, 이 DAO의 메서드를 이 서비스 클래스에서 호출해야 한다.
따라서 DAO 클래스를 정의할 차례.
8. DAO 영역
1) DAO 인터페이스 구현
DTO에서 5개의 데이터를 불러오기 위한 DAO 인터페이스를 설정.
findAll 메서드를 수행하면 5개의 레코드를 반환하도록, 5개의 레코드를 저장할 타입으로 List 타입을 이용한다.
package mvc.jdbc.dao;
import java.util.List;
import mvc.jdbc.dto.ItemBean;
public interface Itemdao {
List<ItemBean> findAll();
}
2) 위의 인터페이스를 구현하는 DAO 클래스 (미완성)
자바빈에서 데이터를 읽어오는 실질적인 기능의 메서드를 여기에서 구현해준다.
DAO에 정의된 메서드를 Service에서 호출해주고, 이 메서드를 다시 Controller에서 호출해준다.
이를 위해 서비스는 DAO의 객체를 주입받아야 하고, 컨트롤러는 서비스 영역의 객체를 주입받아야 한다.
(스프링 구조의 기본)
DAO에서는 데이터와 연동을 위해 우선 자바빈의 객체를 주입받는다.
package mvc.jdbc.dao;
import java.util.List;
import mvc.jdbc.dto.ItemBean;
public class ItemDaoImpl implements Itemdao {
private ItemDao itemDao;
public void setItemDao(ItemDao itemDao) { // 자바빈 객체를 주입받게 설정메서드를 정의
this.itemDao = itemDao;
}
@Override
public List<ItemBean> findAll() {
// TODO Auto-generated method stub
return null;
}
}
위에서 자바빈 객체(ItemDao)를 주입하려면 에러가 나는데 설정 파일에서 객체를 생성해야 한다.
웹 관련은 servlet-context.xml에서 해준다.
3) 설정 추가 : servlet-context.xml
1) 서비스 클래스의 객체를 생성한다.
<beans:bean id="goodsItem" class="mvc.jdbc.service.GoodsItemImpl">
</beans:bean>
2) 여기에서 itemDAO를 주입받게끔 itemDAO 객체도 생성한다.
(itemDAO는 DB관련이니 root-context.xml에 해줘도 되고, 웹과 연결되니 servlet-context.xml에 해줘도 된다.)
<beans:bean id="item" class="mvc.jdbc.dao.ItemDaoImpl"></beans:bean>
3) 서비스 객체에 ItemDAO를 주입받게 설정을 추가해준다.
<beans:bean id="goodsItem" class="mvc.jdbc.service.GoodsItemImpl">
<beans:property name="itemDao" ref="itemDao" />
</beans:bean>
4) 컨트롤러에도 주입 처리.
package mvc.jdbc.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import mvc.jdbc.service.GoodsItem;
public class ShoppingController {
private GoodsItem goodsItem;
public void setGoodsItem(GoodsItem goodsItem) {
this.goodsItem = goodsItem;
}
@RequestMapping(value="/main.do")
public ModelAndView main() {
return new ModelAndView();
}
}
package mvc.jdbc.dao; import java.util.List; import org.springframework.jdbc.core.JdbcTemplate; import mvc.jdbc.dto.ItemBean; public class ItemDaoImpl implements ItemDao { private ItemDao itemDao; public void setItemDao(ItemDao itemDao) { this.itemDao = itemDao; } private JdbcTemplate jdbcTemplate; public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { } @Override public List<ItemBean> findAll() { // TODO Auto-generated method stub return null; } }
위에서 각각 주입처리를 하려면 설정파일에서 프로퍼티를 이용하여 주입 설정을 해야 한다.
jsp 폴더를 만들어 그 안에 jsp 파일들을 넣으려면 servlet-context.xml에서 다음과 같이 바꿔준다.
<!-- 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/jsp/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
9. 설정 파일 : SimpleUrlHandlerMapping 방식으로 각 객체에 대한 주입 설정
최종적으로 servlet-context.xml은 다음과 같이 된다.
<?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 http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- DefaultAnnotationHandlerMapping 어노테이션 사용을 위한 지정: 입력 화면은 어노테이션으로 구현 -->
<!-- <beans:bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /> -->
<beans:bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<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/jsp/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<context:component-scan base-package="mvc.jdbc.shop" />
<!-- 1. SimpleUrlHandlerMapping -->
<beans:bean id="" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<beans:property name="mappings">
<beans:value>
/main.do=shoppingController
/content.do=shoppingController
</beans:value>
</beans:property>
</beans:bean>
<beans:bean id="shoppingController" class="mvc.jdbc.controller.ShoppingController">
<beans:property name="goodsItem" ref="goodsItem" />
</beans:bean>
<beans:bean id="goodsItem" class="mvc.jdbc.service.GoodsItemImpl">
<beans:property name="itemDao" ref="itemDao" />
</beans:bean>
<beans:bean id="itemDao" class="mvc.jdbc.dao.ItemDaoImpl">
<beans:property name="jdbcTemplate" ref="jdbcTemplate" />
<!-- jdbcTemplate는 root-context.xml에서 이미 설정해줬음 -->
</beans:bean>
</beans:beans>
package mvc.jdbc.controller;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import mvc.jdbc.dto.ItemBean;
import mvc.jdbc.service.GoodsItem;
public class ShoppingController {
private GoodsItem goodsItem;
public void setGoodsItem(GoodsItem goodsItem) {
this.goodsItem = goodsItem;
}
@RequestMapping("/main.do")
public ModelAndView main() {
List<ItemBean> list = goodsItem.getItemList();
Map<String, Object> model = new HashMap<String, Object>();
model.put("itemList", list);
return new ModelAndView("main", model);
}
@RequestMapping(value="/content.do")
public ModelAndView contentItem(int item_id) {
ModelAndView mav = new ModelAndView();
ItemBean item = goodsItem.getItem_id(item_id);
Map<String, Object> model = new HashMap<String, Object>();
model.put("item", item);
mav.setViewName("content"); // 이렇게 한 뒤 content.jsp 만들어주면 됨. (view page 연결)
mav.addAllObjects(model); // 담아온 값을 전달할 때엔 이렇게 한다.
return mav;
}
}
package mvc.jdbc.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import mvc.jdbc.dto.ItemBean;
public class ItemDaoImpl implements ItemDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
// jdbcTemplate는 실질적인 SQL 명령을 수행할 수 있는 동작의 객체가 된다.
@Override
public List<ItemBean> findAll() {
String sql = "select * from GoodsItem order by item_id asc";
return jdbcTemplate.query(sql, new RowMapper<ItemBean>(){
// 읽어온 데이터를 입력으로 반환해주며 호출해주는 메서드
// 인터페이스 RowMapper는 객체를 생성할 수 없어 바로 오버라이딩하여 객체 생성
@Override
public ItemBean mapRow(ResultSet arg0, int arg1) throws SQLException {
ItemBean item = new ItemBean();
item.setItem_id(arg0.getInt("item_id"));
item.setItem_name(arg0.getString("item_name"));
item.setItem_price(arg0.getInt("item_price"));
item.setItem_des(arg0.getString("item_des"));
item.setItem_pic(arg0.getString("item_pic"));
return item;
}
});
}
@Override
public ItemBean findItem_id(int item_id) {
// TODO Auto-generated method stub
String sql = "select * from GoodsItem where item_id = ?";
return jdbcTemplate.queryForObject(sql, new RowMapper<ItemBean>(){
@Override
public ItemBean mapRow(ResultSet arg0, int arg1) throws SQLException {
// TODO Auto-generated method stub
ItemBean item = new ItemBean();
item.setItem_id(arg0.getInt("item_id"));
item.setItem_name(arg0.getString("item_name"));
item.setItem_price(arg0.getInt("item_price"));
item.setItem_des(arg0.getString("item_des"));
item.setItem_pic(arg0.getString("item_pic"));
return item;
}
}, item_id);
}
}
package mvc.jdbc.service;
import java.util.List;
import org.springframework.stereotype.Service;
import mvc.jdbc.dao.ItemDao;
import mvc.jdbc.dto.ItemBean;
public class GoodsItemImpl implements GoodsItem {
private ItemDao itemDao;
public void setItemDao(ItemDao itemDao) { // 자바빈 객체를 주입받게 설정메서드를 정의
this.itemDao = itemDao;
}
@Override
public List<ItemBean> getItemList() {
List<ItemBean> list = itemDao.findAll();
return list;
}
@Override
public ItemBean getItem_id(int item_id) {
return itemDao.findItem_id(item_id); // 서비스 안의 메서드는 어디로 리턴? 컨트롤러로!
}
}
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>상품 목록 화면</title>
<style>
</style>
</head>
<body>
<div align="center" class="body">
<h2>상품 목록 화면</h2>
<table border="1">
<tr>
<th align="center" width="80">상품ID</th>
<th align="center" width="250">상품명</th>
<th align="center" width="100">가격</th>
</tr>
<c:forEach var="item" items="${ itemList }">
<tr>
<td align="center">${ item.item_id }</td>
<td align="center"><a href="content.do?item_id=${item.item_id}">${ item.item_name }</a></td>
<td align="right">${ item.item_price }</td>
</tr>
</c:forEach>
</table>
</div>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<link rel=“stylesheet” type="text/css" href=“css/main.css” />
<link rel=“stylesheet” type="text/css" href=“css/content.css” />
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ include file = "header.jsp" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<style>
</style>
<title>상품 상세 화면</title>
</head>
<body>
<div align="center" class="body">
<h2 id="title">상품 상세 정보 화면</h2>
<table>
<tr>
<td><img src="img/${item.item_pic}" /></td>
<td>
<ul>
<li>상품명 : ${item.item_name}</li>
<li>가격 : ${item.item_price}원</li>
<li>특징 : ${item.item_des}</li>
</ul>
</td>
</tr>
<tr>
<td>
<a href="main.do"><input type="button" value="목록" class="btn" /></a>
</td>
</tr>
</table>
</div>
</body>
</html>
index.jsp를 실행하면 된다.
' Spring Framework' 카테고리의 다른 글
| iBATIS 실습: DB연동 구조 (미완) (0) | 2016.04.12 |
|---|---|
| 스프링 JDBC 연동을 통한 쇼핑몰: 커넥션 풀 (0) | 2016.04.11 |
| 스프링 MVC로 게시판 구현: 상세, 입력 화면 (방법2: SimpleUrlHandlerMapping, 어노테이션) (0) | 2016.04.08 |
| 스프링 MVC로 게시판 구현: 리스트 화면 (방법1: BeanNameUrlHandlerMapping) (0) | 2016.04.07 |
| 스프링 MVC 패턴 간단하게 구현하기 (어노테이션 활용) (0) | 2016.04.07 |
