정성환의 IT개발 창고

스프링 프레임워크에서 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를 참조하여 만들면 된다.

앞서 만들었던 게시판 리스트이다. (현재는 글쓰기 안됨)

백단의 DAO, VO, Service, Controller와 프론트단의 list.jsp가 어떻게 유기적으로 소통하는지 살펴본다.

"<-----화살표로 끊어지는 로직을 설명해놓았다.

여기 코딩 들은 단순 설명용 코딩이니 복붙해서 실행해도 안먹는다.

1-1. Controller // 리퀘스트 맵핑

주소창에 localhost:8080/list라고 입력하면 디스패처가 컨트롤러로 전달해준다.

Bcontroller에서 일련의 과정을 처리한다.

Bcontroller.java

@RequestMapping("/list")

public String list(Model model) {

cmd = new ListCmd(); <-------여기서 Service 클래스를 참조한다.

/*
cmd.service(model); 

return "list";



}
*/

2-1. Service //  DAO 참조

ListCmd는 Bcmd 인터페이스를 참조하지만 Bcmd 없이 ListCmd로 만들어줘도 된다. 

ListCmd.java

public class ListCmd implements Bcmd {

	@Override
	public void service(Model model) {
		
		BDAO dao =new BDAO(); <------------여기서 DAO클래스를 참조한다.
      	
        
/*        
        
        ArrayList<BVO> bVOs = dao.list(); 

		model.addAttribute("list", bVOs);
	}

}
*/

3-1. DAO // JNDI 네이밍을 이용하여 오라클 Lookup

실재로 SQL문을 데이터베이스에서 실행시키게끔 하는 클래스이다. 객체는 VO에서 참조한다.

BDAO.java

public class BDAO {
	DataSource dataSource; //데이타소스를 가져오는 구문
	
	//생성자
	public BDAO() {
		//JNDI 를 사용한다. JNDI란 자바에서 객체를 네이밍 서비스에 등록, 삭제, 검색을 할 수 있는 방법
		
		try{
			
			Context ctx = new InitialContext(); //JNDI 네이밍 서비스 컴파일해줌
			dataSource = (DataSource)ctx.lookup("java:comp/env/jdbc/Oracle11g");
			//lookup으로 데이타소스의 객체를 얻어온다. java:comp/env/는 기본이며 그뒤의 이름은 톰캣서버 context.xml의 name을 참조한다.
			
	} catch(NamingException e) {
		e.printStackTrace();
	}
		
}

	public ArrayList<BVO> list() {
		//DB에 있는 글목록들을 가져오는 역할 형식은 ArrayList이고 BVO타입. 칼럼정보가 BVO에 있다.
		
		ArrayList<BVO> bVOs = new ArrayList<BVO>(); <-------여기서 VO를 참조하여 ArrayList 객체를 만든다.
		
/*        
		//////연결을 위한 3구문/////
		Connection connection = null; //커넥션 javax
		PreparedStatement preparedStatement = null; //프리패어드 스테이트먼트 javax		
		ResultSet resultSet = null;  //데이터를 가져오는 기능의 리절트셋 javax
		//////////////
		
		
		try {
		connection = dataSource.getConnection();
		
		//쿼리문을 만들어줌
		String sql = "select bNo, bName, bSubject, bContent, bDate, bHit, bGroup, bStep, bIndent from mvc_bbs"
					+ " order by bGroup desc, bStep asc";
		
		preparedStatement = connection.prepareStatement(sql); //preparedStatement에 전송
		
		resultSet = preparedStatement.executeQuery(); //result값 데이터를 가져오는 것
		
		while(resultSet.next()) {
			//Resultset 다음행에 데이터가 있으면 while 문으로 반복 작업을 함		
			
			//vo의 9인자를 참조해서 작성
			int bNo = resultSet.getInt("bNo");
			String bName = resultSet.getString("bName");
			String bSubject = resultSet.getString("bSubject");
			String bContent = resultSet.getString("bContent");
			Timestamp bDate = resultSet.getTimestamp("bDate");
			
			int bHit = resultSet.getInt("bHit");
			int bGroup = resultSet.getInt("bgroup");
			int bStep = resultSet.getInt("bStep");
			int bIndent = resultSet.getInt("bIndent");
			///////
			
			//인자생성자
			BVO bVO = new BVO(bNo, bName, bSubject, bContent, bDate, bHit, bGroup, bStep, bIndent); <--여기서도 VO 참조
			
			bVOs.add(bVO); //bVOs라는 어레이에 bVO 추가함
		}
				
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			
			//finally 안에 있는 구문
			try {
				//null이면 구문들을 다 안쓰는 것
				if(resultSet !=null) resultSet.close();
				if(preparedStatement != null) preparedStatement.close();
				if(connection != null) connection.close();
				
			} catch (Exception e2) {	
				e2.printStackTrace();
			}
	
		}
		
		return bVOs;	
	}
	
}
*/

4-1. VO // 변수 선언

DAO에서 최초로 VO를 불러내었다. VO에서는 따로 참조하는 클래스가 없다.

VO에서는 순수하게 변수선언, 인자생성, setter/getter만 만들어준다.

따라서 코딩할때 가장 먼저 작성되어야할 클래스이기도 하다.

BVO.java

public class BVO {
	
	//db에서의 인덱스를 변수로 지정해준다. 각자의 형식에 맞춰서 형식을 지정해준다.
	//VO클래스는 변수선언, 인자생성자, setter getter 이렇게 3개로 나뉜다.
	
	//1.변수 선언
	int bNo;
	String bName;
	String bSubject;
	String bContent;
	Timestamp bDate;  //timestamp는 sql에서 불러오면됨
	int bHit;
	int bGroup;
	int bStep;
	int bIndent;
	
//	public BVO() {
//		
//	}
	
	
	//2.인자생성자
	public BVO(int bNo, String bName, String bSubject, String bContent, Timestamp bDate, int bHit, int bGroup, int bStep, int bIndent) {
		this.bNo = bNo;
		this.bName = bName;
		this.bSubject = bSubject;
		this.bContent = bContent;
		this.bDate = bDate;
		this.bHit = bHit;
		this.bGroup = bGroup;
		this.bStep = bStep;
		this.bIndent = bIndent;
	}
	
	
	//3.setter getter
	public int getbNo() {
		return bNo;
	}

	public void setbNo(int bNo) {
		this.bNo = bNo;
	}

	public String getbName() {
		return bName;
	}

	public void setbName(String bName) {
		this.bName = bName;
	}

	public String getbSubject() {
		return bSubject;
	}

	public void setbSubject(String bSubject) {
		this.bSubject = bSubject;
	}

	public String getbContent() {
		return bContent;
	}

	public void setbContent(String bContent) {
		this.bContent = bContent;
	}

	public Timestamp getbDate() {
		return bDate;
	}

	public void setbDate(Timestamp bDate) {
		this.bDate = bDate;
	}

	public int getbHit() {
		return bHit;
	}

	public void setbHit(int bHit) {
		this.bHit = bHit;
	}

	public int getbGroup() {
		return bGroup;
	}

	public void setbGroup(int bGroup) {
		this.bGroup = bGroup;
	}

	public int getbStep() {
		return bStep;
	}

	public void setbStep(int bStep) {
		this.bStep = bStep;
	}

	public int getbIndent() {
		return bIndent;
	}

	public void setbIndent(int bIndent) {
		this.bIndent = bIndent;
	}
	
}

간단히 "VO > DAO > Service > 컨트롤러"  이 순서대로 불러와진다고 보면된다.

다시 3. DAO로 거슬러 돌아간다.

3-2. DAO // 남은 부분처리

남은 부분을 처리 해주고 끝부분에서는 bVOs ArrayList를 리턴해준다.

BDAO.java

public class BDAO {
	/*DataSource dataSource; //데이타소스를 가져오는 구문
	
	//생성자
	public BDAO() {
		//JNDI 를 사용한다. JNDI란 자바에서 객체를 네이밍 서비스에 등록, 삭제, 검색을 할 수 있는 방법
		
		try{
			
			Context ctx = new InitialContext(); //JNDI 네이밍 서비스 컴파일해줌
			dataSource = (DataSource)ctx.lookup("java:comp/env/jdbc/Oracle11g");
			//lookup으로 데이타소스의 객체를 얻어온다. java:comp/env/는 기본이며 그뒤의 이름은 톰캣서버 context.xml의 name을 참조한다.
			
	} catch(NamingException e) {
		e.printStackTrace();
	}
		
}

	public ArrayList<BVO> list() {
		//DB에 있는 글목록들을 가져오는 역할 형식은 ArrayList이고 BVO타입. 칼럼정보가 BVO에 있다.
		
		ArrayList<BVO> bVOs = new ArrayList<BVO>(); <-------여기서 VO를 참조하여 ArrayList 객체를 만든다.
		*/
        
		//////연결을 위한 3구문/////
		Connection connection = null; //커넥션 javax
		PreparedStatement preparedStatement = null; //프리패어드 스테이트먼트 javax		
		ResultSet resultSet = null;  //데이터를 가져오는 기능의 리절트셋 javax
		//////////////
		
		
		try {
		connection = dataSource.getConnection();
		
		//쿼리문을 만들어줌
		String sql = "select bNo, bName, bSubject, bContent, bDate, bHit, bGroup, bStep, bIndent from mvc_bbs"
					+ " order by bGroup desc, bStep asc";
		
		preparedStatement = connection.prepareStatement(sql); //preparedStatement에 전송
		
		resultSet = preparedStatement.executeQuery(); //result값 데이터를 가져오는 것
		
		while(resultSet.next()) {
			//Resultset 다음행에 데이터가 있으면 while 문으로 반복 작업을 함		
			
			//vo의 9인자를 참조해서 작성
			int bNo = resultSet.getInt("bNo");
			String bName = resultSet.getString("bName");
			String bSubject = resultSet.getString("bSubject");
			String bContent = resultSet.getString("bContent");
			Timestamp bDate = resultSet.getTimestamp("bDate");
			
			int bHit = resultSet.getInt("bHit");
			int bGroup = resultSet.getInt("bgroup");
			int bStep = resultSet.getInt("bStep");
			int bIndent = resultSet.getInt("bIndent");
			///////
			
			//인자생성자
			BVO bVO = new BVO(bNo, bName, bSubject, bContent, bDate, bHit, bGroup, bStep, bIndent); <--여기서도 VO 참조
			
			bVOs.add(bVO); //bVOs라는 어레이에 bVO 추가함
		}
				
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			
			//finally 안에 있는 구문
			try {
				//null이면 구문들을 다 안쓰는 것
				if(resultSet !=null) resultSet.close();
				if(preparedStatement != null) preparedStatement.close();
				if(connection != null) connection.close();
				
			} catch (Exception e2) {	
				e2.printStackTrace();
			}
	
		}
		
		return bVOs; <----list()메소드 끝부분에서는 bVOs ArrayList를 리턴해준다.
	}
	
}

다시 2. Service로 거슬러 올아간다.

2-2. Service //

dao.list()에서 Return시킨 bVOs를 cmd의 bVOS에도 저장 시킨다.

그리고 이 bVOS를 "list"란 이름의 모델명에 적용시킨다.

ListCmd.java

public class ListCmd implements Bcmd {
/*
	@Override
	public void service(Model model) {
		
		BDAO dao =new BDAO(); <------------여기서 DAO클래스를 참조한다.
 */     	
       
        
        ArrayList<BVO> bVOs = dao.list(); <---list()에서 리턴된 bVOs를 bVOs에 저장

		model.addAttribute("list", bVOs);
	}

}

적용시킨 모델명 "list"는 컨트롤러를 통해서 list.jsp로 값을 보내주게된다. (또는 불러오게)

그리고 public void service(Model model)에서 model이 아닌 이름을 내가 아무렇게나 지정해도 된다.

한국의 주입식 교육의 폐해 중 하나가 이건 vo로 써야하고, 이건 model로 써야하고 이건 dao로 써야 하는 것으로 알고 가르치는 것이다.

편의상 그렇게 쓰는 것이지 소문자로 시작하는 것은 내가 정한 변수이므로 아무렇게나 지정해줘도 된다.

이른바 아래처럼

 ListCmd.java

public class ListCmd implements Bcmd {

	@Override
	public void service(Model abcdefg) {
		
		BDAO dddddddd=new BDAO(); <------------여기서 DAO클래스를 참조한다.
    	
       
        
        ArrayList<BVO> qwerqwer = dddddddd.list(); <---list()에서 리턴된 bVOs를 bVOs에 저장

		abcdefg.addAttribute("list", qwerqwer);
	}

}

극단적인 예로 이렇게 한것이다. 복사 붙혀넣기만 하지말고 이렇게 변수를 이거저거 바꾸어 적용해보고 하면 온전히 나의 것으로 만들 수 있다.

ListCmd 클래스에서는 이렇게 모델을 지정해주는 것으로 끝났고, 이제 Back단 중 마지막으로  1. Controller로 올라가보자.

1-2. Controller // 뷰페이지로 이동

cmd= new ListCmd()로 서비스를 가져와서 cmd에 저장해주었다.

하지만 거기서 끝이 아니라 cmd안의 service()메소드를 실행시켜줘야 작동한다.

service(model)의 model은 물론 변수이기 때문에 아무렇게나 지정해줘도 된다.

@RequestMapping("/list")
public String list(Model model) {
/*
cmd = new ListCmd(); <-------여기서 Service 클래스를 참조한다.
*/

cmd.service(model); <-------ListCmd의 service()메소드를 실행시킨다.

return "list"; <-------list.jsp를 사용자에게 보여준다.



}

list로 리턴하였으므로 list.jsp로 넘어간다.

5. 뷰페이지 // list.jsp

여기서는 다른 내용은 볼것없고 <Table>태그 안의 내용만 보면 된다.

태그라이브러리를 이용할 것이므로 맨 윗부분에 <%@ taglib prefix = "c" uri="http://java.sun.com/jsp/jstl/core" %>를 붙여주었다.

<c:forEach items="${list}" var="vo">

</c:forEach>

구문을 통하여 아까 모델로 지정해주었던 "list"를 불러온다.

이 list라는 모델에는 bNo, bSubject 등의 행들이 리스트형태로 저장되어 있다.

forEach라는 이름에 걸맞게 태그안에서 각각의 행들을 모두 불러와준다.

그리고 ${vo.bNO} 등을 통하여 그 모델값을 불러올 수 있다.

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <% request.setCharacterEncoding("utf-8"); %>
<%@ taglib prefix = "c" uri="http://java.sun.com/jsp/jstl/core" %>
    
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" http-equiv="Content-Type" content="text/html;">
<title>게시판 리스트</title>
</head>
<body>

<div align="center">
	<h2>게시판 글목록</h2>
	<hr width="400" color="red" />
	
	<table border="1" cellpadding="0" cellspacing="0" width="500">
		<tr>
			<td>번호</td>
			<td>제목</td>
			<td>작성자</td>
			<td>날짜</td>
			<td>조회수</td>
		</tr>
 
				<!-- 게시글 목록 가져오기 -->
		<c:forEach items="${list}" var="vo">	
		<!-- ListCmd에서 만들었던 모델 list를 컨트롤러를 통해 받아온다.-->
		<tr>
			<td>${vo.bNo}</td>
			<td>${vo.bSubject}</td>
			<td>${vo.bName}</td>
			<td>${vo.bDate}</td>
			<td>${vo.bHit}</td>
		</tr>
		</c:forEach>
		<tr>
			<td colspan="5" align="center"><a href="writeForm">글쓰기</a></td>
		</tr>
		
	</table>
    
   
</div>
<div>
</div>

</body>
</html>

다음 포스팅에선 글쓰기 기능을 추가해본다.