Spring을 통한 jdbc연결

-- JDBC 연결 하기위한 준비

Maven Repository에서 다운받을 파일.

1. spring jdbc :: 스프링에서 JDBC연결해주는 파일

2. c3p0 :: 커네션 풀 제공해주는 파일

1. 여러결과값을 받는 select문 메서드 :: List query

2. 하나의 값을 받는 select 문 메서드 :: Object queryForObject

3. insert update delete 문 메서드 :: public int update

- Spring - JDBC 예제.

[db.properties]

jdbc.driver=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@localhost:1521:XE
jdbc.username=scott
jdbc.password=tiger

본인의 DB에 맞게 driver, url, username, password를 로그인 할 수 있도록 properties파일로 뺀다.

나중에 다른 DB로 쓰려면 여기 부분에서 수정하면 된다.

[jdbcEx.xml]

<beans>
    <!-- 프로퍼티 파일로부터 데이터를 읽어온다. -->
    <context:property-placeholder
    location="classpath:db.properties" />
 
    <!-- 커넥션 풀을 만들기위한 과정. db.properties에 있는 값을 가져와 EL로 꺼냄 -->
    <bean id="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close">
        <property name="driverClass" value="${jdbc.driver}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
 
    <!-- dataSource는 위의 bean객체를 가져와서 쓴다. -->
    <bean id="jdbcTemplate"
        class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />
 
 
    <!-- jdbcTemplate를 주입받고있는 jdbcDAO클래스로 빈으로 등록. -->
    <bean id="jdbcDAO" class="spring.jdbc.jdbcDAO"
        p:jdbcTemplate-ref="jdbcTemplate" />
</beans>

- 빈 객체의 생성과 소멸시 메서드 호출하기

1. init-method ="생성시 호출할 빈 메서드명" 

2. destory-method = "소멸시 호출할 빈 메서드명" 속성을 가진다.

[UserRowMapper.java]

public class UserRowMapper implements RowMapper<memberDTO>{
 
    public memberDTO mapRow(ResultSet rs, int rowNum) throws SQLException{
        memberDTO member = new memberDTO();
        member.setMemberid(rs.getString("memberid"));
        member.setPassword(rs.getString("password"));
        member.setName(rs.getString("name"));
        member.setEmail(rs.getString("email"));
        
        return member;
    }
}

컬럼명과 같은 변수를 선언한 DTO값에 DB에 저장된 데이터를 ResultSet으로 꺼내와 저장하는 작업.

이부분을 하나의 클래스로 뺀다. RowMapper라는 클래스명으로

[jdbcDAO.java]

public class jdbcDAO {
 
    // JdbcTemplate을 사용하는 DAO클래스 작성.
    JdbcTemplate jdbcTemplate;
 
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    // 메서드 - 쿼리 실행
    public List<memberDTO> selectAll() {
        String sql = "select * from member";
        UserRowMapper mapper = new UserRowMapper();
        // DB에 만든 컬럼과 같은 변수를 가진 클래스에
        // DB에있는 값을 꺼내와서 DTO에 저장한 클래스 객체 생성
 
        List<memberDTO> list = jdbcTemplate.query(sql, mapper);
        // jdbcTemplate에 수행할 쿼리문과, rs문을 실행할 mapper를 매개변수로 넣는다.
        // 기존에 하던 방식과 다른점은, DB에 저장되어있는 값을 꺼내와 DTO에 저장하는 과정을
        // 다른 클래스로 뺐다는점이다.
        return list;
    }
    
    //하나의 결과값을 숫자로 받아오는 문
    public Integer count() {
        Integer count = jdbcTemplate.queryForObject("select count(*) from member", Integer.class);
        return count;
    }
    
    //select-one
    //insert
    //update
    //delete
    
    //하나의 셀렉트결과값을 받아오는 문
    public Object selectOne() {
        UserRowMapper mapper = new UserRowMapper();
        Object[] id = {"seypark"};
        Object select = jdbcTemplate.queryForObject("select * from member where memberid = ?", id, mapper);
        return select;
    }
    
    //insert문
    public int insert() {
        String sql = "insert into member values(?,?,?,?)";
        Object[] insert = {"scott","tiger","1234","scott@tiger.com"};
        int a = jdbcTemplate.update(sql, insert);
        return a;
    }
    
    //update문
    public int  update() {
        String sql = "update member set password = ?, name = ? where memberid = ?";
        Object[] update = {"4444","토끼","scott"};
        int a= jdbcTemplate.update(sql, update);
        return a;
    }
    
    //delete
    public int delete() {
        String sql = "delete from member where memberid = ?";
        Object[] delete = {"scott"};
        int a = jdbcTemplate.update(sql, delete);
        return a;
    }

[Main.java]

public class Main {
 
    public static void main(String[] args) {
        ApplicationContext context = new GenericXmlApplicationContext("jdbcEx.xml");
        
        jdbcDAO dao = context.getBean("jdbcDAO", jdbcDAO.class);
 
//        if(dao.insert() == 1) {
//            System.out.println("insert 성공");
//        }else {
//            System.out.println("insert 실패");
//        }
//        
//        if(dao.update() == 1) {
//            System.out.println("update 성공");
//        }else {
//            System.out.println("update 실패");
//        }
//        if(dao.delete() == 1) {
//            System.out.println("delete 성공");
//        }else {
//            System.out.println("delete 실패");
//        }
//        
//        Object member_count = dao.count();
//        System.out.println("member_count : " + member_count);
//        
//        Object member1 = dao.selectOne();
//        System.out.println("select One : " + member1);
//        
        List<memberDTO> mem = dao.selectAll();
        
        for(memberDTO member : mem) {
            System.out.println(member+"\n");
        }
 
        System.out.println("END!!");
    }
}

결과 ::

DB에 저장되어있는 값을 꺼내서 DTO에 저장하는 과정은 기존에 하던 jdbc방식과 똑같지만,

그것을 다른 클래스영역으로 빼서 분리 해놨다는것이 가장 큰 차이점이다.

지금까지 DAO를 만들때마다 Statement / PrepareStatement한 후

'rs.getXxxx 를 반복하던 작업'을 따로빼서 객체화한후 간편하게 사용할 수 있는 장점이 있다.

아마도 저 rs.get하는 방법도 나중에 더 쉬운방법으로 뺄 수 있는 방법이 있을것이다.