spring注解驱动(servlet):注解的web,Shared libraries / runtimes pluggability,整合SpringMVC,异步请求处理

最新推荐文章于 2022-12-20 16:42:11 发布
最新推荐文章于 2022-12-20 16:42:11 发布
阅读量226 收藏 1
点赞数
分类专栏： Spring(+注解开发)&&SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43416157/article/details/109061657
版权

快速启动一个注解的web

之前呀,我们自己写一个servletfilter listener,如果想使用起来,就得在web,xml里面
配置好,现在我们不需要在web.xml里面配置了,就是使用一个注解就可以了
但是支持注解的是servlet3.0以上才支持注解,servlet3.0的规范属于JSR315系列的,
如果想看API就去https://www.jcp.org/en/home/index这里搜索servlet3.0进行下载
对应的文档,还有就是只有Tomcat7.0以上才支持servlet3.0
现在我们快熟创建一个动态web工程

页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<a href="HelloWorld">HelloWorld</a>
</body>
</html>

java代码
按照之前,我们应该在web.xml里面进行配置

	<servlet>
		<servlet-name>HelloWorld</servlet-name>
		<servlet-class>jane.HelloWorld</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>HelloWorld</servlet-name>
		<url-pattern>/HelloWorld</url-pattern>
	</servlet-mapping>

而现在我们不需要在web.xml里面配置了,而是直接加@WebServlet("/HelloWorld")注解

package jane;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/HelloWorld")
public class HelloWorld extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	protected void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException
	{
		response.getWriter().write("Hello World");
	}

}

Shared libraries / runtimes pluggability

Shared libraries (共享库)/ runtimes pluggability(运行时插件能力)
根据里面的解释

An instance of the ServletContainerInitializer is looked up via the jar 
services API by the container at container / application startup time. 
The framework providing an implementation of the 
ServletContainerInitializer MUST bundle in the META-INF/services directory 
of the jar file a file called javax.servlet.ServletContainerInitializer, 
as per the jar services API, that points to the implementation class 
of the ServletContainerInitializer.

就是在Servlet容器启动的时候会扫描当前应用的每一个jar包里面的
ServletContainerInitializer的实现类,这个框架提供了一个
ServletContainerInitializer实现类的方法,就是必须绑定在
META-INF/services目录下一个叫javax.servlet.ServletContainerInitializer
的文件,文件里面的内容就是指向ServletContainerInitializer实现类的全类名

我们自己快速开始尝试吧

那这里为了方便就不写jar包了,直接在当前项目的类路径下写
META-INF/servicesjavax.servlet.ServletContainerInitializer文件
在里面写上ServletContainerInitializer实现类的全类名

写好那个文件路径,写好对应的值,我这里是jane.servlet.MyServletContainerInitializer
编写对应的实现类

package jane.servlet;

import java.util.EnumSet;
import java.util.Set;

import javax.servlet.DispatcherType;
import javax.servlet.FilterRegistration;
import javax.servlet.ServletContainerInitializer;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration.Dynamic;
import javax.servlet.annotation.HandlesTypes;
/*
 * 容器启动的时候会将@HandlesTypes指定的这个类型下面的子类,实现类,子接口等等传递过来
 * 但是自身是不会传递过来的,
 */
@HandlesTypes(value = {})
public class MyServletContainerInitializer implements ServletContainerInitializer
{
	/*
	 * onStartup()方法就是应用启动的时候运行
	 * Set<Class<?>> arg0:这个就是上面@HandlesTypes注解传入的感兴趣的类型,
	 * 					  我们可以根据传入的类型创建对象
	 * 
	 * ServletContext arg1:代表当前web应用的ServletContext,一个web应用对应一个ServletContext
	 * 
	 * 使用ServletContext来注册Web组件(Servlet,Filter,Listener)
	 * 之前我们注册web组件的时候,都是可以在web.xml里面写,但是现在没有了web.xml
	 * 如果是我们自己写的组件想加入容器中加上@WebServlet之类的注解就行
	 * 但是如果我们想加入第三方的jar包的组件,我们就没有办法再加注解了,
	 * 所以这里使用ServletContext来注册Web组件
	 * 
	 * 可以给容器添加组件的方法大概有两种
	 * (必须在项目启动的时候才能给容器添加组件,启动完成后不能再添加组件):
	 * 1.首先是这里写的这个方法,使用ServletContainerInitializer
	 * 2.就是ServletContextListener里面的contextInitialized可以得到
	 * 	ServletContext进行添加组件
	 */
	@Override
	public void onStartup(Set<Class<?>> arg0, ServletContext servletContext) throws ServletException
	{
		//注册组件
		//注册Servlet
		Dynamic addServlet = servletContext.addServlet("userServlet", new UserServlet());
		//配置Servlet的映射信息
		addServlet.addMapping("/user");
		
		//注册Listener
		servletContext.addListener(UserListener.class);
		
		//注册Filter
		FilterRegistration.Dynamic addFilter = servletContext.addFilter("userfilter", UserFilter.class);
		/*
		 * 配置Filter的映射信息
		 * dispatcherTypes:是需要拦截什么类型的请求
		 *      FORWARD,
			    INCLUDE,
			    REQUEST,
			    ASYNC,
			    ERROR
		 */
		
		addFilter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*");
	}

}

编写对应的三大组件

package jane.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class UserServlet extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
	{
		resp.getWriter().write("UserServlet...");
	}
}


package jane.servlet;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
//监听项目的启动和停止
public class UserListener implements ServletContextListener
{
	@Override
	public void contextInitialized(ServletContextEvent sce)
	{
		System.out.println("UserListener...contextInitialized");
	}
	@Override
	public void contextDestroyed(ServletContextEvent sce)
	{
		System.out.println("UserListener...contextDestroyed");
	}
}


package jane.servlet;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class UserFilter implements Filter
{

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException
	{
		System.out.println("UserFilter...doFilter");
		chain.doFilter(request, response);
	}
}

整合SpringMVC

原理

整合这方面在官方文档里面写得挺详细的,具体可以参考官方文档
官网
对应的框架
对应文档
例子
我们利用上面刚刚说的知识利用起来整合
在Maven Dependencies的spring-web的jar包里面存在这样的资源
在这里插入图片描述

按照上面说的,web容器在启动的时候,会扫描每个jar包下的
META-INF/servicesjavax.servlet.ServletContainerInitializer文件,
根据里面的值,加载SpringServletContainerInitializer的实现类

进入SpringServletContainerInitializer查看一番
可以看到spring一启动就会加载感兴趣类型WebApplicationInitializer接口下的
所有的组件,并且如果它接口下的组件不是接口,不是抽象类,那么就会为它们创建对象

在这里插入图片描述

进入WebApplicationInitializer接口,
发现它有三个抽象类,那么我们一个一个地查看它们干了什么

在这里插入图片描述

进入AbstractContextLoaderInitializer
可以发现这个抽象类创建了一个根容器,而且加入一个ContextLoaderListener

在这里插入图片描述

进入AbstractDispatcherServletInitializer,由名知义,这是DispatherServlet初始化器
首先看出它是调用父类的onStartup()方法,然后调用registerDispatcherServlet()
在里面创建了一个web的IOC容器,还创建了dispatcherServlet
然后将dispatcherServlet添加到servletContext中,然后进行配置
registration.addMapping(getServletMappings());中的getServletMappings()
方法由我们来进行实现

在这里插入图片描述

进入AbstractAnnotationConfigDispatcherServletInitializer(注解配置DispatcherServlet初始化器)
里面有两个方法
	创建根容器:重写createRootApplicationContext,是根据实现的getRootConfigClasses();方法获得
	创建web的IOC容器:重写createServletApplicationContext,根据实现的getServletConfigClasses();方法获得

这两个容器在官方文档里面有图示,各自执行各自的功能

在这里插入图片描述
在这里插入图片描述

实操

pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>jane</groupId>
	<artifactId>AnnotationSpringMVC</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.11.RELEASE</version>
		</dependency>
		
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>3.0-alpha-1</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>

	<!-- pom.xml文件因为你是web项目但是没有web.xml文件而报错
	所以我们加了这个插件设置<failOnMissingWebXml>false</failOnMissingWebXml>
	让它没有这个文件也不会报错 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.4</version>
				<configuration>
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>
		</plugins>
	</build>
	
</project>

继承AbstractAnnotationConfigDispatcherServletInitializer

package jane;

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

import jane.config.RootConfig;
import jane.config.WebAppConfig;

//这个类呢就是web容器启动的时候创建对象,里面的方法能初始化容器的前端控制器
public class MyAnnotationConfigDispatcherServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer
{
	//这个是获取根容器的配置类,相当于之前的spring配置文件,这里作为父容器
	@Override
	protected Class<?>[] getRootConfigClasses()
	{
		return new Class<?>[] {RootConfig.class};
	}
	//这里是获取web容器的配置类,就是之前的springMVC的配置文件,这里作为子容器
	@Override
	protected Class<?>[] getServletConfigClasses()
	{
		return new Class<?>[] {WebAppConfig.class};
	}
	//获取DispatherServlet的映射信息
	//这里写"/"就可以了,这是拦截所有请求,包括静态资源*.png,*.js,*.html,但是不包括*.jsp
	//而"/*",也是拦截所有请求,连*.jsp页面都会进行拦截,jsp页面是Tomcat的jsp引擎解析的
	@Override
	protected String[] getServletMappings()
	{
		return new String[] {"/"};
	}

}


配置类

package jane.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
//Spring不扫描Controller,是个父容器
@ComponentScan(value = ("jane"),excludeFilters = 
	{
			@Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
	}
		)
public class RootConfig
{

}


package jane.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
//SpringMVC只扫描Controller,是个子容器
@ComponentScan(value = ("jane"),includeFilters = 
	{
			@Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
	},useDefaultFilters = false
		)
public class WebAppConfig
{

}


相关组件

package jane.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import jane.service.HelloService;

@Controller
public class HelloController
{
	@Autowired
	HelloService helloService;
	
	@ResponseBody
	@RequestMapping("/hello")
	public String hello()
	{
		String sayHello = helloService.sayHello("good boy");
		return sayHello;
	}
}


package jane.service;

import org.springframework.stereotype.Service;

@Service
public class HelloService
{
	public String sayHello(String name)
	{
		return "Hello"+name;
	}
}

更多的配置

按照之前,我们还有很多的配置配置在springMVC的配置文件中,但是现在我们如何配置呢?

官方文档里面的MVC config有说
官方文档

首先我们得在配置类里面写上@EnableWebMvc,开启SpringMVC自定义配置
相当于配置文件里面的<mvc:annotation-driven/>
然后In Java config implement WebMvcConfigurer interface:
就是在配置类里面实现WebMvcConfigurer 接口
这个接口有很多的抽象方法来实现上面的需求
但是因为实现WebMvcConfigurer接口的话需要重写所有方法,为了想只重写想要得方法
所以就继承它的实现类WebMvcConfigurerAdapter,这个实现类什么都没写
我们想实现哪个方法就重写哪个方法

package jane.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import jane.controller.MyInterceptor;
//SpringMVC只扫描Controller,是个子容器
@ComponentScan(value = ("jane"),includeFilters = 
	{
			@Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
	},useDefaultFilters = false
		)
@EnableWebMvc
public class WebAppConfig extends WebMvcConfigurerAdapter
{
	//我们来写之前在配置文件里面经常写的几个配置
	//视图解析器
	@Override
	public void configureViewResolvers(ViewResolverRegistry registry)
	{
		registry.jsp("/WEB-INF/view/", ".jsp");
	}
	//静态资源访问
	@Override
	public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)
	{
		//相当于之前配置的<mvc:default-servlet-handler/>
		configurer.enable();
	}
	//拦截器
	@Override
	public void addInterceptors(InterceptorRegistry registry)
	{
		//"/**"拦截任意多重路径的请求
		registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
	}
}

异步请求处理

对于客服端的请求,服务器里面都有一个主线程池里面的创建好的线程进行响应工作
如果一个客户端的请求需要处理的时间很长,那么这个客户的请求就会一直占用着这个主线程
但是线程池里面的线程是有限的,如果还有很多的请求来到服务器,但是主线程池已经
没有空闲的线程来处理这些请求了,就会造成无法响应之类的
servlet3.0就可以开启异步请求
就是客户端向服务器请求的时候,如果这个请求处理的时间很长,那么就可以
开启一个子线程来处理它,子线程处理完后将结果响应回去,
而主线程会很快空闲下来回到线程池里面提供下一个请求来使用

web中如何实现

package jane.servlet;

import java.io.IOException;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(value = "/Async",asyncSupported = true)
public class HelloAsyncServlet extends HttpServlet
{
	/*
	 * 1.首先让它支持异步处理asyncSupported = true
	 * 2.开启异步模式
	 */
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
	{
		System.out.println("主线程开始"+Thread.currentThread());
		
		AsyncContext startAsync = req.startAsync();
		startAsync.start(new Runnable()
		{
			@Override
			public void run()
			{
				try
				{
					System.out.println("子线程开始"+Thread.currentThread());
					Thread.sleep(2000);
					
					
					//然后想响应出去
					//获取到异步上下文
					AsyncContext asyncContext = req.getAsyncContext();
					//获取响应
					ServletResponse response = asyncContext.getResponse();
					response.getWriter().write("Hello World Asunc");
					
					//这个说明异步处理调用完毕
					startAsync.complete();
					System.out.println("子线程结束"+Thread.currentThread());
				} catch (Exception e)
				{
					System.out.println("异常");
					e.printStackTrace();
				}
			}
		});
		System.out.println("主线程结束"+Thread.currentThread());
	}
}

SpringMVC中如何实现

其实官方文档也写得很详细:文档

package jane.controller;

import java.util.concurrent.Callable;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.async.DeferredResult;

@Controller
public class AsyncController
{
/*
下面代码的结果:
preHandle
preHandle
postHandle
afterCompletion

官网这样说流程:
Callable processing:

Controller returns a Callable.
控制器返回的是Callable,而不是之前的url拼接或者json对象之类的

Spring MVC calls request.startAsync() and submits the Callable 
to a TaskExecutor for processing in a separate thread.
springmvc会开始异步请求处理,并且将Callable对象提交到TaskExecutor(任务执行器)
里面使用的是一个隔离的线程执行它

Meanwhile the DispatcherServlet and all Filter’s exit the Servlet 
container thread but the response remains open.
DispatcherServlet和所有的Filter退出容器线程,但是response保持打开状态

Eventually the Callable produces a result and Spring MVC dispatches 
the request back to the Servlet container to complete processing.
Callable处理返回结果,并且SpringMVC将请求重新派发给容器去完成这个处理

The DispatcherServlet is invoked again and processing resumes with the 
asynchronously produced return value from the Callable.
DispatcherServlet再次执行,根据Callable的返回值SpringMVC继续进行视图渲染等等

分析结果:
1.接收到请求:http://localhost:8080/AnnotationSpringMVC/async
2.preHandle
3.主线程开始
4.主线程结束
5.DispatcherServlet和所有的Filter退出容器线程
6.Callable执行
7.开启子线程
8.子线程结束
9.重新接收到请求:http://localhost:8080/AnnotationSpringMVC/async
10.preHandle
11.Callable的之前的返回值就是目标方法的返回值
12.postHandle
13.afterCompletion
14.将页面显示,页面需要的Callable的值
*/
	@ResponseBody
	@RequestMapping("/async")
	public Callable<String> async()
	{
		Callable<String> callable = new Callable<String>()
		{

			@Override
			public String call() throws Exception
			{
				return "public Callable<String> async()";
			}
		};
		return callable;
	}
	@ResponseBody
	@RequestMapping("/DeferredResult")
	public DeferredResult<Object> Getname()
	{
		//第一个参数代表留给其他线程多长时间来处理,过了这个时间就会后面的报错
		DeferredResult<Object> deferredResult = new DeferredResult<Object>((long)3000, "没线程处理/失败");
		//一般是将这个deferredResult保存下来,
		//然后等待其他的进程来处理,来处理这个的可以自己手动调用,
		//或者有监听器自动调用,当发现有线程调用了deferredResult.setResult(order);方法
		//代表处理完成了,就会在页面显示对应的结果
		
		/*
		 * 下面程序执行的结果
		 *  preHandle
			preHandle
			postHandle
			afterCompletion
		 */
		new Thread(new Runnable()
		{
			@Override
			public void run()
			{
				try
				{
					Thread.currentThread().sleep(2000);
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
				deferredResult.setResult("child over");
			}
		}).start();
		return deferredResult;
		
	}
}
ReflectMirroring
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
解决启动MongoDB错误：error while loading shared libraries: libstdc++.so.6:cannot open shared object file:
12-16
error while loading shared libraries: libstdc++.so.6: cannot open shared object file: No such file or directory [root@SnsWeb ~]# /usr/local/mongodb/bin/mongod --dbpath=/usr/local/mongodb/data --log...
spring源码分析(十)——Servlet容器注册组件
青春季风暴
11-23 172
1、Servlet容器启动会扫描，当前应用里面每一个jar包的 ServletContainerInitializer的实现 2、提供ServletContainerInitializer的实现类； 必须绑定在，META-INF/services/javax.servlet.ServletContainerInitializer 文件的内容就是ServletContainerI...
the Servlet Specification 之 annotations 和 pluggability
luccs624061082的专栏
08-09 796
annotations 和 pluggability  8.2  Pluggability（可插拔性）
SpringMVC的异步
梁老师教你编程序
12-20 2477
注意：在Controller中使用时，一定要注意做好接口的线程池隔离，让慢的接口使用固定数量的线程池， 否则从tomcat减少的线程会转移到应用里，导致拥塞，在部分接口下游异常的情况的情况下，会出现影响正常接口的服务.所以，需要注意的一个错误用法是，如果a方法调用它同类中的标注@Async的b方法，是不会异步执行的，因为从a方法进入调用的都是该类对象本身，不会进入代理类。1，@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为。
Spring 笔记（一）
jurenzhouqi的博客
09-04 109
Spring 笔记（一） Spring的简介和特征 简单来说，Spring是一个分层的JavaSE/EE full-stack（一站式）轻量级开源框架。 Spring的特征 控制反转（IOC） 依赖注入（Dependency Injection） AOP 可插拔性（Pluggability） 容器（container） 轻量级（li...
Spring 注解开发学习笔记（二）—— Servlet3.0
q42368773的博客
04-12 206
新的servlet3.0规范，定义了很多web注解，web工程可以不需要web.xml文件了。首先我们来创建一个没有web.xml的maven工程 <!-- 原生web程序，没有集成spring，所以是war包 --> <packaging>war</packaging> <!-- 添加servlet依赖 --> &l...
phpmyadmin安装时提示：Warning: require_once(./libraries/common.inc.php)错误解决办法
01-20
安装好PHPmyAdmin后，在IE里访问时会出现下面的这种错误： Warning: require_once(./libraries/common.inc.php) [function.require-once]: failed to open stream: No such file or directory in X:...
error while loading shared libraries xx.so处理方法
01-10
tmux: error while loading shared libraries: libevent-1.4.so.2: cannot open shared object file: No such file or directory 原因一般有两个, 一个是操作系统里确实没有包含该共享库(lib*.so.*文件)或者共享库...
【JavaWEB/表单提交/Tomcat】报404，显示“请求资源[.../Servlet]不可用问题
热门推荐
qq_44699928的博客
05-01 3万+
【JavaWEB/表单提交/Tomcat】报404，显示“请求资源[…/Servlet]不可用问题 废话不多说，直接上问题截图，我用的工具是eclipse。 如果你在学习web开发的过程中，尤其是在写表单提交类程序过程中出现了这个错误那么，这篇文章可以保证完美解决它。 我是用的servlet名字叫LoginServlet。一下内容完全围绕它展开、 一下是我遇到这个问题的排查步骤。请大家跟我一起一一检查。 1、首先检查代码，是否是报错的/爆红的，这里我不截图了。大家自行检查。 2、点开WEB-INF，点开we
ssm框架整合入门系列——配置SpringMVC dispatcherServlet-servlet.xml
练涛
10-16 5102
配置SpringMVC dispatcherServlet-servlet.xml 在ssm-crud项目中 SpringMVC的配置主要是在dispatcherServlet-servlet.xml文件 在这之前，先修改beans的头信息，否则按alt+/ 快捷键没有提示，并且添加context:component-scan还报错:context:component-scan is not b...
Tomcat8.x web.xml监听器的配置的解析->监听器的实例化->监听器的调用
~~简~~
08-06 2151
web.xml监听器的配置的解析->监听器的实例化->监听器的调用 // web.xml监听器的配置的解析、监听器的实例化、监听器的调用 org.apache.catalina.core.StandardContext{ protected synchronized void startInternal() throws LifecycleException {
Servlet在web.xml中的注册(配置)（Servlet3.0以上版本可以用注解方法）
捕影世界
10-20 3429
web.xml中的：       ,,, 1，这四个都是注册一个servlet组件必须的四个节点             这个是我们要注册servlet的名字,一般跟Servlet类名有关             这个就是指向我们要注册的servlet 的类地址, 要带包路径 以上两个包在一个servlet 节点之下. 2， 是用来配置我们注册的组件的访问路径,里面包括两个
SpringMVC 如何实现异步处理
weixin_42225963的博客
07-16 536
SpringMVC 如何实现异步处理
Tomcat源码分析（四）：ServletContext应用启动之核心组件初始化
源码之下，了无秘密
01-16 5146
概述
tomcat触发ServletContext初始化监听事件的源码(原创)
weixin_30674525的博客
10-27 132
tomcat 8.0.36 知识点： 动态监听器的好处可以根据环境条件进行选择性添加。 静态监听器有七类。 ServletContextAttributeListener ServletRequestListener ServletRequestAttributeListener HttpSessionIdListener HttpSessionAttributeLis...
[持续交付实践] pipeline使用：Shared Libraries
weixin_30861797的博客
11-09 353
[持续交付实践] pipeline使用：Shared Libraries 前言 随着pipeline交付流水线在团队中的推广，使用pipeline脚本的job也迅速增加。虽然我们已经基于公司的技术栈特点做了一个尽可能通用的pipeline脚本样例，让搭建者只需要修改几个赋值参数就可以在自己的项目中应用，初衷是希望所有人能理解pipeline中...
SpringBoot：过滤器：Servlet的注解原生Servlet实战（3）
q736317048的博客
11-29 95
javaweb的使用doPost和doGet方法使用Servlet3.0替代更轻量级 @WebServlet(name = "userServlet",urlPatterns = "/api/v1/test/customs")//一定要以/开头 public class UserServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse r..
WEB注解开发—Servlet3.0与SpringMVC整合与分析
huxiutao的博客
01-23 2174
以前写WEB的三大组件（servlet、filter、listener），都需要在web.xml中注册，包括DispatcherServlet等。而自Servlet3.0以后，就提供了相应的注解方式完成各个组件的注册与添加，包括运行时的可插拔功能。本文首先分析一下Servlet3.0的开发事项，然后再分析Servlet3.0与SpringMVC的整合。 一、Servlet3.0 （Servlet...
python: error while loading shared libraries: /root/.tros/1.5.6/Linux/lib/third_party/libz.so.1: file too short
最新发布
11-28
这个错误提示表明你的Python程序在加载共享库时遇到了问题，因为共享库文件太短了。这可能是由于文件损坏或编译错误导致的。为了解决这个问题，你可以尝试以下几个步骤： 1.检查文件是否存在并且完整。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ReflectMirroring

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值