第1章 Java与面向对象思想 1
1.1初识Java语言 1
1.1.1 Java是什么 1
1.1.2为什么要选用Java语言 2
1.1.3 Java语言的解释执行与跨平台特性 3
1.1.4怎样学好Java 4
1.2什么是面向对象思想 5
1.2.1软件开发的方法学——面向对象思想提出的背景 5
1.2.2面向对象的物质基础——类与封装 6
1.2.3抽象与代码复用——抽象类与概念抽象 7
1.2.4模块的开关——接口与功能抽象 8
1.2.5同名但不同参——多态与重载 8
1.2.6具有面向对象思想语言的优势 9
1.3开发我们的第一个Java程序 10
1.3.1如何配置Java的开发环境 10
1.3.1.1下载和安装JDK 10
1.3.1.2设置JDK的环境变量 10
1.3.3.3安装Eclipse 12
1.3.3.4添加Eclipse的中文插件 12
1.3.2编写HelloWorld程序 12
1.3.3运行HelloWorld程序 13
1.3.4使用Eclipse集成开发环境运行HelloWorld程序 13
1.4本章小结 16
第2章 开始学习Java语法 17
2.1基本数据类型与操作符 17
2.1.1基本数据类型 17
2.1.2基本操作符 18
2.1.3操作符优先级 21
2.1.4对象型的数据类型 22
2.1.5方法（函数）的参数和返回值 24
2.2程序流程控制 25
2.2.1顺序与分支 25
2.2.2循环流程 27
2.2.3有争议的goto语句 28
2.2.4使用if语句判定是否是闰年 29
2.2.5使用循环语句计算阶乘 30
2.2.6使用switch语句控制输出 30
2.3类与封装 32
2.3.1类的构成要素 32
2.3.2类的构造函数与构造次序 32
2.3.3用package封装工具类和用import引入需要的类 35
2.3.4修饰符与类内部对象的可见性 36
2.3.5静态方法与抽象方法 39
2.3.6类的封装性与模块的解耦合 42
2.3.7垃圾收集机制与Finalize语句段 44
2.3.8提供用电服务类的示例代码 46
2.4继承与抽象类 48
2.4.1继承的设计动机 48
2.4.2抽象类与概念抽象 49
2.5接口与实现 51
2.5.1接口的语法 51
2.5.2为什么要使用接口 52
2.5.3接口与抽象类在本质上的区别——空调外的例子 52
2.5.4通过实现接口的方式开发电视和收音机类 53
2.6具有“分离”特性的多态 55
2.6.1从重载中归纳多态的特性 55
2.6.2多态与“分离”——实现小动物叫 56
2.7 RTTI与反射 58
2.7.1君子无不可用之势——论后期编译的效果 58
2.7.2在代码里实现RTTI的效果 59
2.7.3类的照妖镜——反射 60
2.7.4使用反射机制实现代码还原 61
2.8通过约束降低出错可能性的泛型 64
2.8.1什么是泛型 64
2.8.2泛型的示例代码 64
2.9本章小结 65
第3章 Java中的数据结构——集合类 66
3.1集合类与数据容纳 66
3.1.1在项目中自定义数据类型的难处 66
3.1.2什么是数据结构 67
3.1.3Java集合中的两类数据结构 67
3.2线性表型的集合 67
3.2.1顺序访问的典范——数组类 67
3.2.2数组的改进版本——Vector类 70
3.2.3先进后出的Stack类 75
3.2.4链表式的List接口以及LinkedList实现类 78
3.2.4.1 List接口里的方法 79
3.2.4.2 List实现类及其功能 79
3.2.4.3 List代码示例 80
3.2.5 不允许有重复元素的Set接口 82
3.2.5.1 Set接口里的方法 82
3.2.5.2 Set实现类及其功能 82
3.2.6对第一类集合的归纳 84
3.2.7使用Vector模拟Stack的动作 84
3.2.8使用Vector模拟队列的动作 87
3.3键值对型的集合 89
3.3.1为什么要使用Hash类 89
3.3.2键值对的典范——Hashtable类 90
3.3.3通过“魔术代码”分析equals和hashCode方法 92
3.3.4封装了散列表数据结构的Map接口 97
3.3.4.1 Map接口里的方法 97
3.3.4.2实现Map接口的类 99
3.3.4.3 Map代码实例 99
3.3.4.4采用Entry对象遍历Map 100
3.3.5对第二类集合的归纳 101
3.4枚举器与数据操作 102
3.4.1访问集合类的“不确定性”难题 102
3.4.2“大智若愚”的枚举器接口 102
3.4.3枚举器“分离”思想的启示 104
3.4.4使用枚举器定义统一的访问各集合的方法——一个打印的例子 104
3.5深浅拷贝 106
3.5.1“偷懒”的共享数据块的方法——浅拷贝 107
3.5.2似是而非的浅拷贝——只拷贝ArrayList对象 108
3.5.3“刨根撅底”的深拷贝——实现对ArrayList的整体克隆 110
3.6 Java集合类中的排序 112
3.6.1让你的对象是可比较的 112
3.6.2为你的对象定义比较器 114
3.7本章小结 116
第4章 有异常怎么办 117
4.1异常的基本概念 117
4.1.1险恶的项目运行环境 117
4.1.2步步为营的异常处理机制 118
4.1.3Java虚拟机处理异常的流程 120
4.2异常技术综述 121
4.2.1错了不要紧——论运行期异常 121
4.2.2自食其力——处理自己的异常 122
4.2.3有问题就报告——异常的抛出声明 126
4.2.4弥补阙漏的自定义异常 128
4.3异常的陷阱 130
4.3.1异常与继承 130
4.3.2谁动了我的异常 131
4.3.3论资排辈的异常级别 133
4.4本章小结 134
第5章 IO流与流读写操作 135
5.1输入流与输出流 135
5.1.1什么是流对象 135
5.1.2复杂的输入输出应用与简单的Java IO类库 135
5.1.3 Java里IO流对象的逻辑关系 136
5.2 IO对象使用说明 137
5.2.1怎样读写文件——读写一个文本文件 138
5.2.2怎样读写内存数据 141
5.2.3怎样读写带格式的数据 144
5.2.4标准设备与重定向 146
5.2.5压缩和解压缩ZIP文件——创建一个压缩和解压缩的程序 150
5.2.6用StreamTokenizer类输出不同格式的Token 153
5.3本章小结 155
第6章 Java与多线程开发 156
6.1线程到底是什么 156
6.1.1线程的定义 156
6.1.2线程的生命周期 157
6.1.3操作系统与线程并发 158
6.2定义自己的线程，继承Thread类 158
6.2.1 Thread类与线程 158
6.2.2使用Thread类实现计数器功能 158
6.3解决继承局限性，实现Runnable接口 162
6.3.1 Runnable接口与线程 162
6.3.2使用Runnable接口实现计数器功能 162
6.4避免冲突，控制多线程的并发 165
6.4.1劳逸结合——线程的睡眠 165
6.4.2控制数据的有效性，通过synchronized关键字声明同步——一个由并发引起的数据错误修改及解决的例子 166
6.4.3线程的等待与通知线程恢复工作 177
6.4.4死锁的成因 177
6.4.5特事特办，线程的优先级 180
6.4.6多线程经典案例——生产者消费者问题 183
6.5本章小结 186
第7章 Java与网络开发 187
7.1网络开发的基本需求 187
7.1.1网络通讯模型和网络通讯协议 187
7.1.2通过TCP协议建立可靠的通讯信道 188
7.1.2.1两军问题与建立可靠连接的难题 188
7.1.2.2通过三次握手，建立通讯信道 189
7.1.2.3支持TCP协议的Java包 190
7.1.3通过UDP协议高效地发送数据报文 192
7.1.3.1 UDP协议与数据报文 192
7.1.2.2 Java的UDP相关类说明 193
7.2面向套接字编程 195
7.2.1使用套接字实现基于TCP协议的服务器和客户机程序 195
7.2.1.1开发服务器端代码 196
7.2.1.2开发客户端代码 198
7.2.1.3运行效果演示 199
7.2.2使用套接字连接多个客户机 200
7.2.2.1开发服务器端代码 200
7.2.2.2开发客户端代码 203
7.2.2.3运行效果演示 206
7.2.3 UDP协议与传输数据报文 207
7.2.3.1开发服务器端代码 207
7.2.3.2开发客户端代码 212
7.2.3.3开发客户端代码 213
7.3 RMI开发概述 215
7.3.1什么是RMI 215
7.3.2 RMI的实质——透明地调用远端方法 215
7.3.3 RMI代码实例——一个非常简单的Hello World程序 216
7.3.3.1编写提供远程方法的接口 216
7.3.3.2编写提供远程方法的实现类 217
7.3.3.3编写RMI客户端代码 218
7.3.3.4配置运行RMI代码 219
7.4本章小结 220
第8章 Java与数据库开发 221
8.1 Java连接数据库的工具 221
8.1.1连接数据库的通用接口 221
8.1.2 JDBC模型与数据库访问控制 222
8.1.3 JDBC接口概述 224
8.2以JDBC-ODBC的方式连接数据库 225
8.2.1配置Access数据库环境 225
8.2.1.1创建一个新的数据库 226
8.2.1.2在新数据库中创建一个表 227
8.2.2配置ODBC数据源连接 233
8.2.3使用JDBC_ ODBC桥接方式连接数据库 235
8.2.4获得并遍历结果集 237
8.3使用数据库驱动程序连接SQL Server 2005 239
8.3.1配置SQL Server数据库环境和数据库驱动程序 239
8.3.2使用JDBC驱动程序的方式连接数据库 242
8.3.3获得并遍历结果集 245
8.4使用数据库驱动程序连接数据库MySQL 250
8.4.1配置MySQL数据库环境和驱动程序 250
8.4.2使用驱动程序连接MySQL 253
8.4.3 Eclipse下的运行结果 255
8.5本章小结 256
第9章 Java与图形界面开发 257
9.1开发Applet应用程序 257
9.1.1什么是Applet 257
9.1.2 Applet的生命周期 258
9.1.3向Applet里添加控件 258
9.1.4 Applet的事件处理模型 260
9.1.5开发Applet的HelloWorld程序 261
9.1.5.1 HelloWorld程序 261
9.1.5.2运行HelloWorld 262
9.2重量级的图形开发工具——AWT库 264
9.2.1什么是AWT 264
9.2.2 AWT的控件说明 264
9.2.2.1容器 265
9.2.2.2组件 265
9.2.2.3布局管理器 266
9.2.3事件监听与事件处理 266
9.2.4 AWT的控件代码 267
9.3让界面开发更容易 270
9.3.1什么是Swing 270
9.3.2 Swing的容器与控件说明 270
9.3.2.1 Swing的容器 270
9.3.2.2 Swing的组件 271
9.3.3 Swing的布局控制 271
9.3.4 Swing的事件监听与事件处理机制 271
9.3.5使用Swing开发象棋界面 271
9.3.5.1象棋程序设计 271
9.3.5.2棋子和类Chess 272
9.3.5.3落子点和类Point 274
9.3.5.4规则和类ChessRule 277
9.3.5.5棋盘和类ChessBoard 277
9.3.5.6类ChessFrame 284
9.4本章小结 287
第10章 生命游戏 288
10.1需求分析与设计 288
10.1.1囚徒博弈 288
10.1.2生命游戏和囚徒博弈 288
10.1.3生命游戏的基本需求 290
10.1.3.1博弈规则 290
10.1.3.2博弈的邻居 291
10.1.3.3移动规则 292
10.1.3.4基本需求 292
10.1.3.5模块设计 293
10.2生命游戏说明 293
10.2.1开发主界面 293
10.2.1.1使用Applet开发主界面 293
10.2.1.2参数设置界面 296
10.2.1.3博弈规则设置界面 297
10.2.1.4模式选择界面 298
10.2.1.5按钮控制界面 301
10.2.1.6设置默认参数 301
10.2.1.7参数说明 302
10.2.2开发游戏模拟界面 305
10.2.2.1获得游戏参数 305
10.2.2.2数据显示界面 306
10.2.2.3模拟界面 307
10.2.2.4构造函数 312
10.2.3开发事件监听与响应机制 312
10.3业务逻辑开发 315
10.3.1企业模块 315
10.3.2生命游戏的逻辑代码 317
10.3.3让生命运动起来 323
10.4运行游戏 324
10.4.1编写运行Applet的网页 324
10.4.2设置游戏参数 325
10.4.3企业ID显示模式 326
10.4.4企业方向显示模式 328
10.4.5企业策略显示模式 329
10.5本章小结 330
第11章 基于图形和网络的Java聊天室 331
11.1设计我们的聊天室 331
11.1.1需求分析 331
11.1.2模块设计 331
11.1.3创建chatroom工程 333
11.2设计并开发数据库模块 333
11.2.1设计数据库的表结构 333
11.2.2设计和开发数据库连接模块 334
11.2.3设计和开发数据库处理模块 336
11.3 swing界面模块开发 338
11.3.1创建Swing类 338
11.3.2登录界面 340
11.3.3注册界面 343
11.3.4聊天界面 346
11.4 swing界面模块开发 348
11.4.1客户端开发 348
11.4.2使用socket发送非阻塞I0流 348
11.4.3使用socket接收非阻塞I0流 352
11.5服务端开发 356
11.5.1非阻塞I0在socket服务器上的应用 356
11.5.2服务端程序 356
11.6运行效果演示 362
11.7本章小结 364
第12章 学生信息管理系统 365
12.1需求分析与设计 365
12.1.1基本需求 3
12.1.2模块设计 365
12.1.3数据库设计 366
12.2界面设计 369
12.2.1登录界面的设计 369
12.2.2查询界面的设计 373
12.2.3新建界面的设计 374
12.2.4修改界面和删除界面的设计 375
12.3系统模块的开发 376
12.3.1学生信息对象 376
12.3.2数据库操作模块 377
12.3.3登录模块 384
12.3.4新建模块 385
12.3.5修改模块 387
12.3.6删除模块 389
12.3.7查询模块 390
12.4本章小结 401
第13章 MVC模式与项目开发 402
13.1 MVC模式概述 402
13.1.1 OCP原则与模块分离思想 402
13.1.2什么是MVC模式 403
13.1.2.1模型层 404
13.1.2.2视图层 405
13.1.2.3控制器 405
13.1.2.4 MVC模型编程综述 406
13.1.3 MVC模式的工作流程 406
13.1.3.1第一步：设计模型接口 407
13.1.3.2第二步：设计视图接口，基本方法同模型接口的设计 408
13.1.4为什么要使用MVC模式 408
13.1.4.1 MVC的优点 408
13.1.4.2 MVC的适用性 409
13.2 MVC模型示例代码 409
13.2.1开发模型组件 409
13.2.2开发视图组件 415
13.2.3开发控制器组件 418
13.2.4让蛇开始活动（MVC工作流程） 420
13.3再论MVC模式 421
13.3.1“分离”思想带来的好处 422
13.3.2 MVC在代码维护时的优势 422
13.3.3 MVC在代码扩展时的优势 423
13.3.4 MVC与Java架构设计 423
13.4本章小结 426
第14章 设计模式与项目开发 427
14.1设计模式概述 427
14.1.1什么是设计模式 427
14.1.2设计模式解决问题的一般途径 428
14.1.3为什么要使用设计模式 428
14.1.4设计模式的优势 429
14.2工厂模式与构造分离 429
14.2.1工厂模式概述 429
14.2.2分离生产过程与生产动作 430
14.2.3工厂模式与连接对象构造 431
14.3桥接模式与业务扩展 434
14.3.1桥接模式与DIP原则 434
14.3.2架在不同解决方案之间的桥梁——桥接模式 435
14.3.3桥接模式与业务扩展 436
14.3.4使用桥接模式优化数据库连接代码 438
14.4观察者模式与拉推数据 439
14.4.1饲机而动的观察者 439
14.4.2观察者与后继动作 441
14.4.3使用观察者模式实现数据动态更新 443
14.5 Vistor模式与RTTI 445
14.5.1 RTTI的局限性 446
14.5.2包容不同类的Vistor模式 447
14.5.3使用Vistor模式实现客户关系动态管理 448
14.6外观、代理模式与屏蔽细节 453
14.6.1什么是外观和代理模式 453
14.6.2外观和代理模式的使用场景及其优势 454
14.6.3使用外观和代理模式优化数据库通用模块 454
14.7单例模式 457
14.7.1只允许有一个实例的单例模式 457
14.7.2单例模式的语法实现 458
14.7.3单例模式的使用案例 459
14.8本章小结 460
第15章 DAO模式与数据库访问 461
15.1 DAO模式与数据库管理架构 461
15.1.1什么是DAO设计模式 461
15.1.2纵观DAO模式的优势 462
15.2 DAO模式应用示例 463
15.2.1使用DAO模式连接数据库 464
15.2.2在DAO里编写数据库访问逻辑 465
15.2.3数据库访问逻辑和业务逻辑的结合体——DAO 472
15.2.4编写业务逻辑 473
15.2.5 DAO模式与业务变更 479
15.3本章小结 483
第16章 设计模式的应用 485
16.1设计模式与代码优化 485
16.1.1学生信息管理系统的需求变更 485
16.1.2业务变更与代码重构 486
16.2使用设计模式提高代码的弹性 487
16.2.1什么是代码的弹性 487
16.2.2利用桥接模式改善系统的弹性 487
16.3数据库的设计和修改 489
16.3.1 User表的设计 489
16.3.2 Students_Information表的设计 490
16.3.3 Teachers_Information表的设计 491
16.4重构系统 492
16.4.1桥的一端——数据库连接 492
16.4.1.1现有的数据库模块 492
16.4.1.2数据库连接接口 494
16.4.1.3采用单态模式实现具体的数据库连接动作 494
16.4.1.4获得数据库连接的工厂模式 497
16.4.2桥的另一端——信息类 498
16.4.2.1抽象的信息类Person 498
16.4.2.2 Student——Person类的扩展 500
16.4.2.3 Teacher——Person的另一个扩展 507
16.4.3业务流程的修改 514
16.4.3.1登录界面的修改 514
16.4.3.2学生信息业务流程的修改 518
16.4.3.3教师信息管理的业务流程 524
16.4.4设计模式总结 524
16.5本章小结 525
第17章 基于JSP+Servlet的Web架构 526
17.1 Java的Web开发概述 526
17.1.1 Web开发里的显示、控制、业务三要素 526
17.1.2 Java处理Web应用的基本方式 527
17.1.3各司其职的Java Web组件 528
17.1.4在Eclipse上引入MyEclipse插件 529
17.1.5在Eclipse＋MyEclipse环境上配置Web服务器环境 530
17.2开发简单的Servlet 533
17.2.1 Servlet的生命周期 533
17.2.2编写简单的Servlet 534
17.2.3编写Servlet的相关配置文件 536
17.2.4打包和发布Web应用 536
17.2.5在Eclipse集成环境中开发Servlet并发布运行 537
17.3开发简单的JSP程序 543
17.3.1 JSP的基本语法和工作过程 543
17.3.2只让JSP做它擅长的事——论JSP的工作范围 544
17.3.3编写JSP的Hello World程序 545
17.3.4打包发布JSP的Web应用程序 545
17.3.5在Eclipse集成开发环境中编写JSP并运行 545
17.4开发JSP＋Servlet构架的程序 547
17.4.1编写登录表单页面 547
17.4.2编写登录成功后的展示页面 548
17.4.3编写登录失败后的展示页面 548
17.4.4编写负责处理登录逻辑的Servlet类并运行测试 549
17.4.5准备数据库以及相关驱动 551
17.4.6修改LoginServlet，添加JDBC访问代码 552
17.5对JSP＋Servlet＋JDBC模式的思考 553
17.5.1组件“各司其职”带来的好处 554
17.5.2 MVC思想及其开发模式的雏形 554
17.5.3没有封装业务逻辑的后果 554
17.6本章小结 555
第18章 基于JavaBean和EJB的Web架构 556
18.1组件思想与多层Web架构 556
18.1.1为什么要构建多层的Web架构 556
18.1.2标准零件般的Java Web组件 557
18.1.3实现后台业务逻辑的JavaBean与EJB组件 559
18.2使用JavaBean组件 560
18.2.1编写负责显示逻辑的JSP代码 560
18.2.2编写封装业务逻辑的JavaBean代码 561
18.2.3通过DAO模式连接访问数据库 564
18.2.4编写数据源的配置文件 567
18.2.5在集成环境里发布JSP＋JavaBean＋数据库的代码 568
18.2.6在Web服务器里运行JSP＋Javabean＋数据库代码 569
18.3开发基于JSP＋Servlet＋EJB＋JDBC的Web构架 569
18.3.1“大”材“小”用的Javabean与“小”材“大”用的EJB 569
18.3.2在集成环境里配置EJB的集成开发环境 570
18.3.3EJB的种类及其用途 571
18.3.4给Javabean加个“E”——升级现有的Javabean组件之了解EJB的规范 572
18.3.5编写负责显示逻辑的JSP代码 572
18.3.6编写负责控制逻辑的Servlet代码 575
18.3.7编写负责业务逻辑的EJB代码 577
18.3.8使用工厂模式规范EJB的初始化过程 580
18.3.9通过DAO模式连接访问数据库 580
18.3.10编写EJB和Servlet的配置文件 581
18.3.11打包发布EJB包 582
18.3.12在集成环境里配置和运行EJB程序 583
18.4开发会话Bean＋实体Bean的综合应用 587
18.4.1会话Bean和实体Bean的用途分析 587
18.4.2根据外观模式的思想整合会话Bean与实体Bean 587
18.4.3编写负责显示逻辑的JSP代码 588
18.4.4编写负责控制逻辑的Servlet代码 590
18.4.5编写承上启下的会话Bean代码 592
18.4.6编写负责业务逻辑的实体Bean代码 594
18.4.7编写Servlet和EJB的配置环境 597
18.4.8打包发布EJB包 601
18.5对EJB组件的思考 601
18.5.1用标准化的EJB积木搭建外观统一的J2EE模型 601
18.5.2J2EE架构里的MVC模式 601
18.5.3从Javabean升级到EJB的启示 602
18.5.4为什么J2EE和EJB能满足企业级的开发需求 602
18.6本章小结 602
第19章 基于J2EE的在线购物系统 603
19.1需求分析与设计 603
19.1.1在线购物系统需求概述 603
19.1.2根据J2EE架构设计模块和流程 605
19.1.3数据库设计 607
19.1.4配置运行环境 611
19.2系统整体架构 612
19.2.1前台展现层设计——通过MVC模式实现页面跳转 612
19.2.2中间业务层设计——通过DAO使用会话Bean建立业务逻辑 624
19.2.3后台数据层设计——通过EJB操作数据库 629
19.2.4整体架构图 630
19.3公共模块 631
19.3.1编写负责显示逻辑的JSP代码 631
19.3.2编写控制器层的Servlet和Action类 634
19.3.3编写封装业务逻辑的DAO类 635
19.3.4编写访问数据库的EJB 636
19.4购物车管理模块 643
19.4.1编写负责显示逻辑的JSP代码 643
19.4.2编写控制器层的Servlet和Action类 647
19.5代码发布 649
19.5.1编写配置文件 649
19.5.2组装EJB组件和Web应用 655
19.5.3显示运行效果 665
19.6企业级项目中应用EJB的思考 667
19.6.1使用EJB可以减轻项目维护的工作量 667
19.6.2 EJB里包含的设计模式 668
19.6.3重量级和轻量级组件的比较 668
19.7本章小结 668
第20章 Struts架构与Web应用 669
20.1 Struts与MvC思想 669
20.1.1从Struts架构里看“架构”的概念 669
20.1.2 MVC思想与分层管理的好处 671
20.1.3 Struts——“抽”出Web应用里“像”的流程 671
20.1.3.1 Struts模型组件 671
20.1.3.2 Struts控制组件 672
20.1.3.3 Struts模型层 672
20.1.3.4 Struts视图组件 673
20.1.4可以抽象出Web流程的Struts重要组件说明 673
20.1.5配置Struts开发环境 673
20.2 Struts的HelloWorld实例 675
20.2.1用JSP编写视图端的代码 676
20.2.1.1 Struts HTML类标签 677
20.2.1.2生成HTML的表单标标签 678
20.2.1.3显示错误和消息的标签 681
20.2.1.4 Struts的其他标签 682
20.2.2编写ActionServlet类 682
20.2.3编写ActionForm类 684
20.2.4编写Action类 686
20.2.5编写ActionMapping类和ActionForward类 689
20.2.6编写配置文件 689
20.2.6.1配置web.xml文件 690
20.2.6.2配置struts-confiig.xml文件 691
20.2.7在集成环境上编译与发布Struts代码 693
20.2.8效果演示与工作流程概述 695
20.3对Struts组件的思考 696
20.3.1 Struts的体系结构与Web流程抽象 696
20.3.2 Struts与业务逻辑如何耦合 697
20.3.3分工不同的Struts与EJB 697
20.4 Struts 2.0新特性 698
20.4.1 Struts 2.0和Struts 1.X的比较 698
20.4.2 Struts 2.0处理请求的流程 699
20.4.3 Struts 2.0的示例代码——经典的Hello World 700
20.5本章小结 704
第21章 Spring架构与Web应用 705
21.1 Spring与控制反转思想 705
21.1.1用到的时候才去获取的控制反转思想 705
21.1.2控制反转与轻量级Web开发 708
21.1.3基于控制反转的Spring概述 709
21.1.4配置Spring的开发环境 710
21.2 Spring的HelloWorld实例 714
21.2.1编写服务提供代码 714
21.2.2在xml文件里登记各项服务 715
21.2.3编写服务调用代码 716
21.2.4效果演示与工作流程概述 717
21.3 Spring的常用技术 717
21.3.1拦截器与AOP编程 718
21.3.2在Spring里实现事务管理 723
21.3.3数据持久性与ORM思想 725
21.4对Spring组件的思考 729
21.4.1 Spring组件是对重量级Web组件的颠覆 729
21.4.2 Spring组件对轻量级Web开发的启示 730
21.4.3指导Web流程的Struts与包含强力工具的Spring组件 731
21.5本章小结 731
第22章 ORM组件与数据库访问控制 732
22.1 ORM组件与数据映射 732
22.1.1什么是ORM 732
22.1.2为什么要用ORM组件 732
22.1.3 ORM组件包含的外观设计模式 733
22.1.4配置ORM组件的开发环境 734
22.2 Hibernate与数据库开发 740
22.2.1数据映射的需求分析 740
22.2.2数据映射的实例 741
22.2.3编写ORM的客户端代码 745
22.2.4效果演示与工作流程概述 749
22.3 Hibernate组件入门 751
22.3.1Hibernate数据库连接APl 751
22.3.2 Hibernate对JDBC的改进 753
22.3.3 Hibernate与数据库事务管理 753
22.3.4 Hibernate配置文件分析 757
22.4对ORM组件的思考 760
22.4.1与轻量级Web组件的关系 760
22.4.2数据映射与DAO模式 761
22.4.3数据映射与数据库分层应用 762
22.5本章小结 763
第23章 Struts与Spring集成开发 764
23.1 Struts与Spring集成概述 764
23.1.1 Struts和Spring的固有局限 764
23.1.2两者集成后的优势 765
23.1.3准备Struts和Spring集成的开发环境 765
23.2在Struts中集成Spring 769
23.2.1需求描述 769
23.2.2基于Struts的实现 770
23.2.2.1配置开发环境 770
23.2.2.2编写web.xml文件 773
23.2.2.3编写环境界面的代码 775
23.2.2.4编写Struts里的form类 775
23.2.2.5编写Struts里的Action类 776
23.2.2.6编写Struts里的struts-config.xml文件 777
23.2.2.7把Struts部署到服务器上 778
23.2.3基于Spring中的ActionSupport类整合Struts 780
23.2.3.1配置开发环境 780
23.2.3.2编写web.xml文件 781
23.2.3.3编写环境界面的代码 782
23.2.3.4编写Struts里的form类 783
23.2.3.5编写Struts里的Action类 783
23.2.3.6配置和编写Spring里的config.xml相关文件 784
23.2.3.7编写Struts里的struts-confiig.xml文件 786
23.2.3.8把Struts部署到服务器上 787
23.2.4基于Spring中的DelegatingRequestProcessor类整合Struts 789
23.2.4.1配置开发环境 789
23.2.4.2编写web.xml文件 789
23.2.4.3编写环境界面的代码 791
23.2.4.4编写Struts里的form类 792
23.2.4.5编写Struts里的Action类 792
23.2.4.6配置和编写Spring里的config.xml相关文件 793
23.2.4.7编写Struts里的struts-config.xml文件 795
23.2.4.8把Struts部署到服务器上 796
23.2.5基于Spring中的DelegatingActionProxy类整合Struts 798
23.2.5.1配置开发环境 798
23.2.5.2编写web.xml文件 798
23.2.5.3编写环境界面的代码 799
23.2.5.4编写Struts里的form类 801
23.2.5.5编写Struts里的Action类 801
23.2.5.6配置和编写Spring里的config.xml相关文件 802
23.2.5.7编写Struts里的struts-config.xml文件 804
23.2.5.8把Struts部署到服务器上 805
23.3集成后的思考 806
23.3.1利用控制反转为代码降耦 807
23.3.2 Spring与Struts三种整合方式的对比 807
23.4本章小结 807
第24章 基于Struts+Spring+Hibernate的在线购物系统 809
24.1 EJB迁移到SSH架构的工作要点 809
24.1.1配置开发环境 809
24.1.2 SSH和EJB的对比 814
24.1.3迁移的工作要点分析 814
24.2整体架构的改写 829
24.2.1前台展现层改写——通过Struts的MVC模式实现页面跳转 829
24.2.2中间业务层改写——通过DAO建立业务逻辑 832
24.2.3后台数据层改写——通过Hibernate将vo对象保存到数据库 833
24.3代码发布 835
24.3.1编写配置文件 835
24.3.2在集成开发环境里发布项目 848
24.3.3显示运行效果 854
24.4 SSH架构的思考 856
24.4.1轻量级和重量级Web构架的差异 857
24.4.2 SSH的适用范围 857
24.5本章小结 857
第25章 Java的Web Service应用 858
25.1 Web Service概述 858
25.1.1什么是Web Service 858
25.1.2为什么要使用Web Service 858
25.1.3 Web Service的特点 859
25.2 Web Service协议 859
25.2.1 SOAP——简单对象访问协议 860
25.2.2 WSDL—— Web服务描述语言 862
25.3开发基于Axis2的Web Service应用程序 863
25.3.1什么是Axis2 863
25.3.2搭建Web Service环境 864
25.3.2.1安装Ant环境 864
25.3.2.2安装Axis2 865
25.3.3第一个Web Service程序 866
25.3.3.1服务端的开发 866
25.3.3.2客户端的开发 871
25.3.4高效的Axiom 875
25.3.4.1服务端的开发 875
25.3.4.2客户端的开发 878
25.4 J2EE架构里的Web Service 881
25.4.1在struts架构中使用Web Service 881
25.4.1.1创建一个struts项目 881
25.4.1.2建立框架 882
25.4.1.3编写代码 885
25.4.2 EJB中的Web Service 894
25.4.2.1 Web Service环境 894
25.4.2.2感受EJB中的Web Service 895
25.5本章小结 896