Fork me on GitHub

Servlet,JSP介绍和使用

字数统计: 5.6k字   |   阅读时长≈ 26分

Http协议

特点

无连接，无状态，简单快速，灵活，支持B/S和C/S

客户端—请求–》服务端

服务器—-响应—》客户端

brower与server 建立连接（三次握手）

N组发送请求和返回响应

brower与server关闭连接（四次分手）

client —-request—->webserver—》找对应页面—response–》客户端

1591357107477

这里因为浏览器的不同，对request数据的封装也就不同，那么应该在WebServer这一层怎么去做到兼容多个浏览器并且还能够简单实现，那就定制好一套传输协议，大家都通过这个协议解析，请求，响应

每次都要准备页面实在太麻烦，那么能不能通过applet（小程序）来实现一个动态生成页面的能力这样就可以按需返回动态页面

引出

servlet基于http协议在服务端生成的程序—发现每次在java代码中内嵌html太麻烦，—–》JSP

格式

—–请求报文格式

请求方法 URL 协议版本–》请求行

头部键 值–》请求头

空行

用户自定义键值对 请求体

—响应报文格式

协议版本 状态码 状态码描述–》状态行

头部键：值 –》 响应头

空行

响应数据–》 响应体

Tomcat：

tomcat是一个WebServer

servlet写好放入webserver，所以webserver是一个容器

实现

客户端IO input output

服务端IO input output

tcp进行连接

因为面向对象，

所以把客户端的请求包装成request对象

把服务端要响应的包装成response对象

applet是需要定义规范的，因为applet可以有很多，所以需要有一个规范必须去实现必要的方法，抽象

容器必须包含service（request和response）{业务最后调用的方法}并且通过request解析出uri在mapper里面找到对应的applet（request和response）类路径

实例化一个servlet（service和applet）

调用一个servlet里面的service方法

代码实现
request和response
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public class Request {

    //get,post
        private String requestMethod;
        private String requestUrl;

    public Request(InputStream inputStream) throws IOException {
        byte[] buffer=new byte[1024];
        int length=0;
        String str=null;
        length = inputStream.read(buffer);
        if (length>0){
            str=new String(buffer,0,length);
        }
        System.out.println(str);
        String[] split = str.split("\n");
        String[] requestCol = split[0].split(" ");
        requestMethod=requestCol[0];
        requestUrl=requestCol[1];

    }

    public String getRequestMethod() {
        return requestMethod;
    }

    public void setRequestMethod(String requestMethod) {
        this.requestMethod = requestMethod;
    }

    public String getRequestUrl() {
        return requestUrl;
    }

    public void setRequestUrl(String requestUrl) {
        this.requestUrl = requestUrl;
    }


}

public class Response {

    private OutputStream outputStream;


    public Response(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    public Response() {
    }

    public void write(String str) throws IOException {

        StringBuilder builder=new StringBuilder();
        builder.append("HTTP/1.1 200 OK\n")
               .append("Content-Type:text/html\n")
                .append("\r\n")
                .append(str);

        if (null!=outputStream){
            outputStream.write(builder.toString().getBytes());
            outputStream.flush();
            outputStream.close();
        }
    }
}
mapper
1
2
3
4
5
6
7
8
9
10
11
12
public class Mapper {


    public static Map<String,String> mapper=new HashMap<>();

    static {
        mapper.put("/mytomcat","com.zgw.MyServlet");

    }


}
servlet
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public abstract class HttpServlet {

    private static final String  METHOD_GET="GET";
    private static final String METHOD_POST="POST";

    public abstract void doGet(Request request, Response response);
    public abstract void doPost(Request request, Response response);


    public void service(Request request, Response response){
        if (request.getRequestMethod().equals(METHOD_GET)){
            doGet(request,response);
        }else if (request.getRequestMethod().equals(METHOD_POST)){
            doPost(request,response);
        }
    }
}

public class MyServlet extends HttpServlet {
    @Override
    public void doGet(Request request, Response response) {
        doPost( request,  response);
    }

    @Override
    public void doPost(Request request, Response response) {
        try {
            response.write("<html><body><h1>牛逼哦</h1></body></html>");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
一个长服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        ExecutorService executorService = Executors.newCachedThreadPool();
        ServerSocket serverSocket=new ServerSocket(8080);
        while (true) {
            Socket accept = serverSocket.accept();
            InputStream inputStream = accept.getInputStream();
            OutputStream outputStream = accept.getOutputStream();

            Request request=new Request(inputStream);
            Response response=new Response(outputStream);
            System.out.println();
            if (Mapper.mapper.containsKey(request.getRequestUrl())){
                String s = Mapper.mapper.get(request.getRequestUrl());

                Class<?> aClass = Class.forName(s);
                HttpServlet o =(HttpServlet) aClass.getDeclaredConstructor().newInstance();
                o.service(request,response);
            }
            accept.close();
        }
    }
}
配置文件和启动tomcat应用servlet：

server.xml配置端口等服务启动配置项

web.xml是配置映射的servlet的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>test</servlet-name>
        <servlet-class>com.zgw.servlet.TestServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>test</servlet-name>
        <url-pattern>/test</url-pattern>
    </servlet-mapping>

</web-app>


需要引入servlet-api.jar

public class TestServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doGet(req, resp);
        ServletOutputStream outputStream = resp.getOutputStream();
        outputStream.print("1111111111");

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);

    }
}

Servlet

其实就是tomcat使用输入和输出流包装成一个Servlet，规定好特点的接口，让子类实现，达到回调的功能，最后通过解析http协议得到数据和 组成http协议组成动态页面

Servlet时java jdk定义的规范，它让我们程序员实现这个规范，也告诉web服务器像tomcat去调用这个规范，

同时servlet弱依赖request和response

生命周期

servlet的创建：

​ 在接受到第一次请求时创建，并且只创建一次（注意成员变量的线程安全）

​ 也可以在web的xml配置中给servlet配置loadonstartup属性，意思是容器启动，他就会创建

servlet的销毁

​ 在tomcat服务停掉时，才进行销毁

request
1
2
3

req.getParameter();//获取key的value
req.getParameterValues();获取同一个key的多个value
response
1
2
resp.addHeader("Content-Type","text/html");
     resp.getWriter().write();
乱码问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

前端页面传到后端参数乱码

get请求
第一种：
new String(param.getBytes("iso-8856-1","utf-8"));


第二种：
request.setCharacterEncoding("utf-8");
tomcat的server配置文件 把useBodyEncodingURI配置为true

第三种 ：
tomcat的server配置文件 把URIEncoding="utf-8";

port请求
第一种：
request.setCharacterEncoding("utf-8");

response：

response.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8")

1591463433571

请求的转发与重定向
1
2
3
4
5
6
7
转发
 req.getRequestDispatcher("/index.jsp").forward(req,resp);
 
 转发之间数据共享 通过req.setAttribute

重定向
  resp.sendRedirect("/index.jsp");

1591464691642

1591497343848

1591497392070

是由服务端告诉客户端让客户端保存需要缓存的数据

存的位置在客户端，指令在服务端

场景：同一个url传特定复杂参数

临时Cookie

1
2
3
4
5
    Cookie cookie=new Cookie("name","a");
        resp.addCookie(cookie);
此时的response返回体中会带有Cookie，
会话不断地情况下 以后地所有请求 会带着Cookie
一旦断开，就会失效

持久Cookie

1
2
3
4
5
6
7
8
        Cookie cookie=new Cookie("name","a");
        cookie.setMaxAge(3*24*60*60);//时间为3天
        resp.addCookie(cookie);
        
此时请求的response返回体中会带有Cookie，
会话断与不断地情况下 以后地所有请求 会带着Cookie，除非时间过期
 
    浏览器一旦检测到过期就不会带此 kv地Cookie
session

不同url数据共享

session的两种实现方式（也就是传递方式）：第一种通过cookies实现。第二种通过URL重写来实现

第一种方式的理解：就是把session的id 放在cookie里面（为什么是使用cookies存放呢，因为cookie有临时的，也有定时的，临时的就是当前浏览器什么时候关掉即消失，也就是说session本来就是当浏览器关闭即消失的，所以可以用临时的cookie存放。保存再cookie里的sessionID一定不会重复，因为是独一无二的。），当允许浏览器使用cookie的时候，session就会依赖于cookies，当浏览器不支持cookie后，就可以通过第二种方式获取session内存中的数据资源。

第二种方式的理解：在客户端不支持cookie的情况下使用。为了以防万一，也可以同时使用。

如果不支持cookie，必须自己编程使用URL重写的方式实现。

如何重写URL：通过response.encodeURL()方法

encodeURL()的两个作用

   第一个作用：转码（说明：转中文的编码，或者一些其他特殊的编码。就好比如网页的链接中存在中文字符，就会转换成为一些百分号或者其他的符号代替。）

第二个作用：URL后面加入sessionID，当不支持cookie的时候，可以使用encodeURL()方法，encodeUTL()后面跟上sessionID，这样的话，在禁用cookie的浏览器中同时也可以使用session了。但是需要自己编程，只要链接支持，想用session就必须加上encodeURL()。

提示：若想程序中永远支持session，那就必须加上encodeURL()，当别人禁用了cookie，一样可以使用session。

1
2
request.getSession().setMaxInactiveInterval();设置最大存活时间
session.invalidate();session失效，每次都声称新的sessionid
servletContext

不同客户端数据共享

运行在jvm上的每一个web应用都对应一个servletContext（servlet的运行环境）

servletContext可以被所有servlet访问

servletContext对象由服务器进行创建，他是单例的，使用时请考虑线程安全

api

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
this.getServletContext();获取servletContext对象
    
 this.getServletConfig().getServletContext();也可以获取到
    
  request.getSession().getServletContext();  也可以获取到
    
    
    
     servletContext.getRealPath("web.xml")；获取输出web.xml的真实路径,这个比较牛，我可以在一个servlet里面获取到真实路径，读取写在web目录下的文件，或者配置文件
    
    
      RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher();//返回一个包装路径信息的Dispatcher

    String contextPath = servletContext.getContextPath();//输出的该项目的虚拟根路径，每次都需要加上虚拟的根路径然后在加上 映射路径才可以访问

   // 把共享数据set进去
   servletContext.setAttribute();  
   servletContext.getAttribute()//取出共享数据

servletContext是一个web应用的上下文环境，简单理解就可以把他看成web.xml（先不考虑注解）

1
2
3
4
5
Enumeration<Servlet> getServlets();

 Dynamic addServlet(String var1, String var2);
 <T extends EventListener> void addListener(T var1);
看，这不就是web.xml里面的东西吗
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"> 
    <context-param>
        <param-name>namespace</param-name>
        <param-value>aaa</param-value>
    </context-param>
    <!-- 
		对应的java代码就是 servletContext.setInitParameter("namespace","aaa")
      那么就可以servletContext.getInitParameter("namespace")获取aaa
    -->
</web-app>
servletConfig
1
2
3
4
一个ServletConfig获取一个servlet的局部参数，就是启动参数，注意这个servletconfig在容器启动时就存在，它可以决定一个servelt什么时候启动
    
   ServletConfig servletConfig = this.getServletConfig();
   servletConfig.getInitParameter()

JSP

JSP是一种动态网页技术

动态生成网页数据，而不是动态效果地网页

常见地动态网页技术 JSP，ASP，PHP

1591530175604

本质：JSP就是一个Servlet，JSP也是java类，通过JSP引擎将JSP翻译成Servlet

JSP约等于java+html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<servlet>
       <servlet-name>jsp</servlet-name>
       <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
       <init-param>
           <param-name>fork</param-name>
           <param-value>false</param-value>
       </init-param>
       <init-param>
           <param-name>xpoweredBy</param-name>
           <param-value>false</param-value>
       </init-param>
       <load-on-startup>3</load-on-startup>
   </servlet>
   
   
   
       <servlet-mapping>
       <servlet-name>jsp</servlet-name>
       <url-pattern>*.jsp</url-pattern>
       <url-pattern>*.jspx</url-pattern>
   </servlet-mapping>
   所以JSP其实就是servlet
文件路径

C:\Users\Administrator.IntelliJIdea2019.3\system\tomcat\Unnamed_tomcatlearn\work\Catalina\localhost\ROOT\org\apache\jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
public final class test_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
      throws java.io.IOException, javax.servlet.ServletException {

    if (!javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      final java.lang.String _jspx_method = request.getMethod();
      if ("OPTIONS".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        return;
      }
      if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS");
        return;
      }
    }

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
      			null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write("\r\n");
      out.write("\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("    <title>111</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("first jsp\r\n");
      out.write("</body>\r\n");
      out.write("</html>\r\n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}
HttpJspBase
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {
    private static final long serialVersionUID = 1L;

    protected HttpJspBase() {
    }

    public final void init(ServletConfig config) throws ServletException {
        super.init(config);
        this.jspInit();
        this._jspInit();
    }

    public String getServletInfo() {
        return Localizer.getMessage("jsp.engine.info", new Object[]{"2.3"});
    }

    public final void destroy() {
        this.jspDestroy();
        this._jspDestroy();
    }

    public final void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this._jspService(request, response);
    }

    public void jspInit() {
    }

    public void _jspInit() {
    }

    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    public abstract void _jspService(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException;
}

1591536747720

使用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<%--  jsp注释  不会进行java代码--%>


<!--html 注释，这个会被jsp写道java代码，但是浏览器不会渲染它 -->


page 指令  变成servlet地参数设置
contentType  内容地类型  "texr/html"
language  翻译成什么语言 "java"
import 导包  多个包用逗号分开 " , "
pageEncoding 设置页面地编码格式
session 用来控制JSp翻译成servlet时，是否包含session
errorPage  错误页面
extends  翻译成servlet时选择性地继承指定类
<%@  page contentType=""    %>


<% 
这里是java代码  if(true){
%>
这里是html代码 <!--这里默认转成 out.write("")-->
<% 
这里是java代码  }
%>
出来地结果
 out.write("<body>\r\n");
  int a= 1+2; 
  out.write("\r\n");



全局代码块
<%! 写java方法，成员变量  %>
     最后转成servlet会加上
 public  void  a(){
    System.out.println("dsdsa");
}
     
引用变量，位置与<%  %> 一样，但是是被out.write(test() )  包起来
<%=test() %>
include

静态导入

1
2
3
4

<%@ include file="logo.jsp" %>

在jsp翻译成servlet引擎转译时，就把此文件内容包含进行，两个文件的代码整合在一起，全部放到_jspService方法中，所以只生成一个service，所以两个界面变量不能同名，运行效率搞，但是耦合也高

动态导入

1
2
3
4
5
6
7
<jsp:include page="logo.jsp" ></jsp:include>

在jsp翻译成servlet引擎转译后，请求此页面，所以共生成了两个servlet，可以有同名变量

相当于两个servlet的类之间的调用

耦合较低
forword
1
2
3
4

<jsp:forward page="forword.jsp"  >

    <jsp:param name="a" value="123" ></jsp:param></jsp:forward>
9大内置对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

jsp页面在转义成servlet时候，会自动声明一些对象，可以直接使用
    pageContext 封装(jsp,req,resp)，每一个jsp界面对应一个此对象，伴随当前页面的生命周期

    application 他是servletContext
    config时servletConfig
    session
    request
    response:响应对象
    
    out  就是对response.getWriter()封装，效率比response搞
    
    page就是 此jspServlet
    exception 需要配置<%@ page isErrorPage=true %>
    
    
    注意全局代码块使用不了
作用域
1
2
3
4
5
6
7
pageContext :表示当前页面，解决当前页面的数据共享问题， 获取其他内置对象
    
    request ，一起请求数据共享
    
    session 一次会话数据共享
    
    application 就是一个服务器不挂，就可以不同用户，不同会话共享数据
路径问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14

jsp界面使用 /* 是虚拟绝对路径 /代表了web目录

./ ../ 这种就是相对路径，更具当前jsp所在位置而定




*/
    可以使用全局路经声明
    
    
    <base href="xx"></base>
    此后的所有请求，就会带上xx，（xx要包含协议，主机名和端口和根路径）

EL和JSTL

servlet和Jsp通讯通过转发

EL表达式

Expression Language

让jsp书写方便，简化jsp中作用域或者请求数据的写法

语法结构${expression}

提供 . 和 [] 两种运算符获取数据

jsp获取servlet传统的方式和el表达式

1
2
3
4
5
6
7
8
9
10
11
12
13

name:<%=request.getParameter("name")>
bb:<%=request.getAtribute("bb")>
    
   EL表达式
   ${param.name} 请求自带的参数
    ${bb} 获取atribute里面的对象
    
    ${header} 获取请求头数据
     ${header['host']} 
    ${headerValues['accept-language'][0]}

	${cookie} 获取cookie

注意有作用域的顺序问题

1
2
3
4
5
6
7
pageContext-->request--->session-->application,肯定先从作用域小的开始获取

    
    获取指定作用域的变量
  ${pageScope.bb} or ${requestScope.bb}  or
    ${sessionScope.bb} or
        ${applicationScope.bb}

可以进行算术运算,关系运算,逻辑运算

1
2
3
4
5
6
7
8
9
${1+2}  +-*/
${1*2}

${1>2}  > < >= <= != ==

${a>2?'男':'女'}  
    || &&  !

el中的+号没有 字符串连接功能
JSTL标签库

jstl是对apche对el表达式的扩展，也就是 jstl 依赖el ，

jstl是标签语言，

意思就是被人写法，导入使用，jstl就是导入别人自定义标签库的

作用就是避免使用大量java逻辑代码来控制html标签

需要有下载jstl.jar,standard.jar

使用：

1
2
3
4
5
6
7
8
<%@ taglib prefix='c' uri="http://java.sun.com/jsp/jstl/core" %>

idea会报红， 
settings -->language & framworks-->schemas and DTDs-->+-->写入地址--->找对应的c.tld文件


<c:out value="哈哈"></c:out>
<c:out value="${name}"></c:out>

格式化标签库:fmt

函数标签库:c

xml标签库:

sql标签库:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
向作用域设置属性,默认向pageContext设置
<c:set var='java' value="1213" scope="request"></c:set>

<c:out value="${java}"></c:out>

移除作用域中的属性
<c:remove var="java"></c:remove>




<c:if test="${name}">
	<h1>
        41513
    </h1>
</c:if>

<c:choose>
	<c:when test="{a}">
        <h1>
            大大大
        </h1>
    </c:when>
    <c:when test="{b}">
        <h1>
            大大大
        </h1>
    </c:when>
</c:choose>



varStatus="sta" sta就是当前循环的状态

<c:forEach begin="${start}" end="${index}" step="${step}" varStatus="sta" var='i' items='${list}'>
    <h1>
    	dasadsda
        ${sta.index}--${sta.index}--${sta.first}--${sta.last}
        ${i}
    </h1>
</c:forEach>

学习网址 https://www.runoob.com/jsp/jsp-jstl.html

过滤器

请求的编码和返回编码，cors配置等 很多可以在每一个servlet中写一次，但是重复了

那么这些东西可以写在过滤器中 ，过滤器会比servlet的先执行，最后通过他返回，过滤器会被放到 容器的一条过滤链，是粗粒度的控制servlet

它的作用就是拦截servlet请求

分析web请求，对输入数据进行处理

阻止web请求和响应的进行

根据功能改动请求的头信息和数据体

与其他web资源协作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


public class MyFilter implements Filter {
    public void destroy() {
        System.out.println("过滤器的销毁,容器关闭时调用");
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {

        //请求处理
        chain.doFilter(req, resp); //调用其他过滤，没有就开始servlet的处理
        //返回处理
    }

    public void init(FilterConfig config) throws ServletException {
        System.out.println("==过滤器在容器初始化时就会启动===");
    }

}


web.xml
    
     <filter>
        <filter-name>my</filter-name>
        <filter-class>com.zgw.controller.MyFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>my</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

filterChain 本身就是一个filter

然后 dofilter里面 保留 下一个执行filter的位置，当一个filer里面调用filterChain.dofilter时，他会找到下一个调用的filter调用，知道没有，然后调用servlet

filterConfig就是根servletConfig差不多，就是可以获取启动入参，还有ServletContext

监听器

Servlet监听器用于监听一些重要事件的发生，监听器的对象可以在事件发生前，发生后可以做一些必要的处理

通过实现Servlet API 提供的listense的接口，可以监听正在执行的某一程序，并根据程序需求做出对应响应

Servlet2.3 提供对ServletContext和HttpSession对象的状态变化监听

Servlet2.4 新增 对ServletRequest对象状态变化监听

ServletContext都能监听，说明监听器的启动时间要远比filter和servlet早，可以监听到那些filter，servlet被加载到容器上下文

HttpSession 可义了解会话期间的状态（数据）并作出响应

ServletReqeust的监听 这就可以控制 web的请求的生命周期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
web.xml
    <listener>
    <listener-class>com.zgw.controller.MyListener</listener-class>
</listener>
        
        
        
public class MyListener implements ServletContextListener,
        HttpSessionListener, HttpSessionAttributeListener {

    // Public constructor is required by servlet spec
    public MyListener() {
    }

    // -------------------------------------------------------
    // ServletContextListener implementation
    // -------------------------------------------------------
    public void contextInitialized(ServletContextEvent sce) {
      /* This method is called when the servlet context is
         initialized(when the Web application is deployed).
         You can initialize servlet context related data here.
      */
        容器初始化调用
    }

    public void contextDestroyed(ServletContextEvent sce) {
      /* This method is invoked when the Servlet Context
         (the Web application) is undeployed or
         Application Server shuts down.
      */
       容器关闭调用 
    }

    // -------------------------------------------------------
    // HttpSessionListener implementation
    // -------------------------------------------------------
    public void sessionCreated(HttpSessionEvent se) {
        /* Session is created. */
        某一个Session创建调用
    }

    public void sessionDestroyed(HttpSessionEvent se) {
        /* Session is destroyed. */
          某一个Session销毁调用
    }

    // -------------------------------------------------------
    // HttpSessionAttributeListener implementation
    // -------------------------------------------------------

    public void attributeAdded(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute
         is added to a session.
         
      */
         某一个Session添加属性调用
    }

    public void attributeRemoved(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute
         is removed from a session.
      */
        某一个Session移除属性调用
    }

    public void attributeReplaced(HttpSessionBindingEvent sbe) {
      /* This method is invoked when an attribute
         is replaced in a session.
      */
          某一个Session替换属性调用
    }
                @Override
    public void requestDestroyed(ServletRequestEvent servletRequestEvent) {
         某一个request销毁完成调用
    }

    @Override
    public void requestInitialized(ServletRequestEvent servletRequestEvent) {
       某一个request初始化完成调用
    }
}

ServletContextListener

ServletContextAttributeListener

HttpSessionListener

HttpSessionActivationListener(session失效监听)

HttpSessionAttributeListener

HttpSessionBindingListener

ServletRequestListener

ServletRequestAttributeListener

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家