设计模式 on 易哥

责任链模式详解及其使用示例

Sat, 15 Feb 2025 00:00:00 +0000

在有些场景下，一个目标对象可能需要经过多个对象的处理。例如我们要筹办一个校园晚会，需要针对演员进行如下的准备工作：

给演员发送邮件，告知晚会时间地点，该工作由邮件发送员负责。
根据演员性别为其准备衣服，该工作由物资管理员负责。
如果演员未成年，则为其安排校车接送，该工作由对外联络员负责。

下面代码展示了这一过程，每一个演员都要好三个工作人员打交道。

// 不使用责任链模式
System.out.println("不使用责任链模式：");
// 创建三个工作人员实例
MailSender mailSender = new MailSender();
MaterialManager materialManager = new MaterialManager();
ContactOfficer contactOfficer = new ContactOfficer();
// 依次处理每个参与者
for (Performer performer : performerList) {
    System.out.println("process " + performer.getName() + ":");
    new MailSender().handle(performer);
    new MaterialManager().handle(performer);
    new ContactOfficer().handle(performer);
    System.out.println("---------");
}

而责任链模式将多个处理器组装成一个链条，被处理对象被放置到链条的起始端后，会自动在整个链条上传递和处理。这样被处理对象不需要和每个处理器打交道，也不需要了解整个链条的传递过程，于是便实现了被处理对象和单个处理器的解耦。

为实现责任链模式，我们首先创建了一个处理器抽象类Handler，如下所示。

public abstract class Handler {
    // 当前处理器的下一个处理器
    private Handler nextHandler;

    /**
     * 当前处理器的处理逻辑，交给子类实现
     * @param performer 被处理对象
     */
    public abstract void handle(Performer performer);

    /**
     * 触发当前处理器，并在处理结束后将被处理对象传给后续处理器
     * @param performer 被处理对象
     */
    public void triggerProcess(Performer performer) {
        handle(performer);
        if (nextHandler != null) {
            nextHandler.triggerProcess(performer);
        }
    }

    /**
     * 设置当前处理器的下一个处理器
     * @param nextHandler 下一个处理器
     * @return 下一个处理器
     */
    public Handler setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
        return nextHandler;
    }
}

然后每个处理器需要继承该抽象类Handler，并实现自身的handle方法。下图是责任链模式的类图。

无所不能的javassist和基于它实现的动态代理

Sun, 14 May 2023 00:00:00 +0000

我们已经介绍了基于反射的动态代理和基于cglib(Code Generation Library，即代码生成库) 的动态代理。本文我们将介绍javassist，基于它也可以实现动态代理。

cglib是基于底层的ASM框架来实现Java字节码的修改。而javassist和ASM类似，它是也是一个开源的用来创建、修改Java字节码的类库，能实现类的创建、方法的修改、继承关系的设置等一系列的操作。

相比于ASM，javassist的优势是学习成本低，可以根据java代码生成字节码，而不需要直接操作字节码。

javassist的使用虽然比ASM简单，但也并不是太容易。我们通过一个示例来展示下javassist的使用，以“无中生有”的方式创建一个类，并给类设置属性和方法。整个示例如如下所示。

public static void main(String[] args) throws Exception {
    ClassPool pool = ClassPool.getDefault();
    // 定义一个类
    CtClass userCtClazz = pool.makeClass("com.github.yeecode.mybatisdemo.User");
    // 创建name属性
    CtField nameField = new CtField(pool.get("java.lang.String"), "name", userCtClazz);
    userCtClazz.addField(nameField);
    // 创建name的set方法
    CtMethod setMethod = CtNewMethod.make("public void setName(String name) { this.name = name;}", userCtClazz);
    userCtClazz.addMethod(setMethod);
    // 创建sayHello方法
    CtMethod sayHello = CtNewMethod.make("public String sayHello() { return \"Hello, I am \" + this.name ;}", userCtClazz);
    userCtClazz.addMethod(sayHello);

    Class<?> userClazz = userCtClazz.toClass();
    // 创建一个对象
    Object user = userClazz.newInstance();
    // 为对象设置name值
    Method[] methods = userClazz.getMethods();
    for (Method method: methods){
        if (method.getName().equals("setName")) {
            method.invoke(user,"易哥");
        }
    }
    // 调用对象sayHello方法
    for (Method method: methods){
        if (method.getName().equals("sayHello")) {
            String result = (String) method.invoke(user);
            System.out.println(result);

        }
    }
}

运行上述代码，可以看到控制台打印出下图所示的输出结果。

神通广大的cglib和基于它实现的动态代理

Sun, 21 Aug 2022 00:00:00 +0000

前面的文章中我们已经介绍了基于反射的动态代理。但是它有一个制约条件，即被代理的类必须要有一个父接口。但是有些类确实没有父接口，对于这些类而言，基于反射的动态代理是不适用的。

本文我们介绍另一种实现动态代理的方式：基于cglib(Code Generation Library，即代码生成库) 的动态代理。

一个类必须要通过类加载过程将类文件加载到JVM后才能使用。那是否能够直接修改JVM中的字节码信息来修改和创建类呢？

答案是可以的，cglib就是基于这个原理工作的。cglib使用字节码处理框架ASM来转换字节码并生成被代理类的子类。然后这个子类就可以作为代理类展开工作。ASM是一个非常底层的框架，除非你对JVM内部结构包括class文件的格式和指令集都很熟悉，否则不要直接使用ASM。

接下来我们通过示例介绍一下如何用cglib实现动态代理。

首先要在项目中引入cglib工具包，以使用Maven为例，在pom文件中增加下面所示的依赖。

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.9</version>
</dependency>

被代理类不需要实现任何接口，下面代码给出了一个简单的被代理类。

public class User{
    public String sayHello(String name) {
        System.out.println("hello " + name);
        return "OK";
    }
}

接下来我们编写一个实现了org.springframework.cglib.proxy.MethodInterceptor接口的类，如下所示。

public class ProxyHandler<T> implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before speak");
        Object ans = methodProxy.invokeSuper(o, objects);
        System.out.println("after speak");
        return ans;
    }
}

被代理类中的方法被拦截后，会进入该类中intercept方法。在该类的intercept方法中，我们在被代理对象的方法执行前后各增加了一句输出语句。

之后我们就可以建立代理对象，实现动态代理操作，该过程如下所示。

public static void main(String[] args) throws Exception {
    Enhancer enhancer = new Enhancer();
    // 设置enhancer的回调对象
    enhancer.setCallback(new ProxyHandler<>());
    // 设置enhancer对象的父类
    enhancer.setSuperclass(User.class);
    // 创建代理对象，实际为User的子类
    User user = (User) enhancer.create();

    // 通过代理对象调用目标方法
    String ans = user.sayHello("易哥");
    System.out.println(ans);
}

我们创建了一个代理对象（即变量user对应的对象），然后调用了其中的方法。最终得到了下图所示的运行结果。

建造者模式详解及其实战源码分析

Sun, 19 Dec 2021 00:00:00 +0000

在软件开发过程中，经常需要新建对象并给对象的属性赋值。当对象的属性比较多时，创建对象的过程会变得比较烦琐。

例如，某个平台需要在开学季给Sunny School和Garden School两所学校的新同学注册账号。Sunny School是一所小学，新同学年龄大多为7岁；Garden School是一所中学，新同学年龄大多为13岁。在注册账号的过程中，如果同学没有电子邮箱的话还要为其注册电子邮箱。

先建造空对象，然后在不断调用set方法为对象属性赋值是一种常见的建造对象的方式，如下面代码所示。

User user01 = new User();
user01.setName("Candy");
user01.setEmail("candy@sunnyschool.com");
user01.setAge(7);
user01.setSex(1);
user01.setSchoolName("Sunny School");

这种方式需要了解对象的所有属性细节，是和对象的属性耦合的，而且这个过程中可能会导致属性的遗忘。

使用具有多个入参的构造方法直接建造对象也是一种常见的建造对象的方式，如下所示。

User user02 = new User("Candy", "candy@sunnyschool.com", 7, 1, "Sunny School");

这种情况下，为了能适应多种入参组合，通常需要重载出大量的构造方法。

建造者模式给我们提供了另一种建造对象的思路。使用建造者模式，对象的建造细节均交给建造者来完成，调用者只需要掌控总体流程即可，而不需要了解被建造对象的细节。

例如，我们编写一个UserBuilder接口作为建造User对象的接口，如下所示。

public interface UserBuilder {

    public UserBuilder setEmail(String email);

    public UserBuilder setAge(Integer age);

    public UserBuilder setSex(Integer sex);

    public User build();
}

然后我们继承UserBuilder接口编写一个SunnySchoolUserBuilder类，它用来建造Sunny School的用户，如下所示。

public class SunnySchoolUserBuilder implements UserBuilder {
    private String name;
    private String email;
    private Integer age;
    private Integer sex;
    private String schoolName;

    public SunnySchoolUserBuilder(String name) {
        this.name = name;
    }

    public SunnySchoolUserBuilder setEmail(String email) {
        this.email = email;
        return this;
    }

    public SunnySchoolUserBuilder setAge(Integer age) {
        this.age = age;
        return this;
    }

    public SunnySchoolUserBuilder setSex(Integer sex) {
        this.sex = sex;
        return this;
    }

    public User build() {
        if (this.name != null && this.email == null) {
            this.email = this.name.toLowerCase().replace(" ", "").concat("@sunnyschool.com");
        }
        if (this.age == null) {
            this.age = 7;
        }
        if (this.sex == null) {
            this.sex = 0;
        }
        this.schoolName = "Sunny School";
        return new User(name, email, age, sex, schoolName);
    }
}

这样一来，我们可以灵活地建造对象。

适配器模式详解与使用示例

Sat, 21 Aug 2021 00:00:00 +0000

1. 适配器思想

适配器模式（Adapter Pattern）是一种结构型模式，基于该模式设计的类能够在两个或者多个不兼容的类之间起到沟通桥梁的作用。

转换插头就是一个适配器的典型例子。不同的转换插头能都够适配不同国家的插座标准，从而使得一个电器能在各个国家使用。

适配器的思想在程序设计中非常常见，下面代码就体现了这种思想：

// 方法一
public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
  return this.selectMap(statement, null, mapKey, RowBounds.DEFAULT);
}

// 方法二
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
  return this.selectMap(statement, parameter, mapKey, RowBounds.DEFAULT);
}

// 方法三
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
  final List<? extends V> list = selectList(statement, parameter, rowBounds);
  final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<>(mapKey,
          configuration.getObjectFactory(), configuration.getObjectWrapperFactory(), configuration.getReflectorFactory());
  final DefaultResultContext<V> context = new DefaultResultContext<>();
  for (V o : list) {
    context.nextResultObject(o);
    mapResultHandler.handleResult(context);
  }
  return mapResultHandler.getMappedResults();
}

上述代码中，方法三是核心方法，它需要四个输入参数。而有些场景下，调用方只能提供三个参数或者两个参数。为了使得只有三个参数或者两个参数的调用方能够正常地调用核心方法，方法一和方法二充当了方法适配器的作用。这两个适配器通过为未知参数设置默认值的方式，搭建起了调用方和核心方法之间的桥梁。

一文搞清楚模板模式的定义及其在MyBatis中的使用

Sat, 17 Jul 2021 00:00:00 +0000

说起模板大家应该都熟悉。一般情况下，模板中规定了大体的框架，只留下一些细节供使用者来修改和完善。使用同一模板做出的不同产品都具有一致的框架。

设计模式中的模板模式与上述模板的概念相同。在模板模式中，需要使用一个抽象类定义一套操作的整体步骤（即，模板），而抽象类的子类则完成每个步骤的具体实现。这样，抽象类的不同子类总是遵循了同样的一套模板。

例如我们定义一套打扫卫生的模板，如下面代码所示。它为所有的打扫卫生工作定义了四个大的步骤：准备（prepare）、实施（implement）、善后（windup）、汇报（report）。

public abstract class Cleaning {

    public void clean(){
        prepare();
        implement();
        windup();
        report();
    }

    abstract void prepare();

    abstract void implement();

    abstract void windup();

    void report() {
        System.out.println("告诉别人已经打扫完成。");
    }
}

这样，我们可以基于该模板完成一些具体的打扫卫生工作。下面分别给出擦玻璃和擦黑板的实现：

public class WipeGlass extends Cleaning{
    @Override
    void prepare() {
        System.out.println("找到抹布。");
        System.out.println("浸湿和清洗抹布。");
    }

    @Override
    void implement() {
        System.out.println("擦玻璃。");
    }

    @Override
    void windup() {
        System.out.println("清理窗台。");
    }
}

public class WipeBlackboard extends Cleaning {
    @Override
    void prepare() {
        System.out.println("找到黑板檫。");
    }

    @Override
    void implement() {
        System.out.println("用力擦黑板。");
    }

    @Override
    void windup() {
        System.out.println("清理粉笔屑。");
    }
}

可以看到，虽然具体的行为不同，但是CleanGlass和WipeBlackboard两者遵循的模板是一样的，都是由Cleaning类给定的。这就是模板模式的作用，即确定了一套操作的框架，而子类只需要在此框架的基础上定义具体的实现。

灵活又强大的装饰器模式实例与应用源码解析

Sun, 21 Feb 2021 00:00:00 +0000

装饰器模式，又称为包装模式，是一种结构型模式。这种设计模式是指能够在一个类的基础上增加一个装饰类（也可以叫包装类），并在装饰类中增加一些新的特性和功能。这样，通过对原有类的包装，就可以在不改变原有类的情况下为原有类增加更多的功能。

例如我们定义Phone接口，它规定了发送和接收语音的抽象方法。

public interface Phone {
    String callIn();
    Boolean callOut(String info);
}

然后定义一个类TelePhone，实现了Phone接口，能够实现打电话的功能。

public class TelePhone implements Phone {
    @Override
    public String callIn() {
        System.out.println("接受语音……");
        return "get info";
    }

    @Override
    public Boolean callOut(String info) {
        System.out.println("发送语音：" + info);
        return true;
    }
}

那现在我们要创建一个装饰器，在不改变原有TelePhone的基础上，实现通话录音功能。我们的装饰器类的源码如下所示。

public class PhoneRecordDecorator implements Phone {
    private Phone decoratedPhone;

    public PhoneRecordDecorator(Phone decoratedPhone) {
        this.decoratedPhone = decoratedPhone;
    }

    @Override
    public String callIn() {
        System.out.println("启动录音……");
        String info = decoratedPhone.callIn();
        System.out.println("结束录音并保存录音文件。");
        return info;
    }

    @Override
    public Boolean callOut(String info) {
        System.out.println("启动录音……");
        Boolean result = decoratedPhone.callOut(info);
        System.out.println("结束录音并保存录音文件。");
        return result;
    }
}

这样，经过我们的PhoneRecordDecorator包装过的Phone就具有了通话录音的能力，如下所示。

RPC与动态代理

Sat, 21 Apr 2018 00:00:00 +0000

1 RPC 简介

RPC（Remote Procedure Call）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。 RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。

2 RPC实现

RPC的实现中一个重要的功能就是动态代理。整个过程如下：

首先，对于用户方而言：

只提供接口不提供实现类，所有的接口文件都导出后，调用方放在一个专门目录下
接口千奇百怪，但是都没有具体实现
代理要代理掉专门目录下的所有接口，任何对这里接口的调用都被序列化后转到远端

假设，我们有一个接口如下：

public interface RemoteService {
    public String getValue(String input);
}

只有方法名称，也不知道接口在远端的实现类的名称。

然后，我们的ProxyHandler如下：

public class ProxyHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Proxy Doing.");
        System.out.println("proxy :" + proxy.getClass().toString());
        System.out.println("method :" + method.toGenericString());
        System.out.println("args :" + args);
        System.out.println("序列化后去寻找具体实现……");
        return "Proxy Finish.";
    }
}

具体使用时这样：

public void test() {
    try {
       // 生成一个代理对象实例。注意，这里我们只需要接口，不需要知道任何实现类的信息
        RemoteService remoteService =
                (RemoteService) Proxy.newProxyInstance(
                        RemoteService.class.getClassLoader(),
                        new Class[] { RemoteService.class },
                        new ProxyHandler());

        String out2 = RemoteService.getValue("AA");
        System.out.println(out2);
    } catch (Throwable ex) {
        ex.printStackTrace();
    }
}

这样，就可以实现RPC的代理了。运行结果：

基于反射的动态代理实现

Wed, 08 Nov 2017 00:00:00 +0000

1 动态代理

动态代理的实现方式常用的有两种：

反射实现：基于反射实现，目标对象必须要有接口。生成的代理类是接口的一个实现类
Cglib实现：基于字节码实现，效率稍低，但目标对象不需要有接口。生成的代理类是目标类的子类，因此目标类不能是final的。

2 背景介绍

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象，只能针对接口做代理。

接口和目标类没有任何变化，只不过为了增加难度，我们增加了返回值。

接口如下，除了增加了方法的返回值外无任何变化：

public interface UserInterface {
    String sayHello(String name);
}

目标类如下，无任何变化：

public class User implements UserInterface {
    @Override
    public String sayHello(String name) {
        System.out.println("hello " + name);
        return "OK";
    }
}

2 反射调用方法

接下来，我们使用JDK完成动态代理，对于代理类只需要实现InvocationHandler接口即可，并且要实现其中的invoke（）方法。

invoke（）中需要传入目标对象、目标对象的方法、调用目标所需的参数，传入后，就会直接调用指定对象的指定方法了。

public class ProxyHandler<T> implements InvocationHandler {
/**
 * @param proxy  被代理的对象
 * @param method 要调用的方法
 * @param args   方法调用时所需要参数
 * @return
 * @throws Throwable
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("pre words");
    Object ans = method.invoke(proxy, args);
    System.out.println("post words");
    return ans;
}

我们使用举例：

代理模式与静态代理

Sat, 14 Oct 2017 00:00:00 +0000

1 代理模式

1.1 定义

代理模式：对某一个目标对象提供它的代理对象，并且由代理对象控制对原对象的引用。

例如，我们想访问某个对象A时，不能直接访问，需要由对象A的代理对象A Proxy进行代理。通俗来说，A Proxy我们可以认为是A的助理、中介、对外联络人。

1.2 作用

隔离作用：可以防止对目标对象的直接访问，实现目标对象与外部的隔离，从而提供安全保障等。例如：在代理中增加权限身份验证。

扩展功能：代理对象可以在目标对象的基础上增加功能。例如：Java切面操作通过建立代理实现。

直接替换：代理对象可以直接替换目标对象的功能，带来全新的实现方式。例如：RPC通过建立代理，直接实现了不存在的接口实现（消费者中只有接口，没有实现类，RPC直接把对实现类的访问转走了）。

2 静态代理

静态代理就是按照代理模式书写的代码，其特点是代理类和目标类在代码中是确定的，因此是静态的。

我们举例子进行介绍。

首先，写出目标类和代理类共同需要实现的接口，我们假设只有一个打招呼的功能。

public interface UserInterface {
    void sayHello(String name);
}

目标类实现如下：

public class User implements UserInterface {
    @Override
    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

代理类实现如下：

public class UserProxy implements UserInterface {
    private UserInterface target;

    public UserProxy (UserInterface target) {
        this.target = target;
    }

    @Override
    public void sayHello(String name) {
        System.out.println("pre words");
        target.sayHello(name);
        System.out.println("post words");
    }
}

测试方法如下：