[Spring] 9. Spring MVC 직접해보기

Spring DI, MyBatis(Mapper사용), Spring MVC(JSP, HTML)

 

Project이름 : SpringMovie

context :movie

 

config/

myspring.movie.vo

myspring.movie.dao

myspring.movie.dao.mapper

myspring.movie.controller

 

 

0.테이블 만들기

create table movie(
    id int(10) not null auto_increment primary key,
    title varchar(30) not null,
    genre varchar(30),
    director varchar(20),
    runningtime bigint,
    opendate timestamp default CURRENT_TIMESTAMP
);

insert into movie(title,genre,director,runningtime) values('미나리', '드라마','김감독',150);
select * from movie order by id;

 

1. Dynamic Web Project 생성

: context이름(movie), web.xml 생성 체크

: 이후 Convert maven project

 

 

2. pom.xml파일에 dependency추가

1) spring-context: 스프링 문법환경 제공

2) spring-test(scope 주석) : 스프링 테스트 문법환경 제공

3) junit(scope 주석) : 자바 유닛테스트 환경 제공

4) spring-jdbc : 스프링에서 DB연동환경제공

5) jdbc driver : 데이터베이스 드라이버(오라클이나 마리아디비)

6) mybatis : JDBC를 편하게 사용하기 위해

7) mybatis-spring: Spring 횐경에서 JDBC를 편하게 사용하기 위해

8) apache dbcp : DataBase Connection Pool 의 약자로 DB와 커넥션을 맺고 있는 객체를 관리하는 역할

9) spring mvc : MVC모델링을 도와주는 라이브러리

10) jstl : JSP에서 특정 문법을 사용하기 위해

 

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>SpringMovie</groupId>
	<artifactId>SpringMovie</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<build>
		<sourceDirectory>src</sourceDirectory>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<release>11</release>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.2.1</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.2.12.RELEASE</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>5.2.12.RELEASE</version>
			<!-- <scope>test</scope> -->
		</dependency>


		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.13.1</version>
			<!-- <scope>test</scope> -->
		</dependency>


		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.2.12.RELEASE</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client -->
		<dependency>
			<groupId>org.mariadb.jdbc</groupId>
			<artifactId>mariadb-java-client</artifactId>
			<version>2.7.1</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.6</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>2.0.6</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-dbcp2</artifactId>
			<version>2.8.0</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.2.12.RELEASE</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

	</dependencies>
</project>

 

 

 

3.Database 연동(Mapper사용) 을 위한 Config 파일들 Setting

springbeans.xml 

values.properties 

MovieVO 

MovieMapper.xml

SqlMapConfig.xml

MovieMapper.java(인터페이스)

만들어보기

 

 

1) springbeans.xml 만들기(Beans와 context체크 꼭 하기)

 

2) values.properties 파일 만들기(DB의 정보 넣어준다.)

db.driver=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://127.0.0.1:3306/java_db?useUnicode=true&charaterEncoding=utf-8&useSSL=false&serverTimezone=UTC
db.username=scott
db.password=tiger

 

3) springbeans.xml에 DataSource 설정한다.

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="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">

	<!-- Aphache DBCP BasicDatasource 클래스를 Bean으로 등록 -->
	<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" 
	p:driverClassName="${db.driver}" 
	p:url="${db.url}" 
	p:username="${db.username}"
	p:password="${db.password}" />
	
	<!-- Properties 파일 만들것이다. -->
	<context:property-placeholder location="classpath:config/values.properties"/> 
	
</beans>

 

 

4) DataSource Test클래스 만들고 DB Connection 잘 되는지 테스트한다.

package myspring.movie.test;

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:config/springbeans.xml")
public class DataSourceTest {
	
	@Autowired
	DataSource dataSource;
	
	@Test
	public void firstTest() {
		
		try {
			Connection con = dataSource.getConnection();
			System.out.println(con);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

결과 이렇게 나와야한다.

1572442646, URL=jdbc:mysql://127.0.0.1:3306/java_db?useUnicode=true&charaterEncoding=utf-8&useSSL=false&serverTimezone=UTC, MySQL Connector/J

 

5) MovieVO 클래스 생성

멤버변수 선언, 생성자 만들기, Getter Setter 만들기

package myspring.movie.vo;

import java.sql.Date;

public class MovieVO {
	
	private int id;
	private String title;
	private String genre;
	private String director;
	private long runningtime;
	private Date opendate;

	
	public MovieVO(String title, String genre, String director, long runningtime) {
		super();
		this.title = title;
		this.genre = genre;
		this.director = director;
		this.runningtime = runningtime;
	}
	
	public MovieVO(int id, String title, String genre, String director, long runningtime, Date opendate) {
		this(title,genre,director,runningtime);
		this.id = id;
		this.opendate = opendate;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getGenre() {
		return genre;
	}

	public void setGenre(String genre) {
		this.genre = genre;
	}

	public String getDirector() {
		return director;
	}

	public void setDirector(String director) {
		this.director = director;
	}

	public long getRunningtime() {
		return runningtime;
	}

	public void setRunningtime(long runningtime) {
		this.runningtime = runningtime;
	}

	public Date getOpendate() {
		return opendate;
	}

	public void setOpendate(Date opendate) {
		this.opendate = opendate;
	}

	@Override
	public String toString() {
		return "MovieVO [id=" + id + ", title=" + title + ", genre=" + genre + ", director=" + director
				+ ", runningtime=" + runningtime + ", opendate=" + opendate + "]";
	}
	
}

 

 

 

 

 

6) MovieMapper.xml

: CRUD SQL문 작성 

<?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="myspring.movie.dao.mapper.MovieMapper">
 
 	<!-- 파라미터 2개이상일경우 객체로받아야댐... -->
 	<select id="selectMovieByTitle" parameterType="string" resultType="Movie">
 		select * from movie where title = #{value}
 	</select>
 	
 	<select id="selectMovieList" resultType="Movie">
 		select * from movie order by id
 	</select>
 	
 	<insert id="insertMovie" parameterType="Movie">
 		insert into movie(title,genre,director,runningtime) value(#{title},#{genre},#{director},#{runningtime})
 	</insert>
 	
 	<update id="updateMovie" parameterType="Movie">
 		update movie set 
 			title = #{title},
 			genre= #{genre},
 			director = #{director},
 			runningtime = #{runningtime}
 		where title = #{title};
 	</update>
 	
 	<delete id="deleteMovie" parameterType="integer">
 		delete from movie where id=#{value}
 	</delete>
 	
 
 </mapper>
 

 

7) SqlMapConfig.xml

: MovieVO Type Aliase 작성, VO클래스의 객체를 짧게 쓰라고 스프링에게 알려주는 것.

<?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>
	<!-- VO객체를 설정한다..(클래스 이름이 뭔지 알려주는거지.) -->
	<!-- jdbc.user.vo.UserVO 이걸 짧게 쓰기 위해 Alias를 준다.alias="User" -->
	<typeAliases>
		<typeAlias alias="User" type="myspring.movie.vo.MovieVO"/>
	</typeAliases>
</configuration>

 

 

 

8) springbeans.xml 에 SQLSessionFactory, SQLSession 설정 

SQL Session에 필요한 것들을 spring에게 알려주기 위함..

<!--  SqlSessionTemplate -->
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg ref="sqlSessionFactory" />
	</bean>
	
	<!--  SqlSessionFactoryBean 클래스를 Bean으로 등록 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource"/>
		<property name="configLocation" value="classpath:config/SqlMapConfig.xml"/>
		<property name="mapperLocations">
			<list>
				<value>classpath:config/MovieMapper.xml</value>
			</list>
		</property>
	</bean>

 

9) MovieMapper.java(인터페이스) 생성

이 Mapper 인터페이스가 이제 데이터베이스에 접근해서 데이터를 받아올 것이다.

그러니까 MovieMapper.xml과 연결되어야 겠지?

그래서 아까 MovieMapper.xml만들 때 namespace에다가 이 경로를 넣어준 것이다..

 

(MovieMapper.xml 은 SQLSession과 연결되겠지?)

 

그리고 중요한 점은.. 해당 인터페이스에 있는 메서드 명은 Mapper.xml에 있는 id와 통일시켜야 한다..

그래야 동작한다.

package myspring.movie.mapper;

import java.util.List;

import myspring.movie.vo.MovieVO;

public interface MovieMapper {
	
	// select 1개
	MovieVO selectMovie(String title);

	// select all
	List<MovieVO> selectMovieList();
	
	// insert
	int insertMovie(MovieVO movie);
	
	// update
	int updateMovie(MovieVO movie);
	
	//delete
	int deleteMovie(int id);
	
	
}

 

10) 그리고 한가지를 더 해줘야 한다.

springbeans.xml에 MapperMapperScannerConfigurer 를 등록해준다.

	<!--  MapperScannerConfigurer를 설정할것이다. -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<property name="basePackage" value="myspring.movie.dao.mapper" />
	<property name="sqlSessionTemplateBeanName" value="sqlSession" />
	</bean>

 

 

11) Mapper설정한 것 테스트 해보자.

잘 동작하는 것을 확인할 수 있다.

@Autowired
	MovieMapper mapper;
	
	
	@Test 
	public void mapperTest() {
		// Select one movie
		//MovieVO movie = mapper.selectMovie("미나리");
		//System.out.println(movie);
		
		
		// Select all movie;
//		List<MovieVO> movies = mapper.selectMovieList();
//		for (MovieVO movieVO : movies) {
//			System.out.println(movieVO);
//		}
		
//		// insert movie;
//		MovieVO movie = new MovieVO("기생충","장르1","봉준호",210L);
//		int cnt = mapper.insertMovie(movie);
//		System.out.println(cnt);
		
//		update movie
//		MovieVO movie = new MovieVO("기생충","장르2","봉준호1",210L);
//		int cnt = mapper.updateMovie(movie);
//		System.out.println(cnt);
		
		// delete movie
//		int cnt = mapper.deleteMovie(2);
//		System.out.println(cnt);
	}

 

 

4. IMovieDAO 인터페이스, MovieDAOImpl클래스 생성

1) MovieDAOImpl클래스를 먼저 생성하고, @Repository 어노테이션 선언

package myspring.movie.dao;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import myspring.movie.dao.mapper.MovieMapper;
import myspring.movie.vo.MovieVO;

@Repository
public class MovieDAOImpl {
	@Autowired
	MovieMapper mapper;
	
	// select 1개
	MovieVO selectMovie(String title) {
		MovieVO movie = mapper.selectMovie(title);
		return movie;
	}

	// select all
	List<MovieVO> selectMovieList(){
		List<MovieVO> movies = mapper.selectMovieList();
		return movies;
	}
	
	// insert
	int insertMovie(MovieVO movie) {
		return mapper.insertMovie(movie);
	}
	
	// update
	int updateMovie(MovieVO movie) {
		return mapper.updateMovie(movie);
	}
	
	//delete
	int deleteMovie(int id) {
		return mapper.deleteMovie(id);
	}

}

 

 

2) springbeans.xml에서 component-scan한다.

	<context:component-scan base-package="myspring.movie">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>

 

 

 

3) 이후 이 DAO의 Interface를 만들어준다..(이건 왜 만들어주는거지)ㅎㅎ

package myspring.movie.dao;

import java.util.List;

import myspring.movie.vo.MovieVO;

public interface IMovieDAO {
	MovieVO selectMovie(String title);
	List<MovieVO> selectMovieList();
	int insertMovie(MovieVO movie);
	int updateMovie(MovieVO movie);
	int deleteMovie(int id);

}

 

 

 

 

여기까지 BACKEND 완료

---

5. springbeans-web.xml

이제 springbeans.xml 과 springbeans-web.xml을 나눠 볼 것이다..

이 작업을 하는 이유는 Front 단과 Back 단을 분리하기 위함이다.

Front단과 Back단의 Config 값들이 하나의 XML에 담겨있다면

종속성이 생기기 때문이다.

 

기존 springbeans.xml에서 exclue(배제)했던 Controller 클래스를 여기서는 Include(포함)시켜준다.

 

springbeans.xml

<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

 

springbeans-web.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"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="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
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!--  DI전략2의 Component Auto Scanning 설정 -->
	<context:component-scan base-package="myspring.movie" >
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
	</context:component-scan>
	
	
</beans>

 

 

추가적으로 Resolver도 Bean으로 등록해줘서, jsp확장자를 코딩할 때 생략하도록 설정한다.

<!-- jsp 확장자 생략하는 설정 -->
	<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/" />
		<property name="suffix" value=".jsp" />
	</bean>

 

6. web.xml

1) web.xml 에

 (1) listner ContextLoaderListener 를 springbeans.xml 으로 등록시킨다.

  	<!-- needed for ContextLoaderListener -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:config/springbeans.xml</param-value>
	</context-param>

	<!-- Bootstraps the root web application context before servlet initialization -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

 

 

 

 

 (2) filter 등록(Request Data를 UTF8로 인코딩 하기위함)

	<!-- org.springframework.web.filter.CharacterEncodingFilter 설정해서 요청(request) 데이터를 UTF-8로 인코딩-->
	<filter>
		<filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
		<url-pattern>*.do</url-pattern>
	</filter-mapping>
	

 

 (3) servlet을 springbeans-web.xml으로 등록시킨다.

<!-- The front controller of this Spring Web application, responsible for 
		handling all application requests -->
	<servlet>
		<servlet-name>springDispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:config/springbeans-web.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
		<servlet-name>springDispatcherServlet</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

 

이렇게 하여 View단과 Controller단의 설정 파일이 나뉘어 짐

 

 

7. Controller 클래스를 생성

8. jsp작성

 

7,8번은 함께 묶어서 설명을 써야 함..

그리고 계속 controller수정 -> JSP수정 -> Controller수정 -> JSP수정 이런식으로 해야대서 번거로울 수 있음.

 

천천히 해보자..

 

1) Controller Class 생성..

여기까지가 Controller class 기본 틀이다.

중요한 것은 Controller클래스 위에 @Controller 어노테이션을 꼭 붙여줘야 한다는 것이다.

 

package myspring.movie.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.servlet.ModelAndView;

import myspring.movie.dao.IMovieDAO;
import myspring.movie.vo.MovieVO;

@Controller
public class MovieController {
	
	@Autowired
	IMovieDAO dao;
	
	public MovieController() {
		System.out.println("MovieController default constructure 생성댐");
	}
}

 

 

2) select All 해보기

 

 (1) Controller

 @RequestMapping과 ModelAndView를 사용한 것이 포인트

package myspring.movie.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.servlet.ModelAndView;

import myspring.movie.dao.IMovieDAO;
import myspring.movie.vo.MovieVO;

@Controller
public class MovieController {
	
	@Autowired
	IMovieDAO dao;
	
	public MovieController() {
		System.out.println("MovieController default constructure 생성댐");
	}

	@RequestMapping("/movieList.do")
	public ModelAndView selectMovies() {
		List<MovieVO> movieList = dao.selectMovieList();
		
		return new ModelAndView("movieList","movies",movieList);
	}

}

 

 (2) JSP

<%@ 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>Movie 리스트</title>
</head>
<body>
	<h2>Movie 리스트</h2>
	<table>
		<tr>
			<th>순서</th>
			<th>타이틀</th>
			<th>장르</th>
			<th>감독</th>
		</tr>
		<%-- JSTL로 하면 이렇게된다.. --%>
		<c:forEach var="movie" items="${movies}" varStatus="status">
			<tr>
				<td>${status.count}</td>
				<td>${movie.title}</td>
				<td>${movie.genre}</td>
				<td>${movie.director}</td>
			</tr>

		</c:forEach>
	</table>
</body>
</html>

 

3) select one movie 해보기

 (1) Controller

여기서는 @GetMapping을 사용했고,

매개변수에 @RequestParam을 준 것과

Model model을 받아와서 addAttrbute해준 것과,

Return 값으로 JSP 이름을 주는 것이 포인트

	@GetMapping("/movieDetail.do")
	public String selectMovie(@RequestParam String title, Model model){
		MovieVO movie = dao.selectMovie(title);
		model.addAttribute("movieOne", movie);
		
		return "movieDetail";
	}

 

 (2) JSP 

우선 movieList.jsp에서 접근 가능하도록 movieList.jsp에 링크를 걸어준다.

title에 링크를 걸어 movieDetail로 넘어가게, 그리고 title도 같이 넘겨주는 것을 볼 수 있다.

<tr>
	<td>${status.count}</td>
	<td><a href="movieDetail.do?title=${movie.title}">${movie.title}</a></td>
	<td>${movie.genre}</td>
	<td>${movie.director}</td>
</tr>

이후 movieDetail.jsp

Controller에서 model.addAttribute("movieOne", movie); 해줬을 때, 첫 번째 인자값으로 넘겨준

attribute name(movieOne) 을 여기서 사용하면 된다.

그리고 다시 Home으로 돌아가는 링크도 아래와 같이 넣어준다.

<a href="${pageContext.request.contextPath}/index.jsp">Home</a>

 

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>movie 상세</title>
</head>
<body>
	<h2>movie 상세정보</h2>
	<table>
		<tr>
			<th>ID</th>
			<td>${movieOne.id}</td>
		</tr>
		<tr>
			<th>movie title:</th>
			<td>${movieOne.title}</td>
		</tr>
		<tr>
			<th>movie genre :</th>
			<td>${movieOne.genre}</td>
		</tr>
		<tr>
			<th>movie director :</th>
			<td>${movieOne.director}</td>
		</tr>
		<tr>
			<th>movie runningtime :</th>
			<td>${movieOne.runningtime}</td>
		</tr>
		<tr>
			<th>movie 개봉일 :</th>
			<td><fmt:formatDate value="${movieOne.opendate}"
					pattern="yyyy-MM-dd HH:mm:ss"></fmt:formatDate></td>
		</tr>
	</table>
	<hr>
	<a href="${pageContext.request.contextPath}/index.jsp">Home</a>
</body>
</html>

 

 

4) InsertMovie 해보기

insert는 아래와 같은 단계로 진행

 

[Home 화면에서 Insert 페이지 호출] (movieInsert.jsp 호출)

->

[Insert 페이지에서 Form입력 후 Submit]

->

[Submit된 값들 확인하여 테이블에 저장(DAO Insert 메서드 호출)]

->

[MovieList페이지로 이동하여 추가됬는지 확인]

 

따라서 여기서는 movieInsert.jsp페이지가 필요함

 

 (1) Controller

우선 InsertForm을 보여줘서 사용자가 입력 가능하도록 한다.

장르는 종류가 여러개 이므로,, JSP코드에서 여러 번 입력하기 보다는

아래와 같이 List에 종류들을 담아서 JSP에서는 Foreach문을 호출하여 보여주게 하는 것으로 한다.

사실 이런것은 없으면 안해줘도 됨.

@GetMapping("/movieInsert.do")
	public String movieInsertForm(Model model) {
		List<String> genreList = List.of("드라마","스릴러","공포","애니메이션","코미디");
		model.addAttribute("genres", genreList);
		return "movieInsert";
	}

 (2) jsp

 

그리고 이걸 호출하는 JSP는 index.jsp이다. index.jsp에 진입점 만들어준다.

index.jsp

<li><a href="movieInsert.do">2.Movie 등록</a></li> 

 

그리고 movieInsert페이지를 완성한다.

여기서 볼것은 movie genre를 foreach문으로 처리한 것.

저 구문을 쓰려면 상단의 <%@ taglib prefix를 해줘야 한다.

 

<%@ 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>movie 등록</title>
</head>
<body>
	<h2>movie 등록</h2>
	<form method="post" action="movieInsert.do">
		<table>
			<tr>
				<th>movie title :</th>
				<td><input type="text" name="title"></td>
			</tr>
			<tr>
				<th>movie genre :</th>
				<td>
					<select name="genre">
						<c:forEach var="genre" items="${genres}" >
								<option value="${genre}">${genre}</option>
						</c:forEach>
					</select>
				</td>
			</tr>
			<tr>
				<th>movie director :</th>
				<td><input type="text" name="director"></td>
			</tr>
			<tr>
				<th>movie runningtime :</th>
				<td><input type="text" name="runningtime"></td>
			</tr>
			<tr>
				<td colspan="2">
					<input type = "submit" value="등록">
				</td>
			</tr>
		</table>
	</form>
</body>
</html>

 

 

 (3) 다시 Controller

여기서는 이제 Form에서 Submit 받은 값들을 실제로DB에 Insert해주는 과정을 작성한다.

	@PostMapping("/movieInsert.do")
	public String movieInsert(@ModelAttribute MovieVO movie) {
		int cnt = dao.insertMovie(movie);
		if(cnt!=0) {
			return "redirect:/movieList.do";
		} else {
			return "redirect:/";
		}
	}

 

이제 잘 동작하는지 확인한다.

여기서 좀 헤멘게, MovieVO에 기본 생성자가 없으면 Insert가 안된다.

기본 생성자가 멤버변수들을 초기화 해주는 역할을 하기 때문이다.

 

 

 

 

 

 

4) UpdateMovie 해보기

 (1) Controller

update는 아래와 같은 단계로 진행(Insert와 유사하다)

 

[Home 화면에서 update페이지 호출] (movieupdate.jsp 호출)

->

[update페이지에서 Form입력 후 Submit]

->

[Submit된 값들 확인하여 테이블에 저장(DAO update 메서드 호출)]

->

[MovieDetail페이지로 이동하여 추가됬는지 확인]

 

	@GetMapping("/movieUpdate.do")
	public ModelAndView movieUpdateForm(@RequestParam String title) {
		List<String> genreList = List.of("드라마","스릴러","공포","애니메이션","코미디");
		MovieVO movie = dao.selectMovie(title);
		
		Map<String, Object> dataMap = new HashMap<>();
		dataMap.put("movie", movie);
		dataMap.put("genres", genreList);
		
		return new ModelAndView("movieUpdate", "map", dataMap);
	}
	

(2) JSP