spring ioc

最新推荐文章于 2025-08-22 18:53:49 发布

原创最新推荐文章于 2025-08-22 18:53:49 发布 · 306 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #ioc #架构

spring是一个非入侵框架，ioc是一种架构思想，致力于将程序模块解耦，突出面向接口编程的思想，把功能模块与业务逻辑部分分离，体现了一种灵活的架构模式

springioc的非入侵性，指的是程序如果能用spring管理运行，那么脱离了springioc程序依然能运行，只是springioc管理之后代码逻辑会更明析一些

springioc相关涉及的依赖有spring-context, spring-bean,spring-core，而spring-core又依赖spring-asm和commons-logging

所以我的依赖为commons-logging-1.1.1.jar，spring-asm-3.1.1.RELEASE.jar，spring-core-3.1.1.RELEASE.jar，spring-beans-3.1.1.RELEASE.jar，spring-context-3.1.1.RELEASE.jar

首先来java程序的注入方式，java注入和spring注入

构造器注入、setter注入、接口注入

首先定义属性接口类

package com.framework.common.java.inject;
/**
 * 引擎
 */
public interface IEngine {
  void start();
}

其次定义属性类

package com.framework.common.java.inject;
/**
 * 引擎1
 */
public class Engine implements IEngine{
  public void start(){
    System.out.println("引擎起动 ... ");
  }
}

1、构造器注入

<pre name="code" class="html">package com.framework.common.java.inject;
/**
 * 构造器注入
 */
public class ConsCar {
  private Engine engine;
  public ConsCar(Engine engine) {
    this.engine = engine;
  }
  public void drive() {
    System.out.println("构造器注入... ");
    engine.start();
  }
}

2、setter注入

package com.framework.common.java.inject;
/**
 * setter注入
 */
public class SetCar {
  private Engine engine;
  public Engine getEngine() {
    return engine;
  }
  public void setEngine(Engine engine) {
    this.engine = engine;
  }
  public void drive(){
    System.out.println("setter注入... ");
    engine.start();
  }
}

3、接口注入

package com.framework.common.java.inject;
/**
 * 接口注入
 */
public abstract class InterCar {
  public abstract IEngine getIEngine();
  public void drive(){
    System.out.println("接口注入 ... ");
    getIEngine().start();
  }
}

下面我们看看三种注入方式的spring配置

<!-- 构造器注入 -->
<bean class="com.framework.common.java.inject.ConsCar">
	<constructor-arg name="engine">
		<bean class="com.framework.common.java.inject.Engine"/>
	</constructor-arg>
</bean>

<!-- setter注入 -->
<bean class="com.framework.common.java.inject.SetCar">
	<property name="engine">
		<bean class="com.framework.common.java.inject.Engine"/>
	</property>
</bean>

<!-- 接口注入-->
<bean class="com.framework.common.java.inject.InterCar">
	<lookup-method name="getIEngine" bean="interEngine"/>
</bean>
<bean id="interEngine" class="com.framework.common.java.inject.Engine"/>

我看看三种注入方式

  public static void main(String[] args){
    ConsCar car1 = new ConsCar(new Engine());
    car1.drive();
    
    SetCar car2 = new SetCar();
    car2.setEngine(new Engine());
    car2.drive();
    
    InterCar car3 = new InterCar(){
      @Override
      public IEngine getIEngine() {
        return  new Engine();
      }
    };
    car3.drive();
  }

运行结果为：

构造器注入... 
引擎起动 ... 
setter注入... 
引擎起动 ... 
接口注入 ... 
引擎起动 ...

再看spring的三种注入方式

  public static void main(String[] args){
    ApplicationContext ctx = new ClassPathXmlApplicationContext("inject.xml");
    ConsCar car1 = ctx.getBean(ConsCar.class);
    car1.drive();
    SetCar car2 = ctx.getBean(SetCar.class);
    car2.drive();
    InterCar car3 = ctx.getBean(InterCar.class);
    car3.drive();
  }

运行结果为：

构造器注入... 
引擎起动 ... 
setter注入... 
引擎起动 ... 
接口注入 ... 
引擎起动 ...

由此可见，spring注入把一些对象之前的关系抽象到了配置文件中，做成了xml配置，而不需要在代码中new对象，或者set属性，让spring容器把bean管理起来