SpringMVC零配置及内嵌tomcat实现Spring boot

本文链接：https://blog.csdn.net/qq_45065241/article/details/117847050

Spring MVC零配置及内嵌tomcat实现Spring boot功能

前言：

我们在使用Spring MVC的时候通常会配置一堆.XML的配置文件，这会对项目的维护造成很大的不便。但是随着Spring的发展，Spring Boot的出现极大的简化了Spring MVC的配置，这使得Spring MVC逐渐淡出大家的视野。但是在Spring官网中，已经提供了Spring MVC的零配置的方式，因为网上教大家的Spring MVC大多数都是要配置.XML文件的，下面我们实现整合SpringMVC和内置Tomcat实现SpringBoot的功能t。

Spring Boot 与Spring MVC的区别是什么？

spring boot只是一个配置工具,整合工具,辅助工具。

springmvc是框架,项目中实际运行的代码。

Spring 框架就像一个家族，有众多衍生产品例如 boot、security、jpa等等。但他们的基础都是Spring 的ioc和 aop. ioc 提供了依赖注入的容器， aop解决了面向横切面的编程，然后在此两者的基础上实现了其他延伸产品的高级功能。

Spring MVC是基于Servlet 的一个 MVC 框架主要解决 WEB 开发的问题，因为 Spring 的配置非常复杂，各种XML、 JavaConfig、hin处理起来比较繁琐。于是为了简化开发者的使用，从而创造性地推出了Spring boot，约定优于配置，简化了spring的配置流程。说得更简便一些：Spring 最初利用“工厂模式”（DI）和“代理模式”（AOP）解耦应用组件。大家觉得挺好用，于是按照这种模式搞了一个 MVC框架（一些用Spring 解耦的组件），用开发 web 应用（ SpringMVC ）。然后发现每次开发都写很多样板代码，为了简化工作流程，于是开发出了一些“懒人整合包”（starter），这套就是 Spring Boot。

Spring MVC概述：

Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。另外还有一种基于组件的、事件驱动的Web框架在此就不介绍了，如Tapestry、JSF等。

Spring Web MVC也是服务到工作者模式的实现，但进行可优化。前端控制器是DispatcherServlet；应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest(request, response) 方法）的实现（也可以是任何的POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

在Spring的Web MVC框架提供了模型 - 视图 - 控制器架构以及可用于开发灵活，松散耦合的Web应用程序准备的组件。 MVC模式会导致分离的应用程序（输入逻辑，业务逻辑和UI逻辑）的不同方面，同时提供这些元素之间的松耦合。

模型（Model ）封装了应用程序的数据和一般他们会组成的POJO。
视图（View）是负责呈现模型数据和一般它生成的HTML输出，客户端的浏览器能够解释。
控制器（Controller ）负责处理用户的请求，并建立适当的模型，并把它传递给视图渲染。

Spring MVC注册并初始化DispatcherServlet官网实例

与许多其他web框架一样，Spring MVC是围绕前端控制器模式设计的，其中中央Servlet (DispatcherServlet)为请求处理提供了共享算法，而实际工作是由可配置的委托组件执行的。该模型灵活，支持多种工作流。DispatcherServlet和任何Servlet一样，需要使用Java配置或在web.xml中根据Servlet规范声明和映射。反过来，DispatcherServlet使用Spring配置来发现请求映射、视图解析、异常处理等所需的委托组件。

下面的Java代码示例：注册并初始化DispatcherServlet，它会被Servlet容器自动检测

public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) {

        //加载Spring web应用程序配置
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);

        // 创建并注册DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/app/*");
    }
}

注意：上面的Java代码可以代替下面的 .xml配置文件的。

下面是web.xml配置注册和初始化DispatcherServlet的示例:

<web-app>
   //启动Spring容器
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
   //配置Spring.xml的文件地址
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>
    //注册DispatcherServlet
    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

</web-app>

总结：在我们日常开发中其实大多数还是用web.xml的方式去初始化项目。其实在Spring官网中，已经告诉我们可以用Java代码开初始化项目。其次还可以用web.xml的方式去替代。

Tomcat与Spring IOC

我们知道Tomcat与Spring分别属于两个独立的应用程序。想要整合Tomcat与Spring必须引入第三方使得两者之间产生联系，这个第三方就是Servlet规范。而Servlet规范就是在J2EE中13个规范中的一种。它为Tomcat和Spring提供了一套规范，二者必须遵守。

J2se（Java 2 standard edition），是Java2的标准版，主要用于开发桌面的应用程序。J2se包含了构成Java语言核心的类：数据库连接、接口定义、输入输出、网络编辑等；
J2se是最基础的运行Java程序的工具包，包含了基本的Java类库，开发程序时不用使用http这些对象。

零配置及内嵌tomcat代码实现

1.使用传统springMVC“必要”的配置：

在创建传统的SpringMVC项目时，我们需要建立：

1.web.xml配置文件用来配置前端控制器DispatcherServlet

2.配置applicationContext.xml，用来扫描业务类

<context:component-scanbase-package="com.service" />

3.配置spring-mvc.xml，用来扫描控制器类

<context:component-scan base-package="com.controller" />

总结：一个传统的spring-mvc(不考虑db与其他中间件等)必要配置为初始化spring环境、前端控制器配置、扫描业务类配置、扫描控制器类配置，一共4个必要的配置，那么如果我们能通过注解or代码来替代上面4个必要的配置的话，就可以做到零配。

不了解SpringMVC的小伙伴可以参考：链接：https://www.cnblogs.com/ysocean/p/7376596.html#_label5

2.整合SpringMVC和内置Tomcat实现SpringBoot的功能

DispatcherServlet是Spring MVC的核心，每当应用接受一个HTTP请求，由DispatcherServlet负责将请求分发给应用的其他组件。在旧版本中，DispatcherServlet之类的servlet一般在web.xml文件中配置，该文件一般会打包进最后的war包种；但是Spring 3引入了注解，我们这节课讲解，如何基于注解配置Spring MVC。

步骤：

1.新建Maven项目，设置为war工程

2.添加Maven依赖

  <dependencies>
        <!--Java语言操作tomcat -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>8.5.16</version>
        </dependency>
        <!--spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.4.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!--spring-mvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.0.4.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!-- tomcat对jsp支持 -->
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jasper</artifactId>
            <version>8.5.16</version>
        </dependency>
    </dependencies>

3.加载SpringMVCDispatcherServlet

package com.tguo.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 * @author tguo
 * 重写web容器配置
 * 加载SpringMVCDispatcherServlet
 */
public class SpittrWebAppInitializer  extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        // TODO Auto-generated method stub
        return new Class[] { RootConfig.class };
    }
    @Override
    protected Class<?>[] getServletConfigClasses() {
        // TODO Auto-generated method stub
        return new Class[] { WebConfig.class };
    }
    @Override
    protected String[] getServletMappings() {
        // TODO Auto-generated method stub
        return new String[] { "/" };
    }
}

4.加载SpringMVC容器

package com.tguo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

/**
 * @author tguo
 * @EnableWebMvc 开启SpringMVC功能<br>
 * @Configuration 配置<br>
 * 启动webmvc 配置及扫包范围设置
 */
@Configuration
@EnableWebMvc
@ComponentScan("com.tguo.controller")
public class WebConfig extends WebMvcConfigurerAdapter {
    // 创建SpringMVC视图解析器
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/views/");
        viewResolver.setSuffix(".jsp");
        //可以在JSP页面中通过${}访问beans
        viewResolver.setExposeContextBeansAsAttributes(true);
        return viewResolver;
    }
}

5.RootConfig容器

package com.tguo.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author tguo
 * web根容器
 */
@Configuration
@ComponentScan(basePackages = "com.tguo")
public class RootConfig {
}

6.建立运行的AppTomcat类

package com.tguo;

import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.webresources.DirResourceSet;
import org.apache.catalina.webresources.StandardRoot;

import java.io.File;

public class AppTomcat {
    // 端口号
    private static int port = 9090;


    public static void main(String[] args) {
        start();
    }

    private static void start() {
        try {
            // TODO Auto-generated method stub
            // 创建Tomcat服务器
            Tomcat tomcat = new Tomcat();
            // 设置端口号
            tomcat.setPort(port);
            tomcat.getHost().setAutoDeploy(false);

            // 创建Context上下文
            // 读取项目路径
            StandardContext ctx = (StandardContext) tomcat.addWebapp("/", new File("src/main/webapp").getAbsolutePath());
            // 禁止重新载入
            ctx.setReloadable(false);

            // class文件读取地址
            File additionWebInfClasses = new File("target/classes");
            // 创建WebRoot
            WebResourceRoot resources = new StandardRoot(ctx);
            // tomcat内部读取Class执行
            resources.addPreResources(
                    new DirResourceSet(resources, "/WEB-INF/classes", additionWebInfClasses.getAbsolutePath(), "/"));


            tomcat.start();
            System.out.println("tomcat启动成功...");


            // 服务阻塞等待
            tomcat.getServer().await();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("tomcat启动失败...");
        }
    }
}

7.项目添加逻辑层

package com.tguo.service;

import org.springframework.stereotype.Service;


@Service
public class UserService {
    public String index() {
        return "UserService 访问成功！！--RollinSpark";
    }
}

8.添加Controller层：

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping(value="/userIndex",produces = "text/html;charset=UTF-8")
    public String index() {
        return userService.index();
    }
}

9.访问