spring_mybatis2.zipimport방법
프로젝트 생성에서 마우스 오른쪽 딸깍
General 폴더에 있는 Existing Projects into Workspace 눌르고 next 딸깍
하면 요 화면 나옴 그럼 select archive file 눌르고 파일찾아야함 Browse 딸깍
해당파일 찾아서 열기 딸깍
가져와서 finish 딸깍
import 성공
import를 설명드린 이유는 이클립스와는 다른 spring타입의 파일을 임포트 하였기 때문입니다.
spring타입의 파일을 익스포트 하는방법을 명시하겠습니다.
본론으로 들어가서
Spring mvc + mysql + Mybatis + 페이징 + 동적쿼리 를 한눈에 배워 보겠습니다.
처음 스프링 프로젝트를 생성하고 나면
설정파일들을 설정및 셋팅 해야합니다.
일단 원리는 뒤에 알고 무작정 따라해서 실행 되게 해보겠습니다 !
생성된 프로젝트 안에 src -> main ->webapp 폴더에 들어있는 web.xml 파일을 클릭하여
기존에 있는 소스코드를 전부 삭제하고 아래의 코드를 적용한다.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<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-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<filter>
<display-name>CharacterEncodingFilter</display-name>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<description></description>
<param-name>encoding</param-name>
<param-value>euc-kr</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>*</url-pattern>
</filter-mapping>
</web-app>
다음은 생성된 프로젝트 안에 src -> main ->webapp ->spring 폴더 안에 있는
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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
</beans>
다음은 생성된 프로젝트 안에 src -> main ->webapp ->spring ->appServlet 폴더 안에
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 -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<default-servlet-handler/>
<!-- 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/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<context:component-scan base-package="com.test.dev" />
<!-- datasoruce -->
<beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<beans:property name="driverClassName" value="com.mysql.jdbc.Driver" />
<beans:property name="url" value="jdbc:mysql://localhost:3306/spring" />
<beans:property name="username" value="root" />
<beans:property name="password" value="java0000" />
</beans:bean>
<!-- transaction manager -->
<beans:bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<beans:property name="dataSource" ref="dataSource" />
</beans:bean>
<!-- mybatis -->
<beans:bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<beans:property name="dataSource" ref="dataSource" />
<beans:property name="mapperLocations" value="classpath:com/test/dev/service/UserMapper.xml" />
</beans:bean>
<beans:bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<beans:constructor-arg index="0" ref="sqlSessionFactory" />
</beans:bean>
</beans:beans>
다음은 프로젝트 안에있는 pom.xml 파일에 기존 소스코드를 삭제하고 아래 소스코드를 적용
<?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 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.test.dev</groupId>
<artifactId>web</artifactId>
<name>spring_mybatis</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>3.1.1.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>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
<!-- dbcp -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<!-- spring jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
<!-- mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.2.2</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.2.8</version>
</dependency>
<!-- mysql jdbc-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.34</version>
</dependency>
</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>
다음은 usermapper.xml 설정인데
이파일은 초기 프로젝트 생성시 생성되는 파일이 아님으로 새로 만들어 주어야 한다.
본인은 프로젝트 내에 서비스패키지에 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.test.dev.service">
<update id="updateUser"
parameterType="com.test.dev.domain.User">
UPDATE USER SET
user_pw=#{userPw}
WHERE user_id=#{userId}
</update>
<delete id="deleteUser"
parameterType="com.test.dev.domain.User">
DELETE FROM USER
WHERE user_id=#{userId} AND user_pw=#{userPw}
</delete>
<select id="selectUserByIdAndPw"
parameterType="com.test.dev.domain.User"
resultType="com.test.dev.domain.User">
SELECT
user_id as userId,
user_pw as userPw
FROM USER
WHERE user_id=#{userId} AND user_pw=#{userPw}
</select>
<select id="selectTotalCount"
resultType="Integer">
SELECT
COUNT(*)
FROM USER
</select>
<select id="selectUserList"
parameterType="java.util.Map"
resultType="com.test.dev.domain.User">
SELECT
user_no as userNo,
user_id as userId,
user_pw as userPw
FROM USER
<where>
<if test="word != null">
user_id like CONCAT('%',#{word},'%')
</if>
</where>
ORDER BY user_no DESC
LIMIT #{pageHelper.startRow}, #{pageHelper.linePerPage}
</select>
<insert id="insertUser" parameterType="com.test.dev.domain.User">
INSERT INTO
USER(
user_id,
user_pw
) VALUES(
#{userId},
#{userPw}
)
</insert>
</mapper>
다음은 model을 만들차례 이다. 모델이라함은 흔히 dto 라고 섞어서 만이 쓴다.
비슷한 말이니 비슷하게 이해하기 바란다.
본인은 com.test.dev.domain 패키지에 모델클래스 들을 만들었다.
아래 소스코드 들을 적용하기 바란다.
User클래스
package com.test.dev.domain;
public class User {
private int userNo;
private String userId;
private String userPw;
public int getUserNo() {
return userNo;
}
public void setUserNo(int userNo) {
this.userNo = userNo;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUserPw() {
return userPw;
}
public void setUserPw(String userPw) {
this.userPw = userPw;
}
}
PageHelper클래스
package com.test.dev.domain;
public class PageHelper {
private int startRow;
private int linePerPage;
public PageHelper(int page, int linePerPage) {
this.linePerPage = linePerPage;
this.startRow = (page-1)*linePerPage;
}
public int getStartRow() {
return startRow;
}
public void setStartRow(int startRow) {
this.startRow = startRow;
}
public int getLinePerPage() {
return linePerPage;
}
public void setLinePerPage(int linePerPage) {
this.linePerPage = linePerPage;
}
}
위 코드 까지 적용 했다면 거의다 끝난지 아랐지만 아직 멀었다. ^^
계속 설명 해보이겠다. 사실 소스코드 복사붙혀넣기만 한다면 쉽다.!!(전 글을 쓰고 있어서 어럽네유;)
먼저 dao 와 daointerface를 만들것인데 dao에 사용하기 위해 interface 를 먼저 만들것이다.
본인은 com.test.dev.service 패키지 에서 UserDao 라는 인터페이스를 먼저 만들었다.
아래소스코드를 적용
UserDao InterFace
package com.test.dev.service;
import java.util.List;
import java.util.Map;
import com.test.dev.domain.User;
public interface UserDao {
public int deleteUser(User user);
public User selectUserByIdAndPw(User user);
public int selectTotalCount();
public int insertUser(User user);
public List<User> selectUserList(Map<String, Object> map);
}
com.test.dev.service 패키지 에 UserDaoImpl 클래스
package com.test.dev.service;
import java.util.List;
import java.util.Map;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.test.dev.domain.User;
@Repository
public class UserDaoImpl implements UserDao {
private final String NS = "com.test.dev.service";
@Autowired
private SqlSessionTemplate sqlSession;
@Override
public int deleteUser(User user) {
return sqlSession.delete(NS+".deleteUser", user);
}
@Override
public User selectUserByIdAndPw(User user) {
return sqlSession.selectOne(NS+".selectUserByIdAndPw",user);
}
@Override
public int selectTotalCount() {
return sqlSession.selectOne(
NS+".selectTotalCount");
}
@Override
public int insertUser(User user) {
return sqlSession.insert(
NS+".insertUser", user);
}
@Override
public List<User> selectUserList(Map<String, Object> map) {
return sqlSession.selectList(
NS+".selectUserList",map);
}
}
위에 까지 적용했다면 dao 까지 적용 한 것이다.
다음은 우리가 어떠한 로직을 처리하는 기능을 하는 서비스를 구현해보겠다.
com.test.dev.service 패키지 에 UserService InterFace
package com.test.dev.service;
import java.util.List;
import com.test.dev.domain.User;
public interface UserService {
public int removeUser(User user);
public User getUserByIdAndPw(User user);
public int getLastPage();
public int addUser(User user);
public List<User> getUserList(int page, String word);
}
com.test.dev.service 패키지 에 UserServiceImpl클래스
package com.test.dev.service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.test.dev.domain.PageHelper;
import com.test.dev.domain.User;
@Service
public class UserServiceImpl implements UserService {
private final int LINE_PER_PAGE = 10;
@Autowired
private UserDao userDao;
@Override
public int removeUser(User user) {
return userDao.deleteUser(user);
}
@Override
public User getUserByIdAndPw(User user) {
return userDao.selectUserByIdAndPw(user);
}
@Override
public int getLastPage() {
return (int)(Math.ceil((double)userDao.selectTotalCount()/LINE_PER_PAGE));
}
@Override
public int addUser(User user) {
return userDao.insertUser(user);
}
@Override
public List<User> getUserList(int page, String word) {
PageHelper pageHelper = new PageHelper(page,LINE_PER_PAGE);
Map<String, Object> map = new HashMap<String, Object>();
map.put("pageHelper", pageHelper);
map.put("word", word);
return userDao.selectUserList(map);
}
}
위 코드까지 적용 했다면 서비스 까지 구현완료 !!
다음은 요청을 받고 처리를 보내주는 역할을 하는 Controller 를 만들겠다.
본인은 com.test.dev.web 패키지에 UserController클래스를 만들었다.
아래 소스코드를 적용 하기 바란다.
package com.test.dev.web;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.bind.support.SessionStatus;
import com.test.dev.domain.User;
import com.test.dev.service.UserService;
@Controller
@SessionAttributes(value={"sessionUser"})
public class UserController {
@Autowired
private UserService userService;
// 회원탈퇴 폼
@RequestMapping(value="/", method=RequestMethod.GET)
public String home(){
return "home";
}
@RequestMapping(value="/userOut", method=RequestMethod.GET)
public String userOut(){
return "userOut";
}
// 회원탈퇴
@RequestMapping(value="/userOut", method=RequestMethod.POST)
public String userOut(@RequestParam(value="userPw") String userPw,
@ModelAttribute(value="sessionUser") User sessionUser,
SessionStatus sessionStatus){
sessionUser.setUserPw(userPw);
if(userService.removeUser(sessionUser)==0) {
return "redirect:/userOut";
} else {
sessionStatus.setComplete();
return "redirect:/";
}
}
@RequestMapping(value="/logout", method=RequestMethod.GET)
public String logout(SessionStatus sessionStats) {
sessionStats.setComplete();
return "redirect:/";
}
// 로그인 폼
@RequestMapping(value="/loginForm", method=RequestMethod.GET)
public String loginForm() {
return "loginForm";
}
// 로그인
@RequestMapping(value="/login", method=RequestMethod.POST)
public String login(Model model, User user) {
User sessionUser = userService.getUserByIdAndPw(user);
if(sessionUser==null){
return "loginForm";
}else{
model.addAttribute("sessionUser", sessionUser);
return "redirect:/";
}
}
// 회원가입 폼
@RequestMapping(value="/signupForm", method=RequestMethod.GET)
public String addUserForm() {
return "signupForm";
}
// 회원가입
@RequestMapping(value="/signup", method=RequestMethod.POST)
public String addUser(User user) {
if(user.getUserId().length()<4 || user.getUserPw().length()<4) {
return "signupForm";
}
int addResult = userService.addUser(user);
if(addResult == 0) {
return "signupForm";
}
return "redirect:/userList";
}
// 사용자 리스트
@RequestMapping(value="/userList", method=RequestMethod.GET)
public String userList(Model model,
@RequestParam(value="page", defaultValue="1") int page,
@RequestParam(value="word", required=false) String word) {
List<User> userList = userService.getUserList(page, word);
model.addAttribute("userList", userList);
model.addAttribute("page", page);
model.addAttribute("lastPage", userService.getLastPage());
return "userList";
}
}
컨트롤러 소스코드 적용이 완료 됬다. 지금까지 잘 따라와 주었다.
그렇지만 아직 끝나지 않았다.
view 쪽을 끝내야 한다. 바로 뷰어 를 시작하겠다.
프로젝트 안에 src -> main -> views 폴더에 초기 생성 jsp가 있다.
본인은 home.jsp 라고 있었다. 들어가서 아래소스코드로 교체 한다.
<%@ page language="java" contentType="text/html; charset=EUC-KR" pageEncoding="EUC-KR"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<title>Home</title>
</head>
<body>
<c:if test="${sessionUser eq null}">
<a href="/loginForm">로그인</a>
<a href="/signupForm">회원가입</a>
</c:if>
<h1>
main index
</h1>
<form action="/userOut" method="post">
<c:if test="${sessionUser ne null}">
ID :${sessionUser.userId}
PW :
<input type="password" name="userPw">
<input type="submit" value="회원탈퇴">
</c:if>
</form>
</body>
</html>
위 소스코드 가 적용되고 나서 실행한다면 아래 화면이 보여야 정상. 아니면 비정상
(현재 주소창에는" http://localhost/ " 쌍따움표 안의 주소만 써도 home.jsp 화면이
보이는 상황이다.[복사붙혀넣기만 잘했다면 ;;] )
자 이제 메인화면은 끝난 샘이다. 그러나 우리에게는 아직 높은 벽이 남아 있다.
여기서 인내를 하느냐 마냐에 따라 스프링 과 마이바티스 의 연동에 대해 알수 있다.
끝까지 함께하자!!
다음은 views 에 있는 jsp파일들의 소스코드를 적용 시켜보자.
회원 가입 폼 을 만들어서 처리 까지 다뤄 보겠다 .
signupForm.jsp 파일
<%@ page language="java" contentType="text/html; charset=EUC-KR" pageEncoding="EUC-KR"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=EUC-KR">
<title>Insert title here</title>
</head>
<body>
<h1>회원가입 폼</h1>
<form action="/signup" method="post">
<table>
<tr>
<td>
<label>ID : </label>
<input type="text" name="userId">
</td>
<td>
<label>PW : </label>
<input type="text" name="userPw">
<input type="submit" value="가입^^">
</td>
</tr>
</table> <br>
<a href="/">홈으로 돌아가기</a>
</form>
</body>
</html>
위소스를 적용 했다면 main index 화면에서 회원가입을 눌러보자
눌러서 아래화면이 나온다면 성공
이제 가입한 정보를 mysql로 연동되었는지 확인 해보겠습니다.
자아 화면하쥬?
이제 가입한 아이디로 로그인을 해보겠습니다.
로그인 views 화면을 만들어 줘야겠네요.
아래소스코드를 loginForm.jsp 에 넣어주세요.
loginForm.jsp
<%@ page language="java" contentType="text/html; charset=EUC-KR" pageEncoding="EUC-KR"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=EUC-KR">
<title>Insert title here</title>
</head>
<body>
<h1>로그인 폼</h1>
<form action="/login" method="post">
<table>
<tr>
<td>
<label>ID : </label>
<input type="text" name="userId">
</td>
<td>
<label>PW : </label>
<input type="text" name="userPw">
<input type="submit" value="로그인">
</td>
</tr>
</table> <br>
<a href="/">홈으로 돌아가기</a>
</form>
</body>
</html>
위 소스코드 를 적용 했다면 main index 화면에서
로그인 을 눌러서 아래 화면이 나와야합니다.
아까전 ID: footcoding PW: codingzzang 로 로그인 했더니
이런 화면이 나왔네유 그럼 감이 오시죠
마이바티스와 스프링이 연동에 성공하여 DB로직을 처리하였습니다.
이제 정말 마지막 이네유 회원 리스트 views 를 만들겠습니다.
아래 소스코드를 userList.jsp 에 적용해주세요.
<%@ page language="java" contentType="text/html; charset=EUC-KR" pageEncoding="EUC-KR"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<%@ page session="false" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=EUC-KR">
<title>Insert title here</title>
</head>
<body>
<h1>User List</h1>
<table>
<tr>
<td>번호</td>
<td>아이디</td>
<td>비밀번호</td>
</tr>
<c:forEach var="obj" items="${userList}">
<tr>
<td>${obj.userNo}</td>
<td>${obj.userId}</td>
<td>${obj.userPw}</td>
</tr>
</c:forEach>
</table>
<c:if test="${page>1}">
<a href="/userList?page=${page-1}">[이전]</a>
</c:if>
[${page}]
<c:if test="${page<lastPage}">
<a href="/userList?page=${page+1}">[다음]</a>
</c:if>
<a href="/">홈으로 돌아가기</a>
</body>
</html>
위 소스코드를 적용 하셨다면 main index 화면에서 회원가입을 클릭
아이디와 비밀번호를 작성하고 가입^^ 을 클릭하면 db에 저장이 되고 db에 저장된 컬럼들이
아래화면처럼 리스트로 보여지게 됩니다.
아마 소스코드에 대해서 궁금하신 사항이 많을것 같은데요
이번주 내로 분석하여 분석내용을 따로 올릴예정입니다.
그전에 해답이 필요하시다면 댓글이나 방명록 남겨주세요.
이상 으로 허접한 발코딩 무작정 따라하기를 마무리 하겠습니다. !
'프레임워크' 카테고리의 다른 글
| Log4J 에 대한 정보를 파악하자. (0) | 2015.11.13 |
|---|