Spring IOC

Posted MeltSky

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spring IOC相关的知识,希望对你有一定的参考价值。

Spring IOC知识点总结

1 .SpringIoc

 

2 Spring框架

2.1 Spring框架概念

Spring 是众多开源java项目中的一员,基于分层的javaEE应用一站式轻量级开源框架,主要核心是

IOC(控制反转/依赖注入)与 AOP(面向切面)两大技术,实现项目在开发过程中的轻松解耦,提高项

目的开发效率。

在项目中引入 Spring 立即可以带来下面的好处 降低组件之间的耦合度,实现软件各层之间的解耦。可

以使用容器提供的众多服务,如:事务管理服务、消息服务等等。当我们使用容器管理事务时,开发人

员就不再需要手工控制事务.也不需处理复杂的事务传播。 容器提供单例模式支持,开发人员不再需要自

己编写实现代码。 容器提供了AOP技术,利用它很容易实现如权限拦截、运行期监控等功能。

 

 

2.2 Spring 源码架构

Spring 总共大约有20个模块,由1300多个不同的文件构成。而这些组件被分别整合在核心容器

(Core Container)、Aop(Aspect Oriented Programming)和设备支持(Instrmentation)、数据

访问及集成(Data Access/Integeration)、Web、报文发送(Messaging)、测试6个模块集合中。

  1. 核心容器:Spring-beans 和 Spring-core 模块是 Spring 框架的核心模块,包含控制反转

(Inversion of Control, IoC)和依赖注入(Dependency Injection, DI),核心容器提供 Spring 框

架的基本功能。核心容器的主要组件是 BeanFactory,工厂模式的实现。BeanFactory 使用控制反

转(IOC) 思想将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文Spring Context:Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。

Spring 上下文包括企业服务,例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring-Expression 模块是统一表达式语言(unified EL)的扩展模块,可以查询、管理运行中的对

象,同时也方便的可以调用对象方法、操作数组、集合等。它的语法类似于传统EL,但提供了额外

的功能,最出色的要数函数调用和简单字符串的模板函数。

  1. Spring-AOP:Spring-aop是Spring的另一个核心模块, 在Spring中,他是以JVM的动态代理技术为

基础,然后设计出了一系列的Aop横切实现,比如前置通知、返回通知、异常通知等。通过其配置

管理特性,Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以,可以很容

易地使 Spring 框架管理的任何对象支持 AOP。

  1. Spring Data Access(数据访问):由Spring-jdbc、Spring-tx、Spring-orm、Spring-jms和Spring

oxm 5个模块组成 Spring-jdbc 模块是 Spring 提供的JDBC抽象框架的主要实现模块,用于简化

Spring JDBC。

Spring-tx 模块是SpringJDBC事务控制实现模块。使用Spring框架,它对事务做了很好的封装,通

过它的Aop配置,可以灵活的配置在任何一层。

Spring-Orm 模块是ORM框架支持模块,主要集成 hibernate, Java Persistence API (JPA) 和 Java

Data Objects (JDO) 用于资源管理、数据访问对象(DAO)的实现和事务策略。

Spring-Jms 模块(Java Messaging Service)能够发送和接受信息。Spring-Oxm 模块主要提供一个抽象层以支撑 OXM(OXM 是 Object-to-XML-Mapping 的缩写,它

是一个O/M-mapper,将java对象映射成 XML 数据,或者将 XML 数据映射成 java 对象),例

如:JAXB, Castor, XMLBeans, JiBX 和 XStream 等。

  1. Web 模块:由Spring-web、Spring-webmvc、Spring-websocket和Spring-webmvc-portlet 4个

模块组成,Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下

文。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

  1. 报文发送:即Spring-messaging模块。

Spring-messaging是Spring4 新加入的一个模块,主要职责是为Spring 框架集成一些基础的报文

传送应用。

  1. 单元测试:即Spring-test模块。Spring-test模块主要为测试提供支持

2.3 Spring框架环境搭建

2.3.1. 环境要求

JDK 版本:

     JDK 1.7 及以上版本

Spring版本:

     Spring 5.x版本

2.3.2. 新建 Maven 项目

  1. 创建 Maven 的普通 Java 项目

 

  1. 设置项目的坐标、名称、工作空间

 

  1. 设置项目的 Maven 环境

 

 

2.3.3 调整项目环境

1.修改JDK版本

 <properties>
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   <maven.compiler.source>1.8</maven.compiler.source>
   <maven.compiler.target>1.8</maven.compiler.target>
 </properties>
  1. 修改单元测试 JUnit 版本

 <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
   <scope>test</scope>
 </dependency>
  1. build标签中的pluginManagement标签

 <!--删除build标签中的pluginManagement标签-->
 <build>
 </build>

2.3.4 添加 Spring 框架的依赖坐标

Maven仓库:https://mvnrepository.com/

 <!-- 添加Spring框架的核心依赖 -->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>5.2.4.RELEASE</version>
 </dependency>

2.3.5 编写Bean对象

 package com.xxxx.service;
 public class UserService 
     public void test()
         System.out.println("Hello Spring!");
    
 

2.3.6 添加Spring配置文件

  1. 在项目的src下创建文件夹 resources(Alt+insert)

  2. 将 resources 标记为资源目录

     

 

  1. 在 src\\main\\resources 目录下新建 spring.xml 文件,并拷贝官网文档提供的模板内容到 xml 中。

配置 bean 到 xml 中,把对应 bean 纳入到 Spring 容器来管理

spring.xml

 <?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
         https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 
         xmlns 即 xml namespace xml使用的命名空间
         xmlns:xsi 即xml schema instance xml 遵守的具体规范
         xsi:schemaLocation 本文档xml遵守的规范 官方指定
    -->
    <bean id="userService" class="com.xxxx.service.UserService"></bean>
 </beans>

4.在 spring.xml 中配置 Bean 对象

<!--
 id:bean对象的id,唯一标识。一般是Bean对象的名称的首字母小写
 class:bean对象的类路径
-->
<bean id="userService" class="com.xxxx.service.UserService"></bean>

2.3.7. 加载配置文件,获取实例化对象

package com.xxxx;
import com.xxxx.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App 
    public static void main(String[] args) 
        // 获取Spring上下文环境 (加载配置文件)
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        // 通过getBean方法得到Spring容器中实例化好的Bean对象 (实例化Bean对象)
        // userService代表的是配置文件中bean标签的id属性值
        UserService userService = (UserService) ac.getBean("userService");
        // 调用方法 (使用实例化对象)
        userService.test();
   

 

3 Spring IOC 容器 Bean对象实例化模拟

 

思路:

  1. 定义Bean 工厂接口,提供获取bean方法

  2. 定义Bean工厂接口实现类,解析配置文件,实例化Bean对象

  3. 实现获取Bean方法

3.1 定义 Bean 属性对象

package com.xxx.spring;

/**
 * Bean属性对象
 *      用来存放配置文件中bean标签对应的id和class属性
 */
public class MyBean 
    private String id;      //bean标签的id属性值
    private String clazz;   //bean标签的class属性值

    public MyBean() 
    

    public MyBean(String id, String clazz) 
        this.id = id;
        this.clazz = clazz;
    

    public String getId() 
        return id;
    

    public void setId(String id) 
        this.id = id;
    

    public String getClazz() 
        return clazz;
    

    public void setClazz(String clazz) 
        this.clazz = clazz;
    

3.2. 添加 dom4j 坐标依赖

<!--引入dom4j依赖-->
    <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/jaxen/jaxen -->
    <dependency>
      <groupId>jaxen</groupId>
      <artifactId>jaxen</artifactId>
      <version>1.1.6</version>
    </dependency>

 

3.3. 准备自定义配置文件

<?xml version="1.0" encoding="UTF-8" ?>

<beans>
<!--设置JavaBean对应的bean标签-->
    <bean id="userDao" class="com.xxx.dao.UserDao"></bean>
    <bean id="userService" class="com.xxx.service.UserService"></bean>
</beans>

 

3.4. 定义 Bean 工厂接口

package com.xxx.spring;

/**
 * Bean 工厂接口定义
 */
public interface MyFactory 
    //通过id属性值获取对象
    public Object getBean(String id);

 

3.5.定义Bean接口的实现类

package com.xxx.spring;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;

import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 模拟Spring的实现
 *  1.通过带参构造器得到对应的配置文件
 *  2.通过dom4j解析配置文件(xml文件),得到list集合(存放bean标签的id和class属性值)
 *  3.通过反射得到对应的实例化对象,放置在map对象中(遍历list集合,通过获取对应的class属性,利用Class.forName(class).newIntance())
 *  4.通过id属性值获取指定的实例化对象
 */
public class MyClassPathXmlApplicationContext implements MyFactory

    private List<MyBean> beanList;   //存放从配置文件文件中获取到的bean标签的信息(myBean代表的就是每一个bean标签)
    private Map<String ,Object> beanMap =new HashMap<>();  //存放实例化好的对象,通过id获取对应的对象

    //1.通过带参构造器得到对应的配置文件
    public MyClassPathXmlApplicationContext(String fileName) 
       // 2.通过dom4j解析配置文件(xml文件),得到list集合
        this.parseXml(fileName);
        //3.通过反射得到对应的实例化对象
        this.instanceBean();
    

    /**
     * 通过dom4j解析配置文件(xml文件),得到list集合
     *  1.获取解析器
     *  2.获取配置文件的URL
     *  3.通过解析器解析配置文件(xml文件)
     *  4.通过XPath语法解析,获取beans标签下的所有bean标签
     *  5.通过指定的解析语法解析文档对象,返回元素集合
     *  6.判断元素集合是否为空
     *  7.如果元素集合不为空,遍历集合
     *  8.获取bean标签元素属性(id和class属性值)
     *  9.获取MyBean对象,将id和class属性值设置到对象中,再将对象设置到MyBean的集合中
     * @param fileName
     */
    private void parseXml(String fileName)  
        //1.获取解析器
        SAXReader saxReader =new SAXReader();
        //2.获取配置文件的URL
        URL url =this.getClass().getClassLoader().getResource(fileName);
        try 
            //3.通过解析器解析配置文件(xml文件)
            Document document =saxReader.read(url);
           // 4.通过XPath语法解析,获取beans标签下的所有bean标签
            XPath xPath =document.createXPath("beans/bean");
            //5.通过指定的解析语法解析文档对象,返回元素集合
            List<Element> elementList =xPath.selectNodes(document);
            //6.判断元素集合是否为空
            if (elementList !=null && elementList.size()>0)
                //实例化beanList
                beanList =new ArrayList<>();
                //7.如果元素集合不为空,遍历集合
                for(Element el:elementList)
                    //8.获取bean标签元素属性(id和class属性值)
                    String id =el.attributeValue("id");
                    String clazz =el.attributeValue("class");
                    //9.获取MyBean对象,将id和class属性值设置到对象中,再将对象设置到MyBean的集合中
                    MyBean myBean =new MyBean(id,clazz);
                    beanList.add(myBean);
                
            
        catch (Exception e)
            e.printStackTrace();
        
    

    /**
     * 通过反射得到对应的实例化对象,放置在map对象中
     *  1.判断对象集合是否为空,如果不为空,则遍历集合,获取对象的id和class
     *  2.通过类的全路径名  反射  得到实例化对象 Class.forName(class).newInstance();
     *  3.将对应的id和实例化的bean对象设置到map对象
     */
    private void instanceBean() 
        //1.判断对象集合是否为空,如果不为空,则遍历集合,获取对象的id和class
        if (beanList !=null &&beanList.size()>0)
            for (MyBean bean :beanList)
                String id =bean.getId();
                String clazz =bean.getClazz();
                try
                    //2.通过类的全路径名  反射  得到实例化对象 Class.forName(class).newInstance();
                    Object object =Class.forName(clazz).newInstance();
                    //3.将对应的id和实例化的bean对象设置到map对象
                    beanMap.put(id,object);
                catch (Exception e)
                    e.printStackTrace();
                
            
        

    

    /**
     * 通过id获取对应的map对象中的value值(实例化好bean对象)
     * @param id
     * @return
     */
    @Override
    public Object getBean(String id) 
        Object object = beanMap.get(id);
        return object;
    

3.6. 测试自定义 IOC 容器

1.创建与配置文件中对应的Bean对象

UserService.java

package com.xxx.service;

public class UserService 
    public void test()
        System.out.println("userService test...");
    

UserDao.java

package com.xxx.dao;

public class UserDao 
    public void test()
        System.out.println("userDao test...");
    

2.测试是否可以获取实例化的Bean对象

package com.xxx;

import com.xxx.dao.UserDao;
import com.xxx.service.UserService;
import com.xxx.spring.MyClassPathXmlApplicationContext;
import com.xxx.spring.MyFactory;

/**
 * Hello world!
 *
 */
public class App 
    public static void main( String[] args ) 
        //得到工厂的实现对象
        MyFactory factory =new MyClassPathXmlApplicationContext("spring.xml");
        //得到对应的实例化对象
        UserDao userDao = (UserDao) factory.getBean("userDao");
        userDao.test();

        UserService userService = (UserService) factory.getBean("userService");
        userService.test();
    

Spring 容器在启动的时候 读取xml配置信息,并对配置的 bean 进行实例化(这里模拟的比较简

单,仅用于帮助大家理解),同时通过上下文对象提供的 getBean() 方法拿到我们配置的 bean 对

象,从而实现外部容器自动化维护并创建 bean 的效果。

4. Spring IOC 配置文件加载

4.1. Spring配置文件加载

spring.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        xmlns 即 xml namespace xml使用的命名空间
        xmlns:xsi 即xml schema instance xml 遵守的具体规范
        xsi:schemaLocation 本文档xml遵守的规范 官方指定
   -->
    <!--
         id:bean对象的id,唯一标识。一般是Bean对象的名称的首字母小写
         class:bean对象的类路径(包名加类名)
    -->
    <bean id="userService" class="com.xxx.service.UserService">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
</beans>

4.1.1 根据相对路径加载资源

ApplicationContext ac  = new ClassPathXmlApplicationContext("spring.xml");

4.1.2 根据绝对路径加载资源(了解)

ApplicationContext ac = new
FileSystemXmlApplicationContext("C:/IdeaWorkspace/spring01/src/main/resources/spring.xml");

 

4.2. Spring 多配置文件加载

Spring 框架启动时可以加载多个配置文件到环境中。对于比较复杂的项目,可能对应的配置文件有多

个,项目在启动部署时会将多个配置文件同时加载进来。

 

service.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="userService" class="com.xxxx.service.UserService"></bean>
</beans>

dao.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="userDao" class="com.xxxx.dao.UserDao"></bean>
</beans>

4.2.1. 可变参数,传入多个文件名

// 同时加载多个资源文件
ApplicationContext ac = new
ClassPathXmlApplicationContext("spring.xml","dao.xml");

 

4.2.2. 通过总的配置文件import其他配置文件

spring.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--通过import导入其他配置文件-->
        <import resource="beans.xml"></import>
        <import resource="spring.xml"></import>
</beans>

加载时只需加载总的配置文件即可

// 加载总的资源文件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");

 

5.Spring IOC容器Bean 对象实例化

5.1. 构造器实例化

注:通过默认构造器创建 空构造方法必须存在 否则创建失败

1.设置配置文件 spring.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        构造器实例化
            对应Bean对象需要提供空构造
    -->
    <bean id="typeDao" class="com.xxx.dao.TypeDao"></bean>
</beans>

2.获取实例化对象

package com.xxx.test;

import com.xxx.dao.TypeDao;
import com.xxx.service.UserService;
import com.xxx.service.UserService02;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * IOC容器Bean对象的实例化方式
 *  1.构造器实例化  (Bean对象需要提供空构造)
 */
public class Starter03 
    public static void main(String[] args) 
        BeanFactory factory =new ClassPathXmlApplicationContext("spring02.xml");
        TypeDao typeDao = (TypeDao) factory.getBean("typeDao");
        typeDao.test();
    

 

5.2.静态工厂实例化(了解)

注:

要有该工厂类及工厂方法

工厂方法为静态的

1.定义静态工厂类

package com.xxx.factory;

import com.xxx.service.TypeService;
import sun.reflect.generics.tree.TypeSignature;

/**
 * 定义静态工厂类
 *
 */
public class StaticFactory 
    /**
     * 定义对应的静态方法
     * @return
     */
    public static TypeService createService()
        return new TypeService();
    

2.设置配置文件 spring.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        静态工厂实例化
            1.定义工厂类及对应的静态方法
            2.配置bean对象对应的工厂类及静态方法

            id:需要被实例化的bean对象的id
            class:静态工厂类的路径
            factory-method:静态工厂类中实例化bean对象的静态方法
    -->
    <bean id="typeService" class="com.xxx.factory.StaticFactory" factory-method="createService"></bean>
</beans>

3.获取实例化对象

//静态工厂实例化
TypeService typeService = (TypeService) factory.getBean("typeService");
typeService.test();

当我们指定Spring使用静态工厂方法来创建Bean实例时,Spring将先解析配置文件,并根据配

置文件指定的信息,通过反射调用静态工厂类的静态工厂方法,并将该静态工厂方法的返回值作为Bean实例,

在这个过程中,Spring不再负责创建Bean实例,Bean实例是由用户提供的静态工厂方法提供的。

 

5.3. 实例化工厂实例化(了解)

 

注:

工厂方法为非静态方法

需要配置工厂bean,并在业务bean中配置factory-bean,factory-method属性

1.定义工厂类

package com.xxx.factory;

import com.xxx.controller.TypeController;

/**
 * 定义实例化工厂
 */
public class InstanceFactory 
    /**
     * 定义实例化方法
     * @return
     */
    public TypeController createTypeController()
        return new TypeController();
    

 

2.设置配置文件 spring.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        实例化工厂
            1.定义工厂类及对应的方法
            2.配置工厂对象
            3.配置bean对象对应的工厂对象及工厂方法

            factory-bean:工厂对象对应的id属性值
            factory-method:工厂类中的方法
    -->
    <!--工厂对象-->
    <bean id="instanceFactory" class="com.xxx.factory.InstanceFactory"></bean>
    <!--bean对象-->
    <bean id="typeController" factory-bean="instanceFactory" factory-method="createTypeController"></bean>
</beans>

 

3.获取实例化对象

package com.xxx.test;

import com.xxx.controller.TypeController;
import com.xxx.dao.TypeDao;
import com.xxx.service.TypeService;
import com.xxx.service.UserService;
import com.xxx.service.UserService02;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * IOC容器Bean对象的实例化方式
 *  1.构造器实例化  (Bean对象需要提供空构造)
 *  2.静态工厂实例化(了解)
 *  3.实例化工厂(了解)
 */
public class Starter03 
    public static void main(String[] args) 
        BeanFactory factory =new ClassPathXmlApplicationContext("spring02.xml");
        //构造器实现
        TypeDao typeDao = (TypeDao) factory.getBean("typeDao");
        typeDao.test();

        //静态工厂实例化
        TypeService typeService = (TypeService) factory.getBean("typeService");
        typeService.test();

        //实例化工厂
        TypeController typeController = (TypeController) factory.getBean("typeController");
        typeController.test();
    

 

5.4. Spring三种实例化Bean的方式比较

方式一:通过bean的缺省构造函数创建,当各个bean的业务逻辑相互比较独立的时候或者和外界

关联较少的时候可以使用。

方式二:利用静态factory方法创建,可以统一管理各个bean的创建,如各个bean在创建之前需要

相同的初始化处理,则可用这个factory方法险进行统一的处理等等。

方式三:利用实例化factory方法创建,即将factory方法也作为了业务bean来控制,1可用于集成

其他框架的bean创建管理方法,2能够使bean和factory的角色互换。

开发中项目一般使用一种方式实例化bean项目开发基本采用第一种方式,交给Spring托管,使用

时直接拿来使用即可。另外两种了解

 

6. Spring IOC 注入

 

手动实例化与外部引入

图一:

 

图二:

 

对比发现:图二中对于 UserDao 对象的创建并没有像图一那样主动的去实例化,而是通过带参方法

形式将UserDao 传入过来,从而实现 UserService 对UserDao类 的依赖。

而实际创建对象的幕后对象即是交给了外部来创建。

6.1. Spring IOC手动装配(注入)

Spring 支持的注入方式共有四种:set 注入、构造器注入、静态工厂注入、实例化工厂注入。

6.1.1. set方法注入

注:

属性字段需要提供set方法

四种方式,推荐使用set方法注入

6.1.1.1. 业务对象 JavaBean

1.属性字段提供set方法

package com.xxx.service;

import com.xxx.dao.UserDao;

public class UserService 
    //手动实例化
    //private UserDao userDao =new UserDao();

    //业务逻辑对象  javabean对象,提供set方法注入
    private UserDao userDao;
    public void setUserDao(UserDao userDao) 
        this.userDao = userDao;
    

    public void test()
        System.out.println("UserService test...");
        userDao.test();
    

2.配置文件的bean标签设置property标签

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<!--
    Set方法注入
          通过property属性注入
            name:bean对象中属性字段的名称
            ref:指定bean标签的id属性值
-->
    <bean id="userService" class="com.xxx.service.UserService">
        <property name="userDao" ref="userDao"></property>
    <!-- collaborators and configuration for this bean go here -->
    </bean>
    <bean id="userDao" class="com.xxx.dao.UserDao"></bean>


</beans>

 

6.1.1.2. 常用对象和基本类型

1.属性字段提供set方法

public class UserService 
    // 常用对象String set注入(提供set方法)
    private String host;
    public void setHost(String host) 
        this.host = host;
   
    // 基本类型Integer   set注入(提供set方法)
    private Integer port;
    public void setPort(Integer port) 
        this.port = port;
   

2.配置文件的bean标签设置property标签

<?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
6.1.1.3. 集合类型和属性对象
1. 属性字段提供set方法
2. 配置文件的bean标签设置property标签
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
   <!--
        IOC通过property标签手动装配(注入):
            Set方法注入
                name:bean对象中属性字段的名称
                value:具体的值(基本类型 常用对象|日期 集合)
    -->
 <bean id="userService" class="com.xxxx.service.UserService">
        <!--常用对象String 注入-->
        <property name="host" value="127.0.0.1"/>
        <!--基本类型注入-->
        <property name="port" value="8080"/>
    </bean>
</beans>

 

6.1.1.3. 集合类型和属性对象

1.属性字段提供set方法

public class UserService 
    // List集合 set注入(提供set方法)
    public List<String> list;
    public void setList(List<String> list) 
        this.list = list;
   
   
    // Set集合 set注入(提供set方法)
    private Set<String> set;
    public void setSet(Set<String> set) 
        this.set = set;
   
    // Map set注入(提供set方法)
    private Map<String,Object> map;
    public void setMap(Map<String, Object> map) 
        this.map = map;
   
    
    // Properties set注入(提供set方法)
    private Properties properties;
    public void setProperties(Properties properties) 
        this.properties = properties;
   
   

2.配置文件的bean标签设置property标签

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
   <!--
        IOC通过property标签手动装配(注入):
            Set方法注入
                name:bean对象中属性字段的名称
                value:具体的值(基本类型 常用对象|日期 集合)
    -->
 <!--List集合 注入-->
    <property name="list">
        <list>
            <value>上海</value>
            <value>北京</value>
            <value>杭州</value>
        </list>
    </property>
    <!--Set集合注入-->
    <property name="set">
        <set>
            <value>上海SH</value>
            <value>北京BJ</value>
            <value>杭州HZ</value>
        </set>
    </property>
    <!--Map注入-->
    <property name="map">
        <map>
            <entry>
                <key><value>周杰伦</value></key>
                <value>我是如此相信</value>
            </entry>
            <entry>
                <key><value>林俊杰</value></key>
                <value>可惜没如果</value>
            </entry>
            <entry>
                <key><value>陈奕迅</value></key>
                <value>十年</value>
            </entry>
        </map>
    </property>
    <!--Properties注入-->
    <property name="properties">
        <props>
            <prop key="上海">东方明珠</prop>
            <prop key="北京">天安门</prop>
            <prop key="杭州">西湖</prop>
        </props>
    </property>
</beans>

 

6.1.1.4. 测试代码

UserService.java

public class UserService 
    // 业务对象UserDao set注入(提供set方法)
    private UserDao userDao;
    public void setUserDao(UserDao userDao) 
        this.userDao = userDao;
   
    // 常用对象String set注入(提供set方法)
    private String host;
    public void setHost(String host) 
        this.host = host;
   
    // 基本类型Integer   set注入(提供set方法)
    private Integer port;
    public void setPort(Integer port) 
        this.port = port;
   
    // List集合 set注入(提供set方法)
    public List<String> list;
    public void setList(List<String> list) 
        this.list = list;
   
    // List集合输出
    public void printList() 
        list.forEach(s -> System.out.println(s));
   
    // Set集合 set注入(提供set方法)
    private Set<String> set;
    public void setSet(Set<String> set) 
        this.set = set;
   
    // Set集合输出
    public void printSet() 
        set.forEach(s -> System.out.println(s));
   
    // Map set注入(提供set方法)
    private Map<String,Object> map;
    public void setMap(Map<String, Object> map) 
        this.map = map;
   
    // Map输出
    public void printMap() 
        map.forEach((k,v) -> System.out.println(k + "," + v));
   
    // Properties set注入(提供set方法)
    private Properties properties;
    public void setProperties(Properties properties) 
        this.properties = properties;
   
    // Properties输出
    public  void printProperties()
        properties.forEach((k,v) -> System.out.println(k + ","+ v ));
   
    public  void  test()
        System.out.println("UserService Test...");
        userDao.test();
        studentDao.test();
        System.out.println("Host:" + host  + ",port:" + port);
        // List集合
        printList();
        // Set集合
        printSet();
        // Map
        printMap();
        // Properties
        printProperties();
   

 

spring.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--
        IOC通过property标签手动装配(注入):
            Set方法注入
                name:bean对象中属性字段的名称
                ref:指定bean标签的id属性值
                value:具体的值(基本类型 常用对象|日期 集合)
    -->
 <bean id="userDao" class="com.xxxx.dao.UserDao"></bean>
    <bean id="userService" class="com.xxxx.service.UserService">
        <!--业务对象 注入-->
        <property name="userDao" ref="userDao"/>
        <property name="studentDao" ref="studentDao"/>
        <!--常用对象String 注入-->
        <property name="host" value="192.168.1.109"/>
        <!--基本类型注入-->
        <property name="port" value="8080"/>
        <!--List集合 注入-->
        <property name="list">
            <list>
                <value>上海</value>
                <value>北京</value>
                <value>杭州</value>
            </list>
        </property>
        
        <!--Set集合注入-->
        <property name="set">
            <set>
                <value>上海SH</value>
                <value>北京BJ</value>
                <value>杭州HZ</value>
            </set>
        </property>
        
        <!--Map注入-->
        <property name="map">
            <map>
                <entry>
                    <key><value>周杰伦</value></key>
                    <value>我是如此相信</value>
                </entry>
                <entry>
                    <key><value>林俊杰</value></key>
                    <value>可惜没如果</value>
                </entry>
                <entry>
                    <key><value>陈奕迅</value></key>
                    <value>十年</value>
                </entry>
            </map>
        </property>
        
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="上海">东方明珠</prop>
                <prop key="北京">天安门</prop>
                <prop key="杭州">西湖</prop>
            </props>
        </property>
    </bean>
    
</beans>

 

6.1.2 构造器注入

注:

提供带参构造器

6.1.2.1. 单个Bean对象作为参数

java代码

public class UserService 
    private UserDao userDao; // JavaBean 对象
    
    public UserService(UserDao userDao) 
        this.userDao = userDao;
   
    public  void  test()
        System.out.println("UserService Test...");
        userDao.test();
   

XML配置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--
        IOC通过构造器注入:
            通过constructor-arg标签进行注入
                name:属性名称
                ref:指定bean标签的id属性值
    -->
    <bean id="userDao" class="com.xxxx.dao.UserDao" ></bean>
    
    <bean id="userService" class="com.xxxx.service.UserService">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>
</beans>

6.1.2.1.多个Bean对象作为参数

Java 代码

public class UserService 
    private UserDao userDao;  // JavaBean 对象
    private AccountDao accountDao  // JavaBean 对象
    XML配置
    6.1.2.3. Bean对象和常用对象作为参数
    Java 代码
        
    public UserService(UserDao userDao, AccountDao accountDao) 
        this.userDao = userDao;
        this.accountDao = accountDao;
   
    public  void  test()
        System.out.println("UserService Test...");
        userDao.test();
        accountDao.test();
   

XML配置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--
        IOC通过构造器注入:
            通过constructor-arg标签进行注入
                name:属性名称
                ref:指定bean标签的id属性值
    -->
    <bean id="userDao" class="com.xxxx.dao.UserDao" ></bean>
    <bean id="accountDao" class="com.xxxx.dao.AccountDao" ></bean>
    
    <bean id="userService" class="com.xxxx.service.UserService">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="accountDao" ref="accountDao"></constructor-arg>
    </bean>
</beans>

6.1.2.3. Bean对象和常用对象作为参数

Java代码

public class UserService 
    private UserDao userDao;  // JavaBean 对象
    private AccountDao accountDao;  // JavaBean 对象
    private String uname;  // 字符串类型
        
    public UserService(UserDao userDao, AccountDao accountDao, String uname) 
        this.userDao = userDao;
        this.accountDao = accountDao;
        this.uname = uname;
   
    public  void  test()
XML配置
6.1.2.4. 循环依赖问题
循环问题产生的原因:
 Bean通过构造器注入,之间彼此相互依赖对方导致bean无法实例化。 
问题展示:
1. Java 代码
        System.out.println("UserService Test...");
        userDao.test();
        accountDao.test();
        System.out.println("uname:" + uname);
   

XML配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns

以上是关于Spring IOC的主要内容,如果未能解决你的问题,请参考以下文章

spring ioc都有哪些优点

什么是spring的ioc aop

Spring学习笔记IOC容器及Spring配置详解

怎么样理解spring ioc与aop

Spring:源码解读Spring IOC原理

Spring:源码解读Spring IOC原理