J2EE Vs NET MV

Comparing J2EE with
.NET
- ACCU 2002 -
Markus Voelter, CTO, MATHEMA AG
voelter@acm.org
http://www.voelter.de
Slides (mostly  ) by
Michael Stal, Senior Principal Engineer
SIEMENS AG, Dept. CT SE 2
E-Mail:
mailto:Michael.Stal@mchp.siemens.de
Goal
 This is intended to be an objective

comparisons of the two platforms
 It will contain criteria to base a

decision which platform to use
 Interoperability issues
Markus Voelter/Michael Stal – Comparing J2EE with .NET

Folie 2
Agenda
 Motivation
 Comparison
• Visions: Sun ONE and .NET
• Layer-by-Layer comparison of the
infrastructures
 Summary
 Literature

Folie 3
Web Frameworks
Core elements of Web Frameworks

Web Service User/Provider
Mainframe Micro/Macro Services
Frontend
Integration
Backend Server Virtual Machine Layer
Layer
(Web Server)
Legacy Workflow Engine
Core Services (Calendar, Preferences, Transactions, ...)

Service Context (Who, Where, When, Why, ....)
Service Description (WSDL)
Service Description, Discovery, Integration (UDDI)
Web-based and -related Protocols (HTTP, SMTP, ...)
Clients
Folie 4
.NET – The Microsoft
Way of Life
.NET Foundation Services (Hailstorm)
Passport, Calendar, Directory & Search, Notification & Messaging,
Personalization, Web-Store/XML, Dynamic Delivery of Software and Services
.NET Framework & Tools
ASP.NET Windows Forms

(Web Services, Web Forms, (Controls, Drawing,
ASP.NET Application Windows
Services) Application Services)
Base Classes
(ADO.NET, XML, Threading, IO, ....)
Common Language Runtime
(Memory Management, Common Type System, Lifecycle Monitor)
.NET Servers
SQL Server, Biztalk, Commerce, Exchange, Mobile Information,
Host Integration, Application Center
.NET Devices
Markus Voelter/Michael Stal – Comparing
TabletPC, PocketPC, ....J2EE with .NET
Folie 5
Sun ONE (Open Net
Environment)
Service Creation and Assembly
(JB, JSP, EJB)
Web Services
Smart Process Smart Policy
(ebXML, XAML) (LDAP, Kerberos, PKI,
OASIS Security))
Service
Service
Integration
Process Container
(SQL, JDBC, XML,
(J2EE, EJB, JSP, Service Interface
XSLT, XP, JMS, Management
J2SE, J2ME,
RMI, J2EE Connectors,
MIDP, Java Card)
...)
Smart Delivery
(XML, HTML, XHTML,
Smart Management WML, VoiceXML,
(SNMP, CIM, WBEM, JMX) Service Platform XSLT, HTTP, SSL,
XP, SOAP, WSDL,
UDDI, ebXML, ...)

Folie 6
Layer-By-Layer
Comparison

Folie 7
Hello World Example
 In C# and Java:
using System;
namespace MyNameSpace {
public class MyClass {
public static void Main(String [] args) {
Console.WriteLine(„Hello, C#!“);
}
}
}
package MyPackage;
public class MyClass {

public static void main(String [] args) {
System.out.println(„Hello, Java!“);
}
}

Folie 8
Layers
 Runtime System
 Object model
 Base classes
- Reflection,
 Enterprise
- Component model
- Database access
- XML
- Server Pages
- Remoting
- Web Services
- More Enterprise APIs
Folie 9
The Runtime System

Folie 10
.NET Runtime
 It is called the Common Language Runtime (CLR)
 It is intended for any language compiled to the
MSIL
 Provides integration for several languages
 Provides support for non-OO languages (e.g. tail
recursion)
C#
Compiler
VB.NET
MSIL + Loader/
Metadata JIT
Verifier
C++
Garbage
Collection, Managed
Perl Security, Execution
Multithreading,
Code
...

Folie 11
Java Virtual Machine
 The JVM is intended for Java and interprets Java Byte
Code.
 Other languages can be compiled to Java bytecode,
however (e.g. Ada)
 Just-in-Time compilers exist for different
environments and OSs
Compiler
Java CLASS- Classloader/

Files Verifier JIT
Garbage
Collection, Interpreter
Security Manager
Call-in+Call-out,
Multithreading, Native
...
Hotspot Code
Folie 12
Commonalities and
Differences
 Commonalities:
• Basic concepts are similar
 Differences:
• Java is intended for interpretation (e.g. type-
dependent primitives i_add, ...)
• Java allows for custom class loaders and
security managers
• .NET CLR provides a command set that also
supports functional languages

Folie 13
The Object Model

Folie 14
Object Model (.NET)
 In .NET, everything is an object

Types
Value Types Reference Types

Pointers Interfaces
System Value User Value
Types Types Self-describing
Types
Enumerations
Classes Arrays
Delegates Boxed Values
User-Defined

Folie 15
System.Object
 The „mother of all .NET classes“

public class Object {
public virtual int GetHashCode();
public virtual bool Equals();
public virtual String ToString();
public static bool Equals(object a, object b);
public static bool ReferenceEquals(object a,
object b);
public Type GetType();
protected object MemberWiseClone();
protected virtual Finalize()´;
}

Folie 16
Object Model (.NET)
 .NET distinguishes between values
types and reference types:
• value types reside on the stack
• reference types reside on the heap
 In C#, there is no difference
between primitive types and
classes
• Automatic boxing/unboxing provides
transparency
 Special strongly-typed function
references
• called delegates
Folie 17
Object Model (Java)
 Java has primitive types and

classes.
• No automatic boxing/unboxing
Types
Primitive Types Reference Types
Arrays Interfaces
Classes

Folie 18
java.lang.Object
 The „Mother of all Java classes“

public class Object {
public Object();
public boolean equals(Object obj);
public final Class getClass();
public int hashCode();
public final void notify();
public final void notifyAll();
public String toString();
public final void wait() throws InterruptedException;
public final void wait(long timeout) throws
InterruptedException;
public final void wait(long timeout, int nanos)
throws InterruptedException;
protected Object clone() throws CloneNotSupportedException;
protected void finalize() throws Throwable;
}
Folie 19
Object Model (Java)
 Primitive types cannot be

transparently used as an object.
Special Holder classes are
necessary.
Integer i_ref = new Integer(7);
List l = ...
l.add( i_ref );
 There are no special function

references. Java uses Observer
Pattern with callback interfaces and
inner classes
Folie 20
.NET-Types that are not
available in Java
 Delegates & Events:
class MyClass {
...
public void somebodyTurnedOnTheLight( int which ) {
...
}
}
class AnotherClass {
...
public delegate void LightTurnedOn(int which);
public event LightTurnedOn OnLightTurnedOn;
...
OnLightTurnedOn+= new
LightTurnedOn(MyClass.somebodyTurnedOnTheLight);
}

Folie 21
.NET-Types that are not
available in Java cont‘d
 Enumerations (value type):
enum Color : byte { RED = 1, BLUE = 2, GREEN = 3 };
 Jagged and unjagged Arrays:

int [2][] a; a[0] = new int[]{1}; a[1] = new int[]{1,2};
int [,] a = new int[2,2];
 Structs (value types):

• Structs are implicitly sealed
• they do not support inheritance
public struct Name {
public String First;
public String Last;
}
Folie 22
Commonalities and
Differences
 Commonalities:
• Interfaces are „completely abstract classes“
• Support single inheritance for classes
(implementation inheritance) and multiple interface
inheritance
• Default-Initialization of Variables
• Namespace-Concept (Java-Package and .NET-
Namespace)
• Similar visibility attributes (public, private, ...)
• Future: Generic types in .NET and Java (Generics)
• Class Constructors (static initializer in Java)
 Differences
• In .NET there is no difference between primitive types
and classes.
• Multiple languages support in .NET
• In Java all methods are implicitly virtual. In .NET this
has to be made explicit virtual, override, new).
• Java maps packages to directories. .NET doesn‘t.
Folie 23
Metainformation
 Java and .NET provide a reflection

API
• to load and instantiate classes
• and inspect classes (introspection).
 In addition, .NET allows to annotate

many aspects of a system (classes,
members, operations) with so-
called Attributes

Folie 24
.NET Examples
 Using an Atttribute
[AuthorIs(„Michael“)]
class MyClass { ... }
• There are several predefined attributes
(WebService, WebMethod, ...)
 Defining an Attribute
[AttributeUsage(AttributeTargets.All)]
public class AuthorIsAttribute : Attribute {
private string m_Name;
public AuthorIsAttribute(string name) { m_Name = name;}
}

Folie 25
.NET Examples cont‘d
 Accessing and using Type

information
using System;
using System.Reflection;
namespace ComponentClient {
class Client {
static void Main(string[] args) {
Assembly a = Assembly.LoadFrom("Component.dll");
Type [] allTypes = a.GetTypes();
Type t = allTypes[0];
object o = Activator.CreateInstance(t);
MethodInfo mi = t.GetMethod("algorithm");
double d = (double) mi.Invoke(o, new object[]{21.0});
}
}
}

Folie 26
Java Example
 Accessing and using Type

information:
• Note that packages are not the same as
import assemblies!!
java.lang.reflect.*;
try {
Class c = Class.forName(„MyPrintComponent“);
Object o = c.newInstance();
Method m = c.getMethod(„print“, new Class[]{ String.class });
m.invoke(o, new Object[]{„Hallo, Java!“});
}
catch (Exception e) {
// handle it here
}

Folie 27
Commonalities and
Differences
 Commonalities:
• Very similar APIs
 Differences:
• .NET allows additional, user-defined meta
information with attributes
• Java Reflection is sometimes a bit more
clumsy (because of primitive types and
classes)
• .NET allows to actually create new artifacts
at runtime and instantiate them or store
them in assemblies.

Folie 28
Statements
 Both platforms support basically

the same statements
 Differences:
• switch-Statement allows Strings, but no
fallthrough:
string name = address.name;
switch (name) {
case “Maier”: Console.WriteLine(“Nice to meet you, Hans!”);
break;
case “Mueller”,
case “Huber”: Console.WriteLine(“You owe me some money!”);
break;
default: Console.WriteLine(“I don’t know you”);
break;
}
Folie 29
Statements (cont‘d)
 Differences:
• Iterators in .NET:
foreach (Elem i in MyContainer) { Console.WriteLine(i); }
...
class MyContainer : IEnumerable, IEnumerator {
public IEnumerator GetEnumerator() {
return (IEnumerator)this;
}
public void Reset() { ... }
public bool MoveNext() { ... }
public object Current { get { ... } }
}
• Note that these are still no „internal

iterators“ as in Smalltalk, for example!
Folie 30
 Differences:
• Iterators in Java:
for (Iterator i = MyContainer.iterator(); i.hasNext();)
doSomething(i.next());
...
class MyContainer implements Iterator {
public boolean hasNext() {…}
public Object next() {...}
public void remove() {...}
public Iterator iterator() { return this; }
}

Folie 31
 Differences:
• Properties in .NET, where Java uses Coding
conventions
Class MyClass { ...
public double x {
set { if (x < 0)
throw new ArgumentException (“< 0”);
m_x = value;
}
get { return m_x; }
} ...
// User:
MyClass m = new MyClass(); m.x = 22;
Folie 32
 Differences:
• .NET supports Indexers, Java does not.
object[17] = 22;
// In class:
Int [] m_a;
public double this[int pos] {
get { return m_a[pos]; }
set { m_a[pos] = value; }
}
• Indexers also work with non-integer keys,

such as strings
Folie 33
 Differences:
• .NET supports operator overloading!
public static Point operator+(Point op1, Point op2) {

return new Point(op1.x+op2.x,op1.y+op2.y);
}
...
Point p = new Point(1,2) + new Point(2,3);

Folie 34
 Differences:
• .NET allows pass-by-reference of method
arguments
class Test {
public void Print(int i) { Console.WriteLine(i); }
public void Inc(ref int i) { i++; }
public int SetInitial(out int i) { i = 42; }
...
}
Test t = ...; int i;

t.SetInitial(out i);
t.Inc(ref i);
t.Print();

Folie 35
 Exceptions in Java
• Exceptions have to be declared in the throws-clause
public int insert(int i) throws OverLimitException;

{ … }
 Exceptions in .NET
• Exceptions are not declared
// only way to tell you about

// OverLimitException thrown below
public int insert(int i) { … }

Folie 36
Important Base Classes
No big conceptual differences here.
.NET Java
GUI Windows.Forms SWING, AWT
Web.Forms
Kommunikation System.Net: Java.net: Sockets, URL,
Connection, ...
HttpWebRequest, ...
Container System.Collections: java.util: Lists, Maps,

ArrayList, BitArray, Sets, Trees, Vectors
Maps, Queue, List,
Stack

Folie 37
Multithreading

Folie 38
Multithreading in .NET
 .NET uses delegates for

multithreading
• The „ThreadStart“ in the example below
 There are monitors for
synchronization
class GlobalData {
int m_Value;
• The “lock” in the example below
public int Value { set { lock(this) { m_Value = value; } } }
}
class Worker {
GlobalData m_Global;
public Worker(GlobalData global) {m_Global = global; }
public void loop() { m_global.Value = 42; Thread.Sleep(100); }
}
// somewhere else:
GlobalData g = new GlobalData();
Thread tMarkus
= new Thread(new
Voelter/Michael Stal ThreadStart(new Worker().loop));
– Comparing J2EE with .NET
t.Start(); t.Join();
Folie 39 1
Multithreading in Java
 In Java there is also a class

„Thread“
 For synchronization there is the
synchronized keyword
class GlobalData {
int m_Value;
public synchronized int setValue { return m_Value; }
}
class Worker implements Runnable {
GlobalData m_Global;
public Worker(GlobalData global) { m_Global = global; }
public void run() { m_Global.setValue(42); Thread.sleep(100); }
}
// somewhere else:
GlobalData g = new GlobalData();
Thread tMarkus
= new Thread(new
Voelter/Michael Stal Worker());
t.start(); t.join();
Folie 40 1
Commonalities and
Differences
 Commonalities:
• Threading is very similar!
• Both use some forms of monitor for
synchronization
 Differences:
• In Java, synchronization is better integrated
into the Java language
• Java provides better synchronization and
thread communication (wait, notify, ...).

Folie 41
Deployment

Folie 42
Assemblies in .NET
 Assembly=Set of Types
name Sharedname Files Types
version Hash Manifest Referenced

Assemblies Security
Custom Product
Attributes Information
Type 1
IL-Code Metadata
Type 2
IL-Code Module 1
Type 3
IL-Code
Resources
Folie 43
Assemblies in .NET
 Private Assemblies are typically

only useful by the owning
application
 Shared Assemblies are stored in a
common cache and can be used by
several applications.
• They are signed by a key
• They are versioned!!
 Runtime uses Application Domains
as an abstraction for (potentially
remote) processes.
Folie 44
Java JAR files
 .jar files are similar to .NET‘s

assemblies
• They can be shared or private
• They can be signed
 They contain
• types
• resources
• optionally, metadata in manifest files.
 There is no versioning!
Folie 45
Commonalities and
Differences
 Commonalities:
• Assemblies and JAR files provide
„deployment“ components
 Differences:
• Much better versioning support in .NET
(side-by-side execution)

Folie 46
Component Models

Folie 47
Server-Side Components
in .NET
 Now Component is used like in
EJB/COM+
 To use container-provided services

like synchronisation or transactions
COM+ services can be used
 COM+-Interop provides these

features.

Folie 48
Java Component Models
 Client Components and Server

Components
 JavaBeans are Client Components
• normal Java classes following some
conventions
• optionally providing metainformation
public
(BeanInfo class)
class MyJavaBean {
private int color;
public void setColor(int v) { color = v; }
public int getColor() { return color; }
// a lot of more ...
}
// BeanInfo class notStalshown

Markus Voelter/Michael here!
Folie 49
Server Components in Java
 Enterprise JavaBeans (EJBs) always

reside in a Container that provides
technical aspects (sep. of concerns)
JNDI Naming
Deployment
Service
Descriptor
1) lookup home
EJB
EJB
2) create bean Context EJB
Home
2”) find bean Jar
Remote Bean
Home Interface
new
4
Client
EnterpriseBean
ejbCreate Bean
EJB ejb...
4) remove Instance
Object
3) Use bean Remote Bean bean-methods
Interface

Folie 50 EJB Run-time
Application Server (Container)
Server Components in Java
cont‘d
 4 Types of Beans
• Stateless Session-Beans (Service
Components)
• Stateful Session Beans (Session
Components)
• Entity-Beans (Entity Components)
• Message-Driven Beans (asynch. Service
Components)
 A bean is (theoretically) portable

across containers (Application
Servers)
Markus Voelter/Michaelfrom different
Stal – Comparing J2EE with .NET vendors.
Folie 51
Commonalities and
Differences
 Commonalities:
• Server Components are available
(Assemblies + COM+, EJB).
• Interop with legacy components in .NET
using COM+, in Java using CORBA)
 Differences:
• EJB are a more mature and proven model
• Special APIs to connect to legacy systems
(Java Connector API)

Folie 52
Database Access in .NET
 In .NET there is ADO.NET

• “connectionless” Client
DataSet
Command DataSetCommand DataReader
Connection Managed Provider
Data Source
Folie 53
.NET-Beispiel
using System;
using System.Data;
using System.Data.SqlClient;
string myConnection =
“server=myserver;uid=sa;pwd=;database=StockTickerDB”;
string myCommand = “SELECT * from StockTable”;
SqlDataSetCommand datasetCommand = new
SqlDataSetCommand(myCommand, myConnection);
DataSet myDataSet = new DataSet();
datasetCommand.FillDataSet(myDataSet, “StockTable”);
DataTable myTable =ds.Tables[“StockTable”];
foreach (DataRow row in myTable.Rows) {
Console.WriteLine(“Value of {0} is {1}”,
row[“LongName”], row[“Value”]);
}

Folie 54
ADO.NET
 ADO.NET is XML based (XML

Infoset)
• DataSet dynamically builds an XML schema
inside to store the data
• Relational data and XML data can be
handled in a similar way!!
 ADO.NET works offline once the
data is fetched
• Updating is partly automatic using DataSets
 Currently there are two Managed
Providers:
• SQL Server
• ADO
Folie 55
Database Access in Java
 Java provides JDBC to access

relational data
Application
Statement
Prepared
Resultset Connection Driver Manager
Statement
Callable JDBC/
Statement ODBC Bridge
ODBC Driver
ODBC
DB
Folie 56
Java Example
import java.sql.*;
// without error handling:
Class.forName(„sun.jdbc.odbc.JdbcOdbcDriver“);
Connection
con=DriverManager.getConnection(„jdbc:odbc:stocks,““,““);
Statement stmt = con.CreateStatement();
ResultSet rs = stmt.executeQuery(„SELECT * from stocks“);
while (rs.next()) {
System.out.println(rs.getString(„COMPANYNAME“));
}
rs.close();
stmt.close();
con.close();

Folie 57
Database Access in Java
 There are several other APIs:

• Embedded SQL in the form of SQLJ (uses
JDBC internally)
• Proprietary ODBMS APIs
• Standardized JDO API to provide (more or
less transparent) persistence for Java
Objects
• XML is handled differently!
• Java Connector API provides access to other
„connection oriented“ legacy systems (such
as SAP R3)

Folie 58
Commonalities and
Differences
 Commonalities:
• Decoupling of the concrete data model and
the user (using DataSets and ResultSets)
 Differences:
• ADO.NET uses XML extensively, JDBC has a
more relational flavor
• JDBC is connection oriented, ADO.NET
always works non-connected, or offline
• .NET DataSets are a kind of In-Memory-
Database-Cache.

Folie 59
XML

Folie 60
XML and .NET
 .NET is very XML-centric

• Web Services (SOAP)
• Configuration Files
• Result sets of a database access (ADO.NET)
• XML processing itself
 Note that formally, many .NET

features are based on the XML
infoset („XML semantics“) and do
not necessarily require megabytes
of text data!!
Folie 61
XML and .NET cont‘d
 The System.Xml Namespace provides

a whole lot of classes
• DOM processing using XmlNode & Sons
• XPath and XslTransform
• XmlTextReader und XmlTextWriter similar
to SAX in that they are both stream-based,
but .NET uses a Pull-Model

Folie 62
XML und Java
 There are several standards and tools
available
• DOM, SAX
• Xerces/Xalan, JDOM
• JAX{M,B,R,RPC}
• Castor
 However, Java‘s libraries have not been
designed with XML as a basis (Java‘s too old
)
 JAXP (Java API for XML Parsing) supports
DOM and SAX.
 Currently under development
• JAXM (Java API for XML Messaging)
• JAXB (Java API for XML Data Binding)
• JAXR (Java API for XML Registries)
• JAX/RPC
Folie 63 (Java API for XML based RPC)
Remoting
Somebody knows
a nice picture
here?

Folie 64
Remoting in .NET
Application Domain A Application Domain B
Client Servant
Transparent Proxy
Object Context Sinks
Real Proxy
Server Context Sinks
Envoy Sinks
Channels Channels
Network
Formatters Formatters

Folie 65
Remoting in .NET
(cont‘d)
 .NET Remoting provides pluggable
transports and formatters
• currently TCP and HTTP transport and
• binary and SOAP formatters
 Contexts are automatically
propagated (very neat feature!!)
 Only very simple lifecycle
management options for servants
(compared to EJB or CORBA)
• Singleton (one object for all calls)
• SingleCall (new instance for each call)
• Client-Activated based on leases
Folie 66
Remoting in .NET
(cont‘d)
 Objects can be marshalled by value
(Serializable)
 Asynchronous invocations are easily

possible without touching the
servant

Folie 67
Remoting in Java
 Several possibilities: RMI/CORBA

• RMI can use JRMP or IIOP as a transport
protocol
• Not pluggable – changes in the code are
necessary
Client Server
Stub Stub/Skeleton-Layer Skeleton
Remote Reference Manager
Transport Layer

Folie 68
Commonalities and
Differences
 Commonalities:
• Relatively easy to use
 Unterschiede:
• .NET Remoting can be extended more
flexibly
• Java provides Interop with CORBA
• Asynchronous invocations are not easily
possible with Java

Folie 69
Web

Folie 70
ASP.NET
(Server-Side Scripting)
 ASP.NET Architecture:
Other
(1) get a.apx IIS 5 (2) process .NET Assemblies
Client Web Assembly
(4) HTTP file Server
.NET
(3) result Engine
Database

Folie 71
ASP.NET Example
 A simple login
screen:

Folie 72
ASP.NET Example
(cont‘d)
<%@ Page language="c#" Codebehind="WebForm1.aspx.cs"
AutoEventWireup="false" Inherits="LoginPage.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<body>
<form id="Form1" method="post" runat="server">
<asp:Label id="TitleLabel" runat="server">Please specify your name and
password</asp:Label> <br>
<asp:Label id="LoginLabel" runat="server">Login</asp:Label> <br>
<asp:TextBox id="LoginText" runat="server"></asp:TextBox>
<asp:RequiredFieldValidator id="RequiredFieldValidator" runat="server"
ErrorMessage="You need to specify your name"
ControlToValidate="LoginText"></asp:RequiredFieldValidator> <br>
<asp:Label id="PasswordLabel" runat="server">Password</asp:Label> <br>
<asp:TextBox id="PasswordText" runat="server"
TextMode="Password"></asp:TextBox> <br>
<asp:Button id="EnterButton" runat="server" Text="Open the entrance"
ToolTip="Press this after you have specified login and
password"></asp:Button> <br>
<asp:Label id="MessageText" runat="server"></asp:Label>
</form>
</body> Markus Voelter/Michael Stal – Comparing J2EE with .NET
</HTML> Folie 73
ASP.NET Example
(cont‘d)
// lot of details omitted
namespace LoginPage {
public class WebForm1 : System.Web.UI.Page {
protected TextBox PasswordText, LoginText;
protected Button EnterButton;
protected Label MessageLabel;
private void InitializeComponent() {
this.EnterButton.Click +=
new System.EventHandler(this.EnterButton_Click);
this.Load += new System.EventHandler(this.Page_Load);
}
private void EnterButton_Click(object sender, System.EventArgs e) {
if (!(LoginText.Text.Equals("aladdin") &&
PasswordText.Text.Equals("sesam"))) {
MessageLabel.Text = " Wrong name or password!";
}
else {
Session["user"] = "aladdin";
Response.Redirect("UserArea.aspx");
}
}
} Markus Voelter/Michael Stal – Comparing J2EE with .NET
} Folie 74
Java Server Pages and
Servlets
 Java also allows for server-side
scripting
• JSPs are based on Servlets Other
(1) get a.jsp (2) process Components
Web JSP
Client
Server
(5) HTTP file
(3) gen. Servlet Servlet
Impl.
(4) result
Servlet
Database
JVM

Folie 75
Java Example

Folie 76
Java Example
 Bean und JSP-Seite:

// Datei MyPerson.java
package MyPackage;
import java.lang.*;
public class MyPerson {

public String getFirstName() { return "Michael"; }
public String getLastName() { return "Stal"; }
}
// Datei MyTest.jsp:
<HTML> <BODY>
<jsp:useBean id="person" scope="session"
class="MyPackage.MyPerson"/>
Your name is: <br>
<jsp:getProperty name="person" property="firstName"/> <br>
<jsp:getProperty name="person"
Markus Voelter/Michael Stal – Comparingproperty="lastName"/>
J2EE with .NET
</BODY> Folie
</HTML>
77
Commonalities and
Differences
 Commonalities:
• Pages are precompiled to accelerate access
• Similar syntax and concepts
• ASP.NET provides „GUI components“ using
Webcontrols, Java provides Taglibs.
 Differences:
• All .NET languages can be used for ASP.NET
scripting
• Servlets/JSP are available for a wide range of
webservers
• Many open source implementations,
frameworks and tools for Java

Folie 78
Web Services in .NET
 .NET provides a very comfortable

and well-integrated way to build
them:
namespace WebService1 {
public class Service1 : System.Web.Services.WebService {
// lot of stuff omitted
[WebMethod]
public double DM_to_Euro(double value) {
return value / 1.95583;
}
[WebMethod]
public double Euro_to_DM(double value) {
return value * 1.95583;
}
}
}
Folie 79
Web Services in .NET
(forts.)
 Using it is also simple
• Some steps have been ommitted
localhost.Service1 s1 = new localhost.Service1();
double result = s1.Euro_to_DM(200);
 Webservices are „just a special way

of remoting“
 BUT:
• Microsoft does not provide ebXML
compliance
• Currently they can only be used with MS
server
Folie 80
Web Services in Java
 Sun ONE will provide a Web Service API
for Java, completely ebXML compliant
 Currently there are many proprietary
solutions
• Some specific SOAP toolkits:
- Apache SOAP
- IBM Web Services Toolkit
- GLUE
• Some integrated with the major application servers
- Silverstream
- IONA
- Weblogic
- ...
 Sun works at standard APIs
• JAXM
Folie 81
Commonalities and
Differences
 Commonalities:
• Both.NET and Java try to be standards-
compliant (SOAP, WSDL, UDDI).
• Handling very similar: WSDLbased
generators that create proxies
 Differences:
• For Java there are different solutions,
whereas .NET provides only one, natively
• Currently, standards are interpreted
differently, so Interop Java-.NET is only
limited. But this will hopefully change!!

Folie 82
More Enterprise APIs

Folie 83
Enterprise APIs
 Naming:
• JNDI in Java (as an interface to
CORBANaming, LDAP, ...)
• Active Directory in .NET (Windows-specific)
 Message-orientierte Middleware:
• JMS in Java
• JAXM is on the horizon (XML based
messaging)
• .NET can use MSMQ, and remoting can be
used asynchronously

Folie 84
Legacy-Integration
 In .NET using the Microsoft Host

Integration Server.
 In Java using the Connector API
 Comparison: Java provides a much

simpler way. Connectors can be
implemented relatively straight
forward.

Folie 85
Interoperability
 Java provides access to C/C++ using

JNI (Java Native Interface).
Relatively complex call-in, call-out.
 .NET provides PInvoke:

class PInvokeTest {
[DllImport("user32.dll")]
static extern int MessageBoxA(int hWnd, string m, string c, int t);
static void Main(string[] args) {
MessageBoxA(0, "Hello DLL", "My Window", 0);
}
}

Folie 86
Interoperability cont‘d
 In .NET there is a way to interop

with COM+ and COM+ Services.
 Java provides CORBA interop
 JMS provides integration with MoMs
 In .NET, the interop between .NET
languages is almost perfect and
easy
• Use the same assemblies, class libraries…
• Languages had to be adapted a little bit
(e.g. Managed C++ does not provide
multiple inheritance)
Folie 87
Mobile and Embedded

Folie 88
Profiles and devices
 There are the following variants of

Java
• J2SE (Java 2 Platform Standard Edition)
• J2EE (Java 2 Platform Enterprise Edition)
• J2ME (Java 2 Platform Micro Edition)
- Configurations,
- and Profiles
• JavaCard

Folie 89
cont‘d
 .NET Universe
• .NET: Framework for Standard und Enterprise
• .NET Compact Framework for Windows CE (and other
embedded OS)
- Design Goals:
> Resource saving
> Adaptability regarding device properties
> Compatibility with the standard IDEs
> Easy integration
> Seamless connectivity
- No ASP.NET, Reflection.Emit,
Optimized JIT
- Depending on machine stack
- Simplified versioning and security, but
similar formats
Folie 90
cont‘d
 .NET Mobile Web SDK
• Abstraction for the developer
• Several markup languages (WML, HTML, ...)
• Configurable and extendible
• ASP.NET can be used
• Emulators for devices are available for
testing and debugging purposes
• Extends ASP.NET with special controls

Folie 91
Selecting one of the two

Folie 92
.NET and/or Java ?
 .NET is a product, Java and J2EE is a
specification
 Both adress the web (among other things)
 For „real big systems“ J2EE is better
suited
 The rule-of-thumb „Java is platform-

independent,´.NET is language
independent“ must be considered
carefully:
• ECMA works on the standardization of C# and parts
of .NET
• Other
Markus languages
Voelter/Michael can beJ2EE
Stal – Comparing compiled
with .NET to the JVM
Folie 93
.NET and/or Java ?
 .NET language independence is not for
free and not completely transparent
#pragma once
using namespace System; // .NET mit C++
namespace CPPBase {
public __gc class CPPBaseClass {
public: virtual System::String __gc* Echo(System::String __gc *s);
};
}
System::String __gc * CPPBase::CPPBaseClass::Echo(System::String __gc *s)
{ return s; }
 In a real project you might want to use

only one language
• But sometimes... 
Folie 94
.NET and/or Java ?
 Windows Applications are probably better
done with .NET than Java (maybe IBMs
SWT changes this ?)
 Java should be used when platform (or
vendor-) independence is necessary
 Java is more mature
 There will also be Java for .NET (Rational)
• But syntax is not the issue!
 Both can be used for web services - .NET
is „nicer“, J2EE is more scalable
 Analysts proclaim a fifty/fifty situation for

Java and .NET
Folie 95
Management Summary -
1
.NET Java
Controller/Owner Microsoft Sun + JCP-Partner
Status Product Line Specification and many

implementations
Languages C#, C++, Eiffel#, VB, .... Java + possibly others
Communication .NET Remoting, MSMQ, RMI/CORBA, JMS, Web

middleware (RPC, Web Services (no ebXML) Services (standard
Messaging, Web) compliant)
Server Components COM+ Enterprise JavaBeans
XML-Support Consistent Currently not yet

completely integrated
Server Pages ASP.NET JSP/Servlets

Folie 96
Management Summary -
2
.NET Java
Database access ADO.NET (ADO) JDBC / SQLJ and others
Base libraries Many many classes on Many many classes on

System.* java.*
GUI-Libs Windows.Forms Swing/AWT

Web.Forms
Runtime .NET CLR Java JVM
Interop (call-in/call-out) PInvoke JNI
InteropMiddleware COM/COM+ (COM CORBA, JMS

Interop)
Legacy Integration Host Integration Server JCA
Folie 97
The End
Thank you very much!!

Folie 98

J2EE Vs NET MV

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

J2EE Vs NET MV

Uploaded by

Copyright:

Available Formats

Comparing J2EE with

 This is intended to be an objective

 It will contain criteria to base a

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Core elements of Web Frameworks

Core Services (Calendar, Preferences, Transactions, ...)

.NET Framework & Tools

ASP.NET Windows Forms

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

public class MyClass {

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Java CLASS- Classloader/

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 In .NET, everything is an object

Value Types Reference Types

Delegates Boxed Values

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 The „mother of all .NET classes“

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 Java has primitive types and

Primitive Types Reference Types

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 The „Mother of all Java classes“

 Primitive types cannot be

 There are no special function

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 Jagged and unjagged Arrays:

 Structs (value types):

 Java and .NET provide a reflection

 In addition, .NET allows to annotate

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 Accessing and using Type

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 Accessing and using Type

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 Both platforms support basically

• Note that these are still no „internal

Markus Voelter/Michael Stal – Comparing J2EE with .NET

• Indexers also work with non-integer keys,

public static Point operator+(Point op1, Point op2) {

Point p = new Point(1,2) + new Point(2,3);

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Test t = ...; int i;

Markus Voelter/Michael Stal – Comparing J2EE with .NET

public int insert(int i) throws OverLimitException;

// only way to tell you about

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Container System.Collections: java.util: Lists, Maps,

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

 .NET uses delegates for

 In Java there is also a class

Markus Voelter/Michael Stal – Comparing J2EE with .NET

Markus Voelter/Michael Stal – Comparing J2EE with .NET

version Hash Manifest Referenced

 Private Assemblies are typically