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