Spring系列篇--关于IOC【控制反转】的详解

已于 2023-08-16 22:35:32 修改
阅读量1k 收藏 7
点赞数 11
分类专栏： 框架 文章标签： spring java 后端
于 2023-08-16 22:35:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74315688/article/details/132326126
版权

🥳🥳Welcome Huihui's Code World ! !🥳🥳

接下来看看由辉辉所写的关于Spring的相关操作吧

目录

🥳🥳Welcome Huihui's Code World ! !🥳🥳

 一.什么是Spring

二.Spring的特点

三.什么是IOC

场景模拟：

控制反转：

使用步骤

1 创建Maven的war项目然后配置web的相关依赖以及项目结构的配置

2在pom.xml文件中配置Spring的依赖

3 在resources下创建并配置spring-context.xml

4 在业务层中创建WorkBiz接口及其实现类

5 在项目中创建MVC的包结构，并创建Web层，并获取Spring的容器对象

6 测试

7 总结

四.IOC的实现方式

五.IOC依赖注入的三种方式

1.Setter方法注入（Setter Injection）：

2.构造函数注入（Constructor Injection）：

3.接口注入（Interface Injection）：

byName:

byType：

六.spring与web容器的整合 

1.监听器的初始化方法 只执行一次

2.spring的上下文要存放在Tomcat上下文中

 一.什么是Spring

  ▲Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的
  ▲ Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情
  🔺简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架

二.Spring的特点

  1. 轻量级和非侵入性：Spring框架采用轻量级的设计理念，不侵入应用程序的业务逻辑，使得应用程序可以更加灵活和可维护

  2. 控制反转（IoC）和依赖注入（DI）：IoC是Spring框架的核心概念，它通过DI将对象的创建和依赖关系的管理从应用程序代码中解耦出来。这样可以降低代码的耦合性，提高代码的可测试性和可维护性

  3. 面向切面编程（AOP）：Spring框架通过AOP提供了一种在应用程序中优雅地处理横切关注点的方式。通过AOP，可以将一些与主要业务逻辑无关的功能，如日志记录、事务管理等，从应用程序代码中分离出来，使得代码更加简洁和可维护

  4. 数据访问和集成：Spring框架提供了一系列的数据访问和集成模块，如JDBC、ORM（Object-Relational Mapping）、事务管理等。这些模块可以帮助开发人员更加方便地与数据库进行交互，处理事务以及与第三方系统进行集成

  5. Web开发支持：Spring框架提供了一系列的Web开发支持模块，如Spring MVC、Spring WebFlux等。这些模块可以帮助开发人员构建灵活、可扩展和高性能的Web应用程序

那么在这篇博客中，我们就来详细的解剖一下IOC【控制反转】，首先让我们看一看IOC到底是个什么吧！！！

三.什么是IOC

▲IOC（Inversion of Control，控制反转）是软件开发中的一种设计原则和编程思想。它指的是将对象的创建和依赖关系的管理转移给外部容器（通常是框架或容器），从而实现了对象间的解耦

⭕在传统的开发模式中，对象之间的依赖关系是由对象自己负责管理的。例如，如果一个对象需要依赖其他对象，它会通过直接实例化其他对象或使用静态方法获取依赖对象。这样的实现方式使得对象之间高度耦合，难以进行更改和测试，因而会使得项目难以维护

▲而在IOC的思想下，对象的创建和依赖关系的管理被转移给一个外部容器。容器负责实例化对象，并在对象之间建立依赖关系。对象只需要声明自己所需要的依赖，容器会自动注入这些依赖。这样可以大大降低代码的耦合性，使得代码更加模块化、可扩展和可测试

了解了IOC是什么之后，可能我们对于IOC的便捷之处还没有一个更加直观的了解，那么接下来我将用代码（不过都是一个简单的模拟）来展示，这样也可以更加直观的感觉出IOC的便捷！！

场景模拟：

 在一个公司的管理系统中，管理层都需要管理公司的事物以及员工，
 但是每个管理层管理员工所关注的点是不同的，因为每个管理者的工作是不同的
 因此需要做出一个十分好用的管理系统还是需要考虑很多方面的，有一天你所在的公司接到了一个项    目：xx公司的管理系统
恰好你就被派任到此项目了，此时你就需要完成一个公司的人员管理系统
接下来就是甲方给你提需求了!

需求1：
      现在人事管理的模块和财务管理的模块都需要查询到用户的信息
      那么我只需要写一个dao方法和一个biz，然后在人事和财务的web层中调用用户的biz层

package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户）信息");
    }

}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {//财务
private WorkerBiz workerBiz = new WokerBizImpl();

    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }

}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class HRAction {//人事
   private WorkerBiz workerBiz = new WokerBizImpl();
    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }
}

结果

但是客户那边商量之后，突然间又换了一个需求

需求2：
      同时在人事模块，财务模块拿到所有的用户数据，并且要求人事模块中的用户数据是通过年龄排序的
      对应策略：修改biz中list方法，添加年龄排序功能
package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl1 implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户），按照年龄来排序...");
    }

}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class HRAction {//人事
   private WorkerBiz workerBiz = new WokerBizImpl1();
    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }
}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {//财务
private WorkerBiz workerBiz = new WokerBizImpl();

    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }

}

结果

客户那边思来想去，认为财务模块中的数据也需要另作要求

需求3：
      同时在人事模块，财务模块拿到所有的用户数据，并且要求人事模块中的用户数据是通过年龄排序的，财务模块中的用户数据是通过薪资排序的
      对应策略，修改biz中list方法，添加排薪资排序功能
package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl1 implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户），按照年龄来排序...");
    }

}

package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl2 implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户），按照薪资排序...");
    }

}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class HRAction {//人事
   private WorkerBiz workerBiz = new WokerBizImpl1();
    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }
}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {//财务
private WorkerBiz workerBiz = new WokerBizImpl2();

    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }

}

结果

 

相信聪明的你也应该发现问题了吧，当客户需求不断变更的时候我们就需要不断的修改代码，我这里只用了两个Action来展示，大家可能觉得不过如此，不就只需要增加几个不同功能的impl类，然后将所实例化的那行代码中的impl类进行改动嘛。但是我们要想，员工/用户的信息在一般情况下，在很多的地方都需要用到，那要是有200个web中都用到了用户的信息，那不是要修改200次？ 要是200个中有一百个是按照年龄排序的，另外一百个是按照薪资排序的，那不是还得一个个看仔细了之后修改？ 可见，这样的方式非常的费时间，不易维护（提出新需求，没方法快速修改）

前面我们已经说到了在IOC的思想下，对象的创建和依赖关系的管理被转移给一个外部容器

那我们就来看一下ioc到底是怎么进行这一波骚操作的吧

控制反转：

使用步骤

1 创建Maven的war项目然后配置web的相关依赖以及项目结构的配置

不会使用IDEA创建Maven项目的看这个

不会使用Eclipse创建Maven的项目的看这个


2在pom.xml文件中配置Spring的依赖
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.javaxl</groupId>
  <artifactId>T224_spring</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>T224_spring Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
    <spring.version>5.0.1.RELEASE</spring.version>
    <javax.servlet.version>4.0.0</javax.servlet.version>
    <junit.version>4.12</junit.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <!-- 2、导入spring依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- 5.1、junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <!-- 5.2、servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${javax.servlet.version}</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>T224_spring</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.7.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

3 在resources下创建并配置spring-context.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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="com.wh.biz.impl.WokerBizImpl1" id="wokerBizImpl1"></bean>
    <bean class="com.wh.biz.impl.WokerBizImpl2" id="wokerBizImpl2"></bean>

    <bean class="com.wh.web.HRAction" id="hrAction">
        <property name="workerBiz" ref="wokerBizImpl1"></property>
    </bean>
    <bean class="com.wh.web.FinanceAction" id="financeAction">
        <property name="workerBiz" ref="wokerBizImpl2"></property>
    </bean>

</beans>

4 在业务层中创建WorkBiz接口及其实现类
package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户）信息");
    }

}

package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl1 implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户），按照年龄来排序...");
    }

}

package com.wh.biz.impl;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:35
 */

public class WokerBizImpl2 implements WorkerBiz {

    @Override
    public void list() {
        System.out.println("查询员工（用户），按照薪资排序...");
    }

}
5 在项目中创建MVC的包结构，并创建Web层，并获取Spring的容器对象
package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class HRAction {/人事
    //    private WorkerBiz workerBiz = new WokerBizImpl1();
    private WorkerBiz workerBiz;//实例化业务逻辑层

    public void list() {
        workerBiz.list();
    }//调用业务逻辑层查询的方法


    public WorkerBiz getWorkerBiz() {//workerBiz的get方法
        return workerBiz;
    }

    public void setWorkerBiz(WorkerBiz workerBiz) {//workerBiz的get方法
        this.workerBiz = workerBiz;
    }
}

package com.wh.web;

import com.wh.biz.WorkerBiz;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {//财务
//    private WorkerBiz workerBiz = new WokerBizImpl1();
private WorkerBiz workerBiz;//实例化业务逻辑层
    public void list() {//调用业务逻辑层查询的方法
        workerBiz.list();
    }

    public WorkerBiz getWorkerBiz() {//workerBiz的get方法
        return workerBiz;
    }

    public void setWorkerBiz(WorkerBiz workerBiz) {//workerBiz的get方法
        this.workerBiz = workerBiz;
    }

}
6 测试
package com.wh.ioc;

import com.wh.web.HRAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-16 18:46
 */
public class IOCTest {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        //建模
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
        HRAction hrAction = (HRAction) context.getBean("hrAction");
        hrAction.list();

    }

}
​
​
package com.wh.ioc;

import com.wh.web.FinanceAction;
import com.wh.web.HRAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-16 18:46
 */
public class IOCTest {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        //建模
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
        HRAction hrAction = (HRAction) context.getBean("hrAction");
        hrAction.list();
        FinanceAction financeAction = (FinanceAction) context.getBean("financeAction");
        financeAction.list();
    }

}

​

7 总结

需要什么功能，或是说需要修改，只需要在spring-context中进行配置/修改便可(web层中进行相应的封装便可)

​

原来的代码进行修改或增加功能，都需要手动的进行查找，先将修改功能的模块写好，在去寻找需要修改功能的Action，一个一个的手动修改，可以说是十分的繁琐。但是我们使用IOC的方式，就只需要修改配置文件，这样一对比，是不是就能够非常直观的感受到使用IOC的好处了!!

四.IOC的实现方式

  1. 依赖注入（Dependency Injection，DI）：通过DI，容器在创建对象时，自动将依赖对象注入到对象中。依赖注入可以通过构造函数、属性注入或接口注入等方式进行。

  2. 依赖查找（Dependency Lookup）：通过依赖查找，对象使用容器提供的查找机制，主动获取所需的依赖对象

可以看到ioc的实现方式主要有两种，那么我们今天就来探究一下其中的依赖注入！

五.IOC依赖注入的三种方式

1.Setter方法注入（Setter Injection）：

通过在目标对象中定义对应的setter方法，从而实现对依赖对象的注入。依赖对象通过调用setter方法设置给目标对象

顾名思义就是需要提供set方法，那如果我没有提供set方法呢？我们可以试一下将action中的set方法给注释掉

​

可以看到报出了一个错误，意思是在其中没有set方法 

package com.wh.web;

import com.wh.biz.WorkerBiz;

import java.util.List;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {
//    private WorkerBiz workerBiz = new WokerBizImpl1();
private WorkerBiz workerBiz;//实例化业务逻辑层
    public void list() {//调用业务逻辑层查询的方法
        System.out.println(name);
        System.out.println(age);
        System.out.println(hobby);

        workerBiz.list();
    }

    public WorkerBiz getWorkerBiz() {//workerBiz的get方法
        return workerBiz;
    }

    public void setWorkerBiz(WorkerBiz workerBiz) {//workerBiz的set方法
        this.workerBiz = workerBiz;
    }

    private String name;
    private int age;
    private List<String> hobby;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getHobby() {
        return hobby;
    }

    public void setHobby(List<String> hobby) {
        this.hobby = hobby;
    }
}

<?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 class="com.wh.biz.impl.WokerBizImpl1" id="wokerBizImpl1"></bean>
    <bean class="com.wh.biz.impl.WokerBizImpl2" id="wokerBizImpl2"></bean>


    <bean class="com.wh.web.HRAction" id="hrAction">
        <property name="workerBiz" ref="wokerBizImpl1"></property>

    </bean>

    <!--set注入-->
    <bean class="com.wh.web.FinanceAction" id="financeAction">
    <property name="workerBiz" ref="wokerBizImpl2"></property>
        <property name="name" value="wh"></property>
        <property name="age" value="18"></property>
        <property name="hobby" >
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>RAP</value>
            </list>
        </property>
    </bean>


</beans>

结果​

2.构造函数注入（Constructor Injection）：

通过在目标对象的构造函数中定义参数，从而实现对依赖对象的注入。依赖对象在创建目标对象时通过构造函数传递进来

package com.wh.web;

import com.wh.biz.WorkerBiz;

import java.util.List;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {
//    private WorkerBiz workerBiz = new WokerBizImpl1();
private WorkerBiz workerBiz;//实例化业务逻辑层
    public void list() {//调用业务逻辑层查询的方法
        System.out.println(name);
        System.out.println(age);
        System.out.println(hobby);

        workerBiz.list();
    }

   
    private String name;
    private int age;
    private List<String> hobby;

    public FinanceAction() {//空参构造
    }

    public FinanceAction(String name, int age, List<String> hobby) {//有参构造
        this.name = name;
        this.age = age;
        this.hobby = hobby;
    }
}

<?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 class="com.wh.biz.impl.WokerBizImpl1" id="wokerBizImpl1"></bean>
    <bean class="com.wh.biz.impl.WokerBizImpl2" id="wokerBizImpl2"></bean>

    <bean class="com.wh.web.HRAction" id="hrAction">
        <property name="workerBiz" ref="wokerBizImpl1"></property>
    </bean>

<!--构造函数注入-->
    <bean class="com.wh.web.FinanceAction" id="financeAction">
        <property name="workerBiz" ref="wokerBizImpl2"></property>
        <constructor-arg name="name" value="wh"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>RAP</value>
            </list>
        </constructor-arg>

    </bean>




</beans>

 结果

​

3.接口注入（Interface Injection）：

通过在目标对象中定义一个接口，并在接口中定义一个设置依赖对象的方法，从而实现对依赖对象的注入。目标对象实现该接口并实现依赖对象的设置方法

注意：

autowire="xx" （其中填的是byName/byType）


byName:

是通过spring管理的bean对象的ID进行查找，如果找不到，则注入失败，反之成功
 

<?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 class="com.wh.biz.impl.WokerBizImpl1" id="wokerBizImpl1"></bean>
    <bean class="com.wh.biz.impl.WokerBizImpl2" id="wokerBizImpl2"></bean>


    <bean class="com.wh.web.HRAction" id="hrAction">
        <property name="workerBiz" ref="wokerBizImpl1"></property>

    </bean>


        <!--自动装配-byname-->
    <bean class="com.wh.web.FinanceAction" id="financeAction" autowire="byName">
        <property name="workerBiz" ref="wokerBizImpl2"></property>
    </bean>



</beans>
package com.wh.web;

import com.wh.biz.WorkerBiz;

import java.util.List;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {
//    private WorkerBiz workerBiz = new WokerBizImpl1();
private WorkerBiz workerBiz;//实例化业务逻辑层
    public void list() {//调用业务逻辑层查询的方法
    

        workerBiz.list();
    }

    public WorkerBiz getWorkerBiz() {//workerBiz的get方法
        return workerBiz;
    }

    public void setWorkerBiz(WorkerBiz workerBiz) {//workerBiz的get方法
        this.workerBiz = workerBiz;
    }

   
}

结果

​

byType：

是通过spring管理的bean对象的接口实现类进行查找，如果没有或者2个以上，则注入失败，反之成功

但是在使用byType时，同一类型的对象，在spring容器中必须唯一。如果不唯一，会报不唯一的异常

​

​

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


    <!--自动装配-byname-->
    <bean class="com.wh.web.FinanceAction" id="financeAction" autowire="byType">
      
    </bean>

   
    <bean class="com.wh.biz.impl.WokerBizImpl1" id="wokerBizImpl1"></bean>
</beans>
package com.wh.web;

import com.wh.biz.WorkerBiz;

import java.util.List;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-15 16:38
 */
public class FinanceAction {
//    private WorkerBiz workerBiz = new WokerBizImpl1();
private WorkerBiz workerBiz;//实例化业务逻辑层
    public void list() {//调用业务逻辑层查询的方法


        workerBiz.list();
    }

    public WorkerBiz getWorkerBiz() {//workerBiz的get方法
        return workerBiz;
    }

    public void setWorkerBiz(WorkerBiz workerBiz) {//workerBiz的get方法
        this.workerBiz = workerBiz;
    }

 
}

结果

​

六.spring与web容器的整合 

  Q:为什么需要进行这一步操作？
  A:  建模的过程是十分耗时的         
  解决问题的思路：
         1.建模必不可少
         2.保证建模只执行一次
         3.建模后期望在每一个servlet都能够拿到spring的上下文对象


   Q：怎么处理？

    A：

1.监听器的初始化方法 只执行一次

package com.wh.listener;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**
 * @author 王辉
 * @site www.shihuihuila.com
 * @create 2023-08-16 18:37
 */
@WebListener
public class Listener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("初始化执行");
        ServletContext servletContext = sce.getServletContext();
        String springConfigLocation = servletContext.getInitParameter("springConfigLocation");
        System.out.println(springConfigLocation+"...");
        //拿到spring上下文
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
        //将spring的上下文保存在Tomcat上下文中
        servletContext.setAttribute("springContext", context);
    }

}

2.spring的上下文要存放在Tomcat上下文中

package com.wh.ioc;

import com.wh.web.FinanceAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * spring与web容器的整合原理
 * 	why:建模的过程是十分耗时的
 * 解决问题：
 * 1.建模必不可少
 * 2.建模只保障只执行一次
 * 3.建模后期望在每一个servlet都能够拿到spring的上下文对象ClassPathXmlApplicationContext
 * how:
 * 1.监听器的初始化方法 只执行一次
 * 2.spring的上下文要存放在Tomcat上下文中
 *  @author 王辉
  * @site www.shihuihuila.com
 *  @create 2023-08-16 19:37
 *
 */
@WebServlet("/springDemo")
public class DemoServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  this.doPost(req,resp);
    }


    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
        ClassPathXmlApplicationContext springcontext = (ClassPathXmlApplicationContext) req.getServletContext().getAttribute("springContext");

        FinanceAction financeAction = (FinanceAction) springcontext.getBean("financeAction");
        financeAction.list();
    }


}

运行即可

​ 

好啦，今天的分享就到这了，希望能够帮到你呢！😊😊  

是辉辉啦
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
Spring详解（一）------IOC控制反转
06-20 179
1、什么是 IOC？ 　　IOC-Inversion of Control，即控制反转。它不是什么技术，而是一种设计思想。 　　传统的创建对象的方法是直接通过new 关键字，而 spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC： 　　IOC让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。 2、分享Bromon的blog上对IoC与DI浅显易懂的..
Spring-从入门到精通.ppt
11-19
Spring是轻量级容器框架，提供了控制反转（IoC）和面向切面编程（AOP）的支持，用于软件开发提供全方位支持的应用程序框架。Spring框架的主要思想是控制反转和依赖注入，使用容器来管理对象之间的依赖关系，而不是...
【Spring系列篇--关于IOC的详解】
m0_73647713的博客
08-16 767
1、Spring的作用它是一个容器框架 用来整合其他的第三方框架有两大核心组件：IOC和aop2、IOC的作用特点：依赖注入、控制反转控制反转：将创建对象的权利，由程序员手动new对象的权利交给Spring容器优点：便于维护，拥抱变化3、依赖注入的方式set注入构造注入自动装配4、自动装配byName:根据bean的id在Spring的上下文进行寻找byType:根据属性接口在Spring上下文找对应的接口实现类5、Spring与web整合。
Spring核心-IoC控制反转详解 (典藏版)
04-21 1374
控制反转 (Inversion of Control， IoC) 与面向切面编程 (Aspect Oriented Programming，AOP)是 Spring Framework 中最重要的两个概念。在本篇博客中，笔者将介绍 Spring Framework 中的 IoC 容器及其背后的主要思想。IoC（控制反转）是一种编程思想，通过它可以更加灵活和可控地管理代码之间的关系，而实现 IoC 这一思想的一个最好体现就是依赖注入（dependency injection，DI）。传统的编程方式中，对象需要
Spring入门-基本介绍和IOC控制反转（注解方式）
weixin_44480609的博客
05-05 340
1.Spring概述 Spring官网 Spring，顾名思义，java软件行业的春天，彻底解放了程序员从原生的开发中，一个轻量级的非侵入式的框架。 特点：控制反转 IoC , 面向切面 Aop 组成 组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下： 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和
Spring5 框架 详解 (一) ---- IOC控制反转
qq_39654399的博客
08-28 253
Spring5 框架spring 框架概述IOC 容器1. 什么是 IOC？2. IOC底层原理：AOPJdbcTemplate事务管理Spring5 新特性 spring 框架概述 1. Spring 是轻量级的开源的 JavaEE 框架 2. Spring 可以解决企业应用开发的复杂性 3. Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向
Spring-----控制反转 ioc
weixin_41298572的博客
03-29 126
Spring几大核心功能： 1. IoC/DI 控制反转/依赖注入 2. AOP 面向切面编程 3.声明式事务 Spring的runtime 1.Test :提供spring的测试功能 2.Core container :核心容器 beans : 创建类对象并管理对象 core: 核心类 contex...
Spring教程--IOC（控制反转）详解
好好学java
04-20 1095
IOC装配Bean 1.1Spring框架Bean实例化的方式 提供了三种方式实例化Bean. * 构造方法实例化:(默认无参数) * 静态工厂实例化: * 实例工厂实例化: 1.1.1 无参数构造方法的实例化: 1.1.2 静态工厂实例化: 1.1.3 实例工厂实例化: 1.2Bean的其他配置 1.2.1
spring：详解控制反转IOC
分享前端开发工程师的一些日常生活、前端知识点、职业发展、对一些问题的看法、感悟等等
10-10 179
依赖注入（DI）是实现控制反转的一种方式，它通过容器自动将所需的依赖关系注入到对象中，从而实现对象之间的解耦。总结起来，这四个注解的作用各不相同，@Autowired和@Qualifier主要用于自动装配bean，@Resource主要用于在J2EE环境中自动装配bean，而@Value主要用于注入基本类型和String类型的值。注解的概念：和XML文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。
Spring-IOC(控制反转详解及demo)
_小点的博客
01-21 551
IOC(控制反转):对象的创建交给外部容器完成。 DI(依赖注入):处理对象的依赖关系。 两者区别: 控制反转:解决对象的创建问题。 依赖注入:在创建完对象之后，对象的关系的处理(set方法的注入).   用到的jar包: spring-beans.jar, spring-core.jar, spring-expression.jar, spring-context.jar,
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
Spring框架系列(7) - Spring IOC实现原理详解之IOC初始化流程.doc
07-13
Spring 框架系列（7）- Spring IOC 实现原理详解之 IOC 初始化流程 本文将详细解释 Spring 框架中的 IOC（Inversion of Control，控制反转）实现原理之 IOC 初始化流程。IOC 是一种软件设计模式，用于将软件系统中...
JAVA spring 系列案例50个和学习资料
03-01
Spring系列第2篇：控制反转（IoC）与依赖注入（DI）。Spring系列第3篇：Spring容器基本使用及原理。Spring系列第4篇：xml中bean定义详解(-)Spring系列第5篇：创建bean实例这些方式你们都知道？Spring系列第6篇：玩转...
详解Spring的核心机制依赖注入
01-08
依赖注入(Dependency Injection) = 控制反转(Inversion ofControl,IoC)：当某个Java实例(调用者)需另一个Java实例(被调用者)时，在依赖注入模式下，创建被调用者的工作不再由调用者来完成，因此称为 控制反转 ；...
6、Spring之Bean生命周期~创建Bean（2）
最新发布
sproutBoy的博客
06-10 677
【代码】6、Spring之Bean生命周期~创建Bean（2）
3、Spring之Bean生命周期~合并BeanDefinition
sproutBoy的博客
06-07 341
spring通过扫描，将class文件封装成BeanDefinition之后，并不能直接拿BeanDefinition去创建Bean对象，中间还需要经过一系列的合并和判断，废话不多说，直接上代码；通过上述代码我们可以看到首先回去mergedBeanDefinitions缓存中判断，这个BeanDefinitions是否已经合并过，如果合并过直接拿缓存中的对象，缓存中没有的话，调用。合并beanDefinition和java中的类继承一样，子类有的用子类，子类没有的用父类；
springboot与flowable（2）：流程部署
游王子的博客
06-10 281
选择建模器应用程序选择要导出的建模点击导出按钮。将导出的文件复制到项目中。
SpringCloud之Zuul源码解析
qq_36851469的博客
06-10 233
Zuul 是在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。Zuul 可以适当的对多个 Amazon Auto Scaling Groups 进行路由请求。其架构如下图所示：Zuul提供了一个框架，可以对过滤器进行动态的加载，编译，运行。过滤器之间没有直接的相互通信。他们是通过一个RequestContext的静态类来进行数据传递的。
spring-core 详解
06-03
Spring-core模块是Spring框架的核心模块，提供了Spring框架的核心功能，包括IoC容器、依赖注入和Spring表达式语言等。 1. IoC容器：IoC（Inversion of Control）即控制反转，是Spring框架的核心思想之一，通过IoC容器来管理和装配Bean，使得对象之间的依赖关系被反转，即由IoC容器来控制对象的创建、销毁和依赖注入等操作。 2. 依赖注入：依赖注入（Dependency Injection）是指通过构造函数、Setter方法或接口注入等方式将Bean之间的依赖关系注入到对象中，使得对象之间的关系更加松散，方便进行单元测试和模块化开发。 3. Spring表达式语言：Spring表达式语言（SpEL）是一种强大的表达式语言，可以在运行时计算表达式的值，支持对Bean的属性、方法和构造函数进行访问和操作，可以用于配置文件、注解和代码中。 除此之外，Spring-core模块还提供了很多其他的功能，如资源访问、事件发布、类型转换和注解处理等。Spring-core模块是Spring框架的核心，其他模块都依赖于它，使用Spring框架时必须引入该模块。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是辉辉啦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值