目录

  • 1、什么是Spring框架?
  • 2、什么是Spring容器或者叫SpringBean容器?
  • 3、Spring的模块化组成结构
    • 3.1. Core Container(核心容器)
      • 3.1.1 IoC(控制反转)
      • 3.1.2 DI(依赖注入)
      • 3.1.3 注册Bean的方法
        • – 在类上使用以下四个注解
        • – 在方法上使用注解:@Bean
        • – 在类上使用注解:@Configuration
        • – 实现FactoryBean接口,在类上使用@Component注解
      • 3.1.4装配Bean的方法
        • @Autowired注解的使用
        • @Autowired和@Resource的区别
      • 3.1.5 获取Bean对象
  • 4、Spring容器使用流程
    • 1)启动容器
    • 2)根据配置完成Bean初始化
    • 3)注册Bean对象到容器中
    • 4)装配Bean的属性
  • 5、Bean的作用域
  • 6、Bean的生命周期
  • 两个比较:
      • 1.BeanFactory和ApplicationContext之间的区别
      • 2.BeanFactory和FactoryBean之间的区别

1、什么是Spring框架?

Spring框架是由于开发的复杂性而创建的,使用基本的JavaBean代替EJB;
Spring框架还是一个轻量级的控制反转和面向切面的容器框架;
Spring框架使用于包括服务器开发等的任何Java应用,使得Java程序更加便捷、高效、安全

2、什么是Spring容器或者叫SpringBean容器?

Bean就是 Java对象,容器就是对Java对象的整个生命周期进行管理(包括创建、装配、销毁).

3、Spring的模块化组成结构

3.1. Core Container(核心容器)

3.1.1 IoC(控制反转)

实现了IoC思想的容器叫做IoC容器,由IoC容器来管理对象的生命周期和依赖关系等,降低了代码的耦合程度(以前手动new对象并设置属性,控制权掌握在应用程序自身,现在由容器来统一管理对象,这种控制权的转移,叫做控制反转).

3.1.2 DI(依赖注入)

DI是实现IoC的方法之一,由IoC容器在运行期间动态的将某种依赖关系注入到对象中.
依赖注入的三种方式:
构造函数方法注入、Setter方法注入与接口注入。

3.1.3 注册Bean的方法

– 在类上使用以下四个注解

@Controller
@Service
@Repository
@Component

当使用以上注解的类被Spring扫描到时就会创建Bean对象并注册到容器中,默认类名首字母小写作为Bean的名称或叫id.
传统的三层架构设计:Controller(控制层)、Service(服务层)、Repository(数据访问层).
@Controller 用于web请求和响应的处理,完成请求数据的校验等操作;
@Service用于业务逻辑处理,根据方法参数完成业务逻辑;
@Repository用于关系型数据库的访问操作;
其他组件使用@Component.
该方法只能注册一个Bean对象.

– 在方法上使用注解:@Bean

当该类被Spring扫描到时,可以在方法上使用@Bean注解,通过方法返回类型,默认使用方法名作为Bean的名称.
该方法比较灵活,可以手动设置属性,可以注册多个Bean对象.

– 在类上使用注解:@Configuration

注册一个配置类到容器,一般用来定义配置某些资源.

– 实现FactoryBean接口,在类上使用@Component注解

FactoryBean以Bean结尾,表示它是一个Bean,而且是一个实现了FactoryBean接口的Bean,
注册一个Bean对象的工厂类,实现了 FactoryBean接口,获取Bean对象时,根据该Bean的id从容器中获取的实际是FactoryBean的 getObject()方法返回的对象,而不是 FactoryBean本身,如果要获取 FactoryBean对象,请在 id前面加一个&符号来获取.

package org.example.model;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;
@Component
public class ByFactoryBean implements FactoryBean<User> { 
    @Override
    public User getObject() throws Exception { 
        User user = new User();
        user.setUsername("abc");
        user.setPassword("123");
        return user;
   }
    @Override
    public Class<?> getObjectType() { 
            return User.class;
   }
}

3.1.4装配Bean的方法

@Autowired
@Resource

@Autowired注解的使用

①属性注入:在属性上使用@Autowired注解可以将该对象从容器中装配到属性中;
在setter方法上使用@Autowired注解可以将Bean对象注入到方法参数,然后装配到属性中;
②构造方法注入:同样在构造方法上使用@Autowired注解可以将Bean对象注入到方法参数,然后装配到属性中.

@Autowired和@Resource的区别

@Autowired是Spring提供的注解,只能在Spring框架中使用,Resource是jdk官方提供的注解,Spring的DI提供了该注解的实现.

3.1.5 获取Bean对象

定义好了Bean对象,注册到容器中以后就可以获取Bean对象了,获取Bean对象有两种方式:
通过类型获取:该类型的Bean只有一个才能使用;
通过名称获取:同类型的Bean有多个也可以获取.

4、Spring容器使用流程

1)启动容器

2)根据配置完成Bean初始化

3)注册Bean对象到容器中

4)装配Bean的属性

写一个入口类并使用名称和类型两种方式获取Bean对象:

package org.example;
import org.example.config.AppConfig;
import org.example.controller.LoginController;
import org.example.dao.LoginDAO;
import org.example.model.User;
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配置文件路径创建容器:应用上下文对象
         ApplicationContext context = new
               ClassPathXmlApplicationContext("beans.xml");
         //获取注册的Bean对象:
         // 根据名称获取
       LoginController loginController1 = (LoginController) context.getBean("loginController");
         //根据类型获取
       LoginController loginController2 = (LoginController) context.getBean(LoginController.class);
       //获取到的是同一个对象
       System.out.println(loginController1 == loginController2);
       //关闭容器
       ((ClassPathXmlApplicationContext) context).close();
   }
}

5、Bean的作用域

1)singleton(单例模式)
该作用域下的Bean在IoC容器中只存在一个实例:获取Bean(即通过
applicationContext.getBean等方法获取)及装配Bean(即通过@Autowired注入)都是同一个对象。
场景:通常无状态的Bean使用该作用域(无状态表示Bean对象的属性状态不需要更新)
例如:

备注:Spring默认选择该作用域
2)prototype(原型模式)
每次对该作用域下的Bean的请求都会创建新的实例:获取Bean(即通过applicationContext.getBean等方法获取)及装配Bean(即通过@Autowired注入)都是新的对象实例。
场景:通常有状态的Bean使用该作用域
3)request
每次http请求会创建新的Bean实例,类似于prototype
场景:一次http的请求和响应的共享Bean
备注:限定SpringMVC中使用
4)session
在一个http session中,定义一个Bean实例
场景:用户回话的共享Bean, 比如:记录一个用户的登陆信息
备注:限定SpringMVC中使用
5)application
在一个http servlet Context中,定义一个Bean实例
场景:Web应用的上下文信息,比如:记录一个应用的共享信息
备注:限定SpringMVC中使用
6)websocket
在一个HTTP WebSocket的生命周期中,定义一个Bean实例
场景:WebSocket的每次会话中,保存了一个Map结构的头信息,将用来包裹客户端消息头。第一次初始化后,直到WebSocket结束都是同一个Bean。
备注:限定Spring WebSocket中使用

6、Bean的生命周期

1)实例化Bean
2)依赖注入
3)注入Aware接口的方法参数对象,如顺序执行BeanNameAware、BeanFactoryAware、
ApplicationContextAware
4)Bean对象初始化前,执行BeanPostProcessor的Before方法
5)Bean对象初始化:顺序执行@PostConstruct注解方法、InitializingBean接口方法、init-method方法
6)初始化后,执行BeanPostProcessor的After方法
7)容器关闭时,执行Bean对象的销毁方法,顺序是:@PreDestroy注解方法、DisposableBean接口
方法、destroy-method

两个比较:

1.BeanFactory和ApplicationContext之间的区别

BeanFactory是最底层的容器接口,只提供最基础的容器功能(包括Bean的实例化和依赖注入,并且使用懒加载的方式,Bean只有在通过调用getBean()方法直接调用时才实例化);
ApplicationContext是BeanFactory的子接口,与BeanFactory懒加载的方式不同,它默认是预加载,每个Bean都在ApplicationContext启动后实例化,但可以自己设置成懒加载.

2.BeanFactory和FactoryBean之间的区别

BeanFactory是个Factory,也就是IOC容器或对象工厂,FactoryBean是个Bean。在Spring中,所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言,这个Bean不是简单的Bean,而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似.

本文地址:https://blog.csdn.net/nefss_/article/details/114272305