가전제품 이것저것 이야기

Spring Container의 bean 관리

- bean 객체의 생성, 의존 객체 주입 및 초기화, 객체 삭제 등 객체 life-cycle에 관련된 작업을 수행한다.

- 각 bean에 대해 callback method를 호출하여 실행함(호출의 주체가 '시스템')

* bean 클래스에 life-cycle 관련된 callback method가 구현된 경우, container가 적절한 시점에 메소드를 호출함

ex) BeanNameAware#setBeanName(String beanName), InitializingBean#afterPropertiesSet()

* 자체적으로 정의된 custom init/destroy method 호출

<bean>의 init-method, destroy-method 속성으로 지정된 메소드

@Bean의 initMethod, destroyMethod 속성으로 지정된 메소드

@PostConstruct, @PreDestroy가 적용된 메소드

전체 life-cyle process

ApplicationContext container의 수행 절차

Life-cycle 관련 interfaces 및 callback methods

- BeanNameAware

void setBeanName(String beanName) ; id/name 속성을 전달

- BeanFactoryAware

void setBeanFactory(BeanFactory factory) : 자신을 관리하는 beanFactory 객체를 전달

- ApplicationContextAware

void setApplicationContext(Application context) : 자신을 관리하는 applicationContext 객체를 전달

예시)

Custom init-method

- Bean 객체 생성 및 DI 수행 후에 호출되는 메소드

- Bean 객체를 삭제하기 전에 호출되는 메소드

- Spring interfaces

- <bean> @Bean 설정 

Bean Scoping

Spring container는 기본적으로 한 개의 bean instance만을 생성(singleton)

Scope 지정 방법 : <bean>의 scope 속성 또는 @Scope annotaion 사용

Singleton vs Prototype

@Scope annotation 사용 예

외부 설정 Property

설정 정보의 외부화

Spring에서 bean 설정에 사용되는 설정 값을 외부의 환경변수나 파일 등에 별도의 property로 저장하고 사용하는 방법

ex) 데이터베이스 구성 정보 등

외부에 정의된 property 이용 방법

1) PropertyPlaceholderConfigurer 

-> <context:property-placeholder />

2) Environment 및 PropertySource 이용

PropertyPlaceholderConfigurer 

객체를 통해 외부에 존재하는 property file을 읽어들임(loading)

XML 기반 설정

- PropertyPlaceholderConfigurer 타입의 객체를 bean으로 생성

- property file의 목록을 location 또는 locations 속성의 값으로 제공

- property file에 정의된 각 property는 ${property-name} 형식으로 참조

- 주의사항 : <context:pro...> 가 두 번 이상 사용될 경우 먼저 처리된 설정만 적용됨

- 해결방법

JavaConfig 기반 설정

@PropertySource, @PropertySources annotation 이용

Environment를 통한 property 이용

Bean에서 Environment 클래스 이용하는 방법

방법 1) EnvironmentAware interface 구현

방법 2) @Autowired 를 통한 Environment 객체 자동 주입

Message Source 

텍스트 메시지들을 프로그램 내에 직접 작성하지 않고 외부 property file에 저장 후 참조

Message bundle 정의 및 활용

ApplicationContext 가 위의 인터페이스를 상속하고 AbstractApplicationContext 클래스가 구현

Bean 객체에서 Message 참조 방법

방법 1) MessageSourceAware 인터페이스 구현

방법 2) ApplicationContextAware 인터페이스 구현 (MessageSourceAware 의 상위 클래스)

Auto-wiring

: DI를 명시적으로 설정하지 않아도 container가 bean의 타입이나 이름을 이용하여 DI를 자동으로 수행하는 기능

XML 기반 설정

예시)

- byName (setter-based injection)

: property와 같은 name(또는 id) 값을 갖는 bean을 찾아 주입한다.

- byType (setter-based injection)

: property와 같은 타입을 갖는 bean을 찾아 주입한다.

단, Instrument 객체가 하나만 존재할 경우에만 쓸 수 있다.

- Constructor (constructor-based injection)

: 생성자 호출 시, argument와 같은 타입을 갖는 bean을 찾아 전달한다.

단, 해당 객체가 유일하게 존재할 경우에만 쓸 수 있다.

Auto-wiring과 명시적 설정의 혼합

자동 설정을 이용하되, 일부 preperty에 대해 명시적으로 <property>나 <constructor-arg>를 이용해 DI 설정 가능하다.

주의) 명시적 설정이 자동 설정보다 우선적으로 적용된다.

주의할 점

- byName, byType 방식 : 주입 가능한 bean이 없을 경우, DI 수행을 안 함

- byType, constructor 방식 : 주입 가능한 bean이 여러 개일 경우, exception 발생

(NoUniqueBeanDefinitionException)

- constructor 방식 : 자동 주입에 사용 가능한 생성자가 여러 개일 경우 exception 발생

- Auto-wiring은 다양한 타입의 bean 객체들이 다수 존재하고, 특정 타입의 bean객체가 한 개씩만 존재할 때 효과적이다.

- 그러나 객체 간의 의존 관계를 명확히 파악하기 어렵고 부작용이 발생할 위험이 있다.

참고 : 부모 Bean을 통한 설정 재사용

Bean들 사이에 중복되는 설정이 많을 경우 추상 bean을 정의하고 그 설정을 재사용(상속)

- abstract : true값을 갖는 경우, 추상 bean 생성(객체 생성 불가)

예1)

예2)

Java Code 기반 설정

@Configuration, @Bean annotation 사용

@Configuration : 이 클래스를 Spring bean의 설정 정보로 사용한다.

@Bean : 이 메서드가 생성 및 반환하는 객체를 bean 객체로 등록한다. method 이름을 bean의 id로 사용한다.

         or name 속성을 통해 bean의 id를 지정 가능하다.

- 생성자 기반 의존 관계 설정 (DI)

- Setter-method 기반 의존 관계 설정 (DI)

Collection Wiring

: Collection(List, Set, Map, Properties, ...) 객체 생성 및 주입

주의! 생성되는 bean들은 기본적으로 singleton 객체이다.

같은 메서드를 여러 번 호출해도 객체는 내부적으로 한 번만 생성되고 호출된다.

Java code 기반 설정 사용 방법

AnnotationConfigApplicationContext class를 container로 사용한다.

여러 개의 JavaConfig 클래스 사용

방법 1 :@Autowired를 이용해 설정 클래스의 객체를 주입한다.

방법 2 : @Autowired를 통해 필요한 의존 객체들을 자동 주입한다.

방법 3 : 모든 설정 클래스를 파라미터로 전달

방법 4 : @import annotation를 이용한 설정정보 결합

Annotaion 기반 설정

- XML 설정을 해줘야 함 !!

@Required

: property에 대한 setter method 앞에 사용

@Autowired

- 생성자, property, method에 대해 적용 가능

: setter 뿐만 아니라 일반 메서드에도 적용 가능

- bean들 사이의 의존 관계를 type을 이용하여 자동 설정

* 만약 할당 가능한 타입의 bean 객체가 존재하지 않을 경우, NoSuchBeanDefinitionException

* 만약 하당 가능한 타입의 bean 객체가 여러 개일 경우, NoUniqueBeanDefinitionException

- required 속성

: 의존 객체 주입이 반드시 필요한지 여부를 나타낸다.

: required = false로 하면 할당가능한 bean이 존재하지 않더라도 exception을 발생시키지 않는다.

- XML 설정

- Java Code 기반 설정

Collection Type property

원소 타입의 모든 bean을 모아서 하나의 collection 객체를 생성 및 주입한다.

- 주의사항

1) autowired를 property에 직접 적용할 경우, setter method가 존재하지 않아도 DI가 실행된다.

2) @Autowired를 property나 setter method, 일반 method에 적용할 경우,

Default 생성자를 통해 객체가 생성되고, 의존 객체가 주입된다.

* Default 생성자가 없고 인자가 있는 생성자가 존재할 경우 exception 발생 !

@Nullable

: @Autowired + @Nullable 사용시 할당 가능한 Bean이 존재하지 않는 경우 null을 주입한다.

@Qualifier

자동 주입 가능한 bean이 여러 개일 때, 특정 bean에 대해 한정자를 붙이거나 특정 bean을 선택하기 위해 사용한다.

- XML 이용 시,

- Java Config 이용 시,

- Bean 클래스에서 정의 시,

@Value

int, boolean, float, String 등의 값을 전달함

@Resource

: @Autowired + @Qualifier

- 주의사항

: name 속성이 생략되면 property 이름을 사용한다.(autowiring by name)

만약 이름이 같은 bean을 찾지 못하면, autowiring by type으로 전환

만약 할당 가능한 bean이 없거나 여러 개이면 exception 발생 !

참고 : JSR - 330 Annotations

Bean Scan

Annotation을 이용한 자동 bean 탐색 및 등록

1) 특정 어노테이션이 붙은 클래스에 대해 자동으로 bean을 등록하는 기능

@Component, @Controller, @Service, @Repository, @Aspect, @Configuration

속성으로 bean의 id 지정 가능, 지정하지 않았다면 클래스 이름으로(첫글자소문자) 지정

2) XML 또는 JavaConfig 클래스에서 명시적인 Bean 설정 생략 가능하다.

예시)

XML 설정 방법

<context:component-scan />

JavaConfig 설정 방법 : @ComponentScan

참고) beanScan 범위 설정

include-filter : 포함시킬 클래스 

exclude-filter : 제외시킬 클래스

설정 방식의 장단점

XML

장점 : 클래스들과 설정 정보를 분리할 수 있고, 관심사의 분리

단점 : 값이 모두 String 타입이므로 type-safe 하지 않음(즉 오타가 있을 때 debugging의 어려움)

Annotation 기반 설정 + bean scan

장점 : Java code 설정하므로 type-safe하고, 적용이 빠름

단점 : 설정이 클래스들과 결합(분산)되어 관리나 관심사의 분리가 어려움

Java Code 기반 설정

장점 : 클래스들과 설정을 분리할 수 있고 관심사의 분리 가능, java code로 설정하므로 type-safe

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 기반)

www.acmicpc.net/problem/9184

코드

MAX_NUM = 51
dp = [[[0 for i in range(MAX_NUM)] for i in range(MAX_NUM)] for i in range(MAX_NUM)]

def w(a, b, c):

    if a <= 0 or b <= 0 or c <= 0:
        return 1


    if dp[a][b][c]:
        return dp[a][b][c]


    if a > 20 or b > 20 or c > 20:
        return w(20,20,20)

    elif a < b and b < c:
        dp[a][b][c] = w(a, b, c-1) + w(a, b-1, c-1) - w(a, b-1, c)
        return dp[a][b][c]
    else:
        dp[a][b][c] = w(a-1, b, c) + w(a-1, b-1, c) + w(a-1, b, c-1) - w(a-1, b-1, c-1)
        return dp[a][b][c]


while True:
    x, y, z = map(int, input().split())
    if x == -1 and y == -1 and z == -1:
        break

    print("w(%d, %d, %d) = %d" %(x, y, z, w(x, y, z)))

문제에서 알려준 함수대로 구현을 먼저하되,

메모이제이션을 이용해서 이미 구한 적 있는 값은 다음 과정을 거치지 않고 바로 반환할 수 있도록 한다.

새로 알게된 문법 )

3차원 리스트 초기화하기 !

MAX_NUM = 51
dp = [[[0 for i in range(MAX_NUM)] for i in range(MAX_NUM)] for i in range(MAX_NUM)]

MAX_NUM을 5로 한다면,

이렇게 된다고 생각하면 된다.

www.acmicpc.net/problem/4949

코드

from collections import deque
deq = deque()

while True:

    s = input()
    flag = 1

    if s[0] == '.':
        break

    for i in range(len(s)):

        if s[i] == '[' or s[i] == '(':
            deq.append(s[i])
        elif s[i] == ']':
            if len(deq) != 0 and deq[len(deq)-1] == '[':
                deq.pop()
            else:
                flag = 0
                break
        elif s[i] == ')':
            if len(deq) != 0 and deq[len(deq)-1] == '(':
                deq.pop()
            else:
                flag = 0
                break

    if flag == 1 and len(deq) == 0:
        print("yes")
    else:
        print("no")

    deq.clear()

새로 알게된 문법 )

deq.clear() 하면 덱 안의 값이 모두 삭제된다.