Spring Boot 에서 JDBC Templet 을 사용 하 는 방법 튜 토리 얼

25416 단어 springboot jdbc templet

머리말
Spring 의 JDBC Templet 은 Spring 이 JDBC 에 사용 하 는 기본 적 인 패키지 이다.그 는 주로 프로그래머 가 데이터베이스 연결 관 리 를 실현 하도록 도 왔 고,나머지 사용 방식 은 JDBC 를 직접 사용 하 는 것 과 크게 다 르 지 않다.
업무 수요
JDBC 의 사용 은 모두 가 비교적 익숙 해 졌 다.스프링 부츠 에서 Spring JDBC Templet 을 사용 하 는 절 차 를 보 여주 기 위해 간단 한 수 요 를 설계 합 니 다.사용자 대상 의 CURD 동작대상 은 두 개의 속성 이 있 고,하 나 는 id 이 며,하 나 는 이름 입 니 다.MySQL 에 저 장 된 authuser 표 안에.
새 항목 과 의존 도 증가
Intellij IDEA 에 빈 SpringBoot 프로젝트 를 새로 만 듭 니 다.구체 적 절차 참조
Intellij IDEA 에서 spring-boot 프로젝트 를 만 드 는 그림 강좌 。본 사례 의 수요 에 따라 우 리 는 다음 세 가지 의존 도 를 추가 해 야 한다.


<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>6.0.6</version>
</dependency>

Http Rest 서 비 스 를 발표 하기 위해 spring-boot-starter-web 의존 도 를 추가 합 니 다.여기 서 는 JDBC Tempet 방법 으로 데이터 베 이 스 를 방문 해 야 하기 때문에 spring-boot-starter-jdbc 의존 도 를 추가 하고 MySQL 데이터 베 이 스 를 방문 해 야 하기 때문에 MySQL 최신 버 전의 JDBC 드라이버 를 추 가 했 습 니 다.
데이터베이스 환경 준비
Linux 운영 체제 에 MySQL 5.7 이 설치 되 어 있다 고 가정 합 니 다.다음 작업 은 운영 체제 명령 줄 에서 루트 사용 자 를 통 해 MySQL 명령 줄 클 라 이언 트 에 로그 인하 여 실 행 됩 니 다.
창고 건설 표


create database springboot_jdbc;
create table auth_user (uuid bigint not null,name varchar(32), primary key (uuid)) default charset=utf8mb4;

사용자 권한 설정


grant all privileges on springboot_jdbc.* to 'springboot'@'%' identified by 'springboot';
flush privileges;

데이터 원본 설정(연결 풀)
SpringBoot 의 데이터 원본 은 자동 으로 설 정 됩 니 다.SpringBoot 2.0 에서 몇 가지 데이터 원본 설정 을 선택 할 수 있 습 니 다.그들 은 HikariCP->Tomcat pooling->Commons DBCP 2 우선 순위 에 따라 마지막 에 실제 사용 할 데이터 원본 을 선택 합 니 다.
프로젝트 가 spring-boot-starter-jdbc 에 의존 할 때 HikariCP 데이터 원본 의 의존 도 를 포함 하기 때문에 HikariCP 연결 풀 데이터 원본 을 자동 으로 설정 합 니 다.
applications.properties 에 다음 설정 을 추가 합 니 다.


#       
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://10.110.2.5:3306/spring-boot-jdbc?charset=utf8mb4&useSSL=false
spring.datasource.username=springboot
spring.datasource.password=springboot
# Hikari        
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5

그 중에서 Hikari 데이터 원본 의 대부분 설정 은 다음 그림 과 같다.각 설정 대표 의 의 미 는 스스로 조회 할 수 있다.

프로그램 개발
사용자 데이터베이스 실체
수요 에 따라 대응 하 는 사용자 데이터 실 체 는 두 가지 속성 이 있 습 니 다.하 나 는 id 이 고 하 나 는 name 입 니 다.이것 은 순수한 POJO 대상 이다.


package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao;
/**
 *       
 *
 * @author    
 * @since 2018-03-09
 */
public class UserDO {
 private Long id;
 private String name;

 public Long getId() {
 return id;
 }

 public void setId(Long id) {
 this.id = id;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }
}

일반적인 Http Rest 반환 대상
보통 Http Rest 인터페이스 에서 저 희 는 업무 대상 의 내용 을 직접 되 돌려 주 고 싶 을 뿐만 아니 라 인터페이스 호출 결과,호출 에 실 패 했 을 때 돌아 오 는 사용자 정의 텍스트 메시지 등 일반적인 정 보 를 되 돌려 주 고 싶 습 니 다.그러면 우 리 는 두 개의 통용 되 는 rest 반환 대상 을 만들어 야 한다.통용 되 는 인터페이스 호출 결과 와 텍스트 메 시 지 를 제외 하고 하 나 는 하나의 단독 업무 내용 을 포함 하고 하 나 는 여러 업무 내용 을 가 진 집합 을 포함한다.구체 적 인 정 의 는 다음 과 같다.
단독 업무 내용 반환 대상


package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo;
/**
 *         
 *
 * @author    
 * @since 2018-03-09
 */
public class RestItemResult<T> {
 private String result;
 private String message;
 private T item;

 public String getResult() {
 return result;
 }

 public void setResult(String result) {
 this.result = result;
 }

 public String getMessage() {
 return message;
 }

 public void setMessage(String message) {
 this.message = message;
 }

 public T getItem() {
 return item;
 }

 public void setItem(T item) {
 this.item = item;
 }
}

업무 내용 반환 대상 집합


package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo;
import java.util.Collection;
/**
 *         
 *
 * @author    
 * @since 2018-03-09
 */
public class RestCollectionResult<T> {
 private String result;
 private String message;
 private Collection<T> items;

 public String getResult() {
 return result;
 }

 public void setResult(String result) {
 this.result = result;
 }

 public String getMessage() {
 return message;
 }

 public void setMessage(String message) {
 this.message = message;
 }

 public Collection<T> getItems() {
 return items;
 }

 public void setItems(Collection<T> items) {
 this.items = items;
 }
}

데이터 지구 층 개발
사용자 데이터 지구 층 인터페이스 정의


package com.yanggaochao.springboot.learn.springbootjdbclearn.dao;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import java.util.List;

/**
 *        
 *
 * @author    
 * @since 2018-03-09
 */
public interface UserDao {
 /**
 *             
 *
 * @param user         
 * @return       
 */
 Boolean add(UserDO user);

 /**
 *            
 *
 * @param user         
 * @return       
 */
 Boolean update(UserDO user);

 /**
 *          
 *
 * @param id          
 * @return       
 */
 boolean delete(Long id);

 /**
 *            
 *
 * @param id          
 * @return        ，      ，     null
 */
 UserDO locate(Long id);

 /**
 *           
 *
 * @param name         
 * @return         
 */
 List<UserDO> matchName(String name);
}

사용자 데이터 지구 층 구현


package com.yanggaochao.springboot.learn.springbootjdbclearn.dao.impl;
import com.yanggaochao.springboot.learn.springbootjdbclearn.dao.UserDao;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;

/**
 *             
 *
 * @author    
 * @since 2018-03-09
 */
@Repository
public class UserDaoJDBCTempletImpl implements UserDao {
 private final JdbcTemplate jdbcTemplate;

 @Autowired
 public UserDaoJDBCTempletImpl(JdbcTemplate jdbcTemplate) {
 this.jdbcTemplate = jdbcTemplate;
 }

 @Override
 public Boolean add(UserDO user) {
 String sql = "INSERT INTO AUTH_USER(UUID,NAME) VALUES(?,?)";
 return jdbcTemplate.update(sql, user.getId(), user.getName()) > 0;
 }

 @Override
 public Boolean update(UserDO user) {
 String sql = "UPDATE AUTH_USER SET NAME = ? WHERE UUID = ?";
 return jdbcTemplate.update(sql, user.getName(), user.getId()) > 0;
 }

 @Override
 public boolean delete(Long id) {
 String sql = "DELETE FROM AUTH_USER WHERE UUID = ?";
 return jdbcTemplate.update(sql, id) > 0;

 }

 @Override
 public UserDO locate(Long id) {
 String sql = "SELECT * FROM AUTH_USER WHERE UUID=?";
 SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, id);

 if (rs.next()) {
  return generateEntity(rs);
 }
 return null;
 }

 @Override
 public List<UserDO> matchName(String name) {
 String sql = "SELECT * FROM AUTH_USER WHERE NAME LIKE ?";
 SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, "%" + name + "%");
 List<UserDO> users = new ArrayList<>();
 while (rs.next()) {
  users.add(generateEntity(rs));
 }
 return users;
 }

 private UserDO generateEntity(SqlRowSet rs) {
 UserDO weChatPay = new UserDO();
 weChatPay.setId(rs.getLong("UUID"));
 weChatPay.setName(rs.getString("NAME"));
 return weChatPay;
 }
}

여기 서 먼저 주석@Repository 로 데이터 영구 층 의 클래스 임 을 표시 합 니 다.SpringBoot 는 이 종 류 를 자동 으로 예화 합 니 다.그리고 구조 함수 에@Autowired 를 추가 합 니 다.SpringBoot 는 이 종 류 를 예화 할 때 자동 으로 JDBCtemplet 인 스 턴 스 를 이 종류 에 주입 합 니 다.여기 JDBCtemplet 실례 는 요. SpringBoot 는 applications.properties 의 데이터 원본 과 관련 된 설정 에 따라 자동 으로 설 정 됩 니 다.SpringBoot 에서 데이터 원본 을 자동 으로 설정 하 는 알고리즘 에 따라 여기에 설 정 될 데이터 원본 은 HikariCP 입 니 다.
나머지 는 일반 Spring JDBCtemplet 개발 과 마찬가지 로 프로그래머 를 통 해 대상 과 데이터베이스 SQL 사 이 를 수 동 으로 전환 함으로써 사용자 의 증가,수정,삭제,모호 일치,정확 한 조회 등 기능 을 실현 했다.
데이터 계층 개발
데이터 계층 인터페이스 정의


package com.yanggaochao.springboot.learn.springbootjdbclearn.service;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import java.util.List;
/**
 *        
 *
 * @author    
 * @since 2018-03-09
 */
public interface UserService {
 UserDO add(UserDO user);
 UserDO update(UserDO user);
 boolean delete(Long id);
 UserDO locate(Long id);
 List<UserDO> matchName(String name);
}

데이터 계층 구현


package com.yanggaochao.springboot.learn.springbootjdbclearn.service.impl;
import com.yanggaochao.springboot.learn.springbootjdbclearn.dao.UserDao;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import com.yanggaochao.springboot.learn.springbootjdbclearn.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
 *         
 *
 * @author    
 * @since 2018-03-09
 */
@Service
public class UserServiceImpl implements UserService {
 private final UserDao userDao;
 @Autowired
 public UserServiceImpl(UserDao userDao) {
 this.userDao = userDao;
 }

 @Override
 public UserDO add(UserDO user) {
 user.setId(new Date().getTime());
 if (userDao.add(user)) {
  return user;
 }
 return null;
 }

 @Override
 public UserDO update(UserDO user) {
 if (userDao.update(user)) {
  return locate(user.getId());
 }
 return null;
 }

 @Override
 public boolean delete(Long id) {
 return userDao.delete(id);
 }

 @Override
 public UserDO locate(Long id) {
 return userDao.locate(id);
 }

 @Override
 public List<UserDO> matchName(String name) {
 return userDao.matchName(name);
 }
}

이 실현 클래스 는 업무 층 의 클래스 임 을@Service 주 해 를 통 해 설명 합 니 다.지구 층 의 UserDao 는@Autowired 를 통 해 SpringBoot 를 이 업무 층 류 를 예화 할 때 해당 하 는 지구 층 류 를 이 업무 류 에 자동 으로 주입 합 니 다.
여기 서 사용자 대상 을 추가 할 때 사용자 에 게 표 지 를 설정 할 때 현재 시간의 밀리초 수 를 간단하게 표지 로 사용 했다.실제 개발 과정 에서 이곳 은 전체적인 유일한 체 제 를 통 해 이 표지 가 중복 되 지 않도록 해 야 한다.
대외 서비스 층 개발


package com.yanggaochao.springboot.learn.springbootjdbclearn.web;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo.RestCollectionResult;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo.RestItemResult;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import com.yanggaochao.springboot.learn.springbootjdbclearn.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
 *    Http Rest   
 *
 * @author    
 * @since 2018-03-09
 */
@RestController
@RequestMapping("api/v1/user")
public class UserApi {
 @Autowired
 private UserService userService;

 @RequestMapping(value = "/add", method = RequestMethod.POST)
 public RestItemResult<UserDO> add(@RequestBody UserDO user) {
 RestItemResult<UserDO> result = new RestItemResult<>();
 user = userService.add(user);
 if (user != null) {
  result.setItem(user);
  result.setResult("success");
 } else {
  result.setMessage("      ");
  result.setResult("failure");
 }
 return result;
 }

 @RequestMapping(value = "/update", method = RequestMethod.POST)
 public RestItemResult<UserDO> update(@RequestBody UserDO user) {
 RestItemResult<UserDO> result = new RestItemResult<>();
 user = userService.update(user);
 if (user != null) {
  result.setItem(user);
  result.setResult("success");
 } else {
  result.setMessage("      ");
  result.setResult("failure");
 }
 return result;
 }

 @RequestMapping(value = "/delete/{uuid}", method = RequestMethod.GET)
 public RestItemResult<UserDO> delete(@PathVariable Long uuid) {
 RestItemResult<UserDO> result = new RestItemResult<>();
 if (userService.delete(uuid)) {
  result.setResult("success");
 } else {
  result.setMessage("      ");
  result.setResult("failure");
 }
 return result;
 }

 @RequestMapping(value = "/locate/{uuid}", method = RequestMethod.GET)
 public RestItemResult<UserDO> locate(@PathVariable Long uuid) {
 RestItemResult<UserDO> result = new RestItemResult<>();
 UserDO user = userService.locate(uuid);
 if (user != null) {
  result.setItem(user);
  result.setResult("success");
 } else {
  result.setMessage("      ");
  result.setResult("failure");
 }
 return result;
 }

 @RequestMapping(value = "/match/{name}", method = RequestMethod.GET)
 public RestCollectionResult<UserDO> match(@PathVariable String name) {
 RestCollectionResult<UserDO> result = new RestCollectionResult<>();
 List<UserDO> users = userService.matchName(name);
 result.setItems(users);
 result.setResult("success");
 return result;
 }
}

여기@RestController 는 Http Rest 인터페이스 클래스 임 을 설명 합 니 다.클래스 의@RequestMapping 과 방법 상의@RequestMapping 조합 을 통 해 모든 인터페이스의 호출 경 로 를 형성 합 니 다.방법 상의@RequestMapping 의 method 속성 은 http 호출 방법 을 설명 합 니 다.@RequestBody 주 해 는 자동 으로 post 데이터 의 json 대상 을 POJO 대상 으로 변환 합 니 다.@PathVariable 은 http url 경로 의 데 이 터 를 서비스 방법의 매개 변수 로 자동 으로 변환 합 니 다.
Http Rest 인터페이스 테스트
테스트 는 Apache comons 의 HttpClient 를 통 해 Http Rest 서 비 스 를 호출 합 니 다.
Http Resst 호출 보조 클래스


package com.yanggaochao.springboot.learn.springbootjdbclearn;
import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.params.HttpMethodParams;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.Map;

/**
 * @author    
 * @since 2018-03-09
 */
public class HttpClientHelper {


 /**
 *   get       http  
 *
 * @param url      http   url
 * @return    http         
 */
 public String httpGetRequest(String url, Map<String, String> headers) {
 try {
  HttpClient httpclient = new HttpClient();
  GetMethod method = new GetMethod(url);
  method.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
   new DefaultHttpMethodRetryHandler(3, false));
  if (headers != null) {
  for (String key : headers.keySet()) {
   method.setRequestHeader(key, headers.get(key));
  }
  }

  int statusCode = httpclient.executeMethod(method);
  if (statusCode == 200) {
  return parseInputStream(method.getResponseBodyAsStream());
  } else {
  System.out.println(url + " status = " + statusCode);
  }
 } catch (Exception e) {
  e.printStackTrace();
 }
 return null;
 }

 /**
 *   post        http   
 *
 * @param url      http   url
 * @param data post      data   
 * @return    http         
 */

 public String httpPostRequest(String url, String data, Map<String, String> headers) {
 try {
  HttpClient httpclient = new HttpClient();
  PostMethod method = new PostMethod(url);
  method.setRequestHeader("Content-Type",
   "application/json;charset=UTF-8");
  method.setRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.131 Safari/537.36");
  if (headers != null) {
  for (String key : headers.keySet()) {
   method.setRequestHeader(key, headers.get(key));
  }
  }

  method.setRequestEntity(new StringRequestEntity(data, "json", "utf-8"));
  int statusCode = httpclient.executeMethod(method);
  if (statusCode == 200) {
  return parseInputStream(method.getResponseBodyAsStream());
  } else {
  System.out.println(url + " status = " + statusCode + parseInputStream(method.getResponseBodyAsStream()));
  }
 } catch (Exception e) {
  e.printStackTrace();
 }
 return null;
 }


 /**
 *   java.io.Reader        
 *
 * @param rd java.io.Reader   
 * @throws Exception          
 */
 private String parseReader(Reader rd) throws Exception {
 BufferedReader brd = new BufferedReader(rd);
 String line;
 StringBuilder respongseContext = new StringBuilder();

 while ((line = brd.readLine()) != null) {
  respongseContext.append(line).append("
");
 }
 //rd.close();
 if (respongseContext.length() > 0) {
  respongseContext.deleteCharAt(respongseContext.length() - 1);
 }
 return respongseContext.toString();
 }

 /**
 *            
 *
 * @param is    
 * @throws Exception          
 */
 private String parseInputStream(InputStream is) throws Exception {
 return parseReader(new BufferedReader(new InputStreamReader(is)));
 }
}

여 기 는 주로 GET 와 POST 방법 으로 Http Rest 서 비 스 를 호출 하 는 방법 을 실현 했다.
테스트 용례
JUnit 을 사용 하여 테스트 용례 를 집행 하 다.테스트 를 실현 하기 위해 서,우 리 는 아래 의 maven 의존 도 를 추가 로 증가 시 켰 다.


<dependency>
 <groupId>commons-httpclient</groupId>
 <artifactId>commons-httpclient</artifactId>
 <version>3.1</version>
 <scope>test</scope>
</dependency>
<dependency>
 <groupId>org.codehaus.jettison</groupId>
 <artifactId>jettison</artifactId>
 <version>1.3.3</version>
 <scope>test</scope>
</dependency>


package com.yanggaochao.springboot.learn.springbootjdbclearn;
import org.codehaus.jettison.json.JSONObject;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;

/**
 * Description:
 *
 * @author    
 * @since 2018-03-09
 */
public class UserApiTest {
 private String userAddUrl = "http://localhost:3030/security/api/v1/user/add";
 private String userLocateUrl = "http://localhost:3030/security/api/v1/user/locate/";
 private String userDeleteUrl = "http://localhost:3030/security/api/v1/user/delete/";
 private String userUpdateUrl = "http://localhost:3030/security/api/v1/user/update";
 private String userMatchUrl = "http://localhost:3030/security/api/v1/user/match/";
 JSONObject addUser = new JSONObject();
 Long addUserId = null;
 List<Long> userIds = new ArrayList<>();
 @Before
 public void before() throws Exception {
 addUser.put("name", "   ");
 JSONObject addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, addUser.toString(), null));
 assert ("success".equals(addResultJson.getString("result")));
 addUserId = addResultJson.getJSONObject("item").getLong("id");

 JSONObject user = new JSONObject();
 user.put("name", "   ");
 addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, user.toString(), null));
 assert ("success".equals(addResultJson.getString("result")));
 userIds.add(addResultJson.getJSONObject("item").getLong("id"));
 user.put("name", "   ");
 addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, user.toString(), null));
 assert ("success".equals(addResultJson.getString("result")));
 userIds.add(addResultJson.getJSONObject("item").getLong("id"));
 }

 @Test
 public void testUpdateUser() throws Exception {
 JSONObject user = new JSONObject();
 user.put("name", "   ");
 user.put("id", addUserId);
 new HttpClientHelper().httpPostRequest(userUpdateUrl, user.toString(), null);
 JSONObject locateResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userLocateUrl + addUserId, null));
 assert (user.getString("name").equals(locateResultJson.getJSONObject("item").getString("name")));
 }


 @Test
 public void testMatchUser() throws Exception {
 JSONObject matchResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userMatchUrl + URLEncoder.encode(" ","UTF-8"), null));
 assert (matchResultJson.has("items") && matchResultJson.getJSONArray("items").length() == 2);
 matchResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userMatchUrl + URLEncoder.encode(" ","UTF-8"), null));
 assert (matchResultJson.has("items") && matchResultJson.getJSONArray("items").length() == 1);
 }

 @After
 public void after() throws Exception {
 if (addUserId != null) {
  JSONObject deleteResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userDeleteUrl + addUserId, null));
  assert ("success".equals(deleteResultJson.getString("result")));
 }

 for (Long userId : userIds) {
  JSONObject deleteResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userDeleteUrl + userId, null));
  assert ("success".equals(deleteResultJson.getString("result")));
 }
 }
}

여기 서@Test 에서 두 개의 테스트 용례 를 발 표 했 습 니 다.하 나 는 사용자 의 수정 기능 을 테스트 했 고 하 나 는 사용자 의 모호 한 조회 기능 을 테스트 했 습 니 다. @Before 는 모든 테스트 용례 를 실행 하기 전에 해 야 할 준비 작업 을 성명 했다.여기에 먼저 데이터베이스 에 세 개의 데 이 터 를 삽입 하 는 동시에 데이터 의 증가 기능,정확 한 조회 기능 도 테스트 했다.@After 는 모든 테스트 용례 를 실행 한 후의 청소 작업 을 성명 했다.여 기 는 주로 이전에 삽 입 된 데 이 터 를 삭 제 했 습 니 다.사용자 가 삭제 한 기능 을 동기 화 테스트 했 습 니 다.
후기
여기에 JDBC Templet 을 사용 하 는 완전한 SpringBoot 의 전체 사례 를 보 여 준다.스프링 에서 JDBC 템 플 릿 을 사용 한 경험 이 있다 면 스프링 에 서 는 주로 배치 작업 을 많이 줄 였 다.
본 논문 과 관련 된 코드 가 이미GitHUB에 올 라 왔 으 니 여러분 도 통과 할 수 있 습 니 다로 컬 다운로드.
총결산
이상 은 이 글 의 전체 내용 입 니 다.본 논문 의 내용 이 여러분 의 학습 이나 업무 에 어느 정도 참고 학습 가치 가 있 기 를 바 랍 니 다.궁금 한 점 이 있 으 시 면 댓 글 을 남 겨 주 셔 서 저희 에 대한 지지 에 감 사 드 립 니 다.

이 내용에 흥미가 있습니까?

현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:

Kotlin Springboot -- 파트 14 사용 사례 REST로 전환하여 POST로 JSON으로 전환

前回前回前回記事のははででででででを使っ使っ使ってててててリクエストをを受け取り、 reqeustbody で、そのリクエストのボディボディをを受け取り、関数内部 ...

텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.

CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.

자바 단 방향 링크 반전 실현

ASP.NET Core 에 서 는 액 션 에 다양한 방식 을 어떻게 활용 할 것 인가?

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다