设计模式课程 设计模式精讲 12-3 适配器模式源码解析

Posted 2022-10-29 1446358788-qq

1　　　　源码解析

1.1　　源码解析1（在jdk中的应用）

1.2　　源码解析2（Spring中的通知管理）

1.3　　源码解析3(SpringMVC中的应用)

 

 

1　　　　源码解析

1.1　　源码解析1（在jdk中的应用）

xmlAdapter（此类是用于适配xml的一个类，是处理xml序列化和反序列化的一个类）

public abstract class XmlAdapter<ValueType,BoundType> 

    /**
     * Do-nothing constructor for the derived classes.
     */
    protected XmlAdapter() 

    /**
     *  处理反序列化*/
    public abstract BoundType unmarshal(ValueType v) throws Exception;

    /**
      * 处理序列化*/
    public abstract ValueType marshal(BoundType v) throws Exception;

 

对于xml序列化的时候，我们时间可以写一个date类，可以继承xmlAdapter抽象类，实现它的序列化和反序列化方法。

 

1.2　　源码解析2（Spring中的通知管理）

功能描述：

通知适配器将通知类适配成各种类型的通知，如：前置通知，后置通知等等（关于通知的课程可以详细查看我的spring笔记）

 

通知适配器接口：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.aop.framework.adapter;

import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.Advisor;

public interface AdvisorAdapter 
    boolean supportsAdvice(Advice var1);

    MethodInterceptor getInterceptor(Advisor var1);

 

前置通知适配器实现类：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.aop.framework.adapter;

import java.io.Serializable;
import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.Advisor;
import org.springframework.aop.MethodBeforeAdvice;

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);
    

 

advisor组合得到通知类：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.aop;

import org.aopalliance.aop.Advice;

public interface Advisor 
    Advice getAdvice();

    boolean isPerInstance();

 

MethodBeforeAdvice继承超类(隔了好几层继承实现)：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.aopalliance.intercept;

import org.aopalliance.aop.Advice;

public interface Interceptor extends Advice 

 

1.3　　源码解析3(SpringMVC中的应用)

重点关注：

springmvc中，通过处理映射器（handlerMapper）找到对应的handler（controler，servlet或者httpRequestHandler）

现在是多个适配器，对应多个

 

适配器接口：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface HandlerAdapter 
    boolean supports(Object var1);

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

    long getLastModified(HttpServletRequest var1, Object var2);

 

适配器类：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet.mvc;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.ModelAndView;

public class SimpleControllerHandlerAdapter implements HandlerAdapter 
    public SimpleControllerHandlerAdapter() 
    

　　/**  如果对应的handler有确切的Controller并支持的话，返回true，否则，返回false
　　　*/
    public boolean supports(Object handler) 
        return handler instanceof Controller;
    

    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
        return ((Controller)handler).handleRequest(request, response);
    

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

 

DispatcherServlet(通过handlermapper找到对应的handler，适配器中的client)

 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception 
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try 
            try 
                ModelAndView mv = null;
                Exception dispatchException = null;

                try 
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null || mappedHandler.getHandler() == null) 
                        this.noHandlerFound(processedRequest, response);
                        return;
                    

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) 
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if (this.logger.isDebugEnabled()) 
                            this.logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                        

                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) 
                            return;
                        
                    

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) 
                        return;
                    

                    try 
　　　　　　　　　　　　//通过适配器handle方法，返回对应的model&View对象
                        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                     finally 
                        if (asyncManager.isConcurrentHandlingStarted()) 
                            return;
                        

                    

                    this.applyDefaultViewName(request, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                 catch (Exception var27) 
                    dispatchException = var27;
                

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
             catch (Exception var28) 
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var28);
             catch (Error var29) 
                this.triggerAfterCompletionWithError(processedRequest, response, mappedHandler, var29);
            

         finally 
            if (asyncManager.isConcurrentHandlingStarted()) 
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                return;
             else 
                if (multipartRequestParsed) 
                    this.cleanupMultipart(processedRequest);
                

            
        
    

 

controller接口：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet.mvc;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;

public interface Controller 
    ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;