JSP和JavaBean

8、JSP

8.1、什么是JSP

Java Servlet Pages：java服务器端页面，也和Servlet一样，用于实现动态Web技术。

最大特点：

• 写JSP就像是写HTML

• 区别：

  • HTML只给用户提供静态的数据
  • JSP页面中可以嵌入Java代码，为用户提供动态数据

8.2、JSP原理

找原理思路：JSP到底怎么执行的？

• 代码层面正常
• 服务器内部工作

​ tomcat中有一个work目录

D:\App\tomcat\apache-tomcat-9.0.55\work\Catalina\localhost\ROOT\org\apache\jsp

​ IDEA的tomcat中生成一个work目录

• 浏览器想服务器发送请求，不管访问什么资源，其实都是在访问Servlet

​ JSP最终也会被转换为一个java类

JSP本质上就是一个Servlet！

//初始化
public void _jspInit() {
}
//销毁
public void _jspDestroy() {
}
//JSPService
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response){    
}

_jspService

• 判断请求
• 内置一些对象

final javax.servlet.jsp.PageContext pageContext;//页面上下文
javax.servlet.http.HttpSession session = null;//Session
final javax.servlet.ServletContext application;//applicationContext
final javax.servlet.ServletConfig config;//config
javax.servlet.jsp.JspWriter out = null;//out
final java.lang.Object page = this;//page:当前页
HttpServletRequest request  //请求
HttpServletResponse response //响应

• 输出页面前，增加的方法

  response.setContentType("text/html");
  pageContext = _jspxFactory.getPageContext(this, request, response,null, true, 8192, true);
  _jspx_page_context = pageContext;
  application = pageContext.getServletContext();
  config = pageContext.getServletConfig();
  session = pageContext.getSession();
  out = pageContext.getOut();
  _jspx_out = out;
  

通俗点理解，就是客户端访问服务器，服务器把JSP代码编译生成 . java 类型的文件在响应给服务器，最终返回给客户端

在JSP页面中，只要是java代码就会原封不动的输出，HTMl代码就会转换成为out.write（“html代码”）这样的形式输出到前端

8.3、JSP基础语法

所有的java语法都支持，并且拥有自己的一些扩充语法。

JSP表达式

<%--  JSP表达式
作用：用来将程序的输出，输出到客户端    
<%=  变量或者表达式%>
--%>

<%= new java.util.Date()%>

jsp脚本片段

<%--jsp脚本片段--%>
<%
    int sum = 0;
    for (int i = 0; i < 5; i++) {
        sum += i;
    }
    out.println("<h1>sum=" + sum + "</h1>");
%>

在java代码中嵌入HTML代码

<%--在java代码中嵌入HTML代码--%>
<%
    for (int i = 0; i < 5; i++) {
%>
    <h1>HelloWorld! <%=i%></h1>
<%
    }
%>

<%=i%>也可以使用EL表达式，写成${i}

JSP声明

<%!
    static {
        System.out.println("loading Servlet!");
    }

    private  int globalvar=0;

    public void tong(){
        System.out.println("进入方法tong");
    }
%>

会被编译到jsp生成的java类的类中，其他的就会被声场到_jspService方法中!

在JSP中嵌入java代码即可

JSP的注释不会再客户端显示，HTML注释可以看到

8.4、JSP指令

1. 定制错误页面

• 方法一：修改jsp文件

  <%--定制错误页面--%>
  <%@page errorPage="jsp2.jsp" %>

• 方法二：修改web.xml里面配置

<error-page>
    <error-code>404</error-code>
    <location>/jsp2.jsp</location>        
</error-page>

1. 引入其他jsp文件

<%--@include引入文件，会将页面合二为一--%>
<%@include file="common/header.jsp"%>
<h1>body</h1>
<%@include file="common/footer.jsp"%>
<hr>

<%--jsp标签jsp:include，是拼接页面，本质上还是三个--%>
<jsp:include page="common/header.jsp"></jsp:include>
<h1>jsp标签</h1>
<jsp:include page="common/footer.jsp"/>

最大区别就是定义参数，如果使用@include，那么编辑的时候如果变量重名，不会报错，运行时合二为一就会报500错误，如果使用jsp:include，编辑的时候就会报错，方便调试，使用上还是使用jsp标签较多

8.5、9大内置对象

1. PageContext 存东西
2. Request 存东西
3. Response
4. Session 存东西
5. Application【ServletContext】存东西
6. config【ServletConfig】
7. out
8. page，几乎不用
9. exception

<%--内置对象--%>
<%
    pageContext.setAttribute("name1","叶通1");//保存的数据只在一个页面中有效
    request.setAttribute("name2","叶通2");//保存的数据只在一个请求中有效，请求转发中会携带这个数据
    session.setAttribute("name3","叶通3");//保存的数据只在一个会话中有效，从浏览器打开到关闭
    application.setAttribute("name4","叶通4");//保存的数据在一个服务器中有效，从服务器打开到关闭
%>
<%--脚本片段里面的代码会原封不动的保存到jsp.java中，所以注释也要用java的注释--%>
<%
    //全部通过pageContext取出保存的值，通过查询的方式来
    //从底层到高层（作用域）
    String name1 = (String) pageContext.findAttribute("name1");
    String name2 = (String) pageContext.findAttribute("name2");
    String name3 = (String) pageContext.findAttribute("name3");
    String name4 = (String) pageContext.findAttribute("name4");
    String name5 = (String) pageContext.findAttribute("name5");//不存在
%>
<%--使用EL表达式输出--%>
<h1 >取出的值为：</h1>
<h3 >${name1}</h3>
<h3 >${name2}</h3>
<h3 >${name3}</h3>
<h3 >${name4}</h3>
<h3 >${name5}</h3>
<%--name5为空，使用EL表达式直接不显示--%>
<hr>
<h3><%=name5%></h3>
<%--使用<%=%>会输出null--%>

request:客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，

session：客户端向服务器发送请求，产生的数据，用户看完一会还有用，比如：购物车，

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户可能还要使用，比如：聊天数据，

8.6、JSP标签、JSTL标签、EL表达式

使用之前都需要导包

<!--JSTL表达式的依赖-->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>
<!--standard标签库-->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式：${ }

• 获取数据

• 执行运算

• 获取web开发的常用对象

• 调用java方法（比较麻烦，不用）

JSP标签

总共需要掌握三个jsp:forward、jsp:param、jsp:include

<%--因为发送的reques信息里面有中文，所以要提前解决乱码问题--%>
<%request.setCharacterEncoding("utf-8");%>

<jsp:forward page="jsptag2.jsp">
    <jsp:param name="name" value="通"/>
    <jsp:param name="age" value="3"/>
</jsp:forward>

<%--jsp标签jsp:include，是拼接页面，本质上还是三个--%>
<jsp:include page="common/header.jsp"></jsp:include>
<h1>jsp标签</h1>
<jsp:include page="common/footer.jsp"/>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足，自定义了许多的标签类，标签的功能和java代码一样（即用标签的来实现java代码）

• 格式化标签
• SQL标签
• XML标签
• 核心标签（重点掌握）
  

1. JSTL标签库使用步骤

• 引入对应的taglib

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

• 使用其中的方法

• 提醒：在tomcat中也需要引入JSTL的jar包和Standard的jar包，否则会报错：JSTL解析错误

c:if

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h4>if测试</h4>
<hr>
<form action="coreif.jsp" method="get">
    <%--EL表达式获取表单中的数据
    ${param.参数名}
    --%>
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">
</form>
<%--判断如果提交的用户名是管理员，则登录成功--%>
<%--test判断条件，var用来接收返回值，scope作用域--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
    <c:out value="管理员，欢迎您！"></c:out>
</c:if>
<c:out value="${isAdmin}"/>
</body>
</html>

c:choose

<%--定义一个变量score，值为85--%>
<c:set var="score" value="85"></c:set>
<c:choose>
<%--注意从上到下判断，依次执行--%>
    <c:when test="${score>=90}">
        你的成绩为优秀
    </c:when>
    <c:when test="${score>=80}">
        你的成绩为良好
    </c:when>
    <c:when test="${score>=70}">
        你的成绩为一般
    </c:when>
    <c:when test="${score>=60}">
        你的成绩为及格
    </c:when>
    <c:when test="${score<60}">
        你的成绩为不及格
    </c:when>
</c:choose>

c:foreach

<%
ArrayList<String> people = new ArrayList<>();
people.add(0,"张三");
people.add(1,"李四");
people.add(2,"王五");
people.add(3,"赵六");
people.add(4,"田七");
request.setAttribute("list",people);
%>
<%--
var:每一次遍历出来的变量
items：要遍历的对象
begin="1"
end="3"
step="2" 步长
--%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/><br>
</c:forEach>
<hr>
<c:forEach var="people" items="${list}" begin="1" end="3" step="2">
    <c:out value="${people}"/><br>
</c:forEach>

9、JavaBean

实体类

JavaBean有特定的写法：

• 必须要有一个无参构造
• 属性必须私有化
• 必须有对应的get/set方法

一般用来和数据库的字段做映射

ORM：对象关系映射

• 表---->类
• 字段---->属性
• 行记录---->对象

id	name	age	address
1	通通1号	12	上海
2	通通2号	24	南京
3	通通3号	42	南京

package com.tong.pojo;
//实体类一般都是和数据库中的表结构一一对应
public class People {
    private int id;
    private String name;
    private int age;
    private String address;

    @Override
    public String toString() {
        return "People{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public People(int id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public People() {
    }
}