我的第一个Spring程序

先上一张结构图

首先明确目标 我们需要一辆车，车有一个行驶（driver）的方法；

package com.cn.rambo.bean;

public class Car {
    private Engine engine;//引擎
    private Tire tire;//轮胎
    private String model;
    
    public Car() {
        super();
    }
    
    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public Tire getTire() {
        return tire;
    }

    public void setTire(Tire tire) {
        this.tire = tire;
    }

    public String getModel() {
        return model;
    }
    public void setModel(String model) {
        this.model = model;
    }
    
    public void driver(){
        this.engine.strat();
        this.tire.roll();
        System.out.println("3.汽车行驶");
    }
    
}

car有两个重要对象 Engine（引擎）、Tire（轮胎）；只有引擎点了火，轮胎才可以滚动，汽车才可以行驶

引擎是一个接口，有一个strat（点火）的方法，有两个实现类；

package com.cn.rambo.bean;

public interface Engine {
    public void strat();
}

引擎实现类1 （自动发送机）

package com.cn.rambo.bean;

public class EngineAuto implements Engine {
    private String name;

    public EngineAuto() {
        super();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void strat(){
        System.out.println("1.自动挡 发动机启动");        
    }

}

引擎实现类2 （手动发动机）

package com.cn.rambo.bean;

public class EngineManual implements Engine {
    private String name;

    public EngineManual() {
        super();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void strat(){
        System.out.println("1.手动挡 发动机启动");        
    }

}

轮胎也是一个接口，有一个roll（滚动）的方法，有两个实现类；

package com.cn.rambo.bean;

public interface Tire {    
    public void roll();
}

轮子实现类1 （15寸）

package com.cn.rambo.bean;

public class Tire15R implements Tire{
    private String name;

    public Tire15R() {
        super();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void roll(){
        System.out.println("2. 15吋 轮胎滚动");
    }    
}

轮子实现类1 （18寸）

package com.cn.rambo.bean;

public class Tire18R implements Tire{
    private String name;

    public Tire18R() {
        super();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void roll(){
        System.out.println("2. 18吋 轮胎滚动");
    }    
}

在src目录下建一个 applicationContext.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"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
            
    <bean id="engine" class="com.cn.rambo.bean.EngineManual">
        <property name="name"><value>发动机1</value></property>
    </bean>
    
    <bean id="engine2" class="com.cn.rambo.bean.EngineAuto">
        <property name="name"><value>发动机2</value></property>
    </bean>
    
    <bean id="tire" class="com.cn.rambo.bean.Tire15R">
        <property name="name"><value>米其林1</value></property>
    </bean>
    
    <bean id="tire2" class="com.cn.rambo.bean.Tire18R">
        <property name="name"><value>米其林2</value></property>
    </bean>
    

    <!-- 前面4个Bean是对实现类的注入 下面是将引擎和轮胎注入到car中 -->
    <bean id="car" class="com.cn.rambo.bean.Car">
        <property name="model"><value>AE_86</value></property>
        <property name="engine"><ref bean="engine2"/></property>
        <property name="tire"><ref bean="tire2"/></property>
    </bean>
    
</beans>

测试：

package com.cn.rambo.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cn.rambo.bean.Car;

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //
        Car c = (Car) ctx.getBean("car");
        c.driver();    
        
    }

}

运行结果如下：

1.自动挡 发动机启动
2. 18吋 轮胎滚动
3.汽车行驶

如果来改动xml文件，不改变任何代码 如下两个地方：

运行结果如下：

1.手动挡 发动机启动
2. 15吋 轮胎滚动
3.汽车行驶

这个程序就简单的运用到了Spring的注入，和java的多态知识； 这样一来我们只需要修改少量代码，或者不修改java代码只修改配置文件的情况下就可以实现不同逻辑运算方法；这也是非常普遍的用法；