一、概述

Web服务器

web服务器是指能够为发出请求的浏览器提供文档的程序。服务器是一种被动程序，只有浏览器发出请求的时候才会响应。
TCP/IP：关注数据是否传输成功
UDP/IP：

web开发：
静态web
动态web

B/S：浏览器-服务器，底层是C/S结构
C/S：客户端-服务器，Client Server，客户端-服务器，跟新需要下载更新包

URL：统一资源定位符，例如http://item.jd.com/10212112.html

协议：包括http、https等

域名：item.jd.cm（域名）

IP地址：116.221.94.1

端口号：80（常用端口号），程序必须使用端口号才能让另外一台计算机访问

资源位置：用于描述web资源服务器的位置，10212112.html

Web服务器

常见的web服务器开发语言：
ASP

常见的web服务器：IIS、tomcat

访问流程

HTTP协议（HyperTextTransferProtocol）

定义：超文本传输协议，对浏览器客户端和服务器客户端之间的数据传输的格式规范。，是在TCP/IP之上封装的一层协议，关注数据传输是否规范。
超文本传输协议，用于定义客户端与服务器交换数据的过程，HTTP协议是web的基础，请求和响应是web开发的基本操作

版本更替：
HTTP/1.0：
HTTP/1.1：

作用和特点：
保证浏览器和服务器之间高效的数据传输，可以控制超文本链接的传输行为
特点：基于请求—响应模型，先有请求后有响应

组成：
Http请求协议：请求行+请求头+请求体
Http响应协议：响应行+响应头+响应体

请求方式方式：get、post

Http请求

由请求行、多个请求头（key-value）、一个空行、实体内容（可选）
请求行：
GET/da09/hello HTTP/1.1

#http协议版本
http1.0：当浏览器与服务器建立连接之后只能发送一次请求，请求完之后关闭链接
http1.1：当浏览器与服务器建立连接之后能发送多次请求。（只要寻找了另外的资源就要再发送请求）

#请求资源
URL：通过的资源定位符，只能定义互联网资源（http://locadhost:8080/day09/testI.img）
URI：统一的资源标记符，可以标记任何资源，可以是本地资源也可以是局域网资源也可以是互联网（/da09/hello/HTTP1.1）

#请求方式
GET：不得超过1k。地址栏会跟上数据，参数跟在URI后面，？开头，参数数据用&连接（默认方式）,但是高效
POST：参数不会跟在URI后面，跟在请求的实体内容之中，没有？开头，多个参数之间用&分隔
只有post内容提交的参数会放在实体内容中

请求头（消息头）

Accept: text/html,image/*                            -- 浏览器接受的数据类型
Accept-Charset: ISO-8859-1                        -- 浏览器接受的编码格式
Accept-Encoding: gzip,compress                --浏览器接受的数据压缩格式
Accept-Language: en-us,zh-                        --浏览器接受的语言
Host: www.it315.org:80                                --（必须的）当前请求访问的目标地址（主机:端口）
If-Modified-Since: Tue, 11 Jul 2000 18:23:51 GMT    --浏览器最后的缓存时间
Referer: http://www.it315.org/index.jsp                        -- 当前请求来自于哪里
User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)  --浏览器类型
Cookie:name=eric                                        -- 浏览器保存的cookie信息
Connection: close/Keep-Alive                -- 浏览器跟服务器连接状态。close: 连接关闭  keep-alive：保存连接。
Date: Tue, 11 Jul 2000 18:23:51 GMT      -- 请求发出的时间

HTTP响应

内容：响应行、响应头、空行、响应体
响应体

Accept:告诉浏览器，它支持的数据类型
Accept-Encoding:支持哪种编码格式    GBK    UTF-8
Accept-Language:告诉浏览器,他的语言环境
Cache-Control:缓存控制
Connect:告诉浏览器,请求完成后是断开还是保持连接
HOST:主机..../
Resfresh:告诉客户端,多久刷新一次
Location:让网页重新定位

响应状态码
服务处理请求的状态
200：处理完成
302：未完成（服务器可以通过这个302状态使得浏览器再次送请求）
404：未找到请求的资源
500：服务器错误
501
502：网管错误

#状态描述
响应头：
空行：
实体内容：

响应行：
response.setStatus()
响应头：
response.setHeader(“name”,”value”)
实体：
response.getWriter().writer();发送字符实体
response.getInputStream().writer();发送字节实体

实体内容：

HttpServletRequest对象
HttpServletRequest对象用于获取请求数据
核心的API：
请求行：
request.getMethod()
request.getRequestURI()
request.getProtocol()
请求头：
request.getHeader(“name”)
request.getHeaderNames()获取所有请求头名称
实体内容：
request.getInputStream()获取实体内容数据
@WebServlet(name = “RequestDemo”,urlPatterns = “/RequestDemo”)
public class RequestDemo extends HttpServlet {

/
1)Tomcat服务器接收到浏览器发送的请求之后，封装到HttpServletRequest对象之中
2）Tomcat服务器调用doGet()方法，然后把request对象传入servlet之中
*/

protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

//获取post方式提交的内容
this.getContent(request);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//3）从request中取出数据
//请求行
//请求方式
System.out.println(request.getMethod());
//请求资源
System.out.println(request.getRequestURI());
System.out.println(request.getRequestURL());
//请求协议
System.out.println(request.getProtocol());

//或者请求头
this.getHead(request);

//请求实体内容
getContent(request);
}
private void getContent(HttpServletRequest request) throws IOException {
InputStream in =request.getInputStream();
byte [] buf=new byte[1024];
int len=0;
while((len=in.read(buf))!=1){
String str=new String(buf,0,len);
System.out.println(str);
}
}
private void getHead(HttpServletRequest request) {
//请求头
String host=request.getHeader(“Host”);//根据头名称到头头内容
//遍历所有请求头
Enumeration enums=request.getHeaderNames();//得到所有头名称的列表
while(enums.hasMoreElements()){ //判断是否含有下一个元素
String headerName=enums.nextElement(); //取出一个元素
String header=request.getHeader(headerName);
System.out.println(headerName+”:”+header);//打印所有头
}
}
}

获取表单传递参数的方法：
get方式：
request.getQueryString()；获取原始的参数数据（未经过加工）
get方式/post方式：
request.getParameter(“name”)，获取单个项，返回字符串，name为表单项目（input）名称
request.getParamenterNames()；获取所有的参数名称，返回一个Enumeration类型。
注意：getParameter()是根据名字拿到值，只能获取一个值的参数，如果名字相同的情况下要使用getParamenteValue(“name”)，返回一个String []，可以获取多个值的同名参数
乱码问题
浏览器发送请求给服务器时，当getParameter(name)中name是中文时，获取容易出现乱码情况，原因是解码和编码的字符集不同，getParameter默认的编码是iSO-8859-1；
html文件如果设置成utf-8就会出现乱码
解决方法1：手动解码
Stringname =request.getParameter(“name”)；
name = newString（name.getByte(“ISO-8859”),”utf-8”）;
解决方法2：全局设置编
在调用getParameter(“name”)；方法前面添加：request.setCharaterEncoding(“utf-8”)；
该方法只能对请求内容的数据编码起作用，对get无效

乱码问题，
在服务器想浏览器发送响应时，比如通过response.getWriter.write(“中国”)发送实体内容时，服务器默认的字符集是iso-8859-1，中文的编码字符是UTF-8，所以需要在这行代码之前添加一句，response.setCharceterEncoding(“UTF-8”);

代码合并：
response.setCharacterEncoding(“utf-8”);
esponse.setContentType(“text/html”);
合并成：
response.setContentType(“text/html;utf-8”);

Tomcat服务器

安装tomcat

官网下载安装
启动运行

Tomcat文件目录

bin：存放启动和关闭Tomcat的脚本程序
conf：存放Tomcat的配置文件
lib：存放Tomcat服务器的支持jar包
temp：存放Tomcat运行产生的临时文件
webapps：wen应用所在目录，即提供给外界访问的资源存放目录
work：Tomcat的工作目录

Web项目的目录结构

Servlet

Servlet简介
Servlet就是sun公司开发的动态web的一门技术
Sun在这些API中提供一个接口叫做:Servlet,如果想要开发一个Servlet程序,只要完成两个小步骤:
编写好一个类，实现　，Servlet接口
把开发好的Java部署到web服务器中
把实现了Servlet接口的java程序叫做Servlet

Java Servlet，在服务器端运行的程序，相当于一个小的服务器，已经升级到3.0
作用：
1，获取接受客户端发过来的请求数据
2，处理请求
3，将处理结果通过响应发送给客户端浏览器

编写第一个Servlet

1，创建一个类继承HttpServlet
2，覆写doGet()，和doPost()
3，配置web.xml
4，部署项目并通过浏览器访问servlet
5，Servlet执行流程

IDEservlet3.0新建servlet
直接新建一个servlet，不需要配置web.xml，可以配置urlPatterns参数

Enumeration

会话，

管理浏览器客户端和服务器之间会话过程中产生的会话数据

域对象：实现资源之间的数据共享，具有保存对象，获取对象，清除数据三大基本功能
request对象
context对象

会话技术的分类，

cookie技术：会话技术保留在浏览器客户端（服务器创建，浏览器保存）
Session技术：会话技术保留在服务器端

cookie技术

特点：数据保留在浏览器客户端
cookie类，用于存储会话对象
1，创建一个cookie，构造cookie对象，
cookie（java.lang.String name, java.lang.String value）
2，设置cookie

3，发送cookie到浏览器端保存
void response.addCookie(Cookie cookie)：发送cookie
4，服务器接收cookie
Cookie [] request.getCookies() ；接收cookie，返回一个Cookie类型的数组
Cookie技术原理
1，服务器创建cookie对象：new Cookie(“name”,”value”);
2，服务器发送cookie信息到浏览器；response.addCookie(cookie);
3，浏览器得到服务器发送的cookie之后会保留在浏览器中
4，浏览器下次访问服务器的时候会带着；cookie信息
5，服务器接收来自浏览器的cookie信息：request.getCookies();
Cookie的细节
1，void setPath（java.lang.String url）
设置cookie的有效访问路径，有效路径指的是cookie的有效路径保存在哪里，那么浏览器在有效路径下访问服务器会带着cookie信息，否则不带cookie信息，默认是路径是项目根目录
2，void setMaxAge（int expiry）设置cookie有效时间。
正整数：表示cookie数据保存浏览器的缓存根目录中（硬盘中），数值就表示时间
负整数：表示cookie数据保存在浏览器的内存中，浏览器关闭数据就丢失了
零：表示删除同名的cookie数据
3，cookie保存的数据类型，非中文（英文）字符串，
4，限制，浏览器一般只允许存放300和cookie，每个站点最对存放20个，大小限制未4KB。
5，相同名字的cookie会被覆盖
案例，显示用户上次访问的时间

Seesion技术

cookie局限：
1，只能保存字符串
2，只能保存英文
3，一个cookie大小为4KB
Session特点
会话数据保存在服务器中
session技术核心：
HttpSession类：用于保存session（会话）数据。
1)创建或者得到session对象
HttpSession getSession（）
HttpSession getSession(boolean create)
2)设置session对象

Session原理
前提：在哪里session域对象保存数据，就必须从哪里域对象取出！！！
浏览器1：(给s1分配一个唯一的标记：s001,把s001发送给浏览器)
1）创建session对象，保存会话数据
HttpSession session = request.getSession(); —保存会话数据 s1
浏览器1 的新窗口（带着s001的标记到服务器查询，s001->s1,返回s1）
1）得到session对象的会话数据
HttpSession session = request.getSession(); —可以取出 s1

新的浏览器1：(没有带s001,不能返回s1)
1）得到session对象的会话数据
HttpSession session = request.getSession(); —不可以取出 s2

浏览器2：(没有带s001,不能返回s1)
1）得到session对象的会话数据
HttpSession session = request.getSession(); —不可以取出 s3

代码解读：HttpSession session = request.getSession();
1，第一次访问创建对象session对象，给session对象分配一个唯一的ID，叫做JESSIONID
2，把JSESSIONEID作为cookie的值发送给浏览器保存
3，第二次访问的时候，浏览器带着JSESSIONID的cookie访问服务器
4，服务器得到JSESSIONID，在服务器的内存中搜索是否存放对应编号的session对象
5，如果找到对应编号session对象，直接返回对象
6，如果找不到对应编号的session对象，创建新的session对象，继续走1的流程

结论：通过JSESSIONID的cookie值在服务器找session对象

Session细节
1，StringgetId（）：得到session编号
2，两个getSession方法

3，voidsetMaxInactiveInterval(int interval) 设置session的有效时间
Session 对象销毁时间
3.1，默认是30分钟服务器自动回收
3.2，修改session回收时间
3.3，全局修改session有效时间
修改全局session的删除时间


1

手动销毁session对象：Voidinvalidate（）

4）如何避免浏览器的JSESSIONID的cookie随着浏览器关闭而丢失的问题

/ 手动发送一个硬盘保存的cookie给浏览器
/
Cookie c = new Cookie(“JSESSIONID”,session.getId());
c.setMaxAge(60*60);
response.addCookie(c);
总结：**
会话技术，浏览器和服务器会话过程中产生的会话数据的管理
Cookie技术
new Cookie(“name”,value)
Response.addCookie(cookie);
Request.getCookies();
Session技术
request.getSeesion();
setAttrbute(“name”,”会话数据”);
getAttribute(“会话数据”)；

编码实战
通讯录程序
一个软件的生命周期
1，需求分析（需求分析师）
功能分析
添加联系人
修改联系人
删除联系人
查询联系人
功能流转
2，需求设计（系统分析师/架构师/资深开发人员）
2.1 设计实体（抽象实体）
class Contact{
private String id;
private String name;
private String gender;
private String age;
private String phone;
private String email;
private String qq;
}
2.2 设计数据库
使用xml代替数据库，一般与项目分离
contact.xml










2.3设计涉及的接口
DAO接口（数据访问对象）：实体对象的CRUD方法
项目原则：通常一个实体对象就会有对应有一个DAO接口和一个DAO实现类
interface ContactDao{
public void addContact(Contact contact);//添加联系人
public void updateContact(Contact contact);//修改联系人
public void deleteContact(String id)；//删除联系人
public List findAll();//查询所有联系人
public Contact findById(String id)；//根据特定ID查询所有联系人
}
2.4 设计项目的目录结构
项目名称：contacSys_web
目录结构：
|-contactSys_web
|-src
|-gz.itcat.contactSys_web.entity：存放实体对象
|-gz.itcat.contactSys_web.dao：存放dao的接口
|-gz.itcat.contactSys_web.dao.impl：存放dao的实现类
|-gz.itcat.contactSys_web.servlet：存放servlet的类
|-gz.itcat.contactSys_web.test：存放测试类
|-gz.itcat.contactSys_web.util：存放工具类
|-gz.itcat.contactSys_web.exception：存放自定义异常类
|-web
|-html：文件
|-images：目录，存放图片文件
|-css：目录，存放css资源
|-js：目录，存放js资源
3，编码实现（软件开发工程师）
开发顺序：
设计数据库》实体》DAO接口》，DAO实现》Servlet+html页面
4，功能测试（测试工程师）
5，性能测试（测试工程师）
6，部署上线（实施工程师）
7，维护阶段（实施工程师）

软件公司：
职业选择：
技术线：初级开发工程师—高级开发—初级架构师—高级架构师—cto（技术总监）
管理线：初始开发—初级项目经理—项目组长—项目经理—ceo

JSP技术

1. JSP的引入

Servlet的作用：用java语言开发的动态资源的技术
Jsp定义：用java语言（+html）开发动态资源的技术，jsp就是servlet

1. JSP的特点：

1，jsp文件的运行需要交给服务器运行
jsp运行文件放置在tomcat的work目录之中
2，页面既可以写html页面也可以写java代码
执行过程：
1，访问jsp文件，tomcat执行

1. JSP的执行过程

例：访问，http://localhost:8080/day12/01.hello.jsp

1. 翻译，访问到01.hello.jsp界面，tomcat扫面jsp文件，在%tomcat%/work把jsp文件翻译成java源文件_01_hello_jsp.java
2. 编译，tomcat把java源文件编译成class文件字节码文件（）
3. tomcat服务器构造_01_hello_jsp.jsp类对象
4. tomcat服务器调用_01_hello_jsp.jsp类里面的方法，返回内容显示到浏览器

第一次访问jsp：
走1，2，3，4
第n次访问走，4
注意：jsp文件被修改了或者jsp的临时文件被删除了要重新走翻译1，2，3，4

疑问：为什么Jsp就是servlet？
jsp翻译的java文件：
public final class _01_hello_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
HttpJspBase类：
public abstract class org.apache.jasper.runtime.HttpJspBase extends javax.servlet.http.HttpServlet implements javax.servlet.jsp.HttpJspPage {
结论： Jsp就是一个servlet程序！！！
servlet的技术可以用在jsp程序中
jsp的技术并不是全部适用于servlet程序！

1. JSP的生命周期
   1. 翻译，jsp->java文件
   2. 编译，java文件->class字节码文件（servlet程序）
   3. 构造方法（第一次访问）
   4. init方法（第一次访问）
   5. service方法；_jspService（）;
   6. destroy方法：_jspDestroy（）；

Servlet的生命周期

1. 构造函数（第一次访问）
2. init方法（第一次访问）
3. service方法

4. destory方法

5. JSP语法

jsp模板：
jsp页面中的html代码就是jsp的模板
JSP表达式：
语法一：<%=表达式或变量%>
作用：想浏览器输出变量或者表达式的计算结果
注意：
表达式的原理就是翻译成out.print(“内容”)
通过该方法向浏览器写出内容
表达式后面不可以加分号
JSP脚本
语法：<%java代码%>
作用：执行java代码
注意：
1，原理是把Java代码照搬过来
2，可以穿插html代码
<%for(int i=1;i<=6;i++){
%>标题<><%}%>
3，脚本生命的变量是局部变量
4，jsp的定义中不能定义翻译好的方法
JSP声明
语法：<&!变量或者方法&>
作用：声明一个成员变量或者成员方法
注意：变量翻译成成员变量，方法翻译成成员方法。
jsp注释
语法：<%!—注释内容 —%>
注意：html的注释会被翻译，jsp的不会

1. JSP三大指令
   1. inclube指令

作用：于包含其他页面
语法：<%@inclube file=”common/header.jsp”%>
原理：把包含的页面搬到包含的页面之中（out.wirte(html代码)）合并翻译成一个java源文件，
再编译运行，这种包含叫做静态包含（源码包含）
如果使用了被包含页面中不需要出现全局的html标签了！！！（如html、head、body）

1. page指令

作用：告诉Tomcat服务器来翻译jsp文件，（使用什么动态语言来翻译）
<%@ page
language=“java”,告诉服务器使用什么动态语言翻译jsp文件
import=“java.util.*”，告诉服务器java文件使用什么包，导入包，多个包之间用逗号隔开
pageEncding=”utf-8”。告诉服务器使用什么编码翻译jsp文件
contentType=”text/html;charset=utf-8”
errorPage=”error.jsp”服务器发送浏览器的数据类型和内容编码
注意：在开发工具中，以后只需要设置pageEncoding即可解决中文乱码问题
session: 是否开启session功能。false，不能用session内置对象；true，可以使用session内置对象。
buffer: jsp页面的缓存区大小。
isELIgnore： 是否忽略EL表达式。
%>

1. taglib指令
2. jsp文件编码问题：

page指令参数
pageEncoding： 告诉tomcat服务器使用什么编码翻译jsp文件（jsp->java文件）
contentType: tomcat服务器发送给浏览器的数据编码（tomcat服务器->浏览器）

1. 异常错误相关的page指令参数

errorPage: 指定当前jsp页面的错误处理页面。
isErorrPage: 指定当前页面是否为错误处理页面。
false，不是错误处理页面，则不能使用exception内置对象；
true，是错误处理页面，可以使用exception内置对象。

1. 配置全局错误处理页面：
   在web.xml文件中配置

500
/common/500.jsp


404
/common/404.html

1. JSP的内置对象

什么是内置对象，tomcat服务器提前帮我们新建的对象
一共有九个内置对象，sun公司设计jsp得时候，jsp加载完之后会自动帮开发者创建好对象
分别是：

1. out对象

out对象类型，jspWriter类，相当于带缓存的PrintWriter
PrintWriter：
writer（内容）：直接向浏览器输出内容
JspWriter
writer(内容)：向缓存区写出内容
JSP的缓存机制
右侧笔记

1. pageContext（）对象

pageContext对象是的类型是pageContext，叫做jsp的上下文对象

1. 获取其他八个内置对象

1，用于获取其他内置对象，在自定义标签的时候PageContext对象频繁使用
2，本身就是一个域对象，可以把数据保存到域中（也可以存到域中）
使用场景：在使用自定义标签的时候频繁使用

1. 本身一个域对象

ServletContext context域
HttpServletRequet request域
HttpSession session域 —Servlet学习的
PageContext page域 —jsp学习的
作用：保存数据和获取数据，用于共享数据

1. 保存数据
   1. 默认情况下，保存到page域

pageContext.setAttribute(“name”)

1. 可以向四个域对象保存数据

pageContext.setAttribute(“name”)

1. 获取数据
   1. 默认情况下，从page域获取

pageContext.getAttribute(“name”)

1. 可以从四个域中获取数据

pageContext.getAttribute(“name”,域范围常量)
域范围常量:
PageContext.PAGE_SCOPE
PageContext.REQUEST_SCOPE
PageContext..SESSION_SCOPE
PageContext.APPLICATION_SCOPE

1. 自动在四个域中搜索数据

pageContext.findAttribute(“name”);
顺序： page域 -> request域 -> session域- > context域（application域）

JSP的最佳应用
Servlet技术：开发动态资源。是一个java类，写Java代码
JSP技术：开发动态资源，通过java代码，输出html代码
各取所长：
在web项目中涉及的逻辑
1，接收参数 servlet做
2，处理业务逻辑，返回结果，serlvet做
3，显示数据到浏览器，jsp做
4，或者跳转到其他页面。servlet
结论：servlet+jsp模式
servlet：
1，接收参数
2，处理业务逻辑，返回结果
3，显示数据到浏览器
4，把数据存到域对象，跳转到JSP页面
JSP：
1，拿数据从域对象中取出来
2，或者跳转到其他页面
Serlvet通过域对象与JSP页面共享

EL表达式

jsp的核心语法：jsp脚本<%…%>和jsp表达式<%=%>
开发jsp原则：尽量在jsp少些java代码
EL表达式作用：
替换JSP表达式（<%= … %>），向浏览器输出（域对象中的）表达式计算结果或者变量
语法：
1，获取基本数据类型的变量：
1.1 从四个域中获取
${变量或者表达式}
等价于：<%=pageContext.findAttribute(变量或者表达式)%>
1.2 指定域获取
${pageScope.name}
域范围：pageScope/requestScope/sessionScope/applicationScope
2，输出对象的属性值
3，输出集合对象
3.1List
3.2Map
4，EL表达式计算

注意：
1，对象或者表达式必须在域对象之中才可以被EL表达式获取
2，从指定域中获取数据
${pageScope.name}
等价于：
<%=pageContext.getAttribute(“name”,PageContext.PAGE_SCOPE)%>
3，EK

JSP标签

作用：替换JSP脚本，
1，流程判断/跳转页面
分类
1，内置标签（动作标签）：不需要jsp页面导入标签
2，外置标签（jstl标签）：需要在JSP页面中导入
3，自定义标签
内置标签(动作标签)
转发标签：
参数标签：
包含标签：
原理：包含与被包=包含页面先先转化为java源文件，然后再运行合并在一起（先翻译在合并）属于动态包含
静态包含与动态包含区别？
外置标签(jstl标签)
JSTL（全名：java standard tag library - java的标准的标签库）

核心标签库，（c标签库）,最常用
国际化标签库（fmt标签库）
EL函数标签库（fn标签库）
使用JSTL外置标签的步骤
1，导入标签库，需要导入jar架包（jstl和standard，java EE 5.0自动导入此架包）
<%@taglib url=”tld文件的url名称” prefix=”简写”%>，tld文件的作用是声明文件
2，
核心标签库的重点标签
保存标签
获取数据
单条件判断
+ +多条件判断
遍历数据
遍历特殊字符串
重定向
自定义标签

JavaBean

定义：是一种开发规范，也可以说是一种技术
java
1，必须提供无参的构造函数
2，类中的属性必须私有化
3，该类中提供公开的getter和setter
作用：
用户保存和封装数据，访问javaBean只能用这两个方法，getter和setter
使用场景：
1，项目中使用到的实体对象（entity）符合javaBean规范
2，EL表达式访问对象属性，${student.name}，调用getName()方法，符合javaBean规范
3，jsp的标签中属性赋值。
4，JSP页面中（）
特例：boolean类型get方法，是isXXX（）方法

WEB开发模式

两种模式
第一种：jsp+javaBean模式
优点：开发速度快
缺点：维护成本高，扩展性低，jsp页面臃肿。jsp职责过重
不适合完成一些业务复杂，需要经常变动的系统
第二种：servle+jsp+javaBean模式（MVC模式）
Model javabean ：显示数据视图，模型
View：jsp，显示数据视图，视图
Controller：servlet，调度jsp和javabean资源控制器，控制器
注意：分工合作，具体的业务业务逻辑放在java类中（service）

三层结构开发
dao层，数据访问对象。实现对数据的操作相关的方法
service层，业务逻辑对象，实现对项目逻辑处理相关的方法
web层，表现层，处理和用户直接相关的，接收参数，处理参数，跳转视图，展示数据

/