深度长文回顾web基础组件

什么是Serlvet ?

全称 server applet 运行在服务端的小程序:

首先来说,这个servlet是java语言编写的出来的应用程序,换句话说servlet拥有java语言全部的优点,比如跨越平台,一次编译到处运行

其次: 相对于CGI(common gateway interface)规范而言,CGI是针对每一个用户的请求创建一个进程处理,而servlet所在的服务器会对每一个请求创建一个线程来处理,虽然线程数量有上限,但是相对于创建进程来说,后者对系统资源的开销更小

然后就是: 现在盛行javaWeb服务器Tomcat也是java语言编写的,毕竟Tomcat有Serlvet容器支持,所以servlet和web服务器之间无缝连接

Servlet其实一个接口,一套规范,不同的厂家对它有不同的实现,tomcat也是如此,
web服务器会把解析http协议信息的逻辑封装进他们的Servlet中,比如将用户发送的请求(request) HttpRequestServlet,
把响应给用户http报文的逻辑封装进HttpResponseServlet中, 然后web服务器负责不同组件,不同servlet之间的调度关系,
什么是调度呢? 比如说: 通过某个URL找到指定的Servlet,回调Servlet的service()方法处理请求

Servlet的体系结构

servlet接口的实现类如上图

Servlet在java中是一个接口,封装了被浏览器访问到服务器(tomcat)的规则

添加serlvet

通过web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  <display-name>Camel Routes</display-name>

    <!-- Camel servlet -->
    <servlet>
        <servlet-name>app1</servlet-name>
        <servlet-class>com.changwu.web.MyServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- Camel servlet mapping -->
    <servlet-mapping>
        <servlet-name>app1</servlet-name>
        <url-pattern>/app1</url-pattern>
    </servlet-mapping>

</web-app>

通过注解

舍弃web.xml是serlet3.0添加全注解技术， 这个注解的属性和需要在xml中配置的对应的

需要Tomcat7及以上才支持

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {
    
    /**
     * servlet-name
     */
    String name() default "";
    
    /**
     * The URL patterns of the servlet
     */
    String[] value() default {};

    /**
     * servlet的资源路径, 可以为一个servlet配置多个访问路径
     */
    String[] urlPatterns() default {};
    
    /**
     * 启动级别默认是-1,同样意味着依然是第一次访问时初始化
     */
    int loadOnStartup() default -1;
    
    /**
     * The init parameters of the servlet
     */
    WebInitParam [] initParams() default {};
    
    /**
     * Declares whether the servlet supports asynchronous operation mode.
     *
     * @see javax.servlet.ServletRequest#startAsync
     * @see javax.servlet.ServletRequest#startAsync(ServletRequest,
     * ServletResponse)
     */
    boolean asyncSupported() default false;
    
    /**
     * The small-icon of the servlet
     */
    String smallIcon() default "";

     /**
      * The large-icon of the servlet
      */
    String largeIcon() default "";

    /**
     * The description of the servlet
     */
    String description() default "";

    /**
     * The display name of the servlet
     */
    String displayName() default "";

}

servlet的路径定义规则

• /xxx

@WebServlet(urlPatterns = {"/app1","/app2"})

• /xxx/yyy

@WebServlet(urlPatterns = {"/app1/app2"})

• /xxx/*

@WebServlet(urlPatterns = {"/app1/*"})

• *.do

@WebServlet(urlPatterns = {"*.do"})

执行原理:

1. tomcat读取xml配置文件中配置servlet,根据用户配置的加载时机,通过反射技术创建出对象实例
2. 用户的请求报文经过tomcat的解析,分发到的Servlet下面,进行不同的回调处理

Servlet接口的方法

• 初始化方法, 创建servlet时执行一次
• 什么时候被创建: 默认情况下 第一次访问时被创建
  • 一般我们都在web.xml配置,让Servlet在启动时完成加载 <load-on-startup>1</load-on-startup>默认这个值是-1, 表示第一次访问时被创建, 整数表示启动时初始化
• 此外: Servlet的init()方法仅仅被执行一次,说明serlet是单例的,那么在并发的情况的就可能出现线程安全问题 , 解决: 尽量不要在serlvet中定义成员变量,我们最好去成员方法中定义变量,即使定义了, 不要提供set()方法,仅仅提供的get()

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("init.....");
    }

• 获取serlvet config 配置对象

    //
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

• 提供服务的方法, 每次serlvet被访问都会执行一次

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("--------------------service------------");
    }

• 获取serlvet 的信息, 版本等

    @Override
    public String getServletInfo() {
        return null;
    }

• 服务器正常关闭前, 销毁servlet时 回调
• 服务器非正常关闭,不会执行

    @Override
    public void destroy() {
        System.out.println("destroy");
    }

Servlet3.0新特性

Servlet3.0中的重大升级是ServletContainerInitializer,通过这个技术使我们可以为现有的组件写出可插拔的组件,与之相对应的是Servlet的新规范如下：

在执行的路径下面创建指定的文件

/classpath:   
    --META-INF    (目录)
       --services   (目录) 
          --javax.servlet.ServletContainerInitializer (文件)

我们可以在上面的文件中配置一个类的全类名,这个类是谁无所谓,但是只要它实现了这个ServletContainnerInitializer接口,并重写它的onStart()方法，于是当容器(tomcat)启动的时候就会调用这个类的 onStart()方法

这个规范带来的革命决定是历史性的,有了它我们的代码就有了可插拔的能力,不信可以回想一下传统的配置文件,如果想给项目进行升级,还不想改动xml文件,那是不可能的,但是现在不同了,只要让我们的类实现这个ServletContainnerInitializer,重写它的方法,它的onStart()就会被回调,而其他的功能不受响应,去掉这个类,项目整体也不受响应

示例:

容器启动的时候,会把容器中,被@HandlerTypes(value={Test.class}) 中指定的所有Test.class实现类(子类,子接口)的实例传递进下面的set集合

@HandlesTypes(Test.class)
public class ChangWuInitializer implements ServletContainerInitializer {

    @Override
    public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
        System.out.println(set);
    }
}

通过上面onstart()方法可以看到,第二个参数位置上是 ServletContext, 这个对象是什么?有啥用? 在下文中单独开一个模块说

ServletContext

tomcat会为每一个web项目创建一个全局唯一的ServeltContext,这个对象里面封装着整个应用的信息,常用的当作域对象,所有的servlet之间共享数据,同时他还可以获取出web.xml文件中的数据

功能:

• 获取MIME类型
  • MIME类型是互联网通信中定义的文件数据类型
  • 格式: 大类型/小类型 如: test/html

在tomcat的配置文件目录中存在web.xml ,里面的存在大量的MEMI类型的数据,都可以从ServletContext中获取出来

String getMimeType(String file)

• 域对象(共享数据)

范围: 类似于Session，通过ServletContext对象我们也可以实现数据共享，但值得注意的是，Session是只能在一个客户端中共享数据，而ServletContext中的数据是在所有客户端中都可以实现数据共享的。

方法:

setAttribute(String name,Onject obj);
getAttribute(String name);
removeAttribute(String name);

• 获取文件真实的文件路径
  方法

this.getServletContext().getRealPath("/");  // 现在访问的目录是tomcat中和WEB-INF同级目录

• 实现请求转发

// 方式1:
request.getRequestDispatcher("/url").forward(req,res);

// 方式2:
this.getServletContext().getRequestDispatcher("/url").forward(req,res);

• 获取web应用的初始化参数

我们可以用标签为servlet配置初始化参数，然后使用ServletConfig对象获取这些参数，假如有如下的MyServlet，它的配置为：

<servlet>  
    <servlet-name>MyServlet</servlet-name>  
    <servlet-class>com.gavin.servlet.MyServlet</servlet-class>  
    <init-param>  
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>  
</servlet> 

获取:

String encoding = this.getServletConfig().getInitParameter("encoding");

如何获取:

ServletContext在web应用上下文中以单例的形式存在,下面两种获取方式得到的ServletContext是同一个对象

ServletContext servlet1 = request.getServletContext();
ServletContext servlet2 = this.getServletContext();
this.getServletConfig().getServletContext();

生命周期

服务器一启动就创建,服务器关闭时才销毁

注册三大web组件(servlet filter listener)

• Servlet

addServlet、createServlet、getServletRegistration、getServletRegistrations

• Filter

addFilter、createFilter、getFilterRegistration、getFilterRegistrations

• 监听器

addListener、createListener

Spring-web对Servlet3.0的应用

先上一张继承体系图,下面围绕这张图片展开

@HandlesTypes({WebApplicationInitializer.class})
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    public SpringServletContainerInitializer() {
    }

    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
        List<WebApplicationInitializer> initializers = new LinkedList();
        Iterator var4;
        if (webAppInitializerClasses != null) {
            var4 = webAppInitializerClasses.iterator();

            while(var4.hasNext()) {
                Class<?> waiClass = (Class)var4.next();
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                        initializers.add((WebApplicationInitializer)ReflectionUtils.accessibleConstructor(waiClass, new Class[0]).newInstance());
                    } catch (Throwable var7) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", var7);
                    }
                }
            }
        }
...
}

可以看到,Spring应用一启动就会加载WebApplicationInitializer接口下的所有组件,并且,只要这些组件不是接口,不是抽象类,Spring就为它们创建实例

更进一步看一下上下文中WebApplicationInitializer接口的实现类

AbstractContextLoaderInitializer

看他对onstart()方法的重写, 主要干了什么呢? 注册了一个上下文的监听器(借助这个监听器读取SpringMvc的配置文件),初始化应用的上下文

public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer {
    protected final Log logger = LogFactory.getLog(this.getClass());

    public AbstractContextLoaderInitializer() {
    }

    public void onStartup(ServletContext servletContext) throws ServletException {
        this.registerContextLoaderListener(servletContext);
    }

    protected void registerContextLoaderListener(ServletContext servletContext) {
        WebApplicationContext rootAppContext = this.createRootApplicationContext();
        if (rootAppContext != null) {
            ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
            listener.setContextInitializers(this.getRootApplicationContextInitializers());
            servletContext.addListener(listener);
        } else {
            this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
        }

    }

AbstractDispatcherServletInitializer

见名知意,他是DispatcherServlet的初始化器,他主要做了什么事呢?

• 上面看了,它的父类初始化上下文,于是它调用父类的构造,往上传递web环境的上下文
• 紧接着添加DispatcherServlet

public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer {
public static final String DEFAULT_SERVLET_NAME = "dispatcher";

public AbstractDispatcherServletInitializer() {
}

public void onStartup(ServletContext servletContext) throws ServletException {
    super.onStartup(servletContext);
    this.registerDispatcherServlet(servletContext);
}

protected void registerDispatcherServlet(ServletContext servletContext) {
    String servletName = this.getServletName();
    Assert.hasLength(servletName, "getServletName() must not return null or empty");
    
    // 可以看一下,它创建的是web的容器 
    WebApplicationContext servletAppContext = this.createServletApplicationContext();
    Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
    
    // 创建负责调度的 DispatcherServlet
    FrameworkServlet dispatcherServlet = this.createDispatcherServlet(servletAppContext);
    Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
    dispatcherServlet.setContextInitializers(this.getServletApplicationContextInitializers());
    
    // 添加Servlet 
    Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
    if (registration == null) {
        throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. Check if there is another servlet registered under the same name.");
    } else {
        
        // 添加servlet的mapping信息
        registration.setLoadOnStartup(1);
        registration.addMapping(this.getServletMappings());
        registration.setAsyncSupported(this.isAsyncSupported());
        Filter[] filters = this.getServletFilters();
        if (!ObjectUtils.isEmpty(filters)) {
            Filter[] var7 = filters;
            int var8 = filters.length;

            for(int var9 = 0; var9 < var8; ++var9) {
                Filter filter = var7[var9];
                this.registerServletFilter(servletContext, filter);
            }
        }

        this.customizeRegistration(registration);
    }
  ...
  }

AbstractAnnotationConfigDispatcherServletInitializer

createRootApplicationContext重写了父类的创建上下文的方法,我觉得这算是一个高潮吧, 因为啥呢,AnnotationConfigWebApplicationContext是SpringMvc使用的应用的上下文,怎么创建的源码在下面,其实我有在Spring源码阅读中写过这个方面的笔记,下面仅仅是将配置类传递给Spring的bean工厂,并没有对配置类进行其他方面的解析,或者是扫描包啥的

createServletApplicationContext()重写了它父类的创建serlvet上下文的方法,

有个点,大家有没有发现,SpringMvc的上下文和Servlet的上下文是同一个对象,都是AnnotationConfigWebApplicationContext,不同点就是添加了if-else分支判断,防止重复创建

public abstract class AbstractAnnotationConfigDispatcherServletInitializer extends AbstractDispatcherServletInitializer {
    public AbstractAnnotationConfigDispatcherServletInitializer() {
    }

    @Nullable
    protected WebApplicationContext createRootApplicationContext() {
        Class<?>[] configClasses = this.getRootConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
            AnnotationConfigWebApplicationContext context = new 有没有大神了解这个情况, SpringMvc的应用上下文和Servlet应用上下文竟然是同一个();
            context.register(configClasses);
            return context;
        } else {
            return null;
        }
    }

    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        Class<?>[] configClasses = this.getServletConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
            context.register(configClasses);
        }

        return context;
    }

对比官网推荐的启动案例:

下面的是Spring官网推荐是通过注解的配置方法,仔细看看,其实和上面的Spring-Web模块的做法是一样的

public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletCxt) {

        // Load Spring web application configuration
        AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext();
        ac.register(AppConfig.class);
        ac.refresh();

        // Create and register the DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(ac);
        ServletRegistration.Dynamic registration = servletCxt.addServlet("app", servlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/app/*");
    }
}

基于Servlet3.0全注解方式整合SpringMvc

经过前面的分析,第一个结论是:服务器一启动,经过自上而下的继承体系AbstractAnnotationConfigDispacherServletInitializer会被加载执行,所以,当我们想使用全注解方式完成继承SpringMVC时,继承AbstractAnnotationConfigDispacherServletInitializer就好

public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    // 获取Spring容器的配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{RootConfig.class};
    }
    // 获取web容器的配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 获取DispatcherSerlvet的映射信息
     * / : 表示拦截所有请求(包含静态资源 XXX.js  XXX.jpg) 但是不包含 XXX.jsp
     * /* : 表示拦截所有请求(包含静态资源 XXX.js  XXX.jpg) 包含 XXX.jsp
     * @return
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

下面的两个配置类, 按照他的意思,分成了两个配置类,一个是web上下文中的配置类,另一个是Spring原生环境的配置类

但是吧,看看下面的配置真的是特别麻烦,一个得排除@Controller,完事另一个得包含@Controller,其实Spring原生上下文都认识这些通用注解,倒不如直接就一个配置类,还省事

@ComponentScan(value = "com.changwu",includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
},useDefaultFilters = false)
public class WebConfig {
}

@ComponentScan(value = "com.changwu",excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
})
public class RootConfig {
}

Servlet3.0 异步请求处理器

早前的前后端请求响应的模型是怎样的呢? 用户发送的请求经过网络传输到Tomcat,Tomcat中存在一个线程池,这时Tomcat会从线程池中取出一条线程专门处理这个请求,一直到处理完毕,给了用户响应之后才将此线程回收到线程池,但是线程池中的线程终究是有限的,一旦同时好几百的连接进来,Tomcat的压力骤然上升,难免会出现阻塞的现象

Serlet3.0引入的异步处理,让主线程拥有非阻塞的特性,这样tomcat接收请求访问的吞吐量就会增加

示例:

// 启动异步
@WebServlet(value = "/async",asyncSupported = true)
public class MyAsyncServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 开启异步处理
        AsyncContext asyncContext = req.startAsync();

        asyncContext.start(new Runnable() {
            @Override
            public void run() {
                // do other things
                // 结束
                asyncContext.complete();
                // 响应
                ServletResponse response = asyncContext.getResponse();
                try {
                    response.getWriter().write("123");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

SpringMvc的异步任务

针对Servlet3.0的异步特性,SpringMvc相关的支持是提供了异步线程池

DeferredResult

我觉得这个异步的实现方式简直是无与伦比!!!无法言表!!!

@GetMapping("/quotes")
@ResponseBody
public DeferredResult<String> quotes() {
    DeferredResult<String> deferredResult = new DeferredResult<String>();
    // Save the deferredResult somewhere..
    return deferredResult;
}

// From some other thread...
deferredResult.setResult(result);

Callable

• 方法的最后将Callable返回
• call()方法中做写需要异步处理器的逻辑

执行流程:

• SpringMvc会将这个Callable放到一个叫TaskExcutor中执行
• DispatcherSerlvet和所有的Filter退出web容器,但是Response保持打开状态
• SpringMvc会将Callable的返回结果重写派发给setlvet恢复之前的处理
• 根据Callable返回的结果SpringMvc进行渲染

@PostMapping
public Callable<String> processUpload(final MultipartFile file) {
    return new Callable<String>() {
        public String call() throws Exception {
            // ...
            return "someView";
        }
    };
}

Request

请求方式与很多种,get post head trace options 还有put delete

其中get post put delete 是RestfulAPI中推荐,也是现在盛行使用的四种请求方法

get: 最为简单的请求方式,一般数据添加在url后面一般这样写username?张三&password?123123, 由于URL的长度有限制,故能传输的数据一般在1M左右, 而且数据明文传输,像上面那样,村咋存在安全隐患

post的数据存放在请求体中,一般没有大小限制,相对于get而言,post的安全性更好一点

继承图如下:

上图中我们最常使用的HttpServletRequest竟然是个接口,当时一开始学web的时候确实觉得很奇怪,但是现在想想其实也还好了,因为Tomcat提供了实现类org.apache.catalina.connector.RequestFacade

获取请求行数据-GET

点击查看文档

请求行: GET /test/app?name=zhangsan http/1.1

• 获取请求方法: GET

String getMethod()

• 获取虚拟路径(项目路径): /test

String getContextPath()

• 获取Servlet路径; /app

String  getServletPath()

• 获取get请求的请求参数: name=zhangsan

String getQueryString()

• 获取URI : /test/app

String getRequestURI()

• 获取URL : http:localhost/test/app

String getRequestURL()

• 获取协议版本

String getProtocol()

• 获取远程主机地址

String getRemoteAddr()

获取请求头数据

• 根据名称获取请求头

String getHeader(String name);

• 获取所有的请求头

Enumertion<String> getHeaderNames(); 获取所有请求头的名称

获取请求体数据

仅仅有post方式,才会有请求体:使用它分成两步:

• 从request中获取流对象

BufferReader getReader(); // 获取字符输入流
ServletInputStream getInputStrream(); // 获取字节输入流

• 从流对象中获取到需要的数据

通用的方法

• 根据参数名获取参数值

String getParamter(String name); 根据参数名获取参数值

• 根据参数名,获取参数值数组

String [] getParameterValues(String name)

• 获取所有请求的参数名称

Enumeration<String> getParamerterNames()

• 获取所有参数键值对形式的map集合

Map<String,String[]) getParamerterMap()

有了通用的方法特性之后,我们就不跟针对doGet,doPost两种方式写两份代码, 只要在doGet()或者doPost()中调用另外一个就ok,因为方法针对两者通用

解决中文乱码

首先: Tomcat8自身解决了中文乱码问题

Post方式提交数据依然存在乱码问题,像下面这样先设置编码再使用 req

request.setCharacterEncoding("utf-8")

request的请求转发

当用户的某一个请求需要通过多个Servlet协作完成时,请求在Servlet之间跳转,这种资源跳转的方式称为请求转发

使用方法:通过当前的request获取出RequestDispacher对象,通过这个对象的forward(req,res)进行转发的动作

RequestDispatcher getRequestDispacher(String path) // path是另一个Servlet的url-pattern
forward(currentReq,currentRes);

特点:

• 浏览器地址栏路径没有发生变化
• 服务器内部官网的资源跳转,不能跳往别的站点
• 一次转发,对浏览器来说,仅仅发送了一次请求

因为我们没让浏览器发送两次请求,在服务端完成了请求转发,所以上面的path仅仅是servlet-url-pattern,而不包含项目路径

域对象-共享数据

域对象: request域, 既然是域对象,他就有自己的作用范围,request的作用范围是什么呢? 就是一次请求,每次请求都是一个域, 换句话说,如果说客户端的一次请求经过了AServlet,然后AServlet将请求转发到了BServlet,name AServlet BServlet就在一个域中,也就可以共享彼此的数据

怎么玩?

在AServlet
setAttribute(String name,Object obj);
请求转发到BServlet

在BServlet
getAttribute(String name);

移除
removeAttribute(String name);

Reponse

响应信息格式如下:

HTTP/1.1 200 OK  //响应行

---------------------------------------

响应头
 // 服务器的类型
Server: server-name 
//服务端告诉客户端,自己推送给它的数据的编码格式(浏览器根据指定的类型进行解码)
Content-Type: text/html;charset=utf-8  
// 响应内容的长度
Content-Length: XXX 
// 响应日期
Date: XXX  
//服务器告诉浏览器用什么格式打开响应体数据, 默认是in-line 表示在当前页面中打开, attachment(文件下载)
Content-disposition: in-line

----------------------------------------

(响应空行)

----------------------------------------

XXX   // 响应体

常用方法

Response对象就是用来设置响应消息的对象

• 设置响应行

// 格式: HTTP/1.1 200 ok
setStatus(int status);

• 设置响应头

setHeader(String name, String value);

• 设置响应体

// 0 在往客户端写中文前先设置编码
response.setContentType("text/html;charset=utf-8");
// 1. 获取到输出流(字节流/字符流)

// 2. 往客户端写
response.getWriter().write("XXXXXXX");

• 重定向

// 实现,从 AServlet 重定向到BServlet

// 两步实现: 重定向
// 设置状态码 / 响应头
reponse.setStatus(302);
response.setHeader("location","/项目路径/serlet-url-pattern");

// 单行代理实现重定向
response.sendRedirect("/项目路径/serlet-url-pattern");

特点:

• 重定向: 浏览器地址栏路径改变了
• 重定向: 可以请求其他服务器
• 重定向: 实际上发起了两次请求 (不能使用request域共享数据)

因为我们让浏览器发送了两次请求, 因此重定向的路径中包含 项目路径

Cookie

常用api

客户端会话技术,将数据保存在浏览器本地, 下一次访问时会携带着cookie

• 创建cookie,绑定数据

new Cookie(String name,String value)

• 发送cookie

response.addCookie(Cookie cookie);

• 获取解析cookie

Cookie [] cookies = request.getCookies();

• 一次发送多个cookie

Cookie c1 = new Cookie(String name,String value)
Cookie c2 =new Cookie(String name,String value)
reponse.addCookie(c1);
reponse.addCookie(c2);

• cookie的生命周期

默认cookie存储在浏览器内存中,一旦浏览器关闭,cookie销毁

设置cookie的生命周期

setMaxAge(int seconds);
seconds 为存活时间, 
正数: 表示以文件的形式进行持久化,默认单位 s
负数: 表示仅仅存在于内存中
零:   表示让浏览器删除cookie

• cookie存储中文

tomcat8之前,cookie不支持中文,Tomcat8之后cookie支持中文

tomcat8之前需要进行转码,一般采用URL编码

• cookie获取的范围

默认情况下:在一个tomcat中的部署的多个web项目之间cookie是不能共享的

但是可以通过下面的方法设置更大路径,实现想要的效果

setPath(String path); // 默认是当前的虚拟目录

// 可以设置成下面这样
setPath("/"); // 默认是当前的虚拟目录

跨域tomcat之间cookie共享使用-- 根据域名划分

setDomain(String path); // 只要一级域名相同,则多个服务器之间共享 cookie

特点:

• 存储在浏览器,不安全
• 浏览器对单个cookie大小(一般都在4kb),对同一个域名下的cookie总数也有限制(一般20个以内)

小场景:

服务器,浏览器协作的流程: 比如登录: 用户通过浏览器往服务端发送登录请求,服务端验证用户名密码,通过后往客户端的发送cookie, 其实是设置了响应头set-cookie=XXX, 浏览器碰到这种响应头,就把这个响应体缓存在本地,再次请求这个网站时,会自动携带这个请求头cookie=XXX , 后端通过解析用户发送过来的cookie,可以判断当前请求的用户是否是合法的

Session

服务端会话技术,在一次会话中多次请求共享数据,将数据保存在服务端的对象--HttpSession

session也是域对象

常用API

• 获取session

HttpSession session = request.getSession();

• 使用session

setAttribute(String name,Object obj);

getAttribute(String name);

romoveAttribute(String name);

如何确保多次会话中,多次获取到的session是同一个

1. 用户通过浏览器向服务端发送请求
2. 服务端验证用户的信息,通过验证后,如果没有当前的session就为用户创建session(每个session都有唯一的id),创建cookie,给客户端返回相应 set-coolkie:JSESSIONID=shdfiuhduifha
3. 用户再次访问服务端,浏览器会自动携带上请求头cookie:JSESSIONID=shdfiuhduifha
4. 服务器解析cookie携带的JSESSIONID=shdfiuhduifha便可以找出唯一的session

细节

• 客户端关闭,服务端不关闭,两次获取到的session一样吗?
  • session是依赖cookie的,客户端关闭,cookie被干掉了,也就是说本次会话也就结束了,后端的session将被干掉
  • 但是如果我们发送给浏览器一个可以存活很长时间的cookie,再次打开浏览器访问后端,session还是同一个
• 客户端不关闭,服务端关闭,两次获取到的session一样吗?
  • 服务器都没了,session肯定被干掉了,session肯定不一样
  • 补救:钝化 tomcat在服务器正常关闭前,将session序列化持久化到磁盘上
  • 补救:活化 tomcat在服务器启动时,将session重新加载进内存

idea中可以成功完成钝化,但是不能完成活化

• session失效时间
  • 服务器关闭
  • 使用api,自动关闭 invalidate()
  • session默认的失效时间30分钟

过期时间可以在Tomcat中的配置文件目录下的web.xml中配置

<session-config>
    <session-timeout>30</session-timeout>
</session-config>

特点:

• session用于存储一次会话的多次请求数据,存储在服务端
• session可以存储任意类型的数据没有大小限制