不得不学的设计模式之一

工厂模式

1. 简单工厂模式

2. 工厂方法模式

3. 抽象工厂模式

   简单工厂模式

   public class SimpleFactory {
   
   
       public enum CarType{
           TUYOUTA,AUDI,BENZ
       }
   
       public static Car createInstance(CarType carType){
   
           if(carType.equals(CarType.TUYOUTA)){
               return new TuYouTaCar();
           }else if(carType.equals(CarType.AUDI)){
               return new AudiCar();
           }else if(carType.equals(CarType.BENZ)){
               return new BenzCar();
           }else {
               return null;
           }
       }
   
   
   }
   

   从以上代码可以看出，工厂类的逻辑比较简单，只负责创建Car对象，符合单一职责原则，用户只调用父类，减少耦合，符合依赖倒置原则；但如果要增加一种类型，则需要修改工厂类逻辑，这样打破了开闭原则。

   简单工厂方法扩展

   public class SimpleFactory {
   
   
   
       public enum CarType {
           TUYOUTA, AUDI, BENZ
       }
   
       /**
        *1. 最简单的方法，添加产品需要修改创建方法
        *
        * @param carType
        * @return
        */
   
       public static Car createInstance(CarType carType) {
   
           if (carType.equals(CarType.TUYOUTA)) {
               return new TuYouTaCar();
           } else if (carType.equals(CarType.AUDI)) {
               return new AudiCar();
           } else if (carType.equals(CarType.BENZ)) {
               return new BenzCar();
           } else {
               return null;
           }
       }
   
       /**
        * 2.利用反射存储创建对象的Class
        * @param type
        * @param typeClass
        */
   
   
       static Map<String, Class> classMap = new HashMap<>();
   
       public static void registerType(String type, Class typeClass) {
           classMap.put(type, typeClass);
       }
   
       /**
        * 2.利用反射存储创建对象的Class
        * @param type
        * @return
        * @throws Exception
        */
       public static Car createInstanceByReflect(String type) throws Exception {
           final Class aClass = classMap.get(type);
           if (aClass != null) {
               return (Car) aClass.newInstance();
           }
           return null;
       }
   
       /**
        * 3. 抽象类定义 newInstance()方法，不在通过反射创建对象避免影响性能
        */
   
       static Map<String,Car> carMap = new HashMap<>();
   
       public static void registerCarObject(String type,Car car){
           carMap.put(type,car);
   
       }
   
       public static Car createInstanceByNew(String type){
           return carMap.get(type).newInstance();
       }
   
   }
   
   

   工厂方法模式

   

   工厂方法模式是静态工厂模式的改进，工厂类被抽象化，用于实例化特定产品类的代码被转移到实现抽象方法的子类中。这样增加种类只需要扩展工厂类。

   抽象工厂方法

   

   抽象工厂模式是工厂方法模式的扩展版，扩展了工厂不在是创建单一类型的对象，而是创建一系列相关联的对象。如果我们说工厂方法模式只包含一类抽象产品类，那么抽象工厂模式则包含多个抽象产品类。

   在开源框架中的使用

   在spring中，所有工厂都是BeanFactory的子类，通过对BeanFactory的实现，可以从Spring容器访问Bean.根据不同的策略调用getBean()方法。

   public interface BeanFactory {
       String FACTORY_BEAN_PREFIX = "&";
   
       Object getBean(String var1) throws BeansException;
   
       <T> T getBean(String var1, Class<T> var2) throws BeansException;
   
       Object getBean(String var1, Object... var2) throws BeansException;
   
       <T> T getBean(Class<T> var1) throws BeansException;
   
       <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
   
       <T> ObjectProvider<T> getBeanProvider(Class<T> var1);
   
       <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
   
       boolean containsBean(String var1);
   
       boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
   
       boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
   
       boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
   
       boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
   
       @Nullable
       Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
   
       @Nullable
       Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;
   
       String[] getAliases(String var1);
   }
   

   主要的子类

   DefaultListableBeanFactory   -- 实现了所有的抽象方法
     FileSystemXmlApplicationContext
     AbstractXmlApplicationContext
   ClassPathXmlApplicationContext
     WebApplicationContext
     。。。