통일장 엔진

이번 포스팅에서는 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 값이 표시되어 있는 것을 확인할 수 있습니다.

이번 포스팅에서는 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 설정 방법

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 설정 방법

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

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

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/

검색창에 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할 때 시간을 비교해보았습니다.    

안녕하세요

이번 포스팅에서는 이클립스에 JUnit 라이브러리를 추가하고 JUnit 테스트를 할 수 있게 환경을 구성해보겠습니다.

1. Maven Dependancies 추가

JUnit 테스트를 하기 위해서는 두 가지 라이브러리가 필요합니다.

springframework spring-test와 JUnit 라이브러리입니다.

JUnit 라이브러리의 최신 버전을 확인하기 위해 메이븐 사이트에 접속합니다.

mvnrepository.com/

JUnit 검색하고 2. JUnit 을 클릭합니다.

원하는 버전을 선택 후 클릭하면 Maven에 추가할 수 있는 코드를 확인 할 수 있습니다.

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

		<!-- Spring-test -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
        
		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.13</version>
			<scope>test</scope>
		</dependency>        

다음과 같이 메이븐 디펜던시에 추가된 것을 확인할 수 있습니다.

2. 이클립스 Build Path에 JUnit 라이브러리 추가

다음과 같이 JUnit을 사용하려는 프로젝트를 선택 후 마우스 오른쪽 클릭 -> Build Path -> Configure Build Path 를 선택합니다.

Libraries 탭에서 Add Library를 클릭합니다.

JUnit을 선택하고 Next를 클릭합니다.

JUnit 4를 선택 후 Finish를 클릭합니다.

JUnit 4 라이브러리가 추가된 것을 확인할 수 있습니다. Apply and Close를 클릭합니다.

JUnit으로 테스트할 수 있는 환경이 구성되었습니다.

DB에 접속이 잘 되는지로 JUnit 테스트를 해보겠습니다.

프로젝트를 선택 후 New -> JUnit Test Case를 클릭합니다.

원하는 파일명을 입력합니다.

파일명을 입력 후 Finish를 누르면 src/test/java에 파일이 생성됩니다.

새로 생성된 파일에 다음 코드를 입력합니다.

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 springDatasourceTest {

    @Autowired
    private ApplicationContext context;
    
	@Test
	public void test() {
		DataSource ds = (DataSource) context.getBean("dataSource");
		
		try {
			System.out.println(ds.getConnection());
		} catch(Exception e){
			//예외 발생 시 처리부분

		}
	}
}

JDBC 설정이 필요하시면 다음 링크를 참조하세요.

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

<Ctrl> + <F11>을 눌러 build를 하면 Console창에 다음과 같이 ConnectionId가 출력됩니다.

지금까지 Spring Framework에 JUnit 설정하는 방법에 대해 알아보았습니다.

이번 포스팅에서는 Spring Maven 프로젝트를 생성 후 MS-SQL과 연결하는 과정을 설명드리겠습니다.

MS SQL Server 2019 JDBC Driver 정보가 있는 다음 사이트에 접속합니다.

docs.microsoft.com/en-us/sql/connect/jdbc/download-microsoft-jdbc-driver-for-sql-server?view=sql-server-ver15

다음과 같이 네모칸으로 표시된 파일을 다운받아 라이브러리를 직접 세팅하셔도 됩니다.

이번 포스팅에서는 pom.xml에 설정하는 방식으로 진행하겠습니다.

스크롤을 내려보면 다음과 같이 pom.xml에 설정하는 방법이 나와 있습니다.

copy를 클릭합니다.

붙여넣기를 할 때 jdk 버전이 11이 아니라면 위 xml 정보에서 jre11을 환경에 맞게 수정해야 합니다.

예를 들어 jdk가 1.8이라면 jre8로 수정해주시기 바랍니다.

pom.xml에 붙여넣기 하고 저장 버튼을 클릭하면 해당 프로젝트의 Maven Dependencies에 MS SQL JDBC가 포함된 것을 확인할 수 있습니다.

properties파일에 데이터베이스 접속 정보를, context.xml에 dataSource Bean을 등록 후 DB에 접속할 수 있는 환경을 세팅해보도록 하겠습니다.

src/main/resources에 config 폴더를 생성하고 db.properties파일을 만듭니다.

해당 파일에 다음과 같이 입력합니다.

jdbc.driverClassName = com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc.url = jdbc:sqlserver://주소;databaseName=데이터베이스명
jdbc.user = 계정id
jdbc.password = password

이 정보를 dataSource Bean에 매핑하는 작업을 하도록 하겠습니다.

context.xml을 따로 만드시거나 tomcat 실행과 함께 로딩되는 WEB-INF/spring/root-context.xml에 작성하면 됩니다.

<beans> 루트 엘리먼트 안에 다음을 입력합니다.

	
    <!-- Root Context: defines shared resources visible to all other web components -->
    <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>

PropertyPlaceholderConfigurer class에는 properties 파일의 위치를 설정합니다.

DriverManagerDataSource class에는 properties 파일에 있는 설정 값을 property로 등록하여 Spring에서 jdbc 설정 값으로 사용할 수 있게 합니다.

그런데 DriverManagerDataSource class에 빨간색으로 표시되면서 읽을 수 없다고 나오는 경우가 있습니다.

DriverManagerDataSource를 사용하기 위하여 pom.xml에 다음을 입력해 spring-jdbc.jar를 Maven Dependencies로 등록해야 합니다.

		<!-- Spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>

다음과 같이 빨간 줄이 사라진 것을 확인 할 수 있습니다.

Spring에서 MS-SQL DB에 접속할 수 있게 환경 설정을 마쳤습니다.