Spring：IOC控制反转、@Bean和@Component、日志、注入、注解

已于 2022-11-27 00:24:09 修改
阅读量411 收藏
点赞数
分类专栏： Spring 文章标签： spring java spring boot
于 2022-11-27 00:21:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43247028/article/details/128056292
版权

Spring核心知识点

Spring 核心功能：IOC（控制反转）和AOP（ 面向切面编程）

一、什么是IOC(Inversion of Control) 控制反转

1.主动控制：

应用程序主动控制管理对象组件

2.控制反转：

由外部容器/框架创建管理对象组件交给应用程序使用

二、使用原生Spring创建Demo项目

1.导入Maven包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.20</version>
</dependency>

2.创建配置类，组件扫描

@Configuration
@ComponentScan("com.demo.spring")
public class ContextConfig {
	@Bean//启动时加载
	public DemoBean bean(){//BeanID:bean
		return new DemoBean();
	}
}

3.创建Demo类

@Component
public class DemoBean {
    @Override
    public String toString() {
        return "Hello World";
    }
}

4.创建Spring容器（应用程序上下文）

public class Application {
    public static void main(String[] args) {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(ContextConfig.class);

        DemoBean demoBean = context.getBean("bean",DemoBean.class);
        System.out.println(demoBean);
    }
}

创建完成！

5.分析

在这里插入图片描述
@SpringBootApplication注解知多少：

  • @SpringBootApplication 是组合注解, 是由元注解组合而成
  • 组成组合注解中的每个注解称为元注解
  • 使用多个元注解标注代码和使用组合注解标注代码作用一样

举例

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { 
   							@Filter(type = FilterType.CUSTOM, 
   									classes = TypeExcludeFilter.class),
   							@Filter(type = FilterType.CUSTOM, 
   									classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}

三、JavaBean

1.JavaBean遵守如下规范：

  1. 需要定义package
  2. 存在无参构造器
  3. 需要实现序列化接口
  4. 包含使用getXxx setXxx声明的"Bean属性（Bean Property）
    a. Bean属性是指serXxx getXxx方法
    b. 对象属性（Object Filed）是指对象的实例变量

举例：

package com.demo.spring
public class Person implements Serializable{
	private String name = "hello Bean";//实例变量，对象属性
	public String getName(){//name
		return name;
	}
	public void setName(String name){//name
		this.name = name;
	}
	public String getPreferName(){//preferName
		return name.substring(0,1);
	}
}

2.JavaBean的作用域（JavaBean的有效范围）

JavaBean默认情况下是单例的（singleton），即任何时候获得的Bean对象都是同一实例
原型作用域（prototype），即每次引到bean时都会创建新的实例

作用域描述
singleton持续时间与 ApplicationContext 一致
prototype每次调用 getBean() 都会返回一个新的对象 持续时间与持有引用的时间一致，没有引用后，会被作为垃圾而回收
session持续时间与用户的HTTP会话一致 （Web 环境）
request持续时间与用户的HTTP请求一致 （Web 环境）
application持续时间与ServletContext一致（Spring 4.0）
global持续时间与Portlet应用程序中的全局HttpSession一致（从Spring 5开始过期）
thread持续时间与所在的线程一致，在Spring中已定义，但默认未注册
websocket持续时间与websocket一致（Spring 4.2）
refresh可以超过其application context的重新加载时间 难以确保效果，假设Spring Cloud配置服务器*

3.组件@Component扫描示例

SingletonBean .java

@Component
@Scope("singleton")
public class SingletonBean {
    @Override
    public String toString() {
        return "SingletonBean";
    }
}

PrototypeBean.java

@Component
@Scope("prototype")
public class PrototypeBean {
    @Override
    public String toString() {
        return "PrototypeBean";
    }
}

测试类ScopeTests .java

@SpringBootTest
public class ScopeTests {
    Logger logger = LoggerFactory.getLogger(ScopeTests.class);

    @Resource
    //@Autowired
    ApplicationContext context;

    @Test
    void test(){
        SingletonBean bean1 = context.getBean(SingletonBean.class);
        SingletonBean bean2 = context.getBean(SingletonBean.class);
        logger.debug("单例 {}", bean1 == bean2);//单例 true
        PrototypeBean bean3 = context.getBean(PrototypeBean.class);
        PrototypeBean bean4 = context.getBean(PrototypeBean.class);
        logger.debug("原形 {}", bean3 == bean4);//原形 false
    }

    @Test
    void single(){
        Single single = context.getBean(Single.class);
        logger.debug("{}", single);//com.demo.bean.Single@40021799
    }
}

4.显式声明@Bean示例

ScopeConfig.java

@Configuration
public class ScopeConfig {

    @Bean
    public List<String> provinceNames() {
        List<String> provinceNames = new ArrayList<>();
        provinceNames.add("北京");
        provinceNames.add("上海");
        return provinceNames;
    }

    @Bean
    @Scope("prototype")//设置为原形
    public List<String> holidayNames() {
        List<String> list = new ArrayList<>();
        list.add("中秋");
        list.add("国庆");
        return list;
    }
}

测试类ScopeTests .java

@SpringBootTest
public class ScopeTests {
    Logger logger = LoggerFactory.getLogger(ScopeTests.class);

    @Resource
    //@Autowired
    ApplicationContext context;
    
    @Test
    void scopeTests(){
        List<String> list1 = context.getBean("provinceNames", List.class);
        List<String> list2 = context.getBean("provinceNames", List.class);
        logger.debug("单例 {}", list1==list2);//单例 true
        List<String> list3 = context.getBean("holidayNames", List.class);
        List<String> list4 = context.getBean("holidayNames", List.class);
        logger.debug("原形 {}", list3==list4);//原形 false

    }
}

四、SpringBoot中使用日志(LoggerFactory)

1.为什么使用日志系统

  • System.out.println() 是IO操作，性能很差，使用过多会严重影响系统性能
  • 日志系统提供了高性能缓存机制，有着很好的性能，并且可以使用配置进行统一打开和关闭
  • Spring Boot 整合了日志系统，简单配置就可以使用

2.使用日志系统

private static Logger logger = LoggerFactory.getLogger(LoggerTests.class);
//static静态方法调用
//Logger和LoggerFactory 来自org.slf4j包，使用@slf4j注解也是同样的效果，但一般不用
//方法参数是当前的类名，用于设置Logger的层级，方便分组管理，分组打开和关闭

3.设置日志门槛

  • 在application.properties中加入该语句：
logging.level.cn.tedu.springioc = debug
//默认的日志级别是info
//功能：该包和子包中的日志输出语句高于debug级别的信息会被输出。
//可以粗粒度设置到包，或者细粒度的类

4.常见的日志等级划分方式如下：

  • FATAL：致命等级的日志，指发生了严重的会导致应用程序退出的事件。
  • ERROR：错误等级的日志，指发生了错误，但是不影响系统运行。
  • WARN： 警告等级的日志，指发生了异常，可能是潜在的错误。
  • INFO： 信息等级的日志，指一些在粗粒度级别上需要强调的应用程序运行信息。
  • DEBUG：调试等级的日志，指一些细粒度的对于程序调试有帮助的信息。
  • TRACE：跟踪等级的日志，指一些包含程序运行详细过程的信息。

五、组件扫描隐式创建对象@Component

1.显式 & 隐式

显式隐式
强制类型转换, 需要明确使用类型转换运算符"(类型)" 明确说明在计算自动类型转换, 不需要写任何代码, 就会自动发生

在Spring中是怎么显式创建组件的：

  • @Bean注解
  • 在配置类中创建Java对象
  • 明确使用new运算创建了对象

隐式创建对象：

  • @Component注解
  • @Autowired注入组件
  • SpringBoot启动时自动创建组件
    示例：
    创建一个配置类

@Configuration
public class ConfigBeans {

   /**
    * 使用@Bean 显示声明Java Bean 组件
    * Bean ID 为 names
    * @return 创建的JavaBean
    */
   @Bean
   public ArrayList<String> names(){
      ArrayList<String> names = new ArrayList<>();
      names.add("Tom");
      names.add("Jerry");
      return names;
   }

   @Bean
   public ArrayList<String> mobilePhone(){
      ArrayList<String> list = new ArrayList<>();
      list.add("110");
      list.add("119");
      return list;
   }

   /**
    * 使用 @Bean的属性设置BeanID
    * @return 城市列表
    */
   @Bean("cities")
   public ArrayList<String> list(){
      ArrayList<String> list = new ArrayList<>();
      list.add("北京");
      list.add("上海");
      return list;
   }
}

创建一个测试类

@SpringBootTest
public class BeanTests {

   Logger logger = LoggerFactory.getLogger(BeanTests.class);

   @Autowired
   @Qualifier("cities")
   ArrayList<String> names;

   @Test
   void names() {
      logger.debug("{}", names);
   }
}

六、SpringBoot自动组件扫描

1.使用@Component组件扫描注意事项

  1. 如果 Java Bean 没有定义在当前包和子包中则扫描不到
  2. 如果 Bean 创建到其他位置（不是当前包和子包）则需要手动配置组件扫描
  3. 如果在启动类上配置了组件扫描，则会关闭自动组件扫描
  4. @Component 注解需要和 @ComponentScan 注解一起使用才可以
  5. 注意精确扫描范围，提升扫描效率

2.举例

ExampleBean.java

package com.test.bean;

import org.springframework.stereotype.Component;

@Component
public class ExampleBean {
    @Override
    public String toString() {
        return "exampleBean";
    }
}

ExampleBeanTests.java

@ComponentScan({"com.test.service","com.test.bean"})
@SpringBootTest
public class ExampleBeanTests {

    Logger logger = LoggerFactory.getLogger(ExampleBeanTests.class);

    @Autowired
    ExampleBean exampleBean;

    @Test
    void exampleBean(){
        logger.debug("{}", exampleBean);
    }

}

七、区分@Bean和@Component

@Bean（显式配置）

优点缺点
集中在一个（或几个）地方，方便统一管理Bean比@Component注解更加冗余，繁琐
编写任何需要的代码，在配置类中自定义初始化程序
可以对配置类进行单元测试，可以单独测试
适用于所有类

@Component（隐式配置）

优点缺点
编辑位置明确，就在类中配置分布在代码库中
方便快速开发，直接标注在源码上难以调试/维护
只适用于自己的代码

八、@Autowired注入和@Resource注入

1.@Autowired注入

（1）注入方式
  • 构造方法注入（推荐）：必须存在唯一的匹配类型的依赖，只有一个构造器时候可以省略
  • set方法注入：构造方法注入和setter注入均支持多参数注入
  • 字段注入（对象属性注入）：private字段也可以注入
（2）@Autowired依赖可以使用requied覆盖
@Autowired(required=false)
(3)注入机制

类型匹配和name匹配
在这里插入图片描述

**注：**添加@Qualifer注解指定beanID
Worker.java

@Component
public class Worker {
    Logger logger = LoggerFactory.getLogger(Worker.class);
    private String name = "Chloe";

    @Autowired
    @Qualifier("crayon")
    private Tool tool;

    public Worker() {
    }

    public void work(){
        logger.debug("{}use{}painting", name, tool);
    }
}

测试类DITests.java

@SpringBootTest
public class DITests {

    @Autowired
    Worker worker;

    @Test
    void worker() {
        worker.work();
    }
}

2.@Resource

@Resource来自JSR-250，能被EJB 3.0和Spring支持。默认根据属性/字段的名称，而不是默认按类型来识别依赖项，名称是Spring的Bean名称，找不到匹配的name,则直接回退到根据类型注入，且仅支持Setter和字段注入

3.@Autowired 和 @Resource区别

注入匹配规则不同支持的注入方式不同注解来源不同包含输入功能
@Autowired先匹配类型， 再匹配名称属性 方法 构造器（只有一个构造器时候， 可以省略）Spring 提供是
@Resource先匹配名称， 再匹配类型属性 方法Java提供(JSR-250)否

九、元注解

  • 拼接的新注解成为 组合注解
  • 没有参与拼接的注解成为 元注解
  • 组合注解都有和 元注解相同的功能

举例一：

在这里插入图片描述
贴上@Configuration注解的源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
   @AliasFor(annotation = Component.class)
   String value() default "";
}

在这里插入图片描述

举例二：

在这里插入图片描述
这些组合注解都有和 @Component 类似的功能

  • @Service 用在业务层组件
  • @Repository 用在数据访问层组件
  • @Controller 和 @RestController 用在 Spring MVC 控制器
  • @Configuration 用在Spring Java 配置类上

也可以自定义自己的组合注解
创建：

@Component
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyService {
}

UserService.java

@MyService
public class UserService {
    @Override
    public String toString() {
        return "UserService";
    }
}

注意： 组合注解和元注解都是相对概念， 一个组合注解也可以作为元注解，再次组合为新注解

chloe的空间
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Bean和IoC（控制反转）简介
weixin_51223540的博客
05-21 107
在现代Java开发中，Spring框架是一个广泛使用的轻量级应用程序开发框架。Spring提供了许多功能和特性，其中最重要的是Spring Bean和IoC（控制反转）机制。本篇文章将介绍Spring Bean和IoC的概念、原理和使用方法。
@Component 和 @Bean 的区别
热门推荐
LKMMKL
09-05 6万+
Spring帮助我们管理Bean分为两个部分，一个是注册Bean，一个装配Bean。 完成这两个动作有三种方式，一种是使用自动配置的方式、一种是使用JavaConfig的方式，一种就是使用XML配置的方式。 @Compent 作用就相当于 XML配置 @Component public class Student { private String name = "lkm"; ...
Java Spring 注解实现IOC(Bean 控制反转)
aicyo8644的博客
09-17 2414
在使用注解实现IOC之前要依赖Spring的aop jar包 在xml中加入context约束，扫描cn.itcast下的所有有注解的文件，完成注解实现IOC，package有多个包的话，可以用逗号隔开也可以写他们的共同父包全路径 　　　 还有一种扫描方式： 　　但只会扫描属性上的注解，使用方式同上 Java中的配置： 　　在要实例化的类上加入@Com...
Spring揭秘日志第一步：IOC基本概念
qq_42942472的博客
07-04 202
Spring揭秘日志第一步：IOC基本概念 本篇文章是本人对本书中第二章的一些个人理解与整理的知识点。 众所周知，Spring始于IOC（Inversion of Control）控制反转，而它现在更多以依赖注入（DI）的方式被我们熟知。在这里还想到了一个设计原则——依赖倒转，下面先说明三者的关系。 Part1:控制反转、依赖注入与依赖倒转的关系 1、依赖倒转的相关概念 2、控制反转、依赖注入相关概念 (1)IOC：将对在自身对象中的一个内置对象的控制反转，反转后不再由自己本身的对象进行控制这个内置对象的
Spring IOC——常用注解（Component）
qq_44706044的博客
01-16 585
常用注解 一、与xml对比 用于创建对象的：他们的作用就和在XML配置文件中编写一个标签 实现的功能是一样的 用于注入数据的：他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一 样的 用于改变作用范围的：他们的作用就和在bean标签中使用scope属性实现的功能是一样的 和生命周期相关的：他们的作用就和在bean标签中使用init- me thod和des troy - met...
详解Spring依赖注入：@Autowired，@Resource和@Inject区别与实现原理
08-25
Spring 依赖注入：@Autowired，@Resource 和@Inject 区别与实现原理 Spring 依赖注入是指在应用程序中将对象之间的依赖关系自动装配的过程。Spring 框架提供了多种依赖注入方式，包括 @Autowired、@Resource 和@...
使用Java注解模拟spring ioc容器过程解析
08-18
Spring框架的IOC（Inversion of Control，控制反转）容器是Spring框架的核心组件之一，它实现了依赖注入和控制反转的功能。通过使用Java注解，我们可以模拟Spring IOC容器的过程，实现依赖注入和控制反转。 在下面...
IoC容器的设计（利用反射、注解和工厂模式实现）
06-24
我们需要将自定义四个注解，然后将Group和User类使用@Component注解，在User类中创建Group类的实例化对象并设置为自动装配，这样就能在User类中调用Group类的方法； 然后我们需要自己实现一个IoC容器类，处理自定义...
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
在本文中，我们将深入探讨Spring框架中的重要概念——控制反转（Inversion of Control，简称IOC），并重点关注如何通过注解和Java配置来实现IOC。Spring是Java开发中广泛使用的轻量级框架，它简化了应用程序的构建，...
spring ioc的简单实例及bean的作用域属性解析
08-28
</p></li></ol><h2 id="总结">总结</h2><p>Spring的IoC容器通过控制反转和依赖注入，实现了对象的解耦和管理。在本实例中，我们创建了数据访问层和业务逻辑层的bean，并通过XML配置文件进行注入。同时，了解了bean的...
从零写Spring注解版框架系列 IoC篇 （2）实现 @Component、@Autowired、@Qualifier注解
且炼时光
11-30 424
一 结构设计 首先创建一个 Maven 工程 winter-core，这里我们我们只需要依赖于 commons-lang 工具包，另外还有测试用的 junit 包。再创建各个类如下： 核心注解在 annotation 包下，util 包下是 ClassUtil 工具类 和 StringUtil 工具类，真正的核心组件是 BeanFactory 下的 ClassPathAnnotaionAppli...
spring学习日志之四 IOC原理
xuqiaobo的博客
08-16 953
1,Spring的IOC IOC（控制反转：Inverseof Control）是Spring容器的核心，AOP、声明式事务等功能都是以IOC作为基础展开的。控制反转的含义是：调用类对某一接口实现类的依赖关系由第三方（容器或者协作类）注入，以移除调用类对某一接口实现类的依赖。所以IOC的原理也被人叫做“依赖注入”。 2，IOC的类型 1）       构造函数注入：在构造函数中注入，我们通过
Spring之IoC操作Bean
Nicer_feng's blog
09-16 261
上一篇博客主要介绍IoC是什么，本篇主要介绍IoC的Bean管理，刚学的时候懵懵懂懂，不知道xml配置是干什么呀，有的类头上还有个注解是什么意思呢，相信很多初学者也是这样，下面带来管理Bean的两种主要方式。（其实有三种）
Spring_06_基于注解的IOC-component注解
weixin_43338519的博客
03-18 94
1.在bean.xml中加上以下几行 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns...
IOC容器和Bean的配置
naumy的博客
05-12 525
IOC容器和Bean的配置 1.IOC和DI ①IOC(Inversion of Control)：反转控制。 在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，
context:component-scan向Spring IOC容器中注入组件
Ron.Zheng
03-28 591
本文我们就来详细的探索一下在使用XML配置方式注入Bean时，component-scan组件扫描的应用。
模拟Spring IoC（一）Component及Autowired注解
a_un_l的博客
06-04 303
下面的文章内容是对Spring的IoC部分的简单模仿，但并不是完全一样，有很多的不足之处 依赖注入解释： IoC(Inversion of Control)即控制反转，与依赖注入DI(Dependency Injection)意义相同。 下面举个例子说明一下什么是依赖注入： public class TwoClass { public TwoClass() { } @Override public String toString() { return "这是一个TwoClass的对象"
Spring：IoC 用法（九、@Bean 用法）
晚虫的博客
07-24 372
Java 配置详解 1、@Bean
控制反转及Bean装配的几种方式
qq_31439011的博客
01-02 373
控制反转及Bean装配的几种方式 Spring两大基础核心，一是控制反转，二是依赖注入。 控制反转和依赖注入 控制反转，通俗来讲，就是将bean的创建和销毁交由另一个东西全权管理，这个东西叫做Spring容器，一般来说，在Spring应用中，容器管理着应用中所有bean的生命周期，包括何时创建，何时使用，何时销毁，该容器相当于一个bean的管家。控制反转具体体现在：当需要一个bean时，不是...
@Component使用@Bean和@Service使用@Bean
最新发布
11-25
因此，@Bean的功能比@Component的功能更强大，当需要引入外部类并将其注入到IOC容器中时，@Component注解是做不到的，但@Bean可以做到。 下面是使用@Component和@Bean注册bean的示例： 使用@Component注册bean： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值