书籍详情

J2EE宝典

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厂商和系统                  

猜您喜欢

读书导航