SpringIoc 和 工廠模式(反射實現)

一、先演示 “簡單工廠”：

package org;

interface Fruit {
    public void eat();
}

class Apple implements Fruit {
    public void eat() {
        System.out.println("吃蘋果。");
    }
}

class Orange implements Fruit {
    public void eat() {
        System.out.println("吃橘子");
    }
}

class Factory { // 工廠類
    public static Fruit getInstance(String className) {
        Fruit f = null;
        if (className.equals("apple")) {
            f = new Apple();
        }
        if (className.endsWith("orange")) {
            f = new Orange();
        }
        return f;
    }
}

public class FactoryDemo {
    public static void main(String args[]) {
        Fruit f = Factory.getInstance("apple");
        f.eat();
    }
}

問題:若增加新水果，如香蕉，則工廠類也要修改.

解決:java的反射機制.

二、修改“工廠類”：

//工廠類(修改)
class Factory { 
    public static Fruit getInstance(String className) {
        Fruit f = null;
        try {  
            f = (Fruit) Class.forName(className).newInstance();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return f;
    }
}

問題：創建實例時，需要提供“完整的類名”

public class FactoryDemo2 {
    public static void main(String args[]) {
        Fruit f = Factory.getInstance("org.Orange");
        f.eat();
    }
}

解決:增加“配置文件”優化.

三、增加“配置文件”：

class PropertiesOperate{  
    private Properties pro=null;  
    private File file=new File("d:"+File.separator+"fruit.properties");  
      
    public PropertiesOperate(){  
        pro=new Properties();  
        if(file.exists()){  
            try {  
                pro.loadFromXML(new FileInputStream(file));  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }else{  
            this.save();  
        }  
    }  
    private void save(){  
        pro.setProperty("apple","org.Apple");  
        pro.setProperty("orange", "org.Orange");  
        try {  
            pro.storeToXML(new FileOutputStream(this.file),"Fruit");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
    public Properties getProperties(){  
        return pro;  
    }  
} 

public class FactoryDemo3 {
    public static void main(String args[]) {
        Properties pro=new PropertiesOperate().getProperties();  
        Fruit f= Factory.getInstance(pro.getProperty("orange")); 
        f.eat();
    }
}

通過配置文件，可以控制程序的執行，現在看起來有點像spring的ioc了。

 

該程序使用了工廠模式，把所有的類放在一個Factory里面，而為了動態的管理這些類（即使增加了新的Fruit類，這個工廠也不用變化），就用了java的反射機制。

另外，通過配置文件，使得一長串完整的類名稱（如org.Apple）可用任意簡短的名稱來代替（如apple）。

 

四、簡單的spring配置文件測試

 

package test;

public class Person {
    private String name;
    private int age;
    private Grade grade;

    public String getName() {
        return name;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

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

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

    public int getAge() {
        return age;
    }

    public int getTotleGrade() {
        return grade.getEnglish() + grade.getMath();
    }
}

package test;

public class Grade {
    private int math;
    private int english;

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }
}

bean .xml 類

<?xml version="1.0" encoding="UTF-8"?>  
  
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"  
  
"http://www.springframework.org/dtd/spring-beans.dtd">  
<beans>
    <bean id="Person" class="test.Person"><!-- 第一個bean，是一個Person類，id名字隨便取，還要寫上類的全名 -->  
        <property name="name"> 
            <value>小龍</value><!-- 這里的名字是通過程序里面的set來賦值的，如果去掉程序對應的set，就出錯了 -->  
        </property>  
        <property name="age">  
            <value>23</value>  
        </property>  
        <property name="grade"><!-- 這里有點特別，這個grade變量是一個對象，和一般的變量要區別對待 -->  
            <ref local="Grade"/><!-- 這里指向了本配置文件里面一個名字叫Grade(即id=Grade)的bean --> 
        </property>  
    </bean>  
    <bean id="Grade" class="test.Grade"><!-- 同上 -->  
        <property name="math">  
            <value>99</value>  
        </property>  
        <property name="english">  
            <value>59</value>  
        </property>  
    </bean>  
</beans>  

測試類

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Test {  
    public static void main(String args[]){  
        Resource input = new ClassPathResource("test/Bean.xml");//Bean.xml的路徑  
  
        System.out.println("resource is:" + input);  
  
        BeanFactory factory = new XmlBeanFactory(input);//把input扔到工廠里面去，這個工廠就能為你提供實例了（我也不知道能不能這樣說）  
  
        Person person =(Person) factory.getBean("Person");//你要一個叫Person的東西，那好，工廠就去找“Person"給你  
        Grade grade=(Grade)factory.getBean("Grade");  
        System.out.println("姓名："+person.getName());//person可以調用里面相關的方法，就相當於new了一個Person一樣  
        System.out.println("年齡："+person.getAge());  
        System.out.println("數學成績："+grade.getMath());  
        System.out.println("英語成績："+grade.getEnglish());  
        System.out.println("數學，英語總成績："+person.getTotleGrade());  
    }  
}

 

對比前面的那個“Fruit程序”，你會發現，spring配置文件，還是一個工廠（只是換種形式一樣），它管理所有的類，新建的類要到工廠里面去登記，不然就不能被主程序用，這就是為什么說ioc就是工廠模式的升級版。