spring boot 개발 웹 api 응용 실천 (2) 조작 데이터베이스

더 읽 기
이전 글 (spring boot 개발 웹 api 응용 실천 (1) 입문) 에 서 는 spring boot 를 이용 하여 웹 응용 을 만 드 는 방법 을 간단하게 소개 하 였 으 나 데이터 베이스 작업 층 이 없 으 며, 이 편 은 데이터 베이스 작업 층 을 어떻게 인용 하 는 지 소개 합 니 다.
 
 단계: 1. 사전 준비 - 데이터베이스 만 들 기
            2. pom. xml 파일 을 편집 하여 spring - boot - starter - jdbc 의존 도 를 추가 합 니 다.
            3. application. properties 파일 설정 데이터 원본 편집
            4. DAO 인터페이스 코드 작성
            5. 서비스 인터페이스 코드 작성
            6. 컨트롤 러 층 로그 인 컨트롤 러 수정
 
 
사전 준비
      my sql 에 test 데 이 터 를 새로 만 들 고 tbl 을 만 듭 니 다.사용자 테이블

CREATE TABLE `tbl_user` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `account` varchar(32) NOT NULL COMMENT '    account name',
  `password` varchar(128) NOT NULL COMMENT '   password',
  `name` varchar(256) NOT NULL COMMENT '  ',
  `email` varchar(256) NOT NULL COMMENT 'email',
  `last_login_date` datetime DEFAULT NULL COMMENT '      ',
  `incorrect_login_attempt` int(10) NOT NULL DEFAULT '0' COMMENT '      ，         0',
  `is_locked_out` int(1) NOT NULL DEFAULT '0' COMMENT '      '
   PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

 
 
2. pom. xml 파일 편집:
   jdbc 관련 의존 도 를 증가 시 킵 니 다:
 

    
    
        org.springframework.boot
        spring-boot-starter-jdbc
        compile
    
    
        mysql
        mysql-connector-java
        runtime
    

 
 
3. 데이터 원본 설정:
    프로젝트 의 src \ main \ resources 디 렉 터 리 아래 application. properties 파일 을 만 듭 니 다. 이것 은 spring boot 의 기본 설정 파일 입 니 다. 데이터베이스 설정 과 같은 맞 춤 형 설정 을 할 수 있 습 니 다.
 

spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-idle=20
spring.datasource.min-idle=5
spring.datasource.initial-size=5
spring.datasource.max-wait=10000
spring.datasource.validation-query=SELECT 1
spring.datasource.test-on-borrow=false
spring.datasource.test-while-idle=true
spring.datasource.time-between-eviction-runs-millis=18800
spring.datasource.jdbc-interceptors=ConnectionState;SlowQueryReport(threshold=3)

   
   이전 입문 에서 마지막 으로 기본 접근 포트 를 수정 하 는 것 을 언급 했 습 니 다. 즉, application. properties 파일 에 server. port 를 설정 하면 됩 니 다.

server.port=18081

    tomcat 관련 설정 도 설정 할 수 있 습 니 다. 예 를 들 어:

server.tomcat.minSpareThreads=5
server.tomcat.maxThreads=150
server.tomcat.uriEncoding=utf-8

 
 
    이것 은 모두 spring boot 가 기본적으로 지원 하 는 설정 항목 입 니 다. 더 많은 설정 항목 은 spring boot 의 공식 문 서 를 참고 하 십시오.
  
4. dao 층 작성
       JdbcBaseDAO.java

package com.zweichxu.springboot.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

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

import com.google.common.collect.Lists;
import com.zweichxu.platform.entity.SqlParams;

public class JdbcBaseDAO{
    public static final int MAX_IN_SIZE = 1000;
    
    @Autowired
    protected JdbcTemplate jdbcTemplate;

    //         
    private  void removeDupData(List inList){
        int size = inList.size();
        List retList = new ArrayList(size);
        inList.forEach(m -> {
            if(!retList.contains(m)){
                retList.add(m);
            }
        });

        inList.clear();
        inList.addAll(retList);
    }

    // in    
    protected  List> divideArrayForSqlIn(List inList){
        removeDupData(inList);
        return Lists.partition(inList, MAX_IN_SIZE);
    }

    protected  String whereIn(List c, SqlParams params){
        int size = c.size();
        if(size <= 0){
            throw new RuntimeException("      ，     where in   ");
        }
        StringBuilder sb = new StringBuilder();
        c.forEach(m -> {
            sb.append("?,");
            params.addParam(m);
        });

        return sb.substring(0, sb.length() - 1);
    }

    protected String whereIn(Object[] c, SqlParams params){
        int size = c.length;
        if(size <= 0){
            throw new RuntimeException("      ，     where in   ");
        }
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < size; i++){
            sb.append("?,");
            params.addParam(c[i]);
        }

        return sb.substring(0, sb.length() - 1);
    }
    
    protected  String multiValue(List c, SqlParams params){
        int size = c.size();
        if(size <= 0){
            throw new RuntimeException("      ，     where in   ");
        }

        StringBuilder sb = new StringBuilder();
        if (size > 1){
            sb.append(" in (").append(whereIn(c, params)).append(")");
        }else{
            sb.append("=?");
            params.addParam(c.get(0));
        }

        return sb.toString();
    }
}

 
 
        UserDAO.java

package com.zweichxu.springboot.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import com.zweichxu.springboot.model.User;

/**
 * @author zweichxu
 * @date 2017 3 30  15:40:56
 * @version 1.0
 */
@Repository(UserDAO.ANNOTATION_NAME)
public class UserDAO extends JdbcBaseDAO {
    public final static String ANNOTATION_NAME = "userDAO";

    public User findUserByAccount(String acct){
        String sql = "select `id`, `account`, `password`, `name`, `email` from tbl_user where `account`=?";
        
        return jdbcTemplate.query(sql, new ResultSetExtractor(){
            @Override
            public User extractData(ResultSet rs) throws SQLException, DataAccessException{
                if (rs.next()){ 
                    return parseUser(rs);
                }
                
                return null;
            }
        }, acct);
    }
    
    public User findUserById(int id){
        String sql = "select `id`, `account`, `password`, `name`, `email` from tbl_user where `id`=?";
        
        return jdbcTemplate.query(sql, new ResultSetExtractor(){
            @Override
            public User extractData(ResultSet rs) throws SQLException, DataAccessException{
                if (rs.next()){ 
                    return parseUser(rs);
                }
                
                return null;
            }
        }, id);
    }
     
    public void updateUserLoginInfo(int id, int isLockedOut, int incorrectLoginAttempt){
        String sql = "update tbl_user set is_locked_out =?, incorrect_login_attempt =?," 
                   + " last_login_date =now() where `id`=?";
        
        jdbcTemplate.update(sql, isLockedOut, incorrectLoginAttempt, id);
    }
    private User parseUser(ResultSet rs) throws SQLException{
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setAccount(rs.getString("account"));
        user.setPassword(rs.getString("password"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email")); 
        user.setIsLockedOut(covert(rs.getInt("is_locked_out")));
        user.setIncorrectLoginAttempt(rs.getInt("incorrect_login_attempt"));
        user.setLastLoginDate(rs.getTimestamp("last_login_date"));
        return user;
    } 

    private boolean covert(Integer value){
        return value==null?false:(value==1?true:false);
    }
}

 
5. 서비스 계층 코드 작성
 
    UserService.java

package com.zweichxu.springboot.service;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.Resource;
import org.springframework.stereotype.Service;

import com.zweichxu.platform.entity.BaseResp;
import com.zweichxu.platform.entity.ServiceException;
import com.zweichxu.springboot.dao.UserDAO;
import com.zweichxu.springboot.model.User;

@Service(UserService.ANNOTATION_NAME)
public class UserService {
    public final static String ANNOTATION_NAME = "userService";
    
    @Resource(name=UserDAO.ANNOTATION_NAME)
    private UserDAO userDao;
    
    public User doLogin(String acct, String pwd){
        User user = userDao.findUserByAccount(acct);
        
        if (user == null || !pwd.equals(user.getPassword())){
            int maxErr = 5;
            int errCnt = 0;
            if (user != null){
                errCnt = user.getIncorrectLoginAttempt() + 1;
                userDao.updateUserLoginInfo(user.getId(), errCnt>=maxErr?1:0, errCnt);
            }
            
            throw new ServiceException(BaseResp.DATA_NOT_EXIST, errCnt>=maxErr?"        ，      ，      ":"        ");
        }
        
        if (user.getIsLockedOut()){
            throw new ServiceException(BaseResp.DATA_NOT_EXIST, "        ，      ");
        }
        
        userDao.updateUserLoginInfo(user.getId(), 0, 0);
        
        return user;
    }
}

 
6. LoginController 수정 (spring boot 개발 웹 api 응용 실천 참조 (1) 입문)

   @Resource(name=UserService.ANNOTATION_NAME)
   private UserService userService;   //  Service 
    
    @RequestMapping(value="login")
    public BaseResp doLogin(@RequestParam("acct") String userName, @RequestParam("pwd") String password){
        if (Util.isEmpty(userName) || Util.isEmpty(password)){
            return BaseResp.fail(BaseResp.RET_CODE_PROTOCOL_ERROR, "           ");
        }
       
        //do something
        try{
            User user = userService.doLogin(userName, password); 
            return BaseResp.success().setRetMsg("    ").addProperty("loginUser", user);
        }catch(ServiceException e){
            return BaseResp.fail(e.getRetCode(), e.getMessage());
        } 
    }

 
   데이터 베 이 스 를 도입 하려 면 spring - boot - starter - jdbc 의존 도 를 추가 하 는 것 이 관건 입 니 다. 그리고 spring boot 는 설 정 된 데이터 베이스 정보 와 연결 풀 파라미터 에 따라 tomcat - jdbc 연결 풀 을 자동 으로 설치 하고 데이터 원본 과 jdbc Template 를 자동 으로 초기 화 합 니 다.
 그리고 브 라 우 저 주소 표시 줄 에 접근:http://localhost:8080/login?acct=zweichxu&pwd=123, 브 라 우 저 페이지 반환 값 을 볼 수 있 습 니 다.
 
다음 편 은 tomcat - jdbc 연결 풀 을 proxool 연결 풀 로 바 꾸 는 방법 을 소개 합 니 다. (개인 적 으로 proxool 연결 풀 을 좋아 합 니 다 ^ ^)