【手撕Spring源码】深度理解SpringMVC【上】

news2024/11/20 14:22:40

文章目录

  • DispatcherServlet
  • RequestMappingHandlerMapping
  • RequestMappingHandlerAdapter
    • 自定义参数处理器
    • 自定义返回值处理器
  • 参数解析器
  • 获取参数名
  • 对象绑定与类型转换
    • 底层第一套转换接口与实现
    • 底层第二套转换接口与实现
    • 高层转换接口与实现
    • 自定义转换器
  • @ControllerAdvice 之 @InitBinder
  • 附：说说MVC
    • ModelAndView
    • ModelAndViewContainer

DispatcherServlet

既然我们讨论SpringMVC那么就必然绕不开一个东西叫做DispatcherServlet。

DispatcherServlet是SpringMVC的核心Servlet，也叫做前端控制器。它的主要作用是调度请求并将请求分发给相应的处理器。

我们要注意：
DispatcherServlet由Servlet容器创建，并且它的生命周期也是Servlet那套体系由Servlet容器进行控制

DispatcherServlet 是在第一次被访问时执行初始化, 也可以通过配置修改为 Tomcat 启动后就初始化：

在这里插入图片描述

那么DispatcherServlet 在初始化的时候都做了什么呢？

DispatcherServlet 初始化的时候会调用onRefresh方法，而这个方法中又会调用initStrategies方法：
在这里插入图片描述

DispatcherServlet的initStrategies()方法用于初始化DispatcherServlet所需的各种策略(strategy)：
在这里插入图片描述

主要包括:

  1. HandlerMapping：路径映射器，用于根据请求URL找到对应的Handler(Controller的方法)
  2. HandlerAdapter：处理器配置器，用于执行Handler，将请求参数绑定到Handler入参，创建返回的ModelAndView。
  3. ViewResolver:用于根据逻辑视图名解析成真正的视图View。
  4. LocaleResolver：本地化信息解析器，用于获取客户端的地域信息,国际化用。
  5. ThemeResolver:用于提供主题信息,一般用不太多。
  6. MultipartResolver：文件上传解析器，用于上传文件用，当有文件上传需求时使用。
  7. HandlerExceptionResolvers：控制器异常解析器

默认的DispatcherServlet会对这些策略进行自动检测和设置。我们也可以自定义这些策略。

其中最常自定义的就是HandlerMapping、ViewResolver和MultipartResolver。

所以这个方法主要是初始化一些DispatchServlet执行请求所需要的策略和组件。这些组件大多来自Spring容器，所以DispatcherServlet在初始化阶段首先要创建Spring容器,然后再从容器中获取这些策略的实现。有了这些策略和组件的支持，DispatchServlet才有能力完成从接收请求到产生响应的整个流程。

RequestMappingHandlerMapping

RequestMappingHandlerMapping是一个HandlerMapping实现，它的作用是根据RequestMapping注解将请求映射到对应的Handler(Controller的方法)。
它会解析类及方法上的@RequestMapping注解，并根据注解中的信息注册Handler。当请求过来时,会根据URL查找对应的Handler进行执行。
主要功能如下:

  1. 解析@RequestMapping注解，获取URL、method等信息。

  2. 根据URL、method等条件查找对应的Handler。支持ANT风格的URL。

  3. 支持组合注解。即一个类或方法上有多个@RequestMapping注解的情况。会将这些信息组合起来一并解析。

  4. 支持派生注解。如@GetMapping、@PostMapping等也可以使用。

  5. 支持定制的HandlerMapping通过实现HandlerMapping接口。

主要的解析规则是:

  • 方法上的@RequestMapping优先级最高
  • 然后是类上的@RequestMapping
  • URL可以使用ANT风格的通配符
  • 当一个Handler同时匹配类和方法的@RequestMapping时,方法的映射规则优先

RequestMappingHandlerMapping 初始化时，会收集所有 @RequestMapping 映射信息，封装为 Map，其中

  • key 是 RequestMappingInfo 类型，包括请求路径、请求方法等信息
  • value 是 HandlerMethod 类型，包括控制器方法对象、控制器对象
  • 有了这个 Map，就可以在请求到达时，快速完成映射，找到 HandlerMethod 并与匹配的拦截器一起返回给 DispatcherServlet

接下来我们使用代码模拟一下过程：

配置类：
在这里插入图片描述

这个地方我们如果不主动注入，DispatcherServlet 初始化时默认会添加RequestMappingHandlerMapping组件，但是并不会作为 bean，而是会当作DispatcherServlet 的属性。

public class A20 {
    private static final Logger log = LoggerFactory.getLogger(A20.class);

    public static void main(String[] args) throws Exception {
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);

        // 作用 解析 @RequestMapping 以及派生注解，生成路径与控制器方法的映射关系, 在初始化时就生成
        RequestMappingHandlerMapping handlerMapping = context.getBean(RequestMappingHandlerMapping.class);

        // 获取映射结果
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = handlerMapping.getHandlerMethods();
        handlerMethods.forEach((k, v) -> {
            System.out.println(k + "=" + v);
        });

        // 请求来了，获取控制器方法  返回处理器执行链对象
        MockHttpServletRequest request = new MockHttpServletRequest("GET", "/test4");
        HandlerExecutionChain chain = handlerMapping.getHandler(request);
        System.out.println(chain);
    }
}

结果：
在这里插入图片描述

注意：

  • 路径与控制器方法的映射关系, 在初始化时就生成了
  • HandlerExecutionChain是一个HandlerMethod执行链，它包含一个HandlerMethod和多个HandlerInterceptor。当一个请求匹配到一个HandlerMethod时，会创建一个HandlerExecutionChain，然后顺序执行链中的所有拦截器和最后一个HandlerMethod。
    • 它的主要属性有:
      • HandlerMethod：要执行的HandlerMethod
      • HandlerInterceptorList：要执行的拦截器列表

RequestMappingHandlerAdapter

RequestMappingHandlerAdapter是一个HandlerAdapter实现,它支持处理基于注解的Controller,即使用@RequestMapping映射请求的Controller。

它主要功能是:

  1. 绑定请求参数到Controller方法的参数上。支持@RequestParam、@RequestBody等注解。
  2. 执行HandlerMethod，为方法提供一个绑定了请求参数的可执行的方法参数数组。
  3. 处理返回值并设置到ModelAndViewContainer中,包括:
    • 返回String则当成逻辑视图名,交给视图解析器解析。
    • 返回void则当作逻辑视图名为空。
    • 返回ModelAndView对象则直接使用。
    • 返回其他对象则当作模型数据添加到Model中。

RequestMappingHandlerAdapter 初始化时，会准备 HandlerMethod 调用时需要的各个组件(这两个组件都是RequestMappingHandlerAdapter的属性)，如：

  • HandlerMethodArgumentResolver 解析控制器方法参数
  • HandlerMethodReturnValueHandler 处理控制器方法返回值

我们使用代码模拟一下：

在这里插入图片描述

这里我们使用的MyRequestMappingHandlerAdapter是因为invokeHandlerMethod方法是Protected的，我们继承一下才能用：
在这里插入图片描述

自定义参数处理器

例如我们经常需要用到请求头中的 token 信息, 用下面注解来标注由哪个参数来获取它：

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Token {
}

Controller：

    @PutMapping("/test3")
    public ModelAndView test3(@Token String token) {
        log.debug("test3({})", token);
        return null;
    }

然后我们自定义一个参数处理器：

public class TokenArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    // 是否支持某个参数
    public boolean supportsParameter(MethodParameter parameter) {
        Token token = parameter.getParameterAnnotation(Token.class);
        return token != null;
    }

    @Override
    // 解析参数
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        return webRequest.getHeader("token");
    }
}

注意：

HandlerMethodArgumentResolver接口中定义了两个方法:

  • supportsParameter()：该方法用于判断当前的参数解析器是否支持解析该方法参数。如果返回true,则会调用resolveArgument()进行实际解析。
  • resolveArgument()：该方法会根据请求信息(webRequest)解析请求参数,并将解析后的参数绑定到方法入参上。
  • 这两个方法需要结合使用,DispatcherServlet会先调用supportsParameter判断当前解析器是否支持该参数,如果支持再调用resolveArgument()进行实际解析。

我们自定义完一个参数解析器之后，还要讲我们的参数解析器加入到我们的RequestMappingHandlerAdapter 中去：

    // ⬅️2. 继续加入RequestMappingHandlerAdapter, 会替换掉 DispatcherServlet 默认的 4 个 HandlerAdapter
    @Bean
    public MyRequestMappingHandlerAdapter requestMappingHandlerAdapter() {
        TokenArgumentResolver tokenArgumentResolver = new TokenArgumentResolver();
        MyRequestMappingHandlerAdapter handlerAdapter = new MyRequestMappingHandlerAdapter();
        handlerAdapter.setCustomArgumentResolvers(List.of(tokenArgumentResolver));
        return handlerAdapter;
    }

这里使用setCustomArgumentResolvers()就可以添加我们自定义的参数解析器了。

自定义返回值处理器

与前面的自定义参数处理器差不多：

HandlerMethodReturnValueHandler接口用于处理HandlerMethod的返回值。它定义了两个方法:

  • supportsReturnType()：该方法用于判断当前的返回值处理器是否支持处理该返回值类型。如果返回true,则会调用handleReturnValue()方法进行实际处理。
  • handleReturnValue()：该方法会对返回值进行处理,主要做了以下工作:
    1. 根据返回值添加模型数据到ModelAndViewContainer中。
    2. 设置逻辑视图名到ModelAndViewContainer。
    3. 对特殊的返回值类型(如ResponseEntity)进行处理。
    4. 处理异常,添加到ModelAndViewContainer中。

接下来我们看一个例子：

我们自定义了一个注解@Yml，接下来我们通过识别这个注解来达到返回值处理的效果：

在这里插入图片描述

自定义返回值处理器：

public class YmlReturnValueHandler implements HandlerMethodReturnValueHandler {
    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        Yml yml = returnType.getMethodAnnotation(Yml.class);
        return yml != null;
    }

    @Override                   //  返回值
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
                                  ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        // 1. 转换返回结果为 yaml 字符串
        String str = new Yaml().dump(returnValue);

        // 2. 将 yaml 字符串写入响应
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().print(str);

        // 3. 设置请求已经处理完毕
        mavContainer.setRequestHandled(true);
    }
}

最后将自定义的返回值处理器加入到RequestMappingHandlerAdapter 中去：

在这里插入图片描述

参数解析器

绑定请求参数到Controller方法的参数上，这一重要的步骤在SpringMVC框架中就是参数解析器帮助我们完成的。

解析参数依赖的就是各种参数解析器，它们都有两个重要方法

  • supportsParameter 判断是否支持方法参数
  • resolveArgument 解析方法参数

在RequestMappingHandlerAdapter 中自带了以下几种HandlerMethodArgumentResolver(参数解析器)：

在这里插入图片描述

这里我们看几个常用的参数解析器，测试代码如下：

    static class Controller {
        public void test(
                @RequestParam("name1") String name1, // name1=张三
                String name2,                        // name2=李四
                @RequestParam("age") int age,        // age=18
                @RequestParam(name = "home", defaultValue = "${JAVA_HOME}") String home1, // spring 获取数据
                @RequestParam("file") MultipartFile file, // 上传文件
                @PathVariable("id") int id,               //  /test/124   /test/{id}
                @RequestHeader("Content-Type") String header,
                @CookieValue("token") String token,
                @Value("${JAVA_HOME}") String home2, // spring 获取数据  ${} #{}
                HttpServletRequest request,          // request, response, session ...
                @ModelAttribute("abc") User user1,          // name=zhang&age=18
                User user2,                          // name=zhang&age=18
                @RequestBody User user3              // json
        ) {
        }
    }

这里我们首先来看RequestParamMethodArgumentResolver参数解析器，它对应的注解就是@RequestParam。也就对应了我们测试代码中这五个示例：
在这里插入图片描述

都一种是标准使用方式，对比第一种：

  • 第二种测试不显示使用@RequestParam的情况
  • 第三种测试涉及类型转换的情况
  • 第四种测试从环境变量中获取值的情况
  • 第五种测试获取文件的情况

测试代码如下：

    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
        // 准备测试 Request对象，这里使用了mock进行模拟，可以让我们脱离web环境进行测试
        HttpServletRequest request = mockRequest();

        // 要点1. 控制器方法被封装为 HandlerMethod
        HandlerMethod handlerMethod = new HandlerMethod(new Controller(), Controller.class.getMethod("test", String.class, String.class, int.class, String.class, MultipartFile.class, int.class, String.class, String.class, String.class, HttpServletRequest.class, User.class, User.class, User.class));

        // 要点2. 准备对象绑定与类型转换
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, null);

        // 要点3. 准备 ModelAndViewContainer 用来存储中间 Model 结果
        ModelAndViewContainer container = new ModelAndViewContainer();

        // 要点4. 解析每个参数值
        for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
           
            //false 表示必须有 @RequestParam
            RequestParamMethodArgumentResolver resolver =   new RequestParamMethodArgumentResolver(beanFactory, false),                                    
            
            String annotations = Arrays.stream(parameter.getParameterAnnotations()).map(a -> a.annotationType().getSimpleName()).collect(Collectors.joining());
            String str = annotations.length() > 0 ? " @" + annotations + " " : " ";
            parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());

            if (composite.supportsParameter(parameter)) {
                // 支持此参数
                Object v = composite.resolveArgument(parameter, container, new ServletWebRequest(request), factory);
//                System.out.println(v.getClass());
                System.out.println("[" + parameter.getParameterIndex() + "] " + str + parameter.getParameterType().getSimpleName() + " " + parameter.getParameterName() + "->" + v);
                System.out.println("模型数据为：" + container.getModel());
            } else {
                System.out.println("[" + parameter.getParameterIndex() + "] " + str + parameter.getParameterType().getSimpleName() + " " + parameter.getParameterName());
            }
        }


    }

    private static HttpServletRequest mockRequest() {
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setParameter("name1", "zhangsan");
        request.setParameter("name2", "lisi");
        request.addPart(new MockPart("file", "abc", "hello".getBytes(StandardCharsets.UTF_8)));
        Map<String, String> map = new AntPathMatcher().extractUriTemplateVariables("/test/{id}", "/test/123");
        System.out.println(map);
        request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, map);
        request.setContentType("application/json");
        request.setCookies(new Cookie("token", "123456"));
        request.setParameter("name", "张三");
        request.setParameter("age", "18");
        return new StandardServletMultipartResolver().resolveMultipart(request);
    }

结果：
在这里插入图片描述

注意：

  • 测试代码主体分为以下几部分

    • 控制器方法被封装为 HandlerMethod：这一部分的工作一般是由HandlerMapping来做的，他们在做路径映射的时候就会把方法封装成HandlerMethod，这里我们没有使用。这里我们没有使用路径映射，所以要自己单独封装
    • 准备对象绑定与类型转换
    • 准备 ModelAndViewContainer 用来存储中间 Model 结果
    • 解析每个参数值

  • RequestParamMethodArgumentResolver有两种工作模式，对应着构造器中的第二个参数，true表示可以没有@RequestParam也能解析，false表示必须有@RequestParam才能解析

  • ServletRequestDataBinderFactory用于对象的绑定与类型转换，如果没有它那么我们这个时候解析出来的age其实是string类型的，而我们想要的是int类型。对象的绑定就是说方法接收到的是一个对象，该组件就可以将对象的属性与方法的参数进行绑定

  • 如果涉及到${ } #{ }的解析，前文我们提到过ApplicationContext 容器继承了EnvironmentCapable接口具有读取环境变量、配置文件的能力，也就是说这方面的功能我们是交给容器去实现的。这也就是说我们为什么在构造RequestParamMethodArgumentResolver的时候要传入一个容器对象

可以看到我们解析到第五个之后就报错了，这是因为此时我们只有1个解析器，我们可以多添加几种解析器，一个解析失败就换另一个尝试。Spring在底层使用了一种组合模式：

在这里插入图片描述
我们也使用这种组合模式：

在这里插入图片描述

这里的HandlerMethodArgumentResolverComposite就是一个参数解析器的复合，有了它之后我们可以更加方便。以后我们只需要调用复合解析器的supportsParameter、resolveArgument方法，而不需要关心其中包含有什么解析器。

然后我们加入PathVariableMethodArgumentResolver，这个解析器用来处理@PathVariable。

其原理如下：

  • HandlerMapping会将路径中的一组对应关系放在map集合里，存在request域中
    • 举个例子：请求路径：/test/124 ，注解中的值：/test/{id}
    • 于是map中就会把id --> 124 进行对应
  • 当执行到此解析器的时候，他就会根据@PathVariable中的name到map集合中去找
  • 找到之后就和我们方法的参数值进行绑定

@Value对应的解析器是ExpressionValueMethodArgumentResolver

而我们的第九种：
在这里插入图片描述

它使用的解析器是ServletRequestMethodArgumentResolver，它是根据参数的类型进行解析，事实上这个解析器他不光可以解析HttpServletRequest这一个类型，还有一些其他的类型，我们看看它的supportsParameter 方法：

在这里插入图片描述

再来说说@ModelAttribute，它由ServletModelAttributeMethodProcessor进行解析，它可以将名字等于值的参数与我们的java对象进行绑定，参数名对应着java对象中的属性。并且它还会把我们参数解析器处理得到的结果作为模型数据存储到ModelAndViewContainer中。
在这里插入图片描述

在Spring底层添加了两次ServletModelAttributeMethodProcessor：
在这里插入图片描述

分别处理@ModelAttribute标识和省略@ModelAttribute的情况。

我们还有一个注意点：我们参数解析器的顺序也是有讲究的：
在这里插入图片描述
我们省略的情况要统一放到最后判断，加入这里我将倒数第二和倒数第三换个位置，就会出现下面的结果：
在这里插入图片描述
我们使用@RequestBody解析的参数，会被误认为省略@ModelAttribute的情况而被ServletModelAttributeMethodProcessor先解析。

最后还要注意：

@RequestParam, @CookieValue 等注解中的参数名、默认值, 都可以写成活的, 即从 ${ } #{ }中获取

获取参数名

首先我们要知道我们的java文件在编译的时候，是不会保留参数名的，例如：
Java文件：
在这里插入图片描述
编译之后：
在这里插入图片描述

所以说这个参数名的获取也不是我们想象中的那么简单。

获取参数名的方法如下：

  1. 如果编译时添加了 -parameters 可以生成参数表, 反射时就可以拿到参数名(通过ASM拿不到)
    在这里插入图片描述

  2. 如果编译时添加了 -g 可以生成调试信息, 但分为两种情况
    在这里插入图片描述

    • 普通类, 会包含局部变量表, 用 asm 可以拿到参数名(局部变量表使用反射是拿不到的)
    • 接口, 不会包含局部变量表, 无法获得参数名
      • 这也是 MyBatis 在实现 Mapper 接口时为何要提供 @Param 注解来辅助获得参数名
  • spring boot 在编译时会加 -parameters
  • 大部分 IDE 编译时都会加 -g

在Spring中，其底层使用了LocalVariableTableParameterNameDiscoverer来通过ASM去获得参数名。

还记得我们在前面写过的代码吗？

我们在获得参数名称的时候直接使用MethodParameter.getParameterName()得到的参数名是null，我们还需要一句话：

 parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());

而这个DefaultParameterNameDiscoverer中我们就可以发现LocalVariableTableParameterNameDiscoverer：

在这里插入图片描述

上面那个StandardReflectionParameterNameDiscoverer就是用来解决第一种情况。也就是说Spring对两种情况都进行了处理并进行了封装。

对象绑定与类型转换

Spring中的类型转换体系非常的复杂，涉及到：

  • 底层第一套转换接口与实现
  • 底层第二套转换接口与实现
  • 高层接口与实现

接下来我们一个个来看：

底层第一套转换接口与实现
«interface»
Formatter
«interface»
Printer
«interface»
Parser
Converters
Set<GenericConverter>
«interface»
Converter
«interface»
ConversionService
FormattingConversionService
Adapter1
Adapter2
Adapter3
  • Printer 把其它类型转为 String
  • Parser 把 String 转为其它类型
  • Formatter 综合 Printer 与 Parser 功能
  • Converter 把类型 S 转为类型 T
  • Printer、Parser、Converter 经过适配转换成 GenericConverter 放入 Converters 集合
  • FormattingConversionService 利用它们实现转换

底层第二套转换接口与实现

这一套由JDK提供，并不是Spring中的
多
«interface»
PropertyEditorRegistry
«interface»
PropertyEditor
  • PropertyEditor 把 String 与其它类型相互转换
  • PropertyEditorRegistry 可以注册多个 PropertyEditor 对象
  • 与第一套接口直接可以通过 FormatterPropertyEditorAdapter 来进行适配

问：为什么Spring要同时使用这两套类型转换接口？
答：历史遗留问题，最早的Spring直至JDK的这套转换接口，随着发展这套转换接口的功能不够全面，例如：不支持任意两个类型的转换。为了拓展于是Spring引入了一套新的转换体系。不抛弃旧的是因为涉及到版本兼容原因。所以呈现出了两套转换接口并存的情况。

高层转换接口与实现
«interface»
TypeConverter
SimpleTypeConverter
BeanWrapperImpl
DirectFieldAccessor
ServletRequestDataBinder
TypeConverterDelegate
«interface»
ConversionService
«interface»
PropertyEditorRegistry
  • 它们都实现了 TypeConverter 这个高层转换接口，在转换时，会用到 TypeConverter Delegate 委派ConversionService 与 PropertyEditorRegistry 真正执行转换（Facade 门面模式）
    • 处理逻辑：
    • 首先看PropertyEditorRegistry中是否有自定义转换器, @InitBinder 添加的即属于这种 (用了适配器模式把 Formatter 转为需要的 PropertyEditor)
    • 再看有没有 ConversionService 转换
    • 再利用默认的 PropertyEditor 转换
    • 最后有一些特殊处理
  • SimpleTypeConverter 仅做类型转换
  • BeanWrapperImpl 为 bean 的属性赋值，当需要时做类型转换，走 Property
  • DirectFieldAccessor 为 bean 的属性赋值，当需要时做类型转换，走 Field
  • ServletRequestDataBinder 为 bean 的属性执行绑定，当需要时做类型转换，根据 directFieldAccess 选择走 Property 还是 Field，同时还具备校验与获取校验结果功能

接下来我们详细的说说这四个组件，他帮我们实现了基本的类型转换与数据绑定：

  • SimpleTypeConverter
  • BeanWrapperImpl
  • DirectFieldAccessor
  • ServletRequestDataBinder

SimpleTypeConverter

public class TestSimpleConverter {
    public static void main(String[] args) {
        // 仅有类型转换的功能
        SimpleTypeConverter typeConverter = new SimpleTypeConverter();
        Integer number = typeConverter.convertIfNecessary("13", int.class);
        Date date = typeConverter.convertIfNecessary("1999/03/04", Date.class);
        System.out.println(number);
        System.out.println(date);
    }
}

BeanWrapperImpl

BeanWrapperImpl是Spring框架中一个重要的类,它的主要作用是:
将JavaBean属性的读取、写入操作统一进行处理。它可以设置和获取JavaBean的属性(本质是通过getter/setter方法)，并通过PropertyEditor支持数据类型转换。

它简化了我们直接操作Bean的复杂度,提供了一套完备的机制用于属性的访问。在Spring框架中有广泛的使用,如:

  • DataBinder使用BeanWrapper进行数据绑定
  • BeanFactory使用BeanWrapper进行Bean属性的依赖注入
  • Expression解析器使用BeanWrapper获取或设置值
  • 等等
public class TestBeanWrapper {
    public static void main(String[] args) {
        // 利用反射原理, 为 bean 的属性赋值
        MyBean target = new MyBean();
        BeanWrapperImpl wrapper = new BeanWrapperImpl(target);
        wrapper.setPropertyValue("a", "10");
        wrapper.setPropertyValue("b", "hello");
        wrapper.setPropertyValue("c", "1999/03/04");
        System.out.println(target);
    }

    static class MyBean {
        private int a;
        private String b;
        private Date c;

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public String getB() {
            return b;
        }

        public void setB(String b) {
            this.b = b;
        }

        public Date getC() {
            return c;
        }

        public void setC(Date c) {
            this.c = c;
        }

        @Override
        public String toString() {
            return "MyBean{" +
                   "a=" + a +
                   ", b='" + b + '\'' +
                   ", c=" + c +
                   '}';
        }
    }
}

DirectFieldAccessor

与传统的通过getter/setter方法来读写属性相比,DirectFieldAccessor的优点是：

  1. 性能更高。直接访问field避免了方法调用的开销。
  2. 可以访问private字段。

与传统的BeanWrapperImpl相比,DirectFieldAccessor的优点在于性能更高,可以访问private字段。但是由于直接访问Field的方式破坏了封装性,也带来了一定隐患:

  1. 子类继承的字段也会变成可访问,这可能不是设计意图。
  2. 修改字段值会直接作用在原始对象上,违反JavaBean的设计模式。这可能会引起既有代码的问题。
public class TestFieldAccessor {
    public static void main(String[] args) {
        // 利用反射原理, 为 bean 的属性赋值
        MyBean target = new MyBean();
        DirectFieldAccessor accessor = new DirectFieldAccessor(target);
        accessor.setPropertyValue("a", "10");
        accessor.setPropertyValue("b", "hello");
        accessor.setPropertyValue("c", "1999/03/04");
        System.out.println(target);
    }

    static class MyBean {
        private int a;
        private String b;
        private Date c;
        @Override
        public String toString() {
            return "MyBean{" +
                   "a=" + a +
                   ", b='" + b + '\'' +
                   ", c=" + c +
                   '}';
        }
    }
}

DataBinder

public class TestDataBinder {

    public static void main(String[] args) {
        // 执行数据绑定
        MyBean target = new MyBean();
        DataBinder dataBinder = new DataBinder(target);
        //根据 directFieldAccess 选择走 Property 还是 Field
        dataBinder.initDirectFieldAccess();
        MutablePropertyValues pvs = new MutablePropertyValues();
        pvs.add("a", "10");
        pvs.add("b", "hello");
        pvs.add("c", "1999/03/04");
        dataBinder.bind(pvs);
        System.out.println(target);
    }

    static class MyBean {
        private int a;
        private String b;
        private Date c;

        @Override
        public String toString() {
            return "MyBean{" +
                   "a=" + a +
                   ", b='" + b + '\'' +
                   ", c=" + c +
                   '}';
        }
    }
}

web环境下对应着其子类ServletRequestDataBinder：

public class TestServletDataBinder {

    public static void main(String[] args) {
        // web 环境下数据绑定
        MyBean target = new MyBean();
        ServletRequestDataBinder dataBinder = new ServletRequestDataBinder(target);
        
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setParameter("a", "10");
        request.setParameter("b", "hello");
        request.setParameter("c", "1999/03/04");
		//可以更好的处理请求中的参数
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));

        System.out.println(target);
    }

    static class MyBean {
        private int a;
        private String b;
        private Date c;

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public String getB() {
            return b;
        }

        public void setB(String b) {
            this.b = b;
        }

        public Date getC() {
            return c;
        }

        public void setC(Date c) {
            this.c = c;
        }

        @Override
        public String toString() {
            return "MyBean{" +
                   "a=" + a +
                   ", b='" + b + '\'' +
                   ", c=" + c +
                   '}';
        }
    }
}

我们前面所说的ServletModelAttributeMethodProcessor参数解析器中的功能就是它提供的。

ServletRequestParameterPropertyValues是Spring框架中一个实现了PropertyValues接口的类。
它的主要作用是:将ServletRequest中的参数转为PropertyValues,以便用于数据绑定。
在这里插入图片描述
当我们要将ServletRequest的参数绑定到JavaBean时,需要先将这些参数转为PropertyValues格式,才可以使用DataBinder进行绑定。
ServletRequestParameterPropertyValues常与WebDataBinder、RequestMappingHandlerAdapter等配合使用,完成高效的请求参数到Bean的绑定,

自定义转换器

接下来我们将上面的代码稍作修改：

在这里插入图片描述

可以看到这两个绑定上面这一种肯定是不能成功的，日期准换不支持这种格式，而下面这一种可以成功：
在这里插入图片描述
如果我们非要这样绑定呢？所以这里我们就引出一个新的问题：添加自定义转换器

这里我们有两种思路：

  • ConversionService + Formatter
  • PropertyEditorRegistry + PropertyEditor

也就是对应着我们前面说的底层两套转换接口。接下来我们开始实现：

PropertyEditorRegistry + PropertyEditor

这里我们就不自己创建ServletRequestDataBinder，而是改用ServletRequestDataBinderFactory帮我们创建ServletRequestDataBinder。因为使用这个工厂创建时可以添加各种选项，比如说想基于JDK转换接口进行拓展还是Spring转换接口进行拓展自己的转换器。

当然直接使用工厂还是没有转换功能的，这里我们可以借助@InitBinder注解帮助我们进行转换器的拓展。

@InitBinder是SpringMVC中一个非常重要的注解,它的主要作用是:
初始化WebDataBinder,为Web请求参数到JavaBean的绑定提供定制化的功能。

这里的WebDataBinder是DataBinder和ServletRequestDataBinder的中间类型：
在这里插入图片描述

例如,我们可以通过@InitBinder在控制器中添加:

  1. Custom editors 自定义属性编辑器
  2. Custom converters 自定义类型转换器
  3. Custom validators 自定义校验器

来增强WebDataBinder的功能,以完成更加丰富的数据绑定。

使用方式：

在@Controller的方法上标注@InitBinder,传入WebDataBinder类型的参数:

@Controller
public class MyController {
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        // 添加编辑器、转换器、校验器
        binder.addCustomEditor(...);
        binder.addConverter(...); 
        binder.addValidator(...);
    }  
}

这样,为@InitBinder方法传入的WebDataBinder对象添加的定制化功能会应用到该Controller的所有@RequestMapping方法中。

接下来我们就开始修改我们的代码：

public class TestServletDataBinderFactory {
    public static void main(String[] args) throws Exception {
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setParameter("birthday", "1999|01|02");
        request.setParameter("address.name", "西安");

        User target = new User();
        //将控制器中的方法包装成回调方法
        InvocableHandlerMethod method = new InvocableHandlerMethod(new MyController(), MyController.class.getMethod("aaa", WebDataBinder.class));
        //创建工厂的时候将回调方法的传入，在创建DataBinder的时候会进行回调
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(List.of(method), null);
               

        WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), target, "user");
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));
        System.out.println(target);
    }


    static class MyController {
        @InitBinder
        public void aaa(WebDataBinder dataBinder) {
            // 扩展 dataBinder 的转换器
            dataBinder.addCustomFormatter(new MyDateFormatter("用 @InitBinder 方式扩展的"));
        }
    }

自定义转换器：

在这里插入图片描述

这个地方要注意我们使用InvocableHandlerMethod将@InitBinder标注的方法包了一层。

InvocableHandlerMethod是Spring MVC中一个重要的类,它的主要作用是:
代表一个可调用的控制器方法,通过它我们可以调用指定的控制器方法。

在创建ServletRequestDataBinderFactory的时候，我们传入了一个列表里面就装着这些控制器回调方法，如此该工厂在创建WebDataBinder就可以回调这些方法，对WebDataBinder进行类型转换的拓展。

我们点开addCustomFormatter方法，发现它使用的就是PropertyEditorRegistry + PropertyEditor：
在这里插入图片描述

ConversionService + Formatter

public class TestServletDataBinderFactory {
    public static void main(String[] args) throws Exception {
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setParameter("birthday", "1999|01|02");
        request.setParameter("address.name", "西安");

        User target = new User();
        //创建类型转换服务
        FormattingConversionService service = new FormattingConversionService();
        //将自定义的转化器添加到服务中
        service.addFormatter(new MyDateFormatter("用 ConversionService 方式扩展转换功能"));
        //创建一个WebDataBinder的初始化器
        ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
        //设置类型转换服务
        initializer.setConversionService(service);
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, initializer);
               

        WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), target, "user");
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));
        System.out.println(target);
    }

这里我们使用到了ConfigurableWebBindingInitializer，其主要作用就是初始化WebDataBinder。这次我们在创建ServletRequestDataBinderFactory时候没有传入回调函数的列表而是传入了这个WebDataBinder的初始化器。

如果我们同时使用这两种方法：

ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(List.of(method), initializer);

@InitBinder的优先级更高

还有一种方法：使用默认 ConversionService 转换
在这里插入图片描述
在这里插入图片描述
要配合@DateTimeFormat注解进行使用。
也就是说：
@DateTimeFormat注解是DefaultFormattingConversionService负责解析的。

最后我们总结一下：

ServletRequestDataBinderFactory 的用法和扩展点

  1. 可以解析控制器的 @InitBinder 标注方法作为扩展点，添加自定义转换器
    • 控制器私有范围
  2. 可以通过 ConfigurableWebBindingInitializer 配置 ConversionService 作为扩展点，添加自定义转换器
    • 公共范围
  3. 同时加了 @InitBinder 和 ConversionService 的转换优先级
    1. 优先采用 @InitBinder 的转换器
    2. 其次使用 ConversionService 的转换器
    3. 使用默认转换器
    4. 特殊处理（例如有参构造）

@ControllerAdvice 之 @InitBinder

@ControllerAdvice是一个注解，它的主要作用是:
对一组Controller进行全局配置，比如:

  • 异常处理
  • 数据绑定
  • 拦截器绑定
  • 等等

使用@ControllerAdvice，我们可以将一些共享的代码抽取出来，应用到一组Controller上。比如:

// 定义一个统一异常处理类
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(value = Exception.class)
    public String exception(Exception e) {
        // 统一异常处理逻辑
    }
}

然后，GlobalExceptionHandler中的方法会应用到所有@Controller上，实现全局异常处理。

我们也可以将@ControllerAdvice的属性使用更加具体：

@ControllerAdvice(assignableTypes = {Controller1.class, Controller2.class})
public class ExampleAdvice {}

上述@ControllerAdvice只应用于Controller1和Controller2类型的Controller,实现更加细粒度的配置。

@ControllerAdvice还支持像@ModelAttribute这样的注解，我们可以整合多个Controller的@ModelAttribute方法:

@ControllerAdvice
public class ExampleAdvice {
    @ModelAttribute("commonAttribute")
    public void commonAttribute() { ... }
}

这样,所有的Controller在其@RequestMapping方法被调用前，首先会执行@ModelAttribute(“commonAttribute”)方法。

除此之外,@ControllerAdvice还支持:

  • @InitBinder: 实现多个Controller的参数绑定定制
  • @Resource和@Autowired: 向一组Controller提供共享的bean
  • Interceptor: 向一组Controller添加拦截器
  • 等等

接下来我们详细的说说@InitBinder：
在这里插入图片描述

它是由RequestMappingHandlerAdapter进行解析的。其解析后的结果存放在RequestMappingHandlerAdapter的两个属性值中：

在这里插入图片描述

  • initBinderCache：用来存放每个控制器类的initBinder，map中的key是控制器类型，值是@InitBinder标注的方法
  • initBinderAdviceCache：用来存储全局的initBinder

接下来我们看看这两种@InitBinder解析的时机：

@InitBinder 在整个 HandlerAdapter 调用过程中所处的位置

HandlerAdapter WebDataBinderFactory ModelFactory ServletInvocableHandlerMethod ArgumentResolvers ReturnValueHandlers ModelAndViewContainer 准备 @InitBinder 准备 @ModelAttribute 添加Model数据 invokeAndHandle 获取 args 有的解析器涉及 RequestBodyAdvice 有的解析器涉及数据绑定生成Model数据 args method.invoke(bean,args) 得到 returnValue 处理 returnValue 有的处理器涉及 ResponseBodyAdvice 添加Model数据,处理视图名,是否渲染等 获取 ModelAndView HandlerAdapter WebDataBinderFactory ModelFactory ServletInvocableHandlerMethod ArgumentResolvers ReturnValueHandlers ModelAndViewContainer
  • RequestMappingHandlerAdapter 在图中缩写为 HandlerAdapter
  • HandlerMethodArgumentResolverComposite 在图中缩写为 ArgumentResolvers
  • HandlerMethodReturnValueHandlerComposite 在图中缩写为 ReturnValueHandlers

重点💡：

  1. RequestMappingHandlerAdapter 初始化时会解析 @ControllerAdvice 中的 @InitBinder 方法
  2. RequestMappingHandlerAdapter 会以类为单位，在该类首次使用时，解析此类的 @InitBinder 方法
  3. 以上两种 @InitBinder 的解析结果都会缓存来避免重复解析
  4. 控制器方法调用时，会综合利用本类的 @InitBinder 方法和 @ControllerAdvice 中的 @InitBinder 方法创建绑定工厂

附：说说MVC

MVC可以说是三层架构的一种实现类

MVC框架是一种设计模式，它将应用程序分为三个核心组件：模型（Model）、视图（View）和控制器（Controller）。MVC框架通过这三个组件的协同工作，实现了应用程序的解耦、可维护性和可扩展性。

具体来说，MVC框架中的：

  • 模型（Model）表示应用程序的数据和业务逻辑
  • 视图（View）表示数据的展示方式
  • 控制器（Controller）则负责协调模型和视图之间的交互。

当用户请求一个页面时，控制器接收到请求后会调用模型来获取数据，然后将数据传递给视图进行展示。用户可以通过视图来操作数据，控制器则负责将这些操作反映到模型中。

我们举个例子：

假设我们正在开发一个简单的图书管理系统，其中包含以下功能：

  • 用户可以浏览图书列表，并查看每本书的详细信息；
  • 用户可以添加、编辑和删除图书。

在这个系统中，我们可以将：

  • 图书作为模型（Model），它包含图书的各种属性（如书名、作者、出版社、出版日期等）以及对图书的各种操作（如添加、编辑和删除等）。

  • 视图（View）则是用来展示图书信息的界面，它可以是一个HTML页面、一个JSP页面或者一个JSON数据格式等。例如，我们可以创建一个图书列表页面，用来展示所有图书的基本信息，以及一个图书详情页面，用来展示某本书的详细信息。

  • 控制器（Controller）则负责协调模型和视图之间的交互。例如，当用户请求图书列表页面时，控制器会调用模型来获取所有图书的信息，然后将这些信息传递给视图进行展示。当用户点击某本书的链接时，控制器会根据图书的ID来调用模型，获取该书的详细信息，然后将这些信息传递给视图展示。

ModelAndView

ModelAndView是SpringMVC中重要的对象之一，它封装了模型数据和视图信息，用来从Controller向视图传递 数据和视图信息。

它包含两个部分:

  • Model：模型数据,用来携带Controller处理后需要显示给用户的数据。可以是任意的POJO对象。
  • View：视图信息，指定了视图的名称或实例，告诉Spring要使用哪个视图渲染模型数据。可以是一个逻辑名称，也可以是View实例。

ModelAndView的创建方式有三种:

  1. 指定模型数据和逻辑视图名：

    ModelAndView mv = new ModelAndView("viewName", "modelAttr", modelObj);

  2. 指定模型数据和View实例：

    View view = ... 
ModelAndView mv = new ModelAndView(view, "modelAttr", modelObj);

  3. 不指定任何参数,后续再添加模型数据和视图信息：

    ModelAndView mv = new ModelAndView();
mv.addObject("modelAttr", modelObj); 
mv.setViewName("viewName");

使用方式：

Controller方法可以返回ModelAndView,并在方法中创建并返回：

@Controller
public class MyController {
    @RequestMapping("/someUrl")
    public ModelAndView handleRequest() {
        ModelAndView mv = new ModelAndView("viewName");
        mv.addObject("modelAttr", modelObj);
        return mv;
    }
}

这样DispatcherServlet在调用完Controller后会获取到返回的ModelAndView，并使用其中的视图信息进行视图解析，得到View。然后利用ModelAndView中的模型数据渲染View，得到最终响应。

所以ModelAndView的主要作用是在Controller和View之间传递数据和视图信息。Controller将需要显示的数据和视图放入ModelAndView,然后DispatcherServlet使用这些信息进行视图解析和渲染，生成最终响应。

综上，ModelAndView是SpringMVC中非常重要且常用的对象，它承载了Controller处理请求后需要显示给用户的模型数据和指定的视图，起到了在Controller和View之间传递信息的作用。虽然现在有更加灵活的返回值支持，但是ModelAndView仍然是比较经典和简单的选择。

ModelAndViewContainer

ModelAndViewContainer用来存储 HandlerMethod的处理结果，它包含模型数据、逻辑视图名、异常信息等。

它主要有以下作用:

  1. 存储从HandlerMethod中返回的模型数据。无论HandlerMethod的返回值是Model、ModelMap、Map等,都可以存储为模型数据。
  2. 存储HandlerMethod返回值中的逻辑视图名。
  3. 存储在HandlerMethod执行过程中出现的异常信息。
  4. 此外，也可以存储一些标志位,如是否跳转至登录页等信息。
  5. ModelAndViewContainer会在HandlerAdapter处理完HandlerMethod后，将结果传递给DispatcherServlet使用。DispatcherServlet会使用视图解析器解析逻辑视图名，得到View，并使用ModelAndViewContainer中的模型数据渲染View。

所以ModelAndViewContainer是连接HandlerAdapter和DispatcherServlet的重要载体，它承载处理HandlerMethod的结果，并传递给DispatcherServlet使用。

它简化了HandlerMethod的返回值，方法可以返回各种类型，而不需要局限于ModelAndView。因为无论返回什么类型，都可以通过HandlerMethodReturnValueHandler处理后存储到ModelAndViewContainer中，然后再由DispatcherServlet使用。

使用方式:

我们无需自己创建ModelAndViewContainer，它是由HandlerAdapter创建并使用的。我们主要是从HandlerMethod的返回值中添加信息到ModelAndViewContainer。

举个例子，在HandlerMethodReturnValueHandler的handleReturnValue()方法中，我们可以这样做:

// 处理返回Model类型
modelMap.addAttribute("attr", returnValue); 
mavContainer.addAllAttributes(modelMap); 

// 处理返回String,作为逻辑视图名    
mavContainer.setViewName(returnValue); 

// 标记请求已处理    
mavContainer.setRequestHandled(true);

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/603127.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

NeRF与三维重建专栏（二）NeRF原文解读与体渲染物理模型

NeRF与三维重建专栏（二）NeRF原文解读与体渲染物理模型

前言 上一章中我们大致介绍了三维重建的背景、NeRF应用于三维重建的难点以及相关数据集和评估指标&#xff0c;本章节将会详细介绍NeRF原文以及部分源码&#xff0c;以及体渲染的物理模型&#xff0c;来帮助读者更好理解NeRF&#xff1b;下一章我们将会结合colmap&#xff0c;讲…
阅读更多...
PrivateGPT(如何部署及使用感受)

PrivateGPT(如何部署及使用感受)

前言 最近在GitHub上出现了一个名为PrivateGPT的开源项目。该项目旨在为面临敏感数据、涉密信息或个人隐私问题的用户提供一种新的聊天工具。PrivateGPT具备完整的数据控制能力&#xff0c;使用户能够在本地环境中与强大的语言模型进行交互&#xff0c;无需上传数据到互联网或…
阅读更多...
kotlin的for循环遍历

kotlin的for循环遍历

kotlin的for循环遍历 1、List val list listOf("A", "B", "C")for (item in list) {println(item)} A B C 2、List的in val list listOf("A", "B", "C")for (item: String in list) {println(item)} A B C 3、l…
阅读更多...
【C/C++】基础知识之命名空间与作用域

【C/C++】基础知识之命名空间与作用域

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; &#x1f525;c系列专栏&#xff1a;C/C零基础到精通 &#x1f525; 给大…
阅读更多...
【学习日记2023.6.2】之 管理端报表统计

【学习日记2023.6.2】之 管理端报表统计

文章目录 11. 管理端报表统计11.1 Apache ECharts11.1.1 介绍11.1.2 入门案例 11.2 营业额统计11.2.1 需求分析和设计11.2.2 代码开发Controller层Service层接口Service层实现类Mapper层 11.2.3 功能测试11.2.4 提交代码 11.3 用户统计11.3.1 需求分析和设计11.3.2 代码开发Con…
阅读更多...
【QCA6174】QCA6174认证DFS跳转信道距离干扰信道太近，导致边带可以检测到信号问题分析及解决方案

【QCA6174】QCA6174认证DFS跳转信道距离干扰信道太近，导致边带可以检测到信号问题分析及解决方案

WIFI DFS测试要求 Master设备需要测试的项目 4.6.2.1 Channel Availability Check ---信道可用性检查 定义其作为雷达脉冲检测机制，当雷达脉冲出现时所占用的信道需要能被设备检测到已经被占用。当相关信道未被占用时，这些信道被称为Avaliable Channel可用信道 4.6.2.2 In…
阅读更多...
23Java面试专题 八股文面试全套真题（含大厂高频面试真题）多线程

23Java面试专题 八股文面试全套真题（含大厂高频面试真题）多线程

文档说明 在文档中对所有的面试题都进行了 难易程度和 出现频率的等级说明 星数越多代表权重越大&#xff0c;最多五颗星&#xff08;☆☆☆☆☆&#xff09; 最少一颗星&#xff08;☆&#xff09; Java多线程相关面试题 1.线程的基础知识 1.1 线程和进程的区别&#xff1f; 难…
阅读更多...
敷尔佳三闯IPO：去年狂赚8亿，广告宣传费近4亿

敷尔佳三闯IPO：去年狂赚8亿，广告宣传费近4亿

618大促已经开启&#xff0c;敷尔佳能否借“618”撑起“医美面膜第一股”&#xff1f; 近日&#xff0c;哈尔滨敷尔佳科技发展有限公司&#xff08;下称“敷尔佳”&#xff09;更新招股书&#xff0c;继续冲刺“医美面膜第一股”。 敷尔佳是一家主要从事专业皮肤护理产品的研…
阅读更多...
MySQL中的业务数据该如何正确导入到Hive中 - Sqoop

MySQL中的业务数据该如何正确导入到Hive中 - Sqoop

水善利万物而不争&#xff0c;处众人之所恶&#xff0c;故几于道&#x1f4a6; 目录 1. 使用Sqoop脚本将MySQL中的数据迁移到HDFS 2. 在Hive中建立与之对应的表 3. 将HDFS中的数据load到 Hive 数仓的ODS层的表中 1 . 使用Sqoop 将 MySQL中的数据导入到HDFS上 #! /bin/bashsqoo…
阅读更多...
二进制安装Kubernetes(K8s)集群(基于containerd)---从零安装教程（带证书）

二进制安装Kubernetes(K8s)集群(基于containerd)---从零安装教程（带证书）

一、实验环境 1、安装说明 selinux iptables off 官方网站&#xff1a;https://kubernetes.io/zh-cn/docs/home 主机名IP系统版本安装服务master0110.10.10.21rhel7.5nginx、etcd、api-server、scheduler、controller-manager、kubelet、proxymaster0210.10.10.22rhel7.5nginx、…
阅读更多...
Ubuntu安装ssh并开启服务

Ubuntu安装ssh并开启服务

Ubuntu开启SSH服务 1、更新源列表 $ sudo apt-get update 2、安装 说明：安装时需要提供互联网或者提前下载安装包 $ sudo apt-get install openssh-server 3、启动 $ sudo service ssh start 查询服务启动状态： $ sudo ps -e | grep ssh 或者 $ sudo service ssh status …
阅读更多...
【C++】模板（1）

【C++】模板（1）

文章目录 前言一、泛型编程二、模板2.1 函数模板2.2 函数模板实例化&#xff1a;2. 3 函数模板的原理&#xff1a;2.4 模板参数的匹配原则 三、类模板 前言 C中的模板(template)是一种强大的语言特性&#xff0c;它可以让程序员编写可以适用于不同数据类型的通用代码。通过使用…
阅读更多...
Js中的堆（heap)和栈(stack)内存

Js中的堆（heap)和栈(stack)内存

目录 1、堆和栈的概念2、数据类型3、腾讯面试题4、阿里面试题 1、堆和栈的概念 在JS钟变量都存放在内存中&#xff0c;而内存给变量开辟了两块区域&#xff0c;分别为栈区域和堆区域栈(stack)&#xff1a;是栈内存的简称&#xff0c;栈是自动分配相对固定大小的内存空间&#…
阅读更多...
长尾词挖掘，挖掘有效长尾关键词的3个方法

长尾词挖掘，挖掘有效长尾关键词的3个方法

长尾关键词的特征是比较长&#xff0c;往往是2-3个词组成&#xff0c;甚至是短语&#xff0c;存在于内容页面&#xff0c;除了内容页的标题&#xff0c;还存在于内容中。 长尾关键词带来的客户&#xff0c;转化为网站产品客户的概率比目标关键词高很多&#xff0c;因此长尾…
阅读更多...
Nginx服务

Nginx服务

目录 一、Nginx概述 二、编译安装Nginx服务 1.安装Nginx服务 2. Nginx服务的基础命令 2.1开启nginx服务 2.2关闭nginx服务 2.3重载配置文件 2.4平滑升级 3.添加 Nginx 系统服务 3.1判断 Nginx 服务是否开启 3.2 方法一&#xff1a;将 nginx 服务添加到 chkconfig管…
阅读更多...
《面试1v1》CMS垃圾回收期

《面试1v1》CMS垃圾回收期

我是 javapub&#xff0c;一名 Markdown 程序员从&#x1f468;‍&#x1f4bb;&#xff0c;八股文种子选手。 《面试1v1》 连载中… 面试官&#xff1a; 小伙子,CMS 垃圾收集器跟我讲讲? 候选人&#xff1a; CMS全称Concurrent Mark Sweep,是一种并发标记清除算法。它并发执…
阅读更多...
Unity3d 有关Invoke和 Coroutine 的执行条件的误解

Unity3d 有关Invoke和 Coroutine 的执行条件的误解

文章目录 认识错误的点正解测试代码执行截图 认识错误的点 之前一直以为在父物体未激活的状态下&#xff0c; invoke 和 Coroutine 都不会执行。这里面有一点误区。 正解 Coroutine 在父物体未激活状态下&#xff0c;确实不会执行。并且如果在父物体&#xff08;包括祖先节点…
阅读更多...
新手小白运行Springboot+vue项目

新手小白运行Springboot+vue项目

有时候我们会经常复刻别人的项目代码&#xff0c;在第一次运行别人的代码都需要哪些步骤呢&#xff1f; 我在第一次运行的时候踩了很多坑&#xff0c;也看了很多博文&#xff0c;这篇文章将我认为帮助较大的内容进行了一个整合&#xff0c;希望可以为不了解前后端分离&#xff…
阅读更多...
【踩坑日记】【YOLO5】YOLO5 训练模型的测试结果全部相反（标签混乱）原因

【踩坑日记】【YOLO5】YOLO5 训练模型的测试结果全部相反（标签混乱）原因

问题描述 使用 labelImg 为图片数据集打上标签后交给YOLO5训练&#xff0c;发现测试结果中识别结果全部相反&#xff0c;也就是出现了标签混乱的现象。本人使用猫狗图片各 150 张作为数据集进行模型训练&#xff0c;训练出来的模型将所有的猫识别成了狗&#xff0c;所有的狗识…
阅读更多...
【数据库从0到1】-【入门基础篇】

【数据库从0到1】-【入门基础篇】

【数据库从0到1】-【入门基础篇】 &#x1f53b;一、数据库产生背景&#x1f53b;二、数据库有关概述&#x1f53b;三、数据库访问接口&#x1f53b;四、数据库种类&#x1f53b;五、数据库有关术语&#x1f53b;六、常见DBMS排名&#x1f53b;七、常见数据库介绍7.1 RDS(关系型…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023