728x90

자동주입

 

@Autowired @Qualifier

package main;

import beans.Test;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);


        Test t = ctx.getBean("test1", Test.class);
        System.out.println(t.getD3());
        System.out.println(t.getD4());
        System.out.println(t.getD5());




    }
}
package config;

import beans.Data;
import beans.Data2;
import beans.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test1() {
        return new Test();
    }

    @Bean
    public Data data1() {
        return new Data();
    }


    ///////////////////       qualifier이름 설정한거랑 똑같은 이름으로 멧도드를 설정해야 자동주입됨
    @Bean
    public Data2 obj1() {
        return new Data2();
    }

    @Bean
    public Data2 obj2() {
        return new Data2();
    }

}
package beans;


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

public class Test {

    private int d1;
    private Data d2;

    @Autowired // 자동주입 (타입을 통해 bean 객체를 자동으로 주입)
    private Data d3;

    @Autowired
    @Qualifier("obj1") //autowire로 주입할 때 같은 타입 bean이 여러개 정의되어있다면 이름을 설정(qualifier)해 주입한다.
    private Data2 d4;


    @Autowired
    @Qualifier("obj2")
    private Data2 d5;


    public int getD1() {
        return d1;
    }

    public void setD1(int d1) {
        this.d1 = d1;
    }

    public Data getD2() {
        return d2;
    }

    public void setD2(Data d2) {
        this.d2 = d2;
    }

    public Data getD3() {
        return d3;
    }

    public void setD3(Data d3) {
        this.d3 = d3;
    }

    public Data2 getD4() {
        return d4;
    }

    public void setD4(Data2 d4) {
        this.d4 = d4;
    }

    public Data2 getD5() {
        return d5;
    }

    public void setD5(Data2 d5) {
        this.d5 = d5;
    }
}

 


@Component

 

package main;


import beans.Test;
import beans.Test2;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");


        Test2 t2 = ctx.getBean("test2",Test2.class);
        System.out.println(t2);

        Test2 t22 = ctx.getBean("test22",Test2.class);
        System.out.println(t22);

    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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">


    <!-- 저장된 패키지 안에 있는 Bean클래스들의 어노테이션을 분석 -->
    <context:component-scan base-package="beans2"/>
    <context:component-scan base-package="beans3"/>

    <bean class="beans.Test"/>

    <bean class="beans.Test2" id="test2"/>
    <bean class="beans.Test2" id="test22"/>

</beans>
package beans;


public class Test2 {

}

 

 

 

@Component를 입력해놓은 경우

<context:component-scan base-package="beans2"/>

를 xml에 입력해줘야 스캔이 가능

 

package main;


import beans.Test;
import beans.Test2;
import beans2.Test3;
import beans2.Test4;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");


        Test3 t3 = ctx.getBean(Test3.class);
        System.out.println(t3);

        Test4 t4 = ctx.getBean("component4", Test4.class); // 이름을 설정한 경우 id값이 된다.
        System.out.println(t4);
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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">


    <!-- 저장된 패키지 안에 있는 Bean클래스들의 어노테이션을 분석 -->
    <context:component-scan base-package="beans2"/>
    <context:component-scan base-package="beans3"/>

    <bean class="beans.Test"/>

    <bean class="beans.Test2" id="test2"/>
    <bean class="beans.Test2" id="test22"/>

</beans>
package beans2;


import org.springframework.stereotype.Component;

@Component
//bean을 따로 등록하지 않아도 자동으로 등록
public class Test3 {
}
package beans2;

import org.springframework.stereotype.Component;

@Component("component4")
public class Test4 {
}

 


 

Test4 t4 = ctx.getBean("test4", Test4.class); // 이름을 설정한 경우 id값이 된다.
System.out.println(t4);
<bean class="beans2.Test4" id="test4"/>

 

아이디값을 따로 지정해서 하는 것도 가능하다

 

 

 

Test5 t5 = ctx.getBean("test5", Test5.class);
System.out.println(t5);
<context:component-scan base-package="beans3"/>
package beans3;

import org.springframework.stereotype.Component;

@Component
public class Test5 {
}
728x90
728x90

Spring Framework에서 빈(Bean)을 정의하고 구성하는 데 사용되는 주요 어노테이션


DI는 resource 디렉토리에 따로 config 를 만들고 xml을 넣어서 bean으로 클래스들을 관리했는데

이번에는 config를 java디렉토리 밑에 생성해서 클래스를 만들고 그 클래스를 통해 다른 클래스들을 관리한다.

 


@Configration - 수동주입

package main;

import beans.Test;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {
        //파일형식이 자바이기 때문에 클래스 바뀜
        AnnotationConfigApplicationContext ctx=
                new AnnotationConfigApplicationContext(BeanClass.class);

        Test t1=ctx.getBean("test1", Test.class);
        System.out.println(t1);

        Test t11=ctx.getBean("test1", Test.class);
        System.out.println(t11);

        Test t12=ctx.getBean("test2", Test.class);
        System.out.println(t11);


        }
    }
package config;

import beans.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test1() { // 메소드 이름이 bean의 이름(주소값)이 된다
        Test t1 = new Test();
        return t1;
    }

    @Bean(name = "test2")
    public Test test11() {
        Test t1 = new Test();
        return t1;
    }



}
package beans;


public class Test {

    public Test() {
        System.out.println("test");
    }
}

 

 

@Bean @Lazy (싱글톤)

package main;

import beans.Test;
import beans.Test2;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {
        //파일형식이 자바이기 때문에 클래스 바뀜
        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);


        Test2 t2 = ctx.getBean("test3", Test2.class);
        System.out.println(t2);

        Test2 t22 = ctx.getBean("test3", Test2.class);
        System.out.println(t22);


    }
}
package config;

import beans.Test;
import beans.Test2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test1() { // 메소드 이름이 bean의 이름(주소값)이 된다
        Test t1 = new Test();
        return t1;
    }

    @Bean(name = "test2")
    public Test test11() {
        Test t1 = new Test();
        return t1;
    }



    @Bean
    @Lazy
    public Test2 test3() {
        Test2 t2 = new Test2();
        return t2;
    }


}
package beans;

public class Test2 {

    public Test2() {
        System.out.println("test2");
    }
}

 

 

@Bean @Scope("prototype") (싱글톤X)

package main;

import beans.Test;
import beans.Test2;
import beans.Test3;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {
        //파일형식이 자바이기 때문에 클래스 바뀜
        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);


        Test3 t2 = ctx.getBean("test4", Test3.class);
        System.out.println(t2);

        Test3 t22 = ctx.getBean("test4", Test3.class);
        System.out.println(t22);


    }
}
package config;

import beans.Test;
import beans.Test2;
import beans.Test3;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test1() { // 메소드 이름이 bean의 이름(주소값)이 된다
        Test t1 = new Test();
        return t1;
    }

    @Bean(name = "test2")
    public Test test11() {
        Test t1 = new Test();
        return t1;
    }



    @Bean
    @Lazy
    public Test2 test3() {
        Test2 t2 = new Test2();
        return t2;
    }

    @Bean
    @Scope("prototype")
    public Test3 test4() {
        Test3 t3 = new Test3();
        return t3;
    }

}
package beans;

public class Test3 {

    public Test3() {
        System.out.println("test3");
    }
}

 

 

 


Spring Framework를 사용하여 빈을 초기화하고 소멸하는 방법을 보여주는 예시

 

 

package main;

import beans.Test;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {
        //파일형식이 자바이기 때문에 클래스 바뀜
        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);

        Test t1 = ctx.getBean("test1", Test.class);

        ctx.close();

    }
}
package config;



import beans.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;


@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    @Lazy
    public Test test1() {
        return new Test();
    }


}
package beans;

public class Test {

    public Test() {
        System.out.println("test");
    }

    public void init() {
        System.out.println("Test init");
    }

    public void destroy() {
        System.out.println("Test destroy");
    }
}

 

 

 

 


JavaDI - 자바파일로 주입 (생성자를 통한 주입)

package main;


import beans.Test;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);

        Test t1 = ctx.getBean("test1", Test.class);
        System.out.println(t1.getD1());
        System.out.println(t1.getD2());
        System.out.println(t1.getD3());


    }
}
package config;

import beans.Data;
import beans.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test1() {
        return new Test(10, "spring", new Data()); //생성자를 통한 주입
    }



}
package beans;

public class Test {

    private int d1;
    private String d2;
    private Data d3;

    public Test() {}

    public Test(int d1, String d2, Data d3) {
        this.d1 = d1;
        this.d2 = d2;
        this.d3 = d3;
    }

    public int getD1() {
        return d1;
    }

    public void setD1(int d1) {
        this.d1 = d1;
    }

    public String getD2() {
        return d2;
    }

    public void setD2(String d2) {
        this.d2 = d2;
    }

    public Data getD3() {
        return d3;
    }

    public void setD3(Data d3) {
        this.d3 = d3;
    }
}

 


setter를 통한 주입

 

package main;


import beans.Test;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);


        Test t1 = ctx.getBean("test2", Test.class);
        System.out.println(t1.getD1());
        System.out.println(t1.getD2());
        System.out.println(t1.getD3());


    }
}
package config;

import beans.Data;
import beans.Test;
import beans.Test2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test2() {
       Test t1 = new Test();
       t1.setD1(10); //setter 메소드를 통한 주입
       t1.setD2("spring");
       t1.setD3(new Data());

       return t1;
    }

}
package beans;

public class Test {

    private int d1;
    private String d2;
    private Data d3;

    public Test() {}

    public Test(int d1, String d2, Data d3) {
        this.d1 = d1;
        this.d2 = d2;
        this.d3 = d3;
    }

    public int getD1() {
        return d1;
    }

    public void setD1(int d1) {
        this.d1 = d1;
    }

    public String getD2() {
        return d2;
    }

    public void setD2(String d2) {
        this.d2 = d2;
    }

    public Data getD3() {
        return d3;
    }

    public void setD3(Data d3) {
        this.d3 = d3;
    }
}

 

 

 


 

 

@Value를 활용한 주입

 

package main;

import beans.Test;
import beans.Test2;
import config.BeanClass;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(BeanClass.class);
                
        Test2 t2 = ctx.getBean("test2", Test2.class);
        System.out.println(t2.getD1());
        System.out.println(t2.getD2());
        System.out.println(t2.getD3());
        System.out.println(t2.getD4());
    }
}
package config;

import beans.Data;
import beans.Data2;
import beans.Test;
import beans.Test2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//현재 자바 파일이 빈 등록을 하기위한 (객체등록) 자바파일임을 알리는 어노테이션
public class BeanClass {

    @Bean
    public Test test1() {
        return new Test();
    }

    @Bean
    public Data data1() {
        return new Data();
    }


    ///////////////////       qualifier이름 설정한거랑 똑같은 이름으로 멧도드를 설정해야 자동주입됨
    @Bean
    public Data2 obj1() {
        return new Data2();
    }

    @Bean
    public Data2 obj2() {
        return new Data2();
    }

    @Bean
    public Test2 test2() {
        return new Test2();
    }

}
package beans;

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

public class Test2 {

    private int d1;
    private String d2;
    private Data3 d3;
    private Data4 d4;

    public Test2() {}
    public Test2(@Value("1") int d1, @Value("spring")String d2, Data3 d3, Data4 d4) {
        this.d1 = d1;
        this.d2 = d2;
        this.d3 = d3;
        this.d4 = d4;
    }

    public int getD1() {
        return d1;
    }

    public void setD1(int d1) {
        this.d1 = d1;
    }

    public String getD2() {
        return d2;
    }

    public void setD2(String d2) {
        this.d2 = d2;
    }

    public Data3 getD3() {
        return d3;
    }

    public void setD3(Data3 d3) {
        this.d3 = d3;
    }

    public Data4 getD4() {
        return d4;
    }

    public void setD4(Data4 d4) {
        this.d4 = d4;
    }
}
728x90
728x90

setDI 

<?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="test1" class="beans.Test">
        <property name="d1" value="200"/>
        <property name="d2" value="11.11"/>
        <property name="d3" value='hi'/>
        <property name="d4" value="true"/>
        <property name="d5">
            <bean class="beans.Data"/>
        </property>

        <property name="d6" ref="data"/>
    </bean>

    <bean id="data" class="beans.Data"/>
</beans>
package beans;

public class Test {

        private int d1;
        private double d2;
        private String d3;
        private boolean d4;
        private Data d5;
        private Data d6;

    public int getD1() {
        return d1;
    }

    public void setD1(int d1) {
        this.d1 = d1;
    }

    public double getD2() {
        return d2;
    }

    public void setD2(double d2) {
        this.d2 = d2;
    }

    public String getD3() {
        return d3;
    }

    public void setD3(String d3) {
        this.d3 = d3;
    }

    public boolean isD4() {
        return d4;
    }

    public void setD4(boolean d4) {
        this.d4 = d4;
    }

    public Data getD5() {
        return d5;
    }

    public void setD5(Data d5) {
        this.d5 = d5;
    }

    public Data getD6() {
        return d6;
    }

    public void setD6(Data d6) {
        this.d6 = d6;
    }
}

 

 

AutoDI

 

scope="prototype"

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");

        Test t1 = ctx.getBean("test1", Test.class);
        System.out.println(t1.getD1());
        System.out.println(t1.getD2());
        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">

    <!-- set메소드로 주입하는 방법 -->
    <bean id="test1" class="beans.Test">
        <property name="d1" ref="data"/>
        <property name="d2" ref="data"/>
    </bean>
<!--    <bean id="data" class="beans.Data"/>-->

    <bean id="data" class="beans.Data" scope="prototype"/>
    
    </beans>
package beans;

public class Test {

    private Data d1;
    private Data d2;

    public Data getD1() {
        return d1;
    }

    public void setD1(Data d1) {
        this.d1 = d1;
    }

    public Data getD2() {
        return d2;
    }

    public void setD2(Data d2) {
        this.d2 = d2;
    }
}

 

 

 

autowire="byName"

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");


        Test t2 = ctx.getBean("test2", Test.class);
        System.out.println(t2.getD1());
        System.out.println(t2.getD2());

    }
}
<?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">

    <!-- set메소드로 주입하는 방법 -->
    <bean id="test1" class="beans.Test">
        <property name="d1" ref="data"/>
        <property name="d2" ref="data"/>
    </bean>
<!--    <bean id="data" class="beans.Data"/>-->

    <bean id="data" class="beans.Data" scope="prototype"/>

    <!-- autowire="byName": 프로퍼티 이름과 정의된 빈의 이름이 같은 것을 찾아 자동으로 주입 -->
    <bean id="test2" class="beans.Test" autowire="byName"/>

    <bean id="d1" class="beans.Data"/>
    <bean id="d2" class="beans.Data"/>

</beans>
package beans;

public class Test {

    private Data d1;
    private Data d2;

    public Data getD1() {
        return d1;
    }

    public void setD1(Data d1) {
        this.d1 = d1;
    }

    public Data getD2() {
        return d2;
    }

    public void setD2(Data d2) {
        this.d2 = d2;
    }
}

 

 

 

autowire="byType"

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");


        Test2 t = ctx.getBean("test3", Test2.class);
        System.out.println(t.getD1());
        System.out.println(t.getD2());



    }
}
<?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">

   

    <!-- autowire="byType": 프로퍼티 타입과 정의된 빈의 타입이 일치할 경우 자동으로 주입 -->
    <bean id="test3" class="beans.Test2" autowire="byType"/>
    <bean id="data2" class="beans.Data2"/>

</beans>
package beans;

public class Test2 {

    private Data2 d1;
    private Data2 d2;

    public Data2 getD1() {
        return d1;
    }

    public void setD1(Data2 d1) {
        this.d1 = d1;
    }

    public Data2 getD2() {
        return d2;
    }

    public void setD2(Data2 d2) {
        this.d2 = d2;
    }
}

 

 

 


CollectionDI

 

 

List<String> 주입

 

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");

        Test t1 = ctx.getBean("test1", Test.class);
        List<String> li = t1.getList1();

        for(String str:li) {
            System.out.println(str);
        }
    }
}
<?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="test1" class="beans.Test">
        <property name="list1">
            <list>
                <value>스프링1</value>
                <value>스프링2</value>
                <value>스프링3</value>
            </list>
        </property>

        <property name="list2">
            <list>
                <value type="int">10</value>
                <value type="int">20</value>
                <value type="int">30</value>
            </list>
        </property>

        <property name="list3">
            <list>
                <bean class="beans.Data"/>
                <ref bean="data"/>
            </list>
        </property>

    </bean>

    <bean id="data" class="beans.Data"></bean>
</beans>
package beans;

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

public class Test {

    private List<String> list1;
    private List<Integer> list2;
    private List<Data> list3;

    private Set<String> set1;
    private Set<Integer> set2;
    private Set<Data> set3;

    private Map<String, Objects> map1;


    public List<String> getList1() {
        return list1;
    }

    public void setList1(List<String> list1) {
        this.list1 = list1;
    }

    public List<Integer> getList2() {
        return list2;
    }

    public void setList2(List<Integer> list2) {
        this.list2 = list2;
    }

    public List<Data> getList3() {
        return list3;
    }

    public void setList3(List<Data> list3) {
        this.list3 = list3;
    }

    public Set<String> getSet1() {
        return set1;
    }

    public void setSet1(Set<String> set1) {
        this.set1 = set1;
    }

    public Set<Integer> getSet2() {
        return set2;
    }

    public void setSet2(Set<Integer> set2) {
        this.set2 = set2;
    }

    public Set<Data> getSet3() {
        return set3;
    }

    public void setSet3(Set<Data> set3) {
        this.set3 = set3;
    }
}

 

 

 

List<Integer> / List<Data> 주입

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");
        
        System.out.println("----------------------------------------------------------------");
        List<Integer> li2 = t1.getList2();
        for(int i:li2) {
            System.out.println(i);
        }

        System.out.println("----------------------------------------------------------------");


        List<Data> li3 = t1.getList3();
        for(Data d:li3) {
            System.out.println(d);
        }
    }
}
<?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="test1" class="beans.Test">
        <property name="list1">
            <list>
                <value>스프링1</value>
                <value>스프링2</value>
                <value>스프링3</value>
            </list>
        </property>

        <property name="list2">
            <list>
                <value type="int">10</value>
                <value type="int">20</value>
                <value type="int">30</value>
            </list>
        </property>

        <property name="list3">
            <list>
                <bean class="beans.Data"/>
                <ref bean="data"/>
            </list>
        </property>

    </bean>

    <bean id="data" class="beans.Data"></bean>
</beans>
package beans;

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

public class Test {

    private List<String> list1;
    private List<Integer> list2;
    private List<Data> list3;

    private Set<String> set1;
    private Set<Integer> set2;
    private Set<Data> set3;

    private Map<String, Objects> map1;


    public List<String> getList1() {
        return list1;
    }

    public void setList1(List<String> list1) {
        this.list1 = list1;
    }

    public List<Integer> getList2() {
        return list2;
    }

    public void setList2(List<Integer> list2) {
        this.list2 = list2;
    }

    public List<Data> getList3() {
        return list3;
    }

    public void setList3(List<Data> list3) {
        this.list3 = list3;
    }

    public Set<String> getSet1() {
        return set1;
    }

    public void setSet1(Set<String> set1) {
        this.set1 = set1;
    }

    public Set<Integer> getSet2() {
        return set2;
    }

    public void setSet2(Set<Integer> set2) {
        this.set2 = set2;
    }

    public Set<Data> getSet3() {
        return set3;
    }

    public void setSet3(Set<Data> set3) {
        this.set3 = set3;
    }
}

 

 

Map<String, object> 주입

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");

Map<String, Object> m1 = t1.getMap1();
    String s1 = (String)m1.get("k1");
    int s2 = (Integer)m1.get("k2");
    Data s3=(Data)m1.get("k3");

    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s3);
    }
}
<?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">
                        
                        
   <property name="map1">
        <map>
            <entry key="k1" value="스프링"/>
            <entry key="k2" value="10" value-type="java.lang.Integer"/>
            <entry key="k3">
                <bean class="beans.Data"/>
            </entry>
        </map>
    </property>

</bean>
package beans;

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

public class Test {

    private List<String> list1;
    private List<Integer> list2;
    private List<Data> list3;

    private Set<String> set1;
    private Set<Integer> set2;
    private Set<Data> set3;

    private Map<String, Object> map1;


    public List<String> getList1() {
        return list1;
    }

    public void setList1(List<String> list1) {
        this.list1 = list1;
    }

    public List<Integer> getList2() {
        return list2;
    }

    public void setList2(List<Integer> list2) {
        this.list2 = list2;
    }

    public List<Data> getList3() {
        return list3;
    }

    public void setList3(List<Data> list3) {
        this.list3 = list3;
    }

    public Set<String> getSet1() {
        return set1;
    }

    public void setSet1(Set<String> set1) {
        this.set1 = set1;
    }

    public Set<Integer> getSet2() {
        return set2;
    }

    public void setSet2(Set<Integer> set2) {
        this.set2 = set2;
    }

    public Set<Data> getSet3() {
        return set3;
    }

    public void setSet3(Set<Data> set3) {
        this.set3 = set3;
    }

    public Map<String, Object> getMap1() {
        return map1;
    }

    public void setMap1(Map<String, Object> map1) {
        this.map1 = map1;
    }
}
728x90
728x90

 

스프링이란

  • 오늘날 가장 많이 사용하는 자바 기반 응용 프로그램 개발 프레임워크 (전자정부표준프레임워크)

 

스프링을 사용하는 이유?

  • 스프링 컨테이너는 경량컨테이너로서 자바 객체를 스프링 빈으로 등록하면 스프링빈으로 찾아서 사용하고 관리한다.
    (DI, AOP, IoC, myBatis라이브러리 지원)
  • 스프링 빈 의존관계 설정하여 각 계층이나 서비스들 간에 의존성이 존재할 경우 프레임워크가 서로 연결시켜준다.
  • 객체 지향 언어의 특징을 살린 프레임 워크이다.
    (cf, 추상화, 상속, 다형성, 캡슐화 etc..)
  • 자바 플랫폼을 위한 오픈소스 어플리케이션 프레임워크이다.
  • 소프트웨어 개발의 뼈대 역할을 한다.
  • 자바 코드를 줄일 수 있다. (반복되는 작업을 줄임)
  • 프로젝트 관리가 용이하다. (개발자들과 동시에 프로젝트 하기가 용이하다)

 

특징

IoC(Inversion of Control, 제어의 역전)

  • 객체 생성과 관리를 프레임워크나 컨테이너가 담당하는 디자인 패턴
    1. 개발자가 직접 객체를 생성하고 연결하면 결합도가 높아져 유지보수가 어려워짐
    2. 대신 외부 컨테이너가 객체 생명주기를 관리하고, 객체들은 본인의 로직만 실행함
  • 스프링에서는 ApplicationContext가 IoC 컨테이너 역할을 한다
    1. 프로그램 실행 시 ApplicationContext가 설정 파일(XML, 어노테이션 등)을 참고하여 객체를 생성
    2. getBean() 메소드로 컨테이너에서 객체를 가져올 수 있다

 

  • 객체 간 결합도를 낮추고 유연한 애플리케이션 개발을 돕는다.

 

IoC컨테이너 종류 

1.BeanFactory와 ApplicationContext

  • BeanFactory: 스프링 컨테이너의 최상위 인터페이스로, 빈(Bean) 객체의 생성, 초기화, 조회 등을 관리합니다.
  • ApplicationContext: BeanFactory를 상속받은 서브인터페이스로, 빈 관리 기능 외에도 트랜잭션, 메시지 등 부가 기능을 제공합니다.

스프링 컨테이너 생성 방법

  • XML 파일 설정
  • 어노테이션 기반 설정

2. getBean() 메소드

  • 스프링 컨테이너에서 빈 객체를 가져오는 메소드
  • 동작 방식은 빈의 스코프(scope)에 따라 다르다

A) 싱글톤(singleton) 스코프

  • 기본 스코프로, 컨테이너 시작 시 한 번만 객체를 생성
  • getBean()을 호출하면 이미 생성된 객체의 참조를 반환
default는 lazy-init false 이므로, 자동적으로 객체를 생성함 동시에 Scope도 Singleton으로 설정

 

Mainclass.java

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");

        Test t1=ctx.getBean("test_default", Test.class);
        System.out.println(t1);
        
 -----------------------------------------------------------------------
 beans.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"
       default-init-method="defalut_init" default-destroy-method="defalut_destroy"> <!-- <- 2.여기에 추가해도 됨!-->

<!--     xml로딩할 때 자동으로 객체 생성!-->
<!--     id에 이름설정하면 getBean 메소드를 통해 객체의 주소값을 가져올 수 있다.-->
<!--     생성된 객체는 더이상 생성되지 않는다. / 싱글톤!-->
        <bean class="beans.Test" id="test_default"/>
        
        
-----------------------------------------------------------------------
Test.java


package beans;

public class Test {
 public Test() {
        System.out.println("Test 매개변수 없는 생성자 호출됨");
    }
}
<!--     xml로딩할 때 자동으로 객체 생성!   -->
<!--     id에 이름설정하면 getBean 메소드를 통해 객체의 주소값을 가져올 수 있다.   -->
<!--     생성된 객체는 더이상 생성되지 않는다. / 싱글톤!   -->

<bean class="beans.Test" id="test_default"/>

B) 싱글톤 + lazy-init="true"

  • 컨테이너 시작 시가 아닌 getBean() 호출 시 객체를 생성

MainClass.java

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");        
        Test t2_1=ctx.getBean("test_lazy_init", Test.class);
        Test t2_2=ctx.getBean("test_lazy_init", Test.class);
        
    }
}

-------------------------------------------------------------------------
beans.xml



<!--        lazy-init : true - xml로딩할 때 객체가 생성되지 않는다 // 최초생성만 막음-->
<!--        getBean메소드를 호출할 때 객체가 생성되며 싱글톤이다-->
        <bean class="beans.Test" id="test_lazy_init" lazy-init="true"/>
        
        
---------------------------------------------------------------------------
Test.java

package beans;


public class Test {

 public Test() {
        System.out.println("Test 매개변수 없는 생성자 호출됨");
     }
}

C) 프로토타입(prototype) 스코프

  • getBean()을 호출할 때마다 새로운 객체를 생성하여 반환

MainClass.java

package main;

import beans.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx =
                new ClassPathXmlApplicationContext("config/beans.xml");

        Test t2_3=ctx.getBean("test_proto1", Test.class);
        Test t2_4=ctx.getBean("test_proto1", Test.class);
        Test t2_5=ctx.getBean("test_proto1", Test.class);

  t2_3.setNn(6437);
        System.out.println(t2_3.getNn());
        System.out.println(t2_4.getNn());
        System.out.println(t2_5.getNn());
        
                System.out.println(t2_3);
        System.out.println(t2_4);
        System.out.println(t2_5);
        }
   }
        
        
 -----------------------------------------------------------------------------
 beans.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">
 
 
<!--        scope="prototype" - xml로딩할 때 객체가 생성되지 않음 , 최초생성과 싱글톤 패턴도 막음    -->
<!--        getBean메소드를 호출할 때마다 객체가 생성됨                     -->
        <bean class="beans.Test" id="test_proto1" scope="prototype"/>
        <bean class="beans.Test" id="test_proto2" scope="prototype"/>
        
        

----------------------------------------------------------------------------------------
Test.java



package beans;

public class Test {
    private int nn;
    public int getNn() {
        return nn;
    }

 public Test() {
        System.out.println("Test 매개변수 없는 생성자 호출됨");
        nn = 1;
    }
 }

3. 컨테이너 종료 시

  • 컨테이너가 관리하는 모든 싱글톤 빈 객체가 소멸

// main/MainClass.java


import beans.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainClass {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("config/beans.xml");

        Test t4 = ctx.getBean("test4", Test.class);
        System.out.println(t4);

        ctx.close();
    }
}


-----------------------------------------------------------------
beans.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="test4" class="beans.Test" lazy-init="true" init-method="Test4_init" destroy-method="Test4_destroy"/>
</benas>


--------------------------------------------------------------------
Test.java



package beans;

public class Test {
    public Test() {
        System.out.println("Test"); 
    }

    public void Test4_init() {
        System.out.println("Test4_init");
    }

    public void Test4_destroy() {
        System.out.println("Test4_destroy");
    }
}

 

DI(Dependency Injection, 의존성 주입)

  • 프레임워크가 의존성 객체를 자동으로 주입해주는 기술
  • 모듈 간 결합도를 낮춰준다.

AOP(Aspect Oriented Programming, 관점 지향 프로그래밍)

  • 핵심 로직 외 부가적인 관심사(로깅, 트랜잭션 등)를 별도 모듈로 분리
  • 중복 코드 제거, 가독성 및 유지보수성 향상

PSA(Portable Service Abstraction, 이식 가능한 서비스 추상화)

  • 다양한 기술 스택에서 공통 API를 제공하여 개발 간소화
  • 서로 다른 환경에서도 일관된 개발 가능

POJO(Plain Old Java Object, 순수 자바 객체)

  • 특정 인터페이스나 프레임워크에 종속되지 않는 간단한 자바 객체
  • 객체 지향 원칙을 따르는 기본적인 자바 객체

 

다형성(Polymorphism)이란

자바에서 객체는 상위 클래스 타입의 참조 변수나 구현한 인터페이스 타입의 변수에 담을 수 있다

 

 

 

부모클래스 참조변수 = new 자식클래스();
인터페이스 참조변수 = new 구현클래스();

 

이렇게 하면 참조 변수를 통해 메소드를 호출할 때, 자식 클래스에서 오버라이딩한 메소드가 실제로 호출된

다형성을 사용하면 참조 변수 선언 부분은 수정할 필요가 없지만, 실제 객체를 생성하는 부분의 코드는 변경되어야 한다

부모클래스 참조변수;
// 기존 코드
참조변수 = new 자식클래스A();
// 새로운 코드 
참조변수 = new 자식클래스B();

 

다형성이 필요한 이유

  • 다형성이 없으면 비슷한 기능의 코드들이 중복된다.
  • 하나의 타입에 여러 객체를 대입해서 다양한 기능을 이용할 수 있도록 해준다.
  • 객체를 실행 시점에 유연한 변경이 가능하다.
  • 같은 타입이지만 실행결과가 다양한 객체를 이용할 수 있다.

 

 


DI (의존성 주입) : Dependency Injection

  • DI는 스프링에만 국한된 기술이 아니라 객체지향 프로그래밍에서 자주 사용되는 설계 원칙 중 하나
  • 의존 관계에 있는 객체를 외부에서 주입해주는 방식
  • DI를 사용하면 필요한 객체를 유연하게 주입하고 제거할 수 있다
  • 결국 DI는 클래스 간 강한 의존성을 낮추고, 객체를 쉽게 주입하고 교체할 수 있게 해주는 기술이다
  • 객체지향 설계 원리에 부합하고, 결합도를 낮추어 코드의 유연성과 재사용성을 높여줌
728x90

+ Recent posts