备案控制台
开发者社区 开发与运维 文章 正文

Spring的使用-Bean对象的储存和获取/Bea对象的作用域与生命周期

2024-05-29 20
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Spring的使用-Bean对象的储存和获取/Bea对象的作用域与生命周期

一.存储Bean对象

1.1 <bean></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">
       <bean id="user" class="User"> </bean>
       <bean id="people" class="demo.People"></bean>
</beans>

class路径是以java为当前路径来写的

此时只是将类配置到了配置文件中,并没有真正的放到Spring中,只有在获取上下文对象时，才会将对象放进去。

获取bean对象：

    public static void main(String[] args) {
        //先得到 spring 上下文对象(路径名称要和spring创建的配置文件名称相等)
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        //依赖查找->IoC的一种实现方式
        //通过Bean名称来获取(这里的名称要和配置文件中的id)相等，此时得到的object对象，需要强转
        User user=(User)context.getBean("user");
        //通过类型来获取bean对象(如果Spring容器中有多个该类型对象，会报错)
        User user1=context.getBean(User.class);
        //通过Bean名称和类型来获取
        User user2=context.getBean("user",User.class);
        System.out.println(user.sayHello());
//        People people=context.getBean("people",People.class);
//        System.out.println(people.sayHi());
    }
//User Constructor
//hello world
 
 
    public static void main(String[] args) {
        //XmlBeanFactory 有横线说明被官方弃用了，不建议使用
        BeanFactory context=new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        //通过Bean名称来获取(这里的名称要和配置文件中的id)相等，此时得到的object对象，需要强转
        User user=(User)context.getBean("user");
        //通过类型来获取bean对象
        User user1=context.getBean(User.class);
        //通过Bean名称和类型来获取
        User user2=context.getBean("user",User.class);
        System.out.println(user.sayHello());
        //People people=context.getBean("people",People.class);
        //System.out.println(people.sayHi());
    }
//User Constructor
//People constructor
//hello world

ApplicationContext VS BeanFactory 有什么区别？


相同点：都是容器管理对象，都可以获取Bean对象。


区别：


• ApplicationContext 是 BeanFactory 的子类，ApplicationContext 拥有更多的功能（对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持）


• Bean 的加载机制不同：ApplicationContext 是一次加载并初始化所有的Bean对象，而BeanFactory 是需要哪个才去加载哪个(懒加载)，因此更加轻量。

1.2  配置扫描路径

在spring-config.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"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--       <bean id="user" class="User"> </bean>-->
<!--       <bean id="people" class="demo.People"></bean>-->
<!--       配置bean的扫描根路径：只有当前目录下的类才会扫描是否添加了注解，如果添加了注解-->
       <content:component-scan base-package="demo"></content:component-scan>
</beans>

注意：想要将对象成功的存储到Spring 中，我们需要配置一下存储对象的扫描包路径，只有被配置的包下的所有类，添加了注解才能被正确的识别并保存到Spring中

二. 通过注解添加Bean对象

想要将对象存储在Spring中，有两种注解类型可以实现：

2.1 类注解：@Controller、@Service、@Repository、@Component、@Configuration

• @Controller【控制器】校验参数的合法性(安检系统），负责接口对接。


• @Service【业务】业务组装(客服中心)：会告诉我使用哪些方法，调用哪些接口，但是不具体实行。


• @Repository【数据持久层】实际业务处理（实际办理的业务）：即业务层调用的方法的具体实现，操作一些和数据库相关的信息。


• @Component【组件】 工具类层（基础的工具）：例如对账户加密，进行的业务不涉及数据库


• @Configuration 【配置层】配置：例如一些端口号

这五个类注解都可以使用
//@Controller
//@Service
//@Repository
//@Configuration
  @Component
public class People {
    public People(){
        System.out.println("People constructor");
    }
    public void sayHi(){
        System.out.println("hello world");
    }
}
 
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        People people=context.getBean("people",People.class);
        people.sayHi();
    }

Bean 生成名称源代码（此处是调用的jdk中的命名方法，并不是spring定义的，是Java定义的）

    public static String decapitalize(String name) {
        if (name == null || name.length() == 0) {
            return name;
        }
        //如果name长度大于1，并且前两个字符都是大写，返回name本身
        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
                        Character.isUpperCase(name.charAt(0))){
            return name;
        }
        char[] chars = name.toCharArray();
        //其他的都是将第一个大写字母改为小写
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }

类注解Bean命名规则：


• 默认情况下，当类名的前两个字母都是大写时，名字和类名相同；当类名的前两个字母只有第一个是大写时，则名字是类名首字母小写。


• 若通过value设置，那么只能通过设置的类名来获取


五大类注解之间的关系


查看@Controller/@Service/@Repository/@Configuration 源码发现：

其他的四个类都是基于@Component实现的

2.2  方法注解：@Bean

注意:@Bean 必须配合五大类注解一同使用,否则就会报错. (如果不使用五大类注解,spring就会扫描所有的类中的方法,会大大的降低效率).

public class ArticleInfo {
    private int id;
    private String title;
    private String Content;
    private LocalDateTime CreateTime;
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getTitle() {
        return title;
    }
 
    public void setTitle(String title) {
        this.title = title;
    }
 
    public String getContent() {
        return Content;
    }
 
    public void setContent(String content) {
        Content = content;
    }
 
    public LocalDateTime getCreateTime() {
        return CreateTime;
    }
 
    @Override
    public String  toString() {
        return "ArticleInfo{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", Content='" + Content + '\'' +
                ", CreateTime=" + CreateTime +
                '}';
    }
 
    public void setCreateTime(LocalDateTime createTime) {
        CreateTime = createTime;
    }
}
 
@Controller
public class Articles {
//    可以通过以下三种方式来命名,可以命名任意个名字,若命名后,默认命名(方法名)不能再使用
//    @Bean({"arti","article"})
//    @Bean(name = {"arti","article"})
    @Bean(value = {"arti","article"})
    public ArticleInfo art(){
        //伪代码(真实的代码中是不允许我们去new的,因为我们IoC的思想就是控制反转)
        ArticleInfo articleInfo=new ArticleInfo();
        articleInfo.setId(1);
        articleInfo.setTitle("西游记");
        articleInfo.setContent("大闹天空");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}
 
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
//      ArticleInfo articleInfo=context.getBean("article",ArticleInfo.class);
//      ArticleInfo articleInfo=context.getBean("arti",ArticleInfo.class);
        ArticleInfo articleInfo=context.getBean("art",ArticleInfo.class);
        System.out.println(articleInfo);
    }

• @Bean的默认获取方式:@Bean的默认命名=方法名

2.3 @Bean的加载顺序

2.3.1 名称相同

//此处的Order中的数字越大,权重越高,优先执行
@Order(100)
@Controller
public class Articles {
//    可以通过以下三种方式来命名,可以命名任意个名字,若命名后,默认命名不能再使用
//    @Bean({"arti","article"})
//    @Bean(name = {"arti","article"})
@Bean(value = {"arti","article"})
public ArticleInfo arti(){
    //伪代码(真实的代码中是不允许我们去new的,因为我们IoC的思想就是控制反转)
    ArticleInfo art=new ArticleInfo();
    art.setId(2);
    art.setTitle("三国演义");
    art.setContent("温酒斩华雄");
    art.setCreateTime(LocalDateTime.now());
    return art;
}
 
    @Bean(value = {"arti","article"})
    public ArticleInfo art(){
        //伪代码(真实的代码中是不允许我们去new的,因为我们IoC的思想就是控制反转)
        ArticleInfo art=new ArticleInfo();
        art.setId(1);
        art.setTitle("西游记");
        art.setContent("大闹天空");
        art.setCreateTime(LocalDateTime.now());
        return art;
    }
}
 
@Order(18)
@Component
public class Articles2 {
    @Bean(value = {"arti","article"})
    public ArticleInfo arti(){
        //伪代码(真实的代码中是不允许我们去new的,因为我们IoC的思想就是控制反转)
        ArticleInfo art=new ArticleInfo();
        art.setId(3);
        art.setTitle("红楼梦");
        art.setContent("我也不知道");
        art.setCreateTime(LocalDateTime.now());
        return art;
    }
}

在同一个类中,返回同名的相同类型的方法 Bean 时, 按照前后顺序执行


如果一个类的多个Bean使用相同的名称,那么程序执行不会报错,但是第一个Bean之后的对象不会放到容器中,也就是只有第一次创建Bean的时候会将对称的Bean 名称关联起来,后续再有相同名称Bean,容器会自动忽略


2.3.2 名称不同

对于同种类型的Bean,而名称不同时,仍可注入到容器中

三. 获取Bean 对象

对于之前我们获取 Bean 对象的方法,是通过依赖查找的方法,先获取上下文对象(容器对象)context,然后在通过getBean来获取对象的实例.对此,似乎还没有直接new来的快.因此我们还可以通过对象(依赖)注入的方式来获取对象的实例.

3.1 属性注入

@Repository
public class UserResposity {
    private int num;
    public int add(){
        System.out.println("Do UserResposity method");
        return num;
    }
}
 
@Service
public class UserService {
 
    @Autowired
    UserResposity userResposity;
 
    public int add(){
        System.out.println("Do UserService method.");
        return userResposity.add();
    }
}
 
//使用测试验证对象是否被注入
class UserServiceTest {
    @Test
    public void test1(){
        //此处只是为了验证UserService中的UserResposity是否被注入了对象
        ApplicationContext context= new ClassPathXmlApplicationContext("spring-config.xml");
        UserService userService=context.getBean("userService",UserService.class);
        userService.add();
    }
}

上述代码该类型的对象在spring容器中只有一个,那若有多个呢?

public class User {
    private String name;
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Users{" +
                "name='" + name + '\'' +
                '}';
    }
}
 
@Component
public class Users {
    @Bean("user1")
    public User user1(){
        User user=new User();
        user.setName("张三");
        return user;
    }
 
    @Bean("user2")
    public User user2(){
        User user=new User();
        user.setName("李四");
        return user;
    }
 
}
 
@Service
public class UserService2 {
    @Autowired
    User user;
    public void sayHi(){
        System.out.println(user.toString());
    }
}
 
class UserService2Test {
    @Test
    public void test(){
        ApplicationContext context= new ClassPathXmlApplicationContext("spring-config.xml");
        UserService2 userService2=context.getBean("userService2",UserService2.class);
        userService2.sayHi();
    }
}
 
//available: expected single matching bean but found 2: user1,user2

依赖注入 vs 依赖查找


• 依赖查找依赖Bean的名称


• @Autowried 依赖注入流程:首先先根据 getType (从spring容器)获取对象,如果只获取一个,那么直接将此对象 注入到当前属性中;如果获取到多个对象,才会使用getName(根据名称)进行匹配。


此时我们发现会报错,因为找到了两个该类型的对象。此时我们可以通过以下几种方法解决：• 将属性名成改为Bean 储存在spring容器中对应的名称

    @Autowired
    User user2;
    User user1;

使用注解  @Qualifier

1. @Autowired
2. @Qualifier("user2")
3.     User user;

优点：使用简单

缺点：

• 无法注入final 修饰的属性

• 只适用于IoC容器

3.2 Setter 注入

@Service
public class SetterUserService {
    private UserResposity userResposity;
    @Autowired
    public void setRepository(UserResposity repository){
        this.userResposity=repository;
    }
    public void sayHi(){
        userResposity.add();
    }
}
 
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        SetterUserService service = context.getBean("setterUserService", SetterUserService.class);
        service.sayHi();
    }

优点：通常Setter只Set一个属性，所以Setter注入更符合单一设计原则

缺点：

• 无法注入一个final 修饰的变量

• setter 注入的对象可以被修改，setter 本来就是一个方法，既然是一个方法，就有可能被多次调用和修改。

3.3 构造方法注入

@Service
public class ConstructorService {
    //可以注入final修饰的属性
    private final UserResposity userResposity;
//    private UserResposity userResposity;
    //如果当前类中只存在一个构造方法时，@Autowired可以省略
    @Autowired
    //若容器中有多个UserResposity时，可以通过参数列表中的变量名改为容器中对应的名字
    public ConstructorService(UserResposity userResposity) {
        this.userResposity = userResposity;
    }
    public void sayHi(){
        userResposity.add();
    }
 
}
 
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        ConstructorService service = context.getBean("constructorService", ConstructorService.class);
        service.sayHi();
    }

优点：

• 可以注入一个final 修饰的变量

• 注入的对象不会被改变（构造方法只调用一次）

• 构造方法可以保证注入对象完全初始化

• 通用性更好（不依赖IoC)

四. @Resource

@Service
public class UserService2 {
    @Resource(name = "user2")
    User user;
    public void sayHi(){
        System.out.println(user.toString());
    }
}
 
class UserService2Test {
    @Test
    public void test(){
        ApplicationContext context= new ClassPathXmlApplicationContext("spring-config.xml");
        UserService2 userService2=context.getBean("userService2",UserService2.class);
        userService2.sayHi();
    }
}

@Autowried与@Resource 的区别:


• 出身不同：@Resource 来自于JKD；@Autowired来自于Spring


• 支持参数不同：@Resource 支持的参数有很多，@Autowired只支持一个参数


• 使用上不同：@Resource 不支持构造方法注入；而@Autowired 支持


• idea 兼容性支持不同：使用@Atowired 在idea 专业版下可能误报（required 设置为false表示该属性可不被注入，可以通过设置为false来解决）

五. Bean 作用域

案例：

@Service
public class ScopeService1 {
    @Resource(name = "user1")
    private User user;
    @Resource(name = "user1")
    private User user2;
    public void print(){
        user.setId(222);
        user2.setId(333);
        System.out.println("user1:"+user.toString());
        System.out.println("user2:"+user2.toString());
    }
}
 
    @Test
    public void Test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        ScopeService1 service1=context.getBean("scopeService1",ScopeService1.class);
        service1.print();
    }

我们想要两个user属性有不同的id,但是设置完后发现两个user的id相同。


原因分析：操作以上问题的原因是因为Bean 默认情况下是单例状态，也就是所有人使用的都是同一个对象。单例模式可以很大程度上提高性能，所以在Spring中Bean的作用域默认也是 singleton单例模式

解决方案：在bean对象放入Spring 容器中时，指定作用域

    @Bean("user1")
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public User user1(){
        User user=new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }

5.1 作用域定义

Bean 的作用域是指 Bean 在 Spring 整个框架中的某种行为模式，比如 singleton 单例作用域，就表示 Bean 在整个 Spring 中只有一份，它是全局共享的，那么当其他人修改了这个值之后，那么另一个人读取到的就是被修改的值。

5.2 Bean 的6 中作用域

sigleton


• 描述：该作用域下的Bean在IoC 中只存在一个实例：获取Bean及装配Bean都是同一个对象


• 场景：通常无状态的Bean使用该作用域。无状态表示Bean对象的属性不需要更新


• 备注：Spring 默认选择该作用域

prototype

• 描述：每次对该作用域下的Bean 的请求都会创建新的实例：获取Bean及装配Bean都是新的对象

• 场景：通常有状态的Bean使用该作用域

request

描述：每次 http 请求都会创建新的Bean实例，类似于prototype

场景：一次 http 请求和响应的共享Bean

备注：限定 SpringMVC 中使用

session

描述：在一个 http session 中定义一个Bean实例

场景：用户会话的共享Bean,比如：记录一个用户的登录信息

备注：限定SpringMVC中使用

application

描述：在一个 http servlet Context 中，定义一个Bean实例

场景：Web 应用的上下文信息，比如：记录一个应用的共享信息

备注：限定在SpringMVC中使用

websocket


描述：在一个http websocket 的生命周期中，定义一个Bean实例


场景：WebSocket 的每次会话中，保存了一个Map 结构的头信息，将用来包裹客户端消息头。第一次初始化后，直到 WebSocket 结束都是同一个Bean


备注：限定Spring WebSocket 中使用

六. Spring 执行流程和 Bean 的生命周期

6.1 Spring 的执行流程

Spring 生命周期:

• 启动容器

• 读取配置进行 Bean 初始化

• 将 Bean 加入到容器中

• 装配 Bean 属性(给当前类的属性ID进行注入)

6.2 Bean 的生命周期

1. 实例化(内存空间分配)

2. 设置Bean 属性 (进行依赖注入,将依赖的Bean 赋值到当前类的属性上)

3. Bean的初始化

• 实现了各种 Aware 通知的方法,如 BeanNameAware、BeanFactoryAware、ApplicationContextAware 的接口方法；


• 执行 BeanPostProcessor初始化的前置方法


• 执行 @PostConsturct 初始化方法，依赖注入操作之后被执行


• 执行 BeanPostProcessor 初始化后置方法


@Component
public class BeanLifeComponent implements BeanNameAware {
 
    @Override
    public void setBeanName(String name) {
        System.out.println("执行了 setBeanName 方法："+name);
    }
//  初始化方法
    @PostConstruct
    public void postConsturct(){
        System.out.println("执行了 postConsturct 方法");
    }
    //这个方法是和初始化方法一样的，只是这里需要在xml文件中声明
    public void myInit(){
        System.out.println("执行了 myInit 方法");
    }
 
    public void use(){
        System.out.println("使用Bean");
    }
 
    @PreDestroy
    public void preDestroy(){
        System.out.println("执行了 preDestroy 方法");
    }
}
 
 
public static void main(String[] args) {
        //这里不要使用ApplicationContext，因为它没有close方法
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent beanLife=context.getBean("myBean",BeanLifeComponent.class);
        //使用Bean
        beanLife.use();
        //此时的上下文对象若不关闭，是不会执行 preDestroy 方法的
        context.close();
}

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"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
       <!--这里的init-method 的名字和我们代码中初始化方法名字要一致-->
       <bean id="myBean" class="BeanLifeComponent" init-method="myInit"></bean>
</beans>

4. 使用Bean

5. 销毁Bean

销毁容器的各种方法，如@PreDestroy、DisposableBean 接口方法、destroy-method。

思考：为什么要先设置属性在进行初始化呢

因为我的初始化方法在执行的过程中可能会用到我这个类中的某个属性，如果我不先进行属性的赋值，那么在执行到使用属性的这行代码时一定会报错

文章标签：
Java
Spring
容器
存储
数据库
关键词：
Spring生命周期
Spring Bean
Spring对象
spring Bean生命周期
Spring作用域
游客jajxe3foty4uc
目录
相关文章
Pseudocode
|
10天前
|
前端开发 Java Spring
Spring MVC 是如何对对象参数进行校验的
【6月更文挑战第4天】对象参数校验是使用 SpringMVC 时常用的功能，这篇文章尝试分析了，Spring 是如何实现这一功能的。
Pseudocode
24 5
Pseudocode
|
6天前
|
Java Spring
解决 Spring 中 Prototype Bean 注入后被固定的问题
【6月更文挑战第8天】学习 Spring 框架内不原理的意义就是，当遇到问题时，分析出原因，就可以从多个切入点，利用 Spring 的特性，来解决问题。
Pseudocode
19 2
Pseudocode
|
8天前
|
JSON 前端开发 Java
Spring MVC 级联对象参数校验
【6月更文挑战第6天】在 Spring MVC 的使用过程中，我们会发现很多非常符合直觉的功能特性，但往往我们会习惯这种「被照顾得很好」的开发方式，依靠直觉去判断很多功能特性的用法。
Pseudocode
14 1
算精通
|
16天前
|
Java Spring 缓存
Spring Bean循环依赖详解
【6月更文挑战第2天】
算精通
22 2
风水道人
|
1月前
|
Java 应用服务中间件 Maven
SpringBoot 项目瘦身指南
SpringBoot 项目瘦身指南
风水道人
78 0
zhishijike
|
1月前
|
缓存 安全 Java
Spring Boot 面试题及答案整理，最新面试题
Spring Boot 面试题及答案整理，最新面试题
zhishijike
168 0
风水道人
|
1月前
|
存储 JSON Java
SpringBoot集成AOP实现每个接口请求参数和返回参数并记录每个接口请求时间
SpringBoot集成AOP实现每个接口请求参数和返回参数并记录每个接口请求时间
风水道人
66 2
图灵重生我名苏泽
|
1月前
|
前端开发 搜索推荐 Java
【Spring底层原理高级进阶】基于Spring Boot和Spring WebFlux的实时推荐系统的核心：响应式编程与 WebFlux 的颠覆性变革
【Spring底层原理高级进阶】基于Spring Boot和Spring WebFlux的实时推荐系统的核心：响应式编程与 WebFlux 的颠覆性变革
图灵重生我名苏泽
80 0
程序三两行
|
1月前
|
前端开发 Java 应用服务中间件
Springboot对MVC、tomcat扩展配置
Springboot对MVC、tomcat扩展配置
程序三两行
25 0
JavaPub
|
4天前
|
Java Linux Shell
docker 打包 springboot 项目快速入门
docker 打包 springboot 项目快速入门
JavaPub
13 0

热门文章

最新文章

  • 1
    SpringMVC注解@RequestParam全面解析
  • 2
    (十) Spring Cloud构建分布式微服务架构 - SSO单点登录之OAuth2.0登录认证(1)
  • 3
    SpringCloud Alibaba
  • 4
    Spring Boot 集成 MyBatis和 SQL Server实践
  • 5
    Spring 5 启动性能优化之 @Indexed
  • 6
    Spring_学习_00_资源帖
  • 7
    spring-cloud-kubernetes自动同步k8s的configmap更新
  • 8
    Spring4-HelloWorld
  • 9
    Spring MVC 数据绑定（四）
  • 10
    如何让spring mvc web应用启动时就执行特定处理
  • 1
    Spring的设计哲学--来自官方
    25
  • 2
    nacos常见问题之dubbo+nacos+springboot3的native打包成功后运行出现异常如何解决
    77
  • 3
    Spring Boot从入门到实战
    25
  • 4
    spring boot 参数的过滤注解与实战
    55
  • 5
    挺详细的spring+springmvc+mybatis配置整合|含源代码
    229
  • 6
    Spring5深入浅出篇:Spring配置⽂件参数化
    26
  • 7
    Spring Cloud Alibaba 面试题及答案整理，最新面试题
    319
  • 8
    Spring Cloud 面试题及答案整理，最新面试题
    166
  • 9
    Spring Boot 面试题及答案整理，最新面试题
    168
  • 10
    Spring MVC 面试题及答案整理，最新面试题
    116

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第三阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 对象和接口-2：常见用法
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考