20211222 관리자 로그인, 회원정보 불러오기

·관리자 로그인

-어제 adminDao인터페이스까지 작성이 완료되었고, 서비스부분을 구현하였다.

@Service("adminService")
public class AdminService {
	
	private static Logger logger = LoggerFactory.getLogger(AdminService.class);
	
	@Autowired
	private AdminDao adminDao;
	
	public Admin adminSelect(String admId) 
	{
		Admin admin = null;
		
		try 
		{
			admin = adminDao.adminSelect(admId);
		}
		catch(Exception e) 
		{
			logger.error("[AdminService] adminSelect Exception", e);
		}
		
		return admin;
	}
}

-딱히 특이할 것이 없는 서비스쪽 구현이라서 따로 설명할 것이 없다. 실제로 교수님이 수업시간에 진행하실 때 이미 먼저 작성까지 했던 수준으로 익숙하고 잘 연습되어있었던 것 같다.
-로그인에 대한 컨트롤러를 작성한다.

//로그인
	@RequestMapping(value="/loginProc", method=RequestMethod.POST)
	@ResponseBody
	public Response<Object> loginProc(HttpServletRequest request, HttpServletResponse response)
	{
		Response<Object> ajaxResponse = new Response<Object>();
		
		String admId = HttpUtil.get(request, "admId");
		String admPwd = HttpUtil.get(request, "admPwd");
		
		if(!StringUtil.isEmpty(admId) && !StringUtil.isEmpty(admPwd)) 
		{
			//값이 넘어옴
			Admin admin = adminService.adminSelect(admId);
			
			if(admin != null) 
			{
				if(StringUtil.equals(admPwd, admin.getAdmPwd())) 
				{
					if(StringUtil.equals(admin.getStatus(), "Y")) 
					{
						//상태확인
						ajaxResponse.setResponse(0, "Success");
					}
					else 
					{
						//정지된 사용자, 없다고 표시
						ajaxResponse.setResponse(401, "Not Found");
					}
				}
				else 
				{
					ajaxResponse.setResponse(-1, "Wrong Password");
				}
			}
			else 
			{
				ajaxResponse.setResponse(404, "Not Found");
			}
		}
		else 
		{
			ajaxResponse.setResponse(400, "Bad Request");
			//코드, 메세지, 데이터가 있음.
		}
		
		return ajaxResponse;
	}

-로그인에 대한 처리는, 비동기통신으로 ajax통신을 하기 때문에 @ResponseBody 어노테이션을 꼭 써준다. 그 외에는 인덱스쪽 ajax 통신 코드에 정의된 메세지에 맞춰 해당 상황에 맞는 코드값을 응답으로 보낸다.

보면, 코드가 0번이면 성공이고, /user/list로 url이 지정되어 있다.

if(res.code == 0)
        	{
        		// 성공
        		alert("로그인에 성공했습니다.");
        		location.href = "/user/list";
        	}

이제 해당 /user/list를 찾아서 .jsp를 리턴해줄 컨트롤러 부분을 정의한다. 단, 유저 정보들을 보여줄 것이기 때문에 유저 정보들을 가져올 쿼리문, 또 해당 유저 테이블과 매핑시켜줄 .java이 먼저 필요하다.

public class User implements Serializable
{

	private static final long serialVersionUID = 1L;
	
	private String userId;    // 사용자 아이디
	private String userPwd;   // 비밀번호
	private String userName;  // 사용자 명
	private String userEmail; // 사용자 이메일 
	private String status;    // 상태 ("Y":사용, "N":정지)
	private String regDate;   // 등록일
	
	private int startRow;		//시작row
	private int endRow;			//종료row
	
	public User() 
	{
		userId = "";
		userPwd = "";
		userName = "";
		userEmail = "";
		status = "";
		regDate = "";
		startRow = 0;
		endRow = 0;
	}

	public String getUserId() {
		return userId;
	}

	public void setUserId(String userId) {
		this.userId = userId;
	}

	public String getUserPwd() {
		return userPwd;
	}

	public void setUserPwd(String userPwd) {
		this.userPwd = userPwd;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getUserEmail() {
		return userEmail;
	}

	public void setUserEmail(String userEmail) {
		this.userEmail = userEmail;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getRegDate() {
		return regDate;
	}

	public void setRegDate(String regDate) {
		this.regDate = regDate;
	}

	public int getStartRow() {
		return startRow;
	}

	public void setStartRow(int startRow) {
		this.startRow = startRow;
	}

	public int getEndRow() {
		return endRow;
	}

	public void setEndRow(int endRow) {
		this.endRow = endRow;
	}
}

User.java이다. 그 다음은 쿼리문을 작성한다.

--유저 아이디 가져오기.
SELECT
    USER_ID,
    USER_PWD,
    USER_NAME,
    USER_EMAIL,
    STATUS,
    REG_DATE
FROM    (SELECT 
            ROWNUM AS RNUM,
            USER_ID,
            USER_PWD,
            USER_NAME,
            USER_EMAIL,
            STATUS,
            REG_DATE
          FROM  (SELECT
                        USER_ID,
                        NVL(USER_PWD, '') AS USER_PWD,
                        NVL(USER_NAME, '') AS USER_NAME,
                        NVL(USER_EMAIL, '') AS USER_EMAIL,
                        NVL(STATUS, 'N') AS STATUS,
                        NVL(TO_CHAR(REG_DATE, 'YYYY.MM.DD HH24:MI:SS'), '') AS REG_DATE
                    FROM
                        TBL_USER
                    WHERE
                        1=1
                    AND
                        USER_ID LIKE '%te%'
                    AND
                        USER_NAME LIKE '%te%'
                    AND
                        STATUS = 'Y'
                    ORDER BY
                        REG_DATE DESC))
WHERE RNUM >=1
  AND RNUM <=5
;
--WHERE문이 있을수도 있고 없을 수도 있으니까, 1=1로 묶어야 됨. 꼭 그렇게 안해도 되지만, 그럴려면 조건에 뭐가 있는지 없는지 여부를 확인해서 있으면 WHERE을 붙이고 AND를 붙이고
--처리를 해줘야 함.

--유저 아이디 존재하는지 여부 확인
SELECT
    COUNT(USER_ID) AS CNT
FROM 
    TBL_USER 
WHERE
    1=1
AND
    USER_ID LIKE '%te%'
AND
    USER_NAME LIKE '%te%'
AND
    STATUS = 'Y'
;

이제 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.icia.manager.dao.UserDao">

<resultMap type="com.icia.manager.model.User" id="userResultMap">
	<id column="USER_ID" property="userId" />
	<result column="USER_PWD" property="userPwd" />
	<result column="USER_NAME" property="userName" />
	<result column="USER_EMAIL" property="userEmail" />
	<result column="STATUS" property="status" />
	<result column="REG_DATE" property="regDate" />
</resultMap>

<select id="userListCount" parameterType="com.icia.manager.model.User" resultType="int">
SELECT
    COUNT(USER_ID) AS CNT
FROM 
	TBL_USER 
WHERE
    1=1
<if test='userId != null and userId != ""'>
AND
    USER_ID LIKE '%'|| #{userId} ||'%'
</if>
<if test='userName != null and userName != ""'>    
AND
    USER_NAME LIKE '%'|| #{userName} ||'%'
</if>
<if test='status != null and status != ""'>
AND
    STATUS = #{status}
</if>
    
</select>


<!-- 유저 정보 조회 시작 -->
<select id="userList" parameterType="com.icia.manager.model.User" resultMap="userResultMap">
SELECT
    USER_ID,
    USER_PWD,
    USER_NAME,
    USER_EMAIL,
    STATUS,
    REG_DATE
FROM    (SELECT 
            ROWNUM AS RNUM,
            USER_ID,
            USER_PWD,
            USER_NAME,
            USER_EMAIL,
            STATUS,
            REG_DATE
          FROM  (SELECT
                        USER_ID,
                        NVL(USER_PWD, '') AS USER_PWD,
                        NVL(USER_NAME, '') AS USER_NAME,
                        NVL(USER_EMAIL, '') AS USER_EMAIL,
                        NVL(STATUS, 'N') AS STATUS,
                        NVL(TO_CHAR(REG_DATE, 'YYYY.MM.DD HH24:MI:SS'), '') AS REG_DATE
                    FROM
                        TBL_USER
                    WHERE
                        1=1
			<if test='userId != null and userId !=""'>			
                    AND
                        USER_ID LIKE '%'|| #{userId} || '%'
			</if>
			<if test='userName != null and userName != ""'>
                    AND
                        USER_NAME LIKE '%'|| #{userName} ||'%'
            </if>
            <if test='status != null and status !=""'>   
                    AND
                        STATUS = #{status}
             </if>       
                    ORDER BY
                        REG_DATE DESC))
                        
WHERE RNUM  <![CDATA[>=]]> #{startRow}
  AND RNUM <![CDATA[<=]]> #{endRow}
</select>
<!-- 유저 정보 조회 종료 -->

</mapper>

-이제 UserDao인터페이스에 추상메소드를 정의해준다.

@Repository("userDao")
public interface UserDao {
	
	//사용자 수 조회
	public int userListCount(User user);
	
	//사용자 리스트 조회
	public List<User> userList(User user);
}

-유저서비스를 만들어서 해당 메소드를 불러와 처리하는 코드를 작성한다.

@Service("userService")
public class UserService {
	
	//로거 정의
	private static Logger logger = LoggerFactory.getLogger(UserService.class);
	
	@Autowired
	private UserDao userDao;
	
	
	//사용자 수 조회
	public int userListCount(User user) 
	{
		int count = 0;
		
		try 
		{
			count = userDao.userListCount(user);
		}
		catch(Exception e) 
		{
			logger.error("[UserService] userListCount Exception", e);
		}
		
		return count;
	}
	
	//사용자 리스트
	public List<User> userList(User user)
	{
		List<User> list = null;
		
		try 
		{
			list = userDao.userList(user);
		}
		catch(Exception e) 
		{
			logger.error("[UserService] userList Exception", e);
		}
		
		return list;
	}
}

-불러올 유저 정보 하나당 하나의 유저 객체이기 때문에 List로 리턴받아야 한다.

@Controller("userController")
public class UserController 
{	
	@Autowired
	private UserService userService;
	
	private static final int LIST_COUNT = 10;
	private static final int PAGE_COUNT = 10;
	
	
	//회원리스트
	@RequestMapping(value="/user/list")
	public String list(Model model, HttpServletRequest request, HttpServletResponse response) 
	{
		String status = HttpUtil.get(request, "status");
		//검색타입(1:회원아이디, 2:회원이름)
		String searchType = HttpUtil.get(request, "searchType");
		String searchValue = HttpUtil.get(request, "searchValue");
		
		int curPage = HttpUtil.get(request, "curPage", 1);
		
		//총 게시물 수
		int totalCount = 0;
		 
		//페이징 객체
		Paging paging = null;
		
		List<User> list = null;
		
		User param = new User();
		
		param.setStatus(status);
		
		if(!StringUtil.isEmpty(searchType) && !StringUtil.isEmpty(searchValue)) 
		{
			if(StringUtil.equals(searchType, "1")) 
			{
				//서치타입이 1인 경우, 즉 유저 아이디를 검색한 경우
				param.setUserId(searchValue);
			}
			else if(StringUtil.equals(searchType, "2")) 
			{
				param.setUserName(searchValue);
			}
			else 
			{
				searchType = "";
				searchValue = "";
			}
		}
		else 
		{
			//값이 비어있음
			searchType = "";
			searchValue = "";
		}
		
		totalCount = userService.userListCount(param);
		
		if(totalCount > 0) 
		{
			//값이 존재함.
			//페이징 처리
			paging = new Paging("/user/list", totalCount, LIST_COUNT, PAGE_COUNT, curPage, "curPage");
			paging.addParam("status", status);
			paging.addParam("searchType", searchType);
			paging.addParam("searchValue", searchValue);
			paging.addParam("curPage", curPage);
			
			param.setStartRow(paging.getStartRow());
			param.setEndRow(paging.getEndRow());
			
			list = userService.userList(param);
		}
		
		model.addAttribute("list", list);
		model.addAttribute("searchType", searchType);
		model.addAttribute("searchValue", searchValue);
		model.addAttribute("status", status);
		model.addAttribute("curPage", curPage);
		model.addAttribute("paging", paging);
		
		return "/user/list";
	}
}

-유저 컨트롤러를 작성해준다. 이 부분에서 왜 모델맵이 아니라 모델을 썼는지 굉장히 궁금해서 교수님께 여쭤보려다가 구글링을 해봤더니, 모델은 인터페이스고, 모델맵은 구현체인데, 스프링 프레임워크에서는 사실상 차이가 없다고 한다.

이제 .jsp에서 회원 정보를 불러와야 하기 때문에 아래의 부분에 모델로 받은 값들을 사용해서 넣어준다.

            <select id="status" name="status" style="font-size: 1rem; width: 6rem; height: 3rem;">
               <option value="">상태</option>
               <option value="Y" <c:if test="${status == 'Y'}">selected</c:if> >정상</option>
               <option value="N" <c:if test="${status == 'N'}">selected</c:if> >정지</option>
            </select>
            <select id="searchType" name="searchType" style="font-size: 1rem; width: 8rem; height: 3rem; margin-left:.5rem; ">
               <option value="">검색타입</option>
               <option value="1" <c:if test="${searchType eq '1'}">selected</c:if> >회원아이디</option>
               <option value="2" <c:if test="${searchType eq '2'}">selected</c:if> >회원명</option>
            </select>

검색한 옵션에 따라서 검색타입과 값이 들어가게 조건문을 준다.

            <c:if test="${!empty list}">
            	<c:forEach items="${list}" var="user" varStatus="status">
            <tr>
                <th scope="row" class="table-thead-sub" style="border: 1px solid #c4c2c2;"><a href="/user/update?userId=${user.userId}" name="userUpdate">${user.userId}</a></th>
                <td>${user.userName}</td>
                <td>${user.userEmail}</td>
                <td><c:if test="${user.status eq 'Y'}">정상</c:if> <c:if test="${user.status eq 'N'}">정지</c:if></td>
                <td>${user.regDate}</td>
            </tr>
            	</c:forEach>
            
            </c:if>
            <c:if test="${empty list}">
            	<tr>
            		<td colspan="5">검색된 정보가 없습니다.</td>
            	</tr>
            </c:if>

-list객체로 받은 값들을 반복문을 통해서 하나씩 출력해주는 로직을 구현한다. 사실 아직 forEach에 대해 편하지 않다. 그냥 반복문을 쓰는 것이 뭔가 더 편할 것 같은데, 그래도 방법을 익혀야겠다 싶어서 굉장히 많이 반복해서 써봤다.

·데이터베이스 금요일까지

-ERD를 나름 팀 회의를 통해 구성했는데, 교수님과의 상담 과정에서 전부 다 깨져버렸다. 10개의 테이블을 작성했는데, 순식간에 18개가 되어버렸다. 그런데도 아직 전부 정해진 것이 없는 것 같다...이번주까지 테이블이 전부 나와서 erd를 그릴 수 있을지 의문이다.