가전제품 이것저것 이야기

IoC란 Inversion of Control의 줄임말로 한글로 번역하면 제어의 역전이라는 말이다.

"제어의 역전" 이라는 의미는 말 그대로 메소드나 객체의 호출작업을 개발자가 결정하는 것이 아니라,

외부에서 결정되는 것을 의미한다.

제어의 역전 개념은 이미 폭넓게 적용되어 있다. 일반적으로 자바 프로그램은 main() 메소드에서 시작해서

개발자가 미리 정한 순서를 따라 객체가 생성되고 실행된다.

그런데 서블릿을 생각해보자. 서블릿을 개발해서 서버에 배포할 수는 있지만, 배포하고 나서는 개발자가

직접 제어할 수 있는 방법은 없다. 대신 서블릿에 대한 제어 권한을 가진 컨테이너가 적절한 시점에

서블릿 클래스의 객체를 만들고 그 안의 메소드를 호출한다.

이 방식은 대부분의 프레임워크에서 사용하는 방법으로,

개발자는 필요한 부분을 개발해서 끼워 넣기의 형태로 개발하고 실행하게 된다.

프레임워크가 이러한 구조를 가지기 때문에, 개발자는 프레임워크에 필요한 부품을 개발하고,

조립하는 방식의 개발을 하게 된다.

이렇게 조립된 코드의 최종 호출은 개발자에 의해서 제어되는 것이 아니라,

프레임워크의 내부에서 결정된 대로 이뤄지게 되는데, 이러한 현상을 "제어의 역전"이라고 표현한다.

스프링은 그 자체가 "구조를 설계할 수 있도록 만들어졌다" 라는 뜻이다. 

대부분 프레임워크에서 IoC를 적용한다. 때문에 스프링을 IoC 컨테이너라고만 해서는 스프링을 정확히 정의할 수 없다.

스프링이 여타 프레임워크와 차별화돼서 제공해주는 기능은 의존관계 주입이라는 새로운 용어를 사용할 때

분명히 들어난다.

1. Spring container

- Java 객체("bean")들의 life-cycle 관리

- DI 

DI란 Dependency Injection의 줄임말로 한글로 번역하면 의존성 주입이라는 말이다.

"의존성 주입"은 제어의 역행이 일어날 때 스프링이 내부에 있는 객체들간의 관계를 관리할 때 사용하는 기법이다.

자바에서는 일반적으로 인터페이스를 이용해서 의존적인 객체의 관계를 최대한 유연하게 처리할 수 있도록 한다.

의존성 주입은 말 그대로 의존적인 객체를 직접 생성하거나 제어하는 것이 아니라, 

특정 객체에 필요한 객체를 외부에서 결정해서 연결시키는 것을 의미한다.

즉, 우리는 클래스의 기능을 추상적으로 묶어둔 인터페이스를 갖다 쓰면 되는 것이다.

나머지는 스프링에서 객체를 주입해주기 때문이다.

따라서 이러한 의존성 주입으로 인해 모듈 간의 결합도가 낮아지고 유연성이 높아진다.

* container 종류

1) beanFactory interface 구현체

: getBean(String name, Class <T> requiredType)

2) ApplicationContext interface 및 그 sub-interface 구현체

: BeanFactory를 확장하여 다양한 부가 기능 제공

-> Annotation 기반 설정, Java code 기반 설정, 웹 애플리케이션 관련 기능, 트랜잭션 처리, 메시지 처리 등

GenericXmlApplicationContext : XML file 을 설정 정보로 사용

AnnotationConfigApplicationContext : @Configuration이 적용된 java class 의 설정 정보를 이용

XmlWebApplicationContext /  AnnotationConfigWebApplicationContext : Spring MVC framework에서 사용

ex)

2. 의존 관계 설정 (DI)

1) 생성자 방식 : 가장 근접한 타입의 인자를 가진 생성자를 선택

* <Value>를 통해 전달된 값은 기본적으로 String 으로 간주

* "c" namespace를 이용한 설정

: 순서가 중요 !

2) Setter method

: name을 필드이름과 동일하게 설정하기 때문에 순서를 바꿔도 상관없다.

* "p" namespace 를 이용한 설정

3. 생성자 방식 vs Setter 방식

생성자 방식

: Bean 객체를 생성하는 시점에 모든 의존 객체가 주입됨

: 성능상 유리하고, 객체를 사용하기 전에 필요한 의존 객체가 모두 주입된 상태이므로 NullPointException 가능성이 낮음

단, 생성자가 많은 경우 순서대로 객체를 전달하기 때문에 헷갈릴수있다.

Setter method 방식

: 각 필드마다 필요한 의존 객체를 주입하므로 설정이 명확하고 용이함

:  setter 별로 실행되므로 성능이 다소 저하되고, setter 실행이 누락된 경우 NullPointException 발생 가능

4. Lookup method Injection

4. Collection Wiring

Bean Property가 Collection type인 경우

원소 정의 :

* <value type="java.lang.Double">1.5</value> 이런 식으로 속성 지정 가능

: Bean property가 generic type으로 선언되 경우, 값이 자동으로 변환됨 !

예시) Collection type

-> java 파일에서 Collection, List, 배열 타입으로 선언된 경우 사용 가능

-> java 파일에서 Collection, 배열 타입으로 선언된 경우 사용 가능

-> 중복 제거

예시) Map type

* Properties 는 key와 value가 모두 String인 Map과 같음

5. SpEL

Spring Expression Language

형식 : #{...}

** value-ref 가 아닌 value 속성을 사용한다 !!

** 해당 값이 private이면 getSong()을 호출해야 하며, getter 가 존재해야 한다.

* T() : 클래스 이름을 인자로 지정

# 출처

https://jobc.tistory.com/30

1. What is spring framework?

: DI(Dependency Injection)을 지원하는 Container(자바 객체를 담고 관리하는 컨테이너)

* DI = IoC(Inversion of Control)

- 장점

: POJO(Plain Old Java Objects)를 이용한 쉬운 개발

: 부모 클래스를 이용하지 않고, DI와 interface를 활용한 객체간 느슨한 결합(loose coupling)

: Aspects와 templates를 이용한 단순 반복 코드 제거

2. History of Spring

- EJB(Enterprise JavaBeans)

: 기업용 어플리케이션 개발을 위한 표준 component model

: 복잡한 코드 개발 필요, 성능 미흡

- Spring 1.0

: 기존 EJB를 대체하기 위한 open-source, light-weight framework

: DI, AOP, POJO의 개념을 기반

- EJB 3.0

: spring의 장점을 반영하여 DI, POJO기반 개발 방법 지원

- Spring 2.0

: support for XML namespaces, AspectJ, and @Component

현재: Spring 5.0

3. Spring Framework 특징

1) Light-weight container and framework 

: java 객체의 life-cycle 관리

2) DI(Dependency Injection) 지원

3) AOP(Aspect-Oriented Programming) 지원

4) 효율적인 Web application 지원

: Servlet-based Spring MVC web framework

: Spring WebFlux reactive web framework

: RESTful web wervice framework

5) JDBC, JPA, 선언적 transaction 처리 등 데이터베이스 연동 지원

6) 다양한 기술들과의 연동 지원

: EJB

: JDBC, Hibernate, JPA, MyBatis, NoSQL DB

: JSP, Mustache, Thymeleaf

4. Components

- 주요 module

- 주요 module 간 의존 관계

5. webMCV Framework

6. Dependency Injection(DI)

객체 외부에 존재하는 assembler(container)가 run-time에 객체들 사이의 의존 관계를 파악하고 의존 객체를 객체에 제공해 주는 것

* 객체 생성 시점에 의존 객체가 객체에 제공됨

* IoC : 객체가 의존 객체를 직접 생성하거나 찾을 필요 없음

* 객체들 간의 의존 관계는 XML 파일이나 JAVA 설정 클래스(Java-config), annotation 등을 통해 설정됨

-> Assembler가 설정 내용 참조하여 DI 실행

일반적인 DI 구현방법(Spring x)

- 구현방법 1 : 의존하는 객체를 직접 생성

- 구현방법 2 : Factory 클래스 이용

- 구현방법 3 : DI 이용

1) 생성자를 통해 의존 객체 전달받는 방법

2) Setter method를 통해 의존 객체 전달받는 방법

- 공통

7. 스프링의 DI 지원

Assempler 클래스 불필요

1) XML을 통한 객체 생성 및 의존관계 설정 (appContext.xml)

2) Annotation을 이용한 설정

3) Java code를 이용한 설정

8. AOP(Aspects Oriented Programming)

공통의 관심사항 적용 시 발생하는 의존 관계의 복잡성과 코드 중복 문제를 해결하기 위한 프로그램 개발 방법론

Cross-cutting Concerns(공통 관심사항) 

: transaction, logging, security

AOP 실행 예제(POJO 기반)

DTO란?

• DTO란 Data Transfer Object의 약자입니다.
• 계층간 데이터 교환을 위한 자바빈즈입니다.
• 여기서의 계층이란 컨트롤러 뷰, 비지니스 계층, 퍼시스턴스 계층을 의미합니다.
• 일반적으로 DTO는 로직을 가지고 있지 않고, 순수한 데이터 객체입니다.
• 필드와 getter, setter를 가진다. 추가적으로 toString(), equals(), hashCode()등의 Object 메소드를 오버라이딩 할 수 있습니다.

DTO의 예

public class ActorDTO {
    private Long id;
    private String firstName;
    private String lastName;
    public String getFirstName() {
        return this.firstName;
    }
    public String getLastName() {
        return this.lastName;
    }
    public Long getId() {
        return this.id;
    }
    // ......
}

DAO란?

• DAO란 Data Access Object의 약자로 데이터를 조회하거나 조작하는 기능을 전담하도록 만든 객체입니다.
• 보통 데이터베이스를 조작하는 기능을 전담하는 목적으로 만들어집니다.

ConnectionPool 이란?

• DB연결은 비용이 많이 듭니다.
• 커넥션 풀은 미리 커넥션을 여러 개 맺어 둡니다.
• 커넥션이 필요하면 커넥션 풀에게 빌려서 사용한 후 반납합니다.
• 커넥션을 반납하지 않으면 어떻게 될까요?

ConnectionPool

DataSource란?

• DataSource는 커넥션 풀을 관리하는 목적으로 사용되는 객체입니다.
• DataSource를 이용해 커넥션을 얻어오고 반납하는 등의 작업을 수행합니다.

Spring JDBC

• JDBC 프로그래밍을 보면 반복되는 개발 요소가 있습니다.
• 이러한 반복적인 요소는 개발자를 지루하게 만듭니다.
• 개발하기 지루한 JDBC의 모든 저수준 세부사항을 스프링 프레임워크가 처리해줍니다.
• 개발자는 필요한 부분만 개발하면 됩니다.

Spring JDBC - 개발자가 해야 할 일은?

spring JDBC

Spring JDBC 패키지

org.springframework.jdbc.core

• JdbcTemplate 및 관련 Helper 객체 제공

org.springframework.jdbc.datasource

• DataSource를 쉽게 접근하기 위한 유틸 클래스, 트랜젝션매니져 및 다양한 DataSource 구현을 제공

org.springframework.jdbc.object

• RDBMS 조회, 갱신, 저장등을 안전하고 재사용 가능한 객제 제공

org.springframework.jdbc.support

• jdbc.core 및 jdbc.object를 사용하는 JDBC 프레임워크를 지원

JDBC Template

• org.springframework.jdbc.core에서 가장 중요한 클래스입니다.
• 리소스 생성, 해지를 처리해서 연결을 닫는 것을 잊어 발생하는 문제 등을 피할 수 있도록 합니다.
• 스테이먼트(Statement)의 생성과 실행을 처리합니다.
• SQL 조회, 업데이트, 저장 프로시저 호출, ResultSet 반복호출 등을 실행합니다.
• JDBC 예외가 발생할 경우 org.springframework.dao패키지에 정의되어 있는 일반적인 예외로 변환시킵니다.

실습코드

JdbcTemplate select 예제1

열의 수 구하기

int rowCount = this.jdbcTemplate.queryForInt("select count(*) from t_actor");

JdbcTemplate select 예제2

변수 바인딩 사용하기

int countOfActorsNamedJoe = this.jdbcTemplate.queryForInt("select count(*) from t_actor where first_name = ?", "Joe");

JdbcTemplate select 예제3

String값으로 결과 받기

String lastName = this.jdbcTemplate.queryForObject("select last_name from t_actor where id = ?", new Object[]{1212L}, String.class);

JdbcTemplate select 예제4

한 건 조회하기

Actor actor = this.jdbcTemplate.queryForObject(

  "select first_name, last_name from t_actor where id = ?",

  new Object[]{1212L},

  new RowMapper<Actor>() {

    public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {

      Actor actor = new Actor();

      actor.setFirstName(rs.getString("first_name"));

      actor.setLastName(rs.getString("last_name"));

      return actor;

    }

  });

JdbcTemplate select 예제5

여러 건 조회하기

List<Actor> actors = this.jdbcTemplate.query(

  "select first_name, last_name from t_actor",

  new RowMapper<Actor>() {

    public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {

      Actor actor = new Actor();

      actor.setFirstName(rs.getString("first_name"));

      actor.setLastName(rs.getString("last_name"));

      return actor;

    }

  });

JdbcTemplate select 예제6

중복 코드 제거 (1건 구하기와 여러 건 구하기가 같은 코드에 있을 경우)

public List<Actor> findAllActors() {

  return this.jdbcTemplate.query( "select first_name, last_name from t_actor", new ActorMapper());

}

private static final class ActorMapper implements RowMapper<Actor> {

  public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {

    Actor actor = new Actor();

    actor.setFirstName(rs.getString("first_name"));

    actor.setLastName(rs.getString("last_name"));

    return actor;

  }

}

JdbcTemplate insert 예제

INSERT 하기

this.jdbcTemplate.update("insert into t_actor (first_name, last_name) values (?, ?)",  "Leonor", "Watling");

JdbcTemplate update 예제

UPDATE 하기

this.jdbcTemplate.update("update t_actor set = ? where id = ?", "Banjo", 5276L);

JdbcTemplate delete 예제

DELETE 하기

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

JdbcTemplate외의 접근방법

NamedParameterJdbcTemplate

• JdbcTemplate에서 JDBC statement 인자를 ?를 사용하는 대신 파라미터명을 사용하여 작성하는 것을 지원
• NamedParameterJdbcTemplate 예제

SimpleJdbcTemplate

• JdbcTemplate과 NamedParameterJdbcTemplate 합쳐 놓은 템플릿 클래스
• 이제 JdbcTemplate과 NamedParameterJdbcTemplate에 모든 기능을 제공하기 때문에 삭제 예정될 예정(deprecated)
• SimpleJdbcTemplate 예제

SimpleJdbcInsert

• 테이블에 쉽게 데이터 insert 기능을 제공
• SimpleJdbcInsert 예제

생각해보기

1. JDBC 프로그래밍이 불편해서 이를 해결하기 위해서 등장한 기술에는 Spring JDBC 외에도 다양한 기술들이 존재합니다. 대표적으로 JPA와 MyBatis가 그러한 기술입니다. 문제를 해결하는 방법이 왜 여러 가지가 존재할끼요?
2.  

http://blog.naver.com/PostView.nhn?blogId=admass&logNo=220870636605

Spring JPA와 Mybatis는 각각 장단점이 있습니다.

Spring JPA의 경우에는 객체 단위로 CRUD가 가능합니다. 일반적으로 CUD는 단일 테이블에 대하여 작업을 하는 경우가 많은데 Mybatis에서 하게 되면 해당 쿼리를 직접 짜고, 들어오는 Parameter에 대하여 모두 확인하여 처리해야 하는 경우가 많습니다.

그러나 MyBatis의 장점을 무시할 순 없습니다. ER-DB를 사용하는 경우 자기가 원하는 Query를 짜서 직접 데이터를 손쉽게 전달하고 처리할 수 있다는 장점이 있죠. 특히, Spring JPA에서 활용하는 상당히 복잡한 나름대로의 SQL을 배워야 하고, 테이블 Join을 하게 될 경우 해당 조건을 객체구조에도 녹여내야 하는 등 배우고 익혀서 적용해야 할 포인트가 많아지게 됩니다.

Java config를 이용한 설정을 위한 어노테이션

@Configuration

• 스프링 설정 클래스를 선언하는 어노테이션

@Bean

• bean을 정의하는 어노테이션

@ComponentScan

• @Controller, @Service, @Repository, @Component 어노테이션이 붙은 클래스를 찾아 컨테이너에 등록

@Component

• 컴포넌트 스캔의 대상이 되는 애노테이션 중 하나로써 주로 유틸, 기타 지원 클래스에 붙이는 어노테이션

@Autowired

• 주입 대상이되는 bean을 컨테이너에 찾아 주입하는 어노테이션

Java Config를 이용해 설정하기

ApplicationConfig.java

package kr.or.connect.diexam01;
import org.springframework.context.annotation.*;

@Configuration
public class ApplicationConfig {
	@Bean
	public Car car(Engine e) {
		Car c = new Car();
		c.setEngine(e);
		return c;
	}
	
	@Bean
	public Engine engine() {
		return new Engine();
	}
}

@Configuration 은 스프링 설정 클래스라는 의미를 가집니다.

JavaConfig로 설정을 할 클래스 위에는 @Configuration가 붙어 있어야 합니다.

ApplicationContext중에서 AnnotationConfigApplicationContext는 JavaConfig클래스를 읽어들여 IoC와 DI를 적용하게 됩니다.

이때 설정파일 중에 @Bean이 붙어 있는 메소드들을 AnnotationConfigApplicationContext는 자동으로 실행하여 그 결과로 리턴하는 객체들을 기본적으로 싱글턴으로 관리를 하게 됩니다.

ApplicationContextExam03.java

package kr.or.connect.diexam01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextExam03 {

	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);
		   
		Car car = (Car)ac.getBean("car");
		car.run();
		
	}
}

파라미터로 요청하는 class 타입으로 지정 가능합니다.

Car car = ac.getBean(Car.class);

ApplicationConfig2.java

package kr.or.connect.diexam01;
import org.springframework.context.annotation.*;

@Configuration
@ComponentScan("kr.or.connect.diexam01")
public class ApplicationConfig2 {
}

기존 JavaConfig에서 빈을 생성하는 메소드를 모두 제거했습니다.

단, @Configuration아래에 @ComponentScan이라는 어노테이션을 추가했습니다.

@ComponentScan어노테이션은 파라미터로 들어온 패키지 이하에서 @Controller, @Service, @Repository, @Component 어노테이션이 붙어 있는 클래스를 찾아 메모리에 몽땅 올려줍니다.

기존의 Car클래스와 Engine클래스 위에 @Component를 붙이도록 하겠습니다.

Engine.java

package kr.or.connect.diexam01;

import org.springframework.stereotype.Component;

@Component
public class Engine {
	public Engine() {
		System.out.println("Engine 생성자");
	}
	
	public void exec() {
		System.out.println("엔진이 동작합니다.");
	}
}

Car.java

package kr.or.connect.diexam01;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
	@Autowired
	private Engine v8;
	
	public Car() {
		System.out.println("Car 생성자");
	}
	
	public void run() {
		System.out.println("엔진을 이용하여 달립니다.");
		v8.exec();
	}
}

수정된 JavaConfig를 읽어들이여 실행하는 클래스를 보도록 하겠습니다.

ApplicationContextExam04.java

package kr.or.connect.diexam01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextExam04 {

	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig2.class);
		   
		Car car = ac.getBean(Car.class);
		car.run();
		
	}
}

Spring에서 사용하기에 알맞게 @Controller, @Service, @Repository, @Component 어노테이션이 붙어 있는 객체들은 ComponentScan을 이용해서 읽어들여 메모리에 올리고 DI를 주입하도록 하고, 이러한 어노테이션이 붙어 있지 않은 객체는 @Bean어노테이션을 이용하여 직접 생성해주는 방식으로 클래스들을 관리하면 편리합니다.

생각해보기

• 다루는 빈(Bean)이 많아질수록 xml로 설정하는 것과 @ComponentScan, @Component, @Autowired를 이용하는 것 중 어떤 것이 유지보수에 좋을 것 같습니까?
• @AutoWired 는 Field, Constructor, Setter Method 에 사용할 수 있습니다. 각각의 방식에 장단점에 대해서 더 생각해보세요.

1. 후자의 경우가 좀 더 유지보수하기에 좋을 것같습니다. xml로 설정하게될경우 우선순위는 좀 더 높지만 일일이 id를 지정해줘야하고 그에맞게 연결해줘야하는데 이건 여간 힘든작업이란 생각이 듭니다.

2. 아직은 좀 더 와닿지는않지만 아래의 URL에 설명이 잘되어있더군요.

https://yaboong.github.io/spring/2019/08/29/why-field-injection-is-bad/

DI 확인하기

이번에는 DI 즉 의존성 주입을 확인해보도록 하겠습니다.

Car와 Engine이라는 클래스 2개를 생성합니다.

실습코드

Engine.java

package kr.or.connect.diexam01;

public class Engine {
	public Engine() {
		System.out.println("Engine 생성자");
	}
	
	public void exec() {
		System.out.println("엔진이 동작합니다.");
	}
}

Car.java

package kr.or.connect.diexam01;

public class Car {
	Engine v8;
	
	public Car() {
		System.out.println("Car 생성자");
	}
	
	public void setEngine(Engine e) {
		this.v8 = e;
	}
	
	public void run() {
		System.out.println("엔진을 이용하여 달립니다.");
		v8.exec();
	}
}

위의 Car 클래스가 제대로 동작하도록 하려면 보통 다음과 같은 코드가 작성되야 합니다.

Engine e = new Engine();
Car c = new Car();
c.setEngine( e );
c.run();

1, 2 번째 줄을 Spring 컨테이너에게 맡기기 위해 설정파일에 다음과 같은 코드를 입력합니다.

<bean id="e" class="kr.or.connect.diexam01.Engine"></bean>
<bean id="car" class="kr.or.connect.diexam01.Car">
	<property name="engine" ref="e"></property>
</bean>

즉, 위의 XML설정은 다음과 같은 의미를 가집니다.

Engine e = new Engine();
Car c = new Car();
c.setEngine( e );

이번엔 위의 설정 파일을 읽어들여 실행하는 ApplicationContextExam02.java를 작성해보도록 하겠습니다.

package kr.or.connect.diexam01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ApplicationContextExam02 {

	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext( 
				"applicationContext.xml"); 

		Car car = (Car)ac.getBean("car");
		car.run();
		
	}
}

콘솔을 보면 다음과 같이 실행된 것을 알 수 있습니다.

생각해보기

• Spring컨테이너가 관리하는 객체를 빈(Bean)이라고 말합니다. (여러분들이 직접 new연산자로 생성해서 사용하는 객체는 빈(Bean)이라고 말하지 않습니다.) Spring은 빈을 생성할 때 기본적으로 싱글톤(Singleton)객체로 생성합니다. 싱글톤이란 메모리에 하나만 생성한다는 것입니다. 메모리에 하나만 생성되었을 경우, 해당 객체를 동시에 이용한다면 어떤 문제가 발생할 수 있을까요? 이런 문제를 해결하려면 어떻게 해야할까요?   ( 참고로 Spring에서 빈을 생성할 때 스코프(scope)를 줄 수 있습니다. 스코프를 줌으로써 기본으로 설정된 싱글톤 외에도 다른 방법으로 객체를 생성할 수 있습니다. )

운영체제나 데이터베이스에서 나타나는 동기/비동기와 관련된 문제가 생길 수 있다고 생각합니다. 같은 객체에 동시에 다른 사용자가 접근하여 몇 명은 수정을, 몇 명은 참조를 진행한다면 문제가 생길 수 있습니다. 또한 이를 막기 위해 코딩을 하다보면 데드락과 관련된 이슈도 나올 수 있다고 생각합니다.