Using Jason with Spring Boot

[mindcrime]

Team:

I've been doing some work on using Jason within a Spring Boot application, with a goal of being able to inject Spring managed components into things like Agents, AgentArch's, Environments, and (maybe) BeliefBases.

So far, I have injection into Agent classes and Environment classes working. And (thankfully) accomplishing this required no modifications to any Jason code. I just added a new class that's basically a copy of RunLocalMAS and use the Spring AutowireCapableBeanFactory to inject into the various instances. For example, the Environment part looks like this:

	protected void createEnvironment() throws JasonException
	{
		if (project.getEnvClass() != null && !project.getEnvClass().getClassName().equals(jason.environment.Environment.class.getName())) 
		{
            logger.fine("Creating environment " + project.getEnvClass());
            env = new LocalEnvironment(project.getEnvClass(), this);
        
            
            // Spring injection for Environment instance
            appContext.getAutowireCapableBeanFactory().autowireBeanProperties( env.getUserEnvironment(),
    			    AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);
            
		}		
		
	}

Unfortunately doing Agents was a little bit harder, since it doesn't seem to be easy to get your hand on the Agent class instance where the Agents are created. I did have to subclass LocalAgArch and add a new method that is identical to createArchs except for making the return type "Agent" and returning the Agent class there. From that point, I was able to use my new method and the same pattern as above:

                    if ((generalConf != RConf.THREADED) && cAg > 0 && ap.getAgArchClasses().isEmpty() && ap.getBBClass().getClassName().equals(DefaultBeliefBase.class.getName())) 
                    {
                        // creation by cloning previous agent (which is faster -- no parsing, for instance)
                        agArch.createArchs(ap.getAgArchClasses(), pag);
                    } 
                    else 
                    {
                        // normal creation
                        Agent agent = agArch.createArchs2(ap.getAgArchClasses(), ap.agClass.getClassName(), ap.getBBClass(), ap.getSource().toString(), ap.getAsSetts(debug, project.getControlClass() != null));

                        // Spring injection for Agent classes 
                        appContext.getAutowireCapableBeanFactory().autowireBeanProperties( agent,
                			    AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);
                    
                    }

                    addAg(agArch);
                    createdAgents.add(agArch); // used later to start

Anyway, that's working now and my goal is to be able to extend this to support the AgentArch classes and BeliefBase classes. It would be really handy, I think, to have the ability to easily use things like Spring Data JPA in a BeliefBase for persistence, etc.

Once I get all of this working (assuming I do) and clean this code up a bit I'll put the entire source up in my repo and share with everybody. And in the off chance there is any appetite for including something like this in Jason, I'm happy to contribute my work if it will be of use to anybody.

EDIT: I went ahead and uploaded the code in its current state, just in case anyone is interested in looking at this. The bulk of the work is in the RunSpringMAS.java file.

[jomifred]

Hi, thanks for sharing!

I am not used to Spring.... so what kind of functionality is being added? (or what we can do with that proposal?)

For getting the references of the instance of Agent class, usually, from the AgArch, you can do .getTS().getAg().

[mindcrime]

For getting the references of the instance of Agent class, usually, from the AgArch, you can do .getTS().getAg().

Oh, excellent. Then maybe I can get rid of that extra class. Let me try that.

I am not used to Spring.... so what kind of functionality is being added? (or what we can do with that proposal?)

That could take a lot of words to answer for folks who aren't familiar with Spring. Let me think for a bit and I'll get back to you.

[mindcrime]

OK, I changed my RunSpringMAS class to use the technique you described above Jomi. That means I can delete the SpringLocalAgArch altogether, which makes this a bit cleaner.

Now the injection into Agents just looks like this:

                    if ((generalConf != RConf.THREADED) && cAg > 0 && ap.getAgArchClasses().isEmpty() && ap.getBBClass().getClassName().equals(DefaultBeliefBase.class.getName())) 
                    {
                        // creation by cloning previous agent (which is faster -- no parsing, for instance)
                        agArch.createArchs(ap.getAgArchClasses(), pag);
                    } 
                    else 
                    {
                        // normal creation
                        agArch.createArchs(ap.getAgArchClasses(), ap.agClass.getClassName(), ap.getBBClass(), ap.getSource().toString(), ap.getAsSetts(debug, project.getControlClass() != null));
                    
                    }

                    Agent agent = agArch.getTS().getAg();
                    
                    // Spring injection for Agent classes 
                    appContext.getAutowireCapableBeanFactory().autowireBeanProperties( agent,
            			    AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);

                    
                    addAg(agArch);
                    createdAgents.add(agArch); // used later to start

Full source code for this example is here.

Next up I'm going to try to get injection working for the AgentArch (I think that's going to be trivial) and for BeliefBase classes (less clear how difficult that will be). If/when I get all four scenarios working, I'll work on putting together some demo apps that show off the benefit of using Spring like this. But briefly, I think the benefit will come mainly in scenarios where one wants to integrate Jason apps with existing code / legacy systems / databases, etc. Spring includes a number of pre-built modules that simplify working with JMS and message queueing systems ("message driven POJO's"), databases using Java Persistence API, LDAP, and even LLM integration. And if one buys into the overall idea behind dependency injection to begin with (that it simplifies code and makes it less brittle) then I think it's fair to say that Spring is the standard DI container among Java developers in industry.

I think it's also fair to say that the Spring business probably has more value to people who are using Jason to build real-world systems that need to integrate with stuff. Researchers working on the internals of Jason, the core AgentSpeak language, etc. might not find much benefit in this.

[mindcrime]

I've extended this now to work for the AgentArch class as well as BeliefBase implementations. For this most part this was a straight-forward extension of what I did earlier, but the BeliefBase bit did require a little extra trickery because of some details of how the BB creation process works.

The bulk of the processing is still just this kind of stuff, which we saw above:

                    else 
                    {
                        // normal creation
                        agArch.createArchs(ap.getAgArchClasses(), ap.agClass.getClassName(), ap.getBBClass(), ap.getSource().toString(), ap.getAsSetts(debug, project.getControlClass() != null));
                    
                    }

                    System.out.println( "About to do Spring injection!" );
                    logger.info( "About to do Spring injection!" );
                    
                    AgArch agentArch = agArch.getTS().getAgArch();
                    Agent agent = agArch.getTS().getAg(); 
                    BeliefBase bb = agent.getBB();
                    
                    System.out.println( "bb: " + bb );
                    
                    // Spring injection for AgentArch classes 
                    appContext.getAutowireCapableBeanFactory().autowireBeanProperties( agentArch,
            			    AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);

                    
                    // Spring injection for Agent classes 
                    appContext.getAutowireCapableBeanFactory().autowireBeanProperties( agent,
            			    AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);


                    // Spring injection for BeliefBase classes 
                    appContext.getAutowireCapableBeanFactory().autowireBeanProperties( bb,
            			    AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);

                    
                    addAg(agArch);
                    createdAgents.add(agArch); // used later to start

But unfortunately this fails if you stop here, assuming the custom BeliefBase impl has some service injected into it and uses that service in the add() method (which seems like a reasonable assumption - the thing you'd be injecting would likely be a Spring CrudRepository, or JDBCTemplate, etc). That's because inside the Agent class, when after the BB is instantiated, initialBeliefs are add()'d to the BB immediately, before the create method returns. This means that before the AutowireCapableBeanFactory is even called to do the injection, we've already blown up with a NullPointerException. Blimey. 👎

Fortunately the fix isn't too bad. I mean, yeah, it's a little bit ugly, but not a completely brutal hack. Briefly, you just need to create a static holder for the ApplicationContext with a public getter, and then in the constructor of the BeliefBase class, you retrieve the ApplicationContext, and use it to inject into the current object.

Something like this works:

public class MyBeliefBase2 extends DefaultBeliefBase
{
	private Logger logger = Logger.getLogger( MyBeliefBase2.class.getName() );

	@Autowired
	MyService myService;

	public MyBeliefBase2()
	{
		ApplicationContext appContext = SpringContextHolder.getAppContext();
		
		appContext.getAutowireCapableBeanFactory().autowireBeanProperties( this, AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false );
	}
	
	@Override
	public boolean add( Literal l )
	{
		logger.info(  "add: " + myService.getRandomData( 12 )  );
		return super.add( l );	
	}

and the "holder" class is just:

@Component
public class SpringContextHolder implements ApplicationContextAware
{
	private static ApplicationContext appContext;
	
	@Override
	public void setApplicationContext( ApplicationContext applicationContext )
			throws BeansException
	{
		appContext = applicationContext;
	}
	
	public static ApplicationContext getAppContext()
	{
		return appContext;
	}
	
}

Source code can be found here.

So at this point I've achieved my goal of allowing for injection into Environment, AgentArch, Agent, and BeliefBase classes. I'll use this for some of my own work for sure. And if others find it useful, I'm happy to either make a standalone library that can be added to a Java project to support this, and/or work with the Jason maintainers to incorporate it into Jason itself.

And again, I'll work up some samples later to illustrate why this is even useful. These little contrived test scenarios I've been using don't really communicate anything much beyond "Yes, this is possible." :-)