1. 编写Servlet的映射
为什么需要映射：我们写的是JAVA程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需
要再web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径；
通过路径找到servlet名称，对应找到同名的注册的servlet类
Mapping问题
- 一个Servlet可以指定一个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
- 一个Servlet可以指定多个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello2</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello3</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello4</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello5</url-pattern>
</servlet-mapping>
- 一个servlet可以指定通用映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello/*</url-pattern>
</servlet-mapping>
- 默认请求路径
<!--默认请求路径,直接顶替了Index它成为了首页-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
指定一些后缀或者前缀等等…
<!--可以自定义后缀实现请求映射
注意点，*前面不能加项目映射的路径
例如不能这样： /*.txt /hello/*.txt
-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>*.qinjiang</url-pattern>
</servlet-mapping>
优先级问题
指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求；
<!-- 访问/hello优先级高，不会进入error界面 -->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>myError</servlet-name>
<servlet-class>org.Martin.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>myError</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
2. servlet 原理
浏览器发送http请求给 web容器（tomcat）web容器产生request 和 response 调用 Servlet的service方法（java后端重新写的）， request 将前端信息待会处理 在交给 response 返回给 web容器， web容器在响应给浏览器。
3. servletContext
web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；
可以放置数据在context对象中，用来不同的servlet 通信。
请求转发
、请求转发
把GP的资源转发到了自己的页面
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
System.out.println("进入了ServletDemo04");
//RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp"); //转发的请求路径
//requestDispatcher.forward(req,resp); //调用forward实现请求转发；
context.getRequestDispatcher("/gp").forward(req,resp);
}
A请求BServlet ，B把请求转发给CServlet，c响应给b，b响应给a 所以a的请求路径不变
httpservletResponse
web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest
对象，代表响应的一个HttpServletResponse；
如果要获取客户端请求过来的参数：找HttpServletRequest
如果要给客户端响应一些信息：找HttpServletResponse1、简单分类
负责向浏览器发送数据的方法
ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;
负责向浏览器发送响应头的方法
void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);
void setDateHeader(String varl,long var2);
void addDateHeader(String var1,long var2);
void setHeader(String var1,String var2);
void addHeader(String var1,String var2);
void setIntHeader(String var1,int var2);
void addIntHeader(String varl,int var2);
下载文件
要获取下载文件的路径
下载的文件名是啥？
设置想办法让浏览器能够支持下载我们需要的东西 ：设置响应头
获取下载文件的输入流 in
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到bufer缓冲区
使用OutputStream将缓冲区中的数据输出到客户端！
package org.Martin.servlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URLEncoder;
public class FileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 1. 要获取下载文件的路径
String realPath = this.getServletContext().getRealPath("/WEB-INF/classes/ctfshow.png");
// String realPath = "E:\\Martin_Code\\java\\javaweb\\javaweb-02-servlet\\Response-01\\target\\Response-01\\WEB-INF\\classes\\ctfshow.png";
System.out.println("文件路径："+realPath);
// 2. 下载的文件名是啥？
String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
// 3. 设置想办法让浏览器能够支持下载我们需要的东西
// "Content-Disposition","attachment;filename="+URLEncoder.encode(fileName,"UTF-8"))
resp.setHeader("Content-Disposition","attachment;filename="+URLEncoder.encode(fileName,"UTF-8"));
// 4. 获取下载文件的输入流
FileInputStream fis = new FileInputStream(realPath);
// 5. 创建缓冲区
int len=0;
byte[] buffer = new byte[1024];
// 6. 获取OutputStream对象
ServletOutputStream outputStream = resp.getOutputStream();
// 7. 将FileOutputStream流写入到bufer缓冲区
while ((len=fis.read(buffer))!=-1){
// 8. 使用OutputStream将缓冲区中的数据输出到客户端！
outputStream.write(buffer,0,len);
}
outputStream.close();
fis.close();
}
}
4、实现重定向
重定向和转发的异同点
都会实现跳转
转发url不会产生变化
重定向url会产生变化
// 重定向，需要根目录的地址
response.sendRedirect(req.getContextPath()+"/success.jsp");
// 请求转发， 会保留项目的根目录地址，不用加requset.getContextPath()来获取根目录地址
requset.getRequestDispatcher(“/success.jsp”).forward(req,resp);
// 前端获取项目的根地址
${pageContext.request.contextPath}
public class RedirectServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 跳转到哪里
/*
resp.setHeader("Location","./image");
resp.setStatus(302);
*/
// resp.sendRedirect(req.getContextPath()+"/image");
resp.sendRedirect("./image");
}
}
index.jsp
<html>
<body>
<h2>Hel1o World!</h2>
<%--这里超交的路径,需要寻找到项目的路径--%>
<%--${pageContext. request, contextPath}代表当前的项目--%>
<form action="${pageContext. request.contextPath}/login" method="get">
用户名: <input type="text" name="username"> <br>
密码: <input type="password" name="password"> <br>
<input type="submit">
</form>
</body>
</html>
RequestTest.java
public class RequestTest extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("进入请求");
// 处理请求
String username = req.getParameter("username");
String password = req.getParameter("password");
System.out.println(username+password);
// 重定向到成功，注意路径
resp.sendRedirect(req.getContextPath()+"/success.jsp");
// resp.sendRedirect("./success.jsp");
}
}
重定向页面success.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>success</h1>
</body>
</html>
web.xml配置
<servlet>
<servlet-name>requset</servlet-name>
<servlet-class>com. kuang. servlet. RequestTest</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>requset</servlet-name>
<url-pattern>/login</url-pattern>
</servlet-mapping>
httpServletRequest
HttpServletRequest代表客户端的请求,用户通过Http协议访问服务器, HTTP请求中的所有信息会被封装到HttpServletRequest,通过这个HttpServletRequest的方法,获得客户端的所有信息;
用法：1. 获取前端数据 请求转发 getParameter(String s)
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req. setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
String username = req.getParameter("username"); //对应标签name属性
String password = req.getParameter("password");
System.out.println(username);
System.out.println(password);
for (String hobby : req.getParameterValues("hobby")) {
System.out.println(hobby);
}
// 请求转发 会保留项目地址 所以不用加这个 req.getContextPath()
req.getRequestDispatcher("/success.jsp").forward(req,resp);
System.out.println(req.getPathInfo()); // null
System.out.println(req.getContextPath()); // /Request_01_war 项目的根路径
System.out.println(req.getServletPath()); // /login 自己这个类的路径
}
}
cookie、session
会话
会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；
有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话；
一个网站，怎么证明你来过？
客户端 服务端
- 服务端给客户端一个 信件，客户端下次访问服务端带上信件就可以了； cookie， 客户端拿到cookie后存在本地，下次访问时带着cookie
- 服务器登记你来过了，下次你来的时候我来匹配你； seesion
保存会话的两种技术
cookie
- 客户端技术 （响应，请求）
session
- 服务器技术，利用这个技术，可以保存用户的会话信息？ 我们可以把信息或者数据放在Session中！
常见常见：网站登录之后，你下次不用再登录了，第二次访问直接就上去了！
1）从请求中拿到 cookie 信息
2）服务器响应给客户端 cookie
来看看代码：
Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个cookie（name,value）
cookie.setMaxAge(24*60*60); //设置cookie的有效期
resp.addCookie(cookie); //响应给客户端一个cookie
3）cookie ： 一般会保存在本地的用户目录下 appdata ；
4）cookie是否有限制其大小呢？还是我们随便大小都可以，多少都没关系
(1)一个cookie只能保存一个信息，一个 Web 站点可以给浏览器发送多个 Cookie，最多存放 20 个 cookie；
(2)cookie 大小有限制 4kb；
(3)300 个 cookie 浏览器上限
5）删除cookie（必须要名字一样）
（1）不设置有效期，关闭浏览器，自动失效；
（2）设置有效期时间为 0 ；
6）当我们设置的cookie中的value是中文的时候，会影响要使用中文的时候，可以使用这个类来URLEncoder.encode("xxx","utf-8")设置编码
比如：UTLEcoder.encode("我的javaweb笔记","utf-8")
package cn.mldn.service;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
public class CookieDemo01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//服务器告诉你，你来的时间，把这个事件封装成为一个新建，你下次来，就知道你来了
req.setCharacterEncoding("UTF-8");
resp.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=utf-8");
//可以像前端发送东西
PrintWriter out = resp.getWriter();
//Cookie，服务器从客户端获取
Cookie[] cookies = req.getCookies();
//判断cookie是否存在
if (cookies != null) {
//如果存在怎么办
out.write("你上次来过了的");
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
//获取cookie的名字，进行判断是不是下面那个人人
if (cookie.getName().equals("name")) {
//现在取出来的字符串
cookie.getValue();
//要返回肯定不能是直接字符串的形式撒
long lastLoginTime = Long.parseLong(cookie.getValue());
Date data = new Date(lastLoginTime);
out.write(data.toLocaleString());
}
}
} else {
out.write("你这是第一次访问本网站");
}
//服务器给客户端响应一个cookie
Cookie cookie = new Cookie("name", UTLEcoder.encode("我的javaweb笔记","utf-8"));
resp.addCookie(cookie);
super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req,resp);
}
}
session（重点）
什么是Session：
- 服务器会给每一个用户（浏览器）创建一个Seesion对象；
- 一个Seesion独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
- 用户登录之后， 整个网站它都可以访问！–> 保存用户的信息；保存购物车的信息……
Cookie
得到Cookiereq.getCookies()
添加一个Cookie数组的键值对：resp.addCookies(cookie)
得到Cookie的内容：cookie.getName();cookie.getValue();
Session
得到Sessionreq.getSession()
添加Session对象的键值对session.setAttribute(name,value)
得到Session的内容 ：session.getAttribute(name)
Cookie当用户首次登录时：
客户端发送请求
服务器设置Cookie发送给客户端
客户端接受Cookie，保存到本地，下次访问时带着Cookie
服务器接受Cookie，并放回相应用户的数据(Cookie局限性：只能用键值对保存，效率低，引入Session)
Session ：当用户每次登录时：
客户端发送请求
服务器设置一个唯一的SessionID并返回给客户端(利用Cookie的方式)
客户端每次访问带着SessionID(用Cookie的方式带着)
因为服务器保存了所有用户的SessionID，区分每个用户的方法就是作比较，服务器保存的数据太多了，出现了Token
Token 当用户登录时：
客户端发送请求
服务器生成一个Token,并返回给用户。这个Token保存了被加密的UserID用于区分用户
客户端每次访问都带着Token
服务器接受Token ,解密，然后得到UserID来区分用户；不用Session的方式来保存大量的SessionID数据，节省了空间
Cookie：只能保存键值对，效率低，引入了Session
Session: SessionID是一串键值对的哈希值，效率高，（服务器用SessionID相互匹配来验证区分用户）但是都存到服务器，服务器很难受，引入了Token
Token: 把加密的UserID保存到客户端，服务器解密得到UserID，服务器很轻松
使用Session：
public class SessionDemo01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决乱码
resp.setCharacterEncoding("utf-8");
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 得到Session
HttpSession session = req.getSession();
// session.removeAttribute("name"); 删除session中的name
// session.invalidate(); 清除session,当浏览器再次访问，会生成新的session,应用于用户手动注销
// 给Session 存信息 可以存一个对象
session.setAttribute("name","Martin");
session.setAttribute("Person",new Person("person.name",3));
// 得到Session 的信息
System.out.println(session.getAttribute("name"));
System.out.println(session.getAttribute("Person"));
// 获取Session ID
String sessionId = session.getId();
// 判断是不是新的
if (session.isNew()){
resp.getWriter().write("new: "+sessionId);
}else {
resp.getWriter().write("old: "+sessionId);
}
//Session创建的时候做了什么？
//传递了一个Cookie， name="JSESSIONID" value=session.getId()
}
}
会话自动过期：web.xml配置
<!--设置Session默认的失效时间-->
<session-config>
<!--15分钟后Session自动失效，以分钟为单位-->
<session-timeout>15</session-timeout>
</session-config>
session 和 cookie的区别
cookie 是 客户端通过url地址（servlet）请求服务器，服务器生成一个cookie可以存储少量信息，服务器将cookie相应给客户端，客户端把cookie存在本地，下次在访问服务器时，携带cookie，服务器就知道是谁访问了。
session是 客户端通过url地址请求服务器，在服务器会创建一个session（每个会话一个），在session中存储一些用户信息，服务器将sessionid返回给客户端，用户在访问时携带session id 服务器中根据session id 判断用户是那个，并可以取出对应数据。
JSP
8.1、什么是JSP
Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！
最大的特点：
- 写JSP就像在写HTML
- 区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据；
8.2、JSP原理
思路：JSP到底怎么执行的！
- 代码层面没有任何问题
- 服务器内部工作tomcat中有一个work目录；IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录
发现页面转变成了Java程序！
浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！
JSP最终也会被转换成为一个Java类！
JSP 本质上就是一个封装好的Servlet
在JSP页面中；
只要是 JAVA代码就会原封不动的输出；
如果是HTML代码，就会被转换为： out.write("<html>\r\n"); 这样的格式，输出到前端！
8.3、JSP基础语法
任何语言都有自己的语法，JAVA中有,。 JSP 作为java技术的一种应用，它拥有一些自己扩充的语法（了解，知道即可！），Java所有语法都支持！
JSP表达式
<%-- 注释 --%>
<%= 变量或者表达式%> //作用：用来将程序的输出，输出到客户端
<%= new java.util.Date()%>
jsp脚本片段
<%--jsp脚本片段--%>
<%
int sum = 0;
for (int i = 1; i <=100 ; i++) {
sum+=i;
}
out.println("<h1>Sum="+sum+"</h1>");
%>
脚本片段的再实现
<%
int x = 10;
out.println(x);
%>
<p>这是一个JSP文档</p>
<%
int y = 2;
out.println(y);
%>
<hr>
<%--在代码嵌入HTML元素--%>
<%
for (int i = 0; i < 5; i++) {
%>
<h1>Hello,World <%=i%> </h1>
<%
}
%>
JSP声明
<%!
static {
System.out.println("Loading Servlet!");
}
private int globalVar = 0;
public void kuang(){
System.out.println("进入了方法Kuang！");
}
%>
在JSP，嵌入Java代码即可！
<%%> java代码片段
<%= %> 表达式的值
<%! %> jsp声明
<%--注释--%>
12345
JSP的注释，不会在客户端显示，HTML就会！
九大内置对象
PageContext 存东西
Request 存东西
Response
Session 存东西
Application 【ServletContext】 存东西
config 【ServletConfig】
out
page ，不用了解
exception
pageContext.setAttribute("name1","秦疆1号"); //保存的数据只在一个页面中有效
request.setAttribute("name2","秦疆2号"); //保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3","秦疆3号"); //保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","秦疆4号"); //保存的数据只在服务器中有效，从打开服务器到关闭服务器
request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！
session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；
application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据；
JSP标签 JSTL 标签 EL表达式
EL表达式： ${ }
- 获取数据
- 执行运算
- 获取web开发的常用对象
JSP标签
<%--jsp:include--%>
<%--
http://localhost:8080/jsptag.jsp?name=kuangshen&age=12
--%>
<jsp:forward page="/jsptag2.jsp">
<jsp:param name="name" value="kuangshen"></jsp:param>
<jsp:param name="age" value="12"></jsp:param>
</jsp:forward>
/jsptag2.jsp
<%=request.getParameter("name")%>
JSTL表达式
JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和Java代码一样！,需要引入标签库
JavaBean
其实就是实体类 JavaBean有特定的写法：
必须要有一个无参构造 属性必须私有化 必须有对应的get/set方法；
一般用来和数据库的字段做映射 ORM；
ORM ：对象关系映射 表对应一个类 字段对应属性 行记录对应对象
MVC三层架构
分析一下
1）Model
业务处理：业务逻辑（Service）
数据持久层：CRUD
2）View
展示数据
提供链接发起 Servlet 请求（a,form,img…）
3）Controller （Servlet）
接收用户的请求：（req：请求参数、Session 信息…）
交给业务层处理对应的代码
控制试图的跳转
4）再比如登录的逻辑实现：
登录—>接收用户的登录请求—>处理用户的请求（获取用户登录的参数，username，
password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）—>Mapper层查询用
户名和密码是否正确–>数据库
过滤器Filter
Filter：过滤器，用来过滤网站的数据； 处理中文乱码 登录验证
导包（就是先导入依赖） 实现接口 servlet 的filter
编写实现类 CharacterEncodingFilter implements Filter {}
Filter初始化:web服务器启动，就以及初始化了，随时等待过滤对象出现！
public class CharacterEncodingFilter implements Filter {
//初始化:web服务器启动，就以及初始化了，随时等待过滤对象出现！
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("CharacterEncodingFilter初始化");
}
//Chain : 链
/*
1. 过滤中的所有代码，在过滤特定请求的时候都会执行
2. 必须要让过滤器继续同行
chain.doFilter(request,response);
*/
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=UTF-8");
System.out.println("CharacterEncodingFilter执行前....");
chain.doFilter(request,response); //让我们的请求继续走，如果不写，程序到这里就被拦截停止！
System.out.println("CharacterEncodingFilter执行后....");
}
//销毁，当web服务器关闭的时候，过滤器会销毁
public void destroy() {
System.out.println("CharacterEncodingFilter销毁");
}
}
web.xml 的配置
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>cn.mldn.cookie.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<!--只要是 /servlet的任何请求，会经过这个过滤器-->
<url-pattern>/servlet/*</url-pattern>
<!--<url-pattern>/*</url-pattern>--> //过滤所有请求
</filter-mapping>
监听器
在我们启动的一个Web网站的时候，当我去点击那个X的时候后，就会关闭，这除了给这个X加了事件以外，其实Windows里面还有监听着他的存活状态 实现一个监听器；（有很多中方式的） 1.编写一个监听器（实现一个就是一通百通了）
//统计网站在线人数 ： 统计session
public class OnlineCountListener implements HttpSessionListener {
//创建session监听： 看你的一举一动
//一旦创建Session就会触发一次这个事件！
public void sessionCreated(HttpSessionEvent se) {
ServletContext ctx = se.getSession().getServletContext();
System.out.println(se.getSession().getId());
Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
if (onlineCount==null){
onlineCount = new Integer(1);
}else {
int count = onlineCount.intValue();
onlineCount = new Integer(count+1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
//销毁session监听
//一旦销毁Session就会触发一次这个事件！
public void sessionDestroyed(HttpSessionEvent se) {
ServletContext ctx = se.getSession().getServletContext();
Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
if (onlineCount==null){
onlineCount = new Integer(0);
}else {
int count = onlineCount.intValue();
onlineCount = new Integer(count-1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
/*
我们退出了都是还是有两个，因为Session还是在，所有进行Session销毁
Session销毁：
1. 手动销毁 getSession().invalidate();
2. 自动销毁
*/
2. 这里就开始web.xml的配置了
1
<!--注册监听器-->
<listener>
<listener-class>com.kuang.listener.OnlineCountListener</listener-class>
</listener>
过滤器拦截
用户登录之后才能进入主页！用户注销后就不能进入主页了！ 用户登录之后，向Sesison中放入用户的数据 进入主页的时候要判断用户是否已经登录；要求：在过滤器中实现！ 1. 编写其静态文件（这里的是xxx.jsp文件）,下面是我创建的页面
JDBC
需要jar包的支持：
-
java.sql
-
javax.sql
-
mysql-conneter-java… 连接驱动（必须要导入）
mysql mysql-connector-java 8.0.28
JDBC 固定步骤：
-
加载驱动
-
连接数据库,代表数据库
-
向数据库发送SQL的对象Statement : CRUD
-
编写SQL （根据业务，不同的SQL）
-
执行SQL
-
关闭连接（先开的后关）
package org.example;import java.sql.*;
public class TestJdbc {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//配置信息
//useUnicode=true&characterEncoding=utf-8 解决中文乱码
String url=“jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8”;
String username = “root”;
String password = “root”;
//1.加载驱动
Class.forName(“com.mysql.cj.jdbc.Driver”);
//2.连接数据库,代表数据库
Connection connection = DriverManager.getConnection(url, username, password);//3.向数据库发送SQL的对象Statement,PreparedStatement : CRUD Statement statement = connection.createStatement(); //4.编写SQL String sql = "select * from users"; //5.执行查询SQL，返回一个 ResultSet ： 结果集 ResultSet rs = statement.executeQuery(sql); while (rs.next()){ System.out.println("id="+rs.getObject("id")); System.out.println("name="+rs.getObject("name")); System.out.println("password="+rs.getObject("password")); System.out.println("email="+rs.getObject("email")); System.out.println("birthday="+rs.getObject("birthday")); } //6.关闭连接，释放资源（一定要做） 先开后关 rs.close(); statement.close(); connection.close();}
}
预编译SQL
package org.example;
import java.sql.*;
public class TestJdbc2 {
public static void main(String[] args) throws Exception {
//配置信息
//useUnicode=true&characterEncoding=utf-8 解决中文乱码
String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "root";
//1.加载驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//2.连接数据库,代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//3.编写SQL
String sql = "insert into users(id, name, password, email, birthday) values (?,?,?,?,?);";
//4.预编译
PreparedStatement preparedStatement = connection.prepareStatement(sql);
// 注意这里第一个是ID,有没有自增，或者用不用赋值
preparedStatement.setInt(1,4);//给第一个占位符？ 的值赋值为1；
preparedStatement.setString(2,"狂神说Java");//给第二个占位符？ 的值赋值为狂神说Java；
preparedStatement.setString(3,"123456");//给第三个占位符？ 的值赋值为123456；
preparedStatement.setString(4,"24736743@qq.com");//给第四个占位符？ 的值赋值为1；
preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));//给第五个占位符？ 的值赋值为new Date(new java.util.Date().getTime())；
//5.执行SQL
int i = preparedStatement.executeUpdate();
if (i>0){
System.out.println("插入成功@");
}
//6.关闭连接，释放资源（一定要做） 先开后关
preparedStatement.close();
connection.close();
}
}
事务
- 事务的大概意思
要么都成功，要么都失败！
ACID原则：保证数据的安全。逻辑
开启事务
事务提交 commit()
事务回滚 rollback()
关闭事务
转账：
A:1000
B:1000
A(900) --100–> B(1100)
若是服务器崩了 B没收到 A 却减了100 这样事情不应该发生 所以这一个事务的数据应该同步
@Test
public void test() {
//配置信息
//useUnicode=true&characterEncoding=utf-8 解决中文乱码
String url="jdbc:mysql://localhost:3306/blog?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "111";
Connection connection = null;
//1.加载驱动
try {
Class.forName("com.mysql.cj.jdbc.Driver");
//2.连接数据库,代表数据库
connection = DriverManager.getConnection(url, username, password);
//3.通知数据库开启事务,false 开启
connection.setAutoCommit(false);
String sql = "update account set money = money-100 where name = 'A'";
connection.prepareStatement(sql).executeUpdate();
//制造错误
//int i = 1/0;
String sql2 = "update account set money = money+100 where name = 'B'";
connection.prepareStatement(sql2).executeUpdate();
connection.commit();//以上两条SQL都执行成功了，就提交事务！
System.out.println("success");
} catch (Exception e) {
try {
//如果出现异常，就通知数据库回滚事务
connection.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
3179
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
