适配器设计模式nginx 适配器设计模式属于

转载

mob64ca14085c24 2024-02-19 01:44:19

文章标签 适配器设计模式nginx 适配器模式 System sed ide 文章分类 运维

定义：适配器模式又叫变压器模式。它的功能是将一个类的接口变成客户端所期待的另一个类的接口，从而使原本因接口不匹配而无法一起工作的两个类可以一起工作。属于结构型设计模式。

生活中的适配器应用：手机充电器、插电板转接、显示器转接头

适配器适用场景：

已经存在的类，它的方法和需求不匹配，但是方法的结果相同或者相似的情况。
适配器模式不是软件设计阶段考虑的设计模式，而是随着软件维护，由于不同产品、不同厂家造成功能类似但是接口不相同情况下的解决方案。

适配器的优点：

能提高类的透明性和复用性，现有的类可以复用但不用改变
目标类和适配器类解耦，提高了程序的可扩展性
在很多业务场景中符合开闭原则

适配器的缺点：

适配器编写过程中需要全面考虑，会增加系统的复杂度
增加了代码的阅读难度，降低了代码的可读性，过多使用适配器会使系统代码变得凌乱

类适配器

ClassAdapter extends ExistingClass implements Target，违背了最少知道原则

// 已有类
public class AC220 {
    public int outputAC220() {
        int output = 220;
        System.out.println("输出220V电压");
        return output;
    }
}

// 新业务需求添加的接口类
public interface DC5 {
    public int outputDC5();
}

// 适配器类：继承已有类，实现定义的新业务需求接口
public class PowerAdapter extends AC220 implements DC5 {
    @Override
    public int outputDC5() {
        int adapterInput = super.outputAC220();
        int adapterOutput = adapterInput / 44;
        System.out.println("使用Adapter输入AC" + adapterInput + "V电压，输出DC" + adapterOutput);
        return adapterOutput;
    }
}

public class Test {
    public static void main(String[] args) {
        PowerAdapter powerAdapter = new PowerAdapter();
        powerAdapter.outputDC5();
    }
}

对象适配器

ObjectAdapter implements Target, 通过构造方法传入ExistingClass并使用，遵循最少知道原则

public class AC220 {
    public int outputAC220() {
        int output = 220;
        System.out.println("输出220V电压");
        return output;
    }
}

public interface DC5 {
    public int outputDC5();
}

// 适配器类：实现定义的新业务需求接口，通过构造方法传入已有类，从而使用已有类中的方法
public class PowerAdapter implements DC5 {
    private AC220 ac220;
    public PowerAdapter(AC220 ac220) {
        this.ac220 = ac220;
    }
    @Override
    public int outputDC5() {
        int adapterInput = ac220.outputAC220();
        int adapterOutput = adapterInput / 44;
        System.out.println("使用Adapter输入AC" + adapterInput + "V电压，输出DC" + adapterOutput);
        return adapterOutput;
    }
}

public class Test {
    public static void main(String[] args) {
        PowerAdapter powerAdapter = new PowerAdapter(new AC220());
        powerAdapter.outputDC5();
    }
}

接口适配器

关注点在于解决接口方法过多的问题

public class AC220 {
    public int outputAC220() {
        int output = 220;
        System.out.println("输出220V电压");
        return output;
    }
}

public interface DC {
    public int outputDC5();
    public int outputDC12();
    public int outputDC24();
}

public class PowerAdapter implements DC {
    private AC220 ac220;
    public PowerAdapter(AC220 ac220) {
        this.ac220 = ac220;
    }
    @Override
    public int outputDC5() {
        int adapterInput = ac220.outputAC220();
        int adapterOutput = adapterInput / 44;
        System.out.println("使用Adapter输入AC" + adapterInput + "V电压，输出DC" + adapterOutput);
        return adapterOutput;
    }

    @Override
    public int outputDC12() {
        return 0;
    }

    @Override
    public int outputDC24() {
        return 0;
    }
}

public class Test {
    public static void main(String[] args) {
        PowerAdapter powerAdapter = new PowerAdapter(new AC220());
        powerAdapter.outputDC5();
        powerAdapter.outputDC12();
        powerAdapter.outputDC24();
    }
}

适配器模式在Spring中的应用

Spring中处理通知Advice的适配器

public interface AdvisorAdapter {
    boolean supportsAdvice(Advice var1);

    MethodInterceptor getInterceptor(Advisor var1);
}

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
    MethodBeforeAdviceAdapter() {}

    public boolean supportsAdvice(Advice advice) {
        return advice instanceof MethodBeforeAdvice;
    }

    public MethodInterceptor getInterceptor(Advisor advisor) {
        MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
        return new MethodBeforeAdviceInterceptor(advice);
    }
}

class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {
    AfterReturningAdviceAdapter() {}

    public boolean supportsAdvice(Advice advice) {
        return advice instanceof AfterReturningAdvice;
    }

    public MethodInterceptor getInterceptor(Advisor advisor) {
        AfterReturningAdvice advice = (AfterReturningAdvice)advisor.getAdvice();
        return new AfterReturningAdviceInterceptor(advice);
    }
}

class ThrowsAdviceAdapter implements AdvisorAdapter, Serializable {
    ThrowsAdviceAdapter() {}

    public boolean supportsAdvice(Advice advice) {
        return advice instanceof ThrowsAdvice;
    }

    public MethodInterceptor getInterceptor(Advisor advisor) {
        return new ThrowsAdviceInterceptor(advisor.getAdvice());
    }
}

public interface Advice {}

public interface BeforeAdvice extends Advice {}

public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method var1, Object[] var2, @Nullable Object var3) throws Throwable;
}

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
    private final MethodBeforeAdvice advice;

    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        return mi.proceed();
    }
}

SpringMVC中处理请求的适配器

适配器设计模式nginx 适配器设计模式属于_ide

public class DispatcherServlet extends FrameworkServlet {
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        ModelAndView mv = null;
    
        processedRequest = this.checkMultipart(request);
        // 根据request请求中的url获取handler
        mappedHandler = this.getHandler(processedRequest);
    
        // 根据handler获取适配器Adapter
        HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
    
        // 通过对应的Adapter处理请求
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
        this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
    }

    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();

            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }

        return null;
    }

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
            Iterator var2 = this.handlerAdapters.iterator();

            while(var2.hasNext()) {
                HandlerAdapter adapter = (HandlerAdapter)var2.next();
                if (adapter.supports(handler)) {
                    return adapter;
                }
            }
        }
    }

}

public interface HandlerAdapter {
    boolean supports(Object var1);

    @Nullable
    ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;

    long getLastModified(HttpServletRequest var1, Object var2);
}

public class HttpRequestHandlerAdapter implements HandlerAdapter {
    public HttpRequestHandlerAdapter() {
    }

    public boolean supports(Object handler) {
        return handler instanceof HttpRequestHandler;
    }

    @Nullable
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ((HttpRequestHandler)handler).handleRequest(request, response);
        return null;
    }

    public long getLastModified(HttpServletRequest request, Object handler) {
        return handler instanceof LastModified ? ((LastModified)handler).getLastModified(request) : -1L;
    }
}

@FunctionalInterface
public interface HttpRequestHandler {
    void handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException;
}

public class ResourceHttpRequestHandler extends WebContentGenerator implements HttpRequestHandler, EmbeddedValueResolverAware, InitializingBean, CorsConfigurationSource {
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // ...
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。