SpringBoot-基础

SpringBoot-基础

1.IOC控制反转

Spring的核心是IoC(Inversion of Control,控制反转)容器,它可以管理容器内的普通Java对象以及对象之间关系的绑定(Dependency Injection依赖注入)。容器中被管理的对象称为Bean。

Spring是通过元数据和POJO来定义和管理Bean的。
◎POJO:简单的Java对象。
◎元数据:描述如何管理POJO的数据。

2.注解配置(@Compoent)

当使用了@Compoent,@Service,@Controller,@Repository时,Spring容器(@CompoentScan实现)会自动扫描,并将他们注册成被容器管理的Bean.

@Service、@Repository和@Controller这三个注解组合了@Component注解,它们是@Component语义上的特例。

3.JAVA配置(@Configuration和@Bean)

在类上注解@Configuration(@Component的特例,会被容器自动扫描),可使类成为配置类。如果使用@Bean标注在类的方法上,则方法的返回值即为Bean的实例。

4.依赖注入(DI)

1.注解注入-直接注入类:在类的属性上添加@Autowired注解,即可获取容器中的Bean对象.

@Component
public class SpringTestDI {
    public void di(){
        System.out.println("已注入Bean的方法");
    }
}
@SpringBootTest
@Component
public class SpringAuto {
    @Autowired
    private SpringTestDI springTestDI;

    @Test
    public void autoPoint(){
        this.springTestDI.di();
    }
}

2.注解注入-注入方法:加在方法上,注册Bean的时候会自动依赖注入

@Component
public class SpringTestDI {
    public void di(){
        System.out.println("已注入Bean的方法");
    }
}
@Component
@Data
public class SpringAuto {

    private SpringTestDI springTestDI;

    @Autowired
    public void autoPoint(SpringTestDI springTestDI){
        this.springTestDI = springTestDI;
    }
}
@SpringBootTest
public class SpringTest {
    @Autowired
    private SpringAuto springAuto;

    @Test
    public void xxx(){
        SpringTestDI springTestDI = springAuto.getSpringTestDI();
        springTestDI.di();
    }
}

3.注解注入-构造方法:加在构造方法上依赖注入,只有一个构造方法可以默认不写@Autowired

@SpringBootTest
@Component
@Data
public class SpringAuto {

    private SpringTestDI springTestDI;

    public SpringAuto(SpringTestDI springTestDI){
        this.springTestDI = springTestDI;
    }

}
5.@Primary

使用@Autowired注解是根据类型自动注入的,当两个类型相同时,无法正确注入,可以使用@Primary注解来确定注入哪一个Bean

@Configuration
public class SpringPrimary {
    @Bean
    public SpringAuto a(){
        System.out.println("a");
        return new SpringAuto("a");
    }

    @Primary
    @Bean
    public SpringAuto b(){
        System.out.println("b");
        return new SpringAuto("b");
    }
}
6.@Qualifier

通过指定名称来确定依赖注入的bean

@Configuration
public class SpringPrimary {
    @Bean("a")
    public SpringAuto a(){
        System.out.println("a");
        return new SpringAuto("a");
    }

    @Bean("b")
    public SpringAuto b(){
        System.out.println("b");
        return new SpringAuto("b");
    }
}
@Autowired
@Qualifier("a")
private SpringAuto springAuto;
7.运行校验CommandLineRunner

是Spring Boot框架提供的一个接口,主要用于应用启动后立即执行特定的业务逻辑。当一个类实现了 CommandLineRunner 接口,Spring Boot将会自动检测并运行该类的 run 方法。这对于一些初始化任务或者一次性执行的任务非常有用,比如读取配置文件、数据预加载、初始化缓存等。

@Component
public class SpringCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("SpringBoot项目启动完成,我来前面探探路");
    }
}
8.@Scpoe

指定Bean的作用域,默认是单例模式,整个容器只有一个相同类型的bean

  1. Singleton(单例)
    • 默认作用域,Spring容器中每个Bean定义对应一个单一实例。
    • 整个容器中,无论何时何处请求该Bean,都会返回相同的实例。
  2. Prototype(原型)
    • 每次请求都会创建一个新的Bean实例。
    • 适用于需要独立状态和生命周期的对象,比如临时性的操作对象。
  3. Request
    • 仅在Web应用上下文中适用,每次HTTP请求都会创建一个新实例,仅在当前请求的生命周期内有效。
  4. Session
    • 同样在Web应用上下文中,每个HTTP Session拥有一个Bean实例,该实例在会话期间持续有效。
  5. GlobalSession(Application Session):
    • 仅在支持portlet的Web应用中使用,每种全局会话(如PortletSession或ServletContext)对应一个Bean实例。
  6. WebSocket
    • 在WebSocket相关的Spring应用上下文中,每个WebSocket连接对应一个Bean实例,仅在该连接生命周期内有效。
/**
 * 原型Prototype 每次都会创建一个新的实例
 */
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class SpringScope {
}
@SpringBootTest
public class SpringTest {
    @Autowired
    private SpringScope springScope1;

    @Autowired
    private SpringScope springScope2;

    @Test
    public void xxx(){
        // 结果:false;  默认不使用Scope注解,结果为true
        System.out.println(springScope1 == springScope2);
    }
}
9.Bean的生命周期

先了解简单的生命周期,以下是顺序执行

@Component
public class SpringLife {
    public SpringLife() {
        System.out.println("bean的构造方法");
    }
    @PostConstruct
    public void init(){
        System.out.println("bean的初始化方法");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("bean的销毁方法");
    }
}
10.@Lazy

延迟初始化:再被调用的时候才会初始化,需要已常见四大组件注解搭配使用

11.@DependsOn

可以控制依赖注入的先后顺序

12.@Enable*

@Enable* 注解系列: Spring框架提供了一系列以 @Enable 开头的注解,这些注解用于启用特定的功能模块或框架特性。例如:

  • @EnableAspectJAutoProxy:启用Spring AOP代理和AspectJ切面自动代理功能。
  • @EnableCaching:启用Spring的缓存支持。
  • @EnableScheduling:启用定时任务调度功能。
  • @EnableTransactionManagement:启用Spring的事务管理支持。
  • @EnableWebMvc:在Spring MVC应用中启用注解驱动的Web MVC配置。
  • @EnableAsync : 用于启用异步方法执行的支持

这些注解通常放在一个配置类上,Spring在扫描和解析配置时会识别到这些注解,并加载相应的配置处理器来处理它们。

13.@Import

@Import 注解用于将其他配置类或配置类的全限定名导入到当前配置类中。当Spring容器加载包含 @Import 注解的配置类时,也会加载并处理被导入的配置类。这样可以实现多个配置类的整合和复用。

@Configuration
@Import({DatabaseConfig.class, ServiceConfig.class, WebConfig.class})
public class AppConfig {
    // ...
}
14.BeanPostProcessor接口

可以通过实现BeanPostProcessor接口,在构造时对容器内所有或者部分指定Bean进行处理。和@PostConstruct与@PreDestroy不同的是,它针对的是IoC容器里的所有的Bean。

  1. postProcessBeforeInitialization(Object bean, String beanName): 这个方法会在Spring容器对Bean实例化并设置好所有属性后,但在调用该Bean的初始化方法(如InitializingBean.afterPropertiesSet() 或者带有 @PostConstruct 注解的方法)之前调用。在该方法中,开发者可以对刚实例化的Bean进行进一步的加工或修改。
  2. postProcessAfterInitialization(Object bean, String beanName): 这个方法会在Bean的初始化方法调用完毕后,但在Bean正式交付给Spring容器使用之前调用。开发者可以在该方法中对已经初始化完成的Bean做进一步的处理,例如AOP代理增强、日志记录等。
public class PostProcessorTest implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("属性设置之后,Bean初始化之前:" + beanName + "]");
        // 可以对bean进行某些操作,例如AOP代理、属性修改等
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean初始化之后: [" + beanName + "]");
        // 同样可以对bean进行更多后期处理
        return bean;
    }
}
15.Spring Aware

Spring Aware 是Spring框架中一系列接口的总称,这些接口允许Spring容器在实例化和初始化Bean的过程中向Bean注入特定的资源或信息。实现这些Aware接口的类能够感知Spring容器的存在,并通过Spring容器获取相应的服务或上下文。

◎BeanNameAware:可获得beanName,即Bean的名称。
◎ResourceLoaderAware:可获得ResourceLoader,即用来加载资源的Bean。

◎BeanFactoryAware:可获得BeanFactory,即容器的父接口,用于管理Bean的相关操作。
◎EnvironmentAware:可获得Environment,即当前应用的运行环境。
◎MessageSourceAware:可获得MessageSource,即用来解析文本信息的Bean。
◎ApplicationEventPublisherAware:可获得ApplicationEventPublisher,即用来发布系统时间的Bean。
◎ApplicationContextAware:可自动注入ApplicationContext,即容器本身。

16.Spring 事件通信

如果Bean之间需要通信,比如说BeanA完成了处理后需要告知BeanB,通知BeanB继续处理,那么我们称BeanA为Publisher,称BeanB为Listener。

/**
 * 事件类
 * @Author : MengYansong
 * @create 2024/1/29 15:53
 */
public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}
/**
 * 发布事件
 */
@Component
public class EventPublisher {
    private final ApplicationContext context;

    @Autowired
    public EventPublisher(ApplicationContext context) {
        this.context = context;
    }

    public void fireEvent() {
        System.out.println("1.发布事件");
        context.publishEvent(new MyEvent(this));
    }
}
/**
 * 事件监听
 */
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {

    @Override
    public void onApplicationEvent(MyEvent event) {
        // 在这里处理事件逻辑
        System.out.println("2.监听事件: " + event);
    }
}
17Spring EL

Spring EL(Spring Expression Language,Spring表达式语言)是Spring生态下的通用语言,在运行时使用表达式查询属性信息(使用符号$)或操作Java对象(使用符号#),主要用在XML或注解上。

@SpringBootTest
public class SpringTest {
    @Autowired
    private EventPublisher eventPublisher;

    @Value("${yyds.y1}")
    private String name;

    @Test
    public void xxx(){
        System.out.println(name);
    }
}
yyds:
  y1: 666
  y2: 777

你可能感兴趣的:(spring,boot,后端,java)