Latest posts for the topic "Using Mentawai along with Guice"

Using Mentawai along with Guice

Sven — GMT

Hi Mentawai'ans ;) I've adopted Google Guice recently. I'm using Guice instead of the Mentawai Dependency Injection functionality since my project consists of several subprojects, only one of them being a web application. Also I think that Guice is more powerful for DI (no offense!) and I like configuration by annotations. Anyway, I ask myself why the ActionConfig constructor can only take classes and no instances of objects. Latter would improve the integration of Guice in Mentawai: Let's say there's a SearchAction class. Since the search is performed on a database, an instance of SearchAction holds an instance of Database (the service) Code:

class SearchAction extends BaseAction {
  private Database database;

  @Inject
  public SearchAction( Database database ) {
    this.database = database;
  }

  // other methods
}

Assuming Guice has been properly configured and an Injector instance has been created, the action could be configured like this: Code:

ActionConfig = new ActionConfig( "/search", injector.getInstance( SearchAction.class ) );

Is there any good reason why the ActionConfig constructor only takes classes? If it would also take instances it could hold these instances until the corresponding action is called. Even if no DI framework is used this could improve Mentawai because custom constructors of the actions could be called.

Re:Using Mentawai along with Guice

saoj — GMT

The only reason why Mentawai takes classes and NOT instances is because a new instance is created for each new request. This will make the actions thread-safe. If we make the ActionConfig take an instance, then you must make sure your instance is thread-safe. I have no objection of providing an ActionConfig that takes an instance, but we should not encourage its usage, unless it is really a necessity and the guy knows what he is doing. Now talking about DI, I also like Guice. I understand that you want to use Guice, but allow me to illustrate how your case can be easily solved with Mentawai DI: Code:

filter(new IoCFilter());
filter(new InjectionFilter());

ioc("database", MyDatabaseImpl.class, APPLICATION); // you can also use REQUEST and SESSION

And your action: Code:

class SearchAction extends BaseAction {
   
   private Database database;
 
   // other methods
 }

You can use a setter, but you do not need one. Injection will happen straight in the private field by the InjectionFilter.

Re:Using Mentawai along with Guice

saoj — GMT

I think I found out what you were looking for, Sven. Mentawai already comes with it. SingleInstanceActionConfig: This action config will accept an action instance and it will always return this same instance to all requests: http://www.mentaframework.org/api/org/mentawai/core/SingleInstanceActionConfig.html

API DOC wrote:

Use this action config if you want your action to be a single instance for all requests, in other words, you don't want to create a new instance of your action for every request. If you use this action config, it is your responsibility to make your action thread-safe. If you are not sure that your action is thread-safe, than you should not use this action config. Sometimes our actions are so simple (Ex: org.mentawai.action.SuccessAction) that it doesn't make sense to create a new instance for every request.

SingleInstanceBaseAction: Extend this class if you want an single-instance AND single-threaded action. This will make all the action protected members (input, output, session, etc.) thread safe through ThreadLocals. http://www.mentaframework.org/api/org/mentawai/core/SingleInstanceBaseAction.html

API DOC wrote:

This is the base class for single instance actions, in other words, those actions that will be instantiated only once and shared among all requests. Sometimes, when you looking for every performance drop, you may not want to create a new action instance for every request. This class keeps the action data in thread locals, so that each thread has its own input, output, session, application and locale. The actions extending this class must be configurated with a SingleInstanceActionConfig. It is your responsibility to make your action thread-safe, otherwise you should stick with the BaseAction class.

But now I am very muched pumped to make an good integration of Guice and Mentawai. :-)

Re:Using Mentawai along with Guice

Sven — GMT

Hello Sergjo, I didn't think about thread-safety, pardon me! I could use the SingleInstanceActionConfig but I will also think about a solution how to use Guice with the standard ActionConfig.

Re:Using Mentawai along with Guice

Sven — GMT

By the way, I'm already using Guice functionality which goes beyond that of Mentawai. For example the Database class contains another service, the DatabaseHandler, which does the actual job. There can be different database handlers, a JDODatabaseHandler and a MockDatabaseHandler (for testing). Which handler actually is inserted is configured in a Module class.

Re:Using Mentawai along with Guice

saoj — GMT

I could use the SingleInstanceActionConfig but I will also think about a solution how to use Guice with the standard ActionConfig.

We should think about a filter or something else to provide a very good integration between Mentawai and Guice. Maybe like the Spring integration? Let me know if you come up with something. I will take a look on how Guice works and give it a thought as well.

By the way, I'm already using Guice functionality which goes beyond that of Mentawai. For example the Database class contains another service, the DatabaseHandler, which does the actual job. There can be different database handlers, a JDODatabaseHandler and a MockDatabaseHandler (for testing). Which handler actually is inserted is configured in a Module class.

I think you will be fine using Guice, but just as a reference, you can do that very easily with the Mentawai support for auto-wiring. So you want to insert a DatabaseHandler inside your Database, and the DatabaseHander will have many implementations, right? All you have to do is this: Code:

filter(new IoCFilter());
filter(new DIFilter());
filter(new InjectionFilter());

ioc("database", MyDatabaseImpl.class);
ioc("databaseHandler", JDODatabaseHandler.class);

// auto-wiring
di("databaseHandler", DatabaseHandler.class);

Take a look in the recipe for more details: http://recipes.mentaframework.org/posts/list/14.page

Re:Using Mentawai along with Guice

saoj — GMT

Checking here: http://www.mentaframework.org/spring.jsp?loc=en I think we should create a GuiceActionConfig and a GuiceFilter, pretty much like SpringActionConfig and SpringFilter. Feel free to help here Sven, but only if you have the time and the desire to play with it. :-) Thanks dude!

Re:Using Mentawai along with Guice

Sven — GMT

saoj wrote:

I think we should create a GuiceActionConfig and a GuiceFilter, pretty much like SpringActionConfig and SpringFilter. Feel free to help here Sven, but only if you have the time and the desire to play with it. :-)

Funny, I also thought that we need a GuiceActionConfig. It should have a constructor like this: Code:

GuiceActionConfig( String, com.google.inject.Injector, Class )

I will see if I have the time to implement it. I still don't know how to implement a GuiceFilter yet, though.

Re:Using Mentawai along with Guice

Sven — GMT

Ok, here it is! :) It works in my project but it still needs extensive testing! Code:

package org.mentawai.core;

import org.mentawai.core.Action;
import org.mentawai.core.ActionConfig;
import org.mentawai.core.PojoAction;

import com.google.inject.Injector;

/**
 * ActionConfig to tightly integrate Google Guice.
 * 
 * Use this ActionConfig if you want Guice to create your
 * Action instances and resolve all dependencies.
 * 
 * @author Sven Jacobs 
 * @version 0.1
 */
public class GuiceActionConfig extends ActionConfig {
  private Injector injector;
  
  public GuiceActionConfig( Injector injector, Class klass ) {
    super( klass );
    this.injector = injector;
  }
  
  public GuiceActionConfig( String name, Injector injector, Class klass )
  {
    super( name, klass );
    this.injector = injector;
  }
  
  @Override
  public Action getAction() {
    Object instance = injector.getInstance( actionClass );
    
    if ( Action.class.isAssignableFrom( actionClass ) ) {
      return (Action)instance;
    } else {
      return new PojoAction( instance );
    }
  }
}

EDIT: The org.mentawai.core.* imports are unnecessary. I needed them because I placed GuiceActionConfig in a different package. Feel free to remove them :)

Re:Using Mentawai along with Guice

saoj — GMT

I haved added this filter to org.mentawai.guice I changed the order of the constructor parameters and added another constructor. Take a look: Code:

package org.mentawai.guice;
 
 import org.mentawai.core.Action;
import org.mentawai.core.ActionConfig;
import org.mentawai.core.PojoAction;

import com.google.inject.Injector;
 
 /**
  * ActionConfig to tightly integrate Google Guice.
  * 
  * Use this ActionConfig if you want Guice to create your
  * Action instances and resolve all dependencies.
  * 
  * @author Sven Jacobs 
  * @version 0.1
  */
 public class GuiceActionConfig extends ActionConfig {
	 
   private Injector injector;
   
   public GuiceActionConfig( Class klass, Injector injector ) {
     super( klass );
     this.injector = injector;
   }
   
   public GuiceActionConfig( String name, Class klass, Injector injector ) {
     super( name, klass );
     this.injector = injector;
   }
   
   public GuiceActionConfig( String name, Class klass, String innerAction, Injector injector ) {
	   super( name, klass, innerAction);
	   this.injector = injector;
   }
   
   @Override
   public Action getAction() {
	   
     Object instance = injector.getInstance( actionClass );
     
     if ( Action.class.isAssignableFrom( actionClass ) ) {
    	 
       return (Action) instance;
       
     } else {
    	 
       return new PojoAction( instance );
       
     }
   }
 }

Re:Using Mentawai along with Guice

Sven — GMT

Nice! Is it in the beta jar?

Re:Using Mentawai along with Guice

saoj — GMT

Yes. We are only missing now a GuiceInput, similar to SpringInput. That's to request an object from the input and get it from Guice container. A GuiceFilter would setup the GuiceInput as the action input.

Using Mentawai along with Guice

velo — GMT

Guys, you are both insane! ROFL =P Sven, I like a lot your idea. Never say something earlier because some days I'm lazy =D VELO

Re:Using Mentawai along with Guice

Sven — GMT

@velo: Thank you! :D

saoj wrote:

Yes. We are only missing now a GuiceInput, similar to SpringInput. That's to request an object from the input and get it from Guice container. A GuiceFilter would setup the GuiceInput as the action input.

I'm still thinking how to do it the "Guice" way... The problem is, with the name from the action input alone Guice doesn't know what kind of class to instantiate. So I believe we have to add another layer of configuration, something like this: Code:

GuiceFilter gf = new GuiceFilter()
gf.bind( "myinput", MyClass.class );

addGlobalFilter( gf );

The GuiceFilter then needs to pass this configuration to the GuiceInput... I don't quite like it but I don't see another way. Do you have a better idea?

Using Mentawai along with Guice

velo — GMT

Why don't reuse current ioc method on appManager? http://www.mentaframework.org/ioc.jsp Code:

...
    public void init() {
        
        // Define the IoC components...
        
        ioc("talker1", PortugueseTalker.class);
        
        ioc("talker2", PoliteTalker.class)
            .addProperty("name", "Polite guy");
            
        ioc("talker3", UnpoliteTalker.class, SESSION)
            .addInitValue("Unpolite guy");
            
    }

Re:Using Mentawai along with Guice

saoj — GMT

The problem is, with the name from the action input alone Guice doesn't know what kind of class to instantiate.

I did not know about that. So GUICE cannot instantiate by name and it needs the class as well? hummmm Maybe using the IoC like velo suggested is a way to go. It ties a name to an implementation and also has scopes. We would have a GuiceComponent, something like that. ioc("myclass", guice(MyClass.class)); So when you do a input.getValue("myclass"), the MyClass class will be loaded by Guice.

Using Mentawai along with Guice

velo — GMT

Saoj... The unique problem, today, to use Guice as the default Mentawai ioc is scope? No workaround possible? Maybe when can open an issue to they, when solved guice can become the default ioc on mentawai. Or this is impossible? VELO

Re:Using Mentawai along with Guice

saoj — GMT

I don't want to kill the Mentawai support for IOC. You question is non-sense. :-) I want to add full support to Guice. This is not a government company, where for you to become the director, the director most go away! ;-) We can support Guice and keep the Mentawai IoC support.

Re:Using Mentawai along with Guice

Sven — GMT

saoj wrote:

I did not know about that. So GUICE cannot instantiate by name and it needs the class as well? hummmm

Yes! The Injector#createInstance() method only takes a class as an argument. The Injector then creates an instance of that class (or possibly a subclass if special configuration for this class has been set before).

saoj wrote:

Maybe using the IoC like velo suggested is a way to go. It ties a name to an implementation and also has scopes. We would have a GuiceComponent, something like that. ioc("myclass", guice(MyClass.class)); So when you do a input.getValue("myclass"), the MyClass class will be loaded by Guice.

That looks good!

Re:Using Mentawai along with Guice

Sven — GMT

I think the ApplicationManager should be extended by this method: Code:

public GuiceComponent guice( Class klass,
    com.google.guice.Injector injector ) {
  return new GuiceComponent( klass, injector );
}

or maybe this Code:

public GuiceComponent ioc( String name, Class klass, 
    com.google.guice.Injector injector ) { 
  GuiceComponent gc = new GuiceComponent( klass, injector );
  addComponent( name, gc );
  return gc;
}

The GuiceComponent class should look like this: Code:

class GuiceComponent implements Component {
  private Class klass;
  private Injector injector;

  public GuiceComponent( Class klass, Injector injector ) {
    this.klass = klass;
    this.injector = injector;
  }
  
  @Override
  public Object getInstance() throws InstantiationException {
    return injector.getInstance( klass );
  }
}

Note: The code has not been tested! I just typed this into the forum editor :)

Re:Using Mentawai along with Guice

Sven — GMT

What do you think, Sergio?