JSP 中request、response、session各自的作用是啥?

Posted 2023-05-04

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JSP 中request、response、session各自的作用是啥?相关的知识，希望对你有一定的参考价值。

request、response、session就是字面上的意思请求响应会话..
请求这个好理解把就是像网站发送一个请求比如我要一个1
这个时候就轮到响应出马了当网站接收到你的请求以后如果可能他就返回给你一个1

会话可以理解成一种特殊的请求就像上边的例子你先像网站发送一个请求1 过了一段事件你继续访问这个网站你想要一个2 你给网站发送请求2 但是网站有个要求必须先接受过1 以后才能接受2 但是只用请求的话网站是不会记得你发送过1的无论你发送多少次1 网站都是认为你是第一次访问这个网站这个时候就的用会话使用会话来记录发送过的请求你发送1以后网站就会记住你发送过1 然后你发送2 网站才能给你2的响应参考技术A

这是jsp 九大隐式对象其中的三个，

request 作用域用于用户获取后台servlet 通过转发页面过来的数据。后台代码 request.setAttribute("msg","你好"); 一般通过EL表达式获取：$request.msg ; 取出你好

而 session 页面获取$sessionScope.msg ; 后台 request.getSession().setAttribute("msg","你好") ；。

response 一般通过 Ajax 获取，这个代码比较多你百度看看

jsp的九大隐式对象： out . request,response,session,pageContext,Exception,Application,page,config

参考技术B request请求对象，可以获取客户端的请求信息，比如客户端表单数据，客户端url等
response响应对象，可以从服务器返回数据，比如设置服务器cookie，重定向url等
session会话对象，一般用来保存帐户信息，一般购物车的实现也是用session完成

jsp 修饰 Request 及Response

　　Servlet API包含4个可修饰的类，用于改变Servlet Request以及Servlet Response。这种修饰允许修改 ServletRequest以及ServletResponse或者HTTP中的等价类（即HttpServletRequest和HttpServletResponse）中的任务方法。这种修饰遵循Decorator模式或者Wrapper模式，因此在使用修饰前，需要了解一下该模式的内容。

一.Decorator 模式( 装饰器模式)

　　Decorator模式或者Wrapper模式允许修饰或者封装（在字面意义中，即修改行为）一个对象，即使你没有该对象的源代码或者该对象标识为final。

　　 Decorator模式适用于无法继承该类（例如，对象的实现类使用final标识）或者无法创建该类的实例，但可以从另外的系统中可以取得该类的实现时。例如， Servlet容器方法。只有一种方法可以修改ServletRequest 或者ServletResponse行为，即在另外的对象中封装该实例。唯一的限制是，修饰对象必须继承一个接口，然后实现接口以封装这些方法。

　　类图说明了一个Component接口以及它的实现类ComponentImpl。Component接口定义了A的方法。为了修饰ComponentImpl的实例，需要创建一个 Decorator类，并实现Component的接口，然后在子类中扩展Decorator的新行为。在类图中DecoratorA就是 Decorator的一个子类。每个Decorator实例需要包含 Component的一个实例。Decorator类代码如下（注意在构建函数中获取了Component的实例，这意味着创建 Decorator对象只能传入Component的实例）：

public class Decorator implements Component {
private Component decorated;
// constructor takes a Component implementation
public Decorator(Component component) {
this.decorated = component;
}
// undecorated method
@Override
public void methodA(args) {
decorated.methodA(args);
}
// decorated method
@Override
public void methodB(args) {
decorated.methodB(args)
}
}

　　在Decorator类中，有修饰的方法就是可能在子类中需要修改行为的方法，在子类中不需要修饰的方法可以不需要实现。所有的方法，无论是否需要修饰，都叫作 Component中的配对方法。Decorator是一个非常简单的类，便于提供每个方法的默认实现。修改行为在它的子类中。

　　需要牢记一点，Decorator类及被修饰对象的类需要实现相同的接口。为了实现Decorator，可以在Decorator 中封装修饰对象，并把Decorator作为Component的一个实现。任何Component的实现都可以在Decorator中注入。事实上，你可以把一个修饰的对象传入另一个修饰的对象，以实现双重的修饰。

二. Servlet封装类

　　Servlet API源自于4个实现类，它很少被使用，但是十分强大：ServletRequestWrapper、 ServletResponseWrapper以及 HttpServletRequestWrapper、 HttpServletResponseWrapper。

　　ServletRequestWrapper（或者其他3个Wrapper类）非常便于使用，因为它提供了每个方法的默认实现：即 ServletRequest封闭的配置方法。通过继承 ServletRequestWrapper，只需要实现你需要变更的方法就可以了。如果不用ServletRequestWrapper，则需要继承ServletRequest并实现ServletRequest中所有的方法。

　　图所示为Decorator模式中 ServletRequestWrapper的类图。Servlet容器在每次 Servlet服务调用时创建ServletRequest、ContainerImpl。直接扩展ServletRequestWrapper就可以修饰 ServletRequest了。

三. 示例：AutoCorrect Filter

　　在Web应用中，用户经常在单词的前面或者后面输入空格，更有甚者在单词之间也加入空格。是否很想在应用的每个Servlet中，把多余的空格删除掉呢？本节的 AutoCorrect Filter可以帮助你搞定它。该Filter包含了 HttpServletRequestWrapper子类 AutoCorrectHttpServletRequestWrapper，并重写了返回参数值的方法：getParameter、getParameterValues及 getParameterMap。代码如下所示。

AutoCorrectFilter 类

package filter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
// urlPatterns={"/*"}  不能过滤链接
@WebFilter(filterName = "AutoCorrectFilter", urlPatterns = { "*" })
public class AutoCorrectFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        AutoCorrectHttpServletRequestWrapper wrapper = new AutoCorrectHttpServletRequestWrapper(httpServletRequest);
        filterChain.doFilter(wrapper, response);
    }

    class AutoCorrectHttpServletRequestWrapper extends HttpServletRequestWrapper {
        private HttpServletRequest httpServletRequest;

        public AutoCorrectHttpServletRequestWrapper(HttpServletRequest httpServletRequest) {
            super(httpServletRequest);
            this.httpServletRequest = httpServletRequest;
        }

        @Override
        public String getParameter(String name) {
            return autoCorrect(httpServletRequest.getParameter(name));
        }

        @Override
        public String[] getParameterValues(String name) {
            return autoCorrect(httpServletRequest.getParameterValues(name));
        }
        
        //用匿名内部类 重写 getParameterMap() 方法
        @Override
        public Map<String, String[]> getParameterMap() {
            // 得到request的 parameterMap
            final Map<String, String[]> parameterMap = httpServletRequest.getParameterMap();
            // 重写 parameterMap
            Map<String, String[]> newMap = new Map<String, String[]>() {
                @Override
                public int size() {
                    return parameterMap.size();
                }

                @Override
                public boolean isEmpty() {
                    return parameterMap.isEmpty();
                }

                @Override
                public boolean containsKey(Object key) {
                    return parameterMap.containsKey(key);
                }

                @Override
                public boolean containsValue(Object value) {
                    return parameterMap.containsValue(value);
                }

                @Override
                public String[] get(Object key) {
                    return autoCorrect(parameterMap.get(key));
                }

                @Override
                public void clear() {
// this will throw an IllegalStateException
// but let the user get the original
// exception
                    parameterMap.clear();
                }

                @Override
                public Set<String> keySet() {
                    return parameterMap.keySet();
                }

                @Override
                public Collection<String[]> values() {
                    return autoCorrect(parameterMap.values());
                }

                @Override
                public Set<Map.Entry<String, String[]>> entrySet() {
                    return autoCorrect(parameterMap.entrySet());
                }

                @Override
                public String[] put(String key, String[] value) {
// this will throw an IllegalStateException
// but let the user get the original
// exception
                    return parameterMap.put(key, value);
                }

                @Override
                public void putAll(Map<? extends String, ? extends String[]> map) {
// this will throw an IllegalStateException
// but let
// the user get the original exception
                    parameterMap.putAll(map);
                }

                @Override
                public String[] remove(Object key) {
// this will throw an IllegalStateException,
// but let
// the user get the original exception
                    return parameterMap.remove(key);
                }
            };
            //返回一个新的map
            return newMap;
        }
    }

    private String autoCorrect(String value) {
        if (value == null) {
            return null;
        }
        // 去除String头尾空格
        value = value.trim();
        int length = value.length();
        StringBuilder temp = new StringBuilder();
        boolean lastCharWasSpace = false;
        for (int i = 0; i < length; i++) {
            char c = value.charAt(i);
            // 如果是空格 
            if (c == \' \') {
                // 如果是空格且是最后一个字符 就添加到temp
                if (!lastCharWasSpace) {
                    temp.append(c);
                }
                lastCharWasSpace = true;
            } else {
                // 不是空格的字符直接添加到temp
                temp.append(c);
                lastCharWasSpace = false;
            }
        }
        return temp.toString();
    }

    private String[] autoCorrect(String[] values) {
        if (values != null) {
            int length = values.length;
            for (int i = 0; i < length; i++) {
                values[i] = autoCorrect(values[i]);
            }
            return values;
        }
        return null;
    }

    private Collection<String[]> autoCorrect(Collection<String[]> valueCollection) {
        Collection<String[]> newCollection = new ArrayList<String[]>();
        for (String[] values : valueCollection) {
            newCollection.add(autoCorrect(values));
        }
        return newCollection;
    }

    private Set<Map.Entry<String, String[]>> autoCorrect(Set<Map.Entry<String, String[]>> entrySet) {
        Set<Map.Entry<String, String[]>> newSet = new HashSet<Map.Entry<String, String[]>>();
        for (final Map.Entry<String, String[]> entry : entrySet) {
            Map.Entry<String, String[]> newEntry = new Map.Entry<String, String[]>() {
                @Override
                public String getKey() {
                    return entry.getKey();
                }

                @Override
                public String[] getValue() {
                    return autoCorrect(entry.getValue());
                }

                @Override
                public String[] setValue(String[] value) {
                    return entry.setValue(value);
                }
            };
            newSet.add(newEntry);
        }
        return newSet;
    }
}

　　这个Filter的doFilter方法非常简单：创建 ServletRequest的修饰实现，然后，把修饰类传给 doFilter

HttpServletRequest httpServletRequest =
(HttpServletRequest) request;
AutoCorrectHttpServletRequestWrapper wrapper = new
AutoCorrectHttpServletRequestWrapper(
httpServletRequest);
filterChain.doFilter(wrapper, response);

　　在这个Filter背后的任何Servlet获得的 HttpServletRequest都将被AutoCorrectHttp ServletRequestWrapper 所封装。这个封装类很长，但很好理解。简单地说，就是它把所有获取参数的响应都调用了一下autoCorrect方法：

test1.jsp页面

<!DOCTYPE html>
<html>
<head>
<title>User Form</title>
</head>
<body>
<form action="test2.jsp" method="post">
<table>
<tr>
<td>Name:</td>
<td><input name="name"/></td>
</tr>
<tr>
<td>Address:</td>
<td><input name="address"/></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="Login"/>
</td>
</tr>
</table>
</form>
</body>
</html>

test2.jsp页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
<!DOCTYPE html>
<html>
<head>
<title>Form Values</title>
</head>
<body>
    <table>
        <tr>
            <td>Name:</td>
            <td>${param.name} (length:${fn:length(param.name)})</td>
        </tr>
        <tr>
            <td>Address:</td>
            <td>${param.address} (length:${fn:length(param.address)})</td>
        </tr>
    </table>
</body>
</html>

　　输入一个带空格的单词，无论是前面、后面，还是在单词之间，然后点击提交。接下来，在显示器上你将看到这些输入单词都被修正过来

以上是关于JSP 中request、response、session各自的作用是啥?的主要内容，如果未能解决你的问题，请参考以下文章

JSP内置对象request对象的转发与response对象的重定向

request.getRequestDispatcher("**.jsp").forward(request,response);乱码的解决

关于项目在网页中运行部分jsp出现乱码(由request.getRequestDispatcher("XXX.jsp").forward(request, response)造成）

JSP最常用的五种内置对象(out,request,response,session,application)

jsp 修饰 Request 及Response

JSP 中request、response、session各自的作用是啥?