[Spring] 스프링, MySQL, MyBatis 연동 - 데이터 조회하기

저번 포스팅에서는 단순히 스프링, MySQL, MyBatis 연동을 했었다. 이번에는 DB에 있는 데이터를 화면에서 조회하는 것을 구현할 것이다.

구현할 예제의 전체적인 구조는 위와 같다. 스프링 MVC의 구조로 DAO(데이터 처리를 담당)에서 Mybatis를 호출하고, 여기서 처리된 데이터를 VO(데이터를 전달하는 역할) 객체에 담아 Service, Controller 을 거쳐 화면으로 보내게 된다.

• View : 화면

• Controller : 화면에서 요청한 URL을 매핑

• Service : 비즈니스 로직, 기능적인 부분을 구현하는 곳

• DAO : 데이터 처리를 담당, 하나의 DAO는 하나의 테이블과 연결되어 데이터 처리를 한다.

1. 기본 설정

프로젝트 생성 및 설정과 스프링, MySQL, MyBatis 연동에 대한 기본적인 정보는 지난 포스팅을 참고하면 된다.

■ 관련글

• [Spring] 스프링 개발환경 설정

• [Spring] 스프링, MySQL, MyBatis 연동

프로젝트 생성 후 pom.xml을 수정한다. 스프링과 자바의 버전을 수정하고 각종 라이브러리 dependency를 추가한다.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sample</groupId>
    <artifactId>mybatis</artifactId>
    <name>Spring_EX_01</name>
    <packaging>war</packaging>
    <version>1.0.0-BUILD-SNAPSHOT</version>
    <properties>
        <java-version>1.8</java-version>
        <org.springframework-version>4.3.3.RELEASE</org.springframework-version>
        <org.aspectj-version>1.6.10</org.aspectj-version>
        <org.slf4j-version>1.6.6</org.slf4j-version>
    </properties>
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework-version}</version>
            <exclusions>
                <!-- Exclude Commons Logging in favor of SLF4j -->
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
 
        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${org.aspectj-version}</version>
        </dependency>
 
        <!-- Logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${org.slf4j-version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.15</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.mail</groupId>
                    <artifactId>mail</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.jms</groupId>
                    <artifactId>jms</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jdmk</groupId>
                    <artifactId>jmxtools</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jmx</groupId>
                    <artifactId>jmxri</artifactId>
                </exclusion>
            </exclusions>
            <scope>runtime</scope>
        </dependency>
 
        <!-- @Inject -->
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>
 
        <!-- Servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
 
        <!-- Test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
 
 
        <!-- MySQL -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.5</version>
        </dependency>
 
        <!-- MyBatis 3.4.1 -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.1</version>
        </dependency>
 
 
        <!-- MyBatis-Spring -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
 
        <!-- Spring-jdbc -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
 
        <!-- Spring-test -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
 
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
                <configuration>
                    <additionalProjectnatures>
                        <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
                    </additionalProjectnatures>
                    <additionalBuildcommands>
                        <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
                    </additionalBuildcommands>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArgument>-Xlint:all</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>org.test.int1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
 

다음으로 root-context.xml을 수정한다. 지난 포스팅의 스프링, MySQL, MyBatis 연동과는 소스 코드가 달라졌다.

MySQL DataSource 부분에서는 로그를 확인하기 위해 property를 변경했다. 가끔 SQL이 잘못되어 에러가 발생하는 경우가 있는데, 이를 대비해 좀 더 자세히 로그를 조사할 수 있도록 로그 설정을 변경하였다. 

Mybatis SqlSessionFactoryBean 에서는 Mybatis 설정 기능을 활용할 수 있도록 설정 파일을 읽어오는 부분과 SQL 문을 작성해둘 mapper.xml 파일을 읽어오는 부분을 추가했다. 

다음으로 SqlSessionTemplate 부분이 있는데, SqlSessionTemplate는 기본적인 트랜잭션 관리나 쓰레드 처리의 안정성 등을 보장하고, DB의 연결과 종료를 관리하는 부분이다. SqlSessionTemplate을 등록해두면 개발자가 직접 트랜잭션 관리나 DB 연결, 종료를 해야 하는 작업을 줄일 수 있다.

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
    xsi:schemaLocation="http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.3.xsd
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
        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.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    
    <!-- Root Context: defines shared resources visible to all other web components -->
    
    <!-- MySQL 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/test_db01?useSSL=false&amp;serverTimezone=UTC"></property>
        <property name="username" value="scott"></property>
        <property name="password" value="tiger"></property>
    </bean>
 
    <!-- mybatis SqlSessionFactoryBean -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:/mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:mappers/**/*Mapper.xml"></property>
    </bean>
    
        <!-- mybatis      -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"
        destroy-method="clearCache">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"></constructor-arg>
    </bean>
 
</beans>
 

2. 테이블 생성

테스트를 위한 테이블을 생성하고 데이터를 입력한다.

-- 테이블
CREATE TABLE `test`(  
      `id` VARCHAR(10) NOT NULL,
      `pw` VARCHAR(10),
      `name` VARCHAR(10),
    PRIMARY KEY (`id`)
);
 
 
-- 데이터
INSERT INTO TEST(id, pw, NAME) VALUES ( 'id1', 'pw1', 'name1');
INSERT INTO TEST(id, pw, NAME) VALUES ( 'id2', 'pw2', 'name2');
INSERT INTO TEST(id, pw, NAME) VALUES ( 'id3', 'pw3', 'name3');

3. MyBatis 로그를 위한 작업

root-context.xml에 MySQL DataSource 부분에 로그에 관한 부분이 있었다. 로그를 보기 위해서는 이후 별도의 작업을 해야 한다.

먼저 pom.xml 을 열어 log4jdbc-log4j2 라이브러리를 추가한다.

        <!-- Mybatis log -->
        <!-- https://mvnrepository.com/artifact/org.bgee.log4jdbc-log4j2/log4jdbc-log4j2-jdbc4.1 -->
        <dependency>
            <groupId>org.bgee.log4jdbc-log4j2</groupId>
            <artifactId>log4jdbc-log4j2-jdbc4</artifactId>
            <version>1.16</version>
        </dependency>

다음으로 src/main/resources 아래에 log4jdbc.log4j2.properties 와 logback.xml 파일을 생성한다. 

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

<?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>

그리고 log4j.xml 파일을 열어 위의 표시한 부분의 값을 "info" 로 변경해준다. 

로그를 설정한 뒤 나중에 프로젝트를 실행하게 되면 위와 같이 쿼리와 쿼리의 결과가 로그에 나타난다.

4. MyBatis 설정 파일 및 mapper.xml 파일 추가

다음으로 MyBatis 설정 파일 및 mapper.xml 파일을 추가하자. 설정 파일인 mybatis-config.xml는 src/main/resources 아래에 추가하고, mapper.xml 은 mappers 라는 폴더를 만들어 그 안에 추가를 한다.

<?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>
    

mybatis-config.xml 에는 현재 아무것도 없는 상태이다. 여기에는 추후 <typeAliases> 태그를 통해 VO 클래스를 등록해 둘 것이다. 이렇게 등록을 하면 mapper.xml 에서 VO 클래스를 mybatis-config.xml 등록한 이름으로 사용할 수 있다.

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

***Mapper.xml은 쿼리문을 입력하는 것이다. 보통 테이블당 1개의 mapper.xml을 작성한다. 지금은 <mapper> 태그에 namespace만 입력해 둔다. 

5. VO, DAO 작성

다음으로 할 일은 VO, DAO 클래스를 만드는 것이다. VO는 DB에서 가져온 데이터를 담아 전달하거나, 화면에서 온 데이터를 DB로 전달해주는 역할을 하는 클래스이다.

DAO는 테이블과 연결되어 데이터 처리를 담당한다.

com.example.dao 와 com.example.vo 패키지를 만들어 인터페이스와 클래스를 작성한다.

package com.example.dto;
 
public class MemberVO {
 
    private String id;
    private String pw;
    private String name;
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getPw() {
        return pw;
    }
 
    public void setPw(String pw) {
        this.pw = pw;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
}
 

MemberVO는 테이블의 칼럼에 해당하는 변수를 만들어준다. 그리고 위 처럼 값을 넣거나 가져올 수 있도록 Setter/Getter 메서드를 만든다.

package com.example.dao;
 
import java.util.List;
 
import com.example.dto.MemberVO;
 
public interface MemberDAO {
    
    public List<MemberVO> selectMember() throws Exception;
}
 

우선 MemberDAO 인터페이스만 작성한다. MemberDAO 의 구현 클래스인 MemberDAOImpl을 작성하기 전에 mybatis-config.xml 에 설정과 memberMapper.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>
    
        <typeAliases>
            <typeAlias type="com.example.dto.MemberVO" alias="memberVO"/>
        </typeAliases>
        
    </configuration>

mybatis-config.xml를 보면 <typeAliases> 안에 <typeAlias type="com.example.dto.MemberVO" alias="memberVO"/> 로 되어있다. 이는 memberMapper.xml에서 MemberVO 클래스를 alias 부분에  지정한 이름인 memberVO로 사용하기 위해서이다.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 
<mapper namespace="com.example.mapper.memberMapper">
 
    <!-- 
        mybatis-config.xml의 typeAlias에 등록해두지 않았다면 
        
        <select id="selectMember" resultType="com.example.dto.MemberVO" >
            SELECT ID, PW ,NAME FROM TEST
        </select>
        
        이렇게 해야 한다.
    -->
    
    <select id="selectMember" resultType="memberVO">
        SELECT ID, PW ,NAME FROM TEST
    </select>
    
</mapper>

mapper에는 테이블에서 데이터를 조회하기 위한 쿼리를 작성한다. 조회를 위한 쿼리는 <select></select> 태그 안에 작성한다. 

<select id="selectMember" resultType="memberVO">

태그를 보면 id 와 resultType 이 있다. id는 나중에 DAO에서 사용하기 위해 필요한 값이고, resultType은 쿼리 실행 후 데이터를 memberVO에 담겠다고 설정한 것이다.

다음으로 MemberDAOImpl을 작성한다.

package com.example.dao;
 
import java.util.List;
 
import javax.inject.Inject;
 
import org.apache.ibatis.session.SqlSession;
import org.springframework.stereotype.Repository;
 
import com.example.dto.MemberVO;
 
@Repository
public class MemberDAOImpl implements MemberDAO {
 
    @Inject
    private SqlSession sqlSession;
    
    private static final String Namespace = "com.example.mapper.memberMapper";
    
    @Override
    public List<MemberVO> selectMember() throws Exception {
 
        return sqlSession.selectList(Namespace+".selectMember");
    }
 
}
 

MemberDAOImpl 은 SqlSession을 주입받아서 memberMapper.xml 에 등록한 쿼리문을 실행한다. 쿼리 실행 결과 여러개의 데이터를 가져오게 되므로 List로 받아서 리턴한다.

MemberDAOImpl 작성 후 Bean 등록을 해야 한다. 빈 등록을 하기 위해 root-context.xml을 연다.

MemberDAOImpl에 @Repository 어노테이션이 설정되어있더라도 스프링에서 해당 패키지를 스캔하지 않으면 스피링 빈으로 등록되지 않는다. 그렇기에 root-context.xml 에 빈 등록을 해야 한다. 

 
<context:component-scan base-package="com.example.dao"></context:component-scan>
 

6. Service 작성

DAO의 구현이 끝났으면 Service를 구현한다. Service는 비즈니스 로직이 들어가는 부분인데 예제는 단순히 데이터를 조회하는 간단한 코드이므로 Service가 별다른 의미가 없다.

그래도 전체 구조를 알기위해 작성을 해보는것이 좋다.

Service도 DAO와 마찬가지로 패키지 생성 후 인터페이스와 구현 클래스를 작성한다. 

package com.example.service;
 
import java.util.List;
 
import com.example.dto.MemberVO;
 
public interface MemberService {
    
    public List<MemberVO> selectMember() throws Exception;
}
 

package com.example.service;
 
import java.util.List;
 
import javax.inject.Inject;
 
import org.springframework.stereotype.Service;
 
import com.example.dao.MemberDAO;
import com.example.dto.MemberVO;
 
@Service
public class MemberServiceImpl implements MemberService {
 
    @Inject
    private MemberDAO dao;
    
    @Override
    public List<MemberVO> selectMember() throws Exception {
 
        return dao.selectMember();
    }
 
}
 

Service도 DAO와 마찬가지로 빈 등록을 해야 한다. root-context.xml에 코드를 추가한다.

 
<context:component-scan base-package="com.example.service"></context:component-scan>
 

7. Controller 작성

다음으로 화면에서 요청된 URL을 처리할 Controller를 작성해야 한다. 

package com.example.controller;
 
import java.util.List;
import java.util.Locale;
 
import javax.inject.Inject;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
 
import com.example.dto.MemberVO;
import com.example.service.MemberService;
 
/**
 * Handles requests for the application home page.
 */
@Controller
public class HomeController {
    
    private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
    
    @Inject
    private MemberService service;
    
    /**
     * Simply selects the home view to render by returning its name.
     */
    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String home(Locale locale, Model model) throws Exception{
 
        logger.info("home");
        
        List<MemberVO> memberList = service.selectMember();
        
        model.addAttribute("memberList", memberList);
 
        return "home";
    }
    
}
 

프로젝트 생성시 만들어진 HomeController의 코드를 위와 같이 수정한다.  HomeController에서는 MemberService를 주입받아 데이터를 가져온다. 가져온 데이터는 Model에 담아서 화면으로 전달한다.

여기까지 작성을 했으면 화면을 작성하면 된다. 그전에 Tomcat의 설정을 변경해야 한다.

현재 프로젝트의 URL 설정 보면 /controller 로 되어있는데 이것을 변경해야 한다.

/controller을 / 로 변경해준다. / 로 변경을 해야 프로젝트를 실행하면 http://localhost:8080 의 주소가 나타나고 정상적으로 프로젝트가 실행되게 된다.

8. View 작성 - home.jsp 작성

마지막으로 데이터를 보여줄 화면을 작성한다. HomeController 에서 memberList란 이름으로 List 형식의 데이터를 전달했다. 그것을 home.jsp 에서는 <c:forEach> 를 이용해 화면에 출력한다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
<title>Home</title>
</head>
<body>
    <h1>Hello world!</h1>
 
    <table>
        <thead>
            <tr>
                <th>아이디</th>
                <th>비밀번호</th>
                <th>이름</th>
            </tr>
        </thead>
        <tbody>
            <c:forEach items="${memberList}" var="member">
                <tr>
                    <td>${member.id}</td>
                    <td>${member.pw}</td>
                    <td>${member.name}</td>
                </tr>
            </c:forEach>
        </tbody>
    </table>
 
 
</body>
</html>
 

톰캣을 Start 한 후 브라우저 주소창에  http://localhost:8080를 입력하면 실행 결과가 나타난다.

이것으로 스프링, MySQL, MyBatis 연동 후 데이터 조회하는 과정이 끝이 났다. 

소스 코드 다운로드

Spring_EX_02.zip

코드를 실행하기 전 root-context.xml 에 MySQL dataSource  부분을 수정해야 한다. 

설치한 MySQL의 IP주소(로컬이라면 127.0.0.1), 계정, 비밀번호를 변경하고 실행하면 된다.