简单工厂模式+反射

在本篇文章中就不详细介绍工厂模式，主要介绍一下反射在工厂模式中的使用，让读者对反射机制带来的好处有更深的认识。

首先看一下简单工厂模式

简单工厂模式（simple factory）是类的创建模式，又叫静态工厂方法（static factory method）模式。

简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类。

简单工厂模式实例：

[java] view plain copy

1. //动物接口  
2. interface Animal{  
3.     public void speak();  
4. }  
5. //人实现类  
6. class Man implements Animal{  
7.     @Override  
8.     public void speak() {  
9.         System.out.println("我是人我会说话：哈哈哈！！！");  
10.     }  
11. }  
12. //狗实现类  
13. class Dog implements Animal{  
14.     @Override  
15.     public void speak() {  
16.         System.out.println("我是小狗不会说话：汪汪汪！！！");  
17.     }  
18. }  
19. //工厂类  
20. class Factory{  
21.     public Animal getAnimal(String name){  
22.         if("man".equals(name)){  
23.             return new Man();  
24.         }else{  
25.             return new Dog();  
26.         }  
27.     }  
28. }  
29. //测试类  
30. public class GeneralFactory {  
31.     public static void main(String[] args){  
32.         Factory factory = new Factory();  
33.         Animal an = factory.getAnimal("dog");  
34.         an.speak();  
35.     }  
36. }  

输出结果：

[java] view plain copy

1. 我是小狗不会说话：汪汪汪！！！  

上面代码中，定义了一个动物（Animal）接口，接着分别定义了人（Man）和狗（Dog）实现类，实现了speak()说话的方法。

如果我们现在不用工厂模式，在调用人的说话方法时需要new一个人（Man）的对象，使用狗的说话方式时，需要new一个狗（Dog）类的对象。

这样在new对象时，就需要考虑到接口和子类的实现方式，增加了代码的耦合度。在代码中使用new操作其实也是一种硬编码方式。

使用简单工厂模式解决这个问题（上面的代码），封装一个工厂类，把new对象的操作放在这个工厂类中，这样我们在调用子类里面的方法时，并不需要考虑子类的实现方式，只需要调用工厂类，让工厂类给我们实现new对象的过程，使子类与外界操作没有联系，降低代码耦合性。

大家应该也发现了简单工厂模式有个很大的弊端，就是现在要实现很多动物的speak()方法，那么工厂类里面就要不断的添加new对象的操作，修改里面的代码，很显然这样并没有达到我们理想的要求。可以使用Java的反射机制来解决。

采用反射机制的简单工厂模式实例：

[java] view plain copy

1. package com.qcjy.factory;  
2.   
3. //动物接口  
4. interface Animal1{  
5.     public void speak();  
6. }  
7. //人实现类  
8. class Man1 implements Animal{  
9.     @Override  
10.     public void speak() {  
11.         System.out.println("我是人我会说话：哈哈哈！！！");  
12.     }  
13. }  
14. //狗实现类  
15. class Dog1 implements Animal{  
16.     @Override  
17.     public void speak() {  
18.         System.out.println("我是小狗不会说话：汪汪汪！！！");  
19.     }  
20. }  
21. //工厂类  
22. class Factory1{  
23.     public Object getAnimal(String className) throws Exception{  
24.         Class<?> cls = Class.forName(className);  
25.         Object obj = cls.newInstance();  
26.         return obj;  
27.     }  
28. }  
29. //测试类  
30. public class ReflectFactory {  
31.     public static void main(String[] args) throws Exception{  
32.         Factory1 factory = new Factory1();  
33.         Animal an = (Animal)factory.getAnimal("com.qcjy.factory.Man1");  
34.         an.speak();  
35.     }  
36. }  

输出结果：

[java] view plain copy

1. 我是人我会说话：哈哈哈！！！  

采用反射后，无论添加多少个子类，工厂类中的代码都不需要修改，只需要在操作的时候传入子类的类路径（包.类）就可以了，实现了各个业务逻辑之间的完全分离，代码耦合性进一步降低，很好的解决了上面的问题。

看到这里，大家应该体会到了反射机制给我带来的方便了吧，哈哈！

PS：工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。简单工厂模式是对代码的自然封装，比较容易理解，几乎每个人都会用的上。真正算的上设计模式的是抽象工厂模式，但是大部分人都很少能用上抽象工厂模式。Spring框架中的IOC用到的就是简单工厂模式。