package org1;

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;
		try {
			f = (Fruit) Class.forName(className).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return f;
	}
}

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

反射+简单工厂+xml配置文件

利用java的反射机制，就能动态的实例化各种类了。 但是这个程序还是存在一个问题，就是主函数这里需要填入一个完整的类名称，不够方便，所以要增加配置文件来简化

package org3;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

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;
        try {
            f = (Fruit) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}

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

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

终极版本Spring IOC

加入配置文件问题就解决了，以后如果要增加新的水果类，都要在这个配置文件里面登记。这时我们可以说配置文件可以控制程序的执行，现在看起来有点像spring的ioc了。下面我们来看看Spring IOC是如何实现的。

package test2;

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 test2;

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配置文件（该文件只要放在test2包里面就好了）

<?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="test2.Person">//第一个豆豆，是一个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="test2.Grade">//同上
		<property name="math">
			<value>99</value>
		</property>
		<property name="english">
			<value>59</value>
		</property>
	</bean>
</beans>

Test类

package test2;

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;

import test.ExampleBean;

public class Test {
	public static void main(String args[]){
		Resource input = new ClassPathResource("test2/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());
	}
}

如此看来，你在对比一开始的那个水果的程序，你会发现，spring配置文件，还是一个工厂，只不过换种形式一样，他管理所有的类，新建的类要到工厂里面去登记，不然就不能被主程序用，这就是为什么说ioc就是工厂模式的升级版。至于配置文件的书写，就跟堆积木一样。