jEmbedded Service Oriented Container (SOC)

Puzzle Arcade Lite v1.1 is now Live!

2011-02-05T01:01:00.000-06:00

Puzzle Arcade Lite v1.1 is now available at the App Store, or just looking for "Puzzle Arcade Lite" "Puzzle Arcade Lite" or "PuzzleArcade".

More information at the game's blog.

Puzzle Arcade Lite - Iphone & Itouch new game

2011-01-21T05:44:00.002-06:00

More information at the Game Blog.

Anatomy of a Service

2010-01-25T09:54:00.004-06:00

One of the reasons that I developed jEmbedded was my obsession with services :)

From 2002 onwards I haven´t stopped designing and developing using Services (and a DOM of course) to express and group the business logic of applications.

Make no mistake, we are working in Information Technology and that means that the core of our business is the information and how to store and manage it.

Of course, we have to sell that information and for that we need fancy screens, complex Ajax frameworks etc... and sometimes because of that we lose the perspective and spent a lot of time making that screens look great and forgetting about to organize and develop the business logic.

The business logic it´s where the real value of the company lies, not the UI. In fact, the business logic could stay forever meanwhile the UI changes (look at the banks for instance). Despite that fact, most of the Companies I worked in the past had their business logic buried into the code, with no organization or services whatsoever. That lead to the disaster as you may well know, when you need to change something, add more rules etc...

So Services and SOA comes to rescue, but what is a Service (I will talk about SOA in another post) ?.

A Service is just a piece of code that can be invoked by a client (being a client an application, a controller, a web service, another service etc..) that express some business logic grouped in a logical fashion.

The service acts as a facade for the client so only a few methods are exposed being each method the solution to a complete use case. For instance, a correct method would be

approveInvoice(invoice:Invoice):boolean

and a incorrect one would be

getCountryDescription():String.

It´s easy to see the advantages of doing this and I´m sure you are aware of them so I´m not going to explore this further.

There is many ways to develop a Service being the most common way to have an interface and a implementation for that interface. You can do this with jEmbedded of course but it provides more advanced and simpler ways to do it.

Simpler, because you don´t need to implement a interface (you still can do it if you really need it) or any other class just annotations.

Advanced, because you can create your services as an abstract class using composition (reusing other services through the @Compose annotation and linking its life cycle to the parent service) or injection (@Inject) and letting the SOC container implements the abstract methods.

So once you have figured out what part of your business logic you want to expose to the client you can decide which methods will you need and how you are going to implement then. The best way to implement that methods it´s to use other services that you already have using composition or injection to promote re usability.

So let´s say you want to implement a simple service that evaluates if a list of numbers are odd or not.

It´s obvious we only would need a method:

public List checkOddNumberRS (Object... numbers)

And now we can implement the skeleton of the service or if you are following TDD in a strict way the unit test (by the way, jEmbedded comes with a testing infrastructure for the core and for each service provided based on jUnit):

@AbstractAnnotatedService (id="evenOddService")

public abstract class EvenOddService {

public List checkOddNumbers (Object... numbers) {

return null;

}

That´s good but how can we implement it? We could do it using just a List and the formula (i%2==0) but we´ll use the RulesService that´s provided with jEmbedded showing how to use the composition:

@AbstractAnnotatedService (id="evenOddService")

public abstract class EvenOddService {

@Compose

@AnnotatedRulesService

public abstract RulesService getRulesService();

public List checkOddNumbers (Object... numbers) {

return (List )getRulesService().execute(numbers);

}

As you can see the composition is made through and abstract method that the container will implement. The only restriction is that the method must start with get. The method will be implemented at runtime so you can use it to implement the service methods.

All the services that you create using the jEmbedded container have a properties service that will help you to configure it using a properties file. You can parse attributes of the annotations or variables of the service. You can do that either using the attribute propertiesFile (from the annotations) or using the AnnotationsPropertiesService:

@Compose

@AnnotatedPropertiesService(propertiesFile="META-INF/evenodd/even-odd-service.properties")

public abstract PropertiesService getPropertiesService();

We need to use the properties service not the propertiesFile attribute as we need to configure the RuleService not the the service we are creating.

Learning RoadMap with jEmbedded 0.2

2010-01-15T07:21:00.002-06:00

Hi everybody,

I have added new examples and refactored the existing ones using the new features of the 0.2 version.

In order to learn how to use the framework here it's the roadmap you could follow:

- Start learning the hello world service example, it's easy to follow and it's explained in the wiki. You can learn how to create your custom annotations, etc...

- Then you can learn how to create other services using composition with the included services: jetty example, calculator service, even
odd example etc...

- Once you are comfortable creating services, composing etc you can learn how to organize the services in layers with the layers example.

- When you know how to create a layer you can learn how to use the container in a web environment (using the previous layer example).

- Then you can have a look at the ESB case study that comprises all the previous stuff, services, layers, web environment etc...

I will continue improving the documentation and adding examples, and please feel free to ask everything you need.

Keep in mind that you can create and annotate your services and elements in many ways, I've tried to show this in the examples. There is no just one right way, you can create your custom annotations or not, you can inject fields or methods etc.. depends on the particular case.

Take care

Adolfo

jEmbedded 0.2-RC1 Released

2010-01-15T07:12:00.002-06:00

Hi All,

I'm happy to announce that I've just released the 0.2 RC1 version of jEmbedded.

This version is almost a 1.0 version release as it contains most of the features that I had in mind when I started the project but well I have more stuff ready for next versions. In fact this time I pushed the actual design to the limit, so a new re design it's in place.

New features

- Services and components now can be created using annotations only
and just an abstract class (or a regular one).

* Service

@AnnotatedAbstractService, @Start, @Stop, @Compose, @Inject, ....

* Component

@AnnotatedAbstractComponent, @Init, @Dispose, @Inject ...

- Layers now can be created extending a @Repository or using the new @Layer annotation (no need to use a repository anymore to declare a layer). The layer will act as another service.

- A layer and a repository now has Spring as a external IoC provider
by default. Just add the @AnnotationSpringRepository to the
container.

- Services, components and beans annotations now has a new property: propertiesFile, by default it's META-INF/properties-service/properties- service.properties.

This means that now every element can have a different or the same properties file without needing to use the properties service. You can use still it and it will override the
defaults.

- @Inject and @Compose can be use without using the ref property if the element is declared in that field or method. You still need to use
the ref property if the referenced element is declared elsewhere.

- The extension (inherintance) of annotations has been improved.

- The proxies created (for services and components) now can be more controlled with the properties interfaces and proxyClass.

- All the services have been refactored to be abstract services (just an abstract class).

- I have added more examples creating and learning road map that I will explain in another post.

- The core has been refactored, improved and legacy code has been removed.

Hope you like it.

Take care

Adolfo

jembedded-0.1.3-Release

2009-12-21T22:52:00.001-06:00

Hi all,

I'm very pleased to announce that I've just released the
jEmbedded-0.1.3 version.

It's much more that a collections of fixes from the previous RC
versions as I have included some features that was intended for the
0.2 version (or higher), but it gives a good preview of the future
direction of the project. In fact I though to label this one as 0.2,
but I didn't for consistency.

There are 5 very important features included in this release:

- Annotation inheritance: Now you can extend any of the core
annotations (@AnnotatedService, @AbstractAnnotatedService...) to
create you own annotations. This means that you can set up your
services directly using annotations like if you were writing and xml
bean in Spring:

Until now you were doing this (still you can of course):

@AnnotatedService(id="service", resources={WebClient.class})
public class Service extends AbstractCMTService {

@Compose(ref="webClient")
private WebClient webClient;

@Inject (value=${service.url})
private String url;

}
}

Now you could do this:

public @interface CustomAnnotatedService {

Class inherits() default @AnnotatedService; // the annotation you
want to extend.

//now you override the attributes you'd like to use (this case from
the @AnnotatedService(id, lazy clazz, etc..),
// the ones that are not overriden will be taken from the parent.

String id() default "service";

String clazz() default "org.jsemantic.jembedded.Service";

Class[] resources() default {WebClient.class};

//new attributes
String url();

}

Now the service looks like this:

@CustomAnnotatedService(url="http://code.google.com/p/jembedded")
public class Service extends AbstractCMTService {

@Compose(ref="webClient")
private WebClient webClient;

@Inject (value=${service.url})
private String url;

}

Now you can reuse this new annotation whenever you like.

The inheritance mechanism can be used with the core annotations
(AnnotatedService, AbstractAnnotatedService, AnnotatedBean,
AnnotatedComponent..).

If you have a look at the source code or to the examples you will see
that I have refactored the code to use this feature when it fits.

- @AbstractAnnotatedService

This is a very and a powerful feature that also will give you an idea
of the future direction of the framework. Now you can create a Service
using an abstract class (similar to the @AbstractService) without
needing to extend or implement anything (not even the Service
interface). You can mix regular and abstract classes and injecting or
composing fields.

This is the old example of WebServer refactored to use the new
features (also custom and inheritance annotaions).

@AnnotatedWebServer
public abstract class WebServer {

@Start
public void start() {
getJettyService().start();
}

@Stop
public void stop() {
getJettyService().stop();
}

public void setPort(String port) {
getJettyService().setPort(port);
}

//Composition, WebServer will handle the jettyService lifeCycle
@Compose(ref="httpService")
public abstract JettyService getJettyService();

@Compose(ref = "propertiesService")
@PropertiesService(propertiesFile="META-INF/web-server/web-
server.properties")
public abstract
org.jsemantic.jirepository.core.services.properties.PropertiesService
getPropertiesService();
// end of service composition

//Added functionality, you can create dynamic invoking methods from
any service
//that you may have in the container
@ImplementedBy(ref="httpService", refMethodName="getServerContext")
public abstract ServletContext getServletContext();

}

If you read the code you would notice:

- The abstract methods are implemented in real time, so you can use
then in the regular implemented methods.

- There are 2 new annotations @Start and Stop that replaces the old
startService and stopService.

- The service can be cast to Service (even though it does not need to
implement it).

- If you like the PropertiesService can be declared at class level,
this is just a choice, you have as much freedom as usual.

- @Compose new annotation: works like @Inject, but ties the lifecycle
of the composed service to the parent Service, not the container. In
other words, the composed service will be started and stopped by the
parent service. For example, if you declare the propertiesService at
class level the propertiesService will be handled by the container,
nor by the WebServer:

@AnnotatedWebServer
@PropertiesService(propertiesFile="META-INF/web-server/web-
server.properties")
public abstract class WebServer {

@Start
public void start() {
getJettyService().start();
}

@Stop
public void stop() {
getJettyService().stop();
}

public void setPort(String port) {
getJettyService().setPort(port);
}

//Composition, WebServer will handle the jettyService lifeCycle
@Compose(ref="httpService")
public abstract JettyService getJettyService();

}

In the case of the jettyService it makes sense its lifecyle it's tied
to the WebSever but you can also do this:

@AnnotatedWebServer
@PropertiesService(propertiesFile="META-INF/web-server/web-
server.properties")
public abstract class WebServer {

@Inject (you can use Compose here too), here the container will
handle the jettyService
private JettyService jettyService;

@Start
public void start() {
jettyService.start();
}

@Stop
public void stop() {
jettyService.stop();
}

public void setPort(String port) {
jettyService.setPort(port);
}

//Added functionality, you can create dynamic invoking methods
from any service
//that you may have in the container
@ImplementedBy(ref="httpService", refMethodName="getServerContext")
public abstract ServletContext getServletContext();

}

As you can see you have a lot of freedom to compose or create new
Services with the new features, you can annotate at class, method or
field leve, using abstract or regular methods.

You can also provide a interface for the service if you like or need
it.

The @AnnotatedWebServer ann looks like this:

public @interface AnnotatedWebServer {

/**
*
* @return
*/
String id() default "webServer";

/**
*
* @return
*/
Class inherits() default AbstractAnnotatedService.class;

/**
*
* @return
*/
Class[] resources() default { JettyServiceImpl.class };

}

- Integration testing framework integrated within the container and
services (jIntegration therefore is depecrated):

I've always felt that the testing process should be more integrated
into the development process so what I did was to include the testing
framework within the core framework and the services so now it's
availble at any time (I left the jUnit4 dependency optional though).

So basically now the core framework has an Assert class with some
useful classes and the same happens with the services.

For instance the core has Assert.getService(), Assert.existService()
and so on.

In order to setup a unit test class (or integration test class) you
need to use @Container and the @RunWith annotation. Keep in mind that
the Asserts are static classes so the created container must be
attached to the current thread, so you need to use the
prototype_by_thread annotation.

@RunWith(IntegrationTestClassRunner.class)
@Container(instanceType=ContainerInstanceType.PROTOTYPE_BY_THREAD)

@WebClient
@Include(resources=WebServer.class)
public class IntegrationWebServerTest {

//dispose the container between test methods invocations, if you want
to reuse the same within invocations, delete this method
@After
public void dispose() {
ContainerHolder.releaseCurrentThreadContainer();
}

@Test
public void test() {
WebServer server = (WebServer)Assert.getService("webServer");
assertNotNull(server);
}

}

As you see you don't need to create a container yourself,one will be
created for you by the testing framework.

- Ruby now it's a separate service and services can be fully
implemented with it. Have a look at the new CalculatorService example
that mix a complete ruby service with a java one.

- New Spring AOP Service.

- Core and services Refactored.

I have refactored some parts of the core but I will work more on this.
The services and annotations have been refactored as well and adapted
to the new features.

- Examples and case study.

I have completely refactored them and adapted to the new features,
trying always to simplify as much as possible.

The case study has been completely refactored and simplified (I have
removed GWT in this version), usign the new features and services. I'm
writing a complete paper about this, but I think you will find easier
to understand this time.

- RoadMap

As you can see a lot of effort has been put into this release, not
only to improve the past version but to look to into the future.
The @AsbtractAnnotateService and the annotation inheritance are 2
powerful features and examples of this. The idea is to implement all
the services and elements without any asbtract class (like
AbstractCMTService) and make the services more intelligent.

- Versions 0.1.3 to 0.2 - Maintenance and fixes. Improve Services and
examples . Complete documentation.

- Versions 0.2 ->1.0 - New features (removing the need of abstract
services etc) and new services. More scripting languages.

As I'm designing the new versions, please any features you think it
would be nice to have please let me know.

Special thanks to all of you that downloaded jEmbedded and helped me
to improve it. Your comments are always appreciated.

I will dedicate the next few weeks to upto date the documentation.
Please be patience, I promise I will do it :)

jEmbedded - 0.1.3. RC-1 - Weekend Release

2009-10-01T15:02:00.002-06:00

Hi,

Yes I know I've skipped 2 versions :) but the work has been progressing so well that I decided to wait a bit and release something more complete.

So I'm releasing a rc this weekend, it's still a bit rough on the edges but it contains most of the features that I'd wanted and works pretty well. Also it will fit with the new documentation that I''m going to start writing this weekend as well.

New features:

- Dynamic Injection/creation of Services: create services just with an
interface + annotations, no implementation neded, in case you are
just composing services:

@Repository(id = "serviceLayer", iocProviders = { "springRepository" }, parent = "persistenceLayer")

@AnnotatedService(id = "serviceLayer", resources= {InvoicingServiceImpl.class})

public interface ServicesLayer extends Service {

@Inject(ref="invoicingService")
public InvoicingService getInvoicingService();

@SpringRepository(configurationFile = "META-INF/invoices-app/layers/ persistence-layer.xml")
public Service getSpringRepository();

}

- Complete Spring integration: a service exporter (from jembedded) into the spring context, @Inject can reference a spring bean, a @SpringProvider annotation that will load a context as a service and can be referenced as well., a ContainerListener for web applications..
etc etc..

- More services: Validation-Service (using annotations, oval), dao-service, hibernate-service, agent-service, proxy-service.

- A payload validator for mule using the the validator-service, so you can validate your payload with annotations.

- More examples including an esb/integration case study including spring/spring-mvc, jms, mule, rules etc.. I think it shows very well what you can do with jEmbedded. Also it's an original cas study, it's not the typical aggregator of responses you can find all over the net.

- jIntegration-Test 1.0 (see the web services post).

- Fixes and more stuff.

Well I think it's pretty good for this version.

Adolfo

And after the holidays...

2009-09-20T11:46:00.004-06:00

I resumed my day job this last week and it wasn't very bad :) at all . So this weekend I resumed my work on jEmbedded. First of all, thanks to all the people who took the time to try it and sent me their comments, you have helped me a lot. Even though it was a early release it has given me a lot of insight in which direction I should go.

I decided to release the version 0.1.1 in the next few days that will be focused in:

Improved Spring Integration: The @Inject annotation will be able to reference a Spring Bean and more.
Improved Documentation.
Improved Web Support.
More examples: I'm adding several examples that I'm working on as a complete example of a Invoicing System including Spring MVC integration and a hierarchical services layer (you can have an early peek on the project website). That will show a lot of the jEmbedded features as creating and composing a service layer in a few minutes. Other examples will include jIntegrationTest-0.1, how to package services with jEmbedded etc...
Bug fixes and code refactoring.

jEmbedded - FAQ III

2009-09-01T21:28:00.005-06:00

Well I'm going abroad for my holidays (it's time at last !!) so I won't be writing in a while.

I've just created a new discussion group jEmbedded Discussion Group so you are free to join and post your questions, requests etc...

After holidays want I'm going to do it's to write down a full documentation and upload more examples.

In the meantime here it's more Q/A:

* What's the difference between the @Include and @Repository annotations?

With these two annotations resources can be added to the container but in a different manner as @Repository will create a new container for the resources and @Include will just add them to the current container (default container in case you haven't provided the @Repository ann).

Use @Include if you only want to add some extra resources to the container and not to create a new one.

* Spring Integration, how to do it?

There are many different ways to do this. I've provided a spring-support-module that will help you, but in this stage it's not very comprehensive as I've focused to provide a stand alone IoC container.

In this module a FactoryBean class is provided so an instance of the embedded container can be stored into the spring-context. Then you can inject the container in any bean you want, get the container from Spring or just use ContainerHolder.getCurrentThreadContainer().
Please have a look at the spring-integration-module and the embedded-database example for more information.

You may ignore the integration module and write your own FactoryBean:

@Container(instanceType=

ContainerInstanceType.xxxx)
@Repository(id="database-service-layer", resources={EmbeddedDatabaseImpl.class})
public class EmbeddedDatabaseFactory implements FactoryBean {

public Object getObject() throws Exception {
return EmbeddedHandlerFactory.getInstance(getClass());
}

public Class getObjectType() {
return EmbeddedHandler.class;
}

public boolean isSingleton() {
return false;
}

}

Then you can retrieve the container like this:

ApplicationContex appContex; //SpringContext

EmbeddedHandler handler = (EmbeddedHandler)appContext.getBean("factory-bean-id");

Finally, you can create the container in any spring bean you'd like. Of course watch out what kind of bean it is (singleton, prototype etc...)

* Can the annotation @Inject be used to reference a Spring bean?

No at this moment, but you can inject the container to any spring bean or just accessing the container with ContainerHolder. I will add this feature in the near future.

jEmbedded FAQ II

2009-08-31T21:50:00.012-06:00

Here there are more questions that I kept being asked about jEmbedded:

* What's the best way to use jEmbedded in a web environment?

Depends on how are you planning to use the container as a singleton, prototype or instance by thread.

Singleton

If you are planning to use it as a one single container to serve the whole web app you can create and dispose the instance in a ServletContext listener:

import javax.servlet.ServletContextListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.*;

@Container(instanceType=SINGLETON_VM)
public class EmbeddedContainerListener implements ServletContextListener {
{
private ServletContext context = null;

private EmbeddedHandler handler = null;

public void contextDestroyed(ServletContextEvent event)
{
this.context = null;
handler.stop();
}

public void contextInitialized(ServletContextEvent event)
{
this.context = event.getServletContext();

handler = EmbeddedHandlerFactory.getInstance(EmbeddedContainerListener.class, *.class);
handler.start();
}
}

In order to access the container from any part of the web app:

EmbededHandler handler = ContainerHolder.getCurrentThreadContainer();

If you are using Spring, you can use an implementation of the ContainerListener to create the contaner.

As an instance per thread.

Let's say that you need a fresh container per request, in a MCV controller for instance. In order to do that just create and dispose the instance there.

Prototype instances.

You can create and dispose these instances anywhere but remember to dispose them!

* What are the differences between @Container and @Repository annotations.

@Container is just an annotation to control how the instances are being created when EmbeddedHandlerFactory.getInstance() is invoked.

@Repository is a way to create logical collections of services, components etc, for example different layers of services or components (as you can create them as a hierarchy).

This is useful even when you don't want to create complex collections (as a tree of services) just as an entry point for the container:

@Repository (id="baseServicesRepo", resources={*.class})
public class RepoEntryPoint {

handler = EmbeddedHandlerFactory.getInstance(RepoEntryPoint.class);
...
}

Now for instance lets say you need to create a different group of services that need to reference the former repository for composition:

@Repository (id="extendedServices", resources={*.class}, parent="myRepo")

Now the new container would have access to the to the parent repository as well.

I will be creating a full documentation in September, some web support out of the box and more examples (after my holidays).

Any feedback and comments are welcome.

jEmbedded F.A.Q

2009-08-29T01:05:00.016-06:00

First of all thanks to the people who have sent me emails asking about jEmbedded and of course to those who like it :)

All the feedback are highly appreciated so I can improve it in the next versions.

I reckon that the documentation now is quite scarce but I wanted to release before I went on holidays (I will improved it a lot though) so I did that compromise. Also there are some features that are not explained in the provided documentation (many actually)

So I will try to answer here some of the questions I have received.

* What is this framework good for?

Well first of all it's just an IoC container with all that implies, but more importantly it allows you to manage your application elements (definition, creation, composing, starting, stopping, releasing) in a easy and fast way (using annotations, no need of XML or other additional configuration).

It provides the semantics or annotations needed to promote a bean or a POJO to a service, to a component, or to a entity managing their life cycle (if you choose that). For example, the container will start and stop the services for you.

These additional semantics provide not only a life cycle to the POJOS, or a contract but also additional features as accessing to the executing environment and a chance to be externally managed (through JMX, I'm already working on a console).

I would say that the provided embedded services and the feature of easy composition (creating a new service using other services) it's quite useful. In fact, it's how this framework was born.
For example, you can get the jetty-service and create and web server of your own using just composition. Or a rules-server for your application using the rules-service provided, executing a set of business rules for the rest of the services.

Finally, jEmbedded is an implementation of another framework of mine, jRepository that allows you to create your own IoC customized container (included in the distribution).

* Can jEmbedded be used in a web application?

Of course you can, in the same way you would use it in a standalone application. (I designed it with the 2 environments in mind). You have to be careful though, in the way that the container are created or disposed. This is managed by the annotation :

@Container(ContainerInstanceType instanceType)

public enum ContainerInstanceType {
SINGLETON_VM, PROTOTYPE_VM, PROTOTYPE_BY_THREAD;
}

If you don't provide this annotation by default the way of creating instances it's PROTOTYPE_BY_THREAD (a new instance per thread) so if you are creating an instance of jEmbedded inside a MVC Controller, there is a good chance that you are creating a new container with each request. In this case use the SINGLETON_VM property to have one container per VM.

Another way of getting the handler to the container is using the following static method:

EmbededHandler handler = ContainerHolder.getCurrentThreadContainer();

jEmbedded-0.1 - Release

2009-08-20T11:28:00.006-06:00

Well at last!, after 6 months of work (well just a bit everyday, more the weekends) I'm ready to release a very complete first version of jEmbedded.

jEmbedded bornt out of the necessity to use an IoC container on the go, lighter, faster and easier. Spring is great, but it takes some time to setup all the beans, xml-schemas (also you can use annotations, but still). For my purposes, using embedded services or just services it was a bit too much, and I wanted just to provide some annotations, some configuration data and get it running.

In fact, it was the core of the first version of my testing framework (jIntegration-Test), but I found myself writing a lot of xml schemas for each service or association classes something I wanted to avoid for the sake of simplicity.

What is more, I was looking for something more specific and Spring or Guice are very generic, everything is a POJO for then. I wanted to have more control of my services and have different kind of POJOS:

* Services (CMT / Unmanaged)

- Lifecycle is managed by the container or not.

- Can be started / stopped. Initialized / disposed.

- The context is injected by the container and gives access to the running enviroment.

- A service could contain and manage services, components, beans and entities.

* Components (CMT/ Unmannaged)

- Lifecycle is managed by the container or not.

- Can be initialized / disposed.

- The context is injected by the container and gives access to the running enviroment.

- A component could contain and manage components, beans and entities.

For example, A CMT Service. This service will be started and stopped by the container. Also initialized and disposed.

@AnnotatedService(id="testService", resources=TestBean.class)

public class TestService extends AbstractCMTService {

@Inject

private TestBean testBean = null;

public void test() {

testBean.printMsg();

}

In order to have access to the service and get the container started:

EmbeddedHandler handler= EmbeddedHandlerFactory.getInstance(TestService.class); handler.start();

TestService testService = (TestService) handler.getService("testService")

testService.test();

handler.stop();

As you can see, my main concern has been keeping it easy and fast to use as it should be with embedded services.

More information will be found in the project homepage.

jembedded-0.1-release

jIntegration-Test-0.9.3-SNAPSHOT version released.

2009-05-15T00:08:00.004-06:00

jIntegration-Test-0.9.3-SNAPSHOT

User Guide

jIntegrationTest - version 0.7.1 notes.

2009-04-05T06:55:00.024-06:00

As I've just released the 0.7.1 version of jIntegration-Test (aka JEmbedded) I though I should write down some brief notes about it.

First of all I've changed the name to something more intuitive than jEmbedded because it's main purpose its integration testing (even thought is based on the concept of embedding servers).

Secondly, this is still a work in progress so in every version I'm releasing I'm changing many things: refactoring out code, adding new features, refactoring configuration files, adding new services... etc etc.. always having in mind how to make it easier to use.

So expect more changes and new functionality like more testing methods for every integration test unit. For example, a test method for every HTTP result code: 500, 400..

Of course working this way has some drawbacks but I think it's worth the effort.

The last integration unit I've added is one to test JMS applications using an ActiveMQ embedded server. At the moment you can test destination creation, sending messages etc.. expect more functionality for this integration unit.

@JMSIntegrationConfigurationTest( connector = "tcp://localhost:61666",
jmx = "false")
public class EmbeddedJMSIntegrationTest extends AbstractJMSIntegrationTest {
public void testDestination() {
testDestinationCreation("TEST.TEST", "tcp://localhost:61666");
}
}

Despite all of that, still it's quite functional and I'm using it myself at the moment in real life projects with a degree of success.

In this release I've put some extra care and effort to release something you wouldn't have any problems to compile and use. In order to do that, I've included all the dependencies that you can't get from a external mvn repository. Just copy the folder into your own mvn repository.

Also in the src directory you can find a ready to compile and install project.

Any problems, just drop me and email or leave a comment here.

You can read the complete installation notes in the project's wiki.

jIntegrationTest Framework.

2009-02-14T23:43:00.029-06:00

The Framework.

jIntegrationTest comes from my own experience working in many projects and trying to figure out how could I do the integration tests easier. Usually you will find two approaches: using mocking frameworks or just deploying the application and testing it.

The Mocking Approach.

One approach is using one of the many *.Mock.* frameworks out there. It's a valid one and it works (easy for POJO's, no that easy if you want to mock something more complex as HTTP request for example) but you probably will found yourself writing a lot of code and spending a lot of time just to replicate the behaviour of the application.

Mocking as you are developing and designing it's OK, as you don't have the actual code or HTML's or pages (that's the whole point of mocking). But at the end of the day, when you have the real code it feels lacking doing the integration testing through all that mocking infrastructure as you are not getting most of the real errors you would get in the real environment (application, system, configuration, environment, dependencies errors etc...). The good thing about this approach is that fits easily with automatic testing and continuous integration.

Just Deploy and test Approach.

The other approach and sadly the most common one it's just doing the deployment and see what happens. OK the deployment fails because the XML descriptors are wrong or a file it's missing or we are getting a null pointer. Fix it, compile, test and deploy again. And so on. At last the deployment works, start testing the application, now one SQL sentence is failing. You do it again.. and again :). Now everything seems to work but now one new component is added and the deployment process fails again :(.

Well it's clear how many time it's wasted following this approach and what is worst, you are never sure that you are not breaking something when you add something new having to do expensive regression tests. It's obvious this approach it's no very easy to automatize.

Why to use Embedded Servers and jIntegrationTest.

At this point it's when the idea of using embedded servers (and of course jIntegrationTest) comes handy as you won't have any of the problems of the former approaches:

Don't need to replicate the behaviour of the application, just test the expected real results, being a number, a HTTP response, the creation of a component...
Don't need to deploy the application to test it, just run the the integration test units from Eclipse, maven, ant etc.. getting an instant feedback.
Don't need to do regression testings as the process can be automatized.

The advantages of using jIntegrationTest are:

You get all the above advantages.
Many embedded servers out of the box: HTTP (Jetty), DB (HSQLDB), Web Services (Apache CXF), Spring (Container and MVC), JMS(ActiveMQ) and RMI.
Easy configuration relying on defaults and annotations (almost none).
Based on JUnit so it's very easy to get into.
Many Integration Test Units out of the box: HTTP, DB, Spring, Spring MVC, JSF, Web Services....

A quick example

You can find the complete application and tests in the folder examples/invoices of the jIntegrationTest release.

@HttpIntegrationConfigurationTest( port=9006, root="/test", src="src/main/webapp/")
public class InvoicesControllerTest extends AbstractIntegrationHttpTest {

public void testController() throws Exception {
String uri = "http://localhost:9006/test/invoice.do";
assertResponseStatusOK(uri);
}
}

In this test we are testing an actual controller of the application which is responsible of invoking a service that calculates the invoice.

As we are testing a controller we need to use a HTTP embedded server, which configuration it's very easy, just need a port, a web root and the root location of the web application in your file system.

It's just a simple test in which the framework will execute a request to the indicated URL, in this case the invocation URL of the controller, just if someone would have pressed a button to generate the invoice. If the server returns an OK (200 code) the test will pass.

Of course, if there is any problem in your web application you will get an error and you could fix it right away without having to deploy again.

New Frameworks and change of direction

2009-02-14T00:56:00.010-06:00

Once again it's been a long time since the last time I wrote something here, mainly because I thought was much better to invest the time writing code and new stuff. There are already many good blogs out there commenting the new stuff, enough to keep you occupied for ever.

So I decided to focus on my new frameworks and comment some other interesting stuff from time to time.

I've been working mainly in two new frameworks and the reworking of jServiceRules:

jiContenedor: Multi layer JEE Service Container based on Spring, containing many different services out of the box: Validation (OVAL) , i18n, Logging, Spring/GWT MVC, JMS, jCaptcha, Spring Security, WebServices, Rules (R4Spring). It allows to define different layers for your applications (for example): web layer, repository layer, integration layer, services layer and so on. Relies on default configuration and a mix of xml schemas and annotations.

jIntegrationTest: JEE Integration Testing Framework including HTTP, DB, JMS, WebServices, RMI and JMS embedded Servers. Includes several Integration Testing Units: HTTP(Jetty), DB(HSQLDB), JSF, JMS(ActiveMQ), Spring, Spring MVC, Apache CXF WebServices...
Rules4Spring: evolution project from jServiceRules, focused on using declative/sematic rules in Services, using annotations.

jSemanticService: version 0.5 released!

2008-03-18T02:08:00.006-06:00

A new version of jSemanticService has been released.

jSemanticService allows to use business rules and semantics using annotations in an easy way.

This release includes:

- Full Annotations, Spring and Flex/Blaze DS support.

- New support classes to build Semantic Services on the fly.

- New and improved documentation.

- New integration examples including Flex and Spring MVC.

Project Webs.

jSemanticService in SourceForge

jServiceRules in GoogleCode

jSemanticService in Sourceforge.net

2008-03-05T02:32:00.004-06:00

Good news!

Some days ago jSemanticService was approved by SourceForge, so from now on the releases of this package will be found in the new project site.

The releases of the individual packages (jSemantic-Core, jSemanticRules, jSemanticRules-support) will be made through Google Code.

jSemanticService: Flex Integration.

2008-03-04T05:17:00.015-06:00

The support module included in the jSemanticService release supplies some classes for the integration with Flex.

In these screen shots the Semantic Even Service can be seen (included in the even numbers example) working with Flex as a RIA framework.

The Semantic Even Service is exposed as a Remote Object using BlazeDS.

In the above screen shot some numbers are being introduced.

After pressing the submit button, the SemanticEvenService is invoked and returns the results.

jSemanticService version 0.1.0

2008-03-02T01:37:00.009-06:00

jSemanticService is a package that comprises the functionality of jSemanticRules plus the support package (Spring, Hibernate, Mule, Flex..),

There is also available a documentation guide in pdf format.

Downloads.

jSemanticService version 0.1.0 distribution

Setup and Dependencies of jServiceRules

2008-02-29T02:14:00.008-06:00

The setup process is very easy, just download, unzip the tar file and depending of the environment you are working with (standalone or Web) the jars must be added either to the classpath of the application or to the WEB-INF\lib directory.

The only issue could be getting the right dependencies. If you have downloaded the no dependencies package you can get it in a separate file .

For further information a documentation guide is available.

Transforming Pojo / Web / Enterprise Services into Semantic Services / Agents using jSemanticService

2008-02-28T01:28:00.011-06:00

Let's suppose that you have an existing service (pojo in this case) in a Spring context, (or that you need to write a new service) that needs to use semantics.

How would you do that? Well, in just three steps:

First Step

Writing a SemanticServiceFactory bean (and it's collaborators if needed) in the Spring Context file.

Second Step.

Either inject a reference to the SemanticServiceFactory directly in the service or extend the SemanticServiceSupport abstract class.

public class EvenService {

private SemanticSessionFactory semanticSessionFactory = null;

public Collection check(Collection numbers) {
SemanticSession session = semanticSessionFactory.getInstance();

Collection results = session.execute(numbers);
session.dispose();
session = null;
return results;
}

public void semanticSessionFactory(SemanticSessionFactory semanticSessionFactory){
this.semanticSessionFactory = semanticSessionFactory:
}

}

Now a method that uses the new added semantics functionality can be written. For that matter there is a method in the base class: getInstance(). This method returns a Semantic Session instance that is bound to the current thread. If we dispose the session then we'll get a new one. If not, the same session will be reused.

Third Step

Inject the Semantic Session Factory in the service bean.

And that's all, now the Semantic Service is ready to roll!.

Read the complete article in:

http://code.google.com/p/jservicerules/wiki/TransformServicesIntoSemantics

Why to use Semantics and Rules in your Services.

2008-02-26T23:54:00.012-06:00

The question is why should I use Semantics and rules and when?
Well, using semantics or rules should be another tool in you toolset. And it's a very useful one, even though is very underrated maybe because it´s never been easy to use. Or because semantic or functional programming has never been that popular.
That is changing nowaydays because of SOA and BPM's, that rely heavily upon on Business Rules, specially sSOA.

With the jServiceRules / jSemanticService frameworks I tried to cover up some of that gaps:

# Writing semantic services or agents in a easy way, just writing some rules files (and the service).

# Adapting the BRE to Services and Java environments.

# Integration with another third party frameworks.

When to use Semantics or Rules

In a Enterprise Environment these are some of the cases in which you could use jServiceRules or jSematicService:

# If you need smart agents or services (for example a service that will recommend your tv favorites series of the day).

# If you have a complex model you could write a semantic model to process it.

# Business rules that would change over the time.

# Business rules that you'd like to isolate from the code.

# Business rules that you'd need to edit in a simple way, using a scripting language (so you don't need to compile),

# Different types of events or objects you'd want to recognize and process.

About the jServiceRules alpha working release.

2008-02-24T00:37:00.017-06:00

Well, after some months of development (well, not really that much but as I do it in my spare time, clocks that long) I've finally been able to release an alpha working version.

In fact, it´s a stripped down version compared what I had in mind, but it's more focused (service oriented) and it can be used as a base for future developments.

Even though it's functional and I've tested it in different enviroments (windows, linux, mac os) using unit and stress testing, still some bugs could appear. Also I'm still improving it, so minor changes could be found in the next version. But that's the reason it's an alpha release :) .

About the release.

This release includes the dist binaries, dependencies (if you choose so), API docs, and two examples.

It does not include the support package therefore there is no Spring (and the rest of the bunch) integration yet, so the only option to use and configure the framework is through code (see examples and further posts). I'll release it at the end of this week or early next.

About the examples.

The even numbers example is simple, just a service that returns if a number is even or not. Two simpe rules are produced to do that. The objective of this example is to show how to use the basic features.

The Energy example is a more complex one producing the energy invoice of a customer, giving his personal data and energy readings. In this case, a number of rules are produced to generate the Tariffs available.

JServiceRules alpha 01 working version released.

2008-02-23T13:17:00.013-06:00

Transform existing (or new) Enterprise Services in Semantic Services in no time. Based on a implementation of a generic Business Rules Engine (an implementation using Drools 4 is provided).

Features

# Quick and easy configuration (code or Spring based).

# Easy integration in existing services/applications (code or Spring based).

# Hides the complexity behind a BRE (configuration/development), allowing developers to concentrate in the development of the business logic and rules.

# Agnostic and focused API with the most common features that you'd need (plus new ones).

# New features that helps the BRE to interact with the environment (internal/external), for example invoking external services by rules (that are located in a external Spring context).

# Support package that provides integration out of the box for Spring, Hibernate, Mule etc..

Project Home

http://code.google.com/p/jservicerules

Binaries

http://jservicerules.googlecode.com/files/jservicerules-alpha1.tar

http://jservicerules.googlecode.com/files/jservicerules-alpha01-nodep.tar

Source Code

http://code.google.com/p/jservicerules/source/checkout

Quick Guide

http://code.google.com/p/jservicerules/wiki/IntroductionGuide

jSemantic-Core Beta 1 released.

2008-02-18T01:03:00.014-06:00

The beta 1 for the jSemantic-Core has been released.

This package is the API for the jServiceRules framework, that allows to transform your regular Enterprise Services to Semantic Services on the fly backed by a rules engine.

This is an "agnostic" API, so it doesn't contain any references or dependencies to any rules engine.

This release contains binaries, API docs and dependencies.

Project Home

http://code.google.com/p/jservicerules

Binaries

http://jservicerules.googlecode.com/files/jsemantic-core-beta1.tar

Source Code

http://code.google.com/p/jservicerules/source/checkout

Quick Guide

http://code.google.com/p/jservicerules/wiki/IntroductionGuide

jServiceRules (I). The Semantic Core.

2008-02-17T04:33:00.032-06:00

The first package of the jServiceRules framework is the jSemanticCore, that contains all the interfaces, abstract factories, helpers so a Semantic Session could be implemented.

The Semantic Session is a core concept within the jServiceRules framework and is just a Working Memory object "on steroids". Essentially it offers a focused interface, improves the communication of the WM with the execution enviroment (internal/external) and hides all the complexity behind the backed rules engine. Also helps to manage some external knowledge we could need through the Knowledge Database.

Let's say that you want to execute some business stateless rules. To produce this is as simple as:

Creating a Semantic Session Factory associated to the rules file.
Getting an instance of the Semantic Session (stateless by default), produced by the factory.
Passing some facts to the session (related to the rules you want to evaluate).
The rules will be automatically evaluated and some results will be returned.
The session could be disposed.

SemanticSessionFactory factory = new SemanticSessionFactoryImpl("org/jservicerules/rules/test.drl");

SemanticSession session = factory.getInstance();

Collection results = session.execute(new Integer(10));

session.dispose();

A template to produce the rules files is provided with the package:

package org.jsemantic.templates

global org.jsemantic.core.context.SemanticContext ctx;

rule "rule_one"

when

then

end

.........

rule "rule_n"

when

then

end

For example, we'd like to know if a number it's even:

rule "even"

when

number:Integer()

eval(number.intValue() % 2 == 0)

then

ctx.addObject(number, "Number: " + number + " is even");

end

The Semantic Context is the object that allows to interact with the enviroment. One way is returning results of the rules evaluation through the addObject(id, value) method. There are other ways of interacting as using the ExternalContext or the Session Variables. I'll explain this in future posts.

It´s been a long time since I ...

2008-02-09T01:28:00.003-06:00

Well yes!, it´s been a long time since the last time I wrote in this blog.. and a lot of things happened as well. The thing is, that I have been doing a lot of stuff lately and I´m going to share some of it, starting with a little set of frameworks related to the main topic of this blog: semantics.

First of all, a little of history :D

My first experience with semantic programming was some years ago, when I was assigned (with 2 colleagues) to a "highly urgent project" :P for Telefonica. It was a use case simulator for testing, so we had a lot of different input/output cases.

In order to relate the thousands of different input/output (a group of inputs/outputs would be a use case, depending on some conditions) we used a rule engine to generate and filter them.

Why did we use a rule engine? Because we could declare the different use cases and it's driven conditions, using rules in a declarative fashion (that is, semantic programming), being easily read, changed or updated. Also we could filter the cases using the same rules.

At that time (2003 I think it was) the best open source option was Drools (http://labs.jboss.com/drools/) and still is in my opinion. JRules from iLog, it´s a very good one rules engine but it´s a commercial option though.

I starting using rules engines over the years, collecting a few utility/helper classes.Then last year after the summer, I started working with these classes expanding them with a lot of improvements and concepts, always having Drools 3 as a core.

Then Drools 4 was released, and it had some of the concepts and improvements I´d already added :D to my little framework (well done guys! by the way). For example, changing the concept of WorkingMemory to RulesSession (stateless & stateful). I got something similar, but I went further creating the SemanticSession, a concept that I´ll explain latter.

Anyway, at that point I decided:

first of all, to create an agnostic and simplified API, with the most common features that anyone would use (based in my own experience) and not related to a specific rules engine. It also expands some of the concepts and features. This API would become the jSemanticCore package.
Second of all, to create an implementation based on Drools 4, using its new features and adding/removing others. Also it implements the new concepts, as the SemanticSession, SemanticContext, KnowledgeDatabase etc. This would become the jServiceRules package.
And finally, a support package that provides integration classes for Spring, Hibernate, Mule etc..

I will be releasing all this packages the next 2 weeks through http://code.google.com/p/jservicerules/, in a alpha/beta state. Also, I will be publishing entries in the blog explaining how to use it, technical aspects and examples.

Plugabble XML Validations - Use the Jakarta Struts Validations from your Swing application.

2007-07-25T10:05:00.017-06:00

Even though Swing is not cool anymore (yes, it was back in the day because it was much better than AWT, believe me) and everybody out there is talking about RIA (you could say that Swing is RIA too ;) ) it's not very unlikely that you'd find yourself in the situation you'd to work with it. In fact, it happened to me this year twice.

There a lot of companies out there using Swing (specially financial ones), and even though some of them in the future will change to the "RIA experience" (if one does, everybody else will, yes SOA I'm looking at you ;D ), in the meantime it's good to improve the "Swing experience" :) .

Like I said, I found myself working in a Swing based project, and the first thing I realized (among others) is that the validations and errors messages were hard coded, repeated and spreaded all over the code. One amateur mistake, you'd say but it's not that uncommon.

To prevent that I integrated the "Jakarta Commons Validator" engine that helps you to reuse sets of validations and messages. If you have used Struts, you'd know it for sure.

The thing is that the JCV package does not provide any pluggable validations out of the box (it provides some validations routines to help you out).

I though the best way would be using something like the Struts Validation Plugin, that included many different validations configured by xml but for a standalone application.

So that's what I did. Now you can use the same Struts Validations (same config files, tags etc.. have a look at the Struts guide), but from your Swing application.

Links

Jakarta Commons Validator

Struts Validations Guide

YUI Live Search (aka AJAX AutoComplete) - Integration with Struts - II

2007-07-16T13:37:00.000-06:00

Hi all,

I´ve been very busy lately landing into a new job, so I couldn't add any new entries.

I´ve received a couple of questions about the autocomplete component, and it seems that everybody gets confused in the same part.

The autocomplete component is esentially a ui component, so it does not provide any function to filter the results in the server. That means you have to implement you own search and return it to the client. If you don´t do that, more likely you will get all the results at once.

However, it has a filter function in the client side if you activate the cache, but you would have to return all the results the first time to make it work, and it´s not the way is intended.

Here it is the sources for an example of the autocomplete, provided by Rohitesh (thanks!).

In the next entries I will exploring some not very hot topics, but useful ones like an integration of the Jakarta Commons Validator with Swing (using the struts validations), a little Swing framework, and the use of Cactus Testing Framework with JBoss 4.

It´s amazing the number of companies that still use technologies like swing and ejbs (entities), and the thing is that using some helping tools, it works (with some effort, that is).

YUI Live Search (aka AJAX AutoComplete) - Integration with Struts

2007-04-26T00:52:00.000-06:00

Hi!

Well, if you hadn´t had a look at the YUI LiveSearch component (http://developer.yahoo.com/yui/autocomplete/) go for it. It´s worth the effort.

Autocomplete Component and DataSource.

YUI is just a library of AJAX components, so you would need to integrate it with you favourite framework. However, it´s shipped with some javascript libraries that wrap the XMLHttpRequestObject, so you don´t have to use it like that. Instead it uses the concept of DataSource to send queries and retrieve data:

var serverURL = "/search/liveSearch.do"; //service URL
var schema = ["Results","Id","Name", "Description"]; // data mapping format

var dataSource = new YAHOO.widget.DS_XHR(myServer, mySchema);
dataSource.responseType = YAHOO.widget.DS_XHR.TYPE_JSON;
dataSource.queryMatchSubset = true;
dataSource.maxCacheEntries = 50; // component internal cache size.

this datasource must be passed in the autocomplete constructor:

var liveSearchComponent = new YAHOO.widget.AutoComplete("textField","containerId", datasource);

textField: input search text field component.

containerId: div id that will hold the results.

Well, thats basically what you would need to know to create the datasource and the component (along with some configuration steps, have a look at the YUI tutorial).

Search Service.

We can get the results using a search service invoked by a struts action:

public String search(String searchText, int numMaxResults);

Using this service we should get the data following the format specified in the datasource. In this case we need to get the data in JSON (java script object notation) format:

{"Results":
[{"Id" : "1", "Name": "Lou Reed", "Description": "NYC Man"},
[{"Id" : "2", "Name": "Lou Dylan","Description": "the man!"}]}

Service code using the JSONObject:

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

public class SearchServiceImpl implements SearchService {

public String search(String searchText,...) {

//here goes the code to do the search

//once obtained the results must be formatted using json

JSONObject json = new JSONObject();

JSONArray result = new JSONArray();
JSONObject rowOne = new JSONObject();

JSONObject rowTwo = new JSONObject();
try {

rowOne.put("id", "1");

rowOne.put("Name", "Lou Reed");

rowOne.put("Description", "NYC Man");

result.put(rowOne);

rowTwo.put("id", "2");

rowTwo.put("Name", "Lou Dylan");

rowTwo.put("Description", "the man!");

result.put(rowTwo);
json.put("Results", result);
}

catch (JSONException e) {

//umm a checked exception!! :)

//do something!

}
return json.toString();
};

That would be the search service, of course it could be whatever you want, a POJO, a Web Service etc.. the only thing to keep in mind is returning the data using the JSON format (specified in the datasource schema).

JSON Struts Action

It´s almost finished! we only need the controller code, to return the JSON String. In order to that, we need to write a special kind of action. Intead of returning and instance of action mapping, we should get the response object and flush the JSON object to the client:

public ActionForward execute (ActionMapping mapping,...) {

String json = searchService.search(searchText,...);

res.setContentType(TEXT_JAVASCRIPT);res.setHeader("Cache-Control", "no-cache");
PrintWriter pw = res.getWriter();

pw.write(json);pw.close();
return null;

Of course, you could do an abstract JSON Action class, or a helper to reuse it through the application.

Another Entry, Another Hype

2007-04-22T10:44:00.000-06:00

Hi guys!

I´m going to share with you some technical stuff about Ajax. And the reason is that I´ve been working lately a lot with it, because you know, these days you just can´t use a standard dropdown, you need an ajax driven dropdown or a web 2.0 dropdown.

I suppose you know what Ajax is, if not check out this link:

http://en.wikipedia.org/wiki/Ajax_%28programming%29. (where have you been, in the Lost Island?, by the way I´ve got a crazy theory that I´ll share with you :) )

Generally speaking, Ajax components could improve the user experience, if correctly used. For example the live search component, or the google search, I´m sure you know it; you just type some characters and the result appears without refreshing the page. You go on typing and more results appear.

This component could save a lot of time and pain in a web application, I´ve used it to replace a conventional search (yes, with a pop up and pagination buttons, oh my!), replacing the manual pagination through hundreds of results for a simple search box. You just type a 3 o more chars and the results appear in DIV, under the box or next to it. Even you can have links inside the results!.

So what I will do it´s explain to you how to integrate a Live Search component in your application using different frameworks and components.

Ok, let´s have a look at the frameworks then. There are many of them, almost every software company has one, it´s the sign of the times. I´ll talk about the ones I know and I have used:

- YUI (Yahoo User Interface): http://developer.yahoo.com/yui/.

- DWR (Direct Web Remoting): http://getahead.org/dwr.

- GWT (Google Web Toolkit): http://code.google.com/webtoolkit/.

- Moo.Fx : http://moofx.mad4milk.net.

- Rico: http://openrico.org/rico/home.page.

I´ll start with the YUI framework and the integration of the YUI live seach component with Struts, JSF and Spring MVC. That will be in the next entry.

See you!

In the beginning..let there be Blog

2007-04-22T10:15:00.000-06:00

Hi everyone!

It´s been a while since I wanted to write this blog.. but at last I´ve got some time in my hands to do it.

My goal is to share some practical stuff that I´ve been using in rl projects and other experimental stuff.. of course the main topic will be java and jee (yeah it´s not dead, like some folks would wish) and Ruby (it´s a cool OO language).

About Ruby I have to say that is a neat language but its killer app, Ruby on Rails, failed to impressed me.. it has some neat stuff, thats true, but nothing that you can´t find in java/jee frameworks:

- Code generation: the most talked feature... it´s old stuff in j2ee/java, you have plenty of those, and more advanced: Middlegen, AndroMDA, AppFuse...

-ORM: Hibernate (original, huh?), TopLink, Ibatis (semi-ORM), etc.. and by the way more complete than the ActiveRecord. I suppose that will be fixed in next RRails version.

-Web Framework: it´s nice, but again nothing new there.

-Ajax support: nothing new..

I think the best they have done it´s to integrate all that stuff in one framework, trying to make it as simple as possible. Doing a CRUD application, it´s easy, but beyond that... things change.

Ruby on Rails plays in a different league, it´s a good alternative to php, lamp.. it´s easier and more powerful, but I don´t see an enterprise project done in Ruby on Rails.

Don´t take me wrong, I like the framework, but I can´t understand like java gurus like Bruce Tate, changed his mind and company from java to ruby like that..maybe looking for a new piece of cheese? It´s a new field indeed.

Well, in the next entry I´ll talk about...AJAX, Web 2.0 Holy Grail