SpringMVC和SpringBoot整理_spingboot spingmvc

一、什么是SpringMVC？及其特点？

        Spring MVC（全称 Spring Web MVC）是 Spring 框架提供的一款基于 MVC 模式的轻量级 Web 开发框架，是 Spring 为表示层（UI）开发提供的一整套完备的解决方案。

        Spring MVC 框架内部采用松耦合、可插拔的组件结构，具有高度可配置性，比起其他的 MVC 框架更具有扩展性和灵活性。此外，Spring MVC 的注解驱动（annotation-driven）和对 REST 风格的支持，也是它最具有特色的功能。

        Spring MVC 使用 MVC 架构模式的思想，将 Web 应用进行职责解构，把一个复杂的 Web 应用划分成模型（Model）、控制器（Contorller）以及视图（View）三层，有效地简化了 Web 应用的开发，降低了出错风险，同时也方便了开发人员之间的分工配合。

        特点：

        Spring MVC 是 Spring 家族原生产品，可以与 IoC 容器等 Spring 基础设施无缝对接；

        Spring MVC 支持各种视图技术，例如 JSP、Thymeleaf、 JSP 和 FreeMaker 等。

        Spring MVC 基于原生的 Servlet 实现，通过功能强大的前端控制器 DispatcherServlet，对请求和响应进行统一处理；

        Spring MVC 对表示层各细分领域需要解决的问题全方位覆盖，并提供一整套全面的解决方案；

        代码清新简洁，大幅度提升开发效率；

        内部组件化程度高，可插拔式组件即插即用，想要使用什么功能，配置相应组件即可；

        性能卓著，尤其适合现代大型、超大型互联网项目的开发。

二、SpringMVC创建项目的步骤是什么？

        1、导入jar依赖包：spring-aop-5.3.25.jar、spring-beans-5.3.25.jar、spring-context-5.3.25.jar、spring-core-5.3.25.jar、spring-expression-5.3.25.jar、spring-web-5.3.23.jar、spring-webmvc-5.3.23.jar

        2、配置web.xml文件

<web-app>
  <display-name>Archetype Created Web Application</display-name>
 
<!--  用来在程序启动时初始化上下文环境：容器实例 ：-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
 
<!--  上下文参数：可以被所有的servlet共享-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
 
 
<!--  前端控制器-->
  <servlet>
    <servlet-name>app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>app</servlet-name>
<!--    匹配根目录下的所有内容，不包含jsp-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
 
</web-app>

        3、配置springmvc配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--springmvc配置-->
    <!--扫描指定的包，识别其中的注解，只扫描控制器-->
    <context:component-scan base-package="com.mrlang.controller"/>
    <!--识别mvc中的注解-->
    <mvc:annotation-driven/>
    <!--资源视图解析器-->
    <!--mvc只需要返回视图的名称：index-->
    <!--自动解析如下： prefix +视图名称 +suffix-->
    <!--/WEB-INF/view/index/.jsp-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀-->
        <property name="suffix"  value=".jsp"/>
    </bean>
</beans>

         4、创建Controller测试

package com.wu.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import java.util.Date;
 
@Controller
@RequestMapping("/hello")
public class HelloController {
//    请求的路径和 方法进行映射
    @RequestMapping("/add")
    public ModelAndView add(){
        /*
        * ModelAndView:模型和视图
        * 视图：view : 视图的名称，目标视图（页面）的名称
        * model: 本质上是一个map集合，key-value集合 ：需要在视图上回显的数据；类似于request.setAttribute(key,value)
        * */
        System.out.println("执行添加操作");
        ModelAndView modelAndView=new ModelAndView("hello");
        modelAndView.addObject("key",new Date());
//        modelAndView.addObject("key",new Date());
//        modelAndView.addObject("key",new Date());
//        modelAndView.addObject("key",new Date());
//        modelAndView.addObject("key",new Date());
        return modelAndView;
 
    }
}

        5、测试

三、SpringMVC中接受参数的方式有几种？

        1、以形参的形式进行接收参数

@Autowired
    private TextService textService;
    @RequestMapping(value = "/text1")
    public String getText(HttpServletRequest request, HttpServletResponse response) {
        String name = request.getParameter("name");
        String password = request.getParameter("password");
        HttpSession session = request.getSession();
        session.setAttribute("name", name);
        if (name.equals("admin")  && password.equals("admin")) {
            request.setAttribute("name", name);
            return "text";
        }else{
            request.setAttribute("err", "查无此人");
            return "err";
        }
    }

2、以实体的形式进行接收参数

@RequestMapping("/add")
    public String add(Emp emp){
        System.out.println(emp.getEname());
        System.out.println(emp.getSal());
        System.out.println(emp.getHiredate());
//        默认服务器转发:forward:/路径
//         redirect:/路径 :重定向
        return "redirect:/emp/query";
    }

3、以@RequestParam注解接收参数

 @RequestMapping("/add1")
    public String add(@RequestParam(value = "ename",required = true,defaultValue = "小明") String ename,){
        System.out.println(ename);
        return "redirect:/emp/query";
    }

4、使用原生的servlet api : request获取

 @RequestMapping("/add2")
    public String add2(HttpServletRequest request, HttpServletResponse response, HttpSession session){
 
//        String ename = request.getParameter("ename");
//
//        response.sendRedirect("路径");
 
//        System.out.println(emp.getEname());
//        System.out.println(emp.getSal());
//        System.out.println(emp.getHiredate());
//        默认服务器转发:forward:/路径
//         redirect:/路径 :重定向
        return "redirect:/emp/query";
    }

 四、SpringMVC的回显数据有哪些？

        使用 Servlet API 向 request 域对象中共享数据

@RequestMapping(value = "/query3")
    public String query3(HttpServletRequest request) {
        request.setAttribute("key1", "value1");
        request.setAttribute("key2", "value2");
        request.setAttribute("key3", "value3");
        request.setAttribute("key4", "value4");
        return "order";
    }

        使用 ModelAndView 向 request 域对象中共享数据

@RequestMapping(value = "/query2")
    public ModelAndView query2() {
        ModelAndView modelAndView = new ModelAndView("order");
        modelAndView.addObject("key1", "value1");
        modelAndView.addObject("key2", "value2");
        modelAndView.addObject("key3", "value3");
        modelAndView.addObject("key4", "value4");
        return modelAndView;
    }

        使用 Model 向 request 域对象中共享数据

 @RequestMapping(value = "/query1")
    public String query1(Model model) {
        model.addAttribute("key1", "value1");
        model.addAttribute("key2", "value2");
        model.addAttribute("key3", "value3");
        model.addAttribute("key4", "value4");
        return "order";
    }

        使用 Map 向 request 域对象中共享数据

@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) {
    map.put("testScope", "hello,Map");
    return "success";
}

        使用 ModelMap 向 request 域对象中共享数据

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap) {
    modelMap.addAttribute("testScope", "hello,ModelMap");
    return "success";
}

        使用 Servlet API 向 session 域中共享数据

@RequestMapping("/testSession")
public String testSession(HttpSession session) {
    session.setAttribute("testSessionScope", "hello,session");
    return "success";
}

        使用 Servlet API 向 application 域中共享数据

@RequestMapping("/testApplication")
public String testApplication(HttpSession session) {
    ServletContext application = session.getServletContext();
    application.setAttribute("testApplicationScope", "hello,application");
    return "success";
}

 五、SpringMVC执行流程是什么？

1. 用户通过浏览器发起一个 HTTP 请求，该请求会被 DispatcherServlet（前端控制器）拦截；

2. DispatcherServlet 调用 HandlerMapping（处理器映射器）找到具体的处理器（Handler）及拦截器，最后以 HandlerExecutionChain 执行链的形式返回给 DispatcherServlet。

3. DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）；

4. HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（即 Controller 控制器）对请求进行处理；

5. Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC 的底层对象，包括 Model 数据模型和 View 视图信息）；

6. HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet ；

7. DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析；

8. ViewResolver 解析完成后，会将 View 视图并返回给 DispatcherServlet；

9. DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）；

10. 视图负责将结果显示到浏览器（客户端）。

六、SpringBoot是什么？其特征是什么？

        Spring Boot 具有 Spring 一切优秀特性，Spring 能做的事，Spring Boot 都可以做，而且使用更加简单，功能更加丰富，性能更加稳定而健壮。随着近些年来微服务技术的流行，Spring Boot 也成为了时下炙手可热的技术 。

特征：

        1. 独立运行的 Spring 项目

        2. 内嵌 Servlet 容器

        3. 提供 starter 简化 Maven 配置

        4. 提供了大量的自动配置

        5. 自带应用监控

        6. 无代码生成和 xml 配置

七、yaml简介及其语法规则是什么？

        YAML（/ˈjæməl/，尾音类似camel骆驼）是一个可读性高，用来表达数据序列化的格式。

        YAML 全称 YAML Ain't Markup Language，它是一种以数据为中心的标记语言，比 XML 和 JSON 更适合作为配置文件。

语法规则：

• 大小写敏感

• 使用缩进表示层级关系

• 缩进不允许使用tab，只允许空格

• 缩进的空格数不重要，只要相同层级的元素左对齐即可

• '#'表示注释

例如：

YAML 字面量写法：  使用“key:[空格]value”的形式表示一对键值对 name: xiaoming

YAML 对象写法：在 YAML 中，对象可能包含多个属性，每一个属性都是一对键值对。

user:
  name: zhangsan
  age: 18

或

user: {name: xiaoming,age: 18}

YAML 数组写法:  YAML 使用“-”表示数组中的元素

pets:
  -dog
  -cat
  -pig
或
pets: [dog,cat,pig]

八、ConfigurationProperties和Value的区别是什么？

 九、SpringBoot自动配置的原理是什么？

        SpringBoot的自动配置机制可以让我们无需手动进行繁琐的配置，只需要简单地引入相应的依赖库，SpringBoot就能够根据我们的依赖来自动配置对应的组件，大大减少了开发过程中的工作量，提高了开发效率。

        Spring Boot的自动配置是通过条件化配置（Conditional Configuration）实现的。它使用了Spring 4.0引入的条件注解（@ConditionalOnXxx）来根据当前环境，自动配置和初始化Spring应用程序需要的各种Bean（组件）。条件化配置的实现原理可以简单概括为两个步骤：

        1.收集应用程序配置环境中的信息

        Spring Boot会根据应用程序所引入的Starter、自身配置文件和其他组件，来收集应用程序当前运行的环境中有哪些条件可以使用。每个条件都有一个对应的条件判断类（Condition），用于判断当前环境是否满足条件。Spring Boot再使用条件注解（@ConditionalOnXxx）将这些条件判断类与自动配置类（Auto-Configuration）关联。

        2.根据条件判断类自动配置应用程序组件

        在Spring Boot应用程序启动时，它会扫描classpath下所有的自动配置类，并将它们加载到Spring的ApplicationContext中。这些自动配置类的作用是根据环境条件判断类（Condition），条件性地定义各种组件（Bean），并将它们注册到Spring容器中，以便应用程序可以使用这些组件。如果在应用程序的配置环境中没有找到与某个条件匹配的条件判断类，则该自动配置类不会生效。

        最终，Spring Boot会将所有可用的自动配置类的Bean注册到Spring的ApplicationContext中，完成应用程序的自动配置和初始化。自动配置类的优先级可以通过设置@ConfigurationProperties的prefix属性来改变。如果不需要某个自动配置类的功能，可以通过在应用程序的配置文件中设置相应的属性来禁用它。

SpringBoot的核心注解：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}

@SpringBootConfiguration：本质上就是@Configuration，将一个类配置成容器类，类似于xml的的bean文件

@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

EnableAutoConfiguration:启用自动配置

//自动导入包
@AutoConfigurationPackage 
//@Import：将 指定的class 导入spring容器中，配置成bean
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
 
    Class<?>[] exclude() default {};
 
    String[] excludeName() default {};
}

十、Thymeleaf是什么？有什么特点？

        Thymeleaf 是新一代 Java 模板引擎，与 Velocity、FreeMarker 等传统 Java 模板引擎不同，Thymeleaf 支持 HTML 原型，其文件后缀为“.html”，因此它可以直接被浏览器打开，此时浏览器会忽略未定义的 Thymeleaf 标签属性，展示 thymeleaf 模板的静态页面效果；当通过 Web 应用程序访问时，Thymeleaf 会动态地替换掉静态内容，使页面动态显示。

特点：

• 动静结合：Thymeleaf 既可以直接使用浏览器打开，查看页面的静态效果，也可以通过 Web 应用程序进行访问，查看动态页面效果。

• 开箱即用：Thymeleaf 提供了 Spring 标准方言以及一个与 SpringMVC 完美集成的可选模块，可以快速的实现表单绑定、属性编辑器、国际化等功能。

• 多方言支持：它提供了 Thymeleaf 标准和 Spring 标准两种方言，可以直接套用模板实现 JSTL、 OGNL 表达式；必要时，开发人员也可以扩展和创建自定义的方言。

• 与 SpringBoot 完美整合：SpringBoot 为 Thymeleaf 提供了的默认配置，并且还为 Thymeleaf 设置了视图解析器，因此 Thymeleaf 可以与 Spring Boot 完美整合。