기본 개념을 이해하는 것이 중요하므로 간단하게 다음과 같이 1부터 10까지 리스트에 추가합니다.

    List<Integer> list = new ArrayList<>();
    
    for(int i=1;i<=10;i++) {
        list.add(i);
    }
    System.out.println(list);

print하면 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]가 출력됩니다.

 

여기서 삭제하고 싶은 값이 10이라고 해보고 다음과 같이 입력해본다고 합시다.

    list.remove(10);

remove메소드의 파라미터는 index값을 받게 되어 있습니다.

index는 0부터 시작하므로 위에 있는 list객체에는 10번의 index가 존재하지 않아 IndexOutOfBoundsException가 발생하게 됩니다.

 

여기서 숫자 10을 삭제하고 싶을 때 어떻게 해야 할까요?

    list.remove(new Integer(10));
    
    System.out.println(list);

위와 같이 래퍼 클래스(Wrapper Class)로 감싸서 파라미터 값을 넘겨주면 됩니다.

 

이제 출력값은 다음과 같습니다.

[1, 2, 3, 4, 5, 6, 7, 8, 9]

 

우리가 원했던대로 10이 삭제되었습니다.

 

Java에서 수치나 논리값은 객체가 아니라 기본형으로 관리됩니다. 그런데 List나 Map과 같은 컬렉션 클래스 안에서는 객체만 저장할 수 있습니다. 그렇기 때문에 기본형을 객체로 감싸줘야 하는데 이러한 역할을 하는 것이 래퍼 클래스입니다. 

 

이러한 개념을 바탕으로 List에 숫자 10을 담기 위해서는 다음과 같이 해야 합니다.

    int ten = 10;
    
    Integer wrap_ten = new Integer(ten);
    
    List<Integer> list = new ArrayList<>();
    list.add(wrap_ten);
    
    System.out.println(list);

그런데 굳이 위처럼 하지 않고 다음과 같이 int값을 바로 넣어도 List에 추가가 되는 것을 알 수 있습니다.

    int ten = 10;

    List<Integer> list = new ArrayList<>();
    list.add(ten);
    
    System.out.println(list);

자바가 자동으로 int값을 래퍼 클래스로 변환해주기 때문입니다. 참고로 기본형에서 래퍼 클래스로 변환해주는 것을 '오토박싱'이라고 합니다. 

 

다시 이 글의 주제인 'List에서 특정 index가 아닌 원하는 값 삭제'로 돌아가 보겠습니다.

 

그러면 왜 remove 메소드에 10을 넘겼을 때 왜 래퍼 클래스로 변환해주지 않는 것이냐 라는 의문이 들 수 있습니다. 

 

List 객체의 특성을 다시 생각해보면 됩니다.

List에서 어떠한 작업을 하기 위한 키는 기본적으로 index입니다. 그러므로 remove 메소드 파라미터의 기본은 index인 것입니다. 몇 번째 index에 위치한 것을 우리가 호출한 메소드에 맞게 처리해라가 기본인 것입니다. 

 

그러므로 List에서 index가 아니라 우리가 생각하는 그 숫자를 삭제하려면 래퍼 클래스로 감싸서 파라미터로 넘겨야 합니다. 

 

그렇다면 Java가 List 안에서 우리가 생각하는 것처럼 숫자 10을 인식해서 삭제하는 것일까요?

 

객체의 기본 개념을 생각해봅시다. 이해하기 쉽게 객체는 주소와 값으로 구성된 map과 같은 것입니다. 파이썬에서는 Dictionary 같은 것입니다. 

 

이 글 처음에 for문을 이용해서 1부터 10까지 숫자를 List에 추가하였습니다. 이 때 내부적으로 1부터 10까지 각각 래퍼 클래스로 전부 감싼 후 List에 추가한 것입니다. 그러므로 1부터 10까지 숫자가 있는 것이 아니라 1부터 10까지 주소와 값으로 구성된 객체 10개가 만들어진 것입니다.

 

그러므로 list.remove(new Integer(10))을 실행했을 때 자바가 List 안에서 숫자 10을 인식한 게 아니라 10이 위치한 주소를 찾아 그 객체를 삭제한 게 되는 것입니다.

 

 

 

 

'프로그래밍 > Java' 카테고리의 다른 글

[자바] Open API에서 xml 파싱(parsing)하기  (0) 2020.12.17

이번 포스팅에서는 controller 파일을 생성 후 was를 실행하지 않고 controller 테스트를 진행해보도록 하겠습니다.

 

먼저 스프링 프레임워크에서 어떤 설정이 필요한지 확인해보겠습니다.

 

스프링 프레임워크에서 controller 파일을 인식시키려면 controller class 위에 @Controller 어노테이션을 작성하면 됩니다.

 

다음으로 이 @Controller 어노테이션을 인식하게 하려면 src/main/webapp/WEB-INF/spring/appServlet/servlet-context.xml 파일을 살펴봐야 합니다.

 

아래 그림에 보면 component-scan context를 설정한 부분이 있는데 base-package 속성값에 @Controller 어노테이션을 자동으로 인식시키고자 하는 폴더명을 지정해야 합니다.

 


이제 controller 파일을 생성하고 JSON데이터를 리턴하는 코드를 작성해보도록 하겠습니다.

 

스프링에서 JSON 처리를 하기 위해서는 jackson-databind 라이브러리를 추가해야 합니다.

 

다음과 같이 pom.xml에 추가합니다.

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.12.0</version>
</dependency>

 

그 다음 VO 객체를 만듭니다.

 

다음과 같이 Stock 클래스 파일을 만들겠습니다.

import lombok.Data;

@Data
public class Stock {
	private String code;
	private String name;
}

 

Stock 객체에 종목코드와 종목명을 넣고 JSON으로 리턴하는 클래스 파일을 만들겠습니다.

 

StockController 클래스를 다음과 같이 작성합니다.

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.kenmiles.hellojarvis.web.entity.Stock;

@Controller
public class StockController {
	
	@RequestMapping("/setVO")
	public @ResponseBody Stock setVO(){
		Stock vo = new Stock();
		vo.setCode("005930");
		vo.setName("삼성전자");
		
		return vo;
	}
	  
}

 

여기서 주의할 점은 리턴타입에 @ResponseBody 어노테이션을 추가해야 한다는 점입니다.

 

위 controller가 정상적으로 실행되는지 확인하기 위해서는 보통 톰캣을 실행해 브라우저 창에 주소를 입력해서 확인합니다.

 

하지만 이번 포스팅에서는 톰캣 실행 없이 controller 파일이 정상 실행되는지 확인해보도록 하겠습니다.

 

톰캣 실행 없이 controller를 테스트하기 위해서 브라우저에서 요청과 응답하는 과정을 대신처리할 수 있는 MockMvc를 이용하겠습니다.

 

다음과 같이 JUnit Test 파일을 생성합니다.

import java.nio.charset.Charset;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import com.kenmiles.hellojarvis.web.controller.StockController;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations= {"file:src/main/webapp/WEB-INF/spring/**/*.xml"})
public class sampleControllerTest {

	private static final Logger logger = LoggerFactory.getLogger(sampleControllerTest.class);

	@Autowired
	StockController stockController;
	
	private MockMvc mockMvc;
	
    private MediaType contentType = new MediaType(MediaType.APPLICATION_JSON.getType(),
            MediaType.APPLICATION_JSON.getSubtype(),
            Charset.forName("utf8"));

	@Before
	public void setup(){
		mockMvc = MockMvcBuilders.standaloneSetup(stockController).build();
		logger.info("setup......");
	}
	
	@Test
	public void testGetData()throws Exception{
		mockMvc.perform(MockMvcRequestBuilders.get("/setVO")
				.contentType(contentType))
		.andExpect(MockMvcResultMatchers.status().isOk())
		.andDo(MockMvcResultHandlers.print()); 

	}
}

이 코드에서 일반 자바를 테스트할 때와 다른 점은 @WebAppConfiguration 어노테이션을 추가한 것과 servlet-context.xml을 읽도록 하기 위해 WEB-INF/spring 폴더 아래 xml파일을 전부 인식하도록 했다는 점입니다.

 

테스트를 하고자 하는 controller 파일을 @Autowired로 주입하고 해당 객체를 setup메소드에서 mockMvc 객체로 초기화합니다.

 

<Ctrl> + <F11>로 실행하면 다음과 같이 status가 200이 나타나고 Body에 controller 파일에서 리턴한 JSON 값이 표시되어 있는 것을 확인할 수 있습니다.

 

 

이번 포스팅에서는 API를 호출했을 때 xml로 출력되는 자료를 파싱(parsing)하는 방법에 대해 알아보도록 하겠습니다.

 

예제를 위해 opendart 사이트에 접속해 회원가입하고 API 이용하기 위한 인증키를 신청합니다.

 

opendart.fss.or.kr/

 

전자공시 OPENDART 시스템

--> 시스템 점검으로 모든 서비스 이용이 일시적으로 중단되어니 양해 부탁드립니다. 시스템 점검 일정 2019년12월30일 23:00 ~ 12월31일 24:00 (1시간) *상기 작업 시간은 사정에 의해 변경 될 수 있습니

opendart.fss.or.kr

개발가이드 -> 사업보고서 주요정보에서 증자(감자) 현황 정보를 가져와 보도록 하겠습니다.

 

맨 오른쪽에 바로가기를 클릭합니다.

개발가이드에 보면 기본 정보, 요청 인자, 응답 결과 정보를 확인할 수 있고 화면 아래로 더 내려보면 다음과 같이 OpenAPI 테스트도 해볼 수 있습니다.

 

XML로 파싱할 것이기 때문에 XML을 선택하고 검색을 누릅니다.

API 결과에 요청인자에 따른 url 주소와 요청한 결과값이 XML값으로 표시되는 것을 볼 수 있습니다.

 

이제 url을 호출해서 XML값을 파싱하는 작업을 자바로 구현해보겠습니다.

 

자바파일로 만들어도 되고 JUnit 테스트 코드로 작성해도 됩니다.

 

다음과 같이 자바 파일을 작성합니다.

import java.net.URLDecoder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class xmlParsingTest {

	// tag값의 정보를 가져오는 메소드
	private static String getTagValue(String tag, Element eElement) {
	    NodeList nlList = eElement.getElementsByTagName(tag).item(0).getChildNodes();
	    Node nValue = (Node) nlList.item(0);
	    if(nValue == null) 
	        return null;
	    return nValue.getNodeValue();
	}

	@Test
	public void test() {
		try{
			// parsing할 url 지정(API 키 포함해서)
			String url = "https://opendart.fss.or.kr/api/irdsSttus.xml";
			String serviceKey = "인증키";
			String decodeServiceKey = URLDecoder.decode(serviceKey, "UTF-8");
			String corpCode = "00293886"; //공시대상회사의 고유번호(8자리)
			String bsnsYear = "2018"; //사업연도(4자리)
			String reprtCode = "11011"; //보고서 코드
					
			Document documentInfo = DocumentBuilderFactory
					.newInstance()
					.newDocumentBuilder()
					.parse(url+"?crtfc_key="+decodeServiceKey+"&corp_code="+corpCode+"&bsns_year="+bsnsYear+"&reprt_code="+reprtCode);
			
			// root tag 
			documentInfo.getDocumentElement().normalize();
			//				System.out.println("Root element :" + documentInfo.getDocumentElement().getNodeName());
			
			// 파싱할 tag
			NodeList nList = documentInfo.getElementsByTagName("list");
			//				System.out.println("파싱할 리스트 수 : "+ nList.getLength());
			
			for(int temp = 0; temp < nList.getLength(); temp++){
				Node nNode = nList.item(temp);
				if(nNode.getNodeType() == Node.ELEMENT_NODE){
					
					Element eElement = (Element) nNode;
					System.out.println("######################");
					System.out.println("고유번호  : " + getTagValue("corp_code", eElement));
					System.out.println("법인명  : " + getTagValue("corp_name", eElement));
					System.out.println("주식발행 감소일자 : " + getTagValue("isu_dcrs_de", eElement));
					System.out.println("발행 감소 형태  : " + getTagValue("isu_dcrs_stle", eElement));
					System.out.println("발행 감소 주식 종류  : " + getTagValue("isu_dcrs_stock_knd", eElement));
					System.out.println("발행 감소 수량  : " + getTagValue("isu_dcrs_qy", eElement));
					System.out.println("발행 감소 주당 액면 가액 : " + getTagValue("isu_dcrs_mstvdv_fval_amount", eElement));
					System.out.println("발행 감소 주당 가액  : " + getTagValue("isu_dcrs_mstvdv_amount", eElement));
				}	
			}	
		} catch (Exception e){	
			e.printStackTrace();
		}
	}

}

<Ctrl> + <F11>을 눌러서 실행해보면 다음과 같이 콘솔창에 XML데이터가 파싱되어 표시되는 것을 볼 수 있습니다.

다시 Opendart 사이트로 가서 인증키 신청/관리 -> 오픈API 이용현황에 보면 다음과 같이 일일허용건수와 호출건수를 확인할 수 있습니다.

 

이번 포스팅에서는 MyBatis를 설정하고 Spring과 MyBatis, DB 서버가 제대로 연결이 되었는지까지 확인해보도록 하겠습니다.

 

MyBatis를 사용하기 위해서는 mybatis-spring과 mybatis 라이브러리가 필요합니다.

 

Maven Repository 사이트에 접속해서 mybatis-spring과 mybatis를 검색합니다.

 

Maven Dependency 코드를 복사해서 pom.xml에 붙여넣기 합니다.

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

 

Mybatis와 스프링 연동 작업에서 가장 중요한 객체인 sqlSessionFactory를 사용할 수 있게 설정하도록 하겠습니다.

 

src/main/webapp/WEB-INF/spring/root-context.xml에 들어가 다음과 같이 설정합니다.

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
</bean>

 

dataSource 설정은 다음을 참조하세요.

2020/12/11 - [프로그래밍/Spring Framework] - [JDBC] Spring Maven 프로젝트에 MS-SQL Server 2019 JDBC Driver 설정 방법

 

[JDBC] Spring Maven 프로젝트에 MS-SQL Server 2019 JDBC Driver 설정 방법

이번 포스팅에서는 Spring Maven 프로젝트를 생성 후 MS-SQL과 연결하는 과정을 설명드리겠습니다. MS SQL Server 2019 JDBC Driver 정보가 있는 다음 사이트에 접속합니다. docs.microsoft.com/en-us/sql/connec..

grand-unified-engine.tistory.com

 

MyBatis는 SQL Mapping Framework로 Spring과 별도의 설정 파일을 가질 수 있습니다.

 

src/main/resources 아래 config 폴더를 만들고 mybatis-config.xml 파일을 생성합니다.

 

mybatis-config.xml파일에 다음을 입력합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration></configuration>

 

mybatis-config.xml에 추가로 설정할 것들이 있는데 다음 포스팅 때 하기로 하고 이번 포스팅에서는 기본설정만 하도록 하겠습니다.

 

이렇게 만든 mybatis-config.xml파일을 Spring Framework에서 사용할 수 있게 root-context.xml 파일을 다음과 같이 수정합니다.

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <property name="configLocation" value="classpath:/config/mybatis-config.xml"></property>
</bean>

 

지금까지 Mybatis 기본 설정을 마쳤습니다.

 

마지막으로 정상적으로 스프링에서 Mybatis와 DB 서버가 잘 연결되는지 확인해보도록 하겠습니다.

 

JUnit Test Case로 테스트 자바파일을 생성합니다.

 

테스트 자바 파일에 다음과 같이 입력합니다.

 

import javax.inject.Inject;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/spring/root-context.xml"})
public class MyBatisTest {

	//SqlSessionFactory 객체를 자동으로 생성
	@Inject
	private SqlSessionFactory sqlFactory;
		
	//SqlSessionFactory 객체가 제대로 만들어졌는지 Test
	@Test
	public void test() {
		System.out.println(sqlFactory);
	}
	
	//MyBatis와 DB 서버가 제대로 연결되었는지 Test
	@Test
	public void testSession() throws Exception{
		try(SqlSession session = sqlFactory.openSession()){
			System.out.println(session);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}

}

 

<Ctrl> + <F11>을 눌러서 결과를 확인하도록 하겠습니다.

 

콘솔창에 다음과 같이 출력되는 것을 볼 수 있습니다.

 

잘 연결된 것을 확인할 수 있습니다.

 

이번 포스팅에서는 HikariCP로 DB에 접속해보고 springframework의 jdbc driver와의 속도 차이를 확인해보도록 하겠습니다.

 

springframework의 jdbc 설정은 다음 링크를 참조하시기 바랍니다.

2020/12/11 - [프로그래밍/Spring Framework] - [JDBC] Spring Maven 프로젝트에 MS-SQL Server 2019 JDBC Driver 설정 방법

 

[JDBC] Spring Maven 프로젝트에 MS-SQL Server 2019 JDBC Driver 설정 방법

이번 포스팅에서는 Spring Maven 프로젝트를 생성 후 MS-SQL과 연결하는 과정을 설명드리겠습니다. MS SQL Server 2019 JDBC Driver 정보가 있는 다음 사이트에 접속합니다. docs.microsoft.com/en-us/sql/connec..

grand-unified-engine.tistory.com

JUnit 테스트 환경은 다음을 참조하시기 바랍니다.

2020/12/14 - [프로그래밍/Spring Framework] - [JUnit] JUnit으로 테스트 환경 설정하기

 

[JUnit] JUnit으로 테스트 환경 설정하기

안녕하세요 이번 포스팅에서는 이클립스에 JUnit 라이브러리를 추가하고 JUnit 테스트를 할 수 있게 환경을 구성해보겠습니다. 1. Maven Dependancies 추가 JUnit 테스트를 하기 위해서는 두 가지 라이브

grand-unified-engine.tistory.com

springframework의 jdbc 설정은 Spring Bean Configuration File에 다음과 같이 입력합니다.

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config/db.properties</value> 
            </list>
        </property>
    </bean>	
    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

 

테이블 한개 조회하는 시간을 측정하기 위해 JUnit 테스트를 생성하도록 하겠습니다.

 

프로젝트 선택 후 마우스 오른쪽 -> New ->JUnit Test Case를 클릭하고 자바 파일을 생성합니다.

 

다음과 같이 코드를 입력합니다.

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import javax.sql.DataSource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/spring/root-context.xml"})
public class dataSourceSpeedTest {

    @Autowired
    private ApplicationContext context;
    
    @Test
    public void test() {
    	Connection conn = null;
        Statement state = null; 
        long start = System.currentTimeMillis();
		
        DataSource ds = (DataSource) context.getBean("dataSource");
		
        try {
        	conn = ds.getConnection();
            state = conn.createStatement();
            String sql; //SQL문을 저장할 String
            sql = "SELECT * FROM 테이블명 ";
            ResultSet rs = state.executeQuery(sql); //SQL문을 전달하여 실행
            
            while(rs.next()){
            	String dpt_cd = rs.getString("DPT_CD"); //조회하려는 필드1
                String dpt_nm = rs.getString("DPT_NM"); //조회하려는 필드2
                System.out.println("dpt_cd: "+ dpt_cd + "\ndpt_nm: " + dpt_nm); 
            }
			
            rs.close();
            state.close();
            conn.close();
            long end = System.currentTimeMillis(); 
            long secDiffTime = (end - start);
            System.out.println("조회시간 : "+secDiffTime/1e3 + "초");
        } catch(Exception e){
			//예외 발생 시 처리부분
        }
    }
}

<Ctrl> + <F11>로 빌드하면 콘솔 창에 다음과 같이 조회시간이 표시됩니다.

 


이번에는 Hikari Connection Pool로 DataSource를 연결 후 같은 소스로 조회시간을 측정해보도록 하겠습니다.

 

먼저 HikariCP 환경 설정을 위해 Maven Repository 사이트에 접속합니다.

 

mvnrepository.com/

 

Maven Repository: Search/Browse/Explore

yang-maven-plugin-spi Last Release on Dec 14, 2020

mvnrepository.com

검색창에 hikaricp를 입력하고 조회합니다.

 

Maven dependency 코드를 복사해서 pom.xml에 붙여넣기합니다.

 

Spring Bean Configuration File에 다음과 같이 Hikari Connection Pool 정보를 입력합니다.

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config/db.properties</value> 
            </list>
        </property>
    </bean>	
    
    <bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig">
        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
        <constructor-arg ref="hikariConfig"/>
    </bean>

다시 JUnit Test 소스를 실행해보도록 하겠습니다.

 

자바 파일을 선택 후 <Ctrl> + <F11>을 누릅니다.

 

조회시간이 0.204초가 나옵니다.

 

springframework의 jdbc로 설정했을 때보다 무려 3% 밖에 시간이 안 걸리는 것을 확인할 수 있습니다.

 

조건별로 다른 결과가 나오겠지만 Hikari Connection Pool을 사용하면 시간을 꽤 단축시킬 수 있을 것이라 판단됩니다.

 

지금까지 Hikari Connection Pool로 DB접속할 수 있게 환경을 구성하고 springframework의 jdbc 와 테이블 Full Scan할 때 시간을 비교해보았습니다.    

+ Recent posts