|
I. 序言
在这个白皮书里，我们会在为商业公司建立基于XML的Web services的两种产品中做一个强有力的比较:由太阳微系统公司设计的Java 2 平台, Enterprise Edition (J2EE)1,，另一个是微软公司的Microsoft.NET2。
在这篇文章中，一些观点可能会冒犯你，但我们希望其中大部分观点能和你相通！所以当你阅读这篇文章时，请记住我们的三个承诺 ：
1，我们承诺：在做比较时是在一个合理的，中立的和毫无偏见的基础上！
2，我们承诺：告诉您我们关于这两个技术比较的真实感受！
3，我们承诺：消除您关于市场中这两个技术的不安定因素！
尽管J2EE 和 .NET覆盖了大量的技术和标准，但我们会把焦点明确的集中在为web services建立服务器端这一点上。在读完这篇白皮书后，你会发现我们对这两个技术的比较，能够使你在设计web services时，做出选择！
首先，这个白皮书的前一半是基于web services,J2EE和.NET部分信息的。如果你已经掌握了这些技术，可以跳过这一部分，进入第二部分，那里有您感兴趣的关于两者比较的内容！
II. 介绍
通过已被广范接泛的技术来创建web services
在web services的身后是完整的理论体系，现在让我们来看看如何去创建和使用一个web service。
Web services现在只是旧技术戴着顶新帽子，它现在只是简单的基于XML的界面。下面的一些技术已经为大多数工业所接受，将是建立Web services的方法：
· 供应商选择自己的编程语言，中间件和开发平台开发，装配Web services。
· 各供应商定义一个Web services描述语言（the Web Services Description Language4 ），通过统一语言和标准来建立Web services。
· 供应商在UDDI注册，UDDI能让供应商发布Web services，并能为他们的软件找到由其它供应商提供的服务,也就是大家资源共享！
· 用户通过UDDI搜索他想要的服务。
· 用户通过SOAP（简单对象ACCESS协议）来调用service的操作。SOAP提供一个类似XML的能通过HTTP描绘参数和返回数值的方法。这是一个所有Web services都遵守的协议。
注意，以上的这些技术仅仅是对简单的Web services的。对于商业事务，多请求事务，计划，文件流，扩展的商业交易，就需要一个已经完全协议上的结构,这些应用程序的要求条件经常超出纯粹地基于SOAP的执行。这就是ebXML产生的动机，一套XML规范＋相互联系的程序＋为提供一个B2B协作综合基础的方法。
注意上面的方法只是建立Web services的一种，你还可以有更多的选择，但是我们觉得上面的这些方法是极其重要的将会为广泛的工业所采用！事实上，我们还未能取得关于建立Web services完全一致的意见，现在还是有很多的其它解决方案，例如，关于SOAP的扩展，ebXML和服务流程描述，但它们都还未达成一致。但我们也有好的消息：
· 绝大多数的开发商，包括SUN和Microsoft都在SOAP，WSDL，UDDI上达成一致,这些技术都会为未来提供一个良好的基础。
· 所有的开发商都在共同建立Web services的标准。
The J2EE and Microsoft.NET
如果你想建一个便于使用的web services，你就得使你的web services比须是可靠的，高度可利用的，能容错的，可升级的并且能在可接受的条件下完成任务。这些需要和任何其他的企业应用程序没什么区别。
J2EE和.NET正是从现有的应用程序服务器演变而来，用于建立这些企业应用程序的。在它们的早期版本中，这些技术从历史的观点上看并不是用于web services的。现在web services时代已经到来，这两个阵营都正在各自的平台上重新设计他们的解决方案，任何一个平台都能满足您关于建立web services的需求。
像XML协同工作，平衡载入，事务处理，在J2EE与.NET之间，两者有着太多的相似。你可以通过它们提供的服务轻松的写出你的程序，而不是像以前一样你独自的写出每一句程序。
这样就可以让你专注于编写你想加强功能的那一模块。假如，你从事一家财务服务公司，你非常熟悉财务服务，但是比起像SUN，IBM，BEA，Oracle和Microsoft等这样的技术公司，你对web services的编程就理解甚少。你只需购买他们的相关程序包，你不必成为一个样样精通的编程专家也能建立一个基于财务服务的web services。你只要找到你商业事务中的随时可能遇到的问题就可以了，因为这部分可以由你自己来编程处理，而其它琐碎的程序编写就留给你购买的程序包去解决！
现在，我们就开始看看J2EE与.NET的细节部分。
III. J2EE
JAVA2平台，企业版（J2EE）是为单一的复杂问题，如有关部门发展，人员配置，项目管理等多级企业解决方案而设计的。J2EE是一个由SUN微系统公司提出的工业标准。
你应该意识到J2EE是一个标准，而不是一个产品，这一点是很重要的。所以你没有办法去“下载”J2EE。你更适合去下载一套Adobe Acrobat PDF格式的有关描述应用程序与程序包之间的协议文档。只要双方都服从J2EE的约定，其应用程序就能在各种各样的程序包环境下运行。
J2EE阵营的目的是使所有用户有权自己去选择他们要的产品和工具，这样也鼓励了产品间的竞争。这一目的的实现比须是J2EE已成为工业标准。为了使用户放心的买入，SUN公司同其他的EBusiness平台开发商（像BEA，IBM和Oracle）合作定义J2EE。SUN还发起了JAVA民间组织以汲取新的方案来不断完善J2EE。SUN公司做这些的原因是：他们不得不这样做以争取成功，他们想成为业界标准。
Java: J2EE的基础语言
J2EE体系构造的基础是JAVA语言。JAVA最激动人心的地方是他只用编程者写一次代码，就能运行在其它的平台上，具体如下：
1，开发者用JAVA编写源代码。
2，JAVA代码被编译成字节码，这是一个跨平台的中间代码，居于源代码和机器代码之间。
3，当这些代码运行时，JAVA运行环境（JRE）解释这种字节码并且同时执行。
J2EE是JAVA语言的应用。你的J2EE组件被转化成字节码在JRE下执行。
J2EE和web Services
J2EE从历史观点上看是一个用JAVA语言建筑服务器端应用的体系结构。它能创建传统的网站，软件组件或者是应用程序包。J2EE最近已被扩展成包括支持建立基于XML的web services。这些web services能同其它web services交互操作。
J2EE web services发展模型如图1所示：
图1简要的解释如下：
J2EE应用程序是一组企业应用程序，其由许多必要的服务程序集成，如事务处理服务程序，安全服务程序等。
在商业层上执行商业处理和数据资料处理，在J2EE应用程序中，这些大多数是用Enterprise JavaBeans (EJB) components来建立的。这一层完成商业处理和数据处理，通过Java Database Connectivity (JDBC) 或SQL/J或使用Java Connector Architecture (JCA)的现有系统来实现数据库的连接。当然也能使用web services技术（SOAP，UDDI，WSKL，EBXML），这些是通过JAVA的API函数来实现的。
商业伙伴能经web services技术（SOAP，UDDI，WSKL，EBXML）分享J2EE应用程序。一个小servlet，能接受来自商业伙伴的web service的请求。servlet使用JAVA的API来执行web services操作。
传统的“胖”客户，像applets和应用程序直接通过EJB层来连接，因此这里没有必要与基于XML的web services协作。
WEB浏览器和无线设备与JSP连接，使用户不必在乎它们与HTML，XHTML或WML之间的接口。
参考工具
为了提供详细的说明，SUN公司也提供了J2EE的参考工具。程序员编写工具以保证其组件的可移植性。这些工具不应该是产品，它们仅仅是用来起测试的作用。
额外的服务
所有支持J2EE平台的厂家都能提供额外的服务，当然这些是在业界标准里找不到的，所以其中可能会影响移植能力，如扩展的EAI功能性，电子商业组件，高级的B2B集成。还有其它的一些特色，如平衡载入，是不影响程序代码移植性的，因为它们的服务是由底层的程序包提供的。
IV. Microsoft's .NET 平台
Microsoft .NET是一组能使你建立良好的，企业级的web services的产品。注意，它们有一个重要的不同：.NET是一个产品策略，然而J2EE是一个任何产品都要用到的标准。
.NET大量的改写了Microsoft早期开发平台的底层代码和组件，其中包括了许多现在正广范用到的技术，也包括MTS和COM＋，消息队列（MSMQ），和Microsoft SQL server数据库。新的.NET结构取代了这些技术，并且包括了一个web services层来提高语言的支持能力。
用Microsoft的.NET建筑web services的开发模型如下图：
关于上图的简要解释：
.NET应用程序是运行在一个大型的程序包上，由其提供大量的服务，例如事务处理，安全保护和消息传输服务。
在商业层上用.NET的管理组件来建立.NET应用程序。在这一层上，完成的是商业处理和数据整理。它通过ADO.NET来连接数据，也可通过SOAP，UDDI，WSDL来连接你的商业伙伴。
商业合作者们能由.NET应用程序通过web services技术（SOAP，UDDI，WSDL，BizTalk)来相互联接。
传统的胖客户机，网页浏览，无线设备通过HTML，XHTML或WML与ASP.NET实现联接，高级用户界面则是由windows的窗体建立。
· .NET 框架
Microsoft的.NET实现了语言独立性和语言的互用性，这正是.NET框架中一个迷人的地方。一个单独的.NET组件能由VB.NET编写，也能由C＃(一个新的面向对象编程语言）编写。
它是如何工作的呢？首先，源程序被翻译成Microsoft Intermediate Language（中间代码），我们称其为MSIL，或IL。这种IL代码是一种与JAVA字节码类似的中性语言。
IL代码接着被解释翻译成本地可执行的代码。.NET框架包含了一个通用语言运行库（CLR），与JAVA的实时运行环境（JRE）是类似的。CLR是.NET开发者的源代码与下层硬件的一个中间接口，所有的.NET代码最终都是在CLR上运行的！
CLR提供了一些动人的特性，像自动垃圾收集，异常操作，跨语言继承，调试，还有各个不同版本组件“side-by-side”的执行机制。
.NET 服务程序
.NET平台由以下.NET企业服务程序构成：
SQL Server 2000 微软的关系数据库系统。
Exchange 2000 Server 一个消息传输，协作平台，用于开发，运行核心的商业服务，现在已集成在Windows 2000中。
Commerce Server 2000 提供简单的电子商务解决方案。
Application Center Server 2000用于管理众多的服务程序。
Host Integration Server 2000 轻松的与其它平台相联。
Internet Security and Acceleration (ISA) Server 2000 提供防火墙和网页缓存功能。
BizTalk Server 2000 微软的基于XML的协作的电子商务解决方案。
其他.NET产品和服务程序
微软的旗舰产品：新版本的Visual studio.NET，已经发行。这是一个综合的.NET开发环境。除了JAVA，它几乎支持所有的语言。
Visual Studio.NET也提供了新的所谓C＃语言，与JAVA类似，你会发现它们只有一点点的不同。
另外还有Hailstorm9 。 是微软的portfolio of building block web services. Microsoft and possibly Microsoft partners will host the Hailstorm web services. Some Hailstorm web services will be available on a subscription basis, and others will be free. For example, Microsoft's Passport service is now freely available as a web service-oriented universal identification mechanism.
Web services such as Microsoft's Passport offer a shared context in that many other web services can depend upon Passport for identity and security credentials. User's need not have their contextual information spread across and possibly duplicated across multiple web sites. "Islands" of information can now be located in a single repository and then shared by user-centric web services regardless of the invoking client device. Privacy of information is focal point in Hailstorm web servicing. In fact, users of Hailstorm web services are empowered to manage the availability of their personal information through "affirmative consent".
Understanding J2EE and .NET by analogy
To help you understand both models, we offer analogies between J2EE and .NET technologies in Table 1. This table only showcases the similarities--we will get to the differences in a few moments.
|
特性
|
J2EE
|
.NET
|
|
技术类型
|
标准
|
产品
|
|
中间供应商
|
30+
|
Microsoft
|
|
翻译器
|
JRE
|
CLR
|
|
动态web网页
|
JSP
|
ASP.NET
|
|
中间层组件
|
EJB
|
.NET 管理组件
|
|
数据库存取
|
JDBC SQL/J
|
ADO.NET
|
|
SOAP, WSDL,
UDDI
|
Yes
|
Yes
|
|
Implicit middleware
(load-balancing, etc)
|
Yes
|
Yes
|
Table 1 Analogies between J2EE and .NET
V. Comparative Analysis
Time-to-Market Features
When developing a commerce solution in today's marketplace, a few months of time is an eternity. Missing a small window of opportunity is the difference between a corporation that is first to market, and a corporation that must play catch-up for years.
One way to speed time to market is to choose a Web services platform that allows rapid application development. This enables developers to write and maintain code quickly, lowering development time.
Both Sun J2EE and Microsoft .NET provide runtime mechanisms that insulate software developers from particular dependencies. In addition to a web service-oriented XML layer of indirection between platforms, languages, and enterprise architectures, Sun J2EE and .NET offer language-level intermediation via the Java Runtime Environment (JRE) and the Common Language Runtime (CLR) respectively.
J2EE offers several features that accelerate time-to-market which are not found in .NET. For example, state management services enable developers to write less code and not worry about managing state, resulting in a higher degree of rapid application development. State management services enable you to build components that hold state. Persistence services (entity beans) enable developers to write applications without coding data access logic, resulting in leaner, database-independent applications that are easier to build and maintain. Programmatic transactions allow you to have greater transactional control. And custom tags are extremely powerful, and empower developers and web designers to easily collaborate.
In addition to these features that enable rapid application development, there are several features that specific vendors offer which aid time-to-market, such as business process management, E-Commerce components, XML-based legacy integration, and enhanced B2B collaboration. A warning: Customers who elect to leverage these features will sacrifice portability. This is a consequence of J2EE architecture not being all things to all people. However, it should be noted that even after taking advantage of such proprietary features, there would still be a great deal more portability in the end solution than the .NET alternative.
Microsoft.NET offers a variety of time-to-market features not found in J2EE as well. Most notably, ASP.NET is independent of client device, and allows for user interfaces to be rendered to alternative user interfaces without rewriting code. Microsoft also offers Queued Components which are superior to MessageDriven Beans. It should be noted here that Microsoft has tried to simplify server-side programming greatly by removing support for features found in traditional enterprise applications, such as stateful servers and simple transactions. If developers need to go outside this box, their code must be made to be non-managed and reside outside the .NET Framework rather than take advantage of it. Microsoft also provides business process management and E-Commerce capabilities, which are available in some J2EE implementations but not all.
In conclusion, we feel the ability to achieve rapid application development offered by both J2EE and .NET is definitely not equal. It is, however, comparable. The feature differences are minor and it is very difficult to make a compelling argument either way. We do not recommend organizations make their platform decision based upon them. There are larger business issues at hand that dictate the platform choice.
Single-Vendor Solution
When building web services, in general you should always prefer to have a single-vendor solution. A single vendor solution is usually more reliable, interoperable, and less error-prone than a two-vendor bridged solution.
One of J2EE's strengths is that it has spawned a wide variety of tools, products, and applications in the marketplace, which provide more functionality in total than any one vendor could ever provide. However, this strength is also a weakness. J2EE tools are often-times not interoperable, due to imperfections in portability. This limits your ability to mix and match tools without substantial low-level hacking. With lower-end J2EE implementations, you need to mix and match to get a complete solution, and this is the tradeoff when choosing a less complete package. Larger vendors, such as IBM, Oracle, BEA, and iPlanet, each offer a complete web services solution.
.NET provides a fairly complete solution from a single vendor--Microsoft. This solution may lack some of the higher end features that J2EE solutions offer, but in general, the complete web services vision that Microsoft will be providing is equal in scope to that of a larger J2EE vendor.
Another way to look at a single-vendor solution is from a legacy perspective. Many legacy systems are written by J2EE vendors, such as IBM or BEA. J2EE offers a single-vendor solution from the legacy integration perspective, since you can re-use existing relationships with those vendors. A J2EE solution would therefore be a single-vendor solution, since you can stay with that legacy system vendor rather than inject a new vendor such as Microsoft. For users with existing Microsoft-based systems, the reverse argument applies.
Support for Existing Systems
Most large corporations have existing code written in a variety of languages, and have a number of legacy systems, such as CICS/COBOL, C++, SAP R/3, and Siebel. It is vital that corporations be given an efficient, rapid path to preserve and reuse these investments. After all, it is likely that businesses will have neither the funds nor the time to reinvent all existing systems. This legacy integration often is one of the most challenging (if not the most challenging) tasks to overcome when building a web service.
There are several ways to achieve legacy integration using J2EE, including
o The Java Message Service (JMS) to integrate with existing messaging systems
o Web services to integrate with any system
o CORBA for interfacing with code written in other languages that may exist on remote machines.
o JNI for loading native libraries and calling them locally.
But by far, the most important part of the J2EE vision for integration is the J2EE Connector Architecture (JCA). The JCA is a specification for plugging in resource adapters that understand how to communicate with existing systems, such as SAP R/3, CICS/COBOL, Siebel, and so-on. If such adapters are not available, you can write your own adapter. These adapters are reusable in any container that supports the JCA. The major vendors of existing systems are bought into the JCA.
.NET also offers legacy integration through the Host Integration Server 2000. COM Transaction Integrator (COM TI) can be used for collaborating transactions across mainframe systems. Microsoft Message Queue (MSMQ) can integrate with legacy systems built using IBM MQSeries. Finally, BizTalk Server 2000 can be used to integrate with systems based on B2B protocols, such as Electronic Data Interchange (EDI) (the reader should note, however, that BizTalk does not serve as an access point to a proprietary network on which EDI takes place).
In conclusion, we believe that the legacy integration features offered by J2EE are superior to those offered by .NET. The JCA market is producing a marketplace of adapters that will greatly ease enterprise application integration. Integration with packaged applications and legacy systems will become much easier--imagine integrating with a system such as Siebel, Oracle, or SAP without ever leaving the Java programming environment. There is no analog to this in the Microsoft domain; rather, there is limited connectivity to select systems provided off-the-shelf through the Host Integration Server.
Market Perception
When comparing two platforms, your first instinct is probably to compare the technologies. The unfortunate reality is that good technology rarely succeeds in the marketplace because it's good technology. Usually it's the technology with the best marketing that wins.
J2EE is an extremely well-marketed platform because it is being marketed by an entire industry of 50+ assorted vendors. This network of interdependent businesses form a virtual marketing machine, and the result is a fantastic market perception for J2EE.
.NET's marketing strength stems from the fact that Microsoft knows how to market a platform. They have put their "A" team on marketing .NET, as is apparent in the industry hype surrounding the platform. This is a powerful force not to be reckoned with. Microsoft's advantage is also that it announced it's web services strategy before the J2EE players, which gave it market perception. So in the marketing front, we give the nod to Microsoft for doing the best job in hyping their platform--so far.
Maturity of Platform
Organizations that adopt a web services platform must consider the maturity of the underlying platform. A less mature, earlier-generation platform is more prone to errors and problems.
J2EE is a veneer atop existing J2EE solutions. J2EE deployments are alive and healthy, running a variety of mission-critical business problems today. However, when looking past the surface, it should be noted that there are some identifiable areas of risk where J2EE lacks maturity:
o The automatic persistence provided EJB is still immature
o The Java Connector Architecture (JCA) is new.
o All web service support is new.
For Microsoft.NET, the story is a bit different. Some of .NET is based on Windows DNA, which also runs a variety of mission-critical web sites today and enjoys success. However:
o With the new CLR, a good portion of the underlying .NET platform has been substantially rewritten. Indeed, the platform itself is currently only available in a beta version.
o C# is new.
o All web service support is new.
In conclusion, we must find that J2EE is the more mature platform. It is true that certain new features in J2EE are new and risky. However, the very underlying fabric of .NET, is an overhauled rewrite, and the entire C# language is brand new. This represents enormous risk compared to the new J2EE features. This best thing about .NET is that it removes the dependency on the COM Registry -- .NET will do away with DLL Hell. But the worst thing about .NET is that it tosses out the existing infrastructure. We recommend that the risk averse take a 'wait and see' approach with first-generation software such as this.
Language Support
J2EE promotes Java-centric computing, and as such all components deployed into a J2EE deployment (such as EJB components and servlets) must be written in the Java language. To use J2EE, you must commit to coding at least some of your eBusiness systems using the Java programming language. Other languages can be bridged into a J2EE solution through web services, CORBA, JNI, or the JCA, as previously mentioned. However, these languages cannot be intermixed with Java code. In theory, JVM bytecode is language-neutral, however in practice, this bytecode is only used with Java.
By way of comparison, .NET supports development in any language that Microsoft's tools support due to the new CLR. With the exception of Java, all major languages will be supported. Microsoft has also recently introduced its new C# language which is equivalent (with the exception of portability) to Java and is also available as a programming language within the Visual Studio.NET environment. All languages supported by the CLR are interoperable in that all such languages, once translated to IL, are now effectively a “common” language. A single .NET component can therefore be written in several languages.
The multiple language support that Microsoft has introduced with the CLR is an exciting innovation for businesses. It is clearly a feature advantage that .NET has over J2EE. But is the CLR a business advantage for you? This is a more interesting discussion. We are a bit concerned that the CLR may represent a poor design choice for you if more than one language is used. This is for the following reasons:
Risk.Many existing systems are internally convoluted. Disrupting such existing systems is a risky proposition, since knowledgeable engineers, original source code, and a general understanding of the existing system are often-times unavailable. The old adage, "if it ain't broke, don't fix it" applies here.
Maintainability.We speculate that a combination of languages running in the CLR may lead to a mess of combination spaghetti code that is very difficult to maintain. If you have an application written in multiple languages, then to fully develop, debug, maintain, and understand that application, you will need experts in different languages. The need to maintain code written in several languages equates to an increase in developer training expenditures which contributes further to an increased total cost of ownership.
Knowledge building.With combination language code, your developers are unable to share best practices. While individual productivity may increase, communication breaks down, and team productivity decreases.
Skills transfer.While developers using different languages may have very quickly coded a .NET system using VB.NET and C#, what happens if the new C# developers leave your organization? You have two choices. Train your VB.NET developers to understand and write code with C#, or hire other C# developers who know nothing about your code base. The resulting lack in productivity equates to a reduced time to market and a higher total cost of ownership.
In most cases, we feel that it's much better design to standardize on a single language, and to treat legacy systems as legacy systems and integrate with them by calling them through legacy APIs, which can be achieved using either J2EE or .NET.
We do feel the CLR still adds significant value. The value is that a new eBusiness application can be written in a single language of choice other than Java. This is useful for organizations that are not ready to embrace Java. However, again we must provide words of caution.
o It will not be seamless to transition existing developers from their familiar language into productive .NET developers. Procedural languages such as COBOL and VB are being rewritten for .NET to be object-oriented. Teaching developers object-oriented programming is much more of a stepping stone than understanding syntactical rules.
o Languages such as COBOL or VB were never intended to be object-oriented. Legacy code will not seamlessly transition into .NET. The resulting code is forever bound to .NET and can never be taken from its .NET home.
o We question the general wisdom in reinvesting in outdated technologies, such as COBOL, with new eBusiness or web services initiatives.
In summary, there are pros and cons to both approaches to language support. Use the approach that best suits your business needs, but at least be aware of the consequences of your decision.
Migration from Previous Platform
For organizations who have an existing deployment using either J2EE-based technologies or Windows DNA-based technologies, an interesting discussion is the ease of migration from the previous platform to the new platform.
J2EE does not impose many migration problems. As previously mentioned, the Java Connector Architecture (JCA) as well as the web services support in J2EE is brand new and will require new code, but those are minor overall.
Although Microsoft.NET is based on MTS and COM+, we are concerned that the migration to .NET will be taxing compared to J2EE. First off, .NET is based on the “managed code” framework, which steals a lot of ideas from COM+ and MTS, but it’s still an entirely new infrastructure based on an entirely new code base - CLR. Taking advantage of the most valuable aspects of the CLR impose one-time frictions.
For example to accommodate a Common Type System (CTS) which standardizes on data types used between languages, the original Visual Basic data types have been dismissed. Consequently, code dependent upon those original Visual Basic data types will break, and there is currently no migration tool.
Another example is the COM+ migration path. In .NET terminology, code that runs within the CLR is referred to as managed code, while code running outside the CLR is called unmanaged code. If you're a COM+ developer and want to take advantage of the new CLR, then you have two options for migration:
Rewrite existing code as CLR code.. COM+ code needs to be rewritten to accommodate the CLR’s automatic garbage collection mechanism and its deprecation of pointers. Dependencies also need to be removed to the COM registry.
Keep your existing code as unmanaged.To collaborate between managed and unmanaged code, special measures must be taken.
So as you can see, migration is not free. But to Microsoft's credit, we do understand that with the innovation of the CLR, that this is a necessary step for their customers to evolve into their new platform, and with such a radical change nothing less could be expected. However, we feel obligated to warn users that the migration path will not be easy compared to J2EE migration path, as some might have you believe. Consider these statements from a recent Gartner report:
“‘This is fundamentally a brand new platform,’ said Gartner Analyst Mark Driver, comparing the migration to .NET as more drastic than the switch from MS-DOS to Windows. ‘This is the tiger changing its stripes...the migration to .NET will be a difficult one for IT departments because it represents such a major shift from the current Microsoft platforms. For instance, developers will have to rewrite as much as 60 percent of the code for some existing Windows applications if they want them to take advantage of Microsoft's .NET platform, Gartner analysts predicted. That's a frightening prospect for companies who are currently switching to Windows 2000, or for those who still run Windows 98 and NT.”
Portability
A key difference between J2EE and .NET is that J2EE is platform-agnostic, running on a variety of hardware and operating systems, such as Win32, UNIX, and Mainframe systems. This portability is an absolute reality today because the Java Runtime Environment (JRE), on which J2EE is based, is available on any platform.
There is a second, more debatable aspect of portability as well. J2EE is a standard, and so it supports a variety of implementations, such as BEA, IBM, and Sun. The danger in an open standard such as J2EE is that if vendors are not held strictly to the standard, application portability is sacrificed. CORBA, for example, did not have any way to enforce that CORBA middleware did indeed comply with the standard, and thus there were numerous problems with portability. In the early days of J2EE there were the same problems.
To help with the situation, Sun has built a J2EE compatibility test suite, which ensures that J2EE platforms comply with the standards. This test suite is critical because it ensures portability of applications. At the time of this writing, there were 18 application server vendors certified as J2EE-compatible. There are a myriad of other vendors as well that are not certified10.
Our opinion is that in reality, J2EE portability will never be completely free. It is ridiculous to think that complex enterprise applications can be deployed from one environment to the next without any effort, because in practice, organizations must occasionally take advantage of vendor-specific features to achieve real-world systems. However--and this is important--portability is exponentially cheaper and easier with J2EE and the compatibility test suite than with proprietary solutions, and that is a fact we stand behind through years of consulting with customers using a variety of J2EE solutions. Over time, as the J2EE compatibility test suite becomes more and more robust, portability will become even easier.
By way of comparison, .NET only runs on Windows, its supported hardware, and the .NET environment. There is no portability at all. It should be noted that there have been hints that additional implementations of .NET will be available for other platforms. However, a question remains - how much of the complete .NET framework will be (or even can be) supplied on other platforms? History has taught us to be skeptical of Microsoft's claims of multiple platform support. Microsoft ported COM to other platforms, but never ported the additional services associated with COM that were necessary to make COM useful. We find it hard to believe that .NET portability will ever become a reality given Microsoft's historically monopolistic stance.
So how important is portability to you? This is the key question businesses must ask themselves. When evaluating the importance of portability, there are three scenarios worth considering.
o If your firm is selling software to other businesses, or if you are a consulting company, and your customers are on a variety of platforms, we recommend specializing in J2EE architecture. Unless you can guarantee that every one of your customers will accept a Windows/.NET solution, you are restricting your salespeople from major accounts that may have solutions deployed on UNIX or mainframes. This is rarely acceptable at most ISVs or consulting firms.
o If, on the other hand, your customers are on the Windows platform, then either J2EE or .NET will suffice, since they both run on Windows. You should then ask your sales force and consultants what middleware your customers are using on that platform, and make your architecture decision from there. It's important to really be proactive and get this information--the more data you have, the better.
o If you host your own solutions, then you control the deployment environment. That enables you to pick J2EE as well as .NET. If you are willing to standardize on the Win32 platform, and live with the advantages and disadvantages of that platform exclusively, then platform neutrality is irrelevant, and you should consider other factors when deciding on J2EE or .NET. But we offer a word of caution: you can never predict the future. Business goals might change, new vendors might be introduced into the picture, and mergers and acquisitions might happen. All of these may result in a heterogeneous deployment environment. Your applications will not be portable to those platforms in this scenario.
We offer a final opinion to end the debate about just how important is portability. Although both J2EE and .NET will each have their audiences, think about what platform you would choose if you were an ISVs or a consulting company. Most likely you'd have customers on a variety of platforms, and therefore, you'd probably adopt the architecture behind J2EE because you don't want to lock yourself out of deals.
Indeed, we are noticing today that an incredible number of consulting firms and ISVs are standing behind J2EE, such as Vignette, Broadvision, Chordiant, Kana, NaviSys, and Versata.
What does this mean? It's not about the platform, it's about the applications. As time goes on, customers will likely choose the solution that not only provides the web services infrastructure, but the most consulting support and ISV applications as well.
This makes the future of J2EE very bright in our minds, and is one of the critical differentiators between J2EE and .NET.
Web Services Support
The future of eBusiness collaboration is undoubtedly web services. For organizations that are pursuing a web services strategy, or are preparing for the future of web services, their underlying eBusiness architecture must have strong web services support.
Today, J2EE supports web services through the Java API for XML Parsing (JAXP). This API allows developers to perform any web service operation today through manually parsing XML documents. For example, you can use JAXP to perform operations with SOAP, UDDI, WSDL, and ebXML.
Additional APIs are also under development. These are convenience APIs to help developers perform web services operations more rapidly, such as connecting to business registries, transforming XML-to-Java and Java-to-XML, parsing WSDL documents, and performing messaging such as with ebXML.
A variety of J2EE-compatible 3rd party tools are available today that enable rapid development of web services. There are at least sixteen SOAP implementations that support Java. Almost all of these implementations are built on J2EE (servlets or JSP). There are only five UDDI API implementations available, and four of them support Java (IBM UDDI4J, Bowstreet jUDDI, The Mind Electric GLUE, and Idoox WASP). Third-party software vendors such as Tradia (www.tradia.com ), CapeClear (www.capeclear.com ) and The Mind Electric (www.themindelectric.com ) also offer tools for creating web services.
The preview release of Microsoft.NET also enables organizations to build web services. The tools that ship with Microsoft.NET also offer rapid application development of web services, with automatic generation of web service wrappers to existing systems. You can perform operations using SOAP, UDDI, and SDL (the precursor to WSDL). Visual Studio.NET provides wizards that generate web services.
Our conclusions from our web services comparison are as follows.
With J2EE, you can develop and deploy web services today using JAXP. However, this is not the ideal way to build web services, since it requires much manual intervention. An alternative is for organizations to leverage 3rd party libraries to accelerate their development. In the future these libraries will be standardized through the JAX APIs. For now, if you develop web services rapidly, you'll need to bundle these libraries with your application.
With .NET, you can develop web services today using the partial release of .NET. However, since this is only a beta implementation, it does not represent a realistic deployment platform. Another issue with .NET is that it does not support true web services because of a lack of support for ebXML. ebXML is a very important standard for eBusiness collaboration, and is experiencing broad adoption from around the world. Thousands of vendor and non-vendor companies, government institutions, academic and research institutions, trade groups, standards bodies, and other organizations have joined the ebXML community. This includes HL7 (Health Care), OTA (Open Travel Alliance), RosettaNet, OAG (Open Applications Group), GCI (Global Commerce Initiative), and DISA (Data Interchange Standards Association). Undoubtedly, ebXML is going to be an important force in web services, and we hope that Microsoft chooses to embrace it. Microsoft is still clinging to their BizTalk proprietary framework which has proprietary SOAP extensions. This evidence makes us question Microsoft's true commitment to open and interoperable web services.
Tools
The Sun J2EE Product Portfolio includes Forte, a modular and extensible Java-based IDE that pre-dates both Sun J2EE and .NET. Developers who prefer other IDEs for Java development are free to use WebGain’s Visual Caf? IBM’s VisualAge for Java, Borland’s JBuilder, and more. Numerous 3rd party tools and open source-code products are available.
Microsoft has always been a strong tools vendor, and that has not changed. As part of its launch of .NET, Microsoft released a beta version of the Visual Studio.NET integrated development environment. Visual Studio.NET supports all languages supported by earlier releases of Visual Studio - with the notable exception of Java. In its place, the IDE supports C#, Microsoft’s new object-oriented programming language, which bears a remarkable resemblance to Java. Visual Studio.NET has some interesting productivity features including Web Forms, a web-based version of Win Forms, .NET’s GUI component set. Visual Studio.NET enables developers to take advantage of .NET’s support for cross-language inheritance.
Our conclusion is that Microsoft has the clear win when it comes to tools. While the functionality of the toolset provided by J2EE community as a whole supercedes the functionality of the tools provided by Microsoft, these tools are not 100% interoperable, because they do not originate from a single vendor. Much more low-level hacking is required to achieve business goals when working with a mixed toolkit, and no single tool is the clear choice, nor does any single tool compare with what Microsoft offers in Visual Studio.NET. Microsoft's single-vendor integration, the ease-of-use, and the super-cool wizards are awesome to have when building web services.
Shared Context
A key element of smart web services is shared context. To understand shared context, think about how many usernames, passwords, credit card information, and so-on that you need to remember and re-type in every time you visit a web site. The vision for shared context is that you type this information in once, and that information is then accessible to all web services that you choose to give access to that information. The information is under your control, rather than the control of the web services, and is protected using security rules that you define.
The Sun J2EE vision for shared context is a decentralized, distributed suite of shared context services that live on the Internet. Each user might have a list of one or more of their preferred shared context services, with each repository storing select information about that user. You would point the web service to your preferred shared context service when you connect.
Today, developers are empowered to create shared context services by writing a servlet that exposes itself as a web service using JAXP, and by using JDBC to access a relational storage.
In the future, Sun J2EE will include standards to access shared context services. This will enable the context repositories to act as web services using a standard interface, empowering other web services to connect with and tap into the shared context service in standard ways.
By way of comparison, Microsoft.NET achieves shared context via the Passport.NET service. Passport.NET is a repository hosted by Microsoft that contains user identity information. It is the cornerstone to Microsoft's Hailstorm services, which is their vision for creating user-centric web services experiences.
In conclusion, we have found that both Sun J2EE and Microsoft.NET support shared context, and each have their own advantages and drawbacks. The noticeable difference is that the Sun J2EE approach of a shared context standard will spawn a marketplace of shared context repositories on the Internet, whereas the Microsoft.NET solution is a single shared context repository approach.
The advantages of the Sun J2EE approach are:
o Each shared context repository can be specialized for different needs. For example, there could be medical repositories that store medical history information, or financial repositories that store credit card and banking information. It is unlikely that a single repository approach such as Passport.NET would be specialized enough to cover all the bases of shared context information that the industry demands when smart web services become widely used.
o There is no 'big brother' effect. Businesses and individuals do not need to trust their data to any individual firm. Local shared context repositories can be created within a trusted few partners in a business web, which means data can be contained.
o We believe the J2EE solution will will scale to handle the needs of the masses. The needs of the many better then Passport.NET. Shared context is a more important phenomenon than any one organization.
o There is no single point of failure.
o There is no control being enforced by a single organization. Can you envision a time when AOL agrees to use Passport? Or when VISA, MasterCard, or American Express agree to let Microsoft control their customers’ information? It is difficult to imagine just one vendor-controlled identity service succeeding for all.
The advantages of the Microsoft.NET approach are:
o There is no question of what is the 'official' shared context repository. There is one place to find identity information. This is a very important point. J2EE runs the risk of a fragmented shared context repositories, eliminating the usefulness of such systems, unless care is used.
o Passport is an established and active system.
o Until Sun J2EE standardizes on a schema and API for accessing web services that are shared context services, we do not predict any real usage of J2EE-based shared context services.
Given that almost no web services use shared context yet, it is too early to tell which approach is the best. Fortunately most organizations are barely getting up to speed with the basics of web services, and shared context is in the distance. For most organizations, this debate is likely to be important when choosing J2EE or .NET.
System Cost
A wide variety of implementations based on J2EE architecture are available for purchase, with price points varying dramatically, enabling a corporation to choose the platform that meets its budget and desired service level. Costs are typically in the single-digit thousands of dollars per processor, although there are higher-end implementations and lower-end ones. At the time of this writing, Microsoft had not released pricing information for the .NET platform.
As far as hardware, J2EE supports UNIX and Mainframe systems, while both J2EE and .NET support the Win32 platform, which is generally the less expensive alternative. There is a level playing field for hardware costs, and the hardware cost debate becomes a moot point.
The takeaway point is that you can get low-cost solutions with both Microsoft and J2EE architecture. Microsoft's solution has an aggressive price, whereas J2EE architecture allows you choose your service level. For example, with J2EE you can have a high-end, expensive solution (iPlanet running on Sun Solaris in an E-10000 server), or a low-end, inexpensive solution (jBoss running on Linux on a Cobalt RAQ server). There's also an assortment of free and/or open source tools and services that support Java and XML. It should be noted that you pay for what you get, and most organizations will not go for this low-end solution, but rather will embrace a midrange solution as a happy medium.
If you are trying to make heads or tails out of the price wars, we recommend that you consider this: the price of the platform is always a drop in the bucket compared to the total cost of the project. This is defined as the price of the server platform, the cost to train developers, the cost to build and evolve a solution on that platform, the cost to maintain the solution, and any business opportunity costs from picking the 'wrong' platform.
We hope that firms realize that the total cost of ownership of a project dwarfs any short-term cost differences between underlying platforms. We recommend you do not consider the price of the platform when selecting between J2EE, .NET, or any other platform, but rather consider the more important other factors.
Performance
A platform performs if it yields an acceptable response time under a specified user load. The definition of what is 'acceptable' changes for each business problem. To achieve acceptable performance, it is important that the underlying web services infrastructure empowers you to build high-performing systems.
The primary bottleneck when building web services is usually integration with back-end database systems. The reason for this is that most enterprise applications are data-driven systems with much more data logic than business logic. Given that the database is usually the bottleneck, any possible tactics for reducing database load will result in a significant wins.
J2EE reduces database traffic through two tactics:
Stateful business processes allow you to maintain business process state in memory, rather than writing that state out to the database on each request.
Long-term caching(provided by some implementations) allow for database data to be cached for long periods of time, rather than re-reading database data upon each request.
It should be noted that both maintaining business state in-memory and caching must be used with caution, and may result in problems if developers are not properly trained on when to (and when not to) use these features. This is a fundamental difference between the J2EE and .NET approaches to building web services: J2EE's advantage is that it gives programmers more control over lower-level services such as state management and caching. Well-educated developers can tap into these features to improve the quality of their deployment. But it is of vital importance that developers are properly educated on when to make these tradeoff decisions, or error may be introduced into systems.
By way of comparison, Microsoft.NET does not offer these tactics for improving performance. There are no opportunities for performance wins, but at the same time, there are no opportunities for developers to introduce errors into systems.
When trying to choose between whether these features are important for your organization, consider the quality of your developers. If they are well-educated and do not require much hand-holding, then they will likely find the flexibility and performance gains from a J2EE system as valuable. If your developers require more hand-holding, then the Microsoft approach is clearly superior.
Scalability
Scalability is essential when growing a web services deployment over time, because one can never predict how new business goals might impact user traffic.
A platform is scalable if an increase in hardware resources results in a corresponding linear increase in supported user load while maintaining the same response time. By this definition, the underlying hardware (Win32, UNIX, or Mainframe) is irrelevant when it comes to scalability, because both J2EE and .NET allow one to add additional machines to increase user load while maintaining the same response time. The major implementations based on J2EE architecture, as well as .NET, provide load-balancing technology that enable a cluster of machines to collaborate and service user load that scales over time.
The significant difference between J2EE and .NET scalability is that since .NET supports Win32 only, a greater number of machines are needed than a comparable J2EE deployment due to processor limitations. This multitude of machines may be difficult for organizations to maintain.
VI. Conclusions
The J2EE verses .NET battle will be the soap opera of the decade for geeks to watch. But there are promises and realities about both platforms. For example, J2EE is a rather brilliant move on the vendors' part, but should not be seen as an altruistic initiative. All vendors that participate in J2EE are after financial gains, as well as an effective weapon against Microsoft. J2EE enables these vendors to collaborate together and stand ground. Many of these vendors have undergone recent mergers and acquisitions themselves, and so organizations must exercise good judgment when choosing such a platform.
As far as Microsoft.NET, that is far from an altruistic initiative. It is a monopolistic initiative dressed in altruism. Microsoft has been claiming that .NET is about open and interoperable web services, when in reality Microsoft is already making their web services closed and proprietary. Microsoft will likely increase the costs of their solutions if a monopoly can be achieved, and innovation will be slowed down significantly.
So what's a company like yours to do? Both platforms are useful, and both can lead you to the same destination. Which platform is right for you? When deciding, we recommend you concentrate on the larger business issues. Think about your existing developer skillsets, your existing systems, your existing vendor relationships, and your customers. Those almost always drive the decision, not the minor features.
Arguments supporting both platforms
o Regardless of which platform you pick, new developers will need to be trained (Java training for J2EE, OO training for .NET)
o You can build web services today using both platforms
o Both platforms offer a low system cost, such as jBoss/Linux/Cobalt for J2EE, or Windows/Win32 hardware for .NET.
o Both platforms offer a single-vendor solu
|
