【Spring总结】基于配置的方式来写Spring

本篇文章是对这两天所学的内容做一个总结，涵盖我这两天写的所有笔记：

  1. 【Spring】 Spring中的IoC（控制反转）
  2. 【Spring】Spring中的DI（依赖注入）Dependence Import
  3. 【Spring】bean的基础配置
  4. 【Spring】bean的实例化
  5. 【Spring】bean的生命周期
  6. 【Spring】依赖注入方式，DI的方式
  7. 【Spring】使用三方包进行数据源对象（数据库）管理
  8. 【Spring】加载properties文件
  9. 【Spring】IoC容器的一些总结与补充

文章目录

  • 1. 控制反转与依赖注入的定义
    • 为什么需要控制反转？
    • Spring中怎么做控制反转？
      • 第一步：pom.xml引入相关依赖
      • 第二步：在Resource文件下创建Spring Config File（也就是配置IoC容器的内容），并配置bean
      • 第三步：在代码中调用IoC容器，并获取具体的bean
    • 为什么需要依赖注入？
    • 如何进行依赖注入？
      • Setter注入引用类型和简单类型
        • 第一步：删除`ServiceImpl`中的`new`创建方式，建立set方法，使得可以对`ServiceImpl`中的属性做修改
        • 第二步：在配置文件中写明使用什么类别给bookDao属性做注入
        • 第三步：测试
      • 构造器注入简单类型和引用类型
        • 第一步：删除`ServiceImpl`中的`new`创建方式，无需set方法，通过构造方法对`ServiceImpl`中的属性做修改
        • 第二步：在配置文件中写明使用什么类别给构造方法
        • 第三步：测试
      • 构造器注入的参数适配（了解，通常不用这些方法）
      • 依赖注入方式选择
      • 依赖自动装配，通过`autowire`属性指定类型
        • 按类型注入：`autowire="byType"`
        • 按名称注入：`autowire="byName"`
        • 自动装配注意事项
      • 集合注入
        • 在集合中注入简单类型——`value`
        • 在集合中注入引用类型——`ref`
    • 控制反转与依赖注入的关系
  • 2. bean的配置
    • bean的别名配置——`name`属性配置
    • bean的单例多例——`scope`属性配置
      • bean为什么默认为单例？
      • bean的作用范围说明
    • bean的实例化
      • 构造方法
      • 静态工厂
      • 实例工厂
      • FactoryBean
    • bean的生命周期
      • 在类中提供生命周期控制方法，并在配置文件中配置init-method&destroy-method（配置）
        • 通过ctx.close()执行IoC容器关闭
        • 通过注册关闭钩子执行IoC容器关闭
      • 实现接口来做和init和destroy（接口）
      • bean的生命周期执行顺序
  • 3. 使用第三方包进行数据源的管理（例子：使用com.alibaba.druid进行数据库连接）
    • 第一步：在pom.xml中导入坐标
    • 第二步：在bean中配置连接
  • 4. 在配置文件中读取properties文件中的属性
    • 第一步：建立jdbc.properties文件，内容如下
    • 第二步：开启context命名空间
    • 第三步：使用context命名空间加载指定properties文件
    • 第四步：使用`${}`读取加载的属性值
    • 其他问题
  • 5. 关于IoC容器其他内容的总结与补充
    • 创建容器的两种方式
      • 相对路径导入
      • 绝对路径导入
    • 获取Bean的三种方式
      • 获取后强转类型
      • 在获取时指定类型
      • 通过类型获取Bean
    • 容器类层次结构图
    • BeanFactory
  • 6. 复习内容

1. 控制反转与依赖注入的定义

为什么需要控制反转？

我们在传统写业务层的时候，需要给业务层中的属性通过new操作生成对象。

public class BookServiceImpl implements BookService{private BookDao bookDao = new BookDaoImpl();public void save(){bookDao.save()}
}

假如某一天我不再希望使用BookDaoImpl这个实现类，而是希望使用BookDaoImpl2这个实现类，我们就需要再次修改代码，重新修改BookServiceImpl中bookDao属性的初始化。这样子的修改方式就不是太合理，耦合度较高。
如果我们可以将这种主动式产生对象转换为由外部指定产生对象，就可以减少这种修改，降低耦合度，通俗的说，就是将对象的创建控制权由程序转移到外部，这就是控制反转(IoC, Inversion of Control)。

Spring中怎么做控制反转？

Spring实现了IoC，此处介绍基于配置来写IoC：

第一步：pom.xml引入相关依赖

引入相关依赖，刷新maven：

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

第二步：在Resource文件下创建Spring Config File（也就是配置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"><!--1. 导入spring的坐标spring-context--><!--2. 配置bean--><!--bean标签标示配置beanid属性标示给bean起名字class属性标示给bean定义的类型--><bean id="bookDao" class="com.example.demo231116.dao.impl.BookDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl" />
</beans>

第三步：在代码中调用IoC容器，并获取具体的bean

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

为什么需要依赖注入？

在上面给出的BookServiceImpl.java代码中，有一个bookDao的属性，我们定义为：

private BookDao bookDao = new BookDaoImpl();

我们想要通过IoC去管理bean，为了真正实现解耦，我们不再保留new形式创建的Dao对象，这时候我们就需要使用依赖注入来完成这一点

如何进行依赖注入？

思考两个问题：

  1. Service中需要的Dao对象如何进入到Service中？（提供方法，使得我们可以修改Service中的Dao对象）
  2. Service与Dao间的关系如何描述？（通过配置的形式来描述）
    基于以上两个问题及答案，我们总结了不同的注入方式

Setter注入引用类型和简单类型

第一步：删除ServiceImpl中的new创建方式，建立set方法，使得可以对ServiceImpl中的属性做修改
public class BookServiceImpl implements BookService {// 删除原本的new方法，给bookDao设置一个setter方法public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}public void setBookName(String bookName) {this.bookName = bookName;}private BookDao bookDao;private String bookName;public void save(){System.out.println("book service save... bookName:" + this.bookName);bookDao.save();}}
第二步：在配置文件中写明使用什么类别给bookDao属性做注入

在配置文件中，在bookService的bean内部配置property，该标签表示配置当前bean的属性，其中name表示配置哪一个具体属性，ref表示引用类型参照的具体bean，value则是简单类型的对应值

<?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.example.demo231116.dao.impl.BookDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl"><property name="bookDao" ref="bookDao"/><property name="bookName" value="bkName!!!" /></bean>
</beans>
第三步：测试

运行如下代码：

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

结果为：

book service save... bookName:bkName!!!
book dao save...

构造器注入简单类型和引用类型

第一步：删除ServiceImpl中的new创建方式，无需set方法，通过构造方法对ServiceImpl中的属性做修改
public class BookServiceImpl implements BookService {private BookDao bookDao;private String bookName;// 删除原本的new方法，给bookDao设置一个setter方法public BookServiceImpl(BookDao bookDao, String bookName){this.bookDao = bookDao;this.bookName = bookName;}public void save(){System.out.println("book service save... bookName:" + this.bookName);bookDao.save();}
}
第二步：在配置文件中写明使用什么类别给构造方法

在配置文件中，在bookService的bean内部配置constructor-arg，该标签表示构造方法的参数，其中name表示配置哪一个具体属性，ref表示引用类型参照的具体bean，value则是简单类型的对应值

<?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.example.demo231116.dao.impl.BookDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl"><constructor-arg name="bookDao" ref="bookDao"/><constructor-arg name="bookName" value="bkName!!!" /></bean>
</beans>
第三步：测试

运行如下代码：

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

结果为：

book service save... bookName:bkName!!!
book dao save...

构造器注入的参数适配（了解，通常不用这些方法）

  • 配置中使用constructor-arg的标签type属性按形参类型注入（为了解耦，避免配置和name耦合）
<?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.example.demo231116.dao.impl.BookDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl"><constructor-arg type="com.example.demo231116.dao.bookDao" ref="bookDao"/><constructor-arg type="java.lang.String" value="bkName!!!" /></bean>
</beans>
  • 配置中使用constructor-arg的标签index属性按形参位置注入（为了解决有同样类型的参数的问题）
<?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.example.demo231116.dao.impl.BookDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl"><constructor-arg index="0" ref="bookDao"/><constructor-arg index="1" value="bkName!!!" /></bean>
</beans>

依赖注入方式选择

在这里插入图片描述
建议使用setter注入
第三方技术根据情况选择


依赖自动装配，通过autowire属性指定类型

根据bean所依赖的资源在容器中自动查找并注入到bean的过程为自动装配
自动装配的方式通过autowire指定，有四种类型：

  • 按类型（常用）
  • 按名称
  • 按构造方法
  • 不启用自动装配

注意，想要让IoC容器实现自动装配，必须给这些属性配置setter方法！

按类型注入：autowire="byType"

在这里插入图片描述
此时配置BookServiceImpl的代码应该这么写：

<?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.example.demo231116.dao.impl.BookDaoImpl" /><bean id="userDao" class="com.example.demo231116.dao.impl.UserDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl" autowire="byType" />
</beans>

bean的类型指向必须唯一！，推荐使用。
假如配置了两个指向同一类型，id不同的bean，执行报错会提示找到了两个bean，不知道匹配哪一个。

按名称注入：autowire="byName"

在这里插入图片描述
此时配置BookServiceImpl的代码应该这么写：

<?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.example.demo231116.dao.impl.BookDaoImpl" /><bean id="userDao" class="com.example.demo231116.dao.impl.UserDaoImpl" /><bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl" autowire="byName" />
</beans>

属性的名称要能够在配置的bean中的id对应的上。此方式因变量名与配置耦合，不推荐使用。

自动装配注意事项
  • 自动装配用于引用类型依赖注入，不能对简单类型操作（因为简单类型你可以有很多不同的值，除非一个一个写）
  • 自动装配优先级低于setter注入和构造器注入，同时出现时自动装配无效

集合注入

关于array、list、set、map、properties的注入
假如BookDaoImpl.java代码如下：

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;import java.util.*;public class BookDaoImpl implements BookDao {private int[] array;private List<String> list;private Set<String> set;private Map<String, String> map;private Properties properties;@Overridepublic void save() {System.out.println("book dao save...");System.out.println("遍历数组：" + Arrays.toString(array));System.out.println("遍历List：" + list);System.out.println("遍历set：" + set);System.out.println("遍历Map：" + map);System.out.println("遍历properties：" + properties);}public void setProperties(Properties properties) {this.properties = properties;}public void setMap(Map<String, String> map) {this.map = map;}public void setSet(Set<String> set) {this.set = set;}public void setList(List<String> list) {this.list = list;}public void setArray(int[] array) {this.array = array;}
}
在集合中注入简单类型——value

配置文件需要如下配置：

<bean id="bookDao" class="com.example.demo.dao.impl.BookDaoImpl"><property name="array"><array><value>100</value><value>200</value><value>300</value></array></property><property name="list"><list><value>a</value><value>b</value><value>c</value></list></property><property name="set"><set><value>c</value><value>c</value><value>d</value></set></property><property name="map"><map><entry key="country" value="china" /><entry key="province" value="guangdong" /><entry key="city" value="shenzhen" /></map></property><property name="properties"><props><prop key="country">china</prop><prop key="province">henan</prop><prop key="city">kaifeng</prop></props></property>
</bean>

其中，set属性自动过滤元素，如果执行以下java代码：

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

则结果如下：

book service save...
book dao save...
遍历数组：[100, 200, 300]
遍历List：[a, b, c]
遍历set：[c, d]
遍历Map：{country=china, province=guangdong, city=shenzhen}
遍历properties：{country=china, province=henan, city=kaifeng}
在集合中注入引用类型——ref

只需去掉简单类型的value属性，使用ref属性

<bean id="bookDao" class="com.example.demo.dao.impl.BookDaoImpl"><property name="array"><array><ref bean="beanId" /><ref bean="beanId" /><ref bean="beanId" /></array></property>
</bean>

控制反转与依赖注入的关系

这部分我也思考了一下，认为网上有句话说的很对：简单地说，控制反转是一种设计思想，而依赖注入是控制反转思想的一种实现方式。
我认为，实际上控制反转就是我们将已有的类别放置到IoC容器中，便于让外部进行处理。而依赖注入是真正将具体的类别给属性完成注入的方式。

2. bean的配置

bean的别名配置——name属性配置

通过name属性进行name的别名配置：

<?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" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" /></beans>

这样，当我们在主代码里调用ctx.getBean("bookDao")和ctx.getBean("dao")，起到的效果是相同的：

package com.example.demo231116;import com.example.demo231116.dao.BookDao;
import com.example.demo231116.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo231116Application2 {public static void main(String[] args) {// 获取IoC容器ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao = (BookDao) ctx.getBean("dao");bookDao.save();}
}

bean的单例多例——scope属性配置

若保持别名配置里那样的bean配置，我们生成出来的bean是单例的，当我们执行以下代码：

BookDao bookDao = (BookDao) ctx.getBean("dao");
BookDao bookDao1 = (BookDao) ctx.getBean("dao");
System.out.println(bookDao);
System.out.println(bookDao1);

会得到结果：

com.example.demo231116.dao.impl.BookDaoImpl@309e345f
com.example.demo231116.dao.impl.BookDaoImpl@309e345f

两个对象出自同一个实例，但如果我们不希望它是以单例形式创建，而是以多例形式创建的时候，我们需要配置scope属性：

<?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" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" scope="prototype" /></beans>

scope有两个属性：singleton单例(默认)，prototype非单例
配置scope属性后再执行上面的代码，会得到结果：

com.example.demo231116.dao.impl.BookDaoImpl@309e345f
com.example.demo231116.dao.impl.BookDaoImpl@56a6d5a6

两个对象不出自同一个实例

bean为什么默认为单例？

如果每创建一个对象，都是不同的实例，那么对内存的消耗会很大

bean的作用范围说明

适合交给容器管理的bean：表现层对象、业务层对象、数据层对象、工具对象
不适合交给容器管理的bean：封装实体的域对象

bean的实例化

构造方法

当我们在Spring Config文件中配置：

<bean id="bookDao" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" />

这种bean的实例化默认调用无参构造方法，对于写有参构造，对有参构造中参数的注入则是上面依赖注入的部分

静态工厂

假如写了一个BookDao工厂BookDaoFactory.java：

package com.example.demo231116.factory;import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;public class BookDaoFactory {public static BookDao getBookDao(){System.out.println("Factory method....");return new BookDaoImpl();}
}

我们想让bean通过调用这个工厂方法返回里面的BookDaoImpl，则需要如下配置：

<bean id="bookDaoFactory" class="com.example.demo231116.factory.BookDaoFactory" factory-method="getBookDao" />

id属性和class属性与之前差异不大，分别为bean名称和bean类别，而factory-method指定具体地工厂方法

实例工厂

注意：实例工厂与静态工厂的区别是，实例工厂中的方法不是静态方法！
静态方法和非静态方法的区别是：

  • 静态方法可以在不建立该类对象的情况下，通过类名.方法进行调用
  • 非静态方法需要建立该类对象后，通过对象名.方法进行调用

详细可以看第4个笔记中的实验

假如写了一个BookDao工厂BookDaoFactory.java：

package com.example.demo231116.factory;import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;public class BookDaoFactory {public BookDao getBookDao(){System.out.println("Factory method....");return new BookDaoImpl();}
}

在配置文件中需要如下写：

<bean id="bookDaoFactory2" class="com.example.demo231116.factory.BookDaoFactory" />
<bean id="bd" factory-method="getBookDaoUnstatic" factory-bean="bookDaoFactory2"  />

即先建立出工厂类的bean，再建立下面这个使用该工厂方法的bean。factory-method指定其中具体的工厂方法，factory-bean指定工厂方法所属的父类，在最后调用的时候，直接调用bd就可以完成初始化：

BookDao bookDao3 = (BookDao) ctx.getBean("bd");
System.out.println(bookDao3);

在这种方法里，实际上我们创建出的bookFactory2这个bean没有被用到，所以还有如下的方法FactoryBean

FactoryBean

直接写一个工厂方法，implement FactoryBean。FactoryBean是一个泛型方法，指定其中的类型，实现其方法：
第一个getObject()返回具体地对象
第二个getObjectType()返回对象的类型

package com.example.demo231116.factory;import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;
import org.springframework.beans.factory.FactoryBean;public class BookDaoFactoryBean implements FactoryBean<BookDao>{@Overridepublic BookDao getObject() throws Exception {return new BookDaoImpl();}@Overridepublic Class<?> getObjectType() {return BookDao.class;}
}

如此，在bean配置中，只需要像原本普通的一行即可：

<bean id="bookDaoFactoryMethod" class="com.example.demo231116.factory.BookDaoFactoryBean" />

注意，当我们执行以下代码后，会发现打印出来的结果相同，说明这是单例模式创建的。

BookDao bookDao4 = (BookDao) ctx.getBean("bookDaoFactoryMethod");
BookDao bookDao5 = (BookDao) ctx.getBean("bookDaoFactoryMethod");
System.out.println(bookDao4);
System.out.println(bookDao5);

如果我们想要该工厂方法返回的不是单例模式，而是不同的实例，则我们需要补充FactoryBean中的isSingleton()方法，当这个方法设置为True时，就是用单例模式创建的对象，如果这个方法返回为False，就不会使用单例模式，每一次构造都会创建出新的对象：

@Override
public boolean isSingleton() {return true;
}

bean的生命周期

假如我们希望在建立bean时候执行一些资源的初始化，在bean销毁之前执行一些资源的销毁，我们就会需要考虑到bean的声明周期，通过以下方式进行生命周期的控制。

在类中提供生命周期控制方法，并在配置文件中配置init-method&destroy-method（配置）

定义实现类如下：

package com.example.demo231116.dao.impl;import com.example.demo231116.dao.BookDao;public class BookDaoImpl implements BookDao {public void save(){System.out.println("book dao save...");}public void init(){System.out.println("book dao init...");}public void destroy(){System.out.println("book dao destroy...");}
}

配置时，我们只需要指定具体的初始化方法init-method和销毁方法destroy-method即可：

<bean id="bookDaoCycle" class="com.example.demo231116.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy" />

这样，当我们在主函数中执行：

// IoC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDaoCycle");
System.out.println(bookDao);

结果是：

book dao init...
com.example.demo231116.dao.impl.BookDaoImpl@5dd6264

这时候的疑问可能是，为什么destroy方法没有被执行？
答案是：在程序执行结束之后，IoC容器还没有执行关闭操作，java虚拟机就已经强行关闭了。那么应该如何在java虚拟机关闭之前执行IoC容器关闭呢？如下有两种方法

通过ctx.close()执行IoC容器关闭

ApplicationContext并没有close方法，ApplicationContext下的一个接口ClassPathXmlApplicationContext才有定义close方法，所以这里想要使用close方法，需要修改IoC容器定义，然后在末尾调用ctx.close()

// IoC容器
ClassPathXmlApplicationContextctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDaoCycle");
System.out.println(bookDao);ctx.close()

输出结果为：

book dao init...
com.example.demo231116.dao.impl.BookDaoImpl@5dd6264
book dao destroy...

但是如果是这样的话，ctx.close()只能在程序的末尾写，因为在开头定义结束就写的话，这个IoC容器就被销毁了，也不可能执行一些getBean的操作，还有一个方法是通过注册钩子关闭IoC容器

通过注册关闭钩子执行IoC容器关闭

注册一个关闭钩子，在不用强行关闭IoC容器的情况下，设置在java虚拟机关闭之前让程序执行销毁的方法：

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.registerShutdownHook();BookDao bookDao = (BookDao) ctx.getBean("bookDaoCycle");
System.out.println(bookDao);

这样就不再需要强硬地执行ctx.close()方法了

实现接口来做和init和destroy（接口）

只需要在bean类下多实现InitializingBean和DisposableBean这两个接口，并实现其中的afterPropertiesSet和destroy方法：

package com.example.demo231116.dao.impl;import com.example.demo231116.dao.BookDao;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;public class BookDaoImpl implements BookDao, InitializingBean, DisposableBean {public void save(){System.out.println("book dao save...");}@Overridepublic void destroy() throws Exception {System.out.println("接口destroy");}@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("接口init");}
}

然后配置bean只需要简单地配置如下：

<bean id="bookDaoCycle" class="com.example.demo231116.dao.impl.BookDaoImpl" />

这个afterPropertiesSet的init方法，是在先执行属性设置后再执行init方法

bean的生命周期执行顺序

  • 初始化容器：
    创建对象（内存分配）
    执行构造方法
    执行属性注入（setter注入）
    执行bean的初始化方法
  • 使用bean
    执行业务操作
  • 关闭/销毁容器
    执行bean的销毁方法

3. 使用第三方包进行数据源的管理（例子：使用com.alibaba.druid进行数据库连接）

第一步：在pom.xml中导入坐标

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.21</version>
</dependency>

第二步：在bean中配置连接

在这里，首先应该查看这个Druid包给我们提供了一些什么方法。
先查看构造方法能否让我们通过构造注入写入一些配置信息，但在具体查看后发现是没有的（详细可见笔记7）。
但观察到可以通过setter注入来写一些配置信息，所以这里就使用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"><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="jdbc:mysql://localhost:3306/ecommercedb"/><property name="username" value="root"/><property name="password" value="123456"/><property name="driverClassName" value="com.mysql.jdbc.Driver" /></bean>
</beans>

4. 在配置文件中读取properties文件中的属性

第一步：建立jdbc.properties文件，内容如下

jdbc.url=jdbc:mysql://localhost:3306/ecommercedb
jdbc.username=root
jdbc.password=123456
jdbc.driverClassName=com.mysql.jdbc.Driver

第二步：开启context命名空间

我理解需要开辟新的命名空间，是读取非工程文件中的内容，而是读取外部文件中的内容

第三步：使用context命名空间加载指定properties文件

在这一步中需要通过location写清楚加载properties文件的位置

第四步：使用${}读取加载的属性值

第二——第四步具体代码如下，最终只需要通过${}读取加载的属性值即可：

<?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"><!--    1. 开启context命名空间-->
<!--    2. 使用context空间加载properties文件--><context:property-placeholder location="jdbc.properties"/>
<!--    3. 使用属性占位符${}读取properties文件中的属性--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/><property name="driverClassName" value="${jdbc.url}" /></bean>
</beans>

其他问题

  1. 假如在配置文件中写的是username=root，而不是jdbc.username=root，则可能使用${username}得到的结果并不会是root
    是因为系统环境变量里面有和properties里面定义的变量重名，则properties里面的变量不会被加载，也就是说系统环境变量的优先级会比properties里面的变量优先级高。
    为了使用properties里面面的变量，而不是系统环境变量，我们可以对xml配置文件，让系统环境变量不被使用：
<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>
  1. 加载多个properties文件可以用逗号分隔
<context:property-placeholder location="jdbc.properties, msg.properties"/>
  1. 加载所有properties文件可以用正则*.properties
<context:property-placeholder location="*.properties"/>
  1. 以上写法不够标准，标准的是classpath:*.properties
<context:property-placeholder location="classpath:*.properties"/>
  1. 如果不止要从工程中加载properties文件，还要从jar包等中加载，则写classpath*:*properties
<context:property-placeholder location="classpath*:*.properties"/>

第4、5种根据不同的需求来写

5. 关于IoC容器其他内容的总结与补充

创建容器的两种方式

相对路径导入

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

绝对路径导入

ApplicationContext ctx = new FileSystemXmlApplicationContext("E:\\Code\\Java\\SpringStudy\\project1\\src\\main\\resources\\applicationContext.xml");

获取Bean的三种方式

获取后强转类型

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

在获取时指定类型

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

通过类型获取Bean

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

容器类层次结构图

在这里插入图片描述

BeanFactory

这是最早的加载IoC容器的方法，使用BeanFactory的方法如下：

Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resource);
BookDao bookDao = bf.getBean(BookDao.class);
bookDao.save();

BeanFactory与我们现在ApplicationContext的区别在于：
BeanFactory是延迟加载bean，ApplicationContext是立即加载bean
即前者在没有getBean的时候是不会提前执行类的构造方法的，而Application就算没有getBean也会执行构造方法
如果想在ApplicationContext上实现延迟加载bean，只需要加参数：lazy-init="true"：

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

6. 复习内容

在这里插入图片描述
在这里插入图片描述

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

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

相关文章

web 渗透 信息搜集

web 渗透 信息搜集

一 收集域名信息 1.whois查询 whois&#xff08;读作“Who is”&#xff0c;非缩写&#xff09;&#xff0c;标准的互联网协议&#xff0c…
阅读更多...
Django的可重用HTML模板示例

Django的可重用HTML模板示例

01-配置并运行Django项目 首先按照博文 https://blog.csdn.net/wenhao_ir/article/details/131166889配置并运行Django项目。 02-创建可重用模板文件 templates目录下新建目录common&#xff0c;然后在目录common下新建文件&#xff1a;navbar.html&#xff0c;并写入下面的…
阅读更多...
高济健康：数字化科技创新与新零售碰撞 助推医疗产业优化升级

高济健康：数字化科技创新与新零售碰撞 助推医疗产业优化升级

近日&#xff0c;第六届中国国际进口博览会在上海圆满落幕&#xff0c;首次亮相的高济健康作为一家专注大健康领域的疾病和健康管理公司&#xff0c;在本届进博会上向业内外展示了围绕“15分钟步行健康生活圈”构建进行的全域数字化升级成果。高济健康通过数字化科技创新与新零…
阅读更多...
Linux下非root用户安装CUDA

Linux下非root用户安装CUDA

目录 前言 参考链接 步骤 一. 首先&#xff0c;需要查看系统版本&#xff1a; 二. 安装包下载。 下载CUDA&#xff1a; cuDNN下载 三. 开始安装CUDA和cuDNN 安装CUDA 修改环境变量 安装 cuDNN 查看是否安装成功&#xff0c;输入nvcc -V 前言 由于一些代码实现&…
阅读更多...
Java之SpringCloud Alibaba【九】【Spring Cloud微服务Skywalking】

Java之SpringCloud Alibaba【九】【Spring Cloud微服务Skywalking】

Java之SpringCloud Alibaba【一】【Nacos一篇文章精通系列】跳转Java之SpringCloud Alibaba【二】【微服务调用组件Feign】跳转Java之SpringCloud Alibaba【三】【微服务Nacos-config配置中心】跳转Java之SpringCloud Alibaba【四】【微服务 Sentinel服务熔断】跳转Java之Sprin…
阅读更多...
Java Web 实战 19 - What‘s HTTP ?

Java Web 实战 19 - What‘s HTTP ?

Whats HTTP ? 一 . HTTP 是什么 ?1.1 理解 HTTP 协议的工作过程1.2 HTTP 的报文格式1.2.1 准备工作1.2.2 认识 HTTP 协议的报文详情请求报文请求响应 二 . HTTP 请求报文2.1 URLURL 的 encode 2.2 HTTP 协议中的方法GETPOST常见面试题 : GET 和 POST 之间的区别 2.3 认识请求…
阅读更多...
关于修改了mysql的my_conf文件之后，不能生效问题

关于修改了mysql的my_conf文件之后，不能生效问题

个人名片&#xff1a; &#x1f405;作者简介&#xff1a;一名大三在校生&#xff0c;热爱生活&#xff0c;爱好敲码&#xff01; \ &#x1f485;个人主页 &#x1f947;&#xff1a;holy-wangle ➡系列内容&#xff1a; &#x1f5bc;️ tkinter前端窗口界面创建与优化 &…
阅读更多...
os.path.join函数用法

os.path.join函数用法

os.path.join()是Python中用于拼接文件路径的函数&#xff0c;它可以将多个字符串拼接成一个路径&#xff0c;并且会根据操作系统的规则自动使用合适的路径分隔符。 注&#xff1a;Linux用的是/分隔符&#xff0c;而Windows才用的是\。 该函数属于os.path模块&#xff0c;因此在…
阅读更多...
基于单片机的自动变速箱电控系统

基于单片机的自动变速箱电控系统

**单片机设计介绍&#xff0c; 基于单片机的自动变速箱电控系统 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 基于单片机的自动变速箱电控系统是一种通过单片机来控制车辆自动变速箱的系统。它借助传感器和单片机的协同工作&am…
阅读更多...
服务容错之限流之 Tomcat 限流 Tomcat 线程池的拒绝策略

服务容错之限流之 Tomcat 限流 Tomcat 线程池的拒绝策略

在文章开头&#xff0c;先和大家抛出两个问题&#xff1a; 每次提到服务限流为什么都不考虑基于 Tomcat 来做呢&#xff1f;大家有遇到过 Tomcat 线程池触发了拒绝策略吗&#xff1f; JUC 线程池 在谈 Tomcat 的线程池前&#xff0c;先看一下 JUC 中线程池的执行流程&#x…
阅读更多...
Java中利用OpenCV进行人脸识别

Java中利用OpenCV进行人脸识别

OpenCV 概述 ​ OpenCV&#xff08;Open Source Computer Vision Library&#xff09;是一个开源计算机视觉库&#xff0c;它提供了丰富的工具和算法&#xff0c;用于处理图像和视频数据。该库由一系列高效的计算机视觉算法组成&#xff0c;涵盖了许多领域&#xff0c;包括目…
阅读更多...
修改服务器端Apache默认根目录

修改服务器端Apache默认根目录

目标&#xff1a;修改默认Apache网站根目录 /var/www/html 一、找到 DocumentRoot “/var/www/html” 这一段 apache的根目录&#xff0c;把/var/www/html 这个目录改 #DocumentRoot "/var/www/html" DocumentRoot "/home/cloud/tuya_mini_h5/build" 二、…
阅读更多...
小程序如何添加打印机来打印订单

小程序如何添加打印机来打印订单

在采云小程序中&#xff0c;支持打印订单的小票、标签、发货单和电子面单。小票打印机用于打印小票&#xff0c;类似于超市小票、外卖小票等。标签打印机用于打印商品标签&#xff0c;类似于奶茶上面粘贴的标签&#xff0c;用于表示饮料名称和规格等。货单打印机用于打印发货单…
阅读更多...
【好奇心驱动力】ESP8266驱动SG90舵机开关灯

【好奇心驱动力】ESP8266驱动SG90舵机开关灯

0.前言 ESP8266弄丢了好几个都忘记放在哪&#xff0c;重新买了个typeC接口的方便多了&#xff0c;看到驱动SG90舵机作为智能开关&#xff0c;简单复现了一下&#xff0c;代码比较简单&#xff0c;没有连接小爱同学或者其他语音助手。 1.实验方法 ESP8266连接SG90舵机&#x…
阅读更多...
32位单片机PY32F040，主频72M，外设丰富，支持断码LCD

32位单片机PY32F040，主频72M，外设丰富，支持断码LCD

PY32F040 系列微控制器采用高性能的 32 位 ARM Cortex-M0 内核,宽电压工作范围的 MCU。嵌入高达 128 Kbytes flash 和 16 Kbytes SRAM 存储器,最高工作频率 72 MHz。LQFP64封装两块出头就可以拿到&#xff0c;我们还有开发板和开发资料帮助客户更好的开发。 PY32F040 系列微控…
阅读更多...
C# NAudio 音频库

C# NAudio 音频库

C# NAudio 音频库 NAudio安装NAudio简述简单示例1录制麦克风录制系统声卡WAV格式播放MP3格式播放AudioFileReader读取播放音频MediaFoundationReader 读取播放音频 NAudio安装 项目>NuGet包管理器 搜索NAudio点击安装&#xff0c;自动安装依赖库。 安装成功后工具箱会新增…
阅读更多...
视频推拉流EasyDSS直播点播平台获取指定时间快照的实现方法

视频推拉流EasyDSS直播点播平台获取指定时间快照的实现方法

视频推拉流直播点播系统EasyDSS平台&#xff0c;可提供流畅的视频直播、点播、视频推拉流、转码、管理、分发、录像、检索、时移回看等功能&#xff0c;可兼容多操作系统&#xff0c;在直播点播领域具有广泛的场景应用。为了便于用户集成、调用与二次开发。 今天我们来介绍下在…
阅读更多...
KT148A语音芯片使用串口uart本控制的完整说明_包含硬件和指令举例

KT148A语音芯片使用串口uart本控制的完整说明_包含硬件和指令举例

一、功能简介 KT148A肯定是支持串口的&#xff0c;有客户反馈使用一线还是不方便&#xff0c;比如一些大型的系统不适合有延时的操作&#xff0c;所以更加倾向于使用uart控制&#xff0c;这里我们也给出解决方案 延伸出来另外一个版本&#xff0c;KT158A 注意次版本芯片还是…
阅读更多...
ArcGIS Maps SDK for JS：监听图层的visible属性

ArcGIS Maps SDK for JS：监听图层的visible属性

文章目录 1 问题描述2 解决方案3 拓展 1 问题描述 近期有这么一个需求。在 ArcGIS Maps SDK for JavaScript 中&#xff0c;使用图层的visible属性同步显示某个组件&#xff0c;即打开图层时显示组件&#xff0c;关闭图层时隐藏组件。 首先想到的是&#xff0c;通过点击图层列…
阅读更多...
HTTP 到 HTTPS 再到 HSTS 的转变

HTTP 到 HTTPS 再到 HSTS 的转变

近些年&#xff0c;随着域名劫持、信息泄漏等网络安全事件的频繁发生&#xff0c;网站安全也变得越来越重要&#xff0c;也促成了网络传输协议从 HTTP 到 HTTPS 再到 HSTS 的转变。 HTTP HTTP&#xff08;超文本传输协议&#xff09; 是一种用于分布式、协作式和超媒体信息系…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023