DESC

내가 보려고 쓰는 블로그

«   2025/02   »
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
Today
-
Yesterday
-
Total
-
  • Spring DAO DTO 사용하기
    JAVA 2020. 5. 12. 14:40
    반응형

    Spring 에서 DB 쿼리를 실행하기 위한 데이터를 담을 때 DAO(Data Access Object) 로 데이터를 담는다.
    실제 쿼리 조회 시 파라미터나 조회한 데이터를 담을 때에는 DTO(Data Transfer Object) 클래스를 이용한다.
    아래는 기본적인 데이터 조회를 위한 클래스들의 예제이다.

    - DAO COMMON
    보통 공통의 추상 DAO 클래스를 만든 뒤 이를 구체화 하여 사용하는 구조를 많이 사용한다.

    package com.hailey.commoninfra.dao;
    
    import java.util.List;
    import javax.annotation.Resource;
    import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
    import com.ibatis.sqlmap.client.SqlMapClient;
    
    /**
     * AbstractDAO
     */
    public abstract class AbstractDAO  extends SqlMapClientDaoSupport {
    
      /**
       * AbstractDAO 는 base class 로만 사용되며 해당 인스턴스를 직접 생성할 수 없도록 protected constructor 로 선언
       */
      protected AbstractDAO() {
        // PMD abstract Rule 
        // - If the class is intended to be used as a base class only (not to be instantiated directly)
        // a protected constructor can be provided prevent direct instantiation
      }
    
      /**
       * Annotation 형식으로 sqlMapClient 를 받아와 이를 super(SqlMapClientDaoSupport) 의 setSqlMapClient 메서드를 호출하여 설정해 준다.
       * 
       * @param sqlMapClient - ibatis 의 SQL Map 과의 상호작용을 위한 기본 클래스로 
       *         mapped statements(select, insert, update, delete 등)의 실행을 지원함.
       */
      @Resource(name = "com.hailey.sqlMapClient")
      public void setSuperSqlMapClient(SqlMapClient sqlMapClient) {
        super.setSqlMapClient(sqlMapClient);
      }
    
      /**
       * 입력 처리 SQL mapping 을 실행한다.
       * 
       * @param queryId - 입력 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 입력 처리 SQL mapping 입력 데이터를 세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @return 입력 시 selectKey 를 사용하여 key 를 딴 경우 해당 key
       */
      public Object insert(String queryId, Object parameterObject) {
        return getSqlMapClientTemplate().insert(queryId, parameterObject);
      }
    
      /**
       * 수정 처리 SQL mapping 을 실행한다.
       * 
       * @param queryId - 수정 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 수정 처리 SQL mapping 입력 데이터(key 조건 및 변경 데이터)를 세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @return DBMS가 지원하는 경우 update 적용 결과 count
       */
      public int update(String queryId, Object parameterObject) {
        return getSqlMapClientTemplate().update(queryId, parameterObject);
      }
    
      /**
       * 삭제 처리 SQL mapping 을 실행한다.
       * 
       * @param queryId - 삭제 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 삭제 처리 SQL mapping 입력 데이터(일반적으로 key 조건)를 세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @return DBMS가 지원하는 경우 delete 적용 결과 count
       */
      public int delete(String queryId, Object parameterObject) {
        return getSqlMapClientTemplate().delete(queryId, parameterObject);
      }
    
      /**
       * pk 를 조건으로 한 단건조회 처리 SQL mapping 을 실행한다.
       * 
       * @param queryId - 단건 조회 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 단건 조회 처리 SQL mapping 입력 데이터(key)를 세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @return 결과 객체 - SQL mapping 파일에서 지정한 resultClass/resultMap 에 의한 단일 결과 객체(보통 DTO 또는 Map)
       */
      public Object selectByPk(String queryId, Object parameterObject) {
        return getSqlMapClientTemplate().queryForObject(queryId, parameterObject);
      }
      
      
      /**
       * insert 한 후 키 값을 리턴 받는다.
       * 
       * @param queryId - 단건 조회 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 단건 조회 처리 SQL mapping 입력 데이터(key)를 세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @return 결과 객체 - String
       */
      public String insertWithIdStr(String statementName, Object parameterObject) {
          String insertId = null;
          insertId = (String) getSqlMapClientTemplate().insert(statementName, parameterObject);
          return insertId;
        }
    
      /**
       * 리스트 조회 처리 SQL mapping 을 실행한다.
       * 
       * @param queryId - 리스트 조회 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 리스트 조회 처리 SQL mapping 입력 데이터(조회 조건)를 세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @return 결과 List 객체 - SQL mapping 파일에서 지정한 resultClass/resultMap 에 의한 결과 객체(보통 DTO 또는 Map)의 List
       */
      @SuppressWarnings("rawtypes")
      public List list(String queryId, Object parameterObject) {
        return getSqlMapClientTemplate().queryForList(queryId, parameterObject);
      }
    
      /**
       * 부분 범위 리스트 조회 처리 SQL mapping 을 실행한다. 
       * (부분 범위 - pageIndex 와 pageSize 기반으로 현재 부분 범위 조회를 위한 skipResults, maxResults 를 계산하여 ibatis 호출)
       * 
       * @param queryId - 리스트 조회 처리 SQL mapping 쿼리 ID
       * @param parameterObject - 리스트 조회 처리 SQL mapping 입력 데이터(조회 조건)를  세팅한 파라메터 객체(보통 DTO 또는 Map)
       * @param pageIndex - 현재 페이지 번호
       * @param pageSize - 한 페이지 조회 수(pageSize)
       * @return 부분 범위 결과 List 객체 - SQL mapping 파일에서 지정한 resultClass/resultMap 에 의한 부분 범위 결과 객체(보통 DTO 또는 Map) List
       */
      @SuppressWarnings("rawtypes")
      public List listWithPaging(String queryId, Object parameterObject, int pageIndex, int pageSize) {
        int skipResults = pageIndex * pageSize;
        ///int maxResults = (pageIndex * pageSize) + pageSize;
        int maxResults = pageSize;
    
        return getSqlMapClientTemplate().queryForList(queryId, parameterObject, skipResults, maxResults);
      }
    
    }

     

    - DTO
    DTO는 조회할 쿼리와 1:1로 생성하며, 사용하는 컬럼들의 getter, setter 만 존재하는것이 일반적이다.

    package com.hailey.common.user.dto.request;
    
    public class UserDTO {
    
      private String loginId;
      private String password;
      private String userType;
      private String userName;
      private String phone;
      
      public String getLoginId() {
        return loginId;
      }
      public void setLoginId(String loginId) {
        this.loginId = loginId;
      }
      public String getPassword() {
        return password;
      }
      public void setPassword(String password) {
        this.password = password;
      }
      public String getUserType() {
        return userType;
      }
      public void setUserType(String userType) {
        this.userType = userType; 
      }
      public String getUserName() {
        return userName;
      }
      public void setUserName(String userName) {
        this.userName = userName;
      }
      public String getPhone() {
        return phone;
      }
      public void setPhone(String phone) {
        this.phone = phone;
      }
    
    }
    

     

    - DAO 인터페이스

    package com.soil.ebizportal.common.user.dao;
    
    import java.util.List;
    import com.hailey.common.user.dto.request.UserDTO;
    
    public interface UserDao {
    
      public UserDTO getUserDetail(UserDTO requestUserInfoDTO);
    
      public void updPwd(UserDTO requestChangePwdDTO);
    
      public void updUserInfo(UserDTO requestUserInfoDTO);
        
    }
    

     

    - DAO Class

    package com.hailey.common.user.dao.impl;
    
    import java.util.List;
    
    import org.springframework.stereotype.Repository;
    
    import com.hailey.commoninfra.dao.AbstractDAO;
    import com.hailey.common.user.dao.UserDao;
    import com.hailey.common.user.dto.request.UserDTO;
    
    @Repository
    public class UserDaoImpl extends AbstractDAO implements UserDao {
    
      @Override
      @SuppressWarnings("unchecked")
      public List<UserDTO> getUserDetail(UserDTO requestLoginUserDTO) {
        return list("User.selectLoginUser", requestLoginUserDTO);
      }
    
      @Override
      public void updPwd(UserDTO requestChangePwdDTO) {
        // 현재 비밀번호 체크
        if( (Integer) this.selectByPk("User.checkUserPwd", requestChangePwdDTO) == 0 ){
          System.out.println("현재 비밀번호를 잘못입력 하셨습니다.") ;
        
        }
        else{
          if ( this.update("User.updPwd", requestChangePwdDTO) == 0 ){
            System.out.println("Password을 잘못입력 하셨습니다.") ;
          }
        }
      
      }
    
      @Override
      public void updUserInfo(UserDTO requestUserInfoDTO) {
        if ( this.update("User.updUserInfo", requestUserInfoDTO) == 0 ){
          System.out.println("회원 정보를 찾을 수 없습니다.") ;
        }    
      }
    
    }
    

     

    - SQL MAP

    <?xml version="1.0" encoding="UTF-8"?>
    
    <!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" "http://www.ibatis.com/dtd/sql-map-2.dtd">
    
    <sqlMap namespace="com.hailey.common.user.User">
      <typeAlias  alias="UserDTO" type="com.hailey.common.user.dto.request.UserDTO"/>
    
      <resultMap id="UserDTO" class="UserDTO">
        <result property="loginId"		column="USERID"		columnIndex="1"/>
        <result property="password"		column="USERPW"		columnIndex="2"/>
        <result property="userName"		column="NAME"		columnIndex="3"/>
        <result property="phone"		column="PHONE"		columnIndex="4"/>
        <result property="userType"		column="TYPE"		columnIndex="5"/>
      </resultMap>
      
      <!-- 사용자 정보 조회 -->
      <select id="User.selectLoginUser" parameterClass="UserDTO" resultMap="UserDTO" >
        SELECT   /* SQL-ID = User.selectLoginUser */
             A.USERID
             , A.USERPW
             , A.NAME
             , A.PHONE
             , A.TYPE
        FROM TB_MEMBER A
        WHERE A.LOGIN = #loginId#
        <isNotEmpty prepend="AND" property="password">
          A.USERPW = #password#
        </isNotEmpty>
    
      </select>
      
      
      <!-- 비밀번호 변경 -->
      <update id="User.updPwd"  parameterClass="UserDTO" >
        UPDATE /* SQL-ID:User.updPwd*/
            TB_MEMBER  A
        SET  
            A.USERPW  = #newPassword#,
            A.UPDATED = sysdate
            
        WHERE A.USERID = #loginId#  
         <isNotEmpty prepend="AND" property="password">
           A.USERPW = #password#
         </isNotEmpty>
       </update>   
       
       
      <!-- 정보 변경 -->
      <update id="User.updUserInfo"  parameterClass="UserDTO" >    
        UPDATE /* SQL-ID: User.updUserInfo */
            TB_MEMBER  A
        SET
        	A.UPDATED = sysdate 
         <isNotEmpty property="phoneNum">
          , A.PHONE = #phoneNum# 
         </isNotEmpty>
         <isNotEmpty property="userType">
          , A.TYPE = #userType# 
         </isNotEmpty>
        WHERE A.USERID = #loginId#
         <isNotEmpty prepend="AND" property="password">
          A.USERPW = #password#
         </isNotEmpty>
      </update>
      
    </sqlMap>

     

    이제 서비스 단에서 데이터 조회할 때 위 클래스들을 사용하면 된다.

     

    * 참고 : USER 테이블 정의

     

    ORACLE 기본 CRUD 구문

    자주사용하는데도 매번 스펠링이 틀릴까봐 걱정되는 CRUD 구문 정리 - C CREATE TABLE TB_MEMBER ( USERNO VARCHAR2(20) NOT NULL , USERID VARCHAR2(20) NOT NULL , USERPW VARCHAR2(200) NOT NULL , NAME VARCHA..

    hailey0.tistory.com

     

    반응형

    'JAVA' 카테고리의 다른 글

    이클립스 속도 개선 eclipse.ini / Preference  (0) 2021.01.08
    Spring 다국어 적용하기  (0) 2020.05.27
    Spring 커스텀 태그 활용  (0) 2020.05.12
    Spring 전체 URL 가져오기  (0) 2020.05.12

    댓글

Customed By Hailey Gong.