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就是工厂模式的升级版。