【小家Spring】Spring MVC控制器中Handler的四种实现方式：Controller、HttpRequestHandler、Servlet、@RequestMapping

// @since 第一版Spring MVC就有了  所以这个接口是非常古老的接口~~~也是Spring MVC最早期的实现方式
@FunctionalInterface
public interface Controller {
	@Nullable
	ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

@org.springframework.stereotype.Controller("/democontroller") // 注意此处需要以/开头，表示使用BeanNameURLHandlerMapping的方式处理
public class DemoController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("this my demo controller~");
        return new ModelAndView("index");
    }
}

this my demo controller~

@org.springframework.stereotype.Controller("/democontroller") // 注意此处需要以/开头，表示使用BeanNameURLHandlerMapping的方式处理
public class DemoController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("this my demo controller~");
        response.getWriter().write("this my demo controller from body");
        return null; // 返回null告诉视图渲染  直接把body里面的内容输出浏览器即可
    }
}

this my demo controller~

// 关于WebContentGenerator  这里暂时略过
// AbstractController继承了org.springframework.web.servlet.support.WebContentGenerator抽象类。提供了针对http请求的设定
public abstract class AbstractController extends WebContentGenerator implements Controller {
	...
	@Override
	@Nullable
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		
		// 如果请求是OPTIONS请求  那就直接return null了  它一般用于跨域  所以设置上Allow这个请求头
		//getAllowHeader()方法在WebContentGenerator里
		if (HttpMethod.OPTIONS.matches(request.getMethod())) {
			response.setHeader("Allow", getAllowHeader());
			return null;
		}

		// 指定supportedMethods后，看看这个request是否合法
		checkRequest(request);
		// 处理response的cache缓存和缓存时间等等
		prepareResponse(response);

		// Execute handleRequestInternal in synchronized block if required.
		// 如果有需要，会给这个请求上锁~~~~在锁内执行
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					return handleRequestInternal(request, response);
				}
			}
		}
	
		return handleRequestInternal(request, response);
	}	
	
	// 子类实现这个抽象方法即可~~~~~
	@Nullable
	protected abstract ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
			throws Exception;
}

// @since 1.1.1  实现了接口InitializingBean
public class ServletWrappingController extends AbstractController
		implements BeanNameAware, InitializingBean, DisposableBean {
	...
	@Override
	public void afterPropertiesSet() throws Exception {
		// 必须制定它关联的是哪个Servlet
		if (this.servletClass == null) {
			throw new IllegalArgumentException("'servletClass' is required");
		}
		// 如果没有指定servlet的名字，就用beanName作为名字~
		if (this.servletName == null) {
			this.servletName = this.beanName;
		}
		// 对servlet进行init方法  初始化
		this.servletInstance = ReflectionUtils.accessibleConstructor(this.servletClass).newInstance();
		this.servletInstance.init(new DelegatingServletConfig());
	}

	// 最终请求是交给了这个servlet去真正处理的~~~~~
	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		Assert.state(this.servletInstance != null, "No Servlet instance");
		this.servletInstance.service(request, response);
		return null;
	}
		
}

rd.include(request, response);
rd.forward(request, response);

public class ParameterizableViewController extends AbstractController {
	// 由此课件，默认只支持get和Head方法
	public ParameterizableViewController() {
		super(false);
		setSupportedMethods(HttpMethod.GET.name(), HttpMethod.HEAD.name());
	}
	...
	// 支持redirect:这样的前缀
	@Nullable
	public String getViewName() {
		if (this.view instanceof String) {
			String viewName = (String) this.view;
			if (getStatusCode() != null && getStatusCode().is3xxRedirection()) {
				return viewName.startsWith("redirect:") ? viewName : "redirect:" + viewName;
			} else {
				return viewName;
			}
		}
		return null;
	}
	...
}

<bean name="/index.action" class="org.springframework.web.servlet.mvc.ParameterizableViewController">
     <property name="viewName" value="/index.jsp"/>
</bean>

<bean id="viewMappings" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" >
	<!-- 默认处理器 -->
	<property name="defaultHandler">  
            <bean name="index" class="org.springframework.web.servlet.mvc.UrlFilenameViewController" />  
     </property>   
</bean>

    @Bean("/*") //"/*"会把它注册为一个默认的handler~
    public UrlFilenameViewController urlFilenameViewController() {
        UrlFilenameViewController controller = new UrlFilenameViewController();
        controller.setPrefix("/api/v1/");
        controller.setSuffix(".do");
        return controller;
    }

// @since 2.0  它是Spring2.0后才出来的
// 用于处理HTTP请求的组件的纯处理程序接口，类似于`servlet`
@FunctionalInterface
public interface HttpRequestHandler {
	// Process the given request, generating a response
	// 处理这个request 生成一个response
	void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

<mvc:default-servlet-handler />

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    // 注册 一个默认的servlet处理器  让它处理静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        DefaultServletHandlerConfigurer handlerConfigurer = new DefaultServletHandlerConfigurer(servletContext);
        // 这个Configurer只有一个enable方法，内部会 new DefaultServletHttpRequestHandler();
        handlerConfigurer.enable("default"); //默认值的servlet名字就是default
        super.configureDefaultServletHandling(configurer);
    }
}

	protected SimpleUrlHandlerMapping buildHandlerMapping() {
		if (this.handler == null) {
			return null;
		}
		
		SimpleUrlHandlerMapping handlerMapping = new SimpleUrlHandlerMapping();
		handlerMapping.setUrlMap(Collections.singletonMap("/**", this.handler));
		handlerMapping.setOrder(Integer.MAX_VALUE);
		return handlerMapping;
	}

// @since 3.0.4  可见它是一个HttpRequestHandler
public class DefaultServletHttpRequestHandler implements HttpRequestHandler, ServletContextAware {
}

<!-- 一次性可以写多个路径，里面都可议放置静态资源文件~   location表示资源文件的位置  mapping：表示请求URL-->
<mvc:resources location="/,classpath:/META-INF/publicResources/" mapping="/resources/**"/>

// 当然我们也可以写成多个,类似这样子
<mvc:resources location="/img/" mapping="/img/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>
<mvc:resources location="/css/" mapping="/css/**"/>

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resource/**").addResourceLocations("/WEB-INF/static/"); // 支持Ant风格的路径匹配
    }
}

	Map<String, HttpRequestHandler> urlMap = new LinkedHashMap<>();


// 这个HttpRequestHandler是这么生成的
// 使用的ResourceHttpRequestHandler  因为我们无法指定locationValues  所以这里是[] 空集合
// 个人感觉这是Spring的一个问题，后面有时间回去社区里反馈此问题~~~（我使用的Spring版本为5.1.x）
	protected ResourceHttpRequestHandler getRequestHandler() {
		ResourceHttpRequestHandler handler = new ResourceHttpRequestHandler();
		// 给设置好ResourceResolvers
		if (this.resourceChainRegistration != null) {
			handler.setResourceResolvers(this.resourceChainRegistration.getResourceResolvers());
			handler.setResourceTransformers(this.resourceChainRegistration.getResourceTransformers());
		}
		
		// location们  可以发现每个mapping相当于对应着所有的location的
		handler.setLocationValues(this.locationValues);
		// 设置浏览器cache相关内容 
		if (this.cacheControl != null) {
			handler.setCacheControl(this.cacheControl);
		}
		else if (this.cachePeriod != null) {
			handler.setCacheSeconds(this.cachePeriod);
		}
		return handler;
	}

// @since 3.0.4 可以看到它实现的接口很多  是非常多的强大的一个资源处理器
// EmbeddedValueResolverAware:它能处理占位符~~~~
// 它的afterPropertiesSet()方法里做了非常多的事~~~~
public class ResourceHttpRequestHandler extends WebContentGenerator
		implements HttpRequestHandler, EmbeddedValueResolverAware, InitializingBean, CorsConfigurationSource {
		...
}

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    // 服务端：把HelloService暴露出去  服务端对接口必须有具体的实现~
    @Bean("/helloService") // 注意这里的BeanName请使用/路径的形式  （推荐使用这种方式，简单明了~~~）
    public HttpInvokerServiceExporter helloServiceExporter(HelloService helloService) {
        HttpInvokerServiceExporter exporter = new HttpInvokerServiceExporter();
        exporter.setService(helloService); // 真正的实现类  这个对服务端来说是必须的
        exporter.setServiceInterface(HelloService.class); // 必须设置一个接口~~~~
        return exporter;
    }
}

    //@Autowired
    //private ServletContext servletContext;
    // 需要注意的是：在Spring的config里面，是不允许通过servletContext再向web容器内添加servlet的~~~~
    
    // 注册一个HttpRequestHandlerServlet 来专门处理client端的请求
    // 要求：此servletName必须是上面对应的Bean的BeanName~~~~
    //servletContext.addServlet("helloServiceExporter", new HttpRequestHandlerServlet()).addMapping("/helloService");

// 这里在SPI里完成Servlet的注册~~~
public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected void registerDispatcherServlet(ServletContext servletContext) {
        super.registerDispatcherServlet(servletContext);

        // 注册我们自己的Servlet 因为这个servlet在jar包里面  所以这里只能通过编程的方式注册~~~~
        // 请保证这个servlet的名字和BeanName相同~~  helloServiceExporter：为Bean的名字~~~
        servletContext.addServlet("helloServiceExporter", new HttpRequestHandlerServlet()).addMapping("/helloService");
        servletContext.addServlet("helloServiceExporter", new HttpRequestHandlerServlet()).addMapping("/helloService");
    }
}

@Configuration
public class RootConfig {

    @Bean("helloServiceFactoryBean")
    public HttpInvokerProxyFactoryBean helloServiceFactoryBean() {
        HttpInvokerProxyFactoryBean factoryBean = new HttpInvokerProxyFactoryBean();
        factoryBean.setServiceInterface(HelloService.class);
        factoryBean.setServiceUrl("http://localhost:8080/demo_war_war/helloService");
        return factoryBean;
    }

}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RootConfig.class, AsyncConfig.class})
public class TestSpringBean {

    @Autowired
    private HelloService helloService;

    @Test
    public void test1() {
        System.out.println(helloService); // HTTP invoker proxy for service URL [http://localhost:8080/demo_war_war/helloService]
        System.out.println(helloService.getClass()); //class com.sun.proxy.$Proxy30
        System.out.println(helloService.hello()); //service hello
        System.out.println("结束~");
    }

}

@HandlesTypes(value={XXX.class})
public class MyServletContainerInitializer implements ServletContainerInitializer {
	@Override
	public void onStartup(Set<Class<?>> arg0, ServletContext sc) throws ServletException {
		// 在这里里面完成所有的注册工作~~~~
	}
}

@Controller("/demoHttpRequestHandler")
public class DemoHttpRequestHandler implements HttpRequestHandler {

    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("this my DemoHttpRequestHandler");
        response.getWriter().write("this my DemoHttpRequestHandler");
    }
}

@WebServlet("/myServlet")
public class MyServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.service(req, resp);
    }
}

@Controller("/servletController")
public class ServletController extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("this my servlet controller");
    }
}

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
	// 让支持Servlet这种Handler的方式~~你 SpringMVC默认是不予支持的
    @Bean
    public SimpleServletHandlerAdapter simpleServletHandlerAdapter() {
        return new SimpleServletHandlerAdapter();
    }	
}

<mvc:default-servlet-handler/>
...
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/html/**" location="/html/"/>

// 备注两种只需要配其一，其中<mvc:resources />是被推荐的方式

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
        //configurer.enable("default");
    }
}

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resource/**").addResourceLocations("/WEB-INF/static/");
        // 备注这里addResourceLocations(“file:D:/”)这样都是支持的~~~~~
    }
}