The .NET Framework has been touted as the next big thing for the distributed
computing community. Redesigned from the bottom up, Microsoft’s newest offering
has made marked progress in areas such as
XML
integration, error handling, component processing, and reusable frameworks. The
promise for Web development is clear: faster development, less custom coding,
and increased stability.
But
what if your current application is currently a Java
EJB
implementation? Is it worth the cost and effort to migrate to Microsoft’s new
platform? While the benefits of .NET over Java EJB certainly will be debated for
years to come, the difficulties involved with such a platform port are a little
more predictable. Even assuming a compelling technical or business reason
driving the requirement, here are five good reasons not to migrate your Java or
J2EE applications to .NET.
1. CLR does not support
JavaThe first stumbling block on the road to .NET is its set of
supported languages. The .NET Framework relies on a Common
Language Runtime (CLR) that promises compatibility with multiple languages,
but this compatibility is limited currently to C#, C++, VB, and (soon to come)
J#. Not surprisingly, Java is not a supported language in the CLR.
It's
possible to migrate the Java application tier to .NET without rewriting the
application code in a CLR-supported language by using a Java COM bridge or
Web services.
Java COM, however, relies on third-party applications to create COM DLLs
directly from pure Java code. Difficulties in debugging the resultant binary, as
well as increased complexity in the environment, illuminates why such
heterogeneous application development should be approached with caution, or
avoided completely.
An alternative strategy is to port your Java code to
C# code. In theory, you can translate Java code directly into C# (and J#) code
through automated applications. For example,
ArtinSoft's Java
Language Conversion Assistant Enterprise Edition (JLCA EE) promises up to 99
percent automatic conversion from Java to C#. However, such products have yet to
prove themselves in the marketplace, and experience argues against believing in
automatic code conversions. Whether through an automated processor or done
manually, a language port will undoubtedly require associated architectural
changes. Depending on the implementation specifics of your application,
significant refactoring may be required when rewriting a Java application to VB,
C++, C#, or J#.
2. IIS does not support
JSPAs if an application language port from Java to C# is not daunting
enough, .NET will also require a presentation language port. JSP is not
supported by IIS. Moving from JSP to ASP.NET is a significant undertaking and
will demand a complete rewrite of the presentation layer. Additionally, major
architectural models, such as code reuse through tag libraries, are not
supported in
ASP.NET.
Tag libraries must be converted to server controls or server side includes
(ssi). Interestingly, Java classes written to support tag libraries conceptually
match .NET’s code-behind classes. Significant work, however, will be required
for the actual conversion.
3. Server controls
require redesignsAs mentioned, new architectural requirements will
undoubtedly surface during a language rewrite of your code base for .NET. This
will become immediately evident if the implementation of .NET server controls is
planned. ASP.NET
server controls are one of the biggest advantages offered by .NET. By
utilizing prebuilt server components, developers can reduce repetitive coding
and easily access functionality through objects. Taking advantage of server
controls during a migration to .NET will most likely entail removing custom
presentation, application, and database code and replacing it with a server
control and required database logic.
When upgrading from an existing
Microsoft application, this code extraction will not be difficult, especially if
good coding practices have resulted in cleanly partitioned and well-organized
code. However, when moving from a Java EJB application, server controls require
deep vertical migration and may simultaneously impact the data, application, and
presentation tiers of the application. Not only will the stored procedures, Java
objects, and JSP files require porting to Microsoft-supported standards, they
also will have to be modified to support the Server Control.
For example,
the DataGrid object provides complex table functionality to display a set of
data records. Row and column selection, header styles, and paging functionality
are just a few of the properties available for customization. The DataGrid
object is more functional and maintainable than any custom or proprietary code
base is likely to be. But to take advantage of this control during a port from a
Java application (assuming you're moving an Oracle data tier to
SQL
Server), it would require:
- Rewriting P/L SQL to Transact SQL while formatting the queries to support
the DataGrid.
- Rewriting the Java application code into a .NET-supported language to invoke
the SQL or stored procedures and to support the event model of the DataGrid.
- Rewriting the JSP templates to ASP.NET while removing the code supporting
the existing, custom data presentation objects.
4. No support for Container Managed
PersistenceAssuming that the existing Java application is supported
by a non-SQL Server database, migrating the application will most likely require
either porting the database over to SQL Server or integrating the proper drivers
to allow your .NET application to persist data through a non-SQL Server
database. In either case, you'll need to rewrite your JDBC connection classes to
ADO.NET and migrate your Java ResultSets to ADO.NET DataSets. This task in
itself is not overly difficult. DataSets and ResultSets are similar mechanisms
and beyond implementation specifics should not require significant
rearchitecture.
Migration difficulties will start to surface when the dev
team begins porting object persistence from Java to .NET. .NET has no support
for Container Managed Persistence (CMP) and no similar mechanism. If your
application relies on CMP for object persistence, you'll be forced to rewrite
these object classes with the embedded logic for data retrieval and loading.
5. Different session handling implementationThe EJB
standard does not specify the handling of session data, so EJB session-handling
implementation becomes completely application server specific. Since differences
in session-handling implementations can have a profound impact on performance,
scalability, and network design, you must understand the implementation details
of your application’s
session-handling
mechanisms.
In .NET, Microsoft introduces a distributed session model
that makes session data available over multiple application servers in a Web
farm by using
Microsoft
SQL Server to store the application state. Since .NET relies on embedded
functionality within SQL Server for sessioning, heterogeneous applications using
Oracle or other non-SQL Server databases will be required to implement a SQL
Server instance solely for distributed sessions. Additionally, since large
amounts of session data will reduce overall system performance, prudent use of
session storage is a necessity.
Uphill battle to
parityThe .NET Framework represents Microsoft’s latest effort to
function in the world of highly available, enterprise-level applications. Many
features long absent from previous versions of IIS, Visual Studio, VB, and SQL
Server are now available on the new platform. Microsoft developers and users can
start to feel parity with other industry competitors in realms of scalability,
extendibility, security, and performance.
Industry hype aside, the key
point is that .NET represents only parity with EJB solution providers—there is
no overriding indicator that the .NET platform is superior to WebSphere,
WebLogic, or any other EJB application server. For existing IIS/ASP solutions,
the benefits to migration are clear. For new initiatives, depending on staff
skills and organization orientation, .NET may be the framework of choice. But
for existing Java EJB applications, unless you want to fight an uphill battle to
parity, leave them right where they are.