动力节点Java Web知识笔记

03-19 1616阅读 0评论

前言

本文来自动力节点老杜的JavaWeb视频教程，跟着老杜学javaweb零基础入门到精通_哔哩哔哩_bilibili
本文是对原视频内容进行归纳总结，由于作者记笔记时图片用的是本机路径，所以导致本文无法显示图片，如果有图片需求可以看上方的pdf
servlet

系统架构

c/s架构
- 全称：Client/Server(客户端/服务器)
  $动力节点Java Web知识笔记,动力节点Java Web知识笔记,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第1张$
  （图片来源网络，侵删）
- 代表：QQ
- 特点：需要安装特定的客户端软件
- 优缺点
  - 优点
    - 速度快（因为大量数据集成在客户端软件，服务器端只用传输少量数据）
    - 服务器压力小（理由同上，因为服务器传输数据少，所以压力小）
      $动力节点Java Web知识笔记,动力节点Java Web知识笔记,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第2张$
      （图片来源网络，侵删）
    - 界面酷炫（有专门的语言实现，更加灵活）
    - 数据安全（大量数据在客户端有缓存，服务器故障对其影响较小，并且有多个客户端）
  - 缺点
    - 难升级维护
      - 每个客户端软件都需要升级维护
      - 有些软件不易安装
        $动力节点Java Web知识笔记,动力节点Java Web知识笔记,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第3张$
        （图片来源网络，侵删）
      - 成本高
- 适用场景：娱乐性软件
  
  b/s架构
  - 全称：Browser/Server(浏览器/服务器)
  - 特点
    - 本质上是一个特殊的c/s架构,只不过client是个浏览器软件
    - 开发b/s系统其实就是开发一个网站（web系统）
  - 优缺点
    - 优点
      - 易升级维护，成本低（只需要升级服务器端即可）
      - 不需要安装特定的客户端软件，用户操作方便（只需打开浏览器输入网址即可）
    - 缺点
      - 速度慢（所有数据都是在服务器上的，用户发送的每个请求都需要服务器响应数据，传输的数据量大）
      - 体验差（界面不酷炫，浏览器只支持html，css，js，而且速度慢）
      - 不安全（数据都在服务器上，服务器出故障会导致数据丢失）
  - 适用场景
    - 公司内部的业务软件
      - 需要维护成本低
      - 不追求界面酷炫
      - 使用的企业级系统主要能够进行数据的维护即可
  - 需要的技术
    - web前端（三剑客）
    - web后端（服务器端）
      - 多种编程语言都可以
      - java（javaWEB开发最核心规范：Servlet【Server Applet服务器端的Java小程序】）
      - Servlet是javaEE（WEB方向/系统）规范之一
    b/s结构通信原理
    
    域名
    - 百度一下，你就知道是网址
    - www.baidu.com是域名
    - 浏览器输入域名回车之后，域名解析器会将其解析成一个具体的IP地址和端口号等等
      - 解析结果百度一下，你就知道（百度服务器ip地址）:80（该服务器上某个软件）/index.html（资源路径）
      - IP地址
        
        相当于计算机在网络中的身份证号（唯一标识），同一网络中，IP地址唯一
        
        A计算机要想和B计算机通信，首先你需要知道B计算机的IP地址，有了IP地址才能建立连接
        
        用于定位计算机/服务器
      - 端口号
        
        一个端口代表一个软件、一个服务
        
        计算机中每个软件启动后都有一个端口号
        
        同一计算机上，端口号具有唯一性
      web系统通信原理/步骤（以百度浏览器为例）
      1. 用户输入网址（URL）
        
        url：统一资源定位符（百度一下，你就知道）
      2. 域名解析器进行域名解析（解析出IP地址和端口号）：百度一下，你就知道
      3. 浏览器软件在网络中搜索110.242.68.3（IP地址）这一台主机，直到找到这台主机
      4. 定位110.242.68.3这台主机上的服务器软件，定位到80端口对应的服务器软件
      5. 80端口对应的服务器软件得知浏览器想要的资源名：index.html
      6. 服务器软件找到index.html文件，并且将index.html文件中的内容直接输出响应到浏览器上
        
        请求和响应实际上说的是数据的流向不同
        
        请求（request）：从b端（浏览器）发送数据到s端（服务器）
        
        响应（response）：从s端发送数据到b端
      7. 浏览器接收到来自服务器的代码（HTML CSS JS），浏览器渲染，执行HTML CSS JS代码，展示效果
      $动力节点Java Web知识笔记,image-20221224133346309,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第4张$
      
      web服务器软件
      
      包括
      - Tomcat（WEB服务器）【apache】
        
        tomcat开源免费的轻量级WEB服务器。
        
        体积小，运行速度快，只实现了Servlet+JSP规范
        
        tomcat是java语言写的，Tomcat服务器要想运行，需要先有jre，所以要先安装JDK，配置java运行环境。
      - jetty（WEB服务器）
      - JBOSS（应用服务器）【内嵌tomcat服务器】
      - WebLogic（应用服务器）
      - WebSphere（应用服务器）
      - 应用服务器和web服务器的关系
        
        应用服务器实现了javaee的所有规范（13个）
        
        WEB服务器只实现了JavaEE中的Servlet + JSP两个核心的规范（体积比较小）
        
        应用服务器包含web服务器
        
        tomcat相关
        
        目录
        
        bin ： Tomcat服务器的命令文件存放的目录，比如：启动Tomcat，关闭Tomcat等
        
        conf：Tomcat服务器的配置文件存放目录。（server.xml文件中可以配置端口号，默认Tomcat端口是8080）
        
        lib ：是Tomcat服务器的核心程序目录，因为Tomcat服务器是Java语言编写的，这里的jar包里面都是class文件
        
        logs: Tomcat服务器的日志目录，Tomcat服务器启动等信息都会在这个目录下生成日志文件
        
        temp：Tomcat服务器的临时目录（存储临时文件）
        
        webapps：用来存放大量的webapp（web application：web应用）
        
        work：用来存放JSP文件翻译之后的java文件以及编译之后的class文件
        
        启动Tomcat
        
        bin目录下有一个文件：startup.bat,通过它可以启动Tomcat服务器
        
        分析startup.bat文件得出，执行这个命令，实际上最后是执行：catalina.bat文件
        
        catalina.bat文件中有这样一行配置：MAINCLASS=org.apache.catalina.startup.Bootstrap （这个类就是main方法所在的类）
        
        tomcat服务器就是Java语言写的，启动Tomcat服务器就是执行main方法
        
        tomcat服务器提供了bat和sh文件，说明了这个tomcat服务器的通用性(在windows和linux系统都能使用)
        
        bat文件是windows操作系统专用的，bat文件是批处理文件，这种文件中可以编写大量的windows的dos命令，然后执行bat文件就相当于批量的执行dos命令
        
        startup.sh，这个文件在windows当中无法执行，在Linux环境当中可以使用。在Linux环境下能够执行的是shell命令，大量的shell命令编写在shell文件当中，然后执行这个shell文件可以批量的执行shell命令
        
        关闭tomcat
        
        shutdown.bat
        
        建议shutdown.bat重命名为stop.bat，因为：
        
        shutdown命令和windows中的关机命令冲突
        
        关闭服务器只能写全命令，.bat不能省略，而startup可以省略
        
        配置tomcat的环境变量
        
        JAVA_HOME=JDK的根
        
        CATALINA_HOME=Tomcat服务器的根
        
        PATH=①%JAVA_HOME%\bin;②%CATALINA_HOME%\bin；
        
        %%：把变量的值取出来，即取出目录
        
        测试tomcat启动成功
        
        浏览器输入相应url：http://ip地址:端口号
        
        端口号：8080
        
        IP地址：本机的IP地址是127.0.0.1,或者是localhost
        
        网页资源
        
        一个路径代表一个资源：可能是静态资源，也可能是动态资源（java小程序）
        
        静态：页面中的数据是写死在HTML文件当中的，称为静态资源
        
        动态：需要连接数据库。编写Java程序（jdbc）连接数据库，数据库中有多少条记录，页面上就显示多少条记录，这种技术被称为动态网页技术（动态网页技术指数据是动态的，根据数据库中数据的变化而变化）
        
        后端执行哪个java小程序取决于前端浏览器发送的请求路径，一个路径对应一个servlet程序
        
        请求路径和Java小程序之间有对应关系，该关系由webapp开发者（java程序员）提供
        
        通过指定配置文件，在文件中描述请求路径和servlet之间的对照关系
        
        tomcat服务器解析配置文件，找到资源
        
        $动力节点Java Web知识笔记,image-20221231165854546,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第5张$
        
        通过超链接访问同一项目的其它资源
        
        绝对路径
        
        user login2 d page
        
        相对路径（及不以'/'开头）
        
        起始就是发起跳转的文件的所在路径（相对的就是当前文件所在的路径的前缀）
        
        b/s角色和协议
        
        $动力节点Java Web知识笔记,image-20230102210834126,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第6张$
        
        角色
        
        浏览器软件开发商
        
        WEB Server（服务器）的开发团队
        
        DB Server（数据库）的开发团队
        
        webapp的开发团队（WEB应用是我们做为JavaWEB程序员开发的）
        
        编写一个类实现Servlet接口
        
        将该类配置到配置文件中，指定请求路径和类名的对应关系
        
        因为tomcat服务器已经写好了，所以配置文件文件名和路径有要求
        
        角色和角色之间的协议和规范
        
        webapp的开发团队和 WEB Server的开发团队之间===》 JavaEE规范之一Servlet规范
        
        作用：WEB Server 和 webapp解耦合
        
        耦合：两个子系统（或类）之间的关联程度
        
        当一个子系统（或类）发生变化时对另一个子系统（或类）的影响很小，则称它们是松散耦合的
        
        反之，如果变化的影响很大时，则称它们是紧密耦合的
        
        遵循Servlet规范的webapp，可以放在不同的WEB服务器中运行
        
        包括
        
        规范了哪些接口、类、配置文件
        
        规范了一个web应用中配置文件的名字、存放的路径以及内容（请求路径和Servlet类的对应关系）
        
        规范了一个合法有效的web应用的目录结构
        
        Browser 和 WebServer之间有一套传输协议：HTTP协议（超文本传输协议）
        
        webapp开发团队和 DB Server的开发团队之间===》JDBC规范
        
        $动力节点Java Web知识笔记,image-20230102212438269,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第7张$
        
        开发Servlet程序
        
        !!!开发一个带有Servlet（Java小程序）的webapp!!!
        
        步骤
        
        第一步：在webapps目录下新建一个目录，起名crm（crm就是webapp的名字）
        
        crm就是这个webapp的根
        
        命名非强制
        
        第二步：在webapp的根下新建一个目录：WEB-INF
        
        命名是Servlet规范中规定的，必须全部大写
        
        第三步：在WEB-INF目录下新建如下目录和文件
        
        classes
        
        注意：命名必须是全部小写的classes，这是Servlet规范中规定的
        
        这个目录下一定存放的是Java程序编译之后的class文件（字节码文件）
        
        lib
        
        不是必须的。但如果一个webapp需要第三方的jar包的话，这个jar包要放到这个lib目录下，这个目录的名字必须是全部小写的lib
        
        例如java语言连接数据库需要数据库的驱动jar包，那么这个jar包就一定要放到lib目录下，这Servlet规范中规定的
        
        新建文件：web.xml
        
        是必须的，文件名必须叫做web.xml，必须放在这里
        
        本质是一个配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对照关系
        
        最好从其他的webapp中拷贝
        
        第四步：编写一个Java程序，必须实现Servlet接口
        
        这个Servlet接口不在JDK当中（Servlet属于JavaEE，是另外的一套类库）
        
        Servlet接口（Servlet.class文件）是Oracle提供的（最原始的是sun公司提供的）
        
        Tomcat服务器实现了Servlet规范，所以Tomcat服务器也需要使用Servlet接口。Tomcat服务器的CATALINA_HOME\lib目录下有一个servlet-api.jar，解压这个servlet-api.jar之后，里面有一Servlet.class文件
        
        重点：从JakartaEE9开始，Servlet接口的全名变为jakarta.servlet.Servlet（tomcat10之后的版本不能运行javax）
        
        注意：编写这个Java小程序的时候，java源代码位置无所谓，只需要将java源代码编译之后的class文件放到classes目录即可
        
        第五步：编译我们编写的HelloServlet
        
        重点：怎么能让HelloServlet编译通过--配置环境变量CLASSPATH
        
        CLASSPATH=.;C:\dev\apache-tomcat-10.0.12\lib\servlet-api.jar
        
        以上配置的CLASSPATH和Tomcat服务器运行没有任何关系，该环境变量只是为了能够正常编译生成class文件
        
        第六步：将以上编译之后的HelloServlet.class文件拷贝到WEB-INF\classes目录下
        
        第七步：在web.xml文件中编写配置信息，让“请求路径”和“Servlet类名”关联在一起
        
        这一步用专业术语描述：在web.xml文件中注册Servlet类
        
        fdsafdsagfdsafdsa com.bjpowernode.servlet.HelloServlet fdsafdsagfdsafdsa /fdsa/fd/saf/d/sa/fd/sa/fd
        
        可以在中配置servlet对象初始化信息等等
        
        $动力节点Java Web知识笔记,image-20230108114825303,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第8张$
        
        第八步：启动Tomcat服务器，在浏览器地址栏上输入一个url，这个URL必须是：
        
        http://127.0.0.1:8080/项目名称/url-pattern
        
        浏览器上的请求路径必须和web.xml文件中的url-pattern一致
        
        浏览器上的请求路径和web.xml文件中的url-pattern的唯一区别就是：浏览器上的请求路径带项目名
        
        浏览器上编写的路径太复杂，可以使用超链接（非常重要：html页面只能放到WEB-INF目录外面）
        
        以后不需要我们编写main方法了。Tomcat服务器启动的时候执行的就是main方法。javaweb程序员只需要编写Servlet接口的实现类，然后将其注册到web.xml文件中，即可
        
        总结一下：一个合法的webapp目录结构
        
        webapproot |------WEB-INF |------classes(存放字节码) |------lib(第三方jar包) |------web.xml(注册Servlet) |------html |------css |------javascript |------image ....
        
        浏览器发送请求大致过程（以http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd 为例）
        
        用户输入URL，或者直接点击超链接：http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd
        
        然后Tomcat服务器接收到请求，截取路径：/crm/fdsa/fd/saf/d/sa/fd/sa/fd
        
        Tomcat服务器找到crm项目
        
        Tomcat服务器
        
        在web.xml文件中查找/fdsa/fd/saf/d/sa/fd/sa/fd 对应的Servlet
        
        通过反射机制，创建对应的Servlet的对象
        
        调用该对象的方法
        
        输出字符串
        
        输出到浏览器：response.getWriter()获取输出流对象
        
        该对象由tomcat服务器维护，不需要自行刷新和关闭
        
        对象.print方法输出到浏览器
        
        浏览器可以识别html代码，因此可以输出一段html代码，前提是要设置响应内容类型
        
        response.setContentType("text/html"); //设置相应的内容类型是普通文本和html代码，设置响应的内容必须要在获取流之前
        
        输出到控制台：System.out.....
        
        解决Tomcat服务器在DOS命令窗口中的乱码问题（控制台乱码）
        
        将CATALINA_HOME/conf/logging.properties的内容修改成：java.util.logging.ConsoleHandler.encoding = GBK
        
        Servlet中连接数据库
        
        servlet是Java程序，可以直接编写java代码（jdbc）连接数据库
        
        在一个webapp中去连接数据库，需要将驱动jar包放到WEB-INF/lib目录下（com.mysql.cj.jdbc.Driver类就在驱动jar包中）
        
        在集成开发环境（idea）中开发Servlet程序
        
        第一步：New Project，这个Empty Project起名为：javaweb（非必须，一般情况下新建的Project的名字最好和目录的名字一致）
        
        第二步：新建模块（File --> new --> Module...）
        
        这里新建的是一个普通的JavaSE模块
        
        这个Module自动会被放在javaweb的project下面
        
        第三步：让Module变成JavaEE的模块（webapp的模块，符合Servlet规范的Module）
        
        在Module上点击右键：Add Framework Support...（添加框架支持）
        
        在弹出的窗口中，选择Web Application（选择的是webapp的支持）
        
        IDEA会自动给你生成一个符合Servlet规范的webpp目录结构
        
        重点，需要注意的：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根
        
        第四步：IDEA工具关联Tomcat服务器。关联的过程当中将webapp部署到Tomcat服务器当中
        
        IDEA工具右上角，绿色小锤子右边有一个：Add Configuration
        
        左上角加号，点击Tomcat Server --> local
        
        设置服务器Server的参数（基本上不用动）
        
        vm options配置虚拟机
        
        after launch勾选表示启动服务器默认打开浏览器
        
        on update action更新源代码执行的操作
        
        on frame deactivation光标离开idea执行的操作
        
        在当前窗口中有一个Deployment（用来部署webapp），继续点击加号，部署即可
        
        修改 Application context（webapp的根，也就是项目名称）
        
        第五步：编写Servlet类
        
        要继承Servlet接口
        
        将CATALINA_HOME/lib/servlet-api.jar和jsp-api.jar添加到classpath（IDEA的classpath）
        
        File --> Project Structrue --> Modules --> + 加号 --> Add JARS....
        
        实现jakarta.servlet.Servlet接口中的5个方法（tomcat10之前的是javax不是jakarta）
        
        第六步：在WEB-INF目录下新建一个子目录：lib（这个目录名必须是全部小写的lib），并且将连接数据库的驱动jar包放到lib目录下
        
        第七步：在Servlet当中的service方法中编写业务代码
        
        第八步：在web.xml文件中完成StudentServlet类的注册（请求路径和Servlet之间对应起来）
        
        studentServlet com.bjpowernode.javaweb.servlet.StudentServlet studentServlet /servlet/student
        
        第九步：新建一个HTML页面，里面编写一个超链接，点击这个超链接，发送请求，Tomcat执行后台的StudentServlet
        
        这个文件只能放到WEB-INF目录外面
        
        student.html文件
        
        student page student list
        
        第十步：启动Tomcat服务器
        
        在右上角有绿色的箭头，或者绿色的小虫子
        
        点击绿色的小虫子，可以采用debug的模式启动Tomcat服务器
        
        开发中建议用debug模式启动Tomcat
        
        第十一步：打开浏览器，在浏览器地址栏上输入：http://localhost:8080/xmm/student.html
        
        Servlet对象的生命周期相关
        
        Servlet对象是由tomcat维护，其生命周期由tomcat服务器（通常又称为web容器【web container】）负责
        
        WEB容器创建的Servlet对象会被放到一个集合当中（HashMap），只有在集合中的Servlet才能被WEB容器管理
        
        web容器底层应该有一个HashMap这样的集合，当中存储了Servlet对象和请求路径之间的关系
        
        $动力节点Java Web知识笔记,image-20230106144929952,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第9张$
        
        自己创建的servlet对象是不受web容器管理（自己new的Servlet对象不在容器当中）
        
        服务器启动
        
        默认情况下，服务器在启动时Servlet对象不会被实例化,原因：
        
        用户发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的
        
        创建出来的Servlet如果一直没有用户访问就废了
        
        如何在服务器启动时创建servlet对象
        
        在servlet标签中添加子标签，在该子标签中填写整数（负数不行），越小的整数优先级越高
        
        aservlet com.bjpowernode.javaweb.servlet.AServlet 1 aservlet /a
        
        ！！！生命周期！！！
        
        默认情况下服务器启动时Servlet对象没有被实例化
        
        用户在发送第一次请求时
        
        Servlet对象被实例化（执行的是无参数构造方法，通过反射机制创建对象）
        
        Servlet对象被创建出来之后，Tomcat服务器调用该对象的init方法（init方法执行时，Servlet对象已经被创建出来了）
        
        init方法执行之后，Tomcat服务器调用Servlet对象的service方法
        
        用户之后发送多次请求的时候，还是使用之前创建好的Servlet对象（没有新建），直接调用该对象的service方法，说明：
        
        第一：Servlet对象是单例的（单实例的），多线程共享一个对象
        
        注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。
        
        假单例是因为Servlet对象只能由Tomcat创建，Tomcat只创建了一个，导致了单例
        
        并且我们没有权限去创建对象，所以属于假单例
        
        真单例模式，构造方法是私有化的，这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象
        
        注意：
        
        1、单例类只能有一个实例
        
        2、单例类必须自己创建自己的唯一实例
        
        3、单例类必须给所有其他对象提供这一实例
        
        第二：无参数构造方法、init方法只在第一次用户发送请求的时候执行
        
        无参数构造方法只执行一次
        
        init方法只被Tomcat服务器调用一次
        
        第三：只要用户发送一次请求，service方法必然会被Tomcat服务器调用一次（service方法可以多次被调用）
        
        Servlet的destroy方法只被Tomcat服务器调用一次
        
        destroy方法在服务器关闭时被调用
        
        因为服务器关闭的时候要销毁Servlet对象的内存
        
        服务器在销毁对象内存之前，Tomcat服务器会自动调用对象的destroy方法。
        
        destroy方法执行的时候Servlet对象没有被销毁（因为destroy方法是实例对象的方法）destroy方法执行结束后，对象的内存才被Tomcat释放(自杀)
        
        destory方法可以编写销毁前的准备（遗言）
        
        Servlet类中各方法的调用次数
        
        构造方法、init方法（初始化）、destroy方法只执行一次
        
        service方法：用户发送一次请求则执行一次，可执行多次
        
        处理用户请求的核心方法
        
        Servlet类中编写一个有参数的构造方法，没有手动编写无参数构造方法会出现的问题
        
        $动力节点Java Web知识笔记,image-20230106164905724,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第10张$
        
        报错：500错误
        
        500是一个HTTP协议的错误状态码。
        
        500一般情况下是因为服务器端的Java程序出现了异常（服务器端的错误都是500错误：服务器内部错误）
        
        没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象
        
        在Servlet开发当中，不建议程序员来定义构造方法，定义不当会导致无法实例化Servlet对象
        
        Servlet的无参数构造方法和init方法是在对象第一次创建的时候执行，并且只执行一次，但是无参数构造方法不能代替init方法
        
        Servlet规范中要求，编写Servlet类的时候，不建议手动编写构造方法
        
        编写构造方法容易让无参数构造方法消失，可能会导致Servlet对象无法实例化。init方法是有存在的必要的
        
        init、service、destroy方法中使用频率和使用情境
        
        使用最多就是service方法
        
        service方法是一定要实现的，因为service方法是处理用户请求的核心方法
        
        init方法很少用
        
        通常在init方法当中做初始化操作，并且这个初始化操作只需要执行一次
        
        例如：初始化数据库连接池，初始化线程池....
        
        destroy方法也很少用
        
        通常在destroy方法当中，进行资源的关闭
        
        对象被销毁前，对未关闭/保存的资源进行关闭/保存
        
        适配器设计模式改造servlet
        
        Servlet类直接实现Servlet接口的缺点
        
        业务中只需要service方法，其他方法大部分情况下是不需要使用的，代码很丑陋
        
        适配器设计模式Adapter的理解
        
        手机直接插到220V的电压上，手机直接就报废了怎么办？可以找一个充电器。这个充电器就是一个适配器。手机连接适配器。适配器连接220V的电压。这样问题就解决了
        
        编写一个GenericServlet类
        
        是一个抽象类，其中有一个抽象方法service
        
        GenericServlet实现Servlet接口
        
        GenericServlet是一个适配器
        
        以后编写的所有Servlet类继承GenericServlet，重写service方法即可
        
        改造GenericServlet类
        
        提供了一个GenericServlet之后，init方法还会执行,如果子类没有重写父类的init方法，就会执行GenericServlet类中的init方法
        
        init方法是Tomcat服务器调用的
        
        Tomcat服务器伪代码
        
        public class Tomcat { public static void main(String[] args){ // ..... // Tomcat服务器伪代码 // 创建LoginServlet对象（通过反射机制，调用无参数构造方法来实例化LoginServlet对象） Class clazz = Class.forName("com.bjpowernode.javaweb.servlet.LoginServlet"); Object obj = clazz.newInstance(); Servlet servlet = (Servlet)obj;// 向下转型 /*创建ServletConfig对象 Tomcat服务器负责将ServletConfig对象实例化出来。多态（Tomcat服务器完全实现了Servlet规范）*/ ServletConfig servletConfig = new org.apache.catalina.core.StandardWrapperFacade(); //父类型的引用指向子类型对象 // 调用Servlet的init方法 servlet.init(servletConfig); // 调用Servlet的service方法 // .... } }
        
        init方法中的ServletConfig对象
        
        由Tomcat创建并且传过来
        
        Tomcat服务器先创建了ServletConfig对象，然后调用init方法，将ServletConfig对象传给了init方法
        
        init方法中的Servletconfig对象是局部变量
        
        可以声明一个成员变量config，将该局部变量赋值给成员变量（改造一）
        
        $动力节点Java Web知识笔记,image-20230107160133526,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第11张$
        
        getServletConfig方法返回该成员变量config，子类就可以通过该方法获取config对象
        
        子类重写的init方法
        
        问题：父类的init方法没调用会导致父类的成员变量config未被赋值
        
        解决（模板方法设计模式）
        
        将父类的init方法final，使得子类无法重写（改造二）
        
        然后父类中定义一个新的init方法（改造三），子类就可以重写init方法，并且也能完成父类的成员变量赋值
        
        $动力节点Java Web知识笔记,image-20230107161442539,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第12张$
        
        GenericServlet类已有现成的(tomcat提供的)
        
        public abstract class GenericServlet implements Servlet, ServletConfig, Serializable { private static final long serialVersionUID = 1L;//用于区分类 private transient(游离) ServletConfig config;//transient修饰的变量不可以序列化 public GenericServlet() { } public void destroy() { } public String getInitParameter(String name) { return this.getServletConfig().getInitParameter(name); } public Enumeration getInitParameterNames() { return this.getServletConfig().getInitParameterNames(); } .....详情请通过idea ctrl+shift+N查看反编译代码 }
        
        ServletConfig
        
        定义、作用
        
        Servlet对象的配置信息对象
        
        一个Servlet对应一个ServletConfig对象（一对一，不是多个servlet对象共享一个servletconfig对象）
        
        ServletConfig对象中封装了标签中的配置信息（web.xml文件中servlet的配置信息）
        
        可以获取标签中的配置信息（初始化参数信息等等）
        
        //遍历输出初始化参数信息 Enumeration initParameterNames = config.getInitParameterNames(); while(initParameterNames.hasMoreElements()){ String element = initParameterNames.nextElement(); String initParameter = config.getInitParameter(element); writer.println(element+" "+initParameter+"
        "); }
        
        接口的实现和对象的创建
        
        Servlet对象和ServletConfig对象都是Tomcat服务器创建。默认情况下，都是在发送第一次请求的时候被创建
        
        $动力节点Java Web知识笔记,image-20230107233627064,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第13张$
        
        Tomcat服务器调用Servlet对象的init方法的时候需要传一个ServletConfig对象的参数给init方法
        
        ServletConfig接口的实现类是Tomcat服务器实现的
        
        ServletConfig接口方法
        
        public String getInitParameter(String name); // 通过初始化参数的name获取value public Enumeration getInitParameterNames(); // 获取所有的初始化参数的name集合 public ServletContext getServletContext(); // 获取ServletContext对象 public String getServletName(); // 获取Servlet的name
        
        以上方法在Servlet类中都可以用this（this指当前对象，前提是继承GenericServlet）去调用。因为GenericServlet实现了ServletConfig接口，所以不需要额外获取该对象
        
        GenericServlet类中代码 public String getInitParameter(String name) { return this.getServletConfig().getInitParameter(name); } public Enumeration getInitParameterNames() { return this.getServletConfig().getInitParameterNames(); }
        
        ServletContext
        
        获取
        
        通过config对象调用getServletContext方法
        
        因为GenericServlet实现了ServletConfig接口，所以可以直接用this调用获取
        
        定义
        
        是servlet对象的环境/上下文对象
        
        对应的就是整个web.xml文件
        
        Tomcat服务器中有一个webapps（容器），可以存放多个webapp，一个webapp对应一个ServletContext对象
        
        在同一个webapp当中，所有的Servlet对象共享同一个ServletContext对象
        
        理解
        
        一个教室里有多个学生，这些学生都在同一个教室当中，在同一个教室当中，物品都是共享的
        
        每一个学生是一个Servlet
        
        这个教室就是一个ServletContext对象
        
        放在ServletContext对象中的数据，里面的所有Servlet是共享的（假设多个servlet想共享一个数据，可以把该数据放入ServletContext对象中）
        
        接口的实现和对象的创建
        
        servletContext接口由tomcat服务器实现
        
        servletContext对象由tomcat服务器创建，在web服务器
        
        启动时创建
        
        关闭时销毁
        
        ！！！应用域！！！
        
        ServletContext对象别名应用域
        
        服务器启动的时候，应用域就开启了
        
        如果所有的用户共享一份数据，并且这个数据很少被修改，且数据量小，可以将这些数据放到应用域中
        
        ServletContext这个对象只有一个，只有共享的数据放进去才有意义
        
        数据量比较大的话，占用堆内存较多，并且这个对象的生命周期比较长，在服务器关闭时才会被销毁,从而会影响服务器的性能
        
        所有用户共享的数据，如果涉及到修改操作，必然会存在线程并发所带来的安全问题。所以放在ServletContext对象中的数据一般都是只读的
        
        数据量小、所有用户共享、不修改，这样的数据放到ServletContext这个应用域当中，会大大提升效率
        
        应用域相当于一个缓存，放到缓存中的数据，下次使用时不需要从数据库中再次获取，大大提升执行效率
        
        内存和硬盘文件交互需要IO流，IO流读硬盘数据（机械行为，通过硬盘中的磁针），获取的速度无法达到非常快
        
        高并发的系统频繁连接数据库性能会有问题
        
        常用方法
        
        获取context-param中的配置信息
        
        public String getInitParameter(String name); // 通过初始化参数的name获取value public Enumeration getInitParameterNames(); // 获取所有的初始化参数的name //遍历获取方式和servletconfig的一致
        
        pageSize 10 startIndex 0
        
        以上的配置信息属于应用级的配置信息，一般一个项目中共享的配置信息会放到以上的标签中（相当于全局配置）
        
        如果配置信息只是给某个servlet作为参考，则配置到servlet标签当中，使用ServletConfig对象来获取（相当于局部配置）
        
        理解：公用垃圾桶和家用垃圾桶的区别
        
        ！！！获取应用的根路径（非常重要）！！！
        
        可以动态获取应用的根路径
        
        java源码不要将应用的根路径写死，因为应用在最终部署的时候的命名可能有变动
        
        public String getContextPath(); //String contextPath = application.getContextPath();
        
        获取文件的绝对路径（真实路径）
        
        path指该文件在该项目的相对路径，该路径前加不加/都可以
        
        /代表web的根
        
        不加/也是默认从web的根开始找，所以加不加/不影响
        
        public String getRealPath(String path); public InputStream getResourceAsStream(String path);//获取资源，以流的形式返回（也可以通过路径获取流）
        
        通过ServletContext对象可以记录日志(也可以通过框架)
        
        如果通过项目部署的方式，日志文件会被记录到CATALINA_HOME/Logs目录下
        
        使用idea，日志文件会被记录到idea相关目录下
        
        因为idea会创建多个tomcat副本
        
        idea中的tomcat副本是参照本地的tomcat目录下的资源生成的
        
        Tomcat服务器的logs目录下的日志文件
        
        catalina.2021-11-05.log 服务器端的java程序运行的控制台信息
        
        localhost.日期.log ServletContext对象的log方法记录的日志信息
        
        localhost_access_log.日期.txt 访问日志
        
        public void log(String message);// 这些日志信息记录到localhost.日期.log public void log(String message, Throwable t);//记录异常信息
        
        $动力节点Java Web知识笔记,image-20230113162634034,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第14张$
        
        $动力节点Java Web知识笔记,image-20230113162655693,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第15张$
        
        向应用域存取删数据
        
        // 存（向ServletContext应用域中存数据） public void setAttribute(String name, Object value); // map.put(k, v) // 取（从ServletContext应用域中取数据） public Object getAttribute(String name); // Object v = map.get(k) // 删（删除ServletContext应用域中的数据） public void removeAttribute(String name); // map.remove(k) // 以上的操作类似于Map集合的操作 Map map; map.put("name", obj); // 向map集合中放key和value Object obj = map.get("name"); // 通过map集合的key获取value map.remove("name"); // 通过Map集合的key删除key和value这个键值对
        
        缓存机制
        
        向ServletContext应用域中存储数据，也等于是将数据存放到缓存cache当中了
        
        堆内存中
        
        字符串常量池（待学习）
        
        "abc" 先在字符串常量池中查找，有就直接拿来用
        
        没有则新建，然后再放入字符串常量池。
        
        整数型常量池（待学习，可能在打包那一块）
        
        [-128 ~ 127] 一共256个Integer类型的引用，放在整数型常量池中（没有超出这个范围的话，直接从常量池中取）
        
        连接池(Connection Cache)（jdbc时可能会学到，待学习）
        
        这里所说的连接池中的连接是java语言连接数据库的连接对象：java.sql.Connection对象
        
        问题：JVM是一个进程，MySQL数据库是一个进程。进程和进程之间建立连接，打开通道是很费劲且很耗费资源的
        
        解决：可以提前先创建好N个Connection连接对象，将连接对象放到一个集合当中，放有Connection对象的集合称为连接池。每一次用户连接的时候不需要再新建连接对象，省去了新建的环节，直接从连接池中获取连接对象，大大提升访问效率
        
        连接池
        
        最小连接数
        
        最大连接数
        
        连接池可以提高用户的访问效率。当然也可以保证数据库的安全性。
        
        线程池（待学习，进线程）
        
        Tomcat服务器本身支持多线程的
        
        Tomcat服务器不是在用户发送一次请求，就新建一个Thread线程对象
        
        实际上是在Tomcat服务器启动的时候，会先创建好N多个线程Thread对象，然后将线程对象放到集合当中，称为线程池。用户发送请求过来之后，需要有一个对应的线程来处理这个请求，这个时候线程对象就会直接从线程池中拿，效率比较高。
        
        所有的WEB服务器，或者应用服务器，都是支持多线程的，都有线程池机制
        
        后期学习的缓存技术
        
        redis
        
        NoSQL数据库，非关系型数据库，缓存数据库
        
        mongoDB
        
        HTTP协议
        
        协议
        
        协议实际上是某些人，或者某些组织提前制定好的一套规范，大家都按照这个规范来，这样可以做到沟通无障碍
        
        协议就是一套规范，就是一套标准
        
        HTTP协议定义
        
        是W3C制定的一种超文本传输协议（通信协议：发送消息的模板提前被制定好）
        
        W3C
        
        万维网联盟组织
        
        负责制定标准的：HTTP HTML4.0 HTML5 XML DOM等规范都是W3C制定的
        
        万维网之父：蒂姆·伯纳斯·李
        
        超文本
        
        即不是普通文本，比如流媒体：声音、视频、图片等
        
        HTTP协议支持：不但可以传送普通字符串，同样支持传递声音、视频、图片等流媒体信息
        
        这种协议游走在B和S之间。B向S和S向B发数据都要遵循HTTP协议，这样B和S才能解耦合
        
        解耦合：S和B不互相依赖（前面有提过）
        
        B/S表示：B/S结构的系统（浏览器访问WEB服务器的系统）
        
        HTTP协议就是提前制定好的一种消息模板
        
        不论哪个品牌的浏览器/WEB服务器,都要按照模板
        
        浏览器不依赖具体的服务器品牌
        
        WEB服务器也不依赖具体的浏览器品牌
        
        HTTP协议包括
        
        发送的数据需要遵循一套标准，这套标准中规定了发送的数据具体格式
        
        请求协议（B-->S）
        
        浏览器向WEB服务器发送数据，叫做：请求（request)
        
        HTTP的请求协议包括：4部分
        
        请求行
        
        包括三部分：
        
        第一部分：请求方式（7种）
        
        get（常用的）
        
        post（常用的）
        
        delete
        
        put
        
        head
        
        options
        
        trace
        
        第二部分：URI
        
        URI: 统一资源标识符
        
        代表网络中某个资源的名字。但是通过URI是无法定位资源的（因为路径不全）
        
        URL:统一资源定位符
        
        代表网络中某个资源，同时，通过URL是可以定位到该资源的
        
        URI和URL的关系和区别
        
        URL包括URI
        
        http://localhost:8080/servlet05/index.html 是URL
        
        /servlet05/index.html 这是URI
        
        第三部分：HTTP协议版本号
        
        请求头
        
        请求的主机
        
        主机的端口
        
        浏览器信息
        
        平台信息
        
        cookie等信息
        
        ....
        
        空白行
        
        空白行是用来区分“请求头”和“请求体”
        
        请求体
        
        向服务器发送的具体数据
        
        HTTP请求协议的具体报文：GET请求
        
        GET /servlet05/getServlet?username=lucy&userpwd=1111 HTTP/1.1 请求行 Host: localhost:8080 请求头 Connection: keep-alive sec-ch-ua: "Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99" sec-ch-ua-mobile: ?0 sec-ch-ua-platform: "Windows" Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9 Sec-Fetch-Site: same-origin Sec-Fetch-Mode: navigate Sec-Fetch-User: ?1 Sec-Fetch-Dest: document Referer: http://localhost:8080/servlet05/index.html Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9 空白行请求体
        
        HTTP请求协议的具体报文：POST请求
        
        POST /servlet05/postServlet HTTP/1.1 请求行 Host: localhost:8080 请求头 Connection: keep-alive Content-Length: 25 Cache-Control: max-age=0 sec-ch-ua: "Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99" sec-ch-ua-mobile: ?0 sec-ch-ua-platform: "Windows" Upgrade-Insecure-Requests: 1 Origin: http://localhost:8080 Content-Type: application/x-www-form-urlencoded User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9 Sec-Fetch-Site: same-origin Sec-Fetch-Mode: navigate Sec-Fetch-User: ?1 Sec-Fetch-Dest: document Referer: http://localhost:8080/servlet05/index.html Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9 空白行 username=lisi&userpwd=123 请求体
        
        响应协议（S-->B）
        
        WEB服务器向浏览器发送数据，叫做：响应（response）
        
        HTTP的响应协议包括：4部分
        
        状态行
        
        三部分组成
        
        第一部分：协议版本号（HTTP/1.1）
        
        第二部分：状态码（HTTP协议中规定的响应状态号，不同的响应结果对应不同的号码）
        
        200 表示请求响应成功，正常结束
        
        404表示访问的资源不存在，404错误是前端错误，通常是因为
        
        路径写错了
        
        路径写对了，但是服务器中对应的资源并没有启动成功
        
        405表示前端发送的请求方式与后端请求的处理方式不一致时发生
        
        比如：前端是POST请求，后端的处理方式按照get方式进行处理时，发生405（反之亦然）
        
        500表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的
        
        以4开始的，一般是浏览器端的错误导致的；以5开始的，一般是服务器端的错误导致的（4浏5服）
        
        第三部分：状态的描述信息（chrome浏览器没有显示描述信息）
        
        ok 表示正常成功结束
        
        not found 表示资源找不到
        
        响应头
        
        响应的内容类型
        
        响应的内容长度
        
        响应的时间
        
        ....
        
        空白行
        
        用来分隔“响应头”和“响应体”
        
        响应体
        
        响应体就是响应的正文，这些内容是一个长的字符串，这个字符串被浏览器渲染，解释并执行，最终展示出效果
        
        HTTP响应协议的具体报文：
        
        HTTP/1.1 200 ok 状态行 Content-Type: text/html;charset=UTF-8 响应头 Content-Length: 160 Date: Mon, 08 Nov 2021 13:19:32 GMT Keep-Alive: timeout=20 Connection: keep-alive 空白行响应体 from get servlet
        from get servlet
        
        ！！！Get请求和Post请求！！！
        
        使用Get/Post请求的情况
        
        只有用表单并且声明post（method="post"）才是post请求
        
        剩下的都是get请求
        
        在浏览器地址栏上直接输入URL，回车
        
        在浏览器上直接点击超链接
        
        使用form表单提交数据时，form标签中没有写method属性，默认就是get
        
        或者使用form的时候，form标签中method属性值为：method="get"
        
        ....
        
        区别
        
        发送数据的位置
        
        get请求发送数据，数据会挂在URI的后面的"?"之后，发送的数据会回显在浏览器的地址栏上（get请求在“请求行”上发送数据）
        
        http://localhost:8080/servlet05/getServlet?username=zhangsan&userpwd=1111
        
        post请求发送数据，在请求体当中发送。不会回显到浏览器的地址栏上（post在“请求体”当中发送数据）
        
        get请求和post请求，发送的请求数据格式是完全相同的（位置不同，格式统一，http协议规定的，便于拆分存取数据）
        
        name=value&name=value&name=value&name=value
        
        name
        
        以form表单为例：form表单中input标签的name
        
        value
        
        以form表单为例：form表单中input标签中用户填写的信息，没填写默认为该标签的value属性值
        
        发送数据的要求
        
        get请求
        
        只能发送普通的字符串
        
        发送的字符串长度有限制（无法发送大数据量），不同的浏览器限制不同，这个没有明确的规范
        
        post请求
        
        可以发送任何类型的数据，包括普通字符串，流媒体等信息：视频、声音、图片
        
        可以发送大数据量，理论上没有长度限制
        
        W3C中是这样说的（get获取post传，字面意思）
        
        get请求比较适合从服务器端获取数据
        
        post请求比较适合向服务器端传送数据
        
        安全性
        
        get请求是绝对安全的
        
        因为get请求只是为了从服务器上获取数据。不会对服务器造成威胁
        
        get本身是安全的，用get传数据不好（会回显数据到地址栏）
        
        post请求是危险的
        
        因为post请求是向服务器提交数据，如果这些数据通过后门的方式进入到服务器当中，服务器是很危险的
        
        另外post是为了提交数据，所以一般情况下拦截请求的时候，大部分会选择拦截（监听）post请求
        
        缓存
        
        get请求支持缓存
        
        https://n.sinaimg.cn/finance/590/w240h350/20211101/b40c-b425eb67cabc342ff5b9dc018b4b00cc.jpg
        
        任何一个get请求最终的“响应结果”都会被浏览器缓存起来。在浏览器缓存当中：
        
        一个get请求的路径对应一个资源
        
        发送get请求，浏览器先从本地浏览器缓存中找，找不到的时候才会去服务器上获取。这种缓存机制目的是为了提高用户的体验
        
        需求：避免get请求走缓存，让这个get请求都去服务器上找资源，不从本地浏览器的缓存中取的
        
        只要每一次get请求的请求路径不同即可
        
        解决：可以在路径的后面添加一个每时每刻都在变化的“时间戳”，每一次的请求路径都不一样，浏览器就不走缓存
        
        https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=系统毫秒数
        
        post请求不支持缓存（POST是用来修改服务器端的资源的）
        
        post请求之后，服务器“响应的结果”不会被浏览器缓存起来
        
        该缓存没有意义，比方说银行交易，交易成功与否缓存下来没有意义
        
        选择（衡量标准）
        
        使用post（向服务器提交数据，建议使用POST请求）
        
        大部分的form表单提交，都是post方式，因为form表单中要填写大量的数据，收集的用户的信息一般是需要传给服务器，服务器将这些数据保存/修改等
        
        表单中有敏感信息，还是建议适用post请求，因为get请求会回显敏感信息到浏览器地址栏上（例如：密码信息）
        
        做文件上传，一定是post请求。要传的数据不是普通文本
        
        使用get（从服务器上获取资源，建议使用GET请求）
        
        除了上述使用post的情况，其他情况都可以使用get请求
        
        注意事项
        
        浏览器编写的请求路径以及同一项目中的超链接要加上项目路径
        
        网页换行
        
        println是源代码换行,但是网页上没有换行效果
        
        页面换行用
        
        查看协议内容:使用chrome浏览器,F12,然后找到network，通过这个面板可以查看协议的具体内容
        
        模板方法设计模式
        
        设计模式定义
        
        某个问题的固定的解决方案(可以被重复使用)
        
        不同业务中遇到相同的问题所抽取出的解决方案
        
        设计模式包括
        
        GoF设计模式：
        
        通常我们所说的23种设计模式（Gang of Four：4人组提出的设计模式）
        
        单例模式
        
        工厂模式
        
        代理模式
        
        门面模式
        
        责任链设计模式
        
        观察者模式
        
        模板方法设计模式
        
        .....
        
        JavaEE设计模式：
        
        DAO
        
        DTO
        
        VO
        
        PO
        
        pojo
        
        ....
        
        ....
        
        模板方法设计模式
        
        在模板类的模板方法当中定义核心算法骨架，具体的实现步骤可以延迟到子类当中完成
        
        模板类通常是一个抽象类，模板类当中的模板方法定义核心算法，通常是可以final的
        
        final可以保护核心算法，不能被子类修改
        
        代码复用
        
        算法得到了重复使用
        
        模板类当中的抽象方法就是不确定实现的方法（具体问题具体分析），交给子类去做
        
        举例
        
        学生类和老师类
        
        两个类除了dosome方法不同，其他的一模一样（方法名，方法体都一样）
        
        定义一个人类（抽象类，作为模板类），把所有方法放进一个模板方法
        
        然后将dosome改为抽象方法，子类（学生老师）根据自己的需求重写该方法
        
        $动力节点Java Web知识笔记,image-20230115171114302,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第16张$
        
        HttpServlet
        
        到目前为止接触的servlet规范中的接口和类
        
        jakarta.servlet.Servlet 核心接口（接口）
        
        jakarta.servlet.ServletConfig Servlet配置信息接口（接口）
        
        jakarta.servlet.ServletContext Servlet上下文接口（接口）
        
        jakarta.servlet.ServletRequest Servlet请求接口（接口）
        
        jakarta.servlet.ServletResponse Servlet响应接口（接口）
        
        jakarta.servlet.ServletException Servlet异常（类）
        
        jakarta.servlet.GenericServlet 标准通用的Servlet类（抽象类）
        
        HttpServlet相关知识
        
        HttpServlet类是专门为HTTP协议准备的，比GenericServlet更加适合HTTP协议下的开发
        
        HttpServlet位置：jakarta.servlet.http.HttpServlet
        
        http包下的类和接口：jakarta.servlet.http.*
        
        jakarta.servlet.http.HttpServlet （HTTP协议专用的Servlet类，抽象类）
        
        jakarta.servlet.http.HttpServletRequest （HTTP协议专用的请求对象）
        
        HttpServletRequest对象
        
        HttpServletRequest，简称request对象
        
        HttpServletRequest中封装了请求协议的全部内容（四部分）
        
        Tomcat服务器（WEB服务器）将“请求协议”中的数据全部解析出来，然后将这些数据全部封装到request对象当中
        
        面向HttpServletRequest，就可以获取请求协议中的数据
        
        jakarta.servlet.http.HttpServletResponse （HTTP协议专用的响应对象）
        
        HttpServletResponse对象
        
        是专门用来响应HTTP协议到浏览器的
        
        继承HttpServlet
        
        以后我们编写Servlet类的时候，不用直接去继承GenericServlet类的
        
        因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的
        
        在Servlet规范当中，提供了一个HTTP协议准备的一个Servlet类（HttpServlet，是HTTP协议专用的）
        
        使用HttpServlet处理HTTP协议更便捷，它的继承结构
        
        jakarta.servlet.Servlet（接口）【爷爷】 jakarta.servlet.GenericServlet implements Servlet（抽象类）【儿子】 jakarta.servlet.http.HttpServlet extends GenericServlet（抽象类）【孙子】
        
        以后编写的Servlet类要继承HttpServlet类
        
        HttpServlet源码分析
        
        public class HelloServlet extends HttpServlet { // 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。 public HelloServlet() { } //HttpServlet类没有init()方法，会执行GenericServlet的init()方法 //没有Service方法，先回执行HttpServlet类中原始的service方法，完成向下转型之后，执行重载的service模板方法 //override 重写 doGet方法 //override 重写 doPost方法 } public abstract class GenericServlet implements Servlet, ServletConfig, java.io.Serializable { // 用户第一次请求的时候，HelloServlet对象第一次被创建之后，这个init方法会执行。 public void init(ServletConfig config) throws ServletException { this.config = config; this.init(); } // 用户第一次请求的时候，带有参数的init(ServletConfig config)执行之后，会执行这个没有参数的init() public void init() throws ServletException { // NOOP by default } } // HttpServlet模板类 public abstract class HttpServlet extends GenericServlet { // 用户只要发送一次请求，这个service方法就会执行一次 @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { HttpServletRequest request; HttpServletResponse response; try { // 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse request = (HttpServletRequest) req; response = (HttpServletResponse) res; } catch (ClassCastException e) { throw new ServletException(lStrings.getString("http.non_http")); } // 调用重载的service方法 service(request, response); } // 这个service方法的两个参数都是带有Http的 // 这个service是一个模板方法 // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成 protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 获取请求方式 // 这个请求方式最终可能是："" // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一： // GET POST PUT DELETE HEAD OPTIONS TRACE String method = req.getMethod(); // 如果请求方式是GET请求，则执行doGet方法。 if (method.equals(METHOD_GET)) { long lastModified = getLastModified(req); if (lastModified == -1) { // servlet doesn't support if-modified-since, no reason // to go through further expensive logic doGet(req, resp); } else { long ifModifiedSince; try { ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE); } catch (IllegalArgumentException iae) { // Invalid date header - proceed as if none was set ifModifiedSince = -1; } if (ifModifiedSince
        
        编写的Servlet可以直接重写HttpServlet类中的service()方法，只不过享受不到HTTP协议专属的东西（405报错信息等等...）
        
        405报错信息本质
        
        浏览器发送的请求和服务器端的需要的请求方式不一致
        
        只要HttpServlet类中的doGet或doPost方法执行了，必然405
        
        $动力节点Java Web知识笔记,image-20230116150907482,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第17张$
        
        以上图为例，浏览器发送get请求，但是子类中没有重写doget方法，就会执行父类的doget，而父类的doget会执行sendMethod方法发送405报错信息
        
        解决/避免405报错：后端需要的请求方式决定前端的请求方式
        
        后端重写了doGet/doPost方法，前端一定要发get/post请求
        
        错误解决方式
        
        在Servlet类当中，将doGet和doPost方法都进行了重写（然后在一个方法里面调用另一个方法）
        
        可以避免405的发生，但是不建议，405错误还是有用的。该报错的时候就应该让他报错（掩耳盗铃）
        
        同时重写了doGet和doPost不如直接重写service方法。这样代码还能少写一点
        
        最终的Servlet类的开发步骤
        
        第一步：编写一个Servlet类，直接继承HttpServlet
        
        第二步：重写doGet方法或者重写doPost方法（重写谁，javaweb程序员说了算）
        
        第三步：将Servlet类配置到web.xml文件当中
        
        第四步：准备前端的页面（form表单），form表单中指定请求路径即可
        
        ！！！HttpServletRequest接口！！！
        
        相关知识
        
        HttpServletRequest是一个接口，全限定名称：jakarta.servlet.http.HttpServletRequest
        
        HttpServletRequest接口是Servlet规范中的一员
        
        HttpServletRequest接口的父接口：ServletRequest
        
        public interface HttpServletRequest extends ServletRequest {}
        
        接口的实现和对象的创建
        
        org.apache.catalina.connector.RequestFacade 实现了 HttpServletRequest接口
        
        public class RequestFacade implements HttpServletRequest {}
        
        Tomcat服务器（WEB服务器、WEB容器）实现了HttpServletRequest接口，Tomcat服务器实现了Servlet规范
        
        HttpServletRequest对象是Tomcat服务器负责创建的
        
        对象封装的信息
        
        用户发送请求的时候，发送的是HTTP的请求协议，Tomcat服务器将HTTP协议中的信息以及数据全部解析出来，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中
        
        面向HttpServletRequest接口编程，就可以获取到请求的信息
        
        ！！！request和response对象生命周期！！！
        
        一个request对象只在一次请求中存活
        
        request对象和response对象，这两个对象只在当前请求中有效
        
        一次请求对应一个request
        
        常用方法
        
        ！！！获取前端浏览器用户提交的数据！！！
        
        Map getParameterMap() 这个是获取Map Enumeration getParameterNames() 这个是获取Map集合中所有的key String[] getParameterValues(String name) 根据key获取Map集合的value（复选框提交的数据通常使用） String getParameter(String name) 获取value这个一维数组当中的第一个元素。这个方法最常用 // 以上的4个方法，和获取用户提交的数据有关系
        
        底层存储前端数据采用的数据结构
        
        前端提交的数据格式：username=abc&userpwd=111&aihao=s&aihao=d&aihao=tt
        
        前端表单提交数据的时候，假设提交了120这样的“数字”，其实是以字符串"120"的方式提交的，所以服务器端获取到的一定是一个字符串的"120"（前端永远提交的是字符串，后端获取的也永远是字符串）
        
        采用Map集合来存储
        
        错误
        
        如果采用以上的数据结构存储会发现key重复的时候value覆盖
        
        map的key不能重复
        
        Map key存储String value存储String key value --------------------- username abc userpwd 111 aihao s aihao d aihao tt
        
        正确
        
        Map key存储String value存储String[] key value ------------------------------- username {"abc"} userpwd {"111"} aihao {"s","d","tt"}
        
        手写webapp测试方法
        
        命令行编译
        
        $动力节点Java Web知识笔记,image-20230117163051861,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第18张$
        
        编译编译生成的class文件存放的位置待编译的java文件
        
        数组的toString
        
        $动力节点Java Web知识笔记,image-20230117164655019,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第19张$
        
        存放的元素类型地址
        
        请求域对象操作
        
        void setAttribute(String name, Object obj); // 向域当中绑定数据 Object getAttribute(String name); // 从域当中根据name获取数据 void removeAttribute(String name); // 将域当中绑定的数据移除
        
        获取请求转发器对象
        
        RequestDispatcher dispatcher = request.getRequestDispatcher("/b");//用于请求转发
        
        其他常用方法
        
        获取客户端的IP地址
        
        String remoteAddr = request.getRemoteAddr();
        
        中文乱码的解决（在Tomcat10包括10在内之后的版本，中文将不再出现乱码）
        
        设置请求体的字符集
        
        这个方法是处理POST请求的乱码问题，不能解决get请求的乱码问题
        
        因为get请求在请求行上提交数据， post请求在请求体中提交数据
        
        Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题,Tomcat9前（包括9在内），前端请求体提交的是中文，后端获取之后出现乱码解决方式
        
        request.setCharacterEncoding("UTF-8");//该代码要设置到获取数据之前
        
        在Tomcat9之前（包括9），响应出现中文乱码的解决方式（Tomcat10之后，包括10在内，响应中文时不再出现乱码）
        
        response.setContentType("text/html;charset=UTF-8");
        
        get请求乱码问题解决方式
        
        方案：修改CATALINA_HOME/conf/server.xml配置文件
        
        从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了
        
        ！！！获取应用的根路径！！！(动态获取)
        
        String contextPath = request.getContextPath();
        
        获取请求方式
        
        String method = request.getMethod();
        
        获取请求的URI（带项目名）
        
        String uri = request.getRequestURI(); // /aaa/testRequest
        
        获取servlet path（不带项目名）
        
        getServletPath():获取能够与“url-pattern”中匹配的路径，注意是完全匹配的部分，*的部分不包括
        
        getPageInfo():与getServletPath()获取的路径互补，能够得到的是“url-pattern”中*d的路径部分
        
        getServletPath()加上getPageInfo()获取到的是用户发送请求路径中项目名之后的路径
        
        String servletPath = request.getServletPath(); // /testRequest
        
        ！！！注意以下两个方法不要搞混！！！
        
        // uri?username=zhangsan&userpwd=123&sex=1 String username = request.getParameter("username"); Object obj = request.getAttribute("name");
        
        getParameter():获取的是用户在浏览器上提交的数据
        
        getAttribute():获取的是请求域当中绑定的数据
        
        之前执行过：request.setAttribute("name", new Object())才能获取到数据，否则为null
        
        ！！！请求域！！！
        
        “请求域”对象
        
        “请求域”对象要比“应用域”对象范围小很多，生命周期短很多
        
        请求域只在一次请求内有效
        
        一个请求对象request对应一个请求域对象
        
        请求对象创建时请求域就开启了
        
        一次请求结束之后，这个请求域就销毁了
        
        域的选用原则:尽量使用小的域对象，小的域对象占用的资源较少
        
        转发机制
        
        一次请求中，实现资源跳转
        
        获取请求转发器对象(相当于把路径包装到转发器中，实际上是把下一个跳转资源的路径告诉tomcat服务器)
        
        RequestDispatcher dispatcher = request.getRequestDispatcher("/b");
        
        调用转发器的forward方法完成跳转/转发，将当前资源的request和respond对象传递
        
        dispatcher.forward(request,response);
        
        // 第一步和第二步代码可以联合在一起 request.getRequestDispatcher("/b").forward(request,response);
        
        错误的servlet资源共享方式：Aservlet类中new另一个Bservlet对象，然后将Aservlet的request对象作为参数传递给Bservlet的doget/dopost方法
        
        $动力节点Java Web知识笔记,image-20230117224054214,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第20张$
        
        虽然可以实现功能，但是自己new的Servlet对象不受tomcat管理（非法对象）
        
        两个Servlet共享数据
        
        将数据放到ServletContext应用域当中，但是应用域范围太大，占用资源太多（不建议使用）
        
        将数据放到request域中，同过转发，保证两个Servlet在同一次请求中，这样就可以做到两个或者多个Servlet共享同一份数据
        
        Tomcat服务器当中的合法资源都是可以转发的。例如：html....
        
        转发的路径以“/”开始，不加项目名
        
        关于一个web站点的欢迎页面
        
        一个web站点的欢迎页面（默认页面）
        
        对于一个webapp来说是可以设置它的欢迎页面的
        
        设置了欢迎页面之后，当你访问这个webapp或者web站点的时候，没有指定任何“资源路径”，会默认访问你的欢迎页面
        
        我们一般的访问方式是：
        
        http://localhost:8080/servlet06/login.html 这种方式是指定了要访问的就是login.html资源。
        
        如果我们访问的方式是：
        
        http://localhost:8080/servlet06 我们访问的就是这个站点，没有指定具体的资源路径，默认会访问你设置的欢迎页面
        
        设置欢迎页面
        
        第一步：在IDEA工具的web目录下新建了一个文件login.html由于作为欢迎界面
        
        第二步：在web.xml文件中进行了以下的配置
        
        login.html
        
        设置欢迎页面时，这个路径不以“/”开始（会出现双斜杠从而找不到资源），并且这个路径默认从webapp的根下开始查找
        
        第三步：启动服务器，浏览器地址栏输入地址
        
        http://localhost:8080/servlet07
        
        如果在webapp的根下新建一个目录，目录中再给一个文件，如何设置这个欢迎页
        
        在webapp根下新建page1
        
        在page1下新建page2目录
        
        在page2目录下新建page.html页面
        
        在web.xml文件中应该这样配置
        
        page1/page2/page.html
        
        路径不以“/”开始，默认从webapp的根下开始找。
        
        一个webapp是可以设置多个欢迎页面
        
        page1/page2/page.html login.html
        
        越靠上的优先级越高。找不到的继续向下找
        
        文件名设置为index.html的时候，不需要在web.xml文件中进行配置欢迎页面
        
        这是因为小猫咪Tomcat服务器已经提前配置好了
        
        实际上配置欢迎页面有两个地方可以配置：
        
        一个是在webapp内部的web.xml文件中（局部配置）
        
        一个是在CATALINA_HOME/conf/web.xml文件中进行配置（全局配置）
        
        index.html index.htm index.jsp
        
        Tomcat服务器的全局欢迎页面是：index.html index.htm index.jsp。一个web站点没有设置局部的欢迎页面，Tomcat服务器就会以index.html index.htm index.jsp作为一个web站点的欢迎页面
        
        注意原则：局部优先（就近）原则
        
        欢迎页可以是一个Servlet
        
        欢迎页就是一个资源，可以是静态资源，也可以是动态资源
        
        静态资源：index.html welcome.html .....
        
        动态资源：Servlet类。
        
        步骤：
        
        第一步：写一个Servlet
        
        public class WelcomeServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.print("
        welcome to bjpowernode!
        "); } }
        
        第二步：在web.xml文件中配置servlet
        
        welcomeServlet com.bjpowernode.javaweb.servlet.WelcomeServlet welcomeServlet /fdsa/fds/a/fds/af/ds/af/dsafdsafdsa
        
        第三步：在web.xml文件中配置欢迎页
        
        fdsa/fds/a/fds/af/ds/af/dsafdsafdsa
        
        ！！！WEB-INF目录！！！
        
        在WEB-INF目录下新建了一个文件：welcome.html，打开浏览器访问：http://localhost:8080/servlet07/WEB-INF/welcome.html 出现了404错误
        
        原因：
        
        放在WEB-INF目录下的资源是受保护的，在浏览器上不能够通过路径直接访问
        
        像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外
        
        servlet实现单表的增删改查
        
        实现步骤
        
        第一步：准备一张数据库表（部门表）
        
        第二步：准备一套HTML页面（项目原型）【前端开发工具使用HBuilder】
        
        然后将HTML页面中的链接都能够跑通（页面流转没问题）
        
        需要的页面
        
        欢迎页面：index.html
        
        列表页面：list.html（专门显示所有信息，以列表页面为核心，展开其他操作）
        
        新增页面：add.html
        
        修改页面：edit.html（业务需求：部门编号不可修改）
        
        详情页面：detail.html
        
        第三步：分析系统包含的功能
        
        功能
        
        一个操作连接了数据库，就表示一个独立的功能
        
        包括
        
        查看部门列表
        
        新增部门
        
        删除部门
        
        查看部门详细信息
        
        跳转到修改页面
        
        修改部门
        
        第四步：在IDEA当中搭建开发环境
        
        ①创建一个webapp（添加servlet-api.jar和jsp-api.jar到classpath当中）
        
        ②向webapp中添加连接数据库的jar包（mysql驱动）
        
        必须在WEB-INF目录下新建lib目录，将mysql的驱动jar包拷贝到这个lib目录下（目录名必须是全部小写的lib）
        
        复制完jar包之后要右键Add as Library（否则包会找不到）
        
        ③创建JDBC的工具类（封装获取数据库连接对象操作）
        
        注册驱动
        
        只用注册一次，所以放在静态代码块中，在类加载的时候执行
        
        static { //注册驱动,只用注册一次 try { Class.forName(driver); } catch (ClassNotFoundException e) { e.printStackTrace(); } }
        
        连接驱动不能写死（考虑到要连接不同数据库），所以在配置文件中声明信息（jdbc.properties），通过ResourceBundle绑定资源文件
        
        如果连接oracle数据库的时候，还需要修改java代码，违背了0CP开闭原则
        
        OCP开闭原则:对扩展开放，对修改关闭（扩展不要建立在修改的基础上）
        
        在进行功能扩展的时候，不需要修改java源代码符合0CP
        
        配置信息
        
        driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC username=root password=1212go12
        
        属性资源文件绑定，根据key获取value
        
        静态变量，在类加载的时候执行，有顺序（自上而下）
        
        private static ResourceBundle bundle=ResourceBundle.getBundle("resources.jdbc"); private static String driver=bundle.getString("driver"); private static String url=bundle.getString("url"); private static String user=bundle.getString("username"); private static String password=bundle.getString("password");
        
        获取数据库连接对象
        
        //获取数据库连接对象 public static Connection getConnection() throws SQLException { Connection connection = DriverManager.getConnection(url, user, password); return connection; }
        
        执行sql语句、处理查询结果集（具体业务代码不写在工具类中）
        
        释放资源
        
        public static void close(Connection conn, Statement ps, ResultSet rs){ if(conn!=null){ try { conn.close(); } catch (SQLException throwables) { throwables.printStackTrace(); } }if(ps!=null){ try { ps.close(); } catch (SQLException throwables) { throwables.printStackTrace(); } }if(rs!=null){ try { rs.close(); } catch (SQLException throwables) { throwables.printStackTrace(); } } }
        
        ④将所有HTML页面拷贝到web目录下
        
        第五步：实现功能
        
        查看部门列表
        
        建议
        
        从后端往前端一步一步写或者从前端一步一步往后端写，不要想起来什么写什么
        
        写代码的过程最好是程序的执行过程，程序执行到哪里就写哪里。这样一个顺序流下来之后，基本上不会出现什么错误、意外
        
        功能的开始
        
        假设从前端开始，从用户点击查看按钮开始
        
        第一：设定前端页面的超链接，该链接对应查询部门列表的servlet（要加项目名）
        
        第二：编写web.xml文件
        
        list com.bjpowernode.oa.web.action.DeptListServlet list 对应前端不加项目名的链接
        
        第三：编写ListServlet类继承HttpServlet类，重写doGet方法
        
        第四：doGet方法中连接数据库，查询所有的部门，动态的展示部门列表页面
        
        分析list.html页面中哪部分是固定死的，哪部分是需要动态展示的
        
        list.html页面中的内容所有的双引号要替换成单引号，因为out.print("")这里有一个双引号，容易冲突
        
        只使用servlet写代码太繁琐
        
        while(rs.next()){ String deptno = rs.getString("a"); String dname = rs.getString("dname"); String loc = rs.getString("loc"); out.print(" "); out.print(" "+(++i)+""); out.print(" "+deptno+""); out.print(" "+dname+""); out.print(" "); out.print(" 删除"); out.print(" 修改"); out.print(" 详情"); out.print(" "); out.print(" "); }
        
        jdbc获取查询结果
        
        根据查询结果的列名获取信息，如果起别名则根据别名获取
        
        如果采用*查询，则根据原数据库表中的列名获取
        
        String deptno = rs.getString("deptno");
        
        查看部门详情
        
        建议
        
        从前端往后端一步一步实现
        
        先找到用户点的详情位置==》在后端的java程序中(因为是用servlet打印html代码)
        
        详情
        
        详情是需要连接数据库的，这个超链接点击之后需要执行一段java代码的,所以要设置这个超链接的路径（servlet绑定）
        
        修改路径之后，这个路径是需要加项目名的。"/oa/dept/detail"
        
        配置servlet映射
        
        detail com.bjpowernode.oa.web.action.DeptDetailServlet detail /dept/detail
        
        技巧
        
        out.print("详情");
        
        向服务器提交数据的格式：uri?name=value&name=value&name=value&name=value
        
        这里的问号，必须是英文的问号
        
        字符串拼接技巧：在拼接位置中先加双引号，然后在双引号中加两个加号，添加内容写在两个加号之中
        
        doGet方法中
        
        连接数据库
        
        根据部门编号查询该部门的信息
        
        先获取部门编号，request调用getParameter()
        
        根据该部门编号查询
        
        动态展示部门详情页
        
        删除部门
        
        从前端页面开始，用户点击删除时，提示用户是否删除
        
        删除这个动作是比较危险的,任何系统在进行删除操作之前，必须要提示用户
        
        删除的动作有可能是用户误操作
        
        在提示用户是否删除的js代码
        
        删除 function del(dno){ if(window.confirm("亲，删了不可恢复哦！")){ document.location.href = "/oa/dept/delete?deptno=" + dno; } }
        
        href后面设置为javascript:void(0) 表示
        
        保留住超链接的样子，点击此超链接之后，不进行页面的跳转
        
        数字不一定要是0
        
        confirm会弹出确认框，返回一个布尔值（确定为true取消false）
        
        跳转（去掉href也可以），前端发请求路径要带项目名
        
        document.location.href=”请求路径“
        
        window.location.href=”请求路径“
        
        以上的前端程序要写到后端的java代码中
        
        http://localhost:8080/oa/dept/delete?deptno=30
        
        web.xml文件
        
        重写doGet方法
        
        //先获取部门编号 String deptno = req.getParameter("deptno"); Connection connection=null; PreparedStatement preparedStatement=null; int count=0; try { connection = DBUtils.getConnection(); //开启事务(关闭自动提交) connection.setAutoCommit(false); String sql="delete from dept where deptno=?";//占位符 preparedStatement= connection.prepareStatement(sql); preparedStatement.setString(1,deptno);//给占位符赋值 count = preparedStatement.executeUpdate();//返回值是影响了多少条记录 connection.commit(); } catch (SQLException throwables) { if(connection!=null){ try { //出现异常就回滚 connection.rollback(); } catch (SQLException e) { e.printStackTrace(); } }
        
        删除成功或者失败的时候的一个处理（这里选择了转发，但是应该用重定向机制）
        
        // 判断删除成功 if (count == 1) { //删除成功 //仍然跳转到部门列表页面 //部门列表页面的显示需要执行另一个Servlet。怎么办？转发。 request.getRequestDispatcher("/dept/list").forward(request, response); }else{ // 删除失败 request.getRequestDispatcher("/error.html").forward(request, response); }
        
        新增部门
        
        问题：最后保存成功之后，转发到 /dept/list 的时候，会出现405
        
        原因
        
        保存用的是post请求,底层要执行doPost方法。
        
        转发是一次请求，之前是post，之后还是post
        
        转发到/dept/list，该Servlet中只有doGet方法
        
        解决
        
        第一种：在/dept/list Servlet中添加doPost方法，然后在doPost方法中调用doGet
        
        第二种：重定向
        
        修改部门
        
        跳转到修改部门的页面
        
        先查询需要修改的部门信息（类似于详情功能）
        
        动态输出页面
        
        调试
        
        前端/浏览器
        
        console看JavaScript代码错误
        
        network看具体的浏览器和服务器通信的协议
        
        elements配合
        
        $动力节点Java Web知识笔记,image-20230120195825374,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第21张$
        
        使用，选择页面元素信息
        
        source可以进行断点调试
        
        后端，debug
        
        $动力节点Java Web知识笔记,image-20230120195955368,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第22张$
        
        跳到下一个断点位置（这个图标在左边那一列）
        
        $动力节点Java Web知识笔记,image-20230120200139942,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第23张$
        
        预览程序的所有断点
        
        转发与重定向
        
        web中有两种方式完成资源跳转
        
        转发
        
        重定向
        
        跳转的资源只要是服务器内部合法的资源即可。包括：Servlet、JSP、HTML.....
        
        区别
        
        代码上
        
        转发
        
        转发的时候是一次请求，转发多少次都是一次请求
        
        转发的servlet对象都在同一个请求域中，调用forward方法会将当前的request和response对象传递给下一个Servlet（转发过程中的所有servlet共享同一个request对象和同一个response对象）
        
        // 获取请求转发器对象 RequestDispatcher dispatcher = request.getRequestDispatcher("/dept/list"); // 调用请求转发器对象的forward方法完成转发 dispatcher.forward(request, response);
        
        // 合并一行代码 request.getRequestDispatcher("/dept/list").forward(request, response);
        
        重定向
        
        请求路径上是需要添加项目名，相当于浏览器又发了一次新请求（浏览器发送请求都需要加项目名）
        
        response会将请求路径发送给浏览器，浏览器会自发地向服务器发送一次全新的请求
        
        response.sendRedirect("/项目名/文件路径");
        
        形式
        
        转发（转发不论多少次都是一次请求）
        
        在浏览器地址栏上发送的请求是：http://localhost:8080/servlet10/a ，请求结束之后，浏览器地址栏上的地址不变
        
        转发会存在浏览器的刷新问题（刷新浏览器还是发送最初的请求），如果是新增操作的话就会重复添加相同数据
        
        重定向（重定向一次是两次请求）
        
        最终在浏览器地址栏上显示的地址是最后一次请求的地址，重定向会导致浏览器地址栏的地址改变
        
        本质区别
        
        转发：是由WEB服务器来控制的。A资源跳转到B资源，跳转动作是Tomcat服务器内部完成的
        
        $动力节点Java Web知识笔记,image-20230121193313871,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第24张$
        
        重定向：是浏览器完成的（新发送一次请求）。具体跳转到哪个资源，浏览器说了算
        
        $动力节点Java Web知识笔记,image-20230121193525443,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第25张$
        
        选择
        
        如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet中把request域里面的数据取出来，使用转发机制
        
        剩下所有的请求均使用重定向（重定向使用较多）
        
        Servlet注解
        
        问题及解决
        
        没使用注解前(仅使用web.xml)遇到的问题
        
        web.xml文件中的配置信息对于一个大的项目来说，会非常庞大
        
        在web.xml文件中进行servlet信息的配置，开发效率比较低，每个servlet都需要配置
        
        web.xml文件中的配置是很少被修改
        
        Servlet3.0版本之后，推出了各种Servlet基于注解式开发
        
        开发效率高，不需要编写大量的配置信息（直接在java类上使用注解进行标注）
        
        web.xml文件体积变小
        
        注解加配置文件的开发方式
        
        有一些需要变化的信息，还是要配置到web.xml文件中。一般都是注解+配置文件的开发模式
        
        一些不会经常变化修改的配置建议使用注解。一些可能会被修改的建议写到配置文件中
        
        webservlet（注解）
        
        @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface WebServlet { String name() default ""; String[] value() default {}; ..... }
        
        target表示该注解使用的位置，{ElementType.TYPE}表示该注解可以出现在类上
        
        常用属性
        
        (String)name属性：用来指定Servlet的名字
        
        (String[])urlPatterns属性
        
        用来指定Servlet的映射路径。可以指定多个字符串（多个路径指向同一servlet对象）
        
        urlPatterns底层是数组，指定多个元素的格式：urlPatterns={"元素1"，"元素2"，"元素3".....}
        
        value属性
        
        和urlPatterns作用相同
        
        当注解的属性名是value时且注解中只有一个属性，value可以省略
        
        @WebServlet( {"/a","/b"})
        
        （int）loadOnStartUp属性：用来指定在服务器启动阶段是否加载该Servlet
        
        （WebInitParam[] ）initParams属性
        
        配置初始化参数
        
        底层是WebInitParam注解数组
        
        public @interface WebInitParam { String name(); String value(); String description() default ""; }
        
        使用：initParams={@WebInitParam(name="1"，value="1"),@WebInitParam(name="2"，value="2")...}
        
        注意
        
        不是必须将所有属性都写上，需要什么用什么
        
        如果属性是一个数组并且只有一个元素，使用该注解时，属性值的大括号可以省略
        
        注解对象的使用格式
        
        @注解名称(属性名=属性值, 属性名=属性值, 属性名=属性值....)
        
        使用反射机制解析类上的注解
        
        代码
        
        public class test { public static void main(String[] args) throws ClassNotFoundException { //获取类class对象 Class helloServlet = Class.forName("HelloServlet"); //获取这个类上面的注解对象（先判断有没有该对象） if (helloServlet.isAnnotationPresent(WebServlet.class)) { //获取类上的注解对象 WebServlet annotation = helloServlet.getAnnotation(WebServlet.class); String[] value = annotation.value(); String[] urlPatterns = annotation.urlPatterns(); for (String s : value) { System.out.println(s); } System.out.println("-----------"); for (String urlPattern : urlPatterns) { System.out.println(urlPattern); } } } }
        
        运行结果
        
        $动力节点Java Web知识笔记,image-20230123170954083,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第26张$
        
        value有值，而urlpatterns没有值，说明webServlet只有一个value属性时，可以省略value
        
        使用模板方法设计模式优化oa项目
        
        问题
        
        注解解决了配置文件的问题
        
        当前的项目一个单表的CRUD，就写了6个Servlet。如果一个复杂的业务系统，一个请求一个Servlet类这种开发方式，显然会导致类爆炸（类的数量太大）
        
        解决类爆炸
        
        一个请求对应一个方法，一个业务对应一个Servlet类
        
        例如
        
        处理部门相关业务的对应一个DeptServlet
        
        处理用户相关业务的对应一个UserServlet
        
        处理银行卡卡片业务对应一个CardServlet
        
        /dept/*
        
        请求路径以/dept开始的就执行这个servlet
        
        注意
        
        getServletPath()获取能够与“url-pattern”中匹配的路径，注意是完全匹配的部分，*的部分不包括
        
        getPageInfo():与getServletPath()获取的路径互补，能够得到的是“url-pattern”中*d的路径部分
        
        两者拼接的时候要判断info()是否为空
        
        @WebServlet("/dept/*") public class DeptServlet extends HttpServlet { //模板方法,重写service（因为不知道前端发送的是get还是post请求） @Override protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //获取servlet path（不带项目名） String servletPath = request.getServletPath(); String pathInfo = request.getPathInfo(); String path; if (pathInfo != null) { path = servletPath + pathInfo; } path = servletPath; //一个路径对应一个功能 if ("/dept/list".equals(path)) { doList(request, response); } else if ("/dept/save".equals(path)) { doSave(request, response); } else if ("/dept/edit".equals(path)) { doEdit(request, response); } else if ("/dept/detail".equals(path)) { doDetail(request, response); } else if ("/dept/delete".equals(path)) { doDel(request, response); } else if ("/dept/modify".equals(path)) { doModify(request, response); } else { System.out.println("路径不存在"); } }
        
        只用Servlet开发web应用的缺陷
        
        java程序中编写前端代码
        
        编写难度大、麻烦
        
        程序的耦合度非常高
        
        代码不美观
        
        维护成本太高，修改一个前端代码，就需要重新编译java代码，生成新的class文件，打一个新的war包，重新发布
        
        解决思路
        
        程序员编写Servlet程序中需要的前端代码，让机器把前端代码自动翻译生成java代码（自动加上out.print）
        
        然后机器再自动将“java”程序编译生成"class"文件。然后再使用JVM调用这个class中的方法
        
        b/s系统的会话机制
        
        会话
        
        会话对应的英语单词：session
        
        用户打开浏览器，进行一系列操作，然后最终将浏览器关闭，这个整个过程叫做一次会话
        
        会话在服务器端有一个对应的java对象叫做session（一个session对象对应一次会话）
        
        用户在浏览器上点击了一下，然后到页面停下来，可以粗略认为是一次请求。请求对应的服务器端的java对象是request
        
        一个会话当中包含多次请求（一次会话对应N次请求）
        
        session
        
        定义和作用
        
        在java的servlet规范当中，session对应的类名：HttpSession（jarkata.servlet.http.HttpSession）
        
        session机制属于B/S结构的一部分，实际上是一个规范，不同的语言对这种会话机制都有实现（使用php语言开发WEB项目，也是有session这种机制的）
        
        session对象存储在服务器
        
        session对象最主要的作用是保存会话状态（用户登录成功了，这是一种登录成功的状态，可以用session对象把登录成功的状态一直保存下来）
        
        ！！！需要session保存会话状态的原因！！！
        
        因为HTTP协议是一种无状态协议
        
        无状态：请求的时候，B和S是连接的，但是请求结束之后，连接就断了
        
        无状态协议，可以降低服务器的压力。请求的瞬间是连接的，请求结束之后，连接断开，这样服务器压力小
        
        B和S断开，但是服务器不知道用户关闭浏览器这个动作
        
        举例：网银有个安全退出按钮，点击安全退出比直接关闭浏览器安全，因为点击该按钮会发送请求告诉服务器，然后清除会话信息，直接关闭浏览器服务器端不知道关闭了，所以不安全
        
        不使用request对象和ServletContext对象保存会话状态的原因（域的范围不合适）
        
        request是一次请求一个对象，两次请求的数据不共享，request对象域太小
        
        ServletContext对象是服务器启动时创建，服务器关闭时销毁，ServletContext对象只有一个，ServletContext对象的域太大
        
        request请求域（HttpServletRequest）、session会话域（HttpSession）、application域（ServletContext）
        
        setAttribute()存，getAttribute()取，request、ServletContext和session都有这个方法
        
        使用原则：尽量使用小的域
        
        request
        获取session对象
        
        HttpSession session = request.getSession();
        
        从服务器中获取当前的session对象，如果没有获取到任何session对象则新建
        
        HttpSession session = request.getSession(false);
        
        从服务器中获取当前session对象，如果获取不到session，则不会新建，返回一个null
        
        session对象的销毁
        
        超时销毁（时间限制可以在web.xml中配置）
        
        30
        
        单位分钟，默认30分钟
        
        在规定时间范围内未被访问，则对象被销毁
        
        手动销毁
        
        session.invalidate();
        
        session对象的实现原理
        
        理解：相当于浏览器给服务器端的某个session对象打标记，浏览器通过直接记下的标记找到该会话对象
        
        $动力节点Java Web知识笔记,image-20230128002843131,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第27张$
        
        实现原理
        
        web服务器中有个session列表
        
        session列表是一个Map
        
        key是JSESSIONID（session对象的编号）
        
        value是session对象
        
        用户第一次请求，服务器生成session对象，同时给该对象生成id，将id发送给浏览器，然后浏览器将id保存到浏览器内存中
        
        JSESSIONID=xxxxxx 这个是以Cookie的形式保存在浏览器的内存中的
        
        用户第二次请求，自动将浏览器内存中的id发送给服务器，服务器根据id查找session对象
        
        关闭浏览器，浏览器的缓存消失，cookie消失，sessionid消失，会话等同于结束
        
        下次打开浏览器访问找不到原来的session对象，就会重新获取一个新的session对象
        
        $动力节点Java Web知识笔记,image-20230128183039387,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第28张$
        
        session改造登录功能
        
        登录成功之后，先获取session对象（如果没有获取到就创建，也就是getSession不能有false参数）
        
        然后将用户的登录信息存储到session当中
        
        模板类中先获取session对象（这里要传false，如果没有获取到就不创建session对象），然后判断是否有session对象
        
        有session就进行下一步判断
        
        没有session对象说明没有用户访问或者非法访问
        
        判断session对象中是否有用户信息
        
        有用户的信息就代表登录成功了
        
        没有用户信息，表示用户没有登录过，则跳转到登录页面
        
        只判断有session对象就证明有用户是错误的，因为如果先访问了其它服务器资源就有可能先创建出一个会话对象，后续操作都使用这个对象，比如说jsp中有session的内置对象
        
        设置访问jsp时不创建session对象
        
        如果写上述代码，jsp就不能通过session对象获取会话域的数据
        
        登出功能
        
        在登出的方法中手动销毁session对象
        
        然后跳转到登录页面
        
        Cookie
        
        相关知识
        
        每个session对象都会关联一个sessionid，例如：JSESSIONID=41C481F0224664BDB28E95081D23D5B8
        
        以上的键值对数据就是cookie对象
        
        对于session关联的cookie来说，这个cookie是被保存在浏览器的运行内存当中
        
        只要浏览器不关闭，用户再次发送请求的时候，会自动将运行内存中的cookie（例如上述cookie对象）发送给服务器
        
        然后服务器根据41C481F0224664BDB28E95081D23D5B8这个值来找到对应的session对象
        
        cookie机制和session机制都不属于java中的机制，实际上cookie机制和session机制都是HTTP协议的一部分。web开发不管是什么编程语言都是需要cookie和session机制的（php开发中也有cookie和session机制）
        
        HTTP协议中规定：任何一个cookie都是由name和value组成的（name和value都是字符串类型的）
        
        保存位置
        
        cookie最终是保存在浏览器客户端上的
        
        可以保存在运行内存（浏览器只要关闭cookie就消失了）
        
        也可以保存在硬盘文件（永久保存）
        
        用途
        
        cookie和session机制都是为了保存会话的状态
        
        cookie是将会话的状态保存在浏览器客户端（cookie数据存储在浏览器客户端）
        
        session是将会话的状态保存在服务器端（session对象是存储在服务器）
        
        因为HTTP协议是无状态、无连接协议，所以需要有cookie和session机制
        
        Cookie禁用
        
        $动力节点Java Web知识笔记,image-20230128180307180,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第29张$
        
        cookie禁用指服务器正常发送cookie给浏览器，但是浏览器拒收，并不是服务器不发
        
        Cookie禁用后session就找不到了（每一次请求都会获取新的session对象）
        
        cookie禁用后实现session机制（不建议）
        
        需要使用URL重写机制：在url后面加个分号已经jssessionid=xxxxxxxxxxxxxxxx（32位）
        
        http://localhost:8080/servlet12/test/session;jsessionid=19D1C99560DCBF84839FA43D58F56E16
        
        URL重写机制会提高开发者的成本
        
        开发人员在编写任何请求路径的时候，后面都要添加一个sessionid（而且还是动态的），给开发带来了很大的难度
        
        大部分的网站是这样设计的：禁用cookie，就无法访问
        
        cookie的经典案例
        
        京东商城，在未登录的情况下，向购物车中放几件商品。然后关闭商城，再次打开浏览器访问京东商城的时候，购物车中的商品还在
        
        将购物车中的商品编号放到cookie当中，cookie保存在硬盘文件当中。这样即使关闭浏览器。硬盘上的cookie还在。下一次再打开京东商城的时候，查看购物车的时候，会自动读取本地硬盘中存储的cookie，拿到商品编号，动态展示购物车中的商品
        
        京东存储购物车中商品的cookie可能是这样的：productIds=xxxxx,yyyy,zzz,kkkk
        
        crtl+shift+delete可以清除硬盘文件的cookie，cookie如果被清除掉，购物车中的商品就消失了
        
        126邮箱中有一个功能：十天内免登录
        
        需要cookie来实现
        
        用户输入正确的用户名和密码，并且选择十天内免登录。登录成功后，浏览器客户端会保存一个cookie，这个cookie中保存了用户名和密码等信息，这个cookie是保存在硬盘文件当中的
        
        在十天内用户再次访问126的时候，浏览器自动提交126的关联的cookie给服务器，服务器接收到cookie之后，获取用户名和密码，验证通过之后，自动登录成功
        
        让cookie失效
        
        十天过后自动失效
        
        或者改密码
        
        或者在客户端浏览器上清除cookie
        
        Cookie类
        
        servlet提供了一个Cookie类来专门表示cookie数据：jakarta.servlet.http.Cookie;
        
        java程序发送cookie数据给浏览器：response.addCookie(cookie);
        
        在HTTP协议中是这样规定的：当浏览器发送请求的时候，会自动携带该path下的cookie数据给服务器（URL）
        
        关于cookie的有效时间
        
        用java设置cookie的有效时间（单位秒）
        
        cookie.setMaxAge(60 * 60); 设置cookie在一小时之后失效
        
        设置有效时间后，cookie对象会携带过期时间（时区采取格林威治时间【国家标准时间】，北京时间减八小时）
        
        没有设置有效时间，默认保存在浏览器的运行内存中，浏览器关闭则cookie消失
        
        只要设置cookie的有效时间 > 0，这个cookie一定会存储到硬盘文件当中
        
        设置cookie的有效时间 = 0 ，即删除该cookie，应用在删除同名cookie
        
        设置cookie的有效时间
        
        删除cookie的注意事项
        
        设置完时间为0之后，要将该cookie对象重新响应给浏览器才能实现覆盖
        
        删除Cookie时，新建的Cookie除value、maxAge之外的所有属性，都要与原Cookie完全一样。否则浏览器将视为两个不同的Cookie不予覆盖，导致删除失败
        
        Cookie[] cookies = req.getCookies(); for (int i = 0; i
        
        关于cookie的path（cookie关联的路径)
        
        假设发送的请求路径是“http://localhost:8080/servlet13/cookie/generate”生成的cookie，如果cookie没有设置path
        
        浏览器提不提交cookie取决于默认路径，不在默认路径下的资源不提交
        
        默认的path是：http://localhost:8080/servlet13/cookie 以及它的子路径
        
        http://localhost:8080/servlet13/cookie和http://localhost:8080/servlet13/cookie/generate都会发送cookie对象
        
        只要浏览器的请求路径是http://localhost:8080/项目名称（根路径）/生成cookie的servletpath的根目录【/子目录】
        
        设置cookie路径cookie.setPath("路径");
        
        cookie.setPath(“/项目”); 只要是当前项目的请求路径，都会提交这个cookie给服务器
        
        接收浏览器发送的cookie（模拟服务器接收cookie对象）request.getCookies();
        
        Cookie[] cookies = request.getCookies(); if(cookies != null){ for(Cookie cookie : cookies){ // 获取cookie的name String name = cookie.getName(); // 获取cookie的value String value = cookie.getValue(); } }
        
        注意：
        
        浏览器中如果没有cookie则获取到null而不是空数组
        
        cookie数组长度一定大于0
        
        使用cookie实现十天内免登录功能
        
        先实现登录功能
        
        登录成功
        
        跳转到部门列表页面
        
        登录失败
        
        跳转到登录失败页面
        
        修改前端页面
        
        十天免登录
        
        在登录页面添加一个复选框
        
        选择了复选框：表示要支持十天内免登录
        
        没有选择复选框：表示不想使用十天内免登录功能
        
        checkbox(复选框)的value属性
        
        value 属性可设置或者返回 checkbox 的value属性值
        
        value 属性用于表单数据的提交，只有选中的复选框才会传递数据到服务端（什么都没选则不传递复选框数据）
        
        修改Servlet中的login方法
        
        如果用户登录成功，并且登录时选择了十天内免登录功能
        
        思路：在Servlet的login方法中创建cookie，用来存储用户名和密码，并且设置路径，设置有效期，将cookie响应给浏览器（浏览器将其自动保存在硬盘文件当中10天）
        
        实操：如果走login方法就先获取复选框的数据，判断是否选中，然后创建cookie等一系列操作
        
        用户再次访问该网站的时候，访问这个网站的首页的时候，有两个走向
        
        跳转到部门列表页面
        
        跳转到登录页面
        
        两个走向需要编写java程序进行控制的
        
        先获取cookie数组，数组不为null就遍历获取username和password字符串
        
        两者都获取到之后，两者
        
        不为空进入下一步判断
        
        为空直接重新登录
        
        验证用户名和密码是否正确
        
        正确进入列表页面
        
        错误进入登录页面
        
        jsp
        
        访问jsp文件
        
        假设访问index.jsp，底层执行的是index_jsp.class 这个java程序
        
        index.jsp会被tomcat翻译生成index_jsp.java文件，然后tomcat服务器又会将index_jsp.java编译生成index_jsp.class文件
        
        访问index.jsp，实际上执行的是index_jsp.class中的方法
        
        jsp实际上是一个Servlet
        
        jsp文件对应的类继承 HttpJspBase，而HttpJspBase类继承HttpServlet，所以jsp类是一个Servlet类
        
        jsp的生命周期和Servlet的生命周期完全相同
        
        jsp和servlet一样都是单例（假单例，只创建一个对象）
        
        JSP和Servlet的区别（职责不同）
        
        Servlet的职责：收集数据（Servlet的强项是逻辑处理，业务处理，然后链接数据库，获取/收集数据）
        
        JSP的职责：展示数据（JSP的强项是做数据的展示）
        
        jsp文件第一次被访问比较慢的原因
        
        要把jsp文件翻译生成java源文件
        
        java源文件要编译生成class字节码文件
        
        通过class去创建servlet对象
        
        然后调用servlet对象的init方法
        
        最后调用servlet对象的service方法
        
        之后访问就可以直接执行servlet对象的service方法
        
        ！！！Jsp相关知识！！！
        
        JSP是java程序（JSP本质还是一个Servlet）
        
        对JSP进行错误调试时，还是要直接打开JSP文件对应的java文件，检查java代码
        
        开发JSP的最高境界：眼前是JSP代码，但是脑袋中呈现的是java代码
        
        全名：JavaServer Pages的缩写（基于Java语言实现的服务器端的页面）
        
        JSP是一套规范
        
        JSP是JavaEE的13个子规范之一（因为Servlet是JavaEE的13个子规范之一）
        
        所有的web容器/web服务器都是遵循这套规范的，并且按照这套规范进行翻译（jsp中有个out流对象，每行jsp代码通过out的write方法输出）
        
        每一个web容器/web服务器都会内置一个JSP翻译引擎
        
        $动力节点Java Web知识笔记,image-20230123234958626,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第30张$
        
        jsp文件的扩展名是可以配置的，不是固定的
        
        在CATALINA_HOME/conf/web.xml，在这个文件当中配置jsp文件的扩展名
        
        jsp *.jsp *.jspx
        
        xxx.jsp文件对于tomcat来说，只是普通的文本文件，web容器会将xxx.jsp文件最终生成java程序，最终调用的是java对象相关的方法，真正执行时，和原jsp文件没有关系
        
        jsp中九大内置对象
        
        作用域对象
        
        jakarta.servlet.jsp.PageContext pageContext 页面作用域
        
        jakarta.servlet.http.HttpServletRequest request 请求作用域
        
        jakarta.servlet.http.HttpSession session 会话作用域
        
        jakarta.servlet.ServletContext application 应用作用域
        
        pageContext
        
        以上四个作用域都有：setAttribute、getAttribute、removeAttribute方法
        
        作用域使用原则：尽可能使用小的域
        
        响应相关
        
        jakarta.servlet.jsp.JspWriter out （负责输出）
        
        jakarta.servlet.http.HttpServletResponse response （负责响应）
        
        java.lang.Throwable exception
        
        jakarta.servlet.ServletConfig config
        
        java.lang.Object page （其实是this，当前的servlet对象【jsp本质就是servlet】）
        
        ！！！基础语法！！！
        
        jsp文件中编写文字
        
        会被自动翻译到servlet类的service方法的out.write("")中的双引号里
        
        被java程序当做普通字符串打印输出到浏览器
        
        在JSP中编写的HTML CSS JS代码，对于JSP来说只是普通的字符串。输出到浏览器，浏览器会对进行解释执行，展现一个效果
        
        解决响应时的中文乱码问题
        
        jsp不是默认utf-8
        
        通过page指令来设置响应的内容类型，在内容类型的最后面添加charset=UTF-8
        
        ，表示响应的内容类型是text/html，采用的字符集UTF-8
        
        ！！！JSP中编写Java程序！！！
        
        （““之间不能有空格,两个符号必须是紧挨着的）
        
        在这个符号中编写的代码被视为java程序，被翻译到Servlet类的service方法内部
        
        在这个符号里面写java代码时，就相当于在“方法体”当中写代码，要符合java语法中的方法规范
        
        在service方法当中编写的代码是有顺序的，方法体当中的代码要遵循自上而下的顺序逐行执行
        
        service方法当中不能写静态代码块，不能写方法，不能定义成员变量(定义的变量不能被访问权限修饰符修饰)
        
        在同一个JSP当中这个符号可以出现多个
        
        注意：在中调用setAttribute等方法会爆红，但是可以正常运行
        
        在这个符号当中编写的java程序会自动翻译到service方法之外
        
        这个语法很少用，在service方法外面写静态变量和实例变量，都会存在线程安全问题，因为JSP就是servlet，servlet是单例的，多线程并发的环境下，这个静态变量和实例变量一旦有修改操作，必然会存在线程安全问题
        
        JSP的输出语句
        
        向浏览器上输出一个java变量
        
        以上代码中的out是JSP的九大内置对象之一（在service方法中被创建），可以直接拿来用（只能在service方法内部使用）
        
        向浏览器上输出的内容中没有“java代码”，可以直接在jsp中编写，不需要写到这里
        
        输出的内容中含有“java代码”，可以使用以下语法格式
        
        ，在=的后面编写要输出的内容
        
        翻译成java代码：out.print();，里面的代码不能加分号
        
        翻译到service方法当中
        
        使用的情况
        
        输出的内容中含有java的变量，是一个动态的内容，不是一个死的字符串
        
        如果输出的是一个固定的字符串，直接在JSP文件中编写即可
        
        JSP的专业注释
        
        JSP基础语法总结
        
        JSP中直接编写普通字符串
        
        翻译到service方法的out.write("普通字符串")
        
        翻译到service方法体内部，里面是一条一条的java语句
        
        翻译到service方法之外
        
        翻译到service方法体内部，翻译为：out.print();
        
        page指令，通过contentType属性用来设置响应的内容类型
        
        在jsp中编写的代码最终执行顺序不一定是从上到下的，要根据具体的符号而定，相同符号有从上到下的先后顺序
        
        中的代码最终翻译在类体中，即使在jsp代码的后面也比中的代码先执行
        
        而两个是有先后执行顺序的
        
        $动力节点Java Web知识笔记,image-20230124234006572,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第31张$
        
        JSP的指令
        
        指令的作用：指导JSP的翻译引擎如何工作（指导当前的JSP翻译引擎如何翻译JSP文件）
        
        包括
        
        include指令：包含指令，在JSP中完成静态包含，很少用
        
        taglib指令：引入标签库的指令(到JJSTL标签库的时候再学习)
        
        page指令：目前重点学习
        
        指令的使用语法
        
        关于page指令中常用的属性
        
        启/禁用JSP的内置对象session
        
        true表示启用JSP的内置对象session，一定启动session对象（没有session对象会创建），没有设置，默认值就是session="true"
        
        session="false" 表示不启动内置对象session，当前JSP页面中无法使用内置对象session
        
        contentType属性
        
        设置响应的内容类型
        
        也可以设置响应字符集（方式一）
        
        pageEncoding属性
        
        设置响应时采用的字符集（方式二）
        
        import语句，导包
        
        errorPage属性
        
        指定出错之后的跳转位置
        
        isErrorPage属性
        
        启用JSP九大内置对象之一：exception(异常对象),默认值是false（可以在错误处理页面启用）
        
        Servlet + JSP改造oa项目
        
        使用Servlet处理业务，收集数据。使用JSP展示数据
        
        将之前原型中的html文件，全部修改为jsp，然后在jsp文件头部添加page指令（指定contentType防止中文乱码），将所有的JSP直接拷贝到web目录下
        
        完成所有页面的正常流转（修改超链接的请求路径）
        
        如果发现修改路径后，浏览器的展示的路径还是没变，就要！！！清除浏览器缓存！！！
        
        crtl+shift+delete
        
        在JSP中动态的获取应用的根路径并且输出到jsp代码中
        
        动态根路径写到超链接中注意事项
        
        /资源路径">超链接名称
        
        之中可以随便加空格，最终都会被翻译成根路径
        
        之外不能随便加空格，因为符号之外的只是普通字符串，空格会被当成超链接的一部分
        
        展示数据
        
        Servlet中连接数据库，查询所有的部门，遍历结果集
        
        遍历结果集的过程中，取出部门编号、部门名、位置等信息，封装成java对象
        
        将java对象存放到List集合中
        
        将List集合存储到request域当中
        
        转发forward到jsp(不要重定向)
        
        在JSP中
        
        从request域当中取出List集合
        
        遍历List集合，取出每个部门对象，动态生成表单
        
        注意
        
        jsp中的符号不能嵌套使用，比如是错的
        
        但是jsp符号有截断功能（本质就是翻译成java代码）
        
        修改功能的页面回显和详情功能获取数据基本一致，可以合并
        
        合并技巧（初版）
        
        jsp中，二者跳转路径相同，请求头携带的数据不同，通过f的值来标识是哪个功能
        
        /dept/detail?f=m&deptno=">修改 /dept/detail?f=d&deptno=">详情
        
        servlet中，获取f参数，根据f值决定查询数据之后要执行的功能
        
        String f = request.getParameter("f"); if ("m".equals(f)) { //走修改 request.getRequestDispatcher("/edit.jsp").forward(request,response); }else if("d".equals(f)) { //走详情 request.getRequestDispatcher("/detail.jsp").forward(request, response); }
        
        技巧升级版（缺点：如果两者跳转的资源文件后缀名不同，字符串拼接就有问题）
        
        jsp中，二者跳转路径相同，请求头携带的数据不同，通过path的值来指定跳转路径
        
        /dept/detail?path=edit&deptno=">修改 /dept/detail?path=detail&deptno=">详情
        
        servlet中，获取前端选择的跳转资源路径，进行字符串拼接转发
        
        String path=request.getParameter("path"); request.getRequestDispatcher("/"+path+".jsp").forward(request,response);
        
        只用JSP这一个技术也可以开发web应用
        
        JSP就是Servlet，在JSP的里面写的代码就是在service方法当中的，所以在当中完全可以编写JDBC代码，连接数据库，查询数据，编写业务逻辑代码，处理业务等等
        
        建议采用servlet + jsp的方式进行开发，将各自的优点发挥出来，JSP就是做数据展示，Servlet就是做数据的收集（JSP中编写的Java代码越少越好）
        
        当前的oa应用存在的问题
        
        任何用户都可以访问这个系统，对系统当中的数据进行增删改操作。只让合法用户访问该系统的方式
        
        加一个登录功能。登录成功的可以访问该系统，登录失败不能访问
        
        实现登录功能：
        
        步骤1：数据库中添加一个用户表：t_user
        
        t_user表当中存储的是用户的登录信息，最基本的包括：用户名和密码
        
        密码一般在数据库表中存储的是密文，不以明文的形式存储（一般采用MD5加密，这里先使用明文方式）
        
        向t_user表中插入数据
        
        步骤2：再实现一个登录页面和登录失败的页面
        
        登录页面上应该有一个登录的表单，有用户名和密码输入框
        
        用户点击登录，提交用户名和密码（form以post方式提交）
        
        步骤3：后台要有一个对应的Servlet来处理登录的请求
        
        登录成功：跳转到部门列表页面
        
        登录失败：跳转到失败的页面
        
        目前的登录功能存在的最大问题
        
        只是一个摆设，没有任何作用：只要用户知道后端的请求路径，照样可以在不登录的情况下访问
        
        没有真正起到拦截作用
        
        EL表达式
        
        定义和作用
        
        Expression Language（表达式语言）
        
        表达式：由变量或常量与符号的组合
        
        EL表达式可以代替JSP中的java代码，让JSP文件中的程序看起来更加整洁、美观（简化jsp）
        
        JSP中夹杂着各种java代码，例如、等，导致JSP文件很混乱，不好看且不好维护
        
        jsp2.0时引入el表达式
        
        EL表达式可以算是JSP语法的一部分，EL表达式归属于JSP
        
        jsp中EL表达式的功效（只负责取不负责存）
        
        从某个作用域中取数据，然后将其转换成字符串，然后将其输出到浏览器，三大功效
        
        第一功效：从某个域中取数据
        
        四个域
        
        pageContext
        
        request
        
        session
        
        application
        
        第二功效：将取出的数据转成字符串
        
        如果是一个java对象，会自动调用java对象的toString方法将其转换成字符串。
        
        第三功效：将字符串输出到浏览器
        
        等同于
        
        EL表达式对null进行了预处理
        
        如果是null，则向浏览器输出空字符串
        
        el表达式实际运行时会被翻译成Java代码
        
        ${usernam} 等同于
        
        相较于输出null，el表达式更适合页面展示
        
        EL表达式的使用
        
        基本语法格式：${表达式}
        
        具体获取数据步骤
        
        先通过jsp符号将User对象存储到某个域当中，EL表达式只能从某个范围中取数据（数据是必须存储到四大范围之一）
        
        使用EL表达式
        
        ${这里写的是存储到域对象中name}(不含双引号)
        
        ${userObj}等同于java代码
        
        ${userObj} 底层执行
        
        从域中取数据，取出user对象
        
        调用user对象的toString方法，转换成字符串，输出到浏览器
        
        输出对象的属性值
        
        语法${存储到域对象中name.属性名对应的get方法去掉get并且把首字母大写后的字符串}
        
        使用这个语法的前提是：该对象有get方法，不一定要有与之对应的属性（和成员变量无关，只取决于get方法）
        
        EL表达式中. 这个语法，实际上调用了底层的getXxx()方法，没有对应的get方法，会报500错误
        
        ${userObj.username} 使用这个语法的前提是：User对象有getUsername()方法 ${userObj.password} 使用这个语法的前提是：User对象有getPassword()方法 ${userObj.age} 使用这个语法的前提是：User对象有getAge()方法 ${userObj.email} 使用这个语法的前提是：User对象有getEmail()方法 ${userObj.addr222.zipcode} 以上EL表达式对应的java代码： user.getAddr222().getZipcode()
        
        面试题：${abc} 和 ${"abc"}的区别
        
        ${abc}表示从某个域中取出数据，并且这个数据的name是"abc"，取之前一定有这样的代码: 域.setAttribute("abc", 对象);
        
        ${"abc"} 表示直接将"abc"当做普通字符串输出到浏览器(不会从某个域中取数据）
        
        取数据的范围
        
        EL表达式优先从小范围中读取数据(没指定范围的前提)
        
        pageContext
        
        假设不同域存的数据name相同，输出最小范围域的数据
        
        EL表达式隐含的隐式的范围（可以从指定范围中取数据）
        
        el表达式四个隐式范围对象对应的范围
        
        pageScope 对应的是 pageContext范围
        
        requestScope 对应的是 request范围
        
        sessionScope 对应的是 session范围
        
        applicationScope 对应的是 application范围
        
        语法${范围.name}
        
        注意：指定了范围，如果找不到对应的name就不会从其它域去找
        
        取数据的两种形式
        
        第一种：. name （大部分使用）
        
        第二种：[" name"]
        
        存储到域的name中含有特殊字符，可以使用 [ ]
        
        比如request.setAttribute("abc.def", "zhangsan");
        
        ${requestScope.abc.def} 这样是无法取值的
        
        应该这样：${requestScope["abc.def"]}
        
        使用[]要加双引号，不加双引号会将其看成变量
        
        不同数据结构中取数据
        
        如果取的是对象，则会调用该对象的toString方法
        
        从实体类中取数据（前面的取数据都是）
        
        实体类的属性要有对应的get方法
        
        会报500异常的情况
        
        属性没有get方法
        
        不是属性而且也没有get方法
        
        不是实体类的属性但是有get方法不会报异常
        
        如果实体类作为数组或者集合的元素，域中传入数组或者集合，取实体类元素的属性，该属性也要满足第一条
        
        $动力节点Java Web知识笔记,image-20230201210117002,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第32张$
        
        从Map集合中取数据
        
        ${name.key}
        
        $动力节点Java Web知识笔记,image-20230201204755974,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第33张$
        
        $动力节点Java Web知识笔记,image-20230201205057681,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第34张$
        
        从数组中取数据
        
        取数组对象${name}
        
        取数组元素${name[0]}
        
        $动力节点Java Web知识笔记,image-20230201205314347,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第35张$
        
        数组越界处理
        
        取不出数据在浏览器显示空白，不报错（不会出现下标越界）
        
        从list集合取数据
        
        取list对象${name}
        
        取list集合元素${name[0]}
        
        $动力节点Java Web知识笔记,image-20230201211801478,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第36张$
        
        从set集合中取数据
        
        取set对象${name}
        
        因为set无序，所以无法取set集合的元素，否则会报错
        
        $动力节点Java Web知识笔记,image-20230201211543656,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第37张$
        
        忽略EL表达式
        
        设置忽略el表达式会导致其被当成普通字符串来看待，即在浏览器输出${name}这样的字符串
        
        page指令中的isELIgnored属性（全局忽略）
        
        isELIgnored="true" 表示忽略EL表达式 isELIgnored="false" 表示不忽略EL表达式（默认值）
        
        局部忽略
        
        使用反斜杠
        
        \${username}
        
        其他隐式对象
        
        pageContext
        
        和jsp中的内置对象是同一个
        
        el表达式中没有其他域对象，但是pageContext对象有获取其它域对象的get方法（el表达式可以调用对象的get方法）
        
        $动力节点Java Web知识笔记,image-20230201214038711,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第38张$
        
        通过EL表达式获取应用的根
        
        ${pageContext.request.contextPath}等同于
        
        //获取到的request对象要强转成httpServletRequest
        
        pageContext.getRequest()获取到的是ServletRequest的request对象
        
        getContextPath()是httpServletRequest对象的方法
        
        param
        
        获取单个提交的数据
        
        ${param.username}等同于
        
        如果提交多个数据，则获取第一个数据
        
        paramValues
        
        获取多个提交的数据，以数组形式存储
        
        ${paramValues.habbies}等同于
        
        获取数组单个元素需要通过下标
        
        ${paramValues.habbies[0]}
        
        initParam
        
        获取初始化配置信息
        
        initParam获取的属性名必须是web.xml文件中context-param标签中的param-name
        
        没有对应的属性则输出空白
        
        初始化配置信息存在ServletContext（上下文）对象中，对应的jsp九大内置对象——application
        
        $动力节点Java Web知识笔记,image-20230202180628062,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第39张$
        
        运算符（了解）
        
        算术运算符
        
        +、-、*、/、%
        
        el表达式中+不会做字符串拼接，只能做求和运算（会先把字符串转化成数字，无法转换就报错）
        
        #{10+"20"}输出结果是30（字符串"20"自动转化成数字20）
        
        #{10+"abc"}会报数字转化异常
        
        $动力节点Java Web知识笔记,image-20230202181940622,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第40张$
        
        关系运算符
        
        ==/eq != > >=
        
        在当前页面中，凡是路径没有以“/”开始的，都会自动将base中的路径添加到这些路径之前（对没以”/“开始的路径起作用）

相关阅读：

1、域名访问验证怎么解决问题(域名访问限制不严格怎么解决)

2、Go 使用 MongoDB

3、【Java】Set集合的基本使用

4、【python】flask中蓝图使用方法详细解析

5、【Spring Boot】掌握Spring Boot：深入解析配置文件的使用与管理

免责声明

本网站所收集的部分公开资料来源于AI生成和互联网，转载的目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

发表评论取消回复

评论列表（暂无评论，1616人围观）

还没有评论，来说两句吧...

目录[+]