'Back-End/SpringFrame_1'에 해당되는 글 23건

DI_2

1. Bean 정의 파일로 DI

1_1. BeanFactory

- DI 컨테이너의 핵심이 됨

- BeanFactory는 실행 시에 건네지는 Bean정의 파일(applicationContext.xml)을 바탕으로 인스턴스를 생성하고 인젝션한다

- 웹 어플리케이션 개발에 개발자가 직접 이용하는 일은 별로 없다

- ClassPathXmlApplicationContext는 BeanFactory의 상위에 있다

- BeanFactory의 이용

BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");

1) Bean정의 파일

- Bean의 정의 파일을 프로퍼티, xml, LDAP 등으로 다루지만 XML이 일반적이다

- Bean정의 파일 이용시 Setter 메소드가 필요하다

- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <bean id="productService" class="DI.service.ProductServiceImpl" autowire="byType"/> <bean id="productDao" class="DI.dao.ProductDaoImpl"/> </beans>

- ProductServiceImpl

package DI.service; import DI.dao.ProductDao; import DI.domain.Product; public class ProductServiceImpl implements ProductService{ private ProductDao productDao; public Product findProduct(String name){ return productDao.findProduct(name); } public void setProductDao(ProductDao productDao){ this.productDao = productDao; } }

2) Bean 정의 파일 분할

- 규모가 커질수록 빈 정의 파일을 분할 하는게 좋다

- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="${jdbc.driverClass}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> </beans>

- applicationContext-bean.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <bean id="productService" class="DI.service.ProductServiceImpl" autowire="byType"/> <bean id="productDao" class="DI.dao.ProductDaoImpl"/> </beans>

- import.xml

<beans> <import resource="config/services.xml"/> <import resource="resources/dataaccess.xml"/> </beans>

3)  프로퍼티 파일 이용

a.  bean정의 파일 경우

- message.properties

message = "Hello Spring"

- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <util:properties id="msgProperties" location="classpath:DI/properties/message.properties"/> <bean id="message" class="sample.MessageServiceImpl"> <property name="message" value="#{msgProperties.message}"/> </bean> </beans>

- MessageServiceImpl

package DI.service; public class MessageServiceImpl implements MessageService{ private String message; public void setMessage(String message){ this.message = message; } public String getMessage(){ return message; } }

b. annotation  경우

- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <context:annotation-config/> <context:component-scan base-package="DI.*"/> <util:properties id="msgProperties" location="classpath:DI/properties/message.properties"/> </beans>

- MessageServiceImpl

package DI.service; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; @Component public class MessageServiceImpl implements MessageService{ @Value("#{msgProperties.message") private String message; public String getMessage(){ return message; } }

2. ApplicationContext

- ApplicationContext 는  BeanFactory를 확장해 Bean 정의파일 읽기, 메세지 소스, 이벤트 처리 등의 기능을 추가한것이다

2_1. Bean 정의 파일 읽기

- 웹 어플리케이션은  ContextLoaderListener 클래스나  ContextLoaderServlet 클래스에 의해 자동으로 ApplicationContext(XmlWebApplicationContext 클래스)가 로드됨

a. web.xml

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" > <web-app> <display-name>Archetype Created Web Application</display-name> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- Listener를 사용 할수 없을시 <servlet> <servlet-name>context</servlet-name> <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> --> </web-app>

b. 복수의  Bean 정의 파일

<context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml / WEB-INF/applicationContext-persist.xml</param-value> </context-param>

c. 웹 어플리케이션에선 ApplicationContext를 클래스에서 직접 이용할 일이 없지만 간단한 예제 어플리케이션을 만들때는 아래처럼 사용한다

    ApplicationContext context = new ClassPathXmlApplicationContext("a.xml","b.xml","c.xml");

d. ApplicationContext를 POJO로 만들어진 클래스에 직접 이용할떄

- @Autowired를 사용

@Component public class ProductServiceImpl implements ProductService{ private ProductDao productDao; @Autowired private ApplicationContext ac; public Product findProduct(String name){ productDao = (ProductDao) ac.getBean("/DI/dao/ProductDaoImpl.class"); return productDao.findProduct(name); } }

3. Spring logging

- 스프링은 기본적으로 Commons Logging으로 로그를 출력함

- Log4j라이브러리가 있으면 Commons Logging이 Log4j를 사용한다

- WEB-INF 또는 클래스 패스 아래에 두면 사용가능하다

- log4j.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> <appender name="stdout" class="org.apache.log4j.ConsoleAppender"> <layout class="org.apahce.log4j.PatternLayout"> <param name="ConversionPattern" value="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/> </layout> </appender> <logger name="org.springframework.beans"> <level value="debug"/> </logger> <logger name="org.springframework.transaction"> <level value="debug"/> </logger> <root> <priority value="error"/> <appender-ref ref="stdout"/> </root> </log4j:configuration>

4. Spring unitTest

- DI 컨테이너로 관리하는 오브젝트를 유닛 테스트하기 위한 기능이 제공됨

- Test.java

package DI.test; import org.junit.Test; import org.junit.runner.RunWith; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.*; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import DI.domain.Product; import DI.service.ProductService; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations={"../applicationContext.xml"}) public class ProductServiceTest { @Autowired ProductService productService; @Test public void testFindProduct(){ Product product = productService.findProduct("Kyle"); assertEquals(new Product("Kyle",100),product); } }

- 데이터 베이스 테스트시 자바의 내장 데이터베이스를 사용한다

DI_1

1. What is DI

- DI는 인터페이스를 이용해 컴포넌트화를 실현함

- 오브젝트 사이의 의존 관계를 만든다

1_1 DI 하지 않았을때

- 각자의 new한 다음에 각각의 인스턴스를 생성해서 사용

1_2 DI 사용

- new라는 키워드를 사용하지 않는다

- DI컨테이너 생성, ProductService의 인스턴스 취득은 ApplicationContext에서 함

- 작은 어플리케이션에서는 main에서 DI컨테이너 생성

- DI컨테이너가 인스턴스를 생성할 클래스, 인스턴스를 전달 받은 클래스는 모두 POJO로 작성된다

- 팩토리메소드 같은 디자인 패턴이 필요없다

- DI컨테이너는 클래스를 단 한번 인스턴스로 만들고 재사용 함으로 싱글톤을 구현한다

2. Using of DI

- 서비스와 컨트롤러, 서비스와 DAO의 의존관계를 구축하는데 어울림

- 서비스와 도메인(Product), DAO와 도메인(Product)은 어울리지 않는다

3. DI by using annotation

3_1. DI를 사용하는 방법

1) Bean정의 파일을 사용한 DI

2) Annotation을 사용한 DI

3_2. @Autowired, @Component

package DI.service; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import DI.dao.ProductDao; import DI.domain.Product; @Component public class ProductServiceImpl implements ProductService{ @Autowired private ProductDao productDao; public Product findProduct(String name){ return productDao.findProduct(name); } }

- DI 컨테이너는 @Autowired가 붙은 인스턴스 변수의 형에 대입할 수 있는 클래스를 @Component가 붙은 클래스 중에서 찾아내 그 인스턴스를 인젝션한다

- 인젝션이 setProductDao 같은 셋터 메소드는 필요없다

3_3. applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <context:annotation-config/> <context:component-scan base-package="DI.*"/> </beans>

- bean 스키마 : Bean(컴포넌트) 설정

- context스키마 : Bean(컴포넌트) 검색과 애노테이션 설정

- <context:annotation-config/>

@Autowired, @Resource를 이용할 때의 선언이다

context:component-scan혹은 mvc:annotation-driven이 있으면 생략 가능

- <context:component-scan base-package=""/>

@Component, @Service등의 컴포넌트를 이용할떄 선언

context:exclude-filter(검색하지 않는 컴포넌트 조건)

use-default-filters="false"(지정한 패키지 아래 컴포넌트를 찾지 않을떄)

context:include-filter(검색할 컴포넌트릐 조건)

3_4. @Autowired

1) @Autowired 위치

- 메소드에 선언

@Autowired public void setFoo(Foo foo){ this.foo = foo } @Autowired public void setFoo(Foo foo, Bar bar){ this.foo = foo; this.bar = bar; } ..... @Component public class Foo{ } @Component public class Bar{ }

- 생성자 인젝션

public class Foo{ @Autowired public Foo(Bar b){...}

2) @Autowired 필수 설정

@Autowired(required = false) public void setFoo(Foo foo){ this.foo = foo; }

3) 인젝션할 클래스 찾는 방법

(1) byType 

- @Component가 붙은 클래스가 여러개 있어도 형이 다르면 @Autowired가 붙은 인스턴스 변수에 인젝션되지 않는다

(2) byName 

- 인젝션할 클래스를 형이 아닌 이름으로 찾아주는 방법

@Autowired @Qualifier("productDao") private ProductDao productDao; ... @Component("productDao") public class ProductDaoImpl implements ProductDao{ ... }

(3) context:component-scan 이용

- context:component-scan을 어느 정도 크기의 컴포넌트마다 기술해 두고, 만약 어떤 컴포넌트를 테스트 용으로 바꾸자고 할때는 그 컴포넌트 부분의 정의만 테스트로 바꿈

-평상시

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="..."> <context:annotation-config/> <context:component-scan base-package="sample.di.business.*"/> <context:component-scan base-package="sample.di.service.*"/> </beans>

- 컴포넌트 스캔변경

<beans xmlns="..."> <context:annotation-config/> <context:component-scan base-package="sample.di.business.*"/> <!-- <context:component-scan base-package="sample.di.service.*"/> --> <context:component-scan base-package="test.*"/> </beans>

3_5. @Component

- @Component는 DI 컨테이너가 관리하는, 주로 인젝션을 위한 인스턴스를 설정함

- 클래스 선언 앞에 @Component를 붙이면 스프링의 DI컨테이너가 찾아서 관리함

1) @Component의 확장

- @Controller

- @Service

- @Repository

2) @scope

- @Scope뒤에 value속성을 지정하면 인스턴스화와 삭제를 제어함

- @Scope을 생략하면 해당 클래스는 싱글톤이된다

@Component @Scope("singleton") public class ProductDaoImpl implements ProductDao{ ... }

singleton : 인스턴스를 싱글톤으로 한다

prototype : 이용할 떄마다 인스턴스화 한다

request : Servlet API의 Request 스코프인 동안만 인스턴스가 생존한다

session : Servlet API의 Session 스코프인 동안만 인스턴스가 생존

예제 소스 : https://github.com/KyleJeong/SpringFramework/tree/master/simpleProject/src/main/java/DI

 AOP_1

1. What is AOP?

- AOP란 업무 등 특정 책임이 있는 클래스(예로 주문 클래스, 계좌클래스) 안에 본질적인 처리만 기술하고, 본질적이지 않은 처리는 밖으로 꺼내는 기술(로그, 트랜잭션)

- AOP를 도입함으로 오브젝트가 원래 실행해야 하는 본질적인 처리와 그밖에 횡단관심사(Crosscutting concerns)로 불리는, 복수의 오브젝트에 걸쳐 기술되기 쉬운 처리를 분리해 모듈성을 높인다

1_1. AOP

1) Aspect

- Advice(동작) + Pointcut(동작 적용조건)

- 횡단관심사의 동작과 그 횡단관심사를 적용하는 소스 코드상의 포인트를 모은 것\

2) Joinpoint

- 어드바이스가 실행하는 동작을 끼워 넣을 수 있는 때

- 메소드가 정확히는 메소드가 호출 될 떄와 메소드가 원래 호출한 곳으로 돌아갈 떄를 말한다

3) Advice

- 조인포인트에서 실행되는 코드

4) Pointcut

- 조인포인트와 어드바이스의 중간에 위치 하여 처리가 조인포인트에 이르렀을때 어드바이스를 호출할지 선별한다

2. Advice

2_1. Advice의 종류

• Before : 조인포인트 앞에서 실행할 어드바이스
• After :  조인포인트 뒤에서 실행할 어드바이스
• AfterReturning : 조인포인트가 완전히 정상 종료한 다음에 실행되는 어드바이스
• Around : 조인포인트 앞뒤에서 실행되는 어드바이스
• AfterThrowing : 조인포인트에서 예외가 발생했을 떄 실행되는 어드바이스

3. Proxy

- 프록시를 이용한 AOP 구현

1) Q클래스엔 R 인터페이스 타입의 인스턴스 변수가 있으며 @Autowired 되어있다

2) RImpl 클래스의 어느 메소드를 실행해도 어드바이스가 동작한다고 가정

3) DIxAOP 컨테이너는 R인터페이스를 구현한 프록시 클래스의 인스턴스 자동생성하여 Q클래스의 R인터페이스형 인스턴스에 인젝션해버린다

4) Q클래스는 인젝션 된 내용이 R인지 프록시인지 알수 없다

5) 자동 생성된 프록시 클래스의 인스턴스는 진짜 RImpl 클래스로 구현된 메소드를 호출하게 되어있고 종류에 따라 RImpl 클래스의 메소드를 호출하기 전후에 어드바이스를 호출한다 

4. Skill of Spring

- 스프링에는  POJO프로그래밍을 손쉽게 할 수 있도록 지원하는 세가지 가능 기술( enaling technology)을 제공한다.

- IoC/DI, AOP, PSA

1) 제어의 역전(Ioc)/  의존관계 주입(DI)

- DI 사용이유 : 유연한 확장이 가능하게 하기 위함

- A -> B : 확장은 B가 자유롭게 변경될 수 있음, B가 변경돼도  A는 아무런 영향을 받지 않고 그대로 유지 가능

(1) DI의 활용방법

a. 핵심기능의 변경

- 대표적인 적용방법은 의존 대상의 구현을 바꾸는것 (전략패턴)

- A -> B 구조에서 A의 기능 일부를  B에게 위임한다고 했을 때 B의 구현 방식을 필요에 따라 통째로 B1, B2 처럼 통째로 변경

- 예) 서비스 오브젝트가 사용하는  DAD 의 구현 변경-> JDBC, JPA, 하이버네이트,   iBatis  등으로 통째로 변경 

b. 핵심기능의 동적인 변경

- 일반적인  DI와 다르게 동적으로 매번 다르게 변경 가능

- 예 : 사용자의 등급에 따라서 다르게 DataSource를 사용하게 만들 수도 있다.

- Dao -> DataSource :  Dao하나가 여러개의 DataSource에 의존하게 만들 수 있다.

- VIP에 속한 사용자의 등급에 따라서 그때그때 다른 DataSource를 DAO가 사용하게 함(더 빠르게)

- 다이내믹 라우팅 프록시, 프록시 오브젝트 기법을 활용

c. 부가기능의 추가

- 핵심기능은 그래도 둔 채로 부가기능을 추가(데코레이터 패턴)

- 인터페이스를 두고 사용하게 하고, 실제 사용할 오브젝트는 외부에서 주이하는  DI를 적용해두면 데코레이터 패턴을 쉽게 적용

 d. 인터페이스의 변경

- 클라이언트가 사용하는 인터페이스와 실제 오브젝트 사이에 인터페이스가 일치하지 않는 경우에도 DI유용

- 예 : A가 C오브젝트를 사용하려 한다고 가정 BUT  A -> B 인터페이스만 사용하도록 만들어짐, C는 B인터페이스 구현 안되어있다. 

- A가 DI를 통해 B의 구현 오브젝트를 받도록 만들어져 있다면 -> B 인터페이스를 구현했으면서 내부에서 C를 호출 해주는 기능을 가진 어댑터 오브젝트를 만들어 A에 DI 하면됨

-A -> B(C로위임) -> C

- 좀더 응용하면 PSA(서비스 추상화)

e. 프록시

- 프록시 패턴

- 필요한 시점에서 실제 사용할 오브젝트를 초기화하고 리소스를 준비하게 해주는 지연된 로딩(lazy loading)을 적용 하기위한 방법

- 원격 프로시(원격 오브젝트를 로컬처럼 사용할때)

f. 템플릿과 콜백

- 항상 고정적인 작업흐름과 그사이에서 자주 바뀌는 부분을 분리해서 템플릿과 콜백으로 만들고 이를  DI 원리를 응용해 적용하면 지저분한게 매번 만들어야 하는 코드를 간결하게 만듬

g. 싱글콘과 오브젝트 스코프

- DI가 필요한 이유중 한가지는  DI할 오브젝트의 생명주기를 제어 할 수 있다는 것임.

- 전통적인 싱글톤방식보단 IOC방식이 유용하다.

- 스프링 DI는 기본적으로 싱글톤으로 오브젝트를 만들어서 사용

- 스프링에서는 싱글콘 외에도 다양한 스코프를 갖는 오브젝트를 만들어  DI에 사용 할수도있다.

- HTTP 요청당 하나의 오브젝트를 만들거나 HTTP세션단 하나씩 오브젝트가 만들어 질 수 있다.

h. 테스트

- 여타 오브젝트와 협력해서 동작하는 오브젝트를 효과적으로 테스트하는 방법은 가능한 고립시키는 것임

- 다른 오브젝트와 사이에서 일어나는 일을 테스트를 위해 조작할 수 있도록 만든다.

- 스텁, 또는 목 오브젝트 같은 테스트 대역을 활용

- DI를 위해 만든 수정자 메소드를 사용하면 테스트 코드 안에서 수동으로 목 오브젝트를 주입 할수 있다. 

2) 에스펙트 지향 프로그래밍(AOP)

- AOP와 OOP는 서로 배타적이 아니다.

- IOC/DI를 이용하여 POJO에 선언적인 엔터프라이즈 서비스를 제공할 수 있지만 일부 서비스는 순수한 객체지향 기법만으로는 POJO의 조건을 유지한 채로 적용하기 힘듬

- AOP는 객체지향 기술의 한계와 단점을 극복 하도록 도와주는 프로그램

(1) AOP의 적용 기법

- AOP를 자바 언어에 적용하는 기법은 크게 두가지로 분류함

a. 스프링과 같이 다이내믹 프록시를 사용하는 방법

- 기존 코드에 영향을 주지 않고 부가기능을 적용하게 해주는 데코레이터 패턴을 응용

- 자바의 객체지향 패턴을 활용, 만들기 쉽고 적용 편리

- 부가기능을 부여할 수 있는 곳이 메소드의 호출이 일어나는 지점뿐이라는 제약

b. 자바 언어의 한계를 넘어서는 언어의 확장을 이용

- AspectJ라는 AOP툴이 존재

- AspectJ는 프록시 방식의 AOP에서는 불가능한 다양한 조인 포인트를 제공, 메소드호출뿐 아니라 인스턴스 생성, 필드 엑세스, 특정 호출 경로를 가진 메소드 호출 등에도 부가기능 추가

(2) AOP의 적용단계

- AOP는 하나의 모듈이 수많은 오브젝트에 보이지 않게 적용되기 때문에 매우 주의해서 사용해야한다.

a. AOP적용 1단계: 미리 준비된 AOP 이용

-  스프링이 제공하는 대표 AOP는 트랜잭션

- DB를 사용하는 애플리케이션이면 트랜잭을 필요로 하니 적용해서 AOP를 관찰

- @Configurable 애노테이션을 이용해서 도메인 오브젝트에 DI를 자동적해주는 AOP기능

b. AOP적용 2단계: 전담팀을 통한 정책 AOP 적용

- 소수의 AOP 전담팀을 가짐

- 오브젝트보안,  특정계층의 오브젝트를 이용 전후의 작업 기록을 남기는 로깅 등

c.AOP 적용 3단계: AOP의 자유로운 이용

- 1단계와 2단계를 거치고 익숙해지면 이제 개발자 스스로 활용

3) 포터블 서비스 추상화(PSA)

-  환경과 세부 기술의 변화에 관계없이 일관됭 방식으로 기술에 접근 할 수 있게 해주는  PSA이다

- 스프링은  JavaEE기술에 의존적일 수 밖에 없다. -> POJO? -> PSA 활용

- 트랜잭션 서비스 추상화 : 코드를 이용해 트랜잭션을 제어하지 않는다면 직접 이용할 이유가 없다. -> AOP를 이용하기 때문 -> 대신 구체적인 서비스 클래스를 빈으로 등록

soucre of post is Spring of Toby3