.Servlet

思考

1 浏览器可以直接打开JAVA/class文件吗? 不可以

2浏览器可以打开HTML、JS 文件吗? 可以

3 JAVA程序可以生成HTML文件吗?可以的,用IO流。

4 浏览器解析的时候是需要HTTP协议的,JAVA普通类有没有HTTP协议呢? 普通类没有.

 

JAVA-(class)浏览器如何访问呢?

浏览器---HTML

A   JAVA通过IO流生成HTML--->浏览器

B   JAVA 需要加入HTTP协议

解决上面2个问题可以通过 Servlet

C  如何通过浏览器访问Servlet

   它需要用到一个文件web.xml (webroot-->web-inf--web.xml)

   

Sevlet它是什么?

  Servlet是一个容器(引擎),它包含协议和支持功能的jar包,它是一个整体。

在使用的时候我们不用去关心里面的核心程序,我们只关心业务程序。

业务程序   程序员所写支持协议的类,有一种特殊的叫法 Serlvet类。

 

1.三要素是什么

入口(login.html)     处理(LoginServlet.java)  出口 (success.jsp)

2.如何访问servlet

  http://IP:port/project/urlpattern

  urlpattern ---->web.xml中找

 

3 request 和 response的区别?

Request请求  Broswer---->Tomcat    login.html--->LoginSevlet.java

Response返回 Tomcat---->Broswer   

 

4 doGet  和  doPost的区别?

   doGet   <a href=url>  超链接用的默认方式 get   不解中文决乱么

            <form action=url  method=get >

           明文传递方式 浏览器中可以看到传递的信息

           不安全,并且数据量大的时候会缺损数据

   doPost   <form action=url  method=post >        解决中文乱码

            密文传递方式 浏览器看不到传递的信息

           安全,并且数据量大的时候不会缺损数据

 

5如何解决乱码问题?

Request请求有乱码    

request.setCharacterEncoding("UTF-8");

Reponse返回有乱

response.setCharacterEncoding("UTF-8");

 

6 如何取得请求中的值 ?

String value=request.getParameter(“控件名”);   单个值

String []  values=request.getParmeterValues(“控件名”);  同名多个值

 

7 常见的错误:404 、500?

404 路径错误---解决思路  跟踪路径

500 代码错误---解决思路  jsp/servlet中代码错误

获取不到值null  在console里面去找到错误的位置。

 

8 servlet中得到流的方法?

   字符流   response.getWriter( )----->PrintWriter

   字节流   response.getOutputStream()-->OutputStream

 

9 如何跳转到出口?

//跳转并且可以传递数据

request.getRequestDispatcher("success.jsp").forward(request, response);

 

//重新定向 跳转不传递数据

response.sendRedirect("success.html");

 

10如何将数据传递到出口?

 //保存数据

request.setAttribute("name", username);

request.setAttribute("password", pwd);

 

 //获取数据

 用户名是:${ name}   ,密码: ${password}。

 

11 Servlet的生命周期

   Servlet的生命周期是由tomcat服务器来控制的。

  1 构造方法:

创建servlet对象的时候调用。默认情况下,第一访问servlet就会创建servlet对象只创建一次。说明servlet对象在tomcat中是单实例的。

 

 2初始化   init方法

  当创建完servlet对象的时候会调用init()方法,只调用一次。

 

3 调用服务 service 方法   其中就包含doGet  doPost等方法

  每次发送请求的时候调用。可以调用n次。

4 销毁 destory 方法

   销毁servlet对象的时候调用,停止服务器或者重新部署的web项目的时候销毁servlet就会调用destory方法

 

12 Servlet时序图

 

13 servlet自动加载

在web.xml中加入

  <load-on-startup> 1</load-on-startup>

里面的数字越小加载级别越高

当tomcat启动的时候,就去运行web.xml解析里面的内容,当发现有自动加载的数据时候,就会运行加载。

  <servlet>

    <servlet-name>sl</servlet-name>

    <servlet-class>com.bw.servlet.LoginServlet</servlet-class>

      <load-on-startup>3</load-on-startup>

  </servlet>

 

14 ServletConfig 对象

   主要是加载servlet的初始化参数,在web应用中可以存在多个ServletConfig对象

  

  <servlet>

    <servlet-name>sl</servlet-name>

    <servlet-class>com.bw.servlet.LoginServlet</servlet-class>

     <init-param>

      <param-name>username</param-name>

      <param-value>godyang</param-value>

    </init-param>

    <init-param>

      <param-name>password</param-name>

      <param-value>123456</param-value>

    </init-param>

  </servlet>

 

15 ServletContext对象

 上下文对象,表示当前的web应用(项目)环境。一个web应用只有一个ServletContext对象

 

  上下文参数配置  它是全局的  所有的servlet都可以访问

<context-param>

<param-name>ecode</param-name>

<param-value>UTF-8</param-value>

</context-param>

// 获取上下文对象

ServletContext sc = this.getServletContext();

String contextParamValue = sc.getInitParameter("ecode");

System.out.println("contextParamValue=" + contextParamValue);

//项目路径

String path=sc.getContextPath();

System.out.println("path="+path);

//文件发布后(tomcat/webapps)的真实路径

String realPath=sc.getRealPath("counter.txt");

System.out.println("realPath="+realPath  );

//获取文件流

     InputStream  is=sc.getResourceAsStream("C:\\Tomcat\\webapps\\webThree\\WEB-INF\\classes\\counter.txt");

 

 

二.JSP技术

Jsp技术是用来开发java web的页面显示的,所有MVC模型里面的视图层,所以视图层的开发
jsp不是编程语言,java server pages的缩写
Jsp其实也是继承Servlet的,属于在服务器上的开发。Servlet是用于java语言的动态资源开发的技术,而Jsp是把java和html结合,在html中可以写java语言,主要用在页面的显示开发上。

1.1.Jsp的特点

1.Jsp的运行必须交给tomcat服务器。tomcat的work目录就是服务器用来存放jsp运行时的临时文件的
2.Jsp页面即可直接写html代码,也可以直接写java代码

 

2.Jsp的执行过程
问题1:访问http://localhost:8080/hello/index.jsp 如何显示效果?
1.访问到index.jsp页面,tomcat扫描到jsp文件,在tomcat/work目录下把jsp文件翻译成java源文件

    index.jsp-->index_jsp.java(翻译)

2.tomcat服务器把java源文件编译成class字节码文件(编译)

  index_jsp.java-->index_jsp.class

3.tomcat服务器构造index_jsp类对象
4.tomcat服务器调用index_jsp类里面的方法,返回内容显示到浏览器
如果是第一次访问当前jsp文件时,执行步骤是:1-->2-->3-->4
第N次访问jsp时,执行步骤是:4,不再执行其他步骤

注意:jsp文件被修改或者jsp的临时文件被删除了,要重新走翻译 1 和编译 2  的过程

问题2:既然jsp是servlet,那么jsp的生命周期和servlet的生命周期是不是一样的?
当jsp文件被翻译成java的源码时,可以在翻译出来的源码文件里看到当前访问的jsp文件继承HttpJspBase类,再通过查询JDK,可以发现HttpJspBase又是继承于HttpServlet的。所以,可以得到结论,jsp既是一个servlet的程序,而servlet的技术可以用在jsp程序中,但是并不是所有的servlet技术全部适用于jsp程序

Servlet的生命周期:
1.构造方法(第一次访问执行)默认情况第一次使用的时候 通过单例模式创建一个servlet对象
2.init方法初始化(第一次访问执行)当构造了之后就会调用初始化方法 只调用一次
3.service方法(每n次访问都会执行)每次发出请求的时候调用可以调用n次
4.destory方法(退出时执行)关闭服务软件重新部署的时候销毁 servlet对象

 
Jsp的生命周期:
1.翻译:Jsp-->java文件
2.编译:java-->class文件(servlet程序)
3.构造方法(第一次访问时执行)
4.init方法(第一次访问):_JspInit()
5.service方法:_JspService()
6.destory方法:_jspDestory()

 

问题3:JSP和Servlet作用有什么区别?

1.Servlet作用: 用java语言开发动态资源(  java 流 )的技术.

2.JSP 作用:用java语言开发动态(java 流)+静态资源(html)的技术

 

3.Jsp语法


3.1.Jsp模板
JSP 页面中会自动添加HTML代码内容,该JSP是模板
这些模板定义了网页的基本骨架,也就是说定义了页面的结构和外观
3.2.Jsp表达式
JSP的表达式作用是向浏览器输出变量的值或表达式计算的结果

    语法:<%=变量或表达式 %>
    例如<% String name="Eric";%>

<%=name%>
注意:
1.表达式的原理即使翻译成out.print("变量“);通过该方法向浏览器写出内容。
2.表达式后面不需要带分好结束


3.3.Jsp的脚本

脚本是指在JSP页面编写多行java代码的,可以执行java代码
    语法:<%多行java代码; %>

如:

 <%
      Date date = new Date();
        
      SimpleDateFormat sdFormat = new SimpleDateFormat("yyyy-MM-dd");
    
      String now = sdFormat.format(date);
    
    out.println(now);
    
    %>
注意
1.原理是把脚本中的java代码原封不动的拷贝到jspService方法中执行
2.jsp脚本中写的java是需要加分好的,语法跟java语法是一样的
3.多个脚本片段中的代码可以相互访问
4.单个脚本片段中的java语句可以是不完整的,但是,多个脚本片段组合后的结必须是完整的java语句

3.4.Jsp的声明
JSP的声明是用来声明变量或者方法的,如果在index.jsp页面内声明一个变量或者方法,则该变量或者方法是index_jsp类的成员变量,成员方法,即是全局变量。这个其实就是在类中写好方法,然后可以在jsp_service方法中调用其他方法。
jsp通过脚本也可以定义一个变量,但是这个变量是保存在index_jsp类下的jspService方法下的一个变量,由于是保存在方法下面,所有脚本里是不可以定义一个方法的,只能通过声明来定义方法。
注意以上两者的区别,一个是保存在类下面,称为成员变量或者成员方法,另一个则是保存在方法中,称之为局部变量

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

作用:声明JSP的变量和方法
注意:
1.变量翻译成成员变量,方法翻译成成员方法

3.5.Jsp的注释

jsp的注释格式:

    jsp的注释:<%!--jsp注释 --%>
    html的注释:

注意:
1.html的注释会被翻译和执行,无论在jsp的页面翻译之后的源码还是在浏览器上查看网站的源码,都是可以查看到的。但是jsp的注释是不会被翻译和执行的,在翻译之后源码里是不能找到的,从浏览器查看源码也是查看不到的

 

4.Jsp的三大指令

JSP指令是为JSP引擎而设计的,他们并不产生任何可见的输出,只是告诉引擎如何处理jsp页面中的其余部分。jsp定义的有三大指令,分别是:include,page,tagllb

4.1.Include指令

Include指令的作用是当前页面包含其他页面,主要是导入其他jsp文件

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

注意
1.原理是把被包含的页面(header.jsp)的内容翻译到包含页面(index.jsp)中,合并并翻译成一个java源文件,再编译运行!!,这种包含就加叫静态包含(源码包含)
2.如果使用静态包含,被包含页面中不需要出现全局的html标签了,(如html,body,head)

4.2.page指令
page指令的作用是告诉tomcat服务器如何翻译jsp文件
                      
    语法:<%@ page contentType="text/html;charset=UTF-8" language="java" %>

 

<%@ page 

language="java"        --使用的语言

import="java.util.*"   --需要导入的类

pageEncoding="UTF-8"   --jsp编码方式

contentType="text/html; charset=UTF-8" --tomcathtml流发送给浏览器的文件类型和编码方式

errorPage="error.jsp"   --当前jsp页面解析错误的时候就会跳转到error.jsp

isErrorPage="false"  --当前页面是不是错误导向页面

 %>

 language="java"--告诉服务器只用什么动态语言来翻译jsp文件
import="java.util.*" --告诉服务器java文件使用什么包,导入多个包时,用逗号隔开
pageEncoding="utf-8" --告诉服务器使用什么编码把jsp翻译成java文件
contentType="text/html; charset=utf-8" --服务器发送浏览器的数据类型和内容编码,在开发工具中,只需要设置pageEncoding即可解决中文乱码的问题
errorPage="error.jsp" --如果当前页面出现错误信息,则自动调用此处指定的错误页面
isErrorPage="false" --意思是当前页面为错误页面,默认为false,当设置为true时就认为是一个错误处理页面,就可以在页面中使用<%=exception.getMessage()%>方法来获取错误异常信息,使其在页面上可以显示
全局配置错误处理页面
在web.xml中配置如下:
    <!--全局错误处理页面配置-->
    <error-page>
        <error-code>500</error-code>
        <location>common/500.jsp</location>
    </error-page>
    <error-page>
        <error-code>404</error-code>
        <location>common/404.html</location>
    </error-page>

配置之后,不用在jsp页面中特别指明,会自动跳转的
session="true" --是否开启Session功能,false时不能使用Session内置对象,ture时可以使用。默认为true
buffer="8kb" --页面的缓存区大小。
isELIgnored="false" --是否忽略EL表达式。

page==this 对象 一般用在编译指令中 <%@ page   %>

4.3.tagllb指令

 语法<%taglib  %>

   作用:标签指令 用来解析标签效果

  <%@taglib  prefix="c"  uri="http://java.sun.com/jsp/jstl/core"  %>

5.JSP的内置对象

5.1.什么是内置的对象
service开发中会经常用到一些常用的类比如:HttpSession, ServletConfig, ServletContext, HttpServletRequet,用的时候,我们会直接创建就可以了,但是在jsp中这会经常使用到这些类。为了开发的方便,sun公司在设计jsp的时候,在jsp页面加载完毕以后就自动帮开发者创建好了这些对象,而开发者只需要直接使用这些对象就可以了,那么这些已经创建好的对象有一个统一的名字叫做内置对象,内置对象一共有九个

例如:
在Service中要使用Session,需要先HttpSession session = request.getSession(true); 来创建一个Session对象,然后在使用对象的方法
但是在JSP中,可以直接使用Session的方法,如session.getId();

 

九大内置对象

jsp

servlet

 

对象名

类型

使用范围

request

HttpServletRequest

请求 浏览器--->服务器

response

HttpServletResponse

返回 服务器--->浏览器

config

ServletConfig

用来获取web.xml中的信息

application

ServletContext

整个项目中的全局信息

exception

Thrawable

捕获异常 try/catch  throws

page

this

当前对象,当前页面对象

out

JspWriter---->PrintWriter

当前页面输出流

pageContext

PageContext

当前页面的上下文,整个页面

Session

HttpSession

会话  浏览器和服务器通讯


即:
1.对象名(request)-->类型HttpServletRequest :HTTP请求的时候使用到
2.对象名(response)-->类型HttpServletResponse :HTTP响应的时候用到
3.对象名(config)-->类型ServletConfig :获取属于自己的参数
4.对象名(application)-->类型ServletContext :获取全局参数

5.对象名(exception)-->类型Throwable :异常
6.对象名(page)-->类型 Object(this) :本jsp对象
7.对象名(out)-->类型JspWriter :打印到浏览器
8.对象名(pageContext)-->类型PageContext

9.对象名(session)-->类型HttpServletSession :会话管理使用

 


5.2.Out对象

out  对象  JspWriter 带缓冲的PrinterWriter  就是输出流 , 使用范围是当前页面,超出了当前页无效

1.PrintWriter: 直接向浏览器输出内容
用write直接向浏览器(输出)写出内容

2.JspWrite: 向Jsp 缓冲区写内容
用write向jsp的缓冲区写内容,当缓冲区满足一下条件的时候,把内容一起写到浏览器上,性能高于PrintWriter
当满足一下条件之一,JSP缓冲区内容写出到浏览器:
   (1) 缓冲区满了
    (2)刷新缓存去:out.flush();
    (3)关闭缓冲区:buffer="0kb";
    (4)执行完毕JSP页面

‘out.print()

‘out.println();


5.3.pageContext对象

前面已经有了8个内置对象,这些对象都是在jsp_service方法中被创建的,然后直接使用,但是由于是在方法中被创建,属于局部变量,所以很难在其他方法被调用,所有,使用了PageContext把这八个内置对象封装起来,这样传参的时候只需要传一个就可以了,然后通过这个PageContext来调用
除了调用其他八个内置对象意外,PageContext本身也是一个域对象,可以传递参数,准确的说PageContext是jsp的上下文对象,只可以在当前jsp文件内传参

分别介绍PageContext的两个方法:
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();
                        ........
                    }
            }

注意:调用的时候,使用getout,getrequest等方法来调用
使用场景:在自定义标签的时候,PageContext对象对象频繁使用到

2.PageContext本身就是一个域对象
经常使用的域对象有4个,分别是
ServletContext           context域
HttpServletRequest    request对象
HttpSession               session域
PageContex               page域

PageContext域的作用是保存数据和获取数据,用于共享数据
常用方法如下:
保存数据
1.默认情况下,保存到page域
pageContext.setAttribute("name");

2.可以向四个域对象保存数据
pageContext.setAttribute("name",域范围常量)

获取数据
1.默认情况下,从page域获取
 pageContext.getAttribute("name")

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

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

3.自动在四个域中搜索数据
    pageContext.findAttribute("name");
    顺序: page域 -> request域 -> session域- > context域(application域)

5.4.page对象 page==this 对象 一般用在编译指令中 <%@ page   %>

 

5.5.request对象 

request 请求  浏览器到服务器

当前请求存属性值

request.setAttribute("name","godyang");

当前请求取值

request.getAttribute("name")

请求传递参数

<a href="b.jsp?name=shunshun">  b.jsp</a>

或者

  <form  action="b.jsp"  method=post  >

   <input  type=text name="name" value="shunshun" />

   </form>

 

取得请求参数的值

request.getParameter(参数名);  request.getParameterValues(参数名)

 

5.6.reponse 对象
reponse  返回  服务器返回到浏览器

 

获取返回流

PrintWriter out = response.getWriter();

返回内容形式

response.setContentType("text/html");

返回的编码

response.setCharacterEncoding("UTF-8");

页面重定向

response.sendRedirect("index.jsp");

浏览器端保存cookie对象

response.addCookie()

 

 

 

 

 

5.7.session对象 

session 会话  浏览器和服务器通讯    当浏览器关闭的时候会话结束

 

当浏览器第一访问服务器的时候就会产生一个会话

保存会话信息

 session.setAttribute("uname","abc");

获取会话信息

 session.getAttribute("uname");

 

 

5.8.application对象

application 应用   tomcat启动的时候整个项目就是一个应用

 

   当把值存入应用中,只有当tomcat关闭的时候才销毁

保存应用信息

application.setAttribute("app","appInfo");

获取应用信息

 application.getAttribute("app");

 

5.9.JSP中的四个域对象
四个域度对象
    pageContext   page域
    request           request域
    session           session域
    application     context域

1.域对象作用
保存数据和获取数据,用于数据共享

2.域对象方法
setAttribute("name",Object)保存数据
getAttribute("name")获取数据
removeAttribute("name")消除数据

域对象的作用范围

    page域 :只能在当前jsp页面中使用(当前页面)
    request : 只能在同一个请求中使用(转发)
    Session : 只能在同一个会话(session对象)中使用(私有的)
    context : 只能在同一个web应用中使用(全局的)

5.10.JSP的最佳实践
Servlet技术:开发动态资源。是一个java类,最擅长写java代码
JSP技术:开发动态资源,通过java代码最擅长输出html代码

一个在web项目中涉及到的逻辑:
1.接收参数
2.处理业务逻辑
3.显示数据到浏览器
4.跳转到其他页面

最佳实践中,对上述逻辑进行分工,由Servlet和JSP联合完成
Servlet:
1.接收参数
2.处理业务逻辑
3.把结果保存到域对象中
4.跳转到jsp页面

JSP:
1.从域对象中取出数据
2.把数据显示到浏览器

Servlet的数据-->JSP页面

 

6.EL表达式
6.1.EL表达式的作用
EL表达式也是用在html页面中的,目的是简化JSP操作,代码。
在最佳实践中,总结得出JSP中尽量不要写java代码,最好的方法就是不写,所以的逻辑全部放到Servlet中,所有的数据展示放在JSP中
JSP的核心语法: jsp表达式 <%=%>和 jsp脚本<% %>。

现在使用EL表达式来替换到JSP的表达式
EL表达式的作用:向浏览器输出”域对象中的“变量值或表达式计算的结果!,注意一定要是域对象中的

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

6.2.EL语法
1.输出基本数据类型便变量
1.1.从四个域获取
    输出普通字符串: ${name}
    若没有指定域,则域的搜索先后顺序: pageScoep / requestScope / sessionScope / applicationScope

1.2.指定域获取
    ${pageScope.name},在pageScope域中查找name
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试jsp文件</title>
</head>
<body>
<%
    String name = "roso";
    pageContext.setAttribute("name",name,PageContext.REQUEST_SCOPE);
    %>
<br>
EL表达式:${requestScope.name};
<%--
    ${name}等价于pageContext.findAtribute("name")
--%>
</body>
</html>

2.输出对象的属性值
输出对象属性: ${student.name} 注意: .name 相当于 .getName()方法
如果我们定义了一个Student类,并定义了name成员变量,这个时候可以通过${student.name}来获取name值
点 . 方法是其实是调用getXX()方法

3.输出集合对象
集合对象有List和Map
输出List集合: ${list[0].name } 注意: [0] 相当于 get(下标)方法
输出map集合: ${map[key].name} 注意: [key]相当于get(key)方法
中括号[]其实是调用get
EL表达式没有遍历功能,但是可以结合标签使用遍历

4.EL表达式计算
表达式中需要注意的是字符串判空的一种方法${empty name}<br>

示例代码:

<%@ page import="servers.Student" contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.util.HashMap" %>
<html>
<head>
    <title>测试IE表达式</title>
</head>
<body>

<%--1.EL输出对象的属性--%>
<%
    //保存数据
    Student student = new Student("eric", 20);
    //放入域中
    pageContext.setAttribute("student",student);
%>

<%--2.EL输出集合List对象--%>
<%
    //List
    List<Student> list = new ArrayList<Student>();
    list.add(new Student("rose",18));
    list.add(new Student("jack",20));
    list.add(new Student("luck",38));
    //List放到域中
    pageContext.setAttribute("list",list);
%>

<%--3.EL输出集合Map对象--%>
<%
    //Map
    Map<String,Student> map = new HashMap<String, Student>();
    map.put("100",new Student("mark",20));
    map.put("101",new Student("maxwell",30));
    map.put("102",new Student("Eric",40));
    //放入域中
    pageContext.setAttribute("map",map);
%>

<%--3.EL表达式--%>
    <%--3.1.算术表达式--%>
    ${10+5}<br>
    <%--3.2.比较运算--%>
    ${10>5} <br>
    <%--3.3.逻辑运算--%>
    ${true && false} <br>
    <%--3.4.判空,null或空字符串--%>
    判断null:${name==null}<br>
    判断空字符串:${name==""}<br>
    判空: ${name==null || name==""}<br>
    判空的另一个种写法: ${empty name}<br>

<%--1.使用EL获取对象--%>
<%--实际调用student的getName方法获取的值--%>
获取student的name属性值:${student.name}
<%--${student.name}的点相当于调用getXX()方法--%>
<br>


<%--2.使用EL获取List对象--%>
list对象:${list} <br>
获取list的第一个对象:${list[0]} <br>
获取list的第一个对象的name和age属性:${list[0].name} - ${list[0].age}
<br>
<%--${list[0]}等价于(ListpageContext.findAttribute("list)--%>
<%--${list[0]}的中括号相当于调用get()方法--%>

<%--3.使用EL获取Map对象--%>
获取Map对象:${map}<br>
获取key=100的值:${map['100'].name} - ${map['100'].age}
</body>
</html>

7.JSP标签
7.1.JSP标签的作用

我们使用EL表达式来替换JSP的表达式,但是JSP还有一个经常会使用的语法,就是JSP脚本,出于和EL表达式同样的目的,我们使用标签来替代JSP脚本,以达到简化JSP页面的目的
所以JSP标签作用:替换JSP脚本
主要功能有:
1.路程判断(if,for, 循环)
2.跳转页面(转发,重定向)
3.…………

7.2.JSP标签的分类
JSP的标签也分为几种类型的
    1.内置标签:,也叫动作标签,不需要在jsp页面中导入的标签
    2.JSTL标签:需要在jsp页面中导入的标签
    3.自定义标签:开发者自行定义,需要在jsp页面导入标签

7.3.动作标签
转发标签:
参数标签:
包含标签:
包含标签的原理:
包含与被包含的页面先各自翻译成java源文件,然后在运行时再合并在一起。(先翻译再合并),动态包含,使用include指令包含是静态包含
静态包含 VS 动态包含
1.语法不同

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

2.参数传递不同

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

3.原理不同

    静态包含: 先合并再翻译
    动态包含: 先翻译再合并


7.4.JSTL标签
JSTL的全名是:Java Standard Tag Libarary ---java标准标签库
java标准标签库有五类,常用的是前三类

    标签核心库(c标签库) 天天用
    国际化标签(fmt标签库)
    EL函数库(fn函数库)
    xml标签库(x标签库)
    sql标签库(sqp标签库)

7.5.使用JSTL标签的步骤
1.导入jstl支持的jar包(标签背后隐藏的java代码)
把包放在WEB-INF下的lib包
2.使用tablib指令导入标签库

    <%@taglib prefix="简写" uri="tld文件的uri名称" %>
    uri从jstl.jar包下的META-INF下的tld文件中查找,把uri的值复制过来,prefix的值也是在tld中查找

3.在jsp中使用标签
核心标签库的重点标签
保存数据:
<c:set></c:set>
获取数据:
<c:out value=""></c:out>
单条件判断:
<c:if test=""></c:if>
多条件判断:
<c:choose></c:choose>
<c:when test=""></c:when>
<c:otherwise></c:otherwise>
循环数据:
<c:forEach></c:forEach>
<c:forTokens items="" delims=""></c:forTokens>
重定向:
<c:redirect></c:redirect>
代码示例:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--导入标签库--%>
<%@taglib prefix="c"   uri="http://java.sun.com/jsp/jstl/core"%>
<html>
  <head>
    <title>JSTL核心标签</title>
  </head>
  <body>
  <%--使用标签--%>
  <%--1.set标签:保存数据(保存到域中),默认保存到page域中,可以指定--%>
  <c:set var="name" value="Eric" scope="request"></c:set>
  ${name}<br>
  ${requestScope.name}<br>
  <%--2.out标签:获取数据(从域中),当value值为null时,可以使用default指定的默认值,escapeXml标明默认值是原样输出还是转化为之后再输出,默认为true,表示原样输出--%>
  <%--双引号内虽然是name,但是现实的是字符串name,因为是在双引号内--%>
  <c:out value="name"/>
  <%--调用name的值正确写法--%>
  <c:out value="${name}" default="<h3>标题3</h3>" escapeXml="false"/><br>

  <%--3.if标签:单条件判断,如果test里面的EL表达式为真,则运行if包含的代码--%>
  <c:if test="${10>5}">
    条件成立
  </c:if>

  <%--4.choose标签+when标签+otherwirse标签:多条件的判断--%>
  <c:set var="score" value="86"></c:set>
  <c:choose>
    <c:when test="${score>=90 && score<=100}">
      优秀
    </c:when>
    <c:when test="${score>=80 && score<=90}">
      良好
    </c:when>
    <c:when test="${score>=70 && score<=80}">
      一般
    </c:when>
    <c:when test="${score>=60 && score<=70}">
      及格
    </c:when>
    <c:otherwise>
      不及格
    </c:otherwise>
  </c:choose>
<br>
<%--5.forEach:循环--%>
  <%
    //List
    List<Student> list = new ArrayList<Student>();
    list.add(new Student("rose",18));
    list.add(new Student("jack",20));
    list.add(new Student("luck",38));
    //List放到域中
    pageContext.setAttribute("list",list);
  %>
  <%
    //Map
    Map<String,Student> map = new HashMap<String, Student>();
    map.put("100",new Student("mark",20));
    map.put("101",new Student("maxwell",30));
    map.put("102",new Student("Eric",40));
    //放入域中
    pageContext.setAttribute("map",map);
  %>
  <%--<c:forEach
  begin="从哪个元素开始遍历,默认从0开始,可以不写"
  end="到哪个元素结束,默认到最后一个元素,可以不写"
  step="步长,默认是1,可以不写"
  var="每个元素的名称"
  items="需要遍历的数据(集合)"
  varStatus="当前正在遍历的元素的状态对象(count属性:当前位置,从1开始)"/>--%>
  <%--遍历list--%>
  <c:forEach begin="0" end="2" step="1" items="${list}" var="student" varStatus="varSta">
    姓名:${varSta.count}--${student.name}--年龄:${student.age}<br>
  </c:forEach>
  <%--遍历Map--%>
  <c:forEach items="${map}" var="entry">
    ${entry.key}--姓名:${entry.value.name}--年龄:${entry.value.age}<br>
  </c:forEach>

  <%--6.forToken标签:循环特殊字符串--%>
  <%
    String str = "java-php-net-平面";
    pageContext.setAttribute("str",str);
  %>
  <c:forTokens items="${str}" delims="-" var="s">
    ${s}<br>
  </c:forTokens>

  <%--7.重定向--%>
  <c:redirect url="http://www.baidu.com"/>
  </body>
</html>

8.自定义标签
8.1.引入
当现有的标签无法满足我们的需求时,就需要自己开发一个适合的标签
例如,需要向浏览器输入当前客户端的IP地址,虽然用java程序是可以的,但是用标签是没有这个功能的,现在,我们来自定以这个标签

8.2.第一个自定义标签开发步骤
1.编写一个普通的类,继承SimpleTagSupport类,叫做标签处理器类

/**
 * 标签处理类
 * 1.继承SimpleTagSupport
 */

public class ShowIpTag extends SimpleTagSupport {

    /**
     * 2.覆盖doTag方法
     */
    @Override
    public void doTag() throws JspException, IOException {
        //向浏览器输出客户的IP地址
        PageContext pageContext = (PageContext)this.getJspContext();
        HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();
        String ip = request.getRemoteHost();
        JspWriter out = pageContext.getOut();
        out.write("使用自定义标签输出客户的IP地址:"+ip);
    }
}

2.在web项目的WEB-INF目录下建立net.tld文件,这个tld叫标签的声明文件(参考核心标签库的写法)

<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="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">

    <!--标签库的版本-->
    <tlib-version>1.1</tlib-version>
    <!--标签库前缀-->
    <short-name>net</short-name>
    <!--tld文件的唯一标记-->
    <uri>http://gz.itcast.cn</uri>

    <!--一个标签的声明-->
    <tag>
        <!--标签名-->
        <name>ShoeIp</name>
        <!--标签处理器类的全名-->
        <tag-class>tag.ShowIpTag</tag-class>
        <!--输出标签体内容格式-->
        <body-content>scriptless</body-content>
    </tag>
</taglib>

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

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

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

8.3.自定义标签的执行过程
问题: http://localhost:8080/hello/tag.jsp 如何访问到自定义标签?
前提:tomcat服务器启动时,加载到每个web应用,加载每个web应用的WEB-INF目录下的所有文件,如web.xml, tld文件
访问步骤:
1.访问tag.jsp资源
2.tomcat服务器把jsp文件翻译成java源文件-->编译class-->构造类对象-->调用_jspService()方法
3.检查jsp文件的taglib指令,是否存在名为http://gz.itcast.cn的tld文件,如果没有,则报错
4.上一步已经读取到net.tld文件
5.在tag.jsp中读到,到net.tld文件中查询是否存在为ShoeIp的标签
6.找到对应的标签,则读到内容
7.得到tag.ShowIpTag
8.构造ShowIpTag对象,然后调用ShowIpTag里面的方法

8.4.自定义标签处理类的生命周期
标签处理器本质上实现的还是SimpleTag接口,只是对里面的方法进行了重写。
SimpleTag接口:
void setJspContext(JspContext pc)
设置pageContext对象,传入pageContext(一定调用)
void setParent(JspTag parent)
设置父标签对象,传入父标签对象,如果没有父标签对象,则调用此方法。通过geetParent()方法得到父标签对象
void setXX(值)
设置属性值
void setJspBody(JSpFragment jspBody)
设置标签体内容。标签提内容封装到JspFragment中,然后传入JspFragment对象,通过getJspBody()方法得到标签体内容,如果没有标签体内容,则不会调用此方法
void doTag()
执行标签时调用的方法(一定会调用)

8.5.自定义标签的作用
1.控制标签体内容的是否输出
2.控制标签余下内容是否输出
3.控制重复输出标签体内容
4.改变标签体内容
5.带属性的标签

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

自定义标签的作用代码示例:


/**
 * 标签处理器类
 */
public class TagDemo extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        System.out.println("执行了标签");
        /**
         *1. 控制标签内容是否输出
         * 输出:调用jspFrament.invoke();
         * 不输出:不调用jspFrament.invoke();
         */
        //1.1.得到标签体内容
        JspFragment jspBody = this.getJspBody();
        //执行invoke方法:会把标签体的内容输出到指定的Writer对象
        //1.2.往浏览器输出,writer为null就是默认往浏览器输出
//        JspWriter out = this.getJspContext().getOut();
//        jspBody.invoke(out);
        jspBody.invoke(null);//等价于上面的两行代码

        /**
         * 3.控制重复输出标签体内容
         * 方法:执行多次jspBody.invoke()方法
         */
        for (int i=1; i <= 5 ; i++) {
            jspBody.invoke(null);
        }


        /**
         * 4.改变标签提内容
         */
        //4.1.创建StringWriter临时容器
        StringWriter sw = new StringWriter();
        //4.2.把标签提内容拷贝到临时容器
        jspBody.invoke(sw);
        //4.3.从临时容器中得到的标签
        String content = sw.toString();
        //4.4.改变内容
        content = content.toLowerCase();
        //4.5.把改变的内容输出到浏览器
        //不能使用jspBody.invoke()来输出,因为标签体内的内容并没有改变,改变的是容器里面的
        this.getJspContext().getOut().write(content);
        

        /**
         * 2.控制标签余下内容是否输出
         * 输出:什么都不做就会默认输出
         * 不输出:抛出有SkipPageException()异常则不输出
         */
        throw new SkipPageException();
        
    }
}

8.6.输出标签体内容格式
JSP:在传统标签中使用。可以写和执行jsp的java代码
scriptless:标签体不可以写jsp的java代码
empty:必须是空标签
tagdependent:标签体内容可以写jsp的java代码,但不会执行
9.JavaBean

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

JavaBaen就是一个普通的java类,只要符合以下规定才能称之为javaBean:
1.必须提供无参构造方法
2.类中属性都必须私有化
3.该类提供公开的getter和setter方法

javaBean的作用:
用于方法数据,保存数据
方法javaBean只能使用getter和seetter方法

javaBean的使用场景:
1.项目中用到实体对象(entity)符合javaBean规范
2.EL表达式访问对象属性,${student.name}滴啊用getName()方法,符合javaBean规范
3.jsp标签中的属性赋值,setNum(Integet num)。符合javaBean规范
4.jsp页面中使用javaBean,符合javaBean规范

javaBean在jsp页面中的使用

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>jsp页面中使用javabean</title>
</head>
<body>
<%--创建对象,使用无参构造器--%>
<jsp:useBean id="stu" class="servers.Student"/>

<%--赋值--%>
<jsp:setProperty name="stu" property="name" value="jacky"/>

<%--获取--%>
<jsp:getProperty name="stu" property="name"/>

</body>
</html>