JavaEE 学习笔记 —— Spring Framework

容器：servlet 容器、集合

线程池、常量池、数据库连接池的作用类似于容器
但是他们属于设计模式中的享元模式，即从池子中取东西，如果取不到，再创建

spring 中的核心容器，类似于集合

作用

1. 存放对象
2. 取出来使用

在 spring 中，有些对象是由容器来创建的，并且复制管理对象间的依赖

对于对象间的依赖：A 对象的属性为 B 对象，A 和 B 就产生了依赖关系

概念：IOC，(Inversion of Control，控制反转) —— 以前自己 new 对象以及组织对象间的关系，现在全部交给容器来统一管理，控制权发送了反转，因此称为控制反转。

实现方式：使用 IOC 容器来实现

在 spring 在，称为 spring bean 容器、spring 容器或 IoC 容器

概念：DI， (Dependency Injection，依赖注入) —— 由 IoC 容器在运行期间，动态的将某种依赖关系注入到对象之中

注入
把 B 对象注入到 A ，称为 A 的属性
把 A 注入 IoC 容器中

不使用：

使用：

作用
解耦

1. 配置 pom.xml 文件

    4.0.0

    org.example
    spring01
    1.0-SNAPSHOT

    
        1.8
        ${java.version}
        ${java.version}
        UTF-8
        5.2.10.RELEASE
    

    
        
            org.springframework
            spring-beans
            ${spring-framework.version}
        
        
            org.springframework
            spring-context
            ${spring-framework.version}
        

        
            org.projectlombok
            lombok
            1.18.16
        
    

    
        
            
            
                maven-clean-plugin
                3.1.0
            
            
                maven-compiler-plugin
                3.8.1
            
            
                maven-deploy-plugin
                2.8.2
            
            
                maven-install-plugin
                2.5.2
            
            
                maven-jar-plugin
                3.2.0
            
            
                maven-resources-plugin
                3.1.0
            
            
                maven-site-plugin
                3.3
            
            
                maven-surefire-plugin
                2.22.2
            

        
    

点击刷新，使得配置文件完成

2. 在 resources 目录下创建 beans.xml 文件

3. 启动 spring 容器

package org.example;

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

public class App {

    public static void main(String[] args) {
        //根据Spring配置文件路径创建容器：应用上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //关闭容器
        ((ClassPathXmlApplicationContext) context).close();
    }
}

1. 启动 spring 容器：new ApplicationContext 的实现类
2. 注册 / 注入对象到容器中：加载指定的配置文件，执行包扫描，指定的包，子包下，带 spring 框架提供的四个注解，会注入到容器中
   @Controller
   @Service
   @Repository
   @Component
3. 装配 / 注入依赖关系：如果注册到容器中的对象，属性使用一下两个注释
   @Autowired
   @Resource

1.使用 Controller 注解、Bean 注解 + 方法注入
bean 注解使用在方法上，该方法所在的类也需要注解

package org.example.controller;

import org.example.model.Duck;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Controller;

// 使用 Controller 注解将该类注入到 Bean 容器中
@Controller
public class LoginController {
    
    // 方法前使用 Bean 注解, 也能够注入对象
    @Bean
    public Duck d1() {
        Duck duck = new Duck();
        duck.setName("唐老鸭");
        return duck;
    }


    @Bean
    public Duck d2() {
        Duck duck = new Duck();
        duck.setName("香酥鸭");
        return duck;
    }
}

2. 使用 Repository 注解注入

package org.example.dao;

import org.springframework.stereotype.Repository;

@Repository
public class LoginRepository {
}

3. 创建 Bean 注入的类

package org.example.model;


import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class Duck {
    private String name;
}

4. 通过 Service 注解注入

package org.example.service;

import org.springframework.stereotype.Service;

@Service
public class LoginService {
	// 如果注入的对象不止一个 那么需要使用 @Qualifier 注解来确定使用的是哪个对象
    @Autowired
    @Qualifier("luYa")
    public Duck duck;
}

5. @Scope 注解每次都能创建新对象

package org.example.service;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

// Scope 注解每次都能获取新的 Bean 对象
@Service
@Scope("prototype")
public class LoginServicePrototype {
}

6. 检查注入结果

package org.example;

import org.example.controller.LoginController;
import org.example.dao.LoginRepository;
import org.example.model.Duck;
import org.example.service.LoginService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {


    public static void main(String[] args) {
        //根据Spring配置文件路径创建容器：应用上下文对象
        // 类加载路径下的 beans.xml 文件
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");


        // 1. 通过类型获取
        LoginRepository login1 = context.getBean(LoginRepository.class);

        // 2. 通过类名获取
        LoginRepository login2 = (LoginRepository) context.getBean("loginRepository");

        System.out.println(login1);
        System.out.println(login2);


        // 通过类型获取
        LoginController login3 = context.getBean(LoginController.class);

        // 通过类名获取
        LoginController login4 = (LoginController) context.getBean("loginController");

        System.out.println(login3);
        System.out.println(login4);


        LoginService login5 = context.getBean(LoginService.class);

        // 通过类名获取
        LoginService login6 = (LoginService) context.getBean("loginService");

        System.out.println(login5);
        System.out.println(login6);


        Duck d1 = (Duck) context.getBean("d1");
        Duck d2 = (Duck) context.getBean("d2");

        System.out.println(d1);
        System.out.println(d2);

        // 同一类型注册了两个以上对象, 不能通过类型来获取
//        Duck d3 = context.getBean(Duck.class);
//        System.out.println(d3);
        //关闭容器
        ((ClassPathXmlApplicationContext) context).close();
    }
}




// 		  打印结果
//        org.example.dao.LoginRepository@76a4d6c
//        org.example.dao.LoginRepository@76a4d6c
//        org.example.controller.LoginController@517cd4b
//        org.example.controller.LoginController@517cd4b
//        org.example.service.LoginService@6cc7b4de
//        org.example.service.LoginService@6cc7b4de
//        Duck(name=唐老鸭)
//        Duck(name=香酥鸭)

BeanFactory 和 FactoryBean 的区别

1. BeanFactory 是 Spring 的顶级接口
2. FactroyBean 是工厂 Bean，本身是一个 Bean，且主要是生成 Bean 的工厂
   把 getObject() 方法的返回值注册到容器中