[객체지향설계] jdbcTemplate은 어떻게 만들어졌는가?

Spring에서 DB에 쿼리를 날리기 위해서 _jdbcTemplate_을 사용하곤 했다. 누군가가 쿼리 편하게 작성하라고 만들었구나 정도로 생각했었다. 하지만, 공부를 하다보니 이 이름에는 정말 크나큰 의미가 있다는 것을 알게 되었고 그 구조에 또 한번 감탄하게 되었다.

 

 

이제부터, _jdbcTemplate_라는 객체 지향적으로 DB에 접근할 수 있는 API가 어떻게 만들어졌는지 정리해보고자 한다. 그전에 알아야 하는 개념인 응집도와 결합도에 대해 먼저 살펴보자.

 

 

 

높은 응집도(high cohesion)

 

높은 응집도란 하나의 모듈, 클래스가 하나의 책임, 관심사에 집중되어 있다는 것이다. 그 외의 관련 없는 책임은 얽혀있지 않다. 이는 클래스 레벨 뿐만이 아니라 패키지나 컴포넌트 등의 영역에서도 마찬가지로 적용된다.

 

 

또한 응집도가 높다면 변화가 일어날 때 해당 모듈에서만의 변화가 제일 크다. 만약 다른 모듈도 같이 변한다면 이는 응집도가 낮다는 것이 된다.

 

 

 

 

 

낮은 결합도(low Coupling)

 

낮은 결합도란 다른 모듈과의 의존성 정도이며, 이는 높은 응집도보다 더 민감한 원칙이다. 결합도가 낮다는 것은 책임사가 다른 모듈간의 느슨한 연결 형태를 유지한는 것을 의미한다.

 

 

즉, 관계를 유지하는데 있어서 최소한의 정보만을 주고 나머지 정보는 주면 안된다. 그렇기 때문에 낮은 결합도는 하나의 오브젝트에서 변화가 일어날 때 관계를 맺고 있는 다른 오브젝트에서는 이러한 변경에 대한 요구가 전파되지 않는 상태이다.

 

 

 

 

 

 

 

 

전략 패턴

 

전략 패턴은 디자인 패턴 중 하나로 높은 응집도와 낮은 결합도를 형성하는데 도움을 주는 패턴이다. 물론 템플릿 메서드 패턴도 응집도를 높이고 낮은 결합도를 형성할 수 있다. 하지만, 추상 클래스에서 변화를 원하는 부분을 추상 메서드로 만들고, 일일이 상속을 통해 메서드를 구현해야 해서 굉장히 번거롭다.

 

 

 

따라서 더욱 유연하고 확장성 높도록 만들어진 것이 바로 전략 패턴이다. 전략 패턴을 한 마디로 설명하자면 "클라이언트가 전략 오브젝트를 선택하여 컨텍스트가 활용할 수 있도록 하는 것"이라고 말할 수 있다.

 

 

 

여기서 말하는 컨텍스트와 전략은 다음과 같이 정의한다.

 

• 전략(strategy) : 필요에 따라 변하는 부분
• 컨텍스트(context) : 변하지 않는 부분

 

 

즉, 오브젝트를 둘로 구분하고 클래스 수준에서 인터페이스를 통해서만 의존하는 것이다.

 

클라이언트

public class Client{
    public void methodOfClient(){
    
        Context context = new Context();

        Strategy_Interface strategy = new Strategy_Implement();   

        context.contextWithStrategy(strategy);
    }
}

 

 

클라이언트에서는 변하지 않는 컨텍스트를 통해서 전략을 수행한다.

 

 

컨텍스트

public class Context {
    public void contextWithStrategy(Strategy_Interface st){
    
    }
}

 

 

컨텍스트에서는 일정한 구조를 가지고 행동하는데, 이때 주입 받은 전략을 사용한다. 컨텍스트는 전략 인터페이스를 매개변수로 받기 때문에 객체의 행위를 동적으로 바꿀 수 있다는 장점이 있다.

 

 

전략

public interface Strategy_Interface {
    public void action();
}

public class Strategy_Implement {
    @Override
    public void action(){

    }
}

 

 

 

전략 인터페이스와 이를 상속 받은 구체화된 클래스를 통해서 프로그램 상의 로직이 바뀌어도 유연하게 수정할 수 있다. 따라서 OCP 원칙에도 위반되지 않을 수 있다.

 

 

<토비의 스프링> 을 살펴보면, JDBC의 복잡한 로직을 전략 패턴을 통해서 최적화 과정을 찾아 볼 수 있다.

 

 

 

 

 

 

 

 

템플릿/콜백 패턴

 

전략 패턴은 추가해야할 전략의 갯수가 많아진다면 그만큼 전략 클래스를 새롭게 생성해 주어야 한다. 뿐만 아니라 전달해야 하는 정보가 많다면 인자로 넘겨 주어야 하는데 이렇게 되면 코드가 상당히 지저분해진다.

 

 

이를 보완하기 위한 방안으로 내부 클래스를 사용한다던가 익명 클래스를 사용하여 _context_에 전달하곤 하는데, 이러한 방식의 패턴을 템플릿/콜백 패턴이라고 한다.

 

 

정확히는 인터페이스를 상속하는 클래스를 만들지 않고, 익명 내부 클래스를 활용한다. 또한 전략 패턴의 _context_와 _stretagy_를 템플릿과 콜백이라는 형식 바꾸어 사용한다.

 

 

템플릿과 콜백의 정확한 역할는 다음과 같다.

 

 

• 템플릿 : 고정된 틀 안에서 바꿀 수 있는 부분인 콜백을 넣어서 사용한다.
• 콜백 : 익명 내부 클래스로 구성되며 _특정 로직_을 담은 메소드를 실행하기 위한 오브젝트이다.

 

 

 

클라이언트

public class Client{
    public void methodOfClient(){		
    	Template template = new Template();
        
        Callback temp_Callback = new Callback(){
            @Override
            public int calculate(int A, int B){
            	return ...
            }
        };
    	
       	template.template_Method(temp_Callback, 다른 정보 ... etc);
    }
}

 

 

클라이언트는 _template_에 _callback_을 주입한다. 이와 같이 클라이언트가 콜백 오브젝트를 만들고, 템플릿에 전달하는 것은 메소드 레벨 DI이다. 일반적인 DI는 템플릿에 인스턴스 변수를 만들고, 사용할 의존 오브젝트를 수정자 메서드를 통해서 받을 수 있다.

 

 

 

 

템플릿

public class Template {
    
    public int template_Method(int Callback callback, T 다른 정보){
        int A = &*%;
        int B = !@#$%;
        int result = callback.calculate(A, B);   
    }
}

 

이제 템플릿에서 콜백 오브젝트를 가지고 일정한 로직을 수행하면 된다.

 

 

 

 

콜백 인터페이스

public interface Callback {
    public int calculate(int A, int B);
}

 

 

콜백 인터페이스는 일반적으로 단일 메소드만을 가진다. 템플릿의 작업 흐름 중, 특정 기능을 수행하기 위해 한 번만 호출되는 경우가 대다수이기 때문이다.

 

 

항상 코드 흐름에서 중복되는 코드가 발생했을 때는 코드를 분리해볼 방법을 생각하여야 한다. 메소드로 분리할 수도 있고, 인터페이스를 사이에 둔 채 전략 패턴을 사용해 DI를 해줄 수도 있다. 혹은 바뀌는 부분이 여러 개가 나온다면 템플릿/콜백 패턴을 적용할 수 있다. 중요한 것은 중복된 코드에 대해서 그냥 냅두지 말고 어떻게 하면 최적화할 수 있을 지 고민해야 한다는 것이다.

 

 

만약 템플릿/콜백 패턴을 적용시킨다고 할 때, 고려해야 할 점은 바뀌는 부분과 바뀌지 않는 부분이다. 바뀌는 부분은 콜백에 담을 것이고, 바뀌지 않는 코드 흐름은 템플릿에 담아야 할 것이다. 그리고 이에 따라 콜백 함수가 템플릿으로 전해 줄 내용에 관해서도 제대로 파악하는 것이 필요하다.

 

 

 

 

 

 

 

 

 

Spring의 jdbcTemplate

 

Spring의 _jdbcTemplate_도 템플릿/콜백 패턴을 사용한다. 일반적인 jdbc를 사용하기에는 고려해야 할 점이 너무 많기 때문이다.

 

🤔 jdbcTemplate가 하는 일?

1️⃣ Connection을 열고 닫는다.

2️⃣ Statement를 준비하고 닫는다.

3️⃣ Statement를 실행한다.

4️⃣ ResultSet Loop를 처리한다.

5️⃣ Exception을 처리하고 반환한다.

6️⃣ Transaction을 처리한다.

 

_jdbcTemplate_를 사용한다면 개발자는 쿼리를 짜는 일 이외의 작업에 대해서는 상관 쓰지 않아도 된다. 또한 DB Connection을 하는데 있어 오류가 발생할 일도 적어지니 그 장점이 매우 크다.

 

 

_jdbcTemplate_를 사용하기 위해서는 마찬가지로 DI를 통해 주입을 시켜주어야 한다.

 

public class UserDao {
    DataSource dataSource;
    JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
    ...

 

 

 

 

Object with Count

 

_jdbcTemplate_의 queryForObject_는 단일 객체를 조회할 수 있다.

 

int rowCount = jdbcTemplate.queryForObject("select count(*) from customers", Integer.class);

 

 

 

 

 

Object with Parameter

 

_queryForObject_의 3 번째 매개변수를 통해 파라미터를 지정할 수 있다.

 

String lastName = jdbcTemplate.queryForObject("select last_name from customers where id = ?", String.class, id);

 

 

 

 

 

Object with RowMapper

 

 

_queryForObject_의 두 번째 매개변수에 _RowMapper_를 전달한다면, 객체로써 값을 받을 수 있다.

 

Customer customer = jdbcTemplate.queryForObject(
        "select id, first_name, last_name from customers where id = ?",
        (resultSet, rowNum) -> {
            Customer customer = new Customer(
                    resultSet.getLong("id"),
                    resultSet.getString("first_name"),
                    resultSet.getString("last_name")
            );
            return customer;
        }, id);

 

 

_query_문을 사용한다면, List로써도 받을 수 있다.

 

List<Customer> customers = jdbcTemplate.query(
        "select id, first_name, last_name from customers",
        (resultSet, rowNum) -> {
            Customer customer = new Customer(
                    resultSet.getLong("id"),
                    resultSet.getString("first_name"),
                    resultSet.getString("last_name")
            );
            return customer;
        });

 

 

 

update

 

INSERT, UPDATE, DELETE는 모두 _update_  메서드를 통해서 수행할 수 있다.

 

jdbcTemplate.update("insert into customers (first_name, last_name) values (?, ?)", customer.getFirstName(), customer.getLastName());

 

jdbcTemplate.update("delete from customers where id = ?", Long.valueOf(id));

 

 

 

 

KeyHolder

 

이건 좀 귀찮기는 한데, 가져온 테이블의 PK를 가져오기 위해서 _KeyHolder_라는 것을 통해 가져와야 한다.

 

KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(connection -> {
    PreparedStatement ps = connection.prepareStatement(
            "insert into customers (first_name, last_name) values (?, ?)", 
            new String[]{"id"});
    ps.setString(1, customer.getFirstName());
    ps.setString(2, customer.getLastName());
    return ps;
}, keyHolder);

Long id = keyHolder.getKey().longValue();

 

 

 

 

 

 

References

 

• https://gmlwjd9405.github.io/2018/05/15/setting-for-db-programming.html
• https://n00nietzsche.gitbook.io/jake-seo/books/toby-spring