springboot01

已于 2025-05-15 09:15:19 修改
阅读量881 收藏 26
点赞数 13
CC 4.0 BY-SA版权
文章标签： java 开发语言 spring spring boot
于 2025-05-14 20:40:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang_xiao_wu_/article/details/147959493

目录

一、spring核心

spring全家桶

spring三大思想

spring两大思想

二、IOC

2.1 IOC概念

2.2 IOC容器初始化方式

2.3 类关系

2.4 IOC控制反转思想

三、搭建spring环境

四、创建容器的两种方式

4.1通过类创建

4.2通过配置文件创建

五、容器内部创建对象

5.1配置类创建对象

5.2配置文件模式创建对象

5.3构造方法

5.4工厂方法

六、获取对象的过程

七、对象的生命周期

7.1对象创建

7.2对象销毁

八、Bean的作用域

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

面试题

1.spring的三大核心思想

2.IOC思想的理解

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

4.创建对象的注解

5.底层如何创建对象

6.对象何时创建、何时销毁、能否延迟创建

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

8.bean的作用域范围

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

一、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

spring两大思想

IOC|DI、AOP

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

核心描述
IOCInversion of Control 的简写，译为"控制反转"，指把创建对象过程交给 Spring 进行管理。
AOPAspect Oriented Programming 的简写，译为"面向切面编程"。AOP 用来封装多个类的公共行为，将那些与业务无关、却为业务模块所共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP 还解决一些系统层面上的问题，比如日志、事务、权限等。

二、IOC

2.1 IOC概念

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

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

2.2 IOC容器初始化方式

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

2.3 类关系

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

2.4 IOC控制反转思想

IOC（控制反转）是 Spring 框架的核心思想，其本质是将对象的创建、依赖装配和生命周期管理从应用程序代码转移到容器中完成。

inverse of control 

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

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

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

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

1、创建容器

2、将对象放到容器中

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

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

三、搭建spring环境

字不重要，看图

 

 

四、创建容器的两种方式

4.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 即为容器对象

    }
}

4.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="类的全限定名"
       同一个容器中，对象名不能重复
       单例模式：一个类只有一个实例（对象） 默认 scope="singleton"
       多例模式：一个类有多个实例对象   scope="prototype"
       spring-web 环境 接受前端请求
                 request:一次request请求创建一个对象
                 session:一个会话共享一个对象
                 global-session:全局有效-->
    <bean id="u1" class="com.hl.springboot01.pojo.User" scope="prototype"></bean>
</beans>
@Test
    public void createContainer2(){
        //读取配置文件，创建ioc容器
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = context.getBean(User.class);
        User user2 = context.getBean(User.class);
        System.out.println(user1);
        System.out.println(user2);
        //只要不报空指针异常，就证明从容器中获取了对象
//        System.out.println(user.toString());
    }

五、容器内部创建对象

5.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 {
}

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

5.3构造方法

5.4工厂方法

六、获取对象的过程

package com.hl.springboot01;

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

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");
        User user1 = context.getBean(User.class);
        User user2 = context.getBean(User.class);
        System.out.println(user1);
        System.out.println(user2);
        //只要不报空指针异常，就证明从容器中获取了对象
//        System.out.println(user.toString());
    }
}

七、对象的生命周期

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

7.1对象创建

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

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

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

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

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

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

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

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

7.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的作用域

作用域说明
singleton默认作用域，每个 IoC 容器中仅存在一个共享实例
prototype每次请求（getBean() 或注入）都创建新实例
request每个 HTTP 请求创建一个实例（Web 环境）
session每个 HTTP 会话共享一个实例（Web 环境）
<!--
    创建一个对象
    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>

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

// 方式一： 推荐  名称+类型
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思想的理解

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

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

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

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

 

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

4.创建对象的注解

@Component 类上使用  告诉 Spring：这个类是一个组件，帮我创建它的对象并管理！

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

 告诉 Spring：调用这个方法，把返回的对象放进容器！

5.底层如何创建对象

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

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

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

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

6.对象何时创建、何时销毁、能否延迟创建

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

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

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

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

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

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

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

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

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

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

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

// 方式一： 推荐  名称+类型
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);

8.bean的作用域范围

作用域说明
singleton默认作用域，每个 IoC 容器中仅存在一个共享实例
prototype每次请求（getBean() 或注入）都创建新实例
request每个 HTTP 请求创建一个实例（Web 环境）
session每个 HTTP 会话共享一个实例（Web 环境）

<!--
    创建一个对象
    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>

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

容器配置注解

注解作用示例
@Configuration标记该类为 配置类（相当于 XML 配置文件）java @Configuration public class AppConfig { ... }
@ComponentScan指定 Spring 扫描哪些包下的组件（@Component、@Service 等）java @ComponentScan("com.example")

对象创建与管理

注解作用示例
@Component通用注解，标记类为 Spring 管理的 组件（@Service/@Repository 的父注解）java @Component public class UserService { ... }
@Bean在配置类中定义方法，返回的对象由 Spring 管理（用于 第三方库的类）java @Bean public DataSource dataSource() { ... }
@Lazy延迟初始化（第一次使用时才创建对象）java @Lazy @Component public class HeavyService { ... }
@Scope指定 Bean 的作用域（singleton、prototype、request 等）java @Scope("prototype") @Component public class Task { ... }

生命周期回调

注解作用示例
@PostConstruct初始化方法（相当于 init-method）java @PostConstruct public void init() { ... }
@PreDestroy销毁前方法（相当于 destroy-method）java @PreDestroy public void cleanup() { ... }

lombok简化代码（非spring注解）

注解作用示例
@Data自动生成 getter/setter/toString/equals/hashCodejava @Data public class User { private String name; }
@Getter仅生成 getter 方法java @Getter public class User { private String name; }
@Setter仅生成 setter 方法java @Setter public class User { private String name; }
@TestJUnit 测试方法标记（不属于 Spring）java @Test public void testMethod() { ... }
@Before标记的方法会在 每个@Test测试方法之前 自动执行每个 @Test 前运行一次
@After标记的方法会在 每个@Test测试方法之后 自动执行（无论测试是否抛出异常）每个 @Test 后运行一次
SpringBoot01-架构体系讲解及springboot入门
花哥的博客
08-17 1272
背景 随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。 单一应用架构 当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。 垂直应用架构 当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关
SpringBoot01
m0_68201836的博客
01-25 1568
SpringBoot项目中常见的依赖、使用配置文件切换环境、配置文件的优先级、配置文件没有被springboot识别怎么办(配置文件成粉红色)、SpringBoot内置了Tomcat服务器、、@ServletComponentScan 就可以将 Filter、Servlet 等纳入 Spring 管理
springboot错误: 找不到或无法加载主类 cn.atguigu.springboot.SpringBoot01HelloworldQuickApplication
qq_44606649的博客
07-28 1325
如果配置都正确，那么可能是在打包jar包的时候，某些信息没有打包到位。 所以，可以将target下的jar包delete，然后运行项目，就会重新打包。这个时候应该就没问题。
springboot-01helloWorld
真奇
11-07 267
1 eclipse创建springboot程序
狂神说--SpringBoot01
Mar.三月
03-21 518
springboot 一个javaweb的开发框架，和springmvc类似 约定大于配置，简化开发，几行代码开发一个接口，多数spring应用只需很少的spring配置 springboot基于spring开发，和spring框架紧密结合用于提升spring开发者体验的工具 继承了大量的第三方库配置（redis，mq, mongo）。达到开箱即用 ...
Project build error: Non-resolvable parent POM for com.gzl.cn:springboot01:0.0.1-SNAPSHOT: Could not
怪咖@的博客
11-30 6740
问题描述 这是在通过maven来构建springboot项目的时候报的错，有的时候xml报些小红×没啥，但是这次不一样了。 以下是报错截图 导完依赖发现连maven dependencies都没有，这就更别说运行了，就是纯属的pom依赖错误。 下面截图是调试好之后的样子。 解决过程 首先这块我的依赖是从别的地方复制的，网上很多说法都是说让更换依赖版本，更改完就好了，其实不是，我就不信这个邪，同样都是空项目为啥别的版本就可以，然后最终找到了结果，就是复制的依赖可能中间产生空格导致的。特别是pdf文件复制依
springboot day01
TTT0T的博客
12-02 674
文章目录springboot简介springboot入门springboot热部署配置自定义配置application.yml springboot简介 SpringBoot是由Pivotal团队在2013年开始研发、2014年4月发布第一个版本的全新开源的轻量级框架。它基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建...
一步到位springboot 01：Hello Springboot！
bugpool的博客
04-18 2028
前言 为什么你学了n遍《1天精通springboot》，至今还是不精通springboot，甚至还是停留在学生项目？真正要做项目就应该一步到位，半吊子半桶水是不行的。一个实战项目需要充分考虑状态码、异常处理、日志处理、性能监控、数据安全、部署等等因素，而不是急于求成，为了达到1天精通的目标而糊弄过去。本专题的对象是后端小白，目标是搭建一套完善的Springboot后端框架，不至于项目跑起来，就跟下...
【SpringBoot 01】SpringBoot入门介绍，搭建运行一个SpringBoot小程序，SpringBoot常用注解
Java小皮孩
11-14 1076
文章目录1. Spring简介2. Spring Boot介绍Spring Boot的核心功能概述3. SpringBoot搭建快速入门程序SpringBoot的三种启动方式4. Spring Boot 原理分析起步依赖Spring Boot配置文件yml(yaml)配置文件介绍5. SpringBoot常用注解 1. Spring简介 Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的全栈，轻量级代替品。无需开发重量级的 Enterprise Java
springboot01_static
03-27
在本项目"springboot01_static"中，重点是静态资源的处理，这涉及到Web应用中的前端部分，特别是CSS（Cascading Style Sheets）技术的运用。 首先，我们来理解Spring Boot如何处理静态资源。Spring Boot默认支持...
Java集合中的链表
最新发布
Y409001的博客
08-08 435
本文详细介绍了Java中LinkedList的实现原理及其应用。首先分析了ArrayList在插入删除操作上的效率问题，引出链表结构的必要性。文章详细讲解了单向链表的基本概念、8种链表结构分类，以及不带头单向链表的具体实现，包括节点定义、接口设计和基本操作方法（增删改查）。重点说明了头插法、尾插法和任意位置插入的实现细节与注意事项。最后提供了9个链表相关的经典面试题及其解决方案，包括链表反转、中间节点查找、回文判断、环检测等。
需求EAV模型的优化与思考
HAN_789的博客
08-06 549
针对EAV（Entity-Attribute-Value）存储模型及Elasticsearch集成需求，以下是详细方案设计和实现建议。
Flash循环存储的地址回绕处理：跨边界写入的三种实现方案
u010360138的博客
08-05 1201
本文介绍了三种实现Flash循环存储地址计算的方法：1）条件判断法通过显式判断是否溢出实现地址回绕，逻辑清晰通用性强；2）模运算法利用取模运算自动处理地址回绕，代码简洁；3）位掩码法在存储区大小为2的幂时使用位与运算替代模运算，性能最优。三种方法功能等效但各有特点，选择时应考虑存储区特性、性能需求和代码可读性。关键注意事项包括写入延迟、地址有效性检查和边界条件处理。
Java中的RabbitMQ完全指南
H1658554092的博客
07-31 1106
Java中的RabbitMQ完全指南
SpringMvc的原理深度剖析及源码解读
gonghua0502的专栏
08-07 694
文章主要讲解了SpringServletContainerInitializer类初始化的过程。拦截器与过滤器区别及应用场景。DispatcherServlet处理流程。控制器初始化涉及文件解析器、本地化解析器等组件配置。适配器模式支持多种handler类型，包括Controller继承、HTTP请求和注解方式。异步实现可通过@Async注解或Callable类，需在配置类中开启异步支持。
D:\JavaProject\SpringBoot01\src\main\java\edu\fdzcxy\springboot01\dao\UserDao.java:4:52 java: 找不到符号 符号: 类 Resource 位置: 程序包 org.springframework.beans.factory.annotationD:\JavaProject\SpringBoot01\src\main\java\edu\fdzcxy\springboot01\dao\UserDao.java:4:52 java: 找不到符号 符号: 类 Resource 位置: 程序包 org.springframework.beans.factory.annotation
03-27
好的，我现在要解决用户的问题：Spring Boot项目中UserDao.java文件报错找不到符号类Resource，位于包org.springframework.beans.factory.annotation。用户已经提供了三个相关的引用，我需要结合这些信息来分析问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值