728x90
반응형
728x90
반응형
728x90
반응형

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

 

 

728x90
반응형
728x90
반응형

이번 포스팅에서는 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 이용현황에 보면 다음과 같이 일일허용건수와 호출건수를 확인할 수 있습니다.

 

728x90
반응형
728x90
반응형

이번 포스팅에서는 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>을 눌러서 결과를 확인하도록 하겠습니다.

 

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

 

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

 

728x90
반응형
728x90
반응형

이번 포스팅에서는 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할 때 시간을 비교해보았습니다.    

728x90
반응형
728x90
반응형

안녕하세요

 

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

 

1. Maven Dependancies 추가

 

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

 

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

 

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

 

mvnrepository.com/

 

Maven Repository: Search/Browse/Explore

Generates Cucumber execution report in PDF format for ExtentReports Last Release on Dec 13, 2020

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으로 테스트할 수 있는 환경이 구성되었습니다.

 

728x90

 

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

 

[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

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

 

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

 

728x90
반응형

+ Recent posts