The Mind Electric is pleased to announce the availability of GLUE 4.0, the latest release of its popular web services platform.
GLUE 4.0 seamlessly integrates the Java technologies - Servlets, JSPs, EJBs, and web services into a single, fast, easy-to-use package.

GLUE can be used standalone or within any J2EE container, minimizing the incremental expense for enterprises already using application servers.

GLUE standard is free for most commercial uses.

GLUE 4.0 professional includes these additional features: (Pricing begins at $2000 per runtime license and $1000 per developer seat)

Performance: four different optimizations work together to shrink payload size and boost throughput.
WS-Security: SOAP digital signatures and XML digital encryption support
Real-time Management Console: Unique flash-based management console
IDE Plugins: includes IDE plug-ins for Eclipse, JBuilder and IDEA
Remote Deployment: upload and enable web services on the fly with remote deployment tools
Web Service Instrumentation: all web services are automatically instrumented, providing real-time usage and performance statistics
EJB Integration: exposes any EJB automatically as a web service with no additional coding
Reliable/Async Messaging Over JMS: leverages any existing JMS implementation to send reliable, asynchronous SOAP messages
LDAP Authentication via JAAS: allows users to authenticate web service invocation using existing enterprise security systems
WS-Routing: supports arbitrary routing of SOAP messages through intermediaries
DIME for Bulk Data Transfer with .NET: allows users to transfer bulk data efficiently to/from .NET using DIME. Streams data from a source to its destination without the content ever being copied into memory
Unlimited Capacity UDDI Server: uses a transactional XML data store for ease of installation and high performance
Virtual Services: provide hooks that allow users to easily intercept and process either Java-style or SOAP-style invocations

Here are some useful links:

GLUE home page: http://www.themindelectric.com/glue/index.html

Download area: http://www.themindelectric.net/download

TME interest group: http://groups.yahoo.com/group/MindElectricTechnology

Glue 4 final is not available on the site.

Our marketing people actually jumped the gun a little bit!! :-) GLUE 4.0 GA will be available soon, but has not yet be released.

Harris Reynolds
The Mind Electric

Is it going to fully implement JAX-RPC???

GLUE 4.0 has preview support for JAX-RPC, but we have not licensed the TCK so the implementation is not *official*.

Let me ask a quick question though? Are you interesting in JAX-RPC on the client side? If so consider this example....

In GLUE you get a proxy to an Inteface with one line of code. Following an example from Sun's Web Services Tutorial [1], you could get a proxy to a HelloIF interface with this:

HelloIF myProxy = (HelloIF)Registry.bind( "http://addressOfWSDLHere.wsdl", HelloIF.class )

Then invoke it as a local inteface... myProxy.sayHello( "Buzz" ).

With JAX-RPC you need several lines of code....the example below is cut/pasted from [1].

String UrlString = "http://localhost:8080/ProxyHelloWorld.wsdl";
String nameSpaceUri = "http://proxy.org/wsdl";
String serviceName = "HelloWorld";
String portName = "HelloIFPort";
URL helloWsdlUrl = new URL(UrlString);
ServiceFactory serviceFactory = ServiceFactory.newInstance();
Service helloService = serviceFactory.createService(helloWsdlUrl,
                new QName(nameSpaceUri, serviceName));
HelloIF myProxy = (HelloIF) helloService.getPort(new QName(nameSpaceUri, portName), proxy.HelloIF.class);

Even if the Strings were injected directly into the method calls, JAX-RPC requires more lines of code and is more complicated. I'm not interested in bashing Sun, but as far as ease of use... which is easier? It gets even more complicated when deploying services to the server....of course not of this is rocket science, but at the same time we think it should be as easy for the developer as possible.

hope that helps,

~harris

[1] http://java.sun.com/webservices/docs/1.1/tutorial/doc/index.html

In fact we are interested in both sides (the most important side being the server side; the client side is only an example for our customers).

We are developing some web services (Java implementation class and remote interface + configuration files for JWSDP and Axis). We currently have an ant script that has two tasks (among others) to build and deploy the web services to tomcat either with Axis or JWSDP. Same thing with the client (but here the client classes are not exactly the same for Axis and JWSDP due to some differences in generated classes that we haven't had time to look at yet).

We haven't decide yet what is going to go into production, but the idea is to keep or options open. We want to add more implementations to our ant script as long as we don't modify the java classes and interfaces (just keep adding configuration files and ant taks). We want to be able to switch from one implementation to another by just choosing a different ant task. Things are changing very fast this days and we are still a good 4 moths away of release.

We haven't tryed GLUE yet, but your marketing people have done a good job: it's in our radar and we have heard it's fast. I thing my boss can leave with the price of the product if it realy outperforms badly free products, but the JAX-RPC check ranks high in her list of requirements. I think it buys her peace of mind.

Angel,

Give GLUE a try and let me know what you think. Also.... feel free to shoot me an email directly if you have any questions.

~harris

harris@themindelectric.com

Well, a WSDL can have many Web Services in it and each service can have
multiple ports. JAX-RPC apis let you pick the right service and port.
Hence, JAX-RPC API is not as simple as Registery.bind().

JAX-RPC supports static generated clients, which looks like:

  HelloService service = new HelloServiceImpl();
  HelloIF myProxy = service.getHelloIF();
  myProxy.sayHello();

I think, the above code is as simple as bind().

Regards,
manoj

After JavaSoft introduced Dynamic proxy generation in JDK1.3,
the remote call invocation in Java separated into two ways.

One is static proxy generation through special compilers like rmic
and another one is generating proxy dynamically using Java Dynamic Proxy API.

GLUE uses Dynamic proxy API and hence looks lot simpler even without
static generation of "Stub" and "Skeleton"