Tomcat服务器使用
目录结构介绍:
- \bin 存放启动和关闭 Tomcat 的可执行文件
- \conf 存放 Tomcat 的配置文件
- \lib 存放库文件
- \logs 存放日志文件
- \temp 存放临时文件
- \webapps 存放 web 应用
- \work 存放 JSP 转换后的 Servlet 文件
idea配置web应用
- 1.选择Web Application
- 2.在web/WEB-INF下创建两个文件夹classes和lib,classes用来存放编译后输出的classes文件,lib用于存放第三方jar包
- 3.File -> Project Structure (快捷键:Ctrl + Shift + Alt + S) -> 选择Module :
----------------3.1.选择 Paths -> 选择"Use module compile output path" -> 将Output path和Test output path都选择刚刚创建的classes文件夹。
----------------3.2.接着选择Dependencies(jar包) -> 将Module SDK选择为1.8 -> 点击右边的“+”号 -> 选择1 “Jars or Directories”,选择刚才的ilib文件夹 - 4.配置tomcat,选择本地tomcat,并部署当前创建的项目。选择Deployment -> 点击右边的“+”号 -> 选择Artifact
idea 打包
project Structure,点击+号图标,选择“Artifacts->Web Application Archive”
Artifacts,它的作用是整合编译后的 java 文件,资源文件等,有不同的整合方式,比如war、jar、war exploded 等,对于 Module 而言,有了 Artifact 就可以部署到 web 容器中了。其中 war 和 war exploded 区别就是后者不压缩,开发时选后者便于看到修改文件后的效果。
Servelet使用
1、 创建普通的 java 类并继承 HttpServlet
2、 覆写 service 方法
3、 在 service 方法中书写逻辑代码即可
4、 在 WEB-INF 文件夹下的 web.xml 文件中配置 servlet
Servlet 的生命周期
从第一次调用,到服务器关闭。如果在 web.xml 中配置了 load-on-startup 则是从 服务器开启到服务器关闭
访问流程
访问jsp,form表单提交通过action属性配置的访问路径,找到web.xml对应的Servelet类,再根据form配置的访问方式判断进doGet还是doPost请求。
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/*** Servlet的生命周期:
*
*1、从第一次调用到服务器关闭
*2、如果Servlet在web.xml中配置了load-on-startup,生命周期为 从服务器启动到服务器关闭
*注意:
* init方法是对Servlet进行初始化的一个方法,会在Servlet第一次 加载进行存储时执行
* destory方法是在servlet被销毁时执行,也就服务器关闭时。 *
* */
/**
* Service方法和doGet方法和doPost方法的区别
* Service方法:
* 可以处理get/post方式的请求,如果servlet中有Service方法,会优先调用service方法对请求进行处理。
* doGet方法:
* 处理get方式的请求
* doPost方法:
* 处理post方式的请求
* 注意:
* 如果在覆写的service方法中调用了父类的service方法(super.service(arg0, arg1)),
* 则service方法处理完后,会再次根据请求方式响应的doGet和doPost方法执行。所以,一般情况下
* 我们是不在覆写的service中调用父类的service方法的,避免出现405错误。
* Servlet的常见错误:
* 404错误:资源未找到
* 原因一:在请求地址中的servlet的别名书写错误。
* 原因二:虚拟项目名称拼写错误
* 500错误:内部服务器错误
* 错误一:
* java.lang.ClassNotFoundException: com.bjsxt.servlet.ServletMothod
* 解决:
* 在web.xml中校验servlet类的全限定路径是否拼写错误。
* 错误二:
* 因为service方法体的代码执行错误导致
* 解决:
* 根据错误提示对service方法体中的代码进行错误更改。
* 405错误:请求方式不支持
* 原因:
* 请求方式和servlet中的方法不匹配所造成的。
* 解决:
* 尽量使用service方法进行请求处理,并且不要再service方法中调用父类的service。
*/
public class ServletLife extends HttpServlet {
//初始化方法,在servlet第一次加载内容的时候被调用
@Override
public void init() throws ServletException {
System.out.println("servlet初始化完成");
}
//service方法,真正处理请求的方法
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("servlet life");
System.out.println("servlet life");
}
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
int i=5/0;
System.out.println("我是service");
super.service(req, resp);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
System.out.println("我是doGet方法");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
System.out.println(
@Override
public void destroy() {
System.out.println("我被销毁了...");
}
}
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>my</servlet-name>
<servlet-class>com.zzz.servelet.MyServelet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>my</servlet-name>
<url-pattern>/my</url-pattern>
</servlet-mapping>
</web-app>
<form action="my" method="get">
用户名: <input type="text" name="uname" value="" /><br />
密码: <input type="text" name="pwd" value="" /><br />
爱好:<br />
<input type="checkbox" name="fav" value="1"/>唱歌<br />
<input type="checkbox" name="fav" value="2"/>跳舞<br />
<input type="checkbox" name="fav" value="3"/>游泳<br />
<input type="submit" value="登录" />
</form>
Servelet 的Request和Response对象
service请求处理代码流程:
-
设置响应编码格式
-
获取请求数据
-
处理请求数据
-
数据库操作(MVC思想)
-
响应处理结果
Request
问题:浏览器发起请求到服务器,会遵循HTTP协议将请求数据发送给服务器。 那么服务器接受到请求的数据改怎么存储呢?不但要存,而且要保证完成性。
解决:使用对象进行存储,服务器每接受一个请求,就创建一个对象专门的存 储此次请求的请求数据。
实现: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()//返回所有用户请求数据的枚举集合
public class RequestServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//获取请求头数据
//获取请求方式
String method = req.getMethod();
//获取请求URL
StringBuffer url=req.getRequestURL();
//获取URI
String uri=req.getRequestURI();
//获取协议
String h=req.getScheme();
//获取请求行数据
//获取指定的请求行信息
String value=req.getHeader("aaa");
//获取所有的请求行的键的枚举
Enumeration e = req.getHeaderNames();
while(e.hasMoreElements()){
String name=(String) e.nextElement();
String value2=req.getHeader(name);
System.out.println(name+":"+value2);
}
//获取用户数据
String name=req.getParameter("uname");
String pwd=req.getParameter("pwd");
//String fav=req.getParameter("fav");
String[] favs=req.getParameterValues("fav");
if(favs!=null){
for(String fav:favs){
System.out.println(fav);
}
}
//获取所有的用户请求数据的键的枚举集合---req.getParameterNames()
}
}
Response
问题:在使用 Request 对象获取了请求数据并进行处理后,处理的结果如何显 示到浏览器中呢?
解决: 使用 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");
public class ResponseServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//获取请求信息
//获取请求头
//获取请求行
//获取用户数据
//处理请求
//响应处理结果
//设置响应头
resp.setHeader("mouse", "two fly birds");
resp.setHeader("mouse", "bjsxt");
resp.addHeader("key", "thinkpad");
resp.addHeader("key", "wollo");
//设置响应编码格式
//resp.setHeader("content-type", "text/html;charset=utf-8");
//resp.setContentType("text/plain;charset=utf-8");
//resp.setContentType("text/xml;charset=utf-8");
resp.setContentType("text/html;charset=utf-8");
//设置响应状态吗
//resp.sendError(404, "this Method is not supported");
//设置响应实体
resp.getWriter().write("<b>今天天气真好,适合学习</b>");
}
}
转发和重定向
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.bjsxt.pojo.User;
import com.bjsxt.service.LoginService;
import com.bjsxt.service.impl.LoginServiceImpl;
/**
* 请求中文乱码解决:
* 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");
* Servlet流程总结:
* 浏览器发起请求到服务器(请求)
* 服务器接受浏览器的请求,进行解析,创建request对象存储请求数据
* 服务器调用对应的servlet进行请求处理,并将request对象作为实参传递给servlet的方法
* servlet的方法执行进行请求处理
* //设置请求编码格式
* //设置响应编码格式
* //获取请求信息
* //处理请求信息
* //创建业务层对象
* //调用业务层对象的方法
* //响应处理结果
*请求转发学习:
* 作用:实现多个servlet联动操作处理请求,这样避免代码冗余,让servlet的职责更加明确。
* 使用:
* req.getRequestDispatcher("要转发的地址").forward(req, resp);
* 地址:相对路径,直接书写servlet的别名即可。
* 特点:
* 一次请求,浏览器地址栏信息不改变。
* 注意:
* 请求转发后直接return结束即可。
*reuqet作用域:
* 解决了一次请求内的servlet的数据共享问题
*重定向:
* 解决了表单重复提交的问题,以及当前servlet无法处理的请求的问题。
* 使用:
* resp.sendRedirect(String uri);
* 示例:
* resp.sendRedirect("/login/main");
* 特点:
* 两次请求,两个request对象。
* 浏览器地址栏信息改变
* 时机:
* 如果请求中有表单数据,而数据又比较重要,不能重复提交,建议使用重定向。
* 如果请求被Servlet接收后,无法进行处理,建议使用重定向定位到可以处理的资源。
*
* @author MyPC
*/
public class LoginServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//设置请求编码格式:
req.setCharacterEncoding("utf-8");
//设置响应编码格式
resp.setContentType("text/html;charset=utf-8");
//获取请求信息
String uname=req.getParameter("uname");
//uname=new String(uname.getBytes("iso8859-1"),"utf-8");//使用String进行数据重新编码
String pwd=req.getParameter("pwd");
System.out.println(uname+":"+pwd);
//处理请求信息
//获取业务层对象
LoginService ls=new LoginServiceImpl();
User u=ls.checkLoginService(uname, pwd);
System.out.println(u);
//响应处理结果
if(u!=null){
//创建Cookie信息实现三天免登录。
Cookie c=new Cookie("uid", u.getUid()+"");
//设置Cookie的有效期
c.setMaxAge(3*24*3600);
c.setPath("/login/ck");
//添加Cookie信息
resp.addCookie(c);
//请求转发
//req.getRequestDispatcher("main").forward(req, resp);
//重定向
resp.sendRedirect("/login/main");
return;
}else{
//使用request对象实现不同Servlet的数据流转
req.setAttribute("str", "用户名或密码错误");
//使用请求转发
req.getRequestDispatcher("page").forward(req, resp);
return;
}
}
}
Cookie
解决了发送的不同请求的数据共享问题
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Cookie学习:
* 作用:解决了发送的不同请求的数据共享问题
* 使用:
* Cookie的创建和存储
* //创建Cookie对象
* Cookie c=new Cookie(String name, String value);
* //设置cookie(可选)
* //设置有效期
* c.setMaxAge(int seconds);
* //设置有效路径
* c.setPath(String uri)
* //响应Cookie信息给客户端
* resp.addCookie(c);
* Cookie的获取
* //获取Cookie信息数组
* Cookie[] cks=req.getCookies();
* //遍历数组获取Cookie信息
* 使用for循环遍历即可,示例:
if(cks!=null){
for(Cookie c:cks){
String name=c.getName();
String value=c.getValue();
System.out.println(name+":"+value);
}
}
* 注意:
* 一个Cookie对象存储一条数据。多条数据,可以多创建几个Cookie对象进行存储。
* 特点:
* 浏览器端的数据存储技术。
* 存储的数据声明在服务器端。
* 临时存储:存储在浏览器的运行内存中,浏览器关闭即失效。
* 定时存储:设置了Cookie的有效期,存储在客户端的硬盘中,在有效期内符合路径要求的请求都会附带该信息。
* 默认cookie信息存储好之后,每次请求都会附带,除非设置有效路径
* @author MyPC
*
*/
public class CookieServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//设置请求编码格式
req.setCharacterEncoding("utf-8");
//设置响应编码格式
resp.setContentType("text/html;charset=utf-8");
//获取请求信息
//处理请求信息
//响应处理结果
//使用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);
//直接响应
resp.getWriter().write("Cookie学习");
//请求转发
//重定向
}
}
Session
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
/**
* session技术学习:
* 问题:
* 一个用户的不同请求处理的数据共享怎么办?
* 解决:
* 使用session技术
* 原理:
* 用户第一次访问服务器,服务器会创建一个session对象给此用户,并将
* 该session对象的JSESSIONID使用Cookie技术存储到浏览器中,保证
* 用户的其他请求能够获取到同一个session对象,也保证了不同请求能够获取到
* 共享的数据。
* 特点:
* 存储在服务器端
* 服务器进行创建
* 依赖Cookie技术
* 一次会话
* 默认存储时间是30分钟
* 作用:
* 解决了一个用户不同请求处理的数据共享问题
* 使用:
* 创建session对象/获取session对象
HttpSession hs=req.getSession();
如果请求中拥有session的标识符也就是JSESSIONID,则返回其对应的session队形
如果请求中没有session的标识符也就是JSESSIONID,则创建新的session对象,并将其JSESSIONID作为从cookie数据存储到浏览器内存中
* 如果session对象是失效了,也会重新创建一个session对象,并将其JSESSIONID存储在浏览器内存中。
* 设置session存储时间
* hs.setMaxInactiveInterval(int seconds);
* 注意:
* 在指定的时间内session对象没有被使用则销毁,如果使用了则重新计时。
* 设置session强制失效
* hs.invalidate();
* 存储和获取数据
* 存储:hs.setAttribute(String name,Object value);
* 获取:hs.getAttribute(String name) 返回的数据类型为Object
* 注意:
* 存储的动作和取出的动作发生在不同的请求中,但是存储要先于取出执行。
* 使用时机:
* 一般用户在登陆web项目时会将用户的个人信息存储到Sesion中,供该用户的其他请求使用。
* 总结:
* session解决了一个用户的不同请求的数据共享问题,只要在JSESSIONID不失效和session对象不失效的情况下。
* 用户的任意请求在处理时都能获取到同一个session对象。
* 作用域:
* 一次会话
* 在JSESSIONID和SESSION对象不失效的情况下为整个项目内。
* session失效处理:
* 将用户请求中的JSESSIONID和后台获取到的SESSION对象的JSESSIONID进行比对,如果一致
* 则session没有失效,如果不一致则证明session失效了。重定向到登录页面,让用户重新登录。
* 注意:
* JSESSIONID存储在了Cookie的临时存储空间中,浏览器关闭即失效。
*
* @author MyPC
*
*/
public class SessionServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//设置请求编码格式
req.setCharacterEncoding("utf-8");
//设置响应编码格式
resp.setContentType("text/html;charset=utf-8");
//获取请求信息
String name="张三";
//处理请求信息
//创建session对象
HttpSession hs=req.getSession();
//设置session的存储时间
//hs.setMaxInactiveInterval(5);
System.out.println(hs.getId());
//设置session强制失效
//hs.invalidate();
//存储数据
hs.setAttribute("name",name);
//响应处理结果
//直接响应
resp.getWriter().write("session学习");
//请求转发
//重定向
}
}
ServeletContext
import java.io.IOException;
import java.io.InputStream;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 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>进行存储。
* <context-param>
<param-name>name</param-name>
<param-value>zhangsan</param-value>
</context-param>
作用:将静态数据和代码进行解耦。
获取项目webroot下的资源的绝对路径。
String path=sc.getRealPath(String path);
获取的路径为项目根目录,path参数为项目根目录中的路径
获取webroot下的资源的流对象
InputStream is = sc.getResourceAsStream(String path);
注意:
此种方式只能获取项目根目录下的资源流对象,class文件的流对象需要使用类加载器获取。
path参数为项目根目录中的路径
*
*
* @author MyPC
*
*/
public class ServletContextServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//获取ServletContext对象
//第一种方式:
ServletContext sc=this.getServletContext();
//第二种方式:
ServletContext sc2=this.getServletConfig().getServletContext();
//第三种方式:
ServletContext sc3=req.getSession().getServletContext();
System.out.println(sc==sc2);
System.out.println(sc==sc3);
//使用ServletContext对象完成数据共享
//数据存储
sc.setAttribute("str", "ServletContext对象学习");
//获取项目web.xml的全局配置数据
String str = sc.getInitParameter("name2");
System.out.println("全局配置参数:"+str);
//获取项目根目录下的资源的绝对路径
//String path="D:\\apache-tomcat-7.0.56\\webapps\\sc\\doc\\1.txt";
String path=sc.getRealPath("/doc/1.txt");
System.out.println(path);
//获取项目根目录下资源的流对象
InputStream is = sc.getResourceAsStream("/doc/1.txt");
}
}
ServletConfig
import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* ServletConfig对象学习:
* 问题:
* 如何获取在web.xml中给每个servlet单独配置的数据呢?
* 解决:
* 使用ServletConfig对象
* 使用:
* 获取ServletConfig对象
* 获取web.xml中的配置数据
*/
public class ServletConfigServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//获取ServletConfig对象
ServletConfig sc=this.getServletConfig();
//获取web.xml中的配置数据
String code=sc.getInitParameter("config");
System.out.println(code);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>07-ServletConfig</display-name>
<servlet>
<servlet-name>ServletConfigServlet</servlet-name>
<servlet-class>com.bjsxt.servlet.ServletConfigServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>utf-8</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>ServletConfigServlet</servlet-name>
<url-pattern>/sg</url-pattern>
</servlet-mapping>
</web-app>
web.xml和server.xml
web.xml
Web 项目下的 web.xml 文件为局部配置,针对本项目的位置。
内容(核心组件):
- 全局上下文配置(全局配置参数)
- Servlet 配置
- 过滤器配置
- 监听器配置
加载顺序:
Web 容器会按 ServletContext -> context-param -> listener -> filter -> servlet 这个顺序加载组件,这些元素可配置在 web.xml 文件中的任意位置。
加载时机: 服务器启动时。
server.xml
可以修改项目路径
AJAX
请求
<%@ page language="java" contentType="text/html; charset=utf-8"
pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
<!-- 声明js代码域 -->
<!--
Ajax学习:
1、ajax的概念
局部刷新技术。不是一门新技术,是多种技术的组合。是浏览器端的技术。
2、ajax的作用
实现在当前结果页中显示其他请求的响应内容
3、ajax的使用
ajax的基本流程
//创建ajax引擎对象
//复写onreadystatement函数
//判断ajax状态码
//判断响应状态码
//获取响应内容(响应内容的格式)
//普通字符串:responseText
//json(重点):responseText
其实就是讲述数据按照json的格式拼接好的字符串,方便使用eval方法
将接受的字符串数据直接转换为js的对象
json格式:
var 对象名={
属性名:属性值,
属性名:属性值,
……
}
//XML数据:responseXML.返回document对象
通过document对象将数据从xml中获取出来
//处理响应内容(js操作文档结构)
//发送请求
//get请求
get的请求实体拼接在URL后面,?隔开,键值对
ajax.open("get","url");
ajax.send(null);
//post请求
有单独的请求实体
ajax.open("post", "url");
ajax.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
ajax.send("name=张三&pwd=123");
ajax的状态码
ajax状态码:
readyState:0,1,2,3,4
4: 表示响应内容被成功接收
响应状态码:
status
200:表示一切OK
404:资源未找到
500:内部服务器错误
ajax的异步和同步
ajax.open(method,urL,async)
async:设置同步代码执行还是异步代码执行
true代表异步,默认是异步
false代表同步
-->
<script type="text/javascript">
function getData(){
//创建ajax引擎对象
var ajax;
if(window.XMLHttpRequest){//火狐
ajax=new XMLHttpRequest();
}else if(window.ActiveXObject){//ie
ajax=new ActiveXObject("Msxml2.XMLHTTP");
}
//复写onreadystatement函数
ajax.onreadystatechange=function(){
//判断Ajax状态吗
if(ajax.readyState==4){
//判断响应状态吗
if(ajax.status==200){
//获取响应内容
var result=ajax.responseText;
//处理响应内容
//获取元素对象
var showdiv=document.getElementById("showdiv");
showdiv.innerHTML=result;
}else if(ajax.status==404){
//获取元素对象
var showdiv=document.getElementById("showdiv");
showdiv.innerHTML="请求资源不存在";
}else if(ajax.status==500){
//获取元素对象
var showdiv=document.getElementById("showdiv");
showdiv.innerHTML="服务器繁忙";
}
}else{
//获取元素对象
var showdiv=document.getElementById("showdiv");
showdiv.innerHTML="<img src='img/2.gif' width='200px' height='100px'/>";
}
}
//发送请求
ajax.open("get","ajax",true);
ajax.send(null);
alert("哈哈");
}
</script>
<style type="text/css">
#showdiv{
border:solid 1px;
width:200px;
height:100px;
}
</style>
</head>
<body>
<h3>欢迎登录403峡谷</h3>
<hr>
<input type="button" value="测试 " onclick="getData()"/>
<div id="showdiv"></div>
</body>
</html>
两种传参方式
Get方式传参
直接通过url传参
注意:get方式提交经常会遇到浏览器缓存问题,浏览器不对同样的url重复提交。这时可以在url后面增加参数:
?rand = Math.random() 或者:rand = new Date()
Post方式传参
request.open(“post”,url);
// 必须加下面的请求头
req.setRequestHeader(“Content-Type”,“application/x-www-form-urlencoded”);
req.send(“a=3&b=中国”);
后台:
String name=req.getParameter(“a”);
String pwd=req.getParameter(“b”);
响应数据格式、
JSON
后台
//处理业务
User u=us.getUserInfoService(name);
//响应处理结果
// 引入jar包
resp.getWriter().write(new Gson().toJson(u));
前台接受
eval("var u="+result);
alert(u.name)
XML
前台
<%@ page language="java" contentType="text/html; charset=utf-8"
pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<script type="text/javascript">
function getXML(){
//创建ajax引擎对象
var ajax;
if(window.XMLHttpRequest){//火狐
ajax=new XMLHttpRequest();
}else if(window.ActiveXObject){//ie
ajax=new ActiveXObject("Msxml2.XMLHTTP");
}
//复写onreadystatechange
ajax.onreadystatechange=function(){
//判断Ajax状态吗
if(ajax.readyState==4){
//判断响应状态吗
if(ajax.status==200){
//获取响应内容
var doc=ajax.responseXML;
//处理响应内容
//获取元素对象
alert(doc.getElementsByTagName("name")[0].innerHTML);
}
}
}
//发送请求
ajax.open("get","xml.jsp",true);
ajax.send(null);
}
</script>
</head>
<body>
<h3>XML数据格式学习</h3>
<hr>
<input type="button" value="测试XML" onclick="getXML()" />
</body>
</html>
后台(setContentType:text/xml)
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/xml")
public class XMLServlet extends HttpServlet{
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//设置请求编码格式
//设置响应编码格式
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/xml;charset=utf-8");
//获取请求信息
//处理请求信息
//响应处理结果
resp.getWriter().write("<user><uid>1</uid><name>张三</name><price>11.11</price></user>");
}
}
封装
/*
method:
请求方式,值为get或者post
url:请求地址
data:没有值需要传入null
有请求数据则传入字符串数据,格式为"a=1&b=2";
deal200:
接受一个带有一个形参的js函数对象,形参接收的实参是ajax引擎对象
deal404:接受一个js函数对象
deal500:接受一个js函数对象
*/
function myAjax(method,url,data,deal200,deal404,deal500,async){
//创建ajax引擎对象
var ajax=getAjax();
//复写onreadystatement函数
ajax.onreadystatechange=function(){
//判断Ajax状态吗
if(ajax.readyState==4){
//判断响应状态吗
if(ajax.status==200){
if(deal200){
deal200(ajax);
}
}else if(ajax.status==404){
if(deal404){
deal404();
}
}else if(ajax.status==500){
if(deal500){
deal500();
}
}
}
}
//发送请求
if("get"==method){
ajax.open("get",url+(data==null?"":"?"+data),async);
ajax.send(null);
}else if("post"==method){
ajax.open("post",url,async);
ajax.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
ajax.send(data);
}
}
/* --------------------------------------------------------------------------- */
function getAjax(){
var ajax;
if(window.XMLHttpRequest){//火狐
ajax=new XMLHttpRequest();
}else if(window.ActiveXObject){//ie
ajax=new ActiveXObject("Msxml2.XMLHTTP");
}
return ajax;
}
过滤器
package com.bjsxt.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
/**
* 过滤器的使用:
* 作用:
* 对服务器接受的请求资源和响应给浏览器的资源进行管理。
* 保护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管理
权限管理
资源管理(统一水印,和谐词汇等等)
* @author MyPC
*
*/
public class MyFilter implements Filter{
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("MyFilter.init(我被初始化了)");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("MyFilter.doFilter(我被执行了)");
//设置编码格式
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");
//判断session
HttpSession hs=((HttpServletRequest) request).getSession();
if(hs.getAttribute("user")==null){
((HttpServletResponse)response).sendRedirect("/a/login.jsp");
}else{
//放行
chain.doFilter(request, response);
}
System.out.println("MyFilter.doFilter(我被执行了2)");
}
@Override
public void destroy() {
System.out.println("MyFilter.destroy(我被销毁了)");
}
}
监听器
import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.ServletRequestAttributeEvent;
import javax.servlet.ServletRequestAttributeListener;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
/**
* 监听器的使用:
* 作用:
* 监听作用域对象request、session、application的创建、销毁和内容的改变
* 使用:
* 创建一个实现了指定接口的java类
* 监听request--->ServletRequestListener 监听request对象的创建和销毁
* requestInitialized(ServletRequestEvent sre)//创建
* requestDestroyed(ServletRequestEvent sre)//销毁
* 注意:
* 形参可以获取监听的request对象
* sre.getServletRequest();
* 监听request--->ServletRequestAttributeListener 监听request作用域数据的变更。
attributeAdded(ServletRequestAttributeEvent srae)
* attributeRemoved(ServletRequestAttributeEvent srae)
* attributeReplaced(ServletRequestAttributeEvent srae)
* 注意:形参可以获取被监听的数据
* srae.getName() 获取监听数据的键
* srae.getValue() 获取监听数据的值
* 监听session--->HttpSessionListener 监听session的创建和销毁
* sessionCreated(HttpSessionEvent se) 创建
* sessionDestroyed(HttpSessionEvent se) 销毁
* 注意:形参可以获取被监听的session对象
* se.getSession();
* 监听session--->HttpSessionAttributeListener 监听session数据的变更
* attributeAdded(HttpSessionBindingEvent event)
* attributeRemoved(HttpSessionBindingEvent event)
* attributeReplaced(HttpSessionBindingEvent event)
* 注意:形参可以获取被监听的数据
* event.getName() 获取数据的键名
* event.getValue() 获取数据的值
* 监听application--->ServletContextListener 监听application对象的初始化和销毁
* contextInitialized(ServletContextEvent sce) 初始化 服务器启动
* contextDestroyed(ServletContextEvent sce) 销毁 服务器关闭
* 注意:
* 形参可以获取当前application对象。
* sce.getServletContext();
监听application--->ServletContextAttributeListener 监听数据的变更
attributeAdded(ServletContextAttributeEvent event)
* attributeRemoved(ServletContextAttributeEvent event)
* attributeReplaced(ServletContextAttributeEvent event)
* 注意:
* 形参可以获取当前监听的数据
* event.getName() 获取数据的键名
* event.getValue() 获取数据的值
* 在web.xml中配置监听器类
* <listener>
<listener-class>com.bjsxt.listener.MyListener</listener-class>
</listener>
案例:
统计当前在线人数。
统计网页浏览器次数。
* @author MyPC
*
*/
public class MyListener implements ServletRequestListener,ServletRequestAttributeListener,HttpSessionListener,HttpSessionAttributeListener,ServletContextListener,ServletContextAttributeListener{
//request对象销毁
@Override
public void requestDestroyed(ServletRequestEvent sre) {
System.out.println("我被销毁了");
}
//request对象创建
@Override
public void requestInitialized(ServletRequestEvent sre) {
System.out.println("我被创建了");
}
//监听request作用域数据的添加
@Override
public void attributeAdded(ServletRequestAttributeEvent srae) {
System.out.println("request中增加了一条数据-"+srae.getName()+":"+srae.getValue());
}
@Override
public void attributeRemoved(ServletRequestAttributeEvent srae) {
// TODO Auto-generated method stub
}
@Override
public void attributeReplaced(ServletRequestAttributeEvent srae) {
// TODO Auto-generated method stub
}
/*------------------------------------------------------------------------------*/
//监听session的创建
@Override
public void sessionCreated(HttpSessionEvent se) {
System.out.println("session被创建了");
}
//监听session的销毁
@Override
public void sessionDestroyed(HttpSessionEvent se) {
System.out.println("session被销毁了");
}
//监听session数据的表更
@Override
public void attributeAdded(HttpSessionBindingEvent event) {
System.out.println("session中增加了一条数据"+event.getName()+":"+event.getValue());
}
@Override
public void attributeRemoved(HttpSessionBindingEvent event) {
// TODO Auto-generated method stub
}
@Override
public void attributeReplaced(HttpSessionBindingEvent event) {
// TODO Auto-generated method stub
}
/*------------------------------------------------------------------------------*/
@Override
public void contextInitialized(ServletContextEvent sce) {
System.out.println("application对象被初始化了");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("application对象被销毁了");
}
//监听application的数据变更
@Override
public void attributeAdded(ServletContextAttributeEvent event) {
System.out.println("application中存储了数据:"+event.getName()+":"+event.getValue());
}
@Override
public void attributeRemoved(ServletContextAttributeEvent event) {
// TODO Auto-generated method stub
}
@Override
public void attributeReplaced(ServletContextAttributeEvent event) {
// TODO Auto-generated method stub
}
}