DI 의 필요성

DI 란?

Dependaency Injection 의 약자로, 직역하면 의존적 주입이라는 뜻이다.
스프링 컨테이너가 지원하는 핵심 개념 중의 하나이다.
객체 간의 의존 관계를 객체 자신이 아닌 외부의 조립기가 수행해준다는 개념이다.

클래스만의 이용

맨처음 우리 고객이 영어로 인사하도록 요구하면 다음과 같다.

package diTest01;

public class MessageBean {
	public void sayHello(String name) {
		String str = "Hello, "+ name+"!";
		System.out.println(str);
	}
}

package diTest01;

public class HelloApp {
	public static void main(String[] args) {
		//클래스를 사용하려면 반드시 new 연산자에 의해서 객체를 생성하고 사용할 수 있다.
		new MessageBean().sayHello("홈즈");
		//한국 말로 인사하는 것을 바꾸고 싶을 떄 사용처를 모두 찾아가서 새로 만들어진 메소드 명으로 변경해줘야 한다.
		//시간도 매우 많이 걸릴 뿐더러, 중간에 빼먹을 수도 있다
	}
}

하지만, 다음과 같이 한글로 인사하도록 요구한다면 다음과 같이 변한다.
MessageBean 대신에 MessageBeanKO 라는 클래스를 만들고 MessageBean 이 사용되는 클래스인 HelloApp 의 MessageBean ob = new MessageCean() 이라고 객체를 생성하는 부분을 MessageBeanKO ob = new MessageKO() 로 바꿔야 한다.
여기서 MessageBean 과 HelloApp 은 강한 의존관계에 있다고 이야기 한다.

package diTest01;

public class MessageBeanKO {
	public void sayHello(String name) {
		String str = "안녕하세요, "+ name+"!";
		System.out.println(str);
	}
}

package diTest01;

public class HelloApp {
	public static void main(String[] args) {
        //MessageBean 클래스가 사용되는 곳이 한 곳이 아니라 여러 곳일 때, 일일히 찾아다니며
        //다음과 같이 객체를 생성하는 부분을 전부 바꿔줘야 한다.
		new MessageBeanKO().sayHello("홈즈");
		
	}
}

인터페이스의 이용

위와 같이 여러 변경을 많이 해야하는 것을 고려해서 추상화하여 인터페이스를 만들 수 있다.

package diTest02;

public interface MessageBean {
	public void sayHello(String name);
}

package diTest02;

public class MessageBeanEn implements MessageBean {
	public void sayHello(String name) {
		String str = "Hello "+ name+"!";
		System.out.println(str);
	}
}

package diTest02;

public class MessageBeanKo implements MessageBean {
	public void sayHello(String name) {
		String str = "안녕하세요, "+ name+"!";
		System.out.println(str);
	}
}

package diTest02;

public class HelloApp {
	public static void main(String[] args) {
    	//인터페이스를 이용할 경우 다음과 같이, 인터페이스 타입의 mb 변수의 값만
        //다른 클래스의 값으로 바꿔주면 된다.
		MessageBean mb = new MessageBeanKo();
		mb.sayHello("홈즈");
		
		mb = new MessageBeanEn();
		mb.sayHello("Garam");
	}
}

이 때 HelloApp 과 MessageBean(인터페이스)은 약한 의존 관계라고 한다.

DI 의 이용

다음의 그림과 같이 스프링 환경설정 파일을 이용하여 만들 수도 있다.
가능하면 한번 만든 코드는 고치지 않는다는 생각으로 접근하는 것이다.

옛날에는 자바 프로젝트를 사용할 때, Context에 필요한 모든 라이브러리를 직접 가서 버전에 맞는 것으로 다운받아서 프로젝트 Build Path 에 설정해주어야 했다.
여기서 빌드할 때 Maven을 사용할 수 있는데 Maven에서 제공하는 핵심 클래스로는 Context 등이 있다.
자바 프로그램이 필요로 하는 객체를 코드 내에서 생성하지 않고 스프링 프레임워크가 제공하도록 하자는 것이다.
xml 파일의 이름은 마음대로 변경해도 상관 없되, bean 이라는 태그 필요하다.

일일히 다 써도 되지만 번거로우므로 자동으로 쓸 수 있도록 이클립스의 플러그인을 다운로드한다.
Help MarketPlace 창을 열고 Sping 을 검색
지금 Spring의 기본 Configration 만 도움을 받을 예정이므로, 다음을 다운로드한다.(맨 윗 것은 너무 최신 버전이므로 )

다음 다 체크 해제하고 맨위의 Core 만 체크한 뒤 accept 하고 finish 한다. > Install anyway > restart now 를 선택한다.
이제 pakage> New> other 하면 Spring 관련 메뉴들이 생긴 것을 확인할 수 있다.

xml 은 매우 엄격하므로, 열고 닫는 것이 매우 엄격하다. 이 때, 자식 노드가 없을 때는 < />로 함축해서 쓸 수 있다.
이클립스는 클래스 명의 앞글자 대문자를 쓰면 자동완성을 이용할 수 있다.
<bean class="diTest03.MessageBeanEn"/> 을 쓰면 "" 안이 링크가 걸린다. (Ctrl + 마우스 오버 하면 마우스 모양이 바뀐다.)
이제 아이디 식별자(즉, 명찰)을 부여한다.

<?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="messageBean" class="diTest03.MessageBeanEn"/>
</beans>

package diTest03;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

public class HelloApp {

	public static void main(String[] args) {
		//파일을 먼저 String 으로 가져온다.
		Resource resource = new FileSystemResource("beans.xml");
		BeanFactory factory = new XmlBeanFactory(resource);
		//아까 xml 파일에 정한 id식별자를 준다.
		//이 때, En 일수도 있고 미래에는 Ko 로 바뀔수도 있으므로 인터페이스로 가져온다.
		MessageBean bean = (MessageBean)factory.getBean("messageBean");
		bean.sayHello("Spring");
	}
}

여기서 번거로우므로 다음과 같이 이용할 수도 있다.

package diTest03;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

public class HelloApp2 {

	public static void main(String[] args) {
		//스프링 환경설정 파일을 읽어들인다.
		//매개변수로 xml 파일 위치(경로)를 준다.
		//이때 xml 은 클래스가 아니라 파일이므로.이 아니라 /로 구분한다. 
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest03/beans.xml"); 
		
		//객체 타입을 Object 로 가져오게 되므로, 캐스팅을 해줘야 한다.
		//여기서 미래에 각기 다른 자식 클래스로 편하게 바꿀 수 있도록 인터페이스로 타입캐스팅을 해줘야 한다.
		MessageBean bean = (MessageBean)context.getBean("mb");
		bean.sayHello("tiger");
	}
}

여기서 한국말로 고쳐달라고 한다면 Ko 클래스를 만들고 xml 파일을 수정하면 된다(HelloApp.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="mb" class="diTest03.MessageBeanKo"/>
</beans>

cf) 프레임워크(Framework)

직역하면 (건물 등의) 뼈대(골조), 액자, 틀 등의 뜻을 가지고 있다.
보통 스프링 프레임워크라는 표현을 사용한다.
우리가 jsp의 MVC 패턴에 만들었던 뼈대는 표준화해서 인기있는 Structs와 Spring 등이 있다. 요새는 Sping 을 많이 사용한다.
우리가 학습했던 jsp MVC 패턴의 경우를 보면 kosta.properties 파일을 만들어 사용자의 요청별 일처리를 위한 Action 클래스를 설정하고 FrontController 역할을 하는 DispatcherServlet 클래스를 만들고 모든 Action 들이 가져야할 공통적인 메소드를 일반화한 Action 인터페이스를 만들었다. 만약, 신규 프로젝트에 투입이 된다면 이러한 뼈대로 그대로 가져다가 사용하면 훨씬 개발 시간을 단축시킬 수 있을 것이다.
이와 같이 어플리 케이션 개발에 필요한 기반틀(뼈대)를 이루는 환경을 "프레임워크"라고 한다.
이 때 개발 년차가 쌓일 수록 자신만의 프레임 워크가 보다 더 정교해질 것이다. 또, 개발 회사마다 자신들만의 프레임워크를 만들어서 개발에 적용하기도 한다.
이러한 프레임 워크 중에 공개되어 있는 프레임워크 중에 가장 사랑받고 있는 것이 "스프링" 이다.
(예전에는 structs 라는 것도 있었다. 현재는 일본에서 가끔 사용하기도 한다.)
우리나라의 경우 전자정부 표준 프레임워크에 Spring 이 채택되어있으므로 특히 공공 프로젝트의 경우에 Spring 프레임 워크를 사용할 수밖에 없다.

스프링의 주요 특징

스프링의 DI(Dependency Injection)

사용자의 요구에 의해 수정이 될 것 같은 객체의 생성을 어플리케이션 내에서 직접 new 연산자에 의해서 생성하지 않고 스프링 환경설정 파일에 의해서 생성하는 것을 말한다.
자바로 된 소프트웨어 속을 들여다 보면 수많은 클래스들로 구성되어 있다. 이러한 클래스들의 관계는 상속관계, 포함관계가 있을 수 있는데, 포함관계에 있는 두 클래스 A, B에서 A클래스는 B를 포함하고 있다고 할 때에 A에서 B를 사용하기 위해서는 new연산자에 의해서 객체를 생성하고 사용해야 한다.
만약, 사용자의 요청에 의해서 A와 포함관계에 있는 B대신에 새로운 클래스 K로 변경 요청이 있다면 A 클래스 내에 있는 new B()를 new K() 로 변경해야 할 것이다.
이 때, B 가 사용되던 곳이 A 한 곳이 아니라 여러 곳(n곳)에 사용되었다면 일일히 ㅅ찾아다니면서 수정하는 것은 번거로운 일이고, 미처 수정되지 못하는 부분도 있을 수 있다.
이러한 문제를 해결하기 위하여 스프링 DI 는 사용자의 요청에 의해 수정이 될 것 같은 객체의 생성을 즉, new 연산자를 자바 소스코드 내에서 걷어내고 스프링 컨테이너(환경설정파일)이 제공하는 것을 말한다.

여기서 DI 는 기본 생성자가 사용된다.

매개변수가 있는 생성자를 만들었다면 기본 생성자를 자동으로 만들어주지 않으므로 앞과 같이 사용할 수 없다.

package diTest04;

public class Person {
	private String name;
	private int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}

여기서 다음과 같은 기본 생성자를 추가해 줄 경우 xml 의 에러가 사라진다.

public Person() {
    super();
}

생성자 매개변수에 다른 클래스가 있는 클래스의 DI 이용

먼저 포함된 클래스를 xml 에서 생성해준다. 즉, MySqlArticleDao 를 먼저 생성해준다. 이 때는 기본 생성자가 제공되므로 오류가 나지 않는다.
WriteArtivleServiceImple 은 매개변수 MySqlArticleDao 를 받으므로 이미 만들어진 객체를 매개변수를 받으므로 xml 에 ref 태그를 이용하고, local 속성에 해당 매개변수의 경로를 적어준다.

package diTest05;

public class MySqlArticleDao {
	public void insert() {
		System.out.println("추가하였습니다.");
	}
}

package diTest05;

public class WriteArticleServiceImple {
	private MySqlArticleDao dao; //has a 관계(포함관계)
	
	public WriteArticleServiceImple(MySqlArticleDao dao) {
		this.dao = dao;
	}
	public void pro() {
		dao.insert();
	}
}

<?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="mySqlArticleDao" class="diTest05.MySqlArticleDao" />
	<bean id="writeArticleServiceImple" class="diTest05.WriteArticleServiceImple">
		<constructor-arg>
			<!-- 이미 있는 객체를 참조할 때 ref태그를 사용한다. -->
			<ref local="mySqlArticleDao"/>
		</constructor-arg>
	</bean>
</beans>

package diTest05;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
    	//스프링 컨테이너가 제공하는 객체를 참조하기 위하여 ApplicatinContext 객체를 생성합니다.
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest05/beans.xml");
        
        //이제 위의 컨텍스트를 통해 객체를 가져와서 이용한다.
		WriteArticleServiceImple ws = (WriteArticleServiceImple)context.getBean("writeArticleServiceImple");
		ws.pro();
	}
}

이 때 간략하게 코드를 줄여서 다음과 같이 ref 를 속성으로 바꿔서 입력할 수도 있다.

<?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="mySqlArticleDao" class="diTest05.MySqlArticleDao" />
	<bean id="writeArticleServiceImple" class="diTest05.WriteArticleServiceImple">
		<constructor-arg ref="mySqlArticleDao"/>
	</bean>
	<!-- <bean id="writeArticleServiceImple" class="diTest05.WriteArticleServiceImple">
		<constructor-arg>
			<ref local="mySqlArticleDao"/>
		</constructor-arg>
	</bean>-->
</beans>

생성자가 전달 받은 값이 기본 자료형

package diTest06;

public class SystemMonitor {
	private int periodTime;

	public SystemMonitor(int periodTime) {
		this.periodTime = periodTime;
	}
	
	public void monitor() {
		System.out.println(periodTime + "분 간격으로 모니터링 한다.");
	}
}

<?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="sm" class="diTest06.SystemMonitor">
		<constructor-arg>
			<value>10</value>
		</constructor-arg>
	</bean>
	
</beans>

package diTest06;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
    //ApplicationContext 중에 클래스 패스 기준으로 xml 파일로 이루어진 Application 환경설정 파일을 가져옴
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest06/beans.xml");
		SystemMonitor sm = (SystemMonitor)context.getBean("sm");
		sm.monitor();
	}
}

여기서도 xml 파일의 코드를 줄여서 다음과 같이 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="sm" class="diTest06.SystemMonitor">
		<constructor-arg value="20" />
	</bean>
	<!-- 
	<bean id="sm" class="diTest06.SystemMonitor">
		<constructor-arg>
			<value>10</value>
		</constructor-arg>
	</bean> -->
</beans>

생성자의 매개변수가 여러개 있는 클래스의 DI 이용

package diTest07;

public class SmsSender {
	public void send() {
		System.out.println("메세지를 전송하였습니다.");
	}
}

package diTest07;

public class SystemMonitor {
	private long periodTime;
	private SmsSender sender;
	public SystemMonitor(long periodTime, SmsSender sender) {
		super();
		this.periodTime = periodTime;
		this.sender = sender;
	}
	
	public void monitor() {
		System.out.println(periodTime +"분 간격으로");
		sender.send();
		System.out.println("----------------------------------");
	}
}

<?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="ss" class="diTest07.SmsSender" />
	<bean id="sm" class="diTest07.SystemMonitor">
		<constructor-arg value="15"/>
		<constructor-arg ref="ss" />
	</bean>
</beans>

package diTest07;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest07/beans.xml");
		SystemMonitor sm = (SystemMonitor)context.getBean("sm");
		sm.monitor();
	}
}

생성자가 중복될 경우(생성자 오버로딩)

package diTest08;

public class Worker {
	private String name;
	private int age;
	
	public Worker(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Worker [name=" + name + ", age=" + age + "]";
	}
}

package diTest08;

public class Executor {
	private Worker worker;
	private String runner;
	
	public Executor(Worker worker) {
		super();
		this.worker = worker;
		System.out.println("생성자1");
	}

	public Executor(String runner) {
		super();
		this.runner = runner;
		System.out.println("생성자2");
	}
	
	public void execute() {
		System.out.println("다음에 의해서 동작하였습니다.");
		if(worker != null) {
			System.out.println(worker);
		}else {
			System.out.println(runner);
		}
	}
}

<?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="worker" class="diTest08.Worker">
		<constructor-arg value="이순신"/>
		<constructor-arg value="20"/>
	</bean>
	
	<bean id="exe" class="diTest08.Executor">
		<constructor-arg  ref="worker" />
	</bean>
</beans>

package diTest08;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest08/beans.xml");
		
		Executor exe = (Executor)context.getBean("exe");
		//2개의 생성자 중에 생성자 1이 동작
		exe.execute();
	}
}

다음과 같이 변경해볼 수 있다.

<?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="worker" class="diTest08.Worker">
		<constructor-arg value="이순신"/>
		<constructor-arg value="20"/>
	</bean>
	
	<bean id="exe" class="diTest08.Executor">
		<constructor-arg  ref="worker" />
	</bean> -->
	
	<bean id="exe" class="diTest08.Executor">
		<constructor-arg  value="유관순" />
	</bean>
</beans>

package diTest08;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest08/beans.xml");
		
		Executor exe = (Executor)context.getBean("exe");
		//2개의 생성자 중에 생성자 1이 동작
		exe.execute();
	}
}

value 에 전달된 값은 기본적으로 String 으로 처리한다. 즉 우선순위가 String 이 가장 높다.

package diTest09;

public class JobExecutor {
	public JobExecutor(String name, int seconds) {
		System.out.println("생성자 호출1");
	}
	public JobExecutor(String name, long milliseconds) {
		System.out.println("생성자 호출2");
	}
	public JobExecutor(String name, String seconds) {
		System.out.println("생성자 호출3");
	}
	public void pro(){
		System.out.println("JobExecutor의 처리입니다.");
	}
}

<?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="job" class="diTest09.JobExecutor">
		<constructor-arg value="홍길동"/>
		<constructor-arg value="1000"/>
	</bean>
</beans>

package diTest09;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest09/beans.xml");
		JobExecutor job= (JobExecutor)context.getBean("job");
		job.pro();
		//3번째 생성자가 동작되는 것을 볼 수 있다
	}
}

이 때, 3번째 생성자를 주석으로 막으면 int 타입으로 간다. 이것이 싫다면 type 속성을 이용하여 따로 지정할 수 있다.

프로퍼티 설정 방식(Setter 에 의하여 초기화할 때의 DI 설정 방식은 다음과 같다.)

property 태그를 이용한다.

package diTest10;

public class MySqlArticleDao {
	public void insert() {
		System.out.println("추가하였습니다.");
	}
}

package diTest10;

public class WriteArticleServiceImple {
	private MySqlArticleDao dao; //has a 관계(포함관계)

	public void setDao(MySqlArticleDao dao) {
		this.dao = dao;
	}

	public void pro() {
		dao.insert();
	}
}

<?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="mySqlArticleDao" class="diTest10.MySqlArticleDao" /> 
	<bean id="ws" class="diTest10.WriteArticleServiceImple">
    	<!-- 참조 자료형이므로 ref, 기본 자료형이면 value-->
		<property name="dao" ref="mySqlArticleDao" />
	</bean>
</beans>

package diTest10;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest10/beans.xml");
		WriteArticleServiceImple ws= (WriteArticleServiceImple)context.getBean("ws");
		ws.pro();
	}
}

연습문제

package diTest11;

public class DataSource {
	private String driver;
	private String url;
	private String username;
	private String password;
	
	public void setDriver(String driver) {
		this.driver = driver;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public void info() {
		System.out.println("driver: "+driver);
		System.out.println("url: "+url);
		System.out.println("username: "+username);
		System.out.println("password: "+password);
	}
}

<?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="dataSource" class="diTest11.DataSource">
		<property name="driver" value="oracle.jdbc.driver.OracleDriver" />
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:XE" />
		<property name="username" value="c##madang" />
		<property name="password" value="madang" />
	</bean>
</beans>

package diTest11;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {

	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("diTest11/beans.xml");
		DataSource dataSource= (DataSource)context.getBean("dataSource");
		dataSource.info();
	}
}

저작자표시 비영리 변경금지

'Kosta DevOps 과정 280기 > Java' 카테고리의 다른 글

DI와 XML 이용-2 (0)	2024.08.01
어제 복습 (0)	2024.08.01
스프링 베이직 시작 : 환경설정 (0)	2024.07.31
jquery와 Ajax (0)	2024.07.22
Ajax 통신 (0)	2024.07.22

개발 공부 일지

DI 의 필요성

'Kosta DevOps 과정 280기 > Java' 카테고리의 다른 글

티스토리툴바

DI 의 필요성

'Kosta DevOps 과정 280기 > Java' 카테고리의 다른 글

관련글

티스토리툴바