국비필기노트/jsp

jsp_MVC2 패턴으로 회원가입 만들기(+초기세팅)

개발..너... 2022. 6. 17. 14:23

*index.jsp

 
1
2
3
4
5
6
7
8
9
10
11
12
13
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <a href="./app/user/joinview.jsp">회원가입</a><br>
    <a href="${pageContext.request.contextPath }/user/userLogin.us">로그인</a>
</body> 
</html>
 cs

 

 

*joinview.jsp

 

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
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action="/user/UserJoin.us" method="post">
        <p>
            아이디 : <input type="text" name="userid">
        </p>
        <p>
            비밀번호 : <input type="password" name="userpw">
        </p>
        <p>
            이름 : <input type="text" name="username">
        </p>
        <p>
            전화번호 : <input type="text" name="userphone">
        </p>
        <p>
            주소 : <input type="text" name="useraddr">
        </p>
        <p>
            <input type="submit" value="회원가입">
        </p>
    </form>
</body>
</html>
 cs

 

 

*UserFrontController.java

 

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
54
package com.koreait.app.user;
 
import java.io.IOException;
 
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.koreait.action.Action;
import com.koreait.action.ActionForward;
 
@WebServlet("*.us")
public class UserFrontController extends HttpServlet{
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        doProcess(req, resp);
    }
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        doProcess(req, resp);
    }
    
    protected void doProcess(HttpServletRequest req, HttpServletResponse resp) 
            throws IOException, ServletException {
        String requestURI = req.getRequestURI();
        ActionForward forward = null;
        
        if( requestURI.equals("/user/UserJoin.us") ) {
            forward = new UserJoinAction().execute(req, resp);
            }else if(requestURI.equals("/user/userLogin.us")) {
                forward=new ActionForward(false,"/app/user/loginview.jsp");
            }
        
        //일괄처리
        if( forward != null ){
            if( forward.isRedirect() ) {    // redirect
                resp.sendRedirect(forward.getPath());
            } else {                        // forward
                RequestDispatcher disp = req.getRequestDispatcher(forward.getPath());
                disp.forward(req, resp);
            }
        }
        
    }
 
}
 
 cs

 

 

*Action.java

 

1
2
3
4
5
6
7
8
9
10
11
package com.koreait.action;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public interface Action {
    
    public ActionForward execute(HttpServletRequest req, HttpServletResponse resp);
    
}
 
 cs

 

 

*ActionForward.java

 

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
package com.koreait.action;
 
public class ActionForward {
    private boolean isRedirect;
    private String path;
    
    public ActionForward() {}
    
    public ActionForward(boolean isRedirect, String path) {
        super();
        this.isRedirect = isRedirect;
        this.path = path;
    }
 
    public boolean isRedirect() {
        return isRedirect;
    }
    public void setRedirect(boolean isRedirect) {
        this.isRedirect = isRedirect;
    }
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
    
    
}
 
 cs

 

 

*UserDTO.java

 

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
package com.koreait.app.user.dao;
 
public class UserDTO {
    private String userid;
    private String userpw;
    private String username;
    private String userphone;
    private String useraddr;
    
    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;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getUserphone() {
        return userphone;
    }
    public void setUserphone(String userphone) {
        this.userphone = userphone;
    }
    public String getUseraddr() {
        return useraddr;
    }
    public void setUseraddr(String useraddr) {
        this.useraddr = useraddr;
    }
    
}
 
 cs

 

 

*UserDAO.java

 

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
package com.koreait.app.user.dao;
 
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
 
import com.koreait.app.user.mybatis.SqlMapConfig;
 
 
public class UserDAO {
    SqlSessionFactory factory = SqlMapConfig.getFactory();
    SqlSession sqlsession;
    
    public UserDAO() {
        // autocommit
        sqlsession = factory.openSession(true);
    }
    
    public boolean join(UserDTO user) {
        boolean result = false;
        
        if(sqlsession.insert("User.join", user) != 0) {
            result = true;
        }
        
        return result;
    }
    
}
 cs

 

 

*UserJoinAction.java

 

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
package com.koreait.app.user;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.koreait.action.Action;
import com.koreait.action.ActionForward;
import com.koreait.app.user.dao.UserDAO;
import com.koreait.app.user.dao.UserDTO;
 
public class UserJoinAction implements Action{
 
    @Override
    public ActionForward execute(HttpServletRequest req, HttpServletResponse resp) {
        UserDAO udao = new UserDAO();
        UserDTO user = new UserDTO();
        ActionForward forward = new ActionForward();
        
        user.setUserid(req.getParameter("userid"));
        user.setUserpw(req.getParameter("userpw"));
        user.setUsername(req.getParameter("username"));
        user.setUserphone(req.getParameter("userphone"));
        user.setUseraddr(req.getParameter("useraddr"));
        
 
        if(udao.join(user)) {        
            forward.setRedirect(true);
            forward.setPath(req.getContextPath() + "/app/user/loginview.jsp");
        } else {                
            forward.setRedirect(true);
            forward.setPath(req.getContextPath() + "index.jsp" );
        }
        
        return forward;
    }
 
}
 
 cs

 

 

*UserCharacterEncodingFilter

 

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
package com.koreait.filter;
 
import java.io.IOException;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
 
@WebFilter("*.us")
public class UserCharacterEncodingFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest arg0, 
            ServletResponse arg1, FilterChain arg2)
            throws IOException, ServletException {
        
        arg0.setCharacterEncoding("UTF-8");
        
        arg1.setCharacterEncoding("UTF-8");
        arg1.setContentType("text/html charset=UTF-8"); 
 
        arg2.doFilter(arg0, arg1);
 
    }
 
    @Override
    public void destroy() {
 
        
    }
 
 
    @Override
    public void init(FilterConfig arg0) throws ServletException {
 
    }
 
 
}
 
 cs
 

 

*SqlMapConfig.java

 

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
package com.koreait.app.user.mybatis;
 
import java.io.IOException;
import java.io.Reader;
 
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 
public class SqlMapConfig {
    private static SqlSessionFactory factory;
 
    static {
        try {
            String resource = "./com/koreait/app/user/mybatis/config.xml";
            Reader reader = Resources.getResourceAsReader(resource);
            factory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static SqlSessionFactory getFactory() {
        return factory;
    }
}
 
 cs

 

*user.xml

 

1
2
3
4
5
6
7
8
9
10
<?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="User"> 
    <insert id="join" parameterType="userdto">
        INSERT INTO "user" VALUES (#{userid},#{userpw},#{username},#{userphone},#{useraddr});
    </insert>
    
</mapper>
 cs

 

 

*config.xml

 

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
<?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="com.koreait.app.user.dao.UserDTO" alias="userdto"/>
    </typeAliases>
 
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
                <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
                <property name="username" value="---" />
                <property name="password" value="---" />
            </dataSource>
        </environment>
    </environments>
    
    <mappers>
        <mapper resource="com/koreait/app/user/sql/user.xml"/>
    </mappers>
</configuration>
 cs

 

 

point1) 각 클래스들의 역할

 

Controller

  • UserFrontController.java: 공통로직처리으로 submit을 누르면 가장 먼저 오는 페이지
  • Action.java: UserJoinAction을 위한 interface
  • UserJoinAction.java: 실제 기능을 구현해줄 java 파일
  • ActionForward.java: forward,redirect 방식인지를 판단해줄 파일

 

Model

  • UserDTO.java: javaBean같은 역할
  • UserDAO.java:
  • SqlMapConfig.java: Mybatis첫 시작때만 실행되는 클래스
  • config.xml; Mybatis DB구성요소
  • index.jsp: 회원가입과 로그인이 있는 페이지
  • joinview.jsp: 회원가입 페이지

 

point2) 이동 순서 

 

 

 

회원가입 버튼을 누르면 옆의 href를 통해서 joinview.jsp파일로 넘어간다.

joinview.jsp파일의 회원가입 작성칸은 form으로 감싸져있으며 submit을 누르는 순간 UserJoin.us를 따라 가게된다.

action의 끝은 .us로 끝나며 UserFrontController에서 모이도록 설정해주었다. 
그리고 joinview.jsp의 url joinview.us를 찾아서 해당 if문을 타게되며 UserJoinAciton을 만나게된다.

UserjoinAction의 implement는 Action으로 모든 구성을 구속받아 Action과 메서드를 동일하게 작성한다.

그래서 UserJoinAction은 execute라는 메서드명에 req와 resp 파라미터가 강제가 된 것이다.

그리고 리턴타입은 Actionforward로서 역시 ActionForward의 객체를 생성하여 연결해주고 return forword;를 통해 오류를 잡아준다.

이 과정을 모두 거친 UserJoinAction는 userDao와 userdao 객체를 생성하여 해당 파일을 연결시켜준다.
req를 통해 받은 값을 user를 통해 userDTO에 넣는다.

그리고 udao의 join을 통해 꺼내는 작업을하는데

이 때 udao의 join으로 이동하면 
userDTO user를 통해 UserDTO의 모양으로 파라미터를 받게 되는 것이고 sqlsession.insert를 통해 값을 데이터베이스에 집어넣어준다.

그럼 데이터베이스는 이 때 어떻게 움직일까

우선 SqlMapConfig를 먼저 들어간다. 이 안에는 데이터베이스를 가지고 올 리소스가 들어있는데 이는 config.xml을 통해 가져온다.config.xml은 해당 데이터베이스의 주소를 쭉 읽어내려가 데이터베이스 찾고 데이터베이스를 실행할 구문(insert,select등)을 가져오는데 이걸 user.xml에서 가져온다.

그리고 여기서 sql에 insert하고 select하고 해당 결과값을 처음의 factory로 넘겨받는 것이다.

그럼 다시 UserDao로 돌아오고 해당 return값은UserjoinAction에서 처리받아 forward로 리턴시킨다. 그러면 다시 UserFrontController의 일괄저리로 받아 최종적으로 redirect인지 forward인지 판단하여 다시 넘겨주는 것이다.

 

 

point3) 필터만들기

 

UserCharacterEncodingFilter를 보면  *.us로 .us만의 필터를 만들어준다 .만약 *.do가 있다면 해당 필터를 하나 더 만들어주어야한다.

필터가 없다면 UserJoinAction에서 인코딩을 하나하나 맞춰야하지만 필터를 걸면 일괄적으로 모두 적용되기땜누에 필터는 패키지를 하나 파서 정리해두는 것이 좋다.

https://songg5453.tistory.com/144

 

point4) Config.java의 Aliases & 데이터베이스 순서

 

 

Config.java에서 Aliases를 설정하여 DTO와 연결해준다.

즉, 데이터베이스는 SqlMapConfig-> Config.xml -> User.xml으로 이동했다가 다시 역순으로 데이터를 가지고와서 SqlMapConfig로 데이터를 들고와 factory로 리턴시켜주는 것이다.

 

데이터베이스 구성 참고 

https://songg5453.tistory.com/158

 

 

point5) Redirect/Forward 결정 이동 순서

 

 Redirect로 보낼것인지 Forward방식으로 보낼것인지 처리해주는 코드들이다.

 

우선 UserJoinAction에서 udao.join(user)를 들고 setRedirect인지 아닌지를 정해준다.

UserJoinAction의 파란박스는 Redirect형식인지 아닌지를 true, false로 정해주는 부분이다.

forward는 ActionForward의 객체로서 이를 통해 Redirect형식인지 아닌지를 true, false로 정해준다.

boolean isRedirect로 변수를 선언해주었으니 true면 Redirect, false면 forward이다.

주황색박스는 path를 설정해주는 곳이다.

forward형식이면 경로만 입력해주면 되지만 Redirect형식이면 req.getContextPath( )를 꼭 입력해준다. 

리다이렉트만의 데이터 이동 방식때문에 클라이언트로 데이터가 다시 이동하면서 request가 forward에 비해 중복으로 일어나게 되기 때문이다. 

 

UserJoinAction에서 forward를 리턴함으로서 그 값이 UserFrontController로 넘어왔다. 

그럼 여기서 최종적으로 Redirect인지 Forward인지 일괄저리하게되고 각각의 방법에 맞는 방법으로 페이지를 출력하게된다.

 

forward와 Redirect의 차이 참고

https://songg5453.tistory.com/146

저작자표시 (새창열림)