License:ASF2.0 on SWiK

Introducing Inject4Spring library

Sun, 08 Jun 2008 04:04:09 -0700

In this blog entry I introduce small library that extends base functionality of Spring framework by allowing specifying references between in beans using "opposite" direction of them comparing to standard Spring approach.

What I’ve tried to solve

Several days ago I’ve blogged about necessity and possibilities of specifying dependencies in Spring context using "opposite" direction of references.

In just two words, if we have, say, two beans defined within context, and first bean refers to other bean, that reference should be described within bean context configuration XML directly as part of referring bean definition. This is casual and "natural" Spring way of defining dependencies between beans.

However, for some types of applications that approach does not work. The major drawback of it is as follows: during definition of referring bean it’s assumed that the name of bean to which it refers is known.

Unfortunately, for applications that are built using plugin architecture, that assumption becomes serious limitation, since it does not allow to create really extensible application without necessity of Spring context modification – of course, that does not corresponds to overall idea of plugins at all. And that’s even more sad if we’ll consider functionality that is already included into Spring – like creation of application context from several files that could be resolved dynamically (say, via direct list of their locations or via wildcards withing classpath).

Therefore, to obtain truly extensible applications, we need to have ability to "extend" existing content of Spring context.

From that point of view, the application may include, for example, one or more Spring configuration files with beans that represents "extension points" and, several dynamically loaded modules of plugins which may include beans that may be plugged into that extension points.

The following picture illustrates this concept:

What should be considered as extension point there? Well, the answer is pretty simple there – just properties of some beans. We have named bean, we have named property – so we could address the point where we could inject our reference pretty precise.

Of course, in extending context we need to know names of beans and properties to which we may inject beans from extending contexts. However, this issues is completely different to original approach of Spring – in such case, beans in "core" context represents a kind of dynamic API (pretty funny, but I suppose that such and context definition may be considered as API without API), and at the moment of defining beans in "core" context we are completely not aware how ones will be customized later (or even probably by third-party plugin developer).

Ok, now that we have extension points, the only thing we need to make the entire concept of such injection live is just an ability to specify that beans should be wired outside of referencing bean definition.

In other words, here we need to have some mechanism which will said Spring that beans should be wired not in "core" context, but directly in "extending" one.

The following picture illustrates difference between "normal" and "opposite" directions of references:

Now we are almost ready to move further. The only thing that we need to consider at the moment is types of references. Spring provides several standard ways to specify references between beans:

using ordinary reference;
using list of beans;
using map of beans;
using set of beans.

And, of course, there is ability to specify value of particular property. If we’ll look on these ways of defining relations between beans it will be clear that it’s quite possible to use opposite direction of injection to support them.

Inject4Spring overview

Well, that was background for tasks which are solved by Inject4Spring library. It’s a small (about 35k in jar) library which I wrote about year ago to have support of such "opposite" directions of specifying references between beans. At the moment, we’ve used it in several projects developed in SoftAMIS. Inject4Spring is released under Apache License, so it could be used both in open source and commercial applications.

In general, while it could be used for Spring 1.x, primarily it’s targeted to Spring 2.x, since it heavy relies on custom namespaces functionality introduced in Spring 2.0. Actually, from the usage point of view, all functionality of that library is exposed via set of custom XML tags that belongs to "inject" namespace.

Here is brief overview of possible types of dependencies in Spring and custom tags included into Inject4Spring that corresponds them:

License and download

Inject4Spring is released under Apache License, so it could be used both in open source and commercial applications. At the moment, you may to download it directly from our site, but probably later I’ll move it as project on SourceForge or something like that.

At the moment it’s quite stable and we’ve used it during last year for several projects. However, if you’ll have some comments, issues, requests for improvements – please do not hesitate contacting me

The Inject4Spring library was developed in SoftAMIS, a Ukraine based software development company specialized on Java and Web development outsourcing services. To find more about SoftAMIS, our services, skills and experience, please visit our site –

http://www.soft-amis.com

The home page of Inject4Spring is currently located here

cluster4spring

Mon, 11 Jun 2007 05:14:46 -0700

Clustered Remoting for Spring Framework (Cluster4Spring) represents an alternative implementation of the remoting subsystem of Spring framework and provides possibilities to build more stable and fault tolerant systems with dynamic discovering of remote services. Cluster4Spring uses Apache 2.0 license that allows using it both in commercial and non-commercial products.

Briefly, the major features of Cluster4Spring library are:

Support of one-to-one scheme of remoting (similar to one currently supported by Spring);

Support of one-to-many scheme of remoting, which assumes that one client selects remote service for invocation from one of predefined locations;

Support of one-to-many scheme of remoting with dynamic discovering of remote services;

Several built-in policies for selecting remote service for invocation are included (they are applied if service is available in several locations);
Built-in functionality for handling remoting exceptions of method invocations that provides ability to re-invoke remote service using different service location automatically;
Steep learning curve since ideological implementation of Cluster4Spring bears a close resemblance to the implementation of remoting in Spring;
Non-intrusive for existing applications – it is simply enough to change appropriate remoting-related Spring configuration files to start using Cluster4Spring;
Provides a convenient way to add custom interceptors both on client and server side;
Flexible and modular architecture which is ready for further extensions and customizations;
Library is stable and ready to use;

Another feature, which is currently missing in remoting subsystem offered by Spring framework, is lack of the ability to dynamically discover remote services.

The main purpose of Cluster4Spring is to extend remoting system of Spring framework and overcome limitations mentioned above.

The Cluster4Spring library was developed in SoftAMIS, a Ukraine based software development company specialized on Java and Web development outsourcing services. To find more about SoftAMIS, our services, skills and experience, please visit our site –

http://www.soft-amis.com

The home page of Cluster4Spring is located here

ActiveMQ

Fri, 03 Jun 2005 18:29:18 -0700

ActiveMQ is a Message Broker and JMS 1.1 provider.

It supports:

clustering
peer networks
discovery
TCP
SSL
multicast
persistence
XA

In addition, it integrates seamlessly into J2EE 1.4 containers, light weight containers and any Java application.

ActiveMQ is included in SourceLabs Self-Support for Open Source Java offering.

Other message brokers

ActiveMQ competes with Microsoft Biztalk, Oracle Message Broker, Websphere Message Broker, and other proprietary message brokers.

ActiveMQ is the highest profile of the open source message brokers, and the most liberally licensed.

Proteus – proteus is an alternative message broker and framework that is licensed under the gpl.

Information on the latest (5.0) release

gdata-objectivec-client

Mon, 16 Apr 2007 13:55:11 -0700

gdata-objectivec-client or The Google Data Objective-C Client Library provides an OSX framework and development library to access data via Google Data APIs.

batik

Mon, 11 Jul 2005 12:11:31 -0700

Batik is a Java-based toolkit for applications that want to use images in the Scalable Vector Graphics (SVG) format for various purposes, such as viewing, generation, or manipulation.

License:Apache

Mon, 26 Feb 2007 14:03:46 -0800

The Apache License is an open source license from The Apache Foundation. The most common form of this license is the Apache Software Foundation License 2.0.

Apache.Org

Tue, 16 May 2006 06:50:31 -0700

The Apache Software Foundation or ASF is a non-profit that hosts a number of open source projects. Apache projects are licensed under the namesake Apache License, and development is managed by small groups of active project contributors. Apache gets its name from its founding project, the Apache WebServer that is also its most popular project.

Apache projects have a lifecycle in which new projects are added to a project incubator, when development goals are met and the project takes off it may be added to the roster of other active Apache projects.

The organization itself serves as a legal overhead for Apache contributors, dealing with licensing and trademark issues, as well as providing services and holding events for the general apache community.

External Links

About the Apache foundation

OpenJPA

Mon, 24 Jul 2006 05:31:01 -0700

Open JPA will be an ASL-licensed implementation of the Java Persistence API (JPA) which is defined as part of JSR-220. Open JPA is a derivative of the basis of the BEA WebLogic Server (WLS) EJB3 JPA implementation, and so is an important piece of the BEA code base.

GenericRCP

Sun, 03 Dec 2006 01:51:57 -0800

GenericRCP is a client based on SpringRCP automatic generic gui generation. It uses a hibernate domain model (with .hbm.xml-file or annotations).

please expand this project description.

cglib

Tue, 21 Nov 2006 14:53:16 -0800

cglib is a set of utility classes that can be used to generate and load Java classes at runtime.

SourceLabs includes CGLib in its Self Support for Linux and Open Source Java offering.

Raven

Tue, 14 Nov 2006 21:07:50 -0800

Raven is a build tool for Java applications written in Ruby.

December 2007 article on Raven.

MenuPilot

Fri, 17 Nov 2006 01:29:50 -0800

Fine DHTML context menu with layout of Action Lists/Smart Tags (known from Visual Studio 2005). hi

EasyStub

Thu, 09 Nov 2006 16:38:05 -0800

EasyStub is a framework for making stubs. When you find most of time you are using a mock framework to create an object that always returns the same value, and you did not care about the interactions, what you need is actually a stub.

Examples:

to create stub:

MyInterface stub = createStub(MyInterface.class);

to return value:

make(stub.hello()).returning(‘hello’);

to throw exception:

make(stub.hello()).throwing(expectedException);

to throw exception for method without return value:

stub.nothing();
willThrow(expectedException);

Java based virtual file system for ZIP, TAR and derivatives

Sun, 29 Oct 2006 07:58:53 -0800

TrueZIP is a Java based Virtual File System (VFS) which enables client applications to access ZIP, TAR and derivative archive types transparently as if they were just directories in a file’s path name.

Spline.NET

Thu, 19 Oct 2006 11:59:23 -0700

Spline.NET is a simple and flexible .NET object – relational mapping system built on top of ADO.NET. It is simpler than Ibatis.NET or NHibernate and allows full access to the ADO.NET APIs, rather than replacing them. Spline uses attributes to minimize the amount of boilerplate code needed to populate or save a domain object from a data source.

Spline.NET also leverages attributes to obtain all configuration information (such as connection strings or other externalized settings). This feature in and of itself is extremely useful in and outside the scope of Spline.NET. It can be thought of as a very lightweight “inversion of control” feature, where properties can loaded from an external settings file without ever having to manually set the value of each property.

Spline also includes a small set of utility libraries to do simple tasks such as password hashing/generation and stream handling.

geonames

Sat, 07 Oct 2006 05:00:33 -0700

software for the the geonames.org project.

More information needed! Please edit and add information about geonames

Roma Framework

Fri, 22 Sep 2006 07:44:18 -0700

ROMA is a project that attempts to glue the best of Java tools and frameworks together. ROMA seeks to avoid reinventing the wheel or building a new web framework, but rather package existing Java tools together in a convenient way for a developer.

Roma takes POJOs and creates persistence, presentation, monitoring and reporting around them. In this sense it is a similar project to Rails, which also does little more than glue existing projects togther in a careful and structed way to try and create a better development environment.

FlowPlayer

Sun, 17 Sep 2006 11:50:05 -0700

FlowPlayer is a video player for Flash Video files in the FLV format. You can easily embed it into HTML pages.

Spring-Dashboard

Fri, 15 Sep 2006 10:59:00 -0700

Spring-dashboard provides a real-time statistics and flow monitoring view of any spring-framework web application.

Status

Release 1.0 contains a framework for gathering statistical runtime information on a Spring Web application, a configurable dashboard view with a default AJAX implementation, and an example application that demonstrates Spring-Dashboard’s basic abilities.

dmLite

Thu, 14 Sep 2006 13:01:32 -0700

Modelibra (former dmLite) is a domain model framework for rapid application development. A domain model may be designed, generated, and validated as a web application. Modelibra uses the Wicket web framework for generic web components that are views of model concepts. The generic web components may be mixed with specific web components to develop a professional Wicket application.

Lucene.Net

Mon, 21 Aug 2006 20:14:25 -0700

A powerful search engine for .NET applications. Port of Jakarta Lucene.

Lucene.Net (formerly DotLucene) is the fastest open-source search engine for .NET

Lucene.Net is a source code, class-per-class, API-per-API and algorithmatic port of the Java Lucene search engine to the C# and .NET platform utilizing Microsoft .NET Framework.

PHP Standards based logging

Tue, 01 Aug 2006 14:58:16 -0700

Log4php is a PHP port of Log4j, the most popular Java logging framework. It supports configuration through XML and properties files (with the same structure as log4j) and custom Configurators.

SPARQL4J

Thu, 27 Jul 2006 07:50:35 -0700

SPARQL4J aims to deliver a JDBC driver by the time W3C working group (DAWG) finishes the SPARQL specification.

TurtleMock

Mon, 17 Jul 2006 00:29:24 -0700

An easy to use and understand mock framework for unit testing, makes testing using mock objects less painful.

Different from jmock and easy mock, it uses a “log pattern” to keep setup-do-assert order in your testcase, which makes testcases using mock less confusing. It also puts fewer constraints on the default invocation verify, making testcases smaller, more focused on describing a single behavior, and less fragile…

The point is “only test what you want to test”.

More info

Mock Object Frameworks Comparison

Apache-Axiom

Tue, 18 Jul 2006 14:32:23 -0700

Apache Axiom is the XML object model used by Apache Axis. It features a streaming XML API based on STaX.

Simflet

Sat, 08 Jul 2006 12:06:37 -0700

Simflet is an MVC framework for JSR-168 portlet development that brings the MVC design model to building complex portlets.

ROMA

Sat, 27 May 2006 18:39:58 -0700

ROMA is a web application framework for building Ajax powered web applications from simple POJOs.

ROMA is based on an Object Oriented MVC architecture, encouraging the Domain Driven development model. The use of POJOs as the basic programming elements allows ROMA applications to be portable across Java frameworks.

ROMA utilizes inversion of control through the Spring Framework IoC container, other IoC containers such as Picocontainer may be used as well.

Aranea framework

Thu, 25 May 2006 16:24:30 -0700

Aranea is a hierarchical Model-View-Controller Web framework that provides a common, simple approach to building Web application components, reusing custom or general GUI logic, and extending the framework.

The framework enforces programming using object oriented techniques with POJOs and provides a JSP tag library that facilitates the programming of Web GUIs without writing HTML.

Seekafile - Open-Source Indexing Server

Sun, 21 May 2006 08:31:28 -0700

Seekafile Server is a Windows Service that indexes DOC, PDF, XLS, PPT, RTF, HTML, TXT, XML, and other file formats on the background.

Using DotLucene, Seekafile offers search over indexed files.

Rhino in Spring

Wed, 17 May 2006 11:02:04 -0700

Rhino in Spring is a project that integrates the Java JavaScript interpreter from Mozilla with the Spring Framework.

This allows for javascript server development on a lightweight framework.