精华内容
下载资源
问答
  • 本篇文章主要介绍了Servlet3.0学习总结之基于Servlet3.0的文件上传实例,具有一定的参考价值,有兴趣的可以了解一下
  • 在spring 3.2 及以后版本中增加了对请求的异步处理,这篇文章主要介绍了Spring Boot实现异步请求(Servlet 3.0),感兴趣的小伙伴们可以参考一下。
  • servlet 3.0,jar包综合;用于javaEE servlet 3.0 开发使用。目前下载量很多,良心资源。系统默认涨到了50积分,无奈手动调回来
  • Servlet3.0参考手册

    2018-03-14 09:06:38
    servlet3.0使用手册,这里面有详细的api参考,使用很方便
  • 使用maven创建web项目使用servlet3.0工具包 默认编辑器下载的servlet为2.3 使用此工具将变为3.0 不再需要每次手动修改
  • Servlet3.0规范是JavaEE6.0规范中的子规范。其要求运行环境最多是JDK6.0、Tomcat7.0。而之前学习的是Servlet2.5版本规范,其是JavaEE5.0规范,其要求运行环境最多是JDK5.0、Tomcat5.0。
  • servlet3.0.jar下载

    2018-01-08 19:53:55
    servlet3.0jar下载,非常好用的控制器工具类包,servlet3.0jar下载,非常好用的控制器工具类包,
  • 主要介绍了IDEA中HTML通过servlet3.0注解名提交表单到servlet类找不到页面的问题,本文通过场景描述及问题解析,给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • Servlet 3.0

    2012-05-04 09:45:53
    Servlet3.0的jar文件,可以下载直接加入到CLASS_Path环境变量,若用IDE则直接放入到WEB-INF/lib目录下,即可。
  • 主要介绍了详解Servlet 3.0/3.1 中的异步处理,实例分析了servlet 3.0异步处理的技巧,非常具有实用价值,需要的朋友可以参考下
  • Servlet3.0使用注解标注过滤器 Servlet3.0使用注解标注过滤器
  • Servlet3.0

    2012-08-01 11:17:25
    Servlet3.0新特性解析_02_Servlet3.0的异步支持与反向Ajax深入详解Servlet3.0新特性解析_02_Servlet3.0的异步支持与反向Ajax深入详解
  • 本篇文章主要介绍了SpringMVC + servlet3.0 文件上传的配置和实现代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • 官方Servlet 3.0 - Apache Tomcat 7.0.61文档 打包为zip 首页index.htm ,直接浏览即可
  • Servlet 3.0介绍

    2020-12-27 09:57:43
    Servlet 3.0 介绍

    注意:Servlet3.0的项目一定要使用Tomcat7.0才能看到效果!!

    一、Servlet3.0概述

    Servlet 3.0 作为 Java EE 6 规范体系中一员,随着 Java EE 6 规范一起发布。该版本在前一版本(Servlet 2.5)的基础上提供了若干新特性用于简化 Web 应用的开发和部署。其中有几项特性的引入让开发者感到非常兴奋。

    1. 新增的注解支持:该版本新增了若干注解,用于简化 Servlet、过滤器(Filter)和监听器(Listener)的声明,这使得 web.xml 部署描述文件从该版本开始不再是必选的了。
    2. 异步处理支持:有了该特性,Servlet 线程不再需要一直阻塞,直到业务处理完毕才能再输出响应,最后才结束该 Servlet 线程。在接收到请求之后,Servlet 线程可以将耗时的操作委派给另一个线程来完成,自己在不生成响应的情况下返回至容器。针对业务处理较耗时的情况,这将大大减少服务器资源的占用,并且提高并发处理速度。
    3. 可插性支持:熟悉 Struts2 的开发者一定会对其通过插件的方式与包括 Spring 在内的各种常用框架的整合特性记忆犹新。将相应的插件封装成 JAR 包并放在类路径下,Struts2 运行时便能自动加载这些插件。现在 Servlet 3.0 提供了类似的特性,开发者可以通过插件的方式很方便的扩充已有 Web 应用的功能,而不需要修改原有的应用。

    二、新增的注解支持

    Servlet 3.0 的部署描述文件 web.xml 的顶层标签 <web-app> 有一个 metadata-complete 属性,该属性指定当前的部署描述文件是否是完全的。如果设置为 true,则容器在部署时将只依赖部署描述文件,忽略所有的注解(同时也会跳过 web-fragment.xml 的扫描,亦即禁用可插性支持);如果不配置该属性,或者将其设置为 false,则表示启用注解支持(和可插性支持)。

    @WebServlet

    @WebServlet 用于将一个类声明为 Servlet,该注解将会在部署时被容器处理,容器将根据具体的属性配置将相应的类部署为 Servlet。该注解具有下表给出的一些常用属性(以下所有属性均为可选属性,但是 vlaue 或者 urlPatterns 通常是必需的,且二者不能共存,如果同时指定,通常是忽略 value 的取值):

    属性名类型描述
    nameString指定 Servlet 的 name 属性,等价于 <servlet-name>。如果没有显式指定,则该 Servlet 的取值即为类的全限定名。
    valueString[]该属性等价于 urlPatterns 属性。两个属性不能同时使用。
    urlPatternsString[]指定一组 Servlet 的 URL 匹配模式。等价于 <url-pattern> 标签。
    loadOnStartupint指定 Servlet 的加载顺序,等价于 <load-on-startup> 标签。
    initParamsWebInitParam[]指定一组 Servlet 初始化参数,等价于 <init-param> 标签。
    asyncSupportedboolean声明 Servlet 是否支持异步操作模式,等价于 <async-supported> 标签。
    descriptionString该 Servlet 的描述信息,等价于 <description> 标签。
    displayNameString该 Servlet 的显示名,通常配合工具使用,等价于 <display-name> 标签。

    @WebInitParam

    该注解通常不单独使用,而是配合 @WebServlet 或者 @WebFilter 使用。它的作用是为 Servlet 或者过滤器指定初始化参数,这等价于 web.xml 中 <servlet> 和 <filter> 的 <init-param> 子标签。@WebInitParam 具有下表给出的一些常用属性:

    属性名类型是否可选描述
    nameString指定参数的名字,等价于 <param-name>。
    valueString指定参数的值,等价于 <param-value>。
    descriptionString关于参数的描述,等价于 <description>。

    @WebFilter

    @WebFilter 用于将一个类声明为过滤器,该注解将会在部署时被容器处理,容器将根据具体的属性配置将相应的类部署为过滤器。该注解具有下表给出的一些常用属性 ( 以下所有属性均为可选属性,但是 value、urlPatterns、servletNames 三者必需至少包含一个,且 value 和 urlPatterns 不能共存,如果同时指定,通常忽略 value 的取值 ):

    属性名类型描述
    filterNameString指定过滤器的 name 属性,等价于 <filter-name>
    valueString[]该属性等价于 urlPatterns 属性。但是两者不应该同时使用。
    urlPatternsString[]指定一组过滤器的 URL 匹配模式。等价于 <url-pattern> 标签。
    servletNamesString[]指定过滤器将应用于哪些 Servlet。取值是 @WebServlet 中的 name 属性的取值,或者是 web.xml 中 <servlet-name> 的取值。
    dispatcherTypesDispatcherType指定过滤器的转发模式。具体取值包括:
    ASYNC、ERROR、FORWARD、INCLUDE、REQUEST。
    initParamsWebInitParam[]指定一组过滤器初始化参数,等价于 <init-param> 标签。
    asyncSupportedboolean声明过滤器是否支持异步操作模式,等价于 <async-supported> 标签。
    descriptionString该过滤器的描述信息,等价于 <description> 标签。
    displayNameString该过滤器的显示名,通常配合工具使用,等价于 <display-name> 标签。

    @WebListener

    该注解用于将类声明为监听器,被 @WebListener 标注的类必须实现以下至少一个接口:

    • ServletContextListener
    • ServletContextAttributeListener
    • ServletRequestListener
    • ServletRequestAttributeListener
    • HttpSessionListener
    • HttpSessionAttributeListener
    属性名类型是否可选描述
    valueString该监听器的描述信息。

    @MultipartConfig

    该注解主要是为了辅助 Servlet 3.0 中 HttpServletRequest 提供的对上传文件的支持。该注解标注在 Servlet 上面,以表示该 Servlet 希望处理的请求的 MIME 类型是 multipart/form-data。另外,它还提供了若干属性用于简化对上传文件的处理。

    常用属性:

    属性名类型是否可选描述
    fileSizeThresholdint当数据量大于该值时,内容将被写入文件。
    locationString存放生成的文件地址。
    maxFileSizelong允许上传的文件最大值。默认值为 -1,表示没有限制。
    maxRequestSizelong针对该 multipart/form-data 请求的最大数量,默认值为 -1,表示没有限制。

    三、异步处理支持

    在Servlet 3.0 之前,一个普通 Servlet 的主要工作流程大致如下:

    Servlet ç主è¦å·¥ä½æµç¨

    其中黄色阶段通常是最耗时的,因为业务处理一般涉及数据库操作,还会受到网络等的影响,而在此过程中,Servlet 线程一直处于阻塞状态,直到业务处理完毕。在处理业务的过程中,Servlet 资源一直被占用而得不到释放,对于并发较大的应用,这有可能造成性能的瓶颈。对此,在以前通常是采用私有解决方案来提前结束 Servlet 线程,并及时释放资源。

    为解决这个问题,Servlet 3.0 就开始支持异步处理了,之前的 Servlet 处理流程可以调整为如下的过程:

    Servlet3.0 å¤çæµç¨

    首先,Servlet 接收到请求之后,可能首先需要对请求携带的数据进行一些预处理;接着,Servlet 线程将请求转交给一个异步线程来执行业务处理,线程本身返回至容器,此时 Servlet 还没有生成响应数据,异步线程处理完业务以后,可以直接生成响应数据(异步线程拥有 ServletRequest 和 ServletResponse 对象的引用),或者将请求继续转发给其它 Servlet。如此一来, Servlet 线程不再是一直处于阻塞状态以等待业务逻辑的处理,而是启动异步线程之后可以立即返回。

    启用异步处理

    异步处理特性可以应用于 Servlet 和过滤器两种组件。在默认情况下,Servlet 和过滤器并没有开启异步处理特性,因为异步处理的工作模式和普通工作模式在实现上有着本质的区别,因此如果希望使用该特性,则必须按照如下的方式启用:

    1、在 web.xml 文件中启动

    Servlet3.0 默认是没有 web.xml 文件的,但 Servlet3.0 也是支持 web.xml 文件的,较 Servlet之前的版本,Servlet 3.0 在 <servlet>和 <filter> 标签中增加了 <async-supported> 子标签,该标签默认是 false 。如果想启用异步支持,只需要置为 true 即可。例如:

    <!-- servlet -->
    <servlet> 
        <servlet-name>asynServlet</servlet-name> 
        <servlet-class>com.servlet.AsynServlet</servlet-class> 
        <async-supported>true</async-supported> 
    </servlet>
    <!-- Filter -->
    <filter>
    	<filter-name>asynFilter</filter-name>
    	<filter-class>com.filter.AsynFilter</filter-class>
    	<async-supported>true</async-supported>
    </filter>
    

    2、通过注解开启异步支持

    Servlet 3.0 提供的 @WebServlet 和 @WebFilter 进行 Servlet 或 Filter 配置的情况,这两个注解都提供了 asyncSupported 属性,默认该属性的取值为 false。如果想启用异步支持,只需要置为 true 即可。例如:

    @WebServlet(value="/asyn-servlet",asyncSupported=true)
    public class ServletAsyn extends HttpServlet {...}
    
    @WebFilter(value="/*",asyncSupported=true)
    public class FilterAsyn implements Filter {...}
    

    异步处理的代码实现方式

    Servlet 和 Filter 使用异步支持的实现方式是一模一样的操作。这里只以 Servlet 的实现方式为例。

    模拟注册发信息到邮件的简单的异步处理 Servlet 示例代码:

    package com.servlet;
    
    import java.io.IOException;
    
    import javax.servlet.AsyncContext;
    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(value="/asyn-servlet",asyncSupported=true)
    public class ServletAsyn extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) 
    			throws ServletException, IOException {
    		System.out.println("Servlet is start");
    		
    		//1.获得异步上下文对象
    		AsyncContext ac = request.startAsync();
    		//2.启动一个耗时的子线程
    		ThreadTask tt = new ThreadTask(ac);
    		//3.可设置异步超时对象,需在启动异步上下文对象前设置
    		/*
    		 * 设置超时后,在超时时间内子线程没有结束,主线程则会停止等待,继续往下执行
    		 */
    		ac.setTimeout(3000);
    		//4.开启异步上下文对象
    		ac.start(tt);
    		
    		//主线程结束向客户端发送消息
    		System.out.println("Servlet is end");
    		response.setContentType("text/html;charset=utf-8");
    		response.getWriter().append("信息已发送到邮箱");
    	}
    
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    
    }
    
    

    异步线程的执行类

    package com.servlet;
    
    import java.util.Date;
    
    import javax.servlet.AsyncContext;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpSession;
    
    public class ThreadTask implements Runnable{
    	private AsyncContext ac;  //定义一个异步上下文
    	
    	public ThreadTask(AsyncContext ac) {
    		super();
    		this.ac = ac;
    	}
    
    	@Override
    	public void run() {
    		/*
    		 * 服务端异步典型应用是注册时向邮箱发送验证码
    		 */
    		try {
    			//进行异步的一些处理
    			HttpServletRequest requst = (HttpServletRequest) ac.getRequest();
    			HttpSession session = requst.getSession();
    			System.out.println("asyn-task start" + new Date());
    			for(int i=5;i>0; i--) {
    				System.out.println(i);
    				Thread.sleep(1000);
    			}
    			//将结果放到session等方式
    			session.setAttribute("message", "This is the result of asyn");
    			System.out.println("asyn-task end" + new Date());
    			
    			//通知主线程已经处理完成
    			/* 
    			 * 除了使用 ac.complete() 方法通知主线程已经处理外
    			 * 还可以使用 ac.dispatch() 方法重定向到一个页面
    			 */
    			ac.dispatch("/show.jsp");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    }
    
    

    这里的 show.jsp 模拟为指定邮箱。show.jsp页面body标签内代码为:<p>邮箱内容:${message }</p>

    对异步处理过程的监听

    除此之外,Servlet 3.0 还为异步处理提供了一个监听器,使用 AsyncListener 接口表示。它可以监控如下四种事件:

    • 异步线程开始时,调用 AsyncListener 的 onStartAsync(AsyncEvent event) 方法;
    • 异步线程出错时,调用 AsyncListener 的 onError(AsyncEvent event) 方法;
    • 异步线程执行超时,则调用 AsyncListener 的 onTimeout(AsyncEvent event) 方法;
    • 异步执行完毕时,调用 AsyncListener 的 onComplete(AsyncEvent event) 方法。

    如果要注册一个 AsyncListener,只需将准备好的 AsyncListener 对象传递给 AsyncContext 对象的 addListener() 方法即可,如下所示:

    AsyncContext ac = request.startAsync();
    ac.addListener(new AsyncListener() {
    			@Override
    			public void onComplete(AsyncEvent arg0) throws IOException {
    				// TODO Auto-generated method stub
    			}
    
    			@Override
    			public void onError(AsyncEvent arg0) throws IOException {
    				// TODO Auto-generated method stub
    			}
    
    			@Override
    			public void onStartAsync(AsyncEvent arg0) throws IOException {
    				// TODO Auto-generated method stub
    			}
    
    			@Override
    			public void onTimeout(AsyncEvent arg0) throws IOException {
    				// TODO Auto-generated method stub
    			}
    			
    		});
    

    四、ServletContext 的性能增强

    ServletContext 对象的功能在新版本中也得到了增强。现在,该对象支持在运行时动态部署 Servlet、过滤器、监听器,以及为 Servlet 和过滤器增加 URL 映射等。以 Servlet 为例,过滤器与监听器与之类似。ServletContext 为动态配置 Servlet 增加了如下方法:

    • ServletRegistration.Dynamic addServlet(String servletName,Class<? extends Servlet> servletClass)
    • ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet)
    • ServletRegistration.Dynamic addServlet(String servletName, String className)
    • <T extends Servlet> T createServlet(Class<T> clazz)
    • ServletRegistration getServletRegistration(String servletName)
    • Map<String,? extends ServletRegistration> getServletRegistrations()

    其中前三个方法的作用是相同的,只是参数类型不同而已。

    通过 createServlet() 方法创建的 Servlet,通常需要做一些自定义的配置,然后使用 addServlet() 方法来将其动态注册为一个可以用于服务的 Servlet。两个 getServletRegistration() 方法主要用于动态为 Servlet 增加映射信息,这等价于在 web.xml( 抑或 web-fragment.xml) 中使用 <servlet-mapping> 标签为存在的 Servlet 增加映射信息。

    以上 ServletContext 新增的方法要么是在 ServletContextListener 的 contexInitialized 方法中调用,要么是在 ServletContainerInitializer 的 onStartup() 方法中调用。

    ServletContainerInitializer 也是 Servlet 3.0 新增的一个接口,容器在启动时使用 JAR 服务 API(JAR Service API) 来发现 ServletContainerInitializer 的实现类,并且容器将 WEB-INF/lib 目录下 JAR 包中的类都交给该类的 onStartup() 方法处理,我们通常需要在该实现类上使用 @HandlesTypes 注解来指定希望被处理的类,过滤掉不希望给 onStartup() 处理的类。

    五、HttpServletRequest 对文件上传的支持

    此前,对于处理上传文件的操作一直是让开发者头疼的问题,因为 Servlet 本身没有对此提供直接的支持,需要使用第三方框架来实现,而且使用起来也不够简单。如今这都成为了历史,Servlet 3.0 已经提供了这个功能,而且使用也非常简单。为此,HttpServletRequest 提供了两个方法用于从请求中解析出上传的文件:

    • Part getPart(String name)
    • Collection<Part> getParts()

    前者用于获取请求中给定 name 的文件,后者用于获取所有的文件。每一个文件用一个 javax.servlet.http.Part 对象来表示。该接口提供了处理文件的简易方法,比如 write()、delete() 等。至此,结合 HttpServletRequest 和 Part 来保存上传的文件变得非常简单,如下所示:

    Part photo = request.getPart("photo"); 
    photo.write("/tmp/photo.jpg"); 
    // 可以将两行代码简化为 request.getPart("photo").write("/tmp/photo.jpg") 一行。

    另外,开发者可以配合前面提到的 @MultipartConfig 注解来对上传操作进行一些自定义的配置,比如限制上传文件的大小,以及保存文件的路径等。

    需要注意的是,如果请求的 MIME 类型不是 multipart/form-data,则不能使用上面的两个方法,否则将抛异常。

    六、参考

    https://blog.csdn.net/qq_24598601/article/details/82824937

    展开全文
  • 本篇文章主要介绍了Servlet实现文件上传的方法,所谓文件上传就是将本地的文件发送到服务器中保存。有兴趣的可以了解一下。
  • Servlet3.0的出现是servlet史上最大的变革,其中的许多新特性大大的简化了web应用的开发,为广大劳苦的程序员减轻了压力,提高了web开发的效率。
  • servlet 3.0

    2015-08-26 08:54:52
    java web servlet 3.0.jar
  • springbootServlet3.0过滤器
  • servlet 3.0使用和原理

    2020-04-16 09:53:54
    servlet 3.0介绍手写Servlet 3.0异步ServletServletContainerInitializer介绍 手写Servlet 3.0 @WebServlet("/helloWorld") public class HelloWorldServlet extends HttpServlet { @Override protected void ...

    Servlet 3.0 起步

    Servlet 3.0新增了若干注解,用于简化Servlet、过滤器和监听器的声明,使得web.xml部署描述文件从该版本开始不再是必选的。
    好了,我们先开始体验一下Servlet 3.0的新特性吧,我们新建一个web3的maven项目,项目的目录结构如图:

    在POM文件中配置需要依赖的jar包,如图:

     <dependencies>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.0.1</version>
                <scope>provided</scope>
            </dependency>
    
            <dependency>
                <groupId>javax.servlet.jsp</groupId>
                <artifactId>jsp-api</artifactId>
                <version>2.2</version>
            </dependency>
        </dependencies>
    

    编写我们的第一个servlet程序HelloWorldServlet,重写HttpServlet的doGet 和 doPost方法,并在HelloServlet类上添加@WebServlet 注解。

    /**
     * 注解版Servlet 3.0
     */
    @WebServlet("/hello")
    public class HelloServlet extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //这句话的意思,是让浏览器用utf8来解析返回的数据
            resp.setHeader("Content-type", "text/html;charset=UTF-8");
            //这句话的意思,是告诉servlet用UTF-8转码,而不是用默认的ISO8859
            resp.setCharacterEncoding("UTF-8");
            resp.getWriter().write("Hello , Servlet 3.0 !");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req, resp);
        }
    }
    

    AuthFilter 过滤器代码实现Filter接口,在AuthFilter类上添加@WebFilter注解,其中urlPatterns表示需要过滤的路径地址,asyncSupported表示是否支持异步。

    @WebFilter(urlPatterns = {"/*"}, asyncSupported = true)
    public class AuthFilter implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("AuthFilter init ");
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            String name = servletRequest.getParameter("name");
    
            if (Objects.equals("yangyanping", name)) {
                filterChain.doFilter(servletRequest, servletResponse);
            } else {
                servletResponse.setCharacterEncoding("UTF-8");
                servletResponse.setContentType("text/html;charset=utf-8");
                servletResponse.getWriter().write("没有权限访问");
            }
        }
    
        @Override
        public void destroy() {
            System.out.println("AuthFilter destroy ");
        }
    }
    

    MyListener 监听器类,需要在类上添加@WebListener注解,并实现ServletContextListener接口。

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

    观察系统启动日志,我们发现 先加载的是MyListener的contextInitialized方法,然后加载AuthFilter的init 方法。

    MyListener contextInitialized
    AuthFilter init 
    

    启动程序,在浏览器中输入 http://localhost:8080/hello?name=yangyanping 运行效果如图:
    在这里插入图片描述

    Servlet 3.0 异步

    异步处理支持。有了该特性,Servlet线程不再需要一直阻塞,直到业务处理完毕才能输出响应,最后才结束该Servlet。在接收到请求之后,Servlet线程可以将耗时的操作委托给另一个线程来完成,自己在不生成响应的情况下返回至容器。针对业务处理较耗时的情况,将大大减少服务器资源的占用,并且提高并发处理速度。

    @WebServlet(value = "/order", asyncSupported = true)
    public class AsyncOrderServlet extends javax.servlet.http.HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("主" + Thread.currentThread().getName() + "  start  !");
    
            resp.setHeader("Content-type","text/html;charset=UTF-8");
            req.startAsync();
            AsyncContext asyncContext = req.getAsyncContext();
    
            asyncContext.start(() -> {
                System.out.println("子" + Thread.currentThread().getName() + "  start  !");
                try {
                    Thread.sleep(5000);
                    ServletResponse servletResponse = asyncContext.getResponse();
                    servletResponse.setCharacterEncoding("UTF-8");
                    servletResponse.getWriter().write("Hello ! Async Servlet 。");
                }catch (Exception ex){
                }
                System.out.println("子" + Thread.currentThread().getName() + "  start  !");
                asyncContext.complete();
    
            });
            System.out.println("主" + Thread.currentThread().getName() + "  end  !");
        }
    }         
    

    启动程序,在浏览器中输入 http://localhost:8080/order?name=yangyanping 运行效果如图:
    在这里插入图片描述

    SPI原理分析

    SPI的全名为Service Provider Interface。
    它的约定:

    1. 在META-INF/services/目录中创建以接口全限定名命名的文件该文件内容为Api具体实现类的全限定名
    2. 使用ServiceLoader类动态加载META-INF中的实现类
    3. 如SPI的实现类为Jar则需要放在主程序classPath中
    4. Api具体实现类必须有一个不带参数的构造方法

    我们可以在jar包的META-INF/services/目录下创建一个以服务接口命名的文件(如下图的com.example.demo.People文件)。该文件里就是实现该服务接口的具体实现类(如com.example.demo.impl.ChinaPeople)。而当外部程序装配这个模块的时候,就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名,并装载实例化,完成模块的注入。

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200420145642876.jpg)

    我们定义一个People接口 和它的2个实现类(ChinaPeople,EnglishPeople),代码如下

    public interface People {
        String hello();
    }
    
    public class ChinaPeople implements People {
        @Override
        public String hello() {
            return "您好,世界 !";
        }
    }
    
    public class EnglishPeople implements People {
        @Override
        public String hello() {
            return "Hello World !";
        }
    }
    

    启动类代码

    public class DemoApplication {
    
        public static void main(String[] args) {
            ServiceLoader<People> services = ServiceLoader.load(People.class);
            Iterator<People> iterable = services.iterator();
    
            while (iterable.hasNext()){
                People people = (People)iterable.next();
                 System.out.println(people.hello());
            }
        }
    }
    

    运行效果如图:
    在这里插入图片描述
    我们把com.example.demo.People文件里的内容换成com.example.demo.impl.EnglishPeople 。如图:
    在这里插入图片描述
    再次运行程序,看看打印的日志,如图:
    在这里插入图片描述

    使用SPI手写Servlet 3.0

    同理容器在启动的时候(如tomcat启动),会扫描当前应用中的每一个jar包里面META-INF/services/javax.servlet.ServletContainerInitializer文件中指定的实现类,启动并运行这个实现类的方法onStartup(Set<Class<?>> set, ServletContext servletContext)。

    我们使用SPI机制,自己手写一个servlet 3.0。首先实现一个ServletContainerInitializer接口的类MyServletContainerInitializer。在类上添加@HandlesTypes({OrderService.class}) 注解,关注我们的OrderService的实现类定义。

    @HandlesTypes({OrderService.class})
    public class MyServletContainerInitializer implements ServletContainerInitializer {
        @Override
        public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
    
            for (Class<?> c : set) {
                System.out.println(c.getName());
            }
    
            ServletRegistration.Dynamic orderDynamic = servletContext.addServlet("order", HelloServlet.class);
            orderDynamic.addMapping("/order");
            orderDynamic.setLoadOnStartup(1);
    
    
            FilterRegistration.Dynamic filter = servletContext.addFilter("authFilter", AuthFilter.class);
            filter.addMappingForServletNames(EnumSet.of(DispatcherType.REQUEST), true, "userServlet");
            filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*");
    
    
            servletContext.addListener(new MyListener());
    
            System.out.println(".....init ......");
        }
    }
    

    HttpServlet,ServletContextListener,Filter的实现类如下 (无需使用注解):

    public class HelloServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.getWriter().write("Hello  My Servlet !");
        }
    }
    
    public class MyListener implements ServletContextListener {
        @Override
        public void contextInitialized(ServletContextEvent sce) {
            System.out.println("MyListener...contextInitialized...");
        }
    
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            System.out.println("MyListener...contextDestroyed...");
        }
    }
    
    public class AuthFilter implements Filter {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("AuthFilter.......");
            filterChain.doFilter(servletRequest,servletResponse);
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
    
        }
    
        @Override
        public void destroy() {
    
        }
    }
    

    定义一个OrderService接口 和 一个抽象类AbstractOrderService,实现类OrderServiceImpl

    public interface OrderService {
        String create();
    }
    
    public abstract class AbstractOrderService implements OrderService {
    }
    
    public class OrderServiceImpl extends AbstractOrderService {
        @Override
        public String create() {
            return null;
        }
    }
    

    运行程序,在浏览器中访问地址:http://localhost:8080/hello
    在这里插入图片描述
    好了,我们自己使用SPI的机制,已经自己手写了一个servlet3.0 的HttpServlet 。

    展开全文
  • Servlet3.0新特性

    2019-03-13 17:27:04
    Servlet 3.0中引入了若干个重要的新特性,例如新增的注释、异步处理、可插型支持等内容。这些内容的添加是Servlet技术逐渐完善的一个体现。 1、新增注释 Servlet 3.0中的重大革新之一。通过使用注释就无需在web....

    Servlet 3.0中引入了若干个重要的新特性,例如新增的注释、异步处理、可插型支持等内容。这些内容的添加是Servlet技术逐渐完善的一个体现。

    1、新增注释

    Servlet 3.0中的重大革新之一。通过使用注释就无需在web.xml文件中对Servlet或者过滤器进行配置。Servlet 3.0新增的注释有@WebServlets、@WebFilter、@WebListener、@WebInitParam等。

    1.1 @WebServlet注释

    @WebServlet注释定义在Servlet的类声明之前,用于定义Servlet组件。使用该注释,就无须再 web.xml 文件中对Servlet进行配置。@WebServlet注释包含很多属性。

    @WebServlet注释主要属性列表:

    属性名类型描述
    nameString指定Servlet的name属性,等价于<servlet-name>标签。如果没有显示指定,则该Servlet的取值即为类的全限定名。
    valueString[]该属性等价于urlPatterns属性。两个属性不能同时使用。
    urlPatternsString[]指定一组Servlet的URL匹配模式,等价于<url-pattern>标签。
    loadOnStartupint指定Servlet的加载顺序,等价于<load-on-startup>标签。
    initParamsWebInitParam[]指定一组Servlet初始化参数,等价于<init-param>标签。
    asyncSupportedboolean声明Servlet是否支持异步操作,等价于<async-supported>标签。
    smallIconString此Servlet的小图标。
    largeIconString此Servlet的大图标。
    descriptionString该Servlet的描述信息,等价于<description>标签。
    displayNameString该Servlet的显示名,通常配合工具使用,等价于<display-name>标签。

    示例:使用Servlet实现用户注册功能。

    (1)创建index.jsp页面。

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>用户注册</title>
    </head>
    <body>
    	<div>请输入注册信息
    		<form name="form1" method="post" action="servlet/RegServlet">
    			<table border="0" >
    				<tr>
    					<td>姓名:</td>
    					<td><input type="text" name="name"/></td>
    				</tr>
    				<tr>
    					<td>年龄:</td>
    					<td><input type=text name="age"/></td>
    				</tr>
    				<tr>
    					<td>性别:</td>
    					<td>
    						<select name = "sex">
    							<option value="男" selected="selected">男</option>
    							<option value="女">女</option>
    						</select>
    					</td>
    				</tr>
    				<!-- 以下是提交、取消按钮 -->
    				<tr>
    					<td>
    						<input type="submit" value="提交" />
    					</td>
    					<td>
    						<input type="reset" value="取消" />
    					</td>
    				</tr>
    			</table>
    		</form>
    	</div>
    </body>
    </html>

    (2)创建名为RegServlet的Servlet类。该类继承HttpServlet类,并应用@WebServlet注释,配置Servlet的name属性与urlPatterns属性。

    package com.pjb.servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * 用户注册Servlet类
     * 
     * @author pan_junbiao
     *
     */
    @WebServlet(name = "RegServlet", urlPatterns = "/servlet/RegServlet")
    public class RegServlet extends HttpServlet
    {
    
    	private static final long serialVersionUID = 1L;
    
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    	{
    		// 设置request的编码
    		request.setCharacterEncoding("UTF-8");
    		// 获取信息
    		String name = request.getParameter("name");
    		String age = request.getParameter("age");
    		String sex = request.getParameter("sex");
    
    		// 设置response的编码
    		response.setCharacterEncoding("UTF-8");
    		response.setContentType("text/html");
    		// 获取PrintWriter对象
    		PrintWriter out = response.getWriter();
    		// 输出信息
    		out.println("<HTML>");
    		out.println("<HEAD><TITLE>注册信息</TITLE></HEAD>");
    		out.println("<BODY>");
    		out.println("姓名:" + name + "<br>");
    		out.println("年龄:" + age + "<br>");
    		out.println("性别:" + sex + "<br>");
    		out.println("</BODY>");
    		out.println("</HTML>");
    		// 释放PrintWriter对象
    		out.flush();
    		out.close();
    	}
    }

    说明:使用@WebServlet注释,配置Servlet的name属性与urlPatterns属性,如下代码:

    @WebServlet(name = "RegServlet", urlPatterns = "/servlet/RegServlet")

    这样配置完成后,就不必在 web.xml 文件中配置相应的<servlet>和<servlet-mapping>元素了。与上面的代码等价的 web.xml 文件的配置如下:

    <servlet>
      <servlet-name>RegServlet</servlet-name>
      <servlet-class>com.pjb.servlet.RegServlet</servlet-class>
    </servlet>
     
    <servlet-mapping>
      <servlet-name>RegServlet</servlet-name>
      <url-pattern>/servlet/RegServlet</url-pattern>
    </servlet-mapping>

    执行结果:

    (1)注册页面 index.jsp。

    (2)提交注册结果信息。

     

    1.2 @WebFilter注释

    @WebFilter注释用于声明过滤器,该注释将会在部署时被容器处理,容器将根据具体的属性配置将相应的类部署为过滤器。

    @WebFilter注释主要属性列表:

    属性名类型描述
    filterNameString指定过滤器的name属性,等价于<filter-name>标签。
    valueString[]该属性等价于urlPatterns属性,但是两者不应该同时使用。
    urlPatternsString[]指定一组过滤器的URL匹配模式,等价于<url-pattern>标签。
    servletNamesString[]指定过滤器将应用于哪些Servlet,是@WebServlet中的name属性的取值,或者是web.xml文件中的<servlet-name>标签的取值。
    initParamsWebInitParam[]指定一组过滤器初始化参数,等价于<init-param>标签。
    asyncSupportedboolean声明过滤器是否支持异步操作模式,等价于<async-supported>标签。
    descriptionString该过滤器的描述信息,等价于<description>标签。
    displayNameString该过滤器的显示名,通常配合工具使用,等价于<display-name>标签。
    dispatcherTypesDispatcherType[]指定过滤器的转发模式。具体取值包括:ASYNC、ERROR、FORWARD、INCLUDE 和 REQUEST。

    示例:创建过滤器,使用@WebFilter注释进行配置。

    @WebFilter(filterName = "char", urlPatterns = "/*")
    public class CharFilter implements Filter
    {
    	// 省略了过滤器中间的代码
    }

    如此配置之后,就不需要在 web.xml 文件中配置相应的<filter>和<filter-mapping>元素了,容器会在部署时根据指定的属性将该类发布为过滤器。使用@WebFilter注释,等价于在 web.xml 文件中进行如下配置:

    <filter>
    	<filter-name>char</filter-name>
    	<filter-class>CharFilter</filter-class>
    </filter>
    
    <filter-mapping>
    	<filter-name>char</filter-name>
    	<url-pattern>/*</url-pattern>
    </filter-mapping>

     

    1.3 @WebListener注释

    @WebListener注释用于声明监听器,该注释用于充当给定web应用上下文中各种web应用事件的监听器的类。可以使用@WebListener来标注一个实现:ServletContextListener、ServletContextAttributeListener、ServletRequestListener、ServletRequestAttributeListener、HttpSessionListener、HttpSessionAttributeListener的类。@WebListener注释有一个value的属性,该属性为可选属性,用于描述监听器信息。使用该注释就不需要在 web.xml 文件中配置<listener>标签了。

    示例:使用@WebListener注释,创建监听器。

    @WebListener("监听器的描述信息")
    public class MyContextListener implements ServletContextListener
    {
    	// 省略了监听器中间的代码
    }

    这样配置完成后,就不必在 web.xml 文件中配置相应的<listener>元素了。与上面的代码等价的 web.xml 文件的配置如下:

    <listener>
    	<listener-class>MyContextListener</listener-class>
    </listener>

     

    1.4 @WebInitParam注释

    @WebInitParam注释等价于web.xml文件中的<servlet>和<filter>的<init-param>子标签,该注释通常不单独使用,而是配合@WebServlet或者@WebFilter使用。

    @WebInitParam注释主要属性列表:

    属性名类型描述
    nameString指定参数的名字,等价于<param-name>标签,必填项。
    valueString指定参数的值,等价于<param-value>标签,必填项。
    descriptionString关于参数的描述,等价于<description>标签,非必填项。

    示例:应用@WebInitParam注释配置初始化参数。

    package com.pjb.servlet;
    
    import javax.servlet.annotation.WebInitParam;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    
    @WebServlet(urlPatterns = { "/simple" }, name = "SimpleServlet", 
    initParams = { @WebInitParam(name = "username", value = "pan_junbiao") })
    public class SimpleServlet extends HttpServlet
    {
    	// 省略了Servlet中间的代码
    }

    这样配置完成后,就不必在 web.xml 文件中配置相应的<servlet>和<servlet-mapping>元素了。与上面的代码等价的 web.xml 文件的配置如下:

    <servlet>
    	<servlet-name>SimpleServlet</servlet-name>
    	<servlet-class>com.pjb.servlet.SimpleServlet</servlet-class>
    	<init-param>
    		<param-name>username</param-name>
    		<param-value>pan_junbiao</param-value>
    	</init-param>
    </servlet>
    
    <servlet-mapping>
    	<servlet-name>SimpleServlet</servlet-name>
    	<url-pattern>/simple</url-pattern>
    </servlet-mapping>

     

    2、对文件上传的支持

    在Servlet3.0出现之前,处理文件上传是一件很麻烦的事情,因为要借助第三方组件,例如commons fileupload等。而Servlet3.0出现以后就摆脱了这一问题。使用Servlet3.0可以十分方便的实现文件的上传。实现文件上传需要以下两项内容:

    (1)需要添加@MultipartConfig注释。

    (2)从request对象中获取Part文件对象。

    @MultipartConfig注释需要标注在@WebServlet注释之上。

    @MultipartConfig注释主要属性列表:

    属性名类型描述
    fileSizeThresholdint当数据量大于该值时,内容将被写入文件。
    locationString存放生成的文件地址。
    maxFileSizelong允许上传的文件最大值。默认值为-1,标识没有限制。
    maxRequestSizelong针对该multipart/form-data请求的最大数量,默认值为-1,表示没有限制。

    除了要配置@MultipartConfig注释之外,还需要两个重要的方法,即:getPart(String name)与getParts()方法。

    Part getPart(String name)

    Collection<Part> getParts()

    getPart(String name)方法的name参数表示请求的表单的name文件。getParts()方法可获取请求中的所有文件。上传文件用 javax.servlet.http.Part 对象来表示。Part 接口提供了处理文件的简易方法,如:write(String fileName)、delete()等。

    示例:应用Servlet实现文件上传。

    (1)编写具有上传文件组件的JSP页面。

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>文件上传</title>
    </head>
    <body>
    	<form action="UploadServlet" enctype="multipart/form-data" method="post">
    		选择文件:<input type="file" name="file1" id="file1">
    		<input type="submit" name="btnUpload" value="上传" />
    	</form>
    </body>
    </html>

    (2)编写处理上传文件的Servlet,在该Servlet中对上传文件进行控制。

    package com.pjb.servlet;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.MultipartConfig;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.Part;
    
    /**
     * 文件上传Servlet类
     * 
     * @author pan_junbiao
     *
     */
    @WebServlet("/UploadServlet")
    @MultipartConfig
    public class UploadServlet extends HttpServlet
    {
    	private static final long serialVersionUID = 1L;
    
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    	{
    		response.setContentType("text/html; charset=UTF-8");
    		PrintWriter out = response.getWriter();
    		String path = this.getServletContext().getRealPath("/"); // 获取服务器地址
    		Part p = request.getPart("file1"); // 获取用户选择的上传文件
    		if (p.getContentType().contains("image")) // 仅处理上传的图片文件
    		{
    			String fname1 = p.getSubmittedFileName(); // 获取上传文件的名称
    			String fileName = path + "/upload/" + fname1; // 上传文件的路径和文件名称
    
    			File file = new File(fileName);
    			File parentFile = file.getParentFile();
    			if (!parentFile.exists()) // 如果文件夹不存在,则创建该文件夹
    			{
    				parentFile.mkdir();
    			}
    
    			p.write(fileName); // 写入文件
    			out.write("文件上传成功");
    
    		} else
    		{
    			out.write("请选择图片文件!");
    		}
    	}
    }

    执行结果:

    运行本程序,选择上传文件后,如果上传文件是图片文件,点击“上传”按钮后,即可实现文件上传。

     

    3、异步处理

    异步处理是 Servlet3.0最重要的内容之一。在此之前,一个Servlet的工作流程是:首先,Servlet接收到请求后,需要对请求携带的数据进行一些预处理。接着调用业务接口的某些方法,以完成业务处理。最后,根据处理的结果提交响应,至此,Servlet线程结束。在此过程中,如果任何一个任务没有结束,Servlet线程就处于阻塞转态,直到业务方法执行完毕。对于较大的应用,很容易造成程序性能的降低。

    Servlet3.0针对这一问题做了突破性的工作,现在通过使用 Servlet3.0的异步处理机制可以将之前的Servlet处理流程调整为以下过程。首先,Servlet接收到请求之后,可能需要对请求携带的数据进行一些预处理;接着Servlet线程将请求转交给一个异步线程来执行业务处理,线程本身返回至容器,此时Servlet还没有生成响应数据,异步线程处理完业务之后,可以直接生成响应数据,或者将请求继续转发给其它Servlet。这样,Servlet线程不再是一直处于阻塞状态以等待业务逻辑的处理,而是启动异步之后可以立即返回。

    异步处理机制可以应用于Servlet和过滤器两种组件,由于异步处理的工作模式与普通工作模式有着本质的区别,在默认情况下,并没有开启异步处理特性,如果希望使用该特性,则必须按如下的方法启用:

    3.1 使用asyncSupported属性

    @WebServlet和@WebFilter注释提供了asyncSupported属性,默认该属性的取值为false,要启用异步处理支持,只需将该属性设置为true即可。

    示例:@WebServlet和@WebFilter注释实现设置异步处理。

    @WebFilter(urlPatterns = { "/chFilter" }, asyncSupported = true)
    public class DemoFilter implements Filter
    {
    	// 省略了过滤器实现代码
    }

    3.2 通过在web.xml文件中配置<async-supported>子标签

    如果实现选择在web.xml文件中对Servlet或者过滤器进行配置,可以在Servlet 3.0为<servlet>和<filter>标签增加了<async-supported>子标签,该标签的默认取值为false,要启用异步处理支持,则将其设为true即可。

    示例:在web.xml文件中配置异步处理。

    <servlet>
    	<servlet-name>CharServlet</servlet-name>
    	<servlet-class>com.pjb.servlet.CharServlet</servlet-class>
    	<async-supported>true</async-supported>
    </servlet>

     

    展开全文
  • spring_servlet3:Spring MVC Servlet 3.0博客的源代码
  • 官方servlet3.0.rar

    2019-08-18 11:18:18
    来自官方 servlet 3.0版本源码,全代码 核心类,annotation、descriptor、http、jsp、resources各包全代码
  • Tomcat-Servlet3.0

    2020-04-06 11:16:13
    web 软件架构 C/S:客户端/服务器端 B/S:浏览器/服务器端 ...静态资源:所有用户访问后,得到的结果都是一样的,称为静态资源....动态资源:每个用户访问相同资源后,得到的结果可能不一样。...如:servlet/jsp,php...

    web

    1. 软件架构

      1. C/S:客户端/服务器端
      2. B/S:浏览器/服务器端
    2. 资源分类

      1. 静态资源:所有用户访问后,得到的结果都是一样的,称为静态资源.静态资源可以直接被浏览器解析
        • 如: html,css,JavaScript
      2. 动态资源:每个用户访问相同资源后,得到的结果可能不一样。称为动态资源。动态资源被访问后,需要先转换为静态资源,在返回给浏览器
        • 如:servlet/jsp,php,asp…
    3. 网络通信三要素

      1. IP:电子设备(计算机)在网络中的唯一标识。
      2. 端口:应用程序在计算机中的唯一标识。 0~65536
      3. 传输协议:规定了数据传输的规则
        1. 基础协议:
          1. tcp:安全协议,三次握手。 速度稍慢
          2. udp:不安全协议。 速度快

    web服务器软件

    • 服务器:安装了服务器软件的计算机
    • 服务器软件:接收用户的请求,处理请求,做出响应
    • web服务器软件:接收用户的请求,处理请求,做出响应。
      • 在web服务器软件中,可以部署web项目,让用户通过浏览器来访问这些项目
      • web容器
    • 常见的java相关的web服务器软件:
      • webLogic:oracle公司,大型的JavaEE服务器,支持所有的JavaEE规范,收费的。
      • webSphere:IBM公司,大型的JavaEE服务器,支持所有的JavaEE规范,收费的。
      • JBOSS:JBOSS公司的,大型的JavaEE服务器,支持所有的JavaEE规范,收费的。
      • Tomcat:Apache基金组织,中小型的JavaEE服务器,仅仅支持少量的JavaEE规范servlet/jsp。开源的,免费的。
    • JavaEE:Java语言在企业级开发中使用的技术规范的总和,一共规定了13项大的规范
    • Tomcat:web服务器软件
      1. 下载:http://tomcat.apache.org/
      2. 安装:解压压缩包即可。
        • 注意:安装目录建议不要有中文和空格
      3. 卸载:删除目录就行了
      4. 启动:
        • bin/startup.bat ,双击运行该文件即可

        • 访问:浏览器输入:http://localhost:8080 回车访问自己
          http://别人的ip:8080 访问别人

        • 可能遇到的问题:

          1. 黑窗口一闪而过:

            • 原因: 没有正确配置JAVA_HOME环境变量
            • 解决方案:正确配置JAVA_HOME环境变量
          2. 启动报错:

            1. 暴力:找到占用的端口号,并且找到对应的进程,杀死该进程
              • netstat -ano 找PID,任务管理器对应
            2. 温柔:修改自身的端口号
              • conf/server.xml
              • <Connector port=“8888” protocol=“HTTP/1.1”
                connectionTimeout=“20000”
                redirectPort=“8445” />
              • 一般会将tomcat的默认端口号修改为80。80端口号是http协议的默认端口号。
                • 好处:在访问时,就不用输入端口号
      5. 关闭:
        1. 正常关闭:
          • bin/shutdown.bat
          • ctrl+c
        2. 强制关闭:
          • 点击启动窗口的×
      6. 配置:
        • 部署项目的方式:

          1. 直接将项目放到webapps目录下即可。

            • /hello:项目的访问路径–>虚拟目录
            • 简化部署:将项目打成一个war包,再将war包放置到webapps目录下。
              • war包会自动解压缩
          2. 配置conf/server.xml文件(不太安全)
            <Host>标签体中配置
            <Context docBase=“D:\hello” path="/hehe" />

            • docBase:项目存放的路径
            • path:虚拟目录
          3. 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写
            <Context docBase=“D:\hello” />

            • 虚拟目录:xml文件的名称
        • 静态项目和动态项目:

          • 目录结构
            • java动态项目的目录结构:
              – 项目的根目录
              – WEB-INF目录:
              – web.xml:web项目的核心配置文件
              – classes目录:放置字节码文件的目录
              – lib目录:放置依赖的jar包
        • 将Tomcat集成到IDEA中,并且创建JavaEE的项目,部署项目。

        • IDEA  run->edit Conf…–>defaults–>Tomcat Server,配置路径在这里插入图片描述

          如果报错配置jre
          在这里插入图片描述

    Servlet: server applet

    • 概念:运行在服务器端的小程序
      • Servlet就是一个接口,定义了Java类被浏览器访问到(tomcat识别)的规则。
      • 将来我们自定义一个类,实现Servlet接口,复写方法
    • 快速入门:
      1. 创建JavaEE项目
      2. 定义一个类,实现Servlet接口
        • public class ServletDemo1 implements Servlet
      3. 实现接口中的抽象方法
      4. 配置Servlet
        在web.xml中配置:
    	    <!--配置Servlet -->
    	    <servlet>
    	        <servlet-name>demo1</servlet-name>
    	        <servlet-class>cn.itcast.web.servlet.ServletDemo1</servlet-class>
    	    </servlet>
    	
    	    <servlet-mapping>
    	        <servlet-name>demo1</servlet-name>
    	        <url-pattern>/demo1</url-pattern>
    	    </servlet-mapping>
    
    • 执行原理:

      1. 当服务器接受到客户端浏览器的请求后,会解析请求URL路径,获取访问的Servlet的资源路径
      2. 查找web.xml文件,是否有对应的<url-pattern>标签体内容。
      3. 如果有,则在找到对应的<servlet-class>全类名
      4. tomcat会将字节码文件加载进内存,并且创建其对象
      5. 调用其方法
    • Servlet中的生命周期方法:

      1. 被创建:执行init方法,只执行一次

        • Servlet什么时候被创建?
          • 默认情况下,第一次被访问时,Servlet被创建
          • 可以配置执行Servlet的创建时机。
            • xml在<servlet>标签下配置
              1. 第一次被访问时,创建
                • <load-on-startup>的值为负数,默认-1
              2. 在服务器启动时,创建
                • <load-on-startup>的值为0或正整数
        • Servlet的init方法,只执行一次,说明一个Servlet在内存中只存在一个对象,Servlet是单例的
          • 多个用户同时访问时,可能存在线程安全问题。
          • 解决:尽量不要在Servlet中定义成员变量。即使定义了成员变量,也不要对修改值
      2. 提供服务:执行service方法,执行多次

        • 每次访问Servlet时,Service方法都会被调用一次。
      3. 被销毁:执行destroy方法,只执行一次

        • Servlet被销毁时执行。服务器关闭时,Servlet被销毁
        • 只有服务器正常关闭时,才会执行destroy方法。
        • destroy方法在Servlet被销毁之前执行,一般用于释放资源
    • Servlet3.0:

      • 好处:

        • 支持注解配置。可以不需要web.xml了。
      • 步骤:

        1. 创建JavaEE项目,选择Servlet的版本3.0以上,可以不创建web.xml
        2. 定义一个类,实现Servlet接口
        3. 复写方法
        4. 在类上使用@WebServlet注解,进行配置
          • @WebServlet(“资源路径”)

    续写

    1. Servlet3.0 注解配置

    2. Servlet的体系结构
      Servlet – 接口
      |
      GenericServlet – 抽象类
      |
      HttpServlet – 抽象类

      • GenericServlet:将Servlet接口中其他的方法做了默认空实现,只将service()方法作为抽象

        • 将来定义Servlet类时,可以继承GenericServlet,实现service()方法即可
      • HttpServlet:对http协议的一种封装,简化操作

        1. 定义类继承HttpServlet
        2. 复写doGet/doPost方法
    3. Servlet相关配置

      1. urlpartten:Servlet访问路径
        1. 一个Servlet可以定义多个访问路径 : @WebServlet({"/d4","/dd4","/ddd4"})
        2. 路径定义规则:
          1. /xxx:路径匹配
          2. /xxx/xxx:多层路径,目录结构
          3. *.do:扩展名匹配

    IDEA与tomcat的相关配置

    1. IDEA会为每一个tomcat部署的项目单独建立一份配置文件

      • 查看控制台的log:Using CATALINA_BASE: “C:\Users\17461.IntelliJIdea2017.3\system\tomcat_itcasts”
    2. 工作空间项目 和 tomcat部署的web项目

      • tomcat真正访问的是“tomcat部署的web项目”,“tomcat部署的web项目"对应着"工作空间项目” 的web目录下的所有资源
      • WEB-INF目录下的资源不能被浏览器直接访问。
    3. 断点调试:使用"小虫子"启动 dubug 启动

    展开全文
  • servlet3.0与mybatis整合的示例,本人亲自编写并测试成功
  • 本工程除了JSP必须的Servlet包以外,无须引入其它东西。其实想直接用一个JSP页面完成这个工程的,但是现在搞JSP的,基本上没有人直接在.jsp文件中写东西了吧?后台动作都扔到.java里面了。 一、基本目标 把前台js....
  • 本系列讲座主要讲述如何利用Servlet3.0+mybatis+bootstrap+mysql构建企业级应用解决方案,主要分为三部分完成 第一部分:技能储备阶段,学习项目所需要的技能知识 第二部分:设计部分,通过需求分析,设计物理模型,...
  • 目录Servlet简介Servlet的生命周期三级目录 Servlet简介 Servlet是运行在Web服务器或应用服务器上的程序,他是作为来自Web浏览器或其他HTTP客户端的请求和HTTP服务器上的数据库或应用程序之间的中间层。可以使用...
  • Servlet3.0 新特性

    2019-03-22 02:14:16
    需要在tomcat下运行 博文链接:https://inotgaoshou.iteye.com/blog/975116

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,638
精华内容 37,455
关键字:

servlet3.0