-----------------------------------------JavaEE-Servelt-----------------------------
tomcat三个功能：1、web服务器 2、jsp容器 3、servlet容器
开发servlet有三种方法
a.实现servlet
b.继承GenericServet
c.继承HttpServlet
servlet任务：
读取浏览器发送的html表单，http请求数据（cookie），处理数据生成结果，发送显示数据，发送隐世HTTP响应到浏览器
Servlet生命周期：
Servlet调用 init（）初始化
Servlet调用 service（）处理客户端请求
Servlet调用 destroy（）终止
最后，Servlet由JVM的垃圾回收器进行垃圾回收
如果 Servlet 依赖于任何其他库，您必须在 CLASSPATH 中包含那些 JAR 文件
-----init()方法
只调用一次，在后续每次用户请求时不再调用。因此，它是用于一次性初始化。
Servlet 创建于用户第一次调用对应于该 Servlet 的 URL 时
当用户调用一个 Servlet 时，就会创建一个 Servlet 实例
每一个用户请求都会产生一个新的线程，适当的时候移交给 doGet 或 doPost 方法。
public void init() throws ServletException {
// 初始化代码...
}-----service（）方法
Servlet 容器（即 Web 服务器）调用 service() 方法来处理来自客户端（浏览器）的请求，并把格式化的 响应写回给客户端。
每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。
service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。
public void service(ServletRequest request,
ServletResponse response)
throws ServletException, IOException{
}
service() 方法由容器调用，service 方法在适当的时候调用 doGet、doPost、doPut、doDelete 等方法。
您不用对 service() 方法做任何动作，您只需要根据来自客户端的请求类型来重写 doGet() 或 doPost() 即可。
doGet() 和 doPost() 方法是每次服务请求中最常用的方法。下面是这两种方法的特征。
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
// Servlet 代码
}
GET 请求来自于一个 URL 的正常请求，或者来自于一个未指定 METHOD 的 HTML 表单，它由 doGet() 方法处理。
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
// Servlet 代码
}
POST 请求来自于一个特别指定了 METHOD 为 POST 的 HTML 表单，它由 doPost() 方法处理。
-------destroy（）方法
destroy() 方法只会被调用一次，在 Servlet 生命周期结束时被调用。
destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。
在调用 destroy() 方法之后，servlet 对象被标记为垃圾回收。
public void destroy() {
// 终止化代码...
}------Servlet实例
Servlet 是服务 HTTP 请求并实现 javax.servlet.Servlet 接口的 Java 类
Web 应用程序开发人员通常编写 Servlet 来扩展 javax.servlet.http.HttpServlet，并实现 Servlet 接口的抽象类专门用来处理 HTTP 请求。
--------JSP：动态网页---------------------------------
JSP是一种脚本语言
JSP通过网页表单获取用户输入数据、访问数据库及其他数据源，然后动态地创建网页。
静态、动态：
1、不与“动感”相联系
2、动态网页：
随着时间、地点改变而改变
根据用户操作不同而不同
需要使用到服务端动态语言JSP
--------架构
C/S：客户端-服务端
B/S：浏览器-服务端
类似 点赞 改变
---------HTTP协议
状态码：
404：资源不存在
200：一切正常
300/301：页面重定向（跳转）
403：权限不足（访问A目录但目录设置不可见）
500：服务器内部错误（代码有误）
---------tomcat服务器
代码编写的一个可以根据用户请求事实的调用执行对应的逻辑代码的一个容器
bin：可执行文件
lib：tomcat依赖jar包
webapps：可执行的项目（开发的项目放入该目录）
conf：配置文件
temp：临时文件
work：存放由JSP翻译成的java，以及编辑成的class文件。
配置tomcat
1、配jdk（必须配置JAVA_HOME）
java_homeclasspath path
2、配置 CATALINA_HOME （环境变量）
常见错误：可能与其他端口号冲突
tomcat默认端口号8080，建议修改
5访问：
localhost：8888
默认界面是Root里页面
6、虚拟路径：
将web项目配置到webapps以外的目录
这样你写的网页文件就不用局限在webapps目录里，你可以存在任何的C或D盘的文件夹里
方式一：缺点要重启tomcat
在conf文件夹里的配置文件server.xml中的
<Host>
<Context docBase = " " path = " "></Context>
</Host>
docBase:实际路径 项目实际的路径
path：虚拟路径（绝对路径、相对路径[相对与webpps目录]）
说明：在浏览器输入path的路径 其实访问的是 docBase目录里写的网页
方式二：优点可以不用重新启动 tomcat 服务器
这个目录下写 D:\Software\apache-tomcat-9.0.16\conf\Catalina\localhost
新建 项目名.xml 文件然后，这个文件里写下面这句话
<Context docBase = "D：/software/jspprohect " path = "/jspprohect "></Context>
项目名.xml 和 path 项目名 path 里的目录名要一致
7、虚拟主机
www.test.com
在conf ---> sever.xml中
第一步：
<Host appBase = "D：/dsa/dsa" name = "www.test.com">
<Context docBase="d/das/dsa" path = "/">
</Host>
appBase：项目实际的位置 name：随便起个名字
docBase：项目实际的位置 path：虚拟路径
<engine default = "www.test.com"><>
第二步：在本机的 hosts文件 中加入 域名和对应的 IP
7.1使用 Eclipse 开发web项目
配置tomcat运行时环境
jsp与servlet相互转化 依赖的jar包
a.将servlet-api.jar加入类路径
统一字符编码：
a.编码分类：
设置jsp文件的编码（pageEncoding）：
设置浏览器读取jsp文件的编码（Content）：
一般将上述设置为一致的编码 推荐使用UTF-8
文本编码：
设置整个Eclipse文件编码
设置某个项目编码 右键项目->
设置某个文件的编码
get方式与post方式的区别：
* get方式 在地址栏会显示请求信息 最多容纳4-5KB，如果上传文件 就会报错
* 文件上传，必须是post
统一请求编码：
* get方式：
8、jsp执行流程
第一次访问：
服务端将jsp ------> 翻译java(Servlet) -----> 编译class
第二次访问：
直接访问.class文件（若代码修改了将会重新执行第一次访问步骤）
JSP 和 Servlt可以相互转化
因为第一次请求服务端 会有翻译和编译过程 所以会比较慢
------9、JSP:
页面元素有哪些：java代码（脚本Scriptlet） HTML 注释 指令
第一种脚本:
<% 局部变量、java语句 %>
第二种脚本:
<%! 定义全局变量、方法 %>
第三种标签:
<%= 输出表达式 %> 不用写;号
指令：
page指令：
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1" import = "java.util.Date"%>
属性：language：jsp页面使用的脚本语言
imoprt：java里导入包关键字
pageEncoding:jsp文件自身编码
contentType：浏览器解析jsp编码
---------注释：
java注释、HTML注释、JSP注释<%--jsp注释--%>
---------JSP9大内置对象（不需要new也能使用的对象）
1、out:输出对象
2、request：对象
常见方法：
String getParameter(String name):
根据请求字段名key（例：input标签的name属性）、返回字段值value
String[] getParameterValues(String name):
根据请求字段名key、返回多个字段值value（checkbox）
void setCharacterEncoding("编码格式UTF-8")：
设置请求编码 tomcat8 默认是utf-8
getRequestDispatcher("填入要跳转的页面").forward(request,response): //请求转发
请求跳转的方式
ServletContext getServerContext():
获取项目的ServletContext对象
3、response
response响应对象封装响应信息
提供的方法：
void addCookie(Cookie cookie);
服务端向客户端增加一个cookie对象
void sendRedirect(String location) throw IOException： 页面跳转的一种方式//重定向
void setContetType(String type);
设置服务端响应字符编码（设置服务端的contentType类型字符编码）
--------------------
实例：登陆
login.jsp -> check.jsp;
请求转发和重定向的区别？
请求转发 重定向
地址栏是否改变 请求转发地址栏不变 重定向会改变
是否保留第一次请求时的数据 保留 不保留
请求的次数： 1次 2次
跳转的位置 服务端 客户端发出的第二次跳转
请求转发会在服务器内部发出request请求 所以会保留请求的数据
重定向会重新建立一个会话
-----------
session在服务端
Cookie(在客户端)：Cookie是由 服务端 产生，在发送给客户端保存 不是内置对象要new创建对象
相当于 本地缓存的作用：提高访问服务端的效率，但安全性差
Cookie：键值对 name=value javax.Servlet.http.Cookie 包里
方法：
public Cookie(String name,String value)
String getName()：获取name
String getValue()：获取value
void setMaxAge(int expiry);增加cookie最大有效期
服务端准备Cookie：
response.addCookie(Cookie cookie)
页面跳转（转发，重定向）
客户端获取Cookie：
request.getCookie();
a.服务端增加Cookie：response对象,客户端获取对象：request对象
b.不能直接获取某一个单独对象，只能一次性将 全部的cookie拿到
除了自己写的cookie还有一个默认的cookie jsessionid的cookie
建议cookie只保存 英文数字 否则要解码处理
------实例
Cookie文件夹
小例子：Demo 使用cookie自动记住用户名密码
4、pageContext
5、session
session(会话)
会话：开始浏览网站到关闭网站就是一次会话、购物：浏览，付款，推出就是一次会话
运行原理：
浏览器在第一次请求时，服务端在内部会产生一个session，并设置一个sessionID 并且复制为JSESSIONID
然后响应时把JSESSIONID放入COOKIE里传回给浏览器
浏览器第一次请求服务端时，（JSESSIONID-SESSIONID匹配失败）
服务端会产生一个session对象（用于保存该客户信息）；
并且每个session对象 都会有一个唯一的 seession（用于区分其他session）；
服务端又会产生一个cookie，并且该cookie的name=JSESSIONID，value = 服务端的sessionid的值
然后 服务端会在 响应客户端的同时 将该cookie发送给客户端，至此 客户端就有了一个cookie（JSESSIONID）；
因此，客户端的cookie就可以和服务端的cookie 一 一 对应（JSESSIONID = sessionID）
第二次请求时
服务端会先根据客户端的cookie中的JSESSIONID 去服务端的session中匹配sessionID，如果匹配成功（cookie jsessionid和sessionid中的值是否相同）
说明此用户不是第一次登陆
---session方法
String getId():获取sessionID
boolean isNew():判断是否是新用户（第一次访问）
void invalidate():使session失效（退出登陆、注销）
void setAttribute();
Object getAttribute();
void setMaxInactiveInterval(秒):设置最大有效 非活动时间
int getMaxInactiveInterval():获取最大有效 非活动时间
实例:
登陆（login.jsp）成功返回给浏览器一个session（用户名、密码）
request作用域：只在同一次请求有效
session和cookie的区别：
session cookie
保存的位置 服务端 客户端
安全性 较安全 较不安全
保存的内容 object对象 String
四种范围对象（小->大）
pageContext JSP页面容器 （也叫page对象） 当前页面有效
request 请求对象 同一次请求有效
session 会话对象 同一次会话有效
application 全局对象 全局有效（整个项目有效）
以上4对象共有的方法
void setAttribute(String name); 根据属性名，设置属性值
Object getAttribute(String name ,Object obj); 设置属性值(新增、修改)
setAttribute("a","b");
//如果a对象之前存在，则创建一个a对象
void removeAttribute(String name):根据属性名，删除对象
a.pageContext:
6、application 全局对象
String getContextPath()： 虚拟路径
String getRealPath(String )：绝对路径（虚拟路径 相对路径）
Cookie:
a.不是内置对象必须要使用new
b.服务端会 自动生成一个name = JESSIONID 的 cookie 并返回给浏览器
7、config 配置对象
8、page 当前jsp页面对象
9、exception 异常对象
----------JDBC：Java DataBase Connectivity
为多种数据库提供访问方式
Java程序 <- (JDBC)JDBC DriverManager <- 驱动程序(jar包) <- Oracle/MySql数据库
1、API 提供各种访问接口 Connection Statement PreparedStatement ResultSet
2、JDBC DriverManager:管理不同的数据库驱动
3、各种数据库驱动：数据库厂商提供，作用连接/直接操作数据库
4、JDBCAPI：干以下三件事，通过类/接口实现
{
1、与数据库建立连接Connection(连接字符串 数据库名 IP 端口号
数据库名
密码)
2、发送SQL语句 Statement
3、返回结果集
}
DriverManager:管理JDBC驱动
数据库驱动：
各种驱动jar包：
Oracle ojdbc-x.jar
MySQL mysql-connector-java-x.jar
SQLServer sqljdbc-x.jar
具体驱动类：
Oracle oracle.jdbc.OracleDriver
MySQL com.mysql.cj.jdbc.Driver
SQLServer com.microsoft.sqlserver.jdbc.SQLServerDriver
连接字符串：
Oracle jdbc:oracle:thin:@localhost:1521:ORCL
MySQL jdbc:mysql://localhost:3306/USER1?serverTimezone=GMT%2B8
SQLServer jdbc:microsoft:sqlserver:localhost:1433:databaesname=""
Connection：连接
常见方法：（产生操作数据库的对象）
产生 Statement 对象
产生 PreparedStatement 对象
产生 CallableStatement 对象
Statement(PreparedStatement)：增删改查(通过connection 产生)
executeUpdate() 增删改 数据库
executeQuery() 查询 数据库
PreparedStatement
是 Statement 的子接口
executeUpdate() 增删改 数据库
executeQuery() 查询 数据库
PreparedStatement 比 Statement 强大的地方在于 有一堆赋值语句 setXxx()
执行顺序：
1、sql（可存在占位符）
2、在创建 PreparedStatement 对象时，将进行sql预编译
3、executeUpdate（）
4、setXxx（） 取代占位符的内容
推荐使用 PreparedStatement 接口 原因如下：
1、编码更简单
String name = "zs";
int age = 23;
2、提高性能（有预编译操作，预编译只需要执行一次）
stmt:
String sql = "insert into student(id,name) values('"+name+"',"age")
stmt.executeUpdate(sql);
pstmt:
String sql = "insert into student(id,name) values(?,?)";
pstmt = connection.PreparedStatement(sql);//预编译SQL
pstmt.setString(1,name);
pstmt.setInt(2,age);
pstmt.executeUpdate();
3、安全（有效防止SQL注入）
sql注入：将客户输入的内容 和 开发人员的SQL语句混为一体
stmt:有注入的风险（例如 输入用户名 abc ' or 1=1 --，密码任意值）
pstmt:
案例：登陆查询数据库
CallableStatement：调用数据库中的 存储过程/存储函数(通过connection 产生)
Result：保存查询结果集（stmt产生）
boolean next():判断是否有下一条数据
boolean previous（）：向上是否有数据
getXxx（字段名|位置）获取具体的字段值
5、JDBC访问数据库的具体步骤：
a.导入驱动(jar),加载具体驱动类
Class.forName("具体驱动类名")
b.与数据库建立连接
Connection connection = DriverManager.getConnection("连接字符串");
c.发送SQL，执行(增删改/查)
Statement stmt= connection.createStatement();
CallableStatement cs = connection.PreparedStatement(sql);
PreparedStatement ps = connection.PreparedStatement();
PreparedStatement：
int count = stmt.executeUpdate("sql语句");//返回值表示增删改了几条数据
查询
ResultSet rs = stmt.executeQuery("sql查询语句"); //ResultSet查询的结果表
re默认指向表的第一条数据前面
next():下移并判断是否有数据
getXxx():获取数据
while(rs.next())
{
re.getInt("字段名")；
re.getString("字段名");
}
d.处理结果集
总结：
--jdbc中，除了Class.forName()抛出ClassNotFoundException，其余方法都跑SQLException
这一块MySQL没学存储过程{
2 CallableStatement :调用 存储过程 存储函数
connection.PrepareCall(参数：存储过程或存储函数名)
-参数格式：
存储过程：（无返回值）
{ call 存储过程名（参数列表）}
存储函数（有返回值）
{ ？ = call 存储函数名（参数列表）}
}
处理二进制大对象{
没看
}
JSP连接数据库
JSP就是在html中嵌套java代码
导包操作：在java项目里：1、Jar包复制到工程中 2、右击该Jar包添加到buildPath
Web项目：将Jar包复制到lib目录里
JAVABean
jsp中的代码 转移到loginDao。java 其中loginDao类就是javaBean
JavaBean的作用：a.减轻jsp的复杂度 b.提高代码复用度
JavaBean(就是一个Java类)的定义：满足以下2点，就可以称为JavaBean
a.public 修饰的类， public 无参构造
b.所有属性都是 private ，并提供 get/set 方法
使用层面，Java分为2类
a.封装业务逻辑的JavaBean(longinDao.java封装业务逻辑) 逻辑
b.封装数据的JavaBean(实体类，Student.java) 数据
封装数据的JavaBean 对应于数据库中的一张表
封装业务逻辑的JavaBean 用于操作 一个封装数据的JavaBean
==================================================================================================
-------------------------------MVC设计模式---------------------------------------------------------
M：Model 模型 ：一个功能。用 JavaBean 实现
V：View 视图：html/css/javascript 实现 就是前端页面
C：Controller 控制器：一般建议 Servlet 实现接受请求，将请求跳转到模型处理；处理完毕后，再将处理结果返回给 请求处
----Servlet：
Java类必须符合一定的 规范：
a.必须继承java.HttpServlet
b.重写其中的doGet（）或 doPost（）方法
doGet() :接受 并处理 所有的get提交方式的请求
doPost():接受 并处理 所有的psot提交方式的请求
案例：ServletDemo
Servelt要想使用，必须配置
Servlet2.5:web.xml
Servlet3.0:@WebServlet
Servlet2.5: web.xml:
项目的根目录：WebContent、src 都是项目的根目录
Servlet流程：
请求： -> <url-pattern> -> <servlet-mapping>中的<servlet-name>去匹配<servlet-name> 然后执行<servlet-class>
总结创建第一个Servlet
步骤：
编写一个类，继承HttpServlet
重写doGet（）/doPost（）方法
编写web.xml 中的servelt映射关系
Eclipse可以自动生成
-Servlet3.0
Servlet3.0不需要 在 web.xml中配置映射关系
<a href = "/">
3.项目
项目根目录：WebContent、src（所有构建路径）
例如：
WebContent中有一个文件index,jsp
web.xml中的 /：项目根目录
jsp中的 /：服务器根路径
Servlet生命周期：5个阶段
加载
初始化 init()，该方法会在 Servlet被加载并实例化的以后执行
服务:service（） -> doGet() doPost() 具体实现
销毁:destroy() Servlet被系统回收时执行
卸载
init（）：a.第一次访问是会执行且只执行一次
b.还可以在tomcat启动时自动执行
Servlet2.5:web.xml
<servlet>
<load-on-startup>1</load-on-startup>
</servelt>
Servelt3.0
@WebServlet(value="/webcome",load-on-startup=1)
servi（）：调用几次执行几次
destroy（）：服务器关闭时执行
-Servlet API:由两个软件包组成：对于HTTP协议的软件包、对应于除了HTTP协议以外的其他软件包即 Servlet API 可以适用于任何通信协议
-Servlet继承关系
ServletConfig接口：
ServletContext getServletContext(): 获取上下文对象 application
String getInitParameter(String name): 在当前Servlet范围内，获取名为name的参数值（初始化参数）
ServletContext中的常见方法（application）
getContextPath():相对路径
getRealPath（）：绝对路径
setAttribute()、getAttribute（）
String getInitParameter（String name）:在当前web容器范围内，获取名为name的参数值（初始化参数）
Servelt3.0方式 给当前servlet设置初始值：
@WebServelt(.....,initParams={@WebInitParam(name="servletparaname30"),value()})
HttpServletRequest中的方法：（同request），例如：setAttrite（）、getCookies（）
HttpServletResponse中的方法：同response
Servlet使用层面：
Eclipse中的src创建一个Servlet，然后重写doGet（） doPost（） 即可（doGet（） doPost（）只需要调用一个）
MVC案例：
view视图： 登陆页 login.jsp
Controller: 登陆控制器 LoginController ->Servlet
Model模型层{ ： 登陆功能 LoginDao ->数据库封装
封装逻辑模型
封装数据的模型
}
1、三层架构
与MVC设计模式的目标一致：都是为了 解耦和、提高代码服用
区别 二者对项目理解的角度不同
2、三层组成：
表示层： （USL, User Show Layer; 试图层）
-前台：对应于MVC中的View，用于和用户交互、界面显示
技术：jsp css html
-后台：对应于MVC中的Controller，用于控制跳转、调用业务逻辑
技术：Servlet （SpringMVC Struts2），位于XXX.servlet包
业务逻辑层：（BLL， Business Logic Layer; Service层） 对dao层进行组装
-接受表示层的请求 调用
-组装数据访问层，逻辑性的操作（增删改查）
-般位于 xxx.service包（xxx.dll ）
数据访问层：（DAL， Data Access Layer; Dao层） 真实的增删改
-直接访问数据库的操作：原子性的操作（增删改）
一般位于 xxx.dao包
三层之间的关系：
上层：将请求传递给下层，下层处理后 返回给上层
上层依赖于下层，依赖：代码的理解 就是持有成员变量
三层优化：
1、加入接口
建议面向接口开发：先接口-再实现类
--service、dao加入接口
--接口与实现类的命名规范
接口：interface 起名 IXxxService IStudentService
IStudentDao
实现类：implements 起名 XxxxServiceImpl StudentServiceImpl
接口： I实体类层所在的包名 IStudnetService、IStudentDao
接口所在的包： xxx.service.impl xx.dao.impl
以后使用接口/实现类时，推荐写法：
接口 x = new 实现类()
例：IStudentDao student = new StudentDaoImpl();
2、DBUtil:通用的数据库帮助类，可以简化Dao层的代码量
帮助类 一般建议写在一个包里面
WEB调试：
与java代码调试 启动方式不同
jsp翻译成的Java文件在tomcat work目录里
看到分页P31：
建议：一个servlet对应一个功能 如果有增删改查（2个）五个功能 就创建5个servlet
==========项目：学生管理系统============
分页：
1、要实现分页必须知道某一页的数据 从哪里开始 到 哪里结束 1，10
oracle/sqlserver
第n页 开始 结束
1 1 10
n (n-1)*10 + 1 n*10
结论：
第n页数据 : 第（n-1）*10 + 1条 第n*10条
MySQL实现分页：
limit 开始 多少条
MySql:
第n页 开始 结束
0 0 9
1 10 19
n n*10 (n+1)*10-1
结论：
页面大小：每一页显示的数据量
select * from student 页面*页面大小，页面大小；
oracle/sqlserver：
分页实现：
5个变量（属性）
1、数据总数 select count（*）
2、页面大小（每页显示的数据条数）30 用户自定义
3、总页数 用户自定义
总页数 = 数据总数/页面大小
总页数 = 数据总数/页面大小 + 1
->
总页数 = 数据总数%页面大小==0？数据总数/页面大小：数据总数/页面大小 + 1
4、当前页 程序自动计算
5、当前页的对象集合（实体类集合）：每页所显示的所有数据（10个人的信息） 查数据库，分页SQL
---------------------------------------
EL表达式：Expession Language,可以替代jsp中的java代码 表达式语言可以替代java代码
${域对象.域对象中的属性.属性.属性} 可以获取级联属性
例：${student.name.age.address}
EL表达式不会显示
EL操作符：
. 和 []
例：${student["name"]["age"]["address"]} 或 ${student['name']['age']['address']}
[]操作符功能更强大
可以包含特殊字符（、。|）
获取变量值 例 ${requestScope[student]}
可以包含数组 ${requestScpoe.hobbie[0]}
${requestScpoe.hobbie[1]}
${requestScpoe.hobbie[2]}
EL获取map属性:
${reqeustScope.map.}
EL可以进行关系/逻辑运算：
${requestScope.student.age > 20} 或
${requestScope.student.age gt 20}
Empty运算符：判断一个值是不是 null 或 不存在 则运算之为 true 否则 为 false
${empty reqeustScope.student.name} //结果为false
EL表达式的隐式对象（不需要 new 就能使用的对象，内置对象）：
a.作用域访问对象（EL域对象）
pageScope
requestScope
sessionScope
applicationScope
如果不指定域对象，就会按作用于范围大小取值 pageScope<reqeustScope<sessionScope<applicationScope
b.参谁访问对象：获取表单对象(还可以拿超链接中的值 例a.jsp?a=b&c=d)
request.getParameter() reqeust.getParameterValues()
${param} ${paramValues}
c.JSP隐式对象:pageContext
在jsp中可以通过pagecontext 获取其他的jsp隐式对象：因此如果要在 EL 中使用jsp隐式对象就可以通过pageContext获取。
例{pageContext.request} 就是 JSP里的 ${pageContext.getRequest()}
可以使用此方法 获取级联方法：
&{pageContext.reuqest.servletprtiol}
JSTL:比EL 更加强大
eclipse不支持 需要引入2个jar包 jstl.jar standard.jar
引入tablib指令
<%@ tablib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
prefix="c"% :这个是前缀
核心标签库：通用标签库、条件标签库、迭代标签库
通用标签库：
<c:set/> 赋值语句
1、给某个变量赋值 例：<c:set var="name" value="zhangsan" scope="request"/>
<c:set var="name" value="zhangsan" scope="request"/> 相当于
request.setAttribute("name","zhangsan");
2、给某个对象和属性赋值：不能指定scope
<c:set target="${reqeustScope.student}" property = "sname" value="zxs"/>
<c:set target="那个对象" property = "那个属性" value="赋什么值"/>
注意：<c:set/>可以给不存在的变量赋值 他会先创建变量在赋值 类似 x = y;
<c:out>:显示
传统EL：${reqeustScope.student}
c:out方式：<c:out value="${reqeustScope.student}"/>
<c:out>强大之处：
显示不存在的数据<c:out value="${reqeustScope.dad}" default="zsc" /> 可以给个默认值
escapeXml 属性 可以设置超链接是否显示
<c:remove/>:删除属性
<c:remove value="a" scope="request"/> //
-----条件标签库
·if(boolean)
<c:if test="${10>2}" var="result" requestSope="request"> //var="result" var变量放入判读的结果值（真/假）
镇 ${result}
</c:if>
·多重if if else...if else....
以下类似 switch 用法
<c:choose>
<c:when test="${requestScope.role = '老师'}">
老师代码。。。。。。。。。。
</c:when>
<c:when test=""></c:when>
<c:when test=""></c:when>
<c:when test=""></c:when>
</c:choose>
迭代标签库（循环）
for(int i=0;i<0;i++)
<c:forEach begin="0" end="5" step="1" varStatus="status">
test.........
</c:forEach>
varStatus="status" 这个是记录下标
for(String str:names)
<c:forEach var="name" items="${requestScope.names}">
${name}
</c:forEach>
var属性：类似于str items属性：表示那个集合
-----过滤器（拦截器）
1、过滤器：请求响应
2、需要过滤器放行
·过滤器要实现一个Filter接口
init() destroy() 和servlet一样
·配置Filter
·chain.doFilter(request,response) 放行
Filter 映射：
拦截特定请求：<url-pattern>/MyServlet</url-pattern>
拦截一切请求：<url-pattern>/*</url-pattern> */
通配符：
dispatcher请求方式：
REQUEST:拦截HTTP请求 get post
FORWARD:只拦截 通过 请求转发方式的请求
INCLUDE:只拦截通过 request.getRequestDispatcher().include(0)
ERROR:只拦截<error-page>发出的请求
过滤器中doFilter方法参数：ServletRequest
在Servlet中的方法参数：HttpServletRequest
过滤器链：多个过滤器
过滤器的执行顺序是看 <filter-mapping>配置的过滤器顺序决定
1、监听器：
监听对象：reqeust session application
reqeust:ServletRequestListener
session:HttpSessionListener
application:ServletContextListener
a·监听对象的创建和销毁
reqeust:ServletRequestListener
session:HttpSessionListener
application:ServletContextListener
b·监听对象中属性的变更
reqeust: ServletRequestAttributeListener
session: HttpSessionAttributeListener
application: ServletContextAttributeListener
·配置监听器
<listener>
<listener-class></listener-class>
</listener>
·实现监听器接口 ServletRequestListener 或 HttpSessionListener 或 ServletContextListener
每个监听器提供两个方法 监听开始 和 监听结束 方法
ServletContext是servlet自动创建
session钝化 于 活化
钝化：session对象从内存写入到硬盘里
活化：session对象从硬盘写入到内存里
session对象的四种状态
监听 绑定与解绑的接口：HttpSessionBingListener 绑定就是将对象添加到session域中
a.session.setAttritbute("a",xxx);
b.session.removeAttribute("a"); 解绑就是将对象从session域中移除
监听session对象的活化、钝化的接口：HttpSessionActivationListener
钝化：
活化：
看到24：51
-----------------Ajax: js和xml的组合
异步刷新：点赞效果 只刷新需要修改的地方
实现2种：
js：通过XMLHttpRequest对象实现
XMLHttpRequest对象常见方法：
open(方法名（提交方式 get/post）,服务器地址,true)
send（）：
get:send(null)
post:send(参数值)
setRequestHeader（header，value）：
get:不需要设置此方法
post：需要设置2种情况：
a.如果请求元素包含了文件上传：
setRequestHeader("Context-Type","multiparty-form")
b.如果请求元素不包含了文件上传：
setRequestHeader（"Context-Type","application/x-www-form-urlencoded"）
XMLHttpRequest对象常见属性：
readystate:请求状态 4代表请求完毕
status:响应状态 200正常
onreadystatechange:回掉函数
responseText:响应格式为String
responseXML:响应格式为XML
-----------实例注册手机号码 服务端判断是否存在
jquery ：推荐 要引入jquery包
1、 $.ajax({
url:服务器地址
请求方式：Get|POST
data:请求数据
success：function(result,testStatus){
}
error:function(xhr,errorMessage){
}
})
jQuery：
============================MyBatis框架=====================================================
MyBatis:可以简化JDBC操作，实现数据的持久化(数据存入数据库)
ORM：Object Relational Mapping
ORM的意思是可以将对象和表映射起来
ORM是一个概念：
MyBatis是ORM的一个实现/Hibernate
orm可以让开发人员像操作对象那样操作数据库
mapper文件将数据库表 和 java对象 映射起来 文件的创建位置要和javaBean类文件位置在一起
mapper.xml配置文件里{
namespace： 填的是mapper.xml文件的路径
id：是区分sql语句
resultType:是返回全类名
parameterType：输入参数
}
config.xml{
配置数据库的一些信息
<mapper resource="mapper文件的路径">
}
测试类{
加载MyBatis配置文件config.xml（为了访问数据库）
1、Resources.getResourceAsReader("config.xml")
2、SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(re);
3、SqlSession session = sessionFactory.openSession()//session类似于connection 然后就可以操作数据库
4、拿到sql语句 通过 mapper.xml文件中的 namespace+id 就是sql语句
5、String statemet="lianxi.self.PersonMapper.selectBlog";
6、执行Person person = session.selectOne(statemet);
}
先配置MyBatis: 下载 mybatis jar包
1、config.xml ---->配置数据库的连接 设置 可以抄
2、实体类 和 表 映射文件mapper.xml------>写 具体的sql语句
增：<insert>
insert into student2(snum,sage,sname,saddress) values(#{},#{},#{});
</insert>
删：<delete></delete>
改：<update></update>
查：<select></select>
<!-- parameterType :输入参数的类型-->
<!-- resultType:查询返回结果值的类型，返回类型 -->
3、测试
具体操作类：
//拿到
Reader re = Resources.getResourceAsReader（config.xml）
SqlSessionFactory session = new SqlSessionFactoryBuilder().build(re);
SqlSession sess = session.openSession();
List<Student> s = sess.selectList(sql);
MyBatis规定：parameterType:参数只能写一个
resultType:参数只能写一个
如果输入/输出：简单类型（8个基本类型+String）是可以用任何占位符，#{}
如果是对象类型，则必须是对象的属性#{属性名}
输出参数：如果返回值类型是一个对象，无论返回一个、多个对象都在
parameterType = lianxi.self.entity.Student
二、mapper动态代理方式的curd（MyBatis接口开发）
原则：约定优于配置
配置方式：
abc.xml
<name>myProject</name>
硬配置：
Configuration conf = new Configuration();
conf.setName("myProject");
具体实现的步骤方式：
1、基础环境：mybtais.jar/ojdbc.jar、conf.xml/mapper.xml
2、不同之处
约定的目标：省略掉statement,根据约定 直接可以定位出SQL语句
a.接口，接口中的方法必须遵循以下约定：
* 1、方法名和mapper.xml文件中的标签id值相同
* 2、方法的输入参数 和mapper,xml文件中的标签parameterType一致
* 3、方法返回值 和 mapper.xml文件中的标签resultType一致
除了以上约定，要实现接口中的方法 和 mapper.xml中的SQL标签一一对应，还需要以下2点
1、namespace的值，就是 接口的全类名(接口 --- mapper.xml 一一对应)
匹配的过程：
1、根据接口名 找到 mapper.xml文件（根据的是namespace=接口全类名）
2、根据接口的方法名 找到 mapper.xml文件中的SQL标签（方法名=SQL标签值）
以上2点可以保证：
当我们调用接口中的方法时，程序能自动定位到 某一Mapper.xml文件中SQL标签
习惯：SQL映射文件（mapper.xml） 和接口放在同一个包（注意修改config.xml中加载mapper.xml文件中的路径）
以上可以，通过接口的方法定位SQL语句
执行:
通过session对象获取接口（session.getMapper(接口.class);），再调用该接口中的方法，程序会自动执行该方法
例：MyBatis3
扫一扫
2033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
