JSP：java server page, java服务器端页面，在html中编写java代码。
1.为什么会有jsp
jsp是同servlet编写的一种技术，它将java代码和html代码语句混合在同一个文件中编写
只对网页中的要动态产生的内容采用java代码编写，而对固定不变的静态内容采用普通的html代码编写。
2.jsp的hello程序
新建jsp页面，在 <% %> 之间编写java代码即可。
这个jsp文件可以放在web应用的任何目录（除了WEB-INFO目录）
3.jsp的运行原理
$ ls /tomcat/_day_29/work/Catalina/localhost/hello/org/apache/jsp/ -lh
total 32K
-rw-rw-r-- 1 mamh mamh 6.1K 8月 1 16:30 hello2_jsp.class
-rw-rw-r-- 1 mamh mamh 5.3K 8月 1 16:30 hello2_jsp.java
-rw-rw-r-- 1 mamh mamh 7.0K 8月 29 13:41 index_jsp.class
-rw-rw-r-- 1 mamh mamh 6.9K 8月 29 13:41 index_jsp.java
jsp的本质上其实是一个servlet。每个jsp页面第一次被访问的时候，jsp引擎将他翻译为一个servlet。然后接着把这个servlet源代码程序编译为class文件。
public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent,
org.apache.jasper.runtime.JspSourceImports {
private static final javax.servlet.jsp.JspFactory _jspxFactory =
javax.servlet.jsp.JspFactory.getDefaultFactory();
private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
private static final java.util.Set<java.lang.String> _jspx_imports_packages;
private static final java.util.Set<java.lang.String> _jspx_imports_classes;
static {
_jspx_imports_packages = new java.util.HashSet<>();
_jspx_imports_packages.add("javax.servlet");
_jspx_imports_packages.add("javax.servlet.http");
_jspx_imports_packages.add("javax.servlet.jsp");
_jspx_imports_classes = new java.util.HashSet<>();
_jspx_imports_classes.add("com.atguigu.javaweb.HelloServlet");
_jspx_imports_classes.add("com.atguigu.javaweb.Person");
}
private volatile javax.el.ExpressionFactory _el_expressionfactory;
private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;
public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
return _jspx_dependants;
}
public java.util.Set<java.lang.String> getPackageImports() {
return _jspx_imports_packages;
}
public java.util.Set<java.lang.String> getClassImports() {
return _jspx_imports_classes;
}
public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
if (_el_expressionfactory == null) {
synchronized (this) {
if (_el_expressionfactory == null) {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
}
}
}
return _el_expressionfactory;
}
public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
if (_jsp_instancemanager == null) {
synchronized (this) {
if (_jsp_instancemanager == null) {
_jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
}
}
}
return _jsp_instancemanager;
}
public void _jspInit() {
}
public void _jspDestroy() {
}
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException {
final java.lang.String _jspx_method = request.getMethod();
if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
return;
}
final javax.servlet.jsp.PageContext pageContext;
javax.servlet.http.HttpSession session = null;
final javax.servlet.ServletContext application;
final javax.servlet.ServletConfig config;
javax.servlet.jsp.JspWriter out = null;
final java.lang.Object page = this;
javax.servlet.jsp.JspWriter _jspx_out = null;
javax.servlet.jsp.PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
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;
out.write("\n");
out.write("\n");
out.write("\n");
out.write("<html>\n");
out.write("<head>\n");
out.write(" <title>$Title$</title>\n");
out.write("</head>\n");
out.write("<body>\n");
out.write("<a href=\"upload.jsp\">upload</a>\n");
out.write("<br/><br/>\n");
out.write("<a href=\"download.jsp\">download</a>\n");
out.write("\n");
//9 个隐含对象
//1.HttpServletRequest类的一个对象
String username = request.getParameter("username");
System.out.println(username);
//2.HttpServletResponse类的一个对象,这个几乎不会调用
Class clazz = response.getClass();
System.out.println(clazz);
//3.PageContext,页面的上下文，重要的一个对象。
// 可以从改对象中获取页面所有信息，可以获取其他的８个隐含对象(后面学习自定义标签使用它)
HttpServletRequest req = (HttpServletRequest) pageContext.getRequest();
System.out.println(req == request);
//4.session,HttpSession类的一个对象，代表浏览器和服务器的一次会话
System.out.println("session ID = " + session.getId());
//5.application,代表当前web应用，可以获取web应用的初始化参数
System.out.println(application.getInitParameter("user"));
//6.config,当前jsp对象的servlet的ServletConfig对象，几乎不用
System.out.println(config.getInitParameter("hellojsp.password"));
//7.out, JspWriter 对象 可以直接调用out.println(),可以把字符串都打印到页面上
out.println(config.getInitParameter("hellojsp.password"));
out.print("<br/>");
out.println("session ID = " + session.getId());
//8.page是Obejct的对象，等于是this, final java.lang.Object page = this;
//指向当前ｊｓｐ对象的一个引用,但是他是一个Object类型只能使用Object 类的方法，几乎不用
out.print("<br/>");
out.print(this);
out.print("<br/>");
out.print(page);
//9.exception 只有在error 页面才可以使用
out.write("\n");
out.write("\n");
out.write("\n");
out.write("</body>\n");
out.write("</html>\n");
out.write("\n");
out.write("\n");
out.write("</body>\n");
out.write("</html>\n");
} catch (java.lang.Throwable t) {
if (!(t instanceof javax.servlet.jsp.SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
else throw new ServletException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
}
4.jsp中的9个隐含对象
pageContext, request, session, application(对属性作用域的范围从小到大)这几个很重要
out, response, config, page这几个不常用
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException {
final javax.servlet.jsp.PageContext pageContext;
javax.servlet.http.HttpSession session = null;
final javax.servlet.ServletContext application;
final javax.servlet.ServletConfig config;
javax.servlet.jsp.JspWriter out = null;
final java.lang.Object page = this;
javax.servlet.jsp.JspWriter _jspx_out = null;
javax.servlet.jsp.PageContext _jspx_page_context = null;
try {
pageContext = _jspxFactory.getPageContext(this, request, response,null, true, 8192, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
//这下面是我们自己的代码1）.request
HttpServletRequest类的一个对象
String username = request.getParameter("username");
System.out.println(username);2）.response
HttpServletResponse类的一个对象,这个几乎不会调用
Class clazz = response.getClass();
System.out.println(clazz);3）.pageContext
,页面的上下文，重要的一个对象。
// 可以从该对象中获取页面所有信息，可以获取其他的８个隐含对象(后面学习自定义标签使用它)
HttpServletRequest req = (HttpServletRequest) pageContext.getRequest();
System.out.println(req == request);4）.session
HttpSession类的一个对象，代表浏览器和服务器的一次会话，
System.out.println("session ID = " + session.getId());5）.application
代表当前web应用，可以获取web应用的初始化参数
它就是 ServletContext 的对象。
System.out.println(application.getInitParameter("user"));6）.config
当前jsp对象的servlet的ServletConfig对象，几乎不用
在web.xml 中配置一下这个初始化参数
<servlet>
<servlet-name>hellojsp</servlet-name>
<jsp-file>/index.jsp</jsp-file>
<init-param>
<param-name>hellojsp.password</param-name>
<param-value>hellojsp1234569273498271394723094723984134</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>hellojsp</servlet-name>
<url-pattern>/index.jsp</url-pattern>
</servlet-mapping>在index.jsp文件中获取初始化参数
System.out.println(config.getInitParameter("hellojsp.password"));访问需要访问映射的那个地址
http://localhost:8080/hello/indexjsp7）.out
JspWriter 对象 可以直接调用out.println(),可以把字符串都打印到页面上
out.println(config.getInitParameter("hellojsp.password"));
out.print("<br/>");
out.println("session ID = " + session.getId());8）.page
是Obejct的对象，等于是this, final java.lang.Object page = this;
//指向当前jsp对象的一个引用,但是他是一个Object类型只能使用Object 类的方法，几乎不用
out.print("<br/>");
out.print(this);
out.print("<br/>");
out.print(page);this: org.apache.jsp.index_jsp@4368ebb3
page: org.apache.jsp.index_jsp@4368ebb3 9).exception
只有在error 页面才可以使用
只有主动声明这个页面是isErrorPage=true的页面上才可以使用
<%@ page isErrorPage="true" %>5.jsp语法
1）jsp模板元素
jsp页面中的静态html元素称之位模板元素
2）jsp表达式（重要内容）
<%
//1.jsp 表达式可以将java 变量或java 表达式直接在页面上面输出
Date date = new Date();
out.print(date); //可以这样写
%><%= date %><!-- 还可以这样写 前提是要有这个date变量，这个就是jsp的表达式 -->
3） jsp脚本片段
位于jsp页面中的<% %>之间的代码就是脚本片段
<%
String ageStr = request.getParameter("age");
Integer age = Integer.parseInt(ageStr);
if (age >= 18) {
out.print("成人");
} else {
out.print("未成年");
}
%>也可以像下面这样来写，这就是所谓的脚本片段。多个脚本片段可以互相访问。
脚本片段的代码最后会翻译到jspService（）方法里面。
<%
String ageStr = request.getParameter("age");
int age = 0;
try {
age = Integer.parseInt(ageStr);
} catch (Exception e) {
}
if (age >= 18) {
%>
成人
<%
} else {
%>
未成年
<%
}
%>
上面的代码最后会被翻译为：
String ageStr = request.getParameter("age");
int age = 0;
try {
age = Integer.parseInt(ageStr);
} catch (Exception e) {
}
if (age >= 18) {
out.write("\n");
out.write("成人\n");
} else {
out.write("\n");
out.write("未成年\n");
}4）jsp声明
一般不用。
jsp声明将java代码封装在<%! %>之间，它里面的代码将被插入到servlet的jspService（）方法的外面。如果在hello2.jsp 里面加入下面代码
<%!
void test(){
System.out.println("this is test method");
}
%>
上面的声明会在类里面生成一个方法的。会在hello2_jsp这个类里面有这个方法。
public final class hello2_jsp extends org.apache.jasper.runtime.HttpJspBase
void test() {
System.out.println("this is test method");
}
}5）注释
jsp注释可以阻止java代码的执行。
<!-- 这个是html注释-->
<%-- 这个jsp注释 --%> 6.和属性相关的方法
1） 四个方法
public abstract void setAttribute(String var1, Object var2);
public abstract Object getAttribute(String var1);
public abstract void removeAttribute(String var1);
Enumeration<String> getAttributeNames();2）pageContext,request,session,application 这4个对象都有这几个属性的方法
pageContext 属性的作用范围仅限于当前jsp页面。
request 属性的作用范围仅限于同一个请求。（在请求转发的情况下可以跨页面获取属性的）
session 属性的作用范围仅限于一次会话，
application 属性的作用范围限于当前web应用，是范围最大的，只要在一处设置，其他各个地方都可以获取到。
<%
//只有这４个可以设置属性，这４个称之为域对象，设置属性
//属性作用范围仅仅限于当前页面
pageContext.setAttribute("p", "pageContextValue");
//仅限于同一个请求
request.setAttribute("r", "requestValue");
//作用范围限于一次会话,浏览器打开直道关闭，在此期间会话不失效的前提下。
session.setAttribute("s", "sessionValue");
//限于当前web应用，全局的范围，范围最大
application.setAttribute("a", "applicationValue");
%>
<br><br>
pageContext: <%= pageContext.getAttribute("p") %>
<br><br>
requestContext: <%= request.getAttribute("r") %>
<br><br>
sessionContext: <%= session.getAttribute("s") %>
<br><br>
applicationContext: <%= application.getAttribute("a") %>
<br><br>
7.请求转发和重定向
@WebServlet(name = "forwardServlet", urlPatterns = {"/forwardServlet"})
public class ForwardServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("forward servlet do get ....");
//转发这里的属性可以传递给下个servlet，应为请求转发是一个request
request.setAttribute("r", "forward servlet");
System.out.println("forward servlet do get ...." + request.getAttribute("r"));
//请求的转发
//1.调用HttpServeltRequest 的 getRequestDispatcher(addr) 方法，传入要转发的地址
String path = "forwardDestServlet";
RequestDispatcher requestDispatcher = request.getRequestDispatcher(path);
//2.调用HttpServeltRequest 的 forward() 进行请求的转发
requestDispatcher.forward(request, response); //这样就转发到forwardDestServlet这里了
}
}@WebServlet(name = "forwardDestServlet",urlPatterns = {"/forwardDestServlet"})
public class ForwardDestServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("forward dest servlet do get ....");
System.out.println("ForwardDestServlet servlet do get ...." + request.getAttribute("r"));
PrintWriter out = response.getWriter();
out.println("dest page.....");
}
}请求转发和重定向的区别
请求转发和重定向的区别
请求转发地址栏不发生变化.
转发是一个请求,
请求转发只能发到当前web应用的某个资源,不能转发出去.
对转发而言斜杠代表的是当前应用的根目录.
重定向会改变的.
重定向是２个请求.
重定向可以到任何资源.
对于重定向斜杠代表是站点的/
在这个基础上来讲mvc设计模式（请求转发）
8.jsp指令
指令放在<%@ %> 直接，有3个执行，page，taglib，include
多个属性可以写到一个指令里面，也可以分开写到多个指令中。
page指令的作用都在整个jsp页面，一般放到jsp页面的开头几行。
<%@ page 属性名=“属性值” %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix=""%>
<%@include file=""%>1）page指令
<%@page import="java.lang.Integer" %> 指定导入的java类。<%@page session="true|false" %> 作用是配置是否可以使用session隐含对象。
访问当前页面是否要生成httpsession对象。<%@ page errorPage="/error.jsp" %>
<%@ page isErrorPage="true" %>
从当前页面出错跳转到error.jsp的时候 内部其实用的是转发。
如何是客户端不能直接访问某个页面，对于tomcat来说，web-info下面的文件是不能直接访问的，隐私文件。可以通过转发来访问web-info下面的隐私文件。<%@ page contentType="text/html;charset=UTF-8" language="java" %>
contentType指定当前页面的内容类型，也可以指定编码
实际会被翻译为： response.setContentType("text/html;charset=UTF-8");
通常情况下取值为text/html;charset=UTF-8<%@page pageEncoding="utf-8" %>指定当前jsp页面的编码，通常和contentType里面一致。<%@page isELIgnored="true" %> 指定当前jsp页面是否可以使用EL表达式，通常取值true。2）include指令
include会被文件的所有内容包含进来的。静态包含，源码级别包含。
翻译后是一个java源文件。
相对路径问题，斜杠开头表示当前web应用的根目录。
String str= "";
<%@include file="attr1.jsp"%>
include之前声明的变量在包含的那个attr1.jsp文件中是可以使用的。这个在动态包含中是不生效的。3）jsp：include 标签
动态包含，这个会生成2个java文件的。
<jsp:include page="attr1.jsp"/>
翻译为这样的一个语句：org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "attr1.jsp", out, false);
9.jsp标签
<jsp:include page="attr1.jsp"/>
使用这种标签的方式可以使用子标签<jsp:param> 像下一个jsp页面传入一些参数。在jsp页面转发，直接这样写标签，不用再写java代码了。
<jsp:forward page="attr1.jsp" />
翻译为：
if (true) {
_jspx_page_context.forward("attr1.jsp");
return;
}
使用这种标签的方式可以使用子标签<jsp:param> 像下一个jsp页面传入一些参数。
<jsp:forward page="attr1.jsp">
<jsp:param name="username" value="xxxx"/>
</jsp:forward>
在attr1.jsp里面可以使用request.getParameter("username")获取到请求的参数。