Javaweb学习笔记——（二十）——————Javaweb监听器、国际化
Javaweb监听器
三大组件
*Servlet
*Listener
*Filter
Listener：监听器
1.初次相见：AWT
2.二次相见：SAX
监听器：
*它是一个接口，内容由我们来实现；
*它需要注册，例如注册在按钮上
*监听器中的方法，会在特殊事件发生时被调用
观察者：
*事件源：
小偷
*事件：
偷东西
*监听器：
警察
监听器中的方法：抓普
Javaweb中的监听器
*事件源：三大域：
>ServletContext
*声明周期监听：ServletContextListener，它有两个方法，一个在出生时调用，一个在死亡时调用；
**void contextInitialized(ServletContextEvent sce)：创建ServletContext时
**void contextDestroyed(ServletContextEvent sce)：销毁ServletContext时
*属性监听：ServletContextAtttributeListener，它有三个方法，一个在添加属性时调用，一个在替换属性时调用，最后一一个
是咋移除属性时调用。
**void attributeAdded(ServletContextAttributeEvent event)：添加属性时
**void attributeReplaced(ServletContextAttributeEvent event)：替换属性时
**void attributeRemoved(ServletContextAttributeEvent event)：删除属性时
>HttpSession
*生命周期监听：HttpSessionListener，它有两个方法，一个在出生时，调用，一个在死亡时调用；
**void sessionCreated(HttpSessionEvent se)：创建session时
**void sessionDestroyed(HttpSessionEvent se)：销毁session时
*属性监听：HttpSessionAttributeListener，它有三个方法，一个在添加属性时调用，一个在替换属性时调用，最后一个是在移除属性时调用。
**void attributeAdded(HttpSessionBindingEvent event)：添加属性时
**void attributeReplaced(HttpSessionBindingEvent event)：替换属性时
**void attributeRemoved(HttpSessionBindingEvent event)：移除属性时
>ServletRequest
*生命周期监听：ServletRequestListener，它有两个方法，一个在出生时调用，一个在死亡时调用；
**void requestInitialized(ServletRequestEvent event)：创建request时
**void requsetDestroyed(ServletRequestEvent event)：销毁request是
*属性监听：ServletRequestAttributeListener，它有三个方法，一个在添加属性时调用，一个在替换属性时调用，最后一个是在移除属性时调用。
**void attributeAdded(ServletRequestAttributeEvent event)：添加属性时
**void attributeReplaced(ServletRequestAttributeEvent event)：替换上属性时
**void attributeRemoved(ServletRequestAttributeEvent event)：移除属性时
*Javaweb中完成编写监听器
>写一个监听器类：要求必须去实现某一个监听器接口；
>注册，是在web.xml中配置来完成注册
*事件对象：
>ServletContextEvent:ServletContext getServletContext()
>HttpSessionEvent:HttpSession getSessioin()
>ServletRequest:
*ServletContext getServletContext();
*ServletRequest getServletRequest();
>ServletContextAttributeEvent:
*ServletContext getServletContext();
*String getName();获取属性名
*Objecet getValue();获取属性值
>HttpSessionBindingEvent: 略
>ServletContextRequestAttributeEvent:略
感知监听（都与HttpSession相关）
*它用来添加到javabean上，而不是添加到三大域上
*这两个监听器都不需要在web.xml中配置来完成注册
HttpSessionBindingListener：添加到javabean上，javabean就知道自己是否添加到session中了。
1.Javaweb监听器概述
在Javaweb被监听的事件源为：ServletContext、HttpSession、ServletRequest，即三大域对象
*监听域对象“创建”与“销毁”的监听器
*监听域对象“操作域属性”的监听器
*监听HttpSession的监听器
2.创建与销毁监听器
创建与销毁监听器一共有三个：
*ServletCotnextListener：Tomcat启动和关闭时调用下面两个方法
>public void contextInitialized(ServletContextEvent event):ServletContext对象被创建后调用
>public void contextDestroyed(ServletContextEvent event)：ServletContext对象被销毁之前调用
*HttpSerssionListener：开始会话和结束会话时调用下面两个方法
>public void sessionCreated(HttpSessionEvent event):HttpSession对象被创建后调用
>public void sessionDestroyed(HttpSessionEvent event):HttpSession对象被销毁前调用
*ServletRequestListener：开始请求和结束请求时调用下面两个方法
>public void requestInitialized(ServletRequestEvent event):ServletRequest对象被创建后调用
>public void requsetDestroyed(ServletRequestEvent event):ServletRequest对象被销毁钱调用
事件对象：
*ServletContextEvent：ServletContext getServletContext();
*HttpSessionEvent:HttpSession getSerssion();
*ServletRequestEvent:
>ServletRequest getServletRequest();
>ServletContext getServletContext();
编写测试例子：
*编写MyServletContextListener类，实现ServletContextListener接口；
*在web.xml文件中部署监听器；
*为了看到session销毁的效果，在web.xml文件中设置session失效时间为1分钟
/*
* ServletContextListener实现类
* contextDestroyed() -- 在ServletContext对象被销毁前调用
* contextInitialized() -- -- 在ServletContext对象被创建后调用
* ServletContextEvent -- 事件类对象
* 该类有getServletContext()，用来获取ServletContext对象，即获取事件源对象
*/
public class MyServletContextListener implements ServletContextListener {
public void contextDestroyed(ServletContextEvent evt) {
System.out.println("销毁ServletContext对象");
}
public void contextInitialized(ServletContextEvent evt) {
System.out.println("创建ServletContext对象");
}
}
/*
* HttpSessionListener实现类
* sessionCreated() -- 在HttpSession对象被创建后被调用
* sessionDestroyed() -- -- 在HttpSession对象被销毁前调用
* HttpSessionEvent -- 事件类对象
* 该类有getSession()，用来获取当前HttpSession对象，即获取事件源对象
*/
public class MyHttpSessionListener implements HttpSessionListener {
public void sessionCreated(HttpSessionEvent evt) {
System.out.println("创建session对象");
}
public void sessionDestroyed(HttpSessionEvent evt) {
System.out.println("销毁session对象");
}
}
/*
* ServletRequestListener实现类
* requestDestroyed() -- 在ServletRequest对象被销毁前调用
* requestInitialized() -- 在ServletRequest对象被创建后调用
* ServletRequestEvent -- 事件类对象
* 该类有getServletContext()，用来获取ServletContext对象
* 该类有getServletRequest()，用来获取当前ServletRequest对象，即事件源对象
*/
public class MyServletRequestListener implements ServletRequestListener {
public void requestDestroyed(ServletRequestEvent evt) {
System.out.println("销毁request对象");
}
public void requestInitialized(ServletRequestEvent evt) {
System.out.println("创建request对象");
}
}
<listener>
<listener-class>cn.itcast.listener.MyServletContextListener</listener-class>
</listener>
<listener>
<listener-class>cn.itcast.listener.MyHttpSessionListener</listener-class>
</listener>
<listener>
<listener-class>cn.itcast.listener.MyServletRequestListener</listener-class>
</listener>
<session-config>
<session-timeout>1</session-timeout>
</session-config>
3.操作域属性的监听器
*当对域属性进行增、删、时，执行的监听器一共有三个：
*ServletContextAttributeListener：在ServletContext域进行增、删、改属性时调用下面方法。
**public void attributeAdded(ServletContextAttributeEvent evt)
**public void attributeRemoved(ServletContextAttributeEvent evt)
**public void attributeReplaced(ServletContextAttributeEvent evt)
*HttpSessionAttributeListener：在HttpSerssion域进行增、删、改属性时调用下面方法。
**public void attributeAdded(HttpSessionBindingEvent evt)
**public void attributeRemoved(HttpSessionBindingEvent evt)
**public void attributeReplaced(HttpSessionBindingEvent evt)
*ServletRequestAttributeListener:在ServletRequest域进行增、删、改属性时调用下面方法
**public void attributeAdded(ServletRequestAttributeEvent evt);
**public void attributeRemoved(ServletRequestAttributeEvent evt);
**public void attributeReplaced(ServletRequestAttributeEvent evt);
下面对这三个监听器的事件对象功能进行介绍：
*ServletContextAttributeEvent
>Strinng getName()：获取当前操作的属性名；
>Object getValue():获取当前操作的属性值；
>ServletContext getServletContext():获取ServletContext对象。
*HttpSessionBindingEvent
>String getName():获取当前操作的属性名；
>Object getValue():获取当前操作的属性值;
>HttpSession getSessioin()：获取当前操作的session对象。
*ServletRequestAttributeEvent
>String getName():获取当前操作的属性名；
>Object getValue():获取当前操作的属性值；
>ServletContext getServletContext():获取ServletContext对象；
>ServletRequest getServletRequest:获取当前操作ServletRequest对象。
public class MyListener implements ServletContextAttributeListener,
ServletRequestAttributeListener, HttpSessionAttributeListener {
public void attributeAdded(HttpSessionBindingEvent evt) {
System.out.println("向session中添加属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeRemoved(HttpSessionBindingEvent evt) {
System.out.println("从session中移除属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeReplaced(HttpSessionBindingEvent evt) {
System.out.println("修改session中的属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeAdded(ServletRequestAttributeEvent evt) {
System.out.println("向request中添加属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeRemoved(ServletRequestAttributeEvent evt) {
System.out.println("从request中移除属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeReplaced(ServletRequestAttributeEvent evt) {
System.out.println("修改request中的属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeAdded(ServletContextAttributeEvent evt) {
System.out.println("向context中添加属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeRemoved(ServletContextAttributeEvent evt) {
System.out.println("从context中移除属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeReplaced(ServletContextAttributeEvent evt) {
System.out.println("修改context中的属性：" + evt.getName() + "=" + evt.getValue());
}
}
public class ListenerServlet extends BaseServlet {
public String contextOperation(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ServletContext context = this.getServletContext();
context.setAttribute("a", "a");
context.setAttribute("a", "A");
context.removeAttribute("a");
return "/index.jsp";
}
///////////////////////////////
public String sessionOperation(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
session.setAttribute("a", "a");
session.setAttribute("a", "A");
session.removeAttribute("a");
return "/index.jsp";
}
///////////////////////////////
public String requestOperation(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setAttribute("a", "a");
request.setAttribute("a", "A");
request.removeAttribute("a");
return "/index.jsp";
}
}
<body>
<a href="<c:url value='/ListenerServlet?method=contextOperation'/>">SevletContext操作属性</a>
<br/>
<a href="<c:url value='/ListenerServlet?method=sessionOperation'/>">HttpSession操作属性</a>
<br/>
<a href="<c:url value='/ListenerServlet?method=requestOperation'/>">ServletRequest操作属性</a> |
</body>
4.监听HttpSession的监听器
还有两个与HttpSession相关的 特殊的监听器，这两监听器的特点如下：
*不用在web.xml文件中部署；
*这两个监听器不是给session添加，而是给Bean添加。即让Bean类实现监听接口，然后再把Bean对象添加到session域中。
下面对这两个监听器介绍一下：
*HttpSessionBindingListener：当某个类实现了该接口后，可以感知本类对象添加到session中，已经感觉到session中移除。
例如让Person类实现HttpSessionBindingListener接口，那么当Person对象添加到session中，或者把Person对象从session中移除
时会调用以下两个方法：
>public void valueBound(HttpSessionBindingEvent event)：当把监听器对象添加到session中会调用监听器对象的本方法；
>public void valueUnbound(HttpSessionBindingEvent event)：当把监听器对象从session中移除时会调用监听器对象的本方法；
这里要注意，HttpSessionBindingListener监听器的使用与前面介绍的都不相同，当监听器对象添加到session中，或把该监听器对象从session
移除时调用监听器中的方法。并且无需在web.xml文件中部署这个监听器。
示例步骤：
*编写Person类，让其实现HttpSessionBindingListener监听器接口；
*编写Servlet类，一个方法向session中添加Person对象，另一个从session中移除Person对象；
*在index.jsp中给出两个超链接，分别访问Servlet中的两个方法。
Person.java
public class Person implements HttpSessionBindingListener {
private String name;
private int age;
private String sex;
public Person(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public Person() {
super();
}
public String toString() {
return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void valueBound(HttpSessionBindingEvent evt) {
System.out.println("把Person对象存放到session中：" + evt.getValue());
}
public void valueUnbound(HttpSessionBindingEvent evt) {
System.out.println("从session中移除Pseron对象：" + evt.getValue());
}
}
ListenerServlet.java
public class ListenerServlet extends BaseServlet {
public String addPerson(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Person p = new Person("zhangSan", 23, "male");
request.getSession().setAttribute("person", p);
return "/index.jsp";
}
public String removePerson(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.getSession().removeAttribute("person");
return "/index.jsp";
}
}
index.jsp
<body>
<a href="<c:url value='/ListenerServlet?method=addPerson'/>">addPerson</a>
<br/>
<a href="<c:url value='/ListenerServlet?method=removePerson'/>">removePerson</a>
<br/>
</body>
*HttpSessionActivationListener：Tomcat会在session从时间不被使用时钝化session对象，所谓钝化session，就是把session
通过序列化的方法保存到硬盘文件中。当用户再使用session时，Tomcat还会把钝化的对象再活化session，所谓活化就是把硬盘文件中的
session在反序列化回内存。当session被Tomcat钝化时，sessioin中存储的对象也被钝化，当session被活化时，也会把session
中存储的对象活化。如果某个类实现了HttpSessionActiveationListener接口后，当对象随着session被钝化和活化时，下面两个方法
就会被调用：
>public void sessionWillPassivate(HttpSessionEvent hse)：当对象感知被活化时调用本方法；
>public void sessionDidActivate(HttpSessionEvent hse)：当对象感知被钝化时调用本方法：
HttpSessionActivationListener监听器与HttpSessionBindingListener监听器相似，都是感知型的监听器，例如让Person类实现了
HttpSessionActivationList监听器接口，并把Person对象添加到了session中后，当Tomcat钝化session时，同时也会钝化session中的
Person对象，这时Person对象就会感知到自己被钝化了，其实就是调用Person对象的sessionWillPassvate()方法。当用户再次使用session
时，Tomcat会活化session，这时Person会感知自己被活化，其实就是调用Person对象的sessionDidActivate()方法。
注意：因为钝化和活化session，其实就是使用序列化和反序列化技术吧session从内存保存到硬盘，和把session从硬盘加载到内存。
这说明如果Person类没有实现Serializable接口，当session钝化时就不会钝化Person，而是把Person从session中移除
在钝化。这也说明session活化后，session就不再有Person对象了。
示例步骤：
先不管HttpSessionActivationListener监听器接口，先来配置Tomcat钝化session的参数，把下面配置文件放到
tomcat\conf\catalina\localhost目录下，文文件名称为项目名称。
<Context>
<Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
<Store className="org.apache.catalina.session.FileStore" directory="mysession"/>
</Manager>
</Context>
访问项目的index.jsp页面，这会使Tomcat创建Session对象，然后等待一分钟后，查看Tomcat\work\catalina\localhost\listener\mysession
目录下是否产生文件，如果产生了，说明钝化session的配置成了，可以开始下一步了
*创建Person类，让Person类实现HttpSessionActivationListener和Serializable接口：
Person.java
public class Person implements HttpSessionActivationListener, Serializable {
private String name;
private int age;
private String sex;
public Person(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public Person() {
super();
}
public String toString() {
return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void sessionDidActivate(HttpSessionEvent evt) {
System.out.println("session已经活化");
}
public void sessionWillPassivate(HttpSessionEvent evt) {
System.out.println("session被钝化了！");
}
}
*与上例一样，编写Servlet，提供两个方法：一个向session中添加Person对象，另一个从session中移除Person对象：
ListenerServlet.java
public class ListenerServlet extends BaseServlet {
public String addPerson(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Person p = new Person("zhangSan", 23, "male");
request.getSession().setAttribute("person", p);
return "/index.jsp";
}
public String removePerson(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.getSession().removeAttribute("person");
return "/index.jsp";
}
}
*在index.jsp页面中给出访问addPerson()和removePerson()的方法：
<body>
<a href="<c:url value='/ListenerServlet?method=addPerson'/>">addPerson</a>
<br/>
<a href="<c:url value='/ListenerServlet?method=removePerson'/>">removePerson</a>
<br/>
</body>
*打开index.jsp页面，这时Tomcat会创建session，必须在1分钟之前点击addPerson链接，这能保证在session钝化之前
把Person对象存放到session中；
*等待一分钟，这时session会被钝化，也就会调用Person的sessionWillPassivate();
*刷新一下index.jsp页面，这也会使session活化，会调用Person的sessionDidActivate()方法。
国际化
1.什么是国际化
国际化就是可以把页面中的中文变成英文。例如在页面中的登录表单：
2.理解国际化
想要把页面中的文字修改，那么就不能再使用硬编码,需要使用活编码
3.Local类
创建Locale类对象：
*new Locale("zh", "CN");
*new Locale("en", "US");
zh、en表示语言，而CN、US表示国家。一个Locale对象表示的就是语言和国家
4.ResourceBundle类
ResourceBundle类用来获取配置文件中的内容。
例如：
res_zh_CN.properties
name value
msg.password 密码
msg.username 用户名
res_en_US.properties
name value
msg.username Username
msg.password Password
public class Demo1 {
@Test
public void fun1() {
ResourceBundle rb = ResourceBundle.getBundle("res", new Locale("zh", "CN" ));
String username = rb.getString("msg.username");
String password = rb.getString("msg.password");
System.out.println(username);
System.out.println(password);
}
@Test
public void fun2() {
ResourceBundle rb = ResourceBundle.getBundle("res", new Locale("en", "US" ));
String username = rb.getString("msg.username");
String password = rb.getString("msg.password");
System.out.println(username);
System.out.println(password);
}
}
ResourceBundle的getBundle()方法需要两个参数：
*第一个参数：配置文件的基本名称
*第二个参数：Locale
getBundle()方法会通过两个参数来锁定配置文件
5.页面国际化
其实页面国际化也是同一个道理，只需要通过切换Locale来切换配置文件。我们写一个MessageUtils类，内部需要ResourceBundle
的实例。
我们在写一个过滤器MessageFilter，它会通过参数创建Locale对象，传递给MessageUtils，然后在页面中使用MessageUtils来
获取文本信息。
MessageUtils.java
public class MessageUtils {
private static String baseName = "res";
private static Locale locale;
public static String getText(String key) {
return ResourceBundle.getBundle(baseName, locale).getString(key);
}
public static Locale getLocale() {
return locale;
}
public static void setLocale(Locale locale) {
MessageUtils.locale = locale;
}
}
MessageFilter.java
public class MessageFilter implements Filter {
public void destroy() {
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
String l = req.getParameter("request_locale");
Locale locale = null;
if(l != null && !l.isEmpty()) {
String[] strs = l.split("_");
locale = new Locale(strs[0], strs[1]);
req.getSession().setAttribute("WW_TRANS_I18N_LOCALE", locale);
} else {
locale = (Locale)req.getSession().getAttribute("WW_TRANS_I18N_LOCALE");
}
if(locale == null) {
locale = req.getLocale();
}
MessageUtils.setLocale(locale);
chain.doFilter(request, response);
}
public void init(FilterConfig fConfig) throws ServletException {
}
}
login.jsp
<body>
<h1><%=MessageUtils.getText("msg.login") %></h1>
<form action="<c:url value='/index.jsp'/>" method="post">
<%=MessageUtils.getText("msg.username")%>：<input type="text" name="username"/><br/>
<%=MessageUtils.getText("msg.password")%>：<input type="password" name="password"/><br/>
<input type="submit" value='<%=MessageUtils.getText("msg.login")%>'/>
</form>
</body>
index.jsp
<body>
<p><%=MessageUtils.getText("hello") + ":" +request.getParameter("username") %>：</p>
</body>
6.NumberFormat
NumberFormat类用来对数字进行格式化，我们只需要使用String format(double)一个方法即可。下面是获取NumberFormat实例的方法:
*NumberFormat format = NumberFormat.getNumberFormat()
*NumberFormat format = NumberFormat.getNumberFormat(Locale)
*NumberFormat format = NumberFormat.getCurrentcyFormat()
*NumberFormat format = NumberFormat.getCurrentcyFormat(Locale)
*NumberFormat format = NumberFormat.getPercentFormat()
*NumberFormat format = NumberFormat.getPercentFormat(Locale)
7.DateFormat
DateFormat类用来对日期进行格式化，我们只需要使用String format(Date)一个方法即可。下面是获取DateFormat实例的方法
*DateFormat format = DateFormat.getDateFormat();
*DateFormat format = DateFormat.getTimeFormat();
*DateFormat format = DateFormat.getDateTimeFormat();
*DateFormat format = DateFormat.getDateFormat(int style, Locale locale);
*DateFormat format = DateFormat.getTimeFormat(int style, Locale locale);
*DateFormat format = DateFormat.getDateTimeFormat(int style, Locale locale);
其中style是对日期的长、中、短，以及完整样式。
*SHORT；
*MEDIUM；
*LONG；
*FULL
8.MessageFormat
MessageFormat可以吧模式中的{N}使用参数来替换。我们把{N}称之为点位符。其中点位符的N是从0开始的整数。
MessageFormat.format(String pattern, Object... params)，其中pattern可以包含0~n个点位符，而params表示对点位符的替换文本。注意，点位符需要从0开始。
String p = “{0}或{1}错误”;
String text = MessageFormat.format(p, "用户名", "密码");
System.out.println(text);//用户名或密码错误
分页：
1 什么分页
第N页/共M页 首页 上一页 1 2 3 4 5 6 7 8 9 10 下一页 尾页 口go
分页的优点：只查询一页，不用查询所有页！
2 分页数据
页面的数据都是由Servlet传递来的！
Servlet：
*当前面：pageCode，pc；
*pc：如果页面没有传递当前页码，那么Servlet默认是第一页，或者按页面传递的来准！
*总页数：totalPages，tp
*tp：总记录数/每页记录数
*总记录数：totalRecored，tr
*tr：dao来获取，select count(*) from t_customer；
*每页记录数：业务数据或叫系统数据！10行！
*当前页数据：beanList
*url
3 分页Bean的设计
这些分页数据总要在各层之间来回的传递！
我们把这些分页数据封装到一个javabean中，它就叫分页Bean，例如：PageBean
PageBean.java
public class PageBean<T> {
private int pc;// 当前页码page code
// private int tp;// 总页数total page
private int tr;// 总记录数total record
private int ps;// 每页记录数page size
private List<T> beanList;// 当前页的记录
……
}
4 分页在各层中的处理
*页面：给出分页相关的链接们！
*页面需要给Servlet传递什么：有可能传递pc
*Servlet：创建PageBean对象，给PageBean所有的属性赋值，然后传递给页面；
*Servlet需要给DAO传递pc、ps
*Service：略
*Dao：
*tr：select count(*) t_customer
*beanList：select * from t_customer limit x, y
5 显示分页页码列表
1 2 3 4 5 6 7 8 9 10
*最多显示多少个页码！定为10；
*当前页，在页码列表中的位置，定为6；
只需要当前页码来定出来页码列表！
定下来页码列表只需要两样数据：
*begin
*end
10 11 12 13 14 (15) 16 17 18 19
需要使用pc来推算出begin和end
begin = pc – 5
end = pc + 4
计算公式：
*如果总页数<=10（列表长度），那么begin=1，end=总页数
*使用公式计算；begin=pc-5, end=pc + 4；
*头溢出：当begin<1时，让begin=1
*尾溢出：当end>${tp}时，让end=${tp}
6. 在超链接中要保留参数
当使用多条件查询后，然后在点击第2 页时，这个第2页超链接没有条件了，所以会丢失条件，所以我们需要在页面上的所有链接都要保留条件！
我们要把条件以一个字符串的形式保存到PageBean的url中！这个任务交给Servlet！
Javaweb学习笔记——（二十）——————Javaweb监听器、国际化的更多相关文章
- python3.4学习笔记(二十六) Python 输出json到文件,让json.dumps输出中文 实例代码
python3.4学习笔记(二十六) Python 输出json到文件,让json.dumps输出中文 实例代码 python的json.dumps方法默认会输出成这种格式"\u535a\u ...
- python3.4学习笔记(二十五) Python 调用mysql redis实例代码
python3.4学习笔记(二十五) Python 调用mysql redis实例代码 #coding: utf-8 __author__ = 'zdz8207' #python2.7 import ...
- python3.4学习笔记(二十四) Python pycharm window安装redis MySQL-python相关方法
python3.4学习笔记(二十四) Python pycharm window安装redis MySQL-python相关方法window安装redis,下载Redis的压缩包https://git ...
- python3.4学习笔记(二十二) python 在字符串里面插入指定分割符，将list中的字符转为数字
python3.4学习笔记(二十二) python 在字符串里面插入指定分割符,将list中的字符转为数字在字符串里面插入指定分割符的方法,先把字符串变成list然后用join方法变成字符串str=' ...
- python3.4学习笔记(二十) python strip()函数 去空格\n\r\t函数的用法
python3.4学习笔记(二十) python strip()函数 去空格\n\r\t函数的用法 在Python中字符串处理函数里有三个去空格(包括'\n', '\r', '\t', ' ')的函数 ...
- javaweb学习总结(四十四)——监听器(Listener)学习
一.监听器介绍 1.1.监听器的概念
- (C/C++学习笔记) 二十四. 知识补充
二十四. 知识补充 ● 子类调用父类构造函数 ※ 为什么子类要调用父类的构造函数? 因为子类继承父类,会继承到父类中的数据,所以子类在进行对象初始化时,先调用父类的构造函数,这就是子类的实例化过程. ...
- (C/C++学习笔记) 二十二. 标准模板库
二十二. 标准模板库 ● STL基本介绍 标准模板库(STL, standard template library): C++提供的大量的函数模板(通用算法)和类模板. ※ 为什么我们一般不需要自己写 ...
- (C/C++学习笔记) 二十. 文件和流
二十. 文件和流 ● 文件的概念 文件(file) 一. C/C++语言将文件作为字节序列(sequence of characters)来对待,但从编码角度,或说从对字节信息的解释来看,文件分为:文 ...
- javaweb学习总结(四十五)——监听器(Listener)学习二
一.监听域对象中属性的变更的监听器 域对象中属性的变更的事件监听器就是用来监听 ServletContext, HttpSession, HttpServletRequest 这三个对象中的属性变更信 ...
随机推荐
- HDU--5269 ZYB loves Xor I （字典树）
题目电波: HDU--5269 ZYB loves Xor I 首先我们先解决 ai xor aj 每个数转化为二进制 我们用字典树统计 每个节点 0 和 1 的出现的个数 #include< ...
- MongoDb 命令查询所有数据库列表
原文:http://blog.csdn.net/huxu981598436/article/details/47216493 MongoDb 命令查询所有数据库列表 CODE: > show d ...
- SpringBoot读取application.properties文件
http://blog.csdn.net/cloume/article/details/52538626 Spring Boot中使用自定义的properties Spring Boot的applic ...
- A1011. World Cup Betting
With the 2010 FIFA World Cup running, football fans the world over were becoming increasingly excite ...
- TestNg 11. 超时测试
前沿:多久时间没有响应,就是超时. 代码:用timeOut这个属性,超过规定的时间就是fail,不超过就是success package com.course.testng; import org.t ...
- 我眼中的正则化（Regularization）
警告:本文为小白入门学习笔记 在机器学习的过程中我们常常会遇到过拟合和欠拟合的现象,就如西瓜书中一个例子: 如果训练样本是带有锯齿的树叶,过拟合会认为树叶一定要带有锯齿,否则就不是树叶.而欠拟合则认为 ...
- Qt ------ window下工程项目打包成一个exe程序
最近,在学习QT5的过程中,想尝试着把自己写的工程程序给打包发布出来,在任何一台windows系统都能运行,这样就不会限于电脑需不需要安装QT安装包了. 首先,先介绍自己使用的环境.我使用的QT版本是 ...
- Shiro进行简单的身份验证(二)
一个Realm数据源: shiro.ini: [users] wp=123456 main方法执行认证: package com.wp.shiro; import org.apache.shiro.S ...
- 绑定本地的Session
绑定本地的Session图示解析: 代码的结构: 代码: SaveServlet.java package com.itheima.servlet; import java.io.IOExceptio ...
- 有时候eclipse 导入maven项目 启动的时候回出现这样一个问题
严重: A child container failed during start java.util.concurrent.ExecutionException: org.apache.catali ...