Javaweb详解二

最新推荐文章于 2023-09-21 18:57:12 发布

tiga super

最新推荐文章于 2023-09-21 18:57:12 发布

阅读量244

点赞数

分类专栏：笔记文章标签： java 开发语言后端 javaweb

本文链接：https://blog.csdn.net/weixin_45900005/article/details/120979299

版权

笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

4、实现重定向

一个web资源B收到客户端A请求后，B他会通知A客户端去访问另外一个web资源C，这个过程叫重定向

常见场景：

用户登录

使用方法:

void sendRedirect(String var1) throws IOException;

测试：.

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 请求重定向
        // 重定向的地址前要加上当前当前项目的路径,否则会找不到重定向后的网页
        // 若不加会跳转到: http://localhost:8080/img而不是http://localhost:8080/response/img
        // 拆解: sendRedirect是封装后的setHeader和setStatus
        /*
        // 修改响应头消息为重定位后的位置
        resp.setHeader("Location","/response/img");
        // 修改响应的状态码
        resp.setStatus(302);
         */
        resp.sendRedirect("/response/img");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

面试题：请你聊聊重定向和转发的区别？

相同点

页面都会实现跳转

不同点

请求转发的时候，url地址栏不会产生变化
重定向时候，url地址栏会发生变化；

5、简单实现登录重定向

表单提交后会进入requestest里面走doget方法然后重定向到success

index.jsp

<html>
<body>
<h2>Hello World!</h2>
<%--这里提交的路径,需要寻找到项目的路径--%>
<%--${pageContext.request.contextPath}代表当前的项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
    用户名: <input type="text" name="username"><br>
    密码: <input type="pwd" name="password"><br>
<%--    提交表单--%>
    <input type="submit">
</form>
<%--修改网页编码格式--%>
<%@ page contentType="text/html;charset=utf-8" %>
</body>
</html>

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 处理请求 从请求中获取参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println(username + ":" + password);
        // 将响应重定向的时候一定要注意添加web项目路径问题,否则会404(找不到网页)
        resp.sendRedirect("/response/success.jsp");
    }

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

<servlet>
        <servlet-name>request</servlet-name>
        <servlet-class>com.tiga.servlet.RequestTest</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>request</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>

请求转发保留第一次请求时的数据,重定向不保留
请求转发是在服务端内部跳转(一次请求一次响应),重定向的跳转是把第一次请求的响应返回给客户端,让客户端重新发起一次跳转,(两次请求两次响应)

6.7、HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息；

获取参数，请求转发

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 修改请求和响应的编码格式
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        // 通过请求获取参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbys = req.getParameterValues("hobbys");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        // 通过请求转发
        System.out.println(req.getContextPath());
        // getContextPath(): 获取项目路径
        // 这里的 / : 代表当前的webapp(web应用), 请求转发不用加项目名
        req.getRequestDispatcher("/success.jsp").forward(req,resp);
        // 修改响应编码格式
        resp.setCharacterEncoding("utf-8");
    }

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

面试题：请你聊聊重定向和转发的区别？

相同点

页面都会实现跳转

不同点

请求转发的时候，url不会产生变化 307
重定向时候，url地址栏会发生变化； 302

重定向路径需要写项目名请求转发不需要写

7、Cookie、Session

Cookie就是饼干！很好理解的，就是你第一次访问我我会拦截你，然后我给你分一块饼干，当你有了这个饼干就相当于有了一个令牌，以后访问不会拦截你

客户端：学生上学有发票（cookie）服务器：学校有记录(session)

7.1、会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；

有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话；就是记录了你的一些东西

客户端服务端

服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了； cookie
服务器登记你来过了，下次你来的时候我来匹配你； seesion

7.2、保存会话的两种技术

cookie

客户端技术（响应，请求）

session

服务器技术，利用这个技术，可以保存用户的会话信息？我们可以把信息或者数据放在Session中！

常见场景：网站登录之后，你下次不用再登录了，第二次访问直接就上去了！

从请求中拿到cookie信息
服务器响应给客户端cookie

Cookie[] cookies = req.getCookies(); //获得客户端请求的Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的value
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个cookie对象
cookie.setMaxAge(24*60*60); //设置cookie的最长有效期
resp.addCookie(cookie); //服务端响应给客户端一个cookie

cookie：一般会保存在本地的用户目录下 appdata；

一个网站cookie是否存在上限！聊聊细节问题

一个Cookie只能保存一个信息；比如只能new一个String类型的字符串
一个web站点可以给浏览器发送多个cookie，每个站点最多存放20个cookie；
Cookie大小有限制: 4kb；
浏览器上限为300个cookie

删除Cookie的方法；

不设置有效期，关闭浏览器，自动失效；
设置最长有效期时间为 0 ；

编码,解码:

Cookie cookie = new Cookie("name", URLEncoder.encode("超人", "UTF-8"));// 编码
out.write(URLDecoder.decode(cookie.getValue(),"UTF-8"));// 解码

a.服务端向客户端增加cookie :response对象；服务端向客户端获取对象：request对象
b.不能直接获取某一个单独对象，只能一次性将全部的cookie拿到

通过F12可以发现除了自己设置的Cookie对象外，还有一个name为 JSESSIONID的cookie

建议 cookie只保存英文数字，否则需要进行编码、解码

// 保存用户上一次访问的时间
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 服务器,告诉你,你来的时间,把这个时间封装成为一个信件,你下次带来,我就知道你来了
        // 解决客户端响应时中文乱码
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        // 响应输出信息到客户端
        // 伏笔: 变量名设置为out: out是jsp的内置对象
        PrintWriter out = resp.getWriter();
        // Cookie: 服务器从客户端以请求方式获取
        Cookie[] cookies = req.getCookies();// 返回数组,说明Cookie可能存在多个
        // 判断Cookie是否存在
        if (cookies != null) {
            // 若Cookie存在
            out.write("您上次访问时间是: ");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                // 比较Cookie的名字,并获取Cookie的名字(key-value键值对)
                // 用字符串来比较防止空指针异常,因为getName()可能是为null
                if ("lastLoginTime".equals(cookie.getName())) {
                    // 把字符串类型变成时间戳,获取Cookie中的value值
                    Long lastLoginTime = Long.parseLong(cookie.getValue());
                    // 把时间写出到客户端
                    Date date = new Date(lastLoginTime);
                    // toLocalString(): 本地时间格式化
                    out.write(date.toLocaleString());
                }
            }
        } else {
            // 向客户端响应信息,如果Cookie不为空,则不会执行
            // 不执行原因: 因为浏览器自己携带了1个或多个Cookie去访问你服务器了，你可以手动删除再尝试访问。
            out.write("这是您第一次访问本站");
        }
        // 服务器给客户端响应一个Cookie,第一次访问后更新时间(Cookie的value值),因为下面的代码每运行一次程序都会执行
        // 每次访问都会给你一个小饼干，有了也会给你新的
        // 创建一个Cookie对象
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+ "");
        // 设置Cookie的最长有效期为 1天,把浏览器关了(结束会话),Cookie仍然保留着
        cookie.setMaxAge(24*60*60);
        // 响应时传入cookie
        resp.addCookie(cookie);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

public class CookieDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建一个Cookie对象,key值(名字)必须要和要删除的Cookie的名字相同
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");
        // 设置Cookie的最长有效期为0,
        cookie.setMaxAge(0);
        // 响应给客户端立马过期
        resp.addCookie(cookie);
        // 配置一下Srvlet映射地址
    }

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

// 在通信里传输中文最好用URLEncoder(编码类)和URLDecoder(解码类)
public class CookieDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 修改请求响应的编码格式
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        // 服务端通过客户端的请求来获得一个Cookie
        Cookie[] cookies = req.getCookies();
        // 通过响应获取一个输出流
        PrintWriter out = resp.getWriter();
        // 判断Cookie是否存在(为空)
        if (cookies != null) {
            out.write("你的名字是: ");
            // 若Cookies存在,循环遍历判断Cookie的key值是否匹配
            for (int i = 0; i < cookies.length; i++) {
                // Cookie的编码和解码
                Cookie cookie = cookies[i];
                // 判断cookie的key是否匹配
                if ("name".equals(cookie.getName())) {
                    // Cookie执行的也要修改转码格式
                    // 响应到客户端时解码
                    // 响应给客户端cookie的value值
                    out.write(URLDecoder.decode(cookie.getValue(),"UTF-8"));
                }
            }
        }else{
            // 若Cookies数组不存在
            out.write("这是您第一次访问本站");
        }
        // 创建一个新的Cookie,添加到客户端时编码
        Cookie cookie = new Cookie("name", URLEncoder.encode("超人", "UTF-8"));
        // 通过服务端响应给客户端添加Cookie
        resp.addCookie(cookie);
    }

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

7.4、Session（重点）

session: 出生到死，就是你的唯一“会话”

session :会话
a.浏览网站：开始-关闭
b.购物：浏览、付款、退出
c.电子邮件：浏览、写邮件、退出
开始-结束
session执行机制:

客户端第一次请求服务端时,(JSESSIONID和sessionId匹配失败),服务端会生成一个session对象(用于保存该客户的信息);
并且每个session对象都会自带存有一个唯一的sessionId(用于区分其他不同客户端请求同一服务端的session对象);并且会把sessionID的值复制一份成JSESSIONID,服务端会把JSESSIONID放到服务端生成的cookie里,然后服务端向客户端做出响应,响应时会把Cookie发送回给客户端,因此客户端的id和服务端的id就一一对应起来了,就不会乱了;服务端的sessionID和客户端的JSESSIONID一一对应用来区分客户
服务端又会生成一个cookie,并且该cookie的key(name)=JSESSIONID,value=服务端sessionId的值;
然后,服务端会在响应客户端的同时,间该cookie发送给客户端,至此,客户端就有了一个cookie(JSESISONID);因此,客户端的cookie就可以和服务端的session一一对应(JSESSIONID - sessionID)

客户端第二/n次请求服务端时: 服务端会先用客户端的cookie中的JSESSIONID,去服务端的session中匹配sessionId,若匹配成功(cookie中的JSESSIONID等于session中的sessionId),说明此用户不是第一次访问,无需登录

一个浏览器(客户端)对应一个Session

什么是Session：

服务器会给每一个用户（浏览器）创建一个Seesion对象；
一个Seesion独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
用户登录之后，整个网站它都可以访问！–> 保存用户的信息；保存购物车的信息……

Session和cookie的区别：

Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
Session把用户的数据写到用户独占Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
Session对象由服务创建；

使用场景：

保存一个登录用户的信息；
购物车信息；
在整个网站中经常会使用的数据，我们将它保存在Session中；

作用域：ServletContext/ApplicationContext 全局(共享)（当前web应用），Session 会话,私有的,非共享的

使用Session:

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        resp.setCharacterEncoding("utf-8");
        // 通过客户端的请求获取Session对象
        HttpSession session = req.getSession();
        // 给Session存东西,Session不仅可以存字符,还可以存对象
        session.setAttribute("name", new Person("超人",20));
        // 获取Session的ID
        String sessionId = session.getId();
        // 判断Session是否新创建
        if (session.isNew()) {
            // 若是新创建,则向客户端响应信息
            resp.getWriter().write("session第一次创建成功" + sessionId);
        }else{
            // 若非新创建
            resp.getWriter().write("session已在服务器存在了, ID为: " + sessionId);
        }
        // 注册Servlet映射地址
        // Session对象创建的时候做了什么
        // 客户端第一次访问服务端时,服务端创建了一个Session对象自带存放了唯一一个sessionId,并且复制一份成JSESSIONID,
        // 并且把JESSIONID放到服务端生成的cookie里,服务端响应时发回cookie给客户端,
        // Cookie cookie = new Cookie("JSESSIONID", sessionId);
        // resp.addCookie(cookie);
    }

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

public class SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        // 获取session
        HttpSession session = req.getSession();
        Person person = (Person) session.getAttribute("name");
        System.out.println(person.toString());
    }

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

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取Session对象
        HttpSession session = req.getSession();
        // 移除Session
        // session.removeAttribute("name");
        // 手动注销Session,客户端(浏览器)的sessionId会被删除,但浏览器再访问服务端立马会生成新的,效果同于关闭浏览器
        session.invalidate();
        // 注册Servlet并映射地址
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

会话自动过期：web.xml配置

<!--    设置Session的默认失效时间-->
    <session-config>
<!--        x分钟后Session自动失效,以分钟为单位-->
        <session-timeout>1</session-timeout>
    </session-config>

存在多个用户访问请求,Session是获取针对个人的资源,而ServletContext/ApplicationContext可以获取共享资源,是整个应用级的,多个客户端都可以访问ServletContext/ApplicationContext

8、JSP

8.1、什么是JSP

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！

最大的特点：

写JSP就像在写HTML
区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

8.2、JSP原理

思路：JSP到底怎么执行的！

代码层面没有任何问题
服务器内部工作

tomcat中有一个work目录；

IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录

发现页面(jsp文件)转变成了Java程序！

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！
因为jsp继承了HttpServlet类

JSP最终也会被转换成为一个Java类！

JSP 本质上就是一个Servlet,只不过简化了一些东西,他帮你做了很多事情,只需要写页面部分就可以了,相当于jsp是封装好的Servlet

//初始化
  public void _jspInit() {
      
  }
//销毁
  public void _jspDestroy() {
  }
//JSPService
  public void _jspService(.HttpServletRequest request,HttpServletResponse response)

判断请求是get还是post类型

内置一些对象: jsp中已经创建好的对象,在写jsp时嵌入java代码可以直接使用这些对象

final javax.servlet.jsp.PageContext pageContext;  //页面上下文
javax.servlet.http.HttpSession session = null;    //session
final javax.servlet.ServletContext application;   //applicationContext
final javax.servlet.ServletConfig config;         //config
javax.servlet.jsp.JspWriter out = null;           //out(输出对象)
final java.lang.Object page = this;               //page：当前
HttpServletRequest request                        //请求
HttpServletResponse response                      //响应

这里的out就是前面resp.getWriter

jsp文件输出页面前加入的代码

response.setContentType("text/html");       //设置响应的页面为html类型
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;

以上的这些个对象我们可以在JSP页面中直接使用！

jsp页面要访问浏览器才会生成

通过浏览器上网本质上就是访问服务器,服务器里有web容器(Tomcat),Tomcat中可以放很多网站(web应用),按对应的地址一个访问一个,访问到Tomcat之后会判断对应的请求,如果访问的是jsp就去找对应的jsp页面,访问到jsp之后不能直接使用,在web容器的作用下,将jsp页面转换成java文件,经过转换后得到一个新文件: xxx.jsp.java,得到之后要运行,java文件就被编译成xxx.jsp.class文件,编译为class文件之后就被调到服务器里面,用户真正访问的是服务器,因此,服务器响应得到处理完毕的class对象,这个对象就是Servlet

jsp只是别人帮忙做好了,做一个封装,他帮我们去做事情,我们去访问jsp页面最后还是访问Servlet

在JSP页面中；

只要是 JAVA代码就会原封不动的输出；

如果是HTML代码，就会被转换为：

out.write("<html>\r\n");

这样的格式，输出到前端！

配置Tomcat时把war包改为war explored,~~启动项目时选择uddate classes and resources 实现热更新,无需重启服务器,启动速度快~~

8.3、JSP基础语法

任何语言都有自己的语法，JAVA中有,。 JSP 作为java技术的一种应用，它拥有一些自己扩充的语法（了解，知道即可！），Java所有语法都支持！

JSP表达式

  <%--
jsp表达式
作用: 用来将程序的输出,输出到客户端
语法格式: <%= 变量或表达式%> 相当于java语法中的: out.write()
--%>
  <%= new java.util.Date()%>

jsp脚本片段

  <%--  jsp脚本片段--%>
<%--jsp脚本表达式: <% %>--%>
<%
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    out.println("<h1>sum= " + sum + "</h1>");// jsp.java可以自动把标签转移成html格式,因为jsp类里的response对象调用setContentType方法转换响应格式
%>

脚本片段的再实现

<%
    // 因为变量被定义在了同一个方法_jspService方法里,所以变量不能重复定义声明
    int x = 10;
    out.print(x);
%>
<hr>
<p>jsp文档</p>
<%
    int y = 2;
    out.println(y);
%>
<%-- java代码中嵌入HTML元素 --%>
<%
    for (int i = 0; i < 5; i++) {
%>
<%--本质是同一个Servlet(java)程序--%>
<%--因为是写在同一个jsp类的jspService方法中才能被请求处理,可以在java代码中夹入HTML标签--%>
<h1>hello world <%=i%></h1>
<%
    }
%>

JSP声明

<%--jsp中叫全局变量，JAVA里叫成员变量--%>
<%--之前写的代码没用<%! %>都被放在jspService方法里面,这些写法称作jsp表达式输出或一个jsp片段,都是为了这个方法里去做的--%>
<%--jspService方法是为了给客户端响应,而这里面的代码被写到了jsp生成java的类里,作用域更高了,这叫jsp声明--%>
<%!
static {
    System.out.println("loading Servlet");
}
    private int globalVar = 0;
    public static void show(){
        System.out.println("进入了方法show");
    }
%>

JSP声明：<%!%>里的代码会被编译到JSP生成Java的类中！其他的，就会被生成到_jspService方法中！方法里面的可以调用方法外面的,而外面的作用于更高,这个方法随着方法消失就没了

在JSP，嵌入Java代码就可以用java了！

jsp语法:

<%%> 
<%=%>
<%!%>
<%--注释--%>

JSP的注释，不会在客户端显示，HTML的就会！

8.4、JSP指令

<%--这些代码作用域都在jspService方法里面--%>
<%--
jsp表达式
作用: 用来将程序的输出,输出到客户端
语法格式: <%= 变量或表达式%> 相当于java语法中的: out.write()
--%>
<%--通过导入<%@ page import="java.util.*" %>可以不用写全类名--%>
<%= new Date()%>
<%--分割线--%>
<hr>
<%--  jsp脚本片段--%>
<%--jsp脚本表达式: <% %>--%>
<%
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    out.println("<h1>sum= " + sum + "</h1>");// jsp.java可以自动把标签转移成html格式,因为jsp类里的response对象调用setContentType方法转换响应格式
%>
<%
    // 因为变量被定义在了同一个方法_jspService方法里,所以变量不能重复定义声明
    int x = 10;
    out.print(x);
%>
<hr>
<p>jsp文档</p>
<%
    int y = 2;
    out.println(y);
%>
<%-- java代码中嵌入HTML元素 --%>
<%
    for (int i = 0; i < 5; i++) {
%>
<%--本质是同一个Servlet(java)程序--%>
<%--因为是写在同一个jsp类的jspService方法中才能被请求处理,可以在java代码中夹入HTML标签--%>
<h1>hello world <%=i%></h1>
<%
    }
%>
<hr>
<%--jsp中叫全局变量，JAVA里叫成员变量--%>
<%--之前写的代码没用<%! %>都被放在jspService方法里面,这些写法称作jsp表达式输出或一个jsp片段,都是为了这个方法里去做的--%>
<%--jspService方法是为了给客户端响应,而这里面的代码被写到了jsp生成java的类里,作用域更高了,这叫jsp声明--%>
<%!
static {
    System.out.println("loading Servlet");
}
    private int globalVar = 0;
    public static void show(){
        System.out.println("进入了方法show");
    }
%>
<hr>
<!-- 我是HTML注释-->

自定义错误页面

<%--页面的文本类型是HTML格式,并且编码生成utf-8,页面的编写语言是java--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--这里的路径都是以web开始的 如果按照之前module建项目的话,路径是以webapp开始--%>
<%--定制错误页面方法一--%>
<%--<%@page errorPage="error/500.jsp" %>--%>
<%--方法二: 在web.xml中配置error-page--%>
<%--修改了web.xml就必须要重启(服务器)Tomcat--%>
<%--显式的声明这是个错误页面--%>
<%@page isErrorPage="true" %>
<%--修改页面编码格式--%>
<%@page pageEncoding="utf-8" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    int x = 1 / 0; // 算术异常,500错误
%>

<%--定制错误页面--%>

<html>
<head>
    <title>Title</title>
</head>
<body>
<img src="../img/500.jpg" alt="500">

还可以在web.xml中配置错误页面

<!--    配置错误页面-->
    <error-page>
        <error-code>404</error-code>
<!--        位置开头一定要先加斜杠表示当前项目,否则会报错-->
        <location>/error/404.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/error/500.jsp</location>
    </error-page>

包含(插入)页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--@include会将两个页面合二为一,就是会把两个页面的东西抽离出来放到一起,最后生成一个页面--%>
<%--定义相同变量会重名--%>
<%--插入页面--%>
<%--<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%
    int i = 0; // 报错
%>
<%@include file="common/footer.jsp"%>--%>
<%--相当于拿到了两个页面的文件,这些文件在jsp生成java的类里的static代码块中包含进来了,相当于拼接页面,最后生成三个页面--%>
<%--jsp标签导入页面
jsp:include:拼接页面,本质还是三个,三个页面定义的变量互不影响
--%>
<jsp:include page="/common/header.jsp"/>
<h1>我是主体</h1>
<%
    int i = 0;
%>
<jsp:include page="/common/footer.jsp"/>
</body>
</html>

8.5、9大内置对象

客户端第一次访问jsp页面的时候,会转成java类,然后转换成class对象,变成class对象后自动生成9个对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application 【SerlvetContext】存东西
config 【SerlvetConfig】
out
page ，不用了解
exception

pageContext.setAttribute("name1","超人1号");// 保存的数据只在一个页面中有效
request.setAttribute("name2","超人2号");// 保存的数据只在一次请求中有效,请求转发会携带这个数据
session.setAttribute("name3","超人3号");// 保存的数据只在一次会话中有效,从打开浏览器到关闭浏览器
application.setAttribute("name4","超人4号");// 保存的数据只在服务器中有效,从打开服务器到关闭服务器

应用场景：

request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据；

8.6、JSP标签、JSTL标签、EL表达式

<!--        导入jstl表达式依赖-->
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl-api -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
        <!--Jstl表达式依赖的standard标签库的依赖-->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

EL表达式： ${ }
作用:

获取数据
执行运算
获取web开发的常用对象

JSP标签

<%--标签夹层写注释会报500异常--%>
<%--插入页面--%>
<%--<jsp:include page=""></jsp:include>--%>
<%--页面转发--%>
<%--
可以在请求转发中携带参数
http://localhost:8080/jsptag.jsp?name=tiga&age=18
--%>
<jsp:forward page="jsptag2.jsp">
    <jsp:param name="name" value="tiga"/>
    <jsp:param name="age" value="18"/>
</jsp:forward>

<%--在请求转发页面中提取参数--%>
名字: <%=request.getParameter("name")%>
年龄: <%=request.getParameter("age")%>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和Java代码一样！

格式化标签

SQL标签

XML 标签

核心标签 （掌握部分）

JSTL标签库使用步骤

引入对应的 taglib
比如核心标签

<%–引入JSTL核心标签库,才能用JSTL标签 c代表core–%>
<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

使用其中的方法
在Tomcat9 也需要引入 jstl的包，否则会报错：JSTL解析错误

在tomcat的lib文件夹下导入上面两个jar包

JSTL标签 - c: if

<body>
<h1>if测试</h1>
<hr>
<%--
EL表达式: 获取表单中的数据
获取属性的参数: ${param.参数名}
--%>
<%--和Java中的if条件判断一样--%>
<form action="coreif.jsp" method="get">
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">
</form>
<%--判断如果提交的用户名如果是管理员,则登录成功--%>
<%--test: 表示是必须要写的条件--%>
<%--test值可以用来做是非判断--%>
<%--var用来接收test比较出来的是非返回值--%>
<%--JSTL标签代码只是看起来更整齐,弥补html标签的不足--%>
<c:if test="${param.username == 'admin'}" var = "isAdmin">
    <c:out value="管理员欢迎您"></c:out>
</c:if>
<%--若不是管理员,则返回false--%>
<c:out value="${isAdmin}"></c:out>
</body>

JSTL标签 - c:choose c:when

<body>
<%--c:set用于存储数据,类似于if-else/switch,只要满足就跳出循环--%>
<%--定义一个变量score,值为85--%>
<c:set var="score" value="85"/>
<c:choose>
    <c:when test="${score >= 90}">
        成绩优秀
    </c:when>
    <c:when test="${score >= 80}">
        良好
    </c:when>
    <c:when test="${score >= 70}">
        一般
    </c:when>
</c:choose>
</body>

c:forEach

<body>
<%--先创建一个集合和往集合中存放对象--%>
<%
    ArrayList<String> people = new ArrayList<>();
    // 往集合里添加元素
    people.add(0, "张三");
    people.add(1, "李四");
    people.add(2, "王五");
    people.add(3, "赵六");
    people.add(4, "孙七");
    // 创建一个请求对象名叫list,属性名为people
    request.setAttribute("list", people);
%>
<%--遍历集合元素--%>
<%--
items: 表示要遍历的对象
var: 表示遍历对象中的每一个元素
begin: 表示开始遍历下标
end: 表示结束遍历下标
step: 表示增长步长
--%>
<c:forEach var="peoples" items="${list}">
<%--    打印循环的值--%>
    <c:out value="${peoples}"></c:out><br>
</c:forEach>
=============<br>
<c:forEach var="peoples" items="${list}" begin="1" end="4" step="2">
    <c:out value="${peoples}"></c:out>
</c:forEach>
</body>

9、JavaBean

实体类

JavaBean有特定的写法：

必须要有一个无参构造
属性必须私有化
必须有对应的get/set方法；

一般用来和数据库的字段做映射 ORM；

ORM ：对象关系映射

表—>类
字段–>属性
行记录---->对象

people表

id	name	age	address
1	超人1号	3	广州
2	超人2号	18	广州
3	超人3号	100	广州

javabean实现类

class People{
    private int id;
    private String name;
    private int id;
    private String address;
}

class A{
    new People(1,"超人1号",3，"西安");
    new People(2,"超人2号",3，"广州");
    new People(3,"超人3号",3，"南京");
}

<body>
<%--通过jsp使用实体类,作用域为当前页面--%>
<%--
id: 表示类实例化(对象)的变量名
class: 数据库映射的类名
scope: jsp页面的作用域
--%>
<%
    // 等价于:
    // People people = new People();
%>
<jsp:useBean id="people" class="com.tiga.pojo.People" scope="page"/>
<%
    /*
    等价于:
    people.setId(1);
    people.setName("超人");
    people.setAge(10);
    people.setAddress("广州");
    */
%>
<%--通过jsp设置属性--%>
<%--设置的对象名为name,对象属性为property 设置值为value--%>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="name" value="超人"/>
<jsp:setProperty name="people" property="age" value="10"/>
<jsp:setProperty name="people" property="address" value="广州"/>
<%--
等价于:
<%=people.getId()%>
--%>
<%--通过jsp获取属性--%>
id: <jsp:getProperty name="people" property="id"/>
姓名: <jsp:getProperty name="people" property="name"/>
年龄: <jsp:getProperty name="people" property="age"/>
地址: <jsp:getProperty name="people" property="address"/>
</body>

过滤器
文件上传
邮件发送
JDBC 复习：如何使用JDBC , JDBC crud， jdbc 事务

10、MVC三层架构

什么是MVC： Model view Controller 模型(实体类,数据库表中对应的的字段)、视图(jsp页面)、控制器

10.1、早些年

用户直接访问控制层，控制层就可以直接操作数据库；

10.2、MVC三层架构

(View层)登录-(Controller层)接受请求-(Modelr层)处理请求-交给业务层处理业务-dao层验证-数据库

Model

业务处理：业务逻辑（Service）
数据持久层：CRUD （Dao）

View

展示数据
提供链接发起Servlet请求（a，form，img…）

Controller （Servlet）

接收用户的请求：（req：请求参数、Session信息….）
交给业务层处理对应的代码
控制视图的跳转

登录—>接收用户的登录请求—>处理用户的请求（获取用户登录的参数，username，password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）—>Dao层查询用户名和密码是否正确–>数据库

11、Filter （重点）

Filter：过滤器，
功能:
1.用来拦截传入的请求和传出的响应,过滤网站的数据；
2.修改或以某种方式处理正在客户端和服务端之间交换的数据流

实际开发中的使用场景:

处理中文乱码
登录验证….

客户端访问服务器时,请求会先进到过滤器再进到Servlet,还可以同时加多个过滤器,这多个会形成一个链,有先后顺序

如何使用过滤器?

与使用Servlet类似,Filter是java Web提供的一个接口,开发者只需要自定义一个类并实现该接口即可.

// 过滤器和web服务器同生共死
public class CharacterEncodingFilter implements Filter {
    // 初始化
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("characterEncodingFilter已初始化");
    }
    // chain: 链 可以有很多个过滤器
    /*
    1.过滤方法中的所有代码,在过滤特定请求(在web.xml中配置的filter请求)的时候都会执行
    2.必须让过滤器继续同行
     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        System.out.println("CharacterEncodingFilter执行前");
        // 让客户端的请求继续往下走,如果不写,程序到过滤器就被拦截停止,而无法继续访问到Servlet
         chain.doFilter(request,response);
        System.out.println("CharacterEncodingFilter执行后");
    }
    // 销毁: web服务器关闭的时候,过滤会销毁
    public void destroy() {
        System.out.println("characterEncodingFilter已销毁");
    }
}

与Servlet不同的是,实现Filter接口可以只实现doFilter一个方法,因为jdk1.8的新特性,Filter接口中,只有doFilter是抽象方法,初始,销毁方法都是默认方法,default方法是已经重写过的方法,因此实现类不被再重写,而实现Servlet接口也不用重写所有方法是因为GenericServlet实现了Servlet接口,在这个实现类中已经屏蔽了一些抽象方法.

web.xml中配置Filter

<servlet>
        <servlet-name>ShowServlet</servlet-name>
        <servlet-class>com.tiga.servlet.ShowServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ShowServlet</servlet-name>
        <url-pattern>/servlet/show</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>ShowServlet</servlet-name>
        <url-pattern>/show</url-pattern>
    </servlet-mapping>
<!--    过滤特定的请求-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
<!--        过滤器映射的类-->
        <filter-class>com.tiga.filter.CharacterEncodingFilter</filter-class>
    </filter>
<!--    要过滤的请求-->
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
<!--        只要是/servlet下的任何请求,都要经过这个过滤器-->
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>

注意: doFilter方法中处理完业务逻辑之后,必须添加filterChain.doFilter(request,response);否则请求/响应无法向后传递,一直停留在过滤器中.

12.监听器

如何使用监听器?
写一个普通类实现监听器接口

// 统计在线人数: 统计session
public class OnlineCountListener implements HttpSessionListener {
    // 创建session监听
    // 一旦创建session就会触发一次这个事件
    public void sessionCreated(HttpSessionEvent se) { // 形参代表session事件的一个对象
        ServletContext sc = se.getSession().getServletContext();
        // 获取sessionId
        System.out.println(se.getSession().getId());
        /*
        session销毁:
        1.手动销毁: se.getSession().invalidate();
        2.自动销毁: 在web.xml中配置session过期时间
         */
        // 假设session已经创建了,就去获取OnlineCount对象
        Integer onlineCount = (Integer) sc.getAttribute("OnlineCount");
        if (onlineCount == null) {
            // 若为空,则给人数变量加一个
            onlineCount = new Integer(1);
        }else{
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }
        // 设置属性
        sc.setAttribute("OnlineCount", onlineCount);
    }
    // 销毁session监听
    // 一旦销毁session就会触发一次这个事件
    public void sessionDestroyed(HttpSessionEvent se) {
        // 获取客户端session的上下文
        ServletContext sc = se.getSession().getServletContext();
        // 假设session已经创建了,就去获取OnlineCount对象
        Integer onlineCount = (Integer) sc.getAttribute("OnlineCount");
        // 判断onlineCount是否存在
        if (onlineCount == null) {

            onlineCount = new Integer(0);
        } else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }
        // 把原来的值设置回去,减少新变量的产生
        sc.setAttribute("OnlineCount",onlineCount);
    }
}

在web.xml中配置Listener

<!--    注册监听器-->
    <listener>
        <listener-class>com.tiga.listener.OnlineCountListener</listener-class>
    </listener>
<!--    session自动销毁-->
    <!--<session-config>
        <session-timeout>1</session-timeout>
    </session-config>-->

过滤器过滤用户登录,注销,权限案例

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取前端请求参数
        String username = req.getParameter("username");
        // 判断参数是否存在
        if (username.equals("admin")) {
            // 登录成功, 设置用户session的键和值
            req.getSession().setAttribute("USER_SESSION",req.getSession().getId());
            resp.sendRedirect("/sys/success.jsp");
        } else {
            // 登录失败
            resp.sendRedirect("/error.jsp");
        }
    }

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

// 用户注销类
public class LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取用户的session
        Object user_session = req.getSession().getAttribute("USER_SESSION");
        // 判断用户是否注销
        if (user_session != null) {
            // 若用户session存在,则用户可以通过注销移除session
            req.getSession().removeAttribute("USER_SESSION");
            // 移除后用户不能再进入成功页面,把用户页面重定向到登录页面
            resp.sendRedirect("Login.jsp");
        }else{
            resp.sendRedirect("Login.jsp");
        }
    }

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

<body>
<h1>登录</h1>
<form action="/servlet/login" method="post">
    <input type="text" name="username">
    <input type="submit">
</form>
</body>

<body>
<%--
过滤用户一般写在过滤器里
<%
    Object user_session = request.getSession().getAttribute("USER_SESSION");
    if (user_session == null) {
        response.sendRedirect("/Login.jsp");
    }
%>--%>
<h1>主页</h1>
<p><a href="/servlet/logout">注销</a></p>
</body>

<body>
<h1>错误</h1>
<h3>没权限</h3>
<a href="/Login.jsp">返回登录页</a>
</body>

tiga super

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Javaweb详解二

4、实现重定向一个web资源B收到客户端A请求后，B他会通知A客户端去访问另外一个web资源C，这个过程叫重定向常见场景：用户登录使用方法:void sendRedirect(String var1) throws IOException;测试：.public class RedirectServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpSer
复制链接

扫一扫