JavaWeb知识点汇总

JavaWeb知识点汇总

前言：跟了狂神javaweb学习有一阵子了，这里简单进行笔记总结，也是第一次使用markdown写这么长的文章，虽然是跟着敲的，也是多理解了一遍，以及具体上手自己写的代码和相应效果图。发布于此，进行学习记录以及笔记分享

Http

4.1什么是Http

Http（超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上。

1. 响应状态码

   200：请求响应成功 200

   3**：请求重定向

   404：资源不存在 404

   5**：服务器代码错误 500 502网关错误

5、Maven

为什么要学习这个技术

• 帮我们导入和配置jar包

5.1 Maven项目架构管理工具

目前使用就是方便导入jar包的

Maven的核心思想：约定大于配置

• 有约束，不要去违反

• maven会规定好如何去编写我们的java代码，必须要按照这个规定

  5.2 在build中配置resource，来防止我们资源导出问题

  <build>
  	<resources>
  		<resource>
  			<directory>src/main/resources</directory>
              <includes>
  				<include>**/*.properties</include>													<include>**/*.xml</include>
              </includes>
  			<filtering>true</filtering>
          </resource>
  		<resource>
  			<directory>src/main/java</directory>
              <includes>
  				<include>**/*.properties</include>
                  <include>**/*.xml</include>
              </includes>
  			<filtering>true</filtering>
          </resource>
  </resources>
  </build>
  

6 Servlet

6.1 servlet简介

• Servlet就是sun公司开发的web的一门技术
• 接口叫做servlet
  • 编写一个类，实现servlet接口
  • 把开发好的java类部署到web服务器中

把实现了servlet接口的java程序叫做，servlet

1. 子项目web.xml文件替换成最新的

<?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/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">
</web-app>

2. 搭建maven结构

   1. java
   2. resources

3. 编写一个servlet程序

   1. 编写一个普通类
   2. 实现servlet接口，直接继承HttpServlet

4. Alt+F12构造等方法快捷键，ctrl + o， Fn+Alt+F12PowerShell

5. 

6. alt + enter快速new方法

   

7. 

8. <!--注册servlet -->
       <servlet>
           <servlet-name>hello</servlet-name>
           <servlet-class>com.heze.servlet.HelloServlet</servlet-class>
       </servlet>
       <!--servlet请求路径-->
       <servlet-mapping>
           <servlet-name>hello</servlet-name>
           <url-pattern>/hello</url-pattern>
       </servlet-mapping>
   

9. 配置tomcat

   

10. 启动测试，OK！

    6.2 Servlet原理

    1. Servlet是由Web服务器调用，web服务器在收到请求后，调用service（,）方法

    6.3 Mapping问题

    1. 一个servlet可以指定一个映射路径

    <servlet-mapping>
    	<servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    

    2. 一个Servlet可以指定多个映射路径

    3. 一个Servlet可以指定通用映射路径

    4. 指定一些后缀或者前缀等。。。

    

    5. 默认请求路径

       

    6. 优先级问题

       指定了固有的映射路径优先级最高，如果找不到就会走默认路径处理请求；

       <!--    404		-->
       <!-- 成对，首先注册，然后映射路径 -->
           <servlet>
               <servlet-name>error</servlet-name>
               <servlet-class>com.heze.servlet.ErrorServlet</servlet-class>
           </servlet>
           <servlet-mapping>
               <servlet-name>error</servlet-name>
               <url-pattern>/*</url-pattern>
           </servlet-mapping>
       

6.4 ServletContext

​

​ web容器在启动的时候，他会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；
​
​ - 共享数据
​
​ 我在这个Servlet中保存的数据，可以在另外一个servlet中拿到；
​
​ 三部曲：
​
​ 存放
​
​
​ context.setAttribute(“username”, username); //将数据保存到ServletContext里面

​
​
​
​
​ 读取
​
​
​ String username = (String) context.getAttribute(“username”);
​
​ resp.setContentType(“text/html”);
​ resp.setCharacterEncoding(“utf-8”);
​ resp.getWriter().print(“名字：” + username);
​
​
​ 注册映射xml
​
​
​ <servlet-name》 getc 《/servlet-name>
​ <servlet-class》com.heze.servlet.GetServlet《/servlet-class>
​ </servlet》
​ <servlet-mapping》
​ <servlet-name》getc《/servlet-name>
​ <url-pattern》/getc《/url-pattern>
​ </servlet-mapping》
​
​
​

​
​

6.2 获取初始化参数

1. ​ 在web.xml里面配置初始化参数，用于ServletContext调用，使用getInitParameter()得到。

   web.xml

   <!--  配置一些web初始化参数-->
     <context-param>
       <param-name>url</param-name>
       <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
     </context-param>
   

   java

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           ServletContext context = this.getServletContext();
           String url = context.getInitParameter("url");
           resp.getWriter().print(url);
       }
   

2. 请求转发（ServletContext）

   意思：访问某路径，跳转到其他路径下面去，显示的是其他路径的内容，路径还是该路径。

   

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           ServletContext context = this.getServletContext();
           System.out.println("进入了ServletDemo04\n");
           //请求转发
           RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gb");  //请求路径
           requestDispatcher.forward(req, resp);   //调用forword实现转发
           //context.getRequestDispatcher("gp").forward(req, resp);
       }
   

   本来是/gb里面的内容

   

3. 读取资源文件

   Properties

   • 在java目录下新建properties
   • 在resources目录下新建properties

   发现：都被打包到同一个路径下：classes，我们俗称这个路径为classpath；

   思路：需要一个文件流

   username = root
   password = *****
   

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           InputStream resourceAsStream = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
           Properties properties = new Properties();
           properties.load(resourceAsStream);
           String username = properties.getProperty("username");
           String password = properties.getProperty("password");
           resp.getWriter().print(username + ":" + password);
       }
   

   结果：获取到资源

   6.3 HttpServletRespose

   web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表相应的一个HttpServletRespose；

   • 如果要获取客户端请求过来的参数：找HttpServletRequest
   • 如果要给客户端响应一些信息：找HttpServletRequest

   1. 简单分类

      负责向浏览器发送数据的方法

          ServletOutputStream getOutputStream() throws IOException;
      
          PrintWriter getWriter() throws IOException;
      

      负责向浏览器发送响应头的方法

      void setDateHeader(String var1, long var2);
      
          void addDateHeader(String var1, long var2);
      
          void setHeader(String var1, String var2);
      
          void addHeader(String var1, String var2);
      
          void setIntHeader(String var1, int var2);
      
          void addIntHeader(String var1, int var2);
      
      

      响应的状态码

          int SC_CONTINUE = 100;
          int SC_SWITCHING_PROTOCOLS = 101;
          int SC_OK = 200;
          int SC_CREATED = 201;
          int SC_ACCEPTED = 202;
          int SC_NON_AUTHORITATIVE_INFORMATION = 203;
          int SC_NO_CONTENT = 204;
          int SC_RESET_CONTENT = 205;
          int SC_PARTIAL_CONTENT = 206;
          int SC_MULTIPLE_CHOICES = 300;
          int SC_MOVED_PERMANENTLY = 301;
          int SC_MOVED_TEMPORARILY = 302;
          int SC_FOUND = 302;
          int SC_SEE_OTHER = 303;
          int SC_NOT_MODIFIED = 304;
          int SC_USE_PROXY = 305;
          int SC_TEMPORARY_REDIRECT = 307;
          int SC_BAD_REQUEST = 400;
          int SC_UNAUTHORIZED = 401;
          int SC_PAYMENT_REQUIRED = 402;
          int SC_FORBIDDEN = 403;
          int SC_NOT_FOUND = 404;
          int SC_METHOD_NOT_ALLOWED = 405;
          int SC_NOT_ACCEPTABLE = 406;
          int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
          int SC_REQUEST_TIMEOUT = 408;
          int SC_CONFLICT = 409;
          int SC_GONE = 410;
          int SC_LENGTH_REQUIRED = 411;
          int SC_PRECONDITION_FAILED = 412;
          int SC_REQUEST_ENTITY_TOO_LARGE = 413;
          int SC_REQUEST_URI_TOO_LONG = 414;
          int SC_UNSUPPORTED_MEDIA_TYPE = 415;
          int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
          int SC_EXPECTATION_FAILED = 417;
          int SC_INTERNAL_SERVER_ERROR = 500;
          int SC_NOT_IMPLEMENTED = 501;
          int SC_BAD_GATEWAY = 502;
          int SC_SERVICE_UNAVAILABLE = 503;
          int SC_GATEWAY_TIMEOUT = 504;
          int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
      
      

   2. 下载文件

      1. 向浏览器输出消息

      2. 下载文件

         1. 要获取下载文件的路径
         2. 下载的文件名是啥？
         3. 设置想办法让浏览器能够支持下载我们需要的东西
         4. 获取下载文件的输入流
         5. 创建缓冲区
         6. 获取OutputStram对象
         7. 将FileOutputStream流写入到buffer缓冲区
         8. 使用OutputStream将缓冲区中的数据输出到客户端

      3. 文件下载

          @Override
             protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                 //1. 要获取下载文件的路径
                 String realPath = "D:\\idea2021.2.3\\javaweb-02\\response\\target\\classes\\何泽.jpg";
                 System.out.println("下载的路径：" + realPath);
                 //2. 下载的文件名是啥？
                 String fileName = realPath.substring(realPath.lastIndexOf("\\")  + 1);
                 //3. 设置想办法让浏览器能够支持(Content-disposition)下载我们需要的东西,中文文件名URLEncoder.encode()编码，否则会出现乱码
                 resp.setHeader("Content-Disposition", "attachment;filename="+ URLEncoder.encode(fileName, "UTF-8"));
                 //4. 获取下载文件的输入流
                 FileInputStream in = new FileInputStream(realPath);
                 //5. 创建缓冲区
                 int len = 0;
                 byte[] buffer = new byte[1024];
                 //6. 获取OutputStram对象
                 ServletOutputStream out = resp.getOutputStream();
                 //7. 将FileOutputStream流写入到buffer缓冲区,使用OutputStream将缓冲区中的数据输出到客户端
                 while ((len=in.read(buffer)) > 0){
                     out.write(buffer, 0, len);
                 }
         
                 in.close();
                 out.close();
         
             }
         

         

      4. 新建一个meven webapp

         1. 

         2. 

         3. 

         4. 

         5. 

         6. 

         7. 

   3. 验证码功能

      • 前端实现（js）

      • 后端实现（java）

         @Override
            protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                //如何让浏览器3秒刷新一次
                resp.setHeader("refresh", "3");
        
                //在内存中创建一个图片
                BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
                //得到图片
                Graphics2D g = (Graphics2D) image.getGraphics();//笔
                //设置图片背景颜色
                g.setColor(Color.white);
                g.fillRect(0, 0, 80, 20);
                //给图片写数据
                g.setColor(Color.BLUE);
                g.setFont(new Font(null, Font.BOLD, 20));
                g.drawString(makeNum(), 0, 20);
        
                //告诉浏览器，这个请求用图片的方式打开
                resp.setContentType("image/jpeg");
                //网站存在缓存，不让浏览器缓存
                resp.setDateHeader("expires", -1);
                resp.setHeader("Cache-Control", "no-cache");
                resp.setHeader("Pragma", "no-cache");
        
                //把图片给浏览器
                ImageIO.write(image, "jpg", resp.getOutputStream());
        
            }
        
            //生成随机数
            private  String makeNum(){
                Random random = new Random();
                String num = random.nextInt(9999999) + "";
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < 7 - num.length(); i++) {
                    sb.append("0");
                }
                num = sb.toString() + num;
                return  num;
            }
        

      • 结果
        

   4. 实现重定向

      

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

      常见场景：

      • 用户登录

      void sendRedirect(String var1) throws IOException;
      

      @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      //        resp.setHeader("Location", "/response_war/img");
      //        resp.setStatus(302);
              resp.sendRedirect("/response_war/img"); //重定向
          }
      

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

      相同点

      • 页面都会实现跳转

      不同点

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

      login

      @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);
              //重定向的过程一定要注意路径问题，否则会404
              resp.sendRedirect("/response_war/success.jsp");
          }
      

      <form action="${pageContext.request.contextPath}/login" method="get">
          用户名：<input type="text" name="username" >
          密码：<input type="password" name="password" >
          <input type="submit">
      
      </form>
      

      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      <html>
      <head>
          <title>Title</title>
      </head>
      <body>
        <h1>Success</h1>
      </body>
      </html>
      

      结果

   

   

6.4 HttpServletRequest

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

1.获取参数，请求转发：

​

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("====================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        System.out.println("====================");
        System.out.println(req.getContextPath());
        //通过请求转发
        req.getRequestDispatcher("/success.jsp").forward(req, resp);
    }

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

问题：重定向和请求转发的区别

相同点

• 页面都会实现跳转

不同点

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

7 cookie session

7.1、会话

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

有状态会话：

一个网站，怎么证明你来过？

客户端 服务端

​ 1.服务端给客户端一个 信件，客户端下次访问服务端带上信件就可以了；cookie

​ 2.服务器登记你来过了，下次你来的时候我来匹配你；session

7.2、保存绘画的两种技术

cookie

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

session

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

常见场景：网站登录过后，下次不用再登录，第二次直接访问上去。

7.3、Cookie

1. 从请求中拿到cookie信息

2. 服务器相应给客户端cookie

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

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

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

   • 一个cookie只能保存一个信息；
   • 一个web站点可以给浏览器发送多个cookie；
   • 300个cookie浏览器上限
   • cookie大小限制4kb；

5. 删除Cookie；

   • 不设置有效期，关闭浏览器，自动失效；
   • 设置有效期为0，

6. 编码解码：

   URLEncoder.encode(“秦疆”, “UTF-8”); //编码

   URLDecoder.decode(cookie.getValue(), “UTF-8”); //解码

7.4、Session(重点)

什么是Session：

• 服务器会给每一个用户（浏览器）创建一个Session对象

• 一个Seesion独占一个浏览器，只要浏览器没有关闭，这个session就存在；

• 用户登录后，整个网站都可以访问。

  //1.首先解决乱码问题
          req.setCharacterEncoding("UTF-8");
          resp.setCharacterEncoding("UTF-8");
          resp.setContentType("text/html;charset=utf-8");
          //2.得到session
          HttpSession session = req.getSession();
          //3.给session添加数据
          session.setAttribute("name", "秦疆");
          //4.获取session的id
          String id = session.getId();
          if (session.isNew()){
              resp.getWriter().write("session创建成功；id："+id);
              resp.getWriter().write((String) session.getAttribute("name"));
          }else{
              resp.getWriter().write("session已经存在，id:" + id);
              resp.getWriter().write((String) session.getAttribute("name"));
          }
  

Session和cookie的区别

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

使用场景：

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

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

<!--设置Session默认的失效时间-->
<session-config>
    <!--15分钟后Session自动失效，一分钟为单位-->
    <session-timeout>15</session-timeout>
</session-config>

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代码就会原封不动的输出；

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

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

  这样的格式，输出到前端！（渲染）

8.3、JSP基础语法

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

1. jsp表达式

   <%--
     Created by IntelliJ IDEA.
     User: 何泽
     Date: 2022/8/9
     Time: 8:40
     To change this template use File | Settings | File Templates.
   --%>
   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
     <head>
       <title>$Title$</title>
     </head>
     <body>
   <%--  jsp表达式用来将程序的输出，输出到客户端--%>
     <%=new java.util.Date()%>
     </body>
   </html>
   
   

   

2. jsp脚本片段

   <%--  jsp脚本片段--%>
     <%
       int sum = 0;
       for (int i = 0; i <= 100; i++) {
         sum += i;
       }
       out.println("<h1>Sum="+sum+"</h1>");
     %>
   

   

3. jsp脚本片段的再实现

   <%
       for (int i = 0; i < 5; i++) {
     %>
       <h1>Hello,world <%=i%></h1>
     <%
       }
     %>
   

   

4. jsp声明

   

    jsp声明：会被编译到jsp生成java的类中！其他的，就会被生成到_jspService方法中！
   

   ​ 在jsp中嵌入java代码即可

   <%%>	片段
   <%=%>	输出
   <%!%>	声明
   <%--注释--%>
   

   jsp注释不会在客户端显示，Html就会。

8.4、jsp指令

修改了web.xml就必须重启tomcat

1. 定制错误页面

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <%--<%@ page errorPage="error/500.jsp" %>--%>
   <html>
   <head>
       <title>Title</title>
   </head>
   <body>
       <%
           int x = 1/0;
       %>
   </body>
   </html>
   

   <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>
    <img src="../img/404.jpeg" alt="404">
</body>
</html>

​

<%@ page args...%>	页面指令格式
<%@include file=""%> 公共页面

8.5、9大内置对象

• PageContext 存东西
• Request 存东西
• Response
• Session 存东西
• Application [SerlvetContext] 存东西
• config [Serlvet]
• out
• page
• exception

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

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

EL表达式：${}

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

JSP标签

<%--    <jsp:include page=""--%>
<jsp:forward page="jsptag2.jsp">
    <jsp:param name="name" value="Heze"/>
    <jsp:param name="age" value="12"/>
</jsp:forward>

名字：<%=request.getParameter("name")%>
年龄：<%=request.getParameter("age")%>

JSTL

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

JSTL标签库使用步骤

• 引入对应的taglib

• 使用其中的方法

• 在Tomcat也需要引入jstl和standard的包，否则会报错：JSTL解析错误

  解决办法：将两个jar包复制到tomcat下lib包里面即可

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>表格</h2>
<form action="coreif.jsp" method="get">
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">
</form>

<%--进行判断，是否是管理员登录--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
    <c:out value="管理员欢迎你！"></c:out>
</c:if>
<c:out value="${isAdmin}"></c:out>
</body>
</html>

结果：

<c:set var="score" value="85"></c:set>
<c:choose>
    <c:when test="${score>=90}">
        你的成绩为优秀
    </c:when><c:when test="${score>=80}">
        你的成绩为一般
    </c:when><c:when test="${score>=70}">
        你的成绩为良好
    </c:when><c:when test="${score<70}">
        你的成绩为不及格
    </c:when>
</c:choose>

<%--forEach--%>
<%
    ArrayList<String> people = new ArrayList<>();
    people.add(0, "张三");
    people.add(1, "李四");
    people.add(2, "王五");
    people.add(3, "赵六");
    people.add(4, "田七");
    request.setAttribute("list", people);
%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"></c:out>
    <br>
</c:forEach>

结果：

9、JavaBean

实体类

javaBean有特定的写法：

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

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

ORM：对象关系映射

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

10、MVC三层架构

什么是MVC： Model view Controller 模型、视图、控制器

10.1、早些年

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

servlet--CRUD-->数据库
    弊端：程序十分臃肿，不利于维护		servlet的代码中：处理请求、响应、视图跳转、处理ＪＤＢＣ、处理业务代码、处理逻辑代码
    
    架构：没有什么事加一层解决不了的！
    ＪＤＢＣ

10.2 MVC三层架构

微服务之前,大概就是这个流程进行开发!

Model

• 业务处理:业务逻辑(service)
• 数据持久层:CRUD(Dao)

View

• 展示数据
• 提供链接发起Servlet请求(a, form, img-)

Controller(Servlet)

• 接受用户的请求：（req：请求参数、Session信息-)

• 交给业务层处理对应的代码

• 控制视图的跳转

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

11、Filter（重点）

Fiter:过滤器，用来过滤网站的数据；

• 处理中文乱码
• 登录验证。。。

Filter开发步骤

1. 导包

   <dependencies>
   <!--        Servlet 依赖-->
           <dependency>
               <groupId>javax.servlet</groupId>
               <artifactId>servlet-api</artifactId>
               <version>2.5</version>
           </dependency>
   <!--        JSP 依赖-->
           <dependency>
               <groupId>javax.servlet.jsp</groupId>
               <artifactId>javax.servlet.jsp-api</artifactId>
               <version>2.3.3</version>
           </dependency>
   <!--        JSTL表达式依赖-->
           <dependency>
               <groupId>javax.servlet.jsp.jstl</groupId>
               <artifactId>jstl-api</artifactId>
               <version>1.2</version>
           </dependency>
   <!--        standard标签库-->
           <dependency>
               <groupId>taglibs</groupId>
               <artifactId>standard</artifactId>
               <version>1.1.2</version>
           </dependency>
   <!--        连接数据库-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.47</version>
           </dependency>
       </dependencies>
   

2. 编写过滤器

   1. 导这个包

   

   2. 实现filter接口，重写对应的方法

   package com.heze.filter;
   
   import javax.servlet.*;
   import java.io.IOException;
   
   /**
    * @author 何泽
    * @version 1.0
    */
   public class CharacterEncodingFilter implements Filter {
       @Override
       //初始化
       public void init(FilterConfig filterConfig) throws ServletException {
           System.out.println("初始化");
       }
   
       @Override
       //chain 链
       public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
           servletRequest.setCharacterEncoding("utf-8");
           servletResponse.setCharacterEncoding("utf-8");
           servletResponse.setContentType("text/html;charset=utf-8");
   
           System.out.println("CharacterEncodingFilter执行前。。。");
           filterChain.doFilter(servletRequest,servletResponse);   //让我们的请求继续走，如果不写，程序就在这里被拦截
           System.out.println("CharacterEncodingFilter执行后。。。");
       }
   
       @Override
       //销毁
       public void destroy() {
           System.out.println("销毁");
       }
   }
   
   

   3. 在web.xml中配置Filter

      <filter>
              <filter-name>CharacterEncodingFilter</filter-name>
              <filter-class>com.heze.filter.CharacterEncodingFilter</filter-class>
          </filter>
          <filter-mapping>
              <filter-name>CharacterEncodingFilter</filter-name>
              <url-pattern>/servlet/*</url-pattern>
      

12、监听器

实现一个监听器的接口；

1. 编写一个监听器

   实现监听器的接口

   package com.heze.listener;
   
   //import sun.net.httpserver.ExchangeImpl;
   
   import javax.servlet.ServletContext;
   import javax.servlet.http.HttpSessionEvent;
   import javax.servlet.http.HttpSessionListener;
   
   /**
    * @author 何泽
    * @version 1.0
    */
   //统计网站在线人数：统计session
   public class OnlineCountListener implements HttpSessionListener {
       @Override
       //创建session监听
       //一旦创建一个session，就会触发一次这个监听事件
       public void sessionCreated(HttpSessionEvent httpSessionEvent) {
           ServletContext ctx = httpSessionEvent.getSession().getServletContext();
           System.out.println(httpSessionEvent.getSession().getId());
           Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
           if (onlineCount == null){
               onlineCount = new Integer(1);
           }else{
               int count = onlineCount.intValue();
               onlineCount = new Integer(count+1);
           }
           ctx.setAttribute("OnlineCount", onlineCount);
       }
   
       @Override
       //销毁session监听
       //一旦session销毁就会触发
       public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
           ServletContext ctx = httpSessionEvent.getSession().getServletContext();
           Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
           if (onlineCount == null){
               onlineCount = new Integer(1);
           }else{
               int count = onlineCount.intValue();
               onlineCount = new Integer(count-1);
           }
           ctx.setAttribute("OnlineCount", onlineCount);
       }
   
       /*session销毁
       1.手动销毁
       2.自动销毁
        */
   }
   
   

2. web.xml注册监听器

   <listener>
           <listener-class>com.heze.listener.OnlineCountListener</listener-class>
       </listener>
   

3. 看情况是否使用！

13、过滤器、监听器常见应用

监听器：GUI编程中经常使用；

package com.heze.listener;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 * @author 何泽
 * @version 1.0
 */
public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("中秋节快乐");   //窗口
        Panel panel = new Panel(null);  //面板

        frame.setLayout(null); //设置窗口的布局
        frame.setBounds(300, 300, 500, 500);
        frame.setBackground(new Color(0,0,255));
        panel.setBounds(50, 50,300,300);
        panel.setBackground(new Color(0, 255, 0));
        frame.add(panel);
        frame.setVisible(true);

        //监听事件，监听关闭事件
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowOpened(WindowEvent e) {
                System.out.println("打开");
            }

            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("关闭ing");
                System.exit(0);
            }

            @Override
            public void windowClosed(WindowEvent e) {
                System.out.println("关闭");

            }

            @Override
            public void windowIconified(WindowEvent e) {
                System.out.println();
            }

            @Override
            public void windowDeiconified(WindowEvent e) {
                super.windowDeiconified(e);
            }

            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("激活");
            }

            @Override
            public void windowDeactivated(WindowEvent e) {
                System.out.println("未激活");
            }

            @Override
            public void windowStateChanged(WindowEvent e) {
                super.windowStateChanged(e);
            }

            @Override
            public void windowGainedFocus(WindowEvent e) {
                super.windowGainedFocus(e);
            }

            @Override
            public void windowLostFocus(WindowEvent e) {
                super.windowLostFocus(e);
            }

        });
    }
}

用户登录之后才能进入主页！用户注销后就不能进入主页了！

1. 用户登录之后，向Session中放入用户的数据

2. 进入主页的时候要判断用户是否正确登录

   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
           HttpServletRequest request1 = (HttpServletRequest) servletRequest;
           HttpServletResponse response1 = (HttpServletResponse) servletResponse;
   
           Object user_session = request1.getSession().getAttribute("USER_SESSION");
           if (user_session == null){
               response1.sendRedirect("/error.jsp");
           }
   
   
           filterChain.doFilter(servletRequest,servletResponse);
       }
   

14、JDBC

什么是JDBC：java连接数据库！

需要jar包的支持：

• java.sql
• javax.sql
• mysql-conn

实验环境搭建

导入数据库依赖

<!--        mysql的驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

IDEA中连接数据库

JDBC固定步骤（6部曲）

1. 加载驱动
2. 连接数据库，代表数据库
3. 向数据库发送SQL的对象Statement：CRUD
4. 编写SQL
5. 执行SQL
6. 关闭连接

//配置信息
        //?useUnicode=true&characterEncoding=utf-8  解决中文乱码问题
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "*****";

        
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //3.向数据库发送sql的对象Statement
        Statement statement = connection.createStatement();

        //4.编写sql
        String  sql = "select * from users";

        //5.执行查询sql，返回一个resultSet结果集
        ResultSet resultSet = statement.executeQuery(sql);

        while(resultSet.next()){
            System.out.println("id="+resultSet.getObject("id"));
            System.out.println("id="+resultSet.getObject("name"));
            System.out.println("id="+resultSet.getObject("password"));
            System.out.println("id="+resultSet.getObject("email"));
            System.out.println("id="+resultSet.getObject("birthday"));
        }

        //6.关闭连接，释放资源（一定要做）；结果集

        resultSet.close();
        statement.close();
        connection.close();

事务

要么都成功，要么都失败！

ACID原则：保证数据的安全。

开启事务
事务提交	commit()
事务回滚 	rollback()
关闭事务
    转账：
    
    

Junit单元测试

依赖

<!--       单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

简单使用

@Test注解只有在方法上有效，只要加了这个注解方法，就可以直接测试方法

@Test
    public void test(){
        System.out.println("hello");
    }

 String password = "*****";

    
    //1.加载驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2.连接数据库,代表数据库
    Connection connection = DriverManager.getConnection(url, username, password);

    //3.向数据库发送sql的对象Statement
    Statement statement = connection.createStatement();

    //4.编写sql
    String  sql = "select * from users";

    //5.执行查询sql，返回一个resultSet结果集
    ResultSet resultSet = statement.executeQuery(sql);

    while(resultSet.next()){
        System.out.println("id="+resultSet.getObject("id"));
        System.out.println("id="+resultSet.getObject("name"));
        System.out.println("id="+resultSet.getObject("password"));
        System.out.println("id="+resultSet.getObject("email"));
        System.out.println("id="+resultSet.getObject("birthday"));
    }

    //6.关闭连接，释放资源（一定要做）；结果集

    resultSet.close();
    statement.close();
    connection.close();

事务

要么都成功，要么都失败！

ACID原则：保证数据的安全。

~~~java
开启事务
事务提交	commit()
事务回滚 	rollback()
关闭事务
    转账：
    
    

Junit单元测试

依赖

<!--       单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

简单使用

@Test注解只有在方法上有效，只要加了这个注解方法，就可以直接测试方法

@Test
    public void test(){
        System.out.println("hello");
    }

总结：后面跟狂神视频接着做smbms超市管理系统，具体的一些项目实践经验还需继续亲自动手，这样感受和理解就会更加深刻一些。后面自己跟着手敲的smbms项目会更新到我的gitee仓库里面，这里放两个连接，一个是狂神javaweb学习的链接，另一个是本人新手仓库的链接：

• https://www.bilibili.com/video/BV12J411M7Sj?p=1&vd_source=5660e44b6a7ee502f3adf6c319c27a72
• https://gitee.com/he-ze__-an/projects