欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Spring设计模式_工厂模式

程序员文章站 2023-08-13 10:57:25
先说下工厂模式的特性 1.对于调用者来说,影藏了复杂的逻辑处理过程,调用者只关心执行结果。 2.工厂要对结果负责,保证生产出符合规范的产品。 Git代码地址 https://github.com/wujiachengSH/WjcFactoryDemo 下述的3个栗子分别为简单工厂,工厂方法,抽象工厂 ......

先说下工厂模式的特性

  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的过程。