스프링 컨테이너 의존성 주입 - 생성자, setter메소드 사용

🎯 Spring Framework의 특징과 의존성 주입 방법을 알아본다.

 

 

 

스프링 프레임워크

자바 엔터프라이즈(Java EE) 개발을 편하게 해주는 오픈 소스 경량급 어플리케이션 프레임워크

 

*엔터프라이즈란?

엔터프라이즈 어플리케이션: 기업용 프로그램을 개발하기 적합한 어플리케이션

이런 기업용 프레임워크는 보통 구조가 복잡한 편인데, 스프링은 간단한 구성으로 개발할 수 있는 경량(light-weight) 프레임워크이다.

 

 

 

왜 스프링을 사용할까?

• POJO 개발을 쉽게 할 수 있다.
• IoC(Inversion of Control) 컨테이너: 객체의 관리를 스프링 컨테이너에게 아웃소싱한다. 컨테이너가 코드 대신 객체의 생성과 소멸을 관리할 수 있어서 IoC(제어의 역전)이라고 부른다. configuration.xml 파일이나 자바 소스코드 안에 어노테이션으로 컨테이너를 설정한다.
• 느슨한 연결(디커플링)을 위한 의존성 주입(Dependency Injection): 클래스 사이의 의존 관계를 빈(Bean) 설정 정보를 바탕으로 컨테이너가 자동으로 연결해주는 것
• AOP 지원 (기능별 모듈화)

 

 

 

의존성 주입

난 차가 필요하다. 차 공장(configuration.xml)에 차를 하나 달라고 요청한다. 공장에서 모든걸 만들어서 줄거다.

차를 만들기 위해 필요한 모든 의존성(엔진, 타이어, 시트 등)을 공장에서 주입해준다.

A가 "나는 B가 필요해"라고 의존성 주입 신호만 보내면 ApplicationContext라는 스프링 컨테이너가 필요한 B객체를 생성하고 주입해준다. 여기서 스프링 컨테이너가 관리하는 객체를 Bean 이라고 말하며 빈과 빈의 의존관계는 xml 또는 어노테이션으로 설정한다. sts 레거시 프로젝트는 기본적으로 xml 사용해서 객체를 관리한다.

 

 

 

스프링 개발 과정

1. xml에 beans 설정 (객체)
2. 스프링 컨테이너 생성
   • ApplicationContext가 일반적으로 사용하는 스프링 컨테이너
   • 그밖에 GenericWebApplicationContext 등이 있다.
   • main에 이 컨테이너 객체를 생성해서 사용
3. 스프링 컨테이너에서 beans 찾기
   • context.getBean("빈즈 아이디", 클래스이름.class)
   • 아이디를 잘못적으면 이런 에러가 뜬다: "NoSuchBeanDefinitionException: No bean named 'stu1' available"

ApplicationContext ac = new ClassPathXmlApplicationContext( 
                "classpath:applicationContext.xml"); 

UserBean userBean = (UserBean)ac.getBean("userBean");
userBean.setName("kim");
System.out.println(userBean.getName());

 

 

 

의존성 주입 3가지 방법

• 생성자 주입
• setter 주입
• 어노테이션 사용 오토와이어링

 

 

 

생성자 주입 방법

1. 의존성 클래스 정의
2. 주입을 위해 생성자 만들기
   • 멤버변수를 생성자 인자에 그대로 갖고오기
3. configuration.xml 파일에 의존성 주입 설정하기
   • helper Bean 객체 먼저 생성하고, 주입 받는 Bean 객체는 생성자 주입 방식으로 helper 참조

 

constructor_injection1:

com.dto.Student:

private String name;
    public Student(String x) {
        System.out.println("인자있는 생성자");
        this.name = x;
    }
    public String getInfo() {
        return name;
    }

stu.xml:

<bean id="firstStudent" class="com.dto.Student">
    <constructor-arg name="x" value="홍길동" />
</bean>

이걸 뜯어보면 Student firstStudent = new Student("홍길동"); 객체생성 방식과 똑같다.

TestStudent:

Student test = ctx.getBean("firstStudent", Student.class);
System.out.println(test.getInfo());

 

 

기본생성자를 만드는 이유?

기본생성자(no-arg constructor)를 정의하지 않으면 컴파일러는 일단 기본생성자를 만들어준다. 근데 내가 아무 생성자나 정의해놓으면(인자있는 생성자) 컴파일러는 따로 기본생성자를 만들어주지 않는다.

 

 

constructor_injection2: 인자가 여러개인 생성자

package com.dto;

public class Student {

    private String name;
    private int age;

    public Student() {}

    public Student(String name) { //생성자를 작성
        this.name = name;
        System.out.println("1");
    }

    public Student(int age) { //생성자를 작성
        this.age = age;
        System.out.println("2");
    }

    public Student(String name, int age) { //생성자를 작성
        this.name = name;
        this.age = age;
        System.out.println("3");
    }

    public String getInfo() {
        return name+"\t"+age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

여러개의 생성자를 만들었다. 네임만 들어간거, 나이만 들어간거, 둘다 들어간거

stu.xml:

<bean id="firstStudent" class="com.dto.Student">
    <constructor-arg name="name" value="홍길동" />
</bean>
<bean id="secondStudent" class="com.dto.Student">
    <constructor-arg name="age" value="20" />
</bean>
<bean id="thirdStudent" class="com.dto.Student">
    <constructor-arg name="name" value="유노윤호" />
    <constructor-arg name="age" value="20" />
</bean>

age를 String 타입으로 으로 써도 dto에 지정한 대로 int 타입으로 자동 형변환되어 들어간다. 이렇게 beans 객체 3개를 만들었다. 생성자 인자 2개 받는건 태그도 2개 들어갔다.

TestStudent.java:

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext("stu.xml");

Student test = ctx.getBean("firstStudent", Student.class);
System.out.println(test.getInfo());

Student test2 = ctx.getBean("secondStudent", Student.class);
System.out.println(test2.getInfo());

Student test3 = ctx.getBean("thirdStudent", Student.class);
System.out.println(test3.getInfo());

System.out.println(test+"\t"+test2+"\t"+test3);

 

 

constructor_injection3: 다른 객체 참조하기

package com.dto;

public class Cat {
    private String catName;
    private int catAge;

    public Cat(String catName, int catAge) {
        this.catName = catName;
        this.catAge = catAge;
    }

    public String getCatInfo() {
        return catName+"\t"+catAge;
    }
}

고양이 객체 생성

public class Student {

    private String name;
    private int age;
    private Cat cat;

    public Student() {}

    public Student(String name, int age, Cat cat) { //생성자를 작성
        this.name = name;
        this.age = age;
        this.cat = cat;
    }

학생은 고양이도 한마리 갖고있다. Cat 객체를 외부에서 주입받아야한다.

<bean id="pet01" class="com.dto.Cat">
    <constructor-arg name="catAge" value="3" />
    <constructor-arg name="catName" value="나비" />
</bean>

<bean id="firstStudent" class="com.dto.Student">
    <constructor-arg name="name" value="홍길동" />
    <constructor-arg name="age" value="30"></constructor-arg>
    <constructor-arg name="cat" ref="pet01"></constructor-arg>
</bean>

cat을 참조하기 위해 캣 빈즈 객체를 사용한다. 참조는 ref 속성을 사용한다.

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext("stu.xml");

Student stu = ctx.getBean("firstStudent", Student.class);
System.out.println(stu.getInfo());

Cat cat = ctx.getBean("pet01", Cat.class);
System.out.println(cat.getCatInfo());

Cat cat1 = stu.getCat();
System.out.println(cat1.getCatInfo());

 

 

constructor_injection4: jdbc 연습

DeptDAO.java:

public class DeptDAO {
    public List<String> list(){
        return Arrays.asList("홍길동", "이순신", "유관순");
    }
}

dao에 리스트를 생성한다.

DeptService.java:

public class DeptService {
    DeptDAO dao; //new가 사라지고 .xml에서 주입

    public DeptService(DeptDAO dao) {
        this.dao = dao;
    }
    public List<String> list(){
        return dao.list();
    }
}

서비스 객체는 dao 객체를 생성자 주입 방식으로 받는다.

stu.xml:

<bean id="deptdao" class="com.dao.DeptDAO"></bean>
<bean id="service" class="com.dao.DeptService">
    <constructor-arg name="dao" ref="deptdao"></constructor-arg>
</bean>

DAO Bean 객체를 먼저 생성하고 service 객체는 생성자 주입 방식을 통해 필요한 dao 객체를 참조한다. 

main:

DeptService service = ctx.getBean("service", DeptService.class);
        List<String> list = service.list();
        for (String x : list) {
            System.out.println(x);
        }

반복문을 사용해 리스트를 출력한다.

 

 

 

Setter 주입 방법

1. 클래스에 주입을 위한 setter 메소드를 만든다.

2. configuration.xml 파일에 의존성을 설정한다

 

setter_injection1:

public class Student {
    private String name;
    public Student() {
        System.out.println("기본생성자호출======");
    }
    public Student(String name) { 
        this.name = name;
    }
    public void setName(String name) {
        System.out.println("setName호출======");
        this.name = name;
    }
    public String getInfo() {
        return name;
    }
}

멤버변수 name의 값을 셋팅할 수 있는 setter 메소드를 생성한다. 여기서 인자에 있는 name 이라는 변수가 xml에서 사용할 name속성의 값이 된다. (setter 메소드명이라고 생각해도 된다.)

<bean id="firstStudent" class="com.dto.Student">
    <property name="name" value="홍길동"></property>
</bean>

xml 설정파일에 학생 객체를 새로 만들어준다. setter 주입 방법을 사용할 경우 bean 객체 안에 <property> 태그를 사용해야 한다. 이 프로퍼티 태그는 setter 함수를 호출하겠다는 뜻이다. name속성은 setter함수의 인자 또는 이름! value는 내가 세팅하고 싶은 값을 지정한다.

GenericXmlApplicationContext ctx = 
                new GenericXmlApplicationContext("stu.xml");

        Student stu = ctx.getBean("firstStudent", Student.class);
        System.out.println(stu.getInfo());

set한 값을 가져올 땐 getter 함수를 사용한다.

 

 

setter_injection2: setter 함수 여러개

public class Student {
    private String name;
    private int age;
    //setter injection
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        System.out.println("setName호출======");
        this.name = name;
    }
    public String getInfo() {
        return name + "\t" + age;
    }
}

<bean id="firstStudent" class="com.dto.Student">
    <property name="name" value="홍길동"></property>
    <property name="age" value="20"></property>
</bean>

setter 메소드를 여러개 지정했을 경우 각각에 해당하는 프로퍼티 태그를 작성하면 된다. 프로퍼티로 셋함수 호출해서 나이를 20으로 세팅해줬다.

 

 

setter_injection3: 생성자와 setter 함께 사용

public class Student {

    private String name;
    private int age;

    //setter injection
    public void setName(String name) {
        this.name = name;
    }

    //constructor injection
    public Student(int age) {
        this.age = age;
    }

    public String getInfo() {
        return name + "\t" + age;
    }

}

이번엔 set함수는 name에만 만들어주고 age는 생성자로 만들었다.

<bean id="firstStudent" class="com.dto.Student">
    <property name="name" value="홍길동"></property>
    <constructor-arg name="age" value="20"></constructor-arg>
</bean>

설정파일에서 Stu 객체는 property랑 constructor-arg 태그 둘다 필요하다.

 

 

setter_injection4: 다른 객체 참조하기

public class Cat {
    private String catName;
    private int catAge;

    public void setCatName(String catName) {
        this.catName = catName;
    }

    public void setCatAge(int catAge) {
        this.catAge = catAge;
    }

    public String getCatInfo() {
        return catName + "\t" + catAge;
    }
}

cat dto 생성. setter 함수만 갖고있다.

<bean id="pet01" class="com.dto.Cat">
    <property name="catName" value="나비"></property>
    <property name="catAge" value="3"></property>
</bean>

<bean id="firstStudent" class="com.dto.Student">
    <property name="name" value="홍길동"></property>
    <property name="age" value="30"></property>
    <property name="cat" ref="pet01"></property>
</bean>

학생객체는 Cat객체를 ref 속성으로 참조한다.

GenericXmlApplicationContext ctx = 
                new GenericXmlApplicationContext("stu.xml");

        Student stu = ctx.getBean("firstStudent", Student.class);
        System.out.println(stu.getInfo());
        Cat cat = ctx.getBean("pet01", Cat.class);
        System.out.println(cat.getCatInfo());

 

 

setter_injection5: p 네임스페이스 사용

property 태그를 Bean 객체에 속성으로 간결하게 작성할 수 있는 방법이다. p 네임스페이스를 사용하기 위해 xml 네임스페이스에서 p를 체크한다.

<bean id="firstStudent" class="com.dto.Student" p:name="홍길동"/>

property 태그 안쓰고 bean 안에 인라인으로 작성. 

<bean id="pet01" class="com.dto.Cat" p:catName="나비" p:catAge="2" />

<bean id="firstStudent" class="com.dto.Student" p:name="홍길동" p:age="20" p:cat-ref="pet01">

 

다른 bean 객체를 참조하던 cat도 name-ref 형식의 인라인으로 작성할 수 있다.

 

 

 

😜 NEXT : 스프링 scope, lifeCycle과 collection 공부하기