Java代理模式

0.定义

代理模式(Proxy Pattern) :
Provide a surrogate or placeholder for another object to control access to it.(为其他对象提供
一种代理以控制对这个对象的访问。 )

 

 

 

1.相关类

package com.xkzhangsan.proxy;

public interface Subject {
    // 定义一个方法
    public void request();
}
package com.xkzhangsan.proxy;

public class RealSubject implements Subject {
    // 实现方法
    public void request() {
        // 业务逻辑处理
        System.out.println("RealSubject.request");
    }
}
package com.xkzhangsan.proxy;

public class Proxy implements Subject {
    // 要代理哪个实现类
    private Subject subject = null;

    // 默认被代理者
    public Proxy() {
        this.subject = new Proxy();
    }

    public Proxy(Subject _subject) {
        this.subject = _subject;
    }

    // 通过构造函数传递代理者
    public Proxy(Object... objects) {
    }

    // 实现接口中定义的方法
    public void request() {
        this.before();
        this.subject.request();
        this.after();
    }

    // 预处理
    private void before() {
        // do something
        System.out.println("Proxy.before");
    }

    // 善后处理
    private void after() {
        // do something
        System.out.println("Proxy.after");
    }
}

 

2.测试类

package com.xkzhangsan.proxy;

public class Cilent {
    
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        Proxy proxy = new Proxy(subject);
        proxy.request();
    }

}

 

3.测试结果

Proxy.before
RealSubject.request
Proxy.after

 

4.使用注意

(1)优点

a.职责清晰
b.高扩展性
c.智能化

(2)缺点

(3)使用场景

切面编程

参考:设计模式之禅

GitHub地址:https://github.com/xkzhangsan/java-designpattern-practice

Java建造者模式

0.定义

建造者模式(Builder Pattern) 也叫做生成器模式 :
Separate the construction of a complex object from its representation so that the same
construction process can create different representations.(将一个复杂对象的构建与它的表示分
离, 使得同样的构建过程可以创建不同的表示。 )

 



1.相关类

package com.xkzhangsan.builder;

public abstract class Builder {
    // 设置产品的不同部分, 以获得不同的产品
    public abstract void setPart();

    // 建造产品
    public abstract Product buildProduct();
}
package com.xkzhangsan.builder;

public class ConcreteProduct extends Builder {
    private Product product = new Product();

    // 设置产品零件
    public void setPart() {
        /*
         * 产品类内的逻辑处理
         */
    }

    // 组建一个产品
    public Product buildProduct() {
        return product;
    }
}
package com.xkzhangsan.builder;

public class Product {
    public void doSomething() {
        // 独立业务处理
        System.out.println("Product.doSomething");
    }
}
package com.xkzhangsan.builder;

public class Director {
    private Builder builder = new ConcreteProduct();

    // 构建不同的产品
    public Product getAProduct() {
        builder.setPart();
        /*
         * 设置不同的零件, 产生不同的产品
         */
        return builder.buildProduct();
    }
}

2.测试类

package com.xkzhangsan.builder;

public class Client {
    public static void main(String[] args) {
        Product product = new Director().getAProduct();
        product.doSomething();
    }

}

 

3.测试结果

Product.doSomething

 

4.使用注意

(1)优点

a.封装性
b.建造者独立, 容易扩展
c.便于控制细节风险

(2)缺点

(3)使用场景

a.相同的方法, 不同的执行顺序, 产生不同的事件结果时
b.多个部件或零件, 都可以装配到一个对象中, 但是产生的运行结果又不相同时
c.产品类非常复杂, 或者产品类中的调用顺序不同产生了不同的效能
d.在对象创建过程中会使用到系统中的一些其他对象

 

参考:设计模式之禅

GitHub地址:https://github.com/xkzhangsan/java-designpattern-practice

Java模板方法模式

 

 

0.定义

模板方法模式(Template Method Pattern) :
Define the skeleton of an algorithm in an operation,deferring some steps to subclasses.Template
Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s
structure.(定义一个操作中的算法的框架, 而将一些步骤延迟到子类中。 使得子类可以不改
变一个算法的结构即可重定义该算法的某些特定步骤。 )

 

 

1.相关类

package com.xkzhangsan.templatemethod;

public abstract class AbstractClass {
    // 基本方法
    protected abstract void doSomething();

    // 基本方法
    protected abstract void doAnything();

    // 模板方法
    public void templateMethod() {
        /*
         * 调用基本方法, 完成相关的逻辑
         */
        this.doAnything();
        this.doSomething();
    }
}
package com.xkzhangsan.templatemethod;

public class ConcreteClass1 extends AbstractClass {
    // 实现基本方法
    protected void doAnything() {
        // 业务逻辑处理
        System.out.println("ConcreteClass1.doAnything");
    }

    protected void doSomething() {
        // 业务逻辑处理
        System.out.println("ConcreteClass1.doSomething");
    }
}
package com.xkzhangsan.templatemethod;

public class ConcreteClass2 extends AbstractClass {
    // 实现基本方法
    protected void doAnything() {
        // 业务逻辑处理
        System.out.println("ConcreteClass2.doAnything");
    }

    protected void doSomething() {
        // 业务逻辑处理
        System.out.println("ConcreteClass2.doSomething");
    }
}

2.测试类

package com.xkzhangsan.templatemethod;

public class Client {
    public static void main(String[] args) {
        AbstractClass class1 = new ConcreteClass1();
        AbstractClass class2 = new ConcreteClass2();
        // 调用模板方法
        class1.templateMethod();
        class2.templateMethod();
    }
}

3.测试结果

ConcreteClass1.doAnything
ConcreteClass1.doSomething
ConcreteClass2.doAnything
ConcreteClass2.doSomething

 

4.使用注意

(1)优点

a.封装不变部分, 扩展可变部分
b.提取公共部分代码, 便于维护
c.行为由父类控制, 子类实现

(2)缺点

a.抽象类定义了部分抽象方法, 由子类实现, 子类执行的结果影响了父类的结果

(3)使用场景

a.多个子类有公有的方法, 并且逻辑基本相同时
b.重要、 复杂的算法, 可以把核心算法设计为模板方法, 周边的相关细节功能则由各个
子类实现

c.重构时, 模板方法模式是一个经常使用的模式, 把相同的代码抽取到父类中, 然后通
过钩子函数(见模板方法模式的扩展) 约束其行为

 

参考:设计模式之禅

GitHub地址:https://github.com/xkzhangsan/java-designpattern-practice

 

Java抽象工厂模式

0.定义

抽象工厂模式(Abstract Factory Pattern) :

Provide an interface for creating families of related or dependent objects without specifying
their concrete classes.(为创建一组相关或相互依赖的对象提供一个接口, 而且无须指定它们
的具体类。 )

 

 

1.相关类

package com.xkzhangsan.abstractfactory;

public abstract class AbstractCreator {
    // 创建A产品家族
    public abstract AbstractProductA createProductA();

    // 创建B产品家族
    public abstract AbstractProductB createProductB();
}
package com.xkzhangsan.abstractfactory;

public abstract class AbstractProductA {
    // 每个产品共有的方法
    public void shareMethod() {
    }

    // 每个产品相同方法,不同实现
    public abstract void doSomething();
}
package com.xkzhangsan.abstractfactory;

public abstract class AbstractProductB {
    // 每个产品共有的方法
    public void shareMethod() {
    }

    // 每个产品相同方法,不同实现
    public abstract void doSomething();
}
package com.xkzhangsan.abstractfactory;

public class Creator1 extends AbstractCreator {
    // 只生产产品等级为1的A产品
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    // 只生产产品等级为1的B产品
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}
package com.xkzhangsan.abstractfactory;

public class Creator2 extends AbstractCreator {
    // 只生产产品等级为2的A产品
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    // 只生产产品等级为2的B产品
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}
package com.xkzhangsan.abstractfactory;

public class ProductA1 extends AbstractProductA {
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}
package com.xkzhangsan.abstractfactory;

public class ProductA2 extends AbstractProductA {
    public void doSomething() {
        System.out.println("产品A2的实现方法");
    }
}
package com.xkzhangsan.abstractfactory;

public class ProductB1 extends AbstractProductB {
    public void doSomething() {
        System.out.println("产品B1的实现方法");
    }
}
package com.xkzhangsan.abstractfactory;

public class ProductB2 extends AbstractProductB {
    public void doSomething() {
        System.out.println("产品B2的实现方法");
    }
}

2.测试类

package com.xkzhangsan.abstractfactory;

public class Client {
    
    public static void main(String[] args) {
        //定义出两个工厂
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        //产生A1对象
        AbstractProductA a1 = creator1.createProductA();
        a1.doSomething();
        //产生A2对象
        AbstractProductA a2 = creator2.createProductA();
        a2.doSomething();
        //产生B1对象
        AbstractProductB b1 = creator1.createProductB();
        b1.doSomething();
        //产生B2对象
        AbstractProductB b2 = creator2.createProductB();
        b2.doSomething();
    }
}

3.测试结果

产品A1的实现方法
产品A2的实现方法
产品B1的实现方法
产品B2的实现方法

 

4.使用注意

(1)优点

a.封装性

b.产品族内的约束为非公开状态 

(2)缺点

a.抽象工厂模式的最大缺点就是产品族扩展非常困难

(3)使用场景

一个对象族(或是一组没有任何关系的对象)都有相同的约束, 则可以使用抽象工厂模式。

 

参考:设计模式之禅

GitHub地址:https://github.com/xkzhangsan/java-designpattern-practice

 

 

Java工厂方法模式

0.定义

Define an interface for creating an object,but let subclasses decide which class to
instantiate.Factory Method lets a class defer instantiation to subclasses.(定义一个用于创建对象的
接口, 让子类决定实例化哪一个类。 工厂方法使一个类的实例化延迟到其子类。 )

1.创建相关类

package com.xkzhangsan.factory;

public abstract class Product {
    // 产品类的公共方法
    public void method1() {
        // 业务逻辑处理
        System.out.println("Product.method1");
    }

    // 抽象方法
    public abstract void method2();
}
package com.xkzhangsan.factory;

public class ConcreteProduct1 extends Product {
    public void method2() {
        // 业务逻辑处理
        System.out.println("ConcreteProduct1.method2");
    }
}
package com.xkzhangsan.factory;

public class ConcreteProduct2 extends Product {
    public void method2() {
        // 业务逻辑处理
        System.out.println("ConcreteProduct1.method2");
    }
}
package com.xkzhangsan.factory;

public abstract class Creator {
    /*
     * 创建一个产品对象, 其输入参数类型可以自行设置 通常为String、 Enum、 Class等, 当然也可以为空
     */
    public abstract extends Product> T createProduct(Class c);
}
package com.xkzhangsan.factory;

public class ConcreteCreator extends Creator {
    public extends Product> T createProduct(Class c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            // 异常处理
        }
        return (T) product;
    }
}

2.测试类

package com.xkzhangsan.factory;

public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        product.method1();
        product.method2();
    }
}

3.测试结果

Product.method1
ConcreteProduct1.method2

4.使用注意

(1)优点

a.良好的封装性, 代码结构清晰。

b.工厂方法模式的扩展性非常优秀

c.屏蔽产品类

(2)缺点

(3)使用场景

a.工厂方法模式是new一个对象的替代品

b.需要灵活的、 可扩展的框架时, 可以考虑采用工厂方法模式

c.工厂方法模式可以用在异构项目中

d.可以使用在测试驱动开发的框架下

 

参考:设计模式之禅

GitHub地址:https://github.com/xkzhangsan/java-designpattern-practice