[Spring]Spring JDBC

DTO(Data Transfer Object)

- Data Transfer Object

- 계층간 데이터 교환을 위한 자바빈즈이다.

- 여기서 계층이란 컨틀롤러 뷰, 비지니스 계층, 퍼시스턴스 계층을 의미한다.

- 일반적으로 DTO는 로직을 가지고 있지 않고, 순수한 데이터 객체이다.

- 필드와 getter, setter 등을 가진다. 추가적으로 toString(), equals() 등의 오브젝트 메서드를 오버라이딩 할 수도 있다.

 

 

DAO(Data Acces Object)

- Data Acces Object

- 데이터를 조회하거나 조작하는 기능을 전담하는 객체

- 보통 데이터베이스를 조작하는 기능을 전담하는 목적으로 만들어진다.

 

 

ConnectionPool

- DB연결에 비용(프로그램이 DBMS에 접속하는데 걸리는 비용)이 많이 발생한다.

- 이를 해결하기 위해 DBMS와 커넥션을 미리 많이 맺어둔 객체를 사용하는 것을 ConnectionPool 이라고 한다.

- 커넥션이 필요하면 커넥션 풀에게 빌려서 사용한 후 반납한다.

 

- 커넥션 풀을 사용할 때는, 커넥션을 되도록 빨리 사용하고 빨리 반납해야 한다.

- 커넥션 풀은 경우에 따라 여러 개가 생성 될 수 있는데, 그러한 커넥션 풀을 관리하는 목적으로 사용되는 것을 DataSource이다.

- 커넥션을 얻어오고 반납하는 등의 작업을 수행한다. ex) close() 메서드 - 반납

 

 

 

 

JDBC 실습

 

DB 접속하기

Maven 프로젝트 → Archetype : maven-archetype-quickstart → 프로젝트명 : daoexam

각 클래스 역할별로 패키지 나누기 습관화!

 

*pom.xml

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>kr.or.connect</groupId>
    <artifactId>daoexam</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <name>daoexam</name>
    <url>http://maven.apache.org</url>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.3.5.RELEASE</spring.version>
    </properties>
 
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <!-- basic data source 데이터소스 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.1.1</version>
        </dependency>
 
        <!-- mysql에서 쓰일 드라이버 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.45</version>
        </dependency>
 
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
 
</project>

 

*ApplicationConfig.java

- ApplicationContext한테 어떤 설정들을 읽어들여서 공장을 만들어 주는 클래스

package kr.or.connect.daoexam.config;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
 
@Configuration
@Import({DBConfig.class})//설정 파일이 여러개 있다면 이 어노테이션으로 연결, 우리는 DBConfig를 연결함
public class ApplicationConfig {
 
}

 

*DBconfig

- DB에 관련된 설정들은 DBconfig에 다 구현할 예정

package kr.or.connect.daoexam.config;
 
import javax.sql.DataSource;
 
import org.apache.commons.dbcp2.BasicDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
@Configuration
@EnableTransactionManagement //트랙젝션에 쓰일 어노테이션
public class DBConfig {
    private String driverClassName = "com.mysql.jdbc.Driver";
    private String url = "jdbc:mysql://localhost:3306/connectdb?useUnicode=true&characterEncoding=utf8";
 
    private String username = "connectuser";
    private String password = "connect123!@#";
    
    //DataSource를 생성할 수 있는 객체
    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

 

*DataSourceTest.java

package kr.or.connect.daoexam.main;
 
import java.sql.Connection;
 
import javax.sql.DataSource;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import kr.or.connect.daoexam.config.ApplicationConfig;
 
//데이터 소스 잘 불러지는지 테스트하는 클래스
public class DataSourceTest {
 
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);// DataConfig가 임포트 되어있는 ApplicationConfig 가져오기
        
        DataSource ds = ac.getBean(DataSource.class);
 
        // 커넥션을 잘 가져오는지 확인
        Connection conn = null;
        try {
            conn = ds.getConnection();
            if (conn != null)
                System.out.println("접속 성공^^");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
}
 

 

- "접속 성공^^" 이 콘솔창에 뜨면 성공.

 

 

Select 해오기

1. DTO 만들기(RoleDto)

2. 쿼리문 필요, 쿼리문을 가지고 있는 클래스 만들기(RoleDaoSqls)

3. 데이터에 접근(Access)하는 객체(DAO) 만들기(RoleDao)

- NamedParameterJdbcTemplate

- SimpleJdbcInsert

 

 

- DTO 만들기

*Role.java

package kr.or.connect.daoexam.dto;
 
public class Role {
    private int roleId;
    private String description;
    
    public int getRoleId() {
        return roleId;
    }
    public void setRoleId(int roleId) {
        this.roleId = roleId;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    
    @Override
    public String toString() {//프로그래밍 할 때 객체가 잘 전달되는지 확인하는 역할, 해두면 유용하다
        return "Role [roleID=" + roleId + ", description=" + description + "]";
    }
}

 

 

*RoleDaoSqls.java

package kr.or.connect.daoexam.dao;
 
//여기서 사용하고자 하는 쿼리들을 상수형태로 사용하면 된다.
public class RoleDaoSqls {
    public static final String SELECT_ALL = "SELECT role_id, description FROM role order by role_id";
}

 

 

*RoleDao.java

package kr.or.connect.daoexam.dao;
 
//SELECT_ALL을 사용하기 위해 static import 사용
import static kr.or.connect.daoexam.dao.RoleDaoSqls.SELECT_ALL;
 
import java.util.Collections;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;
 
import kr.or.connect.daoexam.dto.Role;
 
@Repository // 레포지토리 역할을 알려줌
public class RoleDao {
    private NamedParameterJdbcTemplate jdbc; // 바인딩 할 때 '?' 를 사용했었는데, 이 객체를 이용하면 이름을 이용해서 바인딩 할 수 있다.
    private RowMapper<Role> rowMapper = BeanPropertyRowMapper.newInstance(Role.class);    //BeanPropertyRowMapper는 DBMS와 자바의 이름 규칙을 맞춰주는 기능을 한다. role_id = roleId
    
    public RoleDao(DataSource dataSource) {    //생성자, bean으로 등록했던 dataSource를 파라미터로 넘긴다
        this.jdbc = new NamedParameterJdbcTemplate(dataSource); // NamedParameterJdbcTemplate 객체 생성
    }
    
    public List<Role> selectAll(){         // 전부 가져오는 메서드, 여러개니까 List<Role>로..
        return jdbc.query(SELECT_ALL, Collections.emptyMap(), rowMapper);        //query() : 결과가 여러 건이었을 때 내부적으로 반복하면서 DTO 생성, 이 생성한 DTO를 List에 담아 준다 
        //파라미터 1: 실제 쿼리문, 
        //파라미터 2: 비어있는 맵 객체 선언(sql문에 바인딩할 값이 있을 경우, 바인딩할 값을 전달할 목적으로 있는 객체), 
        //파라미터 3 : rowMapper(select 한건한건의 결과를 저장하는 역할), BeanPropertyRowMapper객체를 이용해 컬럼의 값을 자동으로 DTO에 담는다. 
    }
}

 

- ApplicationConfig.java에 아래 코드 추가

@ComponentScan(basePackages = { "kr.or.connect.daoexam.dao" })

 

*ApplicationConfig.java

package kr.or.connect.daoexam.config;
 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
 
@Configuration
@ComponentScan(basePackages = {"kr.or.connect.daoexam.dao"}) //@Repository가 등록된 클래스를 bean에 등록해줌
@Import({DBConfig.class})//설정 파일이 여러개 있다면 이 어노테이션으로 연결, 우리는 DBConfig를 연결함
public class ApplicationConfig {
 
}
 

 

- 이제 SelectAllTest.java 를 만들어 테스트를 해본다.

 

*SelectAllTest.java

package kr.or.connect.daoexam.main;
 
import java.util.List;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import kr.or.connect.daoexam.config.ApplicationConfig;
import kr.or.connect.daoexam.dao.RoleDao;
import kr.or.connect.daoexam.dto.Role;
 
public class SelectAllTest {
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        
        RoleDao roleDao = ac.getBean(RoleDao.class);
        
        List<Role> list = roleDao.selectAll();
        
        for(Role role : list) {
            System.out.println(role);
        }
    }
}

 

- 실행 후 데이터들이 잘 출력되면 성공

 

 

Insert 문

- INSERT 문의 경우 RoleDaoSqls에 쿼리를 만들 필요가 없다.

 

*RoleDao.java

package kr.or.connect.daoexam.dao;
 
import java.util.Collections;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Repository;
 
import kr.or.connect.daoexam.dto.Role;
import static kr.or.connect.daoexam.dao.RoleDaoSqls.*;
 
@Repository // 레포지토리 역할을 알려줌
public class RoleDao {
    private NamedParameterJdbcTemplate jdbc;
    private SimpleJdbcInsert insertAction;
    private RowMapper<Role> rowMapper = BeanPropertyRowMapper.newInstance(Role.class);
    
    public RoleDao(DataSource dataSource) {//생성자
        this.jdbc = new NamedParameterJdbcTemplate(dataSource);
        this.insertAction = new SimpleJdbcInsert(dataSource).withTableName("role");//어떤 테이블에 넣을껀지(role 테이블) 알려준다.
    }
    
    public List<Role> selectAll(){       
        return jdbc.query(SELECT_ALL, Collections.emptyMap(), rowMapper);
    }
    
    public int insert(Role role) {    //원래는 SimpleJdbcInsert 객체가 프라이머리키를 자동으로 읽어오고 증가시켜주는 일을 하는데, 이번엔 프라이머리 키를 직접대입으로 진행
        SqlParameterSource params = new BeanPropertySqlParameterSource(role);    //맵객체 생성
        return insertAction.execute(params);    //알아서 값이 저장되게 된다.
    }
}

 

*JDBCTest.java

package kr.or.connect.daoexam.main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import kr.or.connect.daoexam.config.ApplicationConfig;
import kr.or.connect.daoexam.dao.RoleDao;
import kr.or.connect.daoexam.dto.Role;
 
public class jDBCTest {
 
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        
        RoleDao roleDao = ac.getBean(RoleDao.class);
        
        Role role = new Role();
        role.setRoleId(500);
        role.setDescription("CEO");
        
        int count = roleDao.insert(role);
        
        System.out.println(count + "건 입력하였습니다.");
    }
 
}

 

- 성공하면 "1건 입력하였습니다." 가 출력된다. 프라이머리키를 직접 넣었기 때문에 다시 실행시키면 오류가 나게 된다.

 

UPDATE 문

1. sql문 추가(RoleDaoSqls.java)

2. RoleDao에 update메서드 구현

 

*RoleDaoSqls.java

- update를 위한 쿼리문을 작성해 추가한다.

package kr.or.connect.daoexam.dao;
 
//여기서 사용하고자 하는 쿼리들을 상수형태로 사용하면 된다.
public class RoleDaoSqls {
    public static final String SELECT_ALL = "SELECT role_id, description FROM role order by role_id";
    public static final String UPDATE = "UPDATE role set description = :description where role_id = :roleId";
                                                                        //값으로 바인딩 될 부분에 ':바인될 값' 형식으로
}

 

 

*RoleDao.java

- update 메서드를 구현한다.

package kr.or.connect.daoexam.dao;
 
import static kr.or.connect.daoexam.dao.RoleDaoSqls.*; // 주의! 오토 임포트 쓰다보면 .*가 바뀜
 
import java.util.Collections;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Repository;
 
import kr.or.connect.daoexam.dto.Role;
 
@Repository // 레포지토리 역할을 알려줌
public class RoleDao {
    private NamedParameterJdbcTemplate jdbc;
    private SimpleJdbcInsert insertAction;
    private RowMapper<Role> rowMapper = BeanPropertyRowMapper.newInstance(Role.class);
    
    public RoleDao(DataSource dataSource) {//생성자
        this.jdbc = new NamedParameterJdbcTemplate(dataSource);
        this.insertAction = new SimpleJdbcInsert(dataSource).withTableName("role");//어떤 테이블에 넣을껀지(role 테이블) 알려준다.
    }
    
    public List<Role> selectAll(){       
        return jdbc.query(SELECT_ALL, Collections.emptyMap(), rowMapper);
    }
    
    public int insert(Role role) {    //원래는 SimpleJdbcInsert 객체가 프라이머리키를 자동으로 읽어오고 증가시켜주는 일을 하는데, 이번엔 프라이머리 키를 직접대입으로 진행
        SqlParameterSource params = new BeanPropertySqlParameterSource(role);    //맵객체 생성
        return insertAction.execute(params);    //알아서 값이 저장되게 된다.
    }
    
    public int update(Role role) {    // update 
        SqlParameterSource params = new BeanPropertySqlParameterSource(role);
        return jdbc.update(UPDATE, params); //UPDATE : RoleDaoSqls의 update sql문, params : 맵객체, sql문에 바인딩될 값들을 가지고 있음
    }
}

 

*JDBCTest.java

package kr.or.connect.daoexam.main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import kr.or.connect.daoexam.config.ApplicationConfig;
import kr.or.connect.daoexam.dao.RoleDao;
import kr.or.connect.daoexam.dto.Role;
 
public class jDBCTest {
 
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        
        RoleDao roleDao = ac.getBean(RoleDao.class);
        
        Role role = new Role();
        role.setRoleId(500);
        role.setDescription("PROGRAMMER");
        
        int count = roleDao.update(role);
        System.out.println(count + "건 수정하였습니다.");
    }
 
}

 

- "1건 수정하였습니다."가 출력되면 성공. mysql에서 DB를 확인해본다.

 

1건 SELECT, DELETE

1. 쿼리 추가하기(RoleDaoSqls.java)

2. RoleDao에서 메서드 구현하기 

 

RoleDaoSqls.java에 아래 쿼리문 추가

public static final String SELECT_BY_ROLE_ID = "SELECT role_id, description FROM role where role_id = :roleId";
public static final String DELETE_BY_ROLE_ID = "DELETE FROM role WHERE role_id = :roleId";

- tip : 관례적으로 *를 자주 쓰는거 보단 컬럼명을 정확히 명시하는 것이 좋다.

 

*RoleDao.java

package kr.or.connect.daoexam.dao;
 
// 주의! 오토 임포트 쓰다보면 .*가 바뀜
import static kr.or.connect.daoexam.dao.RoleDaoSqls.*;
 
 
import java.util.Collections;
import java.util.List;
import java.util.Map;
 
import javax.sql.DataSource;
 
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Repository;
 
import kr.or.connect.daoexam.dto.Role;
 
@Repository // 레포지토리 역할을 알려줌
public class RoleDao {
    private NamedParameterJdbcTemplate jdbc;
    private SimpleJdbcInsert insertAction;
    private RowMapper<Role> rowMapper = BeanPropertyRowMapper.newInstance(Role.class);
    
    public RoleDao(DataSource dataSource) {
        this.jdbc = new NamedParameterJdbcTemplate(dataSource);
        this.insertAction = new SimpleJdbcInsert(dataSource).withTableName("role");
    }
    
    public List<Role> selectAll(){       
        return jdbc.query(SELECT_ALL, Collections.emptyMap(), rowMapper);
    }
    
    public int insert(Role role) {
        SqlParameterSource params = new BeanPropertySqlParameterSource(role);    
        return insertAction.execute(params);    
    }
    
    public int update(Role role) {
        SqlParameterSource params = new BeanPropertySqlParameterSource(role);
        return jdbc.update(UPDATE, params); 
    }
    
    
    /*추가한 메서드들*/
    public int deleteById(Integer id) {
        Map<String, ?> params = Collections.singletonMap("roleId", id);// Delete 같은 경우, 딱 한 건만 삭제하는 것이기 때문에, 객체를 생성하는 거 보다 더 효율적이다. 
        return jdbc.update(DELETE_BY_ROLE_ID, params);
    }
    
    public Role selectById(Integer id) {
        try {
            Map<String, ?> params = Collections.singletonMap("roleId", id);
            return jdbc.queryForObject(SELECT_BY_ROLE_ID, params, rowMapper); // 1 건 처리할 때는 queryForObject 메서드를 사용한다.
        }catch(EmptyResultDataAccessException e) { // select를 했는데 해당 조건에 맞지 않으면 null을 반환한다.
            return null;
        }
    }
}
 

 

*JDBCTest.java

package kr.or.connect.daoexam.main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import kr.or.connect.daoexam.config.ApplicationConfig;
import kr.or.connect.daoexam.dao.RoleDao;
import kr.or.connect.daoexam.dto.Role;
 
public class jDBCTest {
 
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        
        RoleDao roleDao = ac.getBean(RoleDao.class);
        
        Role role = new Role();
        role.setRoleId(500);
        role.setDescription("PROGRAMMER");
        
        int count = roleDao.update(role);
        System.out.println(count + "건 수정하였습니다.");
        
        Role resultRole = roleDao.selectById(500);
        System.out.println(resultRole);
        
        int deleteCount = roleDao.deleteById(501);
        System.out.println(count + "건 삭제하였습니다.");
        
        Role resultRole2 = roleDao.selectById(501); //삭제되었는지 확인하기
        System.out.println(resultRole2);
    }
 
}

 

- 잘 반영되면 성공

 

참고 사이트 : http://www.edwith.org/

※
본 게시물은 개인적인 용도로 작성된 게시물입니다. 이후 포트폴리오로 사용될 정리 자료이니 불펌과 무단도용은 하지 말아주시고 개인 공부 목적으로만 이용해주시기 바랍니다.

※