Spring设计模式_工厂模式

先说下工厂模式的特性

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

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

Git代码地址  https://github.com/wujiachengSH/WjcFactoryDemo

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

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

首先是简单工厂模式

声明一个动物工厂

 package com.wjc.Factory;
 
 public interface Animal {
 
     String eat();
 
     String dirnk();
 
     String run();
 
 }

来2个实现类

 package com.wjc.Factory;
 
 public class Elephant implements Animal {
 
     @Override
     public String eat() {
         // TODO Auto-generated method stub
         return "Elephant e";
     }
 
     @Override
     public String dirnk() {
         // TODO Auto-generated method stub
         return "Elephant d";
     }
 
     @Override
     public String run() {
         // TODO Auto-generated method stub
         return "Elephant r";
     }
 
 }

 package com.wjc.Factory;
 
 public class Leopard implements Animal {
 
     @Override
     public String eat() {
         // TODO Auto-generated method stub
         return "Leopard e";
     }
 
     @Override
     public String dirnk() {
         // TODO Auto-generated method stub
         return "Leopard d";
     }
 
     @Override
     public String run() {
         // TODO Auto-generated method stub
         return  "Leopard r";
     }
 
 }

然后我们来定义一个工厂

 package com.wjc.Factory.simple;
 
 import com.wjc.Factory.Animal;
 import com.wjc.Factory.Elephant;
 import com.wjc.Factory.Leopard;
 
 public class SimpleFactory {
 
     public Animal getAnimal(String name) {
         if ("Elephant".equals(name)) {
             return new Elephant();
         }else if ("Leopard".equals(name)) {
             return new Leopard();
         }else {
             return null;
         }
     }
 
 }

测试一下这段代码

 package com.wjc.Factory.simple;
 
 import com.wjc.Factory.Animal;
 
 public class Test {
 
     public static void main(String[] args) {
         SimpleFactory simpleFactory = new SimpleFactory();
         Animal animal = simpleFactory.getAnimal("Leopard");
         System.out.println(animal.eat());
 
     }
 }

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

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

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

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

工厂模式代码

1.声明一个工厂接口

 package com.wjc.Factory.func;
 
 import com.wjc.Factory.Animal;
 
 public interface Factory {
 
     Animal getAnimal();
 
 }

2.分别实现工厂接口

 package com.wjc.Factory.func;
 
 import com.wjc.Factory.Animal;
 import com.wjc.Factory.Elephant;
 
 public class ElephantFactory implements Factory {
 
     @Override
     public Animal getAnimal() {
         // TODO Auto-generated method stub
         return new Elephant();
     }
 
 }

 package com.wjc.Factory.func;
 
 import com.wjc.Factory.Animal;
 import com.wjc.Factory.Leopard;
 
 public class LeopardFactory implements Factory {
 
     //来个单例工厂好了
     private static class  LeopardBean {
         private static final Leopard INSTANCE = new Leopard();
     } 
 
     @Override
     public Animal getAnimal() {
         // TODO Auto-generated method stub
         return LeopardBean.INSTANCE;
     }
 
 }

3.通过工厂生成Bean

 package com.wjc.Factory.func;
 
 public class Test {
 
     public static void main(String[] args) {
         ElephantFactory elephantFactory = new ElephantFactory();
         System.out.println(elephantFactory.getAnimal().eat());
 
         LeopardFactory leopardFactory = new LeopardFactory();
         System.out.println(leopardFactory.getAnimal().eat());
 
     }
 
 }

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

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

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

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

先写一个抽象方法

 package com.wjc.Factory.abstra;
 
 import com.wjc.Factory.Animal;
 import com.wjc.Factory.func.ElephantFactory;
 import com.wjc.Factory.func.LeopardFactory;
 
 public abstract class AbstarctFactory {
 
     protected abstract Animal getAnimal();
 
     public Animal getAnimal(String name) {
         if ("Elephant".equals(name)) {
             return new ElephantFactory().getAnimal();
         }else if ("Leopard".equals(name)) {
             return new LeopardFactory().getAnimal();
         }else {
             return null;
         }
     }
 
 }

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

 package com.wjc.Factory.abstra;
 
 import com.wjc.Factory.Animal;
 import com.wjc.Factory.func.LeopardFactory;
 
 public class Factory extends AbstarctFactory {
 
     private LeopardFactory defaultFactory = new LeopardFactory();
 
     @Override
     protected Animal getAnimal() {
         // TODO Auto-generated method stub
         return defaultFactory.getAnimal();
     }
 
 }

测试一下性能

 package com.wjc.Factory.abstra;
 
 public class Test {
 
     public static void main(String[] args) {
 
         Factory factory = new Factory();
         System.out.println(factory.getAnimal("Elephant").eat());
 
     }
 
 }

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

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