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