JSP(java sever pages)动态网页开发技术2

一：在myeclipse8.5环境中集成tomcat步骤
1:

2：

3：

4：

5.创建一个web项目:
File–>new –>web project

6.打开index.jsp进行编辑

7.部署web应用:


点击了add按钮之后，会弹出以下界面：

选择tomcat6.0之后，finish完成
8.启动tomcat服务器

9.以在浏览器中访问该web应用了。

始终记住，jsp文件仅仅是一个草稿文件，jsp中为我们提供的那些api也都是草稿api，最终jsp中的语法会变成之前我们学习过得java语法。
二：JSP中的各种元素
1：脚本元素
A：<% %>
在该脚本段中所以的内容，最终会出现在一个java方法中。
所以，在java的方法中能写什么内容，在<% %>中就能写什么内容
所以，在java的方法中不能写什么内容，在<% %>中也就不能写什么内容
Java方法中能写的内容 局部变量，局部内部类，各种程序结构(if for..)
Java方法中不能写的内容 方法，static（定义在类中方法外，随着类的加载而加载），4种访问修饰符 （只能修饰全局变量，方法内只能是局部变量）
B:<%! %>
该脚本段中写的内容，会出现在类之内，方法之外。
所以，在java的类之内，方法之外能写什么内容，在<%！ %>中就能写什么内容
所以，在java的类之内，方法之外不能写什么内容，在<%！ %>中也就不能写什么内容
java的类之内，方法之外能写 属性 方法 块 内部类
java的类之内，方法之外不能写 程序结构 表达式
C:<%= %>
在该脚本端中所写的内容，最终会成为out.print()的参数。
所以在java的方法参数中，能写什么，<%= %>就能写什么。
所以在java的方法参数中，不能写什么，<%= %>也就不能写什么。
java的方法参数能写 表达式
java的方法参数不能写除了表达式以外，都不能写
D:<%– –%>
该脚本用于告诉web服务器，在把一个jsp文件解析出一个java源文件的过程中，忽略该脚本中的内容，也就是说，<%– –%>脚本中的内容根本不会出现在java源文件中。
对比： // /* */ 注释的内容会出现在java源文件中。
对比 : 不但会出现在java源文件中。而且还会被web服务器发送给客户端浏览器。
注意以上3种注释是有能在客户端浏览器的源代码中看到。所以有2个术语：
客户端注释：
服务器端注释 <%– –%> // /* */
总结：jsp只有在第一次被访问的时候，才会实例化出对象，第2,3,4,5…n次访问同一个jsp页面时，都使用的是第一次已经创建好的实例!
证明：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>a.jsp</h1>
<%!
    int count=0;
%>
我是a.jsp
我是第<%=count++ %>个访客 

通过在多个客户端观察，发现count的值是累加的，证明了上面的总结。
2：指令元素: 所有的指令元素，都是<%@ %>
A:*page,学习page指令元素，就是学习page指令元素的属性.*
(1)import 用于引入外包的class
(2)buffer 用于控制当前jsp页面的缓冲区大小，默认值为8kb
缓冲区的作用：提高读写速度。
缓冲区就是用来积攒数据的地方。
缓冲区中的数据，何时会被发送到目的地
1.缓冲区已经放满数据了，再多放一个字节。
2.强制发送缓冲区中的数据

<%@ page buffer="1kb"%>
<%
    for(int a=0;a<=1024;a++){
        out.write('a');
    }
//多放了一个字节强制发送
out.write('b');
out.clearBuffer();
%>

输出结果：1024个a

<%@ page buffer="1kb"%>
<%
    for(int a=0;a<=5;a++){
        out.write('a');
    }
//强制发送
out.flush();
out.write('b');
out.clearBuffer();
%>

输出结果：5个a
（3）contentType 用于告诉浏览器，服务器给你发送的是什么格式的数据。

<%@page pageEncoding="gbk" contentType="application/excel; charset=ISO-8859-1" %>
<%
// 该行代码用于控制，下载文件的名字
    response.setHeader("content-disposition","attachment;filename=abc.xls");
%>

输出结果：会生成一个abc.xls文件
（4）errorPage 当当前jsp页面中抛出异常的时候，指定的跳转页面

<%@page errorPage="error.jsp" %>
<%=8/0 %>

error.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
您访问的页面有错误，请检查您的输入。

输出结果：您访问的页面有错误，请检查您的输入。
（5）isThreadSafe 控制web服务器是否对该jsp页面支持并发，取值为true就表示支持并发

<%@page isThreadSafe="true"%>
<%
    Thread.sleep(5000);
%>
<script>
    alert("123")
</script>

输出结果：网页会在5秒后输出123
（7）pageEncoding 1 .Jsp–>java过程中，就是使用该属性指定的码表来生成java源文件的。2.告诉浏览器使用什么码表。
B：include: 静态包含。（稍后还会介绍到动态包含， 关于静态包含与动态包含的区别，一会再介绍，现在只介绍静态包含）。
a.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<marquee >
我是a.jsp页面
</marquee>

error.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<marquee >
我是a.jsp页面
</marquee>

输出结果：

3：动作元素: 所有动作元素都是
*A:
介绍之前，必须要知道，什么是javabean。*
JavaBean的规范：
1. 所有属性必须私有化。
2. 必须为私有属性提供公共的getter(获取器)和setter(设置器)
3. 必须提供一个公共的无参的构造器。
4. 必须实现序列化接口: java.io.Serializable
其实，Javabean就是一个普普通通的java类而已。（不是什么新的技术，也不是什么新的api），只不过这个类要符合一些规范而已。
UserBean.java

package com.westos.bean;
import java.io.Serializable;
public class UserBean implements Serializable{
    private String name;
    private Integer id;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public UserBean() {
        super();
        // TODO Auto-generated constructor stub
    }



}

a.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ page import="com.westos.bean.*" %>
<h2>a.jsp</h2>

<jsp:useBean id="u" class="com.westos.bean.UserBean"></jsp:useBean>
<jsp:setProperty property="name" name="u" value="吴亦凡"/>
<jsp:setProperty property="id" name="u" value="12"/>
<jsp:setProperty property="age" name="u" value="25"/>

<jsp:getProperty property="name" name="u"/>
<jsp:getProperty property="id" name="u"/>
<jsp:getProperty property="age" name="u"/>

输出结果：

在这里：
等价于实例化对象
等价于给对象的属性赋值
等价于 获取对象的属性，并发送给浏览器
注意， 会回调公共的无参构造器
注意， 会回调对应的setter方法。
注意， 会回调对应的getter方法。
B: 动态包含。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>error.jsp</h1>
<fieldset>
    <legend>动态包含</legend>
        <jsp:include page="a.jsp"></jsp:include>    
</fieldset>
<fieldset>
    <legend>静态包含</legend>
        <%@include file="a.jsp" %>  
</fieldset>

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<marquee>
你好
</marquee>

输出结果：

C：静态包含和动态包含的区别

1.静态包含是先包含，后编译; 最终只能生成一个java源文件!class也是一个
动态包含是先编译，后包含。最终生成多个java源文件!class也是多个
2.静态包含不能用变量名作为路径; 动态包含就可以用变量名作为路径。
3.静态包含不能给被包含的目标jsp页面传递参数;动态包含就可以!
4.一个页面上的多个静态包含的页面中，不能有同名的变量；动态包含就可以!
如果有一种场景，既能使用静态包含，又能使用动态包含，那么应该如何抉择？？
应该使用静态包含！ 因为静态包含总共只会编译一次，速度快！
D： 转发。
转发可以暂时理解为一个不用点击就可以自动跳转的超链接，事实上这个说法并不准确。下一个博客详细介绍。
E： 我们先介绍，如何给服务器传递请求参数!
1.通过表单。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<form action="a.jsp">
    username:<input type="text" name="username" /><br />
    password:<input type="password" name="password"/><br />
    <button type="submit">go</button>"
</form>

2.不需要表单，直接在url后面加上?参数名=参数值&参数名2=参数值2…..
3.直接在超链接的url后面写出参数即可!

<a href="a.jsp?username=kk&&password=pp">go to a.jsp</a>

4.通过window.location=”url?请求参数”
5.我们要学习的也是用来给服务器传递参数的，但是该标记必须搭配或者
注意，如果没有给被动态包含的页面传递参数，
则和之间不能有任何内容，必须贴紧

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<jsp:include page="a.jsp">
    <jsp:param  name="username" value="dsh"/>
    <jsp:param  name="password" value="ds"/>
</jsp:include>

注意，如果没有给被转发的目标页面传递参数，
则和之间不能有任何内容，必须贴紧

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<jsp:forward page="a.jsp">
    <jsp:param value="lx" name="username"/>
    <jsp:param value="ls" name="password"/>
</jsp:forward>