javaEE
HTTP 协议详解.
1、 web 交互的基本流程
图片介绍：
客户端根据用户输入的地址信息请求服务器，服务器在接收到用户的请求后进行处理，然后将处理结果响应给客户端，客户端将响应结果展示给用户。
专业术语:
请求：客户端根据用户地址信息将数据发送给服务器的过程
响应：服务器将请求的处理结果发送给浏览器的过程
问题：
客户端也就是浏览器的版本是有很多的，服务器的版本也是有很多
的，如何实现不同版本的浏览器和不同版本的服务器之间的数据交互呢？
解决：
规范浏览器和服务器的数据交互的格式。
实现：
HTTP 协议
概念：
超文本传输协议（Hyper Text Transfer Protocol）
作用：
规范了浏览器和服务器的数据交互
特点：
简单快速：客户向服务器请求服务时，只需传送请求方法和路径。
请求方法常用的有 GET、HEAD、POST。每种方法规定了客户与服
务器联系的类型不同。由于 HTTP 协议简单，使得 HTTP 服务器的
程序规模小，因而通信速度很快
灵活：HTTP 允许传输任意类型的数据对象。正在传输的类型由
Content-Type 加以标记。
无连接：无连接的含义是限制每次连接只处理一个请求。服务器
处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方
式可以节省传输时间
无状态：HTTP 协议是无状态协议。无状态是指协议对于事务处
理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则
它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，
在服务器不需要先前信息时它的应答就较快。
支持 B/S 及 C/S 模式。
HTTP1.1 版本后支持可持续连接
3、 HTTP 的交互流程：
HTTP 的交互流程一般分为四个步骤(一次完整的请求)：
步骤一:
客户端和服务器端建立连接
步骤二：
客户端发送请求数据到服务器端(HTTP 协议)
步骤三：
服务器端接收到请求后，进行处理，然后将处理结果响应客户端(HTTP 协议)
步骤四：
关闭客户端和服务器端的连接(HTTP1.1 后不会立即关闭)
4、 HTTP 协议之请求格式
请求格式的结构：
请求行：请求方式、请求的地址和 HTTP 协议版本
请求头：消息报头，一般用来说明客户端要使用的一些附加信息
空行： 位于请求行和请求数据之间，空行是必须的。
请求数据：非必须。
注意： 一张网页的内容是极其丰富的，浏览器会遵循
HTTP 请求的格式将有效数据发送给服务器。
示例(get 请求方式)：
示例(post 请求方式);
5、 HTTP 协议之请求方式
根据 HTTP 标准，HTTP 请求可以使用多种请求方法。
HTTP1.0 定义了三种请求方法： GET, POST 和 HEAD 方法。
HTTP1.1 新 增了 五种 请 求方 法： OPTIONS, PUT, DELETE, TRACE 和
CONNECT 方法。
get 和 post 请求方式的区别:
get 请求方式：
请求数据会以？的形式隔开拼接在请求头中，不安全，没有请求实体
部分。
HTTP 协议虽然没有规定请求数据的大小，但是浏览器对 URL 的长度
是有限制的，所以 get 请求不能携带大量的数据。
post 请求方式：
请求数据在请求实体中进行发送，在 URL 中看不到具体的请求数据，
安全。适合数据量大的数据发送
6、 HTTP 协议之响应
响应格式的结构：
响应行(状态行)：HTTP 版本、状态码、状态消息
响应头：消息报头，客户端使用的附加信息
空行：响应头和响应实体之间的，必须的。
响应实体：正文，服务器返回给浏览器的信息
示例：
HTTP 常见响应状态码含义：HTTP 状态码由三个十进制数字组成，第一个十进制数字定义了状态码的类型，后两个数字没有分类的作用。HTTP 状态码共分为 5 种类
常见状态码：
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和 WWWAuthenticate 报头域一起使用
403 Forbidden //服务器收到请求，但是拒绝提供服务
404 Not Found //请求资源不存在，eg：输入了错误的 URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常
Tomcat 服务器介绍和使用:服务器软件的概念和作用：
问题：学习了 java 编程之后，java 代码的一个很重要的作用就是进行数据理，但是目前来说我们运行编写的代码，只有一次性，也就是运行完毕后，需要再次运行则需要再次手动启动代码的执行。但是我们无法提前用户会何送请求，也就无法决定我们编写的 java 代码应该什么时候启动运行。而且运行也变得不现实。
解决：那么根据 java 的网络编内容，我们是不是可以使用代码编写一个容象) 呢？，该容器可以根据用户的请求来启动并运行我们编写的数据逻辑答案是可以的。
实现：服务器软件
解释：所谓服务器软件其实就是代码编写的一个可以根据用户请求实时的执行对应的逻辑代码的一个容器。
在普通用户看来就是一个安装程序。我们要将服务器在操作系统上进行安装，并将我们事先编写好的逻辑处理代码根则放到服务器的指定位置，启动服务器，那么服务器就自动的会根据接收到调用并执行对象的逻辑代码进行处理。
https://tomcat.apache.org/download-70.cgi
下载选项：
安装：
下载成功后会为压缩包文件，解压即可使用
注意：尽量不要解压在中文目录中
目录结构介绍：
\bin 存放启动和关闭 Tomcat 的可执行文件
\conf 存放 Tomcat 的配置文件
\lib 存放库文件
\logs 存放日志文件
\temp 存放临时文件
\webapps 存放 web 应用
\work 存放 JSP 转换后的 Servlet 文件
校验安装：
打开 bin 目录，然后双击执行 startup.bat 文件，打开浏览器在地址
栏中输入 localhost：8080/ 如果出现 tomcat 广告页安装成功
常见问题：
1、 tomcat 的运行依赖 JDK，必须配置 JDK 环境。配置方式参照：
https://jingyan.baidu.com/article/6dad5075d1dc40a123e36ea3.html
2、 闪退，启动闪退问题一般是因为JDK的环境变量配置有问题，
参照 1 进行重新进行配置，如果还是闪退，使用：
在 bin\startup.bat 文件中的第一行前面加入：
SET JAVA_HOME=JDK 目录
SET CATALINA_HOME=解压后 Tomcat 的目录
这样，运行 startup.bat 就可以正常启动 tomcat 服务器，如
果想点击 shutdown.bat 关闭服务器，同样在 shutdown.bat 文
件中加入上面的两行即可
Servlet 的 web.xml 配置:
配置方式一：精确配置
<url-pattern>/别名</url-pattern>
注意：
“/”是必须声明的，别名不可以改位中文
此种配置方式可以配置多个
配置方式二：模糊配置
<url-pattern>*.后缀名</url-pattern>
注意：
*表示任意个数的任意字符
所有以指定后缀名结尾的请求都会调用servlet进行处理
作用：
进行模块化开发的划分等。
配置方式三：拦截所有请求
<url-pattern>/*</url-pattern>
注意：
会拦截所有类型的请求。包括静态资源请求(css、js、图片等)和jsp请求
配置方式四：
<url-pattern>/one/*</url-pattern>
注意：
会拦截所有Servlet的别名以one开头的请求
不同的servlet不允许配置相同的url-pattern。如果配置了在服务器启动的时候就会启动报错。
服务器启动的时候就会将部署的项目中的web.xml文件加载进内存
所以综上，/不会拦截页面，只会拦截路径。
/* 会路径和页面
二、/* 和 /**
- /* 是拦截所有的文件夹，不包含子文件夹
- /** 是拦截所有的文件夹及里面的子文件夹
相当于/*只有后面一级
/** 可以包含多级
Servlet 的生命周期
Servlet 的单例创建：
Servlet的生命周期:
结论：
从第一次到被调用到服务器关闭
验证： init方法：servlet被初始化创建的时候调用
service方法：处理请求的时候
destroy方法：servlet被销毁的时候
注意：
我们可以在web.xml中配置load-on-startup来设置servlet的加载时机为服务器启动
生命周期就变为从服务器开启到服务器关闭。
package wq.servlet; import java.io.IOException; import javax.servlet.ServletConfig; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServlet; /** * Servlet的生命周期: * 结论： * 从第一次到被调用到服务器关闭 * 验证： init方法：servlet被初始化创建的时候调用 * service方法：处理请求的时候 * destroy方法：servlet被销毁的时候 * * 注意： * 我们可以在web.xml中配置load-on-startup来设置servlet的加载时机为服务器启动 * 生命周期就变为从服务器开启到服务器关闭。 * @author Administrator * */ public class LifeServlet extends HttpServlet { @Override public void init(ServletConfig config) throws ServletException { System.out.println("我被初始化了"); } @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { System.out.println("我被执行了"); } @Override public void destroy() { System.out.println("LifeServlet.destroy(我被销毁了)"); } }
<?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>03-Servlet</display-name>
<servlet>
<description>This is the description of my J2EE component</description>
<display-name>This is the display name of my J2EE component</display-name>
<servlet-name>LifeServlet</servlet-name>
<servlet-class>wq.servlet.LifeServlet</servlet-class>
<load-on-startup>1</load-on-startup><!-- 配置servlet服务器启动时完成加载和初始化创建 -->
</servlet>
<servlet-mapping>
<servlet-name>LifeServlet</servlet-name>
<url-pattern>/life</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>
Service 和 doGet 和 doPost 方法的区别
Service 方法:
不管是 get 方式还是 post 方式的请求，如果 Servlet 类中有
service 方法，则优先调用 Service 方法。
doGet 方法:
在没有 service 方法的情况下如果是 get 方式的请求所调用
的处理请求的方法
doPost 方法:
在没有 service 方法的情况下如果是 post 方式的请求所调
用的处理请求的方法
Servlet 的常见错误总结：
Servlet的常见错误：
* 404错误:资源未找到
* 原因一：在请求地址中的servlet的别名书写错误。
* 原因二：虚拟项目名称拼写错误
* 500错误：内部服务器错误
* 错误一：
* java.lang.ClassNotFoundException:
com.bjsxt.servlet.ServletMothod
* 解决：
* 在web.xml中校验servlet类的全限定路径是否拼写错误。
* 错误二：
* 因为service方法体的代码执行错误导致
* 解决：
* 根据错误提示对service方法体中的代码进行错误更改。
* 405错误:请求方式不支持
* 原因：
* 请求方式和servlet中的方法不匹配所造成的。
package com.bjsxt.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** *Servlet的生命周期: * 结论： * 从第一次被调用到服务器关闭 * 验证： * init方法 :servlet被初始化创建的时候调用 * service方法:处理请求的时候 * destory方法 :servlet被销毁的时候。 * 当服务器关闭的时候销毁servlet，触发destroy方法的执行 * 注意： * 我们可以在web.xml中配置load-on-startup来设置Servlet的加载时机为服务器启动。 * 生命周期就变为从服务器开启到服务器关闭 */ public class LifeServlet extends HttpServlet { @Override public void init() throws ServletException { System.out.println("LifeServlet.init(我被初始化了)"); } @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("LifeServlet.service(被执行了)"); } @Override public void destroy() { System.out.println("LifeServlet.destroy(我被销毁了)"); } }
package com.bjsxt.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * doGet(HttpServletRequest req, HttpServletResponse resp) * 特点: * 处理get方式的请求。 * * doPost(HttpServletRequest req, HttpServletResponse resp) * 特点： * 处理post方式的请求 * service(HttpServletRequest req, HttpServletResponse resp) * 特点： * 无论是什么类型的请求方式，服务器都会优先执行service方法。 * * 注意： * servlet中没有声明service方法，会根据请求方式调用对应的方法进行请求处理， * 如果在servlet中没有声明对应的请求处理方法，则会报405错误。 * 注意(非常重要) * tomcat服务器其实只认识service方法，如果我们自己声明的servlet中没有覆写service方法，则会执行HttpServlet中的 * service方法，而HttpServlet中的service方法会根据请求方法调用对应的doXX()方法执行请求处理。 * @author MyPC */ public class UserServlet extends HttpServlet { //doGet方法 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("UserServlet.doGet(我是get方式的请求)"); } //doPost方法 /*@Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("UserServlet.doPost(我是post方式的请求)"); } //service方法 @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("UserServlet.service(我是service方法)"); super.service(req, resp); }*/ @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //int i=5/0; System.out.println("UserServlet.service(我是service)"); //super.service(req, resp); } }
<?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>03-Servlet</display-name>
<servlet>
<description>This is the description of my J2EE component</description>
<display-name>This is the display name of my J2EE component</display-name>
<servlet-name>LifeServlet</servlet-name>
<servlet-class>com.bjsxt.servlet.LifeServlet</servlet-class>
<load-on-startup>1</load-on-startup><!-- 配置servlet服务器启动时完成加载和初始化创建 -->
</servlet>
<servlet>
<description>This is the description of my J2EE component</description>
<display-name>This is the display name of my J2EE component</display-name>
<servlet-name>UserServlet</servlet-name>
<servlet-class>com.bjsxt.servlet.UserServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LifeServlet</servlet-name>
<url-pattern>/life</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>UserServlet</servlet-name>
<url-pattern>/user</url-pattern>
</servlet-mapping>
</web-app>
<%@ page language="java" import="java.util.*" pageEncoding="utf-8" %> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <base href="<%=basePath%>"> <title>My JSP 'login.jsp' starting page</title> <meta http-equiv="pragma" content="no-cache"> <meta http-equiv="cache-control" content="no-cache"> <meta http-equiv="expires" content="0"> <meta http-equiv="keywords" content="keyword1,keyword2,keyword3"> <meta http-equiv="description" content="This is my page"> <!-- <link rel="stylesheet" type="text/css" href="styles.css"> --> </head> <body> <form action="code" method="get"> 用户名:<input type="text" name="uname" value=""/><br /> 密码: <input type="password" name="pwd" value="" /><br /> <input type="submit" value="登录" /> </form> </body> </html>
Request 对象:
request对象学习之获取请求数据
* 请求数据：
* 请求行：请求方式 请求URL 协议
* getMethod(); 返回请求方式
* getRequestURL(); 返回url
* getRequestUri(); uri
* getQueryString();//只能get能用
* getSchema(); 返回协议
* 请求头
* 请求实体
* 请求头:
* getHeader(String name)根据键名获取轻求头信息
* 注意：如果获取的请求头信息不存在返回null
* getHeaderNames() 返回存储了请求头键名的枚举集合
* 请求实体：
* getParameter(String name)根据键名获取数据
* 注意：
* 键名其实就是前端页面中的表单标签的name属性的值或者前端页面其他方式提交数据的键的名字
* 如果请求中没有对应的请求数据、则返回null.
问题：
浏览器发起请求到服务器，会遵循HTTP协议将请求数据发送给服务器。
那么服务器接受到请求的数据改怎么存储呢?不但要存，而且要保证完成性。
解决：
使用对象进行存储，服务器每接受一个请求，就创建一个对象专门的存
储此次请求的请求数据。
实现：
request 对象
解释：
服务器接收到浏览器的请求后，会创建一个 Request 对象，对象中
存储了此次请求相关的请求数据。服务器在调用 Servlet 时会将创建的
Request 对象作为实参传递给 Servlet 的方法，比如：service 方法。
使用：
获取请求头数据
获取请求行数据
获取用户数据
package wq.servlet; import java.io.IOException; import java.util.Enumeration; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * request对象学习之获取请求数据 * 请求数据： * 请求行：请求方式 请求URL 协议 * getMethod(); 返回请求方式 * getRequestURL(); 返回url * getRequestUri(); uri * getQueryString();//只能get能用 * getSchema(); 返回协议 * 请求头 * 请求实体 * 请求头: * getHeader(String name)根据键名获取轻求头信息 * 注意：如果获取的请求头信息不存在返回null * getHeaderNames() 返回存储了请求头键名的枚举集合 * 请求实体： * getParameter(String name)根据键名获取数据 * 注意： * 键名其实就是前端页面中的表单标签的name属性的值或者前端页面其他方式提交数据的键的名字 * 如果请求中没有对应的请求数据、则返回null. * @author Administrator * */ public class RequestServlet extends HttpServlet { @Override public void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //获取请求信息 //获取请求行信息 //获取请求方式 String method = req.getMethod(); System.out.println(method); //获取请求url信息 StringBuffer requestURL = req.getRequestURL(); System.out.println("请求URL"+requestURL); //获取请求uri String requestURI = req.getRequestURI(); System.out.println("请求URI"+requestURI); //获取get请求中url中的请求数据 String queryString = req.getQueryString(); System.out.println("获取get请求url中的数据:"+queryString); //获取协议 String scheme = req.getScheme(); System.out.println("获取请求协议:"+scheme); //获取请求头信息 //根据键名 获取请求头信息 String header = req.getHeader("User-Agent"); System.out.println("获取浏览器版本信息"+header); //获取请求头中键名的枚举 Enumeration headerNames = req.getHeaderNames(); while(headerNames.hasMoreElements()){ //获取请求头的键名对应的值 String name = (String)headerNames.nextElement(); //获取请求头的键名对应的值 //一次性全部获取 String value=req.getHeader(name); System.out.println(name+":"+value); } //获取请求实体数据(用户数据) //根据键名获取数据 String uname = req.getParameter("uname"); String pwd = req.getParameter("pwd"); System.out.println("请求实体数据:"+uname+":"+pwd); //获取同名不同值的实体数据 String[] favs = req.getParameterValues("fav"); for(String s:favs){ System.out.println("fav的值为:"+s); } } }
Response 对象：
resp对象处理响应学习
* 设置响应行:协议、状态码 状态消息
* resp.sendError(int status)
* 作用：可以自主的响应状态给浏览器
* 设置响应头
* addHeader(String name,String value)添加响应头
* SetHeader(String name,String value)设置响应头信息，会覆盖原有信息，如果没有此响应头则添加该信息。
* 设置响应实体(处理结果)
* resp.getwriter().writer("实体内容")；
* 注意：
* 实体内容可以分开进行响应。
*
* 注意：
* 一旦使用resp对象做出了请求响应，则意味着此次请求处理完毕。服务器在响应后会将此次请求相关的req对象和resp对象销毁。
问题：
在使用 Request 对象获取了请求数据并进行处理后，处理的结果如何显
示到浏览器中呢？
解决：
使用 Response 对象
解释：
服务器在调用指定的 Servlet 进行请求处理的时候，会给 Servlet 的方法
传递两个实参 request 和 response。其中 request 中封存了请求相关的请求
数据，而 response 则是用来进行响应的一个对象。
使用：
设置响应头
设置响应编码格式
设置响应实体
package wq.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * resp对象处理响应学习 * 设置响应行:协议、状态码 状态消息 * resp.sendError * @author Administrator * */ public class ResponseServlet extends HttpServlet { @Override public void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //获取请求数据 //处理请求数据 //响应处理结果 //设置响应行 //自定义响应404异常 // resp.sendError(404); //resp.sendError(500); //设置响应头 //添加响应头信息 resp.addHeader("mouse", "thinkpad"); resp.addHeader("moouse", "thinkpad2"); //设置响应头 // resp.setHeader("Content-Length", "20"); //resp.setHeader("mouse", "two fly birds2"); //设置响应实体 } }
请求乱码问题解决:
请求乱码：服务器获取的请求数据乱码
* post请求方式乱码
* req.setCharacterEncoding("utf-8");
* get请求方式乱码解决
* 方式一：每个数据都要单独的进行转换
* String uname=req.getParameter("uname");
String uname2=new String(uname.getBytes("iso-8859-1"),"utf-8");
方式二：
req.setCharacterEncoding("utf-8");
在tomcat的server.xml文件中的Connector标签中增加属性：useBodyEncodingForURI="true"
响应乱码问题：浏览器中显示的服务器响应数据乱码
resp.setContentType("text/html;charset=utf-8");
service代码编写流程：
设置页面的编码全部为utf-8 ,这个为pageEncoding="UTF-8"
设置请求编码格式
设置响应编码格式
获取请求信息
处理请求信息
响应处理结果
Get 方式请求：
在 service 方法中使用: req.setCharacterEncoding(“utf-8”)；
在 tomcat 服务器目录下的 conf 文件下找到 server.xml 文件，打开进行
如下配置:
Post 方式请求：
在 service 方法中使用: req.setCharacterEncoding(“utf-8”)；
package wq.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * 请求乱码：服务器获取的请求数据乱码 * post请求方式乱码 * req.setCharacterEncoding("utf-8"); * get请求方式乱码解决 * 方式一：每个数据都要单独的进行转换 * String uname=req.getParameter("uname"); String uname2=new String(uname.getBytes("iso-8859-1"),"utf-8"); 方式二： req.setCharacterEncoding("utf-8"); 在tomcat的server.xml文件中的Connector标签中增加属性：useBodyEncodingForURI="true" 响应乱码问题：浏览器中显示的服务器响应数据乱码 resp.setContentType("text/html;charset=utf-8"); service代码编写流程： 设置页面的编码全部为utf-8 ,这个为pageEncoding="UTF-8" 设置请求编码格式 设置响应编码格式 获取请求信息 处理请求信息 响应处理结果 * @author Administrator * */ public class CodeServlet extends HttpServlet { @Override public void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //设置请求编码格式 req.setCharacterEncoding("utf-8"); //获取请求数据 String uname=req.getParameter("uname"); String uname2=new String(uname.getBytes("iso-8859-1"),"utf-8"); //处理请求数据 System.out.println(uname); //设置响应编码的格式 //resp.setHeader("content-type", "text/html;charset=utf-8"); resp.setContentType("text/html;charset=utf-8"); //响应处理结果 resp.getWriter().write("请求完毕"); } }
请求转发：
问题：
服务器在接收到浏览器的请求后，仅仅使用一个
Servlet 进行请求处理，会造成不同的 Servlet 逻辑代码冗
余，Servlet 的职责不明确。
解决：
使用请求转发。
特点：
- 1.降低Servlet之间的代码冗余
- 2.一次请求转发内的Servlet共享此次请求的request和response对象。
- 3.浏览器地址栏信息，是一次请求(服务器内部转了好多次)
request的作用域：
一次请求转发内的Servlet
作用：request对用可以作为数据流转的载体。
登录代码
package wq.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * 请求乱码：服务器获取的请求数据乱码 * post请求方式乱码 * req.setCharacterEncoding("utf-8"); * get请求方式乱码解决 * 方式一：每个数据都要单独的进行转换 * String uname=req.getParameter("uname"); String uname2=new String(uname.getBytes("iso-8859-1"),"utf-8"); 方式二： req.setCharacterEncoding("utf-8"); 在tomcat的server.xml文件中的Connector标签中增加属性：useBodyEncodingForURI="true" 响应乱码问题：浏览器中显示的服务器响应数据乱码 resp.setContentType("text/html;charset=utf-8"); service代码编写流程： 设置页面的编码全部为utf-8 ,这个为pageEncoding="UTF-8" 设置请求编码格式 设置响应编码格式 获取请求信息 处理请求信息 响应处理结果 * @author Administrator * */ public class CodeServlet extends HttpServlet { @Override public void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //设置请求编码格式 req.setCharacterEncoding("utf-8"); //获取请求数据 String uname=req.getParameter("uname"); String uname2=new String(uname.getBytes("iso-8859-1"),"utf-8"); //处理请求数据 System.out.println(uname); //设置响应编码的格式 //resp.setHeader("content-type", "text/html;charset=utf-8"); resp.setContentType("text/html;charset=utf-8"); //响应处理结果 resp.getWriter().write("请求完毕"); } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class UserServlet 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"); String pwd = req.getParameter("pwd"); //处理请求信息 if("张三".equals(uname)&&"123".equals(pwd)){ resp.getWriter().write("登录成功");//响应处理结果 }else{ //resp.getWriter().write("登录失败");//响应处理结果 //请求转发 req.getRequestDispatcher("login").forward(req, resp); return ; } } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; 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"); //设置req对象中存储的请求转发流转数据 /* String str = (String) req.getAttribute("str"); System.out.println(str);*/ String str=req.getAttribute("str")==null?"": (String)req.getAttribute("str"); //获取请求数据 //处理请求数据 //响应处理结果 resp.getWriter().write("<html>"); resp.getWriter().write("<head>"); resp.getWriter().write("</head>"); resp.getWriter().write("<body>"); resp.getWriter().write("<font color=red>"+str+"</font>"+"<br/>"); resp.getWriter().write("<form action='user'method='post'>"); resp.getWriter().write("用户名：<input type='text' name='uname' value='' /><br/>"); resp.getWriter().write("密码：<input type='password' name='pwd' value='' /><br/>"); resp.getWriter().write("<input type='submit' value='提交' />"); resp.getWriter().write("</form>"); resp.getWriter().write("</body>"); resp.getWriter().write("</html>"); } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class UserServlet 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"); String pwd = req.getParameter("pwd"); //处理请求信息 if("张三".equals(uname)&&"123".equals(pwd)){ resp.getWriter().write("登录成功");//响应处理结果 }else{ //resp.getWriter().write("登录失败");//响应处理结果 //将数据存储到req对象中 req.setAttribute("str", "用户名或者密码错误"); //请求转发 req.getRequestDispatcher("login").forward(req, resp); return ; } } }
重定向
问题：
如果当前的请求，Servlet 无法进行处理怎么办?
如果使用请求转发，造成表单数据重复提交怎么办？
解决：
使用重定向
使用：
response.sendRedirect(“路径”).
本地路径为：uri
网络路径为：定向资源的 URL 信息
特点：
两次请求
cookie的使用特点：
- 如果不设置有效时间则默认存储在浏览器的内存里，浏览器关闭即失效。
- 如果设置了有效期，则存储到客户端的硬盘里，到期后自动销毁。
- 如果设置了有效路径则只有在该路径下的请求才会附带设置的cookie信息。
package wq.servlet; 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; public class MyServlet1 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 a = req.getParameter("a"); String b = req.getParameter("b"); //处理请求信息 System.out.println(a+":"+b); //响应处理结果 //创建cookie数据 Cookie c=new Cookie("b",b); c.setMaxAge(3600*24*3); //设置有效路径 c.setPath("/cookie/my2"); //响应Cookie数据 resp.addCookie(c); resp.getWriter().write("我是myservlet1,处理完毕"); } }
package wq.servlet; 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; public class MyServlet2 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 c = req.getParameter("c"); //String b = req.getParameter("b"); String bc=null; //获取cookie数据 Cookie[] cookies = req.getCookies(); for (Cookie ck : cookies) { if("b".equals(ck.getName())){ bc=ck.getValue(); } } //处理请求数据 System.out.println(c+":"+bc); //响应处理结果 //直接响应 resp.getWriter().write("我是MyServlet2,处理完毕"); //请求转发 //重定向 } }
学习 Cookie 之后，解决了不用发送请求的数据共享问题。Cookie 是
浏览器端的数据存储技术，本节课重点介绍另外一门重要的数据存储
技术，session 技术。
Session 学习:
问题：
Request 对象解决了一次请求内的不同 Servlet 的数据共享问
题，那么一个用户的不同请求的处理需要使用相同的数据怎么办呢?
解决：
使用 session 技术。
原理：
用户使用浏览器第一次向服务器发送请求，服务器在接受到请
求后，调用对应的 Servlet 进行处理。在处理过程中会给用户创建
一个 session 对象，用来存储用户请求处理相关的公共数据，并将
此 session 对象的 JSESSIONID 以 Cookie 的形式存储在浏览器中(临
时存储，浏览器关闭即失效)。用户在发起第二次请求及后续请求
时，请求信息中会附带 JSESSIONID，服务器在接收到请求后，调
用对应的 Servlet 进行请求处理，同时根据 JSESSIONID 返回其对应
的 session 对象。
特点：
Session 技术是依赖 Cookie 技术的服务器端的数据存储技术。
由服务器进行创建
每个用户独立拥有一个 session
默认存储时间为 30 分钟
作用：
解决了一个用户的不同请求的数据共享问题。
使用：
创建 Session 对象
存储数据到 session 对象
获取 session 对象
获取数据从 session 对象
如果获取 session 中不存在的数据返回 null。
1、public void setAttribute(String name,String value)设定指定名字的属性的值，并将它添加到session会话范围内，如果这个属性是会话范围内存在，则更改该属性的值。 2、public Object getAttribute(String name)在会话范围内获取指定名字的属性的值，返回值类型为object，如果该属性不存在，则返回null。 3、public void removeAttribute(String name)，删除指定名字的session属性，若该属性不存在，则出现异常。 4、public void invalidate（），使session失效。可以立即使当前会话失效，原来会话中存储的所有对象都不能再被访问。 5、public String getId( )，获取当前的会话ID。每个会话在服务器端都存在一个唯一的标示sessionID，session对象发送到浏览器的唯一数据就是sessionID，它一般存储在cookie中。 6、public void setMaxInactiveInterval(int interval) 设置会话的最大持续时间，单位是秒，负数表明会话永不失效。 7、public int getMaxInActiveInterval（）,获取会话的最大持续时间，使用时候需要一些处理
session的用法
https://blog.csdn.net/samniwu/article/details/90417160
//使用request对象的getSession()获取session，如果session不存在则创建一个
HttpSession session = request.getSession();
注意：
只要不关闭浏览器，并且 session 不失效的情况下，同一个用
户的任意请求在项目的任意Servlet中获取到的都是同一个session
对象。
作用域：
一次会话
package wq.servlet; 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对象 * HttpSession session=req.getSession(); * 存储到session中 * session.setAttribute("uname",uname); * 获取session对象 * HttpSession session=req.getSession(); * 获取session中的数据 * session.getAttribute("uname"); * 获取session中的数据 * session.getAttribute(String uname);注意:返回object类型，返回的object类型，需要强制转换 * 删除session中的数据 * session.removeAttribute(String uname);注意，如果有数据则删除，没有则什么也不做 * 流程： * 1. 浏览器发起请求到Aservlet。在Aservlet中使用req.getSession()获取session对象， * 如果此次请求中没有sessionID则创建一个新的session对象，如果没有sessionID则将其对应的session对象返回(前提是该session * 没有到对象到期销毁，就算有sessionID也会重新创建一个session。) * 2.存储数据到session对象中或者获取session中的数据或者删除session中的数据。 * 特点： * session解决了同一个不同请求的数据共享问题。 * session的作用域：浏览器不关闭，session不失校，则同一用户的任意请求获取的都是同一个session * 一次会话 * @author Administrator * */ public class ServletA 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"); //处理请求信息 System.out.println("ServletA.service():"+uname); //创建session对象 HttpSession session = req.getSession(); //存储数据到session对象中 session.setAttribute("uname", uname); System.out.println("ServletA.service:"+session.getId()); //响应结果集 //重定向 resp.sendRedirect("B"); } }
package wq.servlet; 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; public class ServletB extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //设置请求编码 req.setCharacterEncoding("utf-8"); //设置响应编码 resp.setContentType("text/html;charset=utf-8"); //获取请求信息 //获取session对象 HttpSession session = req.getSession(); //获取a的处理结果 Object uname = session.getAttribute("uname"); //处理请求数据 //打印A流转的数据 System.out.println("ServletB.service()"+uname); } }
session的设置：
session默认有效时间为30分钟，可以在tomcat下的web。xml中进行配置
注意：此种配置方式是所有的tomcat下的项目默认为30分钟，也可以在代码中使用
session.setMaxInactiveInterval(5);//设置session的有效时间，参数为整数类型的秒
session.invalidate();//销毁session
package wq.servlet; 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对象 * HttpSession session=req.getSession(); * 存储到session中 * session.setAttribute("uname",uname); * 获取session对象 * HttpSession session=req.getSession(); * 获取session中的数据 * session.getAttribute("uname"); * 获取session中的数据 * session.getAttribute(String uname);注意:返回object类型，返回的object类型，需要强制转换 * 删除session中的数据 * session.removeAttribute(String uname);注意，如果有数据则删除，没有则什么也不做 * 流程： * 1. 浏览器发起请求到Aservlet。在Aservlet中使用req.getSession()获取session对象， * 如果此次请求中没有sessionID则创建一个新的session对象，如果没有sessionID则将其对应的session对象返回(前提是该session * 没有到对象到期销毁，就算有sessionID也会重新创建一个session。) * 2.存储数据到session对象中或者获取session中的数据或者删除session中的数据。 * 特点： * session解决了同一个不同请求的数据共享问题。 * session的作用域：浏览器不关闭，session不失校，则同一用户的任意请求获取的都是同一个session * 一次会话 * @author Administrator * */ public class ServletA 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"); //处理请求信息 System.out.println("ServletA.service():"+uname); //创建session对象 HttpSession session = req.getSession(); //设置session的有效期 // session.setMaxInactiveInterval(5); //存储数据到session对象中 session.setAttribute("uname", uname); //强制销毁session //session.invalidate(); System.out.println("ServletA.service:"+session.getId()); //响应结果集 //重定向 resp.sendRedirect("B"); } }
ServletContext 对象：
问题：
Request 解决了一次请求内的数据共享问题，session 解决了
用户不同请求的数据共享问题，那么不同的用户的数据共享该怎
么办呢？
解决：
使用 ServletContext 对象
作用：
解决了不同用户的数据共享问题
原理：
ServletContext 对象由服务器进行创建，一个项目只有一个对
象。不管在项目的任意位置进行获取得到的都是同一个对象，那
么不同用户发起的请求获取到的也就是同一个对象了，该对象由
用户共同拥有。
特点：
服务器进行创建
用户共享
一个项目只有一个
生命周期：
服务器启动到服务器关闭
作用域：
项目内
使用：
获取 ServletContext 对象
使用作用域进行共享数据流转
获取 web.xml 中的全局配置
获取 webroot 下项目资源流对象
获取 webroot 下资源绝对路径
https://blog.csdn.net/qq_36371449/article/details/80314024
案例：网页浏览器次数统计，详见源码
package wq.servlet; import java.io.IOException; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class TestServletContextA 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 str="我是用户共享数据"; ServletContext sc1=this.getServletContext(); ServletContext sc2=this.getServletConfig().getServletContext(); ServletContext sc3=req.getSession().getServletContext(); System.out.println(sc1==sc2); System.out.println(sc2==sc3); //存储用户共享数据到ServletContext中 sc1.setAttribute("str", str); //响应处理结果 //直接响应 resp.getWriter().write("数据已经在ServletContext中"); } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class TestServletContextB extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.setCharacterEncoding("utf-8"); resp.setContentType("text/html;charset=utf-8"); //获取servletcontext对象 ServletContext sc = this.getServletContext(); //获取共享数据 String s = (String) sc.getAttribute("str"); //处理请求信息 System.out.println("TestServletContextB.service()"+s); } }
ServletConfig 对象:
问题：
使用 ServletContext 对象可以获取 web.xml 中的全局配置文件，
在 web.xml 中
每个 Servlet 也可以进行单独的配置，那么该怎么获取配置信
息呢？
解决：
使用 ServletConfig 对象
作用：
ServletConfig 对象是 Servlet 的专属配置对象，每个 Servlet 都
单独拥有一个 ServletConfig 对象，用来获取 web.xml 中的配置信
息。
使用：
获取 ServletConfig 对象
获取 web.xml 中 servlet 的配置信息
package wq.servlet; import java.io.File; 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 sc1=this.getServletContext(); * ServletContext sc2=this.getServletConfig().getServletContext(); * ServletContext sc2=req.getSession().getServletContext(); *存储用户共享数据 * sc.setAttribute(String name,Object value); *获取用户共享数据 * sc.getAttributed(String); *删除共享数据 * sc.removeAttributed(String name); * 获取web.xml中的全局配置属性 * * *作用：将部分动作和源码文件进行解耦，我们只需要在xml配置文件中进行相关配置就会改变代码的执行效果 * sc.getInitParameter(String name);注意返回的是String类型的数据 * 特点： * 服务器创建 * 所有用户共享 * 生命周期： * 服务器开启到服务器关闭 *获取web.xml中的全局配置属性， * @author Administrator * */ public class TestServletContextA 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 str="我是用户共享数据"; ServletContext sc1=this.getServletContext(); ServletContext sc2=this.getServletConfig().getServletContext(); ServletContext sc3=req.getSession().getServletContext(); System.out.println(sc1==sc2); System.out.println(sc2==sc3); //存储用户共享数据到ServletContext中 sc1.setAttribute("str", str); //获取 web.xml中的全局配置和属性 String f = sc1.getInitParameter("flag"); if("false".equals(f)){ System.out.println("TestServletContextA.service(关闭****资源)"); }else{ System.out.println("TestServletContextA.service(打开****资源)"); } //获取webRoot下资源的流对象 //File f2 = new File("E:\\estorexiangmu\\xiangmugongju\\apache-tomcat-8.5.34\\apache-tomcat-8.5.34\\webapps\\09\\image"); InputStream resourceAsStream = sc1.getResourceAsStream("image/abc.png"); //获取webRoot下资源的绝对路径 String path = sc1.getRealPath("image/s.png"); System.out.println(path); //获取web.xml的全局配置 //响应处理结果 //直接响应 resp.getWriter().write("数据已经在ServletContext中存储完毕"); } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class TestServletContextB extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.setCharacterEncoding("utf-8"); resp.setContentType("text/html;charset=utf-8"); //获取servletcontext对象 ServletContext sc = this.getServletContext(); //获取共享数据 String s = (String) sc.getAttribute("str"); //处理请求信息 System.out.println("TestServletContextB.service()"+s); } }
package wq.servlet; 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; 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"); //获取请求数据 //创建session HttpSession session = req.getSession(); String str = (session.getAttribute("flag")==null?"":"用户名或者密码错误"); //销毁session session.invalidate(); //处理结果集 //响应处理结果 resp.getWriter().write("<html>"); resp.getWriter().write("<head>"); resp.getWriter().write("</head>"); resp.getWriter().write("<body>"); resp.getWriter().write("<form action='user' method='get'>"); resp.getWriter().write("<font color='red'>"+str+"</font>"); resp.getWriter().write("用户名:<input type='text' name='uname' value=''/><br/>"); resp.getWriter().write("密码:<input type='password' name='pwd' value=''/><br/>"); resp.getWriter().write("<input type='submit' value='登录'/><br/>"); resp.getWriter().write("</form>"); resp.getWriter().write("</body>"); resp.getWriter().write("</html>"); } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class MainServlet extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //设置请求编码格式、 req.setCharacterEncoding("utf-8"); //设置响应编码 resp.setContentType("text/html;charset=utf-8"); //获取请求信息 ServletContext sc = this.getServletContext(); //获取计数器 int nums = (int) sc.getAttribute("nums"); //响应处理结果 //直接响应 resp.getWriter().write("<html>"); resp.getWriter().write("<head>"); resp.getWriter().write("</head>"); resp.getWriter().write("<body>"); resp.getWriter().write("<h3>欢迎"+req.getSession().getAttribute("uname") +"访问主页</h3><br/>"); resp.getWriter().write("当前网页浏览器次数为："+nums); resp.getWriter().write("<html>"); resp.getWriter().write("<html>"); resp.getWriter().write("<html>"); resp.getWriter().write("<html>"); resp.getWriter().write("</body>"); resp.getWriter().write("<html>"); resp.getWriter().write("</html>"); } }
package wq.servlet; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; /** * 1、在服务器关闭的时候将ServletContext中的计数器数据存储到nums.txt中 * 2、在服务器启动的时候将nums.txt中的数据存储到ServletContext中 * * * * * * */ public class NumServlet extends HttpServlet { //在服务器启动的时候将nums.txt中的数据存储到ServletContext中 @Override public void init() throws ServletException { //获取ServletContext对象 ServletContext sc=this.getServletContext(); //获取nums.txt中存储的浏览器次数 //获取nums.txt的绝对路径(动态获取) String path=sc.getRealPath("num/nums.txt"); //创建File对象 File f=new File(path); //读取nums.txt中的数据 //获取资源流对象 BufferedReader br=null; InputStreamReader is=null; FileInputStream fs=null; try { fs=new FileInputStream(f); is=new InputStreamReader(fs); br=new BufferedReader(is); //读取 String nums=br.readLine(); //将数据存储到ServletContext中 sc.setAttribute("nums",Integer.parseInt(nums)); System.out.println("NumServlet.init()"); } catch (Exception e) { e.printStackTrace(); }finally{ //关闭流资源 try { fs.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { is.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { br.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } //在服务器关闭的时候将ServletContext中的计数器数据存储到nums.txt中 @Override public void destroy() { //获取ServletContext对象 ServletContext sc=this.getServletContext(); //获取计数器数据 int nums=(int) sc.getAttribute("nums"); //将计数器数据存储到nums.txt文件中 //获取nums.txt文件的绝对路径(动态获取) String path=sc.getRealPath("num/nums.txt"); System.out.println("NumServlet.destroy()"); //获取nums.txt的File对象 File f=new File(path); //获取资源的流对象 BufferedWriter bw=null; OutputStreamWriter ow=null; FileOutputStream fs=null; try { //获取nums.txt的流对象 fs=new FileOutputStream(f); ow=new OutputStreamWriter(fs); bw=new BufferedWriter(ow); //将数据写入到nums.txt中 bw.write(nums+""); //刷新 bw.flush(); } catch (Exception e) { e.printStackTrace(); }finally{ //关闭流资源 try { fs.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { ow.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
package wq.servlet; import java.io.IOException; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; public class UserServlet 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"); String pwd = req.getParameter("pwd"); if("张三".equals(uname)&&"123".equals(pwd)){ //将计数器数据存储到ServletContext对象 ServletContext sc = this.getServletContext(); //存储计数器数据 Object obj = sc.getAttribute("nums"); //判断 if(obj!=null){ //计数器数据自增 int nums=(int)obj; nums=nums+1; //存储计数器数据到servletcontext对象中 sc.setAttribute("nums", nums); }else{ sc.setAttribute("nums", 1); } resp.sendRedirect("main"); }else{ HttpSession session = req.getSession(); session.setAttribute("flag", "密码或者用户名错误"); resp.sendRedirect("login"); } } }
servletconfig
package wq.servlet; 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; public class TestServletConfig extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //获取ServletConfig对象 ServletConfig sg = this.getServletConfig(); //设置请求编码格式 req.setCharacterEncoding(sg.getInitParameter("code")); //设置响应编码格式 resp.setContentType("text/html;charset=utf-8"); //获取请求信息 //获取web.xml中的属性配置 String flag = sg.getInitParameter("flag"); System.out.println(flag); //获取用户请求信息 String uname=req.getParameter("uname"); //处理请求信息 System.out.println(uname); //响应处理结果 } }
<?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>11-ServletConfig</display-name> <servlet> <description>This is the description of my J2EE component</description> <display-name>This is the display name of my J2EE component</display-name> <servlet-name>TestServletConfig</servlet-name> <servlet-class>wq.servlet.TestServletConfig</servlet-class> <init-param> <param-name>code</param-name> <param-value>true</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>TestServletConfig</servlet-name> <url-pattern>/config</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list> </web-app>
监听器
问题：在servlet技术中我们学习了request、session、application作用域对象，其主要作用是实现数据在不同场景中的灵活流转。但是数据的具体流转过程我们是看不见的，比如作用域对象是什么时候创建和销毁的，数据是什么时候存取，改变和删除的。因为具体的流转过程看不见，所以也就无法再指定的时机对数据和对象进行操作，比如session的销毁的时候，在线人数减一。
解决：
使用监听器。
概念：
servlet监听器是servlet规范定义的一种特殊类，用于监听servletContext、HttpSession和ServletRequest等域对象的创建与销毁事件，以及监听这些域对象中属性发生修改的事件。
监听对象：
Request
Session
Application
监听内容：
创建、销毁、属性改变事件
监听作用：
在事件发生之前，之后进行一些处理，比如统计在线人数。
监听request
监听session
监听application三个域对象的创建、销毁和数据的变更。
使用：
1、创建一个普通java类实现指定的接口
监听request的创建和销毁：ServletRequestListenerrequestInitialized(ServletRequestEvent sre)
requestDestroyed(ServletRequestEvent sre)
形参：
ServletRequestEvent可以获取当前监听到的request对象，对request对象的中的资源进行操作。
监听request作用域数据的变更：ServletRequestAttributeListener
attributeAdded(ServletRequestAttributeEvent srae)
attributeRemoved(ServletRequestAttributeEvent srae)
attributeReplaced(ServletRequestAttributeEvent srae)
形参：
ServletRequestAttributeEvent可以获取当前被监听到的request中的数据。
geName()返回监听到的数据的键和getValue()返回监听的到的数据的值。
监听session的创建和销毁:HttpSessionListener
sessionCreated(HttpSessionEvent se)
sessionDestroyed(HttpSessionEvent se)
形参：
获取当前被监听到的session对象
监听session的作用域数据的变更:
attributeAdded(HttpSessionBindingEvent event)
attributeRemoved(HttpSessionBindingEvent event)
attributeReplaced(HttpSessionBindingEvent event)
形参：
获取当前监听到的session中的数据 getName()返回数据的键名，getValue()返回数据的值
监听application对象的创建和销毁:ServletContextListener
contextInitialized(ServletContextEvent sce)
contextDestroyed(ServletContextEvent sce)
形参：
获取application对象
监听application对象的数据的变更:ServletContextAttributeListener
attributeAdded(ServletContextAttributeEvent event)
attributeRemoved(ServletContextAttributeEvent event)
attributeReplaced(ServletContextAttributeEvent event)
形参:获取当前被监听的数据 getName()返回数据的键名，getValue()返回数据的值
2、在项目中的web.xml中配置监听器，让监听器生效
<listener>
<listener-class>监听器类的包名和类名</listener-class>
</listener>
示例：
<listener>
<listener-class>com.bjsxt.listener.MyListener</listener-class>
</listener>
HttpSessionListener HttpSessionAttributeListener
listener
package com.bjsxt.listener; import javax.servlet.ServletContextAttributeEvent; import javax.servlet.ServletContextAttributeListener; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import javax.servlet.ServletRequest; 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; /** * * @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) { ServletRequest req = sre.getServletRequest(); System.out.println("request对象被创建了"); } //监听request对象作用域数据的增加、修改、删除 @Override public void attributeAdded(ServletRequestAttributeEvent srae) { System.out.println("request中增加了一条数据"); } @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被创建了11111"); } @Override public void sessionDestroyed(HttpSessionEvent se) { System.out.println("session被销毁了"); } //监听session数据的增加、删除、修改 @Override public void attributeAdded(HttpSessionBindingEvent event) { System.out.println("session中增加了数据"); } @Override public void attributeRemoved(HttpSessionBindingEvent event) { // TODO Auto-generated method stub } @Override public void attributeReplaced(HttpSessionBindingEvent event) { // TODO Auto-generated method stub } //监听application对象的创建(初始化)和销毁 @Override public void contextInitialized(ServletContextEvent sce) { // TODO Auto-generated method stub } @Override public void contextDestroyed(ServletContextEvent sce) { // TODO Auto-generated method stub } //监听application对象的数据的增加，删除，修改 @Override public void attributeAdded(ServletContextAttributeEvent event) { } @Override public void attributeRemoved(ServletContextAttributeEvent event) { // TODO Auto-generated method stub } @Override public void attributeReplaced(ServletContextAttributeEvent event) { // TODO Auto-generated method stub } }
servlet
package com.bjsxt.servlet; 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; public class MyServlet extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("Servlet被访问了"); //在request作用域存储数据 req.setAttribute("str","今天天气真好，适合学习"); //获取session对象 HttpSession session = req.getSession(); session.setAttribute("ss", "session中增加了一条数据"); //session.setMaxInactiveInterval(5); //session.invalidate(); } }
项目案例
listener
package com.bjsxt.listener; import javax.servlet.ServletContext; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import javax.servlet.http.HttpSessionEvent; import javax.servlet.http.HttpSessionListener; public class MyListener implements HttpSessionListener,ServletContextListener{ //监听Application对象 @Override public void contextInitialized(ServletContextEvent sce) { int count=0; //获取Application对象 ServletContext sc = sce.getServletContext(); sc.setAttribute("count",count); } @Override public void contextDestroyed(ServletContextEvent sce) { // TODO Auto-generated method stub } //监听Sesion对象 @Override public void sessionCreated(HttpSessionEvent se) { //获取Application对象中的计数器 ServletContext sc = se.getSession().getServletContext(); int count=(int) sc.getAttribute("count"); //计数器自增 ++count; //然后再将计数器存储到application中 sc.setAttribute("count", count); } @Override public void sessionDestroyed(HttpSessionEvent se) { //获取Application对象中的计数器 ServletContext sc = se.getSession().getServletContext(); int count=(int) sc.getAttribute("count"); //计数器自减 --count; //然后再将计数器存储到application中 sc.setAttribute("count", count); } }
servlet
package com.bjsxt.servlet; import java.io.IOException; import java.lang.reflect.Method; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public abstract class BaseServlet 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 methodName=req.getParameter("method"); //调用方法处理请求（动态根据方法名调用方法--->反射） try { //反射获取方法所在的类的类对象 Class cla=this.getClass(); //反射获取要被调用的方法对象 Method m=cla.getMethod(methodName, HttpServletRequest.class,HttpServletResponse.class); //反射执行方法 m.invoke(this, req,resp); } catch (Exception e) { e.printStackTrace(); } } }
package com.bjsxt.servlet; import java.io.IOException; import java.util.List; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import com.bjsxt.pojo.User; import com.bjsxt.service.UserService; import com.bjsxt.service.impl.UserServiceImpl; /*** * servlet创建一个，在service方法中动态的调用请求处理方法。 * 注意： * 请求中需要附带要调用的方法名 * * * * @author MyPC * */ public class DataServlet extends BaseServlet { //删除用户信息 public void delUserInfo(HttpServletRequest req, HttpServletResponse resp) throws IOException{ //获取请求信息 String uid=req.getParameter("uid"); //处理请求信息 //获取service对象 UserService us=new UserServiceImpl(); int i=us.delUserInfoService(uid); //响应处理结果 if(i>0){ //直接响应 resp.getWriter().write("true"); }else{ //直接响应 resp.getWriter().write("false"); } } //查询用户信息 public void selUserInfo(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{ //获取请求信息 //处理请求信息 //创建业务层对象 UserService us=new UserServiceImpl(); //调用业务层方法处理请求 List<User> lu=us.selUserInfoService(); //响应处理结果 //将结果存储到request作用域中 req.setAttribute("lu",lu); //请求转发 req.getRequestDispatcher("/user/userList2.jsp").forward(req, resp); return; } //登录处理方法 public void userLogin(HttpServletRequest req, HttpServletResponse resp) throws IOException{ System.out.println("DataServlet.userLogin(开始处理用户登录请求)"); //获取请求信息 String uname=req.getParameter("uname"); String pwd=req.getParameter("pwd"); //处理请求信息 System.out.println(uname+":"+pwd); //创建业务层对象 UserService us=new UserServiceImpl(); User u=us.getUserInfoService(uname,pwd); System.out.println("用户登录查询结果为:"+u); //响应处理结果 //创建或者获取session对象 HttpSession hs=req.getSession(); if(u!=null){//登录成功 //将用户信息存储到session中 hs.setAttribute("user",u); //重定向到main.jsp resp.sendRedirect("/project2/main.jsp"); }else{//登录失败 //将登录失败的标记添加到session中 hs.setAttribute("flag", "loginFalse"); //重定向到login.jsp resp.sendRedirect("/project2/login.jsp"); } } //退出处理方法 public void userOut(HttpServletRequest req, HttpServletResponse resp) throws IOException{ System.out.println("DataServlet.userOut(用户退出开始处理)"); //获取请求信息 //处理请求信息 //获取session HttpSession hs = req.getSession(); //销毁session hs.invalidate(); //响应处理结果 //重定向 resp.sendRedirect("/project2/login.jsp"); } //注册处理方法 public void userReg(HttpServletRequest req, HttpServletResponse resp) throws IOException{ System.out.println("DataServlet.userReg(用户注册开始处理)"); //获取请求信息 String uname=req.getParameter("uname"); String pwd=req.getParameter("pwd"); String sex=req.getParameter("sex"); int age=Integer.parseInt(req.getParameter("age")); String birthday=req.getParameter("birthday"); //处理请求信息 //获取业务层对象 UserService us=new UserServiceImpl(); //处理注册 int i=us.regUserInfoService(uname,pwd,sex,age,birthday); //响应处理结果 //获取Session对象 HttpSession hs=req.getSession(); //重定向到登录页面 if(i>0){ //给注册成功添加标记到session中 hs.setAttribute("flag", "regSuccess"); resp.sendRedirect("/project2/login.jsp"); }else{ //重定向到注册页面 resp.sendRedirect("/project2/login.jsp"); } } }
package com.bjsxt.servlet; 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; public class OutServlet extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //设置请求编码格式 req.setCharacterEncoding("utf-8"); //设置响应编码格式 resp.setContentType("text/html;charset=utf-8"); //获取请求信息 //处理请求信息 //获取session HttpSession hs = req.getSession(); //销毁session hs.invalidate(); //响应处理结果 //重定向 resp.sendRedirect("/project2/login.jsp"); } }
package com.bjsxt.servlet; 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; import com.bjsxt.service.UserService; import com.bjsxt.service.impl.UserServiceImpl; public class RegServlet 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"); String pwd=req.getParameter("pwd"); String sex=req.getParameter("sex"); int age=Integer.parseInt(req.getParameter("age")); String birthday=req.getParameter("birthday"); //处理请求信息 //获取业务层对象 UserService us=new UserServiceImpl(); //处理注册 int i=us.regUserInfoService(uname,pwd,sex,age,birthday); //响应处理结果 //获取Session对象 HttpSession hs=req.getSession(); //重定向到登录页面 if(i>0){ //给注册成功添加标记到session中 hs.setAttribute("flag", "regSuccess"); resp.sendRedirect("/project2/login.jsp"); }else{ //重定向到注册页面 resp.sendRedirect("/project2/login.jsp"); } } }
package com.bjsxt.servlet; 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; import com.bjsxt.pojo.User; import com.bjsxt.service.UserService; import com.bjsxt.service.impl.UserServiceImpl; /** * 用户登录： * 1、 用户点击登录发送请求到UserServlet * tomcat服务器接收到请求后调用UserServlet中service方法进行请求处理，并将封存了相关数据的 * request对象和response对象作为实参传递给service方法 * 2、在UserServlet中调用业务层方法进行登录业务处理 * 3、在业务层方法中调用Dao层方法完成数据库操作 * 4、完成功能跳转 * MVC分层开发： * M:model service层和dao层和实体类层 * V:view 视图层 jsp页面等 * C:controller 控制层 servlet * @author MyPC * */ public class UserServlet 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"); String pwd=req.getParameter("pwd"); //处理请求信息 System.out.println(uname+":"+pwd); //创建业务层对象 UserService us=new UserServiceImpl(); User u=us.getUserInfoService(uname,pwd); System.out.println("用户登录查询结果为:"+u); //响应处理结果 //创建或者获取session对象 HttpSession hs=req.getSession(); if(u!=null){//登录成功 //将用户信息存储到session中 hs.setAttribute("user",u); //重定向到main.jsp resp.sendRedirect("/project2/main.jsp"); }else{//登录失败 //将登录失败的标记添加到session中 hs.setAttribute("flag", "loginFalse"); //重定向到login.jsp resp.sendRedirect("/project2/login.jsp"); } } }
jsp
login.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!-- 添加前端代码书写插件 插件在资料中，将查询包放到myEclipse的安装目录中的drops文件中，然后重启myEclipse即可。 安装后快捷键为:ctrl+E 模版套用: 在自己的项目中创建模版对应的jsp文件 将jsp文件中的basepath代码移动到其他位置 然后将模版中的HTML代码整个复制到对应的jsp中 然后将basepath在移动会head标签中 将模版中的前端资源文件复制到webRoot下。 --> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title>登录</title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <script src="js/pintuer.js"></script> </head> <body> <div class="bg"></div> <div class="container"> <div class="line bouncein"> <div class="xs6 xm4 xs3-move xm4-move"> <div style="height:150px;"></div> <div class="media media-y margin-big-bottom"> </div> <form action="data" method="post"> <!-- 声明请求处理方法 --> <input type="hidden" name="method" value="userLogin"/> <div class="panel loginbox"> <div class="text-center margin-big padding-big-top"><h1>尚学堂后台管理中心</h1></div> <!-- 声明jstl进行判断 --> <c:choose> <c:when test="${sessionScope.flag=='loginFalse'}"> <div style="text-align: center;color:red;">用户名或密码错误</div> </c:when> <c:when test="${sessionScope.flag=='regSuccess'}"> <div style="text-align: center;color:red;">用户注册成功</div> </c:when> </c:choose> <c:remove var="flag" scope="session"/> <!--声明java代码块 --> <div class="panel-body" style="padding:30px; padding-bottom:10px; padding-top:10px;"> <div class="form-group"> <div class="field field-icon-right"> <input type="text" class="input input-big" name="uname" placeholder="登录账号" data-validate="required:请填写账号" /> <span class="icon icon-user margin-small"></span> </div> </div> <div class="form-group"> <div class="field field-icon-right"> <input type="password" class="input input-big" name="pwd" placeholder="登录密码" data-validate="required:请填写密码" /> <span class="icon icon-key margin-small"></span> </div> </div> <div class="form-group"> <div class="field"> <input type="text" class="input input-big" name="code" placeholder="填写右侧的验证码" data-validate="required:请填写右侧的验证码" /> <img src="images/passcode.jpg" alt="" width="100" height="32" class="passcode" style="height:43px;cursor:pointer;" onclick="this.src=this.src+'?'"> </div> </div> </div> <div style="padding:30px;"><input type="submit" class="button button-block bg-main text-big input-big" value="登录"></div> <div style="font-size: 15px;position: relative;left:300px;top:-20px;"><a href="reg.jsp">注册</a></div> </div> </form> </div> </div> </div> </body> </html>
main.jsp
<%@ page language="java" import="java.util.*,com.bjsxt.pojo.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title>后台管理中心</title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <!--声明js代码域 --> <script type="text/javascript"> $(function(){ //给退出登录添加单击事件 $("#out").click(function(){ return window.confirm("你真的要退出吗?"); }) }) </script> </head> <body style="background-color:#f2f9fd;"> <div class="header bg-main"> <div class="logo margin-big-left fadein-top"> <h1><img src="images/y.jpg" class="radius-circle rotate-hover" height="50" alt="" />尚学堂后台管理中心</h1> </div> <div style="position: relative;left:400px;top:20px;"> <span style="font-size: 15px;color:white;">当前在线人数为:${applicationScope.count}</span> </div> <div class="head-l" style="position: relative;left:850px;"><span style="font-size: 15px;color:white;">当前用户:${sessionScope.user.uname}</span> <a id="out" class="button button-little bg-red" href="data?method=userOut"><span class="icon-power-off"></span> 退出登录</a> </div> </div> <div class="leftnav"> <div class="leftnav-title"><strong><span class="icon-list"></span>菜单列表</strong></div> <h2><span class="icon-user"></span>基本设置</h2> <ul style="display:block"> <li><a href="data?method=selUserInfo" target="right"><span class="icon-caret-right"></span>查询用户信息</a></li> </ul> <h2><span class="icon-pencil-square-o"></span>栏目管理</h2> <ul> <li><a href="list.html" target="right"><span class="icon-caret-right"></span>内容管理</a></li> <li><a href="add.html" target="right"><span class="icon-caret-right"></span>添加内容</a></li> <li><a href="cate.html" target="right"><span class="icon-caret-right"></span>分类管理</a></li> </ul> </div> <script type="text/javascript"> $(function(){ $(".leftnav h2").click(function(){ $(this).next().slideToggle(200); $(this).toggleClass("on"); }) $(".leftnav ul li a").click(function(){ $("#a_leader_txt").text($(this).text()); $(".leftnav ul li a").removeClass("on"); $(this).addClass("on"); }) }); </script> <ul class="bread"> <li><a href="{:U('Index/info')}" target="right" class="icon-home"> 首页</a></li> <li><a href="##" id="a_leader_txt">网站信息</a></li> <li><b>当前语言：</b><span style="color:red;">中文</php></span> 切换语言：<a href="##">中文</a> <a href="##">英文</a> </li> </ul> <div class="admin"> <iframe scrolling="auto" rameborder="0" src="info.jsp" name="right" width="100%" height="100%"></iframe> </div> <div style="text-align:center;"> <p>来源:<a href="http://www.mycodes.net/" target="_blank">源码之家</a></p> </div> </body> </html>
register.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title></title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <script src="js/pintuer.js"></script> <!--声明js代码域 --> <script type="text/javascript"> $(function(){ //给男添加单击事件 $("#man").click(function(){ //将男的选择状态加上 $("#manSpan").addClass("icon-check"); //给女的span删除选择样式 $("#womanSpan").removeClass("icon-check"); }) //给女添加单击事件 $("#woman").click(function(){ //给女的span添加选择样式 $("#womanSpan").addClass("icon-check"); //将男的选择状态去掉 $("#manSpan").removeClass("icon-check"); }) }) </script> </head> <body> <div class="panel admin-panel"> <div class="panel-head"> <strong><span class="icon-key"></span>用户注册</strong> </div> <div class="body-content"> <form method="post" class="form-x" action="data"> <!--声明请求的方法名 --> <input type="hidden" name="method" value="userReg" /> <div class="form-group"> <div class="label"> <label for="sitename">用户名：</label> </div> <div class="field"> <input type="text" class="input w50" id="mpass" name="uname" size="50" placeholder="请输入用户名" data-validate="required:请输入用户名" /> </div> </div> <div class="form-group"> <div class="label"> <label for="sitename">新密码：</label> </div> <div class="field"> <input type="password" class="input w50" name="pwd" size="50" placeholder="请输入新密码" data-validate="required:请输入新密码,length#>=5:新密码不能小于5位" /> </div> </div> <div class="form-group"> <div class="label"> <label for="sitename">确认新密码：</label> </div> <div class="field"> <input type="password" class="input w50" size="50" placeholder="请再次输入新密码" data-validate="required:请再次输入新密码,repeat#pwd:两次输入的密码不一致" /> </div> </div> <!-- 性别 --> <div class="form-group"> <div class="label"> <label>性别：</label> </div> <div class="field"> <div class="button-group radio"> <label class="button active"> <span class="icon-check" id="manSpan"></span> <input name="sex" value="1" id="man" type="radio" checked="checked">男 </label> <label class="button active" ><span class="" id="womanSpan"></span> <input name="sex" value="0" id="woman" type="radio">女 </label> </div> </div> </div> <!-- 年龄 --> <div class="form-group"> <div class="label"> <label for="sitename">用户年龄：</label> </div> <div class="field"> <input type="text" class="input w50" id="mpass" name="age" size="50" placeholder="请输入年龄" data-validate="required:请输入年龄" /> </div> </div> <!--出生日期 --> <div class="form-group"> <div class="label"> <label for="sitename">出生日期：</label> </div> <div class="field"> <input type="date" class="input w50" id="mpass" name="birthday" size="50" /> </div> </div> <div class="form-group"> <div class="label"> <label></label> </div> <div class="field"> <button class="button bg-main icon-check-square-o" type="submit"> 提交</button> </div> </div> </form> </div> </div> </body> </html>
过滤器
问题：目前我们访问servlet,是可以直接进行访问的，没有进行任何防护。
可能会造成服务器资源的浪费，以及安全性不高。我们希望真的在请求servelt处理之前，进行一次请求的校验，符合要求在调用对应的servelt
进行处理。
解决：
使用过滤器
使用：
1.创建一个普通的java类并实现过滤器接口Fiter
2.在web.xml中配置过滤器
<filter>
<fileter-name>配置的过滤器名称</fileter-name>
<filter-class>要配置的过滤器的全限定路径：包名+类名</filter-class>
</filter>
<filter-mapping>
<filter-name>配置的过滤器名称</filter-name>
<url-pattern>过滤器拦截请求地址的范围</url-pattern>
</filter-mapping>
技能点一:过滤器之doFilter方法
作用: 服务器在接收到浏览器发过来的请求后，先解析请求信息，创建对象request和response
然后根据请求URL地址判断如果符合过滤器的过滤范围，则会调用过滤器中的doFilter来
进行请求拦截，并将request和response对象作为实参传递给doFilter方法。我们
可以在doFilter方法中声明过滤器拦截代码。
参数:
ServletRequest:接收此次拦截的请求的request实参
ServletResponse:接收此次拦截的请求的response实参
FilterChain：可以进行请求放行
chain.doFilter(request, response);
技能点二:过滤器之init和destory方法
init方法：服务器启动时调用
destory方法：服务器关闭时调用
证明：过滤器的生命周期为从服务器开启到服务器关闭
技能点三:过滤器之拦截范围配置
拦截所有:/*
拦截部分Servlet的请求:*.do
拦截指定Servlet的请求:和要拦截的指定的Servlet的url-pattern配置完全一致即可，例如：/my
注意：过滤器之间会出现多重拦截，如果是按照拦截拦截范围的大小在web.xml中自大而小进行的配置
则会先执行大范围的拦截器，再执行小范围的拦截器。
<?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"> <!-- 配置过滤器: 全局拦截器 --> <filter> <filter-name>myFilter3</filter-name> <filter-class>com.szxy.filter.MyFilter3</filter-class> </filter> <filter-mapping> <filter-name>myFilter3</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- 配置过滤器: 部分拦截器 --> <filter> <filter-name>myFilter2</filter-name> <filter-class>com.szxy.filter.MyFilter2</filter-class> </filter> <filter-mapping> <filter-name>myFilter2</filter-name> <url-pattern>*.do</url-pattern> </filter-mapping> <!-- 配置过滤器: 特定拦截器 --> <filter> <filter-name>MyFilter</filter-name> <filter-class>com.szxy.filter.MyFilter</filter-class> </filter> <filter-mapping> <filter-name>MyFilter</filter-name> <url-pattern>/my.do</url-pattern> </filter-mapping> <servlet> <servlet-name>MyServlet</servlet-name> <servlet-class>com.szxy.servlet.MyServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>MyServlet</servlet-name> <url-pattern>/my.do</url-pattern> </servlet-mapping> </web-app>
filter
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; 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(我是过滤器MyFilter:小区门口的保安)"); //放行 chain.doFilter(request, response); System.out.println("aaaa"); } @Override public void destroy() { System.out.println("MyFilter.destroy()"); } }
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; public class MyFilter2 implements Filter{ @Override public void init(FilterConfig filterConfig) throws ServletException { // TODO Auto-generated method stub } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("MyFilter2.doFilter(我是楼门口的保安)"); chain.doFilter(request, response); } @Override public void destroy() { // TODO Auto-generated method stub } }
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; public class MyFilter3 implements Filter{ @Override public void init(FilterConfig filterConfig) throws ServletException { // TODO Auto-generated method stub } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("MyFilter3.doFilter(我是张三家门口的保安)"); chain.doFilter(request, response); } @Override public void destroy() { // TODO Auto-generated method stub } }
servlet
package com.bjsxt.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class MyServlet extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("我是MyServlet,我被访问了：张三家"); } }
Filter案例之统一请求编码格式
dao
package com.bjsxt.dao.impl; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.util.ArrayList; import java.util.List; import com.bjsxt.dao.UserDao; import com.bjsxt.pojo.Url; import com.bjsxt.pojo.User; import com.bjsxt.util.DBUtil; public class UserDaoImpl implements UserDao { //查询用户信息 @Override public User getUserInfoDao(String uname, String pwd) { //声明jdbc变量 Connection conn=null; PreparedStatement ps=null; ResultSet rs=null; //声明变量 User u=null; try { //创建连接 conn=DBUtil.getConnection(); //创建SQL命令 String sql="select * from t_user where uname=? and pwd=?"; //创建SQL命令对象 ps=conn.prepareStatement(sql); //给占位符赋值 ps.setString(1,uname); ps.setString(2, pwd); //执行SQL命令 rs=ps.executeQuery(); //遍历 while(rs.next()){ //给变量赋值 u=new User(); u.setUid(rs.getInt("uid")); u.setUname(rs.getString("uname")); u.setPwd(rs.getString("pwd")); u.setSex(rs.getString("sex")); u.setAge(rs.getInt("age")); u.setBirthday(rs.getString("birthday")); } } catch (Exception e) { e.printStackTrace(); }finally{//关闭资源 DBUtil.closeAll(rs, ps, conn); } //返回结果 return u; } //用户注册 @Override public int regUserInfoDao(String uname, String pwd, String sex, int age, String birthday) { //创建SQL语句 String sql="insert into t_user values(default,?,?,?,?,?)"; return DBUtil.executeDML(sql, uname,pwd,sex,age,birthday); } //查询所有的用户信息 @Override public List<User> selUserInfoDao() { //声明jdbc变量 Connection conn=null; PreparedStatement ps=null; ResultSet rs=null; //声明变量 List<User> lu=null; try { //创建连接 conn=DBUtil.getConnection(); //创建SQL命令 String sql="select * from t_user"; //创建SQL命令对象 ps=conn.prepareStatement(sql); //执行SQL命令 rs=ps.executeQuery(); //给list集合赋值 lu=new ArrayList<>(); //遍历 while(rs.next()){ //给变量赋值 User u=new User(); u.setUid(rs.getInt("uid")); u.setUname(rs.getString("uname")); u.setPwd(rs.getString("pwd")); u.setSex(rs.getString("sex")); u.setAge(rs.getInt("age")); u.setBirthday(rs.getString("birthday")); lu.add(u); } } catch (Exception e) { e.printStackTrace(); }finally{//关闭资源 DBUtil.closeAll(rs, ps, conn); } //返回结果 return lu; } //删除用户信息 @Override public int delUserInfoDao(String uid) { //声明SQL语句 String sql="delete from t_user where uid=?"; return DBUtil.executeDML(sql, uid); } //查询当前用户的URL权限信息 @Override public List<Url> getUserUrlInfoDao(int uid) { //声明jdbc变量 Connection conn=null; PreparedStatement ps=null; ResultSet rs=null; //声明变量 List<Url> lu=null; try { //创建连接 conn=DBUtil.getConnection(); //创建SQL命令 String sql="select * from t_url where urlid in (select urlid from t_user_url where uid=?)"; //创建SQL命令对象 ps=conn.prepareStatement(sql); //给占位符赋值 ps.setInt(1, uid); //执行SQL命令 rs=ps.executeQuery(); //给list集合赋值 lu=new ArrayList<>(); //遍历 while(rs.next()){ //给变量赋值 Url u=new Url(); u.setUrlid(rs.getInt("urlid")); u.setLocation(rs.getString("location")); u.setRemark(rs.getString("remark")); lu.add(u); } } catch (Exception e) { e.printStackTrace(); }finally{//关闭资源 DBUtil.closeAll(rs, ps, conn); } //返回结果 return lu; } }
package com.bjsxt.dao; import java.util.List; import com.bjsxt.pojo.Url; import com.bjsxt.pojo.User; public interface UserDao { /** * 根据用户名和密码查询用户信息 * @param uname * @param pwd * @return */ User getUserInfoDao(String uname, String pwd); /** * 用户注册 * @param uname * @param pwd * @param sex * @param age * @param birthday * @return */ int regUserInfoDao(String uname, String pwd, String sex, int age, String birthday); /** * 查询所有用户信息 * @return */ List<User> selUserInfoDao(); /** * 删除用户信息 * @param uid * @return */ int delUserInfoDao(String uid); /** * 查询用户的URL权限 * @param uid * @return */ List<Url> getUserUrlInfoDao(int uid); }
filter
package com.bjsxt.filter; import java.io.IOException; import java.util.List; 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; import com.bjsxt.pojo.Url; /** * Filter案例之统一编码格式: * 在doFilter中使用 * //设置请求编码格式 request.setCharacterEncoding("utf-8"); //设置响应编码格式 response.setContentType("text/html;charset=utf-8"); Filter案例之session管理 在过滤器中获取session对象，然后查看session中的数据是否还在 如果数据没了，则因为session失效则重定向到登录页面。如果数据还在 session没有失效，则放行 问题1： 在过滤器中使用session校验后发现登录页面的访问成了死循环，因为登录页面的 请求也就是login.jsp的请求也会被过滤器拦截，而此时session中没有相关数据的 造成又重定向到登录页面...... 解决1： 对login.jsp和登录请求进行放行 问题2： 过滤器会拦截所有的请求，包括静态资源（css文件\js文件\image图片）请求也会拦截。 造成页面中的样式和动态效果等出不来 解决2： 对静态资源放行 Filter案例之权限管理 需求： 不同的用户在对同一功能使用时，有的用户可以直接使用，有的用户会被提示权限不足。 思路： 1、在数据库中创建一个URL权限表，该表存储了该系统需要被管理的URL。 2、在数据库中创建用户权限中间表，用来进行权限分配 3、在数据库中将权限给用户分配好 4、在用户登录成功后查询该用户具备的URL权限，存储到该用户的session中 5、在过滤器中对当前发起请求的用户的请求地址进行校验，校验该用户是否具备该请求地址的 权限，如果具备则放行执行，如果不具备则提示权限不足。 数据库设计： URL权限表：t_url 编号: urlid url地址 :location 描述：remark 用户权限中间表：t_user_url uid urlid SQL语句的设计:查询当前登录用户的url信息 子查询: select * from t_url where urlid in (select urlid from t_user_url where uid=8) 联合查询: select * from t_url tu,t_user_url tul where tu.urlid=tul.urlid and tul.uid=8 * @author MyPC * */ public class MyFilter implements Filter{ @Override public void init(FilterConfig filterConfig) throws ServletException { // TODO Auto-generated method stub } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { //设置请求编码格式 request.setCharacterEncoding("utf-8"); //设置响应编码格式 response.setContentType("text/html;charset=utf-8"); //强转request对象 HttpServletRequest req=((HttpServletRequest)request); //强转response对象 HttpServletResponse resp=((HttpServletResponse)response); //获取此次请求uri String uri=req.getRequestURI(); //获取此次请求的method String method=req.getParameter("method"); System.out.println("当前请求的uri为:"+uri); //放行登录页面 放行登录请求 放行静态资源 if("/project2/login.jsp".equals(uri) || ("/project2/data".equals(uri)&& "userLogin".equals(method)) || uri.startsWith("/project2/css/") || uri.startsWith("/project2/js/")|| uri.startsWith("/project2/images/")){ //放行 chain.doFilter(request, response); }else{ //session管理(session统一校验) //获取Session对象 HttpSession session = req.getSession(); Object obj=session.getAttribute("user"); //判断 if(obj!=null){ //获取权限信息 List<Url> lu=(List<Url>) session.getAttribute("lu"); //权限校验 for(Url url:lu){ if(url.getLocation().equals(method) || url.getLocation().equals(uri)){ //放行 chain.doFilter(request, response); return; } } //响应 resp.getWriter().write("power"); return; }else{ //重定向到登录页面 resp.sendRedirect("/project2/login.jsp"); } } } @Override public void destroy() { // TODO Auto-generated method stub } }
listener
package com.bjsxt.listener; import javax.servlet.ServletContext; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import javax.servlet.http.HttpSessionEvent; import javax.servlet.http.HttpSessionListener; public class MyListener implements HttpSessionListener,ServletContextListener{ //监听Application对象 @Override public void contextInitialized(ServletContextEvent sce) { int count=0; //获取Application对象 ServletContext sc = sce.getServletContext(); sc.setAttribute("count",count); } @Override public void contextDestroyed(ServletContextEvent sce) { // TODO Auto-generated method stub } //监听Sesion对象 @Override public void sessionCreated(HttpSessionEvent se) { //获取Application对象中的计数器 ServletContext sc = se.getSession().getServletContext(); int count=(int) sc.getAttribute("count"); //计数器自增 ++count; //然后再将计数器存储到application中 sc.setAttribute("count", count); } @Override public void sessionDestroyed(HttpSessionEvent se) { //获取Application对象中的计数器 ServletContext sc = se.getSession().getServletContext(); int count=(int) sc.getAttribute("count"); //计数器自减 --count; //然后再将计数器存储到application中 sc.setAttribute("count", count); } }
pojo
package com.bjsxt.pojo; public class Url { private int urlid; private String location; private String remark; public int getUrlid() { return urlid; } public void setUrlid(int urlid) { this.urlid = urlid; } public String getLocation() { return location; } public void setLocation(String location) { this.location = location; } public String getRemark() { return remark; } public void setRemark(String remark) { this.remark = remark; } @Override public String toString() { return "Url [urlid=" + urlid + ", location=" + location + ", remark=" + remark + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((location == null) ? 0 : location.hashCode()); result = prime * result + ((remark == null) ? 0 : remark.hashCode()); result = prime * result + urlid; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Url other = (Url) obj; if (location == null) { if (other.location != null) return false; } else if (!location.equals(other.location)) return false; if (remark == null) { if (other.remark != null) return false; } else if (!remark.equals(other.remark)) return false; if (urlid != other.urlid) return false; return true; } public Url() { super(); // TODO Auto-generated constructor stub } public Url(int urlid, String location, String remark) { super(); this.urlid = urlid; this.location = location; this.remark = remark; } }
package com.bjsxt.pojo; public class User { private int uid; private String uname; private String pwd; private String sex; private int age; private String birthday; public int getUid() { return uid; } public void setUid(int uid) { this.uid = uid; } public String getUname() { return uname; } public void setUname(String uname) { this.uname = uname; } public String getPwd() { return pwd; } public void setPwd(String pwd) { this.pwd = pwd; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getBirthday() { return birthday; } public void setBirthday(String birthday) { this.birthday = birthday; } @Override public String toString() { return "User [uid=" + uid + ", uname=" + uname + ", pwd=" + pwd + ", sex=" + sex + ", age=" + age + ", birthday=" + birthday + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((birthday == null) ? 0 : birthday.hashCode()); result = prime * result + ((pwd == null) ? 0 : pwd.hashCode()); result = prime * result + ((sex == null) ? 0 : sex.hashCode()); result = prime * result + uid; result = prime * result + ((uname == null) ? 0 : uname.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; User other = (User) obj; if (age != other.age) return false; if (birthday == null) { if (other.birthday != null) return false; } else if (!birthday.equals(other.birthday)) return false; if (pwd == null) { if (other.pwd != null) return false; } else if (!pwd.equals(other.pwd)) return false; if (sex == null) { if (other.sex != null) return false; } else if (!sex.equals(other.sex)) return false; if (uid != other.uid) return false; if (uname == null) { if (other.uname != null) return false; } else if (!uname.equals(other.uname)) return false; return true; } public User() { super(); // TODO Auto-generated constructor stub } public User(int uid, String uname, String pwd, String sex, int age, String birthday) { super(); this.uid = uid; this.uname = uname; this.pwd = pwd; this.sex = sex; this.age = age; this.birthday = birthday; } }
service
package com.bjsxt.service; import java.util.List; import com.bjsxt.pojo.Url; import com.bjsxt.pojo.User; public interface UserService { /** * 用户登录 * @param uname * @param pwd * @return */ User getUserInfoService(String uname, String pwd); /** * 用户注册 * @param uname * @param pwd * @param sex * @param age * @param birthday * @return */ int regUserInfoService(String uname, String pwd, String sex, int age, String birthday); /** * 获取所有的用户信息 * @return */ List<User> selUserInfoService(); /** * 删除用户信息 * @param uid * @return */ int delUserInfoService(String uid); /** * 查询当前用户的URL权限信息 * @param uid * @return */ List<Url> getUserUrlInfoService(int uid); }
package com.bjsxt.service.impl; import java.util.List; import com.bjsxt.dao.UserDao; import com.bjsxt.dao.impl.UserDaoImpl; import com.bjsxt.pojo.Url; import com.bjsxt.pojo.User; import com.bjsxt.service.UserService; public class UserServiceImpl implements UserService { //创建Dao层对象 UserDao ud=new UserDaoImpl(); @Override public User getUserInfoService(String uname, String pwd) { //处理登录业务 return ud.getUserInfoDao(uname,pwd); } //用户注册 @Override public int regUserInfoService(String uname, String pwd, String sex, int age, String birthday) { //处理注册业务 return ud.regUserInfoDao(uname,pwd,sex,age,birthday); } //获取所有的用户信息 @Override public List<User> selUserInfoService() { //处理注册业务 return ud.selUserInfoDao(); } //删除用户信息 @Override public int delUserInfoService(String uid) { //处理删除业务 return ud.delUserInfoDao(uid); } //查询当前用户的url权限信息 @Override public List<Url> getUserUrlInfoService(int uid) { return ud.getUserUrlInfoDao(uid); } }
servlet
BaseServlet
package com.bjsxt.servlet; import java.io.IOException; import java.lang.reflect.Method; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public abstract class BaseServlet 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 methodName=req.getParameter("method"); //调用方法处理请求（动态根据方法名调用方法--->反射） try { //反射获取方法所在的类的类对象 Class cla=this.getClass(); //反射获取要被调用的方法对象 Method m=cla.getMethod(methodName, HttpServletRequest.class,HttpServletResponse.class); //反射执行方法 m.invoke(this, req,resp); } catch (Exception e) { e.printStackTrace(); } } }
DataServlet
package com.bjsxt.servlet; import java.io.IOException; import java.util.List; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import com.bjsxt.pojo.Url; import com.bjsxt.pojo.User; import com.bjsxt.service.UserService; import com.bjsxt.service.impl.UserServiceImpl; /*** * servlet创建一个，在service方法中动态的调用请求处理方法。 * 注意： * 请求中需要附带要调用的方法名 * @author MyPC * */ public class DataServlet extends BaseServlet { //删除用户信息 public void delUserInfo(HttpServletRequest req, HttpServletResponse resp) throws IOException{ //获取请求信息 String uid=req.getParameter("uid"); //处理请求信息 //获取service对象 UserService us=new UserServiceImpl(); int i=us.delUserInfoService(uid); //响应处理结果 if(i>0){ //直接响应 resp.getWriter().write("true"); }else{ //直接响应 resp.getWriter().write("false"); } } //查询用户信息 public void selUserInfo(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{ //获取请求信息 //处理请求信息 //创建业务层对象 UserService us=new UserServiceImpl(); //调用业务层方法处理请求 List<User> lu=us.selUserInfoService(); //响应处理结果 //将结果存储到request作用域中 req.setAttribute("lu",lu); //请求转发 req.getRequestDispatcher("/user/userList2.jsp").forward(req, resp); return; } //登录处理方法 public void userLogin(HttpServletRequest req, HttpServletResponse resp) throws IOException{ System.out.println("DataServlet.userLogin(开始处理用户登录请求)"); //获取请求信息 String uname=req.getParameter("uname"); String pwd=req.getParameter("pwd"); //处理请求信息 System.out.println(uname+":"+pwd); //创建业务层对象 UserService us=new UserServiceImpl(); User u=us.getUserInfoService(uname,pwd); System.out.println("用户登录查询结果为:"+u); //响应处理结果 //创建或者获取session对象 HttpSession hs=req.getSession(); if(u!=null){//登录成功 //查询当前用户的URL权限 List<Url> lu=us.getUserUrlInfoService(u.getUid()); System.out.println(lu); //将url权限数据存储到session中 hs.setAttribute("lu",lu); //将用户信息存储到session中 hs.setAttribute("user",u); //重定向到main.jsp resp.sendRedirect("/project2/main.jsp"); }else{//登录失败 //将登录失败的标记添加到session中 hs.setAttribute("flag", "loginFalse"); //重定向到login.jsp resp.sendRedirect("/project2/login.jsp"); } } //退出处理方法 public void userOut(HttpServletRequest req, HttpServletResponse resp) throws IOException{ System.out.println("DataServlet.userOut(用户退出开始处理)"); //获取请求信息 //处理请求信息 //获取session HttpSession hs = req.getSession(); //销毁session hs.invalidate(); //响应处理结果 //重定向 resp.sendRedirect("/project2/login.jsp"); } //注册处理方法 public void userReg(HttpServletRequest req, HttpServletResponse resp) throws IOException{ System.out.println("DataServlet.userReg(用户注册开始处理)"); //获取请求信息 String uname=req.getParameter("uname"); String pwd=req.getParameter("pwd"); String sex=req.getParameter("sex"); int age=Integer.parseInt(req.getParameter("age")); String birthday=req.getParameter("birthday"); //处理请求信息 //获取业务层对象 UserService us=new UserServiceImpl(); //处理注册 int i=us.regUserInfoService(uname,pwd,sex,age,birthday); //响应处理结果 //获取Session对象 HttpSession hs=req.getSession(); //重定向到登录页面 if(i>0){ //给注册成功添加标记到session中 hs.setAttribute("flag", "regSuccess"); resp.sendRedirect("/project2/login.jsp"); }else{ //重定向到注册页面 resp.sendRedirect("/project2/login.jsp"); } } }
OutServlet
package com.bjsxt.servlet; 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; public class OutServlet extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //设置请求编码格式 req.setCharacterEncoding("utf-8"); //设置响应编码格式 resp.setContentType("text/html;charset=utf-8"); //获取请求信息 //处理请求信息 //获取session HttpSession hs = req.getSession(); //销毁session hs.invalidate(); //响应处理结果 //重定向 resp.sendRedirect("/project2/login.jsp"); } }
RegisterServlet
package com.bjsxt.servlet; 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; import com.bjsxt.service.UserService; import com.bjsxt.service.impl.UserServiceImpl; public class RegServlet 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"); String pwd=req.getParameter("pwd"); String sex=req.getParameter("sex"); int age=Integer.parseInt(req.getParameter("age")); String birthday=req.getParameter("birthday"); //处理请求信息 //获取业务层对象 UserService us=new UserServiceImpl(); //处理注册 int i=us.regUserInfoService(uname,pwd,sex,age,birthday); //响应处理结果 //获取Session对象 HttpSession hs=req.getSession(); //重定向到登录页面 if(i>0){ //给注册成功添加标记到session中 hs.setAttribute("flag", "regSuccess"); resp.sendRedirect("/project2/login.jsp"); }else{ //重定向到注册页面 resp.sendRedirect("/project2/login.jsp"); } } }
UserServlet
package com.bjsxt.servlet; 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; import com.bjsxt.pojo.User; import com.bjsxt.service.UserService; import com.bjsxt.service.impl.UserServiceImpl; /** * 用户登录： * 1、 用户点击登录发送请求到UserServlet * tomcat服务器接收到请求后调用UserServlet中service方法进行请求处理，并将封存了相关数据的 * request对象和response对象作为实参传递给service方法 * 2、在UserServlet中调用业务层方法进行登录业务处理 * 3、在业务层方法中调用Dao层方法完成数据库操作 * 4、完成功能跳转 * MVC分层开发： * M:model service层和dao层和实体类层 * V:view 视图层 jsp页面等 * C:controller 控制层 servlet * @author MyPC * */ public class UserServlet 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"); String pwd=req.getParameter("pwd"); //处理请求信息 System.out.println(uname+":"+pwd); //创建业务层对象 UserService us=new UserServiceImpl(); User u=us.getUserInfoService(uname,pwd); System.out.println("用户登录查询结果为:"+u); //响应处理结果 //创建或者获取session对象 HttpSession hs=req.getSession(); if(u!=null){//登录成功 //将用户信息存储到session中 hs.setAttribute("user",u); //重定向到main.jsp resp.sendRedirect("/project2/main.jsp"); }else{//登录失败 //将登录失败的标记添加到session中 hs.setAttribute("flag", "loginFalse"); //重定向到login.jsp resp.sendRedirect("/project2/login.jsp"); } } }
DBUtils
package com.bjsxt.util; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.Properties; public class DBUtil { //声明全局变量记录jdbc参数 private static String driver; private static String url; private static String username; private static String password; //使用静态代码块，在类加载时即完成对属性文件的读取 static{ //动态获取属性配置文件的流对象 InputStream in=DBUtil.class.getResourceAsStream("/db.properties"); //创建Properties对象 Properties p=new Properties(); //加载 try { p.load(in);//会将属性配置文件的所有数据存储到Properties对象中 //将读取的jdbc参数赋值给全局变量 driver=p.getProperty("driver"); url=p.getProperty("url"); username=p.getProperty("username"); password=p.getProperty("password"); //加载驱动 Class.forName(driver); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //创建连接对象并返回 public static Connection getConnection(){ Connection conn=null; try { conn = DriverManager.getConnection(url, username, password); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return conn; } //关闭资源 public static void closeAll(ResultSet rs,Statement stmt,Connection conn){ try { if(rs!=null){ rs.close(); } } catch (SQLException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } try { stmt.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { conn.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //封装增加删除修改的通用工具方法 /** * @param sql SQL语句 * @param objs SQL语句占位符实参，如果没有参数则传入null * @return 返回增删改的结果，类型为int */ public static int executeDML(String sql,Object...objs){ // 声明jdbc变量 Connection conn = null; PreparedStatement ps = null; int i = -1; try { // 获取连接对象 conn = DBUtil.getConnection(); // 开启事务管理 conn.setAutoCommit(false); // 创建SQL命令对象 ps = conn.prepareStatement(sql); // 给占位符赋值 if(objs!=null){ for(int j=0;j<objs.length;j++){ ps.setObject(j+1,objs[j]); } } // 执行SQL i = ps.executeUpdate(); conn.commit(); } catch (Exception e) { try { conn.rollback(); } catch (SQLException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } e.printStackTrace(); } finally { DBUtil.closeAll(null, ps, conn); } return i; } }
db.properties
driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/project username=root password=1234
Web.xml
<?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"> <!-- 配置过滤器 --> <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> <!--配置监听器 --> <listener> <listener-class>com.bjsxt.listener.MyListener</listener-class> </listener> <listener> <listener-class>com.bjsxt.listener.MyListener</listener-class> </listener> <display-name>14-project</display-name> <servlet> <description>This is the description of my J2EE component</description> <display-name>This is the display name of my J2EE component</display-name> <servlet-name>UserServlet</servlet-name> <servlet-class>com.bjsxt.servlet.UserServlet</servlet-class> </servlet> <servlet> <description>This is the description of my J2EE component</description> <display-name>This is the display name of my J2EE component</display-name> <servlet-name>OutServlet</servlet-name> <servlet-class>com.bjsxt.servlet.OutServlet</servlet-class> </servlet> <servlet> <description>This is the description of my J2EE component</description> <display-name>This is the display name of my J2EE component</display-name> <servlet-name>RegServlet</servlet-name> <servlet-class>com.bjsxt.servlet.RegServlet</servlet-class> </servlet> <servlet> <description>This is the description of my J2EE component</description> <display-name>This is the display name of my J2EE component</display-name> <servlet-name>DataServlet</servlet-name> <servlet-class>com.bjsxt.servlet.DataServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>UserServlet</servlet-name> <url-pattern>/user</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>OutServlet</servlet-name> <url-pattern>/out</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>RegServlet</servlet-name> <url-pattern>/reg</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>DataServlet</servlet-name> <url-pattern>/data</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list> </web-app>
info.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title>网站信息</title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <script src="js/pintuer.js"></script> </head> <body> <div class="panel admin-panel"> <div class="panel-head"><strong><span class="icon-pencil-square-o"></span> 网站信息</strong></div> <div class="body-content"> <form method="post" class="form-x" action=""> <div class="form-group"> <div class="label"> <label>网站标题：</label> </div> <div class="field"> <input type="text" class="input" name="stitle" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>网站LOGO：</label> </div> <div class="field"> <input type="text" id="url1" name="slogo" class="input tips" style="width:25%; float:left;" value="" data-toggle="hover" data-place="right" data-image="" /> <input type="button" class="button bg-blue margin-left" id="image1" value="+ 浏览上传" > </div> </div> <div class="form-group"> <div class="label"> <label>网站域名：</label> </div> <div class="field"> <input type="text" class="input" name="surl" value="" /> </div> </div> <div class="form-group" style="display:none"> <div class="label"> <label>副加标题：</label> </div> <div class="field"> <input type="text" class="input" name="sentitle" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>网站关键字：</label> </div> <div class="field"> <textarea class="input" name="skeywords" style="height:80px"></textarea> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>网站描述：</label> </div> <div class="field"> <textarea class="input" name="sdescription"></textarea> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>联系人：</label> </div> <div class="field"> <input type="text" class="input" name="s_name" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>手机：</label> </div> <div class="field"> <input type="text" class="input" name="s_phone" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>电话：</label> </div> <div class="field"> <input type="text" class="input" name="s_tel" value="" /> <div class="tips"></div> </div> </div> <div class="form-group" style="display:none;"> <div class="label"> <label>400电话：</label> </div> <div class="field"> <input type="text" class="input" name="s_400" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>传真：</label> </div> <div class="field"> <input type="text" class="input" name="s_fax" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>QQ：</label> </div> <div class="field"> <input type="text" class="input" name="s_qq" value="" /> <div class="tips"></div> </div> </div> <div class="form-group" style="display:none"> <div class="label"> <label>QQ群：</label> </div> <div class="field"> <input type="text" class="input" name="s_qqu" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>Email：</label> </div> <div class="field"> <input type="text" class="input" name="s_email" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>地址：</label> </div> <div class="field"> <input type="text" class="input" name="s_address" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>底部信息：</label> </div> <div class="field"> <textarea name="scopyright" class="input" style="height:120px;"></textarea> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label></label> </div> <div class="field"> <button class="button bg-main icon-check-square-o" type="submit"> 提交</button> </div> </div> </form> </div> </div> </body></html>
login.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title>网站信息</title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <script src="js/pintuer.js"></script> </head> <body> <div class="panel admin-panel"> <div class="panel-head"><strong><span class="icon-pencil-square-o"></span> 网站信息</strong></div> <div class="body-content"> <form method="post" class="form-x" action=""> <div class="form-group"> <div class="label"> <label>网站标题：</label> </div> <div class="field"> <input type="text" class="input" name="stitle" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>网站LOGO：</label> </div> <div class="field"> <input type="text" id="url1" name="slogo" class="input tips" style="width:25%; float:left;" value="" data-toggle="hover" data-place="right" data-image="" /> <input type="button" class="button bg-blue margin-left" id="image1" value="+ 浏览上传" > </div> </div> <div class="form-group"> <div class="label"> <label>网站域名：</label> </div> <div class="field"> <input type="text" class="input" name="surl" value="" /> </div> </div> <div class="form-group" style="display:none"> <div class="label"> <label>副加标题：</label> </div> <div class="field"> <input type="text" class="input" name="sentitle" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>网站关键字：</label> </div> <div class="field"> <textarea class="input" name="skeywords" style="height:80px"></textarea> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>网站描述：</label> </div> <div class="field"> <textarea class="input" name="sdescription"></textarea> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>联系人：</label> </div> <div class="field"> <input type="text" class="input" name="s_name" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>手机：</label> </div> <div class="field"> <input type="text" class="input" name="s_phone" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>电话：</label> </div> <div class="field"> <input type="text" class="input" name="s_tel" value="" /> <div class="tips"></div> </div> </div> <div class="form-group" style="display:none;"> <div class="label"> <label>400电话：</label> </div> <div class="field"> <input type="text" class="input" name="s_400" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>传真：</label> </div> <div class="field"> <input type="text" class="input" name="s_fax" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>QQ：</label> </div> <div class="field"> <input type="text" class="input" name="s_qq" value="" /> <div class="tips"></div> </div> </div> <div class="form-group" style="display:none"> <div class="label"> <label>QQ群：</label> </div> <div class="field"> <input type="text" class="input" name="s_qqu" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>Email：</label> </div> <div class="field"> <input type="text" class="input" name="s_email" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>地址：</label> </div> <div class="field"> <input type="text" class="input" name="s_address" value="" /> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label>底部信息：</label> </div> <div class="field"> <textarea name="scopyright" class="input" style="height:120px;"></textarea> <div class="tips"></div> </div> </div> <div class="form-group"> <div class="label"> <label></label> </div> <div class="field"> <button class="button bg-main icon-check-square-o" type="submit"> 提交</button> </div> </div> </form> </div> </div> </body></html>
main.jsp
<%@ page language="java" import="java.util.*,com.bjsxt.pojo.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title>后台管理中心</title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <!--声明js代码域 --> <script type="text/javascript"> $(function(){ //给退出登录添加单击事件 $("#out").click(function(){ return window.confirm("你真的要退出吗?"); }) }) </script> </head> <body style="background-color:#f2f9fd;"> <div class="header bg-main"> <div class="logo margin-big-left fadein-top"> <h1><img src="images/y.jpg" class="radius-circle rotate-hover" height="50" alt="" />尚学堂后台管理中心</h1> </div> <div style="position: relative;left:400px;top:20px;"> <span style="font-size: 15px;color:white;">当前在线人数为:${applicationScope.count}</span> </div> <div class="head-l" style="position: relative;left:850px;"><span style="font-size: 15px;color:white;">当前用户:${sessionScope.user.uname}</span> <a id="out" class="button button-little bg-red" href="data?method=userOut"><span class="icon-power-off"></span> 退出登录</a> </div> </div> <div class="leftnav"> <div class="leftnav-title"><strong><span class="icon-list"></span>菜单列表</strong></div> <h2><span class="icon-user"></span>基本设置</h2> <ul style="display:block"> <li><a href="data?method=selUserInfo" target="right"><span class="icon-caret-right"></span>查询用户信息</a></li> </ul> <h2><span class="icon-pencil-square-o"></span>栏目管理</h2> <ul> <li><a href="list.html" target="right"><span class="icon-caret-right"></span>内容管理</a></li> <li><a href="add.html" target="right"><span class="icon-caret-right"></span>添加内容</a></li> <li><a href="cate.html" target="right"><span class="icon-caret-right"></span>分类管理</a></li> </ul> </div> <script type="text/javascript"> $(function(){ $(".leftnav h2").click(function(){ $(this).next().slideToggle(200); $(this).toggleClass("on"); }) $(".leftnav ul li a").click(function(){ $("#a_leader_txt").text($(this).text()); $(".leftnav ul li a").removeClass("on"); $(this).addClass("on"); }) }); </script> <ul class="bread"> <li><a href="{:U('Index/info')}" target="right" class="icon-home"> 首页</a></li> <li><a href="##" id="a_leader_txt">网站信息</a></li> <li><b>当前语言：</b><span style="color:red;">中文</php></span> 切换语言：<a href="##">中文</a> <a href="##">英文</a> </li> </ul> <div class="admin"> <iframe scrolling="auto" rameborder="0" src="info.jsp" name="right" width="100%" height="100%"></iframe> </div> <div style="text-align:center;"> <p>来源:<a href="http://www.mycodes.net/" target="_blank">源码之家</a></p> </div> </body> </html>
register.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE html> <html lang="zh-cn"> <head> <base href="<%=basePath%>"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> <meta name="renderer" content="webkit"> <title></title> <link rel="stylesheet" href="css/pintuer.css"> <link rel="stylesheet" href="css/admin.css"> <script src="js/jquery.js"></script> <script src="js/pintuer.js"></script> <!--声明js代码域 --> <script type="text/javascript"> $(function(){ //给男添加单击事件 $("#man").click(function(){ //将男的选择状态加上 $("#manSpan").addClass("icon-check"); //给女的span删除选择样式 $("#womanSpan").removeClass("icon-check"); }) //给女添加单击事件 $("#woman").click(function(){ //给女的span添加选择样式 $("#womanSpan").addClass("icon-check"); //将男的选择状态去掉 $("#manSpan").removeClass("icon-check"); }) }) </script> </head> <body> <div class="panel admin-panel"> <div class="panel-head"> <strong><span class="icon-key"></span>用户注册</strong> </div> <div class="body-content"> <form method="post" class="form-x" action="data"> <!--声明请求的方法名 --> <input type="hidden" name="method" value="userReg" /> <div class="form-group"> <div class="label"> <label for="sitename">用户名：</label> </div> <div class="field"> <input type="text" class="input w50" id="mpass" name="uname" size="50" placeholder="请输入用户名" data-validate="required:请输入用户名" /> </div> </div> <div class="form-group"> <div class="label"> <label for="sitename">新密码：</label> </div> <div class="field"> <input type="password" class="input w50" name="pwd" size="50" placeholder="请输入新密码" data-validate="required:请输入新密码,length#>=5:新密码不能小于5位" /> </div> </div> <div class="form-group"> <div class="label"> <label for="sitename">确认新密码：</label> </div> <div class="field"> <input type="password" class="input w50" size="50" placeholder="请再次输入新密码" data-validate="required:请再次输入新密码,repeat#pwd:两次输入的密码不一致" /> </div> </div> <!-- 性别 --> <div class="form-group"> <div class="label"> <label>性别：</label> </div> <div class="field"> <div class="button-group radio"> <label class="button active"> <span class="icon-check" id="manSpan"></span> <input name="sex" value="1" id="man" type="radio" checked="checked">男 </label> <label class="button active" ><span class="" id="womanSpan"></span> <input name="sex" value="0" id="woman" type="radio">女 </label> </div> </div> </div> <!-- 年龄 --> <div class="form-group"> <div class="label"> <label for="sitename">用户年龄：</label> </div> <div class="field"> <input type="text" class="input w50" id="mpass" name="age" size="50" placeholder="请输入年龄" data-validate="required:请输入年龄" /> </div> </div> <!--出生日期 --> <div class="form-group"> <div class="label"> <label for="sitename">出生日期：</label> </div> <div class="field"> <input type="date" class="input w50" id="mpass" name="birthday" size="50" /> </div> </div> <div class="form-group"> <div class="label"> <label></label> </div> <div class="field"> <button class="button bg-main icon-check-square-o" type="submit"> 提交</button> </div> </div> </form> </div> </div> </body> </html>
Filter案例之session管理
在过滤器中获取session对象，然后查看session中的数据是否还在
如果数据没了，则因为session失效了则重定向到登录页面。入宫数据还在
session没有失效，则放行
问题1：
在过滤器中使用session校验后发现登录页面的访问成了死循环，因为登录页面的请求也就是login。
jsp的请求也会被过滤器拦截，而此时session中没有相关的的数据造成了重定向到登录页面......
解决1：
在过滤器中使用session检验后发现登录页面的访问成了死循环，因为登录也页面的请求也就是login.jsp
的请求也会被过滤器拦截，而此时session中没有相关的数据造成了又重定向到登录页面......
问题2：过滤器会拦截所有请求，包括静态资源(css文件\js文件\image图片)请求也会被拦截。
造成了页面中的样式和动态效果等出不来。
解决2：对静态资源也放行。
Filter案例之权限管理
需求：
不同的用户在对同一功能使用时，有的用户可以直接使用，有的用户会被提示权限不足。
思路：
1. 在数据库中创建一个URL权限表，该表存储了该系统需要被管理的URL。
2.在数据库中创建用户权限中间表，用来进行权限分配。
3.在数据库中将权限给用户分配好。
4.在用户登录成功后查询该用户具备的URL权限，存储到该用户的session中。
在过滤器中对当前发起的用户请求地址进行校验，校验该用户是否具备该请求地址的
权限，如果具备则放行，如果不具备则提示权限不足。
权限，入宫具备则放行，如果不具备则提示权限不足。
数据库设计：
URL权限表： t_url
编号：id
url地址：location
描述：remark
用户权限中间表：t_user_url
uid
urlid
sql语句的设计：查询当前登录用户的url信息。
子查询：
select * from t_url where urlid in(select urlid from t_user_url where uid=8)
联合查询：
select * from t_url tu,t_ser_url tul where tu.urlid=tul.urlid and tul.uid=8;
个人学习笔记，记录日常学习，便于查阅及加深，仅为方便个人使用。
