'[Spring]'에 해당되는 글 34건

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# @Autowired

    - 클래스 타입을 통한 자동 주입.

    - 하나의 클래스만 유일하게 존재할 때 사용하는 것을 추천.

# @Qualifier

    - 이름(아이디)을 통한 자동 주입.

    - 여러개의 동일 클래스가 존재할 때 사용하는 것을 추천.

# Autowired 어노테이션은 setter DI의 형식을 취함.

# XML을 통한 방식 / JAVA을 통한 방식

0. Java , Xml 방식의 기본 Beans 생성.

  - DataBean1.java

package AnnotationBean;

import org.springframework.stereotype.Component;

public class DataBean1 {
	private int a = 10;
	private String b = "간다";
	
	public int getA() {
		return a;
	}
	
	public String getB() {
		return b;
	}
	
	public void setA(int a) {
		this.a = a;
	}
	
	public void setB(String b) {
		this.b = b;
	}
}

  - DataBean2.java

package AnnotationBean;

public class DataBean2 {
	private int a = 20;
	private String b = "온다";
	
	public int getA() {
		return a;
	}
	
	public String getB() {
		return b;
	}
	
	public void setA(int a) {
		this.a = a;
	}
	
	public void setB(String b) {
		this.b = b;
	}
}

  - DataBean3.java

package AnnotationBean;

public class DataBean3 {
	private int a = 20;
	private String b = "온다";
	
	public int getA() {
		return a;
	}
	
	public String getB() {
		return b;
	}
	
	public void setA(int a) {
		this.a = a;
	}
	
	public void setB(String b) {
		this.b = b;
	}
}

  - DataBean4.java

package AnnotationBean;

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

public class DataBean4 {
	private int a = 20;
	private String b = "온다";
	
	// 생성자 기본값을 지정.
	public DataBean4(@Value("1000") int a , @Value("안녕하세요") String b) {
		this.a = a;
		this.b = b;
	}
	
	public int getA() {
		return a;
	}
	
	public String getB() {
		return b;
	}

}

  - TestBean1.java 

package AnnotationBean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class TestBean1 {
	
	// data1, data2의 주입은 사실상 동일하다고 생각해도 된다.
	// @Autowired 어노테이션의 경우 data1에 대한 setter 메소드를 통해서 주입이 된다.	
	@Autowired
	private DataBean1 data1;
	
	// @Autowired가 setter 메소드에 붙힘으로써 setter 메소드를 통해서 주입이 된다.
	private DataBean2 data2;
	@Autowired
	public void setData2(DataBean2 data2) {
		this.data2 = data2;
	}
	
	// @Autowried는 클래스 형식으로 찾을 때, 
	// 동일한 클래스가 한 개 이상 지정되어 있으면,
	// @Qualifier를 통해서 이름(id)값을 통해 지정한다.
	@Autowired
	@Qualifier("data3_1")
	private DataBean3 data3_1;
	
	// @Autowried는 클래스 형식으로 찾을 때, 
	// 동일한 클래스가 한 개 이상 지정되어 있으면,
	// @Qualifier를 통해서 이름(id)값을 통해 지정한다.
	@Autowired
	@Qualifier("data3_2")
	private DataBean3 data3_2;
	
	@Autowired
	@Qualifier("data4_1")
	private DataBean4 data4_1;
	
	@Autowired
	@Qualifier("data4_2")
	private DataBean4 data4_2;
	
	public TestBean1() {
		System.out.println("TestBean1 Created");
	}
	
	// Getter 부분.	
	public DataBean1 getData1() {
		return data1;
	}
	
	public DataBean2 getData2() {
		return data2;
	}
	
	public DataBean3 getData3_1() {
		return data3_1;
	}
	
	public DataBean3 getData3_2() {
		return data3_2;
	}
	
	public DataBean4 getData4_1() {
		return data4_1;
	}
	
	public DataBean4 getData4_2() {
		return data4_2;
	}
}

1. JAVA을 통한 방식

- AnnotationJavaBeans.java : Object을 대한 정보를 정의.

package config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import AnnotationBean.DataBean1;
import AnnotationBean.DataBean2;
import AnnotationBean.DataBean3;
import AnnotationBean.DataBean4;
import AnnotationBean.TestBean1;

// XML이 방식이 아닌 JAVA의 형식으로 beans.xml을 대체한다.
@Configuration
public class AnnotationJavaBeans {

	@Bean
	public TestBean1 java1() {
		TestBean1 t1 = new TestBean1();
		return t1;
	}

	@Bean
	public DataBean1 data1() {
		DataBean1 d1 = new DataBean1();
		return d1;
	}

	@Bean
	public DataBean2 data2() {
		DataBean2 d2 = new DataBean2();
		return d2;
	}

	// DataBean3의 경우 setter형식	
	@Bean
	public DataBean3 data3_1() {
		DataBean3 d3 = new DataBean3();
		d3.setA(111);
		d3.setB("DataBean3_1");
		return d3;
	}

	// DataBean3의 경우 setter형식
	@Bean
	public DataBean3 data3_2() {
		DataBean3 d3 = new DataBean3();
		return d3;
	}

	// DataBean4의 경우 생성자 형식
	@Bean
	public DataBean4 data4_1() {
		DataBean4 d4 = new DataBean4(1000, "문자열1");
		return d4;
	}

	// DataBean4의 경우 생성자 형식
	@Bean
	public DataBean4 data4_2() {
		DataBean4 d4 = new DataBean4(2000, "문자열1");
		return d4;
	}

}

- main.java : 실행 코드 부분.

// JAVA 파일을 사용하는 방식
		System.out.println("-------------------------------------------");
		AnnotationConfigApplicationContext ctx2 = new AnnotationConfigApplicationContext(AnnotationJavaBeans.class);

		TestBean1 java1 = ctx2.getBean("java1" , TestBean1.class);
		System.out.println("java1.getData1().getA() = > " + java1.getData1().getA());
		System.out.println("java1.getData1().getB() = > " + java1.getData1().getB());
		System.out.println("----------------------");
		
		System.out.println("java1.getData2().getA() = > " + java1.getData2().getA());
		System.out.println("java1.getData2().getB() = > " + java1.getData2().getB());
		
		System.out.println("----------------------");
		System.out.println("java1.getData3_1().getA() = > " + java1.getData3_1().getA());
		System.out.println("java1.getData3_1().getB() = > " + java1.getData3_1().getB());
		
		System.out.println("----------------------");
		System.out.println("java1.getData3_2().getA() = > " + java1.getData3_2().getA());
		System.out.println("java1.getData3_2().getB() = > " + java1.getData3_2().getB());
		
		System.out.println("----------------------");
		System.out.println("java1.getData4_1().getA() = > " + java1.getData4_1().getA());
		System.out.println("java1.getData4_1().getB() = > " + java1.getData4_1().getB());
		
		System.out.println("----------------------");
		System.out.println("java1.getData4_2().getA() = > " + java1.getData4_2().getA());
		System.out.println("java1.getData4_2().getB() = > " + java1.getData4_2().getB());

		System.out.println("----------------------");
		ctx2.close();

실행결과

2. XML을 통한 방식

- Annotataionbeans.xml : Object을 대한 정보를 정의.

<?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.xsd
						http://www.springframework.org/schema/context
						http://www.springframework.org/schema/context/spring-context.xsd">

	<!--  bean 클래스에 설정되어 있는 어노테이션을 이용한다. -->
	<context:annotation-config></context:annotation-config>
	<bean class="AnnotationBean.TestBean1"></bean>
	
	<bean class="AnnotationBean.DataBean1"></bean>
	<bean class="AnnotationBean.DataBean2"></bean>
	
	<bean id="data3_1" class="AnnotationBean.DataBean3" lazy-init="true">
		<property name="a" value="100"></property>
		<property name="b" value="가나다라"></property>
	</bean>
	
	<bean id="data3_2" class="AnnotationBean.DataBean3" lazy-init="true">
		<property name="a" value="200"></property>
		<property name="b" value="뮤뮤뮤뮤뮤뮤~~"></property>
	</bean>
	
	<bean id="data4_1" class="AnnotationBean.DataBean4"></bean>
	<bean id="data4_2" class="AnnotationBean.DataBean4">
		<constructor-arg index="0" value="20000"></constructor-arg>
		<constructor-arg index="1" value="Hello"></constructor-arg>
	</bean>
	
</beans>

- main.java : 실행 코드 부분.

TestBean1 xml1 = ctx1.getBean(TestBean1.class);
		
		System.out.println("xml1.getData1().getA() = > " + xml1.getData1().getA());
		System.out.println("xml1.getData1().getB() = > " + xml1.getData1().getB());
		System.out.println("----------------------");
		
		System.out.println("xml1.getData2().getA() = > " + xml1.getData2().getA());
		System.out.println("xml1.getData2().getB() = > " + xml1.getData2().getB());
		
		System.out.println("----------------------");
		System.out.println("xml1.getData3_1().getA() = > " + xml1.getData3_1().getA());
		System.out.println("xml1.getData3_1().getB() = > " + xml1.getData3_1().getB());
		
		System.out.println("----------------------");
		System.out.println("xml1.getData3_2().getA() = > " + xml1.getData3_2().getA());
		System.out.println("xml1.getData3_2().getB() = > " + xml1.getData3_2().getB());
		
		System.out.println("----------------------");
		System.out.println("xml1.getData4_1().getA() = > " + xml1.getData4_1().getA());
		System.out.println("xml1.getData4_1().getB() = > " + xml1.getData4_1().getB());
		
		System.out.println("----------------------");
		System.out.println("xml1.getData4_2().getA() = > " + xml1.getData4_2().getA());
		System.out.println("xml1.getData4_2().getB() = > " + xml1.getData4_2().getB());

		System.out.println("----------------------");

실행결과

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# 자바로 Bean 만들기 

    - Spring 의존성 주입을 XML 방식이 아닌 자바로 생성하는 방법.

1. Package JavaBean , JavaTestBean1.java 

   - 패키지 JavaBean에는 생성할 Bean JavaTestBean1.java를 만든다.

package JavaBean;

public class JavaTestBean1 {

	public JavaTestBean1() {
		System.out.println("JavaTestBean1이 생성이 되었습니다.");
	}
}

2. Package config, JavaBeans.java

   - 패키지 config에 JavaBeans.java는 기존의 XML 방식에서 Java형식으로 Bean을 정의한다.

package config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import JavaBean.JavaTestBean1;

// XML이 방식이 아닌 JAVA의 형식으로 beans.xml을 대체한다.
@Configuration
public class JavaBeans {
		
	// AnnotationConfigApplcationContext 되는 순간 생성.
	// getBean할 때 마다 동일한 객체 전달.	
	@Bean
	public JavaTestBean1 testBean1_1() {
		System.out.println("testBean1_1");
		JavaTestBean1 jtb1 = new JavaTestBean1();
		return jtb1;
	}
	
	// getBean하는 순간에 생성 
	// getBean할 때 마다, 객체 생성.
	@Bean
	@Lazy(true)
	@Scope("prototype")
	public JavaTestBean1 testBean1_2() {
		System.out.println("testBean1_2");
		JavaTestBean1 jtb1 = new JavaTestBean1();
		return jtb1;
	}
	
	// testBean50이라는 이름으로 부르도 명시.
	// name이 없는 경우 메소드명으로 부름(default 경우)
	@Bean(name="testBean50")
	public JavaTestBean1 testBean1_3() {
		System.out.println("testBean1_3");
		System.out.println("naming testBean50");
		JavaTestBean1 jtb1 = new JavaTestBean1();
		return jtb1;
	}
		
	@Bean(name="testBean100")
	@Lazy(true)
	public JavaTestBean1 testBean1_4() {
		System.out.println("testBean1_4");
		System.out.println("naming testBean100");
		JavaTestBean1 jtb1 = new JavaTestBean1();
		return jtb1;
	}
}

3. Main.java

package main;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import JavaBean.JavaTestBean1;
import config.JavaBeans;
import constructorDI.StudentData;
import constructorDI.StudentTestBean;

public class Main {

	public static void main(String[] args) {
		// JAVA 파일을 사용하는 방식
		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(JavaBeans.class);
		JavaTestBean1 testBean1_1 = ctx.getBean("testBean1_1", JavaTestBean1.class);
		System.out.printf("testBean1_1 = > %s\n", testBean1_1);
		System.out.println("-------------------------------------------");

		JavaTestBean1 testBean1_2 = ctx.getBean("testBean1_2", JavaTestBean1.class);
		System.out.printf("testBean1_2 = > %s\n", testBean1_2);
		System.out.println("-------------------------------------------");

		JavaTestBean1 testBean50 = ctx.getBean("testBean50", JavaTestBean1.class);
		System.out.printf("testBean50 = > %s\n", testBean50);
		System.out.println("-------------------------------------------");

		JavaTestBean1 testBean100 = ctx.getBean("testBean100", JavaTestBean1.class);
		System.out.printf("testBean100 = > %s\n", testBean100);
		System.out.println("-------------------------------------------");

		ctx.close();
		System.out.println("-ctx.close() 됨");
	}
}

4. 결과화면

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# 의존성 주입 : DI(Dependency Injection) - Constructor DI 주입 

    - Spring 의존성 주입 중 생성자(Constructor)를 통한 방법.

# 수행 과제 

    - 학생들의 정보를 생성자(Constructor)방식을 통해서 주입하는 과정을 알아보도록 하겠습니다.

1. Package SetterDI , StudentTestBean.java , StudentData.java

 생성자(Constructor) 생성

   - 패키지 constructorDI는 Student에 관한 Bean을 생성한다.

   - StudentTestBean.java는 학생의 이름, 학번, 학점 변수와 학생의 정보 객체을 가진다.

   - StudentData.java는 학생의 정보 주소를 가진다.

package constructorDI;

public class StudentTestBean {

	private String stuName; // 학생 이름
	private int stuNum; // 학생 번호
	private double stuGrade; // 학생 점수
	private StudentData stuData;

	// Constructor 방식 DI
	public StudentTestBean(String stuName, int stuNum, double stuGrade, StudentData stuData) {
		this.stuName = stuName;
		this.stuNum = stuNum;
		this.stuGrade = stuGrade;
		this.stuData = stuData;
	}

	public String getStuName() {
		return stuName;
	}

	public int getStuNum() {
		return stuNum;
	}

	public double getStuGrade() {
		return stuGrade;
	}

	public StudentData getStuData() {
		return stuData;
	}

}

package constructorDI;

public class StudentData {
	private String address; // 학생주소

	// constructor 방식 DI
	public StudentData(String stuAddress) {
		this.address = stuAddress;
	}

	public String getAddress() {
		return address;
	}
}

2. ConstructorBeans.xml (생성자 매개 변수 넣는법)

   - index로 위치 지정.

   - 생성자와 동일 순서로 매개변수 지정.

   - 매개변수의 type 지정을 통한 지정.

<?xml version="1.0" encoding="UTF-8" ?>
<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
						http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<!-- 자료형을 명시하지는 않는 경우, String > double > int 형으로 자리를 잡는다. -->
	<!-- 자료형 명시를 통해서 매개변수의 위치를 잡아준다. -->
	<bean id="stuTest1_1" class="constructorDI.StudentTestBean"
		lazy-init="true">
		<constructor-arg value="이름1" type="java.lang.String"></constructor-arg>
		<constructor-arg value="2.2" type="double"></constructor-arg>
		<constructor-arg value="20501212" type="int"></constructor-arg>
		<!-- studentData를 bean을 생성을 통해서 명시 -->
		<constructor-arg index="3">
			<bean class="constructorDI.StudentData">
				<constructor-arg index="0" value="제주" type="java.lang.String"></constructor-arg>
			</bean>
		</constructor-arg>
	</bean>
	
	<!-- index 위치를 지정해주면서, 매개변 위치를 잡아준다. -->
	<bean id="stuTest1_2" class="constructorDI.StudentTestBean"
		lazy-init="true">
		<constructor-arg index="2" value="2.2"></constructor-arg>
		<constructor-arg index="0" value="이름1"></constructor-arg>
		<constructor-arg index="1" value="20501212"></constructor-arg>
		<!-- studentData를 bean을 생성을 통해서 명시 -->
		<constructor-arg index="3">
			<bean class="constructorDI.StudentData">
				<constructor-arg index="0" value="제주" type="java.lang.String"></constructor-arg>
			</bean>
		</constructor-arg>
	</bean>

	<!-- 생성자의 들어가는 매개변수가 생성자와 동일하면 순서대로 명시하면 그대로 들어간다. -->
	<bean id="stuTest2" class="constructorDI.StudentTestBean"
		lazy-init="true">
		<constructor-arg value="이름2"></constructor-arg>
		<constructor-arg value="20501213"></constructor-arg>
		<constructor-arg value="4.5"></constructor-arg>
		<!-- studentData를 bean을 id를 참조를 통해서 명시 -->
		<constructor-arg ref="stuBasicData"></constructor-arg>
	</bean>

	<!-- studentData의 기본형 -->
	<bean id="stuBasicData" class="constructorDI.StudentData"
		scope="prototype">
		<constructor-arg type="java.lang.String" value="서울"></constructor-arg>
	</bean>

</beans>

3. Main.java

package main;


import org.springframework.context.support.ClassPathXmlApplicationContext;

import constructorDI.StudentData;
import constructorDI.StudentTestBean;

public class Main {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/ConstructorBeans.xml");
		System.out.println("--------------------------");

		// getter를 통해서 setter을 통해서 주입한 데이터를 가져온다.
		// student stuTest1 의 정보 출력
		StudentTestBean stb1_1 = ctx.getBean("stuTest1_1", StudentTestBean.class);
		System.out.println("stuTest1 name => " + stb1_1.getStuName());
		System.out.println("stuTest1 num => " + stb1_1.getStuNum());
		System.out.println("stuTest1 grade => " + stb1_1.getStuGrade());
		System.out.println("stuTest1 address => " + stb1_1.getStuData().getAddress());
		// 또는 StudentData stuData= stb1.getStuData(); stuData.getAddress(); 하는 방법도 있다.
		System.out.println("--------------------------");
		
		StudentTestBean stb1_2 = ctx.getBean("stuTest1_2", StudentTestBean.class);
		System.out.println("stuTest1 name => " + stb1_2.getStuName());
		System.out.println("stuTest1 num => " + stb1_2.getStuNum());
		System.out.println("stuTest1 grade => " + stb1_2.getStuGrade());
		System.out.println("stuTest1 address => " + stb1_2.getStuData().getAddress());
		// 또는 StudentData stuData= stb1.getStuData(); stuData.getAddress(); 하는 방법도 있다.
		System.out.println("--------------------------");

		// student stuTest2 의 정보 출력
		StudentTestBean stb2 = ctx.getBean("stuTest2", StudentTestBean.class);
		System.out.println("stuTest2 name => " + stb2.getStuName());
		System.out.println("stuTest2 num => " + stb2.getStuNum());
		System.out.println("stuTest2 grade => " + stb2.getStuGrade());
		System.out.println("stuTest2 address => " + stb2.getStuData().getAddress());

		ctx.close();
		System.out.println("--------------------------");
		System.out.println("-ctx.close() 됨");
	}
}

4. 실행결과.

# 의존성 주입 : DI(Dependency Injection) -Setter DI 주입 

    - Spring 의존성 주입 중 Setter를 통한 방법.

# 수행 과제 

    - 학생들의 정보를 setter 방식을 통해서 주입하는 과정을 알아보도록 하겠습니다.

1. Package SetterDI , StudentTestBean.java , StudentData.java 생성

   - 패키지 SetterDI는 Student에 관한 Bean을 생성한다.

   - StudentTestBean.java는 학생의 이름, 학번, 학점 변수와 학생의 정보 객체을 가진다.

   - StudentData.java는 학생의 정보 주소를 가진다.

package SetterDI;

public class StudentTestBean {

	private String stuName; // 학생 이름
	private int stuNum; // 학생 번호
	private double stuGrade; // 학생 점수
	private StudentData stuData;

	public String getStuName() {
		return stuName;
	}

	public void setStuName(String stuName) {
		this.stuName = stuName;
	}

	public int getStuNum() {
		return stuNum;
	}

	public void setStuNum(int stuNum) {
		this.stuNum = stuNum;
	}

	public double getStuGrade() {
		return stuGrade;
	}

	public void setStuGrade(double stuGrade) {
		this.stuGrade = stuGrade;
	}

	public StudentData getStuData() {
		return stuData;
	}

	public void setStuData(StudentData stuData) {
		this.stuData = stuData;
	}
}

package SetterDI;

public class StudentData {
	private String address; // 학생주소

	public void setAddress(String address) {
		this.address = address;
	}
	
	public String getAddress() {
		return address;
	}
}
​

2. StudentBeans.xml 생성

   - StudentBeans.xml에서는 stuTest1, stuTest2 객체를 생성한다.

      - stuTest1의 학생 정보를 입력하고, StudentData는 bean 객체를 생성한다.

      - stuTest2의 학생 정보를 입력하고, StudentData는 bean 객체를 참조해서 생성한다.

         - 객체 생성시 property에 name을 명시하여, 넣을 변수에 알맞은 값을 value에 넣는다.

<?xml version="1.0" encoding="UTF-8" ?>
<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
						http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<bean id="stuTest1" class="SetterDI.StudentTestBean"
		lazy-init="true">
		<property name="stuName" value="이름1"></property>
		<property name="stuNum" value="205012000"></property>
		<property name="stuGrade" value="2.2"></property>
		<!-- studentData를 bean을 생성을 통해서 명시 -->
		<property name="stuData">
			<bean class="SetterDI.StudentData">
				<property name="address" value="제주"></property>
			</bean>
		</property>
	</bean>

	<bean id="stuTest2" class="SetterDI.StudentTestBean"
		lazy-init="true">
		<property name="stuName" value="이름2"></property>
		<property name="stuNum" value="205012100"></property>
		<property name="stuGrade" value="4.5"></property>
		<!-- studentData를 bean을 id를 참조를 통해서 명시 -->
		<property name="stuData" ref="stuBasicData"></property>
	</bean>

	<!-- studentData의 기본형  -->
	<bean id="stuBasicData" class="SetterDI.StudentData"
		scope="prototype">
		<property name="address" value="서울"></property>
	</bean>

</beans>

3. Main.java 

   - StudentBeans.xml에서는 stuTest1, stuTest2 객체를 생성한다.

   - stuTest1의 학생 정보를 입력하고, StudentData는 bean 객체를 생성한다.

   - stuTest2의 학생 정보를 입력하고, StudentData는 bean 객체를 참조해서 생성한다.

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import SetterDI.StudentData;
import SetterDI.StudentTestBean;

public class Main {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/SetterBeans.xml");
		System.out.println("--------------------------");

		// getter를 통해서 setter을 통해서 주입한 데이터를 가져온다.
		
		// student stuTest1 의 정보 출력
		StudentTestBean stb1 = ctx.getBean("stuTest1", StudentTestBean.class);
		System.out.println("stuTest1 name => " + stb1.getStuName());
		System.out.println("stuTest1 num => " + stb1.getStuNum());
		System.out.println("stuTest1 grade => " + stb1.getStuGrade());
		System.out.println("stuTest1 address => " + stb1.getStuData().getAddress());
		// 또는 StudentData stuData= stb1.getStuData(); stuData.getAddress(); 하는 방법도 있다.
		System.out.println("--------------------------");

		// student stuTest2 의 정보 출력
		StudentTestBean stb2 = ctx.getBean("stuTest2", StudentTestBean.class);
		System.out.println("stuTest2 name => " + stb2.getStuName());
		System.out.println("stuTest2 num => " + stb2.getStuNum());
		System.out.println("stuTest2 grade => " + stb2.getStuGrade());
		System.out.println("stuTest2 address => " + stb2.getStuData().getAddress());

		ctx.close();
		System.out.println("--------------------------");
		System.out.println("-ctx.close() 됨");
	}
}

4. 결과화면

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# 목표 : Bean이 생성시 실행되는 메소드(BeanPostProcessor)에 대해서 알아보겠습니다. 

    - 특정한 자바의 클래스에서 BeanPostProcessor를 implements를 통해서 모든 Bean의 생성 할 때, 확인할 수 있는 클래스를 만들어 보겠습니다.

    - 참고하시면 이해하기 좋은 StackOverflow 자료입니다.

    # https://stackoverflow.com/questions/29743320/how-exactly-does-the-spring-beanpostprocessor-work

#  1. beanPostProcessorTest.java 생성하기

package beanPostProcessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class beanPostProcessorTest implements BeanPostProcessor {

	public beanPostProcessorTest() {
		System.out.println("--------------------------------");
		System.out.println("beanPostProcessorTest를 생성했습니다.");
		System.out.println("--------------------------------");
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("init-method가 시작 되기 전.");
		System.out.println("beanName post process before Initialization = > " + beanName);
		// 객체를 반환
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("init-method가 시작 된 후.");
		System.out.println("beanName post Process After Initialization = > " + beanName);
		// 객체를 반환
		return bean;
	}
}

#  2. beans.xml에 beanPostProcessorTest.java 명시하기

<?xml version="1.0" encoding="UTF-8" ?>
<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
						http://www.springframework.org/schema/beans/spring-beans.xsd"
	default-init-method="defalutInit"
	default-destroy-method="defalutDestory">

	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<!-- init-method와 destory-method에 TestBean.java 시작, 종료 메소드를 지정합니다. -->
	<bean id="test1" class="beans.TestBean1" lazy-init="true"
		init-method="bean1Init" destroy-method="bean1Destory"></bean>

	<!-- bean에는 명시하지 않고, xml 상단에 defalut로 명시합니다. -->
	<!-- <bean id="test2" class="beans.TestBean2" lazy-init="true"></bean> -->

	<!-- bean에도 명시하고 , xml 상단에 defalut로 명시합니다. -->
	<!-- <bean id="test3" class="beans.TestBean3" lazy-init="true"
		init-method="bean3Init" destroy-method="bean3Destory"></bean> -->

	<!-- 각각 생성 될 때마다 해당 메소드가 호출된다. -->
	<!-- 이 부분에 명시합니다. -->
	<bean class="beanPostProcessor.beanPostProcessorTest"></bean>

</beans>

#  3. TestBean1.java

package beans;

public class TestBean1 {
	
	public TestBean1() {
		System.out.println("TestBean1 Created");
	}
	
	// 생성자 호출 후 자동으로 실행
	public void bean1Init() {
		System.out.println("TestBean1의 init 메서드");
	}
	
	// ClassPathXmlApplicationContext close 될 때 모든 메소드가 호출 된다.
	public void bean1Destory() {
		System.out.println("TestBean1의 destory 메소드");
	}
}

#  4. Main.java 실행하기

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import beans.TestBean1;
import beans.TestBean2;
import beans.TestBean3;

public class Main {

	public static void main(String[] args) {
		System.out.println("-1------------");
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/beans.xml");

		// init-method, destory-method 지정
		TestBean1 t1 = ctx.getBean("test1", TestBean1.class);

		// defalut-init-method, defalut-destory-method 지정
		// TestBean2 t2 = ctx.getBean("test2", TestBean2.class);

		// init-method, destory-method, defalut-init-method, defalut-destory-method 지정
		// TestBean3 t3 = ctx.getBean("test3", TestBean3.class);

		ctx.close();
		System.out.println("-ctx.close() 됨");
	}
}

#  5. 실행결과

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# Bean이 생성될 때, 모든 Bean의 init와 destory를 실행하기

    - beans.xml에서 init-method, destory-method와 xml에서 지정되는 defalut-init-method와 defalut-destory-method의 차이점을 유의하시면 좋을 것 같습니다.

1. TestBean1.java , TestBean2.java ,TestBean3.java

   - TestBean1.java에는 init-method, destory-method만 명시

   - TestBean2.java에는 defalut-init-method , defalut-init-destroy만 명시

   - TestBean3.java에는 init-method, destory-method, defalut-init-method , defalut-init-destroy 명시

package beans;

public class TestBean1 {
	
	public TestBean1() {
		System.out.println("TestBean1 Created");
	}
	
	// 생성자 호출 후 자동으로 실행
	public void bean1Init() {
		System.out.println("TestBean1의 init 메서드");
	}
	
	// ClassPathXmlApplicationContext close 될 때 모든 메소드가 호출 된다.
	public void bean1Destory() {
		System.out.println("TestBean1의 destory 메소드");
	}
}

package beans;

public class TestBean2 {
	
	public TestBean2() {
		System.out.println("TestBean2 Created");
	}
	
	// 자동으로 생성될 때 호출
	public void defalutInit() {
		System.out.println("defalut init");
	}
	
	// 자동으로 없어질 때 호출
	public void defalutDestory() {
		System.out.println("defalut destory");
	}
}

package beans;

public class TestBean3 {

	public TestBean3() { // --1
		System.out.println("TestBean3 Created");
	}

	// 자동으로 생성될 때 호출
	public void defalutInit() {
		System.out.println("TestBean3 : defalut_init");
	}

	// 자동으로 없어질 때 호출
	// 가장 마지막으로 실행된다.
	public void defalutDestory() { // -- 4
		System.out.println("TestBean3 : defalut_destory");
	}

	// 생성자 호출 후 자동으로 실행
	public void bean3Init() { // --2
		System.out.println("TestBean3의 init 메서드");
	}

	// ClassPathXmlApplicationContext close 될 때 모든 메소드가 호출 된다.
	// Bean에서 지정된거 보다 먼저 실행된다 
	public void bean3Destory() { // --3
		System.out.println("TestBean3의 destory 메소드");
	}
}

2. beans.xml에 init-method,destory-method,defalut-init-method,defalut-init-destroy를 명시.

   - TestBean1.java에는 init-method, destory-method만 명시

   - TestBean2.java에는 defalut-init-method , defalut-init-destroy만 명시

   - TestBean3.java에는 init-method, destory-method, defalut-init-method , defalut-init-destroy 명시

<?xml version="1.0" encoding="UTF-8" ?>
<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
						http://www.springframework.org/schema/beans/spring-beans.xsd"
	default-init-method="defalutInit"
	default-destroy-method="defalutDestory">

	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<!-- init-method와 destory-method에 TestBean.java 시작, 종료 메소드를 지정합니다. -->
	<bean id="test1" class="beans.TestBean1" lazy-init="true"
		init-method="bean1Init" destroy-method="bean1Destory"></bean>

	<!-- bean에는 명시하지 않고, xml 상단에 defalut로 명시합니다. -->
	<bean id="test2" class="beans.TestBean2" lazy-init="true"></bean>

	<!-- bean에도 명시하고 , xml 상단에 defalut로 명시합니다. -->
	<bean id="test3" class="beans.TestBean3" lazy-init="true"
		init-method="bean3Init" destroy-method="bean3Destory"></bean>

</beans>

3. Main.java에서 실행하기.

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import beans.TestBean1;
import beans.TestBean2;
import beans.TestBean3;

public class Main {

	public static void main(String[] args) {
		System.out.println("-1------------");
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/beans.xml");
		
		// init-method, destory-method 지정
		TestBean1 t1 = ctx.getBean("test1", TestBean1.class);
		
		// defalut-init-method, defalut-destory-method 지정
		TestBean2 t2 = ctx.getBean("test2", TestBean2.class);
		
		// init-method, destory-method, defalut-init-method, defalut-destory-method 지정
		TestBean3 t3 = ctx.getBean("test3", TestBean3.class);
		
		ctx.close();
		System.out.println("-ctx.close() 됨");
	}
}

4. 결과화면

   - TestBean1은 생성자와 지정된 메소드 출력.

   - TestBean2은 생성자와 defalut 메소드 출력.

   - TestBean3은 생성자와 defalut와 지정된 메소드가 있지만 지정된 메소드만 출력.

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# Bean의 생성 시점과 종료 시점의 특정 메소드 실행하기 

    -  TestBean.java에 beanInit() , beanDestory() 메소드를 만들겠습니다. (메소드명은 마음대로 지정합니다.) 

    -  beans.xml에서 init-method, destory-method에 TestBean.java 메소드를 명시합니다.

1. TestBean.java에 생성 메소드, 종료 메소드를 만듭니다.

    -  TestBean.java에 beanInit() , beanDestory() 메소드를 만들겠습니다. (메소드명은 마음대로 지정합니다.) 

    -  beans.xml에서 init-method, destory-method에 TestBean.java 메소드를 명시합니다.

package beans;

public class TestBean {
	// 생성자
	public TestBean() {
		System.out.println("---------------------");
		System.out.println("TestBean을 생성하였습니다.");
		System.out.println("---------------------");
	}
	
	// bean 생성되는 시점에서 beanInit 메소드가 실행 
	public void beanInit() {
		System.out.println("######################");
		System.out.println("bean Init 메소드르르 생성합니다");
		System.out.println("######################");
		
	}
	
	// bean 종료되는 시점(ctx.close 되기전에)에서 beanDestory 메소드가 실행 
	public void beanDestory() {
		System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
		System.out.println("bean Destory 메소드르르 종료합니다");
		System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
	}
	
}

2. beanInitDestory.xml에 생성 메소드, 종료 메소드를 지정합니다.

    -  TestBean.java에 beanInit() , beanDestory() 메소드를 만들겠습니다. (메소드명은 마음대로 지정합니다.) 

    -  (생성한)beansInitDestory.xml에서 init-method, destory-method에 TestBean.java 메소드를 명시합니다.

<?xml version="1.0" encoding="UTF-8" ?>
<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
						http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<!-- init-method와 destory-method에 TestBean.java 시작, 종료 메소드를 지정합니다.-->
	<bean id="test1" class="beans.TestBean" 
	 	lazy-init="true" 
		init-method="beanInit" 
		destroy-method="beanDestory"></bean>

</beans>

3. Main.java에서 bean을 가져오도록 하겠습니다.

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import beans.TestBean;

public class Main {

	public static void main(String[] args) {
		System.out.println("-1------------");
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/beansInitDestory.xml");
		
		// getBean한 순간에 init-method 메소드가 실행됩니다.
		TestBean t1 = ctx.getBean("test1", TestBean.class);
		// ctx.close() 전에 bean t1의 요소의 destoy-method가 실행됩니다.
		
		ctx.close();
		System.out.println("-ctx.close() 됨");
	}
}

4. 실행 결과 화면.

    -  beanInit() , beanDestory() 실행되는 부분을 확인하시길 바랍니다.

- 이 글은 아래의 내용에서 이어지는 내용입니다.

# Bean의 생성 시점과 새로운 객체로 생성하기

    -  XML 에서 bean 요소에 lazy-init와 scope를 지정합니다.

    -  아래 xml 두개 bean 생성 요소에 lazy-init, scope를 넣어보겠습니다.

	<!-- 총 두개의 bean을 생성합니다. -->
	<!-- id값 없이 생성해 보도록 하겠습니다. -->
	<bean class="beans.TestBean"></bean>
	
	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<bean id="test1" class="beans.TestBean"></bean>	

# 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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- bean id 값으로 객체를 불러올 거라 bean id 값을 부여하였습니다. -->
	<bean id="test1" class="beans.TestBean"></bean>

	<!-- getBean 할 때 마다 새로운 객체의 주소를 줍니다 -->
	<bean id="test2" class="beans.TestBean" scope="prototype"></bean>

	<!-- getBean 할 때 딱 한번 객체를 생성합니다. -->
	<bean id="test3" class="beans.TestBean" lazy-init="true"></bean>

	<!-- getBean 할 때 마다 객체를 생성 및 새로운 객체를 생성합니다 -->
	<bean id="test4" class="beans.TestBean" lazy-init="true"
		scope="prototype"></bean>

</beans>

1. Main.java

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import beans.TestBean;

public class Main {

	public static void main(String[] args) {
		System.out.println("-1------------");
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/beans.xml");

		System.out.println("TestBean은 test1의 요소만 한번 생성");
		System.out.println("-2------------");
		// beans.xml에서 정의한 TestBean의 요소를 가져오겠습니다.
		System.out.println("-3--getBean 불러오기 전-");

		// getBean해서 부르기 전에 이미 test1의 bean의 생성되어진 상태.
		TestBean t1_1 = ctx.getBean("test1", TestBean.class);
		System.out.printf("t1 : %s\n", t1_1);
		TestBean t1_2 = ctx.getBean("test1", TestBean.class);
		System.out.printf("t2 : %s\n", t1_2);
		// t1_1,t1_2 동일한 주소의 객체.

		// scope가 정의된 bean은 getBean 할 때 마다 새로운 객체를 생성합니다.
		// getBean할 때마다 생성자가 실행됨.
		TestBean t2_1 = ctx.getBean("test2", TestBean.class);
		System.out.printf("t2_1 : %s\n", t2_1);
		TestBean t2_2 = ctx.getBean("test2", TestBean.class);
		System.out.printf("t2_2 : %s\n", t2_2);
		// t2_1,t2_2 동일한 주소를 가지고 있지 않음.

		// lazy-init가 정의된 bean은 getBean할 때 새로운 객체를 생성합니다.
		// 단, getBean한 이후, 싱글톤으로 생성된다.
		TestBean t3_1 = ctx.getBean("test3", TestBean.class);
		System.out.printf("t3_1 : %s\n", t3_1);
		TestBean t3_2 = ctx.getBean("test3", TestBean.class);
		System.out.printf("t3_2 : %s\n", t3_2);
		// t3_1과 t3_2의 주소가 동일하게 나올 것입니다.

		// getBena 할 때, 생성자가 실행되며, 항상 새로운 객체가 생성됩니다.
		TestBean t4_1 = ctx.getBean("test2", TestBean.class);
		System.out.printf("t2_1 : %s\n", t4_1);
		TestBean t4_2 = ctx.getBean("test2", TestBean.class);
		System.out.printf("t2_2 : %s\n", t4_2);
		// t4_1,t4_2 동일한 주소를 가지고 있지 않음.
		System.out.println("-4--getBean 불러온 후-");
		ctx.close();
	}

}

2. Main.java, Beans.xml 관계

  - main.java에서 실행 시, Beans.xml 정의된 내용

3. 결과화면

   - scope, lazy-init 이 정의된 내용에 따라서 bean 생성에 영향을 줍니다,