目    录

第1章  Java与面向对象思想

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语法

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中的数据结构——集合类

3.1  集合类与数据容纳 66

3.1.1  在项目中自定义数据类型的难处 66

3.1.2  什么是数据结构 67

3.1.3  Java集合中的两类数据结构 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章  有异常怎么办

4.1  异常的基本概念 117

4.1.1  险恶的项目运行环境 117

4.1.2  步步为营的异常处理机制 118

4.1.3  Java虚拟机处理异常的流程 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流与流读写操作

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与多线程开发

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与网络开发

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与数据库开发

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与图形界面开发

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章  生命游戏

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聊天室

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发送非阻塞IO流 348

11.4.3  使用socket接收非阻塞IO流 352

11.5  服务端开发 356

11.5.1  非阻塞IO在socket服务器上的应用 356

11.5.2  服务端程序 356

11.6  运行效果演示 362

11.7  本章小结 364

第12章  学生信息管理系统

12.1  需求分析与设计 365

12.1.1  基本需求 365

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模式与项目开发

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章  设计模式与项目开发

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模式与数据库访问

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章　设计模式的应用

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架构

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架构

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.3  EJB的种类及其用途 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.2  J2EE架构里的MVC模式 601

18.5.3  从Javabean升级到EJB的启示 602

18.5.4  为什么J2EE和EJB能满足企业级的开发需求 602

18.6  本章小结 602

第19章  基于J2EE的在线购物系统

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应用

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-config.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应用

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组件与数据库访问控制

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.1  Hibernate数据库连接API 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集成开发

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-config.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的

在线购物系统

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应用

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

??

??

??

??

Java第一步——基础+设计模式+Servlet+EJB+Struts+Spring+Hibernate

目录