'연동' 태그의 글 목록

연동

09. 스프링에서 myBatis사용하여 mySQL db연동 2019.06.24

09. 스프링에서 myBatis사용하여 mySQL db연동

KOC25 2019. 6. 24. 16:46

2019. 6. 24. 16:46

스프링 프레임워크에서 myBatis사용하여 mySQL db연동하는 방법

결론적으로 아래와 같이 파일구성이 되야한다.

예제파일-----

jdbcTest2.zip

0.03MB

--------

그럼 차근차근 진행해본다.

1. src/main/resources에 파일 생성

1) mybatis-config.xml 파일 생성

아래 코드를 mybatis-config.xml에 넣는다.

이 파일을 생성하여야 log dependency를 넣었을 때 오류가 나지 않는다.

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

</configuration>

2) log4jdbc.log4j2.properties 파일 생성

아래코드를 log4jdbc.log4j2.properties에 넣는다.

log4jdbc에 접속시켜주는 역할을 한다.

log4jdbc.log4j2.properties

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

3) logback.xml 생성

레벨을 설정해주는 파일이다.

아래코드를 logback.xml에 넣는다.

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    log4jdbc-log4j2
	<logger name="jdbc.sqlonly"        level="DEBUG"/>
    <logger name="jdbc.sqltiming"      level="INFO"/>
    <logger name="jdbc.audit"          level="WARN"/>
    <logger name="jdbc.resultset"      level="ERROR"/>
    <logger name="jdbc.resultsettable" level="ERROR"/>
    <logger name="jdbc.connection"     level="INFO"/>
</configuration>

아래와 같이 파일들이 생성된다.

2. dependency 주입

pom.xml에 스프링, jdbc, 로그 관련 의존성을 주입한다.

아래 코드를 pom.xml에 붙여넣기한다.

<!-- db 연결 관련 -->
		<!-- spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
			<!-- mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.38</version>
		</dependency>
			<!-- MyBatis 관련 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.3.1</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.5</version>
		</dependency>
				<!-- log 관련 -->
		<dependency>
			<groupId>org.bgee.log4jdbc-log4j2</groupId>
			<artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
			<version>1.16</version>
		</dependency>	
        
        				<!-- sprint-test 관련-->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>

그리고 <properties>태그안에 org.springframework-version을 4.2.3으로 변경시킨다.

	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>4.2.3.RELEASE</org.springframework-version>
		<org.aspectj-version>1.6.10</org.aspectj-version>
		<org.slf4j-version>1.6.6</org.slf4j-version>
	</properties>

3. VO와 DAO 생성

1) VO 생성

com.mysql.domain에 memberVO.java를 생성하여 아래 코드들을 넣는다.

MemberVO.java

package com.mysql.domain;

import java.sql.Date;

public class memberVO {

	String userid;
	String userpw;
	String username;
	String email;
	Date regdate;
	Date updatedate;
	
	public String getUserid() {
		return userid;
	}
	public void setUserid(String userid) {
		this.userid = userid;
	}
	public String getUserpw() {
		return userpw;
	}
	public void setUserpw(String userpw) {
		this.userpw = userpw;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Date getRegdate() {
		return regdate;
	}
	public void setRegdate(Date regdate) {
		this.regdate = regdate;
	}
	public Date getUpdatedate() {
		return updatedate;
	}
	public void setUpdatedate(Date updatedate) {
		this.updatedate = updatedate;
	}
	@Override
	public String toString() {
		return "MemberVO [userid=" + userid + ", userpw=" + userpw + ", username=" + username + ", email=" + email
				+ ", regdate=" + regdate + ", updatedate=" + updatedate + "]";
	}
}

2) DAO 생성

DAO는 데이터베이스와 연결시켜주는 역할을 한다.

1) com.mysql.persistence에 memberDAO.java를 생성하여 아래 코드들을 넣는다.

MemberDAO.java

package com.mysql.persistence;

import com.mysql.domain.MemberVO;

// 타입만 명세
	public interface MemberDAO extends GenericDAO<MemberVO, String> {

	}// interface

2) com.mysql.persistence에 memberDAOImpl.java를 생성하여 아래 코드들을 넣는다.

MemberDAOImpl.java

package com.mysql.persistence;

import org.springframework.stereotype.Repository;
import com.mysql.domain.MemberVO;


@Repository
public class MemberDAOImpl extends GenericDAOImpl<MemberVO, String> implements MemberDAO {

}

3) com.mysql.persistence에 GenericDAO.java를 생성하여 아래 코드들을 넣는다.

GenericDAO.java

package com.mysql.persistence;

import java.util.List;

public interface GenericDAO<E, K> {

	public K getTime();
	public void register(E vo);
	public E get(K userid);
	public List<E> getList();
	// 아래는 등록, 조회 구현 이후에 할 것임..
	//public void update();
	//public void delete();
	
}// interface

4) com.mysql.persistence에 GenericDAOImpl.java를 생성하여 아래 코드들을 넣는다.

GenericDAOImpl.java

package com.mysql.persistence;


import java.util.List;
import javax.inject.Inject;
import org.apache.ibatis.session.SqlSession;

// GenericDAO 인터페이스의 추상클래스들을 오버라이딩 해주어야 한다.
// 즉, 여기서 DB와 연결을 하고 SQL문을 처리해주어야 하므로 sessionTemplate을 인스턴스 변수로 갖고서 
// 이를 통해 CRUD 작업을 처리해주면 된다.
public abstract class GenericDAOImpl<E, K> implements GenericDAO<E, K> {

	@Inject
	private SqlSession sqlSession;
	
	private static final String namespace = 
			"com.mysql.mapper.MemberMapper";
	
	@Override
	public K getTime() {
		return sqlSession.selectOne(namespace + ".getNow");
	}

	@Override
	public void register(E vo) {
		sqlSession.insert(namespace + ".register", vo);
	}

	@Override
	public E get(K userid) {
		return sqlSession.selectOne(namespace + ".get", userid);
	}

	@Override
	public List<E> getList() {
		return sqlSession.selectList(namespace + ".getList");
	}

}// class

5) com.mysql.persistence에 TimeDao.java를 생성하여 아래 코드들을 넣는다.

TimeDAO.java

package com.mysql.persistence;


import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.springframework.stereotype.Repository;


@Repository
public class TimeDAO {

	@Inject
	private DataSource ds;
	
	
	public String getTime() throws Exception{
		
		Connection conn = ds.getConnection();
		PreparedStatement pstmt = conn.prepareStatement("select now()");
		
		ResultSet rs = pstmt.executeQuery();
		
		rs.next();
		return rs.getString(1);
		
	}// getTime()
	
	
}

4. root-context 코드 추가

root-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
		
		
	<!-- JDBC의 연결을 처리하는 기능을 가진 DataSource -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="net.sf.log4jdbc.sql.jdbcapi.DriverSpy"></property>
		<property name="url" value="jdbc:log4jdbc:mysql://127.0.0.1:3306/book_ex"></property>
		<property name="username" value="zerock"></property>
		<property name="password" value="12351235"></property>
	</bean>

	<!-- SqlSessionFactoryBean 생성 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 		<!-- mybatis-config.xml 파일이 스프링이 동작할 때 같이 동작하도록 설정한 것. -->
		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
		<property name="dataSource" ref="dataSource"></property>
		<property name="mapperLocations" value="classpath:mappers/**/*.xml"></property>
	</bean>

	<!-- sqlSession 을 SqlSessionTemplate으로 만든다. -->
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>


	<!-- 스프링이 관리하는 패키지에 com.mysql.persistence 를 추가한다. -->
	<context:component-scan base-package="com.mysql.persistence" />
	
</beans>

5. mapper 추가

resources에 mappers라는 패키지를 추가한 뒤에 memberMapper.xml 파일을 만든다.

그 뒤 아래 코드를 붙여넣는다.

memberMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mysql.mapper.MemberMapper">

	<!-- 이거에 접근할 때 namespace.id 로 접근한다. -->
	<!-- resultType은 자바의 타입과 매핑되는 것이 있다. 여기선 string이 java.lang.String과 매핑 -->
	<select id="getNow" resultType="string">
		select now()   <!-- 세미콜론 쓰면 안됨 -->
	</select>
	
	<insert id="register">
		insert into tbl_member(userid, userpw, username, email)
		values( #{userid} , #{userpw}, #{username}, #{email} );
	</insert>
	
	<!-- 
			XML Mapper를 작성할 때 매번 resultType을 패키지까지 포함된 클래스명을 작성하는 일이 번거롭다면
			MyBatis의 설정 파일인 mybatis-config.xml을 사용해서 다음과 같이 <typeAliases>를 작성하면된다.
			<typeAliases>
				<package name = "org.zerock.domain"/>
			</typeAliases>		
	-->
	<select id="get" resultType="com.mysql.domain.MemberVO">
		select *
		from tbl_member
		where userid = #{userid}
	
	</select>
	
	<select id="getList" resultType="com.mysql.domain.MemberVO">
		select *
		from tbl_member;
	</select>
</mapper>

6. src/test/java 폴더의 controller 패키지에 자바파일들 추가

AbstractTest.java

package com.mysql.controller;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/* 모든 테스트 파일이 상속할 추상클래스
 * - 어노테이션 자동 추가
 * - Logger 
 * */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/**/*.xml"})
public abstract class AbstractTest {

	protected static final Logger logger = 
			LoggerFactory.getLogger(AbstractTest.class);

}

ApplicationContextTest.java

package com.mysql.controller;
/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */

import javax.inject.Inject;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class ApplictationContextTest extends AbstractTest{

	@Inject
	private ApplicationContext ctxt;
	
	
	@Test
	public void test() {
		logger.info(""+ctxt);
		
	}// test()

}// class

DataSourceConnectionTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import static org.junit.Assert.fail;

import java.sql.SQLException;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class DataSourceConnectionTest extends AbstractTest{
	
	@Inject
	private DataSource ds;
	
	@Test
	public void test() throws SQLException {
		logger.info(""+ds.getConnection());
	}// test()

}// class

MemberDAOImplTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import javax.inject.Inject;

import org.junit.Test;
import com.mysql.domain.MemberVO;
import com.mysql.persistence.MemberDAO;

public class MemberDAOImplTest extends AbstractTest{

	@Inject
	private MemberDAO dao;
	
	@Test
	public void test() {
		logger.info(""+dao);
	}
	
	@Test
	public void getTimeTest() {
		logger.info(""+dao.getTime());
	}
	
	@Test
	public void registerTest(){
		MemberVO vo = new MemberVO();
		vo.setUserid("fff");
		vo.setUserpw("cccc");
		vo.setUsername("ejg");
		vo.setEmail("ej@g.com");
		
		// DB에 넣고 DB테이블에서 직접 확인해봐야 한다.
		dao.register(vo);
	}
	
//	@Test
//	public void getTest(){
//		logger.info(""+dao.get("wjheoid"));
//	}
//	
//	@Test
//	public void getListTest(){
//		logger.info(""+dao.getList());
//	}
	
}// class

SqlSessionFactoryBeanTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import javax.inject.Inject;

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

public class SqlSessionFactoryBeanTest extends AbstractTest{

	@Inject
	SqlSessionFactoryBean factoryBean;
	
	@Test
	public void test(){
		logger.info(""+factoryBean);
	}// test()
	
	@Test
	public void sesseionTest(){
		try {
			logger.info(""+factoryBean.getObject().openSession().toString());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}// test()
	
}// class

TimeDAOTest.java

package com.mysql.controller;
/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */

import static org.junit.Assert.fail;

import javax.inject.Inject;

import org.junit.Test;
import com.mysql.persistence.TimeDAO;

public class TimeDAOTest extends AbstractTest{

	@Inject
	private TimeDAO dao;
	
	@Test
	public void test() throws Exception {
		logger.info(""+dao.getTime());
		
	}// test()
}// class

아래와 같이 파일들이 구성되어야 함

이후 MemberDAOImplTest에서 테스트를 하면 db에 값이 저장됨

위에 값들은 vo를 참조하여 만들면 된다.

'스프링 프레임워크 > 스프링 기초' 카테고리의 다른 글

11. 자바 타이머 timeTask 예제 (스케쥴러) (0)	2020.06.30
10. db 시간 timestamp error (0)	2020.03.26
08. JsonArray, JsonObject 만들고 불러오기 (AJAX column 사용) (0)	2019.06.19
07. Json 파싱(parsing) (0)	2019.06.11
06. Mybatis란? (0)	2019.04.22

PREV 이전 1 NEXT 다음

정성환의 IT개발 창고

연동