Spring基础IoC(控制反转)与DI(依赖注入)

1. Spring 基础

1.1 什么是Spring框架？它能带来那些好处？

Spring 是一个开源的轻量级的 Java 开发框架，可以帮助开发人员更高效的进行开发，主要优势在于简化开发和框架整合。

Spring框架整合了很多模块，这些模块可以协助我们开发。例如Spring中的两大核心技术：IoC (Inversion of Control:控制反转) 和 AOP (Aspect-Oriented Programming : 面向切面编程)，可以很方便的支持对数据库的访问，并集成第三方组件（例如调度，缓存等等），还支持单元测试。

1.2 Spring的组成是什么？包含哪些模块？

Spring 4.x版本：

image-20231227195147302

Spring 5.x 版本：

Spring5.x 版本中 Web 模块的 Portlet 组件已经被废弃掉，同时增加了用于异步响应式处理的 WebFlux 组件。

Spring5.x主要模块

  • Core Container
  • AOP
  • Data Access/Integration
  • Web
  • Test
  • …

（每个模块的作用，和技术？）

1.3 Spring, Spring MVC, Spring Boot 之间的关系？

首先回答什么是 Spring，Spring MVC，Spring Boot

在这里插入图片描述

联系：

Spring MVC 是 Spring 众多模块中的一个重要模块，可以让 Spring 快速构建出一个 MVC 架构的 Web 程序。

MVC 是指模型（Model），视图（View），控制器（Controller）的简写，MVC架构的核心思想是将业务逻辑，数据，显示分离来组织代码，以简化 Web 程序的开发。

（与三层开发模型 Controller，Service，Dao 的关系是？）

img

Spring 进行开发的过程中需要用 XML 或者 Java 进行显示的配置，比较繁琐。而 Spring Boot 简化了这些配置，减少了配置文件，做到了开箱即用。

（如何做到简化配置文件的？原理是什么？）

2 Spring 核心技术

  1. 什么是IoC/DI 思想？
  • IoC（控制反转）：对象的创建权交给外部的 IoC 容器
  • DI （依赖注入）：绑定对象与对象之间的依赖关系
  1. 什么是 IoC 容器？

Spring 创建的用来存放所创建对象的容器

  1. 什么是 Bean?

IoC 容器中存放的一个个对象就是 Bean 或者 Bean 对象

2.1 Spring IoC & DI

（应该要补充原理的这里）

2.2 案例

IoC 的入门案例

  1. 首先创建一个 Maven 工程

  2. 在 pom 中添加 spring-context 依赖

  3. 创建BookService,BookServiceImpl，BookDao和BookDaoImpl四个类

  4. **添加 spring 配置文件：**在 resource 目录下添加 applicationContext.xml 文件 用于配置 bean 信息

    image-20231228144257809

  5. **在配置文件中对 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"><!--    id 为 bean 的名字 class 为 bean 对象所属的类--><bean id="bookDao" class="com.rainsun.Dao.Impl.BookDaoImpl"/><bean id="bookService" class="com.rainsun.Service.Impl.BookServiceImpl"/>
</beans>

  6. 获取 IoC 容器：把我们配置好的 Bean 文件进行解析，获得一个存放着Bean的容器

    public class App2 {public static void main(String[] args) {// IoC 容器获取：传入Bean的配置文件ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");}
}

  7. 从容器中获取 Bean 对象 并进行方法调用：

    public class App2 {public static void main(String[] args) {// IoC 容器获取ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");// 获取 Bean
//        BookDao bookDao = (BookDao)ctx.getBean("bookDao");
//        bookDao.save();BookService bookService = (BookService)ctx.getBean("bookService");bookService.save();}
}

问题：这里完成了控制反转，将对象的创建权交给了Spring，也可以获取对象，但是 Service 层中依然存在 Dao 层的 new 对象，这需要依赖注入(DI）来解决

DI 入门案例

  1. 去掉原先 new 创建对象的方式，改为使用 set 方法进行Bean对象赋值

    public class BookServiceImpl implements BookService {// 去掉 new 的实现方式，改为 DI（依赖注入）
//    private BookDao bookDao = new BookDaoImpl();private BookDao bookDao;@Overridepublic void save() {System.out.println("Book service save");bookDao.save();}// 通过调用set方法进行依赖注入public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
}

  2. 修改 Spring 配置文件，为 bookService 对象添加一个依赖

    把 Ioc 容器中的 bookDao 对象，绑定到 bookService 对象的 bookDao 属性上，这个绑定的实现要靠 setter 方法

    <?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 为 bean 的名字 class 为 bean 对象所属的类--><bean id="bookDao" class="com.rainsun.Dao.Impl.BookDaoImpl"/><bean id="bookService" class="com.rainsun.Service.Impl.BookServiceImpl">
<!--        name 指 BookServiceImpl 中的 bookDao 成员变量ref 指 IoC 容器存放的 bookDao Bean对象 --><property name="bookDao" ref="bookDao"/></bean>
</beans>

    image-20231228152133121

3 IoC相关 （Bean 的创建）

3.1 Bean 配置相关

基础配置 id, class, name

<bean id="" name="xxx xx xxx" class=""></bean>
  • id 表示 Bean 的名字
  • class 是bean的类型，也就是属于哪个实现类的
  • name 是 bean 的别名，可以有多个，用逗号（，）分号（；）空格（ ）进行分隔。通过别名也可以获取 Bean 对象

作用范围 scope

<bean id="" name="xxx xx xxx" class="" scope="singleton/prototype"></bean>

可选范围：

  • singleton：默认为单例模式，获取的同一名字的 bean 对象为同一个对象（地址相同）
  • prototype：非单例

思考：

  1. Bean 为什么默认为单例的？
    • 单例模式下 IoC 容器中只有该类的一个对象
    • 便于对象的复用，避免了对象的频繁创建和销毁
  2. 哪些 Bean 对象适合交给容器管理？
    • 表现层对象
    • 业务层对象
    • 数据层对象
    • 工具对象
    • 它们的对象只创建一次就够了，后面可以反复使用
  3. 哪些 Bean 对象不适合交给容器进行管理？
    • 封装实例的域对象（什么意思呢？），记录了一些属性值，状态在不断的变化的对象。
    • 会引发线程安全问题，所以不适合

3.2 Bean 实例化

我们将对象交给 Spring 的 IoC 容器进行创建了，但是容器是如何创建的呢？

构造方法实例化

我们为 BookDaoImpl 添加一个 public 的构造方法：

public class BookDaoImpl implements BookDao {public BookDaoImpl() {System.out.println("book dao constructor is running");}@Overridepublic void save() {System.out.println("Book dao save");}
}

然后获取 bookDao 对象，调用save 方法，可以发现构造方法被调用了：

book dao constructor is running
Book service save
Book dao save

如果将构造方法改为私有的 private，构造方法依然被调用：

private BookDaoImpl() {System.out.println("book dao constructor is running");
}

说明无论构造函数是公开还是私有的，spring底层都能通过构造函数创建出一个bean对象。也就是说Spring底层是利用反射实现的。

如果我们在无参构造函数中添加一个参数，Spring就会报错：没有默认构造函数

进一步说明Spring底层是使用类的无参构造方法

静态工厂实例化

首先环境准备：（创建一个工程提供实现类的一个实例）

实现的接口：

package com.rainsun.Dao;
public interface OrderDao {public void save();
}

实现类：

package com.rainsun.Dao.Impl;
import com.rainsun.Dao.OrderDao;
public class OrderDaoImpl implements OrderDao {@Overridepublic void save() {System.out.println("order dao save ...");}
}

工厂类提供静态方法，返回一个实例

package com.rainsun.factory;
import com.rainsun.Dao.Impl.OrderDaoImpl;
import com.rainsun.Dao.OrderDao;
public class OrderDaoFactory {public static OrderDao getOrderDao(){return new OrderDaoImpl();}
}

从工厂中获取对象：

package com.rainsun;
import com.rainsun.Dao.OrderDao;
import com.rainsun.factory.OrderDaoFactory;
public class AppForInstanceOrder {public static void main(String[] args) {OrderDao orderDao = OrderDaoFactory.getOrderDao();orderDao.save();}
}

如何将getOrderDao中创建的对象交给Spring管理呢？

这需要用到 Spring 中静态工厂实例化的知识：

在配置文件中添加 工厂方法的全类名(class) 和 工厂方法（factory-method) getOrderDao

<bean id="orderDao" class="com.rainsun.factory.OrderDaoFactory" factory-method="getOrderDao" />

image-20231228162022562

就可以把 getOrderDao 创建的 orderDao对象加入到容器，我们也可以通过 orderDao的名字获取到对应的bean，然后调用对应的方法了

实例工厂实例化

相比与静态工厂，实例工厂需要创建工厂的实例才能创建对象。也就是方法没有了 static 修饰：

package com.rainsun.factory;
import com.rainsun.Dao.Impl.OrderDaoImpl;
import com.rainsun.Dao.OrderDao;
public class OrderDaoFactory {public OrderDao getOrderDao(){return new OrderDaoImpl();}
}

获取对象，需要创建工厂实例，再调用方法：

public class AppForInstanceOrder {public static void main(String[] args) {//创建实例工厂对象OrderDaoFactory orderDaoFactory = new OrderDaoFactory();//创建实例工厂对象OrderDao orderDao = orderDaoFactory.getOrderDao();orderDao.save();}
}

如何将实例工厂创建的对象交给 Spring 管理呢？

我们也需要创建一个工厂的实例对象，然后用 factoryBean 指向该对象，再指明调用的工厂方法：

<bean id="orderDaoFactory" class="com.rainsun.factory.OrderDaoFactory"/><bean id="orderDao" factory-method="getOrderDao" factory-bean="orderDaoFactory"/>

  • 首先实例化工厂对象

  • 调用对象中的方法创建bean

    • factory-bean：工厂的实例对象

    • factory-method：工厂中具体创建对象的方法名称

      image-20231228163103914

FactoryBean的使用

实际上创建的工厂 bean 只是为了配合后面创建对象bean的使用，且每次创建对象bean的时候都需要指定 工厂bean对象。比较麻烦，Spring 提供了一个 FactoryBean接口的方式简化开发：

实例工厂实现 FactoryBean 接口，重写接口中的方法：

public class OrderDaoFactoryBean implements FactoryBean<OrderDao> {@Override // 代替原始工厂中创建对象的方法public OrderDao getObject() throws Exception {return new OrderDaoImpl();}@Overridepublic Class<?> getObjectType() {return OrderDao.class;}
}

Spring的bean配置中就可以只写一行配置，指明id和class就行：

<bean id="orderDao" class="com.rainsun.factory.OrderDaoFactoryBean"/>

继承的 FactoryBean接口中有三个方法：

T getObject() throws Exception;Class<?> getObjectType();default boolean isSingleton() {return true;
}
  • getObject ：重写返回创建的对象
  • getObjectType：重写返回被创建对象的Class对象
  • isSingleton：有默认值，为单例模式。如果重写返回 false 就是非单例的

3.3 Bean 的生命周期

Bean的生命周期是指 bean 对象从创建到销毁的整个过程。

我们主要关注 Bean 的生命周期控制，控制 bean 创建后和销毁前做一些操作。

如何将这些控制操作添加进去呢？

通过在配置文件中指定初始化方法和销毁方法的方式实现

生命周期设置

生命周期的控制分为两个阶段：

  • bean 创建之后，添加一些操作内容，例如初始化用到的资源
  • bean 销毁之前，添加一些操作内容，例如释放用到的资源
  1. 添加初始化方法和销毁方法：
import com.rainsun.Dao.BookDao;public class BookDaoImpl implements BookDao {private BookDaoImpl() {System.out.println("book dao constructor is running");}@Overridepublic void save() {System.out.println("Book dao save");}// bean 初始化对应的操作public void init(){System.out.println("init ...");}// bean销毁前的操作public void destroy(){System.out.println("destroy ...");}
}
  1. 配置文件中添加生命周期控制方法
 <bean id="bookDao" class="com.rainsun.Dao.Impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>

但是运行程序后，init 方法执行了，但是 destroy 方法是没有被执行的：

image-20231228203633061

因为 bean 对象是交给 IoC 容器的，JVM退出后，IoC 容器没有被关闭， bean 对象还没还得及销毁，程序已经结束了。

所以我们需要关闭 IoC 容器才能销毁 bean 对象

close 关闭IoC容器

  • ApplicationContext 接口中没有 close 方法，但是其下一个接口 ClassPathXmlApplicationContext 中有 close 方法

  • 改变 IoC 容器的类型，调用 close 方法：

    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.close();

注册钩子关闭IoC容器

close 关闭容器的方法比较暴力，我们可以提前在容器没关闭前设置一个回调函数，让JVM在退出的时候回调这个函数完成容器的关闭

回调函数的设置（钩子方法）：

ctx.registerShutdownHook();

上面控制bean生命周期的方式比较繁琐，不仅需要编写对应的控制方法，还需要编写配置文件。

Spring为了简化生命周期的控制，提供了两个接口 InitializingBean 和 DisposableBean ，重写其中的 afterProperiesSet 和 destroy 方法：

package com.rainsun.Service.Impl;import com.rainsun.Dao.BookDao;
import com.rainsun.Dao.Impl.BookDaoImpl;
import com.rainsun.Service.BookService;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {// 去掉 new 的实现方式，改为 DI（依赖注入）
//    private BookDao bookDao = new BookDaoImpl();private BookDao bookDao;@Overridepublic void save() {System.out.println("Book service save");bookDao.save();}// 通过调用set方法进行依赖注入public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}@Override // 属性设置之后，也就是属性注入bean对象之后，执行public void afterPropertiesSet() throws Exception {System.out.println("service init");}@Overridepublic void destroy() throws Exception {System.out.println("service destroy");}
}

小结：

  1. bean 生命周期控制的方法：

    1. 编写对象创建后和销毁前方法，并在配置文件中为对应bean对象的标签中添加 init-method 和 destroy-method 属性
    2. 实现 InitializingBean 和 DisposableBean 接口，重写其中的 afterPropertiesSet 和 destroy 方法

  2. 生命周期控制在Bean整个生命周期的位置？

    1. 初始化容器

      1. 创建对象（内存分配）
      2. 执行构造方法
      3. 执行属性注入（set操作）
      4. 执行bean的初始化方法

    2. 使用bean

      执行业务操作

    3. 关闭/销毁容器

      1. 执行 bean的销毁方法

  3. 关闭容器的方法：

    调用ConfigurableApplicationContext接口中的方法，它是ApplicationContext接口的子类

    • 调用 close() 方法
    • 调用回调函数：registerShutdownHook() 方法

4 DI 相关

依赖注入描述了容器中建立bean与bean之间的依赖关系的过程，bean的运行需要的数据类型有两类：引用类型，简单类型（基本数据类型与String）

向类中传递数据有两种方法：普通方法（set方法），构造方法

所以我们可以使用 setter 或者构造器完成简单类型和引用类型的bean注入

4.1 setter 注入

  1. setter 注入引用类型：

  • 在类中定义引用类型属性

  • 提供可访问的set方法

  • 在 property 标签的 ref 属性中引用该引用类型的 bean

    <property name="" ref=""/>
  1. setter 注入简单类型

  • 在类中定义简单类型属性

  • 提供可访问的set方法

  • 在 property 标签的 value 属性中注入具体的值

    public class BookDaoImpl implements BookDao{private String databaseName;private int connectionNum;public void setDatabaseName(String databaseName) {this.databaseName = databaseName;}public void setConnectionNum(int connectionNum) {this.connectionNum = connectionNum;}
}

    Spring 在注入时会自动转换为对应的参数类型

    <bean id="bookDao" class="com.rainsun.Dao.Impl.BookDaoImpl" init-method="init" destroy-method="destroy"><property name="databaseName" value="mysql"/><property name="connectionNum" value="10"/>
</bean>

4.2 构造器注入

  1. 构造器注入引用类型：

  • 在类中定义引用类型属性

  • 提供构造方法

  • 在 constructor-arg 标签的 ref 标签引用注入的 bean

    public class BookServiceImpl implements BookService {private BookDao bookDao; // 1public BookServiceImpl(BookDao bookDao) { // 2this.bookDao = bookDao;}
}

    <bean id="bookService" class="com.rainsun.Service.Impl.BookServiceImpl"><constructor-arg name="bookDao" ref="bookDao"/>
</bean>
  1. 构造器注入简单类型

同样的定义简单类型属性，提供构造方法，不同的是这里用 value 属性注入数据

<constructor-arg name="databaseName" value="mysql"/>
<constructor-arg name="connectionNum" value="10"/>
  1. 构造器注入多个数据的耦合问题

对应关系耦合：构造函数形参与 标签中的 name 属性对应

image-20231229102157908

解决耦合的方法：

  • 方式一：按照类型注入，使用 type 属性指明类型：

    <constructor-arg type="java.lang.String" value="mysql"/>
<constructor-arg type="int" value="10"/>

    如果存在类型相同的参数，这种注入方法就存在问题

  • 方式二：按照索引下标注入，下标从0开始：

    <constructor-arg index="0" value="mysql"/>
<constructor-arg index="1" value="10"/>

    解决了参数类型重复的问题，但是如果参数顺序发生了变化，就带来了新的耦合问题

  1. 依赖注入的方式选择
  • 强制依赖使用构造器进行注入。强制依赖是指对象创建过程中必须注入的依赖参数对象，而setter注入可能会导致注入null对象
  • 可选依赖使用setter注入。可选依赖指对象创建过程中注入的依赖参数对象可有可无
  • Spring提倡使用构造器，第三方框架大多使用构造器注入，相对严谨
  • 我们自己开发用 setter 注入比较简单

4.3 自动配置

上面配置bean依赖的过程很繁琐，需要编写配置文件，Spring提供了自动配置的方式。

依赖自动装配： IoC 容器根据 bean 所依赖的资源自动在容器中自动查找并注入到bean的过程称为自动装配

自动装配的方式：

  • 按类型注入 ：byType
  • 按名称 ：byName
  • 按构造方法
  • 不启用自动装配

image-20231229104747657

实现方式：

  • 类中定义属性

  • 编写set方法

  • bean标签中添加autowire属性，填写自动注入的方式

    public class BookServiceImpl implements BookService {private BookDao bookDao;public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
}

    <bean id="bookService" class="com.rainsun.Service.Impl.BookServiceImpl" autowire="byType"/>

注意：

  • 注入属性对应的 setter 方法不能省略
  • 该属性对应的 bean 对象必须存在在 IoC 容器中被管理
  • 如果存在同一类型bean对象，则会报错：NoUniqueBeanDefinitionException
  • 此时可以按照名称注入，使用属性 byName，该名称是指setter方法去掉set并小写首字母的属性名

自动装配的特征：

  • 自动装配只能用于引用类型，不能用于简单类型
  • byType 需要保证容器中同类型的bean唯一
  • byName必须保证容器中存在该名称的bean，否则注入为 null，这里存在耦合
  • 自动装配的优先级低于setter注入和构造器注入，同时出现时自动装配会失效

4.4 集合注入

需要注入的数据类型：

public class BookDaoImpl implements BookDao{private int[] myArray;private List<String> myList;private Set<String> mySet;private Map<String, String> myMap;private Properties myProperties;public void setMyArray(int[] myArray) {this.myArray = myArray;}public void setMyList(List<String> myList) {this.myList = myList;}public void setMySet(Set<String> mySet) {this.mySet = mySet;}public void setMyMap(Map<String, String> myMap) {this.myMap = myMap;}public void setMyProperties(Properties myProperties) {this.myProperties = myProperties;}@Overridepublic void save() {System.out.println("Book dao save");System.out.println("遍历数组：" + Arrays.toString(myArray));System.out.println("遍历List: " + myList);System.out.println("遍历set: " + mySet);System.out.println("遍历map: " + myMap);System.out.println("遍历properties: " + myProperties);}
}

配置文件编写：

<?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="bookDao" class="com.rainsun.Dao.Impl.BookDaoImpl"><property name="myArray"><array><value>100</value><value>200</value><value>300</value></array></property><property name="myList"><list><value>rainsun</value><value>xiongyuqing</value><value>sdu</value></list></property><property name="mySet"><set><value>rainsun</value><value>xiongyuqing</value><value>sdu</value></set></property><property name="myMap"><map><entry key="name" value="xyq"/><entry key="age" value="23"/><entry key="city" value="qingdao"/></map></property><property name="myProperties"><props><prop key="name">xyq</prop><prop key="age">23</prop><prop key="city">qingdao</prop></props></property></bean><bean id="bookService" class="com.rainsun.Service.Impl.BookServiceImpl" autowire="byType"/>
</beans>

运行：

public class App2 {public static void main(String[] args) {ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao)ctx.getBean("bookDao");bookDao.save();}
}

Book dao save
遍历数组：[100, 200, 300]
遍历List: [rainsun, xiongyuqing, sdu]
遍历set: [rainsun, xiongyuqing, sdu]
遍历map: {name=xyq, age=23, city=qingdao}
遍历properties: {city=qingdao, name=xyq, age=23}
  • List的底层也是通过数组实现的，所以<list>和<array>标签是可以混用
  • 集合中要添加引用类型，只需要把<value>标签改成<ref>标签，这种方式用的比较少

5 IoC&DI 配置管理第三方 Bean

5.1 数据源对象管理

实现 Druid 对象的管理：

  1. 连接数据库，创建一个数据库 spring_db

    image-20231229152914301

  2. pom 文件导入 Druid 的依赖：

    <dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.15</version>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.1.1</version>
</dependency>

  3. 在 applicationContext.xml 文件中添加 DruidDataSource 的配置，配置第三方 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">
<!--    管理DruidDataSource对象-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><!--  数据库驱动设置：--><property name="driverClassName" value="com.mysql.jdbc.Driver"/><!--  数据库连接地址：--><property name="url" value="jdbc:mysql://localhost:3306/spring_db"/><!--  数据库连接用户名：--><property name="username" value="root"/><!--  数据库连接密码：--><property name="password" value="1234"/>
</bean>
</beans>

  4. 从容器中获取对应的 bean 对象：

    public class App 
{public static void main( String[] args ) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource) ctx.getBean("dataSource");System.out.println(dataSource);}
}

Druid 封装了 com.mysql.jdbc.Driver 驱动，其他数据源可能没封装需要在pom中导入

5.2 加载 properties 配置文件

数据库连接的哪些地址，密码写在Spring配置文件中的，不利于后期维护。需要把这些配置信息单独提取出来到 properties 文件中，然后从 properties 配置文件中读取属性值来配置bean

  1. 在resources 目录下准备一个保存了配置信息的 jdbc.properties文件：

    jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=1234

  2. 开启 context 命名空间：

    xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd“

    <?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">

  3. 使用context命名空间下的 property-placeholder 标签来加载properties配置文件

    <context:property-placeholder location="jdbc.properties"/>

  4. 使用 ${key} 读取对应属性的内容完成属性注入

    <?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"><context:property-placeholder location="jdbc.properties"/><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean>
</beans>

6 核心容器

6.1 容器创建

  1. 根据 类路径下的 XML 配置文件创建容器 ApplicationContext：

    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

  2. 根据 文件系统下的XML配置文件创建 ApplicationContext：

    ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\CodeProject\\Java\\SpringFramework\\spring_01_base\\src\\main\\resources\\applicationContext.xml");

    这样耦合度较高

6.2 获取Bean的方式

  1. 根据 id 或者 name 直接获取，但是需要进行类型转换：

    BookDao bookDao = (BookDao) ctx.getBean("bookDao");

  2. 传入bean的名字的同时，传入bean的类型

    BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

  3. 直接传入 bean 的类型。类似依赖注入的类型注入

    BookDao bookDao = ctx.getBean(BookDao.class);

6.3 容器类的层次结构

image-20231229200149710

可以看出容器的顶层接口是BeanFactory，它的常用实现类是 FileSystem/ClassPath XmlApplicationContext

  • BeanFactory是延迟加载，只有在获取bean对象的时候才会去创建

  • ApplicationContext是立即加载，容器加载的时候就会创建bean对象

  • ApplicationContext要想成为延迟加载，需要给对应的 bean 添加属性：lazy-init="true"：

     <bean id="bookDao" class="com.rainsun.dao.impl.BookDaoImpl"  lazy-init="true"/>

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

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

相关文章

LeetCode 刷题日志

LeetCode 刷题日志

文章目录 1954. 收集足够苹果的最小花园周长思考&#xff1a;暴力枚举代码实现二分查找代码实现 1954. 收集足够苹果的最小花园周长 1954. 收集足够苹果的最小花园周长 难度&#xff1a; 中等 题目大意&#xff1a; 给你一个用无限二维网格表示的花园&#xff0c;每一个 整…
阅读更多...
Matplotlib ------ 纵坐标科学计数法含义

Matplotlib ------ 纵坐标科学计数法含义

matplotlib 纵坐标科学计数法含义 引言正文 引言 今天画图时遇到了一个问题&#xff0c;发现纵坐标是科学计数法的表示&#xff0c;但是很难理解它的含义&#xff0c;这里特来记录一下。 正文 我们以下图为例&#xff0c; 由图上我们可以看出&#xff0c;纵坐标显示为 1e-…
阅读更多...
PHP序列化总结3--反序列化的简单利用及案例分析

PHP序列化总结3--反序列化的简单利用及案例分析

反序列化中生成对象里面的值&#xff0c;是由反序列化里面的值决定&#xff0c;与原类中预定义的值的值无关&#xff0c;穷反序列化的对象可以使用类中的变量和方法 案例分析 反序列化中的值可以覆盖原类中的值 我们创建一个对象&#xff0c;对象创建的时候触发了construct方…
阅读更多...
纯CSS3制作优惠券线性UI效果

纯CSS3制作优惠券线性UI效果

纯CSS3制作优惠券线性UI效果-遇见你与你分享
阅读更多...
《分布式事务理论基础：CAP定理 BASE理论》

《分布式事务理论基础：CAP定理 BASE理论》

目录 学习目标 1.分布式事务理论基础 1.1.本地事务 1.2.分布式事务 分布式事务产生的原因&#xff1f; 哪些场景会产生分布式事务&#xff1f; 单体系统会产生分布式事务问题吗&#xff1f; 只有一个库&#xff0c;会产生分布式事务问题吗&#xff1f; 分布式事务举…
阅读更多...
rax3000m刷openwrt固件

rax3000m刷openwrt固件

rax3000m刷机过程&#xff08;nand版本&#xff09; 刷机准备文件https://www.123pan.com/s/X5m9-6Ynj.html提取码:VtBW 接线关系&#xff1a;路由器lan口接电脑 1.上传配置开启ssh的配置文件&#xff08;登录路由器后台管理界面在找到配置管理&#xff0c;上传配置文件rax3…
阅读更多...
HBase深度历险 | 京东物流技术团队

HBase深度历险 | 京东物流技术团队

简介 HBase 的全称是 Hadoop Database&#xff0c;是一个分布式的&#xff0c;可扩展&#xff0c;面向列簇的数据库&#xff0c;是一个通过大量廉价的机器解决海量数据的高速存储和读取的分布式数据库解决方案。本文会像剥洋葱一样&#xff0c;层层剥开她的心。 特点 首先我…
阅读更多...
【网络安全 | CTF】FlatScience

【网络安全 | CTF】FlatScience

该题考察SQL注入 正文 后台扫到robots.txt 页面内容如下&#xff1a; 进入login.php 页面源代码如图&#xff1a; 传参debug得到php代码&#xff1a; <?php if(isset($_POST[usr]) && isset($_POST[pw])){$user $_POST[usr];$pass $_POST[pw];$db new SQLite3…
阅读更多...
ArcGIS批量计算shp面积并导出shp数据总面积（建模法）

ArcGIS批量计算shp面积并导出shp数据总面积（建模法）

在处理shp数据时&#xff0c; 又是我们需要知道许多个shp字段的批量计算&#xff0c;例如计算shp的总面积、面积平均值等&#xff0c;但是单个查看shp文件的属性进行汇总过于繁琐&#xff0c;因此可以借助建模批处理来计算。 首先准备数据&#xff1a;一个含有多个shp的文件夹。…
阅读更多...
【三维目标检测/自动驾驶】IA-BEV：基于结构先验和自增强学习的实例感知三维目标检测（AAAI 2024）

【三维目标检测/自动驾驶】IA-BEV：基于结构先验和自增强学习的实例感知三维目标检测（AAAI 2024）

系列文章目录 论文&#xff1a;Instance-aware Multi-Camera 3D Object Detection with Structural Priors Mining and Self-Boosting Learning 地址&#xff1a;https://arxiv.org/pdf/2312.08004.pdf 来源&#xff1a;复旦大学 英特尔Shanghai Key Lab /美团 文章目录 系列文…
阅读更多...
初识智慧城市

初识智慧城市

文章目录 智慧家居 智慧社区 智慧交通 智慧医疗 智慧教育 智慧旅游 智慧农业 智慧安防 智慧家居 利用智能语音、智能交互等技术,实现用户对家居系统各设备的远程操控和能控制如开关窗帘(窗户)、操控家用电器和照明系统、打扫卫生等操作。利用计算机视觉等技术,对被照看…
阅读更多...
数据库——简单查询复杂查询

数据库——简单查询复杂查询

1.实验内容及原理 1. 在 Windows 系统中安装 VMWare 虚拟机&#xff0c;在 VMWare 中安装 Ubuntu 系统,并在 Ubuntu 中搭建 LAMP 实验环境。 2. 使用 MySQL 进行一些基本操作&#xff1a; &#xff08;1&#xff09;登录 MySQL&#xff0c;在 MySQL 中创建用户&#xff0c;…
阅读更多...
Tips:VS2022提示MSB8040 此项目需要缓解了 Spectre 漏洞的库解决方法。

Tips:VS2022提示MSB8040 此项目需要缓解了 Spectre 漏洞的库解决方法。

1&#xff0c;打开Visual Studio Installer 2、点击【修改】 3、选中【单个组件】&#xff0c;输入Spectre&#xff0c;下拉到【编译 工具和运行时】进行选择&#xff08;尽量寻找最新版本&#xff09;&#xff0c;然后点击【修改】进行安装&#xff08;如果VS2022没有关闭&…
阅读更多...
PHP序列化总结2--常见的魔术方法

PHP序列化总结2--常见的魔术方法

魔术方法的概念 PHP的魔术方法是一种特殊的方法&#xff0c;用于覆盖PHP的默认操作。它们以双下划线&#xff08;__&#xff09;开头&#xff0c;后面跟着一些特定的字符串&#xff0c;如__construct()、__destruct()、__get()等。这些魔术方法在对象执行特定操作时被自动调用…
阅读更多...
山西电力市场日前价格预测【2023-12-31】

山西电力市场日前价格预测【2023-12-31】

日前价格预测 预测说明&#xff1a; 如上图所示&#xff0c;预测明日&#xff08;2023-12-31&#xff09;山西电力市场全天平均日前电价为445.23元/MWh。其中&#xff0c;最高日前电价为791.27元/MWh&#xff0c;预计出现在08:15。最低日前电价为270.52元/MWh&#xff0c;预计…
阅读更多...
什么是SSL证书？在哪里免费申请？

什么是SSL证书？在哪里免费申请？

随着互联网蓬勃发展&#xff0c;人们在日常生活中越来越依赖网络。然而&#xff0c;网络攻击和数据泄露日益猖獗&#xff0c;保护网站和用户信息的安全变得尤为紧迫。在这一背景下&#xff0c;SSL证书成为至关重要的安全措施。 SSL证书的首要功能在于防范网络攻击。相较于不安全…
阅读更多...
MYSQL的UPDATE时锁表机制

MYSQL的UPDATE时锁表机制

&#xff08;笔记&#xff0c;只为获取流量券&#xff09; MySQL中&#xff0c;UPDATE 操作涉及到行级锁和表级锁的概念&#xff0c;具体取决于事务隔离级别和被更新的条件, 无索引的情况下&#xff1a; 当表没有索引的情况下&#xff0c;UPDATE 操作通常会涉及到表级锁。这是…
阅读更多...
2023年末，软件测试面试题总结与分享

2023年末，软件测试面试题总结与分享

大家好&#xff0c;最近有不少小伙伴在后台留言&#xff0c;得准备年后面试了&#xff0c;又不知道从何下手&#xff01;为了帮大家节约时间&#xff0c;特意准备了一份面试相关的资料&#xff0c;内容非常的全面&#xff0c;真的可以好好补一补&#xff0c;希望大家在都能拿到…
阅读更多...
Linux-权限

Linux-权限

1.Linux权限的概念 Linux下有两种用户&#xff1a;超级用户&#xff08;root&#xff09;、普通用户。 超级用户&#xff1a;可以再 linux 系统下做任何事情&#xff0c;不受限制 普通用户&#xff1a;在 linux 下做有限的事情。 超级用户的命令提示符是 “#” &#xff0c…
阅读更多...
数字图像处理——亚像素边缘的轮廓提取

数字图像处理——亚像素边缘的轮廓提取

像素 像素是图像处理中的基本单位&#xff0c;一个像素是图像中最小的离散化单位&#xff0c;具有特定的位置和颜色信息。在数字图像中&#xff0c;每个像素都有一个特定的坐标&#xff0c;通常以行和列的形式表示。每个像素的颜色信息可以通过不同的表示方式&#xff0c;如灰…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023