胡书敏，大连理工大学计算机科学硕士。现就职于上海威迅教育，有丰富的培训经验与教材开发经验，擅长架构及设计模式的综合运用。5年Java方面的软件开发经验，开发过交通银行外汇交易满金宝系统等一系列大型银行和电子商务系列的Java程序，担任过项目经理和架构师。
　　曾著有《Visual C# 2005数据库通用模块开发与系统移植》一书。
　　陈宝峰，国家火炬计划软件基地示范讲师、神州文华优秀教师奖获得者、Java国际认证讲师、软件开发课程国际认证讲师。拥有多年软件开发和架构经验，同时拥有6年授课经历，在其学员中有着很好的口碑。精通Java、.NET、C++、Oracle、SQL Server，以及Red Hat Linux。
　　程炜杰，上海交通大学计算机工程硕士。现就职于上海电信，任软件设计师。具有多年软件开发经验，从事基于Java的Web以及Application开发工作，曾经负责及参与过的项目有：上海电信小灵通PHS基站告警系统、上海电信112故障派修系统、上海电信故障派修短信网关系统、上海电信用户终端自修复系统。主要担任项目经理以及Struts、Web Service、JMS等相关模块的开发。

　　《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》讲述Java语言是复杂的，因为它承载着太多的Web开发需求点；Java又是简单的，只要用心，每个人都可以学会。你手中的这本《Java第一步》，就是通过生动的语言和一个个引人入胜的案例，向你讲述Java开发的各个知识点。《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》作者已从事Java开发多年。在《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》中，作者以自己的经验向大家描述了一条学习Java的道路，其中不求向大家讲述最复杂最高深的知识点，但求通过讲述当前最实用的开发思想和方法，尽快地达到让大家掌握用Java语言开发中等规模项目的目的。
　　“知其然，知其所以然”是《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》的创作动机，而通俗易懂更是贯穿《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》写作的全程。当你阅读《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》时，将会发现作者在字里行间中，正用文字与你交流。
　　在《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》的第一到第九章里，将围绕“实用性”这个主题，以“面向对象”的思考方式，向大家逐渐展开Java开发的各项基础知识，比如异常处理、网络开发、数据库，以及Swing。在这个部分里，大家将通过一种益智游戏——象棋，来理解Swing里的界面开发和事件处理方式。
　　在《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》的第十到第十六章里，将围绕Java语言的精髓——设计模式和架构思想，通过贪吃蛇和生命游戏等案例，讲述Java项目设计过程中思考问题的方式。通过了解本章的DAO、MVC等思想，大家能了解到Java设计思想的本质。
　　在前两部分的铺垫下，在《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》的十七章及以后的部分里，讲述了Java的Web开发组件和Web开发模式。这部分比较实用的Java技术将会使你能够很快地从事软件公司里的Web开发工作。
　　《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》虽以“实用性”为宗旨，但大家在阅读《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》时，不应过多地拘泥于“实用主义”，过分地关注其中的API，而应当通过语法关注设计模式和架构思想的本质，这样才能在Java艺术殿堂里得到更完美的享受。
　　《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》不是一本技术说明手册，而是一本Java编程思想的指南。你即将探索Java艺术的殿堂，这《Java第一步：基础+设计模式+Servlet+EJB+Struts+Spring+Hiberna》将会让你更快地获得Java的知识、智慧和成就感。

　　第3章 Java中的数据结构——集合类
　　本章将通过讲解Java集合类的具体语法和使用方式，来向大家展示Java在数据结构方面编程的强大功能。
　　集合类的这些强大功能，源自于Java具有的面向对象思想特性。所以，希望大家在学习这个章节的时候，把集合类的语法同面向对象思想中的“通过继承抽象基类功能”和“通过多态屏蔽逻辑动作细节”等原则结合起来，这样能更好地从模块层次的角度理解和运用Java集合类。
　　3.1  集合类与数据容纳
　　Java用集合类来容纳代码中的不同种类数据，这种容纳是建立在未知的基础上，即Java要用有限种类的集合类，来容纳代码中无限种类的数据对象。
　　用生活里的场景来对应的话，Java的集合类需要设计成“能容纳液态气态和固态等不同类型物质”的容器，要设计这样的“万能容器”确实很困难，但JDK 的设计者们通过借鉴面向对象思想里的“多态”，实现了这个需求。
　　3.1.1  在项目中自定义数据类型的难处
　　如果我们在项目运行前，事先为项目代码准备好所有类型的数据对象，并根据这些数据对象的不同类型，为它们在内存里分配好空间，这是非常理想的，但事实上，我们做不到这点。
　　比如，在关于天气预报的项目里，我们需要一个对象来保存描述温度的信息，这个问题看上去很好解决，定义一个变量就行了，但没有那么简单。
　　如果描述温度信息的格式有多种，有用数字型的格式（比如多少度），也有用字符型的格式（比如 “很冷”），并且程序员只有在接收到这个信息的时候才能明确地知道信息的格式，事情就比较麻烦。为了保证能容纳所有类型的数据，我们不得不用Java语言所有对象的老祖宗类——Object类型数据来接收这个温度信息。
　　但是，如果问题变得再复杂点呢？如果我们在代码里需要用一个（或一组）对象来描述一天里所有来访的客户信息，这样，除非这段代码被运行，否则我们甚至不知道当天会来多少客户和客户的种类，这给我们的编程带来了很大的难题。因为我们不知道代码所需要的对象的数目和种类。所以在代码里，要求能够在任何时候、任何地点创建任意数量的任何类型对象。
　　这对代码的要求似乎高了些，但是，很不幸的是，在编程中这是个“常规”要求。不过，使用数据结构的思想能够较好地解决这一问题。
　　3.1.2  什么是数据结构
　　数据结构是在计算机编程领域里被广泛使用的术语，它用来研究数据对象的内部构成，即这个数据对象由哪些基本的数据元素构成，这个数据对象以什么方式构成，以及它呈什么结构。
　　数据结构主要研究数据的各种逻辑结构和存储结构，以及对不同种数据类型的各种操作。因此，数据结构主要有两方面的内容：数据的逻辑存储结构和对数据的操作。
　　Java的集合类可以很好地用来描述基于Java语言的数据结构，在本章里，我们不会具体描述如何实现数据结构内部细节的内容，而是将通过学习Java的集合，在了解其数据组织方式和操作的基础上，熟悉这些集合类的用途和特长，为能够在项目中很好地使用这些集合类打下坚实的基础。
　　3.1.3  Java集合中的两类数据结构
　　归纳起来讲，Java的集合可以分为两类，第一类是以数组为代表，这类集合可以描述线性表类型的数据结构，第二类是以Map为代表，这类集合可以描述“键值对”类型的数据结构。
　　描述第一类数据结构的集合是以Collection为基类，在Collection类里，封装了线性表的插入、删除等基本操作；而数据结构的集合是以Map为基类。两类集合分别通过继承和扩展这两个基类，可以逐渐细化，从而得到诸如堆栈和哈希表之类的数据集合对象。
　　这两类不同类型的集合，可以很好地在各种应用中存储各种类型的数据，所以说，熟悉了这两类集合，就可以熟悉Java语言下的两类数据结构。

目 录
第1章 Java与面向对象思想
1.1 初识Java语言
1.1.1 Java是什么
1.1.2 为什么要选用Java语言
1.1.3 Java语言的解释执行与跨平台特性
1.1.4 怎样学好Java

1.2 什么是面向对象思想
1.2.1 软件开发的方法学——面向对象思想提出的背景
1.2.2 面向对象的物质基础——类与封装
1.2.3 抽象与代码复用——抽象类与概念抽象
1.2.4 模块的开关——接口与功能抽象
1.2.5 同名但不同参——多态与重载
1.2.6 具有面向对象思想语言的优势

1.3 开发我们的第一个Java程序
1.3.1 如何配置Java的开发环境
1.3.1.1 下载和安装JDK
1.3.1.2 设置JDK的环境变量
1.3.3.3 安装Eclipse
1.3.3.4 添加Eclipse的中文插件
1.3.2 编写HelloWorld程序
1.3.3 运行HelloWorld程序
1.3.4 使用Eclipse集成开发环境运行HelloWorld程序
1.4 本章小结

第2章 开始学习Java语法
2.1 基本数据类型与操作符
2.1.1 基本数据类型
2.1.2 基本操作符
2.1.3 操作符优先级
2.1.4 对象型的数据类型
2.1.5 方法（函数）的参数和返回值

2.2 程序流程控制
2.2.1 顺序与分支
2.2.2 循环流程
2.2.3 有争议的goto语句
2.2.4 使用if语句判定是否是闰年
2.2.5 使用循环语句计算阶乘
2.2.6 使用switch语句控制输出

2.3 类与封装
2.3.1 类的构成要素
2.3.2 类的构造函数与构造次序
2.3.3 用package封装工具类和用import引入需要的类
2.3.4 修饰符与类内部对象的可见性
2.3.5 静态方法与抽象方法
2.3.6 类的封装性与模块的解耦合
2.3.7 垃圾收集机制与Finalize语句段
2.3.8 提供用电服务类的示例代码

2.4 继承与抽象类
2.4.1 继承的设计动机
2.4.2 抽象类与概念抽象

2.5 接口与实现
2.5.1 接口的语法
2.5.2 为什么要使用接口
2.5.3 接口与抽象类在本质上的区别——空调外的例子
2.5.4 通过实现接口的方式开发电视和收音机类

2.6 具有“分离”特性的多态
2.6.1 从重载中归纳多态的特性
2.6.2 多态与“分离”——实现小动物叫

2.7 RTTI与反射
2.7.1 君子无不可用之势——论后期编译的效果
2.7.2 在代码里实现RTTI的效果
2.7.3 类的照妖镜——反射
2.7.4 使用反射机制实现代码还原

2.8 通过约束降低出错可能性的泛型
2.8.1 什么是泛型
2.8.2 泛型的示例代码
2.9 本章小结

第3章 Java中的数据结构——集合类
3.1 集合类与数据容纳
3.1.1 在项目中自定义数据类型的难处
3.1.2 什么是数据结构
3.1.3 Java集合中的两类数据结构

3.2 线性表型的集合
3.2.1 顺序访问的典范——数组类
3.2.2 数组的改进版本——Vector类
3.2.3 先进后出的Stack类
3.2.4 链表式的List接口以及LinkedList实现类
3.2.4.1 List接口里的方法
3.2.4.2 List实现类及其功能
3.2.4.3 List代码示例
3.2.5 不允许有重复元素的Set接口
3.2.5.1 Set接口里的方法
3.2.5.2 Set实现类及其功能
3.2.6 对第一类集合的归纳
3.2.7 使用Vector模拟Stack的动作
3.2.8 使用Vector模拟队列的动作

3.3 键值对型的集合
3.3.1 为什么要使用Hash类
3.3.2 键值对的典范——Hashtable类
3.3.3 通过“魔术代码”分析equals和hashCode方法
3.3.4 封装了散列表数据结构的Map接口
3.3.4.1 Map接口里的方法
3.3.4.2 实现Map接口的类
3.3.4.3 Map代码实例
3.3.4.4 采用Entry对象遍历Map
3.3.5 对第二类集合的归纳

3.4 枚举器与数据操作
3.4.1 访问集合类的“不确定性”难题
3.4.2 “大智若愚”的枚举器接口
3.4.3 枚举器“分离”思想的启示
3.4.4 使用枚举器定义统一的访问各集合的方法——一个打印的例子

3.5 深浅拷贝
3.5.1 “偷懒”的共享数据块的方法——浅拷贝
3.5.2 似是而非的浅拷贝——只拷贝ArrayList对象
3.5.3 “刨根撅底”的深拷贝——实现对ArrayList的整体克隆

3.6 Java集合类中的排序
3.6.1 让你的对象是可比较的
3.6.2 为你的对象定义比较器
3.7 本章小结

第4章 有异常怎么办
4.1 异常的基本概念
4.1.1 险恶的项目运行环境
4.1.2 步步为营的异常处理机制
4.1.3 Java虚拟机处理异常的流程

4.2 异常技术综述
4.2.1 错了不要紧——论运行期异常
4.2.2 自食其力——处理自己的异常
4.2.3 有问题就报告——异常的抛出声明
4.2.4 弥补阙漏的自定义异常

4.3 异常的陷阱
4.3.1 异常与继承
4.3.2 谁动了我的异常
4.3.3 论资排辈的异常级别
4.4 本章小结

第5章 IO流与流读写操作
5.1 输入流与输出流
5.1.1 什么是流对象
5.1.2 复杂的输入输出应用与简单的Java IO类库
5.1.3 Java里IO流对象的逻辑关系

5.2 IO对象使用说明
5.2.1 怎样读写文件——读写一个文本文件
5.2.2 怎样读写内存数据
5.2.3 怎样读写带格式的数据
5.2.4 标准设备与重定向
5.2.5 压缩和解压缩ZIP文件——创建一个压缩和解压缩的程序
5.2.6 用StreamTokenizer类输出不同格式的Token
5.3 本章小结

第6章 Java与多线程开发
6.1 线程到底是什么
6.1.1 线程的定义
6.1.2 线程的生命周期
6.1.3 操作系统与线程并发

6.2 定义自己的线程，继承Thread类
6.2.1 Thread类与线程
6.2.2 使用Thread类实现计数器功能

6.3 解决继承局限性，实现Runnable接口
6.3.1 Runnable接口与线程
6.3.2 使用Runnable接口实现计数器功能

6.4 避免冲突，控制多线程的并发
6.4.1 劳逸结合——线程的睡眠
6.4.2 控制数据的有效性，通过synchronized关键字声明同步——一个由并发引起的数据错误修改及解决的例子
6.4.3 线程的等待与通知线程恢复工作
6.4.4 死锁的成因
6.4.5 特事特办，线程的优先级
6.4.6 多线程经典案例——生产者消费者问题
6.5 本章小结

第7章 Java与网络开发
7.1 网络开发的基本需求
7.1.1 网络通讯模型和网络通讯协议
7.1.2 通过TCP协议建立可靠的通讯信道
7.1.2.1 两军问题与建立可靠连接的难题
7.1.2.2 通过三次握手，建立通讯信道
7.1.2.3 支持TCP协议的Java包

7.1.3 通过UDP协议高效地发送数据报文
7.1.3.1 UDP协议与数据报文
7.1.2.2 Java的UDP相关类说明

7.2 面向套接字编程
7.2.1 使用套接字实现基于TCP协议的服务器和客户机程序
7.2.1.1 开发服务器端代码
7.2.1.2 开发客户端代码
7.2.1.3 运行效果演示

7.2.2 使用套接字连接多个客户机
7.2.2.1 开发服务器端代码
7.2.2.2 开发客户端代码
7.2.2.3 运行效果演示

7.2.3 UDP协议与传输数据报文
7.2.3.1 开发服务器端代码
7.2.3.2 开发客户端代码
7.2.3.3 开发客户端代码

7.3 RMI开发概述
7.3.1 什么是RMI
7.3.2 RMI的实质——透明地调用远端方法
7.3.3 RMI代码实例——一个非常简单的Hello World程序
7.3.3.1 编写提供远程方法的接口
7.3.3.2 编写提供远程方法的实现类
7.3.3.3 编写RMI客户端代码
7.3.3.4 配置运行RMI代码
7.4 本章小结

第8章 Java与数据库开发
8.1 Java连接数据库的工具
8.1.1 连接数据库的通用接口
8.1.2 JDBC模型与数据库访问控制
8.1.3 JDBC接口概述

8.2 以JDBC-ODBC的方式连接数据库
8.2.1 配置Access数据库环境
8.2.1.1 创建一个新的数据库
8.2.1.2 在新数据库中创建一个表
8.2.2 配置ODBC数据源连接
8.2.3 使用JDBC_ODBC桥接方式连接数据库
8.2.4 获得并遍历结果集

8.3 使用数据库驱动程序连接SQL Server 2005
8.3.1 配置SQL Server数据库环境和数据库驱动程序
8.3.2 使用JDBC驱动程序的方式连接数据库
8.3.3 获得并遍历结果集

8.4 使用数据库驱动程序连接数据库MySQL
8.4.1 配置MySQL数据库环境和驱动程序
8.4.2 使用驱动程序连接MySQL
8.4.3 Eclipse下的运行结果
8.5 本章小结

第9章 Java与图形界面开发
9.1 开发Applet应用程序
9.1.1 什么是Applet
9.1.2 Applet的生命周期
9.1.3 向Applet里添加控件
9.1.4 Applet的事件处理模型
9.1.5 开发Applet的HelloWorld程序
9.1.5.1 HelloWorld程序
9.1.5.2 运行HelloWorld

9.2 重量级的图形开发工具——AWT库
9.2.1 什么是AWT
9.2.2 AWT的控件说明
9.2.2.1 容器
9.2.2.2 组件
9.2.2.3 布局管理器
9.2.3 事件监听与事件处理
9.2.4 AWT的控件代码

9.3 让界面开发更容易
9.3.1 什么是Swing
9.3.2 Swing的容器与控件说明
9.3.2.1 Swing的容器
9.3.2.2 Swing的组件

9.3.3 Swing的布局控制
9.3.4 Swing的事件监听与事件处理机制
9.3.5 使用Swing开发象棋界面
9.3.5.1 象棋程序设计
9.3.5.2 棋子和类Chess
9.3.5.3 落子点和类Point
9.3.5.4 规则和类ChessRule
9.3.5.5 棋盘和类ChessBoard
9.3.5.6 类ChessFrame
9.4 本章小结

第10章 生命游戏
10.1 需求分析与设计
10.1.1 囚徒博弈
10.1.2 生命游戏和囚徒博弈
10.1.3 生命游戏的基本需求
10.1.3.1 博弈规则
10.1.3.2 博弈的邻居
10.1.3.3 移动规则
10.1.3.4 基本需求
10.1.3.5 模块设计

10.2 生命游戏说明
10.2.1 开发主界面
10.2.1.1 使用Applet开发主界面
10.2.1.2 参数设置界面
10.2.1.3 博弈规则设置界面
10.2.1.4 模式选择界面
10.2.1.5 按钮控制界面
10.2.1.6 设置默认参数
10.2.1.7 参数说明

10.2.2 开发游戏模拟界面
10.2.2.1 获得游戏参数
10.2.2.2 数据显示界面
10.2.2.3 模拟界面
10.2.2.4 构造函数

10.2.3 开发事件监听与响应机制
10.3 业务逻辑开发
10.3.1 企业模块
10.3.2 生命游戏的逻辑代码
10.3.3 让生命运动起来

10.4 运行游戏
10.4.1 编写运行Applet的网页
10.4.2 设置游戏参数
10.4.3 企业ID显示模式
10.4.4 企业方向显示模式
10.4.5 企业策略显示模式
10.5 本章小结

第11章 基于图形和网络的Java聊天室
11.1 设计我们的聊天室
11.1.1 需求分析
11.1.2 模块设计
11.1.3 创建chatroom工程

11.2 设计并开发数据库模块
11.2.1 设计数据库的表结构
11.2.2 设计和开发数据库连接模块
11.2.3 设计和开发数据库处理模块

11.3 swing界面模块开发
11.3.1 创建Swing类
11.3.2 登录界面
11.3.3 注册界面
11.3.4 聊天界面

11.4 swing界面模块开发
11.4.1 客户端开发
11.4.2 使用socket发送非阻塞IO流
11.4.3 使用socket接收非阻塞IO流

11.5 服务端开发
11.5.1 非阻塞IO在socket服务器上的应用
11.5.2 服务端程序
11.6 运行效果演示
11.7 本章小结

第12章 学生信息管理系统
12.1 需求分析与设计
12.1.1 基本需求
12.1.2 模块设计
12.1.3 数据库设计

12.2 界面设计
12.2.1 登录界面的设计
12.2.2 查询界面的设计
12.2.3 新建界面的设计
12.2.4 修改界面和删除界面的设计

12.3 系统模块的开发
12.3.1 学生信息对象
12.3.2 数据库操作模块
12.3.3 登录模块
12.3.4 新建模块
12.3.5 修改模块
12.3.6 删除模块
12.3.7 查询模块
12.4 本章小结

第13章 MVC模式与项目开发
13.1 MVC模式概述
13.1.1 OCP 原则与模块分离思想
13.1.2 什么是MVC模式
13.1.2.1 模型层
13.1.2.2 视图层
13.1.2.3 控制器
13.1.2.4 MVC模型编程综述

13.1.3 MVC模式的工作流程
13.1.3.1 第一步：设计模型接口
13.1.3.2 第二步：设计视图接口，基本方法同模型接口的设计

13.1.4 为什么要使用MVC模式
13.1.4.1 MVC的优点
13.1.4.2 MVC的适用性

13.2 MVC模型示例代码
13.2.1 开发模型组件
13.2.2 开发视图组件
13.2.3 开发控制器组件
13.2.4 让蛇开始活动（MVC工作流程）

13.3 再论MVC模式
13.3.1 “分离”思想带来的好处
13.3.2 MVC在代码维护时的优势
13.3.3 MVC在代码扩展时的优势
13.3.4 MVC与Java架构设计
13.4 本章小结

第14章 设计模式与项目开发
14.1 设计模式概述
14.1.1 什么是设计模式
14.1.2 设计模式解决问题的一般途径
14.1.3 为什么要使用设计模式
14.1.4 设计模式的优势

14.2 工厂模式与构造分离
14.2.1 工厂模式概述
14.2.2 分离生产过程与生产动作
14.2.3 工厂模式与连接对象构造

14.3 桥接模式与业务扩展
14.3.1 桥接模式与 DIP原则
14.3.2 架在不同解决方案之间的桥梁——桥接模式
14.3.3 桥接模式与业务扩展
14.3.4 使用桥接模式优化数据库连接代码

14.4 观察者模式与拉推数据
14.4.1 饲机而动的观察者
14.4.2 观察者与后继动作
14.4.3 使用观察者模式实现数据动态更新

14.5 Vistor模式与RTTI
14.5.1 RTTI的局限性
14.5.2 包容不同类的Vistor模式
14.5.3 使用Vistor模式实现客户关系动态管理

14.6 外观、代理模式与屏蔽细节
14.6.1 什么是外观和代理模式
14.6.2 外观和代理模式的使用场景及其优势
14.6.3 使用外观和代理模式优化数据库通用模块

14.7 单例模式
14.7.1 只允许有一个实例的单例模式
14.7.2 单例模式的语法实现
14.7.3 单例模式的使用案例
14.8 本章小结

第15章 DAO模式与数据库访问
15.1 DAO模式与数据库管理架构
15.1.1 什么是DAO设计模式
15.1.2 纵观DAO模式的优势

15.2 DAO模式应用示例
15.2.1 使用DAO模式连接数据库
15.2.2 在DAO里编写数据库访问逻辑
15.2.3 数据库访问逻辑和业务逻辑的结合体——DAO
15.2.4 编写业务逻辑
15.2.5 DAO模式与业务变更
15.3 本章小结

第16章 设计模式的应用
16.1 设计模式与代码优化
16.1.1 学生信息管理系统的需求变更
16.1.2 业务变更与代码重构

16.2 使用设计模式提高代码的弹性
16.2.1 什么是代码的弹性
16.2.2 利用桥接模式改善系统的弹性

16.3 数据库的设计和修改
16.3.1 User表的设计
16.3.2 Students_Information表的设计
16.3.3 Teachers_Information表的设计

16.4 重构系统
16.4.1 桥的一端——数据库连接
16.4.1.1 现有的数据库模块
16.4.1.2 数据库连接接口
16.4.1.3 采用单态模式实现具体的数据库连接动作
16.4.1.4 获得数据库连接的工厂模式

16.4.2 桥的另一端——信息类
16.4.2.1 抽象的信息类Person
16.4.2.2 Student——Person类的扩展
16.4.2.3 Teacher——Person的另一个扩展

16.4.3 业务流程的修改
16.4.3.1 登录界面的修改
16.4.3.2 学生信息业务流程的修改
16.4.3.3 教师信息管理的业务流程
16.4.4 设计模式总结
16.5 本章小结

第17章 基于JSP+Servlet的Web架构
17.1 Java的Web开发概述
17.1.1 Web开发里的显示、控制、业务三要素
17.1.2 Java处理Web应用的基本方式
17.1.3 各司其职的Java Web组件
17.1.4 在Eclipse上引入MyEclipse插件
17.1.5 在Eclipse+MyEclipse环境上配置Web服务器环境

17.2 开发简单的Servlet
17.2.1 Servlet的生命周期
17.2.2 编写简单的Servlet
17.2.3 编写Servlet的相关配置文件
17.2.4 打包和发布Web应用
17.2.5 在Eclipse集成环境中开发Servlet并发布运行

17.3 开发简单的JSP程序
17.3.1 JSP的基本语法和工作过程
17.3.2 只让JSP做它擅长的事——论JSP的工作范围
17.3.3 编写JSP的Hello World程序
17.3.4 打包发布JSP的Web应用程序
17.3.5 在Eclipse集成开发环境中编写JSP并运行

17.4 开发JSP+Servlet构架的程序
17.4.1 编写登录表单页面
17.4.2 编写登录成功后的展示页面
17.4.3 编写登录失败后的展示页面
17.4.4 编写负责处理登录逻辑的Servlet类并运行测试
17.4.5 准备数据库以及相关驱动
17.4.6 修改LoginServlet，添加JDBC访问代码

17.5 对JSP+Servlet+JDBC模式的思考
17.5.1 组件“各司其职”带来的好处
17.5.2 MVC思想及其开发模式的雏形
17.5.3 没有封装业务逻辑的后果
17.6 本章小结

第18章 基于JavaBean和EJB的 Web架构
18.1 组件思想与多层Web架构
18.1.1 为什么要构建多层的Web架构
18.1.2 标准零件般的Java Web组件
18.1.3 实现后台业务逻辑的JavaBean与EJB组件

18.2 使用JavaBean组件
18.2.1 编写负责显示逻辑的JSP代码
18.2.2 编写封装业务逻辑的JavaBean代码
18.2.3 通过DAO模式连接访问数据库
18.2.4 编写数据源的配置文件
18.2.5 在集成环境里发布JSP+JavaBean+数据库的代码
18.2.6 在Web服务器里运行JSP+Javabean+数据库代码

18.3 开发基于JSP+Servlet+EJB+JDBC的 Web构架
18.3.1 “大”材“小”用的Javabean与“小”材“大”用的EJB
18.3.2 在集成环境里配置EJB的集成开发环境
18.3.3 EJB的种类及其用途
18.3.4 给Javabean加个“E”——升级现有的Javabean组件之了解EJB的规范
18.3.5 编写负责显示逻辑的JSP代码
18.3.6 编写负责控制逻辑的Servlet代码
18.3.7 编写负责业务逻辑的EJB代码
18.3.8 使用工厂模式规范EJB的初始化过程
18.3.9 通过DAO模式连接访问数据库
18.3.10 编写EJB和Servlet的配置文件
18.3.11 打包发布EJB包
18.3.12 在集成环境里配置和运行EJB程序

18.4 开发会话Bean+实体Bean的综合应用
18.4.1 会话Bean和实体Bean的用途分析
18.4.2 根据外观模式的思想整合会话Bean与实体Bean
18.4.3 编写负责显示逻辑的JSP代码
18.4.4 编写负责控制逻辑的Servlet代码
18.4.5 编写承上启下的会话Bean代码
18.4.6 编写负责业务逻辑的实体Bean代码
18.4.7 编写Servlet和EJB的配置环境
18.4.8 打包发布EJB包

18.5 对EJB组件的思考
18.5.1 用标准化的EJB积木搭建外观统一的J2EE模型
18.5.2 J2EE架构里的MVC模式
18.5.3 从Javabean升级到EJB的启示
18.5.4 为什么J2EE和EJB能满足企业级的开发需求
18.6 本章小结

第19章 基于J2EE的在线购物系统
19.1 需求分析与设计
19.1.1 在线购物系统需求概述
19.1.2 根据J2EE架构设计模块和流程
19.1.3 数据库设计
19.1.4 配置运行环境

19.2 系统整体架构
19.2.1 前台展现层设计——通过MVC模式实现页面跳转
19.2.2 中间业务层设计——通过DAO使用会话Bean建立业务逻辑
19.2.3 后台数据层设计——通过EJB操作数据库
19.2.4 整体架构图

19.3 公共模块
19.3.1 编写负责显示逻辑的JSP代码
19.3.2 编写控制器层的Servlet和Action类
19.3.3 编写封装业务逻辑的DAO类
19.3.4 编写访问数据库的EJB

19.4 购物车管理模块
19.4.1 编写负责显示逻辑的JSP代码
19.4.2 编写控制器层的Servlet和Action类

19.5 代码发布
19.5.1 编写配置文件
19.5.2 组装EJB组件和Web应用
19.5.3 显示运行效果

19.6 企业级项目中应用EJB的思考
19.6.1 使用EJB可以减轻项目维护的工作量
19.6.2 EJB里包含的设计模式
19.6.3 重量级和轻量级组件的比较
19.7 本章小结

第20章 Struts架构与Web应用
20.1 Struts与MVC思想
20.1.1 从Struts架构里看“架构”的概念
20.1.2 MVC思想与分层管理的好处
20.1.3 Struts——“抽”出Web应用里“像”的流程
20.1.3.1 Struts模型组件
20.1.3.2 Struts控制组件
20.1.3.3 Struts模型层
20.1.3.4 Struts视图组件
20.1.4 可以抽象出Web流程的Struts重要组件说明
20.1.5 配置Struts开发环境

20.2 Struts的HelloWorld实例
20.2.1 用JSP编写视图端的代码
20.2.1.1 Struts HTML类标签
20.2.1.2 生成HTML的表单标标签
20.2.1.3 显示错误和消息的标签
20.2.1.4 Struts的其他标签

20.2.2 编写ActionServlet类
20.2.3 编写ActionForm类
20.2.4 编写Action类
20.2.5 编写ActionMapping类和ActionForward类
20.2.6 编写配置文件
20.2.6.1 配置web.xml文件
20.2.6.2 配置struts-config.xml文件

20.2.7 在集成环境上编译与发布Struts代码
20.2.8 效果演示与工作流程概述

20.3 对Struts组件的思考
20.3.1 Struts的体系结构与Web流程抽象
20.3.2 Struts与业务逻辑如何耦合
20.3.3 分工不同的Struts与EJB

20.4 Struts 2.0新特性
20.4.1 Struts 2.0和Struts 1.X的比较
20.4.2 Struts 2.0处理请求的流程
20.4.3 Struts 2.0的示例代码——经典的Hello World
20.5 本章小结

第21章 Spring架构与Web应用
21.1 Spring与控制反转思想
21.1.1 用到的时候才去获取的控制反转思想
21.1.2 控制反转与轻量级Web开发
21.1.3 基于控制反转的Spring概述
21.1.4 配置Spring的开发环境

21.2 Spring的HelloWorld实例
21.2.1 编写服务提供代码
21.2.2 在xml文件里登记各项服务
21.2.3 编写服务调用代码
21.2.4 效果演示与工作流程概述

21.3 Spring的常用技术
21.3.1 拦截器与AOP编程
21.3.2 在Spring里实现事务管理
21.3.3 数据持久性与ORM思想

21.4 对Spring组件的思考
21.4.1 Spring组件是对重量级Web组件的颠覆
21.4.2 Spring组件对轻量级Web开发的启示
21.4.3 指导Web流程的Struts与包含强力工具的Spring组件
21.5 本章小结

第22章 ORM组件与数据库访问控制
22.1 ORM组件与数据映射
22.1.1 什么是ORM
22.1.2 为什么要用ORM组件
22.1.3 ORM组件包含的外观设计模式
22.1.4 配置ORM组件的开发环境

22.2 Hibernate与数据库开发
22.2.1 数据映射的需求分析
22.2.2 数据映射的实例
22.2.3 编写ORM的客户端代码
22.2.4 效果演示与工作流程概述

22.3 Hibernate组件入门
22.3.1 Hibernate数据库连接API
22.3.2 Hibernate对JDBC的改进
22.3.3 Hibernate与数据库事务管理
22.3.4 Hibernate配置文件分析

22.4 对ORM组件的思考
22.4.1 与轻量级Web组件的关系
22.4.2 数据映射与DAO模式
22.4.3 数据映射与数据库分层应用
22.5 本章小结

第23章 Struts与Spring集成开发
23.1 Struts与Spring集成概述
23.1.1 Struts和Spring的固有局限
23.1.2 两者集成后的优势
23.1.3 准备Struts和Spring集成的开发环境

23.2 在Struts中集成Spring
23.2.1 需求描述
23.2.2 基于Struts的实现
23.2.2.1 配置开发环境
23.2.2.2 编写web.xml文件
23.2.2.3 编写环境界面的代码
23.2.2.4 编写Struts里的form类
23.2.2.5 编写Struts里的Action类
23.2.2.6 编写Struts里的struts-config.xml文件
23.2.2.7 把Struts部署到服务器上

23.2.3 基于Spring中的ActionSupport类整合Struts
23.2.3.1 配置开发环境
23.2.3.2 编写web.xml文件
23.2.3.3 编写环境界面的代码
23.2.3.4 编写Struts里的form类
23.2.3.5 编写Struts里的Action类
23.2.3.6 配置和编写Spring里的config.xml相关文件
23.2.3.7 编写Struts里的struts-config.xml文件
23.2.3.8 把Struts部署到服务器上

23.2.4 基于Spring中的DelegatingRequestProcessor类整合Struts
23.2.4.1 配置开发环境
23.2.4.2 编写web.xml文件
23.2.4.3 编写环境界面的代码
23.2.4.4 编写Struts里的form类
23.2.4.5 编写Struts里的Action类
23.2.4.6 配置和编写Spring里的config.xml相关文件
23.2.4.7 编写Struts里的struts-config.xml文件
23.2.4.8 把Struts部署到服务器上

23.2.5 基于Spring中的DelegatingActionProxy类整合Struts
23.2.5.1 配置开发环境
23.2.5.2 编写web.xml文件
23.2.5.3 编写环境界面的代码
23.2.5.4 编写Struts里的form类
23.2.5.5 编写Struts里的Action类
23.2.5.6 配置和编写Spring里的config.xml相关文件
23.2.5.7 编写Struts里的struts-config.xml文件
23.2.5.8 把Struts部署到服务器上

23.3 集成后的思考
23.3.1 利用控制反转为代码降耦
23.3.2 Spring与Struts三种整合方式的对比
23.4 本章小结

第24章 基于Struts+Spring+Hibernate的在线购物系统
24.1 EJB迁移到SSH架构的工作要点
24.1.1 配置开发环境
24.1.2 SSH和EJB的对比
24.1.3 迁移的工作要点分析

24.2 整体架构的改写
24.2.1 前台展现层改写——通过Struts的MVC模式实现页面跳转
24.2.2 中间业务层改写——通过DAO建立业务逻辑
24.2.3 后台数据层改写——通过Hibernate将vo对象保存到数据库

24.3 代码发布
24.3.1 编写配置文件
24.3.2 在集成开发环境里发布项目
24.3.3 显示运行效果

24.4 SSH架构的思考
24.4.1 轻量级和重量级Web构架的差异
24.4.2 SSH的适用范围
24.5 本章小结

第25章 Java的Web Service应用
25.1 Web Service概述
25.1.1 什么是Web Service
25.1.2 为什么要使用Web Service
25.1.3 Web Service的特点

25.2 Web Service协议
25.2.1 SOAP——简单对象访问协议
25.2.2 WSDL——Web服务描述语言
25.3 开发基于Axis2的Web Service应用程序
25.3.1 什么是Axis2
25.3.2 搭建Web Service环境
25.3.2.1 安装Ant环境
25.3.2.2 安装Axis2

25.3.3 第一个Web Service 程序
25.3.3.1 服务端的开发
25.3.3.2 客户端的开发

25.3.4 高效的Axiom
25.3.4.1 服务端的开发
25.3.4.2 客户端的开发

25.4 J2EE架构里的Web Service
25.4.1 在struts架构中使用Web Service
25.4.1.1 创建一个struts项目
25.4.1.2 建立框架
25.4.1.3 编写代码

25.4.2 EJB中的Web Service
25.4.2.1 Web Service环境
25.4.2.2 感受EJB中的Web Service
25.5 本章小结