你想要多大的成功,你愿意为这份成功付出什么?
1 . JavaWeb可以监听的三个对象:
1. HttpServletRequest 对象
2.ServletContext 对象
3. httpSession对象 (-监听保存的对象的变换- )
2. 监听对象的创建和销毁
1.ServletContextListener
2. HttpSessionListener
3. servletRequestListener
3. 监听 --域对象中属性值的变化
1.ServletContextAttributeListener
2. HttpSessionAttributeListener
3.ServletRequestAttributeListener
4. 监听: -- 域对象中自定义对象的值的变化
httpSessionBindingListener( user类必须实现这个接口 )
练习一: 访问一个jsp相当于创建了一个Servlet , jsp里面给你创建了9大内置对象
每个监听都要配置一下 web.xml 里面的Listener标签
1.监听 session域 创建一个类实现HttpSessionListener 接口
public class MyHttpSessionListener implements HttpSessionListener{
@Override
public void sessionCreated(HttpSessionEvent se) {
//HttpSessionEvent session的事件对象 来获取session.
HttpSession session = se.getSession();
String id = session.getId();
System.out.println(id +"创建了");
System.out.println("我session被创建了");
}
@Override
public void sessionDestroyed(HttpSessionEvent se) {
System.out.println("我session被销毁了");
}
}
2.监听request域 创建一个类实现servletContextListener
* 测试监听 ServletContext 创建和销毁;
* 1. 实现一个接口
*/
public class MyServletContextListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
System.out.println("初始化了");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("销毁了");
}
}
<%@page import="com.lanou3g.User"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
都是范德萨范德萨的收费更换
<%
/* request.setAttribute("name", "wanglong"); */
User user = new User();
session.setAttribute("user", user);
%>
</body>
</html>package com.lanou3g;
import javax.servlet.ServletRequestAttributeEvent;
import javax.servlet.ServletRequestAttributeListener;
public class MyServletContextAttributeListener implements ServletRequestAttributeListener {
@Override
public void attributeAdded(ServletRequestAttributeEvent srae) {
System.out.println("添加的值"+srae.getName()+"----"+srae.getValue());
}
@Override
public void attributeRemoved(ServletRequestAttributeEvent srae) {
System.out.println("移除的值"+srae.getName()+"----"+srae.getValue());
}
@Override
public void attributeReplaced(ServletRequestAttributeEvent srae) {
System.out.println("替换的值"+srae.getName()+"----"+srae.getValue());
}
}4. 利用监听实现定时销毁
4.1 配置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_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>sh-web-timer</display-name>
<listener>
<listener-class>com.lanou3g.MyServletContextListener</listener-class>
</listener>
<listener>
<listener-class>com.lanou3g.MyHttpSessionListener</listener-class>
</listener>
<servlet>
<servlet-name>demo01</servlet-name>
<servlet-class>com.lanou3g.Demo01</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>demo01</servlet-name>
<url-pattern>/demo01</url-pattern>
</servlet-mapping>
</web-app>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;
/*
* 4练习.定时销毁session(5秒销毁一次);
1. 把所有创建出来的session保存起来.用户只要访问服务器就会产生session, 保存在哪个域里面呢?
1.ServletContext(哪个类都能获取到);
2.把session对象扔进数组里面 把数组保存到域中
---什么时候cj到数组中
1. 当ServletContext对象 初始化的时候创建数组; --需要一个监听类,触发方法的时候就创建数组;
----什么时候把session放到数据里面.
1.当session对象创建的时候, 就把对象放入到数组中;
2. 遍历保存起来的session对象;
查看session 5秒没用的 就让该session失效;
long getLastAccessedTime();
获取最后session 没使用的时间, 返回值是long的; 1970年到 没有使用时间的毫秒数?
System.currentTimeMillis() - long getLastAccessedTime(); ---结果就是五秒没使用的session;
*/
public class Demo01 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
//防止请求数据乱码;
request.setCharacterEncoding("UTF-8");
HttpSession session = request.getSession();
System.out.println(session.getId()+"创建了");
}
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}4.3 获取ServletContext的监听
public class MyServletContextListener implements ServletContextListener {
@Override
// 第一步:
public void contextInitialized(ServletContextEvent sce) {
// 创建一个数组 保存session;
ArrayList<HttpSession> list = new ArrayList<>();
// 从 ServletContextEvent 里面获取域;
sce.getServletContext().setAttribute("list", list);
// 当保存session的数组被创建出来
// 就开始每隔一秒中检查一次, 有没有超过5秒的session 将他移除;
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("扫描中");
// 使用迭代器遍历集合
Iterator<HttpSession> iterator = list.iterator();
while (iterator.hasNext()) {
// 获取每一个session
HttpSession session = iterator.next();
// 计算时间
Long time = System.currentTimeMillis() - session.getLastAccessedTime();
// 判断时间
if (time > 5000) {
// 让session失效,
session.invalidate();
// 从数组中删除该session
iterator.remove();
System.out.println(session.getId() + "被移除了");
}
}
}
}, 2000, 1000);
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
// TODO Auto-generated method stub
ServletContextListener.super.contextDestroyed(sce);
}
}4.4 获取保存在ServletContext域 中的 session对象的数组 , 取出数组;
package com.lanou3g;
import java.util.ArrayList;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
/*
* 创建监听session; 扔到数组里, 数组已经创建了保存在ServletContext域中了
*/
public class MyHttpSessionListener implements HttpSessionListener {
@Override
public void sessionCreated(HttpSessionEvent se) {
//获取保存在ServletContext域 中的 session对象的数组 , 取出数组;
ArrayList<HttpSession> list = ( ArrayList<HttpSession>)se.getSession().getServletContext().getAttribute("list");
//将创建好的session对象,放入数组中
list.add(se.getSession());
//从新将list放回域中?????-------不用了;
}
@Override
public void sessionDestroyed(HttpSessionEvent se) {
}
}二二 .过滤器( Filter)
1. 过滤器是处于客户端与服务器资源文件之间的一道过滤网，在访问资源文件之前，通过一系列的过滤器对请求进行修改、判断等，把不符合规则的请求在中途拦截或修改。也可以对响应进行过滤，拦截或修改响应。
2.Filter配置和Servlet配置类似
3.无论访问哪个jsp页面，都会事先设置其字符集，不用分别对每个页面都进行设置了。
4. 进入过滤器以后:需要 chain.doFilter(request, response); 才能回到
5.当配置xml里面写/* 对所有的servlet 都有拦截左营
</filter>
<filter-mapping>
<filter-name>demo01</filter-name>
<!-- 配置要过滤的路径 /* 过滤所有路径 可以填绝对的/Demo01 配一个过滤器 配一个所有路径都拦截,-->
<url-pattern>/*</url-pattern>
<!-- 配置拦截跳转方式 只要是请求就能拦截 -->
<dispatcher>FORWARD</dispatcher> //加上这句, 只会拦截请求转发的路径
</filter-mapping>3. 分页查询
1. 获取数据池 ,并且给数据池取出来的数据进行赋值, 利用Properties 集合进行文件读取,.properties放在src下面
package com.lanou3g;
/*
* 获取数据库连接池类
*/
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;
public class DataSourceUtil {
private static BasicDataSource dataSource = new BasicDataSource();
static {
//读取文件
InputStream inputStream = DataSourceUtil.class.getClassLoader().getResourceAsStream("dbinfo.properties");
Properties properties = new Properties();
try {
properties.load(inputStream);
//设置连接池
dataSource.setDriverClassName(properties.getProperty("driverClass"));
dataSource.setUrl(properties.getProperty("url"));
dataSource.setUsername(properties.getProperty("user"));
dataSource.setPassword(properties.getProperty("password"));
//扩展设置;字符串转成integer类型
dataSource.setInitialSize(Integer.parseInt(properties.getProperty("initialSize")));
dataSource.setMaxActive(Integer.parseInt(properties.getProperty("maxActive")));
dataSource.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));
dataSource.setMinIdle(Integer.parseInt(properties.getProperty("minIdle")));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//私有化构造方法
private DataSourceUtil() {
}
public static DataSource getDateSource() {
return dataSource;
}
}
2. 获取Sort表中的字段, 并且创建Sort对象, 对象属性与数据库字段一一对应!
package com.lanou3g;
public class Sort {
private int sid;
private String sname;
private double sprice;
private String sdesc;
// 添加属性用于 多条件查询 where and and
private String min;
private String max;
public Sort() {
super();
// TODO Auto-generated constructor stub
}3 . 创建一个pagebean对象 里面有--1.当前页--2.每页多少条记录--3.总记录数--4.总页数--5.保存sort集合!
package com.lanou3g;
import java.util.ArrayList;
public class PageBean {
// 当前页
private int currentPage;
// 每页显示多少条数据
private int pageSize;
// 总记录数
private int count;
// 总页数
private int totalPage;
// 保存数据的数组或者集合;
private ArrayList<Sort> sorts;
public PageBean() {
super();
// TODO Auto-generated constructor stub
}
4.创建servlet网页
首先知道 1. pagesize 和currentPage( 默认为1)
2. beginPage = (currentPage-1)*size
3.count(总记录数)=直接数据库查询
4. 总页数tatolPage= (count%pageSize )?(count/pageSize):(count/pageSize+1)
5. sorts保存数据表中所有数据;--
package com.lanou3g;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/*
* 分页查询:
* dao层:
* 1.ArrayList findList(beginPage,pageSize)
* limit 起始页(beginPage),每页显示多少条数据(pageSize);
* 2.getCount(); 查询总记录数;
*
* service 层调用dao层的方法.
* pageSize = 3;
* beginPage=
* 当前页,currentPage=1
* beginPage = (current-1)*pageSize
* tatalPage = (count%pageSize) ?(count/pageSize):(count/pageSize+1)
* 9条 3页
* 注意: 将要返回的值封装成一个对象返回去;
*
*
* jsp 页面都显示什么;
* 1.商品数据,都在ArrayList 里面保存在
* 2.上一页和下一页 currentPage-1;
* 3.下一页 currentPage+1
* 第几页 currentPage
* 共几页 totalPage = (总记录数count)
*
*
* Servlet 层
* 1. 获取参数 currentPage(点上一页或下一页传来的,)
* 第一次访问 默认当前页 currentPage =1;
* 2. 调用service 的方法, 封装好的对象PageBean,
* 请求分法
*
* 3.把封装好的的pageBean保存到域中, 转发到jsp页面中显示对象;
*/
public class ListServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
// 防止请求数据乱码;
request.setCharacterEncoding("UTF-8");
// 获取参数
// 默认从第一页开始
int currentPage = 1;
String currentPageString = request.getParameter("currentPage");
if (currentPageString != null) {
// 不等于null默认点了上一页或者下一页
currentPage = Integer.parseInt(currentPageString);
}
// 每页显示多少条数据
int pageSize = 3;
// 调用逻辑层方法
ListService service = new ListService();
PageBean pageBean = service.findList(pageSize, currentPage);
// 跳转页面
request.setAttribute("pageBean", pageBean);
request.getRequestDispatcher("/list.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}
5. 完成pageBean的对象的封装, 以及调用service层的方法
// 分页查询
public PageBean findList(int pageSize, int currentPage) {
// 计算
int beginPage = (currentPage - 1) * pageSize;
// 获取查询集合
ArrayList<Sort> sorts = null;
int count = 0;
try {
sorts = dao.findList(beginPage, pageSize);
// 获取总记录数
count = dao.getCount();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 获取总页数
int totalPage = (count % pageSize == 0) ? (count / pageSize) : (count / pageSize + 1);
// 创建pageBean
PageBean pageBean = new PageBean(currentPage, pageSize, count, totalPage, sorts);
return pageBean;
}
}package com.lanou3g;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
public class ListDao {
private QueryRunner runner = new QueryRunner(DataSourceUtil.getDateSource());
public ArrayList<Sort> findList(int beginPage, int pageSize) throws SQLException {
// 分页查询
String sql = "select *from sort limit ?,?";
Object[] params = { beginPage, pageSize };
List<Sort> query = runner.query(sql, new BeanListHandler<>(Sort.class), params);
ArrayList<Sort> sorts = (ArrayList<Sort>) query;
return sorts;
}
public int getCount() throws SQLException {
// 获取记录数;
String sql = "select count(*) from sort ";
Long query = runner.query(sql, new ScalarHandler<>());
return query.intValue();
}
}
7. jsp内容
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<table>
<tr>
<td>商品</td>
<td>名称</td>
<td>目录</td>
</tr>
<c:forEach items="${pageBean.sorts }" var="sort" >
<tr>
<td>${sort.sname }</td>
<td>${sort.sprice }</td>
<td>${sort.sdesc }</td>
</tr>
</c:forEach>
</table>
<!-- 上一页 第几页 共几页 下一页
-->
<a href="${pageContext.request.contextPath }/listServlet?currentPage=${pageBean.currentPage-1}">上一页</a>
第${pageBean.currentPage==1:pageBean.currentPage?pageBean.currentPage-1 }页---
共${pageBean.totalPage }页
<a href="${pageContext.request.contextPath }/listServlet?currentPage=${pageBean.currentPage+1}">下一页</a>
</body>
</html>
2118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
