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

【Spring框架三】——Spirng IOC和DI的实现

2023-07-28 88
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【Spring框架三】——Spirng IOC和DI的实现

系列文章目录

【Spring框架一】——Spring框架简介

Spirng IOC和DI的实现


前言

本篇博客主要总结的是以Spring 5为例，通过XML方式和注解的方式分别实现IOC和DI。并使用Spring5 进行基础运用。

一、IDEA新建Spring 项目

  1. 创建Maven项目：使用IDE创建一个maven项目
  2. 添加Spring依赖：在Maven配置文件pom.xml中添加Spring框架的依赖项
<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.8</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.8</version>
  </dependency>
</dependencies>
  1. 这样Spring的基础环境已经搭建完毕
    项目的主体结构为三层结构，层与层之间通过接口进行隔离

二、使用XML文件的方式实现IOC和DI

实现依赖注入的方式常用的有构造函数注入、setter方法注入

1.创建XML文件

在resources目录下创建applicationContext.xml文件，之后需要在xml文件中配置组件（指Spring容器中的管理的对象）和依赖关系

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="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
          http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

2. 通过构造函数的方式进行注入

IXMLUserDaoImpl类

package com.wangwei.springioc.dao.daoImpl;
import com.wangwei.springioc.dao.IXMLUserDao;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : UserDaoImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:04]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:04]
 * @updateRemark : [描述说明本次修改内容]
 */
public class IXMLUserDaoImpl implements IXMLUserDao {
    @Override
    public void addUser(String username, String password) {
        System.out.println("IUserDaoImpl.addUser()"+username+password);
    }
}

IXMLUserDao接口

package com.wangwei.springioc.dao;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : UserDao
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:04]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:04]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IXMLUserDao {
    void addUser(String username, String password);
}

XMLUserManagerImpl类

package com.wangwei.springioc.manager.managerImpl;
import com.wangwei.springioc.dao.IXMLUserDao;
import com.wangwei.springioc.manager.IXMLUserManager;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : UserManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
public class XMLUserManagerImpl implements IXMLUserManager {
       //构造函数注入
    private  IXMLUserDao ixmlUserDao;
    public XMLUserManagerImpl(IXMLUserDao ixmlUserDao) {
        this.ixmlUserDao=ixmlUserDao;
    }
    @Override
    public void addUser(String name, String password) {
        ixmlUserDao.addUser(name,password);
    }
}

IXMLUserManager接口

package com.wangwei.springioc.manager;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : IUserManager
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:02]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:02]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IXMLUserManager {
    void addUser(String name ,String password);
}

在xml文件中配置通过构造函数的方式进行注入

由于在XMLUserManagerImpl类中通过接口依赖到了IXMLUserDaoImpl类，所以需要在xml配置其依赖关系。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="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
          http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="userDao" class="com.wangwei.springioc.dao.daoImpl.IXMLUserDaoImpl"/>
    <bean id="userManager" class="com.wangwei.springioc.manager.managerImpl.XMLUserManagerImpl">
        <!--构造函数注入-->
        <constructor-arg ref="userDao"/>
     </bean>
</beans>

XMLClient类进行调用

package com.wangwei.springioc.client;
import com.wangwei.springioc.manager.IXMLUserManager;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : Client
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:11]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:11]
 * @updateRemark : [描述说明本次修改内容]
 */
public class XMLClient {
    public static void main(String[] args) {
    //通过Spring的XML配置文件创建了一个IOC容器，并读取文件中的定义，创建相应的Bean对象并将它们放到IOC容器中
        BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取名为userManager的Bean对象
        IXMLUserManager IXMLUserManager =(IXMLUserManager) factory.getBean("userManager");
        IXMLUserManager.addUser("wangwei","123");
    }
}

运行结果

3.setter方法进行注入

  1. 需要在依赖方，创建对应的setter方法
    //setter方式注入
    private IXMLUserDao ixmlUserDao;
    public void setIxmlUserDao(IXMLUserDaoImpl ixmlUserDao) {
        this.ixmlUserDao=ixmlUserDao;
    }
  1. xml文件中进行配置
<bean id="userDao" class="com.wangwei.springioc.dao.daoImpl.IXMLUserDaoImpl"/>
    <bean id="userManager" class="com.wangwei.springioc.manager.managerImpl.XMLUserManagerImpl">
        <!--setter方法注入-->
        <property name="ixmlUserDao" ref="userDao"/>
     </bean>

三、使用注解的方式实现IOC和DI

Spring 5中的常用注解

@Component

@Component是Spring框架中最基本的注解之一，它的作用是将Java类定义为一个Bean，并在程序启动的时候告诉Spring这个类需要被Spring 管理。


@Service

@Service用于标记一个类为服务类（Service class），通常是指该类用于处理业务逻辑的类。并在程序启动的时候告诉Spring这个类需要被Spring 管理。


@Repository

用于将数据访问层 (DAO) 类标记为 Spring Bean，并为其提供 Spring 特定的异常转换。在程序启动的时候告诉Spring这个类需要被Spring 管理。


@Autowired

它可以自动地为我们进行依赖注入。当一个类中有一个属性需要依赖注入时，我们可以在这个属性上面使用@Autowired注解，而在程序启动的时候Spring框架会自动找到这个属性对应的Bean，并将其注入到类中。

@Autowired注解可以用在属性、构造方法、和方法上。如果被注入的类有多个实现，可以使用@Qualifier注解来指定具体注入哪个实现。


@Bean

用于在配置类中定义一个Bean，@Bean 注解只有在 Spring 配置类中才会生效。

@Bean注解可以用在一个方法上，该方法可以创建一个对象并返回该对象的实例。这个对象会被Spring容器管理并可以被其他对象注入。

使用@Bean注解时，可以将其放置在一个类的任意方法上（通常是@Configuration注解的类中），方法返回的对象实例可以被Spring容器进行管理。在程序启动的时候告诉Spring这个类需要被Spring 管理。


@Configuration

用于标记类为配置类。在 Spring 中，配置类是一种特殊的类，用于配置应用程序上下文中的 bean。使用 @Configuration 注解的类可以包含 @Bean 注解，用于声明 bean 定义。这些 bean 可以是被 Spring 托管的任何类型。在程序启动的时候告诉Spring这个类需要被Spring 管理。


示例代码：

@Configuration
public class AppConfig {
    @Bean
    public PaymentService paymentService() {
        return new NewClassB();
    }
}

@ComponentScan

用于扫描和注册组件（包括 @Component、@Service、@Controller、@Repository 等注解修饰的类）

通过使用 @ComponentScan 注解，Spring 将会在指定的包或类中扫描组件（在 Spring 应用程序中，组件通常是指 Spring 管理的对象），然后将其实例化、初始化并将其添加到 Spring 的应用程序上下文中，以便在整个应用程序中可以使用这些组件。

@ComponentScan的常用属性：

basePackages：指定要扫描的包，可以指定多个包；

basePackageClasses：指定要扫描的类，可以指定多个类；

excludeFilters：指要排除的组件，可以使用正则表达式、类型过滤器等方式进行排除；

需要注意的是，使用 @ComponentScan 注解需要在 Spring 配置类上添加该注解，如：

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // ...
}

使用注解方式实现构造函数注入

先创建各层的类

IAnnotateDao接口

package com.wangwei.springioc.dao;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : IAnnotateDao
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 8:58]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 8:58]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IAnnotateDao {
    void addUser(String username, String password);
}

AnnotateUserDaoImpl类

package com.wangwei.springioc.dao.daoImpl;
import com.wangwei.springioc.dao.IAnnotateDao;
import org.springframework.stereotype.Repository;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateUserDaoImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 8:59]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 8:59]
 * @updateRemark : [描述说明本次修改内容]
 */
@Repository
public class AnnotateUserDaoImpl implements IAnnotateDao {
    @Override
    public void addUser(String username, String password) {
        System.out.println("IUserDaoImpl.addUser()"+username+password);
    }
}

IAnnotateManager接口

package com.wangwei.springioc.manager;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : IAnnotateManager
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IAnnotateManager {
    void addUser(String name ,String password);
}

AnnotateManagerImpl类

成员变量被声明为 final，这是为了避免在类的其他地方意外地修改它的引用，保证其只能在构造函数中被初始化，并且在对象创建后不会再被更改。

package com.wangwei.springioc.manager.managerImpl;
import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {
    //构造函数注入
    private final IAnnotateDao iAnnotateDao;
    @Autowired
    public AnnotateManagerImpl(IAnnotateDao iAnnotateDao) {
        this.iAnnotateDao = iAnnotateDao;
    }
    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }
}

AnnotateClient类

程序启动类

package com.wangwei.springioc.client;
import com.wangwei.springioc.manager.IAnnotateManager;
import com.wangwei.springioc.manager.managerImpl.AnnotateManagerImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateClient
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 8:56]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 8:56]
 * @updateRemark : [描述说明本次修改内容]
 */
//使用@Configuration注解来告诉Spring这是一个配置类,并将其放入到ioc容器中
@Configuration
//@ComponentScan注解来指定要扫描的包路径，@ComponentScan注解会告诉Spring去哪里查找组件，它会扫描指定的包及其子包，查找使用了特定注解的类，并将它们注册为Spring的bean。
@ComponentScan(basePackages = "com.wangwei.springioc")
public class AnnotateClient {
    public static void main(String[] args) {
            //我们使用AnnotationConfigApplicationContext来加载配置类，使用MyAppApplication.class作为配置类，即告诉Spring使用MyAppApplication这个类中的注解来构建应用程序上下文
            ApplicationContext context = new AnnotationConfigApplicationContext(AnnotateClient.class);
            //使用context对象来获取我们的bean并进行依赖注入和使用。
            IAnnotateManager iAnnotateManager = context.getBean(AnnotateManagerImpl.class);
            iAnnotateManager.addUser("wangwei","123");
    }
}

运行结果

使用注解方式实现Setter方式注入

AnnotateManagerImpl类

package com.wangwei.springioc.manager.managerImpl;
import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {
  //Setter方式进行注入
    private  IAnnotateDao iAnnotateDao;
    @Autowired
    public void setiAnnotateDao(IAnnotateDao iAnnotateDao) {
        this.iAnnotateDao = iAnnotateDao;
    }
    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }
}

运行效果

使用注解方式实现字段方式注入

package com.wangwei.springioc.manager.managerImpl;
import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {
    @Autowired
    private IAnnotateDao iAnnotateDao;
    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }
}

运行效果

使用注解方式实现通过方法注入

AnnotateManagerImpl类

package com.wangwei.springioc.manager.managerImpl;
import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {
    private IAnnotateDao iAnnotateDao;
    @Autowired
    public void anotateIAnnotateDao(IAnnotateDao iAnnotateDao){
        this.iAnnotateDao=iAnnotateDao;
    }
    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }
}

运行结果

每种注入方式的优缺点

构造函数注入的优缺点

优点：

  1. 对象的完整性：通过构造函数注入，可以保证在创建对象时所需要的所有依赖都被满足，从而确保对象的完整性。
  2. 对象不可变：通过构造函数注入，可以将依赖关系作为对象的不可变属性，防止意外修改对象依赖。

缺点：

  1. 冗长：需要编写额外的构造函数，增加代码量。
  2. 限制：在对象创建后无法更改依赖关系。

Setter方法注入的优缺点

优点：

  1. 灵活：可以在任何时候更改依赖关系，不受对象创建时依赖关系的限制。
  2. 可选性：某些依赖关系不是必需的，可以使用setter方法注入来提供可选依赖项。

缺点：

  1. 对象可变性：setter方法注入会使对象变得可变，因为依赖关系可以随时更改。
  2. 不够显式：相对于构造函数注入，setter方法注入可能导致依赖关系不够显式和清晰。

字段注入的优缺点

优点：

  1. 简单方便：字段注入是一种简单方便的依赖注入方式，无需编写额外的代码。
  2. 可选性：某些依赖关系不是必需的，可以使用字段注入来提供可选依赖项。

缺点：

  1. 对象可变性：字段注入会使对象变得可变，因为依赖关系可以随时更改。
  2. 不够显式：相对于构造函数注入，字段注入可能导致依赖关系不够显式和清晰。

方法注入的优缺点

优点：

  1. 灵活性：方法注入可以在任何时候更改依赖关系，不受对象创建时依赖关系的限制。

缺点：

  1. 冗长：需要编写额外的方法，增加代码量。

四、总结

  1. XML和注解实现的IOC和DI是两种不同的方式，它们都可以用于管理应用程序中的组件和依赖关系。
  2. 在实际开发中，通常使用注解来代替XML，这是因为注解更加方便、简洁和易于维护，而且可以让开发者更加专注于业务逻辑的实现。
  3. 相比之下，XML需要编写更多的代码，需要手动配置依赖关系，维护起来相对麻烦一些。不过，使用XML的好处是可以更加灵活地配置和管理应用程序，可以在不修改代码的情况下改变应用程序的行为。

总的来说，使用注解可以使开发更加高效，使用XML可以使配置更加灵活，具体使用哪种方式取决于项目的需求和开发者的偏好。

文章标签：
Java
开发工具
容器
Spring
IDE
Maven
数据格式
开发者
XML
关键词：
Spring IOC
Spring框架
spring IOC DI
Spring DI
Spring框架ioc
王卫
目录
相关文章
Cyan_RA9
|
14天前
|
XML Java 测试技术
Spring IOC—基于注解配置和管理Bean 万字详解（通俗易懂）
Spring 第三节 IOC——基于注解配置和管理Bean 万字详解！
Cyan_RA9
95 26
SheepRunner
|
2月前
|
XML Java 数据格式
【SpringFramework】Spring IoC-基于XML的实现
本文主要讲解SpringFramework中IoC和DI相关概念，及基于XML的实现方式。
SheepRunner
116 69
蓝易云
|
17天前
|
SQL Java 数据库连接
对Spring、SpringMVC、MyBatis框架的介绍与解释
Spring 框架提供了全面的基础设施支持，Spring MVC 专注于 Web 层的开发，而 MyBatis 则是一个高效的持久层框架。这三个框架结合使用，可以显著提升 Java 企业级应用的开发效率和质量。通过理解它们的核心特性和使用方法，开发者可以更好地构建和维护复杂的应用程序。
蓝易云
106 29
心疼你的一切
|
6天前
|
XML Java 开发者
通过springboot框架创建对象（一）
在Spring Boot中，对象创建依赖于Spring框架的核心特性——控制反转（IoC）和依赖注入（DI）。IoC将对象的创建和管理交由Spring应用上下文负责，开发者只需定义依赖关系。DI通过构造函数、setter方法或字段注入实现依赖对象的传递。Spring Boot的自动配置机制基于类路径和配置文件，自动为应用程序配置Spring容器，简化开发过程。Bean的生命周期包括定义扫描、实例化、依赖注入、初始化和销毁回调，均由Spring容器管理。这些特性提高了开发效率并简化了代码维护。
心疼你的一切
29 5
智物科技库
|
1月前
|
开发框架 运维 监控
Spring Boot中的日志框架选择
在Spring Boot开发中，日志管理至关重要。常见的日志框架有Logback、Log4j2、Java Util Logging和Slf4j。选择合适的日志框架需考虑性能、灵活性、社区支持及集成配置。本文以Logback为例，演示了如何记录不同级别的日志消息，并强调合理配置日志框架对提升系统可靠性和开发效率的重要性。
智物科技库
45 5
SheepRunner
|
2月前
|
Java Spring 容器
【SpringFramework】Spring IoC-基于注解的实现
本文主要记录基于Spring注解实现IoC容器和DI相关知识。
SheepRunner
60 21
蓝易云
|
2月前
|
Java 开发者 Spring
理解和解决Spring框架中的事务自调用问题
事务自调用问题是由于 Spring AOP 代理机制引起的，当方法在同一个类内部自调用时，事务注解将失效。通过使用代理对象调用、将事务逻辑分离到不同类中或使用 AspectJ 模式，可以有效解决这一问题。理解和解决这一问题，对于保证 Spring 应用中的事务管理正确性至关重要。掌握这些技巧，可以提高开发效率和代码的健壮性。
蓝易云
127 13
三三是该溜子
|
2月前
|
存储 Java 应用服务中间件
【Spring】IoC和DI，控制反转，Bean对象的获取方式
IoC，DI，控制反转容器，Bean的基本常识，类注解@Controller，获取Bean对象的常用三种方式
三三是该溜子
65 12
Love-Java.
|
Java Spring
spring框架之AOP模块(面向切面)，附带通知类型---超详细介绍
spring框架之AOP模块(面向切面)，附带通知类型---超详细介绍
Love-Java.
152 0
Java_文昊
|
缓存 监控 Java
Spring框架之AOP（面向切面编程）
Spring框架之AOP（面向切面编程）
Java_文昊
70 0

热门文章

最新文章

  • 1
    Spring Boot 两种部署到服务器的方式
  • 2
    SpringBoot缓存注解使用
  • 3
    2025春招，Spring 面试题汇总
  • 4
    AI 时代：从 Spring Cloud Alibaba 到 Spring AI Alibaba
  • 5
    对Spring、SpringMVC、MyBatis框架的介绍与解释
  • 6
    Spring之定时任务基本使用篇
  • 7
    SpringBoot 通过集成 Flink CDC 来实时追踪 MySql 数据变动
  • 8
    Spring IOC—基于注解配置和管理Bean 万字详解（通俗易懂）
  • 9
    Spring Boot中的WebFlux编程模型
  • 10
    Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）
  • 1
    Spring容器的本质
    28
  • 2
    编写SpringBoot的自定义starter包
    32
  • 3
    SpringBoot：SpringBoot通过注解监测Controller接口
    33
  • 4
    Spring Cloud是什么及基本特性都有哪些？
    33
  • 5
    spring boot 启动流程
    50
  • 6
    通过springboot框架创建对象（一）
    29
  • 7
    java spring 项目若依框架启动失败，启动不了服务提示端口8080占用escription: Web server failed to start. Port 8080 was already in use. Action: Identify and stop the process that’s listening on port 8080 or configure this application to listen on another port-优雅草卓伊凡解决方案
    29
  • 8
    智慧工地云平台的技术架构解析：微服务+Spring Cloud如何支撑海量数据？
    41
  • 9
    SpringBoot 通过集成 Flink CDC 来实时追踪 MySql 数据变动
    104
  • 10
    Spring 手动实现Spring底层机制
    63

    • 相关课程

    更多
  • 全面讲解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仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    PAI Model Gallery 支持云上一键部署 DeepSeek-V3、DeepSeek-R1 系列模型