반응형
스프링 프레임워크에서 myBatis사용하여 mySQL db연동하는 방법
결론적으로 아래와 같이 파일구성이 되야한다.
예제파일-----
--------
그럼 차근차근 진행해본다.
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 |