3、Spring 之IOC 容器 详解

IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。

Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。

IoC 容器是 Spring 框架中最重要的核心组件之一，它贯穿了 Spring 从诞生到成长的整个过程。

1、IoC容器

1.1、控制反转（IoC）

在这里插入图片描述

  • 控制反转是一种思想。

  • 控制反转是为了降低程序耦合度，提高程序扩展力。

  • 控制反转，反转的是什么？

    • 将对象的创建权利交出去，交给第三方容器负责。
    • 将对象和对象之间关系的维护权交出去，交给第三方容器负责。

  • 控制反转这种思想如何实现呢？

    • DI（Dependency Injection）：依赖注入

1.2、依赖注入

DI（Dependency Injection）：依赖注入，依赖注入实现了控制反转的思想。

依赖注入：

  • 指Spring创建对象的过程中，将对象依赖属性通过配置进行注入

依赖注入常见的实现方式包括两种：

  • 第一种：set注入
  • 第二种：构造注入

所以结论是：IOC 就是一种控制反转的思想， 而 DI 是对IoC的一种具体实现。

Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。

1.3、IoC容器在Spring的实现

Spring 的 IoC 容器就是 IoC思想的一个落地的产品实现。IoC容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IoC 容器。Spring 提供了IoC 容器的两种实现方式：

①BeanFactory

这是 IoC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

②ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext的主要实现类

iamges

类型名简介
ClassPathXmlApplicationContext通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContextApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

2、基于XML管理Bean

2.1 搭建子模块spring6-ioc-xml

①搭建模块

搭建方式如：spring-first

②引入配置文件

引入spring-first模块配置文件：beans.xml、log4j2.xml

③添加依赖

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.11</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.9.2</version></dependency><!--log4j2的依赖--><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.20.0</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j2-impl</artifactId><version>2.20.0</version></dependency></dependencies>

④引入java类

引入spring-first模块java实体类

image-20230830150556427

2.2 实验一：获取bean

①方式一：根据id获取

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。前面 我们的spring 入门用的就是这种方式。

image-20230830151840343

②方式二：根据类型获取

image-20230830152134346

③方式三：根据id和类型

image-20230830152342438

④注意的地方

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个

当IOC容器中一共配置了两个：

image-20230830152900977

然后我们根据类型进行获取Bean。

image-20230830153023661

就会抛出异常。

⑤扩展知识

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

可以，前提是bean唯一

package com.jie.ioc.service;/*** @Auther: Administrator* @Date: 2023/08/30/15:38* @Description:*/
public interface HelloWorldService {void run();}

package com.jie.ioc.service.impl;import com.jie.ioc.HelloWorldTest;
import com.jie.ioc.service.HelloWorldService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;/*** @author JIE* @version 1.0* @description: TODO* @date 2023/8/30 15:39*/
public class HelloWorldServiceImpl implements HelloWorldService {private final Logger logger = LoggerFactory.getLogger(HelloWorldTest.class);@Overridepublic void run() {logger.info("方法调用");}
}

image-20230830154346906

测试结果：

image-20230830154942040

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

不行，因为bean不唯一

package com.jie.ioc.service.impl;import com.jie.ioc.HelloWorldTest;
import com.jie.ioc.service.HelloWorldService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;/*** @author JIE* @version 1.0* @description: 第二个实现类* @date 2023/8/30 15:39*/
public class HelloWorldServiceImpl2 implements HelloWorldService {private final Logger logger = LoggerFactory.getLogger(HelloWorldTest.class);@Overridepublic void run() {logger.info("方法调用");}
}

image-20230830155137074

测试结果：

image-20230830155214596

结论

根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

java中，instanceof运算符用于判断前面的对象是否是后面的类，或其子类、实现类的实例。如果是返回true，否则返回false。也就是说：用instanceof关键字做判断时， instanceof 操作符的左右操作必须有继承或实现关系

2.3 实验二：依赖注入之setter注入

①创建学生类Student

package com.jie.ioc.model;public class Student {private Integer id;private String name;private Integer age;private String sex;public Student() {}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", age=" + age +", sex='" + sex + '\'' +'}';}}

②配置bean时为属性赋值

<bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="张三"/><property name="age" value="23"/><property name="sex" value="男"/>
</bean>

③测试

@Test
public void testDIBySet(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");Student studentOne = ac.getBean("studentOne", Student.class);System.out.println(studentOne);
}

image-20230830164909282

2.4 实验三：依赖注入之构造器注入

①在Student类中添加有参构造

public Student(Integer id, String name, Integer age, String sex) {this.id = id;this.name = name;this.age = age;this.sex = sex;
}

②配置bean

spring-di.xml

  <bean id="studentTwo" class="com.jie.ioc.model.Student"><constructor-arg value="1002"/><constructor-arg value="李四"/><constructor-arg value="33"/><constructor-arg value="女"/></bean>

注意：

constructor-arg标签还有两个属性可以进一步描述构造器参数：

  • index属性：指定参数所在位置的索引（从0开始）
  • name属性：指定参数名

③测试

@Test
public void testDIByConstructor(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");Student studentOne = ac.getBean("studentTwo", Student.class);System.out.println(studentOne);
}

image-20230830165839973

2.5 实验四：特殊值处理

①字面量赋值

什么是字面量？

int a = 10;

声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。

而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>

②null值

<property name="name"><null />
</property>

注意：

<property name="name" value="null"></property>

以上写法，为name所赋的值是字符串null

③xml实体

<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a &lt; b"/>

④CDATA节

<property name="expression"><!-- 解决方案二：使用CDATA节 --><!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 --><!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 --><!-- 所以CDATA节中写什么符号都随意 --><value><![CDATA[a < b]]></value>
</property>

2.6、实验五：为对象类型属性赋值

①创建班级类Clazz

package com.jie.ioc.model;public class Clazz {private Integer clazzId;private String clazzName;public Integer getClazzId() {return clazzId;}public void setClazzId(Integer clazzId) {this.clazzId = clazzId;}public String getClazzName() {return clazzName;}public void setClazzName(String clazzName) {this.clazzName = clazzName;}@Overridepublic String toString() {return "Clazz{" +"clazzId=" + clazzId +", clazzName='" + clazzName + '\'' +'}';}public Clazz() {}public Clazz(Integer clazzId, String clazzName) {this.clazzId = clazzId;this.clazzName = clazzName;}
}

②修改Student类

在Student类中添加以下代码：

image-20230831155426370

private Clazz clazz;public Clazz getClazz() {return clazz;
}public void setClazz(Clazz clazz) {this.clazz = clazz;
}

方式一：引用外部bean

配置Clazz类型的bean：

<bean id="clazzOne" class="com.jie.ioc.model.Clazz"><property name="clazzId" value="1111"/><property name="clazzName" value="财源滚滚班"/>
</bean>

为Student中的clazz属性赋值：

image-20230831155742937

<bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="null"/><property name="age" value="23"/><property name="sex" value="男"/><!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 --><property name="clazz" ref="clazzOne"/>
</bean>

测试结果：

image-20230831160029763

记得重新生成一下toString 方法。

image-20230831160104016

错误演示：

image-20230831160129284

image-20230831160216242

如果错把ref属性写成了value属性，会抛出异常： org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘studentOne’ defined in class path resource [bean.xml]: Failed to convert property value of type ‘java.lang.String’ to required type ‘com.jie.ioc.model.Clazz’ for property ‘clazz’; Cannot convert value of type ‘java.lang.String’ to required type ‘com.jie.ioc.model.Clazz’ for property ‘clazz’: no matching editors or conversion strategy found

意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值

方式二：内部bean

image-20230831160757368

<bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="null"/><property name="age" value="23"/><property name="sex" value="男"/><property name="clazz"><!-- 在一个bean中再声明一个bean就是内部bean --><!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 --><bean class="com.jie.ioc.model.Clazz"><property name="clazzId" value="2222"/><property name="clazzName" value="远大前程班"/></bean></property>
</bean>

测试结果：
image-20230831160827067

方式三：级联属性赋值

image-20230831160933610

<bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="null"/><property name="age" value="23"/><property name="sex" value="男"/><property name="clazz" ref="clazzOne"/><property name="clazz.clazzId" value="3333"/><property name="clazz.clazzName" value="最强王者班"/>
</bean>

测试结果：

image-20230831160952893

2.7 实验六：为数组类型属性赋值

①修改Student类

在Student类中添加以下代码：

image-20230831164250838

private String[] hobbies;public String[] getHobbies() {return hobbies;
}public void setHobbies(String[] hobbies) {this.hobbies = hobbies;
}

②配置bean

image-20230831164348262

<bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="null"/><property name="age" value="23"/><property name="sex" value="男"/><property name="clazz" ref="clazzOne"/><property name="clazz.clazzId" value="3333"/><property name="clazz.clazzName" value="最强王者班"/><property name="hobbies"><array><value>抽烟</value><value>喝酒</value><value>烫头</value></array></property>
</bean>

测试结果：

记得更改一下toString。

image-20230831164449756

2.8 实验七：为集合类型属性赋值

①为List集合类型属性赋值

在Clazz类中添加以下代码：

image-20230831164934375

private List<Student> students;public List<Student> getStudents() {return students;
}public void setStudents(List<Student> students) {this.students = students;
}

配置bean：

image-20230831165506706

 <bean id="clazzOne" class="com.jie.ioc.model.Clazz"><property name="clazzId" value="1111"/><property name="clazzName" value="财源滚滚班"/><property name="students"><list><ref bean="studentTwo"/><ref bean="studentOne"/></list></property></bean>

测试结果：
image-20230831165754727

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

②为Map集合类型属性赋值

创建教师类Teacher：

package com.atguigu.spring6.bean;
public class Teacher {private Integer teacherId;private String teacherName;public Integer getTeacherId() {return teacherId;}public void setTeacherId(Integer teacherId) {this.teacherId = teacherId;}public String getTeacherName() {return teacherName;}public void setTeacherName(String teacherName) {this.teacherName = teacherName;}public Teacher(Integer teacherId, String teacherName) {this.teacherId = teacherId;this.teacherName = teacherName;}public Teacher() {}@Overridepublic String toString() {return "Teacher{" +"teacherId=" + teacherId +", teacherName='" + teacherName + '\'' +'}';}
}

在Student类中添加以下代码：

image-20230831170216337

private Map<String, Teacher> teacherMap;public Map<String, Teacher> getTeacherMap() {return teacherMap;
}public void setTeacherMap(Map<String, Teacher> teacherMap) {this.teacherMap = teacherMap;
}

配置bean：

<bean id="teacherOne" class="com.jie.ioc.model.Teacher"><property name="teacherId" value="10010"/><property name="teacherName" value="大宝"/>
</bean><bean id="teacherTwo" class="com.jie.ioc.model.Teacher"><property name="teacherId" value="10086"/><property name="teacherName" value="二宝"/>
</bean><bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="null"/><property name="age" value="23"/><property name="sex" value="男"/><property name="hobbies"><array><value>抽烟</value><value>喝酒</value><value>烫头</value></array></property><property name="teacherMap"><map><entry key="10010" value-ref="teacherOne"/><entry key="10086" value-ref="teacherTwo"/></map></property>
</bean>

测试结果：
image-20230831170628706

③引用集合类型的bean

我们要使用到util:list、util:map标签必须引入相应的命名空间

<?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:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsdhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">

image-20230831172748169

<!--list集合类型的bean-->
<util:list id="students"><ref bean="studentOne"/><ref bean="studentTwo"/>
</util:list>
<!--map集合类型的bean-->
<util:map id="teacherMap"><entry key="10010" value-ref="teacherOne"/><entry key="10086" value-ref="teacherTwo"/>
</util:map><bean id="studentOne" class="com.jie.ioc.model.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"/><property name="name" value="null"/><property name="age" value="23"/><property name="sex" value="男"/><property name="hobbies"><array><value>抽烟</value><value>喝酒</value><value>烫头</value></array></property><property name="teacherMap" ref="teacherMap"/>
</bean><bean id="clazzOne" class="com.jie.ioc.model.Clazz"><property name="clazzId" value="1111"/><property name="clazzName" value="财源滚滚班"/><property name="students" ref="students"/>
</bean>

测试结果：

​ image-20230831172937130

image-20230831173000252

2.9 实验八：p命名空间

首先解释一下什么叫命名空间，或者说叫名称空间给大家做说明。

大家注意，在 “实验七：为集合类型属性赋值” 中的 引用集合类型的bean 演示过程中。我们增加了

image-20230903125625404

这部分，它的名字 是 util, 我这里再加一个。

image-20230903125807118

比如说你看我现在写一个叉xmlns，大家注意，现在这个标签里边，它的属性名字是不是都叫xmlns这个名字。而现在如果这么写肯定不对的！

因为你不能有两个相同名称属性，所以咱们可以加上一个部分。

image-20230903130133496

比如说加一个P这就叫命名空间。各位可以简单理解为避免标签中属性定义的冲突。那它后面加上这么一个地址，完成之后下面再用它来完成一个注入的过程。

image-20230903130240681

完成之后咱们快速做个测试，试一下这个效果。

image-20230903130533779

2.10 实验九：引入外部属性文件

接下来我们来学习引入外部属性文件。

首先说一下这个引入外部属性文件的一个需求，或者它的应用场景是怎么样。大家注意，就是我现在的各种属注入，咱们是都写到了差不多文件中。

image-20230903135305522

如果说你只有一个bean注入，那没有关系。但是我们很多时候不可能只有一个bean。

这个时候大家发现我们这里面有很多的bean，有很多的值得注入。那咱们要再进行修改，要再进行维护，是不是就特别不方便。

所以实际中咱一般这么来做，把一些特定的固定值放到一个外部文件中，然后引入外文件在里面进行注入。

而比较常见的那就是数据库配置。比如说我们数据里边有他的用户名，有密码，有地址等信息。那咱们写一个外部文件，把文件引入，在里边注入，这样的话方便咱们进行维护。如果说我现在要改数据库，那咱就改我这个外部文件。而spring的插入文件，那咱就不需要修改，这就是它的一个基本的需求。

接下来我们来做一个实现。

①加入依赖

<!-- MySQL驱动 -->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.33</version>
</dependency><!-- 数据源 -->
<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.16</version>
</dependency>

②创建外部属性文件

image-20230903140352553

jdbc.user=root
jdbc.password=ajie
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

③引入属性文件

引入context 名称空间

image-20230903140534968

<?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:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"></beans>

image-20230903140702338

<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

注意：在使用 context:property-placeholder 元素加载外包配置文件功能前，首先需要在 XML 配置的一级标签 中添加 context 相关的约束。

④配置bean

image-20230903142005151

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="${jdbc.url}"/><property name="driverClassName" value="${jdbc.driver}"/><property name="username" value="${jdbc.user}"/><property name="password" value="${jdbc.password}"/>
</bean>

⑤测试

image-20230903142910352

@Test
public void testDataSource() throws SQLException {ApplicationContext ac = new ClassPathXmlApplicationContext("bean.jdbc.xml");DataSource dataSource = ac.getBean(DataSource.class);DruidDataSource bean = ac.getBean(DruidDataSource.class);System.out.println(bean.getUrl());Connection connection = dataSource.getConnection();System.out.println(connection);
}

2.11 实验十：bean的作用域

①概念

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

取值含义创建对象的时机
singleton（默认）在IOC容器中，这个bean的对象始终为单实例IOC容器初始化时
prototype这个bean在IOC容器中有多个实例获取bean时

如果是在WebApplicationContext环境下还会有另外几个作用域（但不常用）：

取值含义
request在一个请求范围内有效
session在一个会话范围内有效

②创建类User

package com.jie.ioc.model;/*** 用户实体类** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 14:33*/
public class User {private Integer id;private String username;private String password;private Integer age;public User() {}public User(Integer id, String username, String password, Integer age) {this.id = id;this.username = username;this.password = password;this.age = age;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", password='" + password + '\'' +", age=" + age +'}';}
}

③配置bean

image-20230903143843157

<?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"><!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建对象 --><!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 --><bean id="user" class="com.jie.ioc.model.User" scope="prototype"/></beans>

④测试

image-20230903144132045

这是多例模式，创建出来的是两个不同的对象，我们换成单例试试看。

image-20230903144439292

image-20230903144454878

@Test
public void testBeanScope(){ApplicationContext ac = new ClassPathXmlApplicationContext("spring-scope.xml");User user1 = ac.getBean(User.class);User user2 = ac.getBean(User.class);System.out.println(user1==user2);
}

2.12 实验十一：bean生命周期

什么叫生命周期？如果说一个人的生命周期，那就是从这个人他出生到死亡这个过程。如果说咱们现在说Bean的生命周期，那指的就是bean对象从创建到销毁的过程，这个叫生命周期。

①具体bean的生命周期过程

  • bean对象创建（调用无参构造器）

  • 给bean对象设置属性

  • bean的后置处理器（初始化之前）

  • bean对象初始化（需在配置bean时指定初始化方法）

  • bean的后置处理器（初始化之后）

  • bean对象就绪可以使用

  • bean对象销毁（需在配置bean时指定销毁方法）

  • IOC容器关闭

②修改类User

package com.jie.ioc.model;/*** 用户实体类** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 14:33*/
public class User {private Integer id;private String username;private String password;private Integer age;public User() {System.out.println("生命周期：1、创建对象");}public User(Integer id, String username, String password, Integer age) {this.id = id;this.username = username;this.password = password;this.age = age;}public Integer getId() {return id;}public void setId(Integer id) {System.out.println("生命周期：2、依赖注入");this.id = id;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public void initMethod(){System.out.println("生命周期：3、初始化");}public void destroyMethod(){System.out.println("生命周期：5、销毁");}@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", password='" + password + '\'' +", age=" + age +'}';}
}

注意其中的initMethod()和destroyMethod()，可以通过配置bean指定为初始化和销毁的方法

③配置bean

image-20230903151645308

<!-- 使用init-method属性指定初始化方法 -->
<!-- 使用destroy-method属性指定销毁方法 -->
<bean id="user" class=" com.jie.ioc.model.User" init-method="initMethod" destroy-method="destroyMethod"><property name="id" value="1001"/><property name="username" value="admin"/><property name="password" value="123456"/><property name="age" value="23"/>
</bean>

④测试

image-20230903153213920

@Test
public void testLife() {ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.lifecycle.xml");User bean = ac.getBean("user", User.class);System.out.println("生命周期：4、通过IOC容器获取bean并使用");System.out.println(bean);ac.close();
}

⑤bean的后置处理器

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

创建bean的后置处理器：

package com.jie.ioc.model;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;/*** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 15:34*/
public class MyBeanProcessor implements BeanPostProcessor {/*** 初始化之前执行** @param bean* @param beanName* @return: java.lang.Object* @author 阿杰 2416338031@qq.com* @date: 2023/9/3 15:37*/@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("bean的后置处理器（初始化之前执行）");System.out.println("☆☆☆" + beanName + " = " + bean);return bean;}/*** 初始化之后执行** @param bean* @param beanName* @return: java.lang.Object* @author 阿杰 2416338031@qq.com* @date: 2023/9/3 15:37*/@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("bean的后置处理器（初始化之后执行）");System.out.println("★★★" + beanName + " = " + bean);return bean;}
}

在IOC容器中配置后置处理器：

image-20230903154101071

<!-- bean的后置处理器要放入IOC容器才能生效 -->
<bean id="myBeanProcessor" class="com.atguigu.spring6.process.MyBeanProcessor"/>

测试结果：

image-20230903154049994

2.13 实验十二：FactoryBean

我们继续往下演示。咱们现在演示这么多都是基于xml 里边的bean管理。那下面咱们演示什么呢？它叫做FactoryBean。

①简介

FactoryBean是Spring提供的一种整合第三方框架的常用机制。

和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

②创建类UserFactoryBean

package com.jie.ioc.model;import org.springframework.beans.factory.FactoryBean;/*** 工厂Bean** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 15:48*/
public class UserFactoryBean implements FactoryBean<User> {/*** 返回对象** @return User*/@Overridepublic User getObject() throws Exception {return new User();}/*** 返回对象类型** @return Class<User>*/@Overridepublic Class<?> getObjectType() {return User.class;}
}

③配置bean

image-20230903155254768

<bean id="user" class="com.atguigu.spring6.bean.UserFactoryBean"></bean>

④测试

image-20230903155529682

这过程中他建了一个单实例的user对象，而不是我们配置这个 UserFactoryBean 的这个对象。

@Test
public void testUserFactoryBean(){//获取IOC容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.factorybean.xml");User user = (User) ac.getBean("user");System.out.println(user);
}

2.14 实验十三：基于xml自动装配

自动装配：

根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值

①场景模拟

创建类UserController

package com.jie.ioc.controller;/***  用户控制器 ** @author 阿杰 2416338031@qq.com* @date 2023/9/3 16:16* @version 1.0
*/
public class UserController {private UserService userService;public void setUserService(UserService userService) {this.userService = userService;}public void saveUser(){userService.saveUser();}}

创建接口UserService

package com.jie.ioc.service;/***  用户服务 ** @author 阿杰 2416338031@qq.com* @date 2023/9/3 16:16* @version 1.0
*/
public interface UserService {void saveUser();}

创建类UserServiceImpl实现接口UserService

package com.jie.ioc.service.impl;import com.jie.ioc.service.UserService;/***   用户服务实现类 ** @author 阿杰 2416338031@qq.com* @date 2023/9/3 16:16* @version 1.0
*/
public class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao;}@Overridepublic void saveUser() {userDao.saveUser();}}

创建接口UserDao

package com.jie.ioc.dao;/*** 用户接口** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 16:17*/
public interface UserDao {void saveUser();}

创建类UserDaoImpl实现接口UserDao

package com.jie.ioc.dao.impl;import com.jie.ioc.dao.UserDao;/*** 用户dao实现类** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 16:17*/
public class UserDaoImpl implements UserDao {@Overridepublic void saveUser() {System.out.println("保存成功");}}

②配置bean

使用bean标签的autowire属性设置自动装配效果

自动装配方式：byType

byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值

若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值null

若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常NoUniqueBeanDefinitionException

<?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="userController" class="com.jie.ioc.controller.UserController" autowire="byType" /><bean id="userService" class="com.jie.ioc.service.impl.UserServiceImpl" autowire="byType"/><bean id="userDao" class="com.jie.ioc.dao.impl.UserDaoImpl"/></beans>

自动装配方式：byName

byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的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="userController" class="com.jie.ioc.controller.UserController" autowire="byName"/><bean id="userService" class="com.jie.ioc.service.impl.UserServiceImpl" autowire="byName"/><bean id="userServiceImpl" class="com.jie.ioc.service.impl.UserServiceImpl" autowire="byName"/><bean id="userDao" class="com.jie.ioc.dao.impl.UserDaoImpl"/><bean id="userDaoImpl" class="com.jie.ioc.dao.impl.UserDaoImpl"/></beans>

③测试

image-20230903163746526

@Test
void testAutoWireByXml(){ApplicationContext ac = new ClassPathXmlApplicationContext("autowire-xml.xml");UserController userController = ac.getBean(UserController.class);userController.saveUser();
}

3、基于注解管理Bean（☆）

从 Java 5 开始，Java 增加了对注解（Annotation）的支持，什么叫注解呢？大家可以理解为注解是代码中的一种特殊的标记。

可以在编译、类加载和运行时被读取，执行相应的处理。开发人员可以通过注解在不改变原有代码和逻辑的情况下，在源代码中嵌入补充信息。

Spring 从 2.5 版本开始提供了对注解技术的全面支持，我们可以使用注解来实现自动装配，简化 Spring 的 XML 配置。

Spring 通过注解实现自动装配的步骤如下：

  1. 引入依赖
  2. 开启组件扫描
  3. 使用注解定义 Bean
  4. 依赖注入

3.1 搭建子模块spring6-ioc-annotation

①搭建模块

搭建方式如：spring6-ioc-xml

②引入配置文件

引入spring-ioc-xml模块日志log4j2.xml

③添加依赖

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.11</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.9.2</version></dependency><!--log4j2的依赖--><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.20.0</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j2-impl</artifactId><version>2.20.0</version></dependency>
</dependencies>

3.2 开启组件扫描

Spring 默认不使用注解装配 Bean，因此我们需要在 Spring 的 XML 配置中，通过 context:component-scan 元素开启 Spring Beans的自动扫描功能。

开启此功能后，Spring 会自动从扫描指定的包（base-package 属性设置）及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。

注意：在使用 context:component-scan 元素开启自动扫描功能前，首先需要在 XML 配置的一级标签 中添加 context 相关的约束（命名空间）。

image-20230903174106993

 <?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:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"></beans>

情况一：最基本的扫描方式

<!-- 开启组件扫描 -->
<context:component-scan base-package="com.jie.annotation"/>

这样只要是建在 annotation 及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。

情况二：指定要排除的组件

<context:component-scan base-package="com.jie.annotation"><!-- context:exclude-filter标签：指定排除规则 --><!-- type：设置排除或包含的依据type="annotation"，根据注解排除，expression中设置要排除的注解的全类名type="assignable"，根据类型排除，expression中设置要排除的类型的全类名--><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--<context:exclude-filter type="assignable" expression="com.atguigu.spring6.controller.UserController"/>-->
</context:component-scan>

情况三：仅扫描指定组件

<context:component-scan base-package="com.jie.annotation" use-default-filters="false"><!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 --><!-- use-default-filters属性：取值false表示关闭默认扫描规则 --><!-- 此时必须设置use-default-filters="false"，因为默认规则即扫描指定包下所有类 --><!--type：设置排除或包含的依据type="annotation"，根据注解排除，expression中设置要排除的注解的全类名type="assignable"，根据类型排除，expression中设置要排除的类型的全类名--><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--<context:include-filter type="assignable" expression="com.atguigu.spring6.controller.UserController"/>-->
</context:component-scan>

一般情况下，我们使用第一种就足够了。

3.3 使用注解定义 Bean

Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean。

注解说明
@Component该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。
@Repository该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

3.4 实验一：@Autowired注入

单独使用@Autowired注解，默认根据类型装配。【默认是byType】

查看源代码：

image-20230903175524380

在源码中大家看框起来的部分，这是什么呢？你可以理解为它叫元注解，就是规定的一个注解，它里边具体的一些细节部分。我看第一部分，它叫 @Target ，他表示这注解可以用在什么地方。

例如 @Autowired 可以用在：

  • 构造方法上
  • 方法上
  • 形参上
  • 属性上
  • 注解上

然后第二个地方，该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

①场景一：属性注入

创建UserDao接口

package com.jie.annotation.dao;/*** 用户dao接口** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 18:02*/
public interface UserDao {public void print();
}

创建UserDaoImpl实现

package com.jie.annotation.dao.impl;import com.jie.annotation.dao.UserDao;
import org.springframework.stereotype.Repository;/*** 用户dao实现类*/
@Repository
public class UserDaoImpl implements UserDao {@Overridepublic void print() {System.out.println("Dao层执行结束");}
}

创建UserService接口

package com.jie.annotation.service;/***  用户服务接口 ** @author 阿杰 2416338031@qq.com* @date 2023/9/3 18:03* @version 1.0
*/
public interface UserService {public void out();
}

创建UserServiceImpl实现类

package com.jie.annotation.service.impl;import com.jie.annotation.dao.UserDao;
import com.jie.annotation.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;/***  服务层实现类 ** @author 阿杰 2416338031@qq.com* @date 2023/9/3 18:03* @version 1.0
*/
@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserDao userDao;@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

创建UserController类

package com.jie.annotation.controller;import com.jie.annotation.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;/*** 控制器层** @author 阿杰 2416338031@qq.com* @version 1.0* @date 2023/9/3 18:04*/
@Controller
public class UserController {@Autowiredprivate UserService userService;public void out() {userService.out();System.out.println("Controller层执行结束。");}}

测试一

image-20230903180720473

②场景二：set注入

修改UserServiceImpl类

image-20230903181024363

修改UserController类

image-20230903181107727

测试：成功调用

image-20230903181126839

③场景三：构造方法注入

修改UserServiceImpl类

image-20230903181325615

修改UserController类

image-20230903181344566

测试：成功调用

image-20230903181358517

④场景四：形参上注入

修改UserServiceImpl类

image-20230903181445531

修改UserController类

image-20230903181506016

测试：成功调用

image-20230903181520643

⑤场景五：只有一个构造函数，无注解

修改UserServiceImpl类

image-20230903181801900

测试通过

image-20230903181817121

当有参数的构造方法只有一个时，@Autowired注解可以省略。

说明：有多个构造方法时呢？

image-20230903182039985

测试结果：

image-20230903182058788

⑥场景六：@Autowired注解和@Qualifier注解联合

添加dao层实现

package com.jie.annotation.dao.impl;import com.jie.annotation.dao.UserDao;
import org.springframework.stereotype.Repository;@Repository
public class UserDaoRedisImpl implements UserDao {@Overridepublic void print() {System.out.println("Redis Dao层执行结束");}
}

测试：

image-20230903182340972

错误信息中说：不能装配，UserDao这个Bean的数量等于2

怎么解决这个问题呢？当然要byName，根据名称进行装配了。

修改UserServiceImpl类

image-20230903182527398

总结

  • @Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。
  • 当带参数的构造方法只有一个，@Autowired注解可以省略。（）
  • @Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。

3.5 实验二：@Resource注入

@Resource注解也可以完成属性注入。那它和**@Autowired**注解有什么区别？

  • @Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
  • @Autowired注解是Spring框架自己的。
  • @Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。
  • @Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。
  • @Resource注解用在属性上、setter方法上。
  • @Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。】

<dependency><groupId>jakarta.annotation</groupId><artifactId>jakarta.annotation-api</artifactId><version>2.1.1</version>
</dependency>

①场景一：根据name注入

修改UserDaoImpl类

image-20230903183345700

修改UserServiceImpl类

image-20230903183434415

测试通过

image-20230903183458636

②场景二：name未知注入

修改UserDaoImpl类

image-20230903183703309

修改UserServiceImpl类

image-20230903183733990

测试通过

image-20230903183755279

当@Resource注解使用时没有指定name的时候，还是根据name进行查找，这个name是属性名。

③场景三 其他情况

修改UserServiceImpl类，myUserDao1属性名不存在

image-20230903183919732

测试异常

image-20230903183940020

根据异常信息得知：显然当通过name找不到的时候，自然会启动byType进行注入，以上的错误是因为UserDao接口下有两个实现类导致的。所以根据类型注入就会报错。

@Resource的set注入可以自行测试

总结

@Resource注解：默认byName注入，没有指定name时把属性名当做name，根据name找不到时，才会byType注入。byType注入时，某种类型的Bean只能有一个

3.6 Spring全注解开发

全注解开发就是不再使用spring配置文件了，写一个配置类来代替配置文件。

image-20230903184921430

测试类

image-20230903185115969

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/123642.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

数据向好，分析师预测美联储GDP或将翻一番？

数据向好，分析师预测美联储GDP或将翻一番？

KlipC报道&#xff1a;最新公布的一些数据显示&#xff0c;美国经济看起来十分稳健&#xff0c;华尔街人士认为&#xff0c;这可能促使美联储本月公布的将2023年经济增长预测提高一倍&#xff0c;同时下调明年降息的预期幅度。 KlipC的合伙人Andi D表示&#xff1a;“在从消费者…
阅读更多...
高压放大器在机械制造领域的应用有哪些

高压放大器在机械制造领域的应用有哪些

在机械制造领域&#xff0c;高压放大器扮演着至关重要的角色。它们被广泛应用于各种机械设备和系统中&#xff0c;提供高压力、高精度的电信号放大。下面安泰电子将详细介绍高压放大器在机械制造领域的几个关键应用。 材料测试和强度试验 高压放大器广泛应用于材料测试和强度试…
阅读更多...
什么是跨域问题 ？Spring MVC 如何解决跨域问题 ？Spring Boot 如何解决跨域问题 ？

什么是跨域问题 ？Spring MVC 如何解决跨域问题 ？Spring Boot 如何解决跨域问题 ？

目录 1. 什么是跨域问题 &#xff1f; 2. Spring MVC 如何解决跨域问题 &#xff1f; 3. Spring Boot 如何解决跨域问题 &#xff1f; 1. 什么是跨域问题 &#xff1f; 跨域问题指的是不同站点之间&#xff0c;使用 ajax 无法相互调用的问题。 跨域问题的 3 种情况&#x…
阅读更多...
【C++ Core Guidelines解析】C++学习之路的一盏明灯

【C++ Core Guidelines解析】C++学习之路的一盏明灯

前言&#xff1a;C语言的功能非常丰富&#xff0c;表达能力非常强。因为一种成功的通用编程语言拥有的功能必须比任何开发人员所需要的更多&#xff0c;任何一种有生命力且不断发展的语言都会不断积累用于表达程序员思想的替代用法。这会导致选择过载。那么&#xff0c;开发人员…
阅读更多...
专业的视觉特效处理包，FxFactory 8 Pro for Mac助您打造精彩视频

专业的视觉特效处理包，FxFactory 8 Pro for Mac助您打造精彩视频

FxFactory 8 Pro for Mac是一款强大的视觉特效处理包&#xff0c;专门为Mac用户设计。它集成了超过200种高质量的视觉效果和过渡效果&#xff0c;可以轻松地应用于各种视频项目中。该软件提供了一个直观的界面&#xff0c;用户可以通过简单拖放操作将特效应用到视频片段上。它支…
阅读更多...
Lesson5-1:OpenCV视频操作---视频读写

Lesson5-1:OpenCV视频操作---视频读写

学习目标 掌握读取视频文件&#xff0c;显示视频&#xff0c;保存视频文件的方法 1 从文件中读取视频并播放 在OpenCV中我们要获取一个视频&#xff0c;需要创建一个VideoCapture对象&#xff0c;指定你要读取的视频文件&#xff1a; 创建读取视频的对象 cap cv.VideoCapt…
阅读更多...
java八股文面试[数据库]——索引下推

java八股文面试[数据库]——索引下推

什么是索引下推&#xff1f; 索引下推&#xff08;index condition pushdown &#xff09;简称ICP&#xff0c;在Mysql5.6的版本上推出&#xff0c;用于优化查询。 需求: 查询users表中 "名字第一个字是张&#xff0c;年龄为10岁的所有记录"。 SELECT * FROM users…
阅读更多...
将 Spring Boot 应用程序与 Amazon DocumentDB 集成

将 Spring Boot 应用程序与 Amazon DocumentDB 集成

Amazon DocumentDB&#xff08;与 MongoDB 兼容&#xff09;是一种可扩展、高度持久和完全托管的数据库服务&#xff0c;用于操作任务关键型 MongoDB 工作负载。在 Amazon DocumentDB 上&#xff0c;您可以使用相同的 MongoDB 应用程序代码、驱动程序和工具来运行、管理和扩展工…
阅读更多...
监控 -- linux中的一些系统性能状态指令、Prometheus

监控 -- linux中的一些系统性能状态指令、Prometheus

目录 监控查看性能相关命令Prometheus1、安装和配置2、将 NFS服务器和LB服务器作为exporter采集数据3、在prometheus server里添加安装exporter程序的服务器 grafana出图工具 监控 监控的目的是获取数据&#xff0c;通过数据分析了解机器是否正常运行 查看性能相关命令 查看c…
阅读更多...
学习pytorch8 土堆说卷积操作

学习pytorch8 土堆说卷积操作

土堆说卷积操作 官网debug torch版本只有nn 没有nn.functional代码执行结果 B站小土堆视频学习笔记 官网 https://pytorch.org/docs/stable/nn.html#convolution-layers 常用torch.nn, nn是对nn.functional的封装&#xff0c;使函数更易用。 卷积核从输入图像左上角&#xf…
阅读更多...
Python数据分析实战-将dataframe某列的值分成不同区间并计算每个区间的频数（附源码和实现效果）

Python数据分析实战-将dataframe某列的值分成不同区间并计算每个区间的频数（附源码和实现效果）

实现功能 将dataframe某列的值分成不同区间并计算每个区间的频数 实现代码 import pandas as pd# 创建dataframe data {Name:[Tom1, Jack1, Steve1, Ricky1, Tom2, Jack2, Steve2, Ricky2],Score:[78,60,59,42,88,34,69,142]} df pd.DataFrame(data) print(df)# 定义区间和…
阅读更多...
【VL tracking】Towards Unified Token Learning for Vision-Language Tracking

【VL tracking】Towards Unified Token Learning for Vision-Language Tracking

不知道什么原因学校认证账号进不去&#xff0c;下载不了最新的PDF 广西师范大学 | 国科大 | 厦大 代码开源 zhihu指路&#x1f449;【VL tracking】MMTrack阅读 问题 一方面&#xff0c;传统的VL tracking方法需要昂贵的先验知识。例如&#xff0c;一些tracker是专门用于bou…
阅读更多...
【产线故障】线上接口请求过慢如何排查？

【产线故障】线上接口请求过慢如何排查？

文章目录 前言一、内存使用过高导致CPU满载案例代码分析思路 二、出现了类似死循环导致cpu负载案例代码分析思路 三、死锁案例代码分析思路 前言 首先线上接口变慢&#xff0c;原因可能有很多&#xff0c;有可能是网络&#xff0c;有可能是慢 SQL&#xff0c;有可能是服务本身…
阅读更多...
【Linux】- 一文秒懂shell编程

【Linux】- 一文秒懂shell编程

shell编程 1.1 Shell 是什么1.2 Shell 脚本的执行方式1.3 编写第一个 Shell 脚本2.1 Shell 的变量2.2 shell 变量的定义2.3 设置环境变量3.1 位置参数变量3.2 预定义变量4.1 运算符4.2 条件判断5.1 流程控制5.2 case 语句5.3 for 循环5.4 while 循环5.5 read基本语法6.1函数6.2…
阅读更多...
Mysql性能调优——1.深入理解Mysql索引数据结构和算法

Mysql性能调优——1.深入理解Mysql索引数据结构和算法

本系列所说的Mysql性能调优&#xff0c;主要是针对开发者在实际环境中的sql调优&#xff0c;代码层面上的优化。不涉及到mysql底层代码的调优。 我们知道&#xff0c;一个mysql数据表&#xff0c;数据量小的时候&#xff0c;可能简单的查询耗时不会太久&#xff0c;性能也可以…
阅读更多...
供配电技术

供配电技术

最近&#xff0c;在上一门关于供配电技术的课程&#xff0c;虽说与自动化的关系并不是十分大&#xff0c;但对于扩展知识面还是有很大用处的&#xff0c;不至于与其他人交谈此方面的相关知识的时候&#xff0c;一头雾水。
阅读更多...
百度智能云千帆大模型平台2.0来了！从大模型到生产力落地的怪兽级平台！！

百度智能云千帆大模型平台2.0来了！从大模型到生产力落地的怪兽级平台！！

目录 前言 最佳算力效能为企业降低门槛 最多大模型&#xff0c;最多数据集为企业保驾护航 企业级安全对于企业来说是硬性要求 前言 普通人或许感知不明显&#xff0c;但是对于企业而言&#xff0c;身处AI时代&#xff0c;是否选择投资大模型&#xff0c;是否拥抱人工智能…
阅读更多...
AlmaLinux 经济收益增加，红帽 RHEL 源码限制不成威胁

AlmaLinux 经济收益增加，红帽 RHEL 源码限制不成威胁

导读红帽在两个月前发布公告表示&#xff0c;将限制对 Red Hat Enterprise Linux (RHEL) 源代码的访问&#xff0c;未来 CentOS Stream 将成为公共 RHEL 相关源代码发布的唯一仓库。对于这一决策&#xff0c;AlmaLinux OS Foundation 主席 Benny Vasquez 则向 SiliconANGLE 表示…
阅读更多...
【MyBatis篇】MyBatis框架基础知识笔记

【MyBatis篇】MyBatis框架基础知识笔记

目录 ORM思想&#xff08;对象关系映射思想&#xff09; 初识MyBatis 什么是MyBatis呢&#xff1f; JDBC VS MyBatis代码 获取数据库连接对比 对表格查询操作&#xff1a; JDBC弊端 MyBatis&#xff0c;JDBC对比 MyBatis进一步介绍以及本质分析 JDBC编程的劣势&…
阅读更多...
五大类注解和方法注解详解

五大类注解和方法注解详解

五大类注解为Controller&#xff0c;Service&#xff0c;Repository&#xff0c;Configuration&#xff0c;Component,方法注解为Bean。 需要注意的是&#xff1a;Bean注解必须要在类注解修饰的类内才能正常使用。 一、与配置文件的关系 在spring原生项目中 如果你使用的spri…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023