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

目 录
第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 本章小结