Springboot01-CSDN博客

本文链接：https://blog.csdn.net/Rancemy/article/details/147961150

springboot

1、springboot以spring思想为基础

2、springboot整合springmvc

spring

spring全家桶

spring、springmvc、springboot、springsecurity、springcloud

spring包含的子模块：

spring core ----- 最核心jar包 ioc、di

spring dao ----- 针对jdbc封装

spring orm ----- object relational mapping 对象关系映射思想

spring aop ----- 面向切面管理（事务切面、日志切面、权限控制、自定义切面）

spring web ------ 针对servlet进行的封装，接收请求、响应数据给前端

spring context ---- 上下文环境

springmvc ---- spring webmvc ---包含spring core 、aop等

Spring的核心

三大思想

IOC、DI、AOP

两大思想

IOC|DI、AOP

Spring Framework：Spring 的基础框架，可以视为 Spring 基础设施，基本上任何其他 Spring 项目都是以 Spring Framework 为基础的，其包含IOC/DI和AOP两大核心部分。

IOC 控制反转思想

inverse of control

控制权的反向转移。创建对象的权限转移给spring容器

（原来创建对象，是谁用谁创建，现在应该有spring容器创建，使用时从容器中获取）

User u1 = new User(); 创建需要消耗资源、存储消耗资源、回收消耗资源。

User u2 = new User(); 频繁的创建对象、销毁对象。

1、创建容器

2、将对象放到容器中

3、用的时候从容器中获取

4、不用了，归还对象到容器。

1、IOC概念

IOC全称Inversion Of Control 控制反转，核心的作用就是将原来由开发人员来控制的对象管理操作交由Spring来管理，spring创建出来的对象，会放到spring的一个容器中存储，使用对象的时候可以从容器直接拿，这个容器就称为spring ioc容器。

简单来说：原来我们自己new对象的操作不在做了，而是由spring帮我们创建对象，创建出来的对象spring会放到一个容器中管理，我们用对象的时候，从容器中去拿就行了。

2、IOC容器初始化方式

xml配置文件配置方式【使用读取xml中的bean来创建对象】
纯注解方式

3、类关系

BeanFactory接口：这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
ApplicationContext接口：BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

ClassPathXmlApplicationContext：通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象。
AnnotationConfigApplicationContext：通注解方式创建 IOC 容器对象。

一、搭建spring环境

1、单独引入需要的jar包，比如ioc（spring-core，spring-context）

2、直接引入所有常见的（建议选择）

maven项目（ssm架构模式） pom中指定jar包

springboot项目（更简单）选择直接创建springboot项目（自动引入相关jar包）

二、创建容器的两种方式

1、通过类创建

package com.hl.springboot01;

import org.springframework.context.annotation.Configuration;

//@Configuration 配置文件类
@Configuration
public class MyConfig {
}

package com.hl.springboot01;

import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyBeanTest {

    @Test
    public void createContainer(){
        //读取配置文件类，创建ioc容器
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(MyConfig.class);
        //context 即为容器对象

    }
}

2、通过配置文件

在resources目录中创建applicationContext.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">
    
    
</beans>

三、容器内部创建对象

1、配置类创建对象

创建javabean类

@Data
//创建当前类的对象，并交给spring容器进行管理
@Component
public class User {
    private int id;
    private String name;
}

在配置文件类定义组件扫描的包

//@Configuration 配置文件类
@Configuration
//定义组件扫描的包
@ComponentScan(basePackages = "com.hl.springboot01.pojo")
public class MyConfig {
}

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">
    <!--
    创建一个对象
    id="对象名“
    class="类的全限定名"
    -->
    <bean id="u1" class="com.hl.springboot01.pojo.User"></bean>

</beans>

底层通过构造方式、工厂方法创建对象

无参构造

有参构造

@Component("goods")
public class Goods {
    private int id;
    private String name;
    private int price;

    public Goods() {
        System.out.println("无参构造.......");
    }
}

静态工厂

实例工厂

//创建对象 对象名，默认为方法名
@Bean  //实例工厂方法
public Category category(){
    return new Category();
}

@Bean  //静态工厂方法
public static Category category2(){
    return new Category();
}

四、获取对象的过程

package com.hl.springboot01;

import com.hl.springboot01.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyBeanTest {

    @Test
    public void createContainer(){
        //读取配置文件类，创建ioc容器
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(MyConfig.class);
        //context 即为容器对象
        //从容器中获取对象
        User user = context.getBean(User.class);
        //只要不报空指针异常，就证明从容器中获取对象
        System.out.println(user.toString());
    }
    
    
    @Test
    public void createContainer2(){
        //读取配置文件，创建ioc容器
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");

        //容器对象  context
        //容器中获取对象
        User user = context.getBean(User.class);
        System.out.println(user.toString());

    }
    
}

五、对象的生命周期

对象的生命周期：对象创建到销毁的整个过程

1、对象何时创建

单例模式：默认情况下，在创建ioc容器时，创建对象。

创建对象时，默认调用无参构造方法创建对象。无参构造只执行一遍。

初始化方法（在对象创建后，自动调用的方法）。初始化方法只执行一遍。

销毁前调用的方法（关闭ioc容器时，自动调用的）。只执行一次。

懒加载：只针对单例模式有效。

懒加载：在首次使用对象时创建对象（而不是在创建容器时创建对象）。

多例模式下：可以创建很多对象，不是提前创建的对象，是使用时创建对象。

每获取一次对象，创建一个对象，执行一次构造方法，执行一次初始化方法。

2、对象何时销毁

单例模式下，关闭容器时销毁。

多例模式下：对象由 jvm虚拟机垃圾回收器在后台进程自动销毁。

示例代码：

package com.hl.springboot02.pojo;

import lombok.Getter;
import lombok.Setter;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Getter
@Setter
//创建类的对象  对象名默认为类名（首字母变小写）
//@Component("对象名")
//多例模式
//@Scope(value = "prototype")
//懒加载
@Lazy
@Component("goods")
public class Goods {
    private int id;
    private String name;
    private int price;

    public Goods() {
        System.out.println("goods....无参构造.......");
    }
    //@PostConstruct 初始化方法
    @PostConstruct
    public void init(){
        System.out.println("init ..... 初始化方法");
    }
    //@PreDestroy 销毁前执行
    @PreDestroy
    public void destroy(){
        System.out.println("destroy....销毁前执行");
    }
}
 @Test
    public void objectLife(){
        //单例模式下的对象 默认是在创建容器时，直接创建对象，销毁ioc容器时，销毁对象
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(Springboot02Application.class);
//        //获取对象
//        //多例模式下的对象 默认是在获取对象时创建，由jvm虚拟机自动销毁
        Goods goods = context.getBean("goods", Goods.class);
        Goods goods2 = context.getBean("goods", Goods.class);
//
//        //优雅的销毁容器
        context.registerShutdownHook();

    }

六、bean的作用域范围

<?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">
    <!--
    创建一个对象
    id="对象名“
    class="类的全限定名"
    在同一个容器中，对象名不能重复
    单例模式： 一个类只有一个实例（对象）  默认   scope="singleton"
    多例模式：一个类有多个实例（对象）   scope="prototype"
    spring-web 环境  接收前端请求
            request： 一次request请求创建一个对象
            session： 一个会话共享一个对象
            global-session:  全局有效
    -->
    <bean id="u1" name="u2,u3" class="com.hl.springboot01.pojo.User" scope="singleton"></bean>
<!--    <bean id="u4"   class="com.hl.springboot01.pojo.User"></bean>-->
</beans>

@Test
public void createContainer2(){
    //读取配置文件，创建ioc容器
    ClassPathXmlApplicationContext context =
            new ClassPathXmlApplicationContext("applicationContext.xml");

    //容器对象  context
    //容器中获取对象
    User user1 = context.getBean("u1",User.class);
    User user2 = context.getBean("u1",User.class);
    System.out.println(user1);
    System.out.println(user2);
}

//@Data
@Getter
@Setter
//创建当前类的对象，并交给spring容器进行管理
@Component
public class User {
    private int id;
    private String name;
}

七、如何从容器内部获取对象（从容器中获取对象的三种方式）

// 方式一： 推荐  名称+类型
Goods goods = context.getBean("goods", Goods.class);
System.out.println(goods);
// 方式二： 名称  需要强制类型转换
Goods goods2 = (Goods)context.getBean("goods");
System.out.println(goods2);
// 方式三： 通过类型获取
Goods goods3 = context.getBean(Goods.class);
System.out.println(goods3);
@Getter
@Setter
//创建类的对象  对象名默认为类名（首字母变小写）
//@Component("对象名")
@Component("goods")
public class Goods {
    private int id;
    private String name;
    private int price;

}

总结

1、Spring的三大核心思想

IoC（控制反转）、DI（依赖注入）和AOP（面向切面编程）

2、IOC思想的理解

3、IOC容器创建的两种方式

xml配置文件配置方式【使用读取xml中的bean来创建对象】
纯注解方式 @Configuration
BeanFactory接口：这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
ApplicationContext接口：BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。
ClassPathXmlApplicationContext：通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象。
AnnotationConfigApplicationContext：通注解方式创建 IOC 容器对象。

4、创建对象的注解

@Component 类上使用

@Bean 方法上使用，方法的返回值是对象，将返回的对象交给ioc容器管理。

5、底层如何创建对象

构造方法（无参构造|有参构造）

工厂方法（静态工厂方法|实例工厂方法）

6、对象何时创建，何时销毁, 能不能延迟创建，初始化方法和销毁方法

1、对象何时创建

单例模式：默认情况下，在创建ioc容器时，创建对象。

创建对象时，默认调用无参构造方法创建对象。无参构造只执行一遍。

初始化方法（在对象创建后，自动调用的方法）。初始化方法只执行一遍。

销毁前调用的方法（关闭ioc容器时，自动调用的）。只执行一次。

懒加载：只针对单例模式有效。

懒加载：在首次使用对象时创建对象（而不是在创建容器时创建对象）。

多例模式下：可以创建很多对象，不是提前创建的对象，是使用时创建对象。

每获取一次对象，创建一个对象，执行一次构造方法，执行一次初始化方法。

2、对象何时销毁

单例模式下，关闭容器时销毁。

多例模式下：对象由 jvm虚拟机垃圾回收器在后台进程自动销毁。

7、从容器获取对象的三种方式

名称（强制类型转换）

类型（容易出错，需要一个对象，返回了2个对象）

名称+类型（推荐）

8、bean的作用域范围

作用域	描述	适用场景	配置方式
singleton	默认作用域。容器中仅存在一个Bean实例，所有依赖注入共享同一对象。	无状态工具类、服务层组件（如Service、DAO）。	`@Scope("singleton")` 或默认不声明。
prototype	每次请求（如`getBean()`或注入）时，容器都会创建一个新的Bean实例。	需要保持状态的Bean（如用户会话临时数据）。	`@Scope("prototype")`。
request	每个HTTP请求创建一个新实例，仅在Web应用中有效（如Spring MVC）。	HTTP请求级别的数据（如表单对象）。	`@Scope("request")` 或 `@RequestScope`。
session	每个用户会话（HTTP Session）创建一个实例，仅在Web应用中有效。	用户会话数据（如登录信息、购物车）。	`@Scope("session")` 或 `@SessionScope`。

作用域选择原则

无状态组件：优先使用singleton（默认），减少资源开销。
有状态组件：根据场景选择prototype、request或session。
Web环境：使用request或session管理请求/会话级数据。

9、相关的注解有哪些？各自作用？

分类	注解	核心作用
核心配置	`@Configuration`	声明配置类，替代XML。
	`@ComponentScan`	配置组件扫描路径。
	`@Component`	标记组件类，由容器管理。
	`@Bean`	在配置类中显式定义Bean。
作用域	`@Lazy`	延迟初始化Bean。
	`@Scope`	定义Bean的作用域（如原型、请求域等）。
生命周期	`@PostConstruct`	Bean初始化后执行方法。
	`@PreDestroy`	Bean销毁前执行方法。
Lombok	`@Data`	自动生成POJO方法。
	`@Getter/@Setter`	生成`getter`/`setter`方法。
测试	`@Test`	标记JUnit测试方法。