Spring STEP 2 - 스프링 구성요소

★ 스프링 구성 요소

• DI
• AOP

 

■ 프로젝트 생성하기

• New
• > Spring Legacy Project
• > Spring MVC Project
• > name : "BeginTest"

• "com.test.begin"

 

★ 파일 구조

 

1. src/main/java

• 여태까지 사용하던 Java 소스 폴더

2. src/main/resources

• Java 소스 이외의 자원 폴더
• 주로 스프링 설정 파일

3. src/test/java

• 테스트용

4. src/test/resources

• 테스트용

5. JRE System Library

• JRE jar
• JavaSE-1.6 > JDK 1.6  > (수정) > JDK 11

6. Maven Dependencies

• 메이븐(빌드 도구, 라이브러리 관리 도구 등..)
• 프로젝트 생성 & 유지 관리 & 배포를 도와주는 프로그램
• 수업용 > jar 파일 관리 용도

7. src

• 1~4번 까지의 폴더를 물리적 표현 > 윈도우 탐색기처럼 표시

7.1 Webapp
    - 웹 루트 폴더

7.2 Webapp > resources
    - CSS, JavaScript, Images 등을 저장하는 폴더
    - 강제력(X) > 권장(O)

7.3 webapp > WEB-INF
    7.3.1 classes
        - 컴파일된 클래스 파일 저장 폴더(이전에 bin)
        - 개발자 관여(X)

    7.3.2 spring (*****)
        - 스프링의 모든 설정

        7.3.2.1 appServlet
            - servlet-context.xml : 스프링 설정 파일(MVC 관련, 웹과 관련)

        7.3.2.2 root-context.xml : 스프링 설정 파일(스프링 전반)

    7.3.3 views
        - 뷰 페이지 폴더

    7.3.4 web.xml
        - 아파치 톰캣 서버 설정

7.4 pom.xml, Project Object Model
    - 메이븐 프로그램 설정 파일

 

★ 실행 확인

• 프로젝트 -> 마우스 오른쪽 -> Run AS ->  Run on Server

 

■ pom.xml 버전 수정 ( 프로젝트 변경 시 계속 해주어야함)

• pom.xml 수정후
• 프로젝트 > 마우스 오른쪽 클릭 > Maven > Update Project
• C:\Users\kcv54\.m2\repository >> 메이븐이 다운로드한 jar파일을 보관하는 폴더

 

★ Spring [ DI, AOP : 스프링 기술(X) ]

 

1. Spring DI

• 정의

- DI : 디자인 패턴
- Dependency Injection
- 의존(성) 주입
- 스프링에서 중요한 개념 > 스프링의 모든 객체 관리에 사용.
- 프로그래밍에서 구성 요소간의 의존 관계가 소스 내부가 아닌 외부 환경에서 정의되게 하는 디자인 패턴

• 1-1. 기존 방식

//의존 관계
//Main > (의존) > Hong > (의존) > Pen
//- Pen은 Hong의 의존객체다.
//- Hong은 Main의 의존객체다.


//기존 방식
//- 의존 객체를 직접 생성한다.
Hong hong = new Hong();
hong.run();

• 1-2. 의존 주입(DI) 방식

//- 의존 관계를 다른 방식으로 형성하는 디자인 패턴
//- 의존 주입 > 의존 객체를 자신이 직접 생성하지 않고, 다른 누군가에 의해 건내받는 패턴
Brush b = new Brush();

//Lee lee = new Lee(b); //의존 주입(DI) 발생

Lee lee = new Lee();

lee.setB(b); //의존 주입(DI) 발생

lee.run();

• 1-3. 스프링을 이용하기
• xml 파일 -> beans 객체 선언

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
	스프링이 현재 XML에 정의된 <beans>를 통해서 객체를 관리
	 
	스프링에서 관리하는 객체를 Spring Bean이라고 부른다.
 
-->
<beans xmlns="http://www.springframework.org/schema/beans"
   		   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   		   xsi:schemaLocation="http://www.springframework.org/schema/beans
           							  https://www.springframework.org/schema/beans/spring-beans.xsd">
           							  
       	<!-- 
       		스프링이 관리하는 객체 : Spring Bean 
       		
       		Pen p1 = new Pen();
       			
       	-->
       	<bean id="pen" class="com.test.di02.Pen"></bean>			
       	
       	<!-- name: alias -->
       	<bean id="brush" name="b1 b2 b3" class="com.test.di02.Brush"></bean>	
       	
       	<bean id="hong" class="com.test.di02.Hong">
       		<!-- 스프링 의존 주입(DI) : Constructor 주입 -->
       		<constructor-arg ref="pen"></constructor-arg>
       	</bean>	  
       	
       	<bean id="lee" class="com.test.di02.Lee">
       		<!-- 스프링 의존 주입(DI) : Setter 주입 -->
       		<property name="brush" ref="brush"></property>
       	</bean>  					  
           							  
</beans>

• 선언 및 사용

//Pen 객체 생성하기 > 스프링을 통해서 생성하기
//절대 경로
//ApplicationContext context = new ClassPathXmlApplicationContext("file:/src/main/java/com/test/di02/di02.xml");
//상대 경로
ApplicationContext context = new ClassPathXmlApplicationContext("com/test/di02/di02.xml");

Pen p2 = (Pen)context.getBean("pen"); //id
p2.write();

Brush b1 = (Brush)context.getBean("b1");
b1.draw();

Brush b2 = (Brush)context.getBean("b2");
b2.draw();

Brush b3 = (Brush)context.getBean("brush");
b3.draw();

//-------------------------------------------------------------------
Hong hong = (Hong)context.getBean("hong");
hong.run();

Lee lee = (Lee)context.getBean("lee");
lee.run();

 

■ Spring 어노테이션 방식(jUnit)

• 의존 주입
• @Component : <bean> 태그와 동일하 역할
• @Autowired : 의존주입 어노테이션

//@Component : <bean> 태그와 동일한 역할
// > 스프링에 관리하는 객체

//@Autowired : 의존주입 어노테이션
// > 아래에 있는 대상에 객체를 주입해주세요~

@Component
public class Hong {

	private Pen pen;
	
	@Autowired
	public Hong(Pen pen) {
		this.pen = pen;
	}
	
	public void run() {
		pen.write();
	}
	
}

• Test

package com.test.di03;

import static org.junit.Assert.assertNotNull;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import lombok.extern.log4j.Log4j;

//테스트 용도 자바 클래스 > JUnit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("file:src/main/webapp/WEB-INF/spring/root-context.xml")
@Log4j
public class DITest {

	private Hong hong;
	
	@Autowired
	public void setHong(Hong hong) {
		this.hong = hong;
	}
	
	@Test
	public void testExist() {
		
		//여러가지 테스트
		assertNotNull(hong); //객체 생성 유무?
		
		hong.run();
		
	}
	
}

 

2. Spring AOP, Aspect Oriented Programming

• 정의

- 관점 지향 프로그래밍
- 관점, 관심사  > 코드를 작성하는데 필요한 주 업무가 아닌, 나머지 신경써야할 보조 업무
- 핵심 업무는 아니지만, 코드를 완성하기 위해서 필요한 나머지 업무들
- Concern > 관심사, 관점

• 방식 차이

[게시판 글쓰기]
1. 기존 방식
	- Add.do
		a. 글쓰기 : 주업무
		b. 권한 체크 : 보조업무
	- 주업무와 보조업무를 같은 곳에서 구현(한 파일에서 구현)
2. AOP 방식
	- Add.do
	- 주업무와 보조업무를 분리시켜서 따로 구현
	- 스프링을 통해서 주업무와 보조업무를 다시 결합 후 동작

• Spring AOP 용어

1. Core Concern
	- 비즈니스 코드, 주 업무
	
2. Cross-cutting Concern
	- 보조 업무 
	
3. Target
	- 순수한 비즈니스 로직을 소유한 객체
	- 메소드	

4. Proxy
	- Target을 감싸고 있는 객체
	
5. JoinPoint
	- Target이 가진 메소드(주업무)

6. Pointcut
	- 보조업무와 어떤 JoinPoint에 연결하는 작업
	
7. Aspect
	- 보조업무를 구현하는 객체
	
8. Advice
	- 주업무가 실행되는 어느 시점에서 보조 업무를 실행할지?
	
	- Before Advice
		- 주업무가 실행되기 전에 보조업무를 실행
		
	- After Advice
		- 주업무가 종료된 후에 보조업무를 실행
		- 주업무의 성공 유무와 상관 없이 실행
		
	- Arround Advice
		- 주업무 실행 전후에 보조업무를 실행
		
	- After-returning Advice
		- After Advice와 유사
		- 주업무가 성공했을 때만 실행
		
	- After-throwing Advice		
		- 예외가 발생할 때만 실행

■ 방식 별 차이

• 1. XML 방식

- "com.test.aop1" 패키지 생성	
    > "Main.java"					//메인

    > "Memo.java"(I)				//메인 업무 객체(인터페이스)
    > "MemoImpl.java"(c)		//메인 업무 객체(클래스)

    > "Logger.java"(c)				//보조 업무 객체(클래스)

    > "memo.xml"					//스프링 설정 파일(<beans>)