java设计模式，工厂，代理模式等

javaEE设计模式：

工厂模式：主要分为三种模式：

定义：在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。

为什么要使用工厂模式：

(1) 解耦 ：把对象的创建和使用的过程分开
(2)降低代码重复: 如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
(3) 降低维护成本 ：由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建对象B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。

1 简单工厂模式：

在实际的开发当中较少使用，主要在于违背了我们的开放-封闭原则，主要适用于创建对象较少，客户端不关心对象的创建过程方面。

主要的角色分配如下：

工厂(Factory)角色 :简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

抽象产品(Product)角色 :简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品(Concrete Product)角色:简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。在这里不做赘述。

2 工厂方法模式

定义： 工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

主要的UML类图示例如下：

主要使用的工厂模式步骤如下：

1 创建抽象工厂类，定义具体工厂的公共接口

2  创建抽象产品类定义，具体产品的公共接口

3 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；

4 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

5 最后，外界通过调用具体的工厂类的不同方法，从而创建不同的具体产品类的实例。

示例：

创建抽象工厂类，定义具体工厂的公共接口：

abstract class Factory{
    public abstract Product Manufacture();
}

创建抽象产品类 ，定义具体产品的公共接口：

abstract class Product{
    public abstract void Show();
}

创建具体产品类，（继承抽象产品类），定义生产的具体产品：

//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品B类
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法：

//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例：

//生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();

        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

最终：生产出了产品A,生产出了产品C.

工厂方法模式的优点：符合开闭原则，符合单一职责原则。可以形成基于继承的等级结构。

3 抽象工厂模式：

定义：抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。（抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类。）

 

1 创建抽象工厂类，定义具体工厂的公共接口
2 创建抽象产品族类 ，定义抽象产品的公共接口
3 创建抽象产品类 （继承抽象产品族类），定义具体产品的公共接口
4 创建具体产品类（继承抽象产品类） & 定义生产的具体产品
5创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法
6 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例

1 创建抽象工厂类，定义具体工厂的公共接口：

abstract class Factory{
   public abstract Product ManufactureContainer();
    public abstract Product ManufactureMould();
}

2 创建抽象产品族类 ，定义具体产品的公共接口：

abstract class AbstractProduct{
    public abstract void Show();
}

3 创建抽象产品类 ，定义具体产品的公共接口：

//容器产品抽象类
abstract class ContainerProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

//模具产品抽象类
abstract class MouldProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

4 创建具体产品类（继承抽象产品类）， 定义生产的具体产品：

//容器产品A类
class ContainerProductA extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品A");
    }
}

//容器产品B类
class ContainerProductB extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品B");
    }
}

//模具产品A类
class MouldProductA extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品A");
    }
}

//模具产品B类
class MouldProductB extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品B");
    }
}

5 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法：

//A厂 - 生产模具+容器产品
class FactoryA extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductA();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductA();
    }
}

//B厂 - 生产模具+容器产品
class FactoryB extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductB();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductB();
    }
}

6 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例：

//生产工作流程
public class AbstractFactoryPattern {
    public static void main(String[] args){
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.ManufactureContainer().Show();
        //A厂当地客户需要模具产品A
        mFactoryA.ManufactureMould().Show();

        //B厂当地客户需要容器产品B
        mFactoryB.ManufactureContainer().Show();
        //B厂当地客户需要模具产品B
        mFactoryB.ManufactureMould().Show();

    }
}

最后结果：

生产出了容器产品A
生产出了容器产品B
生产出了模具产品A
生产出了模具产品B

抽象工厂模式的优点：降低耦合。更符合开闭原则，符合单一职责原则，不使用静态工厂方法，可以形成基于继承的等级结构。

代理模式：

定义：给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。通过引入代理对象的方式来间接访问目标对象

模式原理图：

 

 

示例如下：

1 创建抽象对象接口（Subject）：声明你（真实对象）需要让代购（代理对象）帮忙做的事（买Mac）

 

public interface Subject {  
              public void buyMac();
}

2 创建真实对象类（RealSubject）,即”我“。

 public class RealSubject implement Subject{
    @Override
    public void buyMac() {  
        System.out.println(”买一台Mac“);  
    }  
}

3 创建代理对象类（Proxy），即”代购“，并通过代理类创建真实对象实例并访问其方法。

public class Proxy  implements Subject{
  
    @Override
    public void buyMac{
      
      //引用并创建真实对象实例，即”我“
      RealSubject realSubject = new RealSubject()；

      //调用真实对象的方法，进行代理购买Mac
      realSubject.buyMac（）；
      //代理对象额外做的操作
      this.WrapMac()；
    }

     public void WrapMac(){
      System.out.println(”用盒子包装好Mac“);  
    }
}

4 客户端调用

public class ProxyPattern {

    public static void main(String[] args){

    Subject proxy = new Proxy（）；
    proxy.buyMac()；
    }
        
}

上述过程就实现了一般的代理模式的实现。 实现优点：

1 协调调用者和被调用者，降低了系统的耦合度

2 代理对象作为客户端和目标对象之间的中介，起到了保护目标对象的作用

 

 

 

 

 

 

转载于:https://www.cnblogs.com/taue997/p/10676979.html