[Framework] 의존주입(Dependency Injection)

Spring/MVC 2022. 9. 10. 18:37

pom.xml

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>spring</groupId>
  <artifactId>Sq03</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringEx</name>
  
  <dependencies>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context</artifactId>
  		<version>4.1.0.RELEASE</version>
  	</dependency>
  </dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>utf-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
	
</project>

interface

package com.mav.battery;

public interface Battery {
	public int getBatteryValue();
}

com.mav.battery

package com.mav.battery;

public class ChargeBattery implements Battery {

	@Override
	public int getBatteryValue() {
		return 0;
	}
	public void charge(int value) {
	}
}

package com.mav.battery;

public class NormalBattery implements Battery{

	@Override
	public int getBatteryValue() {
		return 0;
	}
}

com.mav.toy

package com.mav.toy;

import com.mav.battery.Battery;
import com.mav.battery.NormalBattery;

public class ElectronicCar {
	
	private Battery bat; // 인터페이스 래퍼런스 변수 
	// NomalBattery or ChargeBattery 인스턴스가 저장될 변수
	public ElectronicCar()	{
		// 생성자에서 노멀배터리를 엠변수에 초기값으로 대입하고 시작함
		bat=new NormalBattery();
		// 인터페이스 멤버 변수에 battery를 임플리먼트 한 클랫를 대입함
	}
}
// 이 장난감은 배터리가 출시당시 탑재(내장)되서 교체가 불가능한 상태로 판매되는 형태임

package com.mav.toy;

import com.mav.battery.Battery;

public class ElectronicRadio {
	
	private Battery bat;
	// 생성자에서 배터리가 초기화 되는데 그 초기값이 생성자의 전달인수로 전달되어야 하는 형태
	public ElectronicRadio(Battery bat) {
		this.bat=bat;
	}
	public void setBattery(Battery battery) {
		this.bat=battery;
	} // 추후 배터리를 새로 교체할 수 있는 기능이 있음
}
// 구매와 동시에 동봉 또는 별도 구입합 새 배터리를 장착할 수 있는 기능이 있음

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"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<bean class="com.mav.battery.NormalBattery"  id="nBattery"></bean>
	<bean class="com.mav.battery.ChargeBattery"  id="cBattery"></bean>
	<bean class="com.mav.toy.ElectronicCar"  id="car"></bean>
	<bean class="com.mav.toy.ElectronicRadio"  id="radio">
		<constructor-arg ref="cBattery"></constructor-arg><!-- 의존 주입 - 객체 조립 -->
	</bean>
<!-- 
클래스의 생성자가 다른 클래스를 매개변수 갖고 해당 객체가 전달되어야 생성자 실행이 가능하며 이는 클래스가 다른 클래스에 의존하고 있다라고 얘기함. 
그리고 의존에 해당하는 객체를 위와 같이 constructor-arg를 이용해서 채워주는 것을 의존 주입이라고 말함. 통틀어 객체 조립이라고 표현
-->
</beans>

com.mav

package com.mav;

import org.springframework.context.support.GenericXmlApplicationContext;

import com.mav.battery.ChargeBattery;
import com.mav.battery.NormalBattery;
import com.mav.toy.ElectronicCar;
import com.mav.toy.ElectronicRadio;

public class MainClass {

	public static void main(String[] args) {
		// 일반적인 사용예
		
		// 배터리가 장착된 상태로 판매되는 일체형. 객체 생성 하나만으로 사용 가능
		ElectronicCar carToy1=new ElectronicCar();
		
		// ElectronicRadio radioToy=new ElectronicRadio(); ->error
		// 생성자에 배터리 객체가 전달되어야 매개변수가 있는 생성자가 실행되므로 위는 오류
		NormalBattery nbatt1=new NormalBattery()	;
		ChargeBattery cbatt1=new ChargeBattery();
		ElectronicRadio radioToy1=new ElectronicRadio(nbatt1);
		// 생성자에 배터리 객체를 전달해주면 정상 실행. 
		// 이렇게 객체 생성시에 다른 객체의 존재 및 생성자료의 전달 인수 필요한 상태
		// 객체 생성이 다른 객체에 의존하고 있는 상태 이를 객체 의존이라고 부름
		// 그리고 필요 객체를 생성자의 전달인수로 넣어주는 것을 의존주입(Dependency Injection)이라고 부름
		
		GenericXmlApplicationContext ctx
		=new GenericXmlApplicationContext("classpath:applicationContext.xml");
		
		ElectronicCar carToy2=ctx.getBean("car",ElectronicCar.class);
		ElectronicRadio radioToy2=ctx.getBean("radio",ElectronicRadio.class);
		radioToy2.setBattery(nbatt1);
		// 스프링 프레임워크에서의 클래스 사용이 약간 업그레이드 되어 조금 간편해짐
	}
}

pom.xml

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>spring</groupId>
  <artifactId>Sp04</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringEx</name>
  
  <repositories>
  	<repository>
  		<id>oracle</id>
  		<name>ORACLE JDBC Repository</name>
  		<url>http://maven.jahia.org/maven2</url>
  	</repository>
  </repositories>
  
  <dependencies>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context</artifactId>
  		<version>4.1.0.RELEASE</version>
  	</dependency>
  	<dependency>
		<groupId>com.oracle</groupId>
		<artifactId>ojdbc6</artifactId>
		<version>12.1.0.2</version>
	</dependency>
  </dependencies>
	
	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>utf-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
	
</project>

SQL

drop table student;
create table student(
	sNum varchar2(20),
	sId varchar2(20),
	sPw varchar2(20),
	sName varchar2(20),
	sAge number(3),
	sGender varchar2(20),
	sMajor varchar2(80)
);

Dto

package com.mav.member.dto;

public class Student {

	private String sNum;
	private String sId;
	private String sPw;
	private String sName;
	private int sAge;
	private String sGender;
	private String sMajor;
	
	public Student(
			String sNum, String sId, String sPw, String sName, 
			int sAge, String sGender, String sMajor) {
		super();
		this.sNum = sNum;
		this.sId = sId;
		this.sPw = sPw;
		this.sName = sName;
		this.sAge = sAge;
		this.sGender = sGender;
		this.sMajor = sMajor;
	}
	
	public String getsNum() {
		return sNum;
	}
	public void setsNum(String sNum) {
		this.sNum = sNum;
	}
	public String getsId() {
		return sId;
	}
	public void setsId(String sId) {
		this.sId = sId;
	}
	public String getsPw() {
		return sPw;
	}
	public void setsPw(String sPw) {
		this.sPw = sPw;
	}
	public String getsName() {
		return sName;
	}
	public void setsName(String sName) {
		this.sName = sName;
	}
	public int getsAge() {
		return sAge;
	}
	public void setsAge(int sAge) {
		this.sAge = sAge;
	}
	public String getsGender() {
		return sGender;
	}
	public void setsGender(String sGender) {
		this.sGender = sGender;
	}
	public String getsMajor() {
		return sMajor;
	}
	public void setsMajor(String sMajor) {
		this.sMajor = sMajor;
	}
}

Dao

package com.mav.member.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class StudentDao {

	String driver="oracle.jdbc.driver.OracleDriver";
	String url="jdbc:oracle:thin:@localhost:1521:xe";
	String id="scott";
	String pw="tiger";
	Connection con=null;
	PreparedStatement pstmt=null;
	ResultSet rs=null;
	// 스프링 컨테이너에 넣어서 사용할 예정이므로 싱글턴 코딩은 하지 않음
	
	public Connection getConnection()	{
		Connection con=null;
		try {
			Class.forName(driver);
			con=DriverManager.getConnection(url,id,pw);
		} catch(ClassNotFoundException e) {e.printStackTrace();
		} catch(SQLException e) {e.printStackTrace();}
		return con;
	}
	
	public void close()	{
		try {
			if(con!=null) con.close();
			if(pstmt!=null) pstmt.close();
			if(rs!=null) rs.close();
		}catch(SQLException e) {e.printStackTrace();}
	}
}

student 테이블에 insert 하기

package com.mav.member.service;

import com.mav.member.dao.StudentDao;
import com.mav.member.dto.Student;

public class StudentInsertService {
	
	private StudentDao sdao;
	StudentInsertService(StudentDao sdao){
		this.sdao=sdao;
	}
	public void insertStudent(Student std) {
		sdao.insertStudent(std);
	}
}

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"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
       
	<bean class="com.mav.member.dao.StudentDao" id="studentdao"></bean>
	  
	<bean class="com.mav.member.service.StudentInsertService" id="insertService">
		<constructor-arg ref="studentdao"></constructor-arg>
	</bean>  
	
</beans>

MainClass

package com.mav.member.main;

import java.util.ArrayList;

import org.springframework.context.support.GenericXmlApplicationContext;

import com.mav.member.dto.Student;
import com.mav.member.service.StudentInsertService;
import com.mav.member.service.StudentSelectAllService;

public class MainClass {

	public static void main(String[] args) {
		// 기존 방식의 레코드 추가
//		StudentDao sdao=new StudentDao();
//		StudentInsertService sis=new StudentInsertServe(sdao);
//		sis.insertStudent(new Student());
		
		// 스프링 컨테이너를 이용한 방법
		GenericXmlApplicationContext ctx
		=new GenericXmlApplicationContext("classpath:applicationContext.xml");
//		Student std=new Student("H39asdfaelu42o23","hippo","94875","barabra",
//				22,"W","Korean Literature"); // 생성자에 전달인수 전달하여 객체 생성
		
		StudentInsertService sis=ctx.getBean("insertService",StudentInsertService.class);
//		sis.insertStudent(std);
		
		String[] sNums= {"H39asdfaelu42o23","H39ilemamca48w9h4","H39lkmn754fghia7","H39plo865cuy8k92",
				"H39mnbviiaed89q1","H399omjjyv56t3d5","H39ixzaqwg644gj8","H39ymbcsh74thgh2","H39lesvj7544vf89"};
		String[] sIds= {"hippo","raccoon","elephant","lion","tiger","pig","horse","bird","deer"};
		String[] sPws= {"94875","15284","48765","28661","60915","30028","29801","28645","28465"};
		String[] sNames= {"barbara","chris","doris","elva","fiona","holly","jasmin","lena","mellssa"};
		int[] sAges= {22,20,27,19,21,19,25,22,24};
		String[] sGenders= {"W","W","M","M","M","W","M","W","W"};
		String[] sMajors= {"Korean Literature","French Literature","Philosophy","History","Law","Statistics","Computer","Economics","Public Admin"};
		
		for(int i=0; i<sNums.length; i++) {
			Student std=new Student(sNums[i],sIds[i],sPws[i],sNames[i],sAges[i],sGenders[i],sMajors[i]);
			sis.insertStudent(std);
		}
	}
}

StudentDao에 insertStudent 추가

public void insertStudent(Student std) {
		String sql="insert into student(snum, sid, spw, sname, sage, sgender, smajor)"
				+" values(?,?,?,?,?,?,?)";
		con=getConnection();
		try {
			pstmt=con.prepareStatement(sql);
			pstmt.setString(1, std.getsNum());
			pstmt.setString(2, std.getsId());
			pstmt.setString(3, std.getsPw());
			pstmt.setString(4, std.getsName());
			pstmt.setInt(5, std.getsAge());
			pstmt.setString(6, std.getsGender());
			pstmt.setString(7, std.getsMajor());
			pstmt.executeUpdate();
		} catch(SQLException e) {e.printStackTrace();
		} finally {close();}
	}

student 테이블 조회하기

package com.mav.member.service;

import java.util.ArrayList;

import com.mav.member.dao.StudentDao;
import com.mav.member.dto.Student;

public class StudentSelectAllService {
	
	private StudentDao sdao;
	StudentSelectAllService(StudentDao sdao){
		this.sdao=sdao;
	}
	public ArrayList<Student> selectAllStudent(){
		ArrayList<Student> list=null;
		list=sdao.selectAllStudent();
		return list;
	}
}

applicationContext.xml에 bean 추가

<bean class="com.mav.member.service.StudentSelectAllService" id="selectAllService">
	<constructor-arg ref="studentdao"></constructor-arg>
</bean>

MainClass에 추가

StudentSelectAllService sas=ctx.getBean("selectAllService",StudentSelectAllService.class);
// 모든 학생 조회
ArrayList<Student> list=sas.selectAllStudent();
for(int i=0; i<list.size(); i++) {
	System.out.print(" | sNum: "+list.get(i).getsNum()+"\t");
	System.out.print(" | sId: "+list.get(i).getsId()+"\t");
	System.out.print(" | sPw: "+list.get(i).getsPw()+"\t");
	System.out.print(" | sName: "+list.get(i).getsName()+"\t");
	System.out.print(" | sAge"+list.get(i).getsAge()+"\t");
	System.out.print(" | sGender: "+list.get(i).getsGender()+"\t");
	System.out.print(" | sMajor: "+list.get(i).getsMajor()+"\n");
}

StudentDao에 selectAllStudent 추가

public ArrayList<Student> selectAllStudent() {
	ArrayList<Student> list=new ArrayList<Student>();
	String sql="select*from student";
	con=getConnection();
	try {
		pstmt=con.prepareStatement(sql);
		rs=pstmt.executeQuery();
		while(rs.next()) {
			Student std=new Student(
				rs.getString("sNum"),
				rs.getString("sId"),
				rs.getString("sPw"),
				rs.getString("sName"),
				rs.getInt("sAge"),
				rs.getString("sGender"),
				rs.getString("sMajor")
			); // 생성자 함수를 이용하여 객체 생성
			list.add(std);
		}
	} catch(SQLException e) {e.printStackTrace();
	} finally {close();}
	return list;
}

아이디로 학생 조회하기

package com.mav.member.service;

import com.mav.member.dao.StudentDao;
import com.mav.member.dto.Student;

public class StudentSelectOneService {

	private StudentDao sdao;
	
	public StudentSelectOneService(StudentDao sdao){
		this.sdao=sdao;
	}
	
	public Student selectOneStudent(String sId) {
		Student std=null;
		std=sdao.selectOneStudent(sId);
		return std;
	}
}

applicationContext.xml에 bean 추가

<bean class="com.mav.member.service.StudentSelectOneService" id="selectOneService">
	<constructor-arg ref="studentdao"></constructor-arg>
</bean>

StudentDao에 selectOneStudent 생성

public Student selectOneStudent(String sId) {
	Student std=null;
	String sql="select*from student where sId=?";
	con=getConnection();
	try {
		pstmt=con.prepareStatement(sql);
		pstmt.setString(1, sId);
		rs=pstmt.executeQuery();
		while(rs.next()) {
			std=new Student(
				rs.getString("sNum"),
				rs.getString("sId"),
				rs.getString("sPw"),
				rs.getString("sName"),
				rs.getInt("sAge"),
				rs.getString("sGender"),
				rs.getString("sMajor")
			);
		}
	} catch(SQLException e) {e.printStackTrace();
	} finally {close();}
	return std;
}

MainClass에 추가

Scanner sc=new Scanner(System.in);
System.out.printf("조회할 학생의 아이디를 입력하세요\n");
String ids=sc.nextLine();

StudentSelectOneService sos=ctx.getBean("selectOneService",StudentSelectOneService.class	);
Student std=sos.selectOneStudent(ids);

if(std==null) {
	System.out.println("조회한 아이디의 학생이 없습니다");
	return;
}
System.out.print(" | sNum: "+std.getsNum()+"\n");
System.out.print(" | sId: "+std.getsId()+"\n");
System.out.print(" | sPw: "+std.getsPw()+"\n");
System.out.print(" | sName: "+std.getsName()+"\n");
System.out.print(" | sAge"+std.getsAge()+"\n");
System.out.print(" | sGender: "+std.getsGender()+"\n");
System.out.print(" | sMajor: "+std.getsMajor()+"\n\n");

아이디로 학생 조회하여 정보 수정하기

package com.mav.member.service;

import com.mav.member.dao.StudentDao;
import com.mav.member.dto.Student;

public class StudentUpdateService {

	private StudentDao sdao;
	public StudentUpdateService(StudentDao sdao){
		this.sdao=sdao;
	}
	public void updateStudent(Student std) {
		sdao.updateStudent(std);
	}
}

applicationContext.xml에 bean 추가

<bean class="com.mav.member.service.StudentUpdateService" id="updateService">
	<constructor-arg ref="studentdao"></constructor-arg>
</bean

StudentDao에 updateStudent 생성

public void updateStudent(Student std) {
	String sql="update student set sPw=?, sName=?,"
			+ "sAge=?, sGender=?, sMajor=? where sId=?";
	con=getConnection();
	try {
		pstmt=con.prepareStatement(sql);
		pstmt.setString(1, std.getsPw());
		pstmt.setString(2, std.getsName());
		pstmt.setInt(3, std.getsAge());
		pstmt.setString(4, std.getsGender());
		pstmt.setString(5, std.getsMajor());
		pstmt.setString(6, std.getsId());
		pstmt.executeUpdate();
	} catch(SQLException e) {e.printStackTrace();
	} finally {close();}
}

MainClass에 추가

System.out.printf("수정할 학생의 아이디를 입력하세요: ");
ids=sc.nextLine();
std=sos.selectOneStudent(ids);
if(std==null) {
	System.out.println("조회한 아이디의 학생이 없습니다");
	return;
}

System.out.printf("기존 비밀번호: %s - 수정할 비밀번호를 입력하세요: ",std.getsPw());
String pw=sc.nextLine();
if(!pw.equals("")) std.setsPw(pw);

System.out.printf("기존 성명: %s - 수정할 성명을 입력하세요: ",std.getsName());
String name=sc.nextLine();
if(!name.equals("")) std.setsName(name);

System.out.printf("기존 나이: %s - 수정할 나이를 입력하세요: ",std.getsAge());
String age=sc.nextLine();
if(!age.equals("")) std.setsAge(Integer.parseInt(age));

System.out.printf("기존 성별: %s - 수정할 성별을 입력하세요: ",std.getsGender());
String gender=sc.nextLine();
if(!gender.equals("")) std.setsGender(gender);

System.out.printf("기존 전공: %s - 수정할 전공을 입력하세요: ",std.getsMajor());
String major=sc.nextLine();
if(!major.equals("")) std.setsMajor(major);

StudentUpdateService us=ctx.getBean("updateService",StudentUpdateService.class);
us.updateStudent(std);

System.out.print(" | sNum: "+std.getsNum()+"\n");
System.out.print(" | sId: "+std.getsId()+"\n");
System.out.print(" | sPw: "+std.getsPw()+"\n");
System.out.print(" | sName: "+std.getsName()+"\n");
System.out.print(" | sAge"+std.getsAge()+"\n");
System.out.print(" | sGender: "+std.getsGender()+"\n");
System.out.print(" |

DataBase connect

StudentDao에 DataBaseConnection 정보(driver, url, id, pw)가 null일 경우

String driver=null;
String url=null;
String id=null;
String pw=null;
StudentDao(DataBaseConnectionInfo dbconinfo){
	this.driver=dbconinfo.getDriver();
	this.url=dbconinfo.getUrl();
	this.id=dbconinfo.getId();
	this.pw=dbconinfo.getPw();
}

package com.mav.member.dto;

public class DataBaseConnectionInfo {
	private String url;
	private String id;
	private String pw;
	private String driver;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getPw() {
		return pw;
	}
	public void setPw(String pw) {
		this.pw = pw;
	}
	public String getDriver() {
		return driver;
	}
	public void setDriver(String driver) {
		this.driver = driver;
	}
}

스프링 컨테이너의 Bean 태그에 property 태그를 이용하여 각 멤버변수에 초기값을 넣어줄 수 있음.

아래와 같이 property 태그로 멤버변수에 값을 초기화하려면 각 변수의 getter/setter가 필수로 존재해야 함

<bean class="com.mav.member.dto.DataBaseConnectionInfo" id="dbconinfo1">
	<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
	<property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
  	<property name="id" value="scott"/>
  	<property name="pw" value="tiger"/>
</bean>

  <!--스프링 컨테이너에 저장되는 Bean은 한개의 객체이므로
  다른 내용의 객체가 필요하다면 초기값을 달리해서 또 하나의 Bean을 생성함 -->
  <bean class="com.mav.member.dto.DataBaseConnectionInfo" id="dbconinfo2">
 	<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
 	<property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
 	<property name="id" value="system"/>
 	<property name="pw" value="adminuser"/>
 </bean>

<bean class="com.mav.member.dao.StudentDao" id="studentdao">
	<constructor-arg ref="dbconinfo1"></constructor-arg>
</bean>

package com.mav.member.dto;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class EMSInformationService {

	private String info;
	private String copyRight;
	private String ver;
	private int sYear;
	private int sMonth;
	private int sDay;
	private int eYear;
	private int eMonth;
	private int eDay;
	private List<String> developers;
	private Map<String, String> administrators;
	private Map<String, DataBaseConnectionInfo> dbInfos;
	
	public void outputEMSInformation() {
		System.out.print("\n\n");
		String devPeriod=sYear+"/"+sMonth+"/"+sDay+" ~ "+eYear+"/"+eMonth+"/"+eDay;
		System.out.println(info+"("+devPeriod+")"+"\n"+copyRight+"\n"+ver);
		System.out.println("Developers: "+developers);
		System.out.println("Administrators: "+administrators);
		outputDataBaseInfo(); // 아래 메서드 호출
		System.out.print("\n\n");
	}
	
	public void outputDataBaseInfo() {
		Set<String> keys=dbInfos.keySet();
		Iterator<String> iterator=keys.iterator();
		while(iterator.hasNext()) {
			String key=iterator.next();
			DataBaseConnectionInfo info=dbInfos.get(key);
			System.out.printf("[%s]", key);
			System.out.print("jdbcUrl"+info.getUrl()+"\t");
			System.out.print("userId"+info.getId()+"\t");
			System.out.print("userPw"+info.getPw()+"\t");
		}
	}
	
	public String getInfo() {
		return info;
	}
	public void setInfo(String info) {
		this.info = info;
	}
	public String getCopyRight() {
		return copyRight;
	}
	public void setCopyRight(String copyRight) {
		this.copyRight = copyRight;
	}
	public String getVer() {
		return ver;
	}
	public void setVer(String ver) {
		this.ver = ver;
	}
	public int getsYear() {
		return sYear;
	}
	public void setsYear(int sYear) {
		this.sYear = sYear;
	}
	public int getsMonth() {
		return sMonth;
	}
	public void setsMonth(int sMonth) {
		this.sMonth = sMonth;
	}
	public int getsDay() {
		return sDay;
	}
	public void setsDay(int sDay) {
		this.sDay = sDay;
	}
	public int geteYear() {
		return eYear;
	}
	public void seteYear(int eYear) {
		this.eYear = eYear;
	}
	public int geteMonth() {
		return eMonth;
	}
	public void seteMonth(int eMonth) {
		this.eMonth = eMonth;
	}
	public int geteDay() {
		return eDay;
	}
	public void seteDay(int eDay) {
		this.eDay = eDay;
	}
	public List<String> getDevelopers() {
		return developers;
	}
	public void setDevelopers(List<String> developers) {
		this.developers = developers;
	}
	public Map<String, String> getAdministrators() {
		return administrators;
	}
	public void setAdministrators(Map<String, String> administrators) {
		this.administrators = administrators;
	}
	public Map<String, DataBaseConnectionInfo> getDbInfos() {
		return dbInfos;
	}
	public void setDbInfos(Map<String, DataBaseConnectionInfo> dbInfos) {
		this.dbInfos = dbInfos;
	}
}

applicationContext.xml에 bean 추가

<bean class="com.mav.member.dto.EMSInformationService" id="informationService">
	<property name="info">
		<value>Education Management System program was developed in 2015.</value>
	</property>
	<property name="copyRight">
		<value>COPYRIGTH(C) 2015 EMS CO., LTD. ALL RIGHT RESERVED.
		CONTACT MASTER FOR MORE INFORMATION</value>
	</property>
	<property name="ver"><value>The version is 1.0</value></property>
	<property name="sYear"><value>2021</value></property>
	<property name="sMonth"><value>10</value></property>
	<property name="sDay"><value>19</value></property>
	<property name="eYear"  value="2021"/> <!-- 단일태그 방식 -->
	<property name="eMonth" value="11"/>
	<property name="eDay" value="19"/>

	<property name="developers">
		<list>
			<value>Cheney.</value><value>Eloy.</value>
			<value>Jasper.</value><value>Dillon.</value>
			<value>Klan.</value>
		</list>
	</property>
	<property name="administrators">
		<map>
			<entry>
				<key><value>Cheney</value></key>
				<value>cheney@springPjt.org</value>
			</entry>
			<entry>
				<key><value>Jasper</value></key>
				<value>jasper@springPjt.org</value>
			</entry>
		</map>
	</property>
		<property name="dbInfos">
		<map>
			<entry>
				<key><value>dev</value></key>
				<ref bean="dbconinfo1"></ref>
			</entry>
			<entry>
				<key><value>real</value></key>
				<ref bean="dbconinfo2"></ref>
			</entry>
		</map>
	</property>
</bean

MainClass에 코드 추가

EMSInformationService eis=ctx.getBean("informationService",EMSInformationService.class);
eis.outputEMSInformation();

@Autowired: 의존객체 자동주입

pom.xml

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>spring</groupId>
  <artifactId>Sp05</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringEx</name>
   
    <repositories>
  	<repository>
  		<id>oracle</id>
  		<name>ORACLE JDBC Repository</name>
  		<url>http://maven.jahia.org/maven2</url>
  	</repository>
  </repositories>
  
  <dependencies>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context</artifactId>
  		<version>4.1.0.RELEASE</version>
  	</dependency>
  </dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>utf-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
	
</project>

sql

drop table wordset;
create table wordset(
	wordkey varchar2(20),
	wordValue varchar2(500)
)

Dto

package com.mav.word.dto;

public class WordSet {
	private String wordKey;
	private String wordValue;

// 마우스 우클릭 후 Source 누르고 
// Generate Getters and Setters... 클릭
// Generate Constructor using Fields... 클릭
// 아래와 같이 생성됨

	public WordSet(String wordKey, String wordValue) {
		super();
		this.wordKey = wordKey;
		this.wordValue = wordValue;
	}
	public String getWordKey() {
		return wordKey;
	}
	public void setWordKey(String wordKey) {
		this.wordKey = wordKey;
	}
	public String getWordValue() {
		return wordValue;
	}
	public void setWordValue(String wordValue) {
		this.wordValue = wordValue;
	}
}

Dao

package com.mav.word.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.mav.word.dto.WordSet;
import com.mav.word.util.DataBaseManager;

public class WordSetDao {
	Connection con=null;
	PreparedStatement pstmt=null;
	ResultSet rs=null;
	
	DataBaseManager dbm;
	public WordSetDao(DataBaseManager dbm) {
		this.dbm=dbm;
	}
	public void insert(WordSet wordSet) {
		con=dbm.getConnection();
	}
}

DataBase

package com.mav.word.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DataBaseManager {

	private DataBaseUserInfo dbi;
	public DataBaseManager(DataBaseUserInfo dbi) {
		this.dbi=dbi;
	}
	
	public Connection getConnection()	{
		Connection con=null;
		try {
			Class.forName(dbi.getDriver());
			con=DriverManager.getConnection(dbi.getUrl(),dbi.getId(),dbi.getPw());
		} catch(ClassNotFoundException e) {e.printStackTrace();
		} catch(SQLException e) {e.printStackTrace();}
		return con;
	}
	public void close(Connection con, PreparedStatement pstmt, ResultSet rs)	{
		try {
			if(con!=null) con.close();
			if(pstmt!=null) pstmt.close();
			if(rs!=null) rs.close();
		}catch(SQLException e) {e.printStackTrace();}
	}
}

package com.mav.word.util;

public class DataBaseUserInfo {
	private String url;
	private String id;
	private String pw;
	private String driver;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getPw() {
		return pw;
	}
	public void setPw(String pw) {
		this.pw = pw;
	}
	public String getDriver() {
		return driver;
	}
	public void setDriver(String driver) {
		this.driver = driver;
	}
}

appCtx.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
	<context:annotation-config />
	<bean class="com.mav.word.util.DataBaseUserInfo" id="dbuserinfo">
	 	<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
	 	<property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
	 	<property name="id" value="scott"/>
	 	<property name="pw" value="tiger"/>
	 </bean>
이 안에 추가될 코드들 배경색은 검정
</beans>

	 <bean class="com.mav.word.util.DataBaseManager" id="dbmanager"></bean>
	<!-- 
    원래 코드
	<bean class="com.mav.word.util.DataBaseManager" id="dbmanager">
	 <constructor-arg ref="dbuserinfo"></constructor-arg>
	</bean> 
	-->

bean에 constructor이 없으므로 DataBaseManager 클래스 수정

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

	@Autowired
	private DataBaseUserInfo dbi; // 의존객체 주입 -> 자동주입
	
//	public DataBaseManager(DataBaseUserInfo dbi) {
//		this.dbi=dbi;
//	}

<bean class="com.mav.word.dap.WordSetDao" id="worddao"></bean>

WordSetDao 클래스 수정

	@Autowired
	DataBaseManager dbm;

//	public WordSetDao(DataBaseManager dbm) {
//		this.dbm=dbm;
//	}

Insert 하기

package com.mav.word.service;

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

import com.mav.word.dao.WordSetDao;
import com.mav.word.dto.WordSet;

public class WordInsertService {
	@Autowired
	private WordSetDao worddao;
	public void insert(WordSet wordSet) {
		worddao.insert(wordSet);
	}
}

<bean class="com.mav.word.service.WordInsertService" id="insertService"></bean>

WordSetDao에 insert 메서드 추가

public void insert(WordSet wordSet) {
	String sql="insert into wordset values(?,?)";
	con=dbm.getConnection();
	try {
		pstmt=con.prepareStatement(sql);
		pstmt.setString(1, wordSet.getWordKey());
		pstmt.setString(2, wordSet.getWordValue());
		pstmt.executeUpdate();
	}catch(SQLException e) {e.printStackTrace();
	} finally {dbm.close(con, pstmt, rs);}
}

package com.mav.word.main;

import org.springframework.context.support.GenericXmlApplicationContext;

import com.mav.word.dto.WordSet;
import com.mav.word.service.WordInsertService;

public class MainClass {
	
	public static void main(String[] args) {
		String[] keyWords= {"c","c++","java","jsp","spring"};
		String[] values= {
				"C는 1972년 켄 톰슨과 데니스 리치가 유닉스 운영 체제에서 사용하기 위해 개발한 프로그래밍 언어이다",
				"C++는 AT&T 별 연구소의 비야네 스트롭스트룹이 1983년 발표하여 발전한 프로그래밍 언어이다",
				"자바는 씬 마이크로시스템즈의 제임스 James Gosling과 다른 연구원들이 개발한 객제 치향적 프로그래밍 언어이다",
				"JSP는 HTML내에 자바 코드를 삽입하여 웹 서버에서 동적으로 웹페이지를 생성하여 웹 브라우저에 둘러주는 언어이다",
				"스프링 프레임어크는 자바 플랫폼을 위한 오픈 소스 애플리케이션 프레임 워크로서 간단히 스프링이라고 불린다"
		};
		GenericXmlApplicationContext ctx=new GenericXmlApplicationContext("classpath:appCtx.xml");
		WordInsertService wis=ctx.getBean("insertService",WordInsertService.class);
		
		for(int i=0; i<keyWords.length; i++) {
			WordSet wordSet=new WordSet(keyWords[i],values[i]);
			wis.insert(wordSet);
		}
	}
}

Select 하기

package com.mav.word.service;

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

import com.mav.word.dao.WordSetDao;
import com.mav.word.dto.WordSet;

public class WordSearchService {

	@Autowired
	private WordSetDao worddao;
	
	public WordSet searchWord(String kw) {
		WordSet ws=worddao.search(kw);
		return ws;
	}
}

<bean class="com.mav.word.service.WordSearchService" id="searchService"></bean>

WordSetDao에 search 메서드 추가

public WordSet search(String kw) {
	WordSet ws=null;
	String sql="select *from wordset where wordkey=?";
	con=dbm.getConnection();
	try {
		pstmt=con.prepareStatement(sql);
		pstmt.setString(1, kw);
		rs=pstmt.executeQuery();
		if(rs.next()) {
			ws=new WordSet(
					rs.getString("wordkey"),
					rs.getString("wordvalues")
					);
		}
	}catch(SQLException e) {e.printStackTrace();
	} finally {dbm.close(con, pstmt, rs);}
	return ws;
}

MainClass에 추가

WordSearchService ss=ctx.getBean("searchService",WordSearchService.class);
Scanner sc=new Scanner(System.in);
System.out.printf("검색할 단어를 입력하세요: ");
String input=sc.nextLine();
WordSet ws=ss.searchWord(input);
if(ws==null) {
	System.out.println("검색한 단어는 존재하지 않습니다");
} else {
	System.out.println("\n\n");
	System.out.print(ws.getWordKey()+"\t ");
	System.out.print(ws.getWordValue());
}
ctx.close();

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

ABOUT ME

im hippo im hippo

티스토리툴바