반응형

# Spring WEB MVC_01버전_06 MVC 동작원리_1 : 톰캣 실행 시

1. listener (ContextLoaderListener)

  • web.xml 에서.. listener가 먼저 실행.   
  • context-param : listener가 참조할 수 있는 것을 설정할때 사용. 해당 태그 내에 있는 param-name으로 param-value를 읽어온다.

## Spring Container 

  • 객체를 관리하는 메모리 공간.
  • A 클래스가 B 클래스를 사용할 경우 일반적으로 A 클래스가 아래와 같이 객체를 생성해야 한다. 이렇게 되면 A클래스와 B클래스는 서로 의존관계가 형성된다. 그래서 B클래스에 변화가 발생하면 A클래스에 영향을 주게 된다.
B b = new B();
  • 스프링에서는 의존관계를 느슨하게하는 DI 기법을 적용한다. 스프링에서는 위에서처럼 A클래스에서 B클래스를 사용할때 객체를 생성해서 하지 않고, 어디엔가(Spring Container) 미리 만들어진 것을 주입받아 사용. 이를 의존성 주입 이라고 한다. (DI)

2. Servlet (DispatcherServlet)

  • servlet-context.xml을 실행.
  • 어노테이션(@)을 사용할 수 있게 하고.
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
  • css, image, js 등의 파일의 resource 위치를 mapping 부분을 참조하겠다는 것.
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<resources mapping="/resources/**" location="/resources/" />

참조할 resource 위치.

  • ViewResolver : view의 논리적인 이름을 prefix 와 suffix 부분을 붙여서 하나의 물리적인 경로를 만들어내는 것.
<!-- 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를 스캐닝
<context:component-scan base-package="kr.narp.myapp" />

## 정리

  • 아래처럼 실행되면서 DispatcherServlet (FrontController)가 준비상태에 되어있다가 클라이언트의 요청을 받아 *.do 등의 요청을 받으면 HandlerMapping 에 맞는 메서드부터 프로그램이 진행된다.

 

# Spring WEB MVC_01버전_07 MVC 동작원리_2 : 클라이언트 요청

## web.xml

  • 기존 / 에서 *.do 로 변경.
<servlet-mapping>
  <servlet-name>appServlet</servlet-name>
  <url-pattern>*.do</url-pattern>
</servlet-mapping>
  • 모든 클라이언트에서 *.do 요청이 오게되면 DispatcherServlet이 요청을 받게 된다.
  • 요청을 받은 DispatcherServlet => HandlerMapping 에서 요청에 맞는 응답 메서드 확인 => DispatcherServlet => MemberController (POJO)에서 요청에 따른 응답 메서드 실행.

## root-context.xml

  • context:component-scan 추가해서 kr.bit.model 에 있는 MemberDAO, MemberVO가 component-scan이 되도록 설정.
<?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"
	xsi:schemaLocation="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">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
	
	<!-- MyBatis SqlSessionFactory -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	    <property name="dataSource"  ref="dataSource"/>
	    <property name="configLocation" value="/WEB-INF/mybatis/config.xml"/>
	    <property name="mapperLocations" value="classpath:kr/bit/mybatis/*.xml"/>
	</bean>
	<!-- JDBC 연결(DataSource) -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
		<property name="driverClass" value="${driver}"/>
		<property name="url" value="${url}"/>
		<property name="username" value="${username}"/>
		<property name="password" value="${password}"/>
	</bean>
	<!-- db.properties 파일 연결 -->
	<bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	    <property name="locations" value="/WEB-INF/mybatis/db.properties"/>
	</bean>
	
	<context:component-scan base-package="kr.bit.model" />	
	
</beans>
  • 그리고 컴포넌트 스캔 지정한 MemberDAO에 어노테이션 추가. 이렇게 해주면 Spring Container에 객체가 생성된다.
@Repository
public class MemberDAO {
	...
}

## DI (Dependency Injection) 방법 (의존성 주입 방법).

  • 스프링의 핵심 기술.

1. @Autowried

  • Spring Container에 가서 Autowied 걸린 MemberDAO를 찾아서 dao에 연결해주겠다.
@Autowired
	private MemberDAO dao;

2. @Inject

## MemberDAO 개선

  • @Autowried 사용하여 개선 진행
package kr.bit.model;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class MemberDAO {
	
	@Autowired
	private SqlSessionFactory sqlSessionFactory;	// DB를 연결하고 있는 객체들이 존재.
	
	// 회원 리스트 조회 기능
	public List<MemberVO> memberList() {
		// SqlSession 은 Connection + Statement 의 기능을 합쳐 놓은 것.
		SqlSession session = sqlSessionFactory.openSession();
		List<MemberVO> list = session.selectList("memberList");		// mapper와 연결 ""에는 id이름 적기 일반적으로 해당 매서드 이름적음.
		session.close();	// 연결 종료(반납)
		return list;
	}
	
	// 회원 가입 기능
	public int memberInsert(MemberVO vo) {
		SqlSession session = sqlSessionFactory.openSession();
		int cnt = session.insert("memberInsert", vo);
		session.commit();	// DB 내용이 수정되므로 commit을 해줘야 한다.
		session.close();	// 연결 종료(반납)
		return cnt;
	}
	
	// 회원 삭제 기능
	public int memberDelete(int num) {
		SqlSession session = sqlSessionFactory.openSession();
		int cnt = session.delete("memberDelete", num);
		session.commit();	// DB 내용이 수정되므로 commit을 해줘야 한다.
		session.close();	// 연결 종료(반납)
		return cnt;
	}
	
	// 회원 상세보기
	public MemberVO memberContent(int num) {
		SqlSession session = sqlSessionFactory.openSession();
		MemberVO vo = session.selectOne("memberContent", num);
		session.close();	// 연결 종료(반납)
		return vo;
	}
	
	// 회원 수정하기
	public int memberUpdate(MemberVO vo) {
		SqlSession session = sqlSessionFactory.openSession();
		int cnt = session.update("memberUpdate", vo);
		session.commit();	// DB 내용이 수정되므로 commit을 해줘야 한다.
		session.close();	// 연결 종료(반납)
		return cnt;
	}
}

## Model

  • 객체 바인딩을 하기 위해 스프링이 제공해주는 클래스.
  • HttpServletRequest 객체 == Model
@RequestMapping("/memberList.do")
public String memberList(Model model) {
  List<MemberVO> list = dao.memberList();
  // 객체 바인딩.
  model.addAttribute("list", list);	
  return "memberList";
}

 

# Spring WEB MVC_01버전_08 Spring WEB MVC를 이용한 회원관리

## 스프링 한글처리 (한글 깨짐 방지)

  • 요청이 DispatcherServlet으로 가기 전. 필터를 거치도록 하여 한글 깨짐 방지 처리.
  • 아래 코드를 web.xml에 추가.
<!-- Character Encoding -->
<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>

## 회원가입 기능 작업

  • MemberVO의 경우 Default 생성자에 의해서 내부적으로 vo = new MemberVO( ); 만들어진다. 그렇기 때문에 MemberVO에 public MemberVO() { } 가 존재해야 한다. 그렇지 않으면 에러 발생. (스프링에서 중요한 부분.)
@RequestMapping("/memberInsert.do")
public String memberInsert(MemberVO vo) {
  int cnt = dao.memberInsert(vo);

  return "redirect:/memberList.do";
}

## 회원 삭제 기능 작업

  • 넘어오는 변수를 다른이름으로 받으려면 @RequestParam("num") int su 사용
@RequestMapping("/memberDelete.do")
public String memberDelete(int num) {	// 넘어오는 변수를 다른이름으로 받으려면 @RequestParam("num") int su 사용
  int cnt = dao.memberDelete(num);

  return "redirect:/memberList.do";
}

## 회원 상세정보 보기 기능 작업

@RequestMapping("/memberContent.do")
public String memberContent(int num, Model model) {
  MemberVO vo = dao.memberContent(num);
  // 객체 바인딩
  model.addAttribute("vo", vo);

  return "memberContent";
}

## 회원 정보 수정하기 기능 작업

@RequestMapping("/memberUpdate.do")
public String memberUpdate(MemberVO vo) {
  int cnt = dao.memberUpdate(vo);

  return "redirect:/memberList.do";
}
반응형
반응형

# Spring WEB MVC_01버전_04~05 DataBase 연결

  • 스프링 실행 시 아래 부분들이 먼저 실행된다.
  1. ContextLoaderListener => root-context.xml 참조
  2. DispatchServlet => servlet-context.xml 참조
  • 일반적으로 데이터 베이스 설정은 root-context.xml에서 진행.
  • config.xml / db.properties 파일의 경우 거의 수정하는일이 없다. 외부에서 접근이 불가능 하도록 WEB-INF > mybatis 폴더 생성하여 해당 폴더로 이동.

## 데이터베이스 연결

  • JDBC를 이용해서 MySQL을 연결하기 위해서 MySQL Driver API 필요.
  • myBatis를 JDBC와 연결하기 위한 API가 필요.
  • Spring에서 MyBatis를 연결하기 위한 API 필요.
  • 아래와 같이 Spring DB API 확인하여 pom.xml에 dependency 설정.

1. MySQL Connector API

  • mvnRepository 사이트에서 mysql-connector-java 알맞은 버전 클릭 후 dependency 복사하여 pom.xml에 삽입.
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.31</version>
</dependency>

 2. MyBatis API

  • 마찬가지로 알맞은 버전 클릭 후 dependency 복사하여 pom.xml에 삽입.
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.5</version>
</dependency>

3. MyBatis-Spring API

  • 마찬가지로 알맞은 버전 클릭 후 dependency 복사하여 pom.xml에 삽입.
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

4. Spring JDBC API

  • 마찬가지로 알맞은 버전 클릭 후 dependency 복사하여 pom.xml에 삽입.
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>3.1.1.RELEASE</version>
</dependency>

## root-context.xml 설정

  • 스프링에서 클래스 설정 시 <beans> 태그를 사용.
1. 자바 객체 생성
A a = new A();

2. xml의 경우 bean 사용하여 객체 생성
<bean id='a' class='A'/>

=> 자바의 리플렉션 기법.
(클래스 이름(A)만 알면 객체를 내부적으로 생성해낼수 있는 방법)

1. db.properties 파일 연결

Libraries > Maven Dependencies > spring-beans-3.1.1.RELEASE.jar > org.springframework.beans.factory.config

해당 경로로 가서 PropertyPlaceholderConfigurer.class 찾기.

해당 class 파일을 찾은 후 우 클릭 > Copy Qualified Name > db.properties에 생성한 bean class에 넣기.
( Copy Qualified Name => 패키지 이름 포함하여 파일 이름 복사. )
  • 일반적으로 bean의 id 이름은 class 이름을 그대로 따른다.(id 이름의 첫 글자는 소문자로 처리)
  • bean 내부 property 태그는bean의 class가 가지고 있는 Locations에 setter 메서드를 호출하여 property value를 설정해주면,  PropertyPlaceholderConfigurer가 파일을 리딩해서 db.properties에 있는 정보를 내부적으로 갖고있게 된다.
<!-- db.properties 파일 연결 -->
<bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	<property name="locations" value="/WEB-INF/mybatis/db.properties"/>
</bean>

2. JDBC 연결(DataSource)

  • db.properties에 있는 정보를 설정 (추후 db.properties 제거 예정)
<!-- JDBC 연결(DataSource) -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
  <property name="driverClass" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</bean>

3. MyBatis SqlSessionFactory

  • property 태그에서 ref의 경우 '참조'
  • qlSessionFactoryBean이 JDBC를 이용해서 JDBC 연결(dataSource)하고, configLocation 파일과 mapperLocation 파일을 연결.
  • 그래서 기존 config.xml 파일에서 typeAlias만 사용.
<!-- MyBatis SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource"  ref="dataSource"/>
  <property name="configLocation" value="/WEB-INF/mybatis/config.xml"/>
  <property name="mapperLocations" value="classpath:kr/bit/mybatis/*.xml"/>
</bean>

### config.xml 정리(typeAlias만 존재하도록 변경)

<?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>
	<typeAliases><!-- 별칭 -->
	    <typeAlias type="kr.bit.model.MemberVO" alias="memberVO"/>
	</typeAliases>
</configuration>

## 코드 어시스턴트 기능 사용 설정 방법

  • 이클립스 > 상단 Window > Preferences > Editors 검색 > File Associations 에서 File Types 선택(예)xml 파일) 후 하단 Associated editors에서 XML editor 선택 후 Default 설정 > Apply and close.
  • 열러있는 xml 파일을 닫고 새로 오픈 후 Source 탭에서 name 등의 입력 부분 클릭 후 Ctrl + Space 클릭 시 코드 어시스턴트 기능을 사용할 수 있다.
반응형
반응형

# Spring WEB MVC_01버전_03 POJO 개수 줄이기

  • 기존에 생성한 SpringMVC01 에서 작업 진행 예정
  • Spring 프로젝트 생성 시에는 Maven Tool에 의해 Spring 프로젝트가 생성된다.
  • Maven에서 가장 중요한 파일은 pom.xml 파일(Project Object Model : Maven 환경 설정 파일) 이다.
  • pom.xml에서 할 수 있는 것 중 가장 중요한 한 가지는 바로 '라이브러리(API) 관리'이다.

## MemberController 생성

  • 프로젝트 > java Resources > src/main/java > kr.narp.myapp 우 클릭 > New > Class > MemberController 이름으로 생성
  • @Controller : Spring 에서는 생성한 클래스가 컨트롤러가 되기 위해 어노테이션을 추가해줘야한다.
  • 아래와 같이 기본틀 형성하여 작업 진행
package kr.narp.myapp;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class MemberController {

	@RequestMapping("/memberList.do")
	public String memberList() {
		
				
		return "memberList";
	}
	
}

 

## MVC05 -> Spring 프로젝트로 가져오기

  • MVC05 자료에서 mybatis 관련(config.xml, db.properties, MemberMapper.xml), MemberDAO, MemberVO

## pom.xml

  • pom.xml에서 할 수 있는 것 중 가장 중요한 한 가지는 바로 '라이브러리(API) 관리'이다.
  • 아래 부분 기존 1.6 에서 1.8 버전으로 변경 후 저장, 그리고 프로젝트 우 클릭 > Maven > Update Project.. 클릭 하여 변경사항 적용.
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>2.5.1</version>
  <configuration>
    <source>1.8</source>
    <target>1.8</target>
    <compilerArgument>-Xlint:all</compilerArgument>
    <showWarnings>true</showWarnings>
    <showDeprecation>true</showDeprecation>
  </configuration>
</plugin>
  • pom.xml 에서 'dependency' 는 의존성으로 해당 부분에 API를 적어주면 자동으로 다운로드 됨. (의존성 주입 시 mvnrepository 사이트에서 다운로드 됨.)
	<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>
	
		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.7</version>
			<scope>test</scope>
		</dependency>        
	</dependencies>
  • mvnRepository 사이트에서 Maven에서 사용 가능한 의존성 중 필요한 것을 찾아서 주입 https://mvnrepository.com/

 

반응형
반응형

# Spring WEB MVC 프로젝트_01버전_01 Spring WEB MVC 프로젝트 생성

## Spring 프로젝트 생성.

  • File > New > Spring Legacy Project 클릭 후 아래 입력 및 선택. > Next > kr.narp.myapp 이름으로 생성 예정
Project name : SpringMVC01

Templates :  Spring MVC Project
  • 초기 생성 시 API도 다운로드된다. Maven으로 만들어진 Spring 프로젝트.

## Context 등록

  • Servers 탭 > 톰캣 우 클릭 > Add and Remove > 신규로 생성한 springMVC01 등록 후 Finish.
  • http://localhost:8081/myapp/ 접속하여 연결 확인.

 

# Spring WEB MVC 프로젝트_01버전_02 기존 MVC를 Sprong WEB MVC로 변형

  • 기존 HandlerMapping에 의해 들어온 요청에 따라 각 개별로 처리 진행. (요청에 따라 각 POJO 보유, 해당 POJO에서 처리.)
  • 현재는 요청에 따라 요청에 맞는 POJO가 개별로 진행하던 부분을 하나의 컨트롤러에서 메서드를 이용하여 진행될 수 있도록 변형.

## 문제점

  • 요청이 들어왔을 때 어떤 메서드를 사용해야 할지 모르기 때문에.. HandlerMapping이 큰 의미가 없어진다.
  • Spring에서는 @RequestMapping(); 를 이용하여 해당 문제 해결 가능.

## MemberController

  • 기존 아래의 POJO들의 기능을 MemberController에 메서드로 구현.
MmeberContentController.java
MemberDeleteController.java
MemberInsertController.java
MemberListController.java
MemberRegisterController.java
MemberUpdateController.java
  • MemberController에서 위 POJO 기능을 모두 처리할 수 있도록 메서드 추가.
  • Spring에서는 자체적으로 HandlerMapping이 존재 @RequsestMapping에 따른 처리가 만들어져 있기 때문에 에러가 발생하지 않지만, 해당 코드는 MVC04를 변형하여 해당 어노테이션이 없기 때문에 에러발생.
package kr.bit.controller;

import java.io.IOException;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import kr.bit.model.MemberDAO;
import kr.bit.model.MemberVO;

// 기존 6개의 POJO가 해야할 일들을 1개의 POJO로 처리.
public class MemberController {	// implements Controller 인터페이스 미사용.

	// memberContentController
	@RequsetMapping("/memberContent.do");
	public String memberContent(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		int num = Integer.parseInt(request.getParameter("num"));
		
		MemberDAO dao = new MemberDAO();
		
		MemberVO vo = dao.memberContent(num);
		
		// 객체 바인딩
		request.setAttribute("vo", vo);
		
		// ViewResolver 사용을 위해 논리경로만 남기기.
		// return "/WEB-INF/member/memberContent.jsp";
		return "memberContent";
	}
	
	// memberDelete
	@RequsetMapping("/memberDelete.do");
	public String memberDelete(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		// Context Path 가져오기
		String ctx = request.getContextPath();	// MVC04가 옴
		
		int num = Integer.parseInt(request.getParameter("num"));
		
		MemberDAO dao = new MemberDAO();
		
		int cnt = dao.memberDelete(num);
		
		String nextPage = null;
		
		if (cnt > 0) {
			nextPage = "redirect:" + ctx + "/memberList.do";	// Context Path 추가
		} else {
			throw new ServletException("not delete");
		}
		
		return nextPage;
	}
	
	// memberInsertController
	@RequsetMapping("/memberInsert.do");
	public String memberInsert(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		// Context Path 가져오기
		String ctx = request.getContextPath();	// MVC04가 옴
				
		// 1. 파라미터 수집(VO)
		String id = request.getParameter("id");
		String pass = request.getParameter("pass");
		String name = request.getParameter("name");
		int age = Integer.parseInt(request.getParameter("age"));
		String email = request.getParameter("email");
		String phone = request.getParameter("phone");
		
		// 파라미터 수집(VO)
		// MemberVO vo = new MemberVO(id, pass, name, age, email, phone);
		MemberVO vo = new MemberVO();		
		vo.setId(id);
		vo.setPass(pass);
		vo.setName(name);
		vo.setAge(age);
		vo.setEmail(email);
		vo.setPhone(phone);
		
		//System.out.println("vo : " + vo);	// vo.toString() 이 생략되어있는 것.
		// Model과 연동하는 부분
		MemberDAO dao = new MemberDAO();
		int cnt = dao.memberInsert(vo);
		
		// PrintWriter out = response.getWriter();
		String nextPage = null;
		// 가입 성공
		if ( cnt > 0 ) {
			//out.println("insert success");	
			// 다시 회원 리스트 보기로 가야함.
			// response.sendRedirect("/MVC04/memberList.do");
			nextPage = "redirect:" + ctx + "/memberList.do";	// Context Path 추가
		// 가입 실패 -> 예외 객체를 만들어서 WAS에게 던지자.
		} else {
			throw new ServletException("not insert");	
		}
		return nextPage;
	}
	
	// memberListController
	@RequsetMapping("/memberList.do");
	public String memberList(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		// POJP가 해야할 일
		// 1. model과 연동
		MemberDAO dao = new MemberDAO();
		List<MemberVO> list = dao.memberList();
		
		// 2. 객체 바인딩
		request.setAttribute("list", list);		// 객체 바인딩
		// list를 member/memberList.jsp 로 전달해줘야 함.
		
		// 3. 다음 페이지 정보를 FrontController에게 넘겨주는 일
		// 다음 페이지 (View Page 정보)
		// return "/WEB-INF/member/memberList.jsp";
		return "memberList";
	}
	
	// memberRegisterController
	@RequsetMapping("/memberRegister.do");
	public String memberRegister(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// return "/WEB-INF/member/memberRegister.jsp";
		return "memberRegister";
	}
	
	// memberUpdateController
	@RequsetMapping("/memberUpdate.do");
	public String memberUpdate(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		// Context Path 가져오기
		String ctx = request.getContextPath();	// MVC04가 옴
				
		request.setCharacterEncoding("utf-8");
		// 1. 파라미터 수집(VO)
		int num = Integer.parseInt(request.getParameter("num"));
		int age = Integer.parseInt(request.getParameter("age"));
		String email = request.getParameter("email");
		String phone = request.getParameter("phone");
	
		MemberVO vo = new MemberVO();
		vo.setNum(num);
		vo.setAge(age);
		vo.setEmail(email);
		vo.setPhone(phone);
	
		MemberDAO dao = new MemberDAO();
		
		int cnt = dao.memberUpdate(vo);
		
		String nextPage = null;
		
		if (cnt > 0) {
			nextPage = "redirect:" + ctx + "/memberList.do";	// Context Path 추가
		} else {
			throw new ServletException("not update");
		}
		
		return nextPage;
	}

}

## Spring에서 제공해주는 것

  • FrontController
  • HandlerMapping
  • ViewResolver

## Spring으로 변형되면서 바뀌는 점

  • 기존에는 요청 발생 시 요청에 따른 POJO가 존재하여 해당 요청을 처리, Spring에서는 단일 컨트롤러에서 @RequestMapping() 어노테이션을 이용하여 요청에 따른 메서드를 실행하여 처리. 

반응형

+ Recent posts