Spring详细介绍 zh-Spring核心概念（1）

灰太狼 2023-09-24 20:00 108阅读 0赞

学习路线

在这里插入图片描述

1.Spring系统架构

  • Spring Framework:Spring框架，是Spring中最早最核心的技术，也是所有其他技术的基础。
  • SpringBoot:Spring是来简化开发，而SpringBoot是来帮助Spring在简化的基础上能更快速进行开发。
  • SpringCloud:这个是用来做分布式之微服务架构的相关开发。
    在这里插入图片描述

(1)核心层

  • Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

(2)AOP层

  • AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
  • Aspects:AOP是思想,Aspects是对AOP思想的具体实现

(3)数据层

  • Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
  • Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
  • Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容

(4)Web层

  • 这一层的内容将在SpringMVC框架具体学习

(5)Test层

  • Spring主要整合了Junit来完成单元测试和集成测试

2.Spring核心概念

Spring核心概念这部分内容中主要包含IOC/DI、IOC容器和Bean,那么问题就来了，这些都是什么呢?

在这里插入图片描述

(1)业务层需要调用数据层的方法，就需要在业务层new数据层的对象

(2)如果数据层的实现类发生变化，那么业务层的代码也需要跟着改变，发生变更后，都需要进行编译打包和重部署

(3)所以，现在代码在编写的过程中存在的问题是：耦合度偏高

在这里插入图片描述
业务层不想new对象，运行的时候*转换为由外部提供对象
这种实现思就是Spring的一个核心概念

3.IOC

1)理解IOC

(1)什么是控制反转呢？

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。

  • 业务层要用数据层的类对象，以前是自己new的
  • 现在自己不new了，交给别人[外部]来创建对象
  • 别人[外部]就反转控制了数据层对象的创建权
  • 这种思想就是控制反转,也就是利用IOC容器实现数据的注入

(2)Spring和IOC之间的关系是什么呢?

  • Spring技术对IOC思想进行了实现
  • Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的”外部”
  • IOC思想中的别人[外部]指的就是Spring的IOC容器

(3)IOC容器的作用以及内部存放的是什么?

  • IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
  • 被创建或被管理的对象在IOC容器中统称为Bean
  • IOC容器中放的就是一个个的Bean对象

(4)当IOC容器中创建好service和dao对象后，程序能正确执行么?

  • 不行，因为service运行需要依赖dao对象
  • IOC容器中虽然有service和dao对象
  • 但是service对象和dao对象没有任何关系
  • 需要把dao对象交给service,也就是说要绑定service和dao对象之间的关系
  • 在容器中建立对象与对象之间的绑定关系就要用到DI,也就是依赖注入

2)bean基础配置

在这里插入图片描述

(1)id与class

在这里插入图片描述
思考：

  • class属性能不能写接口如BookDao的类全名呢?

  • 不行，因为接口是没办法创建对象的。

(2)bean的name属性

在这里插入图片描述

(3)bean作用范围scope配置

在这里插入图片描述

bean的创建单例

默认情况下，Spring创建的bean对象都是单例的

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.     <bean id="bookDao" class="com.amy.dao.impl.BookDaoImpl"/>
  6.     <bean id="bookService" class="com.amy.service.impl.BookServiceImpl">
  7.         <property name="bookDao" ref="bookDao"/>
  8.     </bean>
  10. </beans>
  12. public class App2 {
  14.     public static void main(String[] args) {
  16.         //获取IoC容器
  17.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  18.         BookService bookService1 = (BookService) ctx.getBean("bookService");
  19.         BookService bookService2 = (BookService) ctx.getBean("bookService");
  20.         System.out.println(bookService1);
  21.         System.out.println(bookService2);
  22.     }
  23. }
  25. com.amy.service.impl.BookServiceImpl@ff5b51f
  26. com.amy.service.impl.BookServiceImpl@ff5b51f

bean的创建非单例

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <!--name:为bean指定别名，别名可以有多个，使用逗号，分号，空格进行分隔-->
  7.     <bean id="bookService" name="service service4 bookEbi" class="com.amy.service.impl.BookServiceImpl">
  8.         <property name="bookDao" ref="bookDao"/>
  9.     </bean>
  11.     <!--scope：为bean设置作用范围，可选值为单例singloton，非单例prototype-->
  12.     <bean id="bookDao" name="dao" class="com.iamy.dao.impl.BookDaoImpl" scope="prototype"/>
  13. </beans>
  15. public class App2 {
  17.     public static void main(String[] args) {
  19.         //获取IoC容器
  20.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  21.         BookService bookService1 = (BookService) ctx.getBean("bookService");
  22.         BookService bookService2 = (BookService) ctx.getBean("bookService");
  23.         System.out.println(bookService1);
  24.         System.out.println(bookService2);
  25.     }
  26. }
  28. com.amy.dao.impl.BookDaoImpl@ff5b51f
  29. com.amy.dao.impl.BookDaoImpl@25bbe1b6

使用bean的scope属性可以控制bean的创建是否为单例：

  • singleton默认为单例
  • prototype为非单例

scope使用后续思考

介绍完scope属性以后，我们来思考几个问题:

  • 为什么bean默认为单例?

    • bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
    • bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高

  • bean在容器中是单例的，会不会产生线程安全问题?

    • 如果对象是有状态对象，即该对象有成员变量可以用来存储数据的，
    • 因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
    • 如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的，
    • 因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。

  • 哪些bean对象适合交给容器进行管理?

    • 表现层对象
    • 业务层对象
    • 数据层对象
    • 工具对象

  • 哪些bean对象不适合交给容器进行管理?

    • 封装实例的域对象，因为会引发线程安全问题，所以不适合。

3)bean实例化

  • 实例化bean的三种方式，构造方法,静态工厂和实例工厂
  • bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的。

构造方法

  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  9.     public BookDaoImpl() {
  11.         System.out.println("book dao constructor is running ....");
  12.     }
  14.     public void save() {
  16.         System.out.println("book dao save ...");
  17.     }
  19. }
  21. <?xml version="1.0" encoding="UTF-8"?>
  22. <beans xmlns="http://www.springframework.org/schema/beans"
  23.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  24.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  26.     <bean id="bookDao" class="com.amy.dao.impl.BookDaoImpl"/>
  28. </beans>
  30. public class AppForInstanceBook {
  32.     public static void main(String[] args) {
  35.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  37.         BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  39.         bookDao.save();
  41.     }
  42. }
  44. book dao constructor is running ....
  45. book dao save ...

将构造函数改成private测试

  1. public class BookDaoImpl implements BookDao {
  4.     private BookDaoImpl() {
  6.         System.out.println("book dao constructor is running ....");
  7.     }
  9.     public void save() {
  11.         System.out.println("book dao save ...");
  12.     }
  14. }
  16. public class AppForInstanceBook {
  18.     public static void main(String[] args) {
  21.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  23.         BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  25.         bookDao.save();
  27.     }
  28. }
  30. book dao constructor is running ....
  31. book dao save ...
  • private和public的构造函数能都运行的原因是Spring底层用的反射

构造函数中添加一个参数测试

  1. public class BookDaoImpl implements BookDao {
  3.     private BookDaoImpl(int i) {
  5.         System.out.println("book dao constructor is running ....");
  6.     }
  7.     public void save() {
  9.         System.out.println("book dao save ...");
  10.     }
  12. }

在这里插入图片描述

  • 程序会报错，说明Spring底层使用的是类的无参构造方法。

静态工厂

1.工厂方式创建bean

  1. public interface OrderDao {
  3.     public void save();
  4. }
  6. public class OrderDaoImpl implements OrderDao {
  8.     public void save() {
  10.         System.out.println("order dao save ...");
  11.     }
  12. }
  14. //静态工厂创建对象
  15. public class OrderDaoFactory {
  17.     public static OrderDao getOrderDao(){
  19.         System.out.println("factory setup....");
  20.         return new OrderDaoImpl();
  21.     }
  22. }
  24. public class AppForInstanceOrder {
  26.     public static void main(String[] args) {
  28.         //通过静态工厂创建对象
  29.         OrderDao orderDao = OrderDaoFactory.getOrderDao();
  30.         orderDao.save();
  31.     }
  32. }
  34. factory setup....
  35. order dao save ...

2. 静态工厂实例化

在这里插入图片描述
在spring的配置文件application.properties中添加以下内容:

  1. <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
  • class:工厂类的类全名

  • factory-mehod:具体工厂类中创建对象的方法名

    public interface OrderDao {

    1. public void save();

    }

    public class OrderDaoImpl implements OrderDao {

    1. public void save() {
    3.     System.out.println("order dao save ...");
    4. }

    }

    //静态工厂创建对象
    public class OrderDaoFactory {

    1. public static OrderDao getOrderDao(){
    3.     System.out.println("factory setup....");
    4.     return new OrderDaoImpl();
    5. }

    }

    public class AppForInstanceOrder {

    1. public static void main(String[] args) {
    3. //静态工厂实例化
    4.     ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    6.     OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
    8.     orderDao.save();
    9. }

    }

    factory setup….
    order dao save …

实例工厂

1.实例工厂方式创建bean

  1. public interface OrderDao {
  3.     public void save();
  4. }
  6. public class OrderDaoImpl implements OrderDao {
  8.     public void save() {
  10.         System.out.println("order dao save ...");
  11.     }
  12. }
  14. //创建实例工厂对象
  15. public class OrderDaoFactory {
  17. //并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法
  18.     public OrderDao getOrderDao(){
  20.         System.out.println("factory setup....");
  21.         return new OrderDaoImpl();
  22.     }
  23. }
  25. public class AppForInstanceOrder {
  27.     public static void main(String[] args) {
  29.         //创建实例工厂对象
  30.         OrderDaoFactory orderDaoFactory= new OrderDaoFactory();
  31.         //通过实例工厂对象创建对象
  32.         OrderDao orderDao = orderDaoFactory.getOrderDao();
  33.         orderDao.save();
  34.     }
  35. }
  37. factory setup....
  38. order dao save ...

2.实例工厂实例化

在这里插入图片描述

  1. <!--方式三：使用实例工厂实例化bean-->
  2.     <bean id="orderDaoFactory" class="com.amy.factory.OrderDaoFactory"/>
  3.     <bean id="orderDao" factory-method="getOrderDao" factory-bean="orderDaoFactory" />
  5. public interface OrderDao {
  7.     public void save();
  8. }
  10. public class OrderDaoImpl implements OrderDao {
  12.     public void save() {
  14.         System.out.println("order dao save ...");
  15.     }
  16. }
  18. //创建实例化工厂对象
  19. public class OrderDaoFactory {
  21. //去掉static，创建实例化工厂对象
  22.     public OrderDao getOrderDao(){
  24.         System.out.println("factory setup....");
  25.         return new OrderDaoImpl();
  26.     }
  27. }
  29. public class AppForInstanceOrder {
  31.     public static void main(String[] args) {
  33.                ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  35.         OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
  37.         orderDao.save();
  38.     }
  39. }
  41. factory setup....
  42. order dao save ...

3.FactoryBean的使用

实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以Spring为了简化这种配置方式就提供了一种叫FactoryBean的方式来简化开发。

  1. <!--方式四：使用FactoryBean实例化bean-->
  2.     <bean id="orderDao" class="com.amy.factory.UserDaoFactoryBean"/>
  4. public interface OrderDao {
  6.     public void save();
  7. }
  9. public class OrderDaoImpl implements OrderDao {
  11.     public void save() {
  13.         System.out.println("order dao save ...");
  14.     }
  15. }
  17. //创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法
  18. public class OrderDaoFactoryBean implements FactoryBean<OrderDao> {
  20.     //代替原始实例工厂中创建对象的方法
  21.     public OrderDao getObject() throws Exception {
  23.         System.out.println("factory setup....");
  24.         return new OrderDaoImpl();
  25.     }
  26.     //返回所创建类的Class对象
  27.     public Class<?> getObjectType() {
  28.     return OrderDao.class;
  29.     }
  30. }
  32. public class AppForInstanceOrder {
  34.     public static void main(String[] args) {
  36.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  38.         OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
  40.         orderDao.save();
  42.     }
  43. }
  45. factory setup....
  46. order dao save ...

这种方式在Spring去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。

  1. //创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法
  2. public class OrderDaoFactoryBean implements FactoryBean<OrderDao> {
  4.     //代替原始实例工厂中创建对象的方法
  5.     public OrderDao getObject() throws Exception {
  7.         System.out.println("factory setup....");
  8.         return new OrderDaoImpl();
  9.     }
  10.     //返回所创建类的Class对象
  11.     public Class<?> getObjectType() {
  12.     return OrderDao.class;
  13.     }
  14. }

查看源码会发现，FactoryBean接口其实会有三个方法，分别是:

  1. T getObject() throws Exception;
  3. Class<?> getObjectType();
  5. default boolean isSingleton() {
  7.         return true;
  8. }

方法一:getObject()，被重写后，在方法中进行对象的创建并返回

方法二:getObjectType(),被重写后，主要返回的是被创建类的Class对象

方法三:没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true，从意思上来看，我们猜想默认应该是单例，如何来验证呢?

思路很简单，就是从容器中获取该对象的多个值，打印到控制台，查看是否为同一个对象。

4)bean的生命周期

具体的控制有两个阶段:

  • bean创建之后，想要添加内容，比如用来初始化需要用到资源
  • bean销毁之前，想要添加内容，比如用来释放用到的资源
    步

(1)bean的生命周期步骤

步骤1:添加初始化和销毁方法

BooDaoImpl类中分别添加两个方法，方法名任意

  1. public class BookDaoImpl implements BookDao {
  3.     public void save() {
  5.         System.out.println("book dao save ...");
  6.     }
  7.     //表示bean初始化对应的操作
  8.     public void init(){
  10.         System.out.println("init...");
  11.     }
  12.     //表示bean销毁前对应的操作
  13.     public void destory(){
  15.         System.out.println("destory...");
  16.     }
  18. }

步骤2:配置生命周期

  1. <!--init-method：设置bean初始化生命周期回调函数-->
  2.     <!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象-->
  3.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

步骤3:运行程序

  1. public interface BookDao {
  3.     public void save();
  4. }
  5. public class BookDaoImpl implements BookDao {
  7.     public void save() {
  9.         System.out.println("book dao save ...");
  10.     }
  11.     //表示bean初始化对应的操作
  12.     public void init(){
  14.         System.out.println("init...");
  15.     }
  16.     //表示bean销毁前对应的操作
  17.     public void destory(){
  19.         System.out.println("destory...");
  20.     }
  22. }
  24. public class AppForLifeCycle {
  26.     public static void main( String[] args ) {
  28.         ApplicationContext ctx = new 
  29.             ClassPathXmlApplicationContext("applicationContext.xml");
  30.         BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  31.         bookDao.save();
  32.     }
  33. }
  35. <?xml version="1.0" encoding="UTF-8"?>
  36. <beans xmlns="http://www.springframework.org/schema/beans"
  37.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  38.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  40.     <!--init-method：设置bean初始化生命周期回调函数-->
  41.     <!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象-->
  42.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
  43.     </beans>
  45. init...
  46. book dao save ...

init方法执行了，但是destroy方法却未执行，这是为什么呢?

  • Spring的IOC容器是运行在JVM中
  • 运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象，然后调方法执行
  • main方法执行完后，JVM退出，这个时候IOC容器中的bean还没有来得及销毁就已经结束了
  • 所以没有调用对应的destroy方法

(2)close关闭容器

  • ApplicationContext中没有close方法

  • 需要将ApplicationContext更换成ClassPathXmlApplicationContext

    1. ClassPathXmlApplicationContext ctx = new 
    2.     ClassPathXmlApplicationContext("applicationContext.xml");

  • 调用ctx的close()方法

    1. ctx.close();

    public class AppForLifeCycle {

    1. public static void main( String[] args ) {
    3.     ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    5.     BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    6.     bookDao.save();
    7.     ctx.close();

    }
    }

    init…
    book dao save …
    destory…

(3)注册钩子关闭容器

  • 在容器未关闭之前，提前设置好回调函数，让JVM在退出之前回调此函数来关闭容器

  • 调用ctx的registerShutdownHook()方法

    1. ctx.registerShutdownHook();

    注意:registerShutdownHook在ApplicationContext中也没有

    public class AppForLifeCycle {

    1. public static void main( String[] args ) {
    3.     ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    5.     BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    6.     bookDao.save();
    7.     //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
    8.     ctx.registerShutdownHook();
    9. }

    }

    init…
    book dao save …
    destory…

两种方式介绍完后，close和registerShutdownHook选哪个?

相同点:这两种都能用来关闭容器

不同点:close()是在调用的时候关闭，registerShutdownHook()是在JVM退出前调用关闭。

(4)InitializingBean， DisposableBean实现接口

分析上面的实现过程，会发现添加初始化和销毁方法，即需要编码也需要配置，实现起来步骤比较多也比较乱。

Spring提供了两个接口来完成生命周期的控制，好处是可以不用再进行配置init-method和destroy-method

接下来在BookServiceImpl完成这两个接口的使用:

修改BookServiceImpl类，添加两个接口InitializingBean， DisposableBean并实现接口中的两个方法afterPropertiesSet和destroy

  1. public interface BookDao {
  3.     public void save();
  4. }
  5. public class BookDaoImpl implements BookDao {
  7.     public void save() {
  9.         System.out.println("book dao save ...");
  10.     }
  11.     //表示bean初始化对应的操作
  12.     public void init(){
  14.         System.out.println("init...");
  15.     }
  16.     //表示bean销毁前对应的操作
  17.     public void destory(){
  19.         System.out.println("destory...");
  20.     }
  22. }
  24. public interface BookService {
  26.     public void save();
  27. }        
  28. public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
  30.     private BookDao bookDao;
  31.     public void setBookDao(BookDao bookDao) {
  33.         this.bookDao = bookDao;
  34.     }
  35.     public void save() {
  37.         System.out.println("book service save ...");
  38.         bookDao.save(); 
  39.     }
  40.     public void destroy() throws Exception {
  42.         System.out.println("service destroy");
  43.     }
  44.     public void afterPropertiesSet() throws Exception {
  46.         System.out.println("service init");
  47.     }
  48. }
  51. public class AppForLifeCycle {
  53.     public static void main( String[] args ) {
  55.         ApplicationContext ctx = new 
  56.             ClassPathXmlApplicationContext("applicationContext.xml");
  57.         BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  58.         bookDao.save();
  59.         ctx.close();
  60.     }
  61. }
  63. <?xml version="1.0" encoding="UTF-8"?>
  64. <beans xmlns="http://www.springframework.org/schema/beans"
  65.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  66.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  68.     <!--init-method：设置bean初始化生命周期回调函数-->
  69.     <!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象-->
  70.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
  72.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  73.         <property name="bookDao" ref="bookDao"/>
  74.     </bean>
  76. </beans>

在这里插入图片描述

(5)bean生命周期小结

(1)关于Spring中对bean生命周期控制提供了两种方式:

  • 在配置文件中的bean标签中添加init-method和destroy-method属性
  • 类实现InitializingBean与DisposableBean接口，这种方式了解下即可。

(2)对于bean的生命周期控制在bean的整个生命周期中所处的位置如下:

  • 初始化容器

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

  • 使用bean

    • 1.执行业务操作

  • 关闭/销毁容器

    • 1.执行bean销毁方法

(3)关闭容器的两种方式:

  • ConfigurableApplicationContext是ApplicationContext的子类

    • close()方法
    • registerShutdownHook()方法

4.DI（Dependency Injection）依赖注入

在这里插入图片描述

1)理解依赖注入，IOC容器中bean之间关系

(1)什么是依赖注入呢?

  • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

    • 业务层要用数据层的类对象，以前是自己new的
    • 现在自己不new了，靠别人[外部其实指的就是IOC容器]来给注入进来
    • 这种思想就是依赖注入

(2)IOC容器中哪些bean之间要建立依赖关系呢?

  • 根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系

Spring的IOC和DI的使用目的：充分解耦，具体实现靠:

  • 使用IOC容器管理bean（IOC)
  • 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
  • 最终结果为:使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系.

2）不使用IOC容器创建Bean

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.   <modelVersion>4.0.0</modelVersion>
  7.   <groupId>com.itheima</groupId>
  8.   <artifactId>spring_01_quickstart</artifactId>
  9.   <version>1.0-SNAPSHOT</version>
  11.   <dependencies>
  12.     <dependency>
  13.       <groupId>org.springframework</groupId>
  14.       <artifactId>spring-context</artifactId>
  15.       <version>5.2.10.RELEASE</version>
  16.     </dependency>
  17.     <dependency>
  18.       <groupId>junit</groupId>
  19.       <artifactId>junit</artifactId>
  20.       <version>4.12</version>
  21.       <scope>test</scope>
  22.     </dependency>
  23.   </dependencies>
  24. </project>
  26. public interface BookDao {
  28.     public void save();
  29. }
  31. public class BookDaoImpl implements BookDao {
  33.     public void save() {
  35.         System.out.println("book dao save ...");
  36.     }
  37. }
  39. public interface BookService {
  41.     public void save();
  42. }

Spring的IOC入门案例已经完成，但是在BookServiceImpl的类中依然存在BookDaoImpl对象的new操作，它们之间的耦合度还是比较高，这块该如何解决，就需要用到下面的DI:依赖注入。

  1. public class BookServiceImpl implements BookService {
  3.     private BookDao bookDao = new BookDaoImpl();
  5.     public void save() {
  7.         System.out.println("book service save ...");
  8.         bookDao.save();
  9.     }
  11. }
  13. public class App {
  15.     public static void main(String[] args) {
  17.         BookService bookService = new BookServiceImpl();
  18.         bookService.save();
  19.     }
  20. }
  22. book service save ...
  23. book dao save ...

3) setter注入

需求:基于IOC入门案例，在BookServiceImpl类中删除new对象的方式，使用Spring的DI完成Dao层的注入

1.删除业务层中使用new的方式创建的dao对象

2.在业务层提供BookDao的setter方法

3.在配置文件中添加依赖注入的配置

4.运行程序调用方法

  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  8.     public void save() {
  10.         System.out.println("book dao save ...");
  11.     }
  12. }
  14. public interface BookService {
  16.     public void save();
  17. }
  19. public class BookServiceImpl implements BookService {
  22.     private BookDao bookDao;
  24.     public void save() {
  26.         System.out.println("book service save ...");
  27.         bookDao.save();
  28.     }
  29.     //提供对应的set方法
  30.     public void setBookDao(BookDao bookDao) {
  32.         this.bookDao = bookDao;
  33.     }
  34. }
  36. <?xml version="1.0" encoding="UTF-8"?>
  37. <beans xmlns="http://www.springframework.org/schema/beans"
  38.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  39.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  40.     <!--1.导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
  42.     <!--2.配置bean-->
  43.     <!--bean标签标示配置bean
  44.     id属性标示给bean起名字
  45.     class属性表示给bean定义类型-->
  46.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  48.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  49.         <!--7.配置server与dao的关系-->
  50.         <!--property标签表示配置当前bean的属性
  51.         name属性表示配置哪一个具体的属性
  52.         ref属性表示参照哪一个bean-->
  53.         <property name="bookDao" ref="bookDao"/>
  54.     </bean>
  56. </beans>
  58. public class App2 {
  60.     public static void main(String[] args) {
  62.         //获取IoC容器
  63.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  64.         BookService bookService = (BookService) ctx.getBean("bookService");
  65.         bookService.save();
  67.     }
  68. }
  70. book service save ...
  71. book dao save ...

注意:配置中的两个bookDao的含义是不一样的

  • name=”bookDao”中bookDao的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前面加set找对应的setBookDao()方法进行对象注入
  • ref=”bookDao”中bookDao的作用是让Spring能在IOC容器中找到id为bookDao的Bean对象给bookService进行注入
    在这里插入图片描述

2）构造器注入

(1)项目中添加BookDao、BookDaoImpl、UserDao、UserDaoImpl、BookService和BookServiceImpl类

  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  9.     private String databaseName;
  10.     private int connectionNum;
  12.     public void save() {
  14.         System.out.println("book dao save ...");
  15.     }
  16. }
  17. public interface UserDao {
  19.     public void save();
  20. }
  21. public class UserDaoImpl implements UserDao {
  23.     public void save() {
  25.         System.out.println("user dao save ...");
  26.     }
  27. }
  29. public interface BookService {
  31.     public void save();
  32. }
  34. public class BookServiceImpl implements BookService{
  36.     private BookDao bookDao;
  38.     public void setBookDao(BookDao bookDao) {
  39.     //set方式注入
  40.         this.bookDao = bookDao;
  41.     }
  43.     public void save() {
  45.         System.out.println("book service save ...");
  46.         bookDao.save();
  47.     }
  48. }

(2)resources下提供spring的配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5. <!--    配置文件中进行配置set方式注入-->
  6.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  7.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  8.         <property name="bookDao" ref="bookDao"/>
  9.     </bean>
  10. </beans>

(3)编写AppForDIConstructor运行类，加载Spring的IOC容器，并从中获取对应的bean对象

  1. public class AppForDIConstructor {
  3.     public static void main( String[] args ) {
  5.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  6.         BookService bookService = (BookService) ctx.getBean("bookService");
  7.         bookService.save();
  8.     }
  9. }
  11. book service save ...
  12. book dao save ...

(1)构造器注入引用数据类型

接下来，在上面这个环境中来完成构造器注入的学习:

需求：将BookServiceImpl类中的bookDao修改成使用构造器的方式注入。

1.将bookDao的setter方法删除掉

2.添加带有bookDao参数的构造方法

3.在applicationContext.xml中配置

步骤1:删除setter方法并提供构造方法

1.将bookDao的setter方法删除掉, 2.添加带有bookDao参数的构造方法

  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  9.     private String databaseName;
  10.     private int connectionNum;
  12.     public void save() {
  14.         System.out.println("book dao save ...");
  15.     }
  16. }
  18. public interface BookService {
  20.     public void save();
  21. }
  23. public class BookServiceImpl implements BookService{
  25.     private BookDao bookDao;
  27.    // public void setBookDao(BookDao bookDao) {
  29.         //this.bookDao = bookDao;
  30.     //}
  31.     //在BookServiceImpl类中将bookDao的setter方法删除掉,并添加带有bookDao参数的构造方法
  32.     public BookServiceImpl(BookDao bookDao) {
  34.         this.bookDao = bookDao;
  35.     }
  36.     public void save() {
  38.         System.out.println("book service save ...");
  39.         bookDao.save();
  40.     }
  41. }
步骤2:配置文件中进行配置构造方式注入

在applicationContext.xml中配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5. <!--    配置文件中进行配置构造方式注入-->
  6.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  7.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  8.         <constructor-arg name="bookDao" ref="bookDao"/>
  9.     </bean>
  10. </beans>

标签中

  • name属性对应的值为构造函数中方法形参的参数名，必须要保持一致。
  • ref属性指向的是spring的IOC容器中其他bean对象。
步骤3：运行程序
  1. book service save ...
  2. book dao save ...

(2)构造器注入多个引用数据类型

需求:在BookServiceImpl使用构造函数注入多个引用数据类型，比如userDao

1.声明userDao属性

2.生成一个带有bookDao和userDao参数的构造函数

3.在applicationContext.xml中配置注入
在BookServiceImpl声明userDao并提供多个参数的构造函数

步骤1:提供多个属性的构造函数
  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  9.     private String databaseName;
  10.     private int connectionNum;
  12.     public void save() {
  14.         System.out.println("book dao save ...");
  15.     }
  16. }
  17. public interface UserDao {
  19.     public void save();
  20. }
  21. public class UserDaoImpl implements UserDao {
  23.     public void save() {
  25.         System.out.println("user dao save ...");
  26.     }
  27. }
  29. public interface BookService {
  31.     public void save();
  32. }
  34. public class BookServiceImpl implements BookService{
  36.     private BookDao bookDao;//提供多个属性的构造函数
  37.     private UserDao userDao;
  39.     public BookServiceImpl(BookDao bookDao,UserDao userDao) {
  41.         this.bookDao = bookDao;
  42.         this.userDao = userDao;
  43.     }
  45.     public void save() {
  47.         System.out.println("book service save ...");
  48.         bookDao.save();
  49.         userDao.save();
  50.     }
  51. }
步骤2:配置文件中配置多参数注入

在applicationContext.xml中配置注入

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  7.     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
  8.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  9.         <constructor-arg name="bookDao" ref="bookDao"/>
  10.         <constructor-arg name="userDao" ref="userDao"/>
  11.     </bean>
  12. </beans>

**说明:**这两个<contructor-arg>的配置顺序可以任意

步骤3:运行程序

运行AppForDIConstructor类，查看结果，说明userDao已经成功注入。

  1. book service save ...
  2. book dao save ...

(3)构造器注入多个简单数据类型

需求:在BookDaoImpl中，使用构造函数注入databaseName和connectionNum两个参数。

参考引用数据类型的注入，我们可以推出具体的步骤为:

1.提供一个包含这两个参数的构造方法

2.在applicationContext.xml中进行注入配置

  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  9.     private String databaseName;
  10.     private int connectionNum;
  12.     public void save() {
  14.         System.out.println("book dao save ..."+databaseName+","+connectionNum);
  15.     }
  16. }
  17. public interface UserDao {
  19.     public void save();
  20. }
  21. public class UserDaoImpl implements UserDao {
  23.     public void save() {
  25.         System.out.println("user dao save ...");
  26.     }
  27. }
  29. public interface BookService {
  31.     public void save();
  32. }
  33. public class BookServiceImpl implements BookService{
  35.     private BookDao bookDao;
  36.     private UserDao userDao;
  38.     public BookServiceImpl(BookDao bookDao, UserDao userDao) {
  40.         this.bookDao = bookDao;
  41.         this.userDao = userDao;
  42.     }
  44.     public void save() {
  46.         System.out.println("book service save ...");
  47.         bookDao.save();
  48.         userDao.save();
  49.     }
  50. }
  51. public class AppForDIConstructor {
  53.     public static void main( String[] args ) {
  55.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  56.         BookService bookService = (BookService) ctx.getBean("bookService");
  57.         bookService.save();
  58.     }
  59. }
步骤1:添加多个简单属性并提供构造方法

修改BookDaoImpl类，添加构造方法

  1. public class BookDaoImpl implements BookDao {
  3.     private String databaseName;
  4.     private int connectionNum;
  6.     public BookDaoImpl(String databaseName, int connectionNum) {
  8.         this.databaseName = databaseName;
  9.         this.connectionNum = connectionNum;
  10.     }
  12.     public void save() {
  14.         System.out.println("book dao save ..."+databaseName+","+connectionNum);
  15.     }
  16. }
步骤2:配置完成多个属性构造器注入

在applicationContext.xml中进行注入配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
  7.         <constructor-arg name="databaseName" value="mysql"/>
  8.         <constructor-arg name="connectionNum" value="666"/>
  9.     </bean>
  10.     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
  11.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  12.         <constructor-arg name="bookDao" ref="bookDao"/>
  13.         <constructor-arg name="userDao" ref="userDao"/>
  14.     </bean>
  15. </beans>

**说明:**这两个<contructor-arg>的配置顺序可以任意

步骤3:运行程序

运行AppForDIConstructor类，查看结果

  1. book service save ...
  2. book dao save ...mysql,666

(4)构造函数中方法的参数名发生变化

在这里插入图片描述

  • 当构造函数中方法的参数名发生变化后，配置文件中的name属性也需要跟着变
  • 这两块存在紧耦合，具体该如何解决?
方式一:删除name属性，添加type属性，按照类型注入
  1. <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
  2.     <constructor-arg type="int" value="10"/>
  3.     <constructor-arg type="java.lang.String" value="mysql"/>
  4. </bean>
  6. * 这种方式可以解决构造函数形参名发生变化带来的耦合问题
  7. * 但是如果构造方法参数中有类型相同的参数，这种方式就不太好实现了
方式二:删除type属性，添加index属性，按照索引下标注入，下标从0开始
  1. <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
  2.     <constructor-arg index="1" value="100"/>
  3.     <constructor-arg index="0" value="mysql"/>
  4. </bean>
  • 这种方式可以解决参数类型重复问题
  • 但是如果构造方法参数顺序发生变化后，这种方式又带来了耦合问题
注入方式如何选择

  1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现

    • 强制依赖指对象在创建的过程中必须要注入指定的参数

  2. 可选依赖使用setter注入进行，灵活性强

    • 可选依赖指对象在创建过程中注入的参数可有可无
  3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
  5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
  6. 自己开发的模块推荐使用setter注入
总结：Spring的依赖注入的实现方式:

  • setter注入

    • 简单数据类型

      1. <bean ...>
      2.     <property name="" value=""/>
      3. </bean>

    • 引用数据类型

      1. <bean ...>
      2.     <property name="" ref=""/>
      3. </bean>

  • 构造器注入

    • 简单数据类型

      1. <bean ...>
      2.     <constructor-arg name="" index="" type="" value=""/>
      3. </bean>

    • 引用数据类型

      1. <bean ...>
      2.     <constructor-arg name="" index="" type="" ref=""/>
      3. </bean>

  • 依赖注入的方式选择上

    • 建议使用setter注入
    • 第三方技术根据情况选择

3) 自动配置

(1)什么是依赖自动装配?

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

(2)自动装配方式有哪些?

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

(3) 未自动装配代码

(1)项目中添加BookDao、BookDaoImpl、BookService和BookServiceImpl类

  1. public interface BookDao {
  3.     public void save();
  4. }
  6. public class BookDaoImpl implements BookDao {
  9.     private String databaseName;
  10.     private int connectionNum;
  12.     public void save() {
  14.         System.out.println("book dao save ...");
  15.     }
  16. }
  17. public interface BookService {
  19.     public void save();
  20. }
  22. public class BookServiceImpl implements BookService{
  24.     private BookDao bookDao;
  26.     public void setBookDao(BookDao bookDao) {
  28.         this.bookDao = bookDao;
  29.     }
  31.     public void save() {
  33.         System.out.println("book service save ...");
  34.         bookDao.save();
  35.     }
  36. }

(2)resources下提供spring的配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  7.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  8.         <property name="bookDao" ref="bookDao"/>
  9.     </bean>
  10. </beans>

(3)编写AppForAutoware运行类，加载Spring的IOC容器，并从中获取对应的bean对象

  1. public class AppForAutoware {
  3.     public static void main( String[] args ) {
  5.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  6.         BookService bookService = (BookService) ctx.getBean("bookService");
  7.         bookService.save();
  8.     }
  9. }
  11. book service save ...
  12. book dao save ...

(4)完成自动装配的配置

自动装配只需要修改applicationContext.xml配置文件即可:

(1)将<property>标签删除

(2)在<bean>标签中添加autowire属性

首先来实现按照类型注入的配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean class="com.itheima.dao.impl.BookDaoImpl"/>
  7.     <!--autowire属性：开启自动装配，通常使用按类型装配-->
  8.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
  10. </beans>

注意事项:

  • 需要注入属性的类中对应属性的setter方法不能省略
  • 被注入的对象必须要被Spring的IOC容器管理
  • 按照类型在Spring的IOC容器中如果找到多个对象，会报NoUniqueBeanDefinitionException

一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入，配置方式为:autowire=“byName”

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean class="com.itheima.dao.impl.BookDaoImpl"/>
  7.     <!--autowire属性：开启自动装配，通常使用按类型装配-->
  8.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byName"/>
  10. </beans>

注意事项:
在这里插入图片描述

在这里插入图片描述

  • 按照名称注入中的名称指的是什么?

    • bookDao是private修饰的，外部类无法直接方法
    • 外部类只能通过属性的set方法进行访问

    • 对外部类来说，setBookDao方法名，去掉set后首字母小写是其属性名

      • 为什么是去掉set首字母小写?
      • 这个规则是set方法生成的默认规则，set方法的生成是把属性名首字母大写前面加set形成的方法名
    • 所以按照名称注入，其实是和对应的set方法有关，但是如果按照标准起名称，属性名和set对应的名是一致的
  • 如果按照名称去找对应的bean对象，找不到则注入Null
  • 当某一个类型在IOC容器中有多个对象，按照名称注入只找其指定名称对应的bean对象，不会报错

两种方式介绍完后，以后用的更多的是按照类型注入。

最后对于依赖注入，需要注意一些其他的配置特征:

  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

4）集合注入

常见的集合类型有哪些?

  • 数组
  • List
  • Set
  • Map

  • Properties

    public interface BookDao {

    1. public void save();

    }
    public class BookDaoImpl implements BookDao {

  1.     private int[] array;
  3.     private List<String> list;
  5.     private Set<String> set;
  7.     private Map<String,String> map;
  9.     private Properties properties;
  11.     public void setArray(int[] array) {
  13.         this.array = array;
  14.     }
  16.     public void setList(List<String> list) {
  18.         this.list = list;
  19.     }
  21.     public void setSet(Set<String> set) {
  23.         this.set = set;
  24.     }
  26.     public void setMap(Map<String, String> map) {
  28.         this.map = map;
  29.     }
  31.     public void setProperties(Properties properties) {
  33.         this.properties = properties;
  34.     }
  36.     public void save() {
  38.         System.out.println("book dao save ...");
  40.         System.out.println("遍历数组:" + Arrays.toString(array));
  42.         System.out.println("遍历List" + list);
  44.         System.out.println("遍历Set" + set);
  46.         System.out.println("遍历Map" + map);
  48.         System.out.println("遍历Properties" + properties);
  49.     }
  50. }
  51. public class AppForDICollection {
  53.     public static void main( String[] args ) {
  55.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  57.         BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  59.         bookDao.save();
  60.     }
  61. }
  63. <?xml version="1.0" encoding="UTF-8"?>
  64. <beans xmlns="http://www.springframework.org/schema/beans"
  65.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  66.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  67.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
  68.         <!--数组注入-->
  69.         <property name="array">
  70.             <array>
  71.                 <value>100</value>
  72.                 <value>200</value>
  73.                 <value>300</value>
  74.             </array>
  75.         </property>
  76.         <!--list集合注入-->
  77.         <property name="list">
  78.             <list>
  79.                 <value>itcast</value>
  80.                 <value>itheima</value>
  81.                 <value>boxuegu</value>
  82.                 <value>chuanzhihui</value>
  83.             </list>
  84.         </property>
  85.         <!--set集合注入-->
  86.         <property name="set">
  87.             <set>
  88.                 <value>itcast</value>
  89.                 <value>itheima</value>
  90.                 <value>boxuegu</value>
  91.                 <value>boxuegu</value>
  92.             </set>
  93.         </property>
  94.         <!--map集合注入-->
  95.         <property name="map">
  96.             <map>
  97.                 <entry key="country" value="china"/>
  98.                 <entry key="province" value="henan"/>
  99.                 <entry key="city" value="kaifeng"/>
  100.             </map>
  101.         </property>
  102.         <!--Properties注入-->
  103.         <property name="properties">
  104.             <props>
  105.                 <prop key="country">china</prop>
  106.                 <prop key="province">henan</prop>
  107.                 <prop key="city">kaifeng</prop>
  108.             </props>
  109.         </property>
  110.     </bean>
  111. </beans>
  113. book dao save ...
  114. 遍历数组:[100, 200, 300]
  115. 遍历List[itcast, itheima, boxuegu, chuanzhihui]
  116. 遍历Set[itcast, itheima, boxuegu]
  117. 遍历Map{
  118.     country=china, province=henan, city=kaifeng}
  119. 遍历Properties{
  120.     province=henan, city=kaifeng, country=china}

说明：

  • property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签
  • List的底层也是通过数组实现的，所以<list>和<array>标签是可以混用
  • 集合中要添加引用类型，只需要把<value>标签改成<ref>标签，这种方式用的比较少

发表评论

表情：
评论列表 （有 0 条评论，108人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring核心概念

    一、Spring是什么？核心功能是什么？如何理解Spring 我们通常所说的Spring,其实也就是Spring Framework ，是java圈子里应用非常广泛的一种

    女爷i女爷i/ 0 赞/ 84 阅读

    相关 三、k8s详细介绍-核心概念

    Kubernetes（简称K8S）是一种开源容器编排平台，用于自动化部署、扩展和管理容器化应用程序。它提供了一种高度可扩展的平台，可以自动化地管理容器化应用程序的部署、伸缩和运

    矫情吗；*矫情吗；*/ 0 赞/ 199 阅读