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