jsp 订阅
JSP(全称JavaServer Pages)是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上,可以响应客户端发送的请求,并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页,然后返回给请求者。JSP技术以Java语言作为脚本语言,为用户的HTTP请求提供服务,并能与服务器上的其它Java程序共同处理复杂的业务需求。JSP将Java代码和特定变动内容嵌入到静态的页面中,实现以静态页面为模板,动态生成其中的部分内容。JSP引入了被称为“JSP动作”的XML标签,用来调用内建功能。另外,可以创建JSP标签库,然后像使用标准HTML或XML标签一样使用它们。标签库能增强功能和服务器性能,而且不受跨平台问题的限制。JSP文件在运行时会被其编译器转换成更原始的Servlet代码。JSP编译器可以把JSP文件编译成用Java代码写的Servlet,然后再由Java编译器来编译成能快速执行的二进制机器码,也可以直接编译成二进制码。 展开全文
JSP(全称JavaServer Pages)是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上,可以响应客户端发送的请求,并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页,然后返回给请求者。JSP技术以Java语言作为脚本语言,为用户的HTTP请求提供服务,并能与服务器上的其它Java程序共同处理复杂的业务需求。JSP将Java代码和特定变动内容嵌入到静态的页面中,实现以静态页面为模板,动态生成其中的部分内容。JSP引入了被称为“JSP动作”的XML标签,用来调用内建功能。另外,可以创建JSP标签库,然后像使用标准HTML或XML标签一样使用它们。标签库能增强功能和服务器性能,而且不受跨平台问题的限制。JSP文件在运行时会被其编译器转换成更原始的Servlet代码。JSP编译器可以把JSP文件编译成用Java代码写的Servlet,然后再由Java编译器来编译成能快速执行的二进制机器码,也可以直接编译成二进制码。
信息
外文名
Java Server Pages
本    质
JSP
中文名
JAVA服务器页面
JSP特点
收起全文
精华内容
参与话题
问答
  • Jsp&Servlet学习笔记(一)

    千次阅读 多人点赞 2019-07-18 15:12:32
    Jsp&Servlet学习笔记(一) 第一章 问候 Jsp&Servlet 他大爷 第一节:Jsp 概述 第二节:B/S vs C/S B/S系统是 浏览器/服务器(瘦客户端); C/S系统是 客户端/服务器(胖客户端)。 第三节:...

    Jsp&Servlet学习笔记(一)

     

    第一章 问候 Jsp&Servlet 他大爷

    第一节:Jsp 概述

     

    第二节:B/S vs C/S

    B/S系统是 浏览器/服务器(瘦客户端); C/S系统是 客户端/服务器(胖客户端)。

     

    第三节:Tomcat 服务器

    简介:百度百科。

    安装及配置:百度。

    目录结构:

     

    第五节:问候他大爷

    第一个Jsp程序:

    <%@ page language="java" contentType="text/html; charset=UTF-8"

        pageEncoding="UTF-8"%>

    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

    <html>

    <head>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

    <title>问候Jsp他大爷</title>

    </head>

    <body>

    问候Jsp他大爷

    </body>

    </html>

    (在Tomcat服务器上运行,具体实现略)

     

    第二章 Jsp 基础语法

    第一节:page 指令介绍

    Language : 用来定义要使用的脚本语言;

    contentType:定义 JSP 字符的编码和页面响应的 MIME 类型;

    pageEncoding:Jsp 页面的字符编码

     

     

    第二节:scriptlet 标签

    通过 scriptlet 标签我们可以在 Jsp 里嵌入 Java 代码;

     

    脚本程序:可以包含任意量的Java语句、变量、方法或表达式。

    语法格式:<% 代码片段 %>

     

    JSP声明:一个声明语句可以声明一个或多个变量、方法,供后面的Java代码使用。

    语法格式:<%! declaration; [ declaration; ]+ ... %>

    JSP表达式:一个JSP表达式中包含的脚本语言表达式,先被转化成String,然后插入到表达式出现的地方。

    语法格式:<%= 表达式 %>

     

    第三节:Jsp 注释

    <!-- --> Html 注释 客户端源码可见

    <%-- --%> Jsp 注释 客户端源码不可见

    // java 单行注释

    /* */ java 多行注释

     

     

    第四节:Jsp 包含指令

    <%@ include file=”要包含的文件”%> 静态包含:先包含,后编译处理;

    <h1>静态包含</h1>

    <%@ include file="common/head.jsp" %>

    <p>content</p>

    <%@ include file="common/foot.jsp" %>

    <jsp:include page=”要包含的文件”/> 动态包含:先编译处理,后包含;

    <h1>动态包含</h1>

    <jsp:include page="common/head.jsp"/>

    <p>content</p>

    <jsp:include page="common/foot.jsp"/>

    (建议开发用动态包含。)

     

    第五节:Jsp 跳转指令

    <jsp:forward page=” ”>

    <jsp:param value=”” name=””>

    </jsp:forward>

    服务器内部跳转,可带参数;

     

    <title>Jsp 跳转指令</title>

    </head>

    <body>

    <jsp:forward page="target.jsp">

        <jsp:param value="huang" name="userName"/>

        <jsp:param value="123" name="password"/>

    </jsp:forward>

    </body>

    -----------------------------------------------------------

    <title>Jsp 跳转后页面target</title>

    </head>

    <body>

    服务器内部跳转后的页面<br>

    userName:<%=request.getParameter("userName") %><br>

    password:<%=request.getParameter("password") %><br>

    </body>

    第三章 JSP 九大内置对象及四个作用域

     

    第一节:Jsp 九大内置对象及四大作用域概述

    在Jsp开发中,Jsp提供了9个内置对象,这些内置对象将由容器为用户进行实例化,用户直接使用即可。

    这9个内置对象分别是:

    pageContext,request,response,session,application,config,out,page,exception;常用的是前面 5个,需要熟练掌握。

    在Jsp开发中,可以保存数据,Jsp提供了四种数据保存范围;分别是 page,request,session,application。

     

     

    第二节:Jsp 四大作用域

    Page 范围:

    只在一个页面中保存数据; javax.servlet.jsp.PageContext(抽象类)

    <body>

    <%

        // 设置两个page范围的数据 key->value

        pageContext.setAttribute("name","page王二小");

        pageContext.setAttribute("age",12);

    %>

    <%

        // 取值

        String name=(String)pageContext.getAttribute("name");

        int age=(Integer)pageContext.getAttribute("age");

    %>

    <font>姓名:<%=name %></font>

    <font>年龄:<%=age %></font>

     

    Request 范围:

    只在一个请求中保存数据; javax.servlet.http.HttpServletRequest(接口)

    RequestScope.jsp

    <body>

    <%

        // 设置两个request范围的数据 key-> value

        request.setAttribute("name","request王二小");

        request.setAttribute("age",12);

    %>

    <jsp:forward page="requestTarget.jsp"></jsp:forward>

    </body>

    RequestTarget.jsp

    <body>

    <%

        // 取值

        String name=(String)request.getAttribute("name");

        int age=(Integer)request.getAttribute("age");

    %>

    <font>姓名:<%=name %></font>

    <font>年龄:<%=age %></font>

    </body>

     

    Session 范围:

    在一次会话范围中保存数据,仅供单个用户使用;

    javax.servlet.http.HttpSession(接口)

    sessionScope.jsp

    <body>

    <%

        // 设置两个session范围的数据 key-> value

        session.setAttribute("name","session王二小");

        session.setAttribute("age",12);

    %>

    <h1>session值设置完毕!</h1>

    </body>

    sessionTarget.jsp

    <%

        // 取值

        String name=(String)session.getAttribute("name");

        int age=(Integer)session.getAttribute("age");

    %>

    <font>姓名:<%=name %></font>

    <font>年龄:<%=age %></font>

     

    Application 范围:

    在整个服务器上保存数据,所有用户共享;javax.servlet.ServletContext(接口)

    applicationScope.jsp

    <body>

    <%

        // 设置两个application范围的数据 key-> value

        application.setAttribute("name","application王二小");

        application.setAttribute("age",12);

    %>

    <h1>application值设置完毕!</h1>

    </body>

     

    applicationTarget.jsp

    <body>

    <%

        // 取值

        String name=(String)application.getAttribute("name");

        int age=(Integer)application.getAttribute("age");

    %>

    <font>姓名:<%=name %></font>

    <font>年龄:<%=age %></font>

    </body>

     

     

    第三节:response 对象

    response内置对象和request内置对象是相对应的,response内置对象用于响应客户请求,向客户端输出信息;javax.servlet.HttpServletResponse 接口。

    1. 自动刷新应用

    <body>

    <%

        // 每隔一秒刷新一次页面

        response.setHeader("refresh","1");

        // 获取当前时间

        Date myDate=new Date();

    %>

    当前时间:<%= myDate.toLocaleString() %>

    </body>

    2,页面重定向应用客户端跳转

    <%

        // 重定向,客户端跳转,网址会变

        response.sendRedirect("index.html");

    %>

    3,操作cookie应用  post、get方法比较:post放数据包里;get放Url后面,get数据量小,不安全;

    //response03.jsp

    <title>登录页面</title>

    <script type="text/javascript">

        function resetValue(){

           document.getElementById("userName").value="";

           document.getElementById("pwd").value="";

        }

    </script>

    <%

        String userName=null;

        String pwd=null;

        Cookie[] cookies=request.getCookies();

        for(int i=0;cookies!=null &&i<cookies.length;i++){

           if(cookies[i].getName().equals("userNameAndPwd")){

               userName=cookies[i].getValue().split("-")[0];

               pwd=cookies[i].getValue().split("-")[1];

           }

        }

       

        if(userName==null){

           userName="";

        }

       

        if(pwd==null){

           pwd="";

        }

    %>

    </head>

    <body>

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

        <table>

           <tr>

               <td>用户名:</td>

               <td><input type="text" id="userName" name="userName" value="<%=userName%>"/></td>

           </tr>

           <tr>

               <td>密码:</td>

               <td><input type="password" id="pwd" name="pwd" value="<%=pwd %>" /></td>

           </tr>

           <tr>

               <td>记住密码:</td>

               <td><input type="checkbox" id="remember" name="remember" value="remember-me"/></td>

           </tr>

           <tr>

               <td><input type="submit" value="登录"/></td>

               <td><input type="button" value="重置" onclick="resetValue()"/></td>

           </tr>

        </table>

    </form>

    </body>

    //userLogin.jsp

    <body>

    <%

        String userName=request.getParameter("userName");  // 获取用户名

        String pwd=request.getParameter("pwd");  // 获取密码

        String remember=request.getParameter("remember");  // 获取记住密码

       

        if("remember-me".equals(remember)){

           Cookie userNameAndPwd=new Cookie("userNameAndPwd",userName+"-"+pwd);

           userNameAndPwd.setMaxAge(1*60*60*24*7); // cookie记录一个星期

           response.addCookie(userNameAndPwd);  // 保存cookie

           System.out.println("设置Cookie成功");

        }

        // response.sendRedirect("response03.jsp");

    %>

    登录成功

    </body>

    4,cookie和session的比较:cookie信息是存客户端的,session 信息是存服务器的;

     

    第四节:out 对象

    Out 内置对象主要用来向客户端输出各种类型的数据,同时还可以管理应用服务器上的输出缓冲区。所以out内置对象的方法是向客户端输出数据和管理缓冲区; 底层javax.servlet.jsp.JspWriter 抽象。

    <body>

    <%

        int totalbuffer=out.getBufferSize();  // 获取总缓冲区的大小

        int available=out.getRemaining(); // 获取未使用的缓冲区的大小

        int user=totalbuffer-available;  // 获取使用的缓冲区大小

        out.println("总共缓冲区的大小:"+totalbuffer);

        out.println("未使用的缓冲区的大小:"+available);

        out.println("使用的缓冲区大小:"+user);

    %>

    </body>

     

    第五节:config 对象

    config 内置对象是JSP页面通过JSP容器进行初始化时被传递的对象。javax.servlet.ServletConfig 。

    在Servlet初始化的时候,JSP引擎通过config 向它传递信息。这种信息可以是属性名和属性值匹配的参数,也可以是通过ServletContext对象传递的服务器的有关信息。

    //web.xml

    <servlet>

        <servlet-name>init</servlet-name>

        <jsp-file>/sysInit.jsp</jsp-file>

        <init-param>

           <param-name>jdbcName</param-name>

           <param-value>com.mysql.jdbc.Driver</param-value>

        </init-param>

        <init-param>

           <param-name>dbUrl</param-name>

           <param-value>jdbc:mysql://localhost:3306/db_xx</param-value>

        </init-param>

      </servlet>

     

      <servlet-mapping>

        <servlet-name>init</servlet-name>

        <url-pattern>/init</url-pattern>

      </servlet-mapping>

     

    //sysInit.jsp

    <body>

    <%

        String jdbcName=config.getInitParameter("jdbcName");

        String dbUrl=config.getInitParameter("dbUrl");

    %>

    <h1>驱动名称:<%=jdbcName %></h1>

    <h1>连接地址:<%=dbUrl %></h1>

    </body>

     

    请求地址:http://localhost:8081/JspServlet/init

     

    第六节:exception 对象

    exception 内置对象用来处理JSP文件在执行时发生的所有异常,它是java.lang.Throwable 类的一个对象。

    //exception01.jsp

    <%@ page errorPage="error.jsp"%>

    ...

    <body>

    <%

        int a=1;

        int b=0;

        out.println(a/b);

    %>

    </body>

     

    //error.jsp

    <%@ page isErrorPage="true"%>

    ...

    <body>

    <%

        if(exception!=null){

           out.println("程序错误信息:");

           out.println(exception.getMessage());

        }

    %>

    </body>

    第七节:pageContext 对象

    pageContext 内置对象是一个比较特殊的对象。它相当于页面中所有对象功能的集合,即使用它可以访问到本页面中所有对象。pageContext 内置对象由Jsp 容器创建并初始化,pageContext 对象提供了对JSP 页面所有对象及控件的访问。

    <body>

    <%

        pageContext.setAttribute("name0", "pageInfo");

        request.setAttribute("name1", "requestInfo");

        session.setAttribute("name2", "sessionInfo");

        application.setAttribute("name3", "applicationInfo");

       

        out.println("使用pageContext<br/>");

        out.println("page中的属性值:"+pageContext.getAttribute("name0")+"<br/>");

        out.println("request中的属性值:"+pageContext.getRequest().getAttribute("name1")+"<br/>");

        out.println("session中的属性值:"+pageContext.getSession().getAttribute("name2")+"<br/>");

        out.println("application中的属性值:"+pageContext.getServletContext().getAttribute("name3")+"<br/>");

    %>

    </body>

     

    第四章 JavaBean组件

    第一节:Javabean 组件引入

    JavaBean 是使用Java 语言开发的一个可重用的组件,在JSP 开发中可以使用JavaBean 减少重复代码,使整个JSP 代码的开发更简洁。

     

    第二节:jsp:useBean 创建javabean

    <jsp:useBean id="实例化对象名称" scope="保存范围" class="类完整名称"/>

    Scope一共有page,request,session和application 4个属性范围,默认是page;

    <jsp:useBean id="student" scope="page" class="com.java1234.model.Student"/>

    <%

        student.setName("王二小2");

        student.setAge(12);

    %>

    <h1>姓名:<%=student.getName() %></h1>

    <h1>年龄:<%=student.getAge() %></h1>

    </body>

    第三节:jsp:setProperty 设置javabean 属性值

    <jsp:setProperty property="属性名称" name="实例化对象的名称" value="属性值" param="参数名称"/>

    当 property=”*” 时,自动匹配所有属性。

    <body>

    <% request.setCharacterEncoding("utf-8"); %>

    <jsp:useBean id="student" scope="page" class="com.java1234.model.Student"/>

    <jsp:setProperty property="*" name="student"/>   <!--  自动匹配所有属性 -->

    <h1>姓名:<%=student.getName() %></h1>

    <h1>年龄:<%=student.getAge() %></h1>

    </body>

    当属性名不匹配时,使用param属性

    <body>

    <% request.setCharacterEncoding("utf-8"); %>

    <jsp:useBean id="student" scope="page" class="com.java1234.model.Student"/>

    <jsp:setProperty property="name" name="student" param="userName"/>

    <jsp:setProperty property="age" name="student" value="100"/>

    <h1>姓名:<%=student.getName() %></h1>

    <h1>年龄:<%=student.getAge() %></h1>

    </body>

     

    第四节:jsp:getProperty 获取javabean 属性值

    <jsp:getProperty property="属性名称" name="实例化对象的名称"/>

    <body>

    <jsp:useBean id="student" scope="page" class="com.java1234.model.Student"/>

    <%

        student.setName("王二小2");

        student.setAge(12);

    %>

    <h1>姓名:<jsp:getProperty property="name" name="student"/></h1>

    <h1>年龄:<jsp:getProperty property="age" name="student"/></h1>

    </body>

     

    第五节:javabean 的保存范围

    Javabean 的保存范围有page,request,session.application,默认是page;

    举例request范围:

    <body>

    <jsp:useBean id="student" scope="request" class="com.java1234.model.Student"/>

    <jsp:setProperty property="name" name="student" value="王八蛋"/>

    <jsp:setProperty property="age" name="student" value="12"/>

    <jsp:forward page="target01.jsp"/>

    </body>

    //target01.jsp

    <body>

    <jsp:useBean id="student" scope="request" class="com.java1234.model.Student"/>

    <h1>姓名:<jsp:getProperty property="name" name="student"/></h1>

    <h1>年龄:<jsp:getProperty property="age" name="student"/></h1>

    </body>

    第六节:javabean 删除

    page 范围:pageContext.removeAttribute(“javaBean Name”);

    request 范围:request.removeAttribute(“javaBean Name”);

    session 范围:session.removeAttribute(“javaBean Name”);

    application 范围:application.removeAttribute(“javaBean Name”);

    <body>

    <jsp:useBean id="student" scope="session" class="com.java1234.model.Student"/>

    <jsp:setProperty property="name" name="student" value="王八蛋"/>

    <jsp:setProperty property="age" name="student" value="12"/>

    <h1>Session数据设置完毕!</h1>

    </body>

    //javabeanDelete.jsp

    <body>

    <% session.removeAttribute("student"); %>

    <h1>javabean已删除!</h1>

    </body>

     

    第五章Servlet 开发

    第一节:问候servlet 他大爷

    Web.xml配置servlet名称、映射等,此处略。

    package com.java1234.web;

     

    import java.io.IOException;

    import java.io.PrintWriter;

     

    import javax.servlet.ServletException;

    import javax.servlet.http.HttpServlet;

    import javax.servlet.http.HttpServletRequest;

    import javax.servlet.http.HttpServletResponse;

     

    public class HelloWorldServlet extends HttpServlet{

     

        /**

         *

         */

        private static final long serialVersionUID = 1L;

     

        @Override

        protected void doGet(HttpServletRequest request, HttpServletResponse response)

               throws ServletException, IOException {

           System.out.println("get");

           this.doPost(request, response);

        }

     

        @Override

        protected void doPost(HttpServletRequest request, HttpServletResponse response)

               throws ServletException, IOException {

           response.setCharacterEncoding("gbk");

           PrintWriter out=response.getWriter();

           out.println("<html>");

           out.println("<head><title>问候大爷</title></head>");

           out.println("Servlet大爷你好!");

           out.println("</html>");

           out.close();

        }

     

    }

    第二节:servlet 生命周期

    Servlet 的生命周期,简单的概括这就分为四步:servlet 类加载--->实例化--->服务--->销毁。

     

    第三节:客户端跳转VS 服务器端跳转

    1,在Servlet 中获取session,application

    2,客户端跳转response.sendRedirect("目标地址");

    //web.xml配置同上

        @Override

        protected void doPost(HttpServletRequest request, HttpServletResponse response)

               throws ServletException, IOException {

           request.setAttribute("requestKey", "request");

           HttpSession session=request.getSession();  // 获取session

           session.setAttribute("sessionKey", "session");

           ServletContext application=this.getServletContext(); // 获取application

           application.setAttribute("applicationKey", "application");

           response.sendRedirect("target.jsp"); // 客户端跳转/重定向

        }

    //target.jsp

    <body>

    <h1>目标地址</h1>

    request值:<%=request.getAttribute("requestKey") %><br/>

    session值:<%=session.getAttribute("sessionKey") %><br/>

    application值:<%=application.getAttribute("applicationKey") %><br/>

    </body>

    (sendRedirect重定向不携带request参数)

    3,服务器跳转:RequestDispatcher rd=request.getRequestDispatcher("目标地址"); rd.forward(request, response);

        @Override

        protected void doPost(HttpServletRequest request, HttpServletResponse response)

               throws ServletException, IOException {

           request.setAttribute("requestKey", "request");

           HttpSession session=request.getSession();  // 获取session

           session.setAttribute("sessionKey", "session");

           ServletContext application=this.getServletContext(); // 获取application

           application.setAttribute("applicationKey", "application");

            RequestDispatcher rd=request.getRequestDispatcher("target.jsp");

           rd.forward(request, response); // 服务器跳转/转发

        }

    //target.jsp

    <body>

    <h1>目标地址</h1>

    request值:<%=request.getAttribute("requestKey") %><br/>

    session值:<%=session.getAttribute("sessionKey") %><br/>

    application值:<%=application.getAttribute("applicationKey") %><br/>

    </body>

    (携带request参数)

    第四节:Jsp&Servlet 用户登录功能实现

    代码太多…

    第五节:Servlet 过滤器

    过滤用户(非法)请求

    Web,xml配置filter,此处略。下面贴核心代码:

    public class LoginFilter implements Filter {

     

        @Override

        public void destroy() {

           // TODO Auto-generated method stub

          

        }

     

        @Override

        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)

               throws IOException, ServletException {

           // TODO Auto-generated method stub

           HttpServletRequest request=(HttpServletRequest)servletRequest;

           HttpSession session=request.getSession();

           Object o=session.getAttribute("currentUser");

           String path=request.getServletPath();  //获取请求路径

           if(o==null&&path.indexOf("login")<0){  // 排除登录请求的过滤

               request.getRequestDispatcher("login.jsp").forward(servletRequest, servletResponse);

           }else{

               filterChain.doFilter(servletRequest, servletResponse);

           }

        }

     

        @Override

        public void init(FilterConfig arg0) throws ServletException {

           // TODO Auto-generated method stub

          

        }

    }

     

    第六节:Servlet 监听器

    监听web 事件;如application,session,request

    示例(session)

    Web.xml配置

    <listener>

      <listener-class>com.java1234.listener.SessionAttributeListener</listener-class>

    </listener>

     

    // SessionAttributeListener.java

    package com.java1234.listener;

     

    import javax.servlet.http.HttpSessionAttributeListener;

    import javax.servlet.http.HttpSessionBindingEvent;

     

    public class SessionAttributeListener implements HttpSessionAttributeListener{

     

        public void attributeAdded(HttpSessionBindingEvent httpSessionBindingEvent) {

           // TODO Auto-generated method stub

           System.out.println("添加的属性名:"+httpSessionBindingEvent.getName()+",属性值:"+httpSessionBindingEvent.getValue());

        }

     

        public void attributeRemoved(HttpSessionBindingEvent httpSessionBindingEvent) {

           // TODO Auto-generated method stub

           System.out.println("删除的属性名:"+httpSessionBindingEvent.getName()+",属性值:"+httpSessionBindingEvent.getValue());

        }

     

        public void attributeReplaced(HttpSessionBindingEvent httpSessionBindingEvent) {

           // TODO Auto-generated method stub

          

        }

    }

     

    展开全文
  • JSP介绍(一)

    万次阅读 多人点赞 2018-09-05 07:17:43
    一、JSP是什么,它有什么作用? Java Server Page,它是用于展示信息操作。 为了servlet展示信息的不方便,引入了JSPJSP本质上也是一个servlet!!!!!! JSP就是在HTML页面中嵌入了java代码。 二、JSP...

    一、JSP是什么,它有什么作用?

    Java Server Page,它是用于展示信息操作。

    为了servlet展示信息的不方便,引入了JSP。

    JSP本质上也是一个servlet!!!!!!

    JSP就是在HTML页面中嵌入了java代码。

    二、JSP原理

    在Tomcat中的web.xml中,有一个默认的servlet,处理不可以处理的请求,还有一个JSPservlet,又叫servlet引擎,所有后缀为.jsp的文件都处理。

    当浏览器访问http://localhost:8080/day9_1/index.jsp。服务器发现后缀为.jsp,它会根据路径找到index.jsp文件,会将index.jsp翻译成index_jsp.java文件,对这个java文件进行编译,产生一个index_jsp.class文件,将class文件加载运行。将JSP翻译成java文件,它是将JSP中的所有的HTML代码通过流进行输出,也就是说最终翻译成class,被虚拟机加载,它本质是servlet,它就会往回响应,响应回去就是把JSP中的HTML代码以流的方式写回浏览器。所以在JSP中展示出了HTML代码。

    当请求过来,这是第一步,到服务器端,服务器端处理了,找到hello.jsp,服务器怎么处理的,就是在Tomcat中的web.xml配置了一个JSP servlet引擎,根据后缀名,处理了,处理之后会找到这个JSP,然后对这个JSP做一个翻译的过程,把它翻译成了一个java文件,这个java文件会进行编译,编译以后变成class,而后被加载,加载后就执行,就把原来JSP里面的代码,即HTML代码以流的方式写回浏览器。

    work --->  catalina -----> localhost ------> day9_1 ------> index_JSP.java

    三、怎么在JSP中书写java代码

    标签 语法 用途
    声明标签 <%! 变量或方法声明%> 声明JSP内所使用的全局变量或方法或内部类(它用于定义成员)(写的内容在成员位置上)
    表达式 <%= 表达式 %> 输出java中变量或者表达式的值到页面上(它用于输出) out.print(内容)
    程序代码标签 <%程序代码%> 编写java程序代码,但不可以定义代码(它用于定义局部)(声明的变量在局部位置_jspService方法中)
    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <%! int i = 10; %> <!-- 成员变量 -->
    <%! public void show(){} %> <!-- 成员方法 -->
    <% int i = 100; %>
    <%= "hello" %>
    </body>
    </html>

    注意:<%! %>中的内容,作为类的成员变量和成员函数,写在类的成员位置。

    <% %>中的内容,写在_jspService函数中。

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <%! 
    	int i = 10;
    %> <!-- 成员变量 -->
    <%! 
    	public void show(){} 
    %> <!-- 成员方法 -->
    <% int i = 100; %>
    输出函数中的i:<%=i%>
    输出成员变量i:<%=this.i %>
    </body>
    </html>

    上面声明,下面可以直接用,因为被编译到一个类中,知道被编译的位置,就可以直接正确使用。

    如果把一个数据存在request域中(因为_jspService方法参数就是request和response,所以可以直接用),取值操作如下:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <%request.setAttribute("name","tom"); %>
    <%=request.getAttribute("name")==null ? "" : request.getAttribute("name") %><br>
    ${requestScope.name}
    </body>
    </html>

    java代码和JSP代码一起使用,在开发中不要这样写,不便于维护

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <%
    	for(int i = 0; i < 10; i++){
    		%>
    		hello&nbsp;<%=i %><br>
    		<%
    	}
    %>
    </body>
    </html>
    <%
    String path=request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <%
    String path=request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <%=path %><br>
    <%=basePath %>
    <form action="<%=path %>/login">
    	<input type="submit">
    </form>
    <form action="<%=basePath%>login">
    	<input type="submit">
    </form>
    </body>
    </html>

    建议使用<%=path%>/login

     

    展开全文
  • javaweb 入门到精通Servlet&JSP;

    万人学习 2018-04-12 09:41:02
    JSP语法,Tomcat服务器应用,状态管理,cookie、session,EL+JSTL,Servlet原理及生命周期,过滤器Filter,监听器Listener,MVC开发模式,自定义MVC框架,标签,自定义标签
  • JSP的基本使用

    万次阅读 多人点赞 2018-08-19 20:31:45
    今天给大家分享一下,修真院官网JAVA任务二,扩展思考中的知识点——JSP基本知识 一、背景介绍   JSP(Java Server Pages),其根本是一个简化的Servlet设计,它实现了在Java中使用HTML标签。JSP是一种动态网页技术...

    大家好,我是IT修真院郑州分院第十期学员,一枚正直纯洁善良的JAVA程序员。

    今天给大家分享一下,修真院官网JAVA任务二,扩展思考中的知识点——JSP基本知识

    一、背景介绍  

           JSP(Java Server Pages),其根本是一个简化的Servlet设计,它实现了在Java中使用HTML标签。JSP是一种动态网页技术标准,也是JavaEE的标准。JSP和Servlet一样,是在服务器端执行的。JSP是在Servlet技术发展之后为了让开发者写html标签更方便而发展起来的技术,JSP实际上就是Servlet。

           人们通常把Servlet作为Web应用中的控制组件来使用,只负责响应请求产生数据,并把数据通过转发技术带给jsp,而把jsp技术作为数据显示模板来使用。这样使程序结构更清晰,可读性和可维护性更高。

    二、知识剖析(JSP页面元素构成)

          1.JSP页面的三大指令

         (1)<%@ page ... %>    定义网页依赖属性,比如脚本语言、error页面、缓存需求等等;

    <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false"  import="java.util.Date"  import="java.text.SimpleDateFormat"%>

           page指令一般在表头位置,用来设置本页面的语法,编码格式,导包等信息,page指令可以合并在一行,也可以分为多行,这个可以根据自己的需求编写。

         (2)<%@ include ... %>    包含其他文件(静态包含);

           有两个页面一个是index.jsp(左)页面,一个是include.jsp(右)页面,在同级目录,如下所示;

          初始页面:

             

          显示:

             

          在index.jsp中加入include指令:

          

          显示:

          

         (3)taglib指令:引入标签库的定义。

          <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
           prefix:指定标签前缀,这个东西可以随意起名
           uri:指定第三方标签库的uri(唯一标识)

          2.表达式

          在JSP页面中执行的表达式 <%=表达式%>,注意表达式不以分号结束。例如,当前时间:<%= new java.util.Date() %>;

          在页面输出指定格式的当前时间:

    <%=new SimpleDateFormat("yy年MM月dd日 HH:mm:ss").format(new Date())%>

     

          3.脚本片段

          在JSP页面中插入多行java代码 <% Java代码 %>,JSP引擎在翻译JSP页面时,会将JSP脚本片段中的Java代码原封不动的放到Servlet的_jspServlet方法中,所以,<% %>中的Java代码必须严格遵循java语法。

        脚本即 Scriptlet , 也就是 JSP 中的代码部分 , 是一段 Java 代码 , 几乎可以使用任何 Java 语法 , 它是在请求时期执行的 , 可以使用 JSP 页面所定义的变量、方法、表达式或 JavaBean . 脚本定义的变量和方法在当前整个页面内有效 , 但不会被其他线程共享 , 用户对该变量的作用不会影响其他用户 , 当变量所在页面关闭时 , 该变量会被销毁

      语法格式如下 :

      <%scriptlet%>

    <%! String str ="为中华之崛起而读书";%>
    <%
        if(true){
    %>
            <%=str%>
    <%
        }
    %>

          4.注释(3种方式)

         (1) HTML注释:<!--html注释,且客户端可见-->;

         (2)JSP注释:<%--JSP注释,客户端不可见--%>;

         (3)JSP脚本注释:即java注释 //单行 , /*多行 */。

          5.声明:

          在JSP页面中,可以声明一个或者多个合法的变量和方法 , 声明后的变量和方法可以在本 JSP 页面的任何位置使用 , 并将在 JSP 页面初始化时被初始化。

     语法格式如下 :

      <!%declaration; [declaration;] ...%>

         在声明时需要注意 :

    1. 声明以 "<%!" 开头 , 以 "%>" 结尾 , "%!" 必须紧挨
    2. 变量和方法的命名规则应与 Java 的命名规则相同
    3. 可以直接使用在 "<@page %>" 中被包含进来的已经声明的变量和方法 , 不需要对其进行重新声明
    4. 一个声明仅在一个页面有效 , 如果想每个页面都用到一些声明 , 可以将它们写成一个单独的文件 , 用 "<%@ include%>" 指令 或 "<jsp:include>" 动作包含进来

    三、常见问题

          html和jsp的区别(见扩展思考)

    四、编码实战(见知识剖析)

    五、扩展思考

          html和jsp的区别:

          HTML(Hypertext Markup Language)文本标记语言,它是静态页面,和JavaScript一样解释性语言,为什么说是解释性语言呢?因为,只要你有一个浏览器那么它就可以正常显示出来,而不需要指定的编译工具,只需在TXT文档中写上HTML标记就OK。

          JSP(Java Server Page)是Java服务端的页面,所以它是动态的,它是需要经过JDK编译后把内容发给客户端去显示,我们都知道,Java文件编译后会产生一个class文件,最终执行的就是这个class文件,JSP也一样,它也要编译成class文件!JSP不止要编译,它还得要转译,首先把JSP转译成一个Servlet文件,然后在编译成class文件。当用户访问JSP时就执行了class文件

          1.HTML能直接打开,jsp只能发布到Tomact等服务器上才能打开;

          2.定义上HTML页面是静态页面可以直接运行,JSP页面是动态页它运行时需要转换成servlet;

          3.他们的表头不同,这个是JSP的头“ <%@ page language="java" import="java.util.*" pageEncoding="gbk"%>”在表头中有编码格式和导入包等;

          4.在jsp中用<%%>就可以写Java代码了,而html没有

     六、参考文献

          本文主要摘自https://www.cnblogs.com/rocomp/p/4822419.htmlhttps://www.cnblogs.com/yuanmiemie/p/6196906.html

    七、更多讨论

         1.jsp页面如何设置没有缓存?

        (1)清空tomcat缓存。

           server->tomcat->clean tomcat work directory.

        (2)设置页面Nocache方式,即每次访问此页面,均需要从服务器重新读取,而不是使用缓存中存在的此页面。

          在jsp页面的<head></head>中间添加如下代码。

    <meta http-equiv="pragma" content="no-cache"> 
    
    <meta http-equiv="cache-control" content="no-cache"> 
    
    <meta http-equiv="expires" content="0">   

        2.jsp怎么去关掉session?

          session.removeAttribute("username"); //注销session中的username对象
          session.removeAttribute("id"); //注销session中的id对象
          session.invalidate(); //关闭session

        3.jsp的内置对象有哪几个?

          JSP中一共预先定义了9个这样的对象,分别为:request、response、session、application、out、pagecontext、config、page、exception

         (1)request对象

          request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息,主要用于接受通过HTTP协议传送到服务器的数据。(包括头信息、系统信息、请求方式以及请求参数等)。request对象的作用域为一次请求。

         (2)response对象

          response 代表的是对客户端的响应,主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域,它只在JSP页面内有效。

          (3)session对象

           session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象,用于保存该用户的信息,跟踪用户的操作状态。session对象内部使用Map类来保存数据,因此保存数据的格式为 “Key/value”。 session对象的value可以使复杂的对象类型,而不仅仅局限于字符串类型。

          (4)application对象

           application 对象可将信息保存在服务器中,直到服务器关闭,否则application对象中保存的信息会在整个应用中都有效。与session对象相比,application对象生命周期更长,类似于系统的“全局变量”。

         (5)out 对象

          out 对象用于在Web浏览器内输出信息,并且管理应用服务器上的输出缓冲区。在使用 out 对象输出数据时,可以对数据缓冲区进行操作,及时清除缓冲区中的残余数据,为其他的输出让出缓冲空间。待数据输出完毕后,要及时关闭输出流。

         (6)pageContext 对象

          pageContext 对象的作用是取得任何范围的参数,通过它可以获取 JSP页面的out、request、reponse、session、application 等 对象。pageContext对象的创建和初始化都是由容器来完成的,在JSP页面中可以直接使用 pageContext对象。

          (7)config 对象

          config 对象的主要作用是取得服务器的配置信息。通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。当一个Servlet 初始化时,容器把某些信息通过 config对象传递给这个 Servlet。 开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。

          (8)page 对象

          page 对象代表JSP本身,只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量,类似于Java编程中的 this 指针。

          (9)exception 对象

           exception 对象的作用是显示异常信息,只有在包含 isErrorPage="true" 的页面中才可以被使用,在一般的JSP页面中使用该对象将无法编译JSP文件。excepation对象和Java的所有对象一样,都具有系统提供的继承结构。exception 对象几乎定义了所有异常情况。在Java程序中,可以使用try/catch关键字来处理异常情况; 如果在JSP页面中出现没有捕获到的异常,就会生成 exception 对象,并把 exception 对象传送到在page指令中设定的错误页面中,然后在错误页面中处理相应的 exception 对象。

    八、视频教程

    https://v.qq.com/x/page/f0761gtmhhp.html

    快点加入我们吧:http://www.jnshu.com/login/1/23284132

    展开全文
  • JSP

    万次阅读 多人点赞 2017-04-10 14:50:42
    jsp简介 JSP(Java Server Pages)是JavaWeb服务器端的动态资源,它与html页面的作用是相同的,显示数据和获取数据。 jsp: 作为请求发起页面,例如显示表单、超链接。 : 作为请求结束页面,例如显示数据。 ...

    这里写图片描述

    jsp简介

    • JSP(Java Server Pages)是JavaWeb服务器端的动态资源,它与html页面的作用是相同的,显示数据和获取数据。
    • jsp: 作为请求发起页面,例如显示表单、超链接。
      : 作为请求结束页面,例如显示数据。
    • Servlet:
      作为请求中处理数据的环节。
    • jsp的组成
      • jsp = html + java脚本 + jsp标签(指令)
      • jsp中可直接使用的对象一共有9个,被称之为9大内置对象
    • 3种java脚本:
      <%…%>:写java代码片段,(类似方法)
      <%=…%>:用于输出,用于输出一条表达式(或变量)的结果。
      <%!…%>:声明,用来创建类的成员变量和成员方法(类似与类)
    • jsp注释:<%– … –%>
      当服务器把jsp编译成java文件时已经忽略了注释部分!

    jsp原理(看源码)

    • jsp其实是一种特殊的Servlet
      • 当jsp页面第一次被访问时,服务器会把jsp编译成java文件
      • 然后再把java编译成.class
      • 然后创建该类对象
      • 最后调用它的service()方法
      • 第二次请求同一jsp时,直接调用service()方法。

    jsp三大指令

    page

    <%@page language=”java” info=”xxx”…%>**

    • pageEncoding和contentType:
      pageEncoding:它指定当前jsp页面的编码,只要不说谎,就不会有乱码!在服务器要把jsp编译成.java时需要使用pageEncoding!
      contentType:它表示添加一个响应头:Content-Type!等同与response.setContentType(“text/html;charset=utf-8”);
      如果两个属性只提供一个,那么另一个的默认值为设置那一个。
      如果两个属性都没有设置,那么默认为iso
    • import:导包!可以出现多次
    • errorPage和isErrorPage
      errorPage:当前页面如果抛出异常,那么要转发到哪一个页面,由errorPage来指定
      isErrorPage:它指定当前页面是否为处理错误的页面!当该属性为true时,这个页面会设置状态码为500!而且这个页面可以使用9大内置对象中的exception!
    <error-page>有两种使用方式:
    <error-code><location>子元素;
    <exception-type><location>子元素;
    其中<error-code>是指定响应码;<location>指定转发的页面;<exception-type>是指定抛出的异常类型。
     <error-page>
        <error-code>404</error-code>
        <location>/error/errorPage.jsp</location>
     </error-page>
          <error-page>
     <exception-type>java.lang.RuntimeException</exception-type>
            <location>/index.jsp</location>
          </error-page>
    • autoFlush和buffer
      autoFlush:指定jsp的输出流缓冲区满时,是否自动刷新!默认为true,如果为false,那么在缓冲区满时抛出异常!
      buffer:指定缓冲区大小,默认为8kb,通常不需要修改!
    • isELIgnored:是否忽略el表达式,默认值为false,不忽略,即支持!
    • (以下了解即可):
      language:指定当前jsp编译后的语言类型,默认值为java。
      info:信息!
      isThreadSafe:当前的jsp是否支持并发访问!
      session:当前页面是否支持session,如果为false,那么当前页面就没有session这个内置对象!
      extends:让jsp生成的servlet去继承该属性指定的类!

    include –> 静态包含

    • 与RequestDispatcher的include()方法的功能相似!
    • <%@include%> 它是在jsp编译成java文件时完成的!他们共同生成一个java(就是一个servlet)文件,然后再生成一个class!
    • RequestDispatcher的include()是一个方法,包含和被包含的是两个servlet,即两个.class!他们只是把响应的内容在运行时合并了!
    • 作用:把页面分解了,使用包含的方式组合在一起,这样一个页面中不变的部分,就是一个独立jsp,而我们只需要处理变化的页面。

    taglib –> 导入标签库

    • 两个属性:
      prefix:指定标签库在本页面中的前缀!由我们自己来起名称!
      uri: 指定标签库的位置!
      <%@taglib prefix=”s” uri=”/struts-tags”%> 前缀的用法<s:text>

    九大内置对象

    • 在jsp中无需声明即可直接使用的9个对象
      • out(JspWriter):等同与response.getWriter(),用来向客户端发送文本数据;
      • config(ServletConfig):对应“真身”中的ServletConfig;
      • page(当前JSP的真身类型):当前JSP页面的“this”,即当前对象,引用为Object类型;
      • pageContext(PageContext):页面上下文对象,它是最后一个没讲的域对象;
      • exception(Throwable):只有在错误页面中可以使用这个对象;
      • request(HttpServletRequest):即HttpServletRequest类的对象;
      • response(HttpServletResponse):即HttpServletResponse类的对象;
      • application(ServletContext):即ServletContext类的对象;
      • session(HttpSession):即HttpSession类的对象,不是每个JSP页面中都可以使用,如果在某个JSP页面中设置<%@page session=”false”%>,说明这个页面不能使用session。
    • pageContext(一个顶9个!)
      • Servlet中有三大域,而JSP中有四大域!
        ServletContext:整个应用程序
        session:整个会话(一个会话中只有一个用户)
        request:一个请求链!
        pageContext:一个jsp页面!这个域是在当前jsp页面和当前jsp页面中使用的标签之间共享数据!
        域对象
        代理其他域:pageContext.setAttribute(“xxx”, “XXX”, PageContext.SESSION_SCOPE);
        全域查找:pageContext.findAttribute(“xxx”);从小到大,依赖查找!
        获取其他8个内置对象:

    JSP动作标签

    动作标签是由tomcat(服务器)来解释执行!而html标签由浏览器来执行!

    • <jsp:include>
      例如:<jsp:include page="xxx"/>,用来包含指定的页面。假如有两个jsp. 分别为a.jsp和b.jsp,他们分别编码成Servlet,然后在执行Servlet时才会执行包含过程。这也是include指令与include标签的区别。
      • 注意:<jsp:include page="<%=myfile%>">,这是可以的!因为include指令是在执行时才完成的包含,在执行时已经可以确定myfile这个变量的值。
      • 该标签内部使用的是RequestDispatcher#include()方法完成的包含
    • <jsp:forward>
      例如:<jsp:forward page="xxx"/>,用来转发到指定页面
      例如在a.jsp中存在如下内容:<jsp:fowrad page="b.jsp"/>
      a.jsp中的内容不会显示在浏览器上,而只是显示b.jsp的内容。而且在<jsp:forwad>标签下面的内容不会被执行。
    • <jsp:param>
      该标签是和的子标签,用来向其他页面传递参数。
    <jsp:include page="/b.jsp">
        <jsp:param value="zhangSan" name="username"/> 
    </jsp:include>
    在b.jsp中可以使用request.getParameter(“username”)来获取参数值。

    javaBean

    • 必须有public的无参的构造器
    • 如果成员变量提供了getter/setter方法,那么称之为javabean属性。

    JavaBean主要是用来通过反射操作的类!
    因为需要通过Class的newInstance()方法来创建类的实例,所以要求类必须提供public的无参构造器

    内省

    • 内省类 –> Bean信息 –> 属性描述符 –> 属性的get/set对应的Method! — > 反射
      1. 通过Class对象获取BeanInfo
        BeanInfo info = Introspector.getBeanInfo(User.class);
      2. 通过BeanInfo获取所有属性描述符对象
        PropertyDescriptor[] pds = info.getPropertyDescriptors();
      3. PropertyDescriptor:
        • String name getName():获取当前属性名称
        • Method getReadMethod():获取get方法反射对象
        • Method getWriteMethod():获取set方法反射对象
      1. jar包 commons-beanutils.jar、commons-logging.jar
      2. 通过反射设置Javabean
        Class<User> clazz = User.class;
        Object user = clazz.newInstance();
        BeanUtils.setProperty(user, “username”, “admin”);
        BeanUtils.setProperty(user, “password”, “admin123”);
      3. 获取属性值
        String username = BeanUtils.getProperty(user, “username”);
      4. 把Map数据封装到JavaBean对象中
    Map<String,String> map = new HashMap<String,String>();
    map.put("username", "admin");
    map.put("password", "admin123");

    User user = new User();
    BeanUtils.populate(user, map);

    要求:map的key名称必须与User类的属性名称相同。不要无法赋值!

    JSP中与JavaBean相关的标签

    • <jsp:useBean>
    • <jsp:setProperty>
    • <jsp:getProperty>
    <jsp:useBean id="user1" class="cn.domain.User" />

    查看page域中是否存在user1这个域属性,如果存在,那么直接获取。
    如果不存在,那么创建之!
    等同与:
    User user1 = pageContext.getAttribute(“user1”);
    if(user1 == null) {
    user1 = new User();//创建user1对象
    pageContext.setAttribute(“user1”, user1);//保存到page域
    }

    • 可以通过scope属性来指定操作

      设置属性值:
    <jsp:setProperty property="username" name="user1" value="admin"/>
    • name:指定名为user1的JavaBean
    • property:指定要设置的属性名称
    • value:指定要设置的属性值
      等同与
      User user1 = (User)pageContext.getAttribute(“user1”);
      user1.setUsername(“admin”);
    **<jsp:getProperty>**

    获取属性值

    <jsp:getProperty property="username" name="user1"/>

    输出user1这个javaBean的username属性值

    等同与
    User user1 = (User)pageContext.getAttribute(“user1”);
    out.print(user1.getUsername());

    EL表达式


    • EL:Expression Language,它是可以在JSP页面中直接使用的语言!
      JSP页面也可以忽略EL:<@page isELIgnored=”true”%>
      EL用来代替<%=…%>
    • EL 11个内置对象

    EL可以输出的东西都在11个内置对象中!11个内置对象,其中10个是Map!pageContext不是map,它就是PageContext类型,1一个顶九个

  • ${pageScope.xxx}、
  • ${requestScope.xxx}、
  • ${sessionScope.xxx}、
  • ${applicationScope.xxx}
  • param:对应参数,它是一个Map,其中key参数名,value是参数值,适用于单值的参数。
  • paramValues:对应参数,它是一个Map,其中key参数名,value是多个参数值,适用于多值的参数。
  • header:对应请求头,它是一个Map,其中key表示头名称,value是单个头值,适用于单值请求头
  • headerValues:对应请求头,它是一个Map,其中key表示头名称,value是多个头值,适用于多值请求头
  • initParam:获取<context-param>内的参数!
  • cookie:Map<String,Cookie>类型,其中key是cookie的name,value是cookie对象。 ${cookie.username.value}
  • pageContext:它是PageContext类型!${pageContext.request.contextPath}

  • EL操作四大域的内置对象:它们是Map类型
    pageScope
    requestScope
    sessionScope
    applicationScope

    ${pageScope.user}:输出pageContext.getAttribute("user")
    ${requestScope.user}:输出request.getAttribute("user");
    ${sessionScope.user}:输出session.getAttribute("user");
    ${applicationScope.user}:输出application.getAttribute("user");

    ${user}
    依次在pageScope、requestScope、sessionScope、applicationScope中查找user
    如果查找到,那么立刻停止查找。

    • 操作JavaBean
      <%
      User user = new User();
      user.setUsername(“zhangSan”);
      user.setPassword(“123”);
      pageContext.setAttribute(“user”, user);
      %>
    ${pageScope.user.username}
    ${pageScope.user.password}
    • 操作List
      <%
      User user = new User();
      user.setUsername(“zhangSan”);
      user.setPassword(“123”);
      List list = new ArrayList();
      list.add(user);
      pageContext.setAttribute(“list”, list);
      %>
    ${pageScope.list[0].username}
    ${pageScope.list[0].password}
    • 操作Map
      <%
      User user = new User();
      user.setUsername(“zhangSan”);
      user.setPassword(“123”);
      Map map = new HashMap();
      map.put(“u1”, user);
      pageContext.setAttribute(“map”, map);
      %>
    ${pageScope.map['u1'].username}
    ${pageScope.map['u1'].password}
    
    ${pageScope.map.u1.username}
    ${pageScope.map.u1.password}

    EL操作参数内置对象:Map类型

    param:Map<String,String>
    paramValues:Map<String,String[]>
    ${param.username}:request.getParameter("username")
    ${paramValues.hobby}:request.getParameterValues("hobby");

    EL操作请求头内置对象:Map类型

    header:Map<String,String>
    headerValues:Map<String,String[]>
    
    ${header.UserAgent}
    ${headerValues.UserAgener[0]
    • 与Cookie相关的内置对象:Map类型
    cookie:Map<String,Cookie>,其中key是Cookie的名称,而值是Cookie对象
    ${cookie.jsessionid.value}:获取sessionid

    • pageContext内置对象:PageContext类型
    ${pageContext.request},等同pageContext.getRequest()
    ${pageContext.session},等同pageContext.getSession()
    
    ${pageContext.request.contextpath},获取项目名
    ${pageContext.session.id},获取sessionId

    • EL中最重要的就是操作四大域!
      使用EL函数库需要在JSP页面中导入标签库:
      导入标签库:<%@ tablib prefix=”fn” uri=”http://java.sun.com/jsp/jstl/functions”%>
      String toUpperCase(String input):把参数转换成大写
      String toLowerCase(String input):把参数转换成小写
      int indexOf(String input, String substring):从大串,输出小串的位置!
      boolean contains(String input, String substring):查看大串中是否包含小串
      boolean containsIgnoreCase(String input, String substring):忽略大小写的,是否包含
      boolean startsWith(String input, String substring):是否以小串为前缀
      boolean endsWith(String input, String substring):是否以小串为后缀
      String substring(String input, int beginIndex, int endIndex):截取子串
      String substringAfter(String input, String substring):获取大串中,小串所在位置后面的字符串
      substringBefore(String input, String substring):获取大串中,小串所在位置前面的字符串
      String escapeXml(String input):把input中“<”、”>”、”&”、”’”、”“”,进行转义
      String trim(String input):去除前后空格
      String replace(String input, String substringBefore, String substringAfter):替换
      String[] split(String input, String delimiters):分割字符串,得到字符串数组
      int length(Object obj):可以获取字符串、数组、各种集合的长度!
      String join(String array[], String separator):联合字符串数组!
    <%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/function"%>
    
    <%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
    …
    String[] strs = {"a", "b","c"};
    List list = new ArrayList();
    list.add("a");
    pageContext.setAttribute("arr", strs);
    pageContext.setAttribute("list", list);
    %>
    ${fn:length(arr) }<br/><!--3-->
    ${fn:length(list) }<br/><!--1-->
    ${fn:toLowerCase("Hello") }<br/> <!-- hello -->
    ${fn:toUpperCase("Hello") }<br/> <!-- HELLO -->
    ${fn:contains("abc", "a")}<br/><!-- true -->
    ${fn:containsIgnoreCase("abc", "Ab")}<br/><!-- true -->
    ${fn:contains(arr, "a")}<br/><!-- true -->
    ${fn:containsIgnoreCase(list, "A")}<br/><!-- true -->
    ${fn:endsWith("Hello.java", ".java")}<br/><!-- true -->
    ${fn:startsWith("Hello.java", "Hell")}<br/><!-- true -->
    ${fn:indexOf("Hello-World", "-")}<br/><!-- 5 -->
    ${fn:join(arr, ";")}<br/><!-- a;b;c -->
    ${fn:replace("Hello-World", "-", "+")}<br/><!-- Hello+World -->
    ${fn:join(fn:split("a;b;c;", ";"), "-")}<br/><!-- a-b-c -->
    
    ${fn:substring("0123456789", 6, 9)}<br/><!-- 678 -->
    ${fn:substring("0123456789", 5, -1)}<br/><!-- 56789 -->
    ${fn:substringAfter("Hello-World", "-")}<br/><!-- World -->
    ${fn:substringBefore("Hello-World", "-")}<br/><!-- Hello -->
    ${fn:trim("     a b c     ")}<br/><!-- a b c -->
    ${fn:escapeXml("<html></html>")}<br/> <!-- <html></html> -->

    自定义函数库

    • 写一个java类,类中可以定义0~N个方法,但必须是static,而且有返回值的!
    • 在WEB-INF目录下创建一个tld文件
      <function>
        <name>fun</name>
        <function-class>haha.fn.MyFunction</function-class>
        <function-signature>java.lang.String fun()</function-signature>
      </function>
    • 在jsp页面中导入标签库
      <%@ taglib prefix=”it” uri=”/WEB-INF/tlds/haha.tld” %>
    • 在jsp页面中使用自定义的函数:${it:fun() }

    JSTL

    • JSTL是apache对EL表达式的扩展

    jstl标签库

    • core:核心标签库,
    • fmt:格式化标签库
    • sql:数据库标签库,过时;
    • xml:xml标签库,过时。

    <c:core>

    • <c:out value=”aaa”/> 输出字符串aaa
    • <c:out value="${aaa}”/> 输出域属性aaa,其中与${aaa}相同
    • <c:out value="${aaa}” default=”xxx”/>如果${aaa}不存在,那么输出xxx字符串
    • <c:out value="${aaa}" escapeXml=”true”/>如果${aaa}中包含特殊字符,那么转义它。这可以防止javascript攻击

    <c:set>

    • <c:set var=”a” value=”hello”/> 创建名为a,值为hello的域属性,范围:page
    • <c:set var=”a” value=”hello” scope=”session”/> 范围为session(page、request、session、application)

    <C:remove>

    • <c:remove var=”a”/> 删除名为a的域属性
    • <c:remove var=”a” scope=”page”/> 删除page域中名为a的域属性

    <C:url>

    • <c:url value=”/AServlet”/> 输出URL:/项目名/AServlet
    • <c:url value=”/AServlet” var=”url” scope=”page”/> 把生成的url保存到page域中,而不会输出
    • 子标签:<c:param>,用来给url后面添加参数,例如:
        <c:url value="/index.jsp">
          <c:param name="username" value="张三"/>  <!--可以对参数进行url编码!!-->
        </c:url>
    结果为:/day13_1/index.jsp?username=%ED%2C%3F%ED%2C%3F
    

    * var:指定变量名,一旦添加了这个属性,那么url标签就不会再输出到页面,而是把生成url保存到域中。
    * scope:它与var一起使用,用来保存url。

    <C:if>

    *<c:if test=”${条件}”> 当条件为true时执行标签体内容
    hello

    <c:choose>

    <c:set var="score" value="${param.score }"/>
    <c:choose>
        <c:when test="${score > 100 || score < 0}">错误的分数:${score }</c:when>[if]
        <c:when test="${score >= 90 }">A级</c:when>
        <c:when test="${score >= 80 }">B级</c:when>
        <c:when test="${score >= 70 }">C级</c:when>
        <c:when test="${score >= 60 }">D级</c:when>
        <c:otherwise>E级</c:otherwise>[else]
    </c:choose>

    <c:forEach>

    <c:forEach var="i" begin="1" end="10">
        ${i}
      </c:forEach>

    属性:
    * var:循环变量
    * begin:设置循环变量从几开始。
    * end:设置循环变量到几结束。
    * step:设置步长!等同与java中的i++,或i+=2。step默认为1

    • 遍历集合或数组方式:
    <%
    String[] names = {"zhangSan", "liSi", "wangWu", "zhaoLiu"};
    pageContext.setAttribute("ns", names);
    %>
    <c:forEach var="item" items="${ns }">
        <c:out value="name: ${item }"/><br/>
    </c:forEach>
    • 遍历List
    <%
        List<String> names = new ArrayList<String>();
        names.add("zhangSan");
        names.add("liSi");
        pageContext.setAttribute("ns", names);
    %>
    <c:forEach var="item" items="${ns }">
        <c:out value="name: ${item }"/><br/>
    </c:forEach>
    • 遍历Map
    <%
        Map<String,String> stu = new LinkedHashMap<String,String>();
        stu.put("number", "N_1001");
        stu.put("name", "zhangSan");
        pageContext.setAttribute("stu", stu);
    %>
    <c:forEach var="item" items="${stu }">
        <c:out value="${item.key }: ${item.value }"/><br/>
    </c:forEach>
    • 循环状态

    循环状态变量有如下属性:
    * count:循环元素的个数
    * index:循环元素的下标
    * first:是否为第一个元素
    * last:是否为最后一个元素
    * current:当前元素

    <c:forEach items="${list }" var="ele" varStatus="vs">
        ${vs.index} ${vs.count } ${vs.first } ${vs.last } ${vs.current }<br/>
    </c:forEach>

    fmt库

    • <fmt:formatDate value=”” pattern=”“>
      value:指定一个Date类型的变量
      pattern:用来指定输出的模板!例如:yyyy-MM-dd HH:mm:ss
      <fmt:formatNumber value=”${num1}” pattern=”0.00”>
      保留小数点后2位,它会四舍五入!如果不足2位,以0补位!
      <fmt:formatNumber value=”${num1}” pattern=”#.##”>
      保留小数点后2位,它会四舍五入!如果不足2位,不补位!

    自定义标签(实现SimpleTag接口,即简单标签)

    步骤:
    1. 标签处理类:继承SimpleTagSupport类
    public class HelloTag extends SimpleTagSupport {
    public void doTag() throws JspException, IOException {
    this.getJspContext().getOut().write(“<p>Hello SimpleTag!</p>“) ;
    }
    }

    标签描述符文件(tld)
    /WEB-INF/tlds/haha.tld

    <?xml version="1.0" encoding="UTF-8"?>
    <taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xml="http://www.w3.org/XML/1998/namespace" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
                            http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd ">
    
        <tlib-version>1.0</tlib-version> 
        <short-name>haha</short-name> 
        <uri>http://www.haha.cn/tags</uri> 
        <tag> 
            <name>hello</name> <!--标签名称-->
            <tag-class>cn.haha.tag.HelloTag</tag-class> <!--标签处理类名称-->
            <body-content>empty</body-content> <!--标签体为空,即空标签-->
        </tag>
    </taglib>
    1. jsp页面中使用自定义标签
    <%@ taglib prefix="it"  uri="/WEB-INF/hello.tld"  %>
    ......
    <it:hello/>

    有标签体的标签

    1. 标签处理类
      public class HelloTag extends SimpleTagSupport {
      public void doTag() throws JspException, IOException {
      PageContext pc = (PageContext) this.getJspContext();
      HttpServletRequest req = (HttpServletRequest) pc.getRequest();
      String s = req.getParameter(“exec”);
      if(s != null && s.endsWith(“true”)) {
      // 获取标签体对象
      JspFragment body = this.getJspBody() ;
      // 执行标签体
      body.invoke (null);
      }

      }
      }

    2. tld

    <tag>
            <name>hello</name>
            <tag-class>cn.itcast.tags.HelloTag</tag-class>
            <body-content>scriptless</body-content> <!--标签体内容不可以是java脚本,但可以是el、jstl等-->
        </tag>

    不执行标签下面的页面内容

    public void doTag() throws JspException, IOException {
        this.getJspContext().getOut().print("<h1>只能看到我!</h1>");
        throw new SkipPageException();
    }
    

    带有属性的标签

    public class IfTag extends SimpleTagSupport {
    private boolean test;//设置属性,提供getter/setter方法
    public boolean isTest() {
    return test;
    }
    public void setTest (boolean test) {
    this.test = test;
    }
    @Override
    public void doTag() throws JspException, IOException {
    if(test) {//如果test为true,执行标签体内容
    this.getJspBody().invoke(null);
    }
    }
    }

    <tag> 
        <name>if</name> 
        <tag-class>cn.haha.tag.IfTag</tag-class> 
        <body-content>scriptless</body-content>
        <!--部署属性-->
        <attribute> 
            <name>test</name> <!--属性名-->
            <required>true</required> <!--属性是否为必须的-->
            <rtexprvalue>true</rtexprvalue> <!--属性值是否可以为EL或JSTL等-->
        </attribute> 
    </tag>
    
    展开全文
  • 学会jsp环境的安装与配置,jsp基础,jsp的9大内置对象应用,servlet技术,几种乱码处理方法;javabean,数据库操作,连接池,自定义标签,标准标签库,监听器和过滤器,文件上传,分页技术,MVC开发模式应用,投票...
  • package com.neuedu.servlet; import com.neuedu.domain.questioninfo; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet;...import ja
  • 详细题目描述可参照博客内文章。。。。。。。。。。。。。。。。。。。。。
  • 自己做的,毕业设计。能够根据教师的考试指令...在线利用JS评出选择填空判断的成绩。 后期再由教师评卷,给出简答题 分数,以致最后得出一个学生的分数。...文件内有任务书 如果资源无法打开,请在rar前面手动添加个1....
  • JSP和Servlet练习题

    千次阅读 2019-08-09 19:23:19
    1、 请简单描述访问一个JSP页面时的执行流程? 访问一个JSP页面时,首先服务器将JSP文件翻译成Java文件,然后把Java文件编译成class文件。服务器实例化该类对象,接收客户端的请求数据,调用类中的_jspService方法...
  • Servlet题库

    2016-11-14 19:40:00
    一、 填空题 Servlet中使用Session对象的步骤为:调用 HttpServletRequest.getSession() 得到Session对象,查看Session对象,在会话中保存数据 ... 用户可以有多种方式请求Servlet,如 浏览器直接调用,页面form中...
  • jsp简介及工作原理

    万次阅读 2017-08-05 07:52:30
    什么是jsp JSP全名为Java Server Pages,中文名叫java服务器页面,是一种动态页面技术,逻辑从servlet中分离出来。在传统的网页HTML(标准通用标记语言的子集)文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP...
  • jsp常用知识点总结

    万次阅读 多人点赞 2015-09-18 19:19:15
    JSP常用知识点总结 JSP 定义: 1)Java Server Page, Java EE 组件,本质上是 Servlet。 2)运行在 Web Container.接收 Http Request,生成 Http Response(默认协议是 Http 请求和响应) .............................
  • 解决eclipse编辑jsp、js文件时,经常出现卡死的问题

    万次阅读 多人点赞 2019-07-31 19:20:50
    使用Eclipse编辑jsp、js文件时,经常出现卡死现象,解决方法如下: 1、取消验证 windows–>perferences–>validation 把 除了manual 下面的全部点掉,build下只留 classpath dependency Validator。 其实...
  • springboot返回html和jsp

    万次阅读 2018-07-04 09:32:04
    一、返回html(1)添加maven依赖&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-thymeleaf...(2)thymelea...
  • jsp+servlet实现简单登录页面功能Demo

    万次阅读 多人点赞 2018-05-28 17:55:16
    1 [转载请联系本人]实现功能:模拟简单登录功能,登录成功跳转新页面,登录失败在原登录界面提示登录失败信息开发环境:eclipseTomcat-8.0预备知识:HTML标签,Servlet相关知识——请求的转发与重定向,jsp相关知识...
  • jsp从数据库读取数据显示到jsp页面

    万次阅读 多人点赞 2018-04-17 10:38:06
    整个项目结构,jar包可网上下载导入package ... import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;...import java.sql.SQLException;...im...
  • JSP + Servlet + JDBC + Mysql 实现增删改查

    万次阅读 多人点赞 2018-04-24 20:56:24
    Servlet是一个特殊的Java程序,它运行于服务器的JVM中,能够依靠服务器的支持...JSP本质上是Servlet的一种简易形式,JSP会被服务器处理成一个类似于Servlet的Java程序,可以简化页面内容的生成。 Servlet和JSP最主...
  • JSP技术简介

    万次阅读 2018-04-13 19:05:09
    1 JSP技术的特征 JSP技术所开发的web应用程序是基于Java的,它拥有Java跨平台的特性,以及业务代码分离,组建重用,基础Java servlet功能和预编译功能。 1)跨平台 由于JSP是基于Java语言的,因而它可以使用Java...
  • JSP九大内置对象

    万次阅读 多人点赞 2019-02-28 15:52:26
    JSP提供了由容器实现和管理的内置对象,也可以称之为隐含对象,由于JSP使用Java作为脚本语言,所以JSP将具有强大的对象处理能力,并且可以动态创建Web页面内容。但Java语法在使用一个对象前,需要先实例化这个对象,...
  • JSP实现简单的用户登录和注册

    万次阅读 多人点赞 2018-11-20 12:34:39
    实验环境:Tomcat 9.0,MySQL 8.0,JDBC 8.0; 实验方法,利用连接池连接MySQL进行操作 首先创建一个Dynamic Web Project 1.连接池的创建 在&amp;nbsp;WebContent&amp;nbsp;目录下的&...xml ve...
  • 如何将一个jsp页面嵌套在另一个页面中 这个在做网页中常要用到,有些通用的内容可集中放在一个页面文件中,其它要用到这些内容的页面只需要包含(引用)这个通用文件即可。这样便于维护,如果有很多网页,当通用内容...
  • Jsp技术总结

    万次阅读 多人点赞 2016-04-29 10:45:40
    这节我们总结一下Jsp的相关技术。 1. 什么是JSP  JSP即Java Server Pages,它和servlet技术一样,都是sun公司定义的一种用于开发动态web资源的技术。该技术的最大特点在于:写JSP就像写html,但它相比html而言,...
  • jsp案例之输出九九乘法表(仅使用jsp脚本元素)

    万次阅读 多人点赞 2015-01-27 17:56:12
    JSP案例:使用JSP输出99乘法表,要求仅使用脚本元素。代码如下: JSP练习使用JSP脚本元素输出九九乘法表 九九乘法表 for(int i = 1; i ; i++){ //行 %> <%
  • JSP实现简易购物商城

    万次阅读 多人点赞 2018-03-22 19:47:24
    一周前开始上手JSP,完成的第一个小项目:简易购物商城+购物车 效果图如下: 具体实现代码如下: javabean: MyTools.java(工具类,解决中文乱码问题和string转int) package com.toolbean; import java....
  • 浅谈jsp、freemarker、velocity区别

    万次阅读 多人点赞 2013-11-18 13:51:37
    听说jsp要淘汰,也不知道是真是假,但本人还是比较喜欢jsp的,下面是网上查找的javaweb项目页面3种技术的区别。 在java领域,表现层技术主要有三种:jsp、freemarker、velocity。 jsp是大家最熟悉的技术 优点: 1...
  • jsp中文乱码现象解决办法

    万次阅读 多人点赞 2018-04-04 15:49:35
    之前总是碰到JSP页面乱码的问题,每次都是现在网上搜,然后胡乱改,改完也不明白原因。这次正好作下总结,中文乱码就是因为编码不符,可能出现乱码有四个地方:1 JSP编码乱码2 HTML编码乱码3 request获取数据乱码4 ...
  • JSP入门

    万次阅读 2016-01-07 20:05:13
    JSP入门 基本概述  JSP全名为Java Server Pages,中文名叫java服务器页面,其根本是一个简化的Servlet设计,它是由Sun公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术,它是在...
  • jsp语法与jsp基本知识点

    千次阅读 2016-04-27 01:38:58
    jsp基本知识点】 JSP全称是Java Server Pages,它和servlet技术一样,都是SUN公司定义的一种用于开发动态web资源的技术。 JSP/Servlet规范。 JSP实际上就是Servlet JSP这门技术的最大的特点在于,写jsp就像在写html...
  • 基于JSP+Servlet的学生宿舍管理系统

    千次阅读 2019-07-14 21:10:48
    使用JSP+Servlet技术并采用MVC架构的思想实现一个学生宿舍管理系统, 实现学生信息资源的IT化管理 运行环境 jdk1.8,tomcat8.5,mysql5.6,EclispseEE 项目技术 jsp, servlet, bootstrap, jsp, jquery 实现功能 管理员...

空空如也

1 2 3 4 5 ... 20
收藏数 991,930
精华内容 396,772
关键字:

jsp