21天学通J2EE

第一周课程  J2EE和EJB的简介                  
 第1天课程  挑战N层开发　12                  
 1.1  单层程序的开发　12                  
 1.2  向二层开发进军　13                  
 1.3  用模块简化复杂性　15                  
 1.3.1  组件技术　16                  
 1.3.2  模块化的好处　16                  
 1.4  三层方案的优势　16                  
 1.5  企业计算模块　17                  
 1.5.1  生命周期　17                  
 1.5.2  持久性　17                  
 1.5.3  命名　18                  
 1.5.4  事务　18                  
 1.6  Java 2企业版（J2EE）　18                  
 1.6.1  组件和容器　19                  
 1.6.2  J2EE标准服务　19                  
 1.6.3  J2EE蓝图　10                  
 1.6.4  J2EE兼容性测试套件　11                  
 1.7  J2EE的发展前景　12                  
 1.8  小结　12                  
 1.9  问与答　12                  
 1.10  练习　13                  
 第2天课程  J2EE平台和角色　14                  
 2.1  再谈J2EE平台　14                  
 2.2  使用Sun微系统的J2EE SDK　15                  
 2.2.1  安装J2EE SDK 1.3　15                  
 2.2.2  启动J2EE引用实现（RI）　17                  
 2.2.3  解决J2EE和云景数据库服务器启动时的常见问题　19                  
 2.2.4  关闭J2EE RI和云景数据库服务器　21                  
 2.2.5  本书中涉及的软件　21                  
 2.3  了解层和组件的概念　22                  
 2.3.1  业务层　22                  
 2.3.2  表达层　25                  
 2.3.3  组件：以Web应用为中心　26                  
 2.3.4  客户层　28                  
 2.3.5  独立的客户端　31                  
 2.4  了解容器　32                  
 2.5  了解容器为组件提供的服务　34                  
 2.5.1  超文本传输协议（HTTP）　34                  
 2.5.2  安全套接层超文本传输协议（HTTPS）　34                  
 2.5.3  Java数据库连接（JDBC）　34                  
 2.5.4  Java事务API（JTA）　34                  
 2.5.5  Java认证和授权服务（JAAS）　35                  
 2.5.6  用于解析XML的Java API（JAXP）　35                  
 2.5.7  Java命名和目录接口（JNDI）　35                  
 2.5.8  JavaBean激活框架（JAF）　35                  
 2.5.9  JavaMail　36                  
 2.5.10  Java消息服务（JMS）　36                  
 2.5.11  Java接口定义语言（Java IDL）　36                  
 2.5.12  基于IIOP协议的远程方法调用（RMI-IIOP）　36                  
 2.5.13  连接器体系结构　37                  
 2.6  J2EE平台上的角色简介　37                  
 2.6.1  J2EE产品供应商　37                  
 2.6.2  应用程序组件供应商　38                  
 2.6.3  应用程序组装者　38                  
 2.6.4  应用程序部署者　38                  
 2.6.5  系统管理员　38                  
 2.6.6  工具供应商　38                  
 2.6.7  J2EE工具发展前景　39                  
 2.7  打包和部署J2EE应用程序　39                  
 2.7.1  J2EE应用程序　40                  
 2.7.2  将模块分解为组件　41                  
 2.8  小结　42                  
 2.9  问与答　42                  
 2.10  练习——学习实例　43                  
 2.10.1  求职代理　43                  
 2.10.2  使用求职代理实例　43                  
 2.10.3  熟能生巧　45                  
 2.10.4  学习实例在光盘中的目录　46                  
 2.10.5  安装实例数据库　46                  
 第3天课程  命名和目录服务　49                  
 3.1  命名和目录服务　49                  
 3.2  为什么使用命名服务　50                  
 3.3  JNDI是什么　50                  
 3.4  常见命名服务　50                  
 3.5  命名约定　51                  
 3.6  使用JNDI　51                  
 3.7  获得一个初始环境　52                  
 3.8  初始环境命名异常　53                  
 3.8.1  定义JNDI服务　53                  
 3.8.2  JNDI属性文件　54                  
 3.8.3  应用程序属性　55                  
 3.8.4  Applet参数　55                  
 3.8.5  硬编码的属性　55                  
 3.9  JNDI对象绑定　56                  
 3.9.1  对象绑定　56                  
 3.9.2  绑定时的常见问题　56                  
 3.9.3  名字持久性　57                  
 3.9.4  重绑定对象　57                  
 3.9.5  解除对象绑定　57                  
 3.9.6  对象重命名　58                  
 3.10  JNDI名字查找　58                  
 3.10.1  改变环境参数　58                  
 3.10.2  定位RMI-IIOP对象　59                  
 3.11  环境参数　60                  
 3.11.1  环境参数列表　60                  
 3.11.2  创建和销毁环境参数　62                  
 3.12  更多关于JNDI名字的内容　63                  
 3.12.1  特殊字符　63                  
 3.12.2  复合名字与混合名字　63                  
 3.12.3  URL的　64                  
 3.13  属性　64                  
 3.13.1  LDAP X.500命名概述　65                  
 3.13.2  获取LDAP服务器　65                  
 3.13.3  使用OpenLDAP　65                  
 3.13.4  配置JNDI以使用LDAP　68                  
 3.13.5  测试LDAP服务器　68                  
 3.13.6  获取目录环境　69                  
 3.13.7  读取属性　69                  
 3.13.8  搜索对象　70                  
 3.13.9  操作属性　72                  
 3.14  更多关于对象的内容　73                  
 3.14.1  从代码基中装载类　74                  
 3.14.2  定义代码基　74                  
 3.14.3  引用　76                  
 3.15  JNDI还可以做什么　79                  
 3.15.1  JNDI事件　79                  
 3.15.2  安全性　79                  
 3.16  小结　80                  
 3.17  问与答　81                  
 3.18  练习　81                  
 第4天课程  EJB简介　82                  
 4.1  什么是EJB　82                  
 4.1.1  Bean. 客户端. 容器和服务器　82                  
 4.1.2  EJB概览　83                  
 4.1.3  发现EJB　83                  
 4.1.4  EJB的类型　84                  
 4.1.5  EJB的常见使用　84                  
 4.2  为什么使用EJB　84                  
 4.2.1  隐藏程序的复杂性　85                  
 4.2.2  从UI和数据访问中分离业务逻辑　85                  
 4.2.3  容器服务　86                  
 4.3  EJB中包括什么　86                  
 4.3.1  业务接口　86                  
 4.3.2  业务逻辑　88                  
 4.3.3  厂类信息　92                  
 4.3.4  Bean元数据　93                  
 4.4  如何创建EJB　93                  
 4.4.1  创建机制　94                  
 4.4.2  创建代码的限制　94                  
 4.4.3  创建可部署组件　94                  
 4.5  如何部署EJB　97                  
 4.5.1  在容器中插入配置　97                  
 4.5.2  执行部署　97                  
 4.6  如何使用EJB　97                  
 4.6.1  发现EJB　97                  
 4.6.2  检索与使用　98                  
 4.6.3  除去EJB　98                  
 4.6.4  运行客户端　99                  
 4.7  在J2EE RI中部署和使用一个EJB　99                  
 4.7.1  打开学习实例的EAR文件　100                  
 4.7.2  查看学习实例应用程序　101                  
 4.7.3  部署实例应用程序　103                  
 4.7.4  测试实例应用程序　104                  
 4.7.5  解决实例应用程序中出现的问题　105                  
 4.8  小结　106                  
 4.9  问与答　106                  
 4.10  练习　107                  
 第5天课程  会话EJB　108                  
 5.1  概述　108                  
 5.2  会话Bean的javax.ejb包　109                  
 5.3  无状态会话Bean的生命周期　110                  
 5.4  指定无状态会话Bean　113                  
 5.5  无状态会话Bean的实现　115                  
 5.5.1  javax.ejb.SessionBean的实现　115                  
 5.5.2  本地接口方法的实现　115                  
 5.5.3  远程接口方法的实现　116                  
 5.5.4  异常　118                  
 5.6  配置和部署一个无状态会话Bean　119                  
 5.6.1  使用deploytool　119                  
 5.6.2  结构元素　120                  
 5.6.3  表达元素　121                  
 5.6.4  会话元素　122                  
 5.6.5  部署企业应用程序　128                  
 5.7  有状态会话Bean的生命周期　128                  
 5.8  指定有状态会话Bean　131                  
 5.9  有状态会话Bean的实现　132                  
 5.9.1  钝化　132                  
 5.9.2  超时　133                  
 5.9.3  连锁状态　133                  
 5.10  配置和部署有状态会话Bean　134                  
 5.11  客户端视图　134                  
 5.12  模式和习惯　135                  
 5.12.1  业务接口　135                  
 5.12.2  适配器　137                  
 5.12.3  粗粒度　137                  
 5.13  忠告　137                  
 5.14  小结　138                  
 5.15  问与答　138                  
 5.16  练习　138                  
 第6天课程  实体EJB　141                  
 6.1  概述　141                  
 6.1.1  再谈n层体系结构　141                  
 6.1.2  与关系型数据库管理系统技术的比较　142                  
 6.1.3  识别实体　142                  
 6.2  实体Bean的javax.ejb包　144                  
 6.3  实体Bean的类型　145                  
 6.4  远程接口与本地接口　145                  
 6.5  BMP实体Bean的生命周期　146                  
 6.6  指定BMP实体Bean　150                  
 6.6.1  本地Home接口　151                  
 6.6.2  本地接口　154                  
 6.7  BMP实体Bean的实现　155                  
 6.7.1  实现本地Home接口方法　159                  
 6.7.2  实现本地接口方法　164                  
 6.7.3  生成ID号　165                  
 6.7.4  再谈粒度　167                  
 6.7.5  使用查找方法的注意事项　167                  
 6.7.6  EJB容器性能调试　168                  
 6.8  配置和部署BMP实体Bean　169                  
 6.9  客户端视图　172                  
 6.10  再谈会话Bean　173                  
 6.11  模式和习惯　176                  
 6.11.1  接口. 外观和状态　176                  
 6.11.2  为实体Bean使用本地接口　176                  
 6.11.3  与值集绑定的类　177                  
 6.11.4  自我封装域　179                  
 6.11.5  不要为查找方法使用Enumeration　179                  
 6.11.6  晚连接, 早释放　179                  
 6.11.7  再谈业务接口　180                  
 6.12  忠告　181                  
 6.13  小结　182                  
 6.14  问与答　182                  
 6.15  练习　182                  
 第7天课程  CMP和EJB QL　185                  
 7.1  容器管理的持久性概述　185                  
 7.1.1  N层体系结构（再谈谈）和CMP字段　186                  
 7.1.2  浅谈实例数据库　188                  
 7.2  CMP实体Bean的生命周期　189                  
 7.3  容器管理的关联　190                  
 7.3.1  关联类型　191                  
 7.3.2  导航　191                  
 7.3.3  cmr字段元素　192                  
 7.3.4  操作关联　194                  
 7.4  EJB查询语言　197                  
 7.4.1  EJB选择方法　198                  
 7.4.2  语法和例子　199                  
 7.4.3  更多内容　204                  
 7.5  指定CMP实体Bean　205                  
 7.5.1  本地Home接口　205                  
 7.5.2  本地接口　205                  
 7.6  CMP实体Bean的实现　206                  
 7.6.1  实现javax.ejb.EntityBean　206                  
 7.6.2  实现本地Home接口方法　208                  
 7.6.3  查找方法　210                  
 7.6.4  实现本地接口方法　213                  
 7.7  配置CMP实体Bean　214                  
 7.7.1  entity元素　214                  
 7.7.2  relationships元素　217                  
 7.8  部署CMP实体Bean　221                  
 7.9  模式和习惯　222                  
 7.9.1  在ejbLoad（）/ejbStore（）中规范化/反规范化数据　222                  
 7.9.2  不要显示cmp字段元素　223                  
 7.9.3  不要显示cmr字段元素　224                  
 7.9.4  通过Bean接口实施引用的完整性　225                  
 7.9.5  使用选择方法实现Home方法　225                  
 7.10  忠告　226                  
 7.11  小结　226                  
 7.12  问与答　227                  
 7.13  练习　227                  
 第二周课程  开发J2EE应用程序                  
 第8天课程  事务处理和持久性　230                  
 8.1  事务处理概述　230                  
 8.2  容器管理的事务划分　232                  
 8.3  Bean管理的事务划分　237                  
 8.3.1  动机和限制　237                  
 8.3.2  使用Java 事务API　237                  
 8.3.3  部署BMTD Bean　240                  
 8.3.4  客户划分事务　240                  
 8.3.5  再谈异常　241                  
 8.4  延长有状态会话bean的生命周期　242                  
 8.5  后台事务：事务实质　243                  
 8.5.1  事务管理器. 资源管理器和2PC　244                  
 8.5.2  JTA API　245                  
 8.5.3  事务出错后应如何解决　247                  
 8.5.4  JTA与JTS　248                  
 8.6  持久性技术概述　249                  
 8.7  JDBC　250                  
 8.8  SQLj　252                  
 8.8.1  SQLj Part 0　253                  
 8.8.2  SQLj Part 1　257                  
 8.8.3  SQLj Part 2　261                  
 8.9  JDO　264                  
 8.9.1  JDO概念　265                  
 8.9.2  javax.jdo类和接口　267                  
 8.9.3  查询　268                  
 8.9.4  其他功能　270                  
 8.10  忠告　270                  
 8.11  小结　271                  
 8.12  问与答　271                  
 8.13  练习　272                  
 第9天课程  Java消息服务　273                  
 9.1  消息　273                  
 9.2  Java消息服务API　275                  
 9.3  JMS API体系结构　275                  
 9.3.1  消息域　277                  
 9.3.2  JMS 点对点消息域　277                  
 9.3.3  JMS发布/订阅消息域　277                  
 9.4  使用JBoss开发JMS应用程序　278                  
 9.5  使用J2EE RI开发JMS应用程序　279                  
 9.5.1  J2EE RI连接工厂　279                  
 9.5.2  在J2EE RI中添加目的地　279                  
 9.5.3  在J2EE RI中创建队列　279                  
 9.6  点对点消息实例　281                  
 9.6.1  JMS消息　282                  
 9.6.2  创建消息　283                  
 9.6.3  发送消息　284                  
 9.6.4  关闭连接　284                  
 9.6.5  发送JMS文本消息实例　284                  
 9.6.6  使用消息　285                  
 9.7  简单的同步接收器实例　286                  
 9.7.1  接收JMS文本消息实例　286                  
 9.7.2  异步消息　287                  
 9.8  发布/订阅消息域　288                  
 9.9  发布/订阅消息实例　289                  
 9.9.1  公告板发布程序　289                  
 9.9.2  公告板订阅程序　291                  
 9.9.3  创建持久订阅　292                  
 9.9.4  JMS的其他特点　294                  
 9.10  XML简介　296                  
 9.11  小结　297                  
 9.12  问与答　297                  
 9.13  练习　298                  
 第10天课程  消息驱动Bean　299                  
 10.1  什么是消息驱动Bean　299                  
 10.1.1  消息生产者的观点　300                  
 10.1.2  与其他EJB的异同之处　300                  
 10.2  消息驱动Bean的编程接口　300                  
 10.3  消息驱动Bean的生命周期　301                  
 10.4  创建消息驱动Bean　302                  
 10.4.1  就绪方法池　302                  
 10.4.2  删除Bean　303                  
 10.4.3  使用消息　303                  
 10.4.4  处理异常　303                  
 10.4.5  容器管理的事务处理和Bean管理的事务处理　304                  
 10.4.6  消息认可　305                  
 10.4.7  JMS消息过滤器　305                  
 10.5  编写简单的消息驱动Bean　305                  
 10.6  运行实例　307                  
 10.6.1  创建队列　307                  
 10.6.2  部署消息驱动Bean　308                  
 10.6.3  创建发送客户端以创建消息　311                  
 10.7  开发代理学习实例　312                  
 10.7.1  步骤1——Sender Helper类　313                  
 10.7.2  步骤2——代理和注册会话Bean　314                  
 10.7.3  步骤3——消息驱动bean　316                  
 10.7.4  步骤4——创建JMS队列　321                  
 10.7.5  步骤5——部署EJB　321                  
 10.7.6  步骤6——测试ApplicantMatch Bean　321                  
 10.8  使用其他的体系结构　321                  
 10.9  小结　322                  
 10.10  问与答　322                  
 10.11  练习　322                  
 第11天课程  JavaMail　324                  
 11.1  E-Mail常识　324                  
 11.1.1  简单邮件传输协议（SMTP）　325                  
 11.1.2  邮箱协议（POP3）　326                  
 11.1.3  网络消息访问协议（IMAP）　326                  
 11.1.4  其他协议　326                  
 11.1.5  多用途Internet邮件扩展（MIME）　326                  
 11.2  JavaMail API简介　326                  
 11.3  安装开发环境　327                  
 11.4  发送第一封电子邮件　327                  
 11.5  创建多媒体电子邮件　331                  
 11.5.1  创建消息：方法＃1　332                  
 11.5.2  创建消息：方法＃2　335                  
 11.6  发送带附件的电子邮件　339                  
 11.7  探索JavaMail API　342                  
 11.7.1  检索消息　342                  
 11.7.2  删除消息　345                  
 11.7.3  取得附件　346                  
 11.7.4  认证用户和安全性　349                  
 11.8  小结　352                  
 11.9  问与答　352                  
 11.10  练习　353                  
 第12天课程  Servlet　354                  
 12.1  Servlet的用途和使用　354                  
 12.1.1  为Web应用程序修改Servlet　354                  
 12.1.2  服务器与平台独立性　355                  
 12.1.3  高效与可扩展性　355                  
 12.1.4  整合Servlet和服务器　355                  
 12.2  HTTP简介　356                  
 12.2.1  HTTP结构　356                  
 12.2.2  其他的HTTP方法　358                  
 12.2.3  服务器响应　358                  
 12.2.4  内容类型头　359                  
 12.3  HTML简介　359                  
 12.4  Servlet环境　363                  
 12.5  Servlet类继承体系　363                  
 12.6  简单的Servlet实例　363                  
 12.7  向Servlet传递参数数据　368                  
 12.7.1  如何访问参数　368                  
 12.7.2  具有参数的Servlet实例　368                  
 12.7.3  使用POST请求　370                  
 12.7.4  Servlet生命周期　370                  
 12.7.5  Servlet环境　371                  
 12.8  Web应用程序　372                  
 12.8.1  Web应用程序的文件和目录结构　372                  
 12.8.2  Web应用程序的部署描述符　373                  
 12.9  处理错误　374                  
 12.9.1  HTTP错误　374                  
 12.9.2  Servlet异常处理　375                  
 12.10  保留客户端信息和状态信息　376                  
 12.10.1  使用会话对象　376                  
 12.10.2  表单隐藏域　377                  
 12.10.3  Cookie　378                  
 12.10.4  创建一个Cookie　378                  
 12.10.5  重写URL　379                  
 12.11  Servlet过滤　380                  
 12.11.1  设计过滤器　380                  
 12.11.2  审计过滤器实例　381                  
 12.11.3  部署过滤器　382                  
 12.12  事件监听　385                  
 12.13  Servlet线程　388                  
 12.14  安全性和Servlet沙箱　388                  
 12.15  求职代理学习实例　389                  
 12.15.1  AgencyTable Servlet代码　389                  
 12.15.2  部署AgencyTable Servlet　391                  
 12.16  小结　394                  
 12.17  问与答　394                  
 12.18  练习　394                  
 第13天课程  JSP　396                  
 13.1  JSP是什么　396                  
 13.1.1  角色分离　397                  
 13.1.2  转换和执行　397                  
 13.2  JSP语法和结构　398                  
 13.3  第一个JSP实例　399                  
 13.4  JSP生命周期　402                  
 13.4.1  发现和纠正JSP错误　403                  
 13.4.2  JSP生命周期方法　406                  
 13.5  JSP指令　406                  
 13.5.1  include指令　407                  
 13.5.2  page指令　407                  
 13.6  存取HTTP Servlet变量　410                  
 13.7  使用HTTP请求的参数　410                  
 13.8  用JavaBean简化JSP网页　412                  
 13.8.1  什么是JavaBean　412                  
 13.8.2  定义JavaBean　412                  
 13.8.3  取得Bean属性　413                  
 13.8.4  设置Bean属性　413                  
 13.8.5  初始化Bean　414                  
 13.8.6  在求职代理实例中使用Bean　414                  
 13.9  向求职代理实例中添加Web接口　417                  
 13.9.1  结构和导航　417                  
 13.9.2  外观和感受　419                  
 13.9.3  错误处理页的定义　425                  
 13.9.4  部署JSP学习实例　427                  
 13.10  比较JSP和Servlet　429                  
 13.11  小结　430                  
 13.12  问与答　430                  
 13.13  练习　430                  
 第14天课程  JSP标记库　432                  
 14.1  标记库扮演的角色　432                  
 14.2  开发简单的自定义标记　433                  
 14.2.1  使用简单的标记　433                  
 14.2.2  标记库描述符（TLD）　434                  
 14.2.3  自定义Java标记　435                  
 14.2.4  自定义标记的生命周期方法　437                  
 14.2.5  自定义标记“Hello World"　437                  
 14.2.6  部署标记库Web应用程序　438                  
 14.2.7  定义TLD位置　439                  
 14.2.8  使用简单的标记　440                  
 14.3  带属性的标记　440                  
 14.4  定义脚本变量的标记　442                  
 14.5  迭代标记　446                  
 14.6  协作标记　449                  
 14.6.1  使用共享脚本变量　449                  
 14.6.2  分层的标记结构　449                  
 14.7  定义标记的额外信息对象　455                  
 14.7.1  验证属性　456                  
 14.7.2  定义脚本变量　457                  
 14.8  处理标记体　458                  
 14.9  JSP标准标记库（JSPTL）　460                  
 14.9.1  在J2EE RI中使用JSPTL　461                  
 14.9.2  使用JSPTL的forEach标记　461                  
 14.9.3  其他JSPTL标记　463                  
 14.9.4  JSPTL脚本语言　464                  
 14.9.5  其他Jakarta标记库　464                  
 14.10  小结　465                  
 14.11  问与答　465                  
 14.12  练习　466                  
 第三周课程  在企业中集成J2EE                  
 第15天课程  安全　468                  
 15.1  安全概述　468                  
 15.2  常用安全技术　470                  
 15.2.1  对称加密法　470                  
 15.2.2  非对称加密　471                  
 15.2.3  SSL和HTTPS　471                  
 15.2.4  校验和与摘要　472                  
 15.2.5  数字证书　472                  
 15.3  J2EE中的安全　473                  
 15.3.1  J2EE安全术语　473                  
 15.3.2  使用J2EE RI安全　474                  
 15.4  安全和EJB　476                  
 15.4.1  定义EJB安全　476                  
 15.4.2  定义角色　476                  
 15.4.3  定义安全身份　478                  
 15.4.4  定义方法许可　479                  
 15.4.5  映射代理到角色　483                  
 15.4.6  使用角色作为安全身份　484                  
 15.5  Web应用程序和组件的安全　488                  
 15.5.1  Web 认证　489                  
 15.5.2  配置J2EE RI 基本认证　489                  
 15.5.3  声明的Web授权　490                  
 15.5.4  可编程Web授权　495                  
 15.5.5  加入可编程Web安全到学习实例　495                  
 15.5.6  使用安全的Web认证方案　497                  
 15.6  安全和JNDI　497                  
 15.6.1  简单LDAP认证　498                  
 15.6.2  SASL认证　498                  
 15.7  小结　500                  
 15.8  问与答　500                  
 15.9  练习　501                  
 第16天课程  整合XML和J2EE　502                  
 16.1  平台无关数据交换的原因　502                  
 16.2  XML起源　503                  
 16.3  XML结构和语法　504                  
 16.3.1  HTML和XML　504                  
 16.3.2  XML文档结构　505                  
 16.3.3  声明　505                  
 16.3.4  元素　505                  
 16.3.5  结构良好的XML文档　506                  
 16.3.6  属性　507                  
 16.3.7  注释　507                  
 16.4  创建有效XML文档　508                  
 16.4.1  文档类型定义　508                  
 16.4.2  名称空间　511                  
 16.4.3  用XML Schema强化文档结构　512                  
 16.4.4  如何在J2EE中使用XML　513                  
 16.5  解析XML　514                  
 16.6  JAXP包　515                  
 16.7  使用SAX解析XML　515                  
 16.8  文档对象模型（DOM）解析器　519                  
 16.9  修改DOM树　523                  
 16.10  支持XML绑定的Java体系结构　524                  
 16.11  扩展求职代理学习实例　525                  
 16.11.1  步骤1——改变会话Bean　526                  
 16.11.2  步骤2——修改MessageSender帮助类　527                  
 16.11.3  步骤3——修改ApplicationMatch消息驱动Bean　528                  
 16.12  小结　530                  
 16.13  问与答　530                  
 16.14  练习　530                  
 第17天课程  XML文档转换　532                  
 17.1  在客户端表示XML文档　532                  
 17.1.1  在浏览器上表示XML文档　533                  
 17.1.2  可扩展样式表语言（XSL）　533                  
 17.1.3  XSL格式化对象（XSL-FO）　533                  
 17.2  可扩展样式表转换（XSLT）　534                  
 17.2.1  应用样式表　535                  
 17.2.2  在服务器上存储转换后的文档　535                  
 17.2.3  在客户端表示XML文档和样式表　535                  
 17.2.4  在服务器上转换XML文档　536                  
 17.3  通过J2EE使用XALAN　536                  
 17.3.1  使用XALAN转换XML文档　537                  
 17.3.2  从命令行使用XALAN　537                  
 17.4  在Java应用程序中使用XSLT　538                  
 17.5  XSLT样式表　542                  
 17.5.1  模板规则　542                  
 17.5.2  XML元素的文本表示　546                  
 17.5.3  通过XSLT使用Xpath　547                  
 17.5.4  默认的样式表规则　549                  
 17.5.5  处理属性　549                  
 17.6  使用样式表元素　550                  
 17.6.1  处理空格和文本　551                  
 17.6.2  添加注释　552                  
 17.6.3  属性值　553                  
 17.6.4  创建和复制元素　554                  
 17.6.5  属性和属性集　557                  
 17.6.6  其他XSL元素　559                  
 17.7  XSLT编译器　562                  
 17.8  小结　562                  
 17.9  问与答　562                  
 17.10  练习　563                  
 第18天课程  模式　567                  
 18.1  J2EE模式　567                  
 18.1.1  什么是模式　567                  
 18.1.2  为什么使用模式　568                  
 18.1.3  模式的类型　569                  
 18.1.4  J2EE模式　569                  
 18.1.5  模式目录　570                  
 18.2  应用J2EE特定的模式　570                  
 18.2.1  在环境中应用模式　570                  
 18.2.2  通用模式　571                  
 18.2.3  J2EE表达层模式　571                  
 18.2.4  J2EE业务层模式　572                  
 18.2.5  J2EE综合层模式　572                  
 18.2.6  J2EE中的模式　573                  
 18.3  环境中的模式　573                  
 18.3.1  分析学习实例　573                  
 18.3.2  会话Facade和实体EJB　574                  
 18.3.3  数据交换和值对象　575                  
 18.3.4  非实体EJB的数据访问　578                  
 18.3.5  消息和异步激活　584                  
 18.3.6  组装实体　584                  
 18.3.7  组装JSP　585                  
 18.3.8  JSP和关注点分离　587                  
 18.3.9  客户端代理服务器和委托　590                  
 18.3.10  定位服务　591                  
 18.3.11  其他业务　591                  
 18.3.12  重构学习实例　592                  
 18.4  J2EE模式趋势　592                  
 18.5  小结　592                  
 18.6  问与答　593                  
 18.7  练习　593                  
 第19天课程  整合外部资源　594                  
 19.1  回顾外部资源和原有系统　594                  
 19.2  连接器体系结构简介　595                  
 19.2.1  体系结构概述　595                  
 19.2.2  角色与职责　596                  
 19.3  使用公共客户接口　598                  
 19.3.1  与EIS交互　599                  
 19.3.2  安装资源适配器　599                  
 19.3.3  创建第一个CCI应用程序　600                  
 19.3.4  管理事务和查找记录　606                  
 19.4  其他连接技术简介　610                  
 19.5  CORBA简介　610                  
 19.6  Java IDL简介　611                  
 19.7  使用基于IIOP的RMI　612                  
 19.7.1  基于JRMP的RMI实例　612                  
 19.7.2  基于IIOP的RMI实例　616                  
 19.8  JNI简介　619                  
 19.9  整合技术评估　622                  
 19.10  小结　623                  
 19.11  问与答　623                  
 19.12  练习　623                  
 第20天课程  借助J2EE使用RPC样式的Web服务　625                  
 20.1  Web服务概述　626                  
 20.1.1  什么是Web服务　626                  
 20.1.2  为什么使用Web服务　627                  
 20.1.3  Web服务技术和协议　627                  
 20.1.4  Web服务体系结构　627                  
 20.2  J2EE的Web服务　628                  
 20.2.1  J2EE的Web服务体系结构　629                  
 20.2.2  工具和技术　629                  
 20.2.3  整合Web服务和已存在的J2EE组件　631                  
 20.3  使用基于SOAP. RPC样式的Web服务　631                  
 20.3.1  面向RPC的Web服务　632                  
 20.3.2  在Tomcat 4.0下设置Axis　633                  
 20.3.3  服务描述信息　634                  
 20.3.4  WSDL文档剖析　634                  
 20.3.5  从WSDL创建Java代理服务器　636                  
 20.3.6  通过SOAP调用Web服务　638                  
 20.3.7  折衷方案　641                  
 20.3.8  调试SOAP交互　641                  
 20.4  实现基于SOAP. RPC样式的Web服务　643                  
 20.4.1  将Java类包装为Web服务　643                  
 20.4.2  Web服务的客户端　646                  
 20.4.3  从WSDL开始　648                  
 20.4.4  使用Axis JWS文件　650                  
 20.4.5  会话情景和Web服务　652                  
 20.4.6  将存在的J2EE功能包装为Web服务　655                  
 20.5  参数类型和类型映射　656                  
 20.5.1  Java和SOAP/WSDL类型间的映射　656                  
 20.5.2  采用Serializer映射复杂类型　657                  
 20.5.3  深入探讨复杂类型映射　663                  
 20.6  小结　663                  
 20.7  问与答　663                  
 20.8  练习　664                  
 第21天课程  Web服务注册表和消息样式的Web服务　665                  
 21.1  Web服务注册表　665                  
 21.1.1  什么是Web服务注册表　665                  
 21.1.2  为什么我们需要Web服务注册表　666                  
 21.1.3  注册表如何工作　666                  
 21.1.4  注册表分类　666                  
 21.1.5  ebXML Registry和Repository　667                  
 21.1.6  UDDI概述　668                  
 21.2  访问UDDI注册表中的信息　668                  
 21.2.1  使用UDDI4J操纵服务信息　669                  
 21.2.2  使用IBM的WSTK客户端API操纵服务信息　671                  
 21.2.3  检索和使用信息　672                  
 21.3  使用JAXR进行注册表访问　672                  
 21.3.1  一种通用方法　672                  
 21.3.2  使用JAXR存储和检索服务信息　674                  
 21.4  使用基于消息的SOAP接口　674                  
 21.4.1  消息样式与RPC样式　675                  
 21.4.2  创建客户　675                  
 21.4.3  创建服务　676                  
 21.5  使用JAXM发送和接收SOAP消息　676                  
 21.5.1  JAXM和J2EE　677                  
 21.5.2  配置JAXM　677                  
 21.5.3  发送基本的SOAP消息　678                  
 21.5.4  运行简单的客户　682                  
 21.5.5  填充消息　682                  
 21.5.6  Header和附件　685                  
 21.5.7  使用JAXM接收SOAP消息　686                  
 21.5.8  使用JAXM profile　688                  
 21.5.9  使用JAXM Profile发送一条消息　690                  
 21.5.10  使用JAXM profile接收一条消息　692                  
 21.6  小结　694                  
 21.7  问与答　694                  
 21.8  练习　695                  
 附录A  UML简介　696                  
 A.1  UML简介　696                  
 A.2  用例图　697                  
 A.3  类图　698                  
 A.3.1  关联　699                  
 A.3.2  属性　699                  
 A.3.3  操作　700                  
 A.3.4  泛化　701                  
 A.3.5  约束　701                  
 A.4  顺序图　702                  
 附录B  SQL语句参考　704                  
 B.1  常用的SQL语句（SQL99）　704                  
 B.1.1  修改表（ALTER TABLE）　704                  
 B.1.2  创建表(CREATE TABLE)　705                  
 B.1.3  创建视图（CREATE VIEW）　705                  
 B.1.4  删除（DELETE）　706                  
 B.1.5  删除数据表（DROP TABLE）　706                  
 B.1.6  删除视图（DROP VIEW）　706                  
 B.1.7  插入（INSERT）　706                  
 B.1.8  选择（SELECT）　706                  
 B.1.9  内联接　707                  
 B.1.10  交叉联接　707                  
 B.1.11  左外联接　707                  
 B.1.12  右外联接　707                  
 B.1.13  全联接　708                  
 B.1.14  更新（UPDATE）　708                  
 B.2  常用的SQL子句　708                  
 B.2.1  FROM子句　708                  
 B.2.2  WHERE子句　708                  
 B.2.3  GROUP BY子句　709                  
 B.2.4  HAVING子句　709                  
 B.2.5  ORDER BY子句　709                  
 附录C  XML概述　710                  
 C.1  什么是XML　710                  
 C.1.1  元素　710                  
 C.1.2  声明　711                  
 C.1.3  注释　712                  
 C.1.4  特殊字符　712                  
 C.1.5  名称空间　712                  
 C.2  强化XML文档结构　713                  
 C.2.1  文档类型定义　713                  
 C.2.2  XML Schema　716                  
 C.3  在哪里获取更多相关信息　717                  
 附录D  Java Community Process　719                  
 D.1  JCP简介　719                  
 D.2  JCP相关内容　719                  
 D.2.1  JCP成员　719                  
 D.2.2  专家组　720                  
 D.2.3  公共成员　720                  
 D.2.4  过程管理办公室　720                  
 D.2.5  执行委员会　720                  
 D.3  了解JSR进程　720                  
 D.4  进入下一步　721                  
 术语表　722