精华内容
下载资源
问答
  • java和JSP和JavaScript区别

    千次阅读 2015-05-26 19:31:38
    JSP全称是:java server page,意思是基于JAVA服务器的网页技术,跟asp,php一样,都是网页制作用的语言 JavaScript:也成为JS,跟JAVA没啥关系,就是赶时髦起个这名字,是一种脚本语言,嵌套在网页中实现各种功能的...
    JSP全称是:java server page,意思是基于JAVA服务器的网页技术,跟asp,php一样,都是网页制作用的语言
    
    JavaScript:也成为JS,跟JAVA没啥关系,就是赶时髦起个这名字,是一种脚本语言,嵌套在网页中实现各种功能的,比如禁止右键菜单,禁止复制什么的
    
    JSP,ASP,PHP都能嵌套使用JavaScript
    展开全文
  • JavaJSP和Servlet基础知识。

    万次阅读 2016-06-24 01:06:12
    JSPJava Server Pager的简称。由SUN倡导并联合其它公司创建。 JSP是一门脚本语言 JSP可以嵌入到HTML中 JSP拥有Java语言的所有特性 面向对象、健壮、多线程、安全、可移植、高性能 JSP运行于JSP容器中Tomcat、Jetty...

    JSP基础

    JSP起源

    JSP,Java Server Pager的简称。由SUN倡导并联合其它公司创建。

    JSP是一门脚本语言

    JSP可以嵌入到HTML中

    JSP拥有Java语言的所有特性

    面向对象、健壮、多线程、安全、可移植、高性能

    JSP运行于JSP容器中

    Tomcat、Jetty等。

    JSP会被转换成Servlet

    JSP->Servlet->Class文件。

    Mac下常用shell命令:

    pwd 打印当前目录
    ls 列出当前目录下的所有文件目录
    cd 更改目录
    .代表当前工作目录
    ..代表上一级目录
    ~代表用户根目录
    chmod更改权限

    JSP基本语法

    <% %> JSP代码段,可以输入任意的Java语言片段。
    <%! %> JSP声明,在JSP页面范围声明变量、函数和类。
    <%= %> JSP表达式
    JSP中HTML注释:

    <!-- -->
    <!-- <% %>--> 

    <%-- --%> JSP注释,不会被客户端浏览器看到。

    JSP编译指令

    通知Servlet引擎处理消息,它只在JSP程序被转化成Servlet的过程中起作用。

    Page指令

    在JSP最上方,用于指定语言,MIME,编码,错误跳转页面等等。
    1. contentType指定MIME和网页编码,无859.
    2. import导入多个java类,也可以使用多个page导入多个java类。
    3. errorPage表示JSP页面发生运行时错误跳转的页面。

    <%@ page contentType="text/html;charset=UTF-8" language="java" import="java.util.ArrayList,java.util.LinkedList"
    errorPage="err.jsp"%>

    include指令

    静态包含指令,可将外部文件包含进来。包含JSP文件时,不能有重复的变量声明。
    被导入的JSP编译指令会起作用。

    <%@ include file="header.jsp"%>

    taglib指令

    JSP动作指令

    客户端请求时动态执行的指令

    forward指令

    重定向指令,它下面的代码不会被执行,不会被返回到客户端。
    可以通过jsp:param指令向跳转的JSP页面传递参数。在目标JSP页面中通过request.getParameter()方法接收参数。

    <jsp:forward page="err.jsp">
      <jsp:param name="name" value="bendeng"></jsp:param>
      <jsp:param name="pass" value="8765432"></jsp:param>
    </jsp:forward>

    include指令

    动态包含指令,包含静态HTML和动态JSP文件。
    被导入的JSP编译指令不会起作用,并可以额外加参数。

    <jsp:include page="body.jsp">
        <jsp:param name="bgcolor" value="red"></jsp:param>
    </jsp:include>

    在被包含的JSP文件中通过request对象将body背景色修改为传过去的值。

    <body bgcolor="<%=request.getParameter("bgcolor")%></body>

    useBean指令

    JavaBean:一个公开的构造函数、属性有get、set方法、可序列化。
    例如:我们在接收提交的页面的,使用User这个bean,然后使用useBean指令配合setProperty、getProperty指令来接收显示提交内容:
    提交页面如下:

    <form action="regist.jsp" method="post">
    用户名:<input type="text" name="name"/><br>
    密码:<input type="password" name="pass"/><br>
    <input type="submit" value="提交"/>

    接受页面如下:

    <jsp:useBean id="user" class="com.ben.bean.User"></jsp:useBean>
    <jsp:setProperty property="name" name="user"></jsp:setProperty>
    <jsp:setProperty property="pass" name="user"></jsp:setProperty>
    
    <jsp:getProperty property="name" name="user"></jsp:getProperty>
    <jsp:getProperty property="pass" name="user"></jsp:getProperty>

    JSP内置对象

    out对象

    向客户端浏览器输出信息

    <%
    out.println("out对象");
    out.newLine();
    out.println("<br>");
    out.flush();
    out.clearBuffer();//清空缓冲区的数据
    //out.clear();//也是清空缓冲区数据,不同的是如果之前调用flush,则会抛出异常。
    out.println("缓冲区大小:" + out.getBufferSize());//默认8K,可通过编译指令修改,如:<%@ page buffer="16kb" %>
    out.println("<br>");
    out.println("当前缓冲区剩余大小:" + out.getRemaining());
    %>

    request对象

    request对象封装了客户端提交到服务器的请求信息,表单、cookie等信息。

    请求的方法名:<%=request.getMethod() %><br/>//GET
    请求的资源:<%=request.getRequestURI() %><br/>
    请求使用的协议:<%=request.getProtocol() %><br/>//HTTP/1.1
    请求的服务器IP:<%=request.getServerName() %><br/>
    请求的服务器端口:<%=request.getServerPort() %><br/>
    客户端的IP地址:<%=request.getRemoteAddr() %><br/>
    客户端的主机名:<%=request.getRemoteHost() %><br/>
    getRequestURL:<%=request.getRequestURL() %><br/>
    getScheme:<%=request.getScheme() %>//Http
    
    //request.getParameter()  用于从客户端请求获取表单信息
    
    request.setAttribute();
    request.getAttribute();
    这两个方法用于在web组件间共享信息,比如JSP之间。
    
    请求头信息;
    <% 
    Enumeration<String> e = request.getHeaderNames();
    while(e.hasMoreElements()){
        String headerName = e.nextElement();
        out.println(headerName+":"+request.getHeader(headerName)+"<br/>");
    }
    %>

    response对象

    对客户端请求封装回复信息。

    response.setHeader("Cache-Control", "no-cache");//浏览器读到这个头信息,就不会将网页信息存到缓存。还有public,private等
    response.setIntHeader("Refresh", 2);//每隔2秒刷新一次
    //response.sendRedirect("index.jsp");//重定向到另一个JSP网页
    //设置Cookie
    Cookie cookie = new Cookie("ben","deng");
    cookie.setMaxAge(3600);//单位为s
    response.addCookie(cookie);

    session对象

    HTTP是无状态的。服务器使用session可以保存客户端浏览器的信息。

    <%! SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); %>
    sessionId= <%=session.getId() %></br>
    session创建时间= <%=sdf.format(new Date(session.getCreationTime())) %></br>
    session最后访问时间= <%=sdf.format(new Date(session.getLastAccessedTime())) %></br>
    session失效时间: <%= session.getMaxInactiveInterval()%>//默认1800s

    session失效时间可以通过修改部署描述符来实现。

    <session-config>
        <session-timeout>10</session-timeout>
    </session-config>

    如果不生效,需要删掉work目录的文件。

    application对象

    应用一启动就会生成application对象。web应用不关闭,application就一直存在。
    servlet的环境通过调用getServletConfig().getContext()方法获得。作用域是application(整个程序运行期)。它提供了关于服务器版本,应用级初始化参数和应用内资源绝对路径,注册信息的方式。

    服务器信息:<%=application.getServerInfo() %>
    应用信息:<%=application.getServletContextName() %>
    主机信息:<%=application.getVirtualServerName() %>

    由于Application对象是随应用的生命周期存在,所以通过它可以对一些配置进行全局加载和存储。

    config对象

    代表当前JSP程序的配置信息。一般JSP在应用中作为View层使用,一般使用较少,在Servlet中用的比较多。读取的配置信息来自web.xml。

    <%=config.getInitParameter("name") %>

    在web.xml中配置一个servlet:

    <servlet>
        <servlet-name>config</servlet-name>
        <jsp-file>/jsp/config.jsp</jsp-file>
        <init-param>
            <param-name>name</param-name>
            <param-value>name</param-value>
        </init-param>
        <init-param>
            <param-name>pass</param-name>
            <param-value>pass</param-value>
        </init-param>
      </servlet>
      <servlet-mapping>
        <servlet-name>config</servlet-name>
        <url-pattern>/*</url-pattern><!--这个样式所有请求都会返回config.jsp的内容 -->
      </servlet-mapping>

    在config.jsp中,使用

    String name = config.getInitParameter("name"); 
    String pass = config.getInitParameter("pass"); 

    取出配置在web.xml中的信息。

    exception对象

    exception对象只有在page指令中具有属性isErrorPage="true"时才有效。它就是Java中普通的Throwable对象。
    通过JSP错误页面中一个catch块已经益出但没有捕获的java.lang.Throwable的任意实例,传向了errorPage的URI。
    比如在indx.jsp中运行如下代码

    <%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"
     errorPage="exception.jsp"%>
    try{
            int c = 3/0;
        }catch(Exception e){
    
        }

    在exception.jsp中:

    <% 
        out.print(exception.getLocalizedMessage());
    %>

    页面输出/ by zero

    page对象

    继承自Object对象,代表当前JSP页面。

    pageContext对象。

    pageContext对象提供所有四个作用域层次的属性查询和修改能力,它也提供了转发请求到其它资源和包含其他资源的方法。该对象的方法都是抽象方法。

    JSP作用域

    作用域规定的是变量的有效期限。JSP有四大作用域:Request、Page、Session、Application。
    我们使用public Object getAttribute(String name)获得变量值,
    使用public void setAttribute(String name, Object value)将变量值保存到对应作用域中。

    对象说明类型作用域
    request请求对象javax.servlet.ServletRequestRequest
    response响应对象javax.servlet.SrvletResponsePage
    pageContext页面上下文对象javax.servlet.jsp.PageContextPage
    session会话对象javax.servlet.http.HttpSessionSession
    application应用程序对象javax.servlet.ServletContextApplication
    out输出对象javax.servlet.jsp.JspWriterPage
    config配置对象javax.servlet.ServletConfigPage
    page页面对象javax.lang.ObjectPage
    exception异常对象javax.lang.Throwablepage

    如果把变量放到pageContext里,就说明它的作用域是page,它的有效范围只在当前jsp页面里。
    从把变量放到pageContext开始,到jsp页面结束,你都可以使用这个变量。
      
    如果把变量放到request里,就说明它的作用域是request,它的有效范围是当前请求周期。
    所谓请求周期,就是指从http请求发起,到服务器处理结束,返回响应的整个过程。在这个过程中可能使用forward的方式跳转了多个jsp页面,在这些页面里你都可以使用这个变量。

    如果把变量放到session里,就说明它的作用域是session,它的有效范围是当前会话。
    所谓当前会话,就是指从用户打开浏览器开始,到用户关闭浏览器这中间的过程。这个过程可能包含多个请求响应。也就是说,只要用户不关浏览器,服务器就有办法知道这些请求是一个人发起的,整个过程被称为一个会话(session),而放到会话中的变量,就可以在当前会话的所有请求里使用。

    如果把变量放到application里,就说明它的作用域是application,它的有效范围是整个应用。
    整个应用是指从应用启动,到应用结束。我们没有说“从服务器启动,到服务器关闭”,是因为一个服务器可能部署多个应用,当然你关闭了服务器,就会把上面所有的应用都关闭了。

    application作用域里的变量,它们的存活时间是最长的,如果不进行手工删除,它们就一直可以使用。
    与上述三个不同的是,application里的变量可以被所有用户共用。如果用户甲的操作修改了application中的变量,用户乙访问时得到的是修改后的值。这在其他scope中都是不会发生的,page, request,session都是完全隔离的,无论如何修改都不会影响其他人的数据。

    初识Servlet

    Servlet = Server + Applet。它是一个特殊的Java类。
    下面新建一个Servlet:

    public class Hello extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //super.doGet(req, resp);
            PrintWriter pw = resp.getWriter();
            pw.println("Hello Servlet");
            pw.close();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //super.doPost(req, resp);
            doGet(req,resp);
        }
    
        @Override
        public void init() throws ServletException {
            System.out.println("hello init()");
            super.init();
        }
    
        @Override
        public void destroy() {
            System.out.println("hello destroy()");
            super.destroy();
        }
    }

    在web.xml中进行配置:

    <servlet>
            <servlet-name>hello</servlet-name>
            <servlet-class>com.ben.servlet.Hello</servlet-class>
    </servlet>
    <servlet-mapping>
            <servlet-name>hello</servlet-name>
            <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    使用tomcat,进行运行。localhost:8080/hello,即可显示Hello Servlet。我是在IDEAIU中进行的,如果在Eclipse中路径可能有变化,需要加工程名。

    如果浏览器出现HTTP Status 405 - HTTP method GET is not supported by this URL,注释掉doGet和doPost的父类调用即可。

    Servlet处理流程

    Servlet-Process
    客户端浏览器发出一个请求,tomcat内置web Server接收到请求,将请求转达给Servlet容器,Servlet容器会加载Servlet实例。Servlet使用HttpServletRequest接收请求实例,Servlet可能会将请求转发给其它的Servlet处理。全部处理完,请求结果通过HttpServletResponse对象返回给浏览器。

    当Servlet装载和实例化以后,Servlet会调用init()方法,进行初始化。Servlet处于服务状态。在整个生命周期中,init()执行一次。接收请求时,会调用service()方法,当Servlet不再使用,容器销毁Servlet之前会调用destroy()方法。destroy()方法中做一些资源释放和日志输出的操作。
    init()不需要重载,只在需要初始化时做一些操作时才需要重载,建议重载无参的init()方法,不用调用super.init()方法,有参的init()必须调用父类的init()方法。

    使用Servlet实现简单的登陆

    login.jsp如下:

    <form method="post" action="<%=request.getContextPath()%>/login">
        <input name="username" type="text" placeholder="用户名"/><br/>
        <input name="password" type="password" placeholder="密码"/><br/>
        <input type="submit" value="登陆">
        <input type="reset" value="重置">
    </form>

    新建一个LoginServlet:

    public class LoginServlet extends HttpServlet {
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            String username = req.getParameter("username");
            String password = req.getParameter("password");
    
            //System.out.println("用户名=" + username);
            //System.out.println("密码=" + password);
    
            String forward = null;
            //这里简单判断用户名来跳转成功和失败页面
           if("ben.deng".equals(username)){
               forward = "success.jsp";
               //这种跳转不会带请求的参数信息,只在响应头中的location中指定了跳转页面。但可以进入其他应用的页面
               //resp.sendRedirect("success.jsp");
           }else{
               forward = "fail.jsp";
               //resp.sendRedirect("fail.jsp");
           }
            //请求转发,可以请求参数带给转发的页面。但只限于应用内的页面。
            RequestDispatcher dispatcher = req.getRequestDispatcher(forward);
            dispatcher.forward(req,resp);
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           doPost(req,resp);
        }
    
        @Override
        public void init() throws ServletException {
            System.out.println("login init()");
        }
    }

    web.xml配置:

    <servlet>
            <servlet-name>login</servlet-name>
            <servlet-class>com.ben.servlet.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
            <servlet-name>login</servlet-name>
            <url-pattern>/login</url-pattern>
    </servlet-mapping>

    Servlet过滤器

    创建一个过滤器:

    public class MyFilter implements Filter {
    
        public void destroy() {
        }
    
        public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
            System.out.println("doFilter...");
            chain.doFilter(req, resp);
        }
    
        public void init(FilterConfig config) throws ServletException {
            System.out.println("filter init():" + config.getInitParameter("paramKey"));
        }
    
    }

    和Servlet一样,需要在web.xml中配置:

    <filter>
            <filter-name>MyFilter</filter-name>
            <filter-class>com.ben.filter.MyFilter</filter-class>
            <init-param>
                <param-name>paramKey</param-name>
                <param-value>paramValue</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>MyFilter</filter-name>
            <url-pattern>/*</url-pattern>
    </filter-mapping>

    在一个web应用中,可以有多个Filter,多个Filter的执行顺序是和web.xml中配置的顺序是一致的。

    过滤器之编码转换

    在doGet或doPost方法中返回一串有中文的字符串,浏览器很多时候会显示乱码。这时我们可以在过滤器中进行处理。

     String charEncoding = "UTF-8";
     public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
            if(!charEncoding.equals(req.getCharacterEncoding())){
                req.setCharacterEncoding(charEncoding);
            }
            resp.setCharacterEncoding(charEncoding);
            chain.doFilter(req, resp);
        }

    过滤器之权限校验

    新建一个权限校验过滤器:

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
            HttpServletRequest request = (HttpServletRequest) req;
            String loginStatus = (String) request.getSession().getAttribute("login");
            if (loginStatus != null && "success".equals(loginStatus)) {
                chain.doFilter(req, resp);
            } else {
                String reqPath = request.getServletPath();
                if (!reqPath.contains("login")) {
                    //System.out.println("您尚未登陆");
                    RequestDispatcher rd = request.getRequestDispatcher("login.jsp");
                    rd.forward(req, resp);
                }else{
                    chain.doFilter(req, resp);
                }
            }
        }

    在部署描述符中注册过滤器:

    <filter>
            <filter-name>AuthFilter</filter-name>
            <filter-class>com.ben.filter.AuthFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>AuthFilter</filter-name>
            <url-pattern>/*</url-pattern>
    </filter-mapping>

    上述代码示例中是将登陆成功后再session中设置一个login属性为success,在其他非login/login.jsp等页面中判断是否有这个session,没有或值不对(比如登录失败设置的其他值),则要求跳转到登录界面。从而实现一个简单的权限校验过滤。

    展开全文
  • JSPJava Server Pages(Java服务器页面)

    千次阅读 2018-09-27 12:42:44
    JSP全称Java Server Pages,是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以&lt;%开头以%&gt;结束。 JSP是一种Javaservlet(服务器小程序),主要用于实现Javaweb应用程序的用户...

    JSP 简介
    什么是Java Server Pages(Java服务器页面)?
    JSP全称Java Server Pages,是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。
    JSP是一种Javaservlet(服务器小程序),主要用于实现Javaweb应用程序的用户界面部分。网页开发者们通过结合HTML代码、XHTML代码、XML元素以及嵌入JSP操作和命令来编写JSP。
    JSP通过网页表单获取用户输入数据、访问数据库及其他数据源,然后动态地创建网页。
    JSP标签有多种功能,比如访问数据库、记录用户选择信息、访问JavaBeans组件等,还可以在不同的网页中传递控制信息和共享信息。
    http:/ /www.iis7.com/b/plc/
    。。。
    为什么使用JSP?
    JSP程序与CGI(公共网关接口)程序有着相似的功能,但和CGI程序相比,JSP程序有如下优势:
    -性能更加优越,因为JSP可以直接在HTML网页中动态嵌入元素而不需要单独引用CGI文件。
    -服务器调用的是已经编译好的JSP文件,而不像CGI/Perl那样必须先载入解释器和目标脚本。
    -JSP基于Java Servlets API,因此,JSP拥有各种强大的企业级Java API,包括JDBC,JNDI,EJB,JAXP等等。
    -JSP页面可以与处理业务逻辑的servlets一起使用,这种模式被Java servlet 模板引擎所支持。
    最后,JSP是Java EE不可或缺的一部分,是一个完整的企业级应用平台。这意味着JSP可以用最简单的方式来实现最复杂的应用。
    。。。
    JSP的优势
    以下列出了使用JSP带来的其他好处:
    -与ASP相比:JSP有两大优势。首先,动态部分用Java编写,而不是VB或其他MS专用语言,所以更加强大与易用。第二点就是JSP易于移植到非MS平台上。
    -与纯 Servlets相比:JSP可以很方便的编写或者修改HTML网页而不用去面对大量的println语句。
    -与SSI相比:SSI无法使用表单数据、无法进行数据库链接。
    -与JavaScript相比:虽然JavaScript可以在客户端动态生成HTML,但是很难与服务器交互,因此不能提供复杂的服务,比如访问数据库和图像处理等等。
    -与静态HTML相比:静态HTML不包含动态信息。
    ::::::::::::::::::::::::::::::::::::::::
    JSP 开发环境搭建
    JSP开发环境是您用来开发、测试和运行JSP程序的地方。
    我们来搭建JSP开发环境,具体包括以下几个步骤:

    1. 配置Java开发工具(JDK)
      这一步涉及Java SDK的下载和PATH环境变量的配置。
      您可以从Oracle公司的Java页面中下载SDK:Java SE Downloads(JavaSE下载)
      JavaSDK下载完后,请按照给定的指示来安装和配置SDK。最后,通过设置PATH和JAVA_HOME环境变量来指明包括java和javac的文件夹路径,通常是java_install_dir/bin和java_install_dir。
      假如您用的是Windows系统并且SDK的安装目录为C::\jdk1.5.0_20,那么您就需要在 C:\autoexec.bat 文件中添加以下两行:
      set PATH=C:\jdk1.5.0_20\bin;%PATH%
      set JAVA_HOME=C:\jdk1.5.0_20
      或者,在Windows NT/2000/XP下,您可以直接右击我的电脑图标,选择属性,然后高级,然后环境变量,接下来您就可以很方便地设置PATH变量并且确定退出就行了。
      在Linux/Unix系统下,如果SDK的安装目录为/usr/local/jdk1.5.0_20并且使用的是C shell,那么您就需要在.cshrc文件中添加以下两行:
      setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
      setenv JAVA_HOME /usr/local/jdk1.5.0_20
      或者,假如您正在使用类似于Borland JBuilder、Eclipse、IntelliJ IDEA和Sun ONE Studio这样的集成开发环境,可以试着编译并运行一个简单的程序来确定IDE(集成开发环境)是否已经知道 SDK的安装目录。
    2. 设置Web服务器:Tomcat
      目前,市场上有很多支持JSP和Servlets开发的Web服务器。他们中的一些可以免费下载和使用,Tomcat就是其中之一。
      Apache Tomcat是一个开源软件,可作为独立的服务器来运行JSP和Servlets,也可以集成在 Apache Web Server中。以下是Tomcat的配置方法:
      下载最新版本的Tomcat:http://tomcat.apache.org/。
      下载完安装文件后,将压缩文件解压到一个方便的地方,比如Windows下的C:\apache-tomcat-5.5.29目录或者Linux/Unix下的/usr/local/apache-tomcat-5.5.29目录,然后创建CATALINA_HOME环境变量指向这些目录。
      在Windows机器下,Tomcat可以通过执行以右命令来启动:%CATALINA_HOME%\bin\startup.bat 或者 C:\apache-tomcat-5.5.29\bin\startup.bat
      在Linux/Unix机器下,Tomcat可以通过执行以右命令来启动: C A T A L I N A H O M E / b i n / s t a r t u p . s h 或 者 / u s r / l o c a l / a p a c h e − t o m c a t − 5.5.29 / b i n / s t a r t u p . s h 成 功 启 动 T o m c a t 后 , 通 过 访 问 h t t p : / / l o c a l h o s t : 8080 / 便 可 以 使 用 T o m c a t 自 带 的 一 些 w e b 应 用 了 。 在 W i n d o w s 机 器 下 , T o m c a t 可 以 通 过 执 行 以 下 命 令 来 停 止 : 在 L i n u x / U n i x 机 器 下 , T o m c a t 可 以 通 过 执 行 以 下 命 令 来 停 止 : CATALINA_HOME/bin/startup.sh 或者 /usr/local/apache-tomcat-5.5.29/bin/startup.sh 成功启动Tomcat后,通过访问http://localhost:8080/便可以使用Tomcat自带的一些web应用了。 在Windows机器下,Tomcat可以通过执行以下命令来停止:%CATALINA_HOME%\bin\shutdown 或者 C:\apache-tomcat-5.5.29\bin\shutdown 在Linux/Unix机器下,Tomcat可以通过执行以下命令来停止: CATALINAHOME/bin/startup.sh/usr/local/apachetomcat5.5.29/bin/startup.shTomcat访http://localhost:8080/便使TomcatwebWindowsTomcatLinux/UnixTomcatCATALINA_HOME/bin/shutdown.sh 或者 /usr/local/apache-tomcat-5.5.29/bin/shutdown.sh
    3. 设置CLASSPATH环境变量
      由于servlets不是Java SE的一部分,所以您必须标示出servlet类的编译器。
      假如您用的是Windows机器,您需要在C:\autoexec.bat文件中添加以下两行:
      set CATALINA=C:\apache-tomcat-5.5.29
      set CLASSPATH=%CATALINA%\common\lib\jsp-api.jar;%CLASSPATH%
      或者,在Windows NT/2000/XP下,您只要右击我的电脑,选择属性,然后点击高级,然后点击环境变量,接下来便可以设置CLASSPATH变量并且确定退出即可。
      在Linux/Unix机器下,假如您使用的是C shell,那么您就需要在.cshrc文件中添加以下两行:
      setenv CATALINA=/usr/local/apache-tomcat-5.5.29
      setenv CLASSPATH C A T A L I N A / c o m m o n / l i b / j s p − a p i . j a r : CATALINA/common/lib/jsp-api.jar: CATALINA/common/lib/jspapi.jar:CLASSPATH
      注意:如果您的开发路径是C:\JSPDev (Windows)或者 /usr/JSPDev (Linux/Unix),那么您就需要将这些路径添加进CLASSPATH变量中。
      ::::::::::::::::::::::::::::::::::::::::::::::::::::::
      Eclipse JSP/Servlet 环境搭建
      我们可以使用 Eclipse 来搭建 JSP 开发环境,首先我们分别下载一下软件包:
      Eclipse J2EE:http://www.eclipse.org/downloads/
      Tomcat:http://tomcat.apache.org/download-70.cgi
      。。。
      Tomcat 下载安装
      你可以根据你的系统下载对应的包(以下以Window系统为例):
      注意目录名不能有中文和空格。目录介绍如下:
      bin:二进制执行文件。里面最常用的文件是startup.bat,如果是 Linux 或 Mac 系统启动文件为 startup.sh
      conf:配置目录。里面最核心的文件是server.xml。可以在里面改端口号等。默认端口号是8080,也就是说,此端口号不能被其他应用程序占用。
      lib:库文件。tomcat运行时需要的jar包所在的目录
      logs:日志
      temp:临时产生的文件,即缓存
      webapps:web的应用程序。web应用放置到此目录下浏览器可以直接访问
      work:编译以后的class文件。
      接着我们可以双击 startup.bat 启动 Tomcat
      这个时候,本地的服务器就已经搭建起来了。如果想关闭服务器,可以直接关闭上面的窗口,或者在里面输入Ctrl+C禁止服务。
      接着我们在浏览器中输入 http://localhost:8080/,表示tomcat安装成功并且启动起来了
      ::::::::::::::::::::::::::::::::::::::::::::::::
      JSP 结构
      网络服务器需要一个JSP引擎,也就是一个容器来处理JSP页面。容器负责截获对JSP页面的请求。本教程使用内嵌JSP容器的Apache来支持JSP开发。
      JSP容器与Web服务器协同合作,为JSP的正常运行提供必要的运行环境和其他服务,并且能够正确识别专属于JSP网页的特殊元素。
      。。。
      JSP处理
      以下步骤表明了Web服务器是如何使用JSP来创建网页的:
      -就像其他普通的网页一样,您的浏览器发送一个HTTP请求给服务器。
      -Web服务器识别出这是一个对JSP网页的请求,并且将该请求传递给JSP引擎。通过使用URL或者.jsp文件来完成。
      -JSP引擎从磁盘中载入JSP文件,然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句,并且将所有的JSP元素转化成Java代码。
      -JSP引擎将servlet编译成可执行类,并且将原始请求传递给servlet引擎。
      -Web服务器的某组件将会调用servlet引擎,然后载入并执行servlet类。在执行过程中,servlet产生HTML格式的输出并将其内嵌于HTTP response中上交给Web服务器。
      -Web服务器以静态HTML网页的形式将HTTP response返回到您的浏览器中。
      -最终,Web浏览器处理HTTP response中动态产生的HTML网页,就好像在处理静态网页一样。
      一般情况下,JSP引擎会检查JSP文件对应的servlet是否已经存在,并且检查JSP文件的修改日期是否早于servlet。如果JSP文件的修改日期早于对应的servlet,那么容器就可以确定JSP文件没有被修改过并且servlet有效。这使得整个流程与其他脚本语言(比如PHP)相比要高效快捷一些。
      总的来说,JSP网页就是用另一种方式来编写servlet而不用成为Java编程高手。除了解释阶段外,JSP网页几乎可以被当成一个普通的servlet来对待。
      :::::::::::::::::::::::::::::::::::::::::::::::
      JSP 生命周期
      理解JSP底层功能的关键就是去理解它们所遵守的生命周期。
      JSP生命周期就是从创建到销毁的整个过程,类似于servlet生命周期,区别在于JSP生命周期还包括将JSP文件编译成servlet。
      以下是JSP生命周期中所走过的几个阶段:
      编译阶段:servlet容器编译servlet源文件,生成servlet类
      初始化阶段:加载与JSP对应的servlet类,创建其实例,并调用它的初始化方法
      执行阶段:调用与JSP对应的servlet实例的服务方法
      销毁阶段:调用与JSP对应的servlet实例的销毁方法,然后销毁servlet实例
      。。。
      JSP编译
      当浏览器请求JSP页面时,JSP引擎会首先去检查是否需要编译这个文件。如果这个文件没有被编译过,或者在上次编译后被更改过,则编译这个JSP文件。
      编译的过程包括三个步骤:
      解析JSP文件。
      将JSP文件转为servlet。
      编译servlet。
      。。。
      JSP初始化
      容器载入JSP文件后,它会在为请求提供任何服务前调用jspInit()方法。如果您需要执行自定义的JSP初始化任务,复写jspInit()方法就行了,就像下面这样:
      public void jspInit(){
      // 初始化代码
      }
      一般来讲程序只初始化一次,servlet也是如此。通常情况下您可以在jspInit()方法中初始化数据库连接、打开文件和创建查询表。
      。。。
      JSP执行
      这一阶段描述了JSP生命周期中一切与请求相关的交互行为,直到被销毁。
      当JSP网页完成初始化后,JSP引擎将会调用_jspService()方法。
      _jspService()方法需要一个HttpServletRequest对象和一个HttpServletResponse对象作为它的参数,就像下面这样:
      void _jspService(HttpServletRequest request,HttpServletResponse response)
      {
      // 服务端处理代码
      }
      _jspService()方法在每个request中被调用一次并且负责产生与之相对应的response,并且它还负责产生所有7个HTTP方法的回应,比如GET、POST、DELETE等等。
      。。。
      JSP清理
      JSP生命周期的销毁阶段描述了当一个JSP网页从容器中被移除时所发生的一切。
      jspDestroy()方法在JSP中等价于servlet中的销毁方法。当您需要执行任何清理工作时复写jspDestroy()方法,比如释放数据库连接或者关闭文件夹等等。
      jspDestroy()方法的格式如下:
      public void jspDestroy()
      {
      // 清理代码
      }
      :::::::::::::::::::::::::::::::::::::::::
      JSP 语法
      。。。
      脚本程序
      脚本程序可以包含任意量的Java语句、变量、方法或表达式,只要它们在脚本语言中是有效的。
      脚本程序的语法格式:<% 代码片段 %>或者,您也可以编写与其等价的XML语句,就像下面这样:
      jsp:scriptlet
      代码片段
      </jsp:scriptlet>
      任何文本、HTML标签、JSP元素必须写在脚本程序的外面。
      注意:请确保Apache Tomcat已经安装在C:\apache-tomcat-7.0.2目录下并且运行环境已经正确设置。
      将以上代码保存在hello.jsp中,然后将它放置在 C:\apache-tomcat-7.0.2\webapps\ROOT目录下,打开浏览器并在地址栏中输入http://localhost:8080/hello.jsp。
      。。。
      JSP声明
      一个声明语句可以声明一个或多个变量、方法,供后面的Java代码使用。在JSP文件中,您必须先声明这些变量和方法然后才能使用它们。
      JSP声明的语法格式:<%! declaration; [ declaration; ]+ … %> 或者,您也可以编写与其等价的XML语句,就像下面这样:
      jsp:declaration
      代码片段
      </jsp:declaration>
      。。。
      JSP表达式
      一个JSP表达式中包含的脚本语言表达式,先被转化成String,然后插入到表达式出现的地方。
      由于表达式的值会被转化成String,所以您可以在一个文本行中使用表达式而不用去管它是否是HTML标签。
      表达式元素中可以包含任何符合Java语言规范的表达式,但是不能使用分号来结束表达式。
      JSP表达式的语法格式:<%= 表达式 %> 同样,您也可以编写与之等价的XML语句:
      jsp:expression
      表达式
      </jsp:expression>
      。。。
      JSP注释
      JSP注释主要有两个作用:为代码作注释以及将某段代码注释掉。
      JSP注释的语法格式:<%-- 这里可以填写 JSP 注释 --%>
      不同情况下使用注释的语法规则:
      语法 描述
      <%-- 注释 --%> JSP注释,注释内容不会被发送至浏览器甚至不会被编译
    HTML注释,通过浏览器查看网页源代码时可以看见注释内容

    <% 代表静态 <%常量
    %> 代表静态 %> 常量
    ’ 在属性中使用的单引号
    " 在属性中使用的双引号
    。。。
    JSP指令
    JSP指令用来设置与整个JSP页面相关的属性。
    JSP指令语法格式:
    <%@ directive attribute=“value” %>
    这里有三种指令标签:
    指令 描述
    <%@ page … %> 定义页面的依赖属性,比如脚本语言、error页面、缓存需求等等
    <%@ include … %> 包含其他文件
    <%@ taglib … %> 引入标签库的定义,可以是自定义标签
    。。。
    JSP行为
    JSP行为标签使用XML语法结构来控制servlet引擎。它能够动态插入一个文件,重用JavaBean组件,引导用户去另一个页面,为Java插件产生相关的HTML等等。
    行为标签只有一种语法格式,它严格遵守XML标准:<jsp:action_name attribute=“value” />
    行为标签基本上是一些预先就定义好的函数,下面罗列出了一些可用的JSP行为标签::
    语法 描述
    jsp:include 用于在当前页面中包含静态或动态资源
    jsp:useBean 寻找和初始化一个JavaBean组件
    jsp:setProperty 设置 JavaBean组件的值
    jsp:getProperty 将 JavaBean组件的值插入到 output中
    jsp:forward 从一个JSP文件向另一个文件传递一个包含用户请求的request对象
    jsp:plugin 用于在生成的HTML页面中包含Applet和JavaBean对象
    jsp:element 动态创建一个XML元素
    jsp:attribute 定义动态创建的XML元素的属性
    jsp:body 定义动态创建的XML元素的主体
    jsp:text 用于封装模板数据
    。。。
    JSP隐含对象
    JSP支持九个自动定义的变量,江湖人称隐含对象。这九个隐含对象的简介见下表:
    对象 描述
    request HttpServletRequest类的实例
    response HttpServletResponse类的实例
    out PrintWriter类的实例,用于把结果输出至网页上
    session HttpSession类的实例
    application ServletContext类的实例,与应用上下文有关
    config ServletConfig类的实例
    pageContext PageContext类的实例,提供对JSP页面所有对象以及命名空间的访问
    page 类似于Java类中的this关键字
    Exception Exception类的对象,代表发生错误的JSP页面中对应的异常对象
    。。。
    控制流语句
    JSP提供对Java语言的全面支持。您可以在JSP程序中使用Java API甚至建立Java代码块,包括判断语句和循环语句等等。
    。。。
    判断语句
    If…else块
    。。。
    循环语句
    在JSP程序中可以使用Java的三个基本循环类型:for,while,和 do…while。
    。。。
    JSP运算符
    JSP支持所有Java逻辑和算术运算符。
    下面罗列出了JSP常见运算符,优先级从高到底:
    类别 操作符 结合性
    后缀 () [] . (点运算符) 左到右
    一元 ++ - - ! ~ 右到左
    可乘性 * / % 左到右
    可加性 + - 左到右
    移位 >> >>> << 左到右
    关系 > >= < <= 左到右
    相等/不等 == != 左到右
    位与 & 左到右
    位异或 ^ 左到右
    位或 | 左到右
    逻辑与 && 左到右
    逻辑或 || 左到右
    条件判断 ?: 右到左
    赋值 = += -= *= /= %= >>= <<= &= ^= |= 右到左
    逗号 , 左到右
    。。。
    JSP常量
    JSP语言定义了以下几个常量:
    -布尔值(boolean):true 和 false;
    -整型(int):与Java中的一样;
    -浮点型(float):与Java中的一样;
    -字符串(string):以单引号或双引号开始和结束;
    -Null:null。
    :::::::::::::::::::::::::::::::::::
    JSP 指令
    JSP指令用来设置整个JSP页面相关的属性,如网页的编码方式和脚本语言。
    语法格式如右:<%@ directive attribute=“value” %>
    指令可以有很多个属性,它们以键值对的形式存在,并用逗号隔开。
    JSP中的三种指令标签:
    指令 描述
    <%@ page … %> 定义网页依赖属性,比如脚本语言、error页面、缓存需求等等
    <%@ include … %> 包含其他文件
    <%@ taglib … %> 引入标签库的定义
    。。。
    Page指令
    Page指令为容器提供当前页面的使用说明。一个JSP页面可以包含多个page指令。
    Page指令的语法格式:<%@ page attribute=“value” %>
    等价的XML格式:<jsp:directive.page attribute=“value” />
    。。。
    属性
    下面列出与Page指令相关的属性:
    属性 描述
    buffer 指定out对象使用缓冲区的大小
    autoFlush 控制out对象的 缓存区
    contentType 指定当前JSP页面的MIME类型和字符编码
    errorPage 指定当JSP页面发生异常时需要转向的错误处理页面
    isErrorPage 指定当前页面是否可以作为另一个JSP页面的错误处理页面
    extends 指定servlet从哪一个类继承
    import 导入要使用的Java类
    info 定义JSP页面的描述信息
    isThreadSafe 指定对JSP页面的访问是否为线程安全
    language 定义JSP页面所用的脚本语言,默认是Java
    session 指定JSP页面是否使用session
    isELIgnored 指定是否执行EL表达式
    isScriptingEnabled 确定脚本元素能否被使用
    。。。
    Include指令
    JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分,会被同时编译执行。
    Include指令的语法格式如右:<%@ include file=“relative url” %>
    Include指令中的文件名实际上是一个相对的URL。如果您没有给文件关联一个路径,JSP编译器默认在当前路径下寻找。
    等价的XML语法:<jsp:directive.include file=“relative url” />
    。。。
    Taglib指令
    JSP API允许用户自定义标签,一个自定义标签库就是自定义标签的集合。
    Taglib指令引入一个自定义标签集合的定义,包括库路径、自定义标签。
    Taglib指令的语法:<%@ taglib uri=“uri” prefix=“prefixOfTag” %>
    uri属性确定标签库的位置,prefix属性指定标签库的前缀。
    等价的XML语法:<jsp:directive.taglib uri=“uri” prefix=“prefixOfTag” />
    ::::::::::::::::::::::::::::::::::::::
    JSP 动作元素
    与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。
    利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。
    动作元素只有一种语法,它符合XML标准:<jsp:action_name attribute=“value” />
    动作元素基本上都是预定义的函数,JSP规范定义了一系列的标准动作,它用JSP作为前缀,可用的标准动作元素如下:
    语法 描述
    jsp:include 在页面被请求的时候引入一个文件。
    jsp:useBean 寻找或者实例化一个JavaBean。
    jsp:setProperty 设置JavaBean的属性。
    jsp:getProperty 输出某个JavaBean的属性。
    jsp:forward 把请求转到一个新的页面。
    jsp:plugin 根据浏览器类型为Java插件生成OBJECT或EMBED标记。
    jsp:element 定义动态XML元素
    jsp:attribute 设置动态定义的XML元素属性。
    jsp:body 设置动态定义的XML元素内容。
    jsp:text 在JSP页面和文档中使用写入文本的模板
    。。。
    常见的属性
    所有的动作要素都有两个属性:id属性和scope属性。
    id属性:id属性是动作元素的唯一标识,可以在JSP页面中引用。动作元素创建的id值可以通过PageContext来调用。
    scope属性:该属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系,scope属性定义了相关联id对象的寿命。 scope属性有四个可能的值: (a) page, (b)request, ©session, 和 (d) application。
    jsp:include动作元素
    jsp:include动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如右:<jsp:include page=“relative URL” flush=“true” />
    前面已经介绍过include指令,它是在JSP文件被转换成Servlet的时候引入文件,而这里的jsp:include动作不同,插入文件的时间是在页面被请求的时候。
    以下是include动作相关的属性列表。
    属性 描述
    page 包含在页面中的相对URL地址。
    flush 布尔属性,定义在包含资源前是否刷新缓存区。
    。。。
    jsp:useBean动作元素
    jsp:useBean动作用来装载一个将在JSP页面中使用的JavaBean。
    这个功能非常有用,因为它使得我们既可以发挥Java组件重用的优势,同时也避免了损失JSP区别于Servlet的方便性。
    jsp:useBean动作最简单的语法为:<jsp:useBean id=“name” class=“package.class” />
    在类载入后,我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索bean的属性。
    以下是useBean动作相关的属性列表:
    属性 描述
    class 指定Bean的完整包名。
    type 指定将引用该对象变量的类型。
    beanName 通过 java.beans.Beans 的 instantiate() 方法指定Bean的名字。
    。。。
    jsp:setProperty动作元素
    jsp:setProperty用来设置已经实例化的Bean对象的属性,有两种用法。首先,你可以在jsp:useBean元素的外面(后面)使用jsp:setProperty,如下所示:
    <jsp:useBean id=“myName” … />

    <jsp:setProperty name=“myName” property=“someProperty” …/>
    此时,不管jsp:useBean是找到了一个现有的Bean,还是新创建了一个Bean实例,jsp:setProperty都会执行。第二种用法是把jsp:setProperty放入jsp:useBean元素的内部
    如下所示:
    <jsp:useBean id=“myName” … >

    <jsp:setProperty name=“myName” property=“someProperty” …/>
    </jsp:useBean>
    此时,jsp:setProperty只有在新建Bean实例时才会执行,如果是使用现有实例则不执行jsp:setProperty。

    展开全文
  • 我们知道java虚拟机只认识class文件,要在虚拟机上运行就必须要遵守class文件格式...由于语法不一样jsp某行执行的逻辑怎样与java文件对应起来,这样在JVM执行过程发生异常或错误才能找到JSP对应的行,提供一个友好的

    我们知道java虚拟机只认识class文件,要在虚拟机上运行就必须要遵守class文件格式,所以JSP编译成servlet后还需要进一步编译成class文件,但从JSP文件到java文件再到class文件的过程需要考虑的事情比较多,其中一个比较重要的就是调试问题,由于语法不一样,jsp某行执行的逻辑怎样与

    展开全文
  • JSPJava Server Pages)Java服务器页面

    千次阅读 2018-11-05 07:42:35
    JSP–&amp;gt;Java Server Pages(java服务器页面) ...-2.jsp是以.jsp为后缀的文件,其主要内容是少量的java代码html -3.容器会将jsp文件转换成对应的sevlet然后执行 -4.jsp的本质就是一个servlet ...
  • 在前面,我们已经看到了JSP如何转换为Java代码,可以写Servlet那样写JSP,拥有强大的功能,那么是否应该在JSP中使用Java?一般不建议,JSP中的Java最大的问题就是太强大。Jsp主要用于表现层,也就是用户界面,即view...
  • 数据库的时间页面的时间显示不一样,数据库的时间是:2015-05-13 12:24:03 显示到页面上:1431491043000,求解
  • JSP——在JSP中嵌入java代码

    千次阅读 2018-08-02 19:32:25
    JSP中嵌入java代码的三种方式:  (1)声明变量或方法 : &lt;%! 声明; %&gt; :慎重使用,因为此方法定义的是全局变量  (2)java片段(scriptlet): &lt;% java代码; %&gt;  (3)表达式...
  • jsp/java执行或者调用bat/cmd脚本文件

    千次阅读 2019-06-15 00:27:15
    jsp页面调用脚本文件或者脚本命令的方法其实和java一样,因为可以在jsp中执行java代码 <%@ page language="java" import="java.lang.*" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-...
  • Java Jsp起源

    千次阅读 2012-11-07 18:52:13
    如果使用Servlet程序来输出只有局部内容需要动态改变的网页,其中所有的静态内容也需要程序员用Java程序代码产生,整个Servlet程序的代码将非常臃肿,编写维护都将非常困难。 对大量静态内容的美工设计相关HTML...
  •  JavaScript和Java名字极为类似,相信不少的初学者或者准备学这些知识的人对于JavaScript、JSPJava及JavaEE这几个感念理解都会混淆,有所疑惑。曾经的我也是常常把这几个感念混淆。后来查了很多资料,也对...
  • JAVA和JSP之间的关系

    万次阅读 2018-02-25 12:15:04
    我现在给你一个JAVA和JSP之间的关系,以及JAVA的完整认识JAVA分为J2EE,J2SE.J2ME,下面分别介绍:一.J2EE:Java 2 Platform Enterprise Edition 企业版,用于企业应用,支持分布式部署。 J2EE平台由一整套服务...
  • JSPJava Server Pages)

    千次阅读 2017-11-01 17:43:21
    JSP全名为Java Server Pages,中文名叫java服务器页面,其根本是一个...JSP技术有点类似ASP技术,它是在传统的网页HTML(标准通用标记语言的子集)文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP标记(tag),从
  • 背景:调试技术是一个开发人员必须掌握的一门...通过本文掌握Idea结合tomcat开发的过程,以及Idea调试jsp和java的配置方法。  一、 系统环境  Windows XP SP2 Professional 简体中文版  IntelliJ IDEA 5.12  
  • JSPjava代码js代码的执行问题

    千次阅读 2017-06-23 09:34:57
    先了解jsp的执行过程:一、JSP执行过程,以及生命周期 JSP 的执行过程 (1) 客户端发出Request (请求); (2) JSP Container 将JSP转译成Servlet的源代码; (3) 将产生的Servlet 的源代码经过编译后,并加载到内存...
  • java web和jsp页面的区别

    千次阅读 2018-04-29 15:45:32
    现在主流的是MVC的三层架构,而jsp就是页面表现层的首选,因为它出现的比较早,技术相对成熟普及。这就是最为流行的J2EE技术。关系就是:jsp服务于java web开发。jsp就是html中间插入java代码,最终要先编译为...
  • Java学习笔记一JSP

    千次阅读 2020-04-10 16:59:08
    JSP和Servlet的本质是一样的,因为JSP最终必须编译成Servlet才能运行,或者说JSP 只是生成Serv let 的“草稿”文件。 DefaultServlet 新建一个动态web工程,只是写了一个HTML,没有编写Servlet,甚至一句Java代码都...
  • Java JSP(一) 基本原理九个隐含对象

    千次阅读 2016-05-16 19:38:33
    所有的页面内容都可以在Servlet,通过out.print输出,之所以用到JSP,是为了简单整洁,而实际上JSP本身就是一个Servlet。 在JSP书写方式中,动态的内容使用Java编写,静态的内容使用HTML来编写; 2.JSP原理 1)JS
  • JSPjava服务器页面)

    千次阅读 2015-03-28 17:58:34
    语言标准编辑 句法 一个JSP页面可以被分为以下几部份: ...JSP指令,如include指令 ...JSP脚本元素变量 ...此时,该JSP输入文件会是一个没有内嵌JAVA或动作的HTML页面。而且,客户端每次请求都会得到相同的
  • JavaScript、JSPJava及javaEE之间区别

    千次阅读 2013-10-18 14:06:01
     JavaScript和Java名字极为类似,相信不少的初学者或者准备学这些知识的人对于JavaScript、JSPJava及JavaEE这几个感念理解都会混淆,有所疑惑。曾经的我也是常常把这几个感念混淆。后来查了很多资料,也对...
  • 格式:和java一样;可以有一行或者多行代码,每一行代码以;为结束符 应用:可访问 java内置对象,session会话,流程控制-------跟java一样 例子:  String str= new Date().toLocaleString();  out....
  • JSP 2:jsp中的java代码

    千次阅读 2018-10-08 16:02:43
    ※ 如何写一个jsp页面以及在页面中如何写java代码。  jsp页面中主要写的东西分为三部分:  1. jsp的脚本元素  1.1表达式(expression) 形式:&lt;%= %&gt; 例如:&lt;%="hello" %&gt;...
  • java web基础之jsp

    千次阅读 2012-04-17 15:21:57
     JSP(Java Server Pages)是一种动态网页技术标准。它在HTML代码中,插入JSP标记(tag)及Java程序片段 (Scriptlet),构成JSP页面,其扩展名为.jsp。当客户端请求JSP文件时,Web服务器执行该JSP文件,然后以HTML的格式...
  • java中 servlet和jsp的概念及区别

    万次阅读 多人点赞 2017-02-25 13:05:59
    林炳文Evankaka原创作品。... 目录 一了解Servlet的概念二Servlet技术功能三 Servlet技术特点四 Servlet生命周期五servlet工作... Servlet与JSP区别七Servlet代码结构八 Servlet第一个程序 一、了解Servlet的概念
  • 最新web/java/jsp实现发送手机短信验证码邮箱验证码的注册登录功能(详细) 最近几天有人需要帮忙做一个关于发送验证码的功能,之前没有做过,于是我鼓捣一阵子,记录一下关于web项目中注册登录常用的手机验证码...
  • 希望大家在看完本入门之后能分清楚js(JavaScript)和jspJava Server Pages)的区别。 希望这两篇文档对大家能有所帮助! ......................................................................................
  • at org.apache.jsp.index_jsp._jspInit(index_jsp.java:23) 环境:Tomcat6 + jdk6 Tomcat服务启动成功,但访问index.jsp出错,Tomcat报错如下: 严重: Servlet.service() for servlet jsp threw...
  • jsp处理表单及JS和JAVA变量互传

    千次阅读 2011-11-21 19:54:13
     这样做会有一个问题:在test.jsp中,除你传递的param1param2参数外,你用request.getParamter()取任何原来页面的表单元素都会为空,这是因为这种方式会产生新的request生命周期,在这个request中只会包含超连接后...
  • 一、JSP技术简介JSPJava Server Page的缩写,它是Servlet的扩展,它的作用是简化网站的创建维护。 JSP是HTML代码与Java代码的混合体。 JSP文件通常以JSP或JSPX的扩展名。 JSP拥有自己的语法。 JSP形式上像...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 178,081
精华内容 71,232
关键字:

jsp和java一样吗

java 订阅