Java EE笔记

Jave EE

Tomcat配置idea

如何在 IDEA 中创建并部署 JavaWeb 程序 (baidu.com)

服务器组件Servlet

快速入门

1. 创建一个java ee项目

2. 在src中创建一个类并且实现Servlet接口

3. 实现接口中的抽象方法

4. 配置Servlet

在web.xml文件中的web-app标签中写入：

<servlet>

	<!--自定义，一般为类名-->
	<servlet-name>demo1</servlet-name>

	<!--一定是package + .类名，项目中定位该servlet的完整路径。-->
	<servlet-class>tom</servlet-class>  

</servlet>

<!--给Servlet提供（映射)一个可供客户端访问的URI,浏览器访问该servlet要访问的url定义-->  
<servlet-mapping>

	<!--和servlet中的name必须相同-->  
	<servlet-name>demo1</servlet-name>

	<!-- servlet的映射路径 客户端访问url -->  
	<url-pattern>/demo1</url-pattern>  
	
</servlet-mapping>

执行原理：

1.当服务器接收到客户端浏览器的请求后，会解析url路径，获取访问的Servlet的路径

2.查找web.xml中是否有对应的<url-pattern>标签内容

3.如果有则会找到对应的<servlet-class>全类名

4.Tomcat会将字节码文件加载进内存，创建类名的实例化对象

5.调用其方法

设置默认打开的页面

在web.xml文件中

<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>

Servlet的生命周期

1.被创建（加载资源）

public void init() {
/*初始化方法，在Servlet创建时执行只会执行一次*/

}

设置什么时候被创建

指定Servlet的创建时机，在web.xml文件的Servlet下创建
1.第一次被访问时创建：<load-on-startup>的值为负数
2.在服务器启动时创建：<load-on-startup>的值为0或者正整数

2.提供服务

public void service() {

System.out.println(“hello service”);
/*提供服务的方法，每一次Servlet被访问时会执行，可执行多次*/
}

3.被销毁

public void destroy() {
/*销毁方法，在Servlet正常关闭时执行*/

}

在Servlet被销毁之前执行，一般用于释放资源

Servlet注解配置

@WebServlet(urlPatterns = “/demo2”)

Servlet体系结构

Servlet—接口

|

GenericServlet—抽象类

| 里面只有一个service方法（将其他的方法做了默认空实现）

HttpServlet—抽象类

| 定义类继承HttpServlet

重写doGet/doPost方法，用来获取方法的

request和response原理

1. tomcat服务器会根据请求url中的资源路径，创建对应的ServletDemo1的对象

2. tomcat服务器会创建request和response两个对象，request

3. tomcat将request和response两个对象传递给service方法，并且调用service

4. 我们就可以通过request对象获取请求消息数据，通过response设置响应消息数据

5. 服务器再给浏览器作出响应之前会从response对象中拿取我们设置的响应消息数据

request功能

1. 获取请求行数据

GET/JavaWeb_war_exploded/s3?name=zs&age=19&xuehao=218&class=A2&zhuany=java HTTP/1.1

方法

1. 获取请求方式：GET

request.getMethod()

2. 获取虚拟目录：/JavaWeb_war_exploded

request.getContextPath()

3. 获取Servle路径：/s3

request.getServletPath()

4. 获取get方式请求参数：name=zs&age=19&xuehao=218

request.getQueryString()

5. 获取请求url：

request.getRequest URI() : /JavaWeb_war_exploded/s3

request.getRequestURL(): http://localhost/JavaWeb_war_exploded/s3

6. 获取协议及版本：HTTP/1.1

request.rotocol()

7. 获取客户机的IP地址：

request.getRemoteAddr()

8. 获取指定键的值

String age=req.getParameter(“age”);

1. 获取请求头数据

1. .getHeader() 通过请求头的名称获取请求头的值

2. Enumeration<String> getHeaderNames() 获取所有的请求头名称

1. 获取请求体数据

请求体：只有post请求方式，才有请求体，在请求体中封装了post请求的请求参数

1. 获取流对象

.getReader():获取字符输入流，只能操作字符数据

.getInputStream():获取字节输入流，可以操作所有类型数据

1. 通用方法

1. 获取请求参数通用方法

2.解决中文乱码问题

resp.setCharacterEncoding(“utf-8”);

resp.setHeader(“content-type”,”text/html;charset=utf-8”);

3. 请求转发：用来跳转页面

req.getRequestDispatcher(“/s2”).forward(req,resp);

注：跳转到名为/s2的页面

特点：浏览器地址栏路径不变

只能转到当前服务器内部资源

转发是一次请求

1. 共享数据

在转发之前存储数据：request.setAttribute(“msg”,”helloworld”)

在被转发的页面中写上：request.getAttribute(“msg”)即可得到helloworld

response功能

1. 设置响应行

1. 格式：HTTP/1.1 200 ok

2. 设置状态码：setStatus(src)

2. 设置响应头

setHeader(name,value)

3. 设置响应体

1.获取输出流

字节输出流：PrintWriter getWriter()

字节输出流：ServletOutputStream getOutputStream()

4. 重定向

resp.sendRedirect(“http://www.baidu.com" );

会话技术

会话：一次会话中包含多次请求和响应

一次会话：浏览器第一次给服务器资源发送请求，会话建立，直到一方断开

功能：在一次会话的范围内的多次请求间共享数据

方法：

1. 客户端会话技术：Cookie

概念：客户端会话技术，将数据保存到客户端

快速入门：

1. 创建Cookie对象，绑定数据

Cookie c=new Cookie(“msg”,”张三”);

2. 发送Cookie对象

resp.addCookie(c);

3. 获取Cookie拿到数据

Cookie [] co= req.getCookies();

if(co!=null){  
	for (Cookie cookie : co) {  
		String name=cookie.getName();  
		String value= cookie.getValue();  
		System.*out*.println(name+":"+value);  
	}  
}

Cookie的细节：

1. 发送多个cookie

只需要创建多个cookie对象，使用response调用多次addCookie方法发送cookie

2. Cookie存活时间

c.setMaxAge(30);
// 正数：永久化存储指定的秒数
// 负数：默认值
// 零：不存储cookie

3. cookie共享问题

同一个服务器下共享：

假设在一个tomcat服务器中，部署了多个项目，那么这些项目中cookie默认情况下不共享也可以通过setPath(String path)设置获取范围path设置为/

在不同的tomcat服务器中共享：

setDomain(String path)如果设置了一级域名相同，那么多个服务器之间cookie可以共享setDomain(“.baidu.com”)那么tieba.baidu.com和news.baidu.com中cookie可以共享

4. cookie作用

1. 存储一些自定义设置如设置了搜索历史关闭第二次打开设置依旧生效

2. 实现账号密码保存

服务器端会话技术：Session

概念：在一次会话中的多次请求间共享数据，将数据保存在服务器端

快速入门：

HttpSession对象： HttpSession session=req.getSession();

Object msg=session.getAttribute(String name) 获取session数据

session.setAttribute(String name,Object value) 设置

session.removeAttribute(String name) 删除

细节：

1. 当客户端关闭后，服务器不关闭，两次获取的session是否为同一个？

默认情况下，不是

如果需要相同，则可以创建Cookie，键为session名字，设置最大存活时间，让cookie持久化保存

Cookie c=new Cookie(“session”,session.getId())

c.setMaxAge(60*60)

resp.addCookie(c)

2. 客户端不关闭，服务器关闭后两次获取的session是否为同一个？

不是同一个，但是要确保数据不丢失

1. session的钝化

在服务器正常关闭之后，将session的对象序列化到硬盘上

2. session的活化

在服务器启动后，将session文件转化为内存的session对象即可

3. session什么时候被销毁

1. 服务器关闭

2. 通过方法invalidate()销毁

3. session默认30分钟自动销毁

4. session的特点

1. session用于存储一次对话的多次请求的数据，存在服务器端

2. session可以存储任意类型，任意大小的数据

3. Cookie和session的区别

session存储在服务器端，Cookie在客户端

session没有数据大小限制Cookie有

session数据安全，Cookie相对于不安全

json

概念

JavaScript object notation js对象表示法

json多用于存储和交换文本信息的语法

json语法

1. 基本规则

• 数据是键值对

• 数据由逗号分割

• 花括号保存对象

• 方括号保存数组

2. 数据类型

• 数字（整数或浮点数）

• 字符串（用双引号引起来）

• boolean值

• 数组（在方括号中）

• 对象（在花括号中）{“address”:{“province”:”山西”…}}

• null

3. 获取数据

• json对象.键名

4. json数据和java对象相互转换

java转json

// java转json对象

public String javaToJson(Bread bread){  
bread.setId("HUAWEI");  
bread.setCompany(50);  
bread.setGuanggao("用技术改变世界");  
Gson gs=new Gson();  
String str=gs.toJson(bread);  
return str;  
}

// 字符串转javabean  
Gson gson=new Gson();  
String json2="{\"id\":\"username\":\"张三\"}";  
Bread bread1=gson.fromJson(json2, Bread.class);  
System.*out*.println("id号："+bread1.getId());  
System.*out*.println("姓名："+bread1.getName());  
}

// 使用javabean输出

public String rowJson(Connection con) throws SQLException{  
PreparedStatement pr=null;  
String sql="select id,name,company,guanggao,qiyong from bread";  
pr=con.prepareStatement(sql);  
ResultSet rs=pr.executeQuery();  
Bread bread=new Bread();  

String rows="";  
rs.beforeFirst();  
int i=0;  
while (rs.next()){  
	i=i+1;  
}  
rs.beforeFirst();  
int j=1;  
while (rs.next()){  
	bread.setId(rs.getString("id"));  
	bread.setName(rs.getString("name"));  
	bread.setCompany(rs.getInt("Company"));  
	bread.setGuanggao(rs.getString("guanggao"));  
if (j!=i){  
	rows=rows+bread.toString()+",";  
}else{  
	rows=rows+bread.toString();  
}  
	j=j+1;  
}  
return "["+rows+"]";  
}

JSP

什么是jsp

jsp全名java server pages，中文名叫java服务器页面

jsp技术是在传统的网页html文件中插入java程序和jsp标记从而形成jsp文件

jsp运行机制

jsp也是一种Servlet，其java类型为HttpJSPBase

jsp不能独立运行，需要jsp引擎

jsp语法

jsp页面由数据模板和元素组成：

数据模板，jsp容器不进行处理，如jsp中的HTML内容这些内容会直接发送到客户端

jsp元素：jsp容器必须处理的部分。jsp元素有三种类型：

1. 指令元素

page指令：定义与页面相关的一些属性

<%@ page contentType=”text/html;charset=UTF-8” language=”java” %>

常见属性：

属性	说明
language=”java”	指定脚本元素中使用的脚本语言，目前只支持java
contentType=”ctinfo”	指定用于响应JSP页面的MIME类型和编码
pageEncoding=”en”	指定当前JSP页面使用的字符编码
import=”importList”	用来引入使用到的Java类
errorPage=”url”	用于当JSP页面发送异常时，转向的错误页面
isErrorPage=”true”	指定页面是否是错误处理页面，默认值为false
session=”true/false”	用于指定该JSP是否参与到会话中，默认值为true
buffer=”none/size”	用于指定out对象使用的缓冲区大小，8kb为默认值
isELIgnored=”true”	指定JSP页面是否忽略EL表达式，默认值为false

include指令：页面包含的。导入页面的资源文件

<%@include file=”top.jsp”%>

taglib指令：在JSP页面中使用第三方的标签库时，需要使用taglib指令来“导包

<%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core" %>

2. 脚本元素：jsp定义java代码的方式

<% %>定义的java代码，在service中可以定义什么，这个脚本中就能写什么

<%! %>定义的java代码，放在全局变量位置

<%= %>会输出到页面上的语句

3. jsp的内置对象

在jsp页面中不需要获取或创建就可以直接使用的对象

• request

request对象是javax.servlet.http.HttpServletRequest类的实例。每当客户端请求一个JSP页面时，JSP引擎就会制造一个新的request对象来代表这个请求。

request对象提供了一系列方法来获取HTTP头信息，cookies，HTTP方法等等

• response

response对象是javax.servlet.http.HttpServletResponse类的实例。当服务器创建request对象时会同时创建用于响应这个客户端的response对象。

response对象也定义了处理HTTP头模块的接口。通过这个对象，开发者们可以添加新的cookies，时间戳，HTTP状态码等等。

• session

session对象是javax.servlet.http.HttpSession类的实例。

session对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。session对象内部使用Map类来保存数据，因此保存数据的格式为Key/value。session对象的value可以使复杂的对象类型，而不仅仅局限于字符串类型。

• out：字符输出流对象，可以利用数据输出到页面上和response.getWrite类似

在tomcat作出响应之前，总是会先执行response.getWrite再去找out缓冲区

• application

服务器启动后就产生了这个application对象，当客户在所访问的网站的各个页面之间浏览时，这个application对象都是同一个，直到服务器关闭。但是与session不同的是，所有客户的application对象都是同一个，即所有客户共享这个内置的application对象。

2．application对象常用方法:

(1)public void setAttribute(String key,Object obj): 将参数Object指定的对象obj添加到application对象中，并为添加的对象指定一个索引关键字。

(2)public Object getAttribute(String key): 获取application对象中含有关键字的对象。

• page 对应this关键字。JSP网页本身

• config

javax.servlet. ServletConfig 的实例，该实例代表该JSP 的配置信息。常用的方法有getInitPararneter(String paramNarne) 及getInitPararneternarnes() 等方法

• exception

该实例代表其他页面中的异常和错误。只有当页面是错误处理页面，即编译指令page 的isErrorPage 属性为true 时，该对象才可以使用。常用的方法有getMessage()和printStackTrace()。

• pageContext

javax.servlet.jsp.PageContext 的实例，对象直译时可以称作“页面上下文”对象，代表的是当前页面运行的一些属性，通过此对象可以拿到其他8大对象，使用该对象可以访问页面中的共享数据。常用的方法有getServletContextO和getServletConfigO等。

//使用pageContext 设置属性，该属性默认在page 范围内

pageContext. setAttribute (“page” , “hello”) ;

//使用request 设置属性，该属性默认在request 范围内

request. setAttribute (“request” , “hello”);

//使用pageContext将属性设置在request 范围中

pageContext.setAttribute(“request2”,”hello”,pageContext.REQUEST_SCOPE);

// 使用session将属性设置在session 范围中

session.setAttribute(“session” , “hello”);

//使用pageContext将属性设置在session范围中

pageContext.setAttribute(“session2”,”hello”,pageContext.SESSION_SCOPE);

//使用application将属性设置在application范围中

application. setAttribute (“app” , “hello”) ;

//使用pageContext 将属性设置在application 范围中

pageContext.setAttribute(“app2”,”hello”,pageContext.APPL CATION_SCOPE) ;

4. 四个作用域

page，request，session，application四个对象对应作用域

*page:*表示将javabean对象存储在pageContext对象中。可以被当前jsp页面的当前请求的响应过程中调用的各个组件访问

request：表示将javabean对象存储在request对象中，可以被属于同一个请求的所有Servlet和jsp页面访问，并且保证线程安全

*session:*表示将javabean对象存储在session对象中，可以被属于同一个对话中的所有Servlet和JSP页面访问

application：表示将javabean对象存储在ServletContext对象中，可以被同一个web应用程序中的所有servlet和jsp页面访问，不同的用户在不同的jsp界面、servlet中都可以使用该javabean对象

5. jsp中的javabean

在jsp中使用javabean方式

直接在脚本元素中使用

<%

User user=new User();
user.setId(1001);
user.setUsername(“zhangsan”);
user.setPassWord(“123456”);
user.setRealName(“张三”);
%>

利用动作元素来使用

<%– 用于实例化JavaBean，或者是从指定的范围中访问一个已存在的JavaBean实例–%>

<jsp:useBean id=”user1” class=”hb.rj.bean.User” scope=”page”/>
* id：JavaBean的实例名称
* class：JavaBean的全限定名(全类名)
* type：指定脚本变量的类型，可以是该JavaBean本身、父类或者该JavaBean实现的接口
* scope：指定一个范围，在这个范围中JavaBean实例是可用的，取值可以为：page/request/session/application，默认值为page

<jsp:setProperty name=”user1” property=”id” value=”12345”/>
<jsp:setProperty name=”user1” property=”passWord” value=”8888888”/>
<jsp:setProperty name=”user1” property=”username” value=”zhangSan”/>
<jsp:setProperty name=”user1” property=”realName” value=”张三”/>

<jsp:getProperty name=”user1” property=”id” />
<jsp:getProperty name= “user1” property=”username “ />
<jsp:getProperty name= “user1” property=”password” />
<jsp:getProperty name=”user1” property=”realName” />

* name：JavaBean实例的名称，必须是在<jsp:useBean>中定义的id属性值
* property：JavaBean的属性名称
* value：属性值
* param：指定请求中的参数名。如果请求参数名和JavaBean的属性名不同时，可以使用param指定参数名。注意不能和value同时使用

EL表达式（用于简化jsp开发）

例如：获取user中的userName对象

初始写法：

<%=user.getUserName()%>

<jsp:getProperty name=”user” property=”userName”/>

EL表达式写法：

${user.userName}

1. JSP EL内置对象

在作用域相关的EL内置对象有pageScope、requestScope、sessionScope和applicationScope。利用他们来对应jsp内置对象中的page、request、session和application

例如：

sessiom.getAttribute(“username”)

在EL中可以使用：

${sessionScope.username}

2. 与输入有关的EL内置对象

param：返回一个请求参数的单个值

${param.userName} 等价于

<%=request.getParameter(“userName”)

paramValues：的返回值是一个字符串数组

${paramValue.userId[0]} 等价于

<%=request.getParameter(“userId”)>

3. 代表HTTP请求消息头集合的内置对象

header：用于获取客户端访问JSP页面所传递的请求头字段的值

${header[“userName”]} 可以获得userName请求头字段的值

headerValue：用于获取请求头字段的所有值

4. EL操作javabean

<%

Person person = new Person();
p.setName(“李四”);
p.setAge(27);
p.setSalary(3600.0);
p.setBirth(new java.util.Date());
request.setAttribute(“person”, p);
%>
EL：<br>
姓名：${person.name }<br>
年龄：${person.age }<br>
薪资：${person.salary }<br>
生日：${person.birth }<br>
薪资2：${person[“salary”] }<br>

5. 访问数组

<%

String[] arr = {“hello”,”java”,”html”,”servlet”};
request.setAttribute(“arr”, arr);
%>
EL表达式获取数组<br>
数组对象：${arr}<br>
数组中的数据：${arr[0]}<br>
数组中的数据：${arr[1]}<br>

6. 访问list集合

<%

List<Person> list = new ArrayList<Person>();
Person p = new Person();
p.setName(“王五”);
list.add(p);
Person p2 = new Person();
p2.setName(“赵六”);
list.add(p2);
request.setAttribute(“personList”, list);
%>
EL表达式获取List集合<br>
集合：${personList }<br>
集合中的数据：${personList[0].name }<br>
集合中的数据：${personList[1].name }<br>

7. 访问Map集合

<%

Map<String,String> map = new HashMap<String,String>();
map.put(“name”, “tom”);
map.put(“pwd”, “123456”);
request.setAttribute(“mymap”, map);
%>
EL表达式获取Map集合<br>
集合：${mymap }<br>
集合中的数据：${mymap.name }<br>
集合中的数据：${mymap[‘pwd’] }<br>

JSTL标签

1. 什么是JSTL

JSP标准标签库

JSTL的目标是简化JSP页面，虽然EL表达式可以访问JavaBean的属性，但是并不能实现在JSP中进行逻辑判断和流程控制，因而要使用JSTL标签

2. 引入JSTL包

• 导入相关的包，jstl-1.2.jar，将包拷入到Web目录下的WEB-INF\lib目录中并导入。

• taglib指令，JSP页面导入标签

<%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core" %>

3. JSTL的标准

功能	说明	前缀	uri
core	核心标签库	c	http://java.sun.com/jsp/jstl/core
i18n	格式化标签库	fmt	http://java.sun.com/jsp/jstl/fmt
sql	数据库标签库	sql	http://java.sun.com/jsp/jstl/sql
xml	xml标签库	x	http://java.sun.com/jsp/jstl/xml
functions	函数标签库	fn	http://java.sun.com/jsp/jstl/function

4. set标签

用于把某一个对象存放在指定的域范围内，相等于setAttribute()方法

<c:set value=”${pageScope.name}” var=”name” scope=”page”/>

属性名	是否支持EL	属性类型	属性描述
value	true	Object	指定属性值
var	false	String	指定要设置的属性名称
scope	false	String	指定属性所在的Web域
target	true	Object	指定要设置属性的对象，这个对象必须是JavaBean对象或集合对象
property	true	string	指定当前要为对象设置的属性名称

5. out标签

向浏览器写入文本内容

<c:out value=”${pageScope.name}”/>

属性名	是否支持EL	属性类型	属性描述
value	true	Object	指定要输出的内容
escapeXml	true	Boolean	指定是否将>、<、&、’、” 等特殊字符进行HTML编码转换后再进行输出。默认值为true
default	true	Object	指定如果value属性的值为null或””时所输出的默认值

6. remove标签

删除指定范围内的变量

<c:remove var=”name” scope=”session”/> <%–移除session中的name属性变量–%>

7. catch标签

用于捕获异常，进行异常处理

<c:catch var=”ex”>

<%–ex用来存放发生异常的信息，此标签是双标签，两个标签之间是被保护的语句–%>

<%
String[] ss={“abc”};
System.out.println(ss[1]);
%>
</c:catch>

8. if标签

单条件的判断语句，相当于java中的if(true){ …}

<c:if test=”${ex!=null}”>
<p>异常为：${ex}</p>
<p>异常的内容为：${ex.message}</p>

</c:if>

9. choose,when,otherwise标签

多分支判断语句。choose标签用于指定多个条件选择的组合边界，它必须与when标签和otherwise标签一起使用。使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似 “if-else if-else” 的复杂条件判断结构。

<c:choose>

<c:when test=”${score>=90&&score<=100}”>
优秀<br>
</c:when>
<c:when test=”${score>=80&&score<=89}”>
良好<br>
</c:when>
<c:when test=”${score>=70&&score<=79}”>
中等<br>
</c:when>
<c:when test=”${score>=60&&score<=69}”>
及格<br>
</c:when>
<c:when test=”${score>=0&&score<=59}”>
不及格<br>
</c:when>
<c:otherwise> <%–当上面when标签的条件不成立，执行otherwise的内容–%>
<h1 style=”color:red”>分数有误</h1>
</c:otherwise>
</c:choose>

10. redirect标签

用于重定向

<c:redirect url=”http://www.baidu.com"></**c:redirect**>

11. 数据库标签库

• setDataSource标签

设置数据源，与数据库建立连接

<sql:setDataSource driver=”com.mysql.cj.jdbc.Driver”

url=”jdbc:mysql://localhost:3306/biglist?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai”
user=”root” password=”510609” var=”ds”/>
数据源：${ds}<br/>

• query标签

数据查询

<sql:query var=”rs” dataSource=”${ds}”

sql=”selectname,age,club,transfer,Goal,Country from player” />
<%–结果集：${rs}–%>

<%–foreach遍历出结果集中的数据，rs.rows意思是以行为单位进行遍历–%>
<c:forEach items=”${rs.rows}” var=”row”>
${row.name}–名字：${row.age}–年龄
</c:forEach>

返回值	函数名称	说明
String	toUpperCase(String input)	将字符串转换为大写
String	toLowerCase(String input)	将字符串转换为小写
int	indexOf(String input, String substring)	在一个字符串input种查找指定子串substring，返回最先匹配的第一个字符的位置
boolean	contains(String input, String substring)	判断字符串input中是否包含了指定的子串substring
boolean	contains(String input, String substring)	判断字符串input中是否包含了指定的子串substring
boolean	containsIgnoreCase(String input, String substring)	判断一个字符串input是否包含指定的子串substring，且忽略大小写
boolean	startsWith(String input, String prefix)	判断字符串input是否有指定的前缀prefix开始
boolean	endsWith(String input, String suffix)	判断字符串input是否由指定的后缀suffix开始
String	substring(String input, int beginIndex, int endIndex)	截取字符串input的某一部分，返回截取后的子串substring
String	substringAfter(String input, String substring)	截取指定的子串，返回子串之后的字符串
String	substringBefore(String input, String substring)	截取指定的子串，返回子串之后的字符串
String	escapeXml(String input)	将字符串的<、>、’ 、”和&转换为对应字符引用或者实体引用
String	trim(String input)	去除字符串前后的空白字符
String	replace(String input, String substringBefore, String substringAfter)	将一个字符串的某一部分替换为另外一部分，返回替换后的结果
String[]	split(String input, String delimiters)	将一个字符串input使用指定的分隔符delimiters分割为数组
int	length(Object obj)	获取字符串、数组、各种集合的长度
String	join(String array[], String separator)	将一个数组array使用分隔符separator连接为一个字符串

12.函数标签库

字符串包含<br>

${fn:contains(“javascript”, “java”) }<br>
截取子字符串<br>
${fn:substring(“hello”,1,4) }<br>
是否以…开始或结束<br>
${fn:startsWith(“mysql”, “my”) }<br>
${fn:endsWith(“oracle”, “abc”) }<br>
位置<br>
${fn:indexOf(“html”,”x”) }<br>
替换<br>
${fn:replace(“how are you”,” “,”-“) }<br>
拆分<br>
${fn:split(“tom@jerry”,”@”) }<br>
${fn:length(fn:split(“tom@jerry”,”@”)) }<br>
组合字符串<br>
${fn:join(fn:split(“aa#bb#cc#dd”,”#“),”,”) }

Filter过滤器

过滤器概念

web中的过滤器：当访问服务器资源的时候，过滤器可以将请求拦截下来，完成一些特殊的功能

过滤器的作用：一般用于完成通用的操作。如：登录验证、统一编码处理、敏感字符过滤。

快速入门

步骤：

1. 定义一个类、实现接口Filter

2. 复写方法

3. 配置拦截路径

web.xml配置 注解配置 @WebFilter(“/*“)//访问所有资源都会执行过滤器

| |

| |

\/

<filter>

<filter-name>Filter1</filter-name>
<filter-class>hb.rj.bean.Filter1</filter-class>
</filter>
<filter-mapping>
<filter-name>Filter1</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

过滤器执行流程（生命周期）

init：在服务器启动后，会创建Filter对象，然后调用init方法。只能执行一次，用于加载资源

doFilter：每一次请求被拦截资源时，会执行。执行多次，

执行过滤器

执行放行后的资源

回来执行过滤器放行代码下边的代码

 注意:在Filter的doFilter方法内如果没有执行chain.doFilter(request,response)
　　　　　　　　那么资源是不会被访问到的。

destroy：在服务器关闭后，Filter对象被销毁。如果服务器是正常关闭，则会执行，只执行一次。一般用于释放资源

过滤器配置详解

拦截路径配置

1. 具体资源路径：/index.jsp 只有访问index.jsp资源时，过滤器才会被执行

2. 拦截目录：/user/* 访问/user下的所有资源时，过滤器都会被执行

3. 后缀名拦截：*.jsp 访问所有后缀名为jsp的资源是，过滤器都会被执行

4. 拦截所有资源：/* 访问所有资源时，过滤器都会被执行

拦截方式配置：资源被访问的方式

设置dispatcherTypes属性

1. request：默认值。浏览器直接请求资源

2. forward：转发访问资源时

3. include：包含访问资源时

4. error：错误跳转资源

5. async：异步访问资源

@WebFilter(value = “/*“,dispatcherTypes = {DispatcherType.REQUEST,DispatcherType.FORWARD})

//浏览器直接请求或者转发访问资源时进行拦截

web.xml配置

<filter>

<filter-name>Filter1</filter-name>
<filter-class>hb.rj.bean.Filter1</filter-class>
</filter>
<filter-mapping>
<filter-name>Filter1</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>

过滤器链（配置多个过滤器）

执行顺序：如果有两个过滤器：过滤器1和过滤器2

过滤器1 –> 过滤器2 –> 资源执行 –> 过滤器2 –> 过滤器1

过滤器先后顺序问题

注解配置：按照类名的字符串比较规则比较，值小的先执行

web.xml配置：谁定义在上边谁先执行

Listener：监听器

概念：web三大组件之一

事件监听机制

事件 –> 事件发生的地方 –> 监听器：监听一个对象 –> 注册监听：将事件事件源监听器绑定在一起。当事件源上发生某一个事件后，执行监听代码

监听器的实质

一个类实现某个监听器接口，然后实现接口对应的方法，达到监听具体事项的动作

监听器的接口有哪些

监听器接口分三类：ServletContext，HttpSession，ServletRequest。

ServletContext

—-ServletContextListener监听ServletContext对象

—-ServletContextAttributeListener监听对ServletContext属性的操作，比如说增加，删除，修改

HttpSession

—-HttpSessionListener监听Session对象

—-HttpSessionAttributeListener监听Session的属性操作

—-HttpSessionActivationListener监听HTTP会话的active和passivate情况，passivate是指非活动的session被写入持久设备（如硬盘），active相反。

—-HttpSessionBindingListener监听器感知Session绑定的事件监听器

Servlet 规范中定义了两个特殊的监听器接口”HttpSessionBindingListener和HttpSessionActivationListener”来帮助JavaBean

对象了解自己在Session域中的这些状态： ，实现这两个接口的类不需要 web.xml 文件中进行注册。

ServletRequest

—-ServletRequestListener监听Requst对象

—-ServletRequestAttributeListener监听Request中的属性操作。ServletContextListener

监听ServletContext的创建和销毁

public class listen implements ServletContextListener {

// 在服务器ServletContext方法启动时调用
@Override
public void contextDestroyed(ServletContextEvent sce) {
// 1.获取ServletContext对象
ServletContext servletcontext= sce.getServletContext();

// 2.加载资源文件
String cont=servletcontext.getInitParameter(“contextConfig”);
}
// 在服务器ServletContext方法销毁时执行
@Override
public void contextInitialized(ServletContextEvent sce) {
ServletContextListener.super.contextInitialized(sce);
}
}