JSF第一步 JSF+Spring+Hibernate+AJAX编程实践PDF电子书下载

第1章　为什么要学习框架及学习什么样的框架 1

1.1　Java的发展与变化 1

1.1.1　版本与称谓的变化 1

1.1.2　应用程序开发方式的变迁 1

1.2　两种形式的多层结构的J2EE应用程序 2

1.2.1　胖客户端J2EE应用程序 2

1.2.2　Web应用程序 3

1.3　Web应用的两种实现方式 4

1.3.1　传统的重量级实现方式 5

1.3.1.1　运行环境 5

1.3.1.2　EJB 5

1.3.1.3　其他特点 6

1.3.1.4　适应的场合 6

1.3.2　方兴未艾的轻量级实现方式 6

1.3.2.1　运行环境 7

1.3.2.2 POJO 7

1.3.2.3　其他特点 7

1.3.2.4　适应场合 7

1.4　风云际会的框架世界 7

1.4.1　框架的出现与流行 8

1.4.2　大器晚成展新颜——JSF 8

1.4.3　层林深处好冬眠——Hibernate 9

1.4.4　七音合奏春光曲——Spring 9

1.5　为什么是JSF而不是Struts 9

1.5.1　比Struts更高的抽象 9

1.5.2　早先暴露的缺陷不断被弥补 11

1.5.2.1　解决了与JSP集成中的一些突出问题 11

1.5.2.2　统一表达式语言与JSTL迭代标签的支持 11

1.5.2.3　其他新的特征 12

1.5.3 客户端技术的完美结合 12

1.5.3.1 可以借助JavaScript改善用户体验 12

1.5.3.2　可与AJAX无缝集成 12

第2章　JSF与Web应用程序 13

2.1　JSF的设计目标及与Web应用的关系 13

2.2　Web应用程序概览 13

2.2.1　基本的Web组件 13

2.2.2　Web部署描述器文件 13

2.2.3　Web应用程序的物理结构 14

2.3　Web应用程序的开发环境配置 14

2.3.1　Java 2 SDK的下载与安装 14

2.3.2　Web容器的下载与安装 15

2.3.3　环境变量的设置 16

2.3.4　其他准备工作 16

2.4　Servlet 18

2.4.1　Servlet的基本概念 18

2.4.2　Servlet的体系结构 18

2.4.3　你的第一个Servlet应用程序——Hello World 19

2.4.3.1　建立示例应用目录结构 19

2.4.3.2　编写Servlet类文件 19

2.4.3.3　编译Servlet类文件 20

2.4.3.4　编写部署描述器文件web.xml 20

2.4.3.5　部署与运行示例应用 21

2.4.3.6　原理分析 22

2.4.4　Servlet的生命周期 22

2.4.4.1　初始化 23

2.4.4.2　处理请求 23

2.4.4.3　销毁 24

2.4.5　Servlet的作用域对象 24

2.4.6　过滤请求与响应 24

2.5　JSP 24

2.5.1　JSP如何表示静态内容 25

2.5.2　JSP如何表示动态内容 25

2.5.3　JSP的注释 25

2.5.3.1　HTML注释 26

2.5.3.2　JSP注释 26

2.5.4　JSP示例 26

2.5.4.1　建立应用程序目录 26

2.5.4.2　编写JSP示例代码 26

2.5.4.3　部署和运行JSP 26

2.5.5　JSP与Servlet的关系 27

2.5.5.1　JSP转换为Servlet后执行 27

2.5.5.2　JSP转化后的Servlet的简要分析 27

2.5.5.3　JSP为Servlet提供了模板机制 29

2.5.6　JSP的元素 29

2.5.6.1　指令 29

2.5.6.2　动作 30

2.5.6.3　脚本元素 30

2.5.7　JSP的标签库 32

2.5.7.1　标签库的组成 32

2.5.7.2　自定义标签库 33

2.5.7.3　JSP标准标签库 35

2.5.8　JSP的内建对象 35

2.5.8.1 out 36

2.5.8.2　request 37

2.5.8.3 session 39

2.5.8.4　application 41

2.5.8.5　config 41

2.5.8.6　pageContext 41

2.5.8.7　page 41

2.5.8.8　response 41

2.5.8.9　exception 41

2.5.9　JSP中的异常处理 42

2.5.10　Web组件间的关联关系 42

2.5.10.1　包含 42

2.5.10.2　请求转发 43

2.5.10.3　重定向 45

2.5.11　JavaBean 45

2.5.11.1　JavaBean的概念 45

2.5.11.2　为什么要引入JavaBean 46

2.5.11.3　JavaBean的编码约定 46

2.5.11.4　一个简单的JavaBean 48

2.5.11.5　在JSP中使用JavaBean 50

2.5.12　JavaBean在JSP中的有效范围 50

2.5.12.1　演示Page范围的Bean 50

2.5.12.2　演示Request范围的Bean 52

2.5.12.3　演示Session范围的Bean 53

2.5.12.4　演示Application范围的Bean 54

2.6　早期框架Struts 55

2.6.1　应用程序的分层 55

2.6.2　表单的处理与验证 55

2.6.3　类型转换 56

2.6.4　导航 56

2.6.5　资源管理 56

2.6.6　国际化编程 56

2.6.7　异常处理的加强 56

2.6.8　模板的重用管理与布局 57

2.7 JSF 57

2.7.1　具有早期框架的一些特性 57

2.7.2　有状态的用户界面组件模型 57

2.7.3　用户界面事件的服务器端的处理 58

2.7.4　自动生成各种标志语言 58

2.7.5　与业务对象的声明式集成 58

第3章　JSF应用程序开发入门 59

3.1　JSF开发环境的配置 59

3.1.1　JSF参考实现的下载与安装 59

3.1.2　ANT的下载与安装 60

3.1.3　环境变量的设置 60

3.2　开发您的第一个JSF应用程序 60

3.2.1　Hello World应用程序的需求分析 61

3.2.2　应用程序的目录结构 61

3.2.3　应用程序的页面文件 61

3.2.3.1　index.jsp 61

3.2.3.2　hello.jsp 62

3.2.3.3　howDoYouDo.jsp 65

3.2.3.4　howAreYou.jsp 66

3.2.4　应用程序的Backing Bean 66

3.2.4.1　Backing Bean及其作用 66

3.2.4.2　示例中的Backing Bean类文件 67

3.2.4.3　Backing Bean的特点 69

3.2.5　JSF的配置文件faces-config.xml 69

3.2.5.1 示例应用的导航规则 70

3.5.5.2　示例应用的托管JavaBean配置 71

3.2.6 应用程序的配置文件web.xml 71

3.2.7　手工编译应用程序 72

3.2.8　应用程序上下文 73

3.2.9　建立应用程序上下文及部署应用程序 73

3.2.9.1　直接修改Tomcat的配置文件server.xml 73

3.2.9.2　使用Tomcat页面形式的管理工具 73

3.2.10　运行应用程序 74

3.3　用ANT工具构建应用程序 75

3.3.1　ANT工具简介 75

3.3.2　创建build.xml文件 76

3.3.2.1　设置属性 76

3.3.2.2　设置classpath 77

3.3.2.3　定义clean目标 77

3.3.2.4　定义prepare目标 77

3.3.2.5　定义deploy.copyJars目标 77

3.2.2.6　定义build目标 78

3.3.2.7　定义build.war目标 79

3.3.2.8　定义deploy目标 79

3.3.3　用ANT工具自动构建和部署应用程序 79

第4章　JSF中的请求处理 80

4.1　JSF处理请求的基本过程 80

4.1.1　将请求映射到FacesServlet 80

4.1.2　FacesServlet类 80

4.1.3　获得配置Servlet的配置信息 81

4.1.4　初始化时获得Faces上下文工厂和生命周期实例 81

4.1.5　FacesServlet对请求的处理过程 81

4.1.5.1　获得Faces上下文并用它处理当前请求 82

4.1.5.2　调用请求处理生命周期的execute（）方法 82

4.1.5.3　调用请求处理生命周期的render（）方法 82

4.1.5.4　释放Faces上下文对象 83

4.1.5.5　与普通Servlet对请求处理的比较 83

4.1.6　处理完成后的资源释放 83

4.2　Faces上下文 83

4.2.1　Faces上下文简介 83

4.2.2　Faces上下文的主要方法 84

4.2.2.1　获取应用程序实例 84

4.2.2.2　获取外部上下文 84

4.2.2.3　获取与设置视图根 85

4.2.2.4　处理消息队列 85

4.2.2.5　获取呈现器工具包 86

4.2.2.6　流程控制方法 86

4.2.2.7　获取表达式语言上下文 87

4.2.2.8　响应 88

4.2.2.9　获取Faces上下文的当前实例 88

4.3　请求处理的生命周期 88

4.3.1　获得生命周期对象 88

4.3.2　生命周期的场景 89

4.3.2.1　非Faces请求生成Faces响应 89

4.3.2.2　Faces请求生成非Faces响应 90

4.3.2.3　Faces请求生成Faces响应 90

4.3.3　标准的JSF请求处理生命周期 90

4.3.3.1　重建视图 92

4.3.3.2　应用请求值 93

4.3.3.3　处理验证 94

4.3.3.4　更新模型值 95

4.3.3.5　调用应用程序 95

4.3.3.6　呈现响应 95

4.4　Application及相关的类 96

4.4.1　Application简介 96

4.4.2　Application的主要属性 97

4.4.2.1　动作监听器 97

4.4.2.2　导航处理器 98

4.4.2.3　视图处理器 98

4.4.2.4　缺省呈现包标识 98

4.4.2.5 状态管理器 98

4.4.2.6　表达式语言解析器 98

4.4.3　Application动作 98

4.4.4　Application作为组件工厂 99

4.4.5　Application支持国际化编程的方法 99

第5章　JSF的体系结构 101

5.1　MVC架构模式 101

5.1.1　耦合与解耦 101

5.1.2　MVC架构模式 102

5.1.3　Web应用中的MVC Model2 104

5.2　MVC架构模式的实现策略 105

5.2.1　Struts的实现策略 105

5.2.2　JSF的实现策略 105

5.2.2.1　JSF的控制器部分 106

5.2.2.2　JSF的视图部分 107

5.2.2.3　JSF的模型部分 107

5.3　JSF的主要组成部分 108

5.3.1　JSF主要组成部分及其关系 108

5.3.1.1　组成部分概览 108

5.3.1.2　各部分之间的关系 109

5.3.2　用户界面组件 109

5.3.2.1　对组件的直观认识 109

5.3.2.2　JSF的组件模型 109

5.3.2.3　组件模型中的接口 110

5.3.2.4　组件模型中的类 111

5.3.2.5　组件的作用 112

5.3.2.6　组件的属性 112

5.3.2.7　组件在服务器和客户端的表现形式 113

5.3.2.8　组件的标识 114

5.3.2.9　通过标识引用组件 115

5.3.2.10　组件是有状态的 116

5.3.2.11　标准组件与自定义组件 116

5.3.3　呈现器 116

5.3.4 Backing Bean 117

5.3.5　事件与事件监听器 118

5.3.6　导航系统 119

5.3.7　类型转换器 120

5.3.8　验证器 120

5.3.9　消息 120

第6章　标准用户界面组件 122

6.1　标准组件概述 122

6.1.1　组件的类型 122

6.1.2　组件的家族 122

6.1.3　组件的呈现器类型 123

6.2　JSF的呈现模型 123

6.2.1　直接实现方式 123

6.2.2　委托实现方式 123

6.2.3　呈现包工厂 124

6.2.4　呈现包 124

6.2.5　呈现器 125

6.3　JSF实现的缺省呈现器类型与标准组件HTML具体类的关系 126

6.4　组件在JSP页面上的表示 127

6.4.1　在JSP页面中使用用户界面组件的定制动作 128

6.4.2　核心标签库 128

6.4.3　HTML标签库 128

6.4.4　组件的HTML属性 130

6.5　标准组件数据模型 130

6.5.1　标准组件与呈现无关的属性 130

6.5.2　标准组件模型Bean 131

6.5.2.1 SelectItem 131

6.5.2.2 SelectItemGroup 131

6.5.2.3 DataModel 131

6.6　标准组件及使用方法 132

6.6.1　用UIViewRoot控制页面 132

6.6.1.1　UIViewRoot简介 132

6.6.1.2　＜f:view＞在JSP页面上的应用 133

6.6.1.3　＜f:subview＞的使用 134

6.6.2　用UIForm处理表单 136

6.6.3　用UIParameter传递参数 137

6.6.4　用Facet制作表头、表脚及列头 137

6.6.5　用UIInput处理输入 138

6.6.5.1　用HtmlInputText输入单行文本 139

6.6.5.2　用HtmlInputSecret输入密码 139

6.6.5.3　用HtmlInputTextarea输入多行文本 139

6.6.5.4　用HtmlInputHidden作为隐含字段 140

6.6.6　用UIOutput处理输出 140

6.6.6.1 用HtmlOutputText输出简单文本 140

6.6.6.2 用HtmlOutputFormat输出格式化文本 141

6.6.6.3　用HtmlOutputLabel作为组件的标注 142

6.6.6.4　用HtmlOutputLink作为超链接 142

6.6.7　用UISelectItem提供单个选项 142

6.6.8　用UISelectItems提供多个选项 143

6.6.9　用UISelectBoolean表示逻辑选项 143

6.6.10　用UISelectOne作为单选组件 144

6.6.10.1　单选列表框HtmlSelectOneListbox 144

6.6.10.2　单选下拉菜单HtmlSelectOneMenu 144

6.6.10.3 单选钮HtmlSelect-OneRadio 144

6.6.11　用UISelectMany作为复选组件 145

6.6.11.1　复选列表框HtmlSelectManyListbox 145

6.6.11.2　复选下拉菜单HtmlSelectManyMenu 145

6.6.11.3　复选钮HtmlSelectManyCheckbox 145

6.6.12　用UICommand调用应用程序 146

6.6.12.1　命令按钮HtmlCommandButton 146

6.6.12.2　命令超链接HtmlCommandLink 146

6.6.13　用UIMessage显示特定组件的消息 147

6.6.14　用UIMessages显示多条消息 147

6.6.15　用UIGraphic显示图片 148

6.6.16　用UIPanel分组与布局组件 148

6.6.16.1 用HtmlPanelGroup分组组件 148

6.6.16.2　用HtmlPanelGrid布局组件 148

6.6.17　用UIColumn表示数据列 149

6.6.18　用UIData显示数据集中的数据 149

6.6.19　到哪里获得组件更详细的信息 150

第7章　表达式语言与托管Bean 151

7.1　表达式语言的出现 151

7.1.1　统一表达式语言出现的背景 151

7.1.1.1　JSP的表达式语言 151

7.1.1.2　JSF自己的表达式语言 152

7.1.1.3　JSP与JSF表达式语言的冲突 153

7.1.2　统一表达式语言 153

7.1.2.1　值表达式 153

7.1.2.2　方法表达式 154

7.1.2.3　解决原来的JSP与JSF表达式的冲突问题 154

7.2　托管Bean 155

7.2.1　托管Bean创建工具与托管Bean 155

7.2.2　托管Bean的配置 155

7.2.2.1　基本的配置元素 156

7.2.2.2　配置托管Bean的属性 156

7.2.2.3　托管Bean属性的初始化与JSF的IoC 157

7.2.3　List配置为托管Bean 158

7.2.4　Map配置为托管Bean 158

7.3　托管Bean的有效范围 159

7.3.1　请求范围 159

7.3.2　会话范围 160

7.3.3　应用程序范围 160

7.3.4　NONE范围 160

7.3.5　不同范围间的托管Bean的引用 161

第8章　JSF中的导航 163

8.1　JSF导航概述 163

8.1.1　应用程序动作与导航 163

8.1.2　导航处理器的行为是可以配置的 163

8.2　JSF支持的导航形式 164

8.2.1　动态导航 164

8.2.1.1　何为动态导航 164

8.2.1.2　简单动态导航示例回顾 164

8.2.2　静态导航 165

8.2.2.1　何为静态导航 165

8.2.2.2　静态导航示例 165

8.3　导航规则 167

8.3.1 导航规则需要配置的元素 167

8.3.2　导航规则的匹配算法 167

8.3.3 复杂导航规则的配置示例 168

8.4　动作事件监听器方法对导航的影响 169

8.4.1 动作事件监听器方法间接影响导航 169

8.4.2　动作事件监听器方法对导航影响的示例 169

8.4.2.1　导航出发页面 169

8.4.2.2　包含动作事件监听器方法和动作方法的Backing Bean 170

8.4.2.3　导航目的地页面 171

8.4.2.4　配置导航规则 172

8.4.2.5　部署和运行示例应用程序 172

第9章　JSF与应用程序模型层的集成 174

9.1　JSF作为表现层框架 174

9.1.1　JSF结构回顾 174

9.1.2　Backing Bean扮演的角色 174

9.1.3　编写Backing Bean代码时的不良实践 174

9.2　登录示例应用程序 175

9.2.1　示例登录应用的需求分析 175

9.2.2　登录示例应用的界面 175

9.2.3 目录结构 176

9.2.4　业务服务接口 176

9.2.5　业务服务实现 176

9.2.6　示例应用的Backing Bean 178

9.2.7　示例中的页面文件 179

9.2.8　在Faces配置文件中配置导航规则 180

9.2.9　在Faces配置文件中配置托管Bean 180

9.2.10　部署和运行示例应用 181

9.3　JSF中的控制反转（IoC） 182

9.3.1　登录示例应用的不足 182

9.3.2　控制反转（IoC）及依赖注入（DI） 182

9.3.2.1　控制反转及依赖注入简介 182

9.3.2.2　依赖注入的形式 183

9.4　在JSF应用程序中使用依赖注入 185

9.4.1　在Backing Bean使用type2型依赖注入 185

9.4.2　在Faces配置文件中配置依赖关系 186

9.4.3　部署和运行示例应用 187

第10章　JSF的事件处理 188

10.1　JSF事件及事件监听器模型 188

10.1.1　事件类 188

10.1.2　监听器类 189

10.1.3　事件广播及处理 189

10.2　JSF中的事件分类 190

10.2.1　值改变事件 190

10.2.2　动作事件 190

10.2.3　阶段事件 190

10.3　事件处理示例 190

10.3.1　值改变事件的处理示例 190

10.3.1.1 示例应用的页面文件 191

10.3.1.2　在Backing Bean中编写处理值改变事件方法 192

10.3.1.3　在Faces配置文件中配置Backing Bean 192

10.3.1.4　部署和运行 192

10.3.1.5　用专门的监听器来处理值改变事件 193

10.3.2　动作事件的处理示例 194

10.3.2.1　在页面中使用命令超链接 194

10.3.2.2　在Backing Bean中编写事件处理方法 195

10.3.2.3　部署和运行示例应用 196

10.3.3　Immediate组件使用示例 197

10.3.3.1　在页面上使用Immediate组件 197

10.3.3.2　在Backing Bean中编写事件监听器方法 199

10.3.3.3　观察示例应用的运行效果 199

第11章　JSF中的转换 201

11.1　JSF的转换模型 201

11.1.1　什么是JSF中的转换 201

11.1.2　JSF中为什么需要转换 201

11.1.3　JSF中何时发生转换 202

11.1.4　JSF的转换器接口 202

11.2　使用JSF的标准转换器 203

11.2.1　JSF的标准转换器 203

11.2.2　使用标准转换器的一般方式 203

11.3　自动转换方式示例 204

11.3.1 在注册页面增加一个表示年龄的文本输入框 204

11.3.2　在注册成功的页面上显示年龄 204

11.3.3　Backing Bean年龄属性的数据类型为int 204

11.3.4　示例应用的业务数据对象 205

11.3.5　示例应用中的自定义异常 206

11.3.6　示例应用的业务服务 206

11.3.7　示例应用的Faces配置 206

11.3.8　自动转换的效果 207

11.3.8.1 自动转换失败的效果 207

11.3.8.2　自动转换成功的效果 207

11.4　使用组件标签的属性 208

11.5　使用转换器标签 208

11.6　Java中的日期与时间 209

11.6.1　Java中的Date类 209

11.6.2　Calendar类 210

11.6.3 GregorianCalendar类 210

11.6.4　日期、时间的格式化 211

11.6.5　访问数据库时使用的日期类 211

11.7 日期时间转换器示例 212

11.7.1　建立示例应用的目录结构 212

11.7.2　新建一个可以输入日期的页面 213

11.7.3　在页面上使用显示日期的组件 213

11.7.4　Backing Bean中的日期型属性 213

11.7.5　业务对象中的日期属性 214

11.7.6　业务服务接口中的日期型参数 215

11.7.7　在业务服务实现中处理日期型数据 215

11.7.8　更改示例应用的Faces配置 216

11.7.9 日期转换的效果 217

11.8　数字转换器 218

11.9　使用自定义转换器 218

11.9.1　创建自定义转换器 218

11.9.2　注册自定义转换器 220

11.10　自定义的转换器示例 220

11.10.1　建立示例应用的目录结构 220

11.10.2　示例应用的BackingBean 220

11.10.3　新建自定义格式的业务对象 222

11.10.4　修改原业务对象 223

11.10.5　在业务服务接口的方法中加入新参数 223

11.10.6　更改业务服务实现类 224

11.10.7　在Faces中配置自定义转换器 225

11.10.8　在用户注册页面上使用自定义转换器 225

11.10.9　在注册成功页面上使用自定义转换器 226

11.10.10　检验自定义转换器的使用效果 226

第12章　JSF中的验证 227

12.1　JSF的验证模型 227

12.1.1　验证器类 227

12.1.2　验证器的注册 227

12.1.3　验证处理过程 228

12.1.4　标准验证器实现 228

12.2　使用标准验证器示例 229

12.2.1　建立示例应用目录结构 229

12.2.2　在页面中使用标准验证器 229

12.2.3　部署和运行应用程序 230

12.3 正则表达式简介 231

12.4　使用自定义验证器示例 233

12.4.1　建立示例应用目录 233

12.4.2　创建自定义验证器类 234

12.4.3　在Faces配置文件中注册验证器 235

12.4.4　在页面中使用自定义验证器 235

12.4.5 自定义验证器的使用效果 235

12.5　使用Backing Bean的验证方法 237

12.5.1　建立示例应用目录结构 237

12.5.2　在Backing Bean中编写验证方法 237

12.5.3　在Faces配置中删除自定义验证器 238

12.5.4　在页面中引用验证方法 238

12.5.5　运行应用程序查看验证效果 239

第13章　JSF的国际化编程 240

13.1　问题的由来 240

13.2　字符集的基础知识 240

13.2.1　计算机表示字符的方式与字符集 240

13.2.2　字符集的发展 241

13.2.3　UTF-8字符集 242

13.3　Java及Web中的编码 243

13.3.1　Java中的编码 243

13.3.2　Web中的编码 243

13.4 中文乱码的几种表现形式及成因浅析 244

13.4.1　字符变问号 244

13.4.2　部分汉字是乱码 247

13.4.3　显示乱码（有些是汉字但并不是你预期的） 248

13.4.4　读写数据库时出现乱码 250

13.5　JSF国际化编程的思路 250

13.6　JSF国际化编程的实现 251

13.6.1　支持国际化编程的应用的基本特征 251

13.6.2　Java平台的本地化类 251

13.6.3　资源束 252

13.6.4　日期与数字的格式化 253

13.7　登录示例程序的国际化与本地化 254

13.7.1 收集区域敏感数据 255

13.7.2　制作缺省资源文件 255

13.7.3　改编页面文件 256

13.7.4　编写和配置Servlet过滤器 258

13.7.5　构建和运行应用程序 259

13.7.6　编写中文资源文件 259

13.7.7　检验应用程序的运行效果 260

13.8　图片的国际化 261

13.8.1　在项目中建立存放图片的目录 262

13.8.2　制作对应各种不同语言的图片 262

13.8.3　在页面文件上添加图片 262

13.8.4　在资源束文件中加上对应图片键-值对 263

13.8.5　在build.xml中添加拷贝图片的内容 263

13.8.6　观察应用程序的运行结果 264

13.9　异常消息的国际化 264

13.9.1　异常消息的种类 265

13.9.2　标准异常消息 265

13.9.3 自定义异常消息的处理过程 266

13.10　异常消息国际化示例 266

13.10.1　在资源文件中加上消息的键-值对 266

13.10.2　创建消息工厂 267

13.10.3　业务模型中的消息处理方式 267

13.10.4　Backing Bean中的消息处理方式 267

13.10.5　示例应用的运行效果 269

13.11 日期的国际化示例 269

13.11.1　示例应用要实现的效果 269

13.11.2　建立示例应用的目录结构 269

13.11.3　修改页面文件 270

13.11.4　准备资源文件 270

13.11.5　修改业务对象 271

13.11.6　修改业务模型中的类文件 271

13.11.7　修改Backing Bean 272

13.11.8　国际化编程后的效果检验 274

第14章 JSF与Tiles框架的集成 275

14.1 页面布局的几种可选方案 275

14.1.1　使用JSP指令的方法 275

14.1.2　使用JSP标签 279

14.1.3　使用Tiles框架 279

14.2　Tiles框架简介 280

14.3　用Tiles布局页面的示例 280

14.3.1　建立示例应用的目录结构 280

14.3.2　下载和安装与Tiles有关的库文件 280

14.3.3　编写tiles的配置文件 281

14.3.4　在web.xml文件中配置tiles 281

14.3.5　编写布局模板文件 282

14.3.6　编写布局的各组成部分的页面文件 283

14.3.7　编写应用模板的页面文件 284

14.3.8　示例应用的运行效果 284

14.4　用Tiles布局Frame页面 285

14.4.1　Frame页面的基础知识 285

14.4.2　一个简单的Frame页面例子 286

14.4.3　让Frame页面居中显示 288

14.5　用Tiles布局Frame页面的示例 289

14.5.1　建立示例应用的目录结构 289

14.5.2　新建图片文件 289

14.5.3　更改tiles配置 289

14.5.4　新建frame布局模板页面 289

14.5.5　新建用于导航的菜单页面 290

14.5.6　新建带frame的页面 291

14.5.7　应用程序的运行效果 291

第15章　JSF访问数据库 293

15.1　MS SQL Server数据库的安装 293

15.1.1　SQL Server数据库的安装过程 293

15.1.2　数据库补丁包的安装 296

15.2　JDBC简介 297

15.2.1　JDBC的发展历程 297

15.2.2　JDBC的结构和工作原理 298

15.2.3　JDBC驱动器 300

15.2.4　JDBC的使用场景 300

15.2.5　两层模式 300

15.2.6　三层模式 301

15.2.6.1　客户层 301

15.2.6.2 中间层 301

15.2.6.3　数据源层 302

15.3　数据访问对象模式简介 302

15.4　让登录程序访问数据库中用户信息 302

15.4.1　建立数据库 302

15.4.2　建立数据库表 303

15.4.3　在表中输入实验用的数据 304

15.4.4　下载和安装JDBC驱动程序 304

15.4.5　建立应用程序的目录结构 305

15.4.6　增加应用程序访问数据库的部分 305

15.4.7　修改应用程序的业务逻辑部分 307

15.4.8　修改backing bean使其使用新的service 308

15.4.9　创建与数据访问相关的自定义异常类 309

15.4.10　修改资源文件，添加新的键-值对 311

15.4.11　配置应用程序 311

15.4.12　运行应用程序 313

第16章　应用程序中的异常处理 315

16.1　Java异常的分类 315

16.2　Java处理异常的一般方法 317

16.3　创建自己的异常子类 320

16.4　成链异常 321

16.5　JSF应用程序的异常处理 322

第17章　应用程序的日志 324

17.1 为什么要记日志 324

17.2　用什么记日志 324

17.3　怎么记日志 324

17.4　在登录示例程序中记日志 326

17.4.1　建立示例应用目录结构 326

17.4.2　下载通用日志包 326

17.4.3　下载日志器实现Log4J 327

17.4.4　写日志有关的配置文件 327

17.4.5　创建一个空的日志文件 329

17.4.6　编写访问日志接口的应用程序代码 329

17.4.7　部署和运行应用程序 331

第18章　JSF与AJAX集成 334

18.1　AJAX概述 334

18.1.1　什么是AJAX 334

18.1.2　AJAX的原则 334

18.1.3　AJAX包含那些技术 334

18.1.4　AJAX的工作原理 335

18.2　Ajax4jsf 336

18.2.1　Ajax4jsf概述 336

18.2.2　Ajax4jsf工作原理 336

18.2.3　下载和安装Ajax4jsf 337

18.3　示例应用程序 338

18.3.1　建立应用程序的目录结构 339

18.3.2　需要的库文件 339

18.3.3　在web.xml文件中添加Ajax4jsf的过滤器 339

18.3.4　在注册页面中使用Ajax4jsf标签 339

18.3.5　在Backing Bean中添加动作监听器方法 340

18.3.6　部署和运行应用 340

第19章　ORM及其Hibernate实现 341

19.1　ORM简介 341

19.1.1　对象模型与关系范例的失配 341

19.1.1.1　粒度问题 341

19.1.1.2　子类型问题 341

19.1.1.3　标识符问题 342

19.1.1.4　关联问题 342

19.1.1.5　对象图导航问题 343

19.1.2　集成层的可选方案 343

19.1.2.1　使用JDBC 343

19.1.2.2　使用EJB 343

19.1.2.3　使用面向对象的数据库系统 344

19.1.2.4　使用对象／关系映射（ORM） 344

19.1.3　ORM面临的问题 344

19.2　Hibernate的结构简介 344

19.2.1　核心应用程序编程接口 345

19.2.2　回调接口 347

19.2.3　扩展接口 348

19.3　映射对象 348

19.3.1　基本映射 348

19.3.2　标识的属性 349

19.3.3　标识生成器 350

19.3.4　多对一映射／一对多映射 350

19.3.5　多对一中的类示例 350

19.3.6　多对一／一对多的表间关系 353

19.3.7　多对一／一对多的映射文件 353

19.3.8　多对一元素的主要属性 354

19.3.9　集合映射 355

19.3.10　外键元素 355

19.3.11　一对多元素的主要属性 355

19.3.12　多对多映射 355

19.4　检索对象 357

19.4.1　Hibernate查询语言 357

19.4.2　条件查询 358

19.4.3　SQL查询 358

19.5　报表查询 358

第20章 JSF与Hibernate的集成 360

20.1　Hibemate的配置 360

20.1.1　Hibernate的下载 360

20.1.2　需要的库文件 361

20.1.3　持久化类的映射文件 361

20.1.4　Hibernate配置文件 362

20.2　用Hibernate重写登录程序的数据库访问部分 362

20.2.1　辅助工具类 362

20.2.2　项目使用的数据库 363

20.3　具体的实现 363

20.3.1　创建应用程序项目目录 363

20.3.2　修改build.xml文件及调整部分配置文件的目录 363

20.3.3　准备必要的Java库文件 363

20.3.4　创建辅助工具类 363

20.3.5　创建持久类及映射文件 364

20.3.6　创建Hibernate配置文件 364

20.3.7　创建DAO接口 365

20.3.8　创建DAO的Hibernate实现类 366

20.3.9　创建应用服务的Hibernate实现类 367

20.3.10　修改Backing Bean 368

20.3.11　用ANT构建和部署应用程序 368

20.3.12　运行应用程序 369

20.4　对应用程序的回顾 369

20.4.1　关于Hibernate Session的关闭问题 369

20.4.2　关于示例程序中的修改问题 369

20.4.3　关于DAO代码简化的问题 370

20.5　进一步简化DAO代码 370

20.5.1 DAO中的样板代码 370

20.5.2　去除样板代码的方法 371

20.5.3　部署和运行新项目 373

第21章　JSF与Spring和Hibernate的集成 374

21.1　Spring的组成 374

21.2　Spring中的IoC以及用Spring管理JSF托管bean 375

21.2.1　JSF与Spring集成的原理 375

21.2.2　集成所需要做的配置工作 375

21.2.3 期版本的JSF参考实现在实际集成中会遇到的问题 377

21.2.4 项目使用的数据库 378

21.3　用JSF、Spring和Hibernate编写注册登录示例 378

21.3.1　建立应用程序项目的目录结构 378

21.3.2　准备Spring库文件 378

21.3.3　准备JSF与Spring的胶代码库文件 380

21.3.4　创建数据访问接口 381

21.3.5　创建数据访问实现类 381

21.3.6　创建业务服务接口 382

21.3.7　创建业务服务实现类 382

21.3.8　创建持久化类及映射文件 384

21.3.9　创建Backing Bean 385

21.3.10　创建注册页面及注册成功页面 385

21.3.11 在Spring上下文中配置服务及数据访问对象 386

21.3.12　配置Faces上下文 388

21.3.13　配置web.xml 388

21.3.14　构建、部署及运行示例应用程序 389

第22章 使用Eclipse和MyEclipse工具 390

22.1　下载与配置Eclipse和MyEclipse 390

22.1.1 下载IDE软件 390

22.1.2　配置开发环境 391

22.2　用IDE开发示例 394

22.2.1　建立新项目 394

22.2.2　加入JSf Capabilities 396

22.2.3　加入Spring Capabilities 397

22.2.4　加入Hibernate Capabilities 398

22.2.5　业务层与集成层对象的编写与配置 402

22.2.5.1 引入访问数据库所需要的包文件 402

22.2.5.2　配置数据源 403

22.2.5.3　创建持久化对象及其映射文件 404

22.2.5.4　修改Hibernate sessionFactory的配置 405

22.2.5.5　创建数据访问对象的接口及实现类 408

22.2.5.6　创建应用服务接口及实现类和自定义异常类 408

22.2.5.7　配置其他对象 408

22.2.6　应用程序表示层对象的编写与配置 409

22.2.6.1　配置Application 410

22.2.6.2　配置和生成Backing Bean 410

22.2.6.3　在Backing Bean中注入依赖 411

22.2.6.4　在Backing Bean中编写动作方法 412

22.2.6.5 可视化方式制作页面文件 412

22.2.6.6　配置导航规则 412

22.2.7　配置应用程序的部署描述器文件web.xml 413

22.2.8　部署和运行项目 415

22.3　用IDE打开示例应用的方法 417

22.4　在IDE中使用Hibernate的反向工程 417

22.4.1　创建一个新项目 417

22.4.2　创建数据库 417

22.4.3　创建数据库浏览器窗口 418

22.4.4　建立必要的包 420

22.4.5　加入JSF和Spring的Capabilities 420

22.4.6　加Hibernate的Capabilities 420

22.4.7　应用反向工程生成类和配置文件 423

22.4.8　反向工程生成的文件样例 425

第23章　AOP及事务管理 427

23.1 AOP简介 427

23.1.1　什么是AOP 427

23.1.1.1　对AOP的一些常见的误解 427

23.1.1.2　AOP的一些常用术语 428

23.1.2　Spring实现的AOP 428

23.1.2.1 Spring实现的AOP的特点 428

23.1.2.2 Spring中AOP的应用 429

23.2　事务简介 429

23.2.1　事务的基本属性 429

23.2.2　Spring的事务策略 429

23.2.3　Spring支持的事务隔离度 430

23.2.4　Spring支持的事务传播类型 430

23.3　事务管理示例 431

23.3.1　示例应用要演示的情形 431

23.3.2　数据库表的建立 431

23.4　没有事务管理的例子 432

23.4.1 编写持久化对象的类文件 432

23.4.2　编写映射文件 433

24.4.3　编写DAO接口 434

23.4.4　编写DAO实现类 435

23.4.5　编写业务服务接口 436

23.4.6　编写没有事务处理的业务服务 436

23.4.7　编写没有事务管理的Spring配置 438

23.4.8　示例应用的Backing Bean 439

23.4.9 配置web.xml 441

23.4.10　应用程序的页面文件 441

23.4.11　示例应用的运行效果 441

23.5　编程式事务管理的例子 442

23.5.1 编程式事务管理的一般方法 442

23.5.2　编写编程式事务的业务服务 442

23.5.3　编写编程式事务管理的Spring配置 444

23.5.4　修改web.xml 445

23.5.5　应用的运行效果 445

23.6　声明式事务管理的例子 445

23.6.1　声明式事务管理的方法 445

23.6.2　在Spring的配置文件中声明事务 446

22.6.3　修改web.xml 447

23.6.4　应用的运行效果 447

第24章　权限系统示例应用程序 448

24.1 基于角色的访问控制 448

24.2　应用程序的界面 448

24.2.1 登录界面 449

24.2.2　管理员用户界面 449

24.2.3　普通用户界面 450

24.3　数据库设计 451

24.3.1 表的结构 451

24.3.2　表之间的关系 454

24.4　持久化对象 455

24.4.1　持久化对象的类文件 455

24.4.2　持久化对象的映射文件 461

24.5　数据访问对象 463

24.5.1　数据访问对象接口 464

24.5.2　数据访问对象实现 465

24.6　业务服务 469

24.6.1 业务服务接口 469

24.6.2 业务服务实现 470

24.6.3　编程式事务在示例中的应用 473

24.7　Backing Bean 474

24.7.1　使用Backing Bean的策略 474

24.7.2 示例Backing Bean的编码 475

24.7.3　安全退出系统的动作 478

24.7.4　在Backing Bean中验证Email地址 478

24.7.5　在Backing Bean中引用其他Backing Bean 480

24.8　配置文件 482

24.8.1　应用程序部署描述器文件 482

24.8.2　JSF配置文件 483

24.8.3　Spring配置文件 486

24.8.4　Hibernate的配置文件 489

24.9 页面文件 489

24.9.1　index.jsp 489

24.9.2　登录页面文件 489

24.9.3　Frameset文件 490

24.9.4　树型菜单文件 491

24.9.5　添加新用户的页面文件 492

24.9.6　指派用户角色的页面文件 492

24.9.7　安全登出系统的页面文件 495

24.9.8 显示操作结果的页面文件 495

24.9.9　页面间的导航关系 496

24.10　辅助文件 496

24.10.1　字符集过滤器类文件 496

24.10.2　资源文件 497

24.10.3　消息工厂类文件 497

24.11 怎样让示例程序运行起来 497

24.11.1 创建示例数据库 497

24.11.2　更改配置文件中的数据库密码 498

24.11.3　用IDE部署示例应用 498

24.12　为已有的JSF项目增加AJAX支持 498

24.12.1　导入库文件 498

24.12.2　更改页面文件 498

24.12.3　更改Backing Bean 500

24.12.4 更改业务服务接口及实现 501

24.12.5　更改应用程序部署描述器文件 502

第25章 办公用品管理系统示例程序 503

25.1　示例程序的需求分析 503

25.1.1　需求分析简述 503

25.1.2　用例（UseCase）图 503

25.1.3　用例文档的书写 504

25.1.4　系统需要用到的页面 505

25.1.5　业务规则的说明 506

25.1.6　其他要求 506

25.2　示例程序的架构设计 506

25.2.1 多层架构 506

25.2.2　选择合适的技术 506

25.2.3　表示层设计 507

25.2.4　业务逻辑层设计 507

25.2.5　数据映射层设计 507

25.2.6　数据库设计 507

25.3　示例程序的实现 508

25.3.1　表示层实现 508

25.3.2　业务层实现 510

25.3.3　数据映射层实现 512

25.4　其他实用功能的实现 512

25.4.1 文件上传 512

25.4.1.1　Java中的输入输出与流 512

25.4.1.2　文件的路径与目录 512

25.4.1.3　MyFaces的文件上传标签 513

25.4.2　文件上传的实现 513

25.4.3　处理分页 518

25.4.4　发送电子邮件 521

25.4.4.1　Spring对电子邮件的抽象 521

25.4.4.2　编写Backing Bean 521

25.4.4.3　配置邮件发送器和邮件消息 523

25.4.4.4　编写发送邮件的方法 524

25.4.4.5　发送邮件时需要加入的库文件 525

25.5　示例应用程序的测试 525

25.5.1　测试简介 525

25.5.2　测试的分类 526

25.5.3　模拟测试与集成测试 526

25.5.4　常用的测试框架JUnit 526

25.5.5　测试用例的运行方式 527

25.5.6　数据访问层测试示例 528

25.5.6.1　创建测试基类 528

25.5.6.2　创建测试具体类 529

25.5.6.3　修改向导生成的测试类文件 531

25.5.6.4　测试过程 532

25.5.6.5　在IDE中测试易出现的问题 533

25.6　部署和运行应用程序 533

25.6.1　数据库的建立 533

25.6.2　配置文件中的参数更改 534

第26章　应用程序的安全性 535

26.1　应用程序的安全性简介 535

26.2　权限管理示例程序的安全性考虑 535

26.2.1　控制对资源的访问 535

26.2.2　保护敏感数据 536

26.3　防止用户绕过登录的方法 537

26.3.1　登录时保存信息到HttpSession中 537

26.3.2　制作验证HttpSession中内容的页面 539

26.3.3　在需要保护的页面前部包含验证页面 539

26.4　Java密码架构和加密服务提供者 540

26.4.1 Java密码架构 540

26.4.2　加密服务提供者 541

26.4.3　Java密码架构的使用方式 541

26.5　消息摘要与口令认证 541

26.5.1　什么是消息摘要 541

26.5.2　口令的加密存储 542

26.5.3　加密后的口令的验证 543

26.6　权限管理应用的口令加密示例 544

26.6.1　新建示例项目 544

26.6.2　更改人员表中口令字段的数据类型 544

26.6.3　改变持久化类中口令字段的数据类型 544

26.6.4　更改映射文件中口令字段的数据类型 545

26.6.5　在业务服务实现中增加口令加密方法 546

26.6.6　在业务服务实现中增加口令验证方法 547

26.6.7　更改业务服务实现的注册新用户方法 548

26.6.8　更改业务服务实现的登录方法 549

26.6.9　更改业务服务实现的用户改变口令方法 551

26.6.10　在数据库表中查看口令数据 552