当前位置: 澳门新濠3559 > 编程 > 正文

利于页面布局,它使用JSP标签在HTML网页中插入

时间:2019-10-07 13:15来源:编程
一.分页技术概述 分页技术: JSP页面,用来显示数据! 如果数据有多条,分页显示,每页显示10条,多页;好处: 利于页面布局,且显示的效率高! servlet基础 1、servlet:sun公司自己制定

一.分页技术概述

分页技术:

JSP页面,用来显示数据! 如果数据有多条,分页显示,每页显示10条,多页; 好处: 利于页面布局,且显示的效率高!

servlet基础
1、servlet:sun公司自己制定了一种用于扩展web服务器功能的组件规范。

JSP技术

JSP全称Java Server Pages,是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。

JSP是一种Java servlet,主要用于实现Java web应用程序的用户界面部分。网页开发者们通过结合HTML代码以及嵌入JSP操作和命令来编写JSP。

JSP通过网页表单获取用户输入数据、访问数据库及其他数据源,然后动态地创建网页。

JSP标签有多种功能,比如访问数据库、记录用户选择信息、访问JavaBeans组件等,还可以在不同的网页中传递控制信息和共享信息。

javaweb学习总结(二十二)——基于Servlet JSP JavaBean开发模式的用户登录注册

转自:

分页关键点:

1.分页SQL语句 SELECT * FROM car LIMIT [*每页显示的行数],[每页显示的行数];;2.后台处理: dao/service/servlet/JSP

1》扩展web服务器功能
web服务器(tomcat、Weblogic、iis、apache)没有处理动态资源请求的能力
(即该请求需要计算),只能处理静态资源的请求(如果浏览器请求某个html页面,
web服务器查看请求的html页面是否存在,存在则返回。)如果要让web服务器
处理动态资源的请求,则需要使用cgi程序、组件加容器的方式。

不用JSP,只用servlet来输出网页

        response.setContentType("text/html;charset=UTF-8");
        PrintWriter writer = response.getWriter();
        //动态的响应html页面
        writer.write("<!DOCTYPE html>");
        writer.write("<html>");
        writer.write("<head>");
        writer.write("<meta charset='UTF-8'>");
        writer.write("<title>Insert title here</title>");
        writer.write("</head>");
        writer.write("<body>");
        writer.write("<h1>这个页面很繁琐</h1>");
        writer.write("</body>");
        writer.write("</html>");                

servlet先出现,只有servlet的时候,servlet又要处理逻辑又要负责输出html。 比如上面实现方式非常繁琐,代码很难维护,所以推出了jsp技术。JSP可以很方便的编写或者修改HTML网页而不用去面对大量的println语句。

利于页面布局,它使用JSP标签在HTML网页中插入Java代码。一、Servlet JSP JavaBean开发模式(MVC)介绍

  Servlet JSP JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,javabean负责封装数据。 Servlet JSP JavaBean模式程序各个模块之间层次清晰,web开发推荐采用此种模式。

  这里以一个最常用的用户登录注册程序来讲解Servlet JSP JavaBean开发模式,通过这个用户登录注册程序综合案例,把之前的学过的XML、Xpath、Servlet、jsp的知识点都串联起来。

实现步骤:
  1. 环境准备a) 引入jar文件i. 数据库驱动包ii. BaseDao引用qr.update 公用类: JdbcUtils.java
  2. 先设计:PageBean.java
  3. Dao接口设计/实现: 2个方法
  4. Service/servlet
  5. JSP

2》组件:可以单独部署的软件模块,组件必须要符合相应的规范。
优点是可以加快软件开发的速度,提高软件的可维护性。
容器:为组件提供运行环境,并且管理组件的生命周期。
组件并不完全依赖特定的容器,只要符合相应的规范就可以。

jsp脚本

 <%java代码%>   内部的java代码翻译到service方法的内部

 <%=java变量或表达式>  会被翻译成service方法内部out.print()

 <%!java代码%>  会被翻译成servlet的成员的内容

二、创建MVC架构的Web项目

  在MyEclipse中新创建一个webmvcframework项目,导入项目所需要的开发包(jar包),创建项目所需要的包,在java开发中,架构的层次是以包的形式体现出来的

项目所需要的开发包(jar包)

序号

开发包名称

描述

1

dom4j-1.6.1.jar

dom4j用于操作XML文件

2

jaxen-1.1-beta-6.jar

用于解析XPath表达式

3

commons-beanutils-1.8.0.jar

工具类,用于处理bean对象

4

commons-logging.jar

commons-beanutils-1.8.0.jar的依赖jar包

5

jstl.jar

jstl标签库和EL表达式依赖包

6

standard.jar

jstl标签库和EL表达式依赖包

 

  

  

 

 

 

 

 

项目所需要的包

序号

包名

描述

所属层次

1

me.gacl.domain

存放系统的JavaBean类(只包含简单的属性以及属性对应的get和set方法,不包含具体的业务处理方法),提供给【数据访问层】、【业务处理层】、【Web层】来使用

 domain(域模型)层

2

**me.gacl.dao**

存放访问数据库的操作接口类

数据访问层

3

**me.gacl.dao.impl**

存放访问数据库的操作接口的实现类

4

**me.gacl.service**

存放处理系统业务接口类

业务处理层

5

**me.gacl.service.impl**

存放处理系统业务接口的实现类

6

**me.gacl.web.controller**

存放作为系统控制器的Servlet

Web层(表现层)

7

**me.gacl.web.UI**

存放为用户提供用户界面的servlet(UI指的是user interface)

8

me.gacl.web.filter

存放系统的用到的过滤器(Filter)

9

me.gacl.web.listener

存放系统的用到的监听器(Listener)

10

**me.gacl.util**

存放系统的通用工具类,提供给【数据访问层】、【业务处理层】、【Web层】来使用

 

11

junit.test

存放系统的测试类

 

 

  一个良好的JavaWeb项目架构应该具有以上的11个包,这样显得层次分明,各个层之间的职责也很清晰明了,搭建JavaWeb项目架构时,就按照上面的1~11的序号顺序创建包:domain→dao→dao.impl→service→service.impl→web.controller→web.UI→web.filter→web.listener→util→junit.test,包的层次创建好了,项目的架构也就定下来了,当然,在实际的项目开发中,也不一定是完完全全按照上面说的来创建包的层次结构,而是根据项目的实际情况,可能还需要创建其他的包,这个得根据项目的需要来定了

  在src目录(类目录)下面,创建用于保存用户数据的xml文件(DB.xml)

  在WEB-INF目录下创建一个pages目录,pages目录存放系统的一些受保护(不允许用户直接通过URL地址访问)的jsp页面,用户要想访问这些受保护的jsp页面,那么只能通过**me.gacl.web.UI**这个包里面的Servlet

  创建好的项目如下图(图-1)所示:

  澳门新濠3559 1

                图-1

效果展示

澳门新濠3559 2

2、书写servlet
1》写一个java类(servlet、servlet只认识java文件)实现servlet
接口或者继承HttpServlet类。
2》编译(需要使用servlet-api.jar)
3》打包:打包成文件夹或war包
一个规范的文件目录具体结构:
appName ->
web-info->
class(字节码文件 )
lib(可选,jar文件,比如jdbc)
web.xml(部署描述文件)

jsp注释

不同的注释可见范围是不同

Html注释: <!--注释内容-->  可见范围 jsp源码、翻译后的servlet、页面显示html源码

java注释: //单行注释  /*多行注释*/  可见范围 jsp源码,翻译后的servlet

jsp注释: <%--注释内容--%> 可见范围 jsp源码可见

Html注释
<%--<div></div>--%>

java注释
    <%
      //int i=10;
      /*System.out.print(i);*/
    %>

jsp注释
    <%--
     int i=10;
      /*System.out.print(i);*/
    --%>

三、分层架构的代码编写

  分层架构的代码也是按照【域模型层(domain)】→【数据访问层(dao、dao.impl)】→【业务处理层(service、service.impl)】→【表现层(web.controller、web.UI、web.filter、web.listener)】→【工具类(util)】→【测试类(junit.test)】的顺序进行编写的。

二.实现思路:

1.通过jsp页面发送请求到servlet 然后servlet将调用service层处理将结果放在pageBean中

4》部署
我们将打包好的war包文件放到web服务器上特定的目录下面。
5》启动web服务器,访问servlet

jsp运行原理

jsp本质就是servlet,jsp在第一次被访问时会被Web容器翻译成servlet,然后再执行。过程:第一次访问---->helloServlet.jsp---->helloServlet_jsp.java---->编译运行。被翻译后的servlet在Tomcat的work目录中可以找到。

tomcat下的web.xml中配置了映射。

澳门新濠3559 3

澳门新濠3559 4

3.1、开发domain层

  在me.gacl.domain包下创建一个User类

  澳门新濠3559 5

  User类具体代码如下:

澳门新濠3559 6

 1 package me.gacl.domain;
 2 
 3 import java.io.Serializable;
 4 import java.util.Date;
 5 /**
 6  * @author gacl
 7  * 用户实体类
 8  */
 9 public class User implements Serializable {
10 
11     private static final long serialVersionUID = -4313782718477229465L;
12     
13     // 用户ID
14     private String id;
15     // 用户名
16     private String userName;
17     // 用户密码
18     private String userPwd;
19     // 用户邮箱
20     private String email;
21     // 用户生日
22     private Date birthday;
23 
24     public String getId() {
25         return id;
26     }
27 
28     public void setId(String id) {
29         this.id = id;
30     }
31 
32     public String getUserName() {
33         return userName;
34     }
35 
36     public void setUserName(String userName) {
37         this.userName = userName;
38     }
39 
40     public String getUserPwd() {
41         return userPwd;
42     }
43 
44     public void setUserPwd(String userPwd) {
45         this.userPwd = userPwd;
46     }
47 
48     public String getEmail() {
49         return email;
50     }
51 
52     public void setEmail(String email) {
53         this.email = email;
54     }
55 
56     public Date getBirthday() {
57         return birthday;
58     }
59 
60     public void setBirthday(Date birthday) {
61         this.birthday = birthday;
62     }
63 }

澳门新濠3559 7

2.service层计算并数据调用dao层

本地其他主机访问
自己访问

jsp指令(3个)

jsp的指令是指导jsp翻译和运行的命令,jsp包括三大指令:

1、page指令:属性最多的指令(实际开发中page指令默认就行),根据不同的属性,指导整个页面特性。格式:<%@ page 属性名1= "属性值1" 属性名2= "属性值2" ...%>,常用属性如下:

  • language:jsp脚本中可以嵌入的语言种类
  • pageEncoding:当前jsp文件的本身编码,内部可以包含contentType
  • contentType:response.setContentType(text/html;charset=UTF-8)
  • session:是否jsp在翻译时自动创建session,默认就是true
  • import:导入java的包
  • errorPage:当当前页面出错后跳转到哪个页面
  • isErrorPage:当前页面是一个处理错误的页面

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>

2、include指令:页面包含(静态包含)指令,可以将一个jsp页面包含到另一个jsp页面中,格式:<%@ include file="被包含的文件地址"%>

3、taglib指令:在jsp页面中引入标签库(jstl标签库、struts2标签库),格式:<%@ taglib uri="标签库地址" prefix="前缀"%>

3.2、开发数据访问层(dao、dao.impl)

  在me.gacl.dao包下创建一个IUserDao接口类,对于开发接口类,我习惯以字母I作类的前缀,这样一眼就看出当前这个类是一个接口,这也算是一种良好的开发习惯吧,通过看类名就可以方便区分出是接口还是具体的实现类。

  澳门新濠3559 8

  IUserDao接口的具体代码如下:

澳门新濠3559 9

 1 package me.gacl.dao;
 2 
 3 import me.gacl.domain.User;
 4 
 5 public interface IUserDao {
 6 
 7     /**
 8      * 根据用户名和密码来查找用户
 9      * @param userName
10      * @param userPwd
11      * @return 查到到的用户
12      */
13     User find(String userName, String userPwd);
14 
15     /**
16      * 添加用户
17      * @param user
18      */
19     void add(User user);
20 
21     /**根据用户名来查找用户
22      * @param userName
23      * @return 查到到的用户
24      */
25     User find(String userName);
26 }

澳门新濠3559 10

   对于接口中的方法定义,这个只能是根据具体的业务来分析需要定义哪些方法了,但是无论是多么复杂的业务,都离不开基本的CRUD(增删改查)操作,Dao层是直接和数据库交互的,所以Dao层的接口一般都会有增删改查这四种操作的相关方法。

  在me.gacl.dao.impl包下创建一个UserDaoImpl类

  澳门新濠3559 11

  UserDaoImpl类是IUserDao接口的具体实现类,对于接口的实现类命名方式,我习惯以"接口名(去除前缀I) impl"形式或者"接口名 impl"形式来命名:IUserDao(接口)→**UserDaoImpl(实现类)或者IUserDao(接口)→IUserDaoImpl(实现类)**,这也算是一些个人的编程习惯吧,平时看到的代码大多数都是以这两种形式中的一种来来命名接口的具体实现类的,反正就是要能够一眼看出接口对应的实现类是哪一个就可以了。

  UserDaoImpl类的具体代码如下:

澳门新濠3559 12

 1 package me.gacl.dao.impl;
 2 
 3 import java.text.SimpleDateFormat;
 4 import org.dom4j.Document;
 5 import org.dom4j.Element;
 6 import me.gacl.dao.IUserDao;
 7 import me.gacl.domain.User;
 8 import me.gacl.util.XmlUtils;
 9 
10 /**
11  * IUserDao接口的实现类
12  * @author gacl
13  */
14 public class UserDaoImpl implements IUserDao {
15 
16     @Override
17     public User find(String userName, String userPwd) {
18         try{
19             Document document = XmlUtils.getDocument();
20             //使用XPath表达式来操作XML节点
21             Element e = (Element) document.selectSingleNode("//user[@userName='" userName "' and @userPwd='" userPwd "']");
22             if(e==null){
23                 return null;
24             }
25             User user = new User();
26             user.setId(e.attributeValue("id"));
27             user.setEmail(e.attributeValue("email"));
28             user.setUserPwd(e.attributeValue("userPwd"));
29             user.setUserName(e.attributeValue("userName"));
30             String birth = e.attributeValue("birthday");
31             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
32             user.setBirthday(sdf.parse(birth));
33             
34             return user;
35         
36         }catch (Exception e) {
37             throw new RuntimeException(e);
38         }
39     }
40 
41     @SuppressWarnings("deprecation")
42     @Override
43     public void add(User user) {
44         try{
45             Document document = XmlUtils.getDocument();
46             Element root = document.getRootElement();
47             Element user_node = root.addElement("user");  //创建user结点,并挂到root
48             user_node.setAttributeValue("id", user.getId());
49             user_node.setAttributeValue("userName", user.getUserName());
50             user_node.setAttributeValue("userPwd", user.getUserPwd());
51             user_node.setAttributeValue("email", user.getEmail());
52             
53             SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
54             user_node.setAttributeValue("birthday", sdf.format(user.getBirthday()));
55         
56             XmlUtils.write2Xml(document);
57             
58         }catch (Exception e) {
59             throw new RuntimeException(e);
60         }
61     }
62 
63     @Override
64     public User find(String userName) {
65         try{
66             Document document = XmlUtils.getDocument();
67             Element e = (Element) document.selectSingleNode("//user[@userName='" userName "']");
68             if(e==null){
69                 return null;
70             }
71             User user = new User();
72             user.setId(e.attributeValue("id"));
73             user.setEmail(e.attributeValue("email"));
74             user.setUserPwd(e.attributeValue("userPwd"));
75             user.setUserName(e.attributeValue("userName"));
76             String birth = e.attributeValue("birthday");
77             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
78             user.setBirthday(sdf.parse(birth));
79             
80             return user;
81         
82         }catch (Exception e) {
83             throw new RuntimeException(e);
84         }
85     }
86 
87 }

澳门新濠3559 13

3.dao层访问数据库通过pageBean中已知的数据查找相应的数据

澳门新濠3559 14

3、tomcat简介
Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,属于轻量级应用服务器,
在中小型系统和并发访问用户不是很多的场合下被普遍使用,是开发和调试JSP 程序
的首选。对于一个初学者来说,可以这样认为,当在一台机器上配置好Apache 服务器,
可利用它响应HTML(标准通用标记语言下的一个应用)页面的访问请求。实际上Tomcat
部分是Apache 服务器的扩展,但它是独立运行的,所以当你运行tomcat 时,它实际上
作为一个与Apache 独立的进程单独运行的。
诀窍是,当配置正确时,Apache 为HTML页面服务,而Tomcat 实际上运行JSP 页面和
Servlet。Tomcat和IIS等Web服务器一样,具有处理HTML页面的功能,另外它还是一个
Servlet和JSP容器,独立的Servlet容器是Tomcat的默认模式。Tomcat处理静态HTML的
能力不如Apache服务器。

jsp内置/隐式对象(9个)

jsp被翻译成servlet之后,service方法中有9个对象定义并初始化完毕,我们在jsp 脚本中可以直接使用这9个对象,

名称

类型

描述

out

javax.servlet.jsp.JspWriter

用于页面输出

request

javax.servlet.http.HttpServletRequest

得到用户请求信息,

response

javax.servlet.http.HttpServletResponse

服务器向客户端的回应信息

config

javax.servlet.ServletConfig

服务器配置,可以取得初始化参数

session

javax.servlet.http.HttpSession

用来保存用户的信息

application

javax.servlet.ServletContext

所有用户的共享信息

page

java.lang.Object

指当前页面转换后的Servlet类的实例

pageContext

javax.servlet.jsp.PageContext

JSP的页面容器

exception

java.lang.Throwable

表示JSP页面所发生的异常,在错误页中才起作用

3.3、开发service层(service层对web层提供所有的业务服务)

   在me.gacl.service包中创建IUserService接口类

  澳门新濠3559 15

  IUserService接口的具体代码如下:

澳门新濠3559 16

 1 package me.gacl.service;
 2 
 3 import me.gacl.domain.User;
 4 import me.gacl.exception.UserExistException;
 5 
 6 public interface IUserService {
 7 
 8     /**
 9      * 提供注册服务
10      * @param user
11      * @throws UserExistException
12      */
13     void registerUser(User user) throws UserExistException;
14 
15     /**
16      * 提供登录服务
17      * @param userName
18      * @param userPwd
19      * @return
20      */
21     User loginUser(String userName, String userPwd);
22 }

澳门新濠3559 17

  在me.gacl.service.impl包中创建UserServiceImpl类

  澳门新濠3559 18

  UserServiceImpl类为IUserService接口的具体实现类,具体代码如下:

澳门新濠3559 19

 1 package me.gacl.service.impl;
 2 
 3 import me.gacl.dao.IUserDao;
 4 import me.gacl.dao.impl.UserDaoImpl;
 5 import me.gacl.domain.User;
 6 import me.gacl.exception.UserExistException;
 7 import me.gacl.service.IUserService;
 8 
 9 public class UserServiceImpl implements IUserService {
10 
11     private IUserDao userDao = new UserDaoImpl();
12     
13     @Override
14     public void registerUser(User user) throws UserExistException {
15         if (userDao.find(user.getUserName())!=null) {
16             //checked exception 
17             //unchecked exception
18             //这里抛编译时异常的原因:是我想上一层程序处理这个异常,以给用户一个友好提示
19             throw new UserExistException("注册的用户名已存在!!!");
20         }
21         userDao.add(user);
22     }
23 
24     @Override
25     public User loginUser(String userName, String userPwd) {
26         return userDao.find(userName, userPwd);
27     }
28 
29 }

澳门新濠3559 20

三.实现代码

package com.huan.pool.bean;import java.util.List;/**封装分页的参数 * Created by 马欢欢 on 2017/5/29. */public class PageBean { private int currentPage=1;//当前页 private int pageCount=10;//每页显示的行数默认每页显示4行 private int totalCount;//总记录数 private List pageData;//分页查询到的数据 private int totalPage;//总页数=总记录数、每页显示的行数 public int getCurrentPage() { if(totalCount % pageCount == 0){ totalPage = totalCount / pageCount; }else { totalPage = totalCount / pageCount  1; } return currentPage; } public void setCurrentPage(int currentPage) { this.currentPage = currentPage; } public int getPageCount() { return pageCount; } public void setPageCount(int pageCount) { this.pageCount = pageCount; } public int getTotalCount() { return totalCount; } public void setTotalCount(int totalCount) { this.totalCount = totalCount; } public int getTotalPage() { return totalPage; } public void setTotalPage(int totalPage) { this.totalPage = totalPage; } public List getPageData() { return pageData; } public void setPageData(List pageData) { this.pageData = pageData; }}

 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setContentType("text/html;charset=utf-8"); req.setCharacterEncoding; String method = req.getParameter; if ("tronClasstype".equals { tronClasstypeFind(req, resp); } else if ("save".equals { save(req, resp); } else if ("pool".equals { pool(req, resp); } else if ("pages".equals { pages(req, resp); } }//查询总数量 public int getTotalCount() throws Exception { PreparedStatement pstmt = null; Connection conn = null; conn = ConnUtil.getConnextion(); String sql = " SELECT count FROM eu_tronclass ; "; pstmt = conn.prepareStatement; ResultSet rs = pstmt.executeQuery(); while) { return rs.getInt; } ConnUtil.close(rs, pstmt, conn); return 0;}//@Test//public void aaa(){// PageBean pageBean = new PageBean();// pageBean.setPageCurrent;// try {// getAll;// } catch (Exception e) {// e.printStackTrace();// }//} public void getAll(PageBean pageBean) throws Exception { int totalCount = this.getTotalCount();//总记录数 pageBean.setTotalCount(totalCount);//填充总记录数 /* * 问题: jsp页面,如果当前页为首页,再点击上一页报错! * 如果当前页为末页,再点下一页显示有问题! * 解决: * 1. 如果当前页 <= 0; 当前页设置当前页为1; * 2. 如果当前页 > 最大页数; 当前页设置为最大页数 */ // 判断 if (pageBean.getPageCurrent { pageBean.setPageCurrent; // 把当前页设置为1 } else if (pageBean.getPageCurrent() > pageBean.getTotalPage{ pageBean.setPageCurrent(pageBean.getTotalPage; // 把当前页设置为最大页数 } int pageCurrent = pageBean.getPageCurrent();//当前页 int index = (pageCurrent -1)*pageBean.getPageCount();//起始查询位置 int count = pageBean.getPageCount();//每页显示的数量 String sql = "select * from eu_tronclass limit ?,?"; Object[] paramsValue = {index,count}; List <TronClasstype> list = super.query(sql,paramsValue,TronClasstype.class); pageBean.setPageData; JSONArray jsonArray = JSONArray.fromObject; System.out.println("getAll" jsonArray); }

 /** * 查询分页显示 */ protected void pool(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { PageBean pageBean = new PageBean(); int pageCurrent = Integer.parseInt(req.getParameter;// int pageCurrent=1; pageBean.setPageCurrent(pageCurrent); tronClassService.getAll; List<TronClasstype> TronClasstypelist = pageBean.getPageData(); JSONArray jsonArray = JSONArray.fromObject(TronClasstypelist); resp.getWriter().print(jsonArray); System.out.println("servlet"   jsonArray); } /** * 将总页数分封装在session */ protected void pages(HttpServletRequest req, HttpServletResponse resp) { PageBean pageBean = new PageBean(); tronClassService.getAll; System.out.println("99999:" pageBean.getTotalPage; req.getSession().setAttribute("pages",pageBean.getTotalPage; try { resp.getWriter().print(pageBean.getTotalPage; } catch (IOException e) { e.printStackTrace(); } }

4、servlet运行过程
在浏览器的地址栏输入:
1> 通过浏览器和ip:port和这个服务器建立连接。
2> 浏览器会生成一个请求数据包(路径appNames/servlet)向服务器发送请求。
3> 服务器收到请求数据包,分析请求资源路径做精准定位,通过请求的appName查找
webapps文件下面的appName做匹配,匹配上了需要获取web.xml中的servlet(mapping)。

out对象

out的类型:JspWriter,out作用就是想客户端输出内容,使用out.write(),out缓冲区默认8kb ,可以设置成0 ,代表关闭out缓冲区 ,内容直接写到response缓冲器。

澳门新濠3559 21

out缓冲区最终会被flush到response缓存区,所以response.getWrite().write()的内容会最先输出。

3.4、开发web层

jsp页面中第一次先创建Session 在servlet的pages方法中获取分页数放入session
var url ="http://localhost:8080/";$.post(url "/TronClassServlet?method=pages", function (data, status) { });

4> 服务器创建两个对象:
第一个对象:请求对象,该对象实现了HttpServletRequest接口,服务器会将请求数
据包中的数据解析出来,存储在该对象里。这样做的好处是没有必要理解
http协议,只需要读取request。

pageContext对象

jsp页面的上下文对象,page对象与pageContext对象不是一回事,作用如下:

1、pageContext是一个域对象,在当前页面内部有效。

setAttribute(String name,Object obj)
getAttribute(String name)
removeAttrbute(String name)

2、pageContext可以向指定的其他域中存取数据

setAttribute(String name,Object obj,int scope)
getAttribute(String name,int scope)
removeAttrbute(String name,int scope)
findAttribute(String name)

依次从pageContext域,request域,session域,application域中获取属性,在某个域中获取后将不在向后寻找。

        //使用pageContext向request域存数据
        //request.setAttribute("name", "zhangsan");
        //pageContext.setAttribute("name", "sunba");
        //pageContext.setAttribute("name", "lisi", PageContext.REQUEST_SCOPE);
        //pageContext.setAttribute("name", "wangwu", PageContext.SESSION_SCOPE);
        //pageContext.setAttribute("name", "tianqi", PageContext.APPLICATION_SCOPE);

<%=request.getAttribute("name") %>
    <%=pageContext.getAttribute("name", PageContext.REQUEST_SCOPE)%>

    <!-- findAttribute会从小到大搜索域的范围中的name -->
    <!-- page域<request域<session域<application域 -->
    <%=pageContext.findAttribute("name") %>

3、可以获得其他8大隐式对象

pageContext.getRequest();
pageContext.getOut();

3.4.1、 开发注册功能

    1、在me.gacl.web.UI包下写一个RegisterUIServlet为用户提供注册界面

    澳门新濠3559 22

  RegisterUIServlet收到用户请求后,就跳到register.jsp

  RegisterUIServlet的代码如下:

澳门新濠3559 23

 1 package me.gacl.web.UI;
 2 
 3 import java.io.IOException;
 4 import javax.servlet.ServletException;
 5 import javax.servlet.http.HttpServlet;
 6 import javax.servlet.http.HttpServletRequest;
 7 import javax.servlet.http.HttpServletResponse;
 8 /**
 9  * @author gacl
10  * 为用户提供注册的用户界面的Servlet
11  * RegisterUIServlet负责为用户输出注册界面
12  * 当用户访问RegisterUIServlet时,就跳转到WEB-INF/pages目录下的register.jsp页面
13  */
14 public class RegisterUIServlet extends HttpServlet {
15 
16     public void doGet(HttpServletRequest request, HttpServletResponse response)
17             throws ServletException, IOException {
18         request.getRequestDispatcher("/WEB-INF/pages/register.jsp").forward(request, response);
19     }
20 
21     public void doPost(HttpServletRequest request, HttpServletResponse response)
22             throws ServletException, IOException {
23         doGet(request, response);
24     }
25 
26 }

澳门新濠3559 24

         2、在/WEB-INF/pages/目录下编写用户注册的jsp页面register.jsp

    澳门新濠3559 25

    凡是位于WEB-INF目录下的jsp页面是无法直接通过URL地址直接访问的,

    澳门新濠3559 26

    在开发中如果项目中有一些敏感web资源不想被外界直接访问,那么可以考虑将这些敏感的web资源放到WEB-INF目录下,这样就可以禁止外界直接通过URL来访问了。

  register.jsp页面的代码如下:

澳门新濠3559 27

 1 <%@ page language="java" pageEncoding="UTF-8"%>
 2 <!DOCTYPE HTML>
 3 <html>
 4     <head>
 5         <title>用户注册</title>
 6     </head>
 7 
 8     <body style="text-align: center;">
 9         <form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
10             <table width="60%" border="1">
11                 <tr>
12                     <td>用户名</td>
13                     <td>
14                         
15                         <input type="text" name="userName">
16                     </td>
17                 </tr>
18                 <tr>
19                     <td>密码</td>
20                     <td>
21                         <input type="password" name="userPwd">
22                     </td>
23                 </tr>
24                 <tr>
25                     <td>确认密码</td>
26                     <td>
27                         <input type="password" name="confirmPwd">
28                     </td>
29                 </tr>
30                 <tr>
31                     <td>邮箱</td>
32                     <td>
33                         <input type="text" name="email">
34                     </td>
35                 </tr>
36                 <tr>
37                     <td>生日</td>
38                     <td>
39                         <input type="text" name="birthday">
40                     </td>
41                 </tr>
42                 <tr>
43                     <td>
44                         <input type="reset" value="清空">
45                     </td>
46                     <td>
47                         <input type="submit" value="注册">
48                     </td>
49                 </tr>
50             </table>
51         </form>
52     </body>
53 </html>

澳门新濠3559 28

  register.jsp中的<form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">指明表单提交后,交给RegisterServlet进行处理
     3、在me.gacl.web.controller包下编写用于处理用户注册的RegisterServlet

    澳门新濠3559 29

    RegisterServlet担任着以下几个职责:
               1、接收客户端提交到服务端的表单数据。

      2、校验表单数据的合法性,如果校验失败跳回到register.jsp,并回显错误信息。

      3、如果校验通过,调用service层向数据库中注册用户。

    为了方便RegisterServlet接收表单数据和校验表单数据,在此我设计一个用于校验注册表单数据RegisterFormbean,再写WebUtils工具类,封装客户端提交的表单数据到formbean中。

  在me.gacl.web.formbean包下创建一个用于校验注册表单数据RegisterFormbean

  澳门新濠3559 30

  RegisterFormbean代码如下:

澳门新濠3559 31

  1 package me.gacl.web.formbean;
  2 
  3 import java.util.HashMap;
  4 import java.util.Map;
  5 
  6 import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
  7 
  8 /**
  9  * 封装的用户注册表单bean,用来接收register.jsp中的表单输入项的值
 10  * RegisterFormBean中的属性与register.jsp中的表单输入项的name一一对应
 11  * RegisterFormBean的职责除了负责接收register.jsp中的表单输入项的值之外还担任着校验表单输入项的值的合法性
 12  * @author gacl
 13  *
 14  */
 15 public class RegisterFormBean {
 16 
 17     //RegisterFormBean中的属性与register.jsp中的表单输入项的name一一对应
 18     //<input type="text" name="userName"/>
 19     private String userName;
 20     //<input type="password" name="userPwd"/>
 21     private String userPwd;
 22     //<input type="password" name="confirmPwd"/>
 23     private String confirmPwd;
 24     //<input type="text" name="email"/>
 25     private String email;
 26     //<input type="text" name="birthday"/>
 27     private String birthday;
 28 
 29     
 30     /**
 31      * 存储校验不通过时给用户的错误提示信息
 32      */
 33     private Map<String, String> errors = new HashMap<String, String>();
 34 
 35     public Map<String, String> getErrors() {
 36         return errors;
 37     }
 38 
 39     public void setErrors(Map<String, String> errors) {
 40         this.errors = errors;
 41     }
 42 
 43     /*
 44      * validate方法负责校验表单输入项
 45      * 表单输入项校验规则:
 46      *         private String userName; 用户名不能为空,并且要是3-8的字母 abcdABcd 
 47      *         private String userPwd; 密码不能为空,并且要是3-8的数字
 48      *         private String confirmPwd; 两次密码要一致
 49      *         private String email; 可以为空,不为空要是一个合法的邮箱 
 50      *         private String birthday; 可以为空,不为空时,要是一个合法的日期
 51      */
 52     public boolean validate() {
 53 
 54         boolean isOk = true;
 55 
 56         if (this.userName == null || this.userName.trim().equals("")) {
 57             isOk = false;
 58             errors.put("userName", "用户名不能为空!!");
 59         } else {
 60             if (!this.userName.matches("[a-zA-Z]{3,8}")) {
 61                 isOk = false;
 62                 errors.put("userName", "用户名必须是3-8位的字母!!");
 63             }
 64         }
 65 
 66         if (this.userPwd == null || this.userPwd.trim().equals("")) {
 67             isOk = false;
 68             errors.put("userPwd", "密码不能为空!!");
 69         } else {
 70             if (!this.userPwd.matches("\d{3,8}")) {
 71                 isOk = false;
 72                 errors.put("userPwd", "密码必须是3-8位的数字!!");
 73             }
 74         }
 75 
 76         // private String password2; 两次密码要一致
 77         if (this.confirmPwd != null) {
 78             if (!this.confirmPwd.equals(this.userPwd)) {
 79                 isOk = false;
 80                 errors.put("confirmPwd", "两次密码不一致!!");
 81             }
 82         }
 83 
 84         // private String email; 可以为空,不为空要是一个合法的邮箱
 85         if (this.email != null && !this.email.trim().equals("")) {
 86             if (!this.email.matches("\w @\w (\.\w ) ")) {
 87                 isOk = false;
 88                 errors.put("email", "邮箱不是一个合法邮箱!!");
 89             }
 90         }
 91 
 92         // private String birthday; 可以为空,不为空时,要是一个合法的日期
 93         if (this.birthday != null && !this.birthday.trim().equals("")) {
 94             try {
 95                 DateLocaleConverter conver = new DateLocaleConverter();
 96                 conver.convert(this.birthday);
 97             } catch (Exception e) {
 98                 isOk = false;
 99                 errors.put("birthday", "生日必须要是一个日期!!");
100             }
101         }
102 
103         return isOk;
104     }
105 
106     public String getUserName() {
107         return userName;
108     }
109 
110     public void setUserName(String userName) {
111         this.userName = userName;
112     }
113 
114     public String getUserPwd() {
115         return userPwd;
116     }
117 
118     public void setUserPwd(String userPwd) {
119         this.userPwd = userPwd;
120     }
121 
122     public String getConfirmPwd() {
123         return confirmPwd;
124     }
125 
126     public void setConfirmPwd(String confirmPwd) {
127         this.confirmPwd = confirmPwd;
128     }
129 
130     public String getEmail() {
131         return email;
132     }
133 
134     public void setEmail(String email) {
135         this.email = email;
136     }
137 
138     public String getBirthday() {
139         return birthday;
140     }
141 
142     public void setBirthday(String birthday) {
143         this.birthday = birthday;
144     }
145 }

澳门新濠3559 32

  在me.gacl.util包下创建一个WebUtils工具类,该工具类的功能就是封装客户端提交的表单数据到formbean中

  澳门新濠3559 33

澳门新濠3559 34

 1 package me.gacl.util;
 2 
 3 import java.util.Enumeration;
 4 import java.util.UUID;
 5 import javax.servlet.http.HttpServletRequest;
 6 import org.apache.commons.beanutils.BeanUtils;
 7 
 8 /**
 9  * @author gacl
10  * 把request对象中的请求参数封装到bean中
11  */
12 public class WebUtils {
13 
14     /**
15      * 将request对象转换成T对象
16      * @param request 
17      * @param clazz
18      * @return
19      */
20     public static <T> T request2Bean(HttpServletRequest request,Class<T> clazz){
21         try{
22             T bean = clazz.newInstance();
23             Enumeration<String> e = request.getParameterNames(); 
24             while(e.hasMoreElements()){
25                 String name = (String) e.nextElement();
26                 String value = request.getParameter(name);
27                 BeanUtils.setProperty(bean, name, value);
28             }
29             return bean;
30         }catch (Exception e) {
31             throw new RuntimeException(e);
32         }
33     }
34     
35     /**
36      * 生成UUID
37      * @return
38      */
39     public static String makeId(){
40         return UUID.randomUUID().toString();
41     }
42     
43 }

澳门新濠3559 35

  最后看一下负责处理用户注册的RegisterServlet完整代码:

澳门新濠3559 36

 1 package me.gacl.web.controller;
 2 
 3 import java.io.IOException;
 4 import java.util.Date;
 5 import javax.servlet.ServletException;
 6 import javax.servlet.http.HttpServlet;
 7 import javax.servlet.http.HttpServletRequest;
 8 import javax.servlet.http.HttpServletResponse;
 9 import org.apache.commons.beanutils.BeanUtils;
10 import org.apache.commons.beanutils.ConvertUtils;
11 import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
12 import me.gacl.domain.User;
13 import me.gacl.exception.UserExistException;
14 import me.gacl.service.IUserService;
15 import me.gacl.service.impl.UserServiceImpl;
16 import me.gacl.util.WebUtils;
17 import me.gacl.web.formbean.RegisterFormBean;
18 /**
19  * 处理用户注册的Servlet
20  * @author gacl
21  *
22  */
23 public class RegisterServlet extends HttpServlet {
24 
25     public void doGet(HttpServletRequest request, HttpServletResponse response)
26             throws ServletException, IOException {
27         //将客户端提交的表单数据封装到RegisterFormBean对象中
28         RegisterFormBean formbean = WebUtils.request2Bean(request,RegisterFormBean.class);
29         //校验用户注册填写的表单数据
30         if (formbean.validate() == false) {//如果校验失败
31             //将封装了用户填写的表单数据的formbean对象发送回register.jsp页面的form表单中进行显示
32             request.setAttribute("formbean", formbean);
33             //校验失败就说明是用户填写的表单数据有问题,那么就跳转回register.jsp
34             request.getRequestDispatcher("/WEB-INF/pages/register.jsp").forward(request, response);
35             return;
36         }
37 
38         User user = new User();
39         try {
40             // 注册字符串到日期的转换器
41             ConvertUtils.register(new DateLocaleConverter(), Date.class);
42             BeanUtils.copyProperties(user, formbean);//把表单的数据填充到javabean中
43             user.setId(WebUtils.makeId());//设置用户的Id属性
44             IUserService service = new UserServiceImpl();
45             //调用service层提供的注册用户服务实现用户注册
46             service.registerUser(user);
47             String message = String.format(
48                     "注册成功!!3秒后为您自动跳到登录页面!!<meta http-equiv='refresh' content='3;url=%s'/>", 
49                     request.getContextPath() "/servlet/LoginUIServlet");
50             request.setAttribute("message",message);
51             request.getRequestDispatcher("/message.jsp").forward(request,response);
52 
53         } catch (UserExistException e) {
54             formbean.getErrors().put("userName", "注册用户已存在!!");
55             request.setAttribute("formbean", formbean);
56             request.getRequestDispatcher("/WEB-INF/pages/register.jsp").forward(request, response);
57         } catch (Exception e) {
58             e.printStackTrace(); // 在后台记录异常
59             request.setAttribute("message", "对不起,注册失败!!");
60             request.getRequestDispatcher("/message.jsp").forward(request,response);
61         }
62     }
63 
64     public void doPost(HttpServletRequest request, HttpServletResponse response)
65             throws ServletException, IOException {
66         doGet(request, response);
67     }
68 
69 }

澳门新濠3559 37

   用户注册时如果填写的表单数据校验不通过,那么服务器端就将一个存储了错误提示消息和表单数据的formbean对象存储到request对象中,然后发送回register.jsp页面,因此我们需要在register.jsp页面中取出request对象中formbean对象,然后将用户填写的表单数据重新回显到对应的表单项上面,将出错时的提示消息也显示到form表单上面,让用户知道是哪些数据填写不合法!

  修改register.jsp页面,代码如下:

澳门新濠3559 38

 1 <%@ page language="java" pageEncoding="UTF-8"%>
 2 <!DOCTYPE HTML>
 3 <html>
 4     <head>
 5         <title>用户注册</title>
 6     </head>
 7 
 8     <body style="text-align: center;">
 9         <form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
10             <table width="60%" border="1">
11                 <tr>
12                     <td>用户名</td>
13                     <td>
14                         <%--使用EL表达式${}提取存储在request对象中的formbean对象中封装的表单数据(formbean.userName)以及错误提示消息(formbean.errors.userName)--%>
15                         <input type="text" name="userName" value="${formbean.userName}">${formbean.errors.userName}
16                     </td>
17                 </tr>
18                 <tr>
19                     <td>密码</td>
20                     <td>
21                         <input type="password" name="userPwd" value="${formbean.userPwd}">${formbean.errors.userPwd}
22                     </td>
23                 </tr>
24                 <tr>
25                     <td>确认密码</td>
26                     <td>
27                         <input type="password" name="confirmPwd" value="${formbean.confirmPwd}">${formbean.errors.confirmPwd}
28                     </td>
29                 </tr>
30                 <tr>
31                     <td>邮箱</td>
32                     <td>
33                         <input type="text" name="email" value="${formbean.email}">${formbean.errors.email}
34                     </td>
35                 </tr>
36                 <tr>
37                     <td>生日</td>
38                     <td>
39                         <input type="text" name="birthday" value="${formbean.birthday}">${formbean.errors.birthday}
40                     </td>
41                 </tr>
42                 <tr>
43                     <td>
44                         <input type="reset" value="清空">
45                     </td>
46                     <td>
47                         <input type="submit" value="注册">
48                     </td>
49                 </tr>
50             </table>
51         </form>
52     </body>
53 </html>

澳门新濠3559 39

   到此,用户注册功能就算是开发完成了!

  下面测试一下开发好的用户注册功能:

    输入URL地址:

    澳门新濠3559 40

  如果输入的表单项不符合校验规则,那么是无法进行注册的,运行效果如下:

    澳门新濠3559 41

jsp中js的核心代码:使用layui自带分页插件

1.从session域中得到总页数2.用ajax访问servlet层查出数据并拼接到页面显示

<script type="text/javascript"> $.ready(function () { var tronClasstype = []; var dataLength = []; //分页代码 layui.use(['laypage', 'layer'], function() { var laypage = layui.laypage// , layer = layui.layer; laypage({ cont: 'demo1' , groups: 5, //连续显示分页数 jump: function(obj, first){ //得到了当前页,用于向服务端请求对应数据 var curr = obj.curr; $.post("${pageContext.request.contextPath}/TronClassServlet?method=pool", { curr:curr }, function (data, status) { $.html; for (var i = 0; i < data.length; i  ) { dataLength.push; tronClasstype = data[i]; $.append("<tr> <td><input type='checkbox'></td>"   "<td>"      "</td>"   "<td>"   tronClasstype['year']   "</td>"   "<td>"   tronClasstype['tron_month']   "</td>"   "<td>"   tronClasstype['eu_rj']   "</td>"   "<td>"   tronClasstype['eu_xin']   "</td>"   "<td>"   tronClasstype['eu_rw']   "</td>"   "<td>"   tronClasstype['eu_ts']   "</td>"   "<td>"   tronClasstype['eu_xiu']   "</td>"   "<td>"   tronClasstype['eu_gz']   "</td>"   "<td>"   tronClasstype['eu_kuai']   "</td>"   "<td>"   tronClasstype['eu_ad']   "</td>"   "<td>"   tronClasstype['eu_wc']   "</td>"   "<td>"   tronClasstype['eu_wu']   "</td>"   "<td>"   tronClasstype['eu_jr']   "</td>"   "<td>"   "<a href='/manage/article_edit_1' class='layui-btn layui-btn-mini'>编辑</a>"   "<a href='javascript:;' data-id='1' data-opt='del' class='layui-btn layui-btn-danger layui-btn-mini'>删除</a>"   "</td> </tr>" ); } }, "json" ); } , pages: <%=session.getAttribute %>//总页数 }); }); });</script>

上一篇:连接池 —— DBCP技术 和 C3P0 技术

第二个对象:响应对象,实现了HttpServletResponse接口,作用是servlet处理完成后
的结果可以存放到该对象上,然后服务器依据该对象的数据生成响应数据包。

四大作用域的总结

  • page域:当前jsp页面范围
  • request域:一次请求
  • session域:一次会话
  • application域:整个web应用

3.4.2、 开发登录功能

  1、在me.gacl.web.UI包下写一个LoginUIServlet为用户提供登录界面

  澳门新濠3559 42

  LoginUIServlet收到用户请求后,就跳到login.jsp

  LoginUIServlet的代码如下:

澳门新濠3559 43

 1 package me.gacl.web.UI;
 2 
 3 import java.io.IOException;
 4 
 5 import javax.servlet.ServletException;
 6 import javax.servlet.http.HttpServlet;
 7 import javax.servlet.http.HttpServletRequest;
 8 import javax.servlet.http.HttpServletResponse;
 9 
10 /**
11  * @author gacl
12  * LoginUIServlet负责为用户输出登陆界面
13  * 当用户访问LoginUIServlet时,就跳转到WEB-INF/pages目录下的login.jsp页面
14  */
15 public class LoginUIServlet extends HttpServlet {
16 
17     public void doGet(HttpServletRequest request, HttpServletResponse response)
18             throws ServletException, IOException {
19 
20         request.getRequestDispatcher("/WEB-INF/pages/login.jsp").forward(request, response);
21     }
22 
23     public void doPost(HttpServletRequest request, HttpServletResponse response)
24             throws ServletException, IOException {
25         doGet(request, response);
26     }
27 
28 }

澳门新濠3559 44

  2、在/WEB-INF/pages/目录下编写用户登录的jsp页面login.jsp

  澳门新濠3559 45

  login.jsp页面的代码如下:

澳门新濠3559 46

 1 <%@ page language="java" pageEncoding="UTF-8"%>
 2 <!DOCTYPE HTML>
 3 <html>
 4   <head>
 5     <title>用户登陆</title>
 6   </head>
 7   
 8   <body>
 9     <form action="${pageContext.request.contextPath }/servlet/LoginServlet" method="post">
10         用户名:<input type="text" name="username"><br/>
11         密码:<input type="password" name="password"><br/>
12         <input type="submit" value="登陆">
13     </form>
14   </body>
15 </html>

澳门新濠3559 47

  login.jsp中的<form action="${pageContext.request.contextPath}/servlet/LoginServlet" method="post">指明表单提交后,交给LoginServlet进行处理。
     3、在me.gacl.web.controller包下编写用于处理用户登录的LoginServlet

  澳门新濠3559 48

  LoginServlet的代码如下:

澳门新濠3559 49

 1 package me.gacl.web.controller;
 2 
 3 import java.io.IOException;
 4 
 5 import javax.servlet.ServletException;
 6 import javax.servlet.http.HttpServlet;
 7 import javax.servlet.http.HttpServletRequest;
 8 import javax.servlet.http.HttpServletResponse;
 9 
10 import me.gacl.domain.User;
11 import me.gacl.service.IUserService;
12 import me.gacl.service.impl.UserServiceImpl;
13 
14 /**
15  * 处理用户登录的servlet
16  * @author gacl
17  *
18  */
19 public class LoginServlet extends HttpServlet {
20 
21     public void doGet(HttpServletRequest request, HttpServletResponse response)
22             throws ServletException, IOException {
23 
24         //获取用户填写的登录用户名
25         String username = request.getParameter("username");
26         //获取用户填写的登录密码
27         String password = request.getParameter("password");
28         
29         IUserService service = new UserServiceImpl();
30         //用户登录
31         User user = service.loginUser(username, password);
32         if(user==null){
33             String message = String.format(
34                     "对不起,用户名或密码有误!!请重新登录!2秒后为您自动跳到登录页面!!<meta http-equiv='refresh' content='2;url=%s'", 
35                     request.getContextPath() "/servlet/LoginUIServlet");
36             request.setAttribute("message",message);
37             request.getRequestDispatcher("/message.jsp").forward(request, response);
38             return;
39         }
40         //登录成功后,就将用户存储到session中
41         request.getSession().setAttribute("user", user);
42         String message = String.format(
43                 "恭喜:%s,登陆成功!本页将在3秒后跳到首页!!<meta http-equiv='refresh' content='3;url=%s'", 
44                 user.getUserName(),
45                 request.getContextPath() "/index.jsp");
46         request.setAttribute("message",message);
47         request.getRequestDispatcher("/message.jsp").forward(request, response);
48     }
49 
50     public void doPost(HttpServletRequest request, HttpServletResponse response)
51             throws ServletException, IOException {
52         doGet(request, response);
53     }
54 
55 }

澳门新濠3559 50

  到此,用户登录的功能就算是开发完成了。

  下面测试一下开发好的用户登录功能,输入URL地址:

  澳门新濠3559 51

  如果输入的用户名和密码错误,那么就无法登录成功,运行效果如下:

  澳门新濠3559 52

5> servlet在执行servlet()方法时,可以通过request获取请求数据,也可以将处理结果
存放到response上。然后服务器与响应对象直接形成一个默契,生成一个响应数据包
给浏览器。

jsp标签(动作)

1)页面包含(动态包含):<jsp:include page="被包含的页面"/>,静态包含与动态包含的区别?

澳门新濠3559 53

澳门新濠3559 54

主要从以下5方面进行分析(来源):

  • 1.语法:

 静态包含:<%@ include file=""%>

动态包含:<jsp: include page=""%>

  • 2.静态包含时,包含页面和被包含页面中的html.head,body等标签总共只有出现一次,否则会报错;而动态包含不会。
  • 3.静态包含不会检查所包含文件中的变化;但是动态包含,可以检查所含文件中的变化,并且可以带参数
  • 4.静态包含是先将文件中内容导入被包含的文件中,再一起编译,最后再展现给用户(先包含再编译
  • 5.动态包含可以自动区分被包含文件是静态的还是动态的,如果是静态,则与静态包含一样处理;若是动态页面,

   则可以先进行动态的处理,再将结果包含进来。(先编译再包含

2)请求转发:<jsp:forward page="要转发的资源" />

 在jsp中写java代码:

<%
            //获得集合List<Product>
            List<Product> productList = (List<Product>)request.getAttribute("productList");
            if(productList!=null){
                for(Product product : productList){
                    out.write("<div class='col-md-2' style='height:250px'>");
                    out.write("<a href='product_info.htm'>");
                    out.write("<img src='" product.getPimage() "' width='170' height='170' style='display: inline-block;'>");
                    out.write("</a>");
                    out.write("<p><a href='product_info.html' style='color: green'>" product.getPname() "</a></p>");
                    out.write("<p><font color='#FF0000'>商城价:&yen;" product.getShop_price() "</font></p>");
                    out.write("</div>");
                }
            }
        %>

3.4.3、 开发注销功能

  在me.gacl.web.controller包下编写用于处理用户注销的LogoutServlet

  LogoutServlet的代码如下:

澳门新濠3559 55

 1 package me.gacl.web.controller;
 2 
 3 import java.io.IOException;
 4 import java.text.MessageFormat;
 5 
 6 import javax.servlet.ServletException;
 7 import javax.servlet.http.HttpServlet;
 8 import javax.servlet.http.HttpServletRequest;
 9 import javax.servlet.http.HttpServletResponse;
10 
11 public class LogoutServlet extends HttpServlet {
12 
13     public void doGet(HttpServletRequest request, HttpServletResponse response)
14             throws ServletException, IOException {
15         //移除存储在session中的user对象,实现注销功能
16         request.getSession().removeAttribute("user");
17         //由于字符串中包含有单引号,在这种情况下使用MessageFormat.format方法拼接字符串时就会有问题
18         //MessageFormat.format方法只是把字符串中的单引号去掉,不会将内容填充到指定的占位符中
19         String tempStr1 = MessageFormat.format(
20                 "注销成功!!3秒后为您自动跳到登录页面!!<meta http-equiv='refresh' content='3;url={0}'/>", 
21                 request.getContextPath() "/servlet/LoginUIServlet");
22         System.out.println(tempStr1);//输出结果:注销成功!!3秒后为您自动跳到登录页面!!<meta http-equiv=refresh content=3;url={0}/>
23         System.out.println("---------------------------------------------------------");
24         /**
25          * 要想解决"如果要拼接的字符串包含有单引号,那么MessageFormat.format方法就只是把字符串中的单引号去掉,不会将内容填充到指定的占位符中"这个问题,
26          * 那么可以需要使用单引号引起来的字符串中使用2个单引号引起来,例如:"<meta http-equiv=''refresh'' content=''3;url={0}''/>"
27          * 这样MessageFormat.format("<meta http-equiv=''refresh'' content=''3;url={0}''/>","index.jsp")就可以正常返回
28          * <meta http-equiv=''refresh'' content=''3;url=index.jsp'/>
29          */
30         String tempStr2 = MessageFormat.format(
31                 "注销成功!!3秒后为您自动跳到登录页面!!<meta http-equiv=''refresh'' content=''3;url={0}''/>", 
32                 request.getContextPath() "/servlet/LoginUIServlet");
33         /**
34          * 输出结果:
35          * 注销成功!!3秒后为您自动跳到登录页面!!
36          * <meta http-equiv='refresh' content='3;url=/webmvcframework/servlet/LoginUIServlet'/>
37          */
38         System.out.println(tempStr2);
39         
40         String message = String.format(
41                 "注销成功!!3秒后为您自动跳到登录页面!!<meta http-equiv='refresh' content='3;url=%s'/>", 
42                 request.getContextPath() "/servlet/LoginUIServlet");
43         request.setAttribute("message",message);
44         request.getRequestDispatcher("/message.jsp").forward(request, response);
45     }
46 
47     public void doPost(HttpServletRequest request, HttpServletResponse response)
48             throws ServletException, IOException {
49         doGet(request, response);
50     }
51 
52 }

澳门新濠3559 56

  用户登录成功后,会将登录的用户信息存储在session中,所以我们要将存储在session中的user删除掉,这样就可以实现用户注销了。

  用户登录成功后就会跳转到index.jsp页面,在index.jsp页面中放一个【退出登陆】按钮,当点击【退出登陆】按钮时,就访问LogoutServlet,将用户注销。

  index.jsp的代码如下:

澳门新濠3559 57

 1 <%@ page language="java"  pageEncoding="UTF-8"%>
 2 <%--为了避免在jsp页面中出现java代码,这里引入jstl标签库,利用jstl标签库提供的标签来做一些逻辑判断处理 --%>
 3 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 4 <!DOCTYPE HTML>
 5 <html>
 6   <head>
 7     <title>首页</title>
 8      <script type="text/javascript">
 9         function doLogout(){
10             //访问LogoutServlet注销当前登录的用户
11             window.location.href="${pageContext.request.contextPath}/servlet/LogoutServlet";
12         }
13     </script>
14   </head>
15   
16   <body>
17     <h1>孤傲苍狼的网站</h1>
18     <hr/>
19     <c:if test="${user==null}">
20         <a href="${pageContext.request.contextPath}/servlet/RegisterUIServlet" target="_blank">注册</a>
21         <a href="${pageContext.request.contextPath}/servlet/LoginUIServlet">登陆</a>
22     </c:if>
23     <c:if test="${user!=null}">
24            欢迎您:${user.userName}
25            <input type="button" value="退出登陆" onclick="doLogout()">
26     </c:if>
27     <hr/>
28 </body>
29 </html>

澳门新濠3559 58

  测试开发好的注销功能,效果如下:

  澳门新濠3559 59

  到此,所有的功能都开发完成了,测试也通过了。

6> 浏览器解析服务器返回的响应数据包,生成响应的结果。

EL技术

EL(Express Lanuage)表达式可以嵌入在jsp页面内部,减少jsp脚本的编写,EL出现的目的是要替代jsp页面中脚本的编写。

四、开发总结

  通过这个小例子,可以了解到mvc分层架构的项目搭建,在平时的项目开发中,也都是按照如下的顺序来进行开发的:

  1、搭建开发环境

    1.1 创建web项目

    1.2 导入项目所需的开发包

    1.3 创建程序的包名,在java中是以包来体现项目的分层架构的

  2、开发domain

  把一张要操作的表当成一个VO类(VO类只定义属性以及属性对应的get和set方法,没有涉及到具体业务的操作方法),VO表示的是值对象,通俗地说,就是把表中的每一条记录当成一个对象,表中的每一个字段就作为这个对象的属性。每往表中插入一条记录,就相当于是把一个VO类的实例对象插入到数据表中,对数据表进行操作时,都是直接把一个VO类的对象写入到表中,一个VO类对象就是一条记录。每一个VO对象可以表示一张表中的一行记录,VO类的名称要和表的名称一致或者对应。

  3、开发dao

    3.1 DAO操作接口:每一个DAO操作接口规定了,一张表在一个项目中的具体操作方法,此接口的名称最好按照如下格式编写:“I表名称Dao”。

      ├DAO接口里面的所有方法按照以下的命名编写:

        ├更新数据库:doXxx()

        ├查询数据库:findXxx()或getXxx()

    3.2 DAO操作接口的实现类:实现类中完成具体的增删改查操作

      ├此实现类完成的只是数据库中最核心的操作,并没有专门处理数据库的打开和关闭,因为这些操作与具体的业务操作无关。

  4、开发service(service 对web层提供所有的业务服务)

  5、开发web层

  点击此处下载项目源码

1、http协议
1》http协议:定义了浏览器与服务器之间通讯的过程以及数据格式。
2》通讯过程
1、浏览器请求web服务器建立一个连接。
2、浏览器向web服务器发送请求(会依据协议将请求数据打包)
3、服务器处理请求,并且将处理结果发送给浏览器(依据协议将处理结果打包)
4、服务器发送结果完毕后立即关闭连接。

EL从域中取出数据

EL最主要的作用是获得四大域中的数据,格式${EL表达式}

  • EL获得pageContext域中的值:$(pageContextScope.key);
  • EL获得request域中的值:$(request.key);
  • EL获得session域中的值:$(session.key);
  • EL获得application域中的值:$(application.key);

3》数据格式

EL从四个域中获得某个值$(key);

同样是依次从pageContext域,request域,session域,application域中获取属性,在某个域中获取后将不在向后寻找。

示例:

1、EL获得普通字符串

2、EL获得User对象的值

3、EL获得List<String>的值

4、EL获得List<User>的值

5、EL获得Map<String,String>的值

6、EL获得Map<String,User>的值

澳门新濠3559 60澳门新濠3559 61

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="com.itheima.domain.*" %>
<%@ page import="java.util.*" %>
<!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>
    <!-- 模拟域中的数据 -->
    <%
        pageContext.setAttribute("company", "阿里");

        //存储字符串
        request.setAttribute("company", "企鹅");

        //存储一个对象
        User user = new User();
        user.setId(1);
        user.setName("zhangsan");
        user.setPassword("123");
        session.setAttribute("user", user);

        //存储一个集合
        List<User> list = new ArrayList<User>();
        User user1 = new User();
        user1.setId(2);
        user1.setName("lisi");
        user1.setPassword("123");
        list.add(user1);
        User user2 = new User();
        user2.setId(3);
        user2.setName("wangwu");
        user2.setPassword("123");
        list.add(user2);
        application.setAttribute("list", list);

    %>


    <!-- 脚本法是取出域中的值 -->
    <%=request.getAttribute("company") %>
    <%
        User sessionUser = (User)session.getAttribute("user");
        out.write(sessionUser.getName());
    %>
    <hr/>
    <!-- 使用EL表达式获得域中的值 -->
    ${requestScope.company }
    ${sessionScope.user.name }
    ${applicationScope.list[1].name}

    <!-- 使用el表达式 全域查找 -->
    ${company }
    ${user.name }
    ${list[1].name}

    <!-- el可以执行表达式运算 -->
    ${1 1 }
    ${1==1?true:false }
    <!-- empty 判定某个对象是否是null  是null返回true -->
    ${empty list}


</body>
</html>

View Code

请求数据包->
第一部分:
请求行:请求方式(get/post)请求资源路径协议版本信息。
第二部分:
若干的消息头,是w3c定义的一些简单通讯规则,比如服务器可
以向浏览器发送一个“content-type”消息头告诉浏览器返回的数据类型以及编码。
第三部分:
实体内容:只有当请求方式是post时,请求参数及参数值才会
存放在这。如果请求方式为get时请求参数和参数值就会添加到请求资源的路径后面。

EL的内置对象(九个)

pageScope,requestScope,sessionScope,applicationScope;

获取JSP中域中的数据

接收参数:param,paramValues;

获取请求头信息:header,headerValues;

获取全局初始化参数:initParam;

WEB开发中cookie:cookie;

WEB开发中的pageContext:pageContext;

例子:

<!-- 获得表单的参数 -->
    <%
        request.getParameter("username");
    %>

    <!-- 使用el获得参数 -->
    ${param.username }
    ${header["User-Agent"] }
    ${initParam.aaa }
    ${cookie.name.value }    
    ${cookie.abc.value }

<!-- 通过el表达式获得request对象 --> 
${pageContext.request }
与${requestScope}不同,对象不仅包含域,而且还有其他数据和方法
<!--获得WEB应用的名称-->
$(pageContext.request.contextPath)相当于<%=pageContext.getRequest().getContextPath%>

响应数据包->
第一部分:
状态行:协议版本、状态码、描述
常见的状态码:404 找不到,500 系统出错,200 正常
第二部分:
若个消息头
第三部分:
实体内容:存放处理结果

JSTL技术

JSTL(JSP Standard Tag Library),JSP标准标签库,可以嵌入在jsp页面中使用标签的形式完成业务逻辑等功能。jstl出现的目的同el一样也是要替换jsp页面中的脚本代码。JSTL标准标准标签库有5个子库,但随着发展,目前常使用的是他的核心库。

标签库

标签库的URI

前缀

Core

http://java.sun.com/jsp/jstl/core

c

I18N

http://java.sun.com/jsp/jstl/fmt

fmt

SQL

http://java.sun.com/jsp/jstl/sql

sql

XML

http://java.sun.com/jsp/jstl/xml

x

Functions

http://java.sun.com/jsp/jstl/functions

fn

2、get请求和post请求
1>get请求:
1、在浏览器地址栏直接输入一个地址
2、点击链接地址
3、表单默认的提交
2>post请求:给表单的method属性设置为“post”
3>get方式和post方式的区别
1、get方式会将参数和参数值放到请求资源路径的后面,而post方式会
将这些数据放到实体内容里。
2、get方式提交的数据会显示在浏览器地址栏,这样不安全。post方式
相对安全,参数和参数值不会显示在地址栏,显示在实体内容里。
3、get方式提交的数据量是有限的(1K),而post方式理论上是没有限制的。

JSTL下载与导入

JSTL下载:从Apache的网站下载JSTL的JAR包。进入 “ JSTL的安装包。jakarta-taglibs-standard-1.1.2.zip,然后将下载好的JSTL安装包进行解压,此时,在lib目录下可以看到两个JAR文件,分别为jstl.jar和standard.jar。 其中,jstl.jar文件包含JSTL规范中定义的接口和相关类,standard.jar文件包含用于 实现JSTL的.class文件以及JSTL中5个标签库描述符文件(TLD)。

将两个jar包导入我们工程的lib中,导入:

澳门新濠3559 62

3.JSTL核心库的常用标签

1、<c:if>标签

<!-- 用户没有登录 -->
<c:if test="${empty user}">
    <li><a href="login.jsp">登录</a></li>
    <li><a href="register.jsp">注册</a></li>
</c:if>
<!-- 用户已经登录 -->
<c:if test="${!empty user}">
    <li>${user.name }</li>
    <li><a href="#">提出</a></li>
</c:if>

2、<c:forEach>标签

使用方式有两种组合形式:

方式一:

澳门新濠3559 63

方式二:

<h1>取出strList的数据</h1>
    <c:forEach items="${strList }" var="str">
        ${str }<br/>
    </c:forEach>

    <h1>取出userList的数据</h1>
    <c:forEach items="${userList}" var="user">
        user的name:${user.name }------user的password:${user.password }<br/>
    </c:forEach>

    <h1>取出strMap的数据</h1>
    <c:forEach items="${strMap }" var="entry">
        ${entry.key }====${entry.value }<br/>
    </c:forEach>

    <h1>取出userMap的数据</h1>
    <c:forEach items="${userMap }" var="entry">
        ${entry.key }:${entry.value.name }--${entry.value.password }<br/>
    </c:forEach>

3、表单的处理
1>设置表单的提交方式为post
2>获取参数值
String request.getParameter(String paraName);
eg:

String username=request.getParameter("username");
如果参数名相同:
String[] request.getParameterValues(String para);
3>处理中文问题
1.在html代码里添加:
<meta http-equiv="content_type" content="text/html;charset=utf-8">
2.在服务器端设置编码时采用统一的编码格式,浏览器请求的时候编码格式
要与服务器一致。request.setCharacterEncoding("utf-8");

javaEE的开发模式

模式在开发过程中总结出的“套路”,总结出的一套约定俗成的设计模式

4、访问数据库
1》将数据库jdbc的驱动(.jar文件)放置到lib文件夹下
2》在servlet类中使用jdbc代码访问数据库需要注意:
1、注意关闭数据库连接
2、写一个错误处理页面
3、可以直接在web.xml文件中配置错误处理页面
<error-page>
<error-code>500</error-code>
<location>/err500.html</location>
</error-page>

javaEE经历的模式

model1模式,技术组成:jsp javaBean,这种模式的弊端是随着业务复杂性,导致jsp页面比较混乱。

model2模式,技术组成:jsp servlet javaBean,这种模式的优点是,开发中使用各个技术擅长的方面:

  • servlet:擅长处理java业务代码
  • jsp:擅长页面的现实

1、重定向
1》定义:服务器向浏览器发送一个状态码302及一个消息头location,
浏览器在接收到以后立刻向location所指的地址发送请求。
2》代码:response.sendRedirect(String url);
3》重定向的特点
a>重定向之后浏览器地址栏的地址会发生改变,变成location所指向的地址。
b>重定义的地址是任意的。
4》注意:在重定义之前不要有任何输出。
主要指:
out.println();
out.flush();
out.close();
如果response中缓存有数据,该数据会被清空,然后做重定向。

MVC:web开发的设计模式

M:Model---模型 javaBean,封装数据

V:View-----视图 jsp,单纯进行页面的显示

C:Controller----控制器 Servelt,获取数据--对数据进行封装--传递数据-- 指派显示的jsp页面

2、在数据库中保存中文
1》设置数据库的编码(支持中文的)
2》给jdbc驱动添加一些参数,让jdbc驱动程序知道数据库的编码从而正确的解码。
eg:
jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8

javaEE三层架构 MVC

web层:收集页面数据,封装数据,传递数据,指定响应jsp页面

service层:逻辑业务代码的编写

dao层:数据库的访问代码的编写

澳门新濠3559 64

比如商品展示,使用Servlet和jsp技术搭建三层架构如下图所示:

澳门新濠3559 65

jsp增删改查Demo.zip

3、servlet容器如何处理请求资源路径
eg:
地址栏输入:
作为请求资源路径放到请求数据包里,发送给servlet容器。

servlet容器按照如下步骤处理请求资源路径:
1》比较web.xml中的<url-pattern>的配置与/index.jsp是否匹配。
a.精确匹配
b.模糊匹配(通配符“*”来匹配)
*表示任意字符串 url-pattern:/index/*
地址:/index/test/ ok
/index/test/test/ ok
/index/test/test ok
/index/ ok
/index ok
c.后缀匹配(不能够以"/"开头)
eg: *.do *.action '.'后是一个任意字符串
表示以这些字符串结尾的地址都匹配

2》如果找不到则认为这是一个jsp,然后再跳转到jsp页面查找,
找到就返回,找不到则提示404错误。

4、如何让一个servlet能够处理多个请求
1》在web.xml文件中,使用后缀匹配。
2》在service()方法里分析请求资源路径。

5、servlet核心与接口以及生命周期
1》servlet生命周期的含义:
指的是servlet容器如何从创建servlet实例、初始化(分配资源)。
调用service()方法、到最后销毁servlet实例的过程。

2》servlet生命周期的四个阶段
第一阶段:实例化
第一种情况:当请求到达容器时,容器会先检查该请求,
检查对应的servlet实例是否存在,如果存在不会重新创建,
如果不存在则重新创建(单例模式)。

第二种情况:当容器启动或者部署某个新的应用时,容器会
检查web.xml文件中的servlet有没有配置<load-on-startup>
如果配置了就会立刻创建实例。参数值越小优先级越高,创建
的机会越靠前。

第二阶段:初始化
给servlet实例分配资源,容器会调用servlet的初始化方法
init(ServletConfig config),创建一个符合ServletConfig
接口的对象给servlet实例。config对象就可以去访问servlet
的初始化参数。init()只执行一次。

第三阶段:就绪
容器收到请求,调用servlet实例的service()方法

第四阶段:销毁
容器依据自己的算法将不再需要的servlet实例进行销毁,在销毁
之前会调用servlet实例的destory()方法。destory()方法也只
执行一次。

1、dao:封装了数据访问逻辑。
1》dao接口
2》daoImp实现类
3》实体对象entity
4》工厂类Factory(创建实现类对象)
servlet通过dao获取结果的过程:
通过dao接口的回调获取对象(该对象是通过工厂相应的方法得到实现dao接口类的对象)
再调用该对象相应的方法获取到想要的结果。

1、servlet核心接口和类
1》servlet接口
init(ServletConfig config) //初始化servlet
destory() //销毁servlet
//http响应的方法是doGet/doPost
service(ServletRequest,ServletResponse)
doGet()
doPost()

2》GenericServlet抽象类
实现了servlet接口中的init(ServletConfig)和destroy()方法
子类可以选择override init()或者init(ServletConfig config)
优先选择override(覆盖的)

3》HttpServlet抽象类:
继承了GenericServlet实现了service()方法。
该service执行的流程:依据请求类型分别调用doGet和doPost方法,
doGet和doPost在默认情况下都是抛出异常的。所以写一个servlet
可以选择的方式有两种:
第一种:override doGet/soPost方法
第二种:override service方法

4》servletConfig接口
获取servlet初始化参数 String getInitParameter(String paraName)

5》ServletRequest/ServletResponse
这两个接口是HttpServletRequest/HttpServletResponse的父接口

6》HttpServletRequest/HttpServletResponse接口

其中只有void service(ServletRequest req,ServletResponse response)
方法是由tomcat自动调用,它将接收的客户端请求转交给HttpServlet中的另一个
protected void service(HttpServletRequest req,HttpServletResponse res)
方法,此保护类型的service方法再把将请求分发给doPost()、doGet()方法
进行下一步处理。
所以我们完全可以重写受保护的service()方法来代替doPost()和doGet()方法

2、jsp
1》定义:sun公司制定的一种服务器端动态页面生成的技术规范。因为直接使用
servlet生成动态页面过于繁琐( out.println("html代码") ),并且难以
维护(页面修改,java代码修改),因此产生了jsp。

2》jsp组成:主要有两块。
1.html内容(包括html、css、js等)
2.少量的java代码

3》书写jsp:直接编写一个以.jsp为后缀的文件,不需要编译。
1.如果是html内容,直接编写。
注释:<!--html浏览器任然执行代码--> <%--浏览器不执行代码--%>

2.如果是java代码,有两种方式书写:
第一种:java代码片段<% java代码 %>
第二种:jsp表达式<% =java表达式 %>

3.指令:所谓指令会在jsp引擎将jsp文件转换成java文件时做一些额外的处理。
eg、导包指令的语法:
<%指令 属性=属性值%>
page指令:
import属性:用于导包
eg:
<%@page import="java.util.*" %>

pageEncoding属性:告诉jsp引擎,jsp文件的编码格式。
eg:
<%@page pageEncoding="utf-8" %>

contentType属性;生成response.setContentType(...);
eg:
<%@page contentType="text/html;charset=utf-8" %>

4.隐含对象
在jsp文件中,不用声明就可以使用的对象
(因为jsp引擎会自动生成声明和创建这些对象的代码)
1.pageContext JSP的页面容器
2.request 得到用户的请求信息
3.response 服务器向客户端的响应信息
4.session 用来保存每一个用户的信息
5.application 表示所有用户的共享信息
6.config 服务器配置可以获取初始化参数
7.out 页面输出
8.page 从页面中表示出来的一个Servlet实例
9.exception JSP页面所发生的异常,在错误页中才起作用。

4》jsp的执行
当浏览器向服务器请求访问jsp文件时,服务器会先将jsp文件转换成java文件
(该转换的java文件实际上是一个servlet),接下来需要编译该servlet(自动编译),然后实例化
(web.xml)、初始化(init方法)、调用service方法(doGet或者doPost)。
可以看出:将jsp文件转换成java文件的模块叫做jsp引擎。

5》jsp文件如何转换成servlet
1.html-->service()方法里,使用out.write()输出(流的方式)。
2.java代码片段-->service方法里,直接照搬。
3.jsp表达式-->service方法里使用out.print()输出。

1、转发
1》定义:在同一应用内部,一个web组件将未完成的处理转发给另外一个web组件
继续处理,这样的过程叫做转发。
转发最常用的应用场景:servlet获取处理数据之后转发给jsp,由jsp生成响应页面。

2》代码
首先绑定数据:
//在request对象上以name为绑定名,绑定一个object
request.setAttribute(String name,Object object);

//依据绑定名获取绑定值,如果name对应的值不存在,返回null。
Object request.getAttribute(String name);

//解除绑定
request.removeAttribute(String name);

接下来转发:
//获取转发器,url指的是转发的目的地,一般是jsp。
RequestDispatcher rd=
request.getRequestDispatcher(String url);

//转发
rd.forward(request,response);

3》转发需要注意的问题
在转发之前不能有任何的输出,转发之前会先将response中缓存的数据先清空。

4》转发的特点
1.转发的目的地只能是同一个应用内部的各个组件之间
2.转发的各个组件之间可以共享request、response

2、include指令
<% @include file="header.jsp/foot.jsp" %>作用是告诉引擎在jsp文件转换为
java文件时,在当前指令所在的位置插入header.jsp/foot.jsp文件的内容。

3、路径问题
在使用链接、表单提交、重定向,转发时如何正确的使用相对路径和绝对路径。
1》相对路径:不以"/"开头的路径,相对当前项目。
eg:<a href="del.do"></a>
2》绝对路径:以"/"开头的路径
eg:<a href="/appName/del.do" ></a>
3》书写绝对路径
链接、表单提交、重定向的绝对路径是从应用名开始的,而转发的绝对路径是从
应用名之后开始。
写绝对路径的时候要尽量避免直接写应用名,而是通过request.getContentPath();

1、转发和重定向的区别
1》相同点:
本质上转发和重定向都是为了实现一个组件去调用另一个组件,也就是组件之间的跳转。
也可以这样认为:转发是通过容器作为媒介实现调用另一个组件,
重定向是通过浏览器作为媒介来实现这样的操作。

2》不同点:
1.浏览器地址栏的地址变化:
重定向:变化
转发:不变

2.目的地地址
重定向:任意
转发:同一个应用的内部

3.能否共享request对象
重定向:不能(因为重定向有两次请求,第一次请求产生的 request对象已经被销毁了)
转发:可以

4.事件是否已经做完
重定向:做完了
转发:未做完

2、状态管理
1》状态管理定义:因为浏览器与web服务器之间是通过http协议来发送请求和响应的,
而http协议是一个无状态协议(浏览器向服务器发送请求时,不会向服务器标示是哪个
浏览器在访问它,服务器发送完响应之后立刻关闭)。
在某些特定情况下需要将浏览器与服务器的多次交互操作看做是一个整体,
在管理这个整体的过程就是状态管理。
多次交互操作所涉及的数据叫做状态,而对这些数据进行管理就叫状态管理。

2》如何进行状态管理
1.cookie 在客户端记录用户状态
2.session 在服务器端记录用户状态

3》cookie
1.定义:
当浏览器访问服务器时服务器会将一些数据以set-cookie消息头
的方式发送给浏览器,浏览器会将这些数据存储到本地或者以
文件的形式保存在磁盘上,也可以保存在内存。当浏览器再次访
问服务器的时候会将这些数据以cookie消息头的方式再次发送给
服务器,通过这种方式就能对状态进行管理。

2.创建cookie
Cookie cookie =
new Cookie(String name,String value);
response.addCookie(cookie);

3.查询cookie
Cookie[] cookies= request.getCookies();
String cookieName= cookies[澳门新濠3559 ,0].getName();
String cookieValue= cookies[1].getValue();

4.cookie保存中文问题
cookie的值只能够是ASSII字符,需要将中文转化为
assii字符的表现形式。

5.cookie的生存时间
cookie.setMaxAge(int seconds);
seconds>0:浏览器会将该数据保存在磁盘上,当超过
seconds指定的值时,浏览器会删除该数据。

seconds<0:浏览器会将该数据保存在本地内存中,浏览器
关闭,会删除此类型的值为默认缺省值。

seconds=0:立即删除cookie
Cookie cookie=
new Cookie("username","baobao");
cookie.setAge(0);
response.addCookie(cookie);

6.cookie的路径
cookie可以设置其访问路径,如果不设置会默认一个
访问路径(默认的访问路径是保存该cookie的路径)
浏览器在访问服务器的某个地址值时,需要比较该地址
与cookie的路径是否匹配,只有匹配的cookie才会被发送。
匹配规则:
要访问的地址必须是cookie的路径或者是其子路径。
cookie.setPath("/appName");
该cookie在访问/appName下的所有组件时都会发出。

cookie.setPath("/");
该cookie在访问同一个服务器上的所有部署应用时都会发送。

7.cookie的限制
1.cookie可以被禁止
2.cookie的大小有限制(4k)
3.cookie的数量也是有限制(指一个浏览器在本地最多存储大约300个左右)
4.cookie只能够保存字符串,并且需要对中文进行编码
5.cookie将数据保存在客户端,不安全。

4》session
1.浏览器访问服务器时服务器会创建一个对象(该对象HttpSession接口
一般称为session对象,每一个session对象都有一个唯一的标识sessionId)
服务器在默认情况下会使用cookie机制将sessionId发送给浏览器。
浏览器再次访问服务器时会将sessionId发送给服务器,服务器依据
sessionId找到之前的session对象。
2.获取session对象
方式一:
HttpSession session =
request.getSession(boolean flag);
当flag= true:
服务器检查浏览器发送的请求当中有没有sessionId
没有就创建session对象,如果有服务器会依据sessionId
去查找session对象。查找到了就不创建session对象,
如果找不到就创建session对象。
当flag=false:
服务器检查浏览器发送过来的请求当中有没有SessionId
如果没有不创建session对象并且返回null。
如果有服务器会依据当前的sessionId去查找session对象
是否存在,如果不存在不创建session对象并且返回null。

方式二:
HttpSession session=request.getSession();
request.getSession()是request.getSession(true)的简写

3.常用的方法。
//获取sessionId
String session.getId();
//
session.setAttribute(String name,Object obj);

session.removeAttribute(String name);

//如果name对应的对象不存在返回null
session.getAttribute(String name);

4.session的失效
//可以设置最大不活动时间间隔,超过这个时间间隔服务器
删除该session。
session.setMaxInactiveInterval(int seconds);
服务器有一个缺省的失效时间(tomcat是30分钟)超过这个时间
间隔也会删除session。
eg: tomcat
tomcat的web.xml
<session-config>
<session-timeout>30</session-timeout>
</session-config>

WEB-INFO/web.xml
<session-config>
<session-timeout>30</session-timeout>
</session-config>

5.立即删除session
session.invalidate();

5》session案例
1.session验证
在用户登录成功之后在session对象里绑定一些数据(userId,放入少量数据)
session.setAttribute("userId","1");
当用户访问需要登录才能看到的资源时进行一下session校验
执行:
Object obj= session.getAttribute("userId");
对当前的用户判断是否登录,obj为null没有登录,
重定向到一个登录页面
obj不为null用户已经登录,放行。

 

过滤器
1》定义:servlet规范当中定义的一种特殊的类,其做用是拦截servlet容器的调用过程。

2》书写过滤器
1.写一个java类,实现Filter接口。
2.在doFilter方法里,实现拦截的逻辑。
3.配置(在web.xml中配置哪些请求地址做过滤条件)

3》过滤器的优先级
<filter-mapping>配置的先后决定了过滤执行的先后。

4》过滤器的优点
1.将一些组件相同或者相近的代码(权限管理、编码处理、安全、session验证
等)集中写到一个过滤器中方便代码维护。
2.实现代码的“可插拔性”

 

编辑:编程 本文来源:利于页面布局,它使用JSP标签在HTML网页中插入

关键词: 澳门新濠3559