SpringBoot(五)Web开发

最新推荐文章于 2023-06-26 01:18:06 发布
最新推荐文章于 2023-06-26 01:18:06 发布
阅读量185 收藏 1
点赞数 1
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhrtyuhrthfgdhtgfh/article/details/103557302
版权

Web开发

简介

  1. 创建SpringBoot应用选中我们需要的web模块儿
  2. SpringBoot已经默认将这些场景已经配置好了，只需要指定少量的配置就可以让应用运行起来
  3. SpringBoot自动配置原理
  • 这个场景SpringBoot帮我们配置了什么？能不能修改？
    xxxxAutoConfiguration：帮我们给容器中自动配置组件；
xxxxProperties:配置类来封装配置文件的内容；

1. SpringBoot对静态资源的映射规则

  1. 分析WebMvcAutoConfiguration类
  • 所有的webjars/**请求都被映射到类路径下的META-INF/resources/webjars下
  • staticPathPattern对应的请求都被映射到this.resourceProperties.getStaticLocations()方法的返回值对应的路径下
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
	if (!this.resourceProperties.isAddMappings()) {
		logger.debug("Default resource handling disabled");
		return;
	}
	Integer cachePeriod = this.resourceProperties.getCachePeriod();
	if (!registry.hasMappingForPattern("/webjars/**")) {
	    //将所有的webjars/**请求都映射到类路径下的META-INF/resources/webjars下
		customizeResourceHandlerRegistration(
				registry.addResourceHandler("/webjars/**")
						.addResourceLocations(
								"classpath:/META-INF/resources/webjars/")
				.setCachePeriod(cachePeriod));
	}
	String staticPathPattern = this.mvcProperties.getStaticPathPattern();
	if (!registry.hasMappingForPattern(staticPathPattern)) {
	    //将staticPathPattern对应的请求都映射到this.resourceProperties.getStaticLocations()方法的返回值对应的路径下
		customizeResourceHandlerRegistration(
				registry.addResourceHandler(staticPathPattern)
						.addResourceLocations(
							this.resourceProperties.getStaticLocations())
				.setCachePeriod(cachePeriod));
	}
}

  1. 分析String staticPathPattern = this.mvcProperties.getStaticPathPattern();

    • 进入getStaticPathPattern()方法
      public String getStaticPathPattern() {
		return this.staticPathPattern;
	}
    • 再继续查看staticPathPattern的值，发现
      private String staticPathPattern = "/**";

  2. 分析registry.addResourceHandler(staticPathPattern).addResourceLocations(this.resourceProperties.getStaticLocations())

    • 进入getStaticLocations()方法

      public String[] getStaticLocations() {
	return this.staticLocations;
}

    • 再继续查看staticLocations对应的值private String[] staticLocations = RESOURCE_LOCATIONS;发现staticLocations是一个数组

    • 继续查看RESOURCE_LOCATIONS数组

      private static final String[] SERVLET_RESOURCE_LOCATIONS = { "/" };

private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
		"classpath:/META-INF/resources/", "classpath:/resources/",
		"classpath:/static/", "classpath:/public/" };

private static final String[] RESOURCE_LOCATIONS;

static {
	RESOURCE_LOCATIONS = new String[CLASSPATH_RESOURCE_LOCATIONS.length
			+ SERVLET_RESOURCE_LOCATIONS.length];
	System.arraycopy(SERVLET_RESOURCE_LOCATIONS, 0, RESOURCE_LOCATIONS, 0,
			SERVLET_RESOURCE_LOCATIONS.length);
	System.arraycopy(CLASSPATH_RESOURCE_LOCATIONS, 0, RESOURCE_LOCATIONS,
			SERVLET_RESOURCE_LOCATIONS.length, CLASSPATH_RESOURCE_LOCATIONS.length);
}

      从这段代码中可以知道，数组RESOURCE_LOCATIONS的值为
      在这里插入图片描述
      则getStaticLocations()方法的返回值就是数组{"/","classpath:/META-INF/resources/","classpath:/resources/","classpath:/static/","classpath:/public/"}

  3. 经过1、2、3对addResourceHandlers()方法的分析，可以总结出静态资源的所有映射规则:

    • 所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找资源；
    • “/**” 访问当前项目的任何资源，都去（静态资源的文件夹）找映射
      • “classpath:/META-INF/resources/”,
      • “classpath:/resources/”,
      • “classpath:/static/”,
      • “classpath:/public/”
      • “/”：当前项目的根路径

2. 欢迎页的映射

在WebMvcAutoConfiguration类中有一个welcomePageHandlerMapping方法


@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(
		ResourceProperties resourceProperties) {
	return new WelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
			this.mvcProperties.getStaticPathPattern());
}
		
		
static final class WelcomePageHandlerMapping extends AbstractUrlHandlerMapping {
	private static final Log logger = LogFactory
			.getLog(WelcomePageHandlerMapping.class);

	private WelcomePageHandlerMapping(Resource welcomePage,
			String staticPathPattern) {
		//发现所有的index.html页面都被/**映射
		if (welcomePage != null && "/**".equals(staticPathPattern)) {
			logger.info("Adding welcome page: " + welcomePage);
			ParameterizableViewController controller = new ParameterizableViewController();
			controller.setViewName("forward:index.html");
			setRootHandler(controller);
			setOrder(0);
		}
	}

所以可以总结出：
欢迎页； 静态资源文件夹下的所有index.html页面；被"/**"映射；

3. SpringMvc自动配置原理

官方解释

1. Spring Mvc auto-configuration

SpringBoot自动帮我们配置好了Spring Mvc

以下是SpringMvc的自动配置：（WebMvcAutoConfiguration）

  • Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

    • 自动配置了ViewResolver（视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？））
    • ContentNegotiatingViewResolver：组合所有的视图解析器的；
    • 如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来；

  • Support for serving static resources, including support for WebJars (see below).静态资源文件夹路径,webjars

  • Static index.html support. 静态首页访问

  • Custom Favicon support (see below). favicon.ico

  • 自动注册了 of Converter, GenericConverter, Formatter beans.

    • Converter：转换器； public String hello(User user)：类型转换使用Converter
    • Formatter 格式化器； 2017.12.17===Date；
		@Bean
		@ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")//在文件中配置日期格式化的规则
		public Formatter<Date> dateFormatter() {
			return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
		}

​ 自己添加的格式化器转换器，我们只需要放在容器中即可

  • Support for HttpMessageConverters (see below).

    • HttpMessageConverter：SpringMVC用来转换Http请求和响应的；User—Json；

    • HttpMessageConverters 是从容器中确定；获取所有的HttpMessageConverter；

      自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean,@Component）

  • Automatic registration of MessageCodesResolver (see below).定义错误代码生成规则

  • Automatic use of a ConfigurableWebBindingInitializer bean (see below).

    我们可以配置一个ConfigurableWebBindingInitializer来替换默认的；（添加到容器）

    初始化WebDataBinder；
请求数据=====JavaBean；

org.springframework.boot.autoconfigure.web：web的所有自动场景；

If you want to keep Spring Boot MVC features, and you just want to add additional MVC configuration (interceptors, formatters, view controllers etc.) you can add your own @Configuration class of type WebMvcConfigurerAdapter, but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter or ExceptionHandlerExceptionResolver you can declare a WebMvcRegistrationsAdapter instance providing such components.

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

4. 扩展SpringMVC

    <mvc:view-controller path="/hello" view-name="success"/>
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean></bean>
        </mvc:interceptor>
    </mvc:interceptors>

编写一个配置类（@Configuration），是WebMvcConfigurerAdapter类型；不能标注@EnableWebMvc;

既保留了所有的自动配置，也能用我们扩展的配置；

//使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
//需要什么功能就重写什么方法
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        //浏览器发送 /atguigu 请求来到 success
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

​ 1）、WebMvcAutoConfiguration是SpringMVC的自动配置类

​ 2）、在做其他自动配置时会导入；@Import(EnableWebMvcConfiguration.class)

    @Configuration
	public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
      private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

	 //从容器中获取所有的WebMvcConfigurer
      @Autowired(required = false)
      public void setConfigurers(List<WebMvcConfigurer> configurers) {
          if (!CollectionUtils.isEmpty(configurers)) {
              this.configurers.addWebMvcConfigurers(configurers);
            	//一个参考实现；将所有的WebMvcConfigurer相关配置都来一起调用；  
            	@Override
             // public void addViewControllers(ViewControllerRegistry registry) {
              //    for (WebMvcConfigurer delegate : this.delegates) {
               //       delegate.addViewControllers(registry);
               //   }
              }
          }
	}

​ 3）、容器中所有的WebMvcConfigurer都会一起起作用；

​ 4）、我们的配置类也会被调用；

​ 效果：SpringMVC的自动配置和我们的扩展配置都会起作用；

5、如何修改SpringBoot的默认配置

模式：

  1. SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置的和自己默认的组合起来；

  2. 在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置

  3. 在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置

6. 嵌入式Servlet容器

SpringBoot默认使用Tomcat作为嵌入式的Servlet容器
在这里插入图片描述

1）使用嵌入式的Servlet容器，如何定制和修改默认的Servlet容器配置

  1. 使用配置文件的方式修改和Servlet有关的配置
    #修改端口号
server.port=8081
#修改项目访问根路径
server.context-path=/aaa
//设置服务器编码
server.tomcat.uri-encoding=UTF-8

//通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx
  2. 使用配置类修改Servlet容器的配置
    @Configuration
public class AppConfig {
    @Bean
    public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer() {
        return new EmbeddedServletContainerCustomizer() {
            @Override
            public void customize(ConfigurableEmbeddedServletContainer container) {
                container.setPort(8081);
            }
        };
    }

}
  3. 注册Servlet三大组件

  • 注册Servlet(使用ServletRegistrationBean)

    • 编写一个Servlet
          public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}
    • 将MyServlet注册到容器中
      @Configuration
public class AppConfig {
    @Bean
    //给容器中注册Servlet
    public ServletRegistrationBean myServlet() {
        return new ServletRegistrationBean(new MyServlet(), "/myServlet");
    }
}

  • 注册filter(使用FilterRegistrationBean)

    • 编写一个filter

          public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("myFilter.....");
    }

    @Override
    public void destroy() {

    }
}

    • 将MyFilter注册到容器中

      @Configuration
public class AppConfig {
    @Bean
    //给容器中注册Filter
    public FilterRegistrationBean myFilter() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new MyFilter());
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/myServlet","/hello"));
        return filterRegistrationBean;
    }
}

  • 注册listener(使用ServletListenerRegistrationBean)

    • 编写一个listener

      public class MyListener implements ServletContexListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("ContextListener......");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

    • 将MyListener注册到容器中

      @Configuration
public class AppConfig {
    @Bean
    //给容器中注册listener
    public ServletListenerRegistrationBean myListener(){
        return new ServletListenerRegistrationBean(new MyListener());
    }
}
  1. Spring Mvc帮我们自动配置的时候，自动注册了前端控制器DispatchServlet,和我们自己注册servlet的方式相同
    @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
	public ServletRegistrationBean dispatcherServletRegistration(
			DispatcherServlet dispatcherServlet) {
		ServletRegistrationBean registration = new ServletRegistrationBean(
				dispatcherServlet, this.serverProperties.getServletMapping());
		registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
		registration.setLoadOnStartup(
				this.webMvcProperties.getServlet().getLoadOnStartup());
		if (this.multipartConfig != null) {
			registration.setMultipartConfig(this.multipartConfig);
		}
		return registration;
	}

2）嵌入式Servlet自动配置原理

EmbeddedServletContainerAutoConfiguration类：嵌入式的Servlet容器自动配置

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
/**
*   @Import导入BeanPostProcessorsRegistrar，
*   BeanPostProcessorsRegistrar的作用：给容器中导入一些组件，
*   导入了EmbeddedServletContainerCustomizerBeanPostProcessor（后置处理器），
*   后置处理器：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作
*/
public class EmbeddedServletContainerAutoConfiguration {

//当前应用导入了哪个容器的依赖就创建哪个容器的工厂

	/**
	 * Nested configuration if Tomcat is being used.
	 */
	@Configuration
	//判断当前是否引入了tomcat依赖
	@ConditionalOnClass({ Servlet.class, Tomcat.class })
	//判断当前容器没有用户自己定义EmbeddedServletContainerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedTomcat {

		@Bean
		public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
			return new TomcatEmbeddedServletContainerFactory();
		}

	}
	
	/**
	 * Nested configuration if Jetty is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
			WebAppContext.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedJetty {

		@Bean
		public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
			return new JettyEmbeddedServletContainerFactory();
		}

	}

	/**
	 * Nested configuration if Undertow is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedUndertow {

		@Bean
		public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
			return new UndertowEmbeddedServletContainerFactory();
		}

	}
  1. EmbeddedServletContainerFactory:嵌入式servlet容器工厂
public interface EmbeddedServletContainerFactory {
    //获取嵌入式的Servlet容器
	EmbeddedServletContainer getEmbeddedServletContainer(
			ServletContextInitializer... initializers);

}

在这里插入图片描述

它的实现类有TomcatEmbeddedServletContainerFactory、JettyEmbeddedServletContainerFactory、UndertowEmbeddedServletContainerFactory

  1. EmbeddedServletContainer:嵌入式Servlet容器
    在这里插入图片描述

  2. 以TomcatEmbeddedServletContainerFactory为例进行分析

public class TomcatEmbeddedServletContainerFactory
		extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware {
	
	@Override
	public EmbeddedServletContainer getEmbeddedServletContainer(
			ServletContextInitializer... initializers) {
		//创建一个tomcat容器对象
		Tomcat tomcat = new Tomcat();
		File baseDir = (this.baseDirectory != null ? this.baseDirectory
				: createTempDir("tomcat"));
		
		//添加tomcat容器的基本配置
		tomcat.setBaseDir(baseDir.getAbsolutePath());
		Connector connector = new Connector(this.protocol);
		tomcat.getService().addConnector(connector);
		customizeConnector(connector);
		tomcat.setConnector(connector);
		tomcat.getHost().setAutoDeploy(false);
		configureEngine(tomcat.getEngine());
		for (Connector additionalConnector : this.additionalTomcatConnectors) {
			tomcat.getService().addConnector(additionalConnector);
		}
		prepareContext(tomcat.getHost(), initializers);
		
		//将配置好的tomcat传入，返回一个EmbeddedServletContainer，并启动tomcat服务器
		return getTomcatEmbeddedServletContainer(tomcat);
	}
  1. 我们对嵌入式Servlet容器的配置怎么生效

  • 通过EmbeddedServletContainerCustomizer：如我们向容器中添加我们自己的EmbeddedServletContainerCustomizer组件来更改servlet配置

    @Configuration
public class AppConfig {
    @Bean
    public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer() {
        return new EmbeddedServletContainerCustomizer() {
            @Override
            public void customize(ConfigurableEmbeddedServletContainer container) {
                container.setPort(8081);
            }
        };
    }

}

  • 通过配置文件的方式(实际上这种方式也是通过EmbeddedServletContainerCustomizer完成的)

    server:
    port: 8080
    • ServerProperties类是和配置文件绑定的
      @ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {

	private Integer port;

	
	private InetAddress address;

这里我们发现ServerProperties类实现了EmbeddedServletContainerCustomizer接口，所以实际上两种更改嵌入式Servlet容器配置的方式是一样的

  1. EmbeddedServletContainerCustomizer定制器帮我们修改Servlet容器配置的原理

在这里插入图片描述

而BeanPostProcessorsRegistrar给容器中添加了EmbeddedServletContainerCustomizerBeanPostProcessor
在这里插入图片描述

EmbeddedServletContainerCustomizerBeanPostProcessor类：

public class EmbeddedServletContainerCustomizerBeanPostProcessor
		implements BeanPostProcessor, BeanFactoryAware {
    //初始化之前
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		//如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
		if (bean instanceof ConfigurableEmbeddedServletContainer) {
			postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		return bean;
	}

    //获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
	private void postProcessBeforeInitialization(
			ConfigurableEmbeddedServletContainer bean) {
		for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
			customizer.customize(bean);
		}
	}

	private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
		if (this.customizers == null) {
			// Look up does not include the parent context
			this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
					this.beanFactory
					//从容器中获取所有这葛类型的组件：EmbeddedServletContainerCustomizer
                    //定制Servlet容器，给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
                    .getBeansOfType(EmbeddedServletContainerCustomizer.class,
									false, false)
							.values());
			Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
			this.customizers = Collections.unmodifiableList(this.customizers);
		}
		return this.customizers;
	}

}

所以根据以上源码配置，可总结出如下步骤：

1）、SpringBoot根据导入的依赖情况，给容器中添加相应的EmbeddedServletContaine>rFactory【TomcatEmbeddedServletContainerFactory】

2）、容器中某个组件要创建对象就会触发后置处理器；EmbeddedServletContainerCus>tomizerBeanPostProcessor；

只要是嵌入式的Servlet容器工厂，后置处理器就工作；

3）、后置处理器，从容器中获取所有的EmbeddedServletContainerCustomizer，>调用定制器的定制方法

7. 使用外置的Servlet容器

  1. 必须创建一个war项目
    在这里插入图片描述
  2. 创建好项目后，idea中默认不是标准的web应用结构，需自行创建webapp文件夹，以及web.xml文件

  • 创建webapp文件夹
    在这里插入图片描述

  • 创建web.xml文件
    在这里插入图片描述

    最后点击应用即可

  1. 需要在项目中配置我们自己的tomcat服务器
    在这里插入图片描述
未来可期☺
关注
专栏目录
五 Spring Boot web开发
凌枫ozo的博客
06-19 247
目录 五 Spring Boot web开发 5.1静态资源的访问 5.2 自动返回json格式数据 ​ 5.3 全局捕获异常 5.4 渲染Web页面 5.5 Freemarker的使用 第一步： 第二步： 第三步：创建.ftl模板文件 5.6 SpringBoot 使用jsp 五 web开发 5.1静态资源的访问 在我们开发Web应用的时候，需要引用大量的js、css...
springboot(五)_消息
limts的博客
05-30 405
文章目录一、基本概念二、消息通信的方式2.1 点对点式2.2 发布订阅式三、JMS与AMQP规范3.1 JMS(Java Message Service)3.2 AMQP3.3 对比3.4 框架支持3.4.1 spring支持3.4.2 springboot自动配置四、RabbitMQ4.1 简介4.2 核心概念4.3 关系图：4.4 Exchange类型:4.5 springboot自动配置： 方式：消息服务中间件 目的：提升系统异步通信、扩展解耦能力 一、基本概念 消息代理：消息者发送消息后，由消息代
SpringBoot学习总结——Web开发
驼君的小小博客园
10-10 808
一、Web开发 1.简介 使用SpringBoot开发Web应用的步骤： 创建SpringBoot应用，选择需要的starter 在配置文件中去指定必要的少量配置 编写业务代码 Web开发的自动配置类：WebMvcAutoConfiguration 2.静态资源的映射 静态资源的位置 查看WebMvcAutoConfiguration——>addResourceHandlers()——&...
SpringBoot——》WebMvcConfigurerAdapter详解
djp567的博客
06-10 830
原文：https://blog.csdn.net/weixin_43453386/article/details/83623242 一、WebMvcConfigurerAdapter是什么 Spring内部的一种配置方式 采用JavaBean的形式来代替传统的xml配置文件形式进行针对框架个性化定制 二、WebMvcConfigurerAdapter常用的方法 /** 解决跨域问题 **...
SpringBoot Web开发
mest的博客
04-12 2587
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言SpringBoot，就是一个javaweb的开发框架,作为当下热门的企业级开发框架，是每一个java后端学习者必要学习的技能；之前在小破站跟着狂神的课程学习，做了一篇大体学习笔记，给自己积累学习，温故 知新，文章中若出现错误，望指正。（课程链接及其相关文献将附在文末）一、S
02. SpringBoot整合Web开发
03-20
SpringBoot整合Web开发是现代Java应用开发中的常见实践，它极大地简化了配置和启动过程，使得开发者能够快速构建可部署的Web服务。本教程将深入探讨如何利用SpringBoot与Web技术进行集成，创建高效且易于维护的应用...
第5章 SpringBoot实现Web开发.ppt
03-08
SpringBoot实现Web开发
基于springboot的web开发简单笔记
08-20
基于springboot的web开发简单笔记
Springboot+VUE Web开发实践.pdf
11-23
SpringBoot+Vue 开发实践是现代Web应用开发中一种高效且流行的方式，它结合了Java后端的强大功能和Vue.js前端的灵活性。本实践指南旨在为初学者提供一个清晰的路径，了解如何利用这两个框架构建现代化的Web应用程序...
springboot的web开发.rar
09-05
在本文中，我们将深入探讨如何使用SpringBoot进行Web开发，并结合Redis和RabbitMQ来构建高效、可扩展的应用程序。SpringBoot是Spring框架的一个模块，它简化了初始设置和配置，使得开发人员能够快速地搭建和运行应用...
SpringBoot 太强了，这些优势你需要了解
最新发布
Why_does_it_work的博客
06-26 2192
例如，如果我们想要使用Spring Data JPA来访问数据库，只需要添加spring-boot-starter-data-jpa依赖，Spring Boot就会自动配置相关的依赖项，并且提供一些默认的配置选项。通过使用这些测试工具，我们可以更快速地编写和运行测试用例，以确保应用程序的质量和稳定性。通过使用Spring Boot提供的Web开发框架和技术，我们可以更快速地创建和部署Web应用程序，并且可以轻松地实现各种类型的Web功能，例如RESTful API、HTML页面渲染、实时数据传输等。
springboot项目中出现Whitelabel Error Page
u012778718的博客
06-04 2845
访问springboot项目显示结果 出现白页的原因： 请求进入org.springframework.web.servlet.DispatcherServlet#doDispatch方法中： #通过请求查询可供处理的handler mappedHandler = getHandler(processedRequest); 默认注册了4个handlerMapping，分别是： org.springframework.web.servlet.mvc.method.annotation.RequestM
springboot中配置addResourceHandler和addResourceLocations，使得可以从磁盘中读取图片、视频、音频等...
weixin_33734785的博客
01-11 1379
2019独角兽企业重金招聘Python工程师标准>>> ...
springboot中配置addResourceHandler读取本地文件
冲冲冲的博客
12-07 1万+
springboot中配置addResourceHandler和addResourceLocations，可以使得可以从磁盘中读取图片、视频、音频等 例如我们要读取该文件夹下的文件 WebMvcConfig的代码 //以windows系统下为例 //对静态资源的配置 @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { // addResourceHandler("/smallapple/**")，
ResourceHandlerRegistry的addResourceLocations方法设置linux路径，访问项目外图片，亲测可行
热门推荐
tqs314的博客
03-08 3万+
场景：部署的Springboot项目，打成jar包，需要通过url直接访问jar外部路径的资源，本人的Springboot为2.1.11.RELEASE。 一、配置WebMvcConfigurer，设置url访问静态资源映射 @Configuration public class WebMvcConfig implements WebMvcConfigurer { /** ...
SpringBoot第十六天 - Web异常处理
adas5f1a51的博客
06-09 1317
SpringBoot - Web异常处理 了解SpringBoot进行Web开发时的异常处理机制。 1. 异常处理机制 1.1 默认异常处理 默认情况下，SpringBoot提供/error映射处理所有的异常， 并在Servlet容器中注册为全局错误处理页面。 对于浏览器客户端，SpringBoot响应一个"Whitelabel"错误视图， 以HTML格式展示，其中包含错误，HTTP状态码和异常的详细信息，看起来像这样： Whitelabel Error Page This application has
Spring5 mvc篇
轻松的小希
12-29 4005
目录第八章 WebMVC8.1、SpringMVC的概述8.2、SpringMVC的原理8.3、SpringMVC的入门8.3.1、项目创建8.3.2、环境准备8.4、SpringMVC的控制器对象8.5、SpringMVC的请求映射8.5.1、位置8.5.2、属性8.5.2.1、value8.5.2.2、method8.5.2.3、params8.5.2.4、headers8.5.2.5、consumes8.5.2.6、produces8.6、SpringMVC的控制器方法8.6.1、控制器方法的参数8.
SpringBoot系列(5)---SpringBoot-Web和SpringBoot基础
搞事情的博客
07-10 2万+
笔者所参考的书籍是SpringBoot实战，其理论性说得不多，内容上也不是非常详细。但是说到的内容也足够平时使用了，以下就是我根据SpringBoot实战学到的一些东西，希望分享给大家，并成为我以后回忆这门技术的笔记。 开始SpringBoot之前，我建议大家还是从Spring官网上按照自己的需要下载一个基础包，https://start.spring.io 。在这个笔记当中只需要用到web 和
28.SpringBoot学习笔记--WebJars与静态资源映射规则
java阳旭的博客
06-12 349
WebJars与静态资源映射规则
SpringBoot入门与Web开发详解
本文主要探讨了Web开发中的SpringBoot框架，以及如何使用它来构建应用程序。SpringBoot是Spring技术栈的一部分，设计目标是简化Spring应用的初始搭建以及开发过程，提供了一个一站式的J2EE开发解决方案。它将常见的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值