深入理解Java设计模式-工厂模式

r囧r小猫 2023-07-15 02:57 19阅读 0赞

### 工厂模式 ###

*   *   *  1.什么是工厂模式
         *  2.工厂模式好处
         *  3.为什么要学习工厂设计模式
         *  4.Spring开发中的工厂设计模式
         *  5.工厂模式分类
         *   *  5.1 简单工厂模式
             *  5.2 工厂方法模式
             *  5.3 抽象工厂模式

### 1.什么是工厂模式 ###

它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式

### 2.工厂模式好处 ###

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。  
利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。  
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

### 3.为什么要学习工厂设计模式 ###

不知道你们面试题问到过源码没有，你知道Spring的源码吗，MyBatis的源码吗，等等等  
如果你想学习很多框架的源码，或者你想自己开发自己的框架，就必须先掌握设计模式（工厂设计模式用的是非常非常广泛的）

### 4.Spring开发中的工厂设计模式 ###

**1.Spring IOC**  
看过Spring源码就知道，在Spring IOC容器创建bean的过程是使用了工厂设计模式

Spring中无论是通过xml配置还是通过配置类还是注解进行创建bean，大部分都是通过简单工厂来进行创建的。

当容器拿到了beanName和class类型后，动态的通过反射创建具体的某个对象，最后将创建的对象放到Map中。

**2.为什么Spring IOC要使用工厂设计模式创建Bean呢**  
在实际开发中，如果我们A对象调用B，B调用C，C调用D的话我们程序的耦合性就会变高。（耦合大致分为类与类之间的依赖，方法与方法之间的依赖。）

在很久以前的三层架构编程时，都是控制层调用业务层，业务层调用数据访问层时，都是是直接new对象，耦合性大大提升，代码重复量很高，对象满天飞

为了避免这种情况，Spring使用工厂模式编程，写一个工厂，由工厂创建Bean，以后我们如果要对象就直接管工厂要就可以，剩下的事情不归我们管了。Spring IOC容器的工厂中有个静态的Map集合，是为了让工厂符合单例设计模式，即每个对象只生产一次，生产出对象后就存入到Map集合中，保证了实例不会重复影响程序效率。

### 5.工厂模式分类 ###

工厂模式分为简单工厂、工厂方法、抽象工厂模式

简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
    工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）   
    抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

我下面来使用代码演示一下：

#### 5.1 简单工厂模式 ####

**什么是简单工厂模式**  
简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。

**代码演示：**

1.  创建工厂

package com.lijie;
    
    public interface Car { 
    	public void run();
    }

1.  创建工厂的产品（宝马）

package com.lijie;
    
    public class Bmw implements Car { 
    	public void run() { 
    		System.out.println("我是宝马汽车...");
    	}
    }

1.  创建工另外一种产品（奥迪）

package com.lijie;
    
    public class AoDi implements Car { 
    	public void run() { 
    		System.out.println("我是奥迪汽车..");
    	}
    }

1.  创建核心工厂类，由他决定具体调用哪产品

package com.lijie;
    
    public class CarFactory { 
    
    	 public static Car createCar(String name) { 
    		if ("".equals(name)) { 
                 return null;
    		}
    		if(name.equals("奥迪")){ 
    			return new AoDi();
    		}
    		if(name.equals("宝马")){ 
    			return new Bmw();
    		}
    		return null;
    	}
    }

1.  演示创建工厂的具体实例

package com.lijie;
    
    public class Client01 { 
    
    	public static void main(String[] args) { 
    		Car aodi  =CarFactory.createCar("奥迪");
    		Car bmw  =CarFactory.createCar("宝马");
    		aodi.run();
    		bmw.run();
    	}
    }

**单工厂的优点/缺点**  
优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。  
缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

#### 5.2 工厂方法模式 ####

**什么是工厂方法模式**  
工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节

**代码演示：**

1.  创建工厂

package com.lijie;
    
    public interface Car { 
    	public void run();
    }

1.  创建工厂方法调用接口（所有的产品需要new出来必须继承他来实现方法）

package com.lijie;
    
    public interface CarFactory { 
    
    	Car createCar();
    
    }

1.  创建工厂的产品（奥迪）

package com.lijie;
    
    public class AoDi implements Car { 
    	public void run() { 
    		System.out.println("我是奥迪汽车..");
    	}
    }

1.  创建工厂另外一种产品（宝马）

package com.lijie;
    
    public class Bmw implements Car { 
    	public void run() { 
    		System.out.println("我是宝马汽车...");
    	}
    }

1.  创建工厂方法调用接口的实例（奥迪）

package com.lijie;
    
    public class AoDiFactory implements CarFactory { 
    
    	public Car createCar() { 
    	
    		return new AoDi();
    	}
    }

1.  创建工厂方法调用接口的实例（宝马）

package com.lijie;
    
    public class BmwFactory implements CarFactory { 
    
    	public Car createCar() { 
    
    		return new Bmw();
    	}
    
    }

1.  演示创建工厂的具体实例

package com.lijie;
    
    public class Client { 
    
    	public static void main(String[] args) { 
    		Car aodi = new AoDiFactory().createCar();
    		Car jili = new BmwFactory().createCar();
    		aodi.run();
    		jili.run();
    	}
    }

#### 5.3 抽象工厂模式 ####

**什么是抽象工厂模式**  
抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。  
![在这里插入图片描述][20200315164025575.png]  
**代码演示：**

1.  创建第一个子工厂，及实现类

package com.lijie;
    
    //汽车
    public interface Car { 
    	   void run();
    }
    
     class CarA implements Car{ 
    
    	public void run() { 
    		System.out.println("宝马");
    	}
    	
    }
     class CarB implements Car{ 
    
    	public void run() { 
    		System.out.println("摩拜");
    	}
    	
    }

1.  创建第二个子工厂，及实现类

package com.lijie;
    
    //发动机
    public interface Engine { 
    
        void run();
    
    }
    
    class EngineA implements Engine { 
    
        public void run() { 
            System.out.println("转的快!");
        }
    
    }
    
    class EngineB implements Engine { 
    
        public void run() { 
            System.out.println("转的慢!");
        }
    
    }

1.  创建一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）

package com.lijie;
    
    public interface TotalFactory { 
    	// 创建汽车
    	Car createChair();
    	// 创建发动机
    	Engine createEngine();
    }
    
    //总工厂实现类，由他决定调用哪个工厂的那个实例
    class TotalFactoryReally implements TotalFactory { 
    
    	public Engine createEngine() { 
    
    		return new EngineA();
    	}
    
    	public Car createChair() { 
    
    		return new CarA();
    	}
    }

1.  运行测试

package com.lijie;
    
    public class Test { 
    
        public static void main(String[] args) { 
            TotalFactory totalFactory2 = new TotalFactoryReally();
            Car car = totalFactory2.createChair();
            car.run();
    
            TotalFactory totalFactory = new TotalFactoryReally();
            Engine engine = totalFactory.createEngine();
            engine.run();
        }
    }

[20200315164025575.png]: /images/20230529/9ba95074a1764f53b69c597e0579c3dd.png