JSP/Servlet/上传/下载/分页/MVC/三层架构/Ajax笔记

一、page指令
Language：用来定义要使用的脚本语言
默认：java
contentType：定义JSP字符的编码和页面响应的MIME类型；
pageEncoding：JSP页面的字符编码

二、scriptlet标签
通过scriptlet标签我们可以在jsp里嵌入java代码

1、<%! %> 我们可以在里面定义全局变量、方法、类
2、<% %> 我们可以在里面定义局部变量、编写语句
3、<%= %> 我们可以在里面输出一个变量或一个具体内容

三、Jsp注释

html注释 客户端可见

<%-- --%> Jsp注释 客户端不可见

四、Jsp包含指令

<%@include file=“要包含的文件”%> 静态包含 先包含，后编译处理;
<jsp:include page=“要包含的文件”/> 动态包含 先编译处理，后包含;
以后开发用动态包含

五、Jsp跳转指令

jsp:forward
<jsp:param value="“name=”">
</jsp:forward>
服务器内部跳转,可带参数;

五、Jsp九大内置对象及四大作用域

在jsp开发中，jsp提供了9个内置对象，这些内置对象将由容器为用户进行实例化
，用户直接使用即可。这9个内置对象分别是:pageContext,request,response
,session,application,config,out,page,exception;常用的是前面5个，需要熟练掌握;
在jsp开发中，可以保存数据，jsp提供了四种数据保存范围;分别是page,request,session,
application

六、jsp四大作用域

pageContext 范围:只在一个页面中保存数据; javax.servlet.jsp.PageContext(抽象类)
*request 范围:只在一个请求中保存数据; javax.servlet.http.HttpServletRequest(接口)
*session 范围：在一次回话范围中保存数据,仅供单个用户使用 javax.servlet.http.HttpSession(接口)
application 范围：在整个服务器上保存数据，所有用户共享; javax.servlet.ServletContext(接口)

---

javaweb
（源码查看ctrl+shift+t）
day01
1、CS架构：Client Server
CS不足：
a.如果软件升级，那么全部软件都需要升级
b.维护麻烦：需要维护每一台客户端软件
c.每一台客户端都需要安装客户端软件

BS架构：Browser Server
	客户端可以通过浏览器直接访问服务端
服务端:(tomcat服务器)
注意：bs和cs都有优缺点

2、tomcat解压后目录
bin:可执行文件（startup.bat shutdown.bat）
conf:配置文件（server.xml）
lib:tomcat依赖的jar包
log:日志文件（记录出错等信息）
temp:临时文件
webapps:可执行的项目（将我们开发的项目放入该目录）
work:存放由jsp翻译成的java，以及编辑成的class文件（jsp -> java -> class）

3、常见状态码：
200（一切正常）
300、301（页面重定向（跳转））
403（权限不足（如果访问a目录，但是a目录不可见））
404（资源不存在）
500（服务器内部错误（代码有误））

4、jsp：在html中嵌套的java代码
在项目WEB-INF/web.xml中设置默认的初始页面

index.jsp

5、虚拟路径
a.方式一
将web项目配置到webapps以外的目录
conf/server.xml中配置
docBase：实际路径
path：虚拟路径（绝对路径、相对路径）

b.方式二
在conf/Catalina/localhost中新建“项目名.xml”中新增一行:
<Context docBase="" path="" />

6、虚拟主机
通过www.test.com访问本机jsp文件
a.conf/server.xml

<Host name="www.test.com"  appBase="项目路径">
	<Context docBase="" path="/" />
</Host>
b.本机host文件
增加映射
域名解析IP    www.test.com

流程:www.test.com -> host找映射关系 ->server.xml找Engine的defaultHost ->
通过"/"映射到

7、JSP执行流程
D:\Tomcat\apache-tomcat-9.0.31\work\Catalina\localhost\ROOT\org\apache\jsp
第一次访问：（jsp -> java（Servlet文件） -> class）
第二次访问：直接访问class文件（如果服务器端代码改了，将会再访问时重新翻译和编译）
第一次访问比较慢，后续访问可以直接访问class，因此访问速度比较快。
Jsp和Servlet可以相互转换

day02
1、使用eclipse开发web项目（JSP项目）tomcat

2、浏览器可以直接访问WebContent中的文件
但是WEB-INF中的文件 无法通过客户端（浏览器）直接访问，只能通过请求转发来访问
注意：并不是任何的内部跳转都能访问WEB-INF;原因是跳转有两种方式:请求转发、
重定向

3、统一字符集编码
a.编码分类
设置jsp文件的编码（jsp文件中的pageEncoding属性）：jsp -> java
设置浏览器读取jsp文件的编码（jsp文件中的content属性）：

4、部署tomcat
在servers面板新建一个tomcat实例，再在该实例中部署项目之后运行
注意：一般建议将eclipse中的tomcat与本地tomcat的配置信息保持一致：将eclipse
中的tomcat设置为托管模式：第一次创建tomcat实例之后，双击，选择Server Location
的第二项

5、jsp的页面元素：HTML JAVA代码（脚本Scriplet）、注释、指令
a.脚本Scriplet
i、 <%
定义局部变量、编写语句
%>
ii、<%!
全局变量、定义方法
%>
iii、<%=
输出表达式
%>
注意：一般而言，修改web.xml、配置文件、java 需要重启tomcat
但是如果修改 Jsp\html\css\js,不需要重启
out.print() <%= %> 可以直接解析html代码

b.指令
	<%@ include ... %>	包含其他文件
	<%@ taglib ... %>	引入标签库的定义
	<%@ page ... %>	定义网页依赖属性，比如脚本语言、error页面、缓存需求等等

	page指令指定的属性：
		language:jsp页面使用的脚本语言
		import:导入类
		pageEncoding:jsp文件自身的编码
		content:浏览器解析jsp文件的编码

c.注释
	html注释<!-- --> 可以被客户通过浏览器查看源码所看到
	java注释//    /* */
	jsp注释<%-- --%>

6、JSP九大内置对象（自带的，不需要new也能使用的对象）
pageContext,request,response,session,application,config,out,page,exception

1）、out（输出对象）：向客户端输出内容

2）、request（请求对象）(数据只在同一次请求有效)：存储“客户端向服务端发送的请求信息”
	request对象的常见方法：
		String getParameter（String name）：根据请求的字段名key（input标签的name属性），返回字段值value（input标签的value属性值）
		String[] getParameterValues（String name）：根据请求的字段名key，返回多个字段值value（checkbox）
		void setCharacterEncoding（“编码格式utf-8”）：设置post方式的请求编码（tomcat7以前默认iso-8859-1，tomcat8以后改为utf-8）
		getRequestDispatcher("B.jsp").forward(request,response) :请求转发 A页面 -(跳转)> B页面
		ServletContext getServerContext() :获取项目的ServletContext对象
	示例：注册
		register.jsp 注册页面
		show.jsp 显示页面

	地址栏请求方式：连接/文件？参数名1=参数值1 & 参数名2=参数值2
	get提交方式： method=“get” 、超链接（<a href="xx">）和 地址栏请求方式默认都属于get提交方式

	get和post请求方式的区别：
		a.get方式在地址栏显示请求信息（但是地址栏能够容纳的信息有限，4-5kb;如果请求数据存在大文件，图片等会出现地址栏无法容纳数据报错），post不会显示
		b.文件上传操作，必须是post
	推荐使用post
3）、response（响应对象）
	提供的方法
		void addCookie(Cookie cookie); 服务端向客户端增加cookie对象
		void sendRedirect(String location) throws IOException; :页面跳转的一种方式（重定向）
		void setContetType（String type）：设置服务端响应的编码（设置服务端的contentType类型）
	示例：登录
		login.jsp  ->  check.jsp -> success.jsp
	
	*请求转发和重定向的区别：
							  请求转发        重定向
		地址栏是否改变			不变 			改变
		是否保留第一次          保留            不保留       --四种范围对象
		请求时的数据
		请求次数/响应次数         1                2
		跳转发生的位置         服务端         客户端发出的第二次跳转  
4）、pageContext（JSP页面容器）

5）、page（当前JSP页面对象）（相当于java中的this）

6）、session（会话对象）
Cookie（客户端，不是内置对象）:Cookie是由服务端生成的，再发送给客户端保存
	相当于本地缓存的作用：客户端（hello.mp4）->服务端（hello.mp4）
	作用：提高访问服务端的效率，但是安全性较差。
	a、不是内置对象要访问必须new
	b、但是服务端会自动生成一个name=JSESSIONID的cookie并返回给客户端
	Cookie：name=value
	javax.servlet.http.Cookie
	public Cookie(String name,String value){}
	String getName():获取name
	String getValue():获取value
	void setMaxAge(int expiry);最大有效期（秒）
	服务端准备Cookie：
	response.addCookie(Cookie cookie)
	页面跳转（转发、重定向）
	客户端获取Cookie：
	request.getCookies();
	注意：只能一次性获取全部Cookie对象
	通过F12可以发现 除了自己设置的Cookie对象外，还有一个name为JSESSIONID的cookie
	建议cookie中只保存英文和数字，否则需要进行编码和解码
示例：使用Cookie实现记住用户名功能
	login.jsp  ->  check.jsp -> result.jsp
session（会话）
	a.浏览网站：开始-关闭
	b.购物：浏览、付款、退出
	c.电子邮件
session机制：
	a.session存储在服务端
	b.session是在同一个用户（客户）请求时共享
	c.session实现机制：
	客户端第一次请求服务端时，（JSESSIONID - sessionID）服务端会产生一个session对象（用于保存该客户的信息）；
	并且每个session对象都会有一个唯一的sessionId（用于区分其他session）；
	服务端就会产生一个cookie，并且该cookie的name=JSESSIONID，value=服务端sessionId的值；
	然后服务端会在响应客户端的同时将该cookie发送给客户端，至此客户端就有了一个cookie（JSESSIONID）
	因此，客户端的cookie就可以和服务端的session一一对应（JSESSIONID - sessionID）
session方法：
	String getId():获取sessionId
	boolean isNew():判断是否是新用户（第一次访问）
	void invalidate():使session失效（退出登录、注销）
	void setMaxInactiveInterval(秒)：设置最大有效非活动时间
	int getMaxInactiveInterval()获取最大有效非活动时间
	void setAttribute()
	object getAttribute()
示例：
	登录
	
cookie和session的区别：
					session          cookie
	保存的位置     	服务端          客户端
	安全性          较安全	        较不安全
	保存的内容       Object          String
服务端在第一次响应客户端时，会发送一个JSESSIONID的cookie给客户端


7）、application
	String getContextPath()： 虚拟路径
	String getRealPath(String name)： 绝对路径（虚拟路径 相对的绝对路径）
	
8）、config（配置对象‘服务器配置信息’）

9）、exception（异常对象）

7、四种范围对象（小->大）
pageContext 当前页面有效（页面跳转后无效）
request 同一次请求有效
session 同一次会话有效
application 全局有效（整个项目有效）（切换浏览器仍然有效）关闭服务、其他项目无效
->多个项目共享、重启后仍然有效：JNDI
以上四个对象共有的方法：
Object getAttribute(String name):根据属性名，或者属性值
void setAttribute(String name,Object obj):设置属性名（新增，修改）
void removeAttribute(String name)：根据属性名，删除对象
注意：以上范围对象，尽量使用最小的范围。因为对象的范围越大，造成的性能损耗越多

8、统一请求的编码request
get方式请求如果出现乱码，解决：
a.统一每一个变量的编码（不推荐）
new String(旧编码，新编码);
b.修改server.xml，一次性的更改tomcat默认get提交方式的编码（utf-8）
建议：使用tomcat时，首先在server.xml中统一get方式的编码
+ URIEncoding=“UTF-8”
get方式请求如果出现乱码，解决：
request.setCharacterEncoding(“utf-8”);

day03

1、JDBC：Java Database Connectivity
可以为多种关系型数据库DBMS提供统一的访问方式，用java来操作数据库
管理驱动程序：JDBC DriverManager
2、JDBC API 主要功能：
三件事具体通过以下类/接口实现：
DriverManager:管理jdbc驱动
Connection:连接（通过DriverManager产生）
Statement(PreparedStatement):增删改查（通过Connection产生）
CallableStatement:调用数据库中的存储过程/存储函数（通过Connection产生）
Result:返回的结果集（上面的Statement等产生）

Connection产生操作数据库的对象：

	Connection产生Statement对象：createStatement()
	Connection产生PreparedStatement对象：prepareStatement()
	Connection产生CallableStatement对象：prepareCall()

Statement操作数据库：
	增删改executeUpdate()
	查询executeQuery()

PreparedStatement操作数据库：
	public interface PreparedStatement extends Statement
	因此
	增删改executeUpdate()
	查询executeQuery();
	赋值操作 setXxx();
PreparedStatement与Statement在使用时的区别：
a、Statement:
	sql
	executeUpdate(sql)

b、PreparedStatement:
	sql(可能存在占位符?)
	在创建PreparedStatement对象时，将sql预编译prepareStatement（sql）
	executeUpdate()
	setXxx()替换占位符
推荐使用PreparedStatement原因
a、编码更加简便
b、提高性能（预编译操作）
c、安全（可以有效防止sql注入）
（例如输入 用户名：任意值 ' or 1=1 -- 
			密码：任意值）


ResultSet:保存结果集 select * from xxx
next():光标下移，判断是否有下一条数据; true/false
previous(): true/false
setXxx(字段名|位置):获取具体的字段值

3、JDBC访问数据库的具体步骤：
a、导入驱动，加载具体的驱动类
b、与数据库建立连接
c、发送sql，执行
d、处理结果集（查询）

4、数据库驱动
驱动jar包 具体驱动类 连接字符串
Oracle ojdbc-x.jar oracle.jdbc-OracleDriver.class jdbc:oracle:thin:@localhost:1521:ORCL
MySQL mysql-connector-java-x.jar com.mysql.jdbc.Driver jdbc:mysql://localhost:3306/数据库实例名
SqlServer sqljdbc-x.jar com.microsoft.sqlserver.jdbc.SQLServerDriver jdbc:microsoft:sqlserver:localhost:1433;databasename=数据库实例名

使用jdbc操作数据库时，如果对数据库进行了更换，只需要替换：驱动、具体驱动类、
连接字符串、用户名、密码

day04
1、jdbc总结（模板、八股文）：
try{
a、导入驱动包，加载具体的驱动类
Class.forName(“com.mysql.jdbc.Driver”);
b、与数据库建立连接
connection = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
c、通过connection，获取操作数据库的对象（Statement\preparedStatement\callableStatement）
pstmt = connection.prepareStatement(sql);//预编译
d、处理结果集（查询）rs = pstmt.executeQuery();
while(re.next()){rs.getXxx(…);}
}catch(ClassNotFoundException e){
e.printStackTrace();
}catch(SQLException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}finally{
关闭资源
例：
if(rs!=null)rs.close();
if(pstmt!=null)pstmt.close();
if(connection!=null)connection.close();
//打开顺序，与关闭顺序相反
}
–jdbc中，除了Class.forName() 抛出ClassNotFoundException，其余方法全部抛出SQLException

2、CallableStatement:调用存储过程、存储函数
Connection.prepareCall（参数：存储过程或存储函数名）
参数格式
存储过程（无返回值return，用out参数代替）：
{call 存储过程名（参数列表）}
存储函数（有返回值return）：
{？=call 存储函数名（参数列表）}
调用存储过程
create or replace procedure addTwoNum(num1 in number,num2 in number,result out number)–num1+num2=result
as
begin
result:=num1+num2;
end ;
/

	强调：
	如果通过sqlplus访问数据库，只需要开启：OracleServiceID
	通过其他程序访问数据（sqldevelop、navicate、JDBC），需要开启：OracleServiceID、XxxListner
	JDBC调用存储过程的步骤：
	a、产生调用存储过程的对象（CallableStatement）cstmt=connection.prepareCall("...");
	b、通过setXxx()处理输入参数值cstmt.setInt(1,10);
	c、通过 registerOutParameter（...）处理输出参数类型
	d、cstmt.execute()执行
	e、接受输出值（返回值）getXxx()
调用存储函数
	create or replace function addTwoNumfunction(num1 in number,num2 in number)--num1+num2=result
	return number
	as
		result number;
	begin
		result:=num1+num2;
		return result;
	end ;
	/
两者区别：两者调用时注意参数

3、处理CLOB[text]/BLOB
处理稍大型数据

a、存储路径 E:\JDK_API
	通过JDBC存储文件路径，然后根据IO操作处理
	例如：JDBC将E:\JDK_API文件以字符串形式“E:\JDK_API”存储到数据库中
	获取：1、获取该路径“E:\JDK_API” 2、IO
b、
CLOB:大文本数据（小说->数据）
BLOB:二进制

clob[text]:大文本数据 字符流Reader Writer
存储过程
	1、先通过pstmt的?占位符代替小说的内容
	2、再通过pstmt.setCharacterStream(2, reader,(int)file.length());将上一步的?
	替换为小说流，注意第三个参数需要是int类型
取出过程
	1、通过Reader reader = rs.getCharacterStream("novel");将text类型的数据保存到
	Reader对象中
	2、将Reader对象通过Writer输出即可
	
blob:二进制 字节流inputStream outputStream
与clob步骤基本一致，区别：setBinaryStream(...) getBinaryStream(...)

4、jsp访问数据库

jsp就是在html中嵌套的Java代码

导包操作：java项目：1、jar复制到工程中2、右键该jar包build path -> add to build Path
		  web项目：jar复制到WEB-INF/lib

5、JavaBean
类名后缀Dao 用于访问数据库
我们将jsp中登录操作的代码转移到了LoginDao.java；其中LoginDao类就称之为JavaBean
JavaBean的作用：a、减轻的jsp复杂度 b、提高代码复用（以后任何地方的登录操作，都可以通过调用LoginDao实现）
JavaBean（就是一个Java类）的定义：
a、public修饰的类，public无参构造
b、所有属性都是private，并且提供set/get（如果boolean 则get可以替换成is）

使用层面，JavaBean分为两大类
	a、封装业务逻辑的JavaBean （LoginDao.java封装了登录逻辑）
	可以将jsp中的JDBC代码，封装到Login.java类中
	b、封装数据的JavaBean（实体类，Student.java Person.java）
	Login login = new Login(uname,upwd);//即用Login对象封装了两个数据（用户名和密码）
	对应于数据库中的一张表

6、MVC设计模式:
M:Model 模型：一个功能。
用JavaBean实现
V:View 视图：用于展示、以及与用户交互
使用html js css jsp jquery 等前端技术实现
C:Controller 控制器：接受请求，将请求跳转到模型进行处理;模型处理完毕后，再将
处理结果返回给请求处
可以用jsp实现，但是一般建议使用Servlet实现控制器。
day05
1、Servlet
Java类必须符合一定的规范：
a、必须继承javax.servlet.http.HttpServlet
b、重写其中的doGet()方法和doPost()方法
C、编写web.xml中的servlet映射关系

doGet()：接受并处理 所有get方式提交的请求
doPost()：接受并处理 所有post方式提交的请求

Servlet要想使用，必须配置
Servlet2.5:web.xml
Servlet3.0:@WebServlet

Servlet2.5:web.xml:
项目的根目录：WebContent、src（所有的构建路径）

<a href="WelcomeServlet">所在的jsp是在webcontent目录下
因此发出的请求WelcomeServlet是去请求项目的根目录。

Servlet流程：
请求 -> <url-pattern> -> 根据<servlet-mapping>中的<servlet-name>
去匹配<servlet>中的<servlet-name>，然后寻找到<servlet-class>，
将请求交由该<servlet-class>执行
1）、手工方式创建第一个Servlet
	a、必须继承javax.servlet.http.HttpServlet
	b、重写其中的doGet()方法和doPost()方法
	C、编写web.xml中的servlet映射关系
2）、借助于Eclipse快速生成Servlet
直接新建Servlet即可！（继承、重写、web.xml 可以借助eclipse快速生成）

Servlet3.0与Servlet2.5的区别：
	Servlet3.0不需要在web.xml中配置，但需要在Servlet类的定义处之上编写注解
	@WebServlet（“url-pattern的值”）
	匹配流程：请求地址与@WebServlet中的值进行匹配，如果匹配成功，则说明请求的就是该注解
	所对应的类

注意：
web.xml中的/:代表项目根路径
http://localhost:8888/Servlet25Project/
jsp中的/:服务器根路径
http://localhost:8888/

2、Servlet生命周期：5个阶段
加载、卸载：Servlet容器自动处理
加载 -> 初始化 -> 服务 -> 销毁 -> 卸载
初始化：init(),该方法会在Servlet被加载并实例化之后执行
服务：抽象方法service() -> doGet() doPost
销毁：destory(),Servlet被系统回收时执行

init()：a、默认第一次访问Servlet时会被执行
b、可以修改为Tomcat启动时自动执行
	i、2.5版本：<servlet>
					<load-on-startup>1</load-on-startup>
				</servlet>
	ii、3.0版本：@WebServlet(value="/WelcomeServlet",loadOnStartup=1)
service() -> doGet() doPost：调用几次执行几次
destory()：关闭tomcat服务时，执行一次

3、servlet API
由两个软件包组成：对应于HTTP协议的软件包、对应于除了HTTP协议以外的其他软件包
即Servlet API适用于任何通信协议
我们学习的Servlet是位于javax.servlet.http包中的类和接口，是基于HTTP协议

4、servlet继承关系
ServletConfig：接口
ServletContext getServletContext():获取Servlet上下文对象 application
String getInitParameter（String name）：在当前Servlet范围内，获取名为那么的参数值（初始化参数）

	ServletContext中的常见方法（application）：
	getContextPath():相对路径
	getRealPath():绝对路径
	setAttribute()、getAttribute()
	String getInitParameter（String name）：在当前WEB容器范围内，获取名为那么的参数值（初始化参数）

Servlet3.0给当前Servlet设置初始值：
@WebServlet(value = "/WelcomeServlet",loadOnStartup=1,initParams= {@WebInitParam(name="servletparamname30",value="servletparamvalue30")})
此注解只隶属于某一个具体的Servlet，因此无法为整个web容器设置初始化参数

HttpServletRequest中的方法：（同request），例如setAttribute()、getCookies()
HttpServletResponse中的方法：（同response）

Servlet使用层面：
	Eclipse中在src创建一个Servlet，然后重写doGet() doPost() 就可以（doGet() doPost()只需要写一个）

5、MVC案例

day06
1、三层架构
与MVC设计模式的目标一致：都是为了解耦合、调高代码复用
区别在于二者对项目理解的角度不同。

2、三层组成：
表示层（USL,User Show Layer）（视图层）
-前台代码：对应于MVC中的View：用于和用户交互、界面显示
jsp js html css jQuery等web前端技术
代码位置：WebContent
-后台代码：对应于MVC中的Controller，用于控制跳转、调用业务逻辑层
Servlet(SpringMVC Struts2)
代码位置：xxx.servlet包中
业务逻辑层（BLL,Business Logic Layer）（Service层）
-接收表示层的请求 调用
-组装数据访问层，逻辑性的操作（增删改查，删：查+删）
代码位置：xxx.service包中（也可以称为xxx.manager，xxx.bll）
数据访问层（DAL,Data Access Layer）（Dao层）
-直接访问数据库操作，原子性的操作（增删改查）
代码位置：xxx.dao包中
实体类（JavaBean）代码位置：xxx.entity
三层间的关系：
上层将请求传递给下层，下层处理后返回给上层
上层依赖于下层，依赖：代码理解，就是持有成员变量

补充：out session application
在servlet中获取out对象：PrintWrtier out = response.getWriter()
session:request.getSession()
application:request.getServletContext()
//设置响应编码
response.setContentType("text/html;charset=UTF-8");
response.setCharacterEncoding("utf-8");

Servlet:一个servlet对应于一个功能，因此如果有增删改查（查询单个和查询多个）4个功能，则需要创建4个Servlet

3、三层优化
a、加入接口（建议面向接口开发）
先接口-再实现类
–service、dao加入接口
–接口与实现类的命名规范
接口：interface, 起名规范 IXxxService IStudentService
IStudentDao
实现类：implements, 起名规范 XxxServiceImpl StudentServiceImpl
StudentDaoImpl
命名规范总结：接口 I-实体类-层所在包名
实体类 实体类-层所在报名-Impl

		接口所在的包：    xxx.service          xxx.dao
		实现类所用的包：  xxx.service.impl     xxx.dao.impl
		
		以后使用接口/实现类时,推荐写法：
		接口 x=new 实现类();
		IBookDao bookDao = new BookDaoImpl();
		
b、DBUtil(通用的数据库帮助类)可以简化Dao层的简化
	帮助类 一般建议写在 xxx.util包

方法重构：将多个方法的共同代码提炼出来，单独写在一个方法里

web调试:
与java代码的调试：启动方式不同
day07

1、分页
要实现分页，必须知道某一页数据从哪里开始到哪里结束
页面大小：每页显示的数据量

mysql从0开始计数，oracle/sqlserver从1开始计数

a、mysql实现分页：从0开始计数
0 0 9
1 10 19
2 20 29
n n10 (n+1)10-1
sql语句： limit 开始，多少条
第0页
select * from student limit 0,10;
第1页
select * from student limit 10,10;
第2页
select * from student limit 20,10;
第n页
select * from student limit n10,10;
mysql分页语句：
select * from student limit 页数页面大小,页面大小;
b、oracle/sqlserver实现分页
第n页 开始 结束
1 1 10
2 11 20
3 21 30
n (n-1)10+1 n10
分页结论：
第n页数据：第(n-1)10+1条 – 第n10条
sql语句： select * from student where sno >= (n-1)10+1 and sno <= n10;–此种写法前提是：id连续

		  select rownum,t.* from student where sno >= (n-1)*10+1 and sno <= n*10 order by sno;
			--1、如果根据sno排序则rownum会混乱（解决方案：先排序，再只查询rowmun） 2、rownum只能查询小于的数据
oracle的查询分页语句：
		select * from
		（
			select rownum r,t.* from
			（select s.* from student s order by sno）t
		）
		where r >= (n-1)*10+1 and r <= n*10;
		
		优化：
		select * from
		（
			select rownum r,t.* from
			（select s.* from student s order by sno asc）t
			rownum <= n*10
		）
		where r >= (n-1)*10+1;
SQLServer分页：
	row_number() over(字段);
		select * from
		（
			select row_number() over(sno order by sno asc) as r,* from student
			where r <= n*10
		）
		where r >= (n-1)*10+1;

分页实现
5个变量（属性）
1、数据总数 （查询数据库，select count（*）… ）
2、页面大小（每页显示的数据条数）（用户自定义）
3、总页数 （程序自动计算）
i、总页数= 数据总数%页面大小==0？（数据总数/页面大小）:（数据总数/页面大小+1）
4、当前页（页码） （用户自定义）
5、当前页的对象集合（实体类集合）：每页所显示的所有数据（10个人的信息）
List （查数据库，分页sql）

2、表单重复提交

day08
1、文件上传
a、引入两个jar包
apache:commons-fileupload.jar组件
commons-fileupload.jar依赖于commons-io.jar
b、代码：
前台（jsp）：

表单提交方式必须是post
在表单中必须增加一个属性 enctype = “multipart/form-data”
后台（servlet）：

注意的问题：
上传的目录：upload
a、如果修改代码，则在tomcat在重新启动时会被删除
原因：当修改代码的时候，tomcat会重新编译一份class并且重新部署（重新创建各种目录）
b、如果不修改代码，则不会被删除
原因：没有修改代码，class不变
因此，为了防止上传目录丢失：i、虚拟路径 ii、直接更换上传目录到非tomcat目录

2、控制上传文件的类型和大小（前台限制（js）后台限制都行）
注意对文件的限制条件写在parseRequest之前

3、下载：不需要依赖任何jar包
a、前台（请求地址） 请求servlet
b、Servlet通过文件的地址 将文件转为输入流 读到servlet中
c、通过输出流将刚才已经转为输入流的文件输出给用户

注意：下载文件 需要设置2个响应头
response.addHeader(“contentType”, “application/octet-stream”);//MIME类型为二进制(任意格式的文件都行)
response.addHeader(“content-Disposition”,“attachement;filename=”+fileName);//fileName包含了文件后缀abc.txt
4、下载时文件名乱码问题

edge：
URLEncoder.encode(fileName,“UTF-8”)//文件名转码操作
firefox:
给文件名加上：
前缀 =?UTF-8?B?
String构造方法
Base64.encode
后缀 ? =
=?UTF-8?B?"+new String(Base64.encodeBase64(fileName.getBytes(“UTF-8”)))+"?="

day09
1、EL：Expression Language
可以替代jsp中的java代码
servlet（增加数据） -> jsp（显示）
EL实例：
${requestScope.student.address.schoolAddress}
${域对象.域对象中的属性.属性.属性.级联属性}
.操作符：使用方便
[""]/[’’]操作符：功能强大 可以包括特殊字符 获取变量值[] 可以访问数组

Map<String,Object> map = new HashMap<>();
map.put("cn","中国")
map.put("us","美国")
request.setAttribute("map",map)

${requestScope.map.cn}
${requestScope.map["us"]}

关系运算符 逻辑运算符
Empty运算符：判断一个值null、不存在

EL表达式的隐式对象(不需要new就能使用的对象,内置对象)
jsp:request\response
	a.作用域访问对象（EL域对象）
		pageScope requestScope sessionScope applicationScope
	b.参数访问对象:获取表单数据(超链接传的值)(request.getParameter()、request.getParameterValues() )
										${param} 				${paramValues}
	c.jsp隐式对象：pageContext
		在jsp中可以通过pageContext获取其他的jsp隐式对象；
		因此如果要在EL中使用Jsp隐式对象，可以通过pageContext间接获取
		例如${pageContext.request}
		可以使用 此方法级联获取方法：
		${pageContext.request.serverport}
		*${pageContext.方法名去掉()和get并且将首字母小写}

2、JSTL:比EL更加强大
需要引入两个jar包
jstl.jar standard.jar
引入taglib
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“c”%>
prefix=“c”：前缀

核心标签库：通用标签库、条件标签库、迭代标签库
a、通用标签库
	<c:set>赋值
	 i、在某个作用域中（4个范围对象），给某个变量赋值
		<%--
			request.setAttribute("name", "zhangsan");
		--%>
		<c:set var="name" value="zhangsan" scope="request"  />
		${requestScope.name}
	ii、在某个作用域中（4个范围对象），给某个对象的属性赋值(不用指定scope属性)
	<c:set target="${requestScope.student}" property="sname" value="zxs"/>
	
	注意：<c:set>可以给不存在的值赋值（但不能给不存在的对象赋值）
	<c:out>显示
	i、<c:out value="${requestScope.stu}"  default="当value为空时显示的默认值"/>
	ii、default:<c:out value='<a href="https://www.baidu.com">百度</a>'/><br/>
	true:<c:out value='<a href="https://www.baidu.com">百度</a>' escapeXml="true"/><br/>
	false:<c:out value='<a href="https://www.baidu.com">百度</a>' escapeXml="false"/><br/>

	<c:remove>
	i、<c:remove var="a" scope="request"/><br/>
	
b、条件标签库
	选择:
	if(boolean)
	<c:if test="" var="" scope=""></c:if>
	
	if else if... else if...
	<c:choose>
		<c:when test="..."> </c:when>
		<c:when test="..."> </c:when>
		<c:when test="..."> </c:when>
		<c:otherwise> </c:otherwise>
	</c:choose>

c、迭代标签库
	循环
	for(int i=0;i<5;i++){}
	
	<c:forEach begin="0" end="5" step="1" varStatus="status">
		${status.index}
		test...<br>
	</c:forEach>

	for(String name:names)
	<c:forEach var="name" items="${requestScope.names }" >
		${name }
	</c:forEach>

day10
1、过滤器（拦截器：springMVC）
1）.在java类里面实现Fileter接口
init()、destory()原理、执行时机同Servlet
2）.在WEB.xml文件中配置过滤器（类似servlet）
i.
过滤器名称
过滤器的完全限定名

ii.
过滤器名称
需要过滤的页面地址

3）.使用场合
	1）对请求和响应统一处理
	2）对请求进行日志记录和审核
	3）对数据进行屏蔽和替换
	4）对数据进行加密和解密
4）.过滤器的作用
	1）可以统一的集中处理请求和响应
	2）可以实现对请求数据的过滤

5）、filter映射
	<url-pattern>/MyServlet</url-pattern> 只拦截访问MyServlet的请求
	<url-pattern>/*</url-pattern> 拦截所有的请求

6）、通配符
dispather请求方式：
	REQUEST:拦截HTTP请求 get post
	FORWARD:只拦截通过请求转发方式的请求
	
	INCLUDE:只拦截通过 request.getRequestDispatcher("").include、通过<jsp:include page="..."/>
	ERROR:只拦截<error-page>发出的请求

通过doFilter()处理拦截，并且通过chain.doFilter(request, response);//将请求和响应放行

7）、过滤器链
	过滤器顺序由<filter-mapping>在web.xml顺序决定

2、监听器
监听对象：request session application
开发步骤
i、编写监听器，实现接口
ii、配置web.xml
a、监听对象的创建和销毁
request:ServletRequestListener
session:HttpSessionListener
application:ServletContextListener

每个监听器各自提供了两个方法：监听开始和监听结束的方法

ServletContext在servlet容器启动时自动创建
b、监听对象中属性的变更
request:ServletRequestAttributeListener
session:HttpSessionAttributeListener
application:ServletContextAttributeListener

1 什么是web监听器？

web监听器是一种Servlet中的特殊的类，它们能帮助开发者监听web中的特定事件，比如ServletContext,HttpSession,ServletRequest的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控。

2 监听器常用的用途

通常使用Web监听器做以下的内容：

统计在线人数，利用HttpSessionLisener

加载初始化信息：利用ServletContextListener

统计网站访问量

实现访问监控

3 接下里看看一个监听器的创建以及执行过程

首先需要创建一个监听器，实现某种接口，例如我想实现一个对在线人数的监控，可以创建如下的监听器：

	public class MyListener implements HttpSessionListener{
		private int userNumber = 0;
		public void sessionCreated(HttpSessionEvent arg0) {
			userNumber++;
			arg0.getSession().setAttribute("userNumber", userNumber);
		}
		public void sessionDestroyed(HttpSessionEvent arg0) {
			userNumber--;
			arg0.getSession().setAttribute("userNumber", userNumber);
		}
	}

　　然后在web.xml中配置该监听器，在web-app中添加：

	  <listener>
		  <listener-class>com.test.MyListener</listener-class>
	  </listener>
　　在JSP中添加访问人数：

	<body>
		在线人数：<%=session.getAttribute("userNumber") %><br/>
	</body>
	
session的钝化和活化
钝化： 内存 -> 硬盘
活化： 硬盘 -> 内存
session对象的四种状态
	
	这两种监听器不需要配置web.xml
	监听绑定和解绑：HttpSessionBindingListener
	a、session.setAttribute("a",xxx) 将对象a【绑定】到session中
	b、session.removeAttribute("a") 将对象a从session中【解绑】
	监听钝化和活化：HttpSessionActivationListener
	c、钝化
	d、活化

	钝化、活化：配置tomcat安装目录/conf/context.xml
	
	钝化、活化本质就是序列化和反序列化
		序列化和反序列化实现Serializable接口

	总结：钝化、活化实际执行是通过context.xml中进行配置而进行。
	
	活化：session中获取某一个对象时，如果该对象在内存中不存在，则直接尝试从之前钝化的文件中去获取
	HttpSessionActivationListener只是负责在session钝化和活化时予以监听。
	需要实现Serializable接口

day11
请求转发/重定向（页面刷新）
1、Ajax ：异步js 和 xml（局部刷新）
异步刷新技术：如果网页中某一个地方需要修改，异步刷新可以使只刷新该需要修改的地方
页面中其他地方保持不变

实现：
js（较麻烦）：XMLHttpRequest对象
XMLHttpRequest对象的方法：
1）、open(方法名（提交方式：get、post）,服务器地址,true):与服务端建立链接

2）、send()：
	get:	send(null)
	post:	send(参数值)
3）、setRequestHeader(header,value):
	get:	不需要设置此方法
	post:	需要设置：
		a、如果请求元素中包含了文件上传
			setRequestHeader("Content-Type","multipart/form-data")
		b、如果请求元素中不包含文件上传
			setRequestHeader("Content-Type","application/x-www-form-urlencoded")
	
XMLHttpRequest对象的属性：
1）、readyState：请求状态  只有状态为4代表请求完毕
	status：响应状态	只有200代表响应正常
	onreadystatechange：回调函数
	responseText：响应格式为String
	responseXML：响应格式为XML


jquery（推荐）
$.ajax({
	url：服务器地址，
	请求方式：get、post，
	data：请求数据，
	success:function(result,testStatus){
	},
	error:function(xhr,errorMessage,e){
	}
});
//顺序不能变
$.get(
	服务器地址,
	请求数据,
	function (result){
	},
	预期返回值类型（string\xml）
	"xml"、"json"、"text"
);

$.post(){
	服务器地址,
	请求数据,
	function (result){
	},
	预期返回值类型（string\xml）
};

$("xxx").load(){
	服务器地址,
	请求数据
};
load:将服务端的返回值直接加载到$("xxx")所选择的元素中

$.getJSON(){
	服务器地址,
	JSON格式请求数据
	function (result){
		eval(result)//js需要通过eval()函数将返回值javajson对象
		//转为一个js能够识别的json对象
	}
};返回的result TYPE是 json对象

遍历json
	$.each(json,function(i,element){
		
	});