Spring设计模式_工厂模式

先说下工厂模式的特性

　　1.对于调用者来说，影藏了复杂的逻辑处理过程，调用者只关心执行结果。

　　2.工厂要对结果负责，保证生产出符合规范的产品。

git代码地址  https://github.com/wujiachengsh/wjcfactorydemo 

 

下述的3个栗子分别为简单工厂，工厂方法，抽象工厂

 

先来个栗子看看什么是工厂把

首先是简单工厂模式

声明一个动物工厂

 1 package com.wjc.factory;
 2 
 3 public interface animal {
 4 
 5     string eat();
 6     
 7     string dirnk();
 8     
 9     string run();
10     
11 }

来2个实现类

 1 package com.wjc.factory;
 2 
 3 public class elephant implements animal {
 4 
 5     @override
 6     public string eat() {
 7         // todo auto-generated method stub
 8         return "elephant e";
 9     }
10 
11     @override
12     public string dirnk() {
13         // todo auto-generated method stub
14         return "elephant d";
15     }
16 
17     @override
18     public string run() {
19         // todo auto-generated method stub
20         return "elephant r";
21     }
22 
23 }

 1 package com.wjc.factory;
 2 
 3 public class leopard implements animal {
 4 
 5     @override
 6     public string eat() {
 7         // todo auto-generated method stub
 8         return "leopard e";
 9     }
10 
11     @override
12     public string dirnk() {
13         // todo auto-generated method stub
14         return "leopard d";
15     }
16 
17     @override
18     public string run() {
19         // todo auto-generated method stub
20         return  "leopard r";
21     }
22 
23     
24     
25 }

然后我们来定义一个工厂

 1 package com.wjc.factory.simple;
 2 
 3 import com.wjc.factory.animal;
 4 import com.wjc.factory.elephant;
 5 import com.wjc.factory.leopard;
 6 
 7 public class simplefactory {
 8 
 9     public animal getanimal(string name) {
10         if ("elephant".equals(name)) {
11             return new elephant();
12         }else if ("leopard".equals(name)) {
13             return new leopard();
14         }else {
15             return null;
16         }        
17     }
18     
19 }

测试一下这段代码

 1 package com.wjc.factory.simple;
 2 
 3 import com.wjc.factory.animal;
 4 
 5 public class test {
 6 
 7     public static void main(string[] args) {
 8         simplefactory simplefactory = new simplefactory();
 9         animal animal = simplefactory.getanimal("leopard");
10         system.out.println(animal.eat());
11         
12     }
13 }

 

可以看到工厂模式的意义在于，当需要使用对象的时候，不再通过new对象的方式拿取对象实例，而是通过工厂来获取对象

通过工厂来声明bean最大的好处就在于

可以在bean工厂中控制bean是单例的？原型模式的？被代理的等等等。

 

不过上述简单工厂能力过于强大，一个工厂竟然可以生产多种动物，显然不符合原理。我们来看正宗的工厂

 工厂模式代码

1.声明一个工厂接口

1 package com.wjc.factory.func;
2 
3 import com.wjc.factory.animal;
4 
5 public interface factory {
6 
7     animal getanimal();
8     
9 }

2.分别实现工厂接口

 1 package com.wjc.factory.func;
 2 
 3 import com.wjc.factory.animal;
 4 import com.wjc.factory.elephant;
 5 
 6 public class elephantfactory implements factory {
 7 
 8     @override
 9     public animal getanimal() {
10         // todo auto-generated method stub
11         return new elephant();
12     }
13 
14 }

 1 package com.wjc.factory.func;
 2 
 3 
 4 import com.wjc.factory.animal;
 5 import com.wjc.factory.leopard;
 6 
 7 public class leopardfactory implements factory {
 8 
 9     //来个单例工厂好了
10     private static class  leopardbean {
11         private static final leopard instance = new leopard();
12     } 
13     
14     
15     @override
16     public animal getanimal() {
17         // todo auto-generated method stub
18         return leopardbean.instance;
19     }
20 
21 }

3.通过工厂生成bean

 1 package com.wjc.factory.func;
 2 
 3 public class test {
 4 
 5     public static void main(string[] args) {
 6         elephantfactory elephantfactory = new elephantfactory();
 7         system.out.println(elephantfactory.getanimal().eat());
 8         
 9         leopardfactory leopardfactory = new leopardfactory();
10         system.out.println(leopardfactory.getanimal().eat());
11         
12     }
13     
14 }

 

可以看到标准的bean工厂，可以在工厂中声明和配置bean对象的实现特性，甚至可以把上一篇代理模式使用进去。

https://www.cnblogs.com/wujc/p/10554933.html

 

但是上述代码还是存在着一个问题，工厂很多的情况下，获取实例其实并不方便，我们再进行进一步的封装，来靠近ioc

我们来定义一个默认工厂，调用刚才封装的几个工厂

先写一个抽象方法

 1 package com.wjc.factory.abstra;
 2 
 3 import com.wjc.factory.animal;
 4 import com.wjc.factory.func.elephantfactory;
 5 import com.wjc.factory.func.leopardfactory;
 6 
 7 public abstract class abstarctfactory {
 8 
 9     protected abstract animal getanimal();
10     
11     public animal getanimal(string name) {
12         if ("elephant".equals(name)) {
13             return new elephantfactory().getanimal();
14         }else if ("leopard".equals(name)) {
15             return new leopardfactory().getanimal();
16         }else {
17             return null;
18         }        
19     }
20     
21 }

来个实现方法，其中有一个默认的产生对象

 

 1 package com.wjc.factory.abstra;
 2 
 3 import com.wjc.factory.animal;
 4 import com.wjc.factory.func.leopardfactory;
 5 
 6 public class factory extends abstarctfactory {
 7 
 8     private leopardfactory defaultfactory = new leopardfactory();
 9     
10     @override
11     protected animal getanimal() {
12         // todo auto-generated method stub
13         return defaultfactory.getanimal();
14     }
15 
16 }

测试一下性能

 1 package com.wjc.factory.abstra;
 2 
 3 public class test {
 4 
 5     public static void main(string[] args) {
 6         
 7         factory factory = new factory();
 8         system.out.println(factory.getanimal("elephant").eat());
 9         
10         
11     }
12     
13 }

上述改造后的代码就是抽象工厂模式了

小结一下工厂模式，特性是封装了创建bean的过程。