sorted by: recent | see : popular

Content Tagged with License:ASF2.0 + Java

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

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.

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.

Spring is a Java/J2EE application framework that assembles components via configuration files. Spring is an open source project but is developed by engineers with Interface 21, and Spring Framework is a trademark of Interface 21. Spring is supported by a number of companies including Interface21 and SourceLabs, and is covered in SourceLabs Self-support Suite for Linux and Open Source Java

Spring’s core technical selling point has been the Inversion of Control design idea, where programming is focused on interfaces rather than classes. Spring’s design comes from the book Expert One-on-One J2EE Design and Development by Rod Johnson.

Mission

Spring’s mission statement as articulated by Interface21 includes these points:

1. J2EE should be easier
2. Interfaces > Classes
3. JavaBeans are good for configuration
4. OOP > implementation technology (J2EE)
5. Testability is important and should be easier
6. Frameworks shouldn’t force recoverable exception catching

And these direct points about Spring

1. Spring should be a pleasure to use
2. Spring APIs should not be a dependency
3. Spring should not compete with good existing solutions like JDO and Hibernate.

External Links

• Spring tutorial
• Spring FAQs
• Introduction to Spring Web Flow
• Spring – iBatis integration tutorial
• Spring 1.1 locations of jar files in Spring that potentially cause classpath problems

From Rod Johnson

• Original introduction to Spring
• Video presentation of Spring

Reviews of Spring

• A Spring Jump Start
• On the MVC model of Spring
• Spring: creating objects so you don’t have to
• 5 Things I Love About Spring

Critiques of Spring

• a critique of spring, and the abuse of the spring framework
• I don’t get spring

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.

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);

software for the the geonames.org project.

More information needed! Please edit and add information about geonames

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

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

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.

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.

Messages is a open source framework to make internationalization easier for Java applications. It supports locales for threads and bundles can be associated with different packages. This allows the usage of different bundles for different parts of the application like plugins, installer or logging.

Bundles can be managed and associated with packages without any changes in the code. This makes bundle management and refactoring much easier than with other solutions. Messages supports global locales for client applications written in Swing or SWT and thread local ones for serverside web applications.

Usage

An example on using Messages:

import static api.cintoo.messages.Messages.*;

public class MessagesExample { 
  public static void main(String[] args) { 
    Messages.setLocale(new Locale(”en”, “”)); // set the Locale 
    Messages.setBundle(”messages”); // set the bundle file to use 
    System.out.println( $(”helloWorld”)); 
  } 
} 

Store a file called Messages.properties in your classpath

#messages.properties 
helloWorld=Hello World! 

Running the program should print “Hello World!”.

Apache Portals is a collaborative software development project dedicated to providing robust, full-featured, commercial-quality, and freely available Portal related software on a wide variety of platforms and programming languages.

This project is managed in cooperation with various individuals worldwide (both independent and company-affiliated experts), who use the Internet to communicate, plan, and develop Portal software and related documentation.

EasyConf is a java library to access configuration of software components and applications.

EasyConf defines simple conventions to make it easier to use and was born in a portlets-based portal and has several features useful for this and similar environments.

EasyConf is based on known and respected open source libraries such as Commons Configuration, Digester, Xstream, etc.

Cayenne is a free object-relational persistence framework written in Java. Its goal is to make development of database Java applications faster and more consistent with the Object Oriented Programming concept.

Tuscany is a SOA runtime framework based on the SCA specifications, with implementations in Java and C++ .

Sequoia (formerly known as the Clustered JDBC project) provides high availability and performance scalability for databases. It provides transparent database clustering (partitioning, replication, etc.)

AjaxAnywhere is designed to turn any set of existing JSP components into Ajax aware components without complex JavaScript coding.