스프링 상세 설명(슈퍼종합)

1. 봄

Spring은 SSM(Spring, SpringMVC, Mybatis) 프레임워크 중 하나이다. 소위 프레임워크는 재사용 가능한 코드를 많이 추출하고 매우 다재다능한 디자인입니다.

1. 개요

(1) Spring은 오픈 소스 프레임워크입니다.

(2) Spring은 엔터프라이즈급 개발을 단순화하기 위해 탄생했으며 Spring을 사용하여 JavaBean은 코드를 매우 우아하고 간결하게 만들 수 있습니다.

(3) Spring은 IoC(DI) 및 AOP 컨테이너 프레임워크입니다.

(4) Spring의 뛰어난 기능

비간섭적: Spring을 기반으로 개발된 애플리케이션의 개체는 Spring API에 의존하지 않을 수 있습니다.

종속성 주입: 제어 역전(IoC)의 가장 고전적인 구현인 DI(의존성 주입);

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

컨테이너: Spring은 애플리케이션 개체의 수명 주기를 포함하고 관리하기 때문에 컨테이너입니다.

(5) 구성 요소화: Spring은 간단한 구성 요소 구성을 복잡한 애플리케이션으로 결합하는 것을 실현합니다.Spring에서는 XML 및 Java 주석을 사용하여 이러한 개체를 결합할 수 있습니다.

(6) 원스톱 상점: IoC 및 AOP를 기반으로 다양한 엔터프라이즈 애플리케이션의 오픈 소스 프레임워크 및 우수한 타사 클래스 라이브러리를 통합할 수 있습니다(사실 Spring 자체도 프레젠테이션 계층을 위한 Spring MVC 및 Spring JDBC를 제공합니다. 지속성 계층);

(7) 스프링 모듈

[외부 링크 사진 전송 실패, 소스 사이트에 거머리 방지 메커니즘이 있을 수 있으므로 사진을 저장하고 직접 업로드하는 것이 좋습니다. (img-TE3J19zB-1682512561625) 그림.png)]

설명하다:

각 녹색 상자는 기능 모듈을 나타내고 녹색 상자의 검은색 상자는 이 기능 모듈을 사용하는 데 필요한 jar 패키지를 나타냅니다.

2. 스프링을 사용하는 이유

(1) 편리한 디커플링 및 간소화된 개발

Spring은 모든 객체의 생성과 종속성 유지 관리를 Spring 관리에 넘길 수 있는 큰 공장입니다.

(2) 다양한 우수한 프레임워크의 편리한 통합

Spring은 다양한 우수한 오픈 소스 프레임워크를 배제하지 않고 다양한 우수한 프레임워크(예: Struts2, Hibernate, MyBatis 등)에 대한 직접적인 지원을 제공합니다.

(3) Java EE API 사용의 어려움 감소

Spring은 Java EE 개발에서 사용하기 매우 어려운 일부 API(JDBC, JavaMail, 원격 호출 등)에 대한 패키징을 제공하여 이러한 API 적용의 어려움을 크게 줄입니다.

(4) 편리한 프로그램 테스트

Spring은 주석을 통해 Spring 프로그램을 쉽게 테스트할 수 있게 해주는 JUnit4를 지원합니다.

(5) AOP 프로그래밍 지원

Spring은 프로그램의 권한 가로채기, 동작 모니터링 등의 기능을 쉽게 구현할 수 있는 aspect-oriented 프로그래밍을 제공한다.

(6) 선언적 트랜잭션 지원

트랜잭션 관리는 수동 프로그래밍 없이 구성을 통해서만 완료할 수 있습니다.

Java 프로그래머로서 Spring에 대한 이해와 숙달의 정도는 기본적으로 프로그래밍 능력의 구현이다.

3. 봄 첫 경험

1. 메이븐 프로젝트 만들기

   Build by archetype을 확인하고 maven-archetype-quickstart를 선택합니다.

2. 의존성 가져오기

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

3. 인터페이스 및 구현 클래스 만들기

public interface UserDao {
    
    
    void queryAll();
}

public class UserDaoImpl implements UserDao {
    
    
    public UserDaoImpl(){
    
    
        System.out.println("UserDaoImpl对象创建了");
    }

    @Override
    public void queryAll() {
    
    
        System.out.println("查询了所有用户信息");
    }
}

4. 스프링 구성 파일 생성

프로젝트의 리소스 디렉토리에 spring-config.xml을 생성합니다.아이디어에서는 리소스 디렉토리에서 직접 New->XML Configuration File->Spring Config 메뉴를 사용하여 생성할 수 있습니다.

<?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指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
        class指定创建对象的类的全类名
    -->
    <bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl"/>
</beans>

5. 시험

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        userDaoImpl.selectAll();
    }
}

둘, IoC

1. 개념

IoC(Inversion of Control)는 제어 반전입니다. Spring을 사용하기 전에는 객체를 얻기 위해 거의 항상 new 메서드를 사용했지만 Spring을 사용하고 나면 더 이상 new 메서드를 사용하여 객체를 생성하지 않고 Spring이 객체를 생성하도록 합니다.

2. IoC 컨테이너

• IoC 컨테이너는 Spring의 핵심이며 Spring 컨테이너라고도 할 수 있습니다. Spring은 IoC 컨테이너를 사용하여 개체의 인스턴스화 및 초기화뿐만 아니라 생성에서 소멸까지 개체의 전체 수명 주기를 관리합니다.

• Spring에서 사용되는 객체는 모두 IoC 컨테이너에 의해 관리되며 수동으로 new 연산자를 사용하여 객체를 생성할 필요가 없습니다. IoC 컨테이너에서 관리하는 객체를 Spring Bean이라고 하며 Spring Bean은 Java 객체로 new 연산자로 생성한 객체와 다르지 않습니다.

• Spring은 XML 또는 Java 주석의 정보를 읽어 인스턴스화해야 하는 객체를 얻습니다.

• Spring은 두 가지 다른 유형의 IoC 컨테이너인 BeanFactory 및 ApplicationContext 컨테이너를 제공합니다.

2.1 빈팩토리

Spring의 최하위 인터페이스인 BeanFactory 컨테이너는 가장 간단한 컨테이너 기능을 제공하며 객체를 인스턴스화하고 객체를 가져오는 기능만 제공합니다.

BeanFactory ac = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

2.2 애플리케이션 컨텍스트

BeanFactory 인터페이스를 상속받은 Application Context는 Spring의 고급 컨테이너로서 보다 유용한 기능을 제공하며, ApplicationContext는 BeanFactory를 기반으로 AOP, 국제화, 트랜잭션 지원 등과 같은 많은 엔터프라이즈급 기능을 추가하고 ApplicationContext는 인스턴스화합니다. 시작할 때 모든 콩. 또한 Bean이 Bean 인스턴스화를 지연하도록 lazy-init=true를 구성할 수 있습니다. ApplicationContext 인터페이스에는 일반적으로 사용되는 두 가지 구현 클래스가 있습니다.

2.2.1 ClassPathXmlApplicationContext

이 클래스는 클래스 경로 ClassPath에서 지정된 XML 구성 파일을 찾고 다음과 같이 ApplicationContext의 인스턴스화를 완료합니다.

ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");

2.2.2 FileSystemXmlApplicationContext

이 클래스는 지정된 파일 시스템 경로에서 지정된 XML 구성 파일을 찾고 다음과 같이 ApplicationContext의 인스턴스화를 완료합니다.

ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\workspace\\spring_demo\\src\\main\\resources\\spring-config.xml");

3. 스프링 빈 생성

Spring IoC 컨테이너에서 관리하는 객체를 Bean이라고 하며 Spring 구성 파일의 정보를 기반으로 Bean이 생성됩니다. 일반적으로 Spring 구성 파일에서 Bean을 관리합니다.

<beans></beans>Spring의 구성 파일에서는 각 개체를 관리하는 데 사용되는 레이블 집합으로 래핑됩니다 <bean></bean>.

1. 파라미터 구성 생성 없음

이런 방식으로 빈을 생성하려면 매개변수가 없는 구조여야 하며, 그렇지 않으면 Spring 구성 파일에 오류가 보고됩니다.

<?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指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
        class指定创建对象的类的全类名
    -->
    <bean id="userDaoImpl" class="com.hqyj.dao.impl.UserDaoImpl" lazy-init="true"/>
</beans>

1.1 빈 태그 속성

속성 이름	설명하다
ID	Bean의 고유 식별자와 Spring 컨테이너에 의한 Bean의 구성 및 관리는 이 속성을 통해 완료됩니다. id의 값은 문자로 시작해야 하며 문자, 숫자, 밑줄 등의 기호를 사용할 수 있습니다.
이름	name 속성에서 Bean에 대해 여러 이름을 지정할 수 있으며 각 이름은 쉼표 또는 세미콜론으로 구분됩니다. Spring 컨테이너는 name 속성을 통해 컨테이너에 Bean을 설정하고 관리할 수 있다.
수업	이 속성은 완전한 클래스 이름, 즉 클래스의 완전한 이름이어야 하는 Bean의 특정 구현 클래스를 지정합니다.
범위	Bean 인스턴스의 범위를 설정하는데 사용되며 속성 값은 싱글톤(singleton), 프로토타입(prototype), 요청, 세션, 글로벌 세션이 될 수 있다. 기본값은 싱글톤입니다.
생성자 인수	이 요소의 구성 매개변수를 전달하여 인스턴스화할 수 있는 요소의 하위 요소입니다. 이 요소의 index 속성은 구성 매개변수의 일련 번호(0부터 시작)를 지정하고 type 속성은 구성 매개변수의 유형을 지정합니다.
재산	요소의 하위 요소는 Bean 인스턴스의 setter 메서드를 호출하여 속성 값을 할당하여 종속성 주입을 완료하는 데 사용됩니다. 이 요소의 name 속성은 Bean 인스턴스에서 해당 속성 이름을 지정하는 데 사용됩니다.
심판	및 와 같은 요소의 하위 요소, 이 요소의 bean 속성은 Bean 인스턴스에 대한 참조를 지정하는 데 사용됩니다.
값	및 등의 요소의 하위 요소는 상수 값을 직접 지정하는 데 사용됩니다.
목록	목록 또는 배열 유형을 캡슐화하기 위한 종속성 주입
세트	집합 유형 캡슐화를 위한 종속성 주입
지도	지도 유형 캡슐화를 위한 의존성 주입
기입
초기화 방법	이 메소드는 Servlet의 init() 메소드와 유사하게 컨테이너가 빈을 로드할 때 호출됩니다.
파괴 방법	이 메소드는 Servlet의 destroy() 메소드와 유사하게 컨테이너가 Bean을 삭제할 때 호출됩니다. 이 방법은 scope=singleton인 경우에만 유효합니다.
게으른 초기화	지연 로딩, 값이 true이면 컨테이너는 첫 번째 요청에서 Bean 인스턴스를 생성하고, 값이 false이면 컨테이너가 시작될 때 Bean 인스턴스를 생성합니다. 이 방법은 scope=singleton인 경우에만 유효합니다.

2. 동적 공장 모드 생성

1. UserDaoFactory 팩토리 생성

public class UserDaoFactory {
    
    
    public UserDao getUserDao(){
    
    
        return new UserDaoImpl();
    }
}

2. 스프링 구성 파일

<!-- 通过普通工厂创建bean-->
<!-- 第一步，将工厂类本身加入ioc容器-->
<bean id="userDaoFactory" class="com.hqyj.cl.dao.impl.UserDaoFactory"/>
<!-- 第二步，配置bean 
    factory-bean指定由ioc容器创建的工厂bean
    factory-method指定的该工程的工厂方法 -->
<bean id="userDaoImpl" factory-bean="userDaoFactory" factory-method="getUserDao"/>

3. 정적 공장 모드 생성

1. UserDaoFactory 팩토리 생성

public class UserDaoFactory {
    
    
    public static UserDao getUserDao02(){
    
    
        return new UserDaoImpl();
    }
}	

2. 스프링 구성 파일

<!-- 第二步，配置bean 
	id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
	class指定创建对象的类的全类名
    factory-method指定的该工程的静态工厂方法 -->
<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoFactory" factory-method="getUserDao02"/>

넷째, Spring Bean의 범위

범위	설명
하나씩 일어나는 것	(기본값) Spring IoC 컨테이너당 단일 빈 정의 범위를 단일 개체 인스턴스로 지정합니다.
원기	단일 bean 정의를 여러 객체 인스턴스로 범위 지정합니다.
요구	단일 HTTP 요청의 수명에 단일 빈 정의 범위를 지정합니다. 즉, 각 HTTP 요청에는 단일 bean 정의 뒤에 생성된 bean 인스턴스가 있습니다. 네트워크 인식 Spring ApplicationContext에서만 사용할 수 있습니다.
세션	단일 빈 정의 범위를 HTTP 세션의 수명으로 지정합니다. 네트워크 인식 Spring ApplicationContext의 컨텍스트에서만 유효합니다.
애플리케이션	8 단일 빈 정의의 범위를 ServletContext의 수명 주기로 제한합니다. 네트워크 인식 Spring ApplicationContext의 컨텍스트에서만 유효합니다.
웹소켓	WebSocket의 수명에 대한 단일 빈 정의의 범위를 지정합니다. 네트워크 인식 Spring ApplicationContext의 컨텍스트에서만 유효합니다.

4.1 샘플 코드

4.1.1 싱글톤

1. 스프링 구성 파일

<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="singleton"/>

2. 테스트 클래스

public class UserDaoTest {
    
    
    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        UserDao userDaoImpl1 = ac.getBean("userDaoImpl", UserDao.class);
        System.out.println(userDaoImpl==userDaoImpl1);
    }
}

결과 출력은 true이며, UserDaoImpl 클래스에 작성된 인수 없는 구성 출력 문은 한 번만 출력되므로 개체가 한 번만 생성되었음을 나타냅니다.

4.1.2 프로토타입

1. 스프링 구성 파일

<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="prototype"/>

2. 테스트 클래스

public class UserDaoTest {
    
    
    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        UserDao userDaoImpl1 = ac.getBean("userDaoImpl", UserDao.class);
        System.out.println(userDaoImpl==userDaoImpl1);
    }
}

결과의 출력은 거짓이며, UserDaoImpl 클래스에 작성된 인수 없는 구성 출력문이 두 번 출력되어 개체가 두 번 생성되었음을 나타냅니다.

다섯째, Spring Bean의 라이프 사이클

• 전통적인 Java 응용 프로그램에서 빈의 수명 주기는 매우 간단합니다.빈은 키워드 new를 사용하여 인스턴스화되고 빈이 필요하지 않을 때 Java가 자동으로 가비지 수집을 수행합니다.

• Spring에서 Bean의 생명 주기는 더 복잡하며 Bean 정의 -> Bean 초기화 -> Bean 사용 -> Bean 파괴로 표현될 수 있습니다.

• Spring은 Bean의 범위에 따라 관리 방법을 선택합니다. 싱글톤 범위를 가진 빈의 경우 Spring은 빈이 언제 생성되고 언제 초기화되고 언제 파괴되는지 정확히 알 수 있으며 프로토타입 범위가 있는 빈의 경우 Spring은 컨테이너가 빈의 인스턴스를 생성할 때 생성만 담당합니다. 즉, Bean 인스턴스는 클라이언트 코드 관리로 넘겨지고 Spring 컨테이너는 더 이상 수명 주기를 추적하지 않습니다.

• XML로 Bean을 구성할 때 Bean 태그의 init-method 속성과 destroy-method 속성을 각각 사용하여 Bean의 초기화 콜백 메소드와 파괴 콜백 메소드를 정의할 수 있습니다.

5.1 샘플 코드

1. userDao

public class UserDaoImpl implements UserDao {
    
    

    public UserDaoImpl(){
    
    
        System.out.println("UserDaoImpl对象创建了");
    }

    @Override
    public void selectAll() {
    
    
        System.out.println("执行了selectAll方法");
    }

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

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

2. 스프링 구성 파일

<bean id="userDaoImpl1" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="prototype"
      init-method="init" destroy-method="destroy"/>

3. 테스트 클래스

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        ac.registerShutdownHook();
    }
}

웹 애플리케이션이 아닌 싱글톤 모드에서 Spring IoC 컨테이너를 수동으로 로드하고 AbstractApplicationContext 인터페이스를 사용하여 ApplicationContext 인터페이스를 상속하며 registerShutdownHook/close 메서드는 컨테이너를 수동으로 닫고 destroy-method가 해당 메서드를 실행하도록 할 수 있습니다.

六、화

DI(Dependency Injection), 즉 "의존성 주입": 구성 요소 간의 종속성은 런타임 시 컨테이너에 의해 결정됩니다. 즉, 컨테이너가 구성 요소에 특정 종속성을 동적으로 주입합니다. 종속성 주입의 목적은 소프트웨어 시스템에 더 많은 기능을 제공하는 것이 아니라 구성 요소 재사용 빈도를 높이고 시스템을 위한 유연하고 확장 가능한 플랫폼을 구축하는 것입니다. 종속성 주입 메커니즘을 통해 간단한 구성을 통해 코드 없이 대상에 필요한 리소스를 지정하고 특정 리소스의 출처와 구현자를 신경쓰지 않고 자체 비즈니스 로직을 완성하면 됩니다.

종속성 주입에는 세터 주입과 생성자 주입이라는 두 가지 주요 구현이 있습니다.

6.1 세터 주입

종속 인스턴스를 주입하기 위해 setter 메서드를 사용하는 IoC 컨테이너를 말합니다. 인수 없는 생성자 또는 인수 없는 정적 팩토리 메서드를 호출하여 빈을 인스턴스화한 후 빈의 세터 메서드를 호출하여 세터 기반 종속성 주입을 실현할 수 있습니다.

Spring에서 Bean을 인스턴스화하는 과정에서 기본 생성자를 먼저 호출하여 Bean 객체를 인스턴스화한 다음 Java의 리플렉션 메커니즘을 통해 setXxx() 메서드를 호출하여 속성을 주입합니다. 따라서 setter 주입을 위해서는 Bean의 해당 클래스가 다음 두 가지 요구 사항을 충족해야 합니다.

• 인수가 없는 기본 생성자를 제공해야 합니다.

• 주입해야 하는 속성에 해당하는 setter 메서드를 제공해야 합니다.

  <bean>setter 주입을 사용할 때 Spring 구성 파일에서 요소의 자식 요소를 사용하여 <property>각 속성에 대한 값을 주입 해야 합니다.

, 구성 파일에서 주로 <constructor-arg>태그를 사용하여 구성 방법의 매개 변수를 정의하고 해당 값 속성(또는 하위 요소)을 사용하여 매개 변수의 값을 설정합니다.

6.1.1 예제 코드

태그에는<property> 이름, 참조 및 값과 같은 속성이 포함됩니다. name은 매개변수 이름을 지정하는 데 사용되며 value 속성은 기본 데이터 유형 및 문자열 유형의 값을 주입하는 데 사용되며 ref 속성은 정의된 Bean을 주입하는 데 사용됩니다.

1. Java 클래스 사용자 만들기

public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User() {
    
    
    }

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

2. 스프링 구성 파일

<?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="user" class="com.hqyj.cl.pojo.User">
        <property name="id" value="1"/>
        <property name="username" value="chenlei"/>
        <property name="password" value="111"/>
    </bean>
</beans>

3. 테스트 클래스

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = ac.getBean("user", User.class);
        System.out.println(user);
    }
}

6.2 생성자

종속 인스턴스를 주입하기 위해 생성자를 사용하는 IoC 컨테이너를 말합니다. 종속성 주입은 각 매개 변수가 종속성을 나타내는 매개 변수가 있는 생성자를 호출하여 구현할 수 있습니다.

생성자를 사용하여 종속 인스턴스를 주입하는 방법에는 첨자 주입, 속성 주입 및 매개 변수 이름 주입의 세 가지 방법이 있습니다.

6.2.1 사용자 클래스 정의

public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User() {
    
    
    }

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

6.2.2 첨자를 통한 주입

생성자의 파라미터가 여러 개인 경우 index 속성을 이용하여 파라미터의 위치를 ​​지정할 수 있으며, index 속성의 값은 0부터 시작한다.

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg index="0" value="1"/>
    <constructor-arg index="1" value="chenchen"/>
    <constructor-arg index="2" value="23"/>
</bean>

6.2.3 속성을 통한 주입

name 속성은 생성 메소드에서 매개변수 이름을 지정하여 주입하는 것으로 가장 많이 사용되며 숙지해야 합니다.

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg type="int" value="2"/>
    <constructor-arg type="java.lang.String" value="chenchen"/>
    <constructor-arg type="java.lang.String" value="123"/>
</bean>

6.2.4 매개변수 이름으로 주입

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg name="id" value="3"/>
    <constructor-arg name="username" value="chenchen"/>
    <constructor-arg name="password" value="123"/>
</bean>

6.3 세터 주입과 생성자 주입 비교

생성자 주입:

장점: 생성자의 모든 매개변수는 bean이 생성되기 전에 생성 시 지정되어야 합니다. 이렇게 하면 개체가 생성된 후 멤버 변수에 값이 있어야 합니다.

단점: 모든 매개변수를 지정해야 하며 그렇지 않으면 개체를 생성할 수 없습니다. 이 방법을 사용하여 개체 생성 프로세스를 변경합니다.

세터 주입:

장점: 객체를 생성할 때 매개변수를 지정할 필요가 없고 객체 생성이 제한되지 않습니다.
단점: 개체에 주입할 수 있는 여러 속성이 있는 경우 모든 속성 또는 일부 속성이 주입된다는 보장이 없습니다.
세터 주입 방법은 더 유연하고 사용하기 편리합니다.

6.4 세터 주입 객체

여러 가지 경우가 있습니다: 공통 유형, 목록 콜렉션, 맵 콜렉션, 문자열 유형, 객체 참조 유형, 세트 콜렉션, 배열, 속성, 널 유형

1. 학생 수업

public class Student {
    
    
    private String name;
    private Counselor counselor;
    private String[] courses;
    private List<String> books;
    private Map<String, String> idCard;
    private Set<String> studentNumber;
    private String wifeName;
    private Properties properties;

    public Student() {
    
    
    }

    public Student(String name, Counselor counselor, String[] courses, List<String> books, Map<String, String> idCard, Set<String> studentNumber, String wifeName, Properties properties) {
    
    
        this.name = name;
        this.counselor = counselor;
        this.courses = courses;
        this.books = books;
        this.idCard = idCard;
        this.studentNumber = studentNumber;
        this.wifeName = wifeName;
        this.properties = properties;
    }

    public String getName() {
    
    
        return name;
    }

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

    public Counselor getCounselor() {
    
    
        return counselor;
    }

    public void setCounselor(Counselor counselor) {
    
    
        this.counselor = counselor;
    }

    public String[] getCourses() {
    
    
        return courses;
    }

    public void setCourses(String[] courses) {
    
    
        this.courses = courses;
    }

    public List<String> getBooks() {
    
    
        return books;
    }

    public void setBooks(List<String> books) {
    
    
        this.books = books;
    }

    public Map<String, String> getIdCard() {
    
    
        return idCard;
    }

    public void setIdCard(Map<String, String> idCard) {
    
    
        this.idCard = idCard;
    }

    public Set<String> getStudentNumber() {
    
    
        return studentNumber;
    }

    public void setStudentNumber(Set<String> studentNumber) {
    
    
        this.studentNumber = studentNumber;
    }

    public String getWifeName() {
    
    
        return wifeName;
    }

    public void setWifeName(String wifeName) {
    
    
        this.wifeName = wifeName;
    }

    public Properties getProperties() {
    
    
        return properties;
    }

    public void setProperties(Properties properties) {
    
    
        this.properties = properties;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "name='" + name + '\'' +
                ", counselor=" + counselor +
                ", courses=" + Arrays.toString(courses) +
                ", books=" + books +
                ", idCard=" + idCard +
                ", studentNumber=" + studentNumber +
                ", wifeName='" + wifeName + '\'' +
                ", properties=" + properties +
                '}';
    }
}

2. 카운슬러 클래스

public class Counselor {
    
    
    private String name;

    public Counselor() {
    
    
    }

    public Counselor(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

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

    @Override
    public String toString() {
    
    
        return "Counselor{" +
                "name='" + name + '\'' +
                '}';
    }
}

3. 스프링 구성 파일

<!--引用注入-->
<bean id="counselor" class="com.hqyj.cl.pojo.Counselor">
    <property name="name" value="张老师"/>
</bean>
<!--注入学生类-->
<bean id="student" class="com.hqyj.cl.pojo.Student">
    <!--普通值注入-->
    <property name="name" value="chenchen"/>
    <!--引用注入-->
    <property name="counselor" ref="counselor"/>
    <!--数组注入-->
    <property name="courses">
        <array>
            <value>计算机组成原理</value>
            <value>计算机网络</value>
            <value>数据结构</value>
        </array>
    </property>
    <!--List集合注入-->
    <property name="books">
        <list>
            <value>Java入门到放弃</value>
            <value>Python大数据挖掘与分析</value>
        </list>
    </property>
    <!--Map集合注入-->
    <property name="idCard">
        <map>
            <entry key="idCard" value="29121821212"/>
            <entry key="phone" value="123121212121"/>
        </map>
    </property>
    <!--Set集合注入-->
    <property name="studentNumber">
        <set>
            <value>20200301123</value>
        </set>
    </property>
    <!--null注入-->
    <property name="wifeName">
        <null/>
    </property>
    <!--Properties注入-->
    <property name="properties">
        <props>
            <prop key="username">chenchen</prop>
            <prop key="password">112112</prop>
        </props>
    </property>
</bean>

4. 테스트 클래스

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Student student = ac.getBean("student", Student.class);
        System.out.println(student);
    }
}

7. 주석 기반 구성

Spring에서는 XML 구성 파일을 사용하여 Bean 어셈블리를 구현할 수 있지만 애플리케이션의 Bean 수가 많으면 XML 구성 파일이 너무 커져 유지 관리 및 업그레이드에 특정 어려움이 발생합니다.

Java는 JDK 5.0부터 Annotation 기능을 제공하고 있으며 Spring 2.5에서도 Annotation 기술에 대한 포괄적인 지원을 제공하고 있으므로 Annotation을 사용하여 종속성 주입을 구성할 수 있습니다.

<context:annotation-config/>Spring은 기본적으로 Bean을 어셈블하기 위해 주석을 사용하지 않으므로 주석 지원을 활성화하려면 구성 파일에 태그를 추가해야 합니다 .

:<context:annotation-config/> 이미 등록된 빈에서만 동작합니다. Spring Container에 등록되지 않은 Bean에 대해서는 어떠한 연산도 수행하지 않는다.

:<context:component-scan/> > 기능 외에도 , 등 의 애노테이션이 있는 객체를 스프링 컨테이너에 <context:annotation-config/자동으로 등록하는 기능도 있습니다 @component.@service@Repository

구성 패키지 스캐닝 주석:

<context:component-scan base-package=“com.hqyj”/>

1. Bean 관련 주석 생성

1.1 @컴포넌트

이 주석은 Spring에서 Bean을 설명하는 데 사용할 수 있지만 컴포넌트(Bean)만을 나타내는 일반화된 개념이며 모든 수준에서 사용할 수 있습니다. 사용할 때 해당 클래스에 주석을 표시하기만 하면 됩니다.

1.2 @저장소

Spring에서 Data Access Layer(DAO Layer)의 클래스를 Bean으로 식별하기 위해 사용하며 그 기능은 @Component와 동일하다.

1.3 @서비스

주로 비즈니스 레이어(Service 레이어)에서 동작하며 Spring에서 비즈니스 레이어의 클래스를 빈으로 식별하는데 사용되며 그 기능은 @Component와 동일하다.

1.4 @컨트롤러

보통 Control Layer(예: Struts2의 Action, SpringMVC의 Controller)에서 동작하며 Spring에서 Control Layer의 클래스를 Bean으로 식별하기 위해 사용되며 그 기능은 @Component와 동일하다.

2. Bean 생명주기 관련 주석

2.1 @범위

클래스 이름에 대한 주석은 Bean의 범위를 지정하는 데 사용되며 이는 xml 파일에서 Bean을 구성할 때 scope 속성을 사용하는 것과 동일합니다. 공통 값 싱글톤, 프로토타입

2.2 @포스트구성

참고로 메소드는 bean이 생성될 때 콜백 메소드를 지정한다. xml 구성 파일의 <bean>태그에 init-method 속성을 사용하는 기능 과 동일합니다.

2.3 @PreDestroy

bean이 파괴될 때 콜백 메서드를 지정하는 메서드에 대한 참고 사항입니다. xml 구성 파일의 <bean>태그에 destroy-method 속성을 사용하는 기능 과 동일합니다.

2.4 @구성

전체 주석 구현, @Configuration은 xml 구성 파일 bean 태그와 유사합니다. @bean은 bean 태그와 유사합니다.

import com.hqyj.pojo.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBean {  //方法返回值就是定义bean的类型 方法名就是id
    @Bean
    public Dog dog(){
        return new Dog("哈士奇","黑白色");
    }
}

public static void main(String[] args) {
    //通过注解Component
    ApplicationContext ac = new AnnotationConfigApplicationContext(MyBean.class);
    Dog dog = ac.getBean("dog", Dog.class);
    System.out.println(dog);
}

3. 의존성 주입 관련 주석

3.1 @자동 유선

자동 배선:

<constructor-arg>자동 조립이란 Spring 컨테이너가 태그 를 사용 <property>하지 않고 협력하는 빈 간의 관계를 자동으로 조립(autowire)하고 빈을 다른 빈의 속성에 주입할 수 있음을 의미합니다.

Autowiring은 적은 코드로 의존성 주입을 가능하게 합니다. 그러나 int, boolean, String과 같은 단순 데이터 유형은 자동으로 어셈블할 수 없으며, 명시적 어셈블에 비해 자동 어셈블은 프로그래머가 제어하지 않습니다.

@Autowired 주석은 Bean의 속성 변수, 속성 setter 메서드, non-setter 메서드 및 생성자 등에 적용할 수 있으며 해당 주석 프로세서와 협력하여 Bean의 자동 구성을 완료합니다. 기본적으로 Bean의 타입에 따라 어셈블된다. 자동 조립에는 해당 설정 방법이 필요하지 않습니다.

구성 파일의 bean 태그에도 autowired 속성이 있습니다.

byType: 빈의 id가 고유한지, 빈의 타입도 고유한지 확인

byName: bean의 id가 고유한지 확인하고 bean의 id가 이 유형의 속성에 해당하는 set 메서드의 메서드 이름인지 확인합니다.

사용자 클래스

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    @Autowired
    private Address address;
}

주소 등급

@Component
public class Address {
    @Value("chengdu")
    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

구성 파일 bean.xml

<bean id="User" class="com.hqyj.pojo.User">
</bean>
<bean id="address" class="com.hqyj.pojo.Address">
</bean>

테스트 클래스

public class UserTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        User user = ac.getBean("User", User.class);
        System.out.println(user);
    }
}

3.2 @자원

기능은 Autowired와 같지만 @Autowired는 기본적으로 Bean 유형에 따라 어셈블되고 @Resource는 기본적으로 Bean 인스턴스 이름에 따라 어셈블된다는 점에서 다릅니다.

@Resource에는 이름과 유형이라는 두 가지 중요한 속성이 있습니다.

Spring은 name 속성을 Bean의 인스턴스 이름으로, type 속성을 Bean의 인스턴스 유형으로 해석합니다. name 속성을 지정하면 인스턴스 이름으로 어셈블하고, type 속성을 지정하면 Bean 유형으로 어셈블한다. 아무것도 지정하지 않으면 먼저 Bean 인스턴스 이름에 따라 어셈블하고 일치하지 않으면 Bean 유형에 따라 어셈블하고 일치하지 않으면 NoSuchBeanDefinitionException이 발생합니다.

사용자 클래스

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    /*@Autowired
    @Qualifier("address1")*/
    @Resource(name = "address1")  //相当于@Autowired+@Qualifier
    private Address address;
}

3.3 @예선자

@Autowired 어노테이션과 함께 사용하면 Bean 유형별 기본 어셈블리가 Bean의 인스턴스 이름으로 어셈블되도록 수정되며 @Qualifier 어노테이션의 매개변수로 Bean의 인스턴스 이름이 지정된다. (주입된 빈을 지정할 수 있음)

주소 클래스(@Component 주석 제거)

public class Address {
    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

구성 파일

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User">
</bean>
<bean id="address" class="com.hqyj.pojo.Address">
    <property name="addr" value="chengdu"></property>
</bean>
<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>

사용자 클래스

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    @Autowired
    @Qualifier("address1")  //指定要注入的bean
    private Address address;
}

테스트 클래스

public class UserTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        User user = ac.getBean("User", User.class);
        System.out.println(user); //拿到haerbin
    }
}

추가 참고 사항:

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User" autowire="byType">
</bean>
<bean id="address" class="com.hqyj.pojo.Address" >
    <property name="addr" value="chengdu"></property>
</bean>
<!--<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>-->

사용자에서 @autowire 주석을 제거하고 구성 파일에 추가할 수 있으며 byType을 주입할 수 있지만 주입된 빈은 고유해야 합니다.

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User" autowire="byName">
</bean>
<bean id="address" class="com.hqyj.pojo.Address" >
    <property name="addr" value="chengdu"></property>
</bean>
<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>

autowire="byName"은 pojo의 get 및 set 메소드의 매개변수 이름에 따라 해당 값을 얻는 것입니다(User 클래스의 getter 및 setter 메소드 테스트를 수동으로 작성할 수 있음).

해당 빈을 주입하려면 set 메서드의 메서드 이름을 수정해야 합니다. 예를 들면 다음과 같습니다.

public void setAddress1(Address address) {
    this.address = address;
}

3.4 @값

@Autowired는 다른 빈을 주입하고 @Value 주석은 값을 주입합니다. 이 주석은 Java 소스 코드에 상수 값을 주입하여 발생하는 하드 코딩 문제 때문에 덜 사용됩니다.

4. 예제 코드

1. 사용자 서비스

public interface UserService {
    
    
    void selectAll();
}

2. UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    
    

    @Autowired
    private UserDao userDao;

    // 注入值
    @Value("张三")
    private String username;

    @Override
    public void selectAll() {
    
    
        System.out.println(username);
        userDao.selectAll();
    }
}

3. 스프링 구성 파일

<context:component-scan base-package="com.hqyj.cl" />
<bean id="man" class="com.hqyj.cl.pojo.Man" />
<bean id="student" class="com.hqyj.cl.pojo.Student">
    <property name="name" value="student1"/>
</bean>
<bean id="student1" class="com.hqyj.cl.pojo.Student">
    <property name="name" value="student1"/>
</bean>
<bean id="counselor" class="com.hqyj.cl.pojo.Counselor">
    <property name="name" value="张老师" />
</bean>

4. 남자 클래스

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class Man {
    
    

    @Value("张三")
    private String name;

/*    @Autowired
    @Qualifier("student1")*/
    @Resource(type = Student.class)
    private Student student;

    @Autowired
    private Counselor counselor;
}

5. 테스트 클래스

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Man man = ac.getBean("man", Man.class);
        System.out.println(man);
    }
}