深度长文回顾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可以存储任意类型的数据没有大小限制

原文地址：https://www.cnblogs.com/ZhuChangwu/p/11712899.html

时间： 2024-10-05 05:50:17

深度长文回顾web基础组件的相关文章

[转]PHP并发IO编程之路（深度长文）

原文:https://www.imooc.com/article/8449 ------------------------------------------------------------------ PHP并发IO编程之路(深度长文) 原创 8235浏览 2016-05-30 16:31:54 小字号 并发IO问题一直是服务器端编程中的技术难题,从最早的同步阻塞直接Fork进程,到Worker进程池/线程池,到现在的异步IO.协程.PHP程序员因为有强大的LAMP框架,对这类底层方面的

十倍效能提升——Web 基础研发体系的建立

1 导读 web 基础研发体系指的是, web 研发中一线工程师所直接操作的技术.工具,以及所属组织架构的总和.在过去提升企业研发效能的讨论中,围绕的主题基本都是——”通过云计算.云存储等方式将底层核心技术封装成基础设施“.而我们在实践中发现,在 互联网渗入到各行各业,业务爆发 企业竞争白热化,对速度和品质要求越来越高 一线工程师队伍越来越庞大,管理成本增高 这样的多重背景下,除了底层核心技术外,一线 web 研发效能的问题也逐渐成为决胜战场的重要因素. 然而在现实中我们看到,因为一线的研发工作

从Java Web 基础看SSH架构

Java Web开发现在已然成为大型Wed项目的标准,之前一直盲目的使用框架,往往知其然不知其所以然.在经过一段时间的学习与开发,大概掌握了其脉络的基础上,对其做一定总结. 一.Java Web 基础 一个典型的Java Web项目往往包含这些元素:Jsp页面.Servlet.Listener.Filter,以及配置文件web.xml.其中: Jsp和Servlet基本是一回事,主要用来响应客户端的请求.当然Jsp中可以直接嵌入HTML标签,主要还是负责展现. Listener则是负责监听Web

数据分析 关于基础组件与介绍

第二部分 关于基础组件与介绍 基础信息库种类 基础信息库是账户或者自然人的纯真数据库查询系统.系统内积累存储的数据包括有: ü 手机号归属信息 ü IP数据纯真库 ü GPS信息对应地址信息 ü 域名空间身份信息 ü 3G分组域通讯信息 ü VPN服务器基础信息 ü VPN服务器日志信息(最新的区域时间段) ü 国内运输系统基础数据 ü 网络帐号密码查询系统 ü 网络帐号详情搜索查询 3S定位技术 3S 是通过遥感技术(RS).地理信息系统(GIS).全球定位系统(GPS)实现位置确认技术的统称

Web应用组件化的权衡

1. 基本概念 什么是Web应用? 所谓Web应用,指的是那些虽然用Web技术构建,但是展现形式却跟桌面程序或者移动端原生应用类似的产品.这类产品的特点是逻辑较重,交互复杂,通常也是单页式的. 主要包括: 交互占比较高的页面体系 以各种Hybrid技术构建的应用,其中的Web部分 大部分可以等同于所谓的"单页面应用",可以参见之前写的这篇:构建单页Web应用 组件化开发的优势是什么? 组件化的最重要作用就是提升开发和维护的效率. 最原始的组件,其功能可以单独开发测试,然后逐级拼装成更复

HT for Web基础动画介绍

在上一篇<基于HT for Web矢量实现3D叶轮旋转>一文中,我略微提了下HT for Web基础动画的相关用法,但是讲得不深入,今天就来和大家分享下HT for Web基础动画的相关介绍及用法. 先上一段枯燥的理论知识,大家混个眼熟. 在HT的数据模型驱动图形组件的设计架构下,动画可理解为将某些属性由起始值逐渐变到目标值的过程, HT提供了ht.Default.startAnim的动画函数,其示例代码如下. ht.Default.startAnim({ frames: 12, // 动画帧

Ext JS 6学习文档-第3章-基础组件

基础组件 在本章中,你将学习到一些 Ext JS 基础组件的使用.同时我们会结合所学创建一个小项目.这一章我们将学习以下知识点: 熟悉基本的组件 – 按钮,文本框,日期选择器等等 表单字段的校验 菜单和工具栏 设计一个表单 计算器程序– 本章的示例项目 转载请注明出处:http://www.jeeboot.com/archives/1219.html 本章的主要目的是创建一个表单设计和一个计算器示例项目.以下图分别展示了表单设计和计算器设计. 首先,你观察下列表单设计,你会发现我们使用了大量的控

Java Web 基础 --- Filter 综述

摘要: 伴随J2EE一起发布的Servlet规范中还包括一个重要的组件--过滤器(Filter).过滤器可以认为是Servlet的一种加强版,它主要用于对用户请求进行预处理以及对服务器响应进行后处理,是个典型的处理链.Servlet规范使用了三个接口对过滤器进行了抽象,即Filter是对具体过滤器的抽象,FilterChain是基于AOP理念对责任链方面的抽象,FilterConfig则是对Filter配置的抽象.本文概述了Filter的提出动机.工作原理.使用流程和应用实例,并指出Java W

Java web基础总结九之—— jsp标签

Java web基础总结九之-- jsp标签 JSP标签也称之为Jsp Action,在前面讲过,jsp的设计目的就是作为表现层.我们希望JSP页面仅用作数据显示模块,不要嵌套任何java代码引入任何业务逻辑,但在实际开发中不引入一点业务逻辑是不可能的,但引入业务逻辑会导致页面出现难看java代码.jsp的标签就是为了解决这个问题.所以jsp页面中也内置了一些标签(这些标签叫做jsp标签),开发人员使用这些标签可以完成页面的一些业务逻辑.我们也可以开发自定义标签,使jsp页面不出现一行java代