八股之设计模式

原创已于 2024-08-20 20:54:25 修改

· 668 阅读

10 ·

版权

文章标签：

#设计模式

于 2024-08-10 14:51:20 首次发布

一、工厂模式

1.简单工厂模式

产品类：

public class ProductA1{
}

public class ProductA2{
}

工厂类：

public class AFactory {
    public static Product newInstance(String type) {
        switch (type) {
            case "productA1":
                return new ProductA1();
            case "productA2":
                return new ProductA2();
            default:
                return new DefaultProductA();
        }
    }
}

使用方法：

ProductA1 productA1 = new AFactory("productA1");

2.工厂方法模式

产品抽象及实现类：

abstract class ProductA {
}

public class ProductA1 extends ProductA{
}

public class ProductA2 extends ProductA{
}

工厂接口及实现类：

public interface AFactory {
    ProductA createProductA();
}

public class A1Factory implements AFactory{
    public ProductA1 createProductA(){
        return new ProductA1();
    }
}

public class FactoryA2 implements AFactory {
    public ProductA2 createProductA(){
        return new ProductA2();
    }
}

使用方法：

A1Factory A1Factory = new A1Factory();
ProductA1 productA1 = A1Factory.createProductA();

3.抽象工厂模式

public interface ABFactory {
    ProductA createProductA();
    ProductB createProductB();
}

4.总结

简单工厂模式：直接通过工厂创建
- 优点：通过引入配置文件，可以在不修改客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性
- 缺点：不符合“开闭原则”，每次添加新产品就需要修改工厂类。在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响
工厂方法模式：定义工厂接口后实现不同工厂
- 优点：每增加新产品，只需增加该产品以及对应的具体实现工厂类，不必修改原来的代码。在使用时，当我们选择出具体的工厂，就已经决定了实际创建的产品
- 缺点：每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖
抽象工厂模式：实现多个产品的生产
- 优点：抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，能够保证客户端始终只使用同一个产品族中的对象
- 缺点：添加一个新产品族对象时需要更改接口及其下所有子类

二、代理模式

使用代理对象来代替对真实对象的访问，在不修改原目标对象的前提下，扩展目标对象的功能

1.静态代理

静态代理中对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦(需要对每个目标类都单独写一个代理类）。实际应用场景非常少

（1）定义一个接口及其实现类

public interface SmsService {
    String send(String message);
}

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

（2）创建一个代理类同样实现这个接口，将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法，在目标方法执行前后拓展功能

public class SmsProxy implements SmsService {

    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}

实际使用

public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}

2.动态代理

在静态代理中，每个类都需要定义自己的代理类，但是很多类的代理的自定义逻辑是相同的，造成代码重复。在动态代理中，可以自定义通用的代理逻辑，实现代码复用

（1）JDK动态代理

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

InvocationHandler 用来自定义处理逻辑。当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

具体实现：

SmsService smsService = (SmsService) Proxy.newProxyInstance(
                            SmsService.getClass().getClassLoader(), // 目标类的类加载器
                            SmsService.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                            new DebugInvocationHandler(SmsService));  // 代理对象对应的自定义 InvocationHandler
smsService.send("java");

自定义InvocationHandler：

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}

（2）CGLIB动态代理

JDK 动态代理有一个最致命的问题是只能代理实现了接口的类

为了解决这个问题，我们可以使用 CGLIB 动态代理机制。CGLIBopen in new window(Code Generation Library)通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB（例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理）

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

被代理的类：

public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

具体实现：

// 创建动态代理增强类
Enhancer enhancer = new Enhancer();
// 设置类加载器
enhancer.setClassLoader(AliSmsService.class.getClassLoader());
// 设置被代理类
enhancer.setSuperclass(AliSmsService.class);
// 设置方法拦截器
enhancer.setCallback(new DebugMethodInterceptor());
// 创建代理类
AliSmsService aliSmsService = (AliSmsService) enhancer.create();
aliSmsService.send("java");

自定义MethodInterceptor：

public class DebugMethodInterceptor implements MethodInterceptor {
    /**
     * @param o           被代理的对象（需要增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }
}