Year: 2003

VC++.NET – The Glue To Integrate .NET and Java

Have you ever had the need for Java/.NET Integration ?
Although the main approach is web services interop, sometimes it’s necessary to do some lower level integration.
For example if you have a neat java library for instance for logging purposes which is tightly integrated in your application.

Why not use it within your .NET application as well ?

With VC++.NET and Java Native Interface (JNI) it’s not that complicated.
Just load the Java VM into the .NET process and call the Java methods with the help of unmanaged C++.

Below you can see an example of how to call the method

boolean MyLogger.log(String name)

which resides in C:\temp\mylogger.jar and is part of the package net.pleus. The class uses log4j.


#include “jni.h” // included in the jdk, link to jvm.lib as well

// configure Java VM
JavaVMOption options[3];
options[0].optionString = “-Djava.compiler=NONE”;
options[1].optionString = “-Djava.class.path=C:\\temp\\mylogger.jar;C:\\temp\\log4j.jar”;
options[2].optionString = “-verbose:jni”;

JavaVMInitArgs vm_args;

vm_args.version = JNI_VERSION_1_4;
vm_args.options = options;
vm_args.nOptions = 3;
vm_args.ignoreUnrecognized = JNI_FALSE;

// load Java VM
JavaVM* jvm;
JNIEnv* env;
JNI_CreateJavaVM(&jvm,(void **)&env, &vm_args);

// find class and method
jclass cls = env->FindClass(“net/pleus/MyLogger”);
jmethodID mid = env->GetStaticMethodID(cls,”log”,”(Ljava/lang/String;)Z”);

// call method
jstring name = env->NewStringUTF(“my message”);
bool res = env->CallStaticObjectMethod(cls,mid,name);

// cleanup
jvm->DestroyJavaVM();

The technology stack could be as follows:

Managed Code (C#, VB.NET) -> Hybrid C++.NET and JNI -> Java

I tried it out. It works very well (and fast).
The most difficult thing is to perform the type conversions and code the cumbersome signature descriptions.
The other way round (call .NET from Java) is also possible though it’s a little bit trickier.

Best Regards From ADO.NET

IBM and BEA announced the the new Service Data Object Specification (SDO).
It promises to simplify and unify several Java data access methods.
Most important it introduces support for disconnected data access scenarios.
Therewith it follows the same design principle as ADO.NET.

Below is a comparsion of the main classes (.NET – Java):

DataSet – DataGraph
DataTable – DataObject
DataAdapter – DataMediatorService

It seems that IBM/BEA favours an object centric approach whereas .NET uses a relational approach.
Interesting to see how .NET affects the J2EE development.

On the whole it’s great, as in the past nearly every enterprise level project created it’s own solution to cope with disconnected data structures.

Who Is Defining The Standards ?

In the past the picture was clear.
On one hand there were “open” standards like the J2SE/J2EE maintained via the Java Community Process(JCP) and hosted by Sun Microsystems.
Other vendors participated and helped the standards evolve.
On the other hand were de facto standards, mainly set by Microsoft, for instance MFC or the .NET technology stack.

Currently the picture is changing.
In my perception the pace in the Java world has become slower. How long did it take to finish for instance the EJB2.1 specification ?
In the meantime Microsoft inceased their effort to elaborate their technologies.

Beside that new boards like WS-I to were founded to help establish the WS-* standards. If you have a look at the specifications you will notice that the key players are IBM, Microsoft and BEA.
In addition to that BEA and IBM work closely together to write Java Joint Specifications.

Quote from the announcement:
“In response to requests from customers and joint Independent Software Vendor (ISV) partners, BEA and IBM are collaborating on specifications for programming models and APIs for Java(tm) 2 Enterprise Edition (J2EE) application servers that provide programmers with simpler and more powerful ways of building portable server applications.”
Why not submitting proposals to the JCP first ?

Many of the upcoming standards are mainly driven by IBM, Microsoft and BEA.
In my opinion the benefit is, that it’s no more everyone against Microsoft but everyone for innovation.

New Article About C++ Templates in VS.NET

The german dotnetpro magazine published my latest article about the new C++ template features in VS.NET.
With the 2003 release C++.NET achieved nearly 100% standards conformance.
This might be interesting news for the virtual machine vendors, because certainly they won’t write their VM’s from scratch for every new operating system. This can be achieved for instance by using ANSI C++.

The Browser is Dying ?!

What are the strengths of browser based applications ?

Sophisticated user interfaces ? No ! (slow server roundtrips)
Easy development ? No ! (a lot of scripts)
Offline capability ? No !

Easy deployment ? Yes !

The most important feature of browser based applications is the easy deployment.
You just have to update the server to update your clients as well.
But everything is based on the HTTP which is relatively simple and not suitable to support rich clients.

Sure there is Java Webstart and .NET Zero Touch Deployment which enables you to type something like


http://ww.pleus.net/MyRichClient.jnlp

or

http://ww.pleus.net/MyRichClient.exe

in your browser to start your managed application.

By using this approach it’s possible to enable rich user experience and user server based deployment.

But that’s not all…

During this years PDC Microsoft announced their next model for the development of user interfaces called Avalon.
This technology is based on XAML (XML Application Markup Language). This enables us to develop rich clients in a declarative way like HTML.
The following snippet is an example of how to write the HelloWorld application with XAML:


<TextPanel xmlns=”http://schemas.microsoft.com/2003/xaml” Background=”BlanchedAlmond” FontFamily=”Comic sans MS” FontSize=”36pt” HorizontalAlignment=”Center”>
Hello, world!
</TextPanel>

This document can be distributed over HTTP. The client uses it to create a UI which runs into the browser or standalone.
This is only a new version of HTML, you might say.
But in contrast to HTML it enables you to develop fully-fledged rich clients in a mostly declarative way.
That’s promising, I think.

Attributes – The New Macros ?

Do you remember the times when C++ was the mainstream programming language in enterprise level projects ?
A popular approach was to simplify the code by defining a lot of macros.
Even Microsoft did that very extensively in their MFC implementation for instance in their ubiquitous messagemaps.
The benefit was an easy progamming model – just add a few macros and be happy.
On the other hand it was very difficult to understand what really happened in the background.
This was especially true for user defined macros which could only be used in the context of a certain project.

Later languages like Java and C# took over and macros became history (C# has a preprocessor but no macros). The nightmare was over.
Todays software systems aren’t easier than in the past. Therefore the language engineers considered it to be a good idea to support some metainformation facility in form of attributed programming.

In .NET you have attributes.


[WebMethod]
public string HelloWorld()
{
return “Hello, .World!”;
}

Java introduces the Language metadata facility (JSR175) which is currently a community draft. This approach is based on javadoc comments.


/**
* @common:operation
*/
public String HelloWorld()
{
return “Hello, World!”;
}

Looks somehow similar, right ?

But it’s not.

In .NET the attributes are stored in the assemblies metadata and therefore can be accessed at runtime.
They can be determined by reflection as shown in the following example:


class Test
{
static void Main(string[] args)
{
Type t = typeof (Test);
MemberInfo[] members = t.GetMember(“DoIt”);
object[] attrs = members[0].GetCustomAttributes(false);
Console.WriteLine(attrs[0].ToString());
}

[Cool()]
public static void DoIt()
{
}

[AttributeUsage(AttributeTargets.All)]
public class CoolAttribute : Attribute
{
}
}

In Java they merely serve to generate code at compile time.
Java supports reflection as well. But due to the fact that the attributes are not stored in the metadata they can’t be determined by reflection at runtime.

What’s the conclusion ?

On one hand both approaches are very useful to simplify the programming model for the developer.

On the other hand they are like C++ macros. A developer can define his/her own attributes which nobody outside a project might know.
This leads to applications which are hard to maintain.
In order to create maintainable software systems I think developers should define their own attributes/annotations as little as possible.
This will ease the job especially for new team members which join a project at a later time.