javaEE

Tomcat

1、程序架构

1-1、C/S架构（Client — Server）

​ 一种两层结构的系统,第一层在客户机上安装了客户机应用程序,第二层在服务器上安装服务器管理程序.在C/S模式的工作过程中,客户机程序发出请求,服务器程序接收并且处理客户机程序提出的请求,然后返回结果 。

C/S模式有以下特点：
​ 1、C/S模式将应用与服务分离,系统具有稳定性和灵活性
​ 2、C/S模式配备的是点对点的结构模式,适用于局域网,有可靠的安全性
​ 3、由于客户端实现与服务器端的直接连接,没有中间环节,因此响应速度快
​ 4、在C/S模式中,作为客户机的计算机都要安装客户机程序,一旦软件系统升级,每台客户机都要安装客户机程序,系统升级和维护较为复杂

1-2、B/S架构（Browser — Server）

​ 浏览器/服务器模式，是一种从传统的两层C/S模式发展起来的新的网络结构模式，其本质是三层结构的C/S模式。在用户的计算机上安装浏览器软件，在服务器上存放数据并且安装服务应用程序，服务器有WWW服务器和文件服务器等。用户通过浏览器访问服务器，进行信息浏览、文件传输和电子邮件等服务。

B/S模式有以下特点：
​ 1、系统开发、维护、升级方便
​ 每当服务器应用程序升级时，只要在服务器上升级服务应用程序即可，用户计算机上的浏览器软件不需要修改，系统开发和升级维护方便
​ 2、B/S模式具有很强的开放性
​ 在B/S模式下，用户通过通用的浏览器进行访问，系统开放性好
​ 3、B/S模式的结构易于扩展
​ 由于Web的平台无关性，B/S模式的结构可以任意扩展，可以从包含一台服务器和几个用户的小型系统扩展成为拥有成千上万个用户的大型系统
​ 4、用户使用方便
​ B/S模式的应用软件都是基于Web浏览器的，而Web浏览器的界面是类似的。对于无用户交换功能的页面。用户接触的界面都是一致的，用户使用方便

2、web交互机制

​ 客户端根据用户输入的地址信息请求服务器，服务器在接收到用户的请求后进行处理，然后将处理结果响应给客户端，客户端将响应结果展示给用户。

专业术语:
​ 请求：客户端根据用户地址信息将数据发送给服务器的过程
​ 响应：服务器将请求的处理结果发送给浏览器的过程

问题：客户端也就是浏览器的版本是有很多的，服务器的版本也是有很多的，如何实现不同版本的浏览器和不同版本的服务器之间的数据交互呢？

解决：规范浏览器和服务器的数据交互的格式。

实现：HTTP 协议

2-1、HTTP概念

​ 超文本传输协议（Hyper Text Transfer Protocol）

作用：
​ 规范了浏览器和服务器的数据交互

特点：

​ 简单快速：
​ 客户向服务器请求服务时，只需传送请求方法和路径。
​ 请求方法常用的有 GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。
​ 由于 HTTP 协议简单，使得 HTTP 服务器的程序规模小，因而通信速度很快

​ 灵活：
​ HTTP 允许传输任意类型的数据对象。正在传输的类型由Content-Type 加以标记。

​ 无连接：
​ 无连接的含义是限制每次连接只处理一个请求。服务器处理完请求，并收到客户的应答后，即断开连接。
​ 采用这种方式可以节省传输时间。

​ 无状态：
​ HTTP 协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。
​ 缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。
​ 在服务器不需要先前信息时它的应答就较快。支持 B/S 及 C/S 模式。HTTP1.1 版本后支持可持续连接。

2-2、HTTP交互

交互流程：
​ 步骤一:
​ 客户端和服务器端建立连接
​ 步骤二：
​ 客户端发送请求数据到服务器端(HTTP 协议)
​ 步骤三：
​ 服务器端接收到请求后，进行处理，然后将
​ 处理结果响应客户端(HTTP 协议)
​ 步骤四：
​ 关闭客户端和服务器端的连接(HTTP1.1 后不会立即关闭)

请求格式：
​ 请求头：请求方式、请求的地址和 HTTP 协议版本
​ 请求行：消息报头，一般用来说明客户端要使用的一些附加信息
​ 空行： 位于请求行和请求数据之间，空行是必须的。
​ 请求数据：非必须。

请求方式：

请求方式	解释
get	请求页面信息，并返回实体主体
head	跟get方式差不多，只是返回的响应中没有具体的内容，用于获取报头
post	向指定的资源数据提交处理请求，数据包含在请求体中；post可能会导致新的资源产生，或者已有资源被修改
put	从客户端向服务器传送的数据取代文档的内容
delete	请求服务器删除指定的页面
connect	HTTP/1.1预留给能够将连接改为管道方式的代理服务器
options	允许客服端查看服务器的性能
trace	回显服务器收到的请求，用于测试或诊断

get 和 post 请求方式的区别:
​ get 请求方式：
​ 请求数据会以？的形式隔开拼接在请求头中，不安全，没有请求实体部分。
​ HTTP 协议虽然没有规定请求数据的大小，但是浏览器对 URL 的长度是有限制的，
​ 所以 get 请求不能携带大量的数据。适合小数据请求
​ post 请求方式：
​ 请求数据在请求实体中进行发送，在 URL 中看不到具体的请求数据，安全。适合数据量大的数据

响应：
​ 响应行(状态行)：HTTP 版本、状态码、状态消息
​ 响应头：消息报头，客户端使用的附加信息
​ 空行：响应头和响应实体之间的，必须的。
​ 响应实体：正文，服务器返回给浏览器的
​ 响应状态码

HTTP 状态码由三个十进制数字组成，第一个十进制数字定义了状态码
的类型，后两个数字没有分类的作用。HTTP 状态码共分为 5 种类型：

分类	描述
1**	服务器收到请求，需要操作者继续进行操作
2**	操作成功被接收并处理
3**	重定向，需要进一步的操作完成请求
4**	客户端错误，请求包含语法错误或请求无法完成
5**	服务器错误，服务器在处理请求过程中发生了错误

常见错误码：

200 OK		//客户端请求成功
400 Bad Request  	//客户端请求有语法错误，不能被服务器所理解
401 Unauthorized  	//请求未经授权，这个状态代码必须和WWW-Authenticate 报头域一起使用
403 Forbidden	//服务器收到请求，但是拒绝提供服务
404 Not Found	//请求资源不存在，eg：输入了错误的 URL
500 Internal Server Error	//服务器发生不可预期的错误
503 Server Unavailable	//服务器当前不能处理客户端的请求，一段时间后可能恢复

3、Tomcat服务器

3-1、服务器

​ 所谓服务器其实就是代码编写的一个可以根据用户请求实时的调用执行对应的逻辑代码的一个容器。在普通用户看来就是一个安装程序。我们只需要将服务器在操作系统上进行安装，并将我们事先编写好的逻辑处理代码根据规则放到服务器的指定位置，启动服务器，那么服务器就自动的会根据接收到请求调用并执行对象的逻辑代码进行处理。

3-2、目录

\bin 存放启动和关闭 Tomcat 的可执行文件
\conf 存放 Tomcat 的配置文件
\lib 存放库文件
\logs 存放日志文件
\temp 存放临时文件
\webapps 存放 web 应用
\work 存放 JSP 转换后的 Servlet 

Servlet

1、Servlet简介

1-1、概念

​ 狭义的 Servlet 是指 Java 语言实现的一个接口，广义的 Servlet 是指任何实现了这个 Servlet 接口的类，一般情况下，人们将 Servlet 理解为后者。Servlet 运行于支持 Java 的应用服务器中。从原理上讲，Servlet 可以响应任何类型的请求，但绝大多数情况下 Servlet 只用来扩展基于 HTTP 协议的 Web 服务器。

1-2、特点

​ 运行在支持 java 的应用服务器上Servlet 的实现遵循了服务器能够识别的规则，也就是服务器会自动的根据请求调用对应的 servlet 进行请求处理，简单方便，可移植性强。

1-3、使用

​ 1、 创建普通的 java 类并继承 HttpServlet
​ 2、 覆写 service 方法

public class MyServlet extends HttpServlet{
    @Override
    protected void service(HttpServletRequest req,HttpServletResponse resp)
    	throws ServletException, IOException {
            resp.getWriter().write("this is my first servlet.");
            System.out.println("this is my first servlet.");
    }
}

​ 3、 在 service 方法中书写逻辑代码即可
​ 4、 在 webRoot 下的 WEB-INF 文件夹下的 web.xml文件中配置 servlet

<!--配置servlet类路径 -->
    <servlet>
        <servlet-name>my</servlet-name>
        <servlet-class>com.bjsxt.servlet.MyServlet</servlet-class>
    </servlet>
<!--配置访问方式 -->
    <servlet-mapping>
        <servlet-name>my</servlet-name>
        <url-pattern>/my</url-pattern>
    </servlet-mapping>

1-4、运行流程

​ 浏览器发送请求到服务器，服务器根据请求 URL 地址中的 URI 信息在 webapps 目录下找到对应的项目文件夹，然后在 web.xml 中检索对应的 servlet，找到后调用并执行Servlet。

URL(服务器地址:端口号/虚拟项目名 /servlet 的别名)

url：http://localhost:8080/project/my2

URI(虚拟项目名 /servlet 的别名)

project/my2

1-5、servlet生命周期

​ 1、从第一次调用到服务器关闭。
​ 2、如果Servlet在web.xml中配置了load-on-startup，生命周期为从服务器启动到服务器关闭

注意：
​ init() 方法是对Servlet进行初始化的一个方法，会在Servlet第一次加载进行存储时执行
​ destory() 方法是在servlet被销毁时执行，也就服务器关闭时。

1-6、servlet交互方法

​ Service方法：
​ 可以处理get/post方式的请求，如果servlet中有Service方法，会优先调用service方法对请求进行处理。
​ doGet方法：
处理get方式的请求
​ doPost方法：
​ 处理post方式的请求
​ 注意：
​ 如果在覆写的service方法中调用了父类的service方法(super.service(arg0, arg1)),
​ 则service方法处理完后，会再次根据请求方式响应的doGet和doPost方法执行。所以，一般情况下
​ 我们是不在覆写的service中调用父类的service方法的，避免出现405错误。

1-7、Servlet常见错误

​ 404错误:资源未找到
​ 原因一：在请求地址中的servlet的别名书写错误。
​ 原因二：虚拟项目名称拼写错误
​ 500错误：内部服务器错误
​ 错误一：
​ java.lang.ClassNotFoundException: com.bjsxt.servlet.ServletMothod
​ 解决：
​ 在web.xml中校验servlet类的全限定路径是否拼写错误。
​ 错误二：
​ 因为service方法体的代码执行错误导致
​ 解决：
​ 根据错误提示对service方法体中的代码进行错误更改。
​ 405错误:请求方式不支持
​ 原因：
​ 请求方式和servlet中的方法不匹配所造成的。
​ 解决：
​ 尽量使用service方法进行请求处理，并且不要再service方法中调用父类的service。

2、请求与响应

2-1、Request

​ 服务器接收到浏览器的请求后，会创建一个 Request 对象，对象中存储了此次请求相关的请求数据。服务器在调用 Servlet 时会将创建的Request 对象作为实参传递给 Servlet 的方法，比如：service 方法。

获取请求头数据
    req.getMethod();//获取请求方式
    req.getRequestURL();//获取请求URL信息
    req.getRequestURI();//获取请求URI信息
    req.getScheme();//获取协议
获取请求行数据
    req.getHeader("键名");//返回指定的请求头信息
    req.getHeaderNames();//返回请求头的键名的枚举集合
获取用户数据
    req.getParameter("键名");//返回指定的用户数据
    req.getParameterValues("键名");//返回同键不同值的请求数据(多选)，返回的数组。
    req.getParameterNames()//返回所有用户请求数据的枚举集合
注意：
	如果要获取的请求数据不存在，不会报错，返回null。
	request对象由tomcat服务器创建，并作为实参传递给处理请求的servlet的service方法。

​ 问题：使用请求转发后，不同的 Servlet 之间怎么进行数据的共享呢？或者说数据怎么从一个 servlet 流转给另外一个 Servlet 呢？
​ 解决：使用 request 对象的作用域

​ 使用：

request.setAttribute(object name,Object value);
request.getAttribute(Object obj)

​ 作用：解决了一次请求内的不同 Servlet 的数据(请求数据+其他数据)共享问题。

​ 作用域：基于请求转发，一次请求中的所有 Servlet 共享。

​ 特点：
​ 服务器创建，每次请求都会创建，生命周期一次请求

​ 注意：
​ 使用 Request 对象进行数据流转，数据只在一次请求内有效。

2-2、Response

​ 服务器在调用指定的 Servlet 进行请求处理的时候，会给 Servlet 的方法传递两个实参 request 和 response。其中 request 中封存了请求相关的请求数据，而 response 则是用来进行响应的一个对象。

设置响应头
    setHeader(String name,String value);//在响应头中添加响应信息，但是同键会覆盖
    addHeader(String name,String value);//在响应头中添加响应信息，但是不会覆盖。
设置响应状态
	sendError(int num,String msg);//自定义响应状态码。
设置响应实体
	resp.getWrite().write(String str);//响应具体的数据给浏览器
设置响应编码格式：
	resp.setContentType("text/html;charset=utf-8");

service请求处理代码流程：
    设置响应编码格式 
    获取请求数据
    处理请求数据
    数据库操作（MVC思想）	
    响应处理结果

2-3、乱码

请求中文乱码解决:
	1、使用String进行数据重新编码
		uname=new String(uname.getBytes("iso8859-1"),"utf-8");
	2、使用公共配置
	get方式：
		步骤一：req.setCharacterEncoding("utf-8");
		步骤二：
			在tomcat的目录下的conf目录中修改server.xml文件：
			在Connector标签中增加属性 useBodyEncodingForURI="true"
	post方式：
		req.setCharacterEncoding("utf-8");
响应中文乱码解决：
	resp.setContentType("text/html;charset=utf-8");

2-4、转发与重定向

请求转发：
​ 作用： 实现多个servlet联动操作处理请求，这样避免代码冗余，让servlet的职责更加明确。

使用：		req.getRequestDispatcher("要转发的地址").forward(req, resp);

​ 地址： 相对路径，直接书写servlet的别名即可。
​ 特点： 一次请求，浏览器地址栏信息不改变。
​ 注意：请求转发后直接return结束即可。
reuqet作用域：
​ 解决了一次请求内的servlet的数据共享问题
重定向：
​ 作用： 解决了表单重复提交的问题，以及当前servlet无法处理的请求的问题。

使用：		resp.sendRedirect(String uri);			如：resp.sendRedirect("/login/main");

​ 特点： 两次请求，两个request对象。浏览器地址栏信息改变
​ 时机：
​ 如果请求中有表单数据，而数据又比较重要，不能重复提交，建议使用重定向。
​ 如果请求被Servlet接收后，无法进行处理，建议使用重定向定位到可以处理的资源。

3、Cookie

​ Cookie 技术其实是浏览器端的数据存储技术，解决了不同请求需要使用相同的请求数据的问题。我们把请求需要共享的请求数据，存储在浏览器端，避免用户进行重复的书写请求数据。但是哪些数据需要使用 Cookie 技术存储起来是一个主观问题，需要在后台进行响应的时候来告诉浏览器，有些数据其他请求还会使用，需要存储起来。——（浏览器端的存储技术）

3-1、Cookie的创建和存储

​ 临时存储：
​ 不设置 cookie 信息的存储时间，周期为一次会话，存储在浏览器内存中
​ 定时存储：
​ 设置存储时间，周期为时间设置，存储在用户电脑中。

1、创建Cookie对象
	Cookie c=new Cookie(String name, String value);
2、设置cookie(可选)
    c.setMaxAge(int seconds);//设置有效期
    c.setPath(String uri)//设置有效路径
3、响应Cookie信息给客户端
	resp.addCookie(c);

如：

//使用Cookie进行浏览器端的数据存储
    //创建Cookie对象
        Cookie c=new Cookie("mouse", "thinkpad");
        Cookie c2=new Cookie("key", "bjsxt");
    //设置Cookie
        //设置Cookie的有效期
      		c2.setMaxAge(3*24*3600);
        //设置有效路径
        	c2.setPath("/cookie/gc");
    //响应Cookie信息
    	resp.addCookie(c);
    	resp.addCookie(c2);

3-2、Cookie的获取

1、获取Cookie信息数组
	Cookie[] cks=req.getCookies();
2、遍历数组获取Cookie信息
	使用for循环遍历即可，示例：
    //获取Cookie信息
        Cookie[] cks=req.getCookies();
        if(cks!=null){
            for(Cookie c:cks){
                String name=c.getName();
                String value=c.getValue();
                System.out.println(name+":"+value);
            }
        }

注意:
​ 一个Cookie对象存储一条数据。多条数据，可以多创建几个Cookie对象进行存储。
特点:
​ 浏览器端的数据存储技术。
​ 存储的数据声明在服务器端。
​ 临时存储:存储在浏览器的运行内存中，浏览器关闭即失效。
​ 定时存储:设置了Cookie的有效期，存储在客户端的硬盘中，在有效期内符合路径要求的请求都会附带该信息。
​ 默认cookie信息存储好之后，每次请求都会附带，除非设置有效路径

3-3、Cookie信息校验

​ 判断请求中是否携带正确的Cookie信息
​ 如果有则校验Cookie信息是否正确
​ 如果校验正确则直接响应主页面给用户
​ 如果校验不正确则响应登录页面给用户
​ 没有则请求转发给登录页面

//获取请求信息
	//获取Cookie信息
		Cookie[] cks=req.getCookies();
	//处理请求信息
		if(cks!=null){
			String uid="";
			//遍历Cookie信息
			for(Cookie c:cks){
				if("uid".equals(c.getName())){
					uid=c.getValue();
				}
			}
			//校验UID是否存在
				if("".equals(uid)){
					//请求转发
						req.getRequestDispatcher("page").forward(req, resp);
						return;
				}else{
					//校验UID用户信息
						//获取业务层对象
							LoginService ls=new LoginServiceImpl();
							User u=ls.checkUidService(uid);
							if(u!=null){
								//将用户数据存储到session对象中
								req.getSession().setAttribute("user",u);
								//网页计数器自增
								int nums=(int)this.getServletContext().getAttribute("nums");
								nums+=1;
								this.getServletContext().setAttribute("nums", nums);
								//重定向
								resp.sendRedirect("/login/main");
								return;
							}else{
								//请求转发
								req.getRequestDispatcher("page").forward(req, resp);
								return;
							}
					}
				
			}else{
				//响应处理结果
					//请求转发
					req.getRequestDispatcher("page").forward(req, resp);
					return;
			}

4、Session

​ 原理：
​ 用户第一次访问服务器，服务器会创建一个session对象给此用户，并将该session对象的JSESSIONID使用Cookie技术存储到浏览器中，保证用户的其他请求能够获取到同一个session对象，也保证了不同请求能够获取到共享的数据。

​ 特点：
​ 存储在服务器端
​ 服务器进行创建
​ 依赖Cookie技术
​ 一次会话默认存储时间是30分钟

​ 作用：session解决了一个用户的不同请求的数据共享问题，只要在JSESSIONID不失效和session对象不失效的情况下。用户的任意请求在处理时都能获取到同一个session对象。

​ 作用域：
​ 一次会话
​ 在JSESSIONID和SESSION对象不失效的情况下为整个项目内。

使用

​ 使用时机:一般用户在登陆web项目时会将用户的个人信息存储到Sesion中，供该用户的其他请求使用。

创建session对象/获取session对象:
	HttpSession hs=req.getSession();
	
常用的方法：
    getId();  //得到session的编号
    setAttribute(key,value); //将数据保存在session范围
    getAttribute(key); //从session范围取出数据,默认是Object，需要强制转换
    removeAttribute(key); //从session范围移除叫key的对象
    setMaxInactiveInterval(5); //设置session最大的有效时间，单位是秒
    getMaxInactiveInterval();//得到session最大的有效时间,单位是秒
    invalidate();//设session失效
    
设置session的有效时间：
	方法一： 单位是秒
    	session.setMaxInactiveInterval(5);
	方法二：当前项目web.xml或tomcat/conf/web.xml中,单位是分钟
        <session-config>
           <session-timeout>1</session-timeout>
        </session-config>
        
session失效处理：
	将用户请求中的JSESSIONID和后台获取到的SESSION对象的JSESSIONID进行比对，如果一致
	则session没有失效，如果不一致则证明session失效了。重定向到登录页面，让用户重新登录。

4-5、注意

​ a1.session默认有效时间是30分钟,可以通过setMaxInactiveInterval(5),设有效时间在指定的时间内session对象没有被使用则销毁，如果使用了则重新计时。
​ a2.session对象与浏览器对应，当前浏览器有一个网页没有关闭，session就是同一个对象，如果当前浏览器所有的 网页全部关闭，则重新创建一个新的session,JSESSIONID存储在了Cookie的临时存储空间中，浏览器关闭即失效。
​ a3.session实现同一个用户，多个页面数据的共享(前提是同一个浏览器)
​ a4.当超时的时间必须是整数，当设为0或负值表示session永远不失效
​ a5.只要不关闭浏览器，并且 session 不失效的情况下，同一个用户的任意请求在项目的任意Servlet中获取到的都是同一个session对象。

​ a6.存储的动作和取出的动作发生在不同的请求中，但是存储要先于取出执行。

​ include指令：实现页面的重用

<%@include file="includePage.jsp" %>包含子页面到主页面中来
相当于<iframe src="includePage.jsp"/>

5、ServletContext

​ 问题:
不同的用户使用相同的数据
解决:
ServletContext对象
特点:
服务器创建
用户共享
作用域：
整个项目内
生命周期：
服务器启动到服务器关闭

使用

​ 获取ServletContext对象

//第一种方式：
	ServletContext sc=this.getServletContext();
//第二种方式：
	ServletContext sc2=this.getServletConfig().getServletContext();
//第三种方式：
	ServletContext sc3=req.getSession().getServletContext();

​ 使用ServletContext对象完成数据共享

sc.setAttribute(String name, Object value);//数据存储
sc.getAttribute("str") //数据获取,返回的是Object类型

注意：
	不同的用户可以给ServletContext对象进行数据的存取。
	获取的数据不存在返回null。
获取项目中web.xml文件中的全局配置数据

sc.getInitParameter(String name); 根据键的名字返回web.xml中配置的全局数据的值，返回String类型。
 								 如果数据不存在返回null。
sc.getInitParameterNames();返回键名的枚举
配置方式
	一组<context-param>标签只能存储一组键值对数据，多组可以声明多个进行存储。<context-param>
    <param-name>name</param-name>
    	<param-value>zhangsan</param-value>
    </context-param>

作用：将静态数据和代码进行解耦。
获取项目webroot下的资源的绝对路径。获取的路径为项目根目录，path参数为项目根目录中的路径

String path=sc.getRealPath(String path);

获取webroot下的资源的流对象

InputStream is = sc.getResourceAsStream(String path);

注意：此种方式只能获取项目根目录下的资源流对象，class文件的流对象需要使用类加载器获取。path参数为项目根目录中的路径

JSP

1、JSP概述

​ JSP全名为Java Server Pages，中文名叫java服务器页面，其根本是一个简化的Servlet设计，它 是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML(标准通用标记语言的子集)文件(.htm,.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件，后缀名为(*.jsp)。 用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。

常见的动态网页技术：JSP,ASP,PHP

jsp的应用服务器有：tomcat,jboss ,weblogic websphere等

1-1、特点

​ 本质上还是 Servlet
​ 跨平台，一次编写处处运行
​ 组件跨平台
​ 健壮性和安全性

静态网页与动态网页的区别
​ 静态网页只能完成网站的基本结构，不能与用户交互，不能实时根据数据库中的记录更新;
​ 动态的网页技术可以与用户交互，能实时更新的

1-2、URL

http:// localhost : 8080/   news/index.jsp
  协议   主机地址    端口号  项目地址

1-3、执行过程

	翻译阶段----------->编译阶段--->运行阶段
.jsp--->.java(servlet)--->.class------>.html

2、jsp页面的组成

a1.指令部分：page指令，include指令，taglib指令
a2.html的模板元素(html的标签，css样式，js脚本)
a3.小脚本 <% 纯java代码 %>
a4.表达式 <%=表达式 %>表示在网页上输出，相当于java中的System.out.print()或html中的document.write();
a5.声明 <%! 声明全部变量和方法%> 已淘汰了
a6.注释部分
​ b1.html的注释也叫显示注释,服务器会运行这种注释
​ b2.jsp的注释，用来注释jsp的元素如小脚本 ,也叫隐式注释 <%-- jsp的注释,服务器不会运行 --%>
​ b3.java代码的注释 //单行或多行注释

2-1、Jsp的page指令

​ <%@page 属性名=“属性值” 属性名=“属性值”…%>
​ language：声明jsp要被转译的语言。
​ import：声明转译的java文件要导入的包，不同的包使用逗号隔开。
​ pageEncoding：设置jsp文件的数据编码格式。
​ contentType=“text/html; charset=utf-8” ：设置jsp数据响应给浏览器时，浏览器的解析和编码格式。
​ session：设置转译的servlet中是否开启session支持,默认开启，true表示开启。false表示关闭。
​ errorPage：设置jsp运行错误跳转的页面.
​ extends：设置jsp转译的java文件要继承的父类(包名+类名)。

​ 作用：配置jsp文件的转译相关的参数。

2-2、局部代码块

​ 特点：
​ 局部代码块中声明的java代码会被原样转译到jsp对应的servlet文件的_JspService方法中
​ 代码块中声明的变量都是局部变量。
​ 使用：<% java代码 %>
​ 缺点：使用局部代码块在jsp中进行逻辑判断，书写麻烦，阅读困难。
​ 开发：servlet进行请求逻辑处理，使用jsp进行页面展现。

2-3、全局代码块

​ 特点：
​ 声明的java代码作为全局代码转译到对应的servlet类中。
​ 使用：
​ <%! 全局代码 %>
​ 注意：
​ 全局代码块声明的代码，需要使用局部代码块调用。

2-4、脚本段

​ 特点：帮助我们快速的获取变量或者方法的返回值作为数据响应给浏览器。
​ 使用：<%=变量名或者方法%>
​ 注意：不要在变量名或者方法后使用分号。
​ 位置：除jsp语法要求以外的任意位置。

3、使用

3-1、静态引入

<%@include file="要引入的jsp文件的相对路径" %>

​ 特点：会将引入的jsp文件和当前jsp文件转译成一个java(Servlet)文件使用。在网页中显示合并后的显示效果。

​ 注意：静态引入的jsp文件不会单独转译成java(Servlet)文件。当前文件和静态引入的jsp文件中不能够使用java代码块声明同名变量。

3-2、动态引入

<jsp:include page="要引入的jsp文件的相对路径"></jsp:include>

​ 特点：会将引入的jsp文件单独转译，在当前文件转译好的java文件中调用引入的jsp文件的转译文件。在网页中显示合并后的显示效果。

​ 注意：动态引入允许文件中声明同名变量。

3-3、jsp的转发标签forward

​ 优点：降低jsp代码的冗余，便于维护升级。 ​

<jsp:forward page="要转发的jsp文件的相对路径"></jsp:forward>

​ 特点：一次请求，地址栏信息不改变。

​ 注意：在转发标签的两个标签中间除了写<jsp:param name=“str” value=“aaa” />子标签不会报错，其他任意字符都会报错。

<jsp:forward page="要转发的jsp文件的相对路径">
    <jsp:param name="str" value="aaa" />
            name属性为附带的数据的键名
            value为附带的数据内容
</jsp:forward>

​ 注意：会将数据以？的形式拼接在转发路径的后面。

3-4、JSP路径

相对路径
​ 问题一：资源的位置不可随意更改。
​ 问题二：需要使用 …/ 进行文件夹的跳出。使用比较麻烦。
绝对路径
​ /虚拟项目名/项目资源路径

<a href="/jsp/jspPro.jsp">jspPro.jsp</a>
<a href="/jsp/a/a.jsp">a.jsp</a>
		注意：在jsp中资源的第一个/表示的是服务器根目录，相当于:localhost:8080
使用jsp中自带的全局路径声明：
<%
	String path = request.getContextPath();
	String basePath = 	request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
			<base href="<%=basePath%>">
作用：给资源前面添加项目路径：http://127.0.0.1:8080/虚拟项目名/	

4、内置对象

​ jsp文件在转译成其对应的Servlet文件的时候自动生成的并声明的对象。我们在jsp页面中直接使用即可。

​ 注意：内置对象在jsp页面中使用，使用局部代码块或者脚本段语句来使用。不能够在全局代码块中使用。

4-1、九大内置对象

pageContext:页面上下文对象，封存了其他内置对象。封存了当前jsp的运行信息。
    注意：每个Jsp文件单独拥有一个pageContext对象。
    作用域：当前页面。
request：封存当前请求数据的对象。由tomcat服务器创建。一次请求
session:此对象用来存储用户的不同请求的共享数据的。一次会话
application：ServletContext对象，一个项目只有一个。存储用户共享数据的对象，以及完成其他操作。
response:响应对象，用来响应请求处理结果给浏览器的对象。设置响应头，重定向。
out:响应对象，Jsp内部使用。带有缓冲区的响应对象，效率高于response对象。
page:代表当前Jsp的对象。相当于java中的this。
exception：异常对象。存储了当前运行的异常信息。
    注意：使用此对象需要在page指定中使用属性isErrorPage="true"开启。
config：也就是ServletConfig，主要是用来获取web.xml中的配置数据，完成一些初始化数据的读取。

4-2、四个作用域对象

pageContext:当前页面.解决了在当前页面内的数据共享问题。获取其他内置对象。
request:一次请求。一次请求的servlet的数据共享。通过请求转发，将数据流转给下一个servlet。
session:一次会话.一个用户的不同请求的数据共享。将数据从一次请求流转给其他请求。
application:项目内.不同用户的数据共享问题。将数据从一个用户流转给其他用户。

作用：数据流转
	
a1. page范围:指的是将数据保存在当前页面中
    pageContext.setAttribute(key,value); //保存数据
    pageContext.getAttribute(key); //取数据
    pageContext.removeAttribute(key); //根据key移除数据

a2. request范围
    request.setAttribute(key,value); //保存数据
    request.getAttribute(key); //取数据
    request.removeAttribute(key); //根据key移除数据    

a3. session范围
    session.setAttribute(key,value); //保存数据
    session.getAttribute(key); //取数据
    session.removeAttribute(key); //根据key移除数据  
a4. application范围
    application.setAttribute(key,value); //保存数据
    application.getAttribute(key); //取数据
    application.removeAttribute(key); //根据key移除数据 

使用频率由高到低：request > session > application > pageContext

JavaBean

1、JavaBean

1-1、JavaBean介绍

其实就是一个普通的Java类，遵循以下规则成为JavaBean

​ 1、必须要有无参构造方法
​ 2、类的属性私有化（外部不能直接访问属性）private
​ 3、对外提供共有的getter和setter方法（通过方法操作属性）

使用场景

​ 1、项目的实体类符合JavaBean
​ 2、EL表达式，访问对象的属性${student.name} 原理调用getName()方法
​ 3、自定义标签处理，给属性赋值 setName(String name)

作用

​ 用于封装业务的数据

1-2、JavaBean的属性

​ a1、JavaBean的属性可以是任意类型，并且一个JavaBean可以有多个属性。
​ a2、每个属性通常都需要具有相应的setter、 getter方法，setter方法称为属性修改器，getter方法称为属性访问器。
​ a3、属性修改器必须以小写的set前缀开始，后跟属性名，且属性名的第一个字母要改为大写。
​ 例如，name属性的修改器名称为setName，password属性的修改器名称为setPassword。
​ a4、属性访问器通常以小写的get前缀开始，后跟属性名，且属性名的第一个字母也要改为大写。
​ 例如，name属性的访问器名称为getName，password属性的访问器名称为getPassword。
​ a5、一个JavaBean的某个属性也可以只有set方法或get方法，这样的属性通常也称之为只写、只读属性。

​ 注意：isText() 是获取boolean 类型的值 同样是符合JavaBean

2、JSP、JavaBean（了解）

2-1、<jsp:useBean>标签

​ <jsp:useBean>标签用于在指定的域范围内查找指定名称的JavaBean对象，如果存在则直接返回该JavaBean对象的引用，如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。

  <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  <%--
  在jsp中使用jsp:useBean标签来实例化一个Java类的对象
  <jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
      ┝<jsp:useBean>：表示在JSP中要使用JavaBean。
      ┝id:表示生成的实例化对象，凡是在标签中看见了id，则肯定表示一个实例对象。
      ┝class：此对象对应的包.类名称
      ┝scope：此javaBean的保存范围，四种范围：page、request、session、application
  --%>
 -------------------------------------------------------------------------------------------------- 
 <jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>	//创建bean对象
 --------------------------------------------------------------------------------------------------
 <%
     //person对象在上面已经使用jsp:useBean标签实例化了，因此在这里可以直接使用person对象
     //使用setXxx方法为对象的属性赋值
     //为person对象的name属性赋值
     person.setName("孤傲苍狼");
     //为person对象的Sex属性赋值
     person.setSex("男");
     //为person对象的Age属性赋值
     person.setAge(24);
     //为person对象的married属性赋值
     person.setMarried(false);
 %>
 --------------------------------------------------------------------------------------------------
 <!DOCTYPE HTML>
 <html>
     <head>
     	<title>jsp:useBean标签使用范例</title>
     </head>
    <body>
        <%--使用getXxx()方法获取对象的属性值 --%>
        <h2>姓名：<%=person.getName()%></h2>
        <h2>性别：<%=person.getSex()%></h2>
        <h2>年龄：<%=person.getAge()%></h2>
        <h2>已婚：<%=person.isMarried()%></h2>
    </body>
</html>

<jsp:useBean>标签的执行原理：

​ 首先在指定的域范围内查找指定名称的JavaBean对象，如果存在则直接返回该JavaBean对象的引用，如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。

//编译后的Java代码
gacl.javabean.study.Person person = null;
       synchronized (_jspx_page_context) {
         person = (gacl.javabean.study.Person) _jspx_page_context.getAttribute("person", PageContext.PAGE_SCOPE);
         if (person == null){
           person = new gacl.javabean.study.Person();
           _jspx_page_context.setAttribute("person", person, PageContext.PAGE_SCOPE);
         }
       }

2-2、<jsp:setProperty>标签

​ <jsp:setProperty>标签用于设置和访问JavaBean对象的属性。

​ 语法：

语法格式一：	
	<jsp:setProperty name="beanName" property="propertyName" value="string字符串"/>
语法格式二：
	<jsp:setProperty name="beanName" property="propertyName" value="<%= expression %>" />
语法格式三：
	<jsp:setProperty name="beanName" property="propertyName" param="parameterName"/>
语法格式四：
	<jsp:setProperty name="beanName" property= "\*" />
	
name：用于指定JavaBean对象的名称。 
property：用于指定JavaBean实例对象的属性名。
value：用于指定JavaBean对象的某个属性的值，value的值可以是字符串，也可以是表达式。为字符串时，该值会自动转化为JavaBean属性相应的类型，如果value的值是一个表达式，那么该表达式的计算结果必须与所要设置的JavaBean属性的类型一致。   
param：用于将JavaBean实例对象的某个属性值设置为一个请求参数值，该属性值同样会自动转换成要设置的JavaBean属性的类型。

注意：
    jsp:setProperty在设置对象的属性值时会自动把【字符串】转换成8种基本数据类型
    但是jsp:setProperty对于复合数据类型无法自动转换
    birthday属性是一个Date类型，这个属于复合数据类型，因此无法将字符串自动转换成Date 
   		<jsp:setProperty property="birthday" name="person" value="1988-05-07"/>--会报错

​ 使用：

<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>	//创建bean实例
---------------------------------------------------------------------------------------------------
1、jsp:setProperty标签设置person对象的属性值：
	<jsp:setProperty property="name" name="person" value="白虎神皇"/>
	<jsp:setProperty property="sex" name="person" value="男"/>
	<jsp:setProperty property="age" name="person" value="24"/>
	<jsp:setProperty property="married" name="person" value="false"/>
	<jsp:setProperty property="birthday" name="person" value="<%=new Date()%>"/>

 2、jsp:setProperty标签可以使用请求参数为bean的属性赋值：
 	<jsp:setProperty property="name" name="person" param="param_name"/>
	param="param_name"用于接收参数名为param_name的参数值，然后将接收到的值赋给name属性

3、jsp:setProperty标签用所有的请求参数为bean的属性赋值
	<jsp:setProperty property="*" name="person"/>
	property="*"代表bean的所有属性

2-3、<jsp:getProperty>标签

​ <jsp:getProperty>标签用于读取JavaBean对象的属性，也就是调用JavaBean对象的getter方法，然后将读取的属性值转换成字符串后插入进输出的响应正文中。

​ 语法：

<jsp:getProperty name="beanInstanceName" property="PropertyName" />
    name属性用于指定JavaBean实例对象的名称，其值应与<jsp:useBean>标签的id属性值相同。
    property属性用于指定JavaBean实例对象的属性名。
    如果一个JavaBean实例对象的某个属性的值为null，那么，使用<jsp:getProperty>标签输出该属性的结果将是一个内容为“null”的字符串。

​ 使用：

<html>
    <head>
    	<title>jsp:getProperty标签使用范例</title>
    </head>
    <body>
        <%--使用jsp:getProperty标签获取对象的属性值 --%>
        <h2>姓名：<jsp:getProperty property="name" name="person"/></h2>
        <h2>性别：<jsp:getProperty property="sex" name="person"/></h2>
        <h2>年龄：<jsp:getProperty property="age" name="person"/></h2>
        <h2>已婚：<jsp:getProperty property="married" name="person"/></h2>
        <h2>出生日期：<jsp:getProperty property="birthday" name="person"/></h2>
    </body>
</html>

EL、JSTL

1、EL表达式

1-1、传统方式

<b><%=request.getParameter("uname")%></b><br />
<b><%=request.getAttribute("str") %></b><br />
<b><%=((User)request.getAttribute("user")).getAddr().getTown() %></b><br />
<b><%=((ArrayList)request.getAttribute("list")).get(2)%></b><br />
<b><%=((User)(((ArrayList)request.getAttribute("list2")).get(0))).getAddr().getPre() %></b><br />
<b><%=((HashMap)request.getAttribute("map")).get("c") %></b><br />
<b><%=((User)(((HashMap)request.getAttribute("map2")).get("a1"))).getAddr().getCity() %></b><br />

​ 缺点：需要导包，需要强转，获取数据代码过于麻烦

1-2、EL表达式

​ 语法：${表达式}

​ 作用：获取作用域对象中的数据。

​ 注意：获取的是pageContext、request、session、application四个对象中的数据，其他数据一概不理会。找到了则获取返回，找不到则什么都不做，也不报错。

1、获取请求数据（request对象）
    {param.键名}		返回值
    {paramvalues.键名}		返回的是数组
2、通过setAttribute方法存储到作用域对象中的数据
	{键名} 返回键名所对应的值。
	普通字符串则直接返回
3、获取对象中的数据：
	普通对象：{键名.属性名.属性名....}
	集合对象：list集合--->{键名[角标]}
			map集合--->{键名.map集合存储的键名}	

​ 如：

使用EL表达式获取作用域对象数据
    <b>${param.uname}</b><br />
    <b>${paramValues.fav[0]}</b><br />
    <b>${str}</b><br />
    <b>${user}</b><br />
    <b>${list[2]}</b><br />
    <b>${list2[0].addr.pre}</b><br />
    <b>${map.c}</b><br />
    <b>${map2.a1.addr.city}</b><br />

1-3、作用域

​ 作用域查找顺序：
​ pageConext—request—session—application
​ （每次查找都是从小到大进行查找，找到了则获取，不再继续找）
​ 指定作用域查找：
​ ${pageScope.键名}
​ ${requestScope.键名}
​ ${sessionScope.键名}
​ ${applicationScope.键名}

pageContext.setAttribute("hello","hello pageContext");
request.setAttribute("hello","hello request");
session.setAttribute("hello","hello session");
application.setAttribute("hello","hello application");

${pageScope.hello}---${requestScope.hello}--${sessionScope.hello}--${applicationScope.hello}

1-4、逻辑运算

​ ${逻辑表达式}：&& || !

​ ${算术表达式}：+，-，*，/

​ ${关系表达式}：>,<,>=,==,!=,%
​ 特殊:三目运算

​ 注意： + 表示加法运算，不表示字符链接。使用EL表达式进行字符链接会报错。EL表达式的逻辑运算

${1+2}--${1*2}--${4/2}--${4-2}--${4%3}--${4==4}--${4>2}--${sex==1?'男':'女'}--${1+'2'}

1-5、空值判断

​ ${empty 键名}
​ 作用：判断键名对象的值是否存有数据。

${empty s}--${empty s1}--${empty s2}---${empty s3}

1-6、获取请求头和cookie

​ 获取请求头数据

${header}-->返回所有的请求头数据
${header["键名"]}--->返回指定的键名的请求头数据
${hedaerValues["键名"]}--->返回指定的键名(同键不同值)的值的数组。

​ 获取Cookie数据

${cookie}--->返回存储了所有的cookie对象的map集合
${cookie.键名}---->返回指定的cookie对象
${cookie.键名.name}--->返回指定的cookie对象存储的数据的键名。
${cookie.键名.value}--->返回指定的cookie对象存储的数据的值。		

​ 例：

${header}--${headerValues["accept-language"][0]} <br /><br /><br />
${cookie}--${cookie.JSESSIONID}---${cookie.JSESSIONID.name}--${cookie.JSESSIONID.value}

1-7、隐含对象

隐含对象	描述
pageScope	page 作用域
requestScope	request 作用域
sessionScope	session 作用域
applicationScope	application 作用域
param	Request 对象的参数，字符串
paramValues	Request对象的参数，字符串集合
header	HTTP 信息头，字符串
headerValues	HTTP 信息头，字符串集合
initParam	上下文初始化参数
cookie	Cookie值
pageContext	当前页面的pageContext

2、JSTL

作用：提高在jsp中的逻辑代码的编写效率，使用标签。

2-1、核心标签库（core）

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>		<!--导入core核心jar包-->

2-1-1、基本标签

<c:out value="数据" default="默认值"></c:out>
	作用：将数据输出给客户端。
		数据可以为常量值也可以是EL表达式。
<c:set var="hello" value="hello pageContext" scope="page"></c:set>
	作用：存储数据到作用域对象中
		var：表示存储的键名
		value：表示存储的数据
		scope：表示要存储的作用域对象 page request session application
<c:remove var="hello" scope="page"/>
	作用：删除作用域中的指定键的数据。
		var：表示要删除的键的名字
		scope：表示要删除的作用域（可选）
		
注意：如果在不指定作用域的情况使用该标签删除数据，会将四个作用域对象中的符合要求的数据全部删除。

<h3>基本标签学习</h3>
<c:out value="哈哈"></c:out>---哈哈--${str2}<br />
<c:out value="${str2}" default="嘿嘿"></c:out><br />
<c:set var="hello" value="hello pageContext" scope="page"></c:set><br />
<c:set var="hello" value="hello request" scope="request"></c:set><br />
<c:set var="hello" value="hello session" scope="session"></c:set><br />
<c:set var="hello" value="hello application" scope="application"></c:set><br />
<%-- <c:out value="${applicationScope.hello}"></c:out> --%>
<c:remove var="hello" scope="page"/><br />
<c:out value="${hello}"></c:out>
<hr />			

2-1-2、逻辑标签

<c:if>

<c:if test="${表达式}">
	前端代码
</c:if>

作用：进行逻辑判断，相当于java代码的单分支判断。
注意：逻辑判断标签需要依赖于EL的逻辑运算，也就是表达式中涉及到的数据必须从作用域中获取。
---------------------------------------------------------------------------------------------------
<c:set var="a" value="4"></c:set>
<c:if test="${a>3}">
	<b>今天的天气有点热哦</b>
</c:if>

<c:choose>

<c:choose>
    <c:when test="">执行内容</c:when>
    <c:when test="">执行内容</c:when>
    ...
	<c:otherwise>执行内容</c:otherwise>
</c:choose>

作用：用来进行多条件的逻辑判断，类似java中的多分支语句
注意：条件成立只会执行一次，都不成立则执行otherwise
---------------------------------------------------------------------------------------------------
<c:set var="score" value="68"></c:set>
<c:choose>
	<c:when test="${score>=90}">
		<i>奖励吃鸡装配一套</i>
	</c:when>
	<c:when test="${score<90&&score>=80}">
		<i>奖励空投箱</i>
	</c:when>
	<c:when test="${score<80&&score>=70}">
		<i>无奖励无惩罚</i>
	</c:when>
	<c:otherwise>
		<i>男女混合双打</i>
	</c:otherwise>
</c:choose>

<c:foreach>

<c:forEach begin="1" end="4" step="2">
    循环体
</c:forEach>

    begin:声明循环开始位置
    end:声明循环结束位置
    step：设置步长
    varStatus:声明变量记录每次循环的数据(角标，次数，是否是第一次循环，是否是最后一次循环)
    items:声明要遍历的对象。结合EL表达式获取对象
    var:声明变量记录每次循环的结果。存储在作用域中，需要使用EL表达式获取。
    
作用：循环内容进行处理    
注意:数据存储在作用域中，需要使用EL表达式获取。
	例如：${vs.index}--${vs.count}--${vs.first}--${vs.last}
---------------------------------------------------------------------------------------------------
<!--1、常量循环  -->
    <c:forEach begin="0" end="4" step="1" varStatus="vs">
        1111---${vs.index}--${vs.count}--${vs.first}--${vs.last}<br />
    </c:forEach>
    
<!--2、动态循环  -->
    <c:forEach items="${list}" var="str">
        ${str}<br />
    </c:forEach>
    
<!--3、创建表格数据  -->
    <table border="1px">
        <tr>
            <td>课程名称</td>
            <td>教师</td>
            <td>价格</td>
            <td>重要性</td>
        </tr>
        <c:forEach items="${list}" var="s">
            <tr>
                <td>${s}</td>
                <td>${s}</td>
                <td>${s}</td>
                <td>${s}</td>
            </tr>
        </c:forEach>
    </table>
    
<!--5、遍历map集合  -->
    <c:forEach items="${map}" var="m">
        ${m.key}--${m.value} <br />
    </c:forEach>

2-2、格式化标签库

2-3、SQL标签库

2-4、函数标签库

2-5、XML标签库

Filter

作用：对服务器接受的请求资源和响应给浏览器的资源进行管理。保护servlet

使用：创建一个实现了Filter接口的普通java类

​ 覆写接口的方法

init方法:服务器启动即执行。资源初始化
doFilter方法:拦截请求的方法，在此方法中可以对资源实现管理。
	注意：需要手动对请求进行放行。chain.doFilter(request, response);
destory方法：服务器关闭执行。

​ 在web.xml中配置过滤器

<filter>
    <filter-name>myFilter</filter-name>
    <filter-class>com.bjsxt.filter.MyFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>myFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

    url-pattern:/*
        表示拦截所有的请求。
    url-pattern:*.do
        表示所有以.do结尾的请求。一般是用来进行模块拦截处理。
    url-pattern:/ts
        表示拦截指定url的请求。针对某个servlet的请求进行拦截，保护servlet。

生命周期：
​ 服务器启动到服务器关闭。
总结:
​ 过滤器程序员声明和配置，服务器根据请求中的uri信息调用。
执行:
​ 浏览器发起请求到服务器，服务器接收到请求后，根据URI信息在web.xml中找到对应的
​ 过滤器执行doFilter方法，该方法对此次请求进行处理后如果符合要求则放行，放行后
​ 如果还有符合要求的过滤则继续进行过滤，找到执行对应的servlet进行请求处理。servlet对
​ 请求处理完毕后，也就service方法结束了。还需继续返回相应的doFilter方法继续执行。

案例：
​ 统一编码格式设置。
​ session管理
​ 权限管理
​ 资源管理（统一水印，和谐词汇等等）

Listener

1、 什么是web监听器

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

​ 监听对象：

ServletContext：application，整个应用只存在一个

HttpSession：session，针对每一个对话

ServletRequest：request，针对每一个客户请求

​ 监听内容：创建、销毁、属性改变事件

​ 监听作用：可以在事件发生前、发生后进行一些处理，一般可以用来统计在线人数和在线用户、统计网站访问量、系统启动时初始化信息等。

2 、用途

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

统计在线人数，利用HttpSessionLisener

加载初始化信息：利用ServletContextListener

统计网站访问量

实现访问监控

3、监听器分类

​ 根据三个域对象上的具体操作，将监听器划分为三类
a1.监听三个域对象的创建和销毁事件的监听器
a2.监听域对象中属性的增加、删除、替换事件的监听器
a3.监听绑定到HttpSession域中的某个对象的状态的监听器，又称为感知型监听器

4、接口与方法

监听对象	监听接口	监听事件
ServletRequest	ServletRequestListener ServletRequestAttributeListener	ServletRequestEvent ServletRequestAttributeEvent
HttpServlet	HttpSessionListener HttpSessionActivationListener HttpSessionAttributeListener HttpSessionBindingListener	HttpSessionEvent HttpSessionBindingEvent
ServletContext	ServletContextListener ServletContextAttributeListener	ServletContextEvent ServletContextAttributeEvent

ServletContextListener	：	在Servlet上下文对象初始化或销毁时得到通知
ServletContextAttributeListener		：	在Servlet上下文中的属性列表发生变化时得到通知
HttpSessionListener	：	在session创建后或者失效前得到通知
HttpSessionActivationListener	：	绑定到session中，当session被钝化或者激活时得到通知
HttpSessionAttributeListener	：	在session中的属性列表发生变化时得到通知
HttpSessionBindingListener	：	在绑定session或从session中删除时会得到通知
ServletRequestListener	：	在请求对象初始化时或者被销毁时得到通知
ServletRequestAttributeListener	：	在请求对象中的属性列表发生变化时得到通知

5、监听器配置

​ a1.使用注解 @WebListener
​ a2.使用web.xml中

<listener>
	<listener-class>com.zhiling.listener.SessionAttributeListener</listener-class>
</listener>
<context-param>
    <param-name>str</param-name>
    <param-value>Hello world</param-value>
</context-param>

AJAX

异步刷新的技术

作用

a1.提高用户的体验，在不刷新页面的情况下，加载页面内容,只刷新局部页面的内容
a2.有效利用带宽，减轻服务器的压力

与传统差异
a1.请求提交的方式不同:传统方式是浏览器同步提交请求，而ajax使用异步引擎对象提交请求
a2.服务器响应不同:传统方式响应内容是一个完整页面；而ajax响应的是局部数据
a3.客户端处理方式不同:需等待服务器响应完成并重新加载整个页面后用户才能进行操作; ajax不需要等待，服务器什么时候响应完数据，什么时候更新页面

Ajax包括的技术：

ajax异步引擎对象：XMLHttpRequest
js,jQuery,css,html
json数据格式

XMLHttpRequest对象
常用的方法

open(); 与服务器建立连接
setRequestHeader(); //设请求头信息
send(); //发送请求

常用的事件

onreadystatechange=回调函数

常用属性：

readystate:就绪状态：为4
status:200 
responseText; 响应的文本

原生Ajax实现异步请求的步骤：

得到XMLHttpRequest
设置回调函数编写回调函数更新页面局部内容
使用open()与服务器建立连接
设置请求头信息(只是post提交请求才需要此步，get无须设请求头信息)
用send()发送请求

2、jQuery—ajax

2-1、$.ajax()

$.ajax({
    url:"",		//发送请求的地址
    method:"POST|GET",	//HTTP请求方式
    async:"true|false",  //是否异步，默认为true异步
    contentType"application/x-www-form-urlencoded; charset=UTF-8",		//数据编码格式
    data:{name:xiaoming,age:13}|{"name":name,"age":age},	//提交的数据
    dataType:"",	//返回数据类型 xml,json,script,html,text
    success:function(data){
        alert(data);
    },	//成功回调函数 data接收到的数据
})；

$.ajax({
    url:"",		//发送请求的地址
    method:"POST|GET",	//HTTP请求方式
    async:"true|false",  //是否异步，默认为true异步
    contentType"application/x-www-form-urlencoded; charset=UTF-8",		//数据编码格式
    data:{name:xiaoming,age:13}|{"name":name,"age":age},	//提交的数据
    dataType:"json",	//返回数据类型 xml,json,script,html,text
}).done(function(data){
	//若之前没有指定返回数据解析方式，使用下面方法转换成json对象
	var json = JSON.parse(data);
    alert(data);	//成功响应回调函数
})；

2-2、$.post()

$.post(
	//请求发送地址
		"url",
    //提交的数据
		{name:"xiaoming",age:13},	
	//回调函数
		function(data){
       		alert(data);	
		},
	//返回数据解析类型
		"json"|"text"
)

2-3、$.get()

$.get(
	//请求发送地址
		"url",
    //提交的数据
		{name:"xiaoming",age:13},	
	//回调函数
		function(data){
       		alert(data);	//返回类型为json则是object 若是text则原样输出字符串
		},
	//返回数据解析类型
		"json"|"text"
)

2-4、$getJSON

2-5、$.load()

3、JSON

一种客户端与服务器端进行数据交换的数据格式

var 变量名={key:value,key2:value,....}

a1.定义一个JSON的对象：
	例：var person = {"name":"兰海昊","sex":"男","age":20};
a2.定义一个JSON的数组
	例：var country=["中国","日本","美国"];
a3.定义一个对象数组
	var stuArray = [{"name":"兰海昊","sex":"男","age":20},{"name":"陈汉","sex":"男","age":21},{"name":"刘丹","sex":"女","age":22}];

JSONObject 常用的方法：

fromObject(Object);  //将java对象转成json的对象
toBean(JSONObject); //将json的对象转成java对象
Map<Integer,Student> stuMap = new HashMap<Integer,Student>();
stuMap.put(100,new Student(100,"张三","男"));
stuMap.put(101,new Student(101,"张a三","男"));
stuMap.put(102,new Student(102,"张dsf三","男"));
new gson().toJSON(map)	

JS 对象(Object)和字符串(String)互转方法

利用原生JSON对象，将对象转为字符串

// 字符串转化为 对象
var jsonString = '[{"name":"天鸽"},{"name":"梅花"},{"name":"台风"}]';

// console.log(JSON.parse(jsonString));
var jsArr = JSON.parse(jsonString);

jsArr.push({"name":"帕卡"});

console.log(jsArr);

// 把js对象 数组 转化为 JSON格式的字符串
var result = JSON.stringify(jsArr);

console.log(result);

软件开发流程

可行性分析 软件销售，架构师，产品经理，UI设计
​ ｜
​ 需求分析 需求规格说明书.doc---->产品经理，系统分析师，架构师，项目经理
​ ｜
​ 概要设计 概要设计文档.doc—>>产品经理，系统分析师，架构师，项目经理
​ ｜ UI
​ 详细设计 详细设计说明书.doc—>项目经理
​ 数据库设计文档.doc----->DBA
​ 项目原型 ------>前端开发工程师
​ 项目推进计划------->项目经理
​ ｜
​ 编码 开发人员
​ ｜
​ 测试 冒烟测试------>软件测试
​ 项目上线---->软件实施
​ ｜
​ 维护