Jsp详解

1Jsp基础

1.1 Jsp引入

Servlet的作用： 用java语言开发动态资源的技术！！！

Jsp的作用：用java语言（+html语言）开发动态资源的技术！！！

Jsp就是servlet！！！

1.2 Jsp的特点

1）jsp的运行必须交给tomcat服务器！！！！

tomcat的work目录： tomcat服务器存放jsp运行时的临时文件

2）jsp页面既可以写html代码，也可以写java代码。

（html页面不能写java代码 。而jsp页面可以写java代码）

1.3 体验jsp页面作用

需求：显示当前时间到浏览器上

 

可以把jsp页面当做html页面在tomcat中访问！！！

 

1.4 Jsp的执行过程

问题： 访问http://localhost:8080/day12/01.hello.jsp  如何显示效果？

 

1）访问到01.hello.jsp页面，tomcat扫描到jsp文件，在%tomcat%/work把jsp文件翻译成java源文件

(01.hello.jsp   ->   _01_hello_jsp.java) （翻译）

2）tomcat服务器把java源文件编译成class字节码文件 （编译）

（_01_hello_jsp.java  ->  _01_hello_jsp.class）

3）tomcat服务器构造_01_hello_jsp类对象

4）tomcat服务器调用_01_hello_jsp类里面方法，返回内容显示到浏览器。

 

第一次访问jsp：

走（1）（2）（3）（4）

第n次访问jsp：

走（4）

 

注意：

1）jsp文件修改了或jsp的临时文件被删除了，要重新走翻译（1）和编译（2）的过程

 

1.5 疑问

问题： 为什么Jsp就是servlet！！！

jsp翻译的java文件：

public final class _01_hello_jsp extends org.apache.jasper.runtime.HttpJspBase

    implements org.apache.jasper.runtime.JspSourceDependent {

 

HttpJspBase类：

public abstract class org.apache.jasper.runtime.HttpJspBase extends javax.servlet.http.HttpServlet implements javax.servlet.jsp.HttpJspPage {

 

结论： Jsp就是一个servlet程序！！！

servlet的技术可以用在jsp程序中

jsp的技术并不是全部适用于servlet程序！

 

 

Servlet的生命周期：

1）构造方法（第1次访问）

2）init方法（第1次访问）

3）service方法

4）destroy方法

Jsp的生命周期

1）翻译： jsp->java文件

2）编译： java文件->class文件（servlet程序）

3）构造方法（第1次访问）

4）init方法（第1次访问）：_jspInit()

5）service方法：_jspService()

6）destroy方法：_jspDestroy()

 

2 Jsp语法

2.1 Jsp模板

jsp页面中的html代码就是jsp的模板

2.2 Jsp表达式

语法：<%=变量或表达式%>

作用： 向浏览器输出变量的值或表达式计算的结果

注意：

1）表达式的原理就是翻译成out.print(“变量” );通过该方法向浏览器写出内容

2）表达式后面不需要带分号结束。

2.3 Jsp的脚本

语法：<%java代码 %>

作用： 执行java代码

注意：

1）原理把脚本中java代码原封不动拷贝到_jspService方法中执行。

2.4 Jsp的声明

语法：<%! 变量或方法 %>

作用： 声明jsp的变量或方法

注意:

1）变量翻译成成员变量，方法翻译成成员方法。

2.5 Jsp的注释

语法： <%!--  jsp注释  --%>

注意;

1)html的注释会被翻译和执行。而jsp的注释不能被翻译和执行。

3 Jsp的三大指令

3.1 include指令

作用： 在当前页面用于包含其他页面

语法： <%@include file="common/header.jsp"%>

注意：

1）原理是把被包含的页面（header.jsp）的内容翻译到包含页面(index.jsp)中,合并成翻译成一 个java源文件，再编译运行！！，这种包含叫静态包含（源码包含）

2）如果使用静态包含，被包含页面中不需要出现全局的html标签了！！！（如html、head、 body）

3.2 page指令

作用： 告诉tomcat服务器如何翻译jsp文件

<%@ page 

language="java"   --告诉服务器使用什么动态语言来翻译jsp文件

import="java.util.*" --告诉服务器java文件使用什么包

导入包，多个包之间用逗号分割

pageEncoding="utf-8"  --告诉服务器使用什么编码翻译jsp文件（成java文件）

 contentType="text/html; charset=utf-8" 服务器发送浏览器的数据类型和内容编码

注意：在开发工具中，以后只需要设置pageEncoding即可解决中文乱码问题

errorPage="error.jsp"

isErrorPage="false"

buffer="8kb"

session="true"

isELIgnored="false"

%>

基本练习：生成9*9乘法表以及一些基本操作：

 

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>



  
    
    
    
    
    
    
        
    
    
    

  
  
  
  <%--逗比啊 --%>
  <%@include file="common/1.hello.jsp" %>
    <%
        String name="handsomecui";
        int a = 15;
        int b = 20;
     %>
     <%=name %>
     <%=(a-b) %>
     <%=(a/b) %>
     

     
     <%
         Random ran = new Random();
         Float num = ran.nextFloat();
      %>
      <%=num %>
      <%
          for(int i = 1; i <= 6; i++){
              %>
              >标题<%=i %>>
              <%              
          }
      %>
      <%
          for(int i = 1; i <= 9; i++){
              for(int j = 1; j <= i; j++){
                  %>
                  <%=j %>*<%=i %>=<%=(j*i) %>&nbsp;
                  <%
              }
              %>
              

              <% 
          }
      %>
      <%!
     String name = "崔哥哥";
      %>
  

 

 

Jsp的内置对象（重点）

2.1 什么是内置对象？

在jsp开发中，会频繁使用到一些对象

。例如HttpSession,ServletContext,ServletContext,HttpServletRequet。如果我们每次要使用这些对象都去创建这些对象就显示非常麻烦。所以Sun公司设计Jsp时，在jsp页面加载完毕之后就会自动帮开发者创建好这些对象，而开发者只需要直接使用这些对象调用方法即可！，这些创建好的对象就叫内置对象！！！！

 

举例：

servlet:

HttpSession session = request.getSession(true); （需要开发者做）

 

jsp:

tomcat服务器： HttpSession session = request.getSession(true);(不需要开发者做)

开发者做的： session.getId();

 

2.2 9大内置对象

内置对象名          类型

   request    HttpServletRequest

  response      HttpServletResponse

   config        ServletConfig

application        ServletContext

 session         HttpSession

exception        Throwable

page            Object(this)

out             JspWriter

pageContext     PageContext

 

  2.3 Out对象

out对象类型，JspWriter类，相当于带缓存的PrintWriter

 

PrintWriter：

wrier(内容)： 直接向浏览器写出内容。

 

JspWriter

writer(内容): 向jsp缓冲区写出内容

 

当满足以下条件之一，缓冲区内容写出：

1）缓冲区满了

2）刷新缓存区

3）关闭缓存区

4）执行完毕jsp页面

 

  2.4 pageContext对象

pageContext对象的类型是PageContext，叫jsp的上下文对象

 

     1）可以获取其他八个内置对象

 

public class 01_hello_jsp {

public void _jspService(request,response){

创建内置对象

HttpSession session =....;

ServletConfig config = ....;

 

把8个经常使用的内置对象封装到PageContext对象中

PageContext pageContext  = 封装；

调用method1方法

method1(pageContext);

}

 

public void method1(PageContext pageContext){

希望使用内置对象

从PageContext对象中获取其他8个内置对象

JspWriter out =pageContext.getOut();

HttpServletRequest rquest = pageContext.getRequest();

........

}

}

 

使用场景： 在自定义标签的时候，PageContext对象频繁使用到！！！

       2）本身是一个域对象

ServletContext context域

HttpServletRequet  request域

HttpSession    session域     --Servlet学习的

PageContext   page域        --jsp学习的

 

 

作用： 保存数据和获取数据，用于共享数据

 

#保存数据

1）默认情况下，保存到page域

pageContext.setAttribute("name");

2）可以向四个域对象保存数据

pageContext.setAttribute("name",域范围常量)

 

#获取数据

1）默认情况下，从page域获取

pageContext.getAttribute("name")

2）可以从四个域中获取数据

pageContext.getAttribute("name",域范围常量)

 

域范围常量:

PageContext.PAGE_SCOPE

PageContext.REQUEST_SCOPE

PageContext..SESSION_SCOPE

PageContext.APPLICATION_SCOPE

3）自动在四个域中搜索数据

pageContext.findAttribute("name");

顺序： page域 -> request域 -> session域- > context域（application域）

3 Jsp中的四个域对象

四个域对象：

pageContext      page域

request          request域

session          session域

application       context域

 

1）域对象作用：

保存数据  和 获取数据 ，用于数据共享。

 

2）域对象方法：

setAttribute("name",Object) 保存数据

getAttribute("name")  获取数据

removeAttribute("name") 清除数据

 

3）域对象作用范围：

page域： 只能在当前jsp页面中使用（当前页面）

request域： 只能在同一个请求中使用（转发）

session域： 只能在同一个会话（session对象）中使用（私有的）

    context域： 只能在同一个web应用中使用。（全局的）

4 Jsp的最佳实践

Servlet技术： 开发动态资源。是一个java类，最擅长写java代码

jsp技术： 开发动态资源。通过java代码最擅长输出html代码。

 

 

各取所长：

在web项目中涉及到逻辑：

1）接收参数      servlet做

2）处理业务逻辑，返回结果    servlet做

3）显示数据到浏览器      jsp做

4）跳转到其他页面        servlet做

 

 

servlet+jsp模式

 

  servlet:

1）接收参数

2）处理业务逻辑

3）把结果保存到域对象中

4）跳转到jsp页面

Jsp:

1）从域对象取出数据

2）把数据显示到浏览器

 

servlet的数据    ->   jsp页面

List    使用域对象 共享数据

 

5 EL表达式

5.1 EL作用

jsp的核心语法： jsp表达式 <%=%>和 jsp脚本<%  %>。

以后开发jsp的原则： 尽量在jsp页面中少写甚至不写java代码。

 

使用EL表达式替换掉jsp表达式

 

EL表达式作用： 向浏览器输出域对象中的变量值或表达式计算的结果！！！

 

语法： ${变量或表达式}

 

5.2 EL语法

1）输出基本数据类型变量

1.1 从四个域获取

${name}

1.2 指定域获取

${pageScope.name}

                    域范围： pageScoep / requestScope / sessionScope / applicationScope

 

    2）输出对象的属性值

Student

3）输出集合对象

   List  和 Map

4）EL表达式计算

6 jsp标签

6.1 jsp标签的作用

jsp标签作用：替换jsp脚本。

 

1）流程判断（if   for循环）

2）跳转页面（转发，重定向）

3）。。。。。

 

6.2 Jsp标签分类

1）内置标签（动作标签）： 不需要在jsp页面导入标签

2）jstl标签： 需要在jsp页面中导入标签

3）自定义标签 ： 开发者自行定义，需要在jsp页面导入标签

6.3 动作标签

  转发标签：

            参数标签：  

包含标签：  

原理： 包含与被包含的页面先各自翻译成java源文件，然后再运行时合并在一起。

（先翻译再合并），动态包含

 

静态包含  vs  动态包含的区别？

 

1） 语法不同

静态包含语法： <%@inclue file="被包含的页面"%>

动态包含语法：　被包含的页面">

 

2）参数传递不同

静态包含不能向被包含页面传递参数

动态包含可以向被包含页面传递参数

 

3）原理不同

静态包含： 先合并再翻译

动态包含： 先翻译再合并

 

6.4 JSTL标签

JSTL (全名：java  standard  tag  libarary   -  java标准标签库  )

 

核心标签库 （c标签库） 天天用

国际化标签（fmt标签库）

EL函数库（fn函数库）

xml标签库（x标签库）

sql标签库（sql标签库）

6.5 使用JSTL标签步骤

1） 导入jstl支持的jar包（标签背后隐藏的java代码）

注意：使用javaee5.0的项目自动导入jstl支持jar包

2）使用taglib指令导入标签库

<%@taglib uri="tld文件的uri名称" prefix="简写" %>

3）在jsp中使用标签

 

核心标签库的重点标签：

保存数据：

   

获取数据：

             "">

单条件判断

            "">

多条件判断

          

       "">

          

    循环数据

          <c:forEach>

          "" delims="">

重定向

          

 代码练习：

<%@ page language="java" import="java.util.*,com.base.others.*" pageEncoding="utf-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>



  
    
    
    
    
    
    
        
    
    
    

  
  
  
      <%--保存到域中（默认page域） --%>
    
    ${requestScope.name }
    
    

    <%
        String msg = null;
           pageContext.setAttribute("msg", msg);
    %>
    default="
默认值
" escapeXml="false">
      

      if test="${empty msg}">
          条件成立
      if>
      

      
      
          
              优秀
          
          
              良好
          
          
              一般
          
          
              及格
          
          
              不及格
          
      
      

      <%
        Listlist = new ArrayList();
        list.add(new Contact("崔俊勇","男",12,"1568445","15152","[email protected]"));
        list.add(new Contact("崔勇","男",12,"1568445","15152","[email protected]"));
        list.add(new Contact("崔帅","男",12,"1568445","15152","[email protected]"));
        pageContext.setAttribute("list",list);
    %>
    
        序号：${varsta.count } - 姓名：${contact.name } - 年龄:${contact.age }
        

    
    <%
        String str = "java-php-net-好吧";
        pageContext.setAttribute("str", str);
    %>
    
        ${s }

    
    <%-- --%>
  

<%@ page language="java" import="java.util.*,com.base.others.*" pageEncoding="utf-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>



  
    
    
    
    
    
    
        
    
    
    

  
  
  
  <%--使用标签 --%>
  <%--
  
  
  
  if test="">if>
  
  
  
  
  
  
  
 
  
   --%>
  
    <%
        Contact contact = new Contact("崔俊勇","男",12,"1568445","15152","[email protected]");
        Listlist = new ArrayList();
        list.add(new Contact("崔俊勇","男",12,"1568445","15152","[email protected]"));
        list.add(new Contact("崔勇","男",12,"1568445","15152","[email protected]"));
        list.add(new Contact("崔帅","男",12,"1568445","15152","[email protected]"));
        
        pageContext.setAttribute("contact",contact);
        pageContext.setAttribute("list",list);
        String name = "";
        pageContext.setAttribute("name", name);
    %>
    ${contact.name} - ${contact.age }
    ${list[1].name} - ${list[1].age }
    ${list[2].name} - ${list[2].age }
    ${name==null} ${empty name }
    <%--  --%>
    
        
        
    
  

 

自定义标签

2.1 引入

需求： 向浏览器输出当前客户的IP地址 （只能使用jsp标签）

 

2.2 第一个自定义标签开发步骤

1）编写一个普通的java类，继承SimpleTagSupport类，叫标签处理器类

 

/**  * 标签处理器类  * @author APPle  * 1）继承SimpleTagSupport  *  */ public class ShowIpTag extends SimpleTagSupport{ private JspContext context;   /**  * 传入pageContext  */ @Override public void setJspContext(JspContext pc) { this.context = pc; }   /**  * 2）覆盖doTag方法  */ @Override public void doTag() throws JspException, IOException { //向浏览器输出客户的ip地址 PageContext pageContext = (PageContext)context;   HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();   String ip = request.getRemoteHost();   JspWriter out = pageContext.getOut();   out.write("使用自定义标签输出客户的IP地址："+ip);   } }

 

2）在web项目的WEB-INF目录下建立itcast.tld文件，这个tld叫标签库的声明文件。（参考核心标签库的tld文件）

 

"1.0" encoding="UTF-8" ?>   "http://java.sun.com/xml/ns/javaee"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"     version="2.1">      1.1      itcast      http://gz.itcast.cn                  showIp          gz.itcast.a_tag.ShowIpTag          scriptless

 

3） 在jsp页面的头部导入自定义标签库

    <%@taglib uri="http://gz.itcast.cn" prefix="itcast"%>

 

4） 在jsp中使用自定义标签

 

2.3 自定义标签的执行过程

问题： http://localhost:8080/day14/01.hellotag.jsp  如何访问到自定义标签？

 

前提： tomcat服务器启动时，加载到每个web应用，加载每个web应用的WEB-INF目录下的所有文件！！！例如。web.xml, tld文件！！！

1）访问01.hellotag.jsp资源

2）tomcat服务器把jsp文件翻译成java源文件->编译class->构造类对象->调用_jspService（）方法

3）检查jsp文件的taglib指令，是否存在一个名为http://gz.itcast.cn的tld文件。如果没有，则报错

4）上一步已经读到itcast.tld文件

5）读到 到itcast.tld文件中查询是否存在为showIp的标签

6）找到对应的标签，则读到内容

7）得到 gz.itcast.a_tag.ShowIpTag

 

构造ShowIpTag对象，然后调用ShowIpTag里面的方法

 

2.4 自定义标签处理器类的生命周期

SimpleTag接口：

void setJspContext(JspContext pc)  --设置pageContext对象，传入pageContext（一定调用）

通过getJspCotext()方法得到pageContext对象

void setParent(JspTag parent)  --设置父标签对象，传入父标签对象，如果没有父标签，则不 调用此方法。通过getParent()方法得到父标签对象。

void     setXXX(值)             --设置属性值。

void setJspBody(JspFragment jspBody) --设置标签体内容。标签体内容封装到JspFragment对象 中，然后传入JspFragment对象。通过getJspBody()方法 得到标签体内容。如果没有标签体内容，则不会调 用此方法

void doTag()                     --执行标签时调用的方法。（一定调用）

 

2.5 自定义标签的作用

1）控制标签体内容是否输出

2）控制标签余下内容是否输出

3）控制重复输出标签体内容

4）改变标签体内容

5）带属性的标签

步骤：

5.1 在标签处理器中添加一个成语变量和setter方法

 

//1.声明属性的成员变量 private Integer num;   //2.关键点： 必须提供公开的setter方法，用于给属性赋值 public void setNum(Integer num) { this.num = num; }

 

2.6 输出标签体内容格式

JSP：   在传统标签中使用的。可以写和执行jsp的java代码。

scriptless:  标签体不可以写jsp的java代码

empty:    必须是空标签。

tagdependent : 标签体内容可以写jsp的java代码，但不会执行。

2.7 案例

核心标签库： c:if   c:choose+c:when+c:otherwise   c:forEach

高仿核心标签库

hellotag.jsp:

<%@ page language="java" import="java.util.*,com.base.others.*"
 pageEncoding="utf-8"%>
<%@taglib uri="http://top.handsomecui.hbc" prefix="hbc" %>
<%@taglib uri="http://top.handsomecui.simple" prefix="simple" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>



  
    
    
    
    
    
    
        
    
    
    

  
  
  
  <%--使用自定义标签 --%>
      

          
          
      
      

      if test="${10>5 }">
          条件成立
      if>
      

      
      
          
              优秀
          
          
              良好
          
          
              一般
          
          
              及格
          
          
              不及格
          
      
      

      <%
  //List
     List  list = new ArrayList();
     list.add(new Student("rose",18));
     list.add(new Student("jack",28));
     list.add(new Student("lucy",38));
     //放入域中
     pageContext.setAttribute("list",list);
     
     //Map
     Map map = new HashMap();
     map.put("100",new Student("mark",20));
     map.put("101",new Student("maxwell",30));
     map.put("102",new Student("narci",40));
     pageContext.setAttribute("list", list);
     pageContext.setAttribute("map", map);
      %>
      <%--
      
      
       --%>
      

      
      姓名：${student.name } - 年龄:${student.age } 

      
      
      编号：${entry.key } - 姓名：${entry.value.name } - 年龄:${entry.value.age } 

      
      

      class="com.base.others.Student">
      
      
      

    
    HANDSOMECUI

        标签余下内容
        
  

View Code

if:

package com.bussy.tag;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class If extends SimpleTagSupport{
    private boolean test;
    public void setTest(boolean test) {
        this.test = test;
    }
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jspbody = getJspBody();
        if(test){
            jspbody.invoke(null);
        }
    }
}

View Code

choose:

package com.bussy.tag;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class Choose extends SimpleTagSupport{
    private boolean flag;
    
    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void doTag() throws JspException, IOException {
        setFlag(false);
        getJspBody().invoke(null);
    }
}

View Code

when:

package com.bussy.tag;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class whenTag extends SimpleTagSupport{
    private boolean test;
    public void setTest(boolean test) {
        this.test = test;
    }
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jspBody2 = getJspBody();
        Choose parent = (Choose)getParent();
        if(test){
            parent.setFlag(test);
            jspBody2.invoke(null);
        }
    }
}

View Code

otherwise:

package com.bussy.tag;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspTag;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class otherwiseTag extends SimpleTagSupport{
    @Override
    public void doTag() throws JspException, IOException {
        Choose parent = (Choose)getParent();
        boolean test = parent.isFlag();
        if(!test){
            getJspBody().invoke(null);
        }
    }
}

View Code

foreach:

package com.bussy.tag;

import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;

import com.base.others.Student;

public class foreachTag extends SimpleTagSupport{
    private Object items;

    public void setItems(Object items) {
        this.items = items;
    }
    public void setVar(String var) {
        this.var = var;
    }
    private String var;
    @Override
    public void doTag() throws JspException, IOException {
//        if(items instanceof List){
//            List list = (List)items;
//            for(Object e:list){
//                ((PageContext)this.getJspContext()).setAttribute(var, e);
//                getJspBody().invoke(null);
//            }
//        }else if(items instanceof Map){
//            Map mp = (Map)items;
//            Set entrySet = mp.entrySet();
//            for(Entry entry:entrySet){
//                ((PageContext)this.getJspContext()).setAttribute(var, entry);
//                getJspBody().invoke(null);
//            }
//        }
//        
        Collection coll = null;
        if(items instanceof List){
            coll = (Collection) items;
        }
        if(items instanceof Map){
            coll = ((Map)items).entrySet();
        }
        for(Object obj:coll){
            ((PageContext)this.getJspContext()).setAttribute(var, obj);
            getJspBody().invoke(null);
        }
    }
}

View Code

3 编码实战

3.1 JavaBean

JavaBean,  咖啡豆。 JavaBean是一种开发规范，可以说是一种技术。

 

 JavaBean就是一个普通的java类。只有符合以下规定才能称之为javabean：

  1）必须提供无参数的构造方法

  2）类中属性都必须私有化(private)

  3）该类提供公开的getter 和 setter方法

 

JavaBean的作用： 用于封装数据，保存数据。

访问javabean只能使用getter和setter方法

 

JavaBean的使用场景：

1）项目中用到实体对象（entity）符合javabean规范

2）EL表达式访问对象属性。${student.name}  调用getName()方法，符合javabean规范。

3）jsp标签中的属性赋值。 setNum（Integer num）。符合javabean规范。

4）jsp页面中使用javabean。符合javabean规范

 

问题：

         以下方法哪些属于javabean的规范的方法？ 答案 ：( 1，3，5，6  )

注意： boolean类型的get方法名称叫 isXXX()方法

1）getName()    2)getName(String name)

3)setName(String name)   4)setName()

5) setFlag(boolean flag)   6)isFlag()

 

3.2 web开发模式

 

总结：

 1）自定义标签

自定义标签作用

 案例

2）编码实战

JavaBean规范： 三点

    MVC开发模式：

Model - JavaBean实现。用于封装业务数据

View - Jsp实现。用于显示数据

Controller-  servlet实现。用于控制model和view

三层结构：

dao层： 和数据访问相关的操作

service层： 和业务逻辑相关的操作

web层： 和用户直接交互相关的操作（传接参数，跳转页面）