java 私塾笔记整理——web 部分

java 私塾笔记整理——web 部分

第一章 web 应用技术

一. 概述
    1.HTTP：
        HTTP协议
        HTML文档
        MIME规范：定义HTTP传输文档的类型，默认text/HTML
    2.客户/服务架构
    客户操作的界面是客户端，大部分功能都运行在服务器端。

二. web站点和web应用
     1.web站点
    一个web站点是一个静态的概念，由一组分层次的HTML文档，媒体文件及相关目录结构组成。
     2.web应用
    在服务器端具有动态功能的web站点。

三.web动态功能实现
  1.CGI程序(Common Gateway Interface).
  2.JavaServlet(Servlet 是web层的核心组件)
    Servlet是在服务器上：①处理HTTP请求的java组件；②动态生成web层的核心组件
    Web容器是一个特殊的JVM，负责维护Servlet生命周期及为每个请求生成线程（即提供运行环境）。
    Servlet优点：性能（线程比进程快），可伸缩。
           缺点：处理代码（业务逻辑）与HTML(表现层)混合在一起。
  3.JSP模板页面（具有Servlet所有的优点）
  JSP页面被专程Servlet类并编译，在Web容器中作为Servlet对待。

   *JAVA中的底层联网都是SOCKET
   *区分web站点和web应用不涉及到客户端，而是看是否在服务器端运行
   *HTTP请求应答模式:
       IE---Request--->Server
       IE<--Response---Server

   特点：一次请求加一次应答是一次完整的操作，每一次完整的操作都是全新的
   *API文档中 java.xxx 一般为sun专用
              Javax.xxx  一般为JEE专用

   *JavaScript运行环境JSEngine
   *动态网页DHTML用JS来实现

第二章 Servlet

一.概述
1.Servlet:运行在服务器端的java组件。
         运行在客户端的是applet组件。
2.Border: Servlet只做接受和生成响应，具体如何处理不管
3.ServletAPI(Servlet中有什么？)
    常用的servlet包的名称是： javax.servlet
                              javax.servlet.http

  顶层            Servlet            ServletRequest           ServletResponse
Abstract class      GenericServlet
Abstract class      HttpServlet        HttpServletRequest       HttpServletResponse

GenericServlet 实现共性方法，HttpServlet跟协议相关，这样分层有利于扩展，有其他  协议可以直接继承GenericSrevlet

二.HTTP协议
   HTTPGet方法:一般是页面上的链接，或地址栏上URL输入。

三.HTTP请求
   1.请求格式

标题栏（固定信息）

Head  Key:value(用户不能更改，有ie生成)

空行

数据区：Parameter（用户输入的数据）id=xxx ;name=xxx

   一次Http请求带的内容有：
     ——head
     ——parameter
     ——attribute
     ——cookie
   2. HttpServlet Request API
     —getHeader(name): 将key当做参数，取她所对应的值;
     —getHeaders(name)：Enumeration;
     —getHeader();

四.Http响应
   1.响应格式（没有空行）

【此处有图片，可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】
2.HttpServletResponseAPI
    —SetContentType(String MIME---type)
    —getWriter; printWriter;
    —getOutputStream();ServletOutputStream
    —addHeader(name,value)
getWriter; printWriter 与getOutputStream();ServletOutputStream 只能二选其一，不能同时或组合使用

五.HTTPServlet
    1.HTTPServletAPI                   javax.Servlet.http.x
   步骤：a.继承HttpServlet
         b.实现doGet()
    c.每个servlet要求有一个public的，空的构造方法
   浏览器：符合HTTP规范的客户端程序

六.流程
    1.引jar包
          1)构建开发环境 tomcat-->lib包-->servlet-api.jar
    2.开发servlet类
          1)首先继承HttpServlet
          2)实现 doGet() doPost()
          3)定义 doGet() doPost()
    3.建个web应用
    4.部署
         安装web容器，例如Tomcat：在Tomcat的webapps目录下新建一个文件夹作为web程序的根，在根下新建一个名为WEB-INF的文件夹，里面建立一个web.xml的文件、一个classes的文件夹、一个lib文件夹。
按照servlet的DTD配置web.xml文件
<servlet>
  <servlet-name>aaa</servlet-name>
  <servlet-class>com.javass.area.web.AreaServlet</servlet-class>
</servlet>

<servlet-mapping>
  <servlet-name>aaa</servlet-name>
  <url-pattern>/areaServlet</url-pattern>
</servlet-mapping>

把编译好的servlet的class文件复制到classes目录下，
lib文件存放程序所需要的jar包
    5.client 页面测试（HTML页面）
    Client页面→action触发事件→web.xml中找class路径→运行组件
     HTML页面地址栏中输入：ht tp://localhost:8080/nanlu/xxx.html
     Web应用和上下文告诉web应用服务器应调用哪个web应用上下文
     Web应用

       *抽象类与接口的选择
    一般来说优先选择接口，在以下情况中选择抽象类：
    既要约束子类的行为，又要为子类提供共性的功能。

   *设计模式实现了可见部分和不可见部分的分离。

   *HTTP目前传输方式有7中最常见的是Get和Post。
   对比get方法和post方法
get方法：请求对服务器没有负面影响，Form数据量小，数据的内部应在url中可见；明文传输，安全度低
post方法：请求的数据过程改变服务器的状态，Form数据量大，数据的内部应在url
中不可见，安全度高；

   *抽象类中所有的抽象方法必须在其子类中实现。

    WEB—INF
      |—web.xml（必须）
      |—classes（可选，有的话，用来放web应用需要的类包）
      |—lib（可选，有的话，用来放web应用需要的jar包）
    xxx.jar   (java档案资源文件)                  
     |—META—INF                     
         |—MANIFEST.MF (描述jar文件的属性和配置)  

     xxx.ear(企业档案文件包)
      |—MEAT—INF
           |—Application.xml（描述era文件所包含的锁个war或者jar还有library）

第三章 Web应用的部署描述符
  
一. Servlet的部署描述
servlet需要配置web.xml文件来使容器认识servlet程序

二.Servlet基本的描述应该是
<servlet>
<servlet-name>Hello</servlet-name>
<servlet-class>sl314.web.FormBasedHello</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Hello</servlet-name>
<url-pattern>/greeting</url-pattern>
</servlet-mapping>

第四章 使用HTML Form的Servlet

一.在html中使用servlet
FORM标记
  ACTION– 指定form信息的目的地（相关的URL）
  METHOD – 指定HTTP方法（GET或POST）
语法：
  <FORM ACTION=’servlet-URL’ METHOD=’{GET|POST}’>
   {HTML form tags and other HTML content}
  </FORM>

二.HTML接受request中的参数
HttpServletRequest接口：
可以从请求对象中访问HTML form参数
   getParameter(name): String
   getParameterValues(name): String[]
   getParameterNames(): Enumeration
例如：
   String name = request.getParameter(“name”);
   String[] sports =request.getParameterValues(“sports”);

三. HTML如何接受request中header的值
HttpServletRequestAPI：
getHeader(name) : String
getHeaders(name) : Enumeration
getHeaderNames() : Enumeration
getIntHeader(name) : int
getDateHeader(name) : Date

四.如何输出html
PrintWriter out = response.getWriter();
out.write("<html>");
out.write("Hello");
out.write("</html>");

五.如何设置输出的contentType
response.getContentType()
  
第五章 生命周期

servlet的生命周期
生命周期是指servlet实例在web容器中从首次创建调用init方法开始初始化期，经过service方法运行期，一直到destory方法销毁期结束,servlet实例的生命周期由web容器来管理
【此处有图片，可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】

一.Servlet 接口只能被web容器调用，用户不能调用
    inti (ServletConfig,config);
    destroy ();
    service (ServletRequest req, ServletRequest resp)
    可提供这些方法的实现，来操纵Servlet实例及资源。

二.init方法：Servlet实例首次创建时，由Web容器调用
   具体XML中<servlet-class>xxx xxx</servlet-class>
   实现步骤：
        1.class.forName(“xxx xxxx”);
        2.创建一个类实例（此处似乎普通类实例，不是servlet类实例）
        3.init()完成后就创建了一个Servlet实例。
        * init()在首次创建Servlet时使用，即遇到第一个new类名()时使用。
          需要Override init方法的情况：
                创建或打开与Servlet相关的资源
                初始化Servlet状态（状态即数据，此处指Servlet属性）
        *inti()的特点：只初始化一次。
   *servlet规范确保在实例调用init方法前，不会被处理。
        *还有一个带参数的init方法，一般不重写。

三.service方法（回调方法）
        接二中第三步
        4.service(调用子类中的doGet(),doPost())
         由web容器调用service方法，处理请求（可以调用多次）。
        HttpServlet实现了Service方法根据HTTP请求方法（”get”,”post”）将请求分发到doGet,doPost中

四.destory方法，只能被调用一次
        1.servlet实例被销毁时，有web容器调用。
        2.servlet规范确保在destory方法被调用前，所有请求处理完成。
        3.需要重写destory()的情况：
                  释放在任何方法中打开的与servlet相关的资源
                  存储Servlet状态
   *综上所述,web容器基本上是一个实例池，里面放的都是Servlet实例。

五.日志
   错误日志，可以方便以后调式程序，知道传入什么会出现bug。

  *ServletAPI
     1.Servlet接口
       Init(config:ServletConfig);
       a.运行之前配置，取参数
       b.在xml中配置，部署描述文件
       service(request,response);
       destroy;
    2.ServletConfig接口
       getInitParameter(name);String
       getInitParameter Names;Enumeration
       getServletName();String
    3.web容器调用GenericServlet的init(config)然后存储器来，再调用init()
      初始化参数（xml中）存储在servlet实例相关的servletConfig对象中。

*回调方法：
  是现在应用程序里面，不由程序调用，而由容器调用
  特点：由容器来决定什么时候来调

*如何设置初始化servlet的参数？
<servlet>
<servlet-name>EnglishHello</servlet-name>
<servlet-class>examples.web.HelloServlet</servlet-class>
<init-param>
       <param-name>greetingText</param-name>
       <param-value>Hello</param-value>
</init-param>
</servlet>

*如何获取servlet初始化的参数
Servlet访问初始化参数：
public class HelloServlet extends HttpServlet {
∵ String greetingText;
public void init(){
     greetingText = getInitParameter(“greetingText”);
     System.out.println(“>> greetingText = ‘”+ greetingText + “‘”);
}

*ServletConfig接口默认实在那里实现的GenericServlet类实现ServletConfig接口，可直接访问配置。

第六章  Servlet Context

一.ServletContext对象是web应用的运行时表示，可通过其实现web应用中的资源共享。
   ServletContext与Servlet没有任何关系所以在xml中配置不在<servlet>中。

二.ServletContext API
     1.this.getServletContext(); 访问ServletContext对象
  2.ServletContext提供4个如下功能
    (1)只读访问上下文初始化参数：getInitParamenter();
    (2)读写访问应用级属性：
         setAttribute(name,value);
         getAttribute(name,value);
         getAttributeNames();
        *此类功能类似于map。 Set时若key相同则相当于作了修改，get…返回的是一个object类，需相知转换。
    (3)只读访问应用级文件资源
        getResource(path):url
        getResourceStream(path):InputStream
     (4)写访问应用级日志文件：log(String),log(String,throwable)

三.访问共享的运行时属性
   变相实现了不同Servlet类中的参数传递
       getAttribute(key);
       setAttribute(key,object value);

四.web应用的生命周期
      1.web容器启动时初始化每个web应用
      2.web容器关闭时销毁每个web应用
   3.创建∵，监听这些事件，只有整个web应用才会有listener,servlet中没有。

*如何设置Context的参数？
<web-app>
<display-name>Serlvet Context Example</display-name>
<description>
This Web Application demonstrates application-scoped variables
</description>
<context-param>
<param-name>catalogFileName</param-name>
<param-value>/WEB-INF/catalog.txt</param-value>
</context-param>

*访问ServletContext的接口
  ServletContext context = sce.getServletContext();
  String catalogFileName = context.getInitParameter(“catalogFileName”);
  是在GenericServlet类中实现的

*用代码实现监控Web应用的生命周期
   可以创建ServletContextListener接口的实现监.听Web应用生命周期事件

第七章 web应用的异常处理

一.web应用中如下错误码:
400    Bad Request
401    Unauthorized
404    Not Found
500    Internal Server Error

二.描述Web应用中用声明方式来进行错误处理的两种方法
使用error-page元素声明一个给定HTTP状态码的处理器
  <error-page>
   <error-code>404</error-code>
   <location>/error/404.html</location>
  </error-page>
可以声明任意数量的错误页面，但一个给定的状态码只能对应一个页面使用exception-type元素声明给定Java异常的处理器
  <error-page>
   <exception-type>
          java.lang.ArithmeticException
   </exception-type>
  <location>/error/ExceptionPage</location>
  </error-page>
可以声明任意数量的错误页面，但一个给定的异常类型只对应一个页面不能使用父类捕获多种异常

三.描述记录异常日志的方法，都位于那些接口？
记录异常日志的两个log方法：
log(String) – 将消息输出到日志文件
log(String, Throwable)– 将消息和异常栈的跟踪信息输出到日志文件
GenericServlet：
log(message:String)
log(message:String, Throwable:excp)
ServletContext：
log(message:String)
log(message:String, excp:Throwable)

第八章 会话管理（session）
一.概述
  1.HTTP是无状态的，因为每个请求和响应的连接都是独立的。从一个请求到另一个请求，HTTP会忘记以前的请求
  2.web容器中的会话：在服务器端为特定的客户保存数据的一种机制
    session区分的是客户端而不是请求，同一客户的对此请求均可访问session

【此处有图片，可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】
*session判断是否是同一客户端的依据是IE浏览器（浏览器生成的head不同，对于session是不同客户）关闭IE后再打开一个即为新的客户端。
*session response的时候在cookie中带有JSessionID,HTTP协议规定，每次请求时都要带cookie,这就为统一客户端的不同请求提供了打开session的钥匙。

request   session  servletContext   三者独立无关系，均有 setAttribute(String,object);  getAttribute(String);   removeAttribute();
  
request发送时带有 a. head
                   b. paramenter
                   c. attribute
                   d. cookie

二.会话API
  1.HttpServletRequest接口   getSession()
                           getSession(create boolean)

   HttpSession接口：getID();isNew()
   在parent中开出的子窗口发送的请求还属于parent客户端。
  2.销毁会话
    (1)在部署描述文件中销毁
<session-config>
<session-timeout>10</session-timeout>
</session-config>
(2)用容器销毁，可以保证所有事情都处理完才销毁。
   SetMaxInactiveInterval(int);最后一次操作session后,多长时间没操作就会清空session。
   若配置文件与程序中都定义了timeout,依程序中为准。
*使用invalidate()销毁时可能引起其他servlet冲突，所以一般不用。

三.使用cookie会话管理

四.使用url重写管理方法（由用户设置阻止cookie文件时）
  *会话是线程不安全的，并发会出现

  *会话：Web容器可为每个用户保存一个"会话对象"，用来存储特定用户的会话信息
  *销毁会话：
可使用部署描述符控制所有会话的生命周期：
         <session-config>
                <session-timeout>10</session-timeout>
        </session-config>
控制特定会话对象的生命周期——HttpSession接口：
        invalidate()
        getCreationTime() :long
        getLastAccessedTime() :long
        getMaxInactiveInterval() :int
        setMaxInactiveInterval(int)

*读写cookie实例
通过将Cookies加到响应对象中，可将其存储在客户计算机上：
写：String name = request.getParameter("firstName");
        Cookie c = new Cookie("yourname", name);
        response.addCookie(c);

可从请求对象中检索Cookies：
读：

1. Cookie[] allCookies = request.getCookies();
   
2.    for ( int i=0; i < allCookies.length; i++ ) {
   
3.       if ( allCookies[i].getName().equals(“yourname”) ) {
   
4.                name = allCookies[i].getValue();  
   
5.       }
   
6.    }

复制代码

* URL重写：
Cookie不能使用时，可使用URL重写 客户在每个URL的后面追加额外的数据服务器将此标识符与其存储的有关会话数据相关联 使用如下URL：
ht tp://host/path/file;jsessionid=123

第九章 web应用的安全

一.web应用的4种认证技术
   BASIC – Web浏览器接收用户名和口令，将其以明码方式发送给Web服务器
   DIGEST – Web浏览器接收用户名和口令，使用加密算法将此数据发送给Web服务器
   FORM – Web应用提供发送给Web浏览器的HTML form
   CLIENT-CERT – Web容器使用SSL验证用户

二.授权与验证
   授权是根据用户角色划分Web资源的过程，其标识Web应用中的安全域

三.审计
   访问跟踪（也称审计）是为Web应用的每次访问保留记录的过程 可通过将其写入日志文件，来审计Web应用发生的动作

四.如何实现声明性授权
   标识Web资源集
   标识角色
   将Web资源集映射到角色
   标识每个角色中的用户

   *什么是HTTPS
   HTTPS (Secure Hypertext Transfer Protocol) 是使用SSL协议的HTTP

第十章 web应用的并发处理问题

一.servlet肯定存在并发
   多个同类线程运行，可共享同一个Servlet实例共享的数据和资源未合理同步，可能引起数据冲突

二.web应用中6中属性范围
      —局部变量（不会并发）
      —实例变量（会并发）
      —类变量（会并发）
      —请求属性（不会并发）
      —会话属性（会并发）
      —上下文属性（会并发）

   *在xml中要传多个parametervalue时(如传数组等)可以写为
                           <param-value>a,b,c,d</param-value>取值后用,拆分
   *JSE定位在客户端程序的应用上
    JEE定位在服务器端程序的应用上
   *反射：能根据名称去运行一个类或一个方法
   *request dispatcher
【此处有图片，可以到JAVA 私塾官网下载完整笔记：ww w.javass.cn】

   情况1：
       requestDispatcher一般用request得到，而不用servletContext(不安全)。
       request.setAttribute(“req”,object);
       request.getAttribute(“req”);
       requestDispatcher rd = request.getRequestDispatcher(“xxxx”);参数为xml中的urlPattern
       不加web应用上下文是因为统一request肯定在统一web应用中

   情况2：
         Response.sendRedirect(“xxxx”);全新的请求
         可以重新定向到任意URL,web应用内外均可，所以要加全路径

   *STM？如何实现？
    STM(SingleThreadModel)：
    实现SingleThreadModel (STM)接口，某一时刻只有一个请求线程执行service方法

   *实现并发管理？
        尽可能只使用局部和请求属性
        使用synchronized语法控制并发
        尽可能减少同步块和同步方法的使用
        使用正确设置了线程安全的资源类

第十一章 JSP

一.概述
   1.JSP页面允许HTML页面中包含java代码。
     JSP≈HTML(主干)+java
     JSP本质上是Servlet
   2.JSP技术的目标：支持表现和业务逻辑相分离
     JSP页面处理过程：a.请求进入web容器，jsp→Servlet
                      b.编译servlet代码,将编译过的类文件装入web容器JVM中
                      c.web容器为jsp页面创建一个Servlet类实例，并执行_jspinit()方法
                      d.web容器为改JSP页面调用servlet实例的_jspservice(),将结果发送给用户

二.脚本元素
  1.JSP脚本元素
   a.注释标记
            <%
              xxxxxx;
                 %>

   b.java中的注释标记
     // 或 /*xxxxxx*/ 直接镶嵌入其中即可。

   C.指令标记<%@  directName %>
     如<%@ page import=”java.util.*”%>

   d.声明标记
     <%!
      Class A{
         方法
       }
      %>
   
   e.脚本标记
     <%
     只能写java语句
     %>

   f.表达式标记(在HTML中镶嵌使用)
    如：input type=”text” value=”<%=str%>”

三.翻译规则
   1.从上到下，按顺序翻译；
   2.指令标记直接拷贝到servlet相应位置
   3.空行，”/r/n”,html,css,JavaScript等非java语句全部当做字符串翻译到_jspService中out.write();出来
   4.声明标记的内容原封不动的拷贝到servlet中
   5.脚本标记内容拷贝到_jspService中
   6.注释：有些服务器忽略。把注释拷贝到_jspService中
   7.HTML语言当文本，如out.write(“<form>”);
   8.表达式标记，翻译到_jspService()中直接输出

四.隐含变量：无需自己定义，已经存在的直接可以拿来用的变量，_jspService()中预定义的变量
   request   与请求相关的HttpServletRequest对象；
   response   与送回浏览器的响应相关的HttpServletResponse对象；
   out     与响应的输出流相关的JspWriter对象；
   session   与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参与一个HTTP会话时有意义；
   application  用于Web应用的ServletContext对象；
   config    与该JSP页面的servlet相关的ServletConfig对象；
   pageContext  该对象封装了一个JSP页面请求的环境；
   page    该变量与Java编程语言中的this变量等价；
   exception    由其它JSP页面抛出的Throwable对象，该变量只在“JSP错误页面”中可用；
     1.隐含变量由容器在翻译JSP时自动生成并赋值；
     2.定义在_jspService中，在JSP中的注释，脚本标记和表达式翻译到_jspService中。

五. page指令
   page指令用于修改JSP页面的整体翻译；
     例如，可以声明从JSP页面生成servlet代码所需要的Date类：
       <%@ page import=”java.util.Date” %>
     可以使用多个页面指令，但任一给定属性只能声明一次；
     可以将page指令放在JSP文件中的任何地方。
   属性：
     autoFlush 定义缓冲满时，缓冲输出是否自动完成(flush)或抛出异常。缺省值为true；
     isThreadSafe 允许JSP开发人员声明JSP页面是否线程安全；
     info 定义一个有关JSP页面的信息串；
     errorPage 指明由另一个JSP页面处理所有该JSP页面运行时抛出的异常。例如，errorPage=”error.jsp” (相对于当前层次) 或errorPage=”/error/formErrors.jsp” (相对于context root)；
     isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或false（缺省）；所有“是错误页面”的JSP页面自动具有访问exception隐含变量的权限；
     contentType 定义输出流的MIME类型，缺省为text/html；
     pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1。

六.调式JSP页面
   1.看例外exception信息报错在哪一行。
   2.分析可能的原因
   3.在关键地方输出

   * Jsp页面中的注释
       HTML注释
     <!-- HTML注释显示在响应中 -->
       JSP页面注释
     <%-- JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。 --%>
       Java注释
     <%
     /* Java注释显示在servlet代码中，不显示在响应中 */
     %>

   * Jsp页面的指令标记
     目的：指令标记影响JSP页面的翻译阶段
     语法：
     <%@ DirectiveName [ attr=” value”]* %>
     例：
     <%@ page session=”false” %>
     <%@ include file=”incl/copyright.html” %>

   * Jsp页面的声明标记
     目的：声明标记允许JSP页面开发人员包含类级声明
     语法：
     <%!  JavaClassDeclaration %>
      例：
     <%! public static final String DEFAULT_NAME = “World”; %>
     <%! public String getName(HttpServletRequest request) {
            return request.getParameter(“name”);
        }
     %>
    <%! int counter = 0; %>

第十二章  使用MVC模式开发web应用
  一. Web Servlet中的MVC—初始化所有共享数据和资源服务于每个Http请求
      1.MVC (Model-View-Controller)
        MVC是什么?是一种架构模式，它本身不引入新的功能，只是指导把web应用结构做的更加合理，使得逻辑与页面相分离。
        MVC—包含3个部分
           Model—封装应用状态（即数据）,标准的是javabean,但是逻辑层来实现
              —响应状态查询
              —暴露应用功能
           Controller—收集参数
                 —验证数据
                 —调用逻辑层API获取返回值
                 —根据返回值，选择下一界面
           View—产生HTML响应
                     —请求模型的更新
                     —提供HTML form用于用户请求
   *以后只要提到web应用就要用到MVC架构模式

二.web应用的活动
    —初始化所有共享数据和资源
    —服务于每个Http请求
      a.验证HTML form数据
      b.如果数据验证检查不通过，发送错误页面
      c.处理可存储持久信息的数据
      d.如果处理失败，发送一个错误页面
      e.如果处理成功，发送一个响应页面

第十三章  使用Model1
一.Model1架构（JSP+JAVABEAN）
    没有控制器Controller，指的是不使用Servlet
    *javabean组件不是EJB组件

二.
    1.javabean组件在服务器端的一种java组件，用于封装对象数据和对象行为。
      即标准的JavaBean = 数据 + 行为
    2.怎么写  a.使用get,set方法定义属性
              b.一个无参构造方法
              c.没有public实例变量

    *我们现在学习的Vo只是封装了数据，没有行为

三.JSP标准动作（6个）翻译到_jspService()中
   1.<jsp:useBean  id=”vv” class=”com.javass.user.Vo.UserVo”/>
   2.<jsp:setPorperty  name=”vv” property=”*”/>
   *要求：form中的组件名称要同Vo中的属性名完全相同，首字母都要小写，
          Servlet中getAttribute(“vv”);名字也要相同。
   *采用这种方法，更高效，方便，并且javabean可以直接进行类型转换，相当于利用javabean进行替换原来的代码，收集参数，组织参数。
   3.javabean的范围（四种）—即缓存范围
    Scope=（”application”,”session”,”request”,’page’）默认为page
    *思路：去缓存中查找，有就用;
           没有就新创建一个，放在当前缓存中。

    *jsp标准动作
        JSP页面中使用类似于XML的标记表示运行时的动作
        jsp:userBean
        jsp:setProperty
        jsp:getProperty
        jsp:param
        jsp:include
        jsp:forward

   *使用useBean、getProperty、setProperty
      <jsp:useBean id=”beanName” class=”BeanClass” />
      <jsp:setProperty name=”beanName” property=”prop1” value=”val” />
      <jsp:getProperty name=”beanName” property=”prop1” />

   *Bean的四种scope
      应用程序范围（Application）：存储在ServletContext对象中
      会话范围（Session）：在会话中创建并被存储在HttpSession对象中
      请求范围（Request）：在请求中创建并被存储在ServletRequest对象中
      页面范围（Page）：在页面中创建并被存储在PageContext对象中

   *页面上的字段和Bean中属性的对应规则
     id 指javabean的变量名
     class指javabean类的全路径
     scope指javabean的应用范围
     name指所用到的javabean的变量名
     property指javabean中的属性

   *useBean动作的处理过程
     jsp:useBean  →
     使用id声明变量 →
     试图在指定的范围内查找对象→
     → [没找到] →
        创建一个类的实例 →
        执行useBean标记体初始化对象
     → [找到] →
        将对象转换为类指定的类型

   *forward动作的功能
      使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图
      <%
      if ( request.getMethod().equals(“POST”) ) {
            guestBookSvc.processRequest();
            if ( guestBookSvc.wasSuccessful() ) {
      %>
                   <jsp:forward  page=”guestBookThankYou.jsp” />
      <%  } else {  %>
                   <jsp:forward  page=”guestBookError.jsp” />
      <%  }  %>

第十四章 使用Model2架构设计
  MVC：JSP页面充当视图
       Servlet充当控制器
       界面:JSP+JavaBean
       JavaBean封装值传给Controller
       在Controller中不再组织参数

   获得分发器：
       上下文对象中的分发器：
       ServletContext context = getServletContext();
       RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
       servlet.forward(request, response);

  请求对象中的分发器：
       RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
       view.forward(request, response);

第十五章 JSP重用模板
  一.复杂布局的构造
     1.使用隐藏的table构造布局
     2.用div进行设计
  二.include指令静态引入。在翻译期间，直接将被引入页面copy到响应的位置，相当于是一个界面，所以可以共享变量
     jsp:include标准动作：动态引入。在运行期间动态引入被引入页面所生成的HTML. 完全是独立的页面运行，所以不能共享变量。

     a.jsp：
          <%=”aaaa”%>
          <%@include file=”b.jsp”%

     b.jsp：
          <%
          Stringb = ”bbb”
          %>
打印出来是aaaa bbbb

     a.jsp：
          <%=aaaa%>
          <jsp:include
           Page=”b.jsp”/>

     b.jsp：
          <%=”bbb”%>
结果是aaaabbb不能在a中直接用包中的变量

可以到java 私塾官网下载完整笔记，还有经典学习视频：w ww.javass.cn