JSTL
1. jstl的概述
* apache的东西，依赖EL
* 使用jstl需要导入jstl1.2.jar
* 四大库：
> core：核心库，重点
> fmt：格式化：日期、数字
> sql：过时
> xml：过时
2. 导入标签库
* jar包
* 在jsp页面中：<%@taglib prefix="前缀" uri="路径"%>
----------------------
core --> c标签！
1. out和set
* <c:out>：输出
> value：可以是字符串常量，也可以是EL表达式
> default：当要输出的内容为null时，会输出default指定的值
> escapeXml：默认值为true，表示转义！
* <c:set>：设置(创建域的属性)
> var：变量名
> value：变量值，可以是EL表达式
> scope：域，默认为page，可选值：page、request、session、application
2. remove
* <remove>：删除域变量
> var：变量名
> scope：如果不给出scope，表示删除所有域中的该名称的变量；如果指定了域，那么只删除该域的变量。
3. url
* value：指定一个路径！它会在路径前面自动添加项目名。
<> <c:url value="/index.jsp"/>，它会输出/day13_1/index.jsp
* 子标签：<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。
4. if：对应java中的if语句
* <c:if test="布尔类型">...</c:if>，当test为值时，执行标签体内容！
5. choose：它对应java中的if/else if/ ... /else
* 例如：
<c:choose>
<c:when test="">...</c:when>
<c:when test="">...</c:when>
<c:when test="">...</c:when>
...
<c:otherwise> ...</c:otherwise>
</c:choose>
等同与
if(...) {
} else if( ....) {
} else if( ....) {
} else if( ....) {
} ...
else { ...}
6. forEach
它用来循环遍历数组、集合！
它还可以用来计数方式来循环！
计数方式：
for(int i = 1; i <= 10; i++) {
...
}
<c:forEach var="i" begin="1" end="10">
${i}
</c:forEach>
属性：
* var：循环变量
* begin：设置循环变量从几开始。
* end：设置循环变量到几结束。
* step：设置步长！等同与java中的i++，或i+=2。step默认为1
----------------------
用来输出数组、集合！
<c:forEach items="${strs }" var="str">
${str }<br/>
</c:forEach>
等同于
for(String str : strs) {
...
}
属性：
* items：指定要循环谁，它可以是一个数组或一个集合
* var：把数组或集合中的每个元素赋值给var指定的变量。
----------------------
循环状态
可以使用varStatus来创建循环状态变量！
循环状态变量有如下属性：
* 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位，不补位！
====================================
自定义标签
1. 步骤
* 标签处理类（标签也是一个对象，那么就需要先有类！）
* tld文件，它是一个xml
* 页面中使用<%@taglib%>来指定tld文件的位置
2. 标签处理类
SimpleTag接口：
* void doTag()：每次执行标签时都会调用这个方法；
* JspTag getParent()：返回父标签（非生命周期方法）
* void setParent(JspTag)：设置父标签
* void setJspBody(JspFragment)：设置标签体
* void seetJspContext(JspContext)：设置jsp上下文对象，它儿子是PageContext
其中doTag()会在其他三个方法之后被tomcat调用。
3. 配置tld文件
tld文件一般都放到WEB-INF之下，这样保证客户端访问不到！
<tag>
<name>myTag1</name> 指定当前标签的名称
<tag-class>com.example.tag.MyTag1</tag-class> 指定当前标签的标签处理类！
<body-content>empty</body-content> 指定标签体的类型，我们这里使用的是空标签！
</tag>
4. 页面中指定tld文件位置
<%@ taglib prefix="ex" uri="/WEB-INF/tlds/example-tag.tld" %>
导标签库，就是为页面指定tld文件的位置！
-------------------------------
进阶
标签体内容
* empty：无标签体！
* JSP：jsp2.0已经不在支持这个类型了！表示标签体内容可以是：java脚本，可以是标签，可以是el表达式
* scriptless：只能是EL表达式，也可以是其他的标签！
* tagdependent：标签体内容不会被执行，而是直接赋值标签处理类！
不在执行标签下面内容的标签！
在标签处理类中的doTag()中使用SkipPageException来结束！
Tomcat会调用标签处理类的doTag()方法，然后Tomcat会得到SkipPageException，它会跳过本页面其他内容！
---------------
标签属性
步骤：
1. 给你的标签处理类添加属性！
为标签处理类添加属性，属性至少要且一个set方法！这个set方法会在doTag()方法之前被tomcat执行！所在doTag()中就可以使用属性了。
2. 在tld文件中对属性进行配置
<attribute>
<name>test</name> 指定属性名
<required>true</required> 指定属性是否为必需的
<rtexprvalue>true</rtexprvalue> 指定属性是否可以使用EL
</attribute>
==========================================
MVC
它不是java独有，所有的B/S结构的项目都在使用它！
M -- model 模型(自己写代码)
V -- View 视图(jsp)
C -- Cotroller 控制器(Servlet)
==========================================
JavaWeb三层框架
Web层 --> 与Web相关的内容(Servlet，JSP，Servlet相关API：request、response、session、ServletContext)
业务层 --> 业务对象(Service)
数据层 --> 操作数据库(DAO Data Access Object)(所有对数据库的操作，不能跳出到DAO之外)
JSTL
Apache提供的标签库，
jar包：jstl-1.2.jar，如果傅MyEclipse，它会在我们导入jar包，无需自己导入，如果没有使用MyEclipse那么需要自行导入。
------------------
导入JSTL核心标签库
<%taglib prefix="c" uri="http://java.sun.com/jstl/core"%>
<c:set>
* <c:set var="a" value="hello"/> 创建名为a,值为hello的域属性，范围：page
* <c:set var="a" value="hello" scope="session"/> 范围为session
<c:out>
* <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攻击
域对象中有相同的属性名时，优先级：pageContext > 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:url value="/AServlet">：输出URL：/项目名/AServlet?username=%xx%xx%xx%xx%xx%xx，其中张三会被URL编码
<c:param name="username" value="张三"/>
</c:url/>
<c:if>
* <c:if test="${条件}"> 当条件为true时执行标签体内容
hello
</c:if>
<c:choose>
* <c:choose>
<c:when test="${条件1}">a</c:when>
<c:when test="${条件2}">b</c:when>
<c:when test="${条件3}">c</c:when>
<c:otherwise>d</c:otherwise>
</c:choose>
等同与：
if() {
} esle if() {
} esle if() {
} else if() {
} else {
}
-------------
<c:forEach>
可以用来遍历数组、List、Map、
1. 计数循环
<c:forEach begin="1" end="10" var="i">
${i}
</c:forEach>
等同于
for(int i = 1; i <= 10; i++) {
out.println(i);
}
<c:forEach begin="1" end="10" var="i" step="2">
${i}
</c:forEach>
等同于
for(int i = 1; i <= 10; i+=2) {
out.println(i);
}
-------------
2. 遍历数组
<%
String[] names = {"zhangSan", "liSi", "wangWu", "zhaoLiu"};
pageContext.setAttribute("ns", names);
%>
<c:forEach var="item " items="${ns } ">
<c:out value="name: ${item } "/><br/>
</c:forEach>
-------------
3. 遍历List
<%
List<String> names = new ArrayList<String>();
names.add("zhangSan");
names.add("liSi");
names.add("wangWu");
names.add("zhaoLiu");
pageContext.setAttribute("ns", names);
%>
<c:forEach var="item" items="${ns }">
<c:out value="name: ${item }"/><br/>
</c:forEach>
-------------
4. 遍历Map
<%
Map<String,String> stu = new LinkedHashMap<String,String>();
stu.put("number", "N_1001");
stu.put("name", "zhangSan");
stu.put("age", "23");
stu.put("sex", "male");
pageContext.setAttribute("stu", stu);
%>
<c:forEach var="item " items="${stu }">
<c:out value="${item.key }: ${item.value } "/><br/>
</c:forEach>
-------------
5. 循环状态对象
循环状态对象是用来说明循环的状态的，属性如下：
count：int类型，当前以遍历元素的个数；
index：int类型，当前元素的下标；
first：boolean类型，是否为第一个元素；
last：boolean类型，是否为最后一个元素；
current：Object类型，表示当前项目。
<c:forEach var="item" items="${ns }" varStatus="vs" >
<c:if test="${vs.first } ">第一行：</c:if>
<c:if test="${vs.last } ">最后一行：</c:if>
<c:out value="第${vs.count } 行: "/>
<c:out value="[${vs.index } ]: "/>
<c:out value="name: ${vs.current } "/><br/>
</c:forEach>
------------------
导入JSTL格式化标签库
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%
Date date = new Date();
pageContext.setAttribute("d", date);
%>
<fmt:formatDate value="${d }" pattern="yyyy-MM-dd HH:mm:ss "/>
---------
<%
double d1 = 3.5;
double d2 = 4.4;
pageContext.setAttribute("d1", d1);
pageContext.setAttribute("d2", d2);
%>
<fmt:formatNumber value="${d1 }" pattern="0.00 "/><br/>
<fmt:formatNumber value="${d2 }" pattern="#.## "/>
* pattern：0.00，表示小数不足两位时，使用0补足两位
* pattern：#.##，表示小数不足两位时，有几位显示几位，不会补足
============================
============================
============================
自定义标签
自定义标签：
1. 实现Tag接口，即传统标签。不建议使用！
2. 实现SimpleTag接口，即简单标签。建议使用！
JavaWeb中还提供了SimpleTagSupport类，继承它要比实现SimpleTag接口方便。
-----------------
步骤：
1. 标签处理类：继承SimpleTagSupport类
public class HelloTag extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
// 获取JspContext对象，再获取out对象，再向页面输出
// 获取到的JspContext其实就是当前页面的pageContext对象
this.getJspContext().getOut().write("<p>Hello SimpleTag!</p>") ;
}
}
2. 标签描述符文件(tld)
/WEB-INF/tlds/example.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>example</short-name>
<uri>http://www.example.com/tags</uri>
<tag>
<name>hello</name> <!--标签名称-->
<tag-class>com.example.tag.HelloTag</tag-class> <!--标签处理类名称-->
<body-content>empty</body-content> <!--标签体为空，即空标签-->
</tag>
</taglib>
3. jsp页面中使用自定义标签
<%@ taglib prefix="ex" uri="/WEB-INF/hello.tld" %>
......
<ex: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>com.example.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>com.example.tag.IfTag</tag-class>
<body-content>scriptless</body-content>
<!--部署属性-->
<attribute>
<name>test</name> <!--属性名-->
<required>true</required> <!--属性是否为必须的-->
<rtexprvalue>true</rtexprvalue> <!--属性值是否可以为EL或JSTL等-->
</attribute>
</tag>
-------------------
MVC
1. 什么是MVC
MVC模式（Model-View-Controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。
* 控制器Controller：对请求进行处理，负责请求转发；
* 视图View：界面设计人员进行图形界面设计；
* 模型Model：程序编写程序应用的功能（实现算法等等）、数据库管理；
2. Java与MVC
JSP Model1第一代：JSP + DB
JSP Model1第二代：JSP + javabean + DB
JSP Model2：JSP + Servlet + JavaBean + DB
-------------------
JavaWeb三层框架
* Web层（表述层）：与Web相关的，例如jsp、servlet都是Web层
* Business层（业务逻辑层）：封装业务逻辑，通常对应一个业务功能，例如登录、注册都是一个业务功能。
* Data层（数据访问层）：封装对数据库的操作，通常对应一次对数据库的访问，例如添加、修改、删除、查询等。
自定义标签
1 自定义标签概述
1.1 自定义标签的步骤
其实我们在JSP页面中使用标签就等于调用某个对象的某个方法一样，例如：<c:if test=””>，这就是在调用对象的方法一样。自定义标签其实就是自定义类一样！
定义标签处理类：必须是Tag或SimpleTag的实现类；
编写标签库描述符文件（TLD）；
SimpleTag接口是JSP2.0中新给出的接口，用来简化自定义标签，所以现在我们基本上都是使用SimpleTag。
Tag是老的，传统的自定义标签时使用的接口，现在不建议使用它了。
1.2 SimpleTag接口介绍
SimpleTag接口内容如下：
void doTag()：标签执行方法；
JspTag getParent()：获取父标签；
void setParent(JspTag parent)：设置父标签
void setJspContext(JspContext context)：设置PageContext
void setJspBody(JspFragment jspBody)：设置标签体对象；
请记住，万物皆对象！在JSP页面中的标签也是对象！你可以通过查看JSP的“真身”清楚的知道，所有标签都会变成对象的方法调用。标签对应的类我们称之为“标签处理类”！
标签的生命周期：
当容器（Tomcat）第一次执行到某个标签时，会创建标签处理类的实例；
然后调用setJspContext(JspContext)方法，把当前JSP页面的pageContext对象传递给这个方法；
如果当前标签有父标签，那么使用父标签的标签处理类对象调用setParent(JspTag)方法；
如果标签有标签体，那么把标签体转换成JspFragment对象，然后调用setJspBody()方法；
每次执行标签时，都调用doTag()方法，它是标签处理方法。
HelloTag.java
public class HelloTag implements SimpleTag {
private JspTag parent;
private PageContext pageContext;
private JspFragment jspBody;
public void doTag() throws JspException, IOException {
pageContext.getOut().print("Hello Tag!!!");
}
public void setParent(JspTag parent) {
this.parent = parent;
}
public JspTag getParent() {
return this.parent;
}
public void setJspContext(JspContext pc) {
this.pageContext = (PageContext) pc;
}
public void setJspBody(JspFragment jspBody) {
this.jspBody = jspBody;
}
}
1.3 标签库描述文件（TLD）
标签库描述文件是用来描述当前标签库中的标签的！标签库描述文件的扩展名为tld，你可以把它放到WEB-INF下，这样就不会被客户端直接访问到了。
hello.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>example</short-name>
<uri>http://www.example.com/tags</uri>
<tag>
<name>hello</name>
<tag-class>com.example.tag.HelloTag</tag-class>
<body-content>empty</body-content>
</tag>
</taglib>
1.4 使用标签
在页面中使用标签分为两步：
使用taglib导入标签库；
使用标签；
<%@ taglib prefix="ex" uri="/WEB-INF/hello.tld" %>
......
<ex:hello/>
2 自定义标签进阶
2.1 继承SimpleTagSupport
继承SimpleTagSuppport要比实现SimpleTag接口方便太多了，现在你只需要重写doTag()方法，其他方法都已经被SimpleTagSuppport完成了。
public class HelloTag extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
this.getJspContext().getOut().write("<p>Hello SimpleTag!</p>");
}
}
2.2 有标签体的标签
我们先来看看标签体内容的可选值：
<body-content>元素的可选值有：
empty：无标签体。
JSP：传统标签支持它，SimpleTag已经不再支持使用<body-content>JSP</body-content>。标签体内容可以是任何东西：EL、JSTL、<%=%>、<%%>，以及html；
scriptless：标签体内容不能是Java脚本，但可以是EL、JSTL等。在SimpleTag中，如果需要有标签体，那么就使用该选项；
tagdependent：标签体内容不做运算，由标签处理类自行处理，无论标签体内容是EL、JSP、JSTL，都不会做运算。这个选项几乎没有人会使用！
自定义有标签体的标签需要：
获取标签体对象：JspFragment jspBody = getJspBody();；
把标签体内容输出到页面：jspBody.invoke(null)；
tld中指定标签内容类型：scriptless。
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);
}
}
}
<tag>
<name>hello</name>
<tag-class>com.example.tags.HelloTag</tag-class>
<body-content>scriptless</body-content>
</tag>
<ex:hello>
<h1>哈哈哈~</h1>
</ex:hello>
2.3 不执行标签下面的页面内容
如果希望在执行了自定义标签后，不再执行JSP页面下面的东西，那么就需要在doTag()方法中使用SkipPageException。
public class SkipTag extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
this.getJspContext().getOut().print("<h1>只能看到我！</h1>");
throw new SkipPageException();
}
}
<tag>
<name>skip</name>
<tag-class>com.example.tags.SkipTag</tag-class>
<body-content>empty</body-content>
</tag>
<ex:skip/>
<h1>看不见我！</h1>
2.4 带有属性的标签
一般标签都会带有属性，例如<c:if test=””>，其中test就是一个boolean类型的属性。完成带有属性的标签需要：
在处理类中给出JavaBean属性（提供get/set方法）；
在TLD中部属相关属性。
public class IfTag extends SimpleTagSupport {
private boolean test;
public boolean isTest() {
return test;
}
public void setTest(boolean test) {
this.test = test;
}
@Override
public void doTag() throws JspException, IOException {
if(test) {
this.getJspBody().invoke(null);
}
}
}
<tag>
<name>if</name>
<tag-class>com.example.tag.IfTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<name>test</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
<%
pageContext.setAttribute("one", true);
pageContext.setAttribute("two", false);
%>
<it:if test="${one }">xixi</it:if>
<it:if test="${two }">haha</it:if>
<it:if test="true">hehe</it:if>
1 MVC设计模式
MVC设计模式
MVC模式（Model-View-Controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。
MVC模式最早为Trygve Reenskaug提出，为施乐帕罗奥多研究中心（Xerox PARC）的Smalltalk语言发明的一种软件设计模式。
MVC可对程序的后期维护和扩展提供了方便，并且使程序某些部分的重用提供了方便。而且MVC也使程序简化，更加直观。
控制器Controller：对请求进行处理，负责请求转发；
视图View：界面设计人员进行图形界面设计；
模型Model：程序编写程序应用的功能（实现算法等等）、数据库管理；
注意，MVC不是Java的东西，几乎现在所有B/S结构的软件都采用了MVC设计模式。但是要注意，MVC在B/S结构软件并没有完全实现，例如在我们今后的B/S软件中并不会有事件驱动！
2 JavaWeb与MVC
JavaWeb的经历了JSP Model1、JSP Model1二代、JSP Model2三个时期。
2.1 JSP Model1第一代
JSP Model1是JavaWeb早期的模型，它适合小型Web项目，开发成本低！Model1第一代时期，服务器端只有JSP页面，所有的操作都在JSP页面中，连访问数据库的API也在JSP页面中完成。也就是说，所有的东西都耦合在一起，对后期的维护和扩展极为不利。
2.2 JSP Model1第二代
JSP Model1第二代有所改进，把业务逻辑的内容放到了JavaBean中，而JSP页面负责显示以及请求调度的工作。虽然第二代比第一代好了些，但还让JSP做了过多的工作，JSP中把视图工作和请求调度（控制器）的工作耦合在一起了。
2.3 JSP Model2
JSP Model2模式已经可以清晰的看到MVC完整的结构了。
JSP：视图层，用来与用户打交道。负责接收用来的数据，以及显示数据给用户；
Servlet：控制层，负责找到合适的模型对象来处理业务逻辑，转发到合适的视图；
JavaBean：模型层，完成具体的业务工作，例如：开启、转账等。
JSP Model2适合多人合作开发大型的Web项目，各司其职，互不干涉，有利于开发中的分工，有利于组件的重用。但是，Web项目的开发难度加大，同时对开发人员的技术要求也提高了。
JavaWeb经典三层框架
我们常说的三层框架是由JavaWeb提出的，也就是说这是JavaWeb独有的！
所谓三层是表述层（WEB层）、业务逻辑层（Business Logic），以及数据访问层（Data Access）。
WEB层：包含JSP和Servlet等与WEB相关的内容；
业务层：业务层中不包含JavaWeb API，它只关心业务逻辑；
数据层：封装了对数据库的访问细节；
注意，在业务层中不能出现JavaWeb API，例如request、response等。也就是说，业务层代码是可重用的，甚至可以应用到非Web环境中。业务层的每个方法可以理解成一个万能，例如转账业务方法。业务层依赖数据层，而Web层依赖业务层！