If we’re moving to the cloud-era, the undestanding of this architecture style is essential. In the cloud we are presented with services (Storage, Search, Graph, Geolocation, …) that we can and should use to build applications. Almost all of these services, available  in the cloud, provide some kind of interface and happens that, this  interfaces is, generally, a RESTful Web Service. If I want collaborate with these services I must talk the same language!! Moreover, exploring this architectural style in new applications opens the door for realy distributed and scalable systems, while the simplicity is kept high!

Here the slides:

PDF can be downloaded from here.

Nothing in this architecture is can go wrong,  it’s so simple! This type of architecture is the perfect fit for this ubiquitous platform that is Internet.

Btw,  SpringSource makes it really easy to develop applications in this way, just look to Spring Integration project, for example. They have a plenty of projects, built on top of Spring, that makes development of this type of architectures more, and more fun and easy.

(Ignore the sound problems at the beginning )

Contrast this with traditional “enterprise” architectures. Which side of the fence you want to be?

Been a while… This post will show you, and remind me in the future, how to quickly setup a

GWT 2.3 project with Maven2 and GIN 1.5. I’m using Ubuntu, but the essential steps should be the same in any operating system.

Let’s start.

Assuming you have maven installed, just run:

mvn archetype:generate -DarchetypeRepository=repo1.maven.org -DarchetypeGroupId=org.codehaus.mojo -DarchetypeArtifactId=gwt-maven-plugin -DarchetypeVersion=2.3.0-1

Then, enter the details for you new GWT 2.3 project. Don’t forget that the property for ‘module’ should be a valid Java Class name, so use camel case when setting the name of module.
My configurations are something like:

Define value for property 'groupId': : eu.jpereira.gwt
Define value for property 'artifactId': : quickstart
Define value for property 'version': 1.0-SNAPSHOT:
Define value for property 'package': eu.jpereira.gwt:
Define value for property 'module': : Quickstart
Confirm properties configuration:
groupId: eu.jpereira.gwt
artifactId: quickstart
version: 1.0-SNAPSHOT
package: eu.jpereira.gwt
module: Quickstart

Now, we just need to add the dependency to GIN 1.5. Open the generated POM for the Quickstart project and add the dependency for GIN 1.5:

<!-- GIN Stuff -->
<dependency>
	<groupId>com.google.gwt.inject</groupId>
	<artifactId>gin</artifactId>
	<version>1.5.0</version>
	<scope>provided</scope>
</dependency>

Now you have a GWT 2.3 project with GIN 1.5 and Maven.
To finalize, let just remind how to setup GIN with the GWT project.
Generate the eclipse project:

mvn eclipse:eclipse gwt:eclipse

Open the project in eclipse and edit the *.gwt.xml (in my case, this is the file Quickstart.gwt.xml) file, located under “src/main/resources/” to import the GIN module:

<inherits name="com.google.gwt.inject.Inject" />

Create the GinModule, the class file that will configure the dependency injection for your application. You can have any number of GinModules. Check the documentation here: http://code.google.com/p/google-gin/wiki/GinTutorial
I like to keep everything related to GIn under the package *.client.gin. My Module is this:

package eu.jpereira.gwt.client.gin;

import com.google.gwt.inject.client.AbstractGinModule;
import com.google.inject.Singleton;
import eu.jpereira.gwt.client.QuaickstartApplication;

public class QuickstartGinModule extends AbstractGinModule {

	@Override
	protected void configure() {
		bind(QuaickstartApplication.class).in(Singleton.class);

	}
}

Here I’m only binding the QuickstartApplication object, which is my main application, like this:

package eu.jpereira.gwt.client;

import com.google.gwt.user.client.Window;

public class QuaickstartApplication {

	public void run() {
		Window.alert("Hello World!!!");
	}
}

Back to Gin setup, let’s create the Ginjector. Create a new Interface that extends from Ginjector:

package eu.jpereira.gwt.client.gin;

import com.google.gwt.inject.client.GinModules;
import com.google.gwt.inject.client.Ginjector;
import eu.jpereira.gwt.client.QuickstartApplication;
@GinModules(QuickstartGinModule.class)
public interface QuickstartInjector extends Ginjector{
	QuickstartApplication getQuickstartApplication();
}

Finally, it’s time to use it. In the Quickstart.java, which contains the entry point to the application, remove everything, create the injector and start your application.

package eu.jpereira.gwt.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;

import eu.jpereira.gwt.client.gin.QuickstartInjector;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class Quickstart implements EntryPoint {

	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {
		QuickstartInjector injector = GWT.create(QuickstartInjector.class);
		injector.getQuickstartApplication().run();

	}

}

Now, run the application with:

mvn gwt:run

And you should see the “Hello World!!” alert.

BTW, you can download the project here.

Happy coding!!!!

Focusing on what is open source, you just need to see those supported by Apache: http://projects.apache.org/indexes/category.html#web-framework

Then you can see a list of Java web development frameworks (result of a Google search):
http://java-source.net/open-source/web-frameworks

There’s are so many and the community does not focus on building a complete Java Web Development Framework. The one I like more is Play! Framework because it’s a complete stack of java technologies that really help the development of web apps and it borrows many concepts from Ruby on Rails, which it’s my favorite.

I don’t know every Java web development framework, of course, and each must have their strengths and serve different purposes, but my feeling is that if there were only a few, then the community will focuses on improving those and we’ll end with a truly good framework.

So, I start looking to what is out there that is enterprise ready, like EJBs, JSF, Hibernate, JBoss, Tomcat, whatever, and start getting the pieces together…. out there in the world there was some a guy with the same product idea, but considered first the productivity aspect of the equation and started to materialize the idea with, let’s say, Ruby on Rails…. guess who’s the winner?

I’m not against the use of JEE, of course, I just think that in some cases it does not make sense. I also have this false argument in my mind: What if I start building it with PHP and then hit a performance problem with my 1Million users? Well, If I ever had one million users, I’ll be happy to deal with these performance issues

private void composeBindErrorsMethod(TreeLogger logger,
			SourceWriter sourceWriter, TypeOracle typeOracle) {

		sourceWriter.println("public void bindErrors("
				+ parameterizedType.getQualifiedSourceName()
				+ " object, Map<String, List<String>> errors) {");

		// Get the fields declared in the parameterized type
		JField[] fields = parameterizedType.getFields();
		for (JField field : fields) {

			JClassType classType = field.getType().isClass();
			if (classType != null) {

				JClassType erroableType = typeOracle.findType(Errorable.class
						.getName());

				if (classType.isAssignableTo(erroableType)) {

					sourceWriter.println("if (errors.containsKey(\""
							+ field.getName() + "\")){");
					sourceWriter.println("object." + field.getName()
							+ ".setErrors(errors.get(\"" + field.getName()
							+ "\"));");
					sourceWriter.println("}");

				}
			}

		}
		sourceWriter.println("}");

Again, hope it helps anyone.

When doing some kind of framework code with GWT, soon you’ll realize that you need reflection, as I did. Bad luck, you’ll have to dig into the underground features of GWT, namely deferred bindings and generators. You can learn the theoretical traits of Deferred Bindings in the documentation: http://code.google.com/webtoolkit/doc/latest/DevGuideCodingBasicsDeferred.html

Let me explain my scenario.

I do all client/server communication using JSON, and the form field errors are returned from the server in JSON like this:

{"errors": {"name": ["Error 1 on field name",  "Error 1 on field name"], "email:  ["Error 1 on field email",  "Error 1 on field email"]}, "_errorMessage": "Could not save the record due validation errors"}

My form editor at the GWT side, has some kind of Editors for each field of the form that implements an interface like this:

public interface Errorable {
	public void setError();
	public void setError(String message);
	public void setErrors(List<String> messages);
	public void clearErrors();
	public boolean hasErrors();
}

My form component has something like this:

public class UserEditor extends Composite implements CompositeEditor<User> {

	@UiField
	TextBoxEditor name;

	@UiField
	TextBoxEditor email;
         //Rest of the code

	public void setFieldErrors(Map<String, List<String>> fieldErrors) {

		//Bind error fields
	}

}

TextEditor class implements the interface Errorable and the implementation of setErrors(List messages) simply shows the validation errors underneath the text box, the usual stuff…

The UserEditor::setFieldErrors(Map> fieldErrors) get a Map produced from the JSON response, with the name of the field as key and a list of Strings representing each error in the field, and show the errors for the corresponding field in the UserEditor

My problem is with the implementation of UserEditor::setFieldErrors(Map> fieldErrors) , I did’n want to do something like this:

	public void setFieldErrors(Map<String, List<String>> fieldErrors) {

		//Bind error fields
		if ( fieldErrors.containsKey("name")) {
			name.setErrors(fieldErrors.get("name"));
		}

		if ( fieldErrors.containsKey("email")) {
			name.setErrors(fieldErrors.get("email"));
		}

	}

This could be a small amount of code now, but for a bigger application this is too much code I have to write by hand. So, here was where I needed the Java reflection. I needed to go through each field of FormEditor and find the members that implements the Erroable interface and check if the Map has a key with the same name and the call the setErros(List) on that members… you get it, right?

This could be done in runtime if I have access to Java reflection features in GWT, but I don’t and what I can have in GWT is code generation at compile time, so the solution to the problem can be slightly different than doing it with Java Reflection, but If I can generate that boilerplate code it would be great.

From here I digged into GWT code generation, and borrow some ideas from the UIBinder.

My UserEditor.java has now something like this:

public class UserEditor extends Composite implements CompositeEditor<User> {

private static UserEditorErrorBinder errorBinder = GWT
			.create(UserEditorErrorBinder.class);

interface UserEditorErrorBinder extends ErrorBinder<UserEditor> {

	}
}

The ErrorBinder interface is defined as:

public interface ErrorBinder<T> {
	public void bindErrors(T editor, Map<String, List<String>> errors);
}

Now I have to implement one generator that generate the code that implements the method bindErrors with my desired logic.

After solving many puzzles, I came out with the this generator code that you can borrow to do your own generators in GWT:

public class ErrorBinderGenerator extends Generator {

	private String implPackageName;

	private String implTypeName;
	private JClassType parameterizedType;

	public String generate(TreeLogger logger, GeneratorContext context,
			String requestedClass) throws UnableToCompleteException {

		TypeOracle typeOracle = context.getTypeOracle();

		JClassType objectType = typeOracle.findType(requestedClass);
		if (objectType == null) {
			logger.log(TreeLogger.ERROR, "Could not find type: "
					+ requestedClass);
			throw new UnableToCompleteException();
		}

		implTypeName = objectType.getSimpleSourceName() + "Impl";

		implPackageName = objectType.getPackage().getName();

		JClassType[] implementedTypes = objectType.getImplementedInterfaces();

		// Can only implement one interface
		if (implementedTypes == null
				|| implementedTypes.length != 1
				|| !implementedTypes[0].getQualifiedSourceName().equals(
						ErrorBinder.class.getName())) {
			logger.log(TreeLogger.ERROR, "The type: " + requestedClass
					+ " Must implement only one interface: "
					+ ErrorBinder.class.getName());
			throw new UnableToCompleteException();
		}

		// Get parameterized type
		JParameterizedType parameterType = implementedTypes[0]
				.isParameterized();
		if (parameterType == null) {
			logger.log(TreeLogger.ERROR, "The type: " + requestedClass
					+ " Must implement only one parameterized interface: "
					+ ErrorBinder.class.getName());
			throw new UnableToCompleteException();
		}

		if (parameterType.getTypeArgs() == null

		|| parameterType.getTypeArgs().length != 1) {
			logger.log(TreeLogger.ERROR, "The type: " + requestedClass
					+ " Must implement only one parameterized interface: "
					+ ErrorBinder.class.getName() + " with only onde Parameter");
			throw new UnableToCompleteException();

		}

		parameterizedType = parameterType.getTypeArgs()[0];

		ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(
				implPackageName, implTypeName);

		composerFactory.addImport(Map.class.getCanonicalName());
		composerFactory.addImport(List.class.getCanonicalName());
		composerFactory.addImplementedInterface(objectType
				.getQualifiedSourceName());

		PrintWriter printWriter = context.tryCreate(logger, implPackageName,
				implTypeName);
		if (printWriter != null) {

			SourceWriter sourceWriter = composerFactory.createSourceWriter(
					context, printWriter);

			composeBindErrorsMethod(sourceWriter);
			sourceWriter.commit(logger);

		}
		return implPackageName + "." + implTypeName;
	}

	private void composeBindErrorsMethod(SourceWriter sourceWriter) {

		sourceWriter.print("public void bindErrors("
				+ parameterizedType.getQualifiedSourceName()
				+ " erroable, Map<String, List<String>> errors) {");
		sourceWriter.print("  System.out.println(\"Implement it now:)\");");
		sourceWriter.print("}");

	}
}

Now I have only to generate the code for bindErrors and implement the setFiledErrors method in my UserEditor like this:

	public void setFieldErrors(Map<String, List<String>> fieldErrors) {
		errorBinder.bindErrors(this, fieldErrors);
	}

I hope this can help someone to bootstrap their own GWT generators.

Well, it’s so easy to make this automatically with Javascript and JQuery…

$("input:visible:enabled:first").focus();

Pior ainda, é que algumas das mensagens estavam duplicadas (Português e Inglês), como podem ver ali na imagem à esquerda.

Mas há quem faça pior. Há quem insista em partilhar tudo nas redes sociais. Por vezes parece que estou a ver a caixa de entrada do email de algumas pessoas, se me enviarem o número do cartão de crédito agradecia

No Google Buzz, que estou a ponderar desactivar, recebi a seguinte mensagem do stream de alguém:

Alguém quer lhe conhecer no Badoo!

Outra pessoa por perto quer lhe conhecer. Vá até o Badoo e veja se a atração é mútua. Decida quem você quer conhecer!

http://ping.fm/—–

Obrigado,
A Equipe Badoo

Esta é uma mensagem de envio somente. Respostas a esta mensagem não são monitoradas ou respondidas.
Você recebeu esta mensagem como um usuário registrado no ,
para controlar que emails você recebe, por favor, modifique as suas configurações:

http://ping.fm/—-

WTF? Então só para passar o tempo, segui o primeiro link e qual é a minha surpresa que estava agora na posse de uma conta desse serviço (Badoo), com acesso à conta por completo… pena não se algo que me interessasse mais

Já não é a primeira vez que isto me acontece. Da última vez foi alguém, com o mesmo nome que eu e provavelmente com um endereço de email muito parecido, que se enganou a introduzir o email no Hi5 e lá fiquei com acesso completo à conta do rapaz…

Se quiserem dar acesso às vossas contas de serviços de redes sociais e outros, utilizem um serviço que publique a vossa caixa de correio no stream do Buzz e outros streams.

Ficam avisados

Cliente: queria saber qual é o melhor plano para acesso à internet através do telemóvel sem carregamentos obrigatórios.

TMN: Zzzzz!! Zzzzz!!

Cliente: estão-me a ouvir?

TMN: Zzzzzz!! Zzzzz!!

Isto não aconteceu com o 1696 mas aconteceu com o Twitter. A TMN tem uma conta do twitter @tmn_pt, mas não responde a estas questões através do Twitter…. Não sei se eles querem propositadamente ignorar este canal de comunicação ou então não perceberam ainda que o Twitter também serve para eles se relacionarem com os clientes e não apenas para fazer publicidade.

http://twitter.com/joaomrpereira/statuses/6836740450

O que acham? Acham que a TMN poderia usar o Twitter sem ser apenas para fazer publicidade mas também para responder a questões dos clientes?