[Java知识库]java web学习笔记（持续更新）

一、Java Web简介

web： 前端的一些内容，在浏览器中展示的内容，html + css + js
Java Web： 使用Java语言来编写前端页面 ；

jsp属于Java ，所以学习jsp实际上就是学习Java的一个类/接口 Servlet

jsp 全名称：java server page Java服务器页面 ( 动态资源页面)

静态资源页面

当这个页面写完之后，内容就固定死了，不管在何时何地打开，页面展示的内容都是一样的；页面中的数据是死的；

**动态资源页面 **

页面中的数据会变化，写完之后，在不同时间、不同条件下，打开页面展示的内容可能会不一样；页面中的数据不是死的；

将html原本内容和从数据库中查询出来的内容重新合并组成一个新的html页面，来进行展示。

二、认识Servlet

JavaWeb程序 --> 将一个请求路径( 网络地址 ) 变成一条sql语句，发送给数据库进行查询；

1、什么是Servlet？

什么是Servlet? JavaWeb的三大组件 ( Servlet Filter过滤器 Listener监听器 )
    小服务，小组件，
主要作用：
    接收用户发来的请求( 路径及数据 )，给用户响应对应内容( 页面 )；

2、请求路径

一般来讲，请求路径指的是 网络访问路径 (不带盘符，基本格式为：协议://ip地址:端口号/路径 )
网络路径：
    http://192.168.15.52:8080/web01/hello.html
    http://220.181.38.149:80 --> 百度首页 www.baidu.com (域名商)
本机路径：带盘符的路径
    D:\工作\apache\apache-tomcat-8.5.57
    
将一个本地路径，变成网络路径
需要使用到服务器：tomcat服务器服务 服务器机器

3、tomcat

tomcat的安装，百度搜索tomcat，去官网下载core中的zip格式，解压版
解压之后的tomcat分布：
    bin：放置的都是可执行文件，包含启动执行文件startup.bat( 如果点击之后，出现闪退的情况，说明jdk的环境变量java_home没有配置好 )、
关闭执行文件shutdown.bat；
    conf：放的都是tomcat的配置文件，tomcat的端口号、编码格式、服务配置、支持的文件配置；server.xml web.xml
    lib：tomcat也是Java编写的，在执行的时候，同样需要Java jar包的支持，都存放在这；编写servlet时需要的jar包
    logs：日志记录文件夹，在使用tomcat过程，出现问题，或者没有问题是，形成的日志文档，都在这个文件夹中；
    temp：临时文件，可以删除，但每次执行时都会自动创建
    webapps：tomcat实际执行过程中，所访问的文件地址，所有的页面文件都保存在这个文件夹中；ROOT表示没有项目名
    work：在执行tomcat时，程序中如果有jsp文件，会在这个文件夹中转换成.java文件

4、Servlet的使用

jdk java开发工具包 --> ( jre java运行环境 --> ( JVM + java运行jar包，jdk自带jar包 ) + java开发工具 )
Servlet是Java中的接口，不属于jdk自带jar包，需要导入第三方的jar包( tomcat ) ;
    1、先导入tomcat的jar包，到项目中；
    2、创建一个AServlet，实现Servlet接口

将一个类变成Servlet的三种方式
    1、实现Servlet接口，重写接口中的全部方法；
    2、继承GenricServlet抽象类，重写抽象方法；
    3、继承HttpServlet抽象类，根据需要进行重写；

三、Servlet简单应用

Servlet是 javaweb的三大组件之一，接受请求，给出响应；

1、创建Servlet的方式：

3种创建Servlet的方式：

1. 通过现实Servlet接口，重写全部方法；
2. 通过继承GenericServlet抽象类，重写service()方法；
3. 通过继承HttpServlet抽象类，重写自己需要的方法；(开发种常用)

一般情况下，Java程序，想要执行需要通过main方法，声明对象，使用对象进行调用方法； Servlet的使用

编写完成Servlet之后，需要将Servlet类与路径相互绑定；

2、Serlvet的生命周期

Serlvet的生命周期： Servlet对象从出生、使用、死亡； Servlet会自己创建对象，然后自己调用自己 的生命周期方法；

3个生命周期方法；

1. init(ServletConfig servletConfig) 初始化方法，看成servlet对象的出生； 当servlet对象一旦被创建时，就会马上执行init方法
2. service(ServletRquest request , ServletResponse response) 服务方法，是servlet的主要方法，每当路径被请求时，就会执行此方法；
3. destroy() 结束方法，当Servlet对象一被销毁，在销毁之前的时间执行此方法；

3、路径与servlet绑定的方式

1、使用web.xml配置文件进行绑定； 比较复杂
<servlet>
    <servlet-name>servlet</servvlet-name>
    <servlet-class>cn. hp. Aservlet</Servlet-class>
</servlet>
servlet-mapp1ng>
    <servlet-name>servlet</servlet-name>
    <!--当用户请求http://locathost:8080/web/a-->
    <url-pattern>/a</url-pattern>
</servlet-mapping>

2、使用注解的方式：简单 
在类的名称上一行，@WebServlet("/b");

4、servlet种的request 和 response

request:数据类型: HttpServletRequest请求
    包含:用户发送来的内容以及浏览器的信息等等;
        路径之后跟?key=value&key=value浏览器请求参数,当用户使用get方式时,就是用户发送的请求操作内容
    用来接收用户从浏览器发送过来的数据
   request.getParamter("key的名称") 获取到参数的value
   
请求转发:表面上还是你这个路径,但实际显示的内容由转发后的对象进行处理
    只能转发给本程序中的路径
req.getRequestDispatcher("success.html").forward(req,resp);

请求包含：用法和转发一样 
    语法中将forward换成include 
req.getRequestDispatcher("success.html").include(req,resp);

response：数据类型：HttpServletResponse 响应

重定向：将本次的请求，重新换了一个路径进行访问； 
    此路径，不局限于本项目，可以访问任意网路路径；
请求转发和重定向的区别： 
1、请求转发由request对象发出，只能发送给本项目中存在的路径 重定向由response对象发出，不仅可以发送给本项目中的路径还能够发送给外部路径； 
2、请求转发中一共有一个请求,导致页面中的路径只会是请求的路径 重定向包含两个请求，一个是用户原请求，第二个是servlet做的重定向请求； 
3、请求转发可以支持post、get的请求 重定向第一个请求post、get都支持，第二个请求只支持get方式

4、服务器中，页面的跳转

当一个路径以 / 开头， /就代表 http://localhost:8080/ 
当一个路径不以 / 开头， 就是把原路径的最后一个文件名换成当前的路径内容 

如 原文件路径 http://localhost:8080/web01/a.html ; 
login 路径 --> http://localhost:8080/web01/login 
/login 路径 --> http://localhost:8080/login 
只有在一种情况下，两者跳的路径相同，javaweb项目没有设置项目名时

四、JSP简介

1、JSP是什么？

JSP：是一种页面，java server pages java服务器页面；想要这个页面运行，必须通过服务器中启跳转；

只能通过网络访问的方式查看效果，不能直接从本地通过浏览器打开； http://localhost:8080/web02/i ndex.jsp

2、JSP和与html的区别？

1、html是静态资源页面，jsp是动态资源页面，页面内的数据会改变； 
2、html中只能使用标签，进行编写内容；jsp = html + java代码 + 指令 ；

3、jsp三大指令

三大指令

1. page
2. taglib
3. include

在jsp页面最上方<%@ 指令名 属性... %> 
1、page 用来配置当前jsp页面中的相关信息 
属性：
    contentType:用来配置当前jsp中文件的类型，以及编码格式 
    session：设置当前页面是否支持会话，false表示页面不支持session对象 
    isErrorPage：设置当前页面是否为错误页面 
    errorPage：指定哪一页面是错误页面 
    pageEncoding：设置当前页面的编码格式 
    import：向页面中导入Java的jar包 
    isELIgnored：用来设置当前页面中是否需要忽略el表达式 
2、taglib：用来向jsp页面中导入 jstl表达式的 
3、include：用来将多个页面合并成一个页面进行展示；

4、在jsp中Java代码编写格式

Java代码编写片段：
    <% Java代码 %> 
Java代码输出片段：
    <%= 将数据内容输出到页面中 %>

5、jsp的作用域

四大作用域

1. page
2. request
3. session
4. application

域：用来保存数据；只不过，不用的域大小不一样，保存的数据时间也不一样； 
page域： 页面域，当前页面中的全部数据，整个页面都共享；pageContext 只能在本页面中进行使用 
request域：请求域，在同一次请求中，所有数据共享；域对象 request 
    在servlet中就是 HttpServletRequest类型的对象 
    在jsp中存在这默认内置对象，这个对象可以不用声明，直接在jsp中使用 对象名：request 
session域：会话域，给服务器一次请求，服务器给一次响应，来回的交互过程就叫会话， 域对象： session 
    session即打开浏览器后的操作，都归为一次session，一旦关闭浏览器，此次session即结束； 
    随着第一次请求而创建，随着浏览器的关闭而销毁； 
application域：应用域，最大的一个域，只要将数据保存在应用域中，在整个程序的任意位置都可以 获取到应用域中的数据， 
    随着程序的启动而创建，随着程序的关闭而销毁； 
    
如何使用域中数据； 
    向域中存数据：req.setAttribute("key","value"); 
    从域中取数据：req.getAttribute("key");

6、jsp的本质

先将jsp转换成.java文件，然后通过Java代码将JSP页面以及域对象数据，获取之后，重新拼接成一个新 的页面； 
域数据 和 页面参数

7、域数据 和 页面参数

页面参数数据：
    http://localhost:8080/web02/login?username=zs&pwd=123 
?之后都是页面参数数据 
    在后端servlet中，通过request.getParamter(key)方法进行获取 
域数据：必须是有放才有拿； 
    放数据：域对象.setAttribute("key",value); 可以在servlet中放、也可以在jsp中放 
    拿数据：域对象.getAttribute("key"); 可以在servlet中拿、也可以在jsp中拿

五、JSP内置对象

1、jsp的组成部分 html + java代码 + 指令

hmtl: 超文本标记语言

hmtl: 超文本标记语言
表格标记：格式化显示数据；
<table> 声明一个表格
    <tr> 声明一行
        <th></th> 标题，加粗居中
        <th></th>
        <th></th>
    </tr>
    <tr> 声明一行
        <td></td> 声明一个单元格
        <td></td> 声明一个单元格
        <td></td> 声明一个单元格
    </tr>
    <tr> 声明一行
        <td></td> 声明一个单元格
        <td></td> 声明一个单元格
        <td></td> 声明一个单元格
    </tr>
</table>

表格的特殊属性：

表格的特殊属性：
给table设置的属性：cellspacing="" 设置当前表格中每个相邻单元格之间的间距
给td设置的属性：colspan=""设置当前单元格占几列 rowspan="" 设置档当前单元格占
几行
表单标记：收集用户的信息，让用户进行填写、选择、点击操作；
<form action="后端地址">
    <input type="text" value="默认值" placeholder="提示内容" /> 文本输入框
    input类型 四种类型( 输入框、选择样式、按钮样式、隐藏样式 )
    <input type="password" /> 密码输入框  // 
    <input type="radio" /> 单选框
    <input type="checkbox" /> 多选框
    <input type="button" /> 默认按钮
    <input type="submit" /> 提交按钮
    <input rype="reset" /> 重置按钮
    <input type="file" /> 文件上传按钮 上传头像、上传图片、上传表格
    <input type="image" src="图片地址" /> 图片按钮
    <input type="hidden" /> 隐藏样式，通常保存不想让外人看到的数据；不在页面中占任
    何位置
    <select multiple size="2"> 下拉框样式 multiple 设置当前下拉框支持多选，
        size 设置拉下展示个数
        <option>选择1</option>
        <option>选择2</option>
        <option SELECTED >选择3</option>  //  默认选3
    </select>
    大文本框
    <textarea rows="行数" cols="列数"> 大文本框
</textarea>
</form>
使用表单进行前端后端交互，必须给每个标记一个name属性，该属性代表着后端页面中接收用户操作时 的key值，来获取value；

属性
readonly 只读属性
disabled 禁用属性 变成灰色的了 相当于把它删除了
文本输入框 <input type="text" readonly>
<br/>
密码输入框 <input type="password" disabled>
<br/>

2、JSP的九大内置对象

jsp可以写Java代码，遵循Java的规范，一个方法想要执行，必须通过 对象.方法名() 调用，创建对象必须使用 new 关键字
九大内置对象，表示不用创建对象，这个对象由jsp自己创建，可以直接使用
当一个jsp文件被编译之后，会变成一个servlet文件，具备servlet的所有特征；
1、out对象，像页面中输出内容对象；
    使用：out.println("内容")
2、config对象，servlet配置信息对象；
    config.getServletName()
3、exception对象，不是每个页面中都有的对象，只有在页面被设置为isErrorPage="true"时，才能使用
    exception.getMessage();
4、page对象，当前页面对象， this
5、application对象，应用域对象；用来存储数据的；
    作用范围：当程序启动时，自动创建应用域，当程序停止运行时，应用域被销毁；只要程序在运行，这个域一直在；
    通常使用：项目的公共资源；spring中的数据库连接对象、日志对象功能等
    application.setAttribute("key",value);
6、session对象，会话域对象，并不是每个页面都支持session( page指令的session="false" 表示当前页面不支持session )
    作用范围：当一个浏览器第一次发送请求时，自动创建会话域，浏览器被关闭时，会话域销毁；当会话超时时，会话域也自动销毁；
    通常应用：保存当前登录账号信息；
    session.setAttribute("key",value);
    session.getAttribute("key");
7、request对象，请求域对象使用：
    作用范围：在一次请求中，随着请求的发出而创建，随着响应接收而销毁；
    通常应用：登录验证验证，程序中的搜索框，
    请求对象使用：
    String value = request.getParamter("参数key");
8、response对象，响应对象；向页面中输出一些内容 文字、html代码、html页面、jsp页面
    response.getWriter().println("内容")
    response.sendRedirect("页面路径")
9、pageContext对象，页面域对象，通常不使用页面域自己的功能
    1.此对象一个顶九个；可以获取其他八个对象；
    JspWriter out = pageContext.getOut(); 获取out对象
    ServletConfig config = pageContext.getServletConfig(); 获取config对象
    Exception exception = pageContext.getException(); 获取exception对象
    Object page = pageContext.getPage(); 获取page对象
    ServletContext application = pageContext.getServletContext(); 获取application对象
    HttpSession session = pageContext.getSession(); 获取session对象
    ServletRequest request = pageContext.getRequest(); 获取request对象
    ServletResponse response = pageContext.getResponse(); 获取response对象
2.用来向其他三个域中存放数据
    pageContext.setAttribute("key",value,域值);
域值：
    1 表示 向page域中存放数据
    2 表示 向request域中存放数据
    3 表示 向session域中存放数据
    4 表示 向application域中存放数据
从其他三个域中取数据
    pageContext.getAttribute("key",域值)

六、 javaBean与JSP动作

1、java类

Java的数据类型： 
一：基本数据类型
 1.整数型：byte（1字节 -128~127） short(-32768~32767) int（4字节） long 
 2.小数型：float double 
 3.布尔型：boolean 
 4.字符型：char（2字节 0~65535） ASCII表，将char类型和int类型相互换 
 二：引用数据类型 
 1.数组：表示一组同一类型的内容； 
 2.类： 
3.接口 
Java设置数据类型的目的： 
Java中的变量和常量： 
常量：在整个程序运行过程中，不会被改变的值； 所有的数字常量，默认为int类型 
变量：在整个程序运行过程中，可能会被改变的值；

2、Java程序执行顺序：

从上往下，同一行从左往右；遇到等号，从右往左； = 表示赋值

Java：万物皆对象，万物皆可new； 一new一对象；

3、JavaBean

JavaBean是一种Java的定义规范，用来描述一个类； 
Java的三大特性；封装、继承、多态； 
封装：
    将属性使用private私有化，对外提供公共的方法进行访问； 
    根据对此类的不同属性的需求，提供响应的set\get方法； 
属性：
    只读属性 只设置get方法 只写属性 只设置set方法 
    
JavaBean类：
    将一个Java类，通过封装的方式设置属性，并对每一个属性设置set\get方法，以及有参无参构造、 toString()方法,统称为JavaBean类 
JavaBean的属性：
    由set\get方法决定，将set\get方法中 set\get去掉后，
属性名：
    首字母的小写后的值， 即为属性名； 
// getStudentNumber --> 属性：studentNumber 
// setStudentNumber1 --> 属性：studentNumber1

4、JSP动作及cookie的使用

三大指令：

 <%@ page /> <%@ taglib /> <%@ include />

jsp动作：jsp动作标签

基本格式：
    <jsp:标签名 属性1="属性值1" 属性2="属性值2" > </jsp:标签名>
作用：
    jsp --> servlet 动作标签就相当于servlet中的语句，所有的动作标记，都相当于Java中的
代码；
1. <jsp:forward page="page1.jsp" /> 将请求转发语句直接使用jsp代码进行书写； 
作用：
    请求转发
相当于servlet中的
    request.getRequestDispatcher("page1.jsp").forward(request,response);
2. <jsp:param name="" value=""/> 将请求参数保存在请求路径上
    使用时，需要放在<jsp:forward> </jsp:forward> 此标签之内，作为请求参数传递，不会暴露在请求路径中；
3. <jsp:include page="page1.jsp"> 请求包含动作和指令 <%@ include page = page1.jsp /> 一样的操作；
    只不过两者中<jsp:include>在编译期就被中执行了
4. <jsp:useBean id="cat2" scope="request" class="cn.hp.model.Cat" /> 
    在request域中去需寻找cat2，如果没有找到，则新建一个cat2，并保存在request域中；如果存在，就直接获取这个值；
    此动作，只是用来保存数据和获取数据的；
    id：在域中创建/获取名字为当前值得数据 相当于 key
    class：保存JavaBean的对象数据类型，必须使用类的全路径方式
    scope：从哪个域中进行获取/保存数据 page request session application
5. <jsp:getProperty name="对应useBean的id值" property="对应JavaBean对象的属性"/>
6. <jsp:setProperty name="对应useBean的id值" property="对应JavaBean对象的属性"value="设置的属性值"/>

5、cookie

项目架构：
    C/S： Client / Server 客户端/服务器 项目 ，如 QQ 微信 LOL 吃鸡
        优势：当恶意修改数据时，不仅要破坏服务器内容还需修改客户端内容，安全性比较高；
        劣势：一旦需要维护，先将服务器进行升级，然后同步客户端数据；
    B/S： Browser / Server 浏览器/服务器 项目 ， 淘宝 京东 唯品会
        优势：只需要维护服务器端，不用操心客户端的内容；
        劣势：只要一破坏服务器端数据，全部数据都会受影响；
java ee 项目，主要是使用 c/s项目模型；

使用cookie完成:
1.小饼干、小甜点；存在于用户电脑中，浏览器中进行保存；样式key1=value1;key2=value2
    在浏览器第一次请求服务器时，是不会携带cookie的，只有请求过服务器之后，服务器会将
cookie放在响应中，一起发送会浏览器；浏览器在接收到cookie之后，会将cookie数据保存在本地中(硬盘
中某一浏览器的存储地址中)；当下一次再去访问相同路径时，再将cookie携带在request请求中一起发送给
服务器；每一个浏览器的cookie是独立的，不通用的；
2.session：会话域，
    从服务器中产生，在用户的电脑中是看不见的；
域范围：
    打开浏览器第一次请求服务器，到关闭浏览器为止；

cookie的使用

Cookie cookie = new Cookie("key","value");

七、MVC模式

jsp组成： html java代码 指令

早期的Javaweb项目，将全部的内容编写在jsp页面中，不仅编写html页面样式，同时还写Java代码；

导致页面内容非常繁杂，一旦发生错误，出现bug，调试成本非常高；

1、MVC设计模式

MVC设计模式，针对项目架构进行设计，将整个项目的代码分成几个包，每个包里用来编写哪种内容；
    M：Model层，模型层，保存数据的层 JavaBean，用来接收数据所使用的类；存储数据Bean 业
务逻辑Bean
    V：View层，视图层，就是给用户展示数据的层，包含页面的样式，html、jsp
    C：Controller层，控制层，控制页面跳转，控制页面中显示的内容；servlet
MVC设计模式，不是独属于Java的，而是适用于所有的B/S( 浏览器/服务器 )项目；

Java出了独有的 三层架构模式
    页面层：web层，程序中所有和页面有关的内容，都归属于web层，包含页面、页面跳转、页面数据
相当于MVC中的 V和C
    业务逻辑层：service层，用来处理业务请求，相当于MVC M
    持久层：dao层，所有和数据库打交道的内容，都归属于dao层，就是使用Java操作数据库进行增、删、改、查；相当于MVCM
java中的容器：保存数据的 
    变量、数组、集合(List Set Map)、对象

2、三层架构

根据三层架构和mvc模式，将Javaweb项目设计为：( 将项目进行分层，分包 )

src下的包：
    model包：用来写JavaBean类
    dao包：用来进行和数据库之间打交道
    service包：用来对项目中的业务做处理
    servlet/controller包：用来写页面跳转的类、数据传递的类； Servlet
    将页面内容全部放在web文件夹下编写；
    util包：（工具包） 针对项目中的额外工具而创建的；

3、 JDBC

jdbc: java database connection Java数据库连接 使用Java语言操作数据库
    java：属于一种编程语言，sun ( JDBC接口,一套数据库相关的规则 )
    数据库：数据库语言，数据库分为多种，sun：MySQL Oracle：Oracle 微软：sqlserver 每
个厂商按照Java的接口生产对应的一套Java操作对应数据库jar包；
    mysql: mysql.jar oracle.jar sqlserver.jar

JDBC的使用

操作MySQL：DML
1、找到mysql连接Java的jar包，将jar包导入到web程序中；
2、告诉程序，我要使用的数据库是哪一个；加载相应的数据库驱动；就是创建一个MySQL的数据库对象；
    Class.forName("com.mysql.jdbc.Driver");
3.知道了是哪一个数据库，接着就要连接到数据库哪一个库中；要指定连接的库的名称，以及使用的用户名、密码
指定连接的库的名称 ： 
    url: 标准格式 三部分
    jdbc: 各个厂商自己规定的连接写法 mysql://localhost:3306 
    连接的数据库及参数 /db?key=value&k2=v2
如： jdbc:mysql://localhost:3306/db?characterEncoding=utf8
    用户名：root 密码：root/123456
    通过上一步的驱动加载，会告知程序中驱动管理器，接着可以使用驱动管理器将url,username,password发送给数据库，从获取一个Java与mysql数据库之间的连接；
Connection con =DriverManager.getConnection("jdbc:mysql://localhost:3306/db", "root", "root");
4.通过连接，创建一个查询编辑器(可以用来编写sql语句，并且执行的 )，
    Statement statement = connection.createStatement(); statement对象就是查询编辑器，可以执行sql语句
5.编写一条sql语句，并执行,执行DML语句，得到受影响行数
    int update = statement.executeUpdate("insert into dept values (50,'实训部','郑州')");
6.执行完毕后，将全部资源进行关闭，先创建的后关闭，后创建的先关闭；
    statement.close();
    connection.close();

DQL:
前4步与DML操作相同；
5.编写一条sql语句，并执行,执行DQL语句，得到结果表
    ResultSet resultSet = statement.executeQuery("select * from dept ");
6.resultSet结果集，记录的是当前查询出来的内容，是一条内容，从第一行上方开始( 即列名行),
    因为不知道查询出来的结果有多少行，所以需要使用while遍历的方式，进行每行数据的查询；循环条件为 resultSet.next()
    通过 resultSet.get数据类型(第几列) 获取到数据库中当前行的第几列的值 如
    resultSet.getString(2);
7.执行完毕后，将全部资源进行关闭，先创建的后关闭，后创建的先关闭；
    resultSet.close()
    statement.close();
    connection.close()
    

八、el表达式

1、EL表达式

el表达式 expression language 表达式语言

专门用来输出内容的； 

目的：

为了使前端人员能够更加便利的开发页面；

jsp(html+java代码+指令)

 如果一个jsp中没有Java代码，纯html，前端人员可以直接开发； jsp中不允许出现Java代码； 将Java代码使用el表达
式来进行代替；

2、EL基本语法

${ 表达式语句 } 
表达式语句：
    变量名称 如：${name }
    
1.如果单独使用el表达式，${name } 程序先去pageContext域中寻找变量名为name的值，如果 没有，则去request中寻找，
再没有，则去session域中寻找，还没有，去application域中寻找；都没 有，则显示空字符；
  

3、el表达式中11个隐藏对象

学习其中6个，3种， 
2.1 域对象 
    pageScope 页面域对象 
    requestScope 请求域对象 
    sessionScope 会话域对象 
    applicationScope 应用域对象      
2.2 cookie对象 使用 cookie.对象名(即name值).name/value   
2.3 param对象 请求参数对象 用来获取请求体的内容； 
    get请求：http://localhost:8080/index.jsp?username=zs&password=123 将请求参数放在路径上，然后可以获取 
    post请求：http://localhost:8080/index.jsp 参数保存在请求体中 和get的方 式一样 key=value&key1=value1
3.el表达式的对象使用方式   
        JavaBean写法：私有化属性，然后set\get方法，有参无参构造、重写toString()方法 
${requestScope.student.age1 } 
相当于Java中的： ((Student)request.getAttribute("student")).getAge1(); 
${ student.age1 = 1} 代表 studnet.setAge1(1);       
4.el表达式的使用位置 
4.1.直接输出在页面； 
    ${name } 在页面中展示内容 
4.2.当前标签的属性内容使用：                    
    <form>
      <input type="text" value="${requestScope.student.name }" />
    </form>                             
5.el表达式中的运算   
1.算术运算符： 
    +加 -减 *乘 /除 %余 得到值 
    算术运算符： ${4+3 } ${4-3} ${4*3} ${4/3 } ${4%3 } 
2.比较元素符：
    > < >= <= (== eq)等于 (!= ne)不等于 empty (空) not empty(非空) 得到比较结果 true/false 
${4>3 } ${4<3 } ${4>=3 } ${4<=3 } ${4!=3 } ${4==3 } ${not empty "" } ${4 eq 3 } ${4 ne 3} 
3.逻辑运算符：
    与 && and 或 || or 非 not ! 得到的是逻辑结果 true/false 
逻辑运算符：
    ${4>3 && 4<3 } ${4>3 and 4<3 } ${4>3 || 4<3 } ${4>3 or 4<3 } ${!(4>3)} 
4.三元运算符：
    boolean表达式?true结果表达式:false的结果表达式 得到表达式内容 
表达式：
    可以是字符串、数字等等，也可以是el表达式 
三元运算符：
    ${ 4>3?requestScope.name :"小于"                                     
                                              

九、JSTL标准标签库

**根据JSTL标签所提供的功能，可以将其分为5个类别。 **

1. 核心标签
2. 格式化标签
3. SQL 标签
4. XML 标签
5. JSTL 函数

jsp: EL表达式，也页面中输出内容或者设置内容；默认存在于jsp中，不需要导入第三方的jar包； 
jstl属于额外的拓展库，想要使用，需要导入第三方的jar包； 
    1.1版本之前的; jstl.jar standard.jar 
    1.2版本之后的; jstl1.2.jar

1、核心标签，core

核心标签，core 通常被称为 c标签

核心标签，core 通常被称为 c标签
使用步骤：
1. 导入第三方jar包在程序中，并且加载进程序；
2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> uri表示要使用的标签库是哪一个，jsp下面
的core标签库，prefix表示在页面中使用哪个标签来进行操作；
    url: 资源路径， http://localhost:8080/index.jsp
    uri: 全网唯一，使用网络端口进行匹配
3. 使用 <c:out />标签 向页面中输出内容
    <c:out value="${username }" default="ls" /> 如果在域中找不到属性 username，则默认显示ls
4. 使用 <c:set />标签 向域中设置内容
两种使用方式：
1、针对String、int、boolean、char、集合类型(非Map) 等，需要使用
    <c:set value="张三丰" var="username" scope="request" /> 
var变量只能修饰 以上几种类型；
    value:设置值 var:设置数据的名称 scope:设置保存的域获取时： ${username }
2、JavaBean、Map类型,需要使用：
    <c:set property="name" target="${student }" value="ww" /> 
这种方式不能出现var以及 scope属性
    property:设置Javabean的属性，setName() target:用来从域中获取Javabean对象的；
5. if选择
   <c:if test="boolean类型表达式" var="test的结果保存变量名" scope="设置var保存的域值" >
        test为true时，显示的内容
    </c:if>
6. if ... else if ... else ...
<c:choose> 表示 以下内容是一个 if else 语句
    <c:when test="${name eq 'zs'}"> if(boolean表达式){ 张三 }
        张三
    </c:when>
    <c:when test="${name eq 'ww'}"> else if(boolean表达式){ 王五 }
        王五</c:when>
    <c:otherwise> else { 其他人 }
        其他人
    </c:otherwise>
</c:choose>
7. forEach循环，增强for循环，
<c:forEach items="需要遍历的对象" var="每次循环出来的内容" begin="开始的下标" end="结束的下标" step="每次增长下标的
    数量" varStatus="循环的对象状态(步长、开始下标、结束下标、下标、是否第一、是否最后、总遍历数、当前元素)">
    ${var的值 }
</c:forEach>
8. <c:url value="index.jsp" var="将路径保存起来" scope="保存的域">
    用来设置url路径的，当value中不带/时，与直接使用相对路径用法一样，
    当设置/时，用法不一样，会将当前的项目名称添加在/之前
        <c:url value="/index.jsp"> --> web04/index.jsp
9. <c:redirect url="重新跳转的路径" > 重定向 ，可以是本项目内的路径也可以是外部资源路径
        <c:redirect url="http://www.baidu.com" />

2、JSTL函数

JSTL函数 ：funcation fn标签
使用步骤：
1. 导入第三方jar包在程序中，并且加载进程序；
2. <%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
3. 使用fn标签库，不是标签，而是在el表达式中使用${fn:函数名称 }
    contains:前一个字符串中，是否包含后一个字符串；
    containsIgnoreCase:前一个字符串中，是否包含后一个字符串(忽略大小写的比较)；
    startsWith:前一个字符串，是否以后一个字符串开头
    endsWith:前一个字符串，是否以后一个字符串结尾
    toLowerCase:将字符串变成全小写；
    toUpperCase:将字符串变成全大写；
    indexOf:后一个字符串在前一个字符串的下标位置；如果没有这个字符串，就返回-1
    length:表示字符串的长度，和中英文无关，只认个数
    replace:将第一个字符串中的内容，替换成另外内容
    substring:将第一个字符串，从开始位置，截取到结束位置 包头不包尾
    join:将一个数组，通过连接符，连接成一个字符串；
    split:将一个字符串，以某一个字符拆分为数组;

十、SQL攻击

早期项目中普遍存在SQL攻击，在需要输入查询条件的地方输入了 sql片段 导致了整体执行的SQL语句发 生了变化，进而影响了查询的功能；

1、攻击代码

a' or '1' = '1
a' or '1' = '1

2、preparedStatement对象

为了解决SQL攻击问题，提出了preparedStatement对象；

preparedStatement 预处理模板对象
jdbc流程： statement对象
    1.导入mysql-java连接jar包，并加载jar包；
    2.加载MySQL的驱动类；Driver
    3.通过DriverManager创建java-mysql之间的连接对象Connection对象；url地址、数据库用户名、数据库密码
    4.通过Connection对象，创建查询编辑器Statement对象；
    5.编写SQL语句，使用statement对象执行当前SQL语句； ( DML执行返回受影响行数 int ;DQL执行返回结果集对象 ResultSet)
    6.对结果集对象进行处理 while(resuletSet.next()){ resultSet.getString(列数) }
    7.关闭资源，从下往上，先创建后关闭，后创建的先关闭；

3、preparedStatement 预处理模板对象

使用preparedStatement 预处理模板对象

使用preparedStatement 预处理模板对象
    1.导入mysql-java连接jar包，并加载jar包；
    2.加载MySQL的驱动类；Driver
    3.通过DriverManager创建java-mysql之间的连接对象Connection对象；url地址、数据库用户名、数据库密码
    4.取preparedStatement对象, 预编译对象 需要使用sql模板语句 将sql语句中的不确定内容,
    使用? 进行替换
    // 其中 ? --> 表示一个字符串 ,在进行sql补全的时,会将?换成一个整体的被""括起来的字符串
    String sql = "select count(*) from user where u_username = ? and u_password = ?" ;
    // 使用sql模板创建一个 sql预编译对象
    preparedStatement = connection.prepareStatement(sql);
    5.将预编译对象中的 不完整内容进行补全; zs 123
    preparedStatement.setString(1,user);
    preparedStatement.setString(2,password);
    6.执行完整sql语句 此时完整的SQL语句,已经prepared Statement保存了,所以不需要再另外添加sql语句参数
    resultSet = preparedStatement.executeQuery();
    7.对结果集对象进行处理 while(resuletSet.next()){ resultSet.getString(列数) }
    8.关闭资源，从下往上，先创建后关闭，后创建的先关闭；

4、statement 和 preparedStatement的区别和使用

  1.当使用preparedStatement的时候，程序会先进行SQL语句的预编译，检测模板sql是否已经补全完整；过程复杂；
    2.statement对象，不需要预编译，直接执行，速度会快；
    3.SQL优化，提升sql的查询速度，针对不带条件的sql语句，可以使用statement进行串；针对有条件查询，使用preparedStatement
    4.针对增、删、改， 删除可以直接使用statement， 增、改使用 preparedStatement

5、JDBCUtil工具类

为了减少代码的重复度，提高程序的可重用性；

package cn.hp.util;

import java.sql.*;

public class JDBCUtil {

    static Connection connection = null ;
    static Statement statement = null ;
    static PreparedStatement preparedStatement = null ;
    static ResultSet resultSet = null ;

    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/apartment?characterEncoding=utf8", "root", "123456");
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }

    //    新增和修改  DML 操作 String sql ， sql中的参数    preparedStatement   Object[] arr 用来补全sql中的?
    public static int DML(String sql , Object[] arr  ){  // 可变参数 Object ... arr  0~n个参数
        int update = 0 ;
        try{
            preparedStatement = connection.prepareStatement(sql);
//            循环完毕，会将sql中全部? 补充齐
            for (int i = 0 ; i < arr.length ; i++){
                preparedStatement.setObject(i+1 , arr[i] );
            }
            update = preparedStatement.executeUpdate();
        }catch (SQLException e){
            e.printStackTrace();
        }
        return update ;
    }

    //     带参查询  DQL 操作
    public static ResultSet DQL(String sql , Object[] arr ){
        try{
            preparedStatement = connection.prepareStatement(sql);
//            循环完毕，会将sql中全部? 补充齐
            for (int i = 0 ; i < arr.length ; i++){
                preparedStatement.setObject(i+1 , arr[i] );
            }
            resultSet = preparedStatement.executeQuery();
        }catch (SQLException e){
            e.printStackTrace();
        }
        return resultSet ;
    }

    //    单独提供关闭资源方法
    public static void close(){
        try {
            if (statement!=null){
                statement.close();
            }
            if (connection!= null){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

十一、ajax

异步的javaScript 和 xml
异步请求: 有 form a标签
    一次只能处理一个请求 ，想要处理多个请求，需要排队；
    等待响应的过程中，只能等待
同步请求: ajax  阿贾克斯
    在同一时间可以发出多个请求，每个请求互不影响;
    等待响应过程中，不影响其他操作
    
基础写法 : 现在使用的 ajax 99% 都是jQuery的ajax
    jQuery.ajax(url,[settings])  []里可省略
最简写法:
    $.ajax("url   --->servlet路径")
常用的settings属性   需要 3,4,6
    1.async:当前的请求是否为异步请求: 默认值 :True 表示异步，可以省略不写
    2.contentType: 发送信息至服务器时内容编码类型 request设置请求的编码类型
默认值:"application/x-www-form- urlencoded"把参数并在ur1之后,如果是文字参数,
使用默认值即可,如果是图片参数,需要修改;
   *3.data:表示随着ur1发送的请求参数,get请求并在ur1之后,post请求,放在请求体中;
        1、key=value & key=value的形式
        2、json(javaScript object)
            格式 {key: value;key: value} 如 User{username:"zs";age:18}
   *4.type:表示本次ajax请求,属于哪一种请求 get / post
    5.dataType:服务器响应给前端的数据类型。默认auto 根据接受的数据自动设置类型 
   *6.success:用来设置服务器成功接收数据并做出响应之后,执行此方法;
        取值为: function(data){
            data表示后端传递而来的数据
         }
    7. error:如果后端执行代码出现问题,前端调用此方法,

js

页面的组成：html + css + javaScript 学习前端内容 W3Cschool 菜鸟教程

js中两个内容
    bom Browser Object Model 浏览器对象模型 window History
        setInterval() - 间隔指定的毫秒数不停地执行指定的代码。
            var i= 60;
            var inter = setInterval(function () { // 启动定时器
                alert(i)
                i-- ;
                },1000)
                // 停止定时器
                clearInterval(inter)
            setTimeout() - 在指定的毫秒数后执行指定代码。执行一次
            
        dom Document Object Model 文档对象模型

    js中的变量定义： var 变量名 = 值 ; ES5的内容
        js：网景 把js捐给了ECMA 欧洲计算机协会 新出版本ES6,更加趋向于面向对象，出现了
class
        ES6中 let/var 变量名 = 值 ;

jQuery

了解jQuery，数js的封装工具包，由js代码组成；
想要使用，使用步骤：
1.引入jquery的内容； 开发环境：编码 尽量清晰 生产环境：上线运行 尽量小
2.在页面中使用<script src="jquery本地文件路径"></script>
网络路径 
    <script src="https://s3.pstatp.com/cdn/expire-1-M/jquery/3.3.1/jquery.min.js">
    </script>
    jquery版本 1.xx 2.xx 3.xx 每个版本之间不通用，
3.使用jQuery，第一步，获取元素通过选择器：
选择器
1.基础选择器： 和css的选择器一样
    id选择器 $("#id值") 
    class选择器 $(".class值") 
    标签选择器 $("标签名") 
    通配符选择器 $("*")
2.复杂选择器：
    后代选择器 $("基础选择器 基础选择器")
    子代选择器 $("基础选择器 > 基础选择器")
3.事件
js中事件 js事件是在标签中写的
    鼠标点击事件 onclick
    失焦事件     onblur
    聚焦事件     onfocus
    覆盖事件     onmouseover
    改变事件     onchange
jQuery事件 jq事件是在方法中写的
    鼠标点击事件 click
    失焦事件     blur
    聚焦事件     focus
    覆盖事件     mouseover
    改变事件     change
    键盘落下事件 keydown
    键盘停止事件 keyup
    鼠标点下事件 mouseleave
    鼠标移开事件 mousedown
    鼠标按下事件 mouseover
    鼠标抬起事件 mouseop