Serverlet

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请求处理代码流程：

1. 设置响应编码格式

2. 获取请求数据

3. 处理请求数据

4. 数据库操作（MVC思想）

5. 响应处理结果

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 文件为局部配置，针对本项目的位置。

内容(核心组件)：

1. 全局上下文配置(全局配置参数)
2. Servlet 配置
3. 过滤器配置
4. 监听器配置

加载顺序：
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
		
	}
		
	
}