JSP/SERVLET/JAVABEAN
第一章 JavaEE概述
Java平台的版本：
Java SE:窗体、控制台应用程序
Java ME:嵌入式开发——手机、移动设备
Java EE:Web Application
Java EE的体系结构：
1、表示层（HTML、JavaScript、Ajax）
2、中间层（JSP、Servlet、JSTL、JavaBean）（Struts）
3、数据层（JDBC）（Hibernate）
三层体系结构的优点：
1、耦合性低2、扩展性好3、重用性好4、便于分工
系统集成技术
1、JAX-WS 2、JNDI
HTTP协议的提交方式
1、GET ——用URL传递数据
2、POST ——用流的方式传递数据
GET和POST的区别：
1、GET方式在地址栏中有数据显示，POST没有
2、GET提交的数据量有限，POST没有
3、GET请求的页面可以设置为书签或通过EMAIL发送，POST不行
第二章 Servlet基础
什么是Servlet：Servlet是一个Java程序，是在服务器端运行的以处理客户端请求并做出响应的程序。 Servlet类一定要继承HttpServlet,Servlet必须和Servlet容器配合运行,Servlet要嵌入容器才能运行。
Web应用程序的结构：
tomcat-webapps-appName:
http://ip:port/appName/index.jsp
1、页面和图片（可以自己组织结构，可以从客户端直接访问，jsp、html、js、jpg……）
2、WEB-INF目录（必须的，其中的东西不能从客户端直接访问）
a、web.xml（必须的，这个Web程序的总体的配置，是一个核心）
b、classes文件夹（必须的，Servlet和JavaBean编译成Class后存放于该文件夹） c、lib文件夹（存放该程序用到的类库Jar包）
Web.XML中要对Servlet进行一些配置
<servlet>
<servlet-name>test</servlet-name>
<servlet-class>org.owl.servlets.TestServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>test</servlet-name>
<url-pattern>/test</url-pattern>
</servlet-mapping>
doPost
doGet
service
JSP在运行时需要翻译成一个Servlet程序，然后在编译成Class文件，然后才可以运行。
Servlet的生命周期由Servlet容器来管理
Servlet的生命周期：
1、加载和实例化（构造方法）：在Web容器中查找用户请求的Servlet，如果没有找到，则实例化，如果找
到加载。
2、初始化（init）：在实例化后调用的方法，可以初始化一些资源。
3、服务（service）：接收请求并做出响应。根据请求的方式不同，调用doXXX方法。
4、销毁（destory）：主要用来销毁初始化时创建的资源，在destory方法中我们标识那些资源可以回收，并不能马上回收。
加载——实例化——初始化——服务——
加载——服务——
加载——服务——
销毁
HttpServlet——基类
MyServlet——派生类
HttpServlet ms = Class.forname("org.owl.MyServlet").getInstance();
容器使用Servlet的伪代码
HttpServlet s = container.getServlet("name");——加载
if(s == null){
s = Class.forname("org.owl.MyServlet").getInstance();——实例化
s.init();——初始化
container.setServlet("name",s);
}
s.service(request,response);——服务
.s.destory();——销毁
s = null;
HttpServletRequest常用方法：
getParameter方法：获得页面传过来的数据
setCharacterEncoding方法：设置请求的编码字符集
setAttribute,getAttribute方法：用于在request中存储一些信息，他们的生命周期就是一个请求的期间。
getRequestDispatcher方法：用于获得一个RequestDispatcher对象，应用于请求转发。 HttpServletResponse常用方法：
setContentType方法：设置响应的字符集和格式
sendRedirect方法：重定向。
getWriter方法：获得向客户端输出字符信息的对象。
RequestDispatcher常用方法
forward方法：请求转发
include方法：服务器端包含
重定向：
客户端发送请求到服务器端，如果服务器端需要重定向，那么将需要重定向到的地址发送给客户端， 客户端再向该地址提出请求。
请求转发：
客户端发送请求到服务器端，如果服务器端需要请求转发，那么服务器端直接把请求传送给另一个servlet或jsp，由其向客户端返回响应。
请求转发(request.getRequestDispacther("1.jsp").forword(request,response))
与重定向(response.sendRedirect("1.jsp"))的区别
1、重定向地址栏地址改变，请求转发不变；
2、重定向可以跳转到站外页面，请求转发不能；
3、重定向不能保存request中的数据，请求转发可以。
第三章 基于Servlet的会话跟踪（一）
HTTP协议无状态
Session指的是在一段时间内，单个客户与Web服务器之间一连串相关的交互过程
Session是通过SessionID来确认是否是一个session过程
Session是一个HttpSession类的实例。
通过request的getSession方法来获取Session
无参数的方法和参数是true方法是一样的，获取匹配的Session，如果无匹配，返回一个新的Session对象。
如果参数是false的话，如果无匹配的Session，返回null
使用Session
利用其setAttribute设置session，使用其getAttribute方法来获取session中的内容。
结束一个Session
1、关闭浏览器
2、当两次访问的时间超过了Session的最大非活动时间间隔
3、调用Session的invalidate方法使一个Session无效
由于Session的易失性，在获取数据后要进行判断。
第四章 基于Servlet的会话跟踪（二）
常用的集合类和接口
集合类分为两种：
1、Collection（单一元素的集合）
2、Map（键值对的集合）
Collection
1、List（有序、元素可以重复）——ArrayList、LinkedList
2、Set（无序、元素不能重复）——HashSet、TreeSet
Map——HashMap、Properties
第五章 基于Servlet的MVC设计模式
设计模式使一套被反复使用，成功的代码设计经验的总结。
MVC设计模式
1、M（Model）模型：JavaBean
2、V（View）视图：JSP
3、C（Controller）控制器：Servlet
优点：
1、各施其职、互不干涉
2、有利于开发中的分工
3、有利于组件的重用
客户端提交请求到C，C获取客户端数据，根据不同的请求调用不同的M，并获得M的结果，根据结果的不同，选择不同的V，V将结果显示给客户端。
V：显示数据，与客户端交互
C：获取客户端数据；调用M；选择V
M：业务逻辑；数据库访问
第六章 Model层开发：高级JDBC
我们需要什么样的数据访问层：
1、完成CRUD操作
2、能够处理数据库发生的各种错误（自定义异常）
3、可以灵活的修改配置（配置文件）
4、提供方便使用的工具（通用DAO）
5、高性能（数据库连接池）
连接池：一个存放着很多连接的容器。
数据源：对容器进行管理的对象
JNDI：获取数据源的方式
在Tomcat中配置连接池并使用：
1、将驱动Jar放入Tomcat中的lib目录（如果是5.0的话，放入tomcat中的common中的lib目录）；
2、修改Tomcat中conf目录中的context.xml配置文件，加入一个Resource标签。
3、在自己项目中的Web.xml中配置Resource-ref标签
4、编写程序，获取数据源
import javax.naming.*;
Context ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookUp("java:comp/env/jdbc/book"); Connection cn = ds.getConnection();
如果JNDI名字是jdbc/book
lookUp方法中的名字应写成：java:comp/env/jdbc/book
属性文件：*.properties
因为Java中有一个类Properties可以用这个类的load方法直接读取*.properties文件。 属性文件如何存储：
键值对的方式，key=value
一行一个键值对
public class Sss{
private static Sss ss = null;
private Sss(){
}
private syn void Init(){
if(ss == null)
ss = new Sss();
}
public static Sss getInstance(){
Init();
return ss;
}
}
Sss ss = Sss.getInstance();
自定义异常：
所有的异常的父类：Throwable
Exception就是Throwable的子类
throw关键字用于抛出异常，throws关键字用于将方法中的异常传递给调用类来处理。 自定义异常可以让我们更方便的看懂异常信息
通用DAO类
Result 相当于C#中的DataTable
ResultSupport 相当于C#中的DataAdapter
第七章 View层开发：JavaBean在JSP中的使用
JavaBean实际上就是一个Java类
1、封装数据
2、封装业务
JavaBean要满足的要求：
1、公有类，公有的无参的构造方法
2、属性私有（field）
3、公有的Getter和Setter方法。
属性，特性（property）
根据Getter和Setter方法来的
1、将Getter和Setter方法中的get和set去掉，剩下的部分首字母变为小写
例如，getName,setName，属性名为name
2、如果剩下的部分前两个字母都是大写，那么首字母不变为小写
例如，getUName,setUName，属性名为UName
JSP标准动作
1、useBean:( <jsp:useBean /> )：获取或者创建JavaBean对象
id 必须有的，代表JavaBean的变量名
class 一个类型，新创建出来的JavaBean的数据类型
type 一个类型，获取对象以后将其转换为那种类型
scope 作用域，可选的参数，默认值是page
class和type必须得有一个，不能都没有，但是可以都有，type和class可以不一样，type指定的类型一定是class指定的类型的父类或者其实现的接口。
scope有四个值：从小到大——page，request，session，application
<jsp:useBean id="test" class="org.owl.User" scope="session"/>
User test = (User)session.getAttribute("test");
if(test == null){
test = new User();
session.setAttribute("test",test);
}
<jsp:useBean id="test" type="org.owl.Person" scope="session"/>
Person test = (Person)session.getAttribute("test");
if(test == null) throw new Exception();
<jsp:useBean id="test" type="org.owl.Person" class="org.owl.User" scope="session"/>
Person test = (Person)session.getAttribute("test");
if(test == null){
test = new User();
session.setAttribute("test",test);
}
2、setProperty：给JavaBean对象的属性赋值。
name 必须有，对应的是JavaBean的名称，（例如useBean标签的id属性的值）
property 必须有，指定的JavaBean的属性（property）名称
value 给属性赋的值
param 上一页表单的表单元素的名字
不使用useBean的时候，也可以使用setProperty
value属性和param属性不可以同时出现，要么只能出现一个，或者一个也不出现。
都不出现时，只要上一页表单元素的名称和属性名称正好相同，那么可以自动给属性赋值。
还可以给property属性赋值为*，那么就会将上一页所有的与JavaBean属性名称相同的表单元素的值赋给JavaBean相对应的属性。
<jsp:setProperty name="test" property="name" value="tom"/>
test.setName("tom");
<jsp:setProperty name="test" property="name" param="userName"/>
test.setName(request.getParameter("userName"));
<jsp:setProperty name="test" property="name"/>
test.setName(request.getParameter("name"));
<jsp:setProperty name="test" property="*"/>
3、getProperty：获取指定JavaBean的某个属性的值并输出
name 必须有
property 必须有
如果property指定的属性的值是null，会输出null
如果name指定的对象的值是null，会抛出异常
4、forward：请求转发
page: 转发到的页面地址
Model I JSP+JAVABEAN 中小型项目
Model II JSP+JAVABEAN+SERVLET 大型项目
第八章 View层开发：EL和JSTL
JSP 2.0版本开始
语法：${ 表达式 }
点号操作符，中括号操作符
中括号操作符可以替换点号操作符，但是反之不可以
${bean.name} 等价于 ${bean["name"]}
${beans[0]},${beans["0"]}
EL的隐式对象
作用域：
pageScope
requestScope
sessionScope
applicationScope
参数访问：
param
paramValues
JSP隐式对象：
pageContext
<input name="name"/><input name="name"/><input name="name"/> ${param.name}
${paramValues[0]}
JSTL——JSP标准标签库
非常好的支持EL，或者说没有EL,JSTL不能正常运作
标签描述文件——扩展名tld
要使用必须在页面上面添加taglib指令
<%@ taglib uri="" prefix="" %>
核心标签库（默认的前缀是c）
通用标签
set 获取或者创建JavaBean
var 变量名
value 值（EL）
scope 作用域
remove删除JavaBean对象
var 变量名
scope 作用域
out 输出一个值
value 输出的值（EL）
条件标签
if 条件分支
test 布尔类型的值（EL），当test的值是true的时候运行标签体中的代码 var 变量名
scope 作用域
迭代标签
foreach 迭代循环
var 变量名（迭代变量）
items 集合（EL）
varStatus 循环状态变量（属性：index——从零开始，count——从1开始） start 开始索引
end 结束索引
step 步长
SQL标签库（默认的前缀是sql）
setDataSource 创建或者获取数据源
update 增删改
query 查询
param 是update和query的子标签，用于给其中的sql语句设置参数
第九章 Web服务
Web服务是为实现“基于Web无缝集成”的目标而提出的全新概念，希望通过Web服务能够实现不同的系统之间的相互调用，从而实现系统集成的平台无关性、语言无关性。
Web服务是一个应用程序，它为调用者提供一个能够通过Web进行调用的API。
Web服务应用的协议：HTTP、SMTP、TCP/IP
传输的数据格式：XML
数据格式限制协议：SOAP
让调用者知道如何访问发布的Web服务，描述方法：WSDL（方法名，方法参数，参数的数据类型，返回值，返回值的数据类型）
如何利用XFire创建Web服务
1、加入XFire的Jar包
2、在Web.xml中配置XFire
3、开发接口
4、开发实现类
5、编写services.xml
6、发布Web服务
7、调用Web服务
JUnit测试
测试类一定要继承或者间接继承TestCase类
测试方法一定要叫做testXXX
开发基于Struts/Spring/Hibernate/Ajax的网上信息发布平台
第一章 框架技术概述
框架是一个提供了可重用的公共结构的半成品
框架的优点（为什么使用框架）
1、不用再考虑公共问题
2、可以专心在业务逻辑上
3、结构统一，便于学习和维护
4、新手也可以写出稳健、性能优良而且结构优美的高质量程序
第二章 Struts原理（一）
创建应用Struts的程序需要的步骤：
1、添加Struts支持（准备过程）
添加Struts的Jar包
在Web.xml中配置ActionServlet
在WEB-INF中添加Struts-Config.xml配置文件
2、编写业务逻辑
3、编写Struts组件
a、编写ActionForm（FormBean）
ActionForm实际上对应的是表单，理论上有几个表单就有几个ActionForm
FormBean的类一定要继承ActionForm这个类
要写与表单元素对应的属性，属性名称要与表单元素的名称一致
承担了一个将客户端传上来的数据封装起来的作用
b、编写Action（ActionBean）
是ActionServlet的扩展
所有的ActionBean的类都要继承Action这个类
要重写Action中的execute方法
参数：ActionMapping,ActionForm,HttpServletRequest,HttpServletResponse 返回值：ActionForward
c、编写JSP
d、配置Struts-config.xml
配置FormBean
在form-beans标签体中，配置form-bean标签
name formbean的名称
type formbean的完全限定名
配置ActionBean
在Action-Mappings标签中配置Action标签
path 代表Action的访问路径，必须以/开头
type ActionBean的完全限定名
name 与这个Action相关的FormBean的名称
scope 相关的FormBean的存入的作用域
attribute 相关的FormBean存入作用域时使用的名称
input 表明由谁来访问此Action，主要作用是当出错时可以自动跳转到 该路径，也必须以/开头
在Action标签中配置Forward标签
name forward对象的名称
path forward对象对应的路径，必须以/开头
4、调试运行
Struts包括三种组件
控制器组件：ActionServlet和自定义的Action
模型组件： 业务逻辑类和数据访问类
视图组件：JSP、ActionForm和Struts标签
运行原理：
客户端发送请求到ActionServlet（比如在web.xml中设置的url-pattern是*.do，那么所有的以.do结尾的请求都会发送给ActionServlet）
ActionServlet将.do去掉获得请求的名称（如add.do的话，就取出add）
ActionServlet将去struts-config.xml中查找所有的Action配置中path属性是/add的配置
然后ActionServlet取出该配置中的type属性，利用反射创建出该类对象，试图去调用其execute方法 execute方法有四个参数，要构建出来
创建ActionMapping：将刚才找到Action配置转换成为一个ActionMapping的对象，包括配置中的Forward集合
创建ActionForm：从该Action配置中找到name属性，取出其值，去所有的FormBean配置中查找name属性值相同的FormBean配置，然后取出其type属性，用反射创建该FormBean对象。根据该FormBean的属性名称去request中取表单传过来的数据，并为其属性赋值。
这样就可以调用ActionBean的execute方法了
execute方法返回一个ActionForward对象。（从ActionMapping的Forwards集合中利用forward的名称查找出来的）
ActionServlet根据该ActionForward对象的path跳转到相应的JSP（请求转发）
第三章 Struts原理（二）
DispatchAction是Action的一个子类
使用：
1、自定义Action类要继承DispatchAction
2、Action配置中要加入一个属性parameter（必须加）
3、DispatchAction中不推荐实现execute方法
4、其中的方法虽然和execute方法基本一样，但是名字不能叫做execute
例如，parameter属性的值为op
在客户端提出请求的时候要多传一个op参数过来，例如op=add（可以利用url重写，也可以利用隐藏表单域）
DispatchAction得到op参数后，会根据其值自动调用相应的方法。例如op=add的话就会去调用Add方法。
在Struts中有一个资源文件，利用他可以实现国际化资源配置
struts-config.xml中配置<message-resource parameter="com.aptech.jb.Messages" /> com.aptech.jb.Messages主资源文件
com.aptech.jb.Messages_zh_CN中国中文资源文件
com.aptech.jb.Messages_en_GB英国英文资源文件
资源文件转码我们可以利用native2ascii命令
利用ActionMessages类作为错误消息的集合
利用ActionMessage类作为错误消息
利用Action类提供的saveErrors方法来存储错误集合
错误集合是存储在request中的
在JSP中利用<html:errors/>标签来显示错误信息
如果要单独显示某一条错误信息，为该标签制定property属性
errors.header=<h1>
errors.footer=</h1>
error.validate.number=cuole
动态Form
配置
<form-bean name="xxForm" type="org.apache.struts.action.DynaAcitonForm"> <form-property name="xxx" type="java.lang.String"/>
</form>
调用
DynaActionForm f = (DynaActionForm)form;
String str = (String)f.get("xxx");
理用实体对象作为ActionForm的属性
作为属性的实体类必须得实例化。
如：private User user = new User();
private String name;
<input name="name"/>
在页面表单上怎么写
写Formbean的属性名称加上点，再加上formbean的属性的属性名称
如：<input name="user.name" type="text" />
第四章 Struts标签库
HTML
form标签（默认是post提交，action属性中可以直接写Action配置中path属性的值） Select标签->option标签
optionsCollection
name 从某个作用域中取出的某个对象的名称（集合）
label 显示的属性名称（集合中存储的元素的类中用于显示的属性名）
value 作为值的属性名称。
一旦用了Struts的HTML标签，这些HTML标签会在第一次访问该页面时就去查找表单对应的FormBean的属性的值。
LOGIC
empty标签和notEmpty标签：判断某个作用域中的某个对象或其某个属性是否为null
name user
scope session
property name
equal和notEqual标签：判断某个作用域中的某个对象或其某个属性是否和特定的值相等 name user
property name
value tom
scope session
iterate标签：迭代
id user
name class
scope session
property users
BEAN
write标签：输出某个作用域中的某个对象或其某个属性的值
name： user
property： birthday
scope： session
format： yyyy-MM-dd
define标签：将某个作用域中的某个对象或其某个属性定义一个可以在页面中使用的变量 id： userName
property: name
type： org.owl.User
name： user
scope： session
size标签：取出集合的元素个数，不具备输出功能
id： listSize
name：（集合） list
属性总结：
id： 新生成的变量的名称
name： 某个作用域中的某个对象的名称
property： 某个对象的某个属性名称
scope： 某个作用域
第五章 使用Hibernate完成对象持久化
持久化的概念：数据在瞬时状态和持久状态之间转换的过程。
ORM的概念：对象关系映射
Hibernate是一个持久化框架，是一个优秀的ORM框架
使用Hibernate的基本步骤
三个准备
1、导入需要的Jar文件
2、准备Hibernate的配置文件（hibernate.cfg.xml）
a、dialect（方言）——确定使用那种数据库
b、数据库的连接信息——Driver、Url、userName、password
c、一些Hibernate的特殊配置——show_sql
d、mapping标签，resource属性：指定映射文件的位置
3、创建实体类和映射文件（*.hbm.xml）
a、实体类就是简单的POJO类：
b、映射文件：
根元素：hibernate-mapping
class标签：（一个实体类）
name：实体类的完全限定名(org.owl.entity.User)
table：与之对应的表名(Users)
id标签：（主键）
name：实体类中的属性名(id)
type：类型(java.lang.Integer)
column：表中的主键列的列名(UserId)
generator子标签（主键生成策略）
class：native（交给数据库自己管理）,assgined（我们程序决定主键） property标签：（普通列）
name：(name)
type：(java.lang.String)
column：(UserName)
七个步骤
1、Configuration（读取并解析配置文件） Configuration conf = Configuration().configure();
2、SessionFactory（读取并解析映射文件） SessionFactory sf conf.buildSessionFactory();
3、Session（打开Session） Session s = sf.openSession();
4、beginTransaction（开启事务） Transaction tx = s.beginTransaction();
5、save/update/delete/get（持久化操作） s.save(obj);
6、commit（提交或回滚事务） tx.commit();
7、Session.close（关闭Session） s.close();
第六章 Hibernate的关联映射
单向的多对一
配置在多的一方
单向的一对多
配置在一的一方
双向的一对多
Clazz表（clazzId，clazzName）
Student（stuId，stuName，stuClassId）
一的一方（班级） 多的一方（学生）
实体类 Clazz Student,将外键列的属性去掉
要存储多的一方对象的集合 要存储一的一方的一个对象作为自己的属性 Set stus = new HashSet(); Clazz clazz;
映射文件 Clazz.hbm.xml Student.hbm.xml
配置Set 配置many-to-one
Set标签的属性 many-to-one属性：
name：储存对方对象 name：存储对方对象的属性名（clazz） 集合属性的名 column：外键列的名称（stuClassId）
称（stus） class：对方的类名（org.owl.Clazz）
key子标签：
column:外键列名
是Student表的字
段（stuClassId）
one-to-many子标签：
class：表示你存储
的对方对象类的完
全限定名(org.owl.
Student)
双向的多对多
Teacher(tId,tName) new =
Student(sId,sName)
TS(ts_tId,ts_sId)
多的一方 多的另一方
实体类 Teacher Student
存储另一方的对象集合 存储一方的对象集合
Set stus = new HashSet(); Set teas = new HashSet();
映射文件 Teacher.hbm.xml Student.hbm.xml
Set标签 Set标签
name：存储另一方对象集 name:(teas)
合属性的属性名 table:(TS)
（stus） key子标签：
table：中间表表名（TS） column：（ts_sId）
key子标签： many-to-many子标签
column：中间表中 class：（org.owl.Teacher）
与当前表对应的外键 column:（ts_tid）
列列名（ts_tId）
many-to-many子标签：
class:另一方的类名
（org.owl.Studnet）
column:中间表用与另
一方表相关联的外键列
列名（ts_sid）
select * from student where sId in( select ts_sId from Teacher,TS where tId = ts_tId and tId = 1)
cascade: 级联的意思（none,all,save-update,delete）默认是none。
inverse: 反转：（true——不管理，false——管理）
第七章 Hibernate查询
HQL查询
Session session = super.getSession();
String hql = "from Student";
Query query = session.createQuery(hql);
List list = query.list();
hql语句和SQL语句很相似，只不过表名将有实体类名代替，列名由实体类的属性名代替
所有涉及到类名和属性名的地方均大小写敏感，其他地方大小写不敏感。
如果查询所有字段，会返回一个存储实体类对象集合的List
并且Hql语句不用些Select段语句。
from Student
select s from Student s
如果不是查询所有字段，会返回一个存储了对象数组的集合List
并且Hql语句需要由Select段，最好给实体类起别名例如：
Select stu.stuName,stu.stuAge from Student stu
如果是上面的写法将会返回一个集合，集合中存储的元素是对象数组，这个数组有两长度，分别存储stuName和stuAge
Hql还可以动态指定参数
在Hql中参数可以用？表示，也可以用：名称表示
然后利用query的setXXX来赋值，XXX是数据类型，
如果用？好站位就给索引位置，索引从0开始
如果用名称站位呢，就给出名称
String hql = "from Student where stuName like ?";
Query q = session.createQuery(hql);
q.setString(0,"%a%");
String hql = "from Student where stuName like :name";
Query q = session.createQuery(hql);
q.setString("name","%a%");
Query有两个方法，一般用于分页
setFirstResult(数字);——开始位置的索引
setMaxResults(数字);——最大取出条数
uniqueResult方法只取出一个结果。
Criteria查询
Session session = super.getSession();
Criteria c = session.createCriteria(Student.class);
List list = c.list();
c.add(Restrictions.like("stuName","a",MatchMode.ANYWHERE)）;
like的第一个参数是属性名称，第二个参数是比对的值，第三个参数是比对方式，ANYWHERE代表前后就有任意字符
c.add(Restrictions.ge("stuAge",10));
ge的第一个参数是属性名称，第二参数是比对的值
c.addOrder(Order.asc("stuId"));
排序
第八章 使用Spring容器管理对象
依赖注入
DI——依赖注入
IOC——控制反转
依赖：一个类方法的实现会跟据另一个类的方法实现的改变而改变，那么前一个类依赖于后一个类 所以要面向接口编程而不是面向实现编程。
编程时要依赖于抽象，而不是依赖于实现。
依赖注入：实现与使用分离（利用接口）。
Spring实现了依赖注入（利用Setter方法实现注入，利用配置文件来组装）
注意：applicationContext.xml的配置
<bean id="office" class="org.owl.Office">
<property name="address" value="白羊大厦"/>
</bean>
<bean id="boss" class="org.owl.Boss">
<property name="office" ref="office"/>
</bean>
Office office = new Office();
office.setAddress("白羊大厦");
Boss boss = new Boss();
boss.setOffice(office);
面向方面编程（AOP）
目的：将与业务逻辑的一些方面提取出来统一处理，让工作者更加专注与业务逻辑
Spring实现了AOP
Spring通过代理模式实现了AOP
三个东西：
1、原Bean：（原来没有任何修饰的业务逻辑类）
2、通知：（统一提取出来的方面处理代码）
3、代理：（代理原Bean，加入通知，最后使用的是代理）
原bean早就准备好了（原来怎么些现在还怎么写）
通知必须实现Spring准备好的一些接口（前置通知、后置通知、环绕通知和异常通知）：
MethodBeforeAdvice（前置通知，接口）
实现before方法
三个参数：Method m，Object[] args，Object target
m：原Bean中，被通知的方法的方法对象
args：传入该方法的参数的集合。
target：原Bean的对象
配置AOP：
<bean id="yuan" class="org.owl.Yuan" />
<bean id="advice" class="org.owl.Advice"/>
<bean id="yuanProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces">
<value>org.owl.IYuan</value>
</property>
<property name="interceptorName">
<list><value>advice</value></list>
</property>
<property name="target" ref="yuan"></property>
</bean>
第九章 Spring与Struts、Hibernate的集成
Spring和Hibernate的集成：
有两种选择：
1、保留Hibernate.cfg.xml
如果保留的话，在applicationContext.xml中配置sessionFactory即可，在其属性中给出Hibernate配置文件的地址。configLocation——classpath:hibernante.cfg.xml
2、不保留Hibernate.cfg.xml
如果没有保留，在applicationContext.xml中要先配置一个DataSource，在其中给出连接参数，然后在配置sessionFactory，填写dataSource属性，用ref给出dataSource的名称。有一些hibernate的配置比如方言、映射文件的位置、显示SQL语句属性修要配置到sessionFactory标签中。 我们的Dao类需要继承HibernateDaoSupport
在我们的Dao的方法中就可以调用，getHibernateTemplate方法，得到一个辅助对象，帮助我们方便的使用Hibernate。
Spring和Struts集成：
1、集成利用了Struts的插件机制，Spring提供了一个插件ContextLoaderPlagIn，来进行SS集成。
2、在Struts-Config.xml中配置plug-in标签，提供一个contextConfigLocation的属性，值指定的是spring配置文件的位置：classpath:applicationContext.xml
3、将所有的Action的type属性改为spring提供的一个代理类的完全限定名，DelegatingActionProxy。
4、在Spring配置文件中配置Action，Bean标签，用name和class属性配置，并为其注入biz。 P200示例10代码
声明式事务：
不管是什么方式都要配置TransactionManager
<bean id="tm" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory">
</bean>
1.x的事务处理方式
原Bean——biz
配代理：
<bean id="daili" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager" ref="tm"/>
<property name="target" ref="biz"/>
<property name="transactionAttributes">
<props>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
关于事务处理策略看一下P203相关说明
注入给Action的Biz。必须是代理而不是原Bean
abstract属性，是true可以先不配target
再配的时候设置parent属性设定代理，再给出target
2.0的方式：
非侵入式-只需要加入配置不需要改变原来的配置和注入关系
1、加入需要的命名空间
2、配置tx:advice标签
3、配置aop:config标签
第十章 使用Ajax改进用户体验
WEB2.0的特点：
1、用户贡献内容
2、内容聚合
3、丰富的用户体验
Ajax是异步的Javascript和XML
XmlHttpRequest核心
创建XmlHttpRequest的方法
var url = "xxx.do?id=1";
//1、创建XMLHttpRequest对象
xmlHttpRequest = createXmlHttpRequest();
//2、设置回调函数
xmlHttpRequest.onreadystatechange=hljw;
//3、初始化XMLHttpRequest，三个参数，第一个代表提交的方式，第二个提交到的地址，第三个是否异步
xmlHttpRequest.open("GET",url,true);
//4、发送请求，当用Get方式提交时，参数为null
xmlHttpRequest.send(null);
function hljw(){
//readyState有五种状态：0、未初始化，1、已初始化，2、发送请求，3、开始接收，4、接收完毕 if(xmlHttpRequest.readyState==4 &&
xmlHttpRquest.status == 200){
var b = xmlHttpRequest.responseText;
}
}
DWR框架
1、加入Jar包
2、配置web.xml
3、准备biz方法
4、编写dwr.xml文件
5、测试调用
6、加入javascript导入
7、调用dwr的映射
将dwr配置一个Servlet，类名：org.directwebremoting.servlet.DwrServlet
如果想要打开dwr内置的测试页面的话要配置一个初始化参数：debug，值为true
dwr的xml如何配置
<allow>
<!--
creator属性表明生成对象的方式
javascript属性表明客户端调用该对象的名称
name=class 有一个参数，名字叫做class
value指定类的完全限定名
include表明白名单，这个里面指定的方法一定会发布
-->
<create creator="new" javascript="client">
<param name="class" value="org.owl.biz.UserBiz"/>
<include method="check"/>
</create>
</allow>
客户端调用：
function checkName(oCtl){
//调用服务器端相应的方法，参数列表要比实际的参数列表多一个成员，最后一个参数是回调函数的名字。 client.check(oCtl.value,hljw);
}
function hljw(isExist){
//回调函数会有一个参数，该参数是服务器端方法的返回值。
alert(isExist);
}