J2EE宝典

作者：（美）Justin Couch等著；马琳[等]译；马琳译

出版社：电子工业出版社

出版时间：2002-10-01

ISBN：9787505379893

定价：¥69.00

　　SUN公司的企业版Java 2平台，定义了开发多层企业级应用的标准，而《J2EE宝典》这本书全面、详细地介绍了该平台所有令人兴奋的开发工具。它是最先面世的全面介绍J2EE 1.3版本的书籍之一。本书包含了所有J2EE的基本技术，包括企业级JavaBean，JSP，Servlet，JNDI，JTA，CORBA和JDBC，同时还专门介绍了Java如何同XML以及其他技术协同工作，以及创建企业级系统所需要注意的问题。开发者完全可以通过使用这本书开发和部署一个全面的、稳定的、安全的、高效的企业级应用系统。

暂缺《J2EE宝典》作者简介

前言
第1部分  快速入门
第1章  定义企业级应用
     1. 1　介绍企业级应用
     1. 1. 1  网站不仅要漂亮
     1. 1. 2　企业级应用的结构
     1. 1. 3　企业级应用组件
     1. 2  J2EE介绍
     1. 2. 1　企业级Java简史
     1. 2. 2  了解J2EE
     1. 2. 3　并不仅仅用于企业级应用
     1. 2. 4　决定使用哪个部分
     1. 3  准备工作
     1. 3. 1　下载并安装J2EE
     1. 3. 2　决定项目类型
     1. 4  小结
第2章  介绍企业级应用
     2. 1  公司对客户应用
     2. 1. 1  例1：电子商务网站
     2. 1. 2  例2：机票预订系统
     2. 2  企业对企业应用
     2. 2. 1  存货系统
     2. 2. 2  电子支付
     2. 3  后台应用
     2. 3. 1  通信应用
     2. 3. 2  月度电子新闻
     2. 4  小结
第2部分  内容发布
第3章  使用Servlet创建动态内容
     3. 1  什么是Servlet
     3. 2  创建基本的HttpServlet
     3. 2. 1  使用Servlet创建静态页面
     3. 2. 2  在哪里运行Servlet
     3. 2. 3  增加动态元素
     3. 3  介绍Servlet API
     3. 3. 1  Servlet家族
     3. 3. 2  ServletRequest家族
     3. 3. 3  ServletResponse家族
     3. 4  保存和共享信息
     3. 4. 1  会话跟踪
     3. 4. 2  使用ServletContext
     3. 5  使用filter(), forward(), include()方法增加新功能
     3. 5. 1  在Servlet中使用过滤器
     3. 5. 2  使用forward()在servlet间转移控制
     3. 5. 3  在不同资源间拼接内容
     3. 6  小结
第4章  使用JSP
     4. 1  创建基本的JSP页面
     4. 1. 1  创建. 保存和访问JSP页面
     4. 1. 2  JSP的生命周期
     4. 1. 3  在JSP中增加动态元素
     4. 2  在JSP中增加Java特征
     4. 2. 1  在JSP中嵌入Java代码
     4. 2. 2  使用JSP指令
     4. 2. 3  使用动作传输控制
     4. 2. 4  访问内部Java对象
     4. 3  添力JavaBean
     4. 3. 1  Bean属性协定
     4. 3. 2  JSP Bean标记
     4. 4  使用自定义标记
     4. 4. 1  返回当前时间的类
     4. 4. 2  标记库描述器
     4. 4. 3  在JSP页面中使用自定义标记
     4. 4. 4  在标记中增加标记
     4. 4. 5  自定义标记的属性
     4. 5  同时使用JSP和Servlet
     4. 6  小结
第5章  使用JavaMail发送和接收电子邮件
     5. 1  什么是电子邮件
     5. 1. 1  电子邮件的一天
     5. 1. 2  邮件的格式
     5. 1. 3  服务器的类型
     5. 2  介绍JavaMail
     5. 2. 1  JavaMail包
     5. 2. 2  JavaMail需求
     5. 2. 3  下载JavaMail
     5. 2. 4  JavaMail术语
     5. 3  发送电子邮件
     5. 3. 1  设置电子邮件
     5. 3. 2  构造邮件
     5. 3. 3  发送邮件
     5. 3. 4  发送到新闻组
     5. 3. 5  带附件的邮件
     5. 4  接收电子邮件
     5. 4. 1  准备接收邮件
     5. 4. 2  管理收到的邮件
     5. 5  建立电子邮件过滤器
     5. 5. 1  构造一个查询
     5. 5. 2  管理邮件
     5. 6  小结
第3部分  数据库搜索
第6章  操作关系型数据库
     6. 1  什么是关系型数据库
     6. 1. 1  关系型数据库中的数据是如何组织的
     6. 1. 2  协商通信的语言
     6. 1. 3  查找可用数据库
     6. 2  在RDBMS中定义信息
     6. 2. 1  SQL介绍
     6. 2. 2  数据库设计
     6. 2. 3  使用数据类型表示数据
     6. 2. 4  表管理
     6. 2. 5  提高数据库性能
     6. 3  数据管理
     6. 3. 1  增加新的记录
     6. 3. 2  修改现存的记录
     6. 3. 3  删除行
     6. 4  信息查询
     6. 4. 1  创建简单查询
     6. 4. 2  实现复杂查询
     6. 5  小结
第7章  使用JDBC操作关系型数据库
     7. 1  Java对数据库的抽象
     7. 1. 1  JDBC简史
     7. 1. 2  隐藏实现
     7. 2  应用JDBC
     7. 2. 1  查找JDBC类
     7. 2. 2  介绍JDBC驱动程序
     7. 2. 3  查找适合自己数据库的驱动程序
     7. 3  连接数据库
     7. 3. 1  表示单一数据库连接
     7. 3. 2  使用核心类建立连接
     7. 3. 3  使用企业级类建立连接
     7. 4  数据库数据结构
     7. 4. 1  将SQL数据类型转换成Java数据类型
     7. 4. 2  表示查询返回的信息
     7. 4. 3  利用获得的结果
     7. 4. 4  管理自定义的数据类型
     7. 5  操作数据库
     7. 5. 1  在Java中描述一个SQL语句
     7. 5. 2  查询数据库
     7. 5. 3  修改数据库
     7. 6  使用企业级特征
     7. 6. 1  动作批处理
     7. 6. 2  为快速访问缓冲语句
     7. 6. 3  事务管理
     7. 7  小结
第8章  使用目录服务和LDAP
     8. 1  介绍目录服务
     8. 1. 1  什么是目录服务
     8. 1. 2  何时使用目录服务
     8. 2  介绍LDAP
     8. 2. 1  LDAP历史简介
     8. 2. 2  LDAP数据库如何构造数据
     8. 2. 3  标准语言
     8. 2. 4  使用LDAP的软件
     8. 3  在LDAP数据库中定义信息
     8. 3. 1  设计新的数据库
     8. 3. 2  标准的LDAP介绍
     8. 4  数据库交互
     8. 4. 1  连接数据库
     8. 4. 2  查询LDAP数据库
     8. 4. 3  修改LDAP数据库中的值
     8. 5  自定义数据结构
     8. 5. 1  数据层次
     8. 5. 2  复制
     8. 5. 3  模式
     8. 6  小结
第9章  使用JNDI访问目录服务
     9. 1  Java对目录服务的抽象
     9. 1. 1  JNDI简史
     9. 1. 2  实现隐藏
     9. 1. 3  包和类
     9. 2  连接一个服务
     9. 2. 1  连接内容
     9. 2. 2  连接命名服务
     9. 2. 3  连接目录服务
     9. 3  操作数据库
     9. 3. 1  一般查询
     9. 3. 2  修改现存数据
     9. 3. 3  改变目录服务结构
     9. 4  小结
第4部分  使用XML在系统间通信
第10章  XML基础
     10. 1  什么是XML
     10. 1. 1  创建XML
     10. 1. 2  显示XML
     10. 1. 3  相同文件的不同视角
     10. 2  XML文档和描述
     10. 2. 1  Word中的简历
     10. 2. 2  HTML形式的简历
     10. 2. 3  XML形式的简历
     10. 3  用于配置的XML
     10. 4  使用XML存储和共享数据
     10. 4. 1  使用ObjectOutputStream进行串行化
     10. 4. 2  使用XML保存状态
     10. 5  XML语法
     10. 5. 1  元素
     10. 5. 2  名字空间
     10. 5. 3  属性
     10. 6  小结
第11章  使用DTD和模式描述文档
     11. 1  生成有效的XML文档
     11. 1. 1  阅读DTD
     11. 1. 2  文档和DTD的连接
     11. 2  编写文档类型定义
     11. 2. 1  元素声明
     11. 2. 2  实体声明
     11. 2. 3  属性声明
     11. 3  XML有效性检查
     11. 4  使用XML模式描述文档
     11. 4. 1  模式的shell
     11. 4. 2  元素和属性
     11. 4. 3  简单类型
     11. 4. 4  复杂类型
     11. 5  小结
第12章  使用JAXP解析文档
     12. 1  JAXP简介
     12. 1. 1  JAX包
     12. 1. 2  安装JAXP和例子
     12. 1. 3  安装测试
     12. 1. 4  剧本的内容
     12. 1. 5  格式良好文档的检查
     12. 1. 6  有效性检查
     12. 2  5  SAX研究
     12. 2. 1  使用SAX调用
     12. 2. 2  使用DefaultHandler处理事件
     12. 3  使用DOM
     12. 3. 1  创建一个文档
     12. 3. 2  遍历文档
     12. 3. 3  创建XML
     12. 4  小结
第13章  使用JDOM同XML文档交互
     13. 1  使用JDOM
     13. 1. 1  为什么使用JDOM
     13. 1. 2  安装JDOM并测试安装
     13. 1. 3  再访DOM例子
     13. 2  JDOM API
     13. 2. 1  创建文档
     13. 2. 2  处理文档
     13. 2. 3  输出文档
     13. 3  小结
第14章  转换和绑定XML文档
     14. 1  显示XML文档
     14. 1. 1  使用级联样式表
     14. 1. 2  使用XSLT显示文件
     14. 2  转换XML文档
     14. 2. 1  莎士比亚剧本的另一个DTD
     14. 2. 2  使用样式表进行转换
     14. 3  用JAXB实现绑定
     14. 3. 1  安装和运行JAXB
     14. 3. 2  用户素材例子介绍
     14. 3. 3  改善绑定模式
     14. 3. 4  UserStory.java文件
     14. 4  使用JAXB绑定
     14. 4. 1  反列举：从XML文档得到Java对象
     14. 4. 2  向内容树添加内容
     14. 4. 3  对象的有效性检查
     14. 4. 4  列举：由Java对象到XML文档
     14. 4. 5  扩展由模式编译器产生的类
     14. 5  小结
第5部分  系统抽象
第15章  探索RMI机制
     15. 1  基本的RMI应用组件
     15. 1. 1  远程接口
     15. 1. 2  在服务器上实现远程接口
     15. 1. 3  启动服务
     15. 1. 4  客户端调整
     15. 1. 5  编译代码
     15. 1. 6  运行RMI应用程序
     15. 2  运行分布式版本
     15. 2. 1  将文件分到两个目录
     15. 2. 2  创建和调用安全策略
     15. 2. 3  设置代码库
     15. 2. 4  从一台机器中的两个目录运行应用程序
     15. 2. 5  运行http类服务器
     15. 2. 6  在两个不同主机上运行程序
     15. 3  使用非远程对象
     15. 3. 1  发送Person对象取代String对象
     15. 3. 2  对象串行化
     15. 3. 3  性能问题
     15. 4  激活服务
     15. 4. 1  改变远程接口的实现
     15. 4. 2  修改设置类
     15. 4. 3  运行范例
     15. 5  小结
第16章  企业级JavaBean
     16. 1  这种新级别抽象的介绍
     16. 1. 1  什么是EJB
     16. 1. 2  寻找开发环境
     16. 2  探索EJB服务的组件
     16. 2. 1  EJB应用术语
     16. 2. 2  bean的类型
     16. 2. 3  应用范例
     16. 2. 4  介绍EJB类和接口
     16. 3  在服务器端使用企业级bean
     16. 3. 1  会话bean
     16. 3. 2  实体bean
     16. 3. 3  本地接口
     16. 3. 4  部署bean到EJB服务器
     16. 4  在客户端使用企业级Bean
     16. 4. 1  查询并使用bean
     16. 4. 2  bean的应用
     16. 5  小结
第17章  高级EJB技术
     17. 1  扩展企业级JavaBean
     17. 1. 1  本地bean提供更好性能
     17. 1. 2  方法和数据的距离
     17. 1. 3  bean间通信
     17. 1. 4  在事务中组合bean
     17. 2  使用消息驱动bean
     17. 2. 1  消息驱动Bean在应用中的角色
     17. 2. 2  编写消息驱动bean
     17. 3  理解容器管理持续性
     17. 3. 1  介绍CMP概念
     17. 3. 2  编写CMP实体bean
     17. 3. 3  容器管理的关系
     17. 3. 4  EBJ QL
     17. 4  管理bean的安全问题
     17. 4. 1  标识用户
     17. 4. 2  配置用户访问能力
     17. 5  处理bean的配置问题
     17. 5. 1  已有的配置技术概述
     17. 5. 2  提供系统未知的配置属性
     17. 6  代码的使用者
     17. 6. 1  EJB开发角色
     17. 6. 2  非开发角色
     17. 7  小结
第18章  介绍CORBA
     18. 1  使用CORBA的需求
     18. 2  CORBA是什么
     18. 3  对象管理体系结构
     18. 3. 1  对象服务
     18. 3. 2  通用工具
     18. 3. 3  域接口
     18. 3. 4  应用程序接口
     18. 3. 5  对象请求代理
     18. 3. 6  idltojava编译器
     18. 4  范例：简单的利息计算
     18. 4. 1  第1步：编写IDL接口
     18. 4. 2  第2步：编译IDL文件
     18. 4. 3  第3步：编写InterestServer
     18. 4. 4  第4步：编写客户端代码
     18. 4. 5  第5步：编译并运行应用程序
     18. 5  CORBA服务
     18. 6  CORBA和RMI的区别
     18. 7  小结
第19章  企业级CORBA应用
     19. 1  建立CORBA对象
     19. 2  开发CORBA服务器
     19. 3  开发CORBA客户端
     19. 3. 1  从客户端应用程序访问CORBA对象
     19. 3. 2  编译和运行应用程序
     19. 3. 3  从Servlet访问CORBA对象
     19. 3. 4  编译和运行Servlet
     19. 4  小结
第20章  使用Jini服务
     20. 1  快速浏览Jini
     20. 1. 1  为什么需要Jini
     20. 1. 2  Jini资源
     20. 2  介绍范例
     20. 2. 1  Calculator(计算器)接口
     20. 2. 2  Adder(加法器类)和Subtractor(减法器类)
     20. 2. 3  Client(客户端类)
     20. 3  启动并且运行Jini
     20. 3. 1  安装Jini
     20. 3. 2  GUI工具
     20. 4  简单代理Jini计算器服务
     20. 4. 1  计算器(Calculator)接口
     20. 4. 2  加法和减法服务代理
     20. 4. 3  创建服务
     20. 4. 4  Jini计算器的客户端
     20. 4. 5  编译应用程序
     20. 4. 6  运行分布式应用程序
     20. 5  在Jini计算器中使用属性
     20. 5. 1  设置服务厨性
     20. 5. 2  在客户端创建过滤器
     20. 5. 3  使用ServiceItemFilter对象
     20. 5. 4  运行范例
     20. 6  缓存服务
     20. 6. 1  一个简单的查询缓存范例
     20. 6. 2  使用ServiceDiscoveryListener
     20. 7  使用RMI桩作为瘦代理
     20. 7. 1  RMI版本的代理
     20. 7. 2  RMIAddingService
     20. 8  小结
第6部分  构建大型系统
第21章  实现Web服务
     21. 1  HelloWorld服务
     21. 1. 1  配置Axis
     21. 1. 2  HelloWorld Web服务的客户端
     21. 1. 3  一个本地的问候服务
     21. 1. 4  使用tcpmon了解幕后细节
     21. 2  理解简单对象访问协议
     21. 2. 1  SOAP消息的结构
     21. 2. 2  SOAP与HTTP
     21. 3  部署Web服务
     21. 3. 1  为例子程序准备环境
     21. 3. 2  使用部署描述器
     21. 3. 3  运行已部署的服务
     21. 4  使用UDDI查找Web服务
     21. 4. 1  UDDI资源
     21. 4. 2  通过UDDI探索Web服务
     21. 5  创建并使用WSDL文件
     21. 5. 1  从HelloService生成WSDL文件
     21. 5. 2  根据WSDL创建客户端
     21. 5. 3  使用WSDL文件创建服务
     21. 6  发送Java对象给你的Web服务
     21. 6. 1  JavaBean版HelloService的类
     21. 6. 2  部署并运行应用程序
     21. 6. 3  发送JavaBean
     21. 7  小结
第22章  Java消息服务
     22. 1  位于中间的消息
     22. 2  JMS出现之前的情况
     22. 3  MOM遭遇JMS
     22. 3. 1  提供应用程序独立性的JMS
     22. 3. 2  纯JMS供应商
     22. 4  消息系统的种类
     22. 4. 1  点到点
     22. 4. 2  发布／订阅
     22. 5  JMS概览
     22. 5. 1  消息术语
     22. 5. 2  接口概览
     22. 5. 3  操作流程概览
     22. 6  JMS系统的建立
     22. 7  被管理对象
     22. 8  发送与接收消息
     22. 8. 1  点到点——发送消息
     22. 8. 2  点到点——接收消息
     22. 8. 3  发布／订阅——发送消息
     22. 8. 4  发布／订阅——接收消息
     22. 8. 5  消息监听器
     22. 8. 6  连接与会话
     22. 9  消息的细节
     22. 9. 1  消息标头
     22. 9. 2  消息属性
     22. 9. 3  消息主体
     22. 10  使用JMS开发应用程序
     22. 10. 1  连接与会话
     22. 10. 2  资源管理
     22. 10. 3  持续性及持续订阅
     22. 10. 4  JMS和线程
     22. 10. 5  JM5事务
     22. 11  一个范例
     22. 11. 1  文本消息的简单收发
     22. 11. 2  增添属性
     22. 11. 3  增加消息选择
     22. 12  JMS和J2EE
     22. 12. 1  连接到已有系统
     22. 12. 2  消息驱动的bean
     22. 12. 3  分布式应用程序
     22. 13  小结
第23章  使用JTA/JTS管理事务
     23. 1  什么是事务
     23. 1. 1  事务的特征
     23. 1. 2  事务处理术语
     23. 1. 3  事务处理组件
     23. 1. 4  分布式事务
     23. 1. 5  两阶段提交
     23. 1. 6  事务处理标准
     23. 2  Java事务服务
     23. 3  Java事务API
     23. 3. 1  JTA接口与类
     23. 3. 2  UserTransaction接口
     23. 3. 3  Status接口
     23. 3. 4  Synchronization接口
     23. 4  如何使用JTA/JTS
     23. 4. 1  容器管理的事务
     23. 4. 2  出错处理
     23. 4. 3  会话bean的重新初始化
     23. 4. 4  bean管理的事务
     23. 4. 5  事务超时
     23. 4. 6  事务隔离
     23. 5  ACME饰品公司——购物车演示
     23. 5. 1  创建数据库和表
     23. 5. 2  订单会话bean
     23. 5. 3  库存会话bean
     23. 5. 4  目录会话bean
     23. 5. 5  购物车客户端应用程序
     23. 5. 6  打包与部署
     23. 5. 7  建立数据源
     23. 5. 8  运行购物车演示程序
     23. 6  小结
第24章  系统体系结构问题
     24. 1  设计真实的系统
     24. 1. 1  理解客户
     24. 1. 2  善待工作伙伴
     24. 2  分割工作负载
     24. 2. 1  将工作分摊到不同的应用层
     24. 2. 2  当一台机器不够时
     24. 3  选择一种设计方法
     24. 3. 1  大规模系统技术的选择
     24. 3. 2  设计选择
     24. 4  实现安全性
     24. 4. 1  连接安全
     24. 4. 2  数据安全
     24. 4. 3  系统安全
     24. 4. 4  用户安全
     24. 5  小结
第25章  J2EE设计模式
     25. 1  设计模式基础
     25. 1. 1  什么是设计模式
     25. 1. 2  核心Java库里的设计模式
     25. 2  企业级设计模式介绍
     25. 2. 1  企业级设计模式的角色
     25. 2. 2  J2EE标准企业级设计模式
     25. 3  小结
附录A  安装J2EE参考实现
附录B  J2EE API版本要求
附录C  J2EE厂商和系统