'분류 전체보기'에 해당되는 글 214건

부록 : zip 압축 풀기.

# 자바로 파일 , 폴더 zip로 압축하기 

    - 폴더 안에 파일과, 하위 폴더 압축해버리기. 

    - 아래의 폴더의 위치를 압축하겠습니다.

# CompressZip.java - ZIP 파일을 만들 유틸 

package zipUtil;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class CompressZip {
	/**
	 * @description 압축 메소드 
	 * @param path 압축할 폴더 경로
	 * @param outputFileName 출력파일명
	 */
	public boolean compress(String path, String outputPath, String outputFileName) throws Throwable {
		// 파일 압축 성공 여부 
		boolean isChk = false;
		
		File file = new File(path);
		
		// 파일의 .zip이 없는 경우, .zip 을 붙여준다. 
		int pos = outputFileName.lastIndexOf(".") == -1 ? outputFileName.length() : outputFileName.lastIndexOf(".");
		
		// outputFileName .zip이 없는 경우 
		if (!outputFileName.substring(pos).equalsIgnoreCase(".zip")) {
			outputFileName += ".zip";
		}
		
		// 압축 경로 체크
		if (!file.exists()) {
			throw new Exception("Not File!");
		}
		
		// 출력 스트림
		FileOutputStream fos = null;
		// 압축 스트림
		ZipOutputStream zos = null;
		
		try {
			fos = new FileOutputStream(new File(outputPath + outputFileName));
			zos = new ZipOutputStream(fos);
			
			// 디렉토리 검색를 통한 하위 파일과 폴더 검색 
			searchDirectory(file, file.getPath(), zos);
			
			// 압축 성공.
			isChk = true;
		} catch (Throwable e) {
			throw e;
		} finally {
			if (zos != null)
				zos.close();
			if (fos != null)
				fos.close();
		}
		return isChk;
	}

	/**
	 * @description 디렉토리 탐색
	 * @param file 현재 파일
	 * @param root 루트 경로
	 * @param zos  압축 스트림
	 */
	private void searchDirectory(File file, String root, ZipOutputStream zos) throws Exception {
		// 지정된 파일이 디렉토리인지 파일인지 검색
		if (file.isDirectory()) {
			// 디렉토리일 경우 재탐색(재귀)
			File[] files = file.listFiles();
			for (File f : files) {
				System.out.println("file = > " + f);
				searchDirectory(f, root, zos);
			}
		} else {
			// 파일일 경우 압축을 한다.
			try {
				compressZip(file, root, zos);
			} catch (Throwable e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * @description압축 메소드 
	 * @param file
	 * @param root
	 * @param zos
	 * @throws Throwable
	 */
	private void compressZip(File file, String root, ZipOutputStream zos) throws Throwable {
		FileInputStream fis = null;
		try {
			String zipName = file.getPath().replace(root + "\\", "");
			// 파일을 읽어드림
			fis = new FileInputStream(file);
			// Zip엔트리 생성(한글 깨짐 버그)
			ZipEntry zipentry = new ZipEntry(zipName);
			// 스트림에 밀어넣기(자동 오픈)
			zos.putNextEntry(zipentry);
			int length = (int) file.length();
			byte[] buffer = new byte[length];
			// 스트림 읽어드리기
			fis.read(buffer, 0, length);
			// 스트림 작성
			zos.write(buffer, 0, length);
			// 스트림 닫기
			zos.closeEntry();

		} catch (Throwable e) {
			throw e;
		} finally {
			if (fis != null)
				fis.close();
		}
	}

}

# Main.java - ZIP 파일을 만들 유틸 

package Main;

import zipUtil.CompressZip;
//import zipUtil.UnZip;

/**
 * Main
 */
public class Main {
	public static void main(String[] args) {

		// 압축 파일 위치와 압축된 파일
		// String zipPath = "G:/ZIP_TEST/";
		// String zipFile = "jsmpeg-player-master.zip";

		// 압축을 해제할 위치, 압축할 파일이름
		String unZipPath = "G:/ZIP_TEST/TEST/";
		String unZipFile = "jsmpeg-player";

//		System.out.println("--------- 압축 해제 ---------");
//		UnZip unZip = new UnZip();
//		// 압축 해제 
//		if (!unZip.unZip(zipPath, zipFile, unZipPath)) {
//			System.out.println("압축 해제 실패");
//		}

		System.out.println("--------- 압축 하기 ---------");
		CompressZip compressZip = new CompressZip();

		// 압축 하기
		try {
			if (!compressZip.compress("G:/ZIP_TEST/TEST/jsmpeg-player-master", unZipPath, unZipFile)) {
				System.out.println("압축 실패");
			}
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
}

# 결과화면

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

# 의존성 주입 : 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 생성에 영향을 줍니다,

# XML로 bean 생성하기

    -  pom.xml : 스프링의 버전 정의 

    -  Main.java : 생성된 Bean 객체 가져오기

    -  beans.xml : 생성할 bean 객체 명시

    -  TestBean.java : 생성할 Bean 객체

# Spring Bean의 알아야할 점

  -  Bean으로 생성된 객체는 싱글톤이다. 싱글톤이라는 의미는 한번 생성되면, 계속해서 똑같은 객체를 불러온다.

     이점은 아래의 생성 과정에서 알아보도록 하겠습니다.

1. pom.xml

  -  Spring의 버전은 5.2.0.RELEASE 을 사용하도록 하겠습니다.

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>minami.tistory.test</groupId>
	<artifactId>TistoryTest</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<description></description>

	<properties>
		<!-- 자바 버전 -->
		<java-version>1.8</java-version>
		<!-- 스프링 버전 -->
		<org.springframework-version>5.2.0.RELEASE</org.springframework-version>
		<!-- 스프링 버전의 변경이 자유롭게 -->
		<!-- <org.springframework-version>4.3.25.RELEASE</org.springframework-version> -->
		<org.slf4j-version>1.7.28</org.slf4j-version>
		<ch.qos.logback-version>1.2.3</ch.qos.logback-version>
	</properties>

	<!-- 프로젝트에서 사용할 라이브러리 정보 -->
	<dependencies>
		<!-- Spring Context -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${org.slf4j-version}</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${ch.qos.logback-version}</version>
			<exclusions>
				<exclusion>
					<groupId>org.slf4j</groupId>
					<artifactId>slf4-api</artifactId>
				</exclusion>
			</exclusions>
			<scope>runtime</scope>
		</dependency>
	</dependencies>
</project>

2. TestBean.java (package beans;)

  -  TestBean의 생성자를 만들어서 생성 시점을 알아보겠습니다.

  -  생성자를 만들어서 TestBean.java의 생성 시점을 확인해보겠습니다.

package beans;

public class TestBean {
	// 생성자
	public TestBean() {
		System.out.println("---------------------");
		System.out.println("TestBean을 생성하였습니다.");
		System.out.println("---------------------");
	}
}

3. config.xml (package config;)

  -  TestBean을 정의하겠습니다.

     id : Main.java에서 bean을 가져올 때, 이름 지정.

     class : 생성할 객체의 위치.

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

</beans>

4. Main.java(package config;)

  -  TestBean을 정의하겠습니다.

     id : Main.java에서 bean을 가져올 때, 이름 지정.

     class : 생성할 객체의 위치.

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import beans.TestBean;

public class Main {

	public static void main(String[] args) {
		System.out.println("-1------------");
		System.out.println("TestBean 두번 생성되는 이유는? id가 있는 경우, id가 없는 경우 총 두번 생성");
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/beans.xml");
		
		System.out.println("-2------------");
		// beans.xml에서 정의한 TestBean의 요소를 가져오겠습니다.
		System.out.println("-3--getBean 불러오기 전-");
		
		// getBean해서 부르기 전에 이미 TestBean은 생성이 되어있는 상황.		
		TestBean t1 = ctx.getBean("test1", TestBean.class);
		System.out.printf("t1 : %s\n", t1);
		
		TestBean t2 = ctx.getBean("test1", TestBean.class);
		System.out.printf("t2 : %s\n", t2);
		
		System.out.println("t1 , t2의 주소가 동일하게 나옴.");
		// t1과 t2의 주소가 동일하게 나올 것입니다.
		
		System.out.println("-4--getBean 불러온 후-");
		ctx.close();
	}

}

4. 출력화면

  -  Main.java을 유심하게 보여 출력 내용을 이해할 수 있습니다.

  - t1, t2의 주소값이 같은 이유는 Spring 한번 생성하면 싱글톤으로 유지하기 때문에, getBean해도 같은 주소를 가리킵니다.

  - bean 정의된 요소들의 생성 시점 getBean한 시점으로 옮겨 보도록 하겠습니다.

5. 객체의 싱글톤, 생성 시점의 변경해보자.

  -  객체의 생성 시점이 getBean한 시점으로 변경하는 방법. (XML에서 scope)

  -  객체의 생성이 항상 동일한 객체가 아니 getBean 할 때 새로운 객체 생성하는 방법(XML에서 lazy-init)

  -> 다음 강좌에서 이어집니다.