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,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类;具体的工厂负责实现具体的产品实例。(抽象工厂模式与工厂方法模式最大的区别:抽象工厂中每个工厂可以创建多种类的产品;而工厂方法每个工厂只能创建一类。)
2 创建抽象产品族类 ,定义抽象产品的公共接口
3 创建抽象产品类 (继承抽象产品族类),定义具体产品的公共接口
4 创建具体产品类(继承抽象产品类) & 定义生产的具体产品
5创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法
6 客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例
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 代理对象作为客户端和目标对象之间的中介,起到了保护目标对象的作用