mjeongriver
article thumbnail
Published 2023. 1. 30. 14:39
day73-spring TIL/Spring

1. 프레임워크 - 뼈대를 이루는 코드들의 묶음

- 프레임워크란 기본 뼈대이다 . 자동차를 만들 때 뼈대를 구현한 다음 만든다
- 프레임워크는 방향성을 제시하고 원하는 기능을 빠르게 만들 수 있게 함

- 스프링 프레임워크는 주요기능으로 DI, AOP, MVC, JDBC 등을 제공한다

- 모듈: 라이브러리, 프레임워크 안에 미리 만들어져 있는 기능

 

2. 스프링 컨테이너 - 스프링에서 객체를 생성하고 조립하는 컨테이너로 컨테이너를 통해 생성된 객체를 빈이라고 부른다.

1) 객체 생성 및 속성 데이터 작성

2) 스프링 컨테이너에서 객체 생성 및 조립

3) 애플리케이션 구현

3. 구축(강의 교안 2강 참고)

- 위 상단 project에서 spring tool 4 version 선택해서 아래로 내려가면 위 사진 나옴

- Spring Tool suite 3 - 3 wiki 선택 하고 2~3번째 사진 체크 표시 다운로드

STS.exe 실행

 

---------------------------------------------------------------------------------------------------------------------------------------------------

* jvm is not suitable for the product version : 11 or greater is required 오류 떴을 때

- 폴더에 버전 2개가 깔려 있으면 인식을 못하기 때문에 밑에 11버전 두고 모두 지울 것

---------------------------------------------------------------------------------------------------------------------------------------------------

 

4. 실행

- 설치가 완료 되면 encoding utf-8로 모두 설정해줄 것

window - preference에서 encodion 검색 - workspace, css ,html, jsp, xml 모두 utf-8로 변경

1) maven project 생성

하고 next
group id: 회사, arti~: 프로젝트 명, 버전: 내 프로젝트의 버전

- pom.xml: 라이브러리를 지정된 형태로 기술하면 다운로드 받을 수 있음(강의 교안 1강_pom에서 스프링 받기 txt 참고해서 pop.xml <version>0.0.1-SNAPSHOT</version> 아래에 넣어줄 것)

- dependency: 필요한 라이브러리를 원격에서 받을 때 작성되는 이름

- build: maven이 필요한 소스코드들을 어느 버전으로 컴파일 시키고 어떻게 쓰는지에 대한 설명(maven 설정)

- <source>11</source>, <target>11</target>로 변경 

<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>com.simple</groupId>
  <artifactId>SpringDI</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.0.7.RELEASE</version>
		</dependency>
	</dependencies>

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

- maven: 원격에 있는 필요한 모듈을 다운로드 해주는 플랫폼(중간에서 필요한거 내려받아서 이 프로젝트에 바로 사용을 할 수 있게끔 제공해주는 플랫폼)

자바 소스 코드 버전, 기본 버전이 달라서 X 오류 발생

- 프로젝트 우클릭 - 빌드패스 - configu~에서 build path 들어가서 라이브러리에서 밑에 있는 첫번째 사진 블럭 더블 클릭 - java se11버전으로 변경 - 다시 프로젝트 우클릭 maven에서 업데이트 프로젝트(alt+f5) 선택해서 선택하면 에러 사라짐(maven 바뀐 것을 프로젝트에 반영하겠다는 뜻)

 

- src/main/java에는 패키지에 클래스 생성

* SpringTest

package ex01;

public class SpringTest {

	public void test() {
		System.out.println("스프링 bean 사용해보기");
	}
	
	
}

 

* MainClass

package ex01;

import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {
	
	public static void main(String[] args) {
		
		GenericXmlApplicationContext ctx =
				new GenericXmlApplicationContext("application-context.xml");
		
		SpringTest bean = ctx.getBean(SpringTest.class);
		
		bean.test();
	}

}

springTest 속성을 가지고 있는 class를 꺼내서 변수(bean)에 저장하고 bean변수에 있는 test 메서드 실행함 = 2번째 사진은 동일한 결과 출력됨

 

* application-context.xml

- src/ main/resources - spring bean configuration file 생성하면 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 = "test" class ="ex01.SpringTest"/>
 
</beans>

ctrl + f11하면 결과창 나옴

1) Spring DI/IoC
- JAVA의 Class 상속 / Interface 를 이용한 추상화를 기반으로 하는 개발 방법
- Spring은 아래 DI/ IoC 를 강력하게 지원하는 프레임워크

 

선언할 때 자동으로 만들어지긴 하지만 beans라는 태그를 사용할 수 있다. bean들의 모임, bean에는 id 속성(고유하게 식별할 이름-중복 불가), class는 내가 미리 생성해놓을 클래스의 경로를 담아둠(xml 파일로 객체 생성)

* IoC: Inversion of Control

- 프로그램을 제어하는 패턴 중 하나
- DI는 IoC 패턴의 구현방법 중 하나
- DI에 따라 프로그램의 흐름이 완전히 변경됨

- Application-context: 스프링이 동작하는데 필요한 다양한 객체들이 200가지 정도 만들어져 있습니다.

- bean은 xml파일에 정의를 합니다. 

 

A클래스는 B클래스가 없으면 실행 할 수 없다 = 객체 안에 객체가 저장되는 형태이다. xml에도 의존관계를 나타내줘야 함. B를 A에 주입한다라고 표현함. dependecy injection

* DI : Dependency Injection

- 스프링 Container 에 만들어둔 각종 클래스 ( 들은 서로 의존적이다
- A객체가 B 객체 없이 동작이 불가능한 상황
- 스프링은 DI 를 기준으로 많은 프레임워크 모듈들이 만들어짐

- Spring은 DI Framework 혹은 IoC Framework 라고 부름

+ 마지막 사진 추가 설명

- 생성자를 통한 의존성 주입:  ref(bean의 아이디가 들어감)

- setter를 통한 의존성 주입: name은 set을 제외한 이름이 들어감(이름은 멤버변수 명이랑 같음), ref는 객체 타입을 주입할 수 있다.

 

 

* 예제(hotel, chef)

<?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 = "test" class ="ex01.SpringTest"/>
 
 <!-- 생성자를 통한 주입 -->
 <bean id="chef" class="ex02.Chef" />
 <bean id="hotel" class="ex02.Hotel" >
 	<constructor-arg ref="chef"/>
 </bean>

 <!-- 세터를 통한 주입 -->
 	<bean id="dev" class="ex02.DatabaseDev">
	<!-- DatabaseDev는 문자열, 비어 있으므로 property로 넣어줌 -->
		<property name="url" value="데이터베이스 주소" />
		<property name="uid" value="데이터베이스 계정명" />
		<property name="upw" value="데이터베이스 비밀번호" />
 	</bean>

	<bean id="dao" class="ex02.MemberDAO">
		<property name="databaseDev" ref="dev"/>
	</bean>
	
</beans>
package ex02;

public class Hotel {

	//hotel 객체가 chef 객체를 사용하고 있는 경우에는 hotel 객체가 chef 객체에 의존성이 있다고 표현함.

	//멤버변수
	private Chef chef;

	//생성자-construct
	public Hotel(Chef chef) {
		this.chef = chef;
	}

	//getter
	public Chef getChef() {
		return chef;
	}

	
	
	
}
package ex02;

public class Chef {
	
	public void cooking() {
		System.out.println("요리하기 기능");
	}
}

* databaseDev,  MemberDAO, MainClass, application-context.xml

package ex02;

public class DatabaseDev {

	private String url;
	private String uid;
	private String upw;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUid() {
		return uid;
	}
	public void setUid(String uid) {
		this.uid = uid;
	}
	public String getUpw() {
		return upw;
	}
	public void setUpw(String upw) {
		this.upw = upw;
	}
	
	
	
}
package ex02;

public class MemberDAO {
	
	private DatabaseDev databaseDev;

	//get
	public DatabaseDev getDatabaseDev() {
		return databaseDev;
	}

	//set
	public void setDatabaseDev(DatabaseDev databaseDev) {
		this.databaseDev = databaseDev;
	}
	
	

}
package ex02;

import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {
	
	public static void main(String[] args) {
		
		GenericXmlApplicationContext ctx =
				new GenericXmlApplicationContext("application-context.xml");
		
		//호텔 안에 있는 get을 통해 cooking 메서드 실행
		//생성자를 통한 주입 확인
//		Hotel hotel = ctx.getBean(Hotel.class);
//		hotel.getChef().cooking();
//		new Hotel(new Chef()); //원래는 이렇게 만들어야 하는데 위와 같이 xml에서는 의존성 주입
	
		//세터를 통한 주입 확인
		MemberDAO dao = ctx.getBean("dao", MemberDAO.class);
		DatabaseDev dev= dao.getDatabaseDev();
		System.out.println(dev.getUid());
		System.out.println(dev.getUrl());
		System.out.println(dev.getUpw());
		
	}

}
<?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 = "test" class ="ex01.SpringTest"/>
 
 <!-- 생성자를 통한 주입 -->
 <bean id="chef" class="ex02.Chef" />
 <bean id="hotel" class="ex02.Hotel" >
 	<constructor-arg ref="chef"/>
 </bean>

 <!-- 세터를 통한 주입 -->
 	<bean id="dev" class="ex02.DatabaseDev">
	<!-- DatabaseDev는 문자열, 비어 있으므로 property로 넣어줌 -->
		<property name="url" value="데이터베이스 주소" />
		<property name="uid" value="데이터베이스 계정명" />
		<property name="upw" value="데이터베이스 비밀번호" />
 	</bean>

	<bean id="dao" class="ex02.MemberDAO">
		<property name="databaseDev" ref="dev"/>
	</bean>
	
</beans>

 

2) singleton

- scope="prototype"이라고 하면 다른 객체로 나옴, 원래 자동으로 singleton으로 생성 됨.

 

3) list or map의 의존성 주입

* 예제(customer, person, collection-context.xml, MainClass)

package ex03;

import java.util.List;
import java.util.Map;

public class Customer {
	
	//list or map의 의존성 주입
	//string을 받는 List
	private List<String> lists;
	
	//객체를 받는 List
	private List<Person> persons;
	
	//map
	private Map<String, Object> maps;
	
	

	//List<String>의 getter, setter
	public List<String> getLists() {
		return lists;
	}

	public void setLists(List<String> lists) {
		this.lists = lists;
	}

	//List<person>의 getter, setter
	public List<Person> getPersons() {
		return persons;
	}

	public void setPersons(List<Person> persons) {
		this.persons = persons;
	}

	//map의 getter, setter
	public Map<String, Object> getMaps() {
		return maps;
	}

	public void setMaps(Map<String, Object> maps) {
		this.maps = maps;
	}
	
	
	
	
	

}
package ex03;

public class Person {

	private String name;
	private String id;
	
	//getter, setter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	
	
}
<?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">

	<!-- list or map의 의존성 주입 -->
	<bean id="customer" class="ex03.Customer">
		<!--list 안에 person -->
		<property name="lists">
			<list>
				<value>홍길동</value>
				<value>이순신</value>
				<value>홍길자</value>
			</list>
		</property>
		
		<!-- list 안에 object -->
		<property name="persons">
			<list>
				<bean class = "ex03.Person">
					<property name="name" value="홍길동"></property>
					<property name="id" value="aaa123"></property>
				</bean>
				
				<bean class = "ex03.Person">
					<property name="name" value="홍길자"></property>
					<property name="id" value="bbb123"></property>
				</bean>
			</list>
		</property>
		
		<!-- map 안에 object가 들어있는 모형 -->
		<property name="maps">
			<map>
				<entry key="k1" value="문자열"></entry>
				<entry key="k2">
					<bean class="ex03.Person">
						<property name="name" value="홍길자"></property>
						<property name="id" value="bbb123"></property>
					</bean>
				</entry>
			</map>
		
		
		</property>
		
	</bean>

</beans>
package ex03;

import java.util.Map;

import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {
	
	public static void main(String[] args) {
		
		
		GenericXmlApplicationContext ctx =
				new GenericXmlApplicationContext("collection-context.xml");
		
		//map 꺼내보기(앞에는 collection-context에서 bean id)
		Customer customer = ctx.getBean("customer", Customer.class);
        
		Map<String, Object> maps = customer.getMaps();
		System.out.println(maps.toString());
		
	}

}

 

4) 연습 문제

 

 

* mainClass, transpotation-context.xml

package ex04;

import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {

	public static void main(String[] args) {
		
		//Car, Airplane 빈을 생성하고, 의존성 주입
		//각 객체 안에 있는 배터리를 자바클래스에서 출력.
		//인터페이스는 모형일 뿐 객체 생성이 안됩니다.
		
		GenericXmlApplicationContext ctx = 
				new GenericXmlApplicationContext("transportation-context.xml");
		
		//예를 들어서 Car.class라는 것은 transportation-context에서 
		//id값이 car인 class를 가지고 온다는 의미임.
		Car car = ctx.getBean(Car.class);
		car.getBattery().energy();
		
		ctx.getBean(Airplane.class).getBattery().energy();
	
		
	}
}
<?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">

	<!-- 생성자를 통한 주입 -->
	<!-- 배터리는 인터페이스라서 객체 생성이 안되기 때문에 java 파일에서 사용해야함. -->
	<!-- 의존 관계니까 배터리를 먼저 만들고, car를 만든다. -->
	<!-- spring은 프로그램을 시작하자마자 객체를 만들고 시작하니까 꺼내서 쓸 수 있고, 
	작성 순서에 영향을 받지 않는다. 	-->
	
	<!-- 배터리1 객체 생성 -->
	<bean id="battery1" class="ex04.Battery1">
	</bean>
	
	<!-- car는 battery에 의존한다. -->
	<!-- battery1이라는 위에 있는 객체의 id를 ref에 넣어줌 -->
	<!-- battery1이라는 배터리를 낀 car를 사용 할거야 -->
	<bean id="car" class="ex04.Car">
		<constructor-arg ref="battery1" />
	</bean>
	
	<!-- 배터리2 객체 생성 -->
	<bean id="battery2" class="ex04.Battery2">
	</bean>
	
	<!-- airplane은 getter, setter를 통한 주입-->
	<bean id="airplane" class ="ex04.Airplane">
		<property name="battery" ref="battery2"/>
	</bean>
	 
		
		
	

</beans>

'TIL > Spring' 카테고리의 다른 글

day78-spring  (0) 2023.02.06
day77-spring  (0) 2023.02.03
day76-spring  (0) 2023.02.02
day75-spring  (1) 2023.02.01
day74-spring  (0) 2023.01.31
profile

mjeongriver

@mjeongriver

포스팅이 좋았다면 "좋아요❤️" 또는 "구독👍🏻" 해주세요!

검색 태그

티스토리툴바