JavaWeb 基础学习

XMAPP是自己封装的一套 web 开发套件 —— 例如Tomcat等是用自己的，而不是使用系统中其他地方安装好了的。此外将提供的 xampp 工具解压到 D 盘根目录下。（注意 xampp 一定要解压到根目录下才有效。所谓根目录是指 D:\xampp\目录下不能再嵌套 xampp 目录，而是直接在 D:\xampp\目录下能够找到 mysql 目录。切记！！）。

Servlet：Services+Applet的缩写。GET 方法可能返回缓存数据，而POST 方法不会缓存数据，并且常用于连同请求一起发送数据。

Tomcat的配置：

1. 下载：http://tomcat.apache.org。
2. 用Eclipse等IDE新建一个Web类型工程，导入Tomcat的servlet-api.jar包(JSP语法支持)。
3. 将工程部署在Tomcat服务器上：选择Window|Preferences选项，在Preferences对话框中，选择Server|Runtime Environments，选中Add按钮，选择与下载的Tomcat版本相同的，在下一个页面选择其安装目录，确定即可完成服务器的配置。
4. 运行选择Run on Server，然后在对话框中，选择与刚才相同版本的Tomcat服务器。

Tomcat管理界面(workspace里面那个Server没有管理界面)：

　　配置登录用户——在Tomcat安装目录的conf下，修改tomcat-users.xml文件，加上一个<user username="" password="" roles=""></user>。

创建Servlet(不使用IDE对话框向导)：

1. 新建一个类，继承javax.servlet.http.HttpServlet接口。
2. 重写GenericServlet的init方法(有/无参数)、destroy方法，以及HttpServlet的service(HttpServletRequest，HttpServletResponse)方法。——探究Servlet的生命周期。
3. 配置WebContent\WEB-INF目录下的web.xml文件：创建访问Servlet类的入口地址(servlet-name、servlet-class、url-pattern，其中servlet-class如果写对了，是可以链接过去的)。

生命周期：

请求访问该Servlet(访问刚才的入口地址)——Tomcat的Web Server将请求发送给Servlet容器，然后容器找到Servlet类并实例化(init方法，无参的init是必须的，因为有参的init也会调用无参的)，然后就可以提供服务(调用service方法：请求n次，实例化一次，提供服务n次，在service方法中根据不同的请求，调用不同的http请求方法)，最后容器销毁Servlet实例(调用destroy方法：把工程最终版本导出到webapps目录下，运行tomcat的启动脚本，进入管理界面，stop或者Undeploy掉Servlet类)。

示例代码：

//servlet.HelloServlet类
@Override
public void init() throws ServletException {
    // TODO Auto-generated method stub
    super.init();
    System.out.println("init without param");
}

@Override
public void init(ServletConfig config) throws ServletException {
    // TODO Auto-generated method stub
    super.init(config);
    System.out.println("init with param");
}

@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // TODO Auto-generated method stub
    System.out.println("service");
    PrintWriter writer = response.getWriter();
    writer.println("hello");
    writer.close();
}

@Override
public void destroy() {
    // TODO Auto-generated method stub
    super.destroy();
    System.out.println("service");
}

<!-- web.xml -->
<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

加上初始化参数：

<servlet>
<servlet-name>InitServlet</servlet-name>
<servlet-class>Servlet.testServlet</servlet-class>
<init-param>
  <param-name>user</param-name>
  <param-value>shutao</param-value>
</init-param>
<init-param>
  <param-name>password</param-name>
  <param-value>114809</param-value>
</init-param>
</servlet>

使用Servlet的filter：

Filter与Servlet的相似，但Filter的生命周期必然在对应的Servlet之前（不过也是在第一次访问对应的url-pattern时，才创建Filter的实例。先执行了过滤器链的所有doFilter方法之后，最后再访问对应的Servlet。过滤器可以截获到用户提交的request，最后由Servlet返回response）——由于过滤器的功能，所以它可以被应用于权限校验、日志记录、图像处理、数据压缩等。

创建一个Filter(这里只列举重要的方法)：

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    // TODO Auto-generated method stub
    // place your code here
    System.out.println("doFilter start");
    chain.doFilter(request, response);
    System.out.println("doFilter end");
}
public void init(FilterConfig fConfig) throws ServletException {
    // TODO Auto-generated method stub
    System.out.println("init");
    String initParam = fConfig.getInitParameter("param");
    System.out.println("initParam = " + initParam);
}

配置过滤器：

<filter>
    <filter-name>FilterOne</filter-name>
    <filter-class>filter.FilterOne</filter-class>
    <init-param>
        <param-name>param</param-name>
        <param-value>qunyh</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>FilterOne</filter-name>
    <!-- 对任意的Servlet过滤 -->
    <url-pattern>/*</url-pattern>
</filter-mapping>

过滤器链：

即依次执行多个过滤器，执行顺序是在web.xml中的编写顺序，但销毁和结束的顺序却是相反。

在JSP页面中，引入包：

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" import="java.util.*"%>

JSP元素：

脚本元素、指令元素、动作元素。

直接总结指令（形如<%@***>）、动作（形如<jsp:***>）：

1、编译指令Page：

JSP页面错误页的设置和使用：

在处理错误的页面的page指令中，设置isErrorPage="true"；在出错页面，设置errorPage="处理错误的页面"。

2、include指令：

//index页面
<body>
<%@ include file="header.jsp" %>
</body>

//header.jsp页面
<div>
This is header.
</div>

与ASP相对照：

<!--Header-->
<%template src="_header.html"%>
<!--/Header-->

3、taglib指令。

动作指令：

forward指令，并且在页面跳转时，进行参数传递：

//index页面
<jsp:forward page="login.jsp">
    <jsp:param value="shutao" name="username"/>
    <jsp:param value="114809" name="password"/>
</jsp:forward>

//login页面
<body>
<%
    //使用JSP内置对象request获得传递的参数
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    out.println(username + ": " + password);
%>

useBean指令：

useBean指令可指定JavaBean的使用范围，例如：

<jsp:useBean id="user" scope="page|request|session|application" class="bean.UserBean"></jsp:useBean>——这其中的scope只能选其一。

创建Bean类：

1. 一定要添加Serializable接口，不然会抛出异常。
2. 所有属性都要通过getter、setter方法来获取、更改。
3. 类中要有一个空的构造函数(仅指参数为空，方法体可以不为空)。

通过Bean实现，多个页面之间传值：

例如创建一个UserBean类，其中有username、password属性；然后创建一个register和do_register页面，将register提交的属性，保存在do_register页面的Bean中(这个页面的实例，所以只能在创建页面使用)。

<!-- register页面 -->
<body>
    <form action="do_register.jsp" method="post">
        用户名：<input type="text" name="username"><br>
        密码：<input type="password" name="password">
        <input type="submit" value="提交">
    </form>
</body>

//do_register页面
<body>
<jsp:useBean id="user" class="bean.UserBean"></jsp:useBean>    <!-- useBean指令注册JavaBean,不必像下面这样,这里的user已经是UserBean的实例了,可直接像使用普通对象一样使用 -->

<jsp:setProperty property="username" name="user"/>    <!-- 设置Bean的属性值 -->
<jsp:setProperty property="password" name="user"/>

<jsp:getProperty property="username" name="user"/>    <!-- 获取Bean的属性值 -->
<jsp:getProperty property="password" name="user"/>
</body>

Servlet实现的接口：

配置-ServletConfig：

继承的主要的方法：

//配置信息：Servlet名字、初始化参数、上下文
getInitParameter(String name);
getInitParameterNames();
getServletContext();

请求与响应-ServletRequest、ServletResponse：

方法：

//Request
getCookies();
getSession();
getSession(boolean create);
getParameter(String name);

String[] getParameterValues(String name);    //获取input(checkbox)或select的值
//获取input或者select的值
<!--input页面，action=show.jsp-->
<input type="checkbox" name="channel" value="报刊">报刊
<input type="checkbox" name="channel" value="网络">网络<br/>
<input type="checkbox" name="channel" value="朋友推荐">朋友推荐
<input type="checkbox" name="channel" value="电视">电视
<!--show.jsp-->
<%
    if (channels != null) {
        for (String channel: channels) {
            out.print(channel+"&nbsp;");
        }
    }
%>

//Response
addCookies(Cookies cookie);
encodeURL(String url);
sendRedirect(String location);
setContentType(String type);
setCharacterEncoding(String charset);

Servlet协作（页面之间的跳转，如果有请求，也会一起转发）：

方法：

forward(ServletRequest req, ServletResponse res);    //把请求转发给RequestDispatcher对象的页面；实际上是新开一个线程，去加载新的页面，但是原来页面中的程序也会继续执行
include(ServletRequest req, ServletResponse res);    //把RequestDispatcher的页面包含到响应之中

重定向sendRedirect和转发请求RequestDispatcher的对比：

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // TODO Auto-generated method stub
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    UserBean user = new UserBean();
    user.setUsername(username);
    user.setPassword(password);
    if(checkUser(user))
    {
        //RequestDispatcher实现对请求的转发：因此无论怎样跳转，表单数据都可以发送到指定页面;此外转发只能用于同一程序的页面（只加载的是新url的内容，地址不变）
        request.setAttribute("user", user);
        RequestDispatcher dispatcher = request.getRequestDispatcher("LoginSuccess.jsp");
        dispatcher.forward(request, response);
    }
    else
    {
        //纯粹的跳转：一共有两次跳转，这是第二次，并没有涉及到表单数据，所以这个页面是无法获取之前提交的表单数据;可以跳转到任何URL（重定向：相当于自动重新访问一个新的url）
        response.sendRedirect("LoginFailed.jsp");
    }
}

会话跟踪-HttpSession：

好像是因为tomcat什么的，没有会话层（ISO7层），因此在客户端创建Session，维持与Http会话之间的关联，即维持单个客户端的状态（由Servlet创建并实现）。

方法：

getCreationTime();
getId();
getLastAccessedTime();
getMaxInactiveInterval();
getValue(String name);
getValueNames();
invalidate();
isNew();
putValue(String name, Object value);
removeValue(String name);　　//如果是用于退出登录，那么应将session中存储的所有对象统统删除，以免退出登录之后，用户在其他页面依然能够访问到这些对象
setMaxInactiveInterval(int interval);

Servlet上下文：

ServletContext对象代表多个Servlet要共享的资源。

方法：

getAttribute(String name);
getAttribute(String uripath);
removeAttribute(String name);
setAttribute(String name, Object obj);

JSP内置对象：

1、request对象：javax.servlet.http.HttpServletRequest的实例（new不出来）。这个对象封装了客户端提交的请求信息：

1. 状态行。
2. HTTP头。
3. 信息体。

<%
    out.println("/工程名：" + request.getContextPath() + "<br />");
    out.println("协议类型：" + request.getScheme() + "<br />");
    request.getServletContext().getRealPath("项目下的某目录名");//获得虚拟目录的真实路径
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    out.println("浏览器访问工程的路径：" + basePath);        //显示效果(即服务器 + 工程名) ———— http://localhost:8080/Spring/
%>

2、response：是javax.servlet.http.HttpServletResponse实例（不是new出来的）。

request是客户端向服务器发送请求，response是服务器对客户端的请求，作出回应。

类似于HTTP请求，HTTP响应也有3个基本部分：

1. 状态行：包含了，协议、状态码（表示请求是否成功）。
2. 头Header：设置关于服务器和返回的文档信息——如服务器名称、文档类型。
3. 信息体。

例子：

<body>
<%
    response.setHeader("Refresh", "1");
    response.setIntHeader("Refresh", 1);
    out.println(new java.util.Date());
%>

3、application对象：

由于同一台电脑的同一浏览器（即同一进程）访问服务器的session相同，所以此时要记录这台电脑上登陆的不同用户，就需要一个跨session的容器：application（相当于所谓的全局变量）。因此不同用户可以通过application共享数据。常用的方法有：

void setAttribute(String key, Object value);    //以键值对保存数据
Object getAttribute(String key);    //通常需要强转