DTO와 DAO 작성


1. Dto 패키지 안에 새로운 클래스 UserDto를 생성한다.

package com.app.app.Dto;

public class UserDto {
    private String user_id;
    private String name;
    private String password;
    private String nickname;
    
	public String getUser_id() {
		return user_id;
	}
	public void setUser_id(String user_id) {
		this.user_id = user_id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getNickname() {
		return nickname;
	}
	public void setNickname(String nickname) {
		this.nickname = nickname;
	}
}

2. Dao 패키지 안에 UDao Interface를 만들어준다.

package com.app.app.Dao;

import java.util.ArrayList;
import java.util.Map;
import com.app.app.Dto.UserDto;

public interface UDao {
	public void Register(Map map);
}

3. Dao 패키지 안에 UDao를 implements 한 UserDao를 만들어준다.

package com.app.app.Dao;
import java.util.ArrayList;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;

import com.app.app.Dto.UserDto;

public class UserDao implements UDao{

	JdbcTemplate template;
	
	@Autowired
	public void setTemplate(JdbcTemplate template) {
		this.template = template;
	}
	
	@Override
	public void Register(Map map) {
		// TODO Auto-generated method stub
		
	}
}

UserDao는 UDao의 구현 클래스로 interface에서 정의한 메소드들에 대한 재정의를 해준다.


SQL 문 작성


mapper패키지 안에 UDao.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="com.app.app.Dao.UDao">

	<insert parameterType="map" id="Register">
	INSERT INTO
		USER (user_id, password, nickname, name)
		VALUES(#{user_id}, #{password}, #{nickname}, #{name}) 
	</insert>
</mapper>

<insert> 태그의 parameterType은 이 퀴리문을 실행시킬때 파라미터로 어떤 객체를 넘길건지 정하는 부분이다

파라미터 타입을 map으로 지정하면 아래와 같이 퀴리문에서 맵에 해당이름에 대한 키를 뽑아낼 수 있다.


AppController 수정


AppController에 새로운 메소드를 추가한다

package com.app.app.Controller;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.app.app.Dao.*;
import com.app.app.Dto.*;
@Controller
public class AppController {
	UserDao userdao;
	@Autowired
	private SqlSession sqlSession;
	......................................................................
	@ResponseBody
	@RequestMapping("/RegisterAct")
	public String RegisterAct(HttpServletRequest request) {
		UDao dao = sqlSession.getMapper(UDao.class);
		Map<String, String> map = new HashMap<String, String>();
        
		map.put("user_id",request.getParameter("user_id").trim());
        map.put("password",request.getParameter("password").trim());
        map.put("nickname",request.getParameter("nickname").trim());
        map.put("name", request.getParameter("name").trim());
		
		dao.Register(map);
		return "OK";
	}
}

@ResponseBody는 이 메소드가  Response 할수 있게 해준다. @ResponseBody 없이 특정 문자를 return하게되면 views에서 해당파일을 찾기 때문에 404 에러가 뜬다.


이제 http://localhost:8080/app/Register 에 접속하여 회원가입을 진행해보자.

아래와 같은 메시지가 나오면 성공한 것이다.

 

컨트롤러 생성하기


com.app.app.Controller 패키지에 AppController 클래스를 생성해준다.

package com.app.app.Controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.app.app.HomeController;

@Controller
public class AppController {
	
	private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
	

}

view 만들기


src - main - webapp - WEB-INF - views 에 index.jsp를 생성한다

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">

<title>Index</title>
</head>
<body>
<table border="1" align="center" width="500" height="200">
	<tr>
		<td colspan="4" height="100" align="center">Main page</td>
	</tr>
	<tr>
		<td colspan="2" align="center" width="250"><a href="Login">로그인</a></td>
		<td colspan="2" align="center" width="250"><a href="Register">회원가입</a></td>
	</tr>
</table>
</body>
</html>

위와 같이 입력한다.

Register.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>
	<form name="Register" method="post" action="RegisterAct">
		<table border="1" align="center" width="500" height="500">
			<tr>
				<td colspan="4" height="100" align="center">회원가입</td>
			</tr>
			<tr>
				<td colspan="1" height="100" align="center">ID</td>
				<td colspan="3" height="100" align="center">
				<input type="text" name="user_id">
				</td>
			</tr>
			<tr>
				<td colspan="1" height="100" align="center">Password</td>
				<td colspan="3" height="100" align="center">
				<input type="text" name="password">
				</td>
			</tr>
			<tr>
				<td colspan="1" height="100" align="center">NickName</td>
				<td colspan="3" height="100" align="center">
				<input type="text" name="nickname">
				</td>
			</tr>
			<tr>
				<td colspan="1" height="100" align="center">Name</td>
				<td colspan="3" height="100" align="center">
				<input type="text" name="name">
				</td>
			</tr>
			<tr>
				<td colspan="4" height="100" align="center"><input type = "submit" value="가입하기"></td>
			</tr>
				</td>
			</tr>
		</table>
	</form>
</body>
</html>

Login.jsp 도 생성해 준다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">

<title>Index</title>
</head>
<body>
<form name="Login" method="post" action="LoginAct">
<table border="1" align="center" width="500" height="400">
	<tr>
		<td colspan="4" height="100" align="center">로그인</td>
	</tr>
	<tr>
		<td colspan="2" align="center" width="250">아이디</td>
		<td colspan="2" align="center" width="250"><input type="text" name="id"></td>
	</tr>
	<tr>
		<td colspan="2" align="center" width="250">비밀번호</td>
		<td colspan="2" align="center" width="250">
		<input type="text" name="password">
		</td>
	</tr>
	<tr>
		<td colspan="4" align="center" width="250">
		<input type="submit" value="로그인">
		</td>
	</tr>
</table>
</form>
</body>
</html>

View에 URL을 매핑하기


AppController를 수정 해 준다

package com.app.app.Controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;


@Controller
public class AppController {
	
	private static final Logger logger = LoggerFactory.getLogger(AppController.class);
	
	@RequestMapping("/")
	public String index(Model model) {
		return "index";
	}
	@RequestMapping("/Register")
	public String Register(Model model) {
		return "Register";
	}
	@RequestMapping("/Login")
	public String Login(Model model) {
		return "Login";
	}
}

위 코드는 각각 index.jsp, Register.jsp, Login.jsp를 /, /Register, /Login 의 url에 매핑해주는 코드이다.

서버를 실행하고 http://localhost:8080/app/ 으로 접속해보자.

아래와 같이 나온다면 잘 따라온 것이다.

MyBatis 라이브러리 추가


1. 프로젝트 내에 있는 pom.xml 파일을 열어준다.

2.<dependencies> ~~~ </dependencies> 안에 아래의 코드를 삽입한다.

		<!-- MyBatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.2</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>
		<!-- MySql -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.31</version>
		</dependency>
        	<!-- xerces parser -->
        	<dependency>
			<groupId>xerces</groupId>
			<artifactId>xercesImpl</artifactId>
			<version>2.9.1</version>
		</dependency>
        

3. src - main - webapp - WEB-INF - spring - appServlet 아래에 datasource-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 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost/bbs?serverTimezone=UTC" />
		<property name="username" value="root" />
		<property name="password" value="1111" />
	</bean>
</beans>

4. src - main - webapp - WEB-INF 아래에 있는 web.xml을 열어준다.

	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

위의 코드를 아래와 같이 수정해준다.

	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/*-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

이 코드는 서버가 시작 될때 /WEB-INF/spring/appServlet 아래의 파일명이  "-context.xml"로 끝나는 파일을 모두 읽어들이는 것을 뜻한다.

5. src - main - webapp - WEB-INF - spring - appServlet 아래에 mapper-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"
	xmlns:context="http://www.springframework.org/schema/context"
	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">
	<bean id="sqlSession"
		class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mapperLocations"
			value="classpath:com/app/app/mapper/*.xml" />
	</bean>
	<bean id="sqlSessionTemplate"
		class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="sqlSession" />
	</bean>
</beans>

위와 같이 입력해준다.

7줄의 name은 위에서 등록한 sqlSession 빈에서 사용할 이름 이고 ref는 datasource-context.xml에서 정의한 빈을 참조하겠다는 의미이다.

9줄의 mapperLocations는 우리가 작성할 sql문이 위치할 장소이다.


패키지 생성


아래와 같은 패키지 구조를 생성해준다.

Controller, Dao, Dto, mapper를 com.app.app 아래에 생성해준다.


서버를 실행해보자.

별 다른 오류가 없다면 잘 따라온 것이다.

STS설치


Eclipse - Help - Eclipse Marketplace 에서 STS또는 tag:spring 를 검색후

아래 Spring Tools 3 로 시작하는 두 항목을 다운로드 합니다.


프로젝트 생성


Spring 을 검색하여 Spring Legacy Project 를 선택하고 Next를 눌러줍니다.

아래와 같이 Spring MVC Project 를 선택하고 Next를 눌러줍니다

Finish를 눌러 프로젝트를 생성합니다.

 

1. jdbc jar 추가하기

프로젝트 우클릭 - Properties - Java Build Path 의 Libraries 탭에서 Add External JARs 를 클릭해준다.

MYSQL\Connector J\에 있는

mysql-connector-java-x.x.x.x.jar를 선택하고 Apply and Close를 클릭해준다.

Tomcat 설치폴더\lib에도 mysql-connector-java 를 복사해서 넣어준다.

2. Schema 만들기

mysql 콘솔을 키고 아래의 명령어를 입력한다.

1
2
3
4
5
6
7
8
9
10
11
12
CREATE DATABASE IF NOT EXISTS BBS
DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
USE BBS;
 
CREATE TABLE IF NOT EXISTS user(
    id INT(10NOT NULL AUTO_INCREMENT PRIMARY KEY,
    user_id VARCHAR(32NOT NULL,
    password VARCHAR(32NOT NULL,
    nickname VARCHAR(32NOT NULL,
    name VARCHAR(32NOT NULL,
    date DATETIME DEFAULT CURRENT_TIMESTAMP
);
http://colorscripter.com/info#e" target="_blank" style="color:#e5e5e5text-decoration:none">Colored by Color Scripter
 

1 - Database 생성

2- Table 생성

Query OK 가 뜨면 정상적으로 DB생성과 Table 생성이 완료된 것이다.

DESC user 을 입력해보자 아래와 같은 테이블 구조를 볼 수 있다.


3. 새로운 패키지 dao, dto, service를 만들어 준다

dto 패키지 안에 UserDto클래스를 생성한다.

1
2
3
4
5
6
7
8
9
package dto;
public class UserDto {
        private String user_id;
        private String name;
        private String password;
        private String nickname;
        
}
 

위와 같이 입력하고 우클릭 - Source - Generate Getters and Setters 를 클릭한다.

Select All 을 클릭하고 Generate를 클릭해준다

UserDto는 DB에 user 데이터를 새로 저장하거나 조회하여 꺼내올때 UserDto객체에 정보를 담아서 이용할 수있다.


새로운 유저 정보를 DB 에 Insert할 Dao를 dao패키지 안에 작성하자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package dao;
 
 
import dto.UserDto;
public class UserDao {
    private Connection conn;
    private PreparedStatement pstmt;
    private ResultSet rs;
    
    public UserDao() {
        try {
            String dbURL = "jdbc:mysql://localhost:3306/BBS?serverTimezone=UTC";
            String dbID = "root";
            String dbPassword = "1111";
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(dbURL,dbID,dbPassword);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public int register(UserDto dto) {
        String SQL = "INSERT INTO USER(user_id, password, nickname, name) VALUES(?,?,?,?)";
        try {
            pstmt= conn.prepareStatement(SQL);
            pstmt.setString(1, dto.getUser_id());
            pstmt.setString(2, dto.getPassword());
            pstmt.setString(3, dto.getNickname());
            pstmt.setString(4, dto.getName());
            return pstmt.executeUpdate();
        } catch(Exception e) {
            e.printStackTrace();
        }
        return -1// database error
    }
}
 
http://colorscripter.com/info#e" target="_blank" style="color:#e5e5e5text-decoration:none">Colored by Color Scripter

14 - DB 연결부분

26 - 새로운 유저를 DB에 Insert 하는 메서드

27 - SQL문

28 - PreparedStatement가 27 줄의 Sql을 사용하겠다는 뜻.

30 - pstmt.setString(1, dto.getUser_id()); Sql문 의 VALUES(?,?,?,?)중 첫번째 ?에 DTO의 user_id 지정


 4. Dao와 Dto를 작성하였으니 이제 회원가입 정보를 받을 join.html 을 수정한다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Join</title>
</head>
<body>
<form name = "join" method="post" action="joinservice">
ID: <input type="text" name="user_id"> <br>
PWD: <input type="password" name="password"> <br>
NickName: <input type="text" name="nickname"><br>
Name: <input type="text" name="name"><br>
<input type = "submit">
</form>
</body>
</html>
 

앞서 BBS 스키마의 user 테이블에 있는 정보를 받아서 joinservice로 넘기는 html 문서이다.


 5. 회원가입 정보를 처리할 Servlet을 service 패키지 안에 작성한다

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//joinservice
package service;
 
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import dao.UserDao;
import dto.UserDto;
 
@WebServlet("/joinservice")
public class joinservice extends HttpServlet {
    private static final long serialVersionUID = 1L;
    //userdao 객체 선언
    private UserDao dao = new UserDao();
    //userdto 객체 선언
    private UserDto dto = new UserDto();
    public joinservice() {
        super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        PrintWriter Writer = response.getWriter();
        response.setContentType("text/html; charset=UTF-8");
        response.setCharacterEncoding("UTF-8");
        //Parameter로 넘어온 값들을 dto에 넣어준다.
        dto.setUser_id(request.getParameter("user_id").trim());
        dto.setPassword(request.getParameter("password").trim());
        dto.setNickname(request.getParameter("nickname").trim());
        dto.setName(request.getParameter("name").trim());
        int result = dao.register(dto);
        if(result == -1) {
            System.out.println("error");
            Writer.println("<script>");
            Writer.println("alert('fail')");
            Writer.println("</script>");
        }
        else {
            System.out.println("success");
            Writer.println("<script>");
            Writer.println("alert('success');");
            Writer.println("</script>");
        }
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
 
}
 
 

 


6. /join.html에 접속하여 값을 입력하고 전송해보자

 

submit

아래와 같이 메시지가 나오면 성공한 것이다. 

이제 DB에 추가되었는지 확인해보자.

mysql 콘솔을 켜고 아래와 같이 입력한다.

use bbs;

select * from user;

DB에 잘 들어간 것을 볼 수 있다.

WebContent 아래에 

아래와같은 html 파일을 생성한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form name = "join" method="post" action="join">
ID: <input type="text" name="id"> <br>
PWD: <input type="password" name="pwd"> <br>
<input type = "submit">
</form>
</body>
</html>
 
 
 

새로운 servlet을 생성해준다( join )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
 
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
 
@WebServlet("/join")
public class join extends HttpServlet {
    private static final long serialVersionUID = 1L;
 
    public join() {
        super();
        // TODO Auto-generated constructor stub
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        PrintWriter Writer = response.getWriter();
        response.setContentType("text/html; charset=UTF-8");
        Writer.println("<html>");
        Writer.println("<head><title>Prameter</title></head>");
        Writer.println("<body>");
        Writer.println("id :"+request.getParameter("id")+"<br>");
        Writer.println("pwd: "+ request.getParameter("pwd"));
        Writer.println("</body></html>");
    }
 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doGet(request, response);
    }
 
}
 
http://colorscripter.com/info#e" target="_blank" style="color:#e5e5e5text-decoration:none">Colored by Color Scripter
http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

28, 29 : 파라미터 이름으로 값을 추출하는 과정이다 위에 작성한 html에서 id는 name = "id"로 지정했었고, PWD는 name = "pwd"로 지정하였기 때문에 request.getParameter("이름") 으로 추출한다.

이제 접속 해보자

제출 버튼을 누르면

아래와 같이 입력 값들이 추출되어 나온다.

[Servlet]

  • Servlet은 웹프로그래밍에서 클라이언트의 요청을 처리하고 결과를 다시 클라이언트에게 전송하는 JAVA 프로그래밍 기술이다.
  • HTTP 프로토콜 서비스를 지원하는 javax.servlet.http.httpServlet 클래스를 상속 받는다.

[ Servlet 동작 방식 ]

  1. Client가 접속하면 HTTP Request를 Servlet Container로 전송한다
  2. Request를 받은 Servelet Container는 HTTPServletRequest, HttpServeltResponse 두 객체를 생성한다.
  3. web.xml은 Client가 요청한 URL을 분석하여 어느 서블릿에 대한 Request인지 찾는다
  4. 해당 서블릿에서 service메소드를 호출한 뒤 클라이언트 요청 방식(Get, Post) 에따라 doGet() 또는 doPost()를 호출한다.
  5. doGet() ,doPost()는 동적페이지를 생성한 후 HttpServlet.Response 객체에 응답한다.
  6. 응답이 끝나면 HttpServeltRequest, HttpServletResponse 객체를 소멸한다.

[Servlet URL_Mapping 방식]

1. web.xml 을 이용하는 방법

먼저 프로젝트를 우클릭 한뒤 New - class 를 선택한다

 

 

아래와 같이 입력해준다.

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Hello_xml extends HttpServlet {
private static final long serialVersionUID = 1L;
       
    
    public Hello_xml() {
        super();
        // TODO Auto-generated constructor stub
    }

    
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        PrintWriter Writer = response.getWriter();
        response.setContentType("text/html; charset=UTF-8");
        Writer.println("<html>");
        Writer.println("<head><title>XML Mapping</title></head>");
        Writer.println("<body>");
        Writer.println("<h1>XML Mapping<h1>");
        Writer.println("</body></html>");
    }

    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doGet(request, response);
    }

}
 

Eclipse에서 생성한 dynamic project를 우클릭 하고나서 Java EE Tools - Generate Deployment Descriptor Stub 를 선택해준다.

WebContent/WEB-INF/ 아래에 web.xml 이 생성된 것을 볼 수 있다.

web.xml을 아래와 같이 수정해준다

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>Servlet_Web_Pjt</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
  <servlet>
      <servlet-name>Hello_xml</servlet-name>
      <servlet-class>Hello_xml</servlet-class>
  </servlet>
  
  <servlet-mapping>
  <servlet-name>Hello_xml</servlet-name>
  <url-pattern>/hello_xml</url-pattern>
  </servlet-mapping>
</web-app>
​
 

13 - servlet을 추가하는 부분이다.

14 - Servlet 이름

15 - Servlet class를 설정하는 부분이다 패키지명.클래스 로 입력한다

18 ~ 21 URL을 Mapping 하는 부분이다.

이제 서버를 실행하고 /hello_xml 로 접속해보자.

아래와 같이 URL이 Mapping 된걸 확인 할 수 있다.

2. Annotation을 이용하는 방법

프로젝트 우클릭 new - servlet을 선택해준다

생성된 class를 보면 기본적인 메서드가 생성되어있다

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@WebServlet("/Hello_annotation")
public class Hello_annotation extends HttpServlet {
    private static final long serialVersionUID = 1L;
       

    public Hello_annotation() {
        super();
        // TODO Auto-generated constructor stub
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        PrintWriter Writer = response.getWriter();
        response.setContentType("text/html; charset=UTF-8");
        Writer.println("<html>");
        Writer.println("<head><title>Annotation Mapping</title></head>");
        Writer.println("<body>");
        Writer.println("<h1>Annotation Mapping<h1>");
        Writer.println("</body></html>");
    }


    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doGet(request, response);
    }

}
 

위의 xml 방식과 다른점은 

7 줄과 13번줄의 어노테이션이 추가된 것 뿐이다

@WebServlet("/~") 은 xml Mapping 방식과 동일하게 /~의 url을 Servlet과 매핑시켜준다

웹 서버를 재시작한뒤 확인해보면 아래와 같은 화면이 나온다

 

+ Recent posts