221018 Spring 시작

wonny·2022년 10월 18일
0

수업 복습

목록 보기
7/14

Spring Framework 기본 개념

1) POJO(Plain Old Java Object)
: 다른 클래스를 상속 받아서 만들어야 하는 클래스가 아닌 순수한 형태의 자바 클래스
2) IoC(Inversion of Control)
: 제어의 역전이라는 뜻으로, 개발자가 직접 객체를 언제 생성하고 없앨지 결정하는 것이 아니라 컨테이너에게 맡긴다는 뜻이다. POJO 객체의 생성에서 생명주기의 관리까지를 IoC Container에게 담당시킴으로써(XML 이용) 개발에 있어서 편의성과 재사용성의 극대화를 추구하는 개념
3) AOP(Aspect Oriented Programming)
: 관점 지향 프로그래밍이란 뜻으로 기존의 객체지향 언어에 의해 추구된 모듈화에 따라 많아진 중복된 코드라던지 공통된 처리에 관련한 것들을 고나점으로 뽑아내어 공통으로 처리하는 방식

  • IoC - Bean의 관리
  1. Spring에서 BeanFactory가 기본 IoC 컨테이너이고, 보다 향상된 형태로 ApplicationContext라는 컨테이너도 지원하고 있다.
  2. IoC 컨테이너에 의해서 Bean의 생명주기가 관리된다.
  3. 이렇게 관리되는 Bean은 POJO 타입이고 싱글톤이다.
  4. XML 설정을 통해 각각의 Bean들을 묶어주는데, 이를 wiring이라고 한다.
  5. 묶인 Bean을 원하는 곳에 적용하는 것을 DI(의존성 주입)이라고 한다.


  • DI(Dependency Injection)
    의존성 주입이라는 뜻으로, 객체를 생성해서 필요로 하는 곳에 넣어주는 것을 뜻한다.
  1. Constructor Injection(생성자 주입)
    생성자에 필요 객체를 선언하고 멤버변수(Field)로써 객체를 사용하는 것을 말한다. 객체 생성시 자동으로 IoC 컨테이너가 관련 객체를 주입시켜준다.
  2. Setter Injection(세터 메서드 이용 주입)
    생성자 주입과 방식은 비슷하나 setter 메서드를 이용한다.
  • DI와 빈 객체를 위한 Annotation 설정
    1) @Required: 필수 프로퍼티를 세팅할 떄 사용
    2) @Autowired: 자동으로 똑같은 이름의 빈을 찾아서 주입해준다(타입으로 찾음)
    3) @Component:XML :설정 없이 자동 빈 등록, @Component("name")으로 이름 지정 가능
    4) @Service: @Component와 다를 바가 없으나 차후 세부화 예정
    5) @Repositary: 퍼시스턴스 영역의 Exception을 번역해주는 기능 제공
    6) @Controller: Spring MVC 사용시 Controller에 설정

HomeController.java

  • @Controller: bean에 자동으로 등록 시킨다.
  • @RequestMapping(value = "/", method = RequestMethod.GET): 프로젝트를 열었을 때 root("/")에서 열린다

servlet-context.xml

  • DispatcherServlet Context: defines this servlet's request-processing infrastructure
    : dispatcherServlet에서 모든 것을 관장한다.
    어떤 Mapping 주소값을 만나면 어느 컨트롤러에 있는 Mapping이랑 같은건지, 그러면 어느 Resolver에 의해서 어떤 view로 포워드 시켜줘야 하군! 이런 것들을 관장함

  • <context:component-scan base-package="spring.day1017.ex1" />: 만들어지는 패키지는 모두 등록되어야 한다.

  • <beans:property name="prefix" value="/WEB-INF/views/" />
    <beans:property name="suffix" value=".jsp" />
    : 앞으로 포워드 하는 파일은 views 폴더 안에 있는 .jsp 파일이라는 뜻, 즉 return "home"; 은 WEB-INF/views 폴더 안에 있는 home.jsp 파일을 리턴한다는 뜻

root-context.xml

DB에 관련된 것들을 설정

pom.xml

<org.springframework-version>5.2.9.RELEASE</org.springframework-version>
5버전 이상이여야 getMapping, postMapping이 가능하기 때문에 항상 5.2.9로 수정한다.

이전에는 jar 파일을 lib 폴더에 넣었지만 이제는 mvnrepository에서 필요한 jar를 pom.xml의 "< dependencies>" 사이에 복사하면 된다.

src/main/java>spring.di.ex1>Hello.java

package spring.day1017.ex1;

public class Hello {

	private String msg = "Have a nice day!";
	
	public String getMessage() {
		return "Hello 메서드 호출: "+msg;
	}
}

src/main/resources>appContext1.xml

src/main/resources 오른쪽 클릭>Spring Bean Configuration File>파일 이름 작성>beans 체크>맨 마지막(4.3)체크

<!-- Hello bean 설정 -->
	<bean name="hello" class="spring.day1017.ex1.Hello"/>

bean에 Hello 클래스를 hello라는 이름으로 등록할게~! (나중에는 어노테이션을 활용해서 자동등록 시킬 것임)

src/main/java>spring.di.ex1>HelloMain.java

1. java 방식으로 출력

public static void main(String[] args) {
		// TODO Auto-generated method stub

		System.out.println("java 방식으로 Hello 메서드 호출하기");
		Hello hello1 = new Hello();
		Hello hello2 = new Hello();
		
		System.out.println(hello1.getMessage());
        
        System.out.println(hello1==hello2);

결과:
java 방식으로 Hello 메서드 호출하기
Hello 메서드 호출: Have a nice day!
false
System.out.println(hello1==hello2); -> 레퍼런스 주소 비교, 자바에서는 new로 생성할 때마다 새로운 영역에 생성하기 때문에 false가 나온다.

2. 스프링 방식으로 출력

System.out.println("Spring 방식으로 Hello 메서드 호출하기");
		
		//application 실행하기 때문에 설정 xml 파일 가져와서 어플리케이션 실행(웹에선 필요 없음)
		ApplicationContext app1 = new ClassPathXmlApplicationContext("appContext1.xml");
		
		//Hello 객체 생성
        //방법1. "hello"는 xml에 썼던 name, getBean(String name)은 object라서 맞춰줌
		Hello h1 = (Hello)app1.getBean("hello"); 
		System.out.println(h1.getMessage());

		//방법2
		Hello h2 = app1.getBean("hello", Hello.class); 	
        System.out.println(h2.getMessage());
		
		System.out.println(h1==h2); //결과값: true, 생성 주소가 같다. 스프링에서는 기본이 싱글톤

결과:
Spring 방식으로 Hello 메서드 호출하기
Hello 메서드 호출: Have a nice day!
Hello 메서드 호출: Have a nice day!
true

spring.di.ex2/MessageInter.java

package spring.di.ex2;

public interface MessageInter {

	public void sayHello(String name);
}

인터페이스를 활용하면 메서드 목록들만 확인할 수 있기 때문에 프로젝트 진행할 때 편함

spring.di.ex2/Message1.java

package spring.di.ex2;

public class Message1 implements MessageInter {

	@Override
	public void sayHello(String name) {
		// TODO Auto-generated method stub
		System.out.println("안녕하세용"+name+"님");
	}

}

spring.di.ex2/Message2.java

package spring.di.ex2;

public class Message2 implements MessageInter {

	@Override
	public void sayHello(String name) {
		// TODO Auto-generated method stub
		System.out.println("반가워요"+name+"씨");
	}

}

src/main/resources/appContext2.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 https://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

	<bean id="mesBean1" class="spring.di.ex2.Message1"/>
	<bean id="mesBean2" class="spring.di.ex2.Message2"/>
</beans>

spring.di.ex2/MesMain.java

package spring.di.ex2;

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

public class MesMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//자바 형식
		System.out.println("java 방식으로 생성 후 호출");
		MessageInter m1 = new Message1(); //인터페이스는 생성이 안됨 
		m1.sayHello("김철수");
		MessageInter m2 = new Message2();
		m2.sayHello("박영희");
		
		//spring 방식
		System.out.println("spring 방식으로 객체 생성 후 호출");
		ApplicationContext context = new ClassPathXmlApplicationContext("appContext2.xml");
		//방법1
		MessageInter m3 = (Message1)context.getBean("mesBean1");
		m3.sayHello("마이클");
		//방법2
		MessageInter m4 = context.getBean("mesBean2", Message2.class);
		m4.sayHello("빅토리아");
		
		
		
	}

}

결과:
java 방식으로 생성 후 호출
안녕하세용김철수님
반가워요박영희씨
spring 방식으로 객체 생성 후 호출
안녕하세용마이클님
반가워요빅토리아씨

스프링은 내가 만드는 class가 xml bean에 등록되어있지 않으면 출력이 불가능, 항상 bean에 등록을 시켜야 한다.

생성자 주입

spring.di.ex3/MyInfo.java

package spring.di.ex3;

public class MyInfo {

	String name;
	int age;
	String addr;
	
	//생성자(클래스 이름과 동일해야 함)
	public MyInfo(String name, int age, String addr) {

		super(); 
		this.name=name;
		this.age=age;
		this.addr=addr;
	}
	
	//메서드(기본적으로 Object 클래스의 상속을 받기 때문에 toString()은 언제나 오버라이딩 가능)
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "MyInfo[name="+name+", age="+age+", addr="+addr+"]";
	}
}

이제 MyInfo의 name, age, addr을 멤버값으로 갖는 클래스를 만들어보자.

spring.di.ex3/Person.java

package spring.di.ex3;

public class Person {

	String schoolName;
	MyInfo info;
	
	//생성자
	public Person(MyInfo info) {
		// TODO Auto-generated constructor stub
		super();
		this.info = info;
		
	}

	//setter

	public void setSchoolName(String schoolName) {
		this.schoolName = schoolName;
	}
	
	//출력
	public void write() {
		System.out.println("***학생 정보 출력***");
		System.out.println("학교명: "+schoolName);
		System.out.println("이름: "+info.name);
		System.out.println("나이: "+info.age+"세");
		System.out.println("주소: "+info.addr);
	}
	
}

Person 클래스에서는 schoolName과 MyInfo 자체를 멤버로 갖게된다

src/main/resources>appContext3.xml

	<bean id="my" class="spring.di.ex3.MyInfo">
		<constructor-arg value="김태희"/>	
		<constructor-arg value="27"/>
		<constructor-arg>
			<value>서울시 강남구 역삼동</value>
		</constructor-arg>
	</bean>

	<bean id="person" class="spring.di.ex3.Person">
		<!-- MyInfo는 생성자 주입 -->
		<constructor-arg ref = "my"/>
		<!-- 학교명은 setter 주입 -->
		<property name="schoolName" value="쌍용교육센터"/>
	</bean>

생성자 주입은 constructor-arg, setter 주입은 property
my 전체를 생성자 주입 -> constructor-arg ref = "my"
ref태그는 bean의 name, id로 찾는다.

spring.di.ex3/InfoMain.java

public class InfoMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ApplicationContext context = new ClassPathXmlApplicationContext("appContext3.xml");
		
		//MyInfo부터 먼저 생성 후 확인
		MyInfo my = (MyInfo)context.getBean("my");
		
		//값 확인
		System.out.println(my.toString());
		
		//person
		Person p = (Person)context.getBean("person");
		p.write();
	}

}

spring.di.ex4/SawonData.java

package spring.di.ex4;

public class SawonData {
	
	private String sawonName;
	private int pay;
	private String ipsaday;

	public SawonData() {
		// TODO Auto-generated constructor stub
	}
	//사원명은 생성자 주입
	public SawonData(String sawonName) {
		this.sawonName=sawonName;
	}	
	//급여, 입사일은 setter 주입
	public int getPay() {
		return pay;
	}
	public void setPay(int pay) {
		this.pay = pay;
	}
	public String getIpsaday() {
		return ipsaday;
	}
	public void setIpsaday(String ipsaday) {
		this.ipsaday = ipsaday;
	}
	public String getSawonName() {
		return sawonName;
	}
	public void setSawonName(String sawonName) {
		this.sawonName = sawonName;
	}
	
}

spring.di.ex4/Sawon.java

package spring.di.ex4;

public class Sawon {

	SawonData data;
	
	public Sawon(SawonData data) {
		this.data=data;
	}
	
	
	//출력
	public void writeData() {
		System.out.println("사원명: "+data.getSawonName());
		System.out.println("급여: "+data.getPay());
		System.out.println("입사일: "+data.getIpsaday());
	}

	
}

src/main/resources>appContext4.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 https://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

	<!--sawonData 설정 -->
	<bean id="data" class="spring.di.ex4.SawonData">
	<!-- sawonName은 생성자 주입 -->
	<constructor-arg value="김하나"/>
	<!-- Sawon은 setter 주입 -->
	<property name="pay" value="2300000"></property>
	<property name="ipsaday" value="2019-10-10"></property>
	</bean>
	
	<!--sawon 설정 -->	
	<bean id="sawon" class="spring.di.ex4.Sawon">
		<!-- SawonData(이름) 생성자 주입 -->
        <constructor-arg ref="data"/>
	</bean>


	<bean id="sdata2" class="spring.di.ex4.SawonData">
	<property name="sawonName" value="이영희"></property>
	<property name="pay" value="1850000"></property>
	<property name="ipsaday" value="2018-12-12"></property>
	</bean>
	
	<bean id="sawon2" class="spring.di.ex4.Sawon">
	<constructor-arg ref="sdata2"/>
	</bean>

</beans>

spring.di.ex4/SawonMain.java

package spring.di.ex4;

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

public class SawonMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		ApplicationContext context = new ClassPathXmlApplicationContext("appContext4.xml");
			
        //방법1
		Sawon s = (Sawon)context.getBean("sawon");
		s.writeData();
	
    	//방법2
        Sawon ss = context.getBean("sawon", Sawon.class);
		ss.writeData();
    
		Sawon s2 = (Sawon)context.getBean("sawon2");
		s2.writeData();
		
	}

}

정리

  1. 클라이언트의 요청이 DispatcherServlet에 전달된다.
  2. DistpatcherServlet은 HandlerMapping을 사용하여 클라이언트의 요청이 전달될 Controller 객체를 구한다.
  3. DispatcherServlet은 Controller 객체의 handleRequest() 메소드를 호출하여 클라이언트의 요청을 처리한다.
  4. Controller.handleRequest() 메서드는 처리 결과 정보를 담은 ModelAndView 객체를 리턴한다.
  5. DispatcherServlet은 ViewResolver로부터 처리 결과를 보여줄 View를 구한다.
  6. View는 클라이언트에 전송할 응답을 생성한다.
profile
wonny
하다 보면 되겠지요..!
이전 포스트

221017 JSTL

0개의 댓글