Spring Boot and RESTful API(14)Spring Boot with AKKA

Spring Boot and RESTful API(14)Spring Boot with AKKA

Logging Performance
https://www.slf4j.org/faq.html#logging_performance
logger.debug("The new entry is {}. It replaces {}.", entry, oldEntry);

Add AKKA to my Spring Boot Project
pom.xml

<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-actor_2.12</artifactId>
    <version>2.4.19</version>
</dependency>
<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-slf4j_2.12</artifactId>
    <version>2.4.19</version>
</dependency>

In the main class, system will initiate the AKKA system.
package com.sillycat.jobsmonitorapi;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.scheduling.annotation.EnableScheduling;
import com.sillycat.jobsmonitorapi.akka.base.SpringExtension;
import com.sillycat.jobsmonitorapi.service.JobDynamicCronService;

import akka.actor.ActorRef;
import akka.actor.ActorSystem;

@SpringBootApplication
@EnableScheduling
public class JobsMonitorAPIApplication extends SpringBootServletInitializer {

    private static final Logger logger = LoggerFactory.getLogger(JobsMonitorAPIApplication.class);

    public static void main(String[] args) throws Exception {
        ConfigurableApplicationContext context = SpringApplication.run(JobsMonitorAPIApplication.class);

        logger.info("Start to init the AKKA system...");
        SpringExtension ext = context.getBean(SpringExtension.class);
        ActorSystem system = context.getBean(ActorSystem.class);
        ActorRef supervisor = system.actorOf(ext.props("outOfBudgetSupervisor").withMailbox("akka.priority-mailbox"),
                "outOfBudgetSupervisor");
        logger.info("supervisor init with path {}", supervisor.path());
        logger.info("AKKA system success inited...");
        logger.info("Start the cron tasks to monitor ");
        context.getBean(JobDynamicCronService.class).startCron();
        logger.info("Cron tasks started! ");
    }

}

In the configuration Directory, system will auto set up the ENV
package com.sillycat.jobsmonitorapi.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

import com.sillycat.jobsmonitorapi.akka.base.SpringExtension;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;

import akka.actor.ActorSystem;

@Configuration
@Lazy
@EnableAutoConfiguration
@ComponentScan(basePackages = { "com.sillycat.jobsmonitorapi.akka" })
public class ApplicationConfiguration {

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private SpringExtension springExtension;

    @Bean
    public ActorSystem actorSystem() {
        ActorSystem system = ActorSystem.create("JobsMonitorAPIAKKA", akkaConfiguration());
        springExtension.initialize(applicationContext);
        return system;
    }

    @Bean
    public Config akkaConfiguration() {
        return ConfigFactory.load();
    }

}

My system will be named as JobsMonitorAPIAKKA, some base class will help Actor use Spring and Spring Bean find Actor
package com.sillycat.jobsmonitorapi.akka.base;

import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import com.sillycat.jobsmonitorapi.akka.base.SpringActorProducer;
import akka.actor.Extension;
import akka.actor.Props;

@Component
public class SpringExtension implements Extension {

    private ApplicationContext applicationContext;

    public void initialize(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    public Props props(String actorBeanName) {
        return Props.create(SpringActorProducer.class, applicationContext, actorBeanName);
    }

}


package com.sillycat.jobsmonitorapi.akka.base;

import org.springframework.context.ApplicationContext;
import akka.actor.Actor;
import akka.actor.IndirectActorProducer;

public class SpringActorProducer implements IndirectActorProducer {

    private final ApplicationContext applicationContext;
    private final String actorBeanName;

    public SpringActorProducer(ApplicationContext applicationContext, String actorBeanName) {
        this.applicationContext = applicationContext;
        this.actorBeanName = actorBeanName;
    }

    @Override
    public Actor produce() {
        return (Actor) applicationContext.getBean(actorBeanName);
    }

    @SuppressWarnings("unchecked")
    @Override
    public Class<? extends Actor> actorClass() {
        return (Class<? extends Actor>) applicationContext.getType(actorBeanName);
    }

}

Customized PriorityMaiBox Policy help system to priority the messages
package com.sillycat.jobsmonitorapi.akka.base;

import com.sillycat.jobsmonitorapi.akka.msg.OutOfBudgetJobMsg;
import com.typesafe.config.Config;

import akka.actor.ActorSystem;
import akka.dispatch.PriorityGenerator;
import akka.dispatch.UnboundedPriorityMailbox;

public class PriorityMailbox extends UnboundedPriorityMailbox {

    public PriorityMailbox(ActorSystem.Settings settings, Config config) {

        // Create a new PriorityGenerator, lower priority means more important
        super(new PriorityGenerator() {

            @Override
            public int gen(Object message) {
                if (message instanceof OutOfBudgetJobMsg) {
                    return ((OutOfBudgetJobMsg) message).getPriority();
                } else {
                    // default
                    return 100;
                }
            }
        });

    }
}

Message POJO will be as normal, just add one priority column
package com.j2c.jobsmonitorapi.akka.msg;

public class OutOfBudgetJobMsg {

private String id;

private Integer sourceID;

private Integer campaignID;

private String jobReference;

private Boolean paused;

private Boolean dailyCapped;

private Boolean deduped;

private Boolean expired;

private Integer priority;

public OutOfBudgetJobMsg(String id) {
this.id = id;
this.priority = 10;
}
public OutOfBudgetJobMsg(String id, Integer sourceID, Integer campaignID, String jobReference, Boolean paused,
Boolean dailyCapped, Boolean deduped, Boolean expired) {
this.id = id;
this.sourceID = sourceID;
this.campaignID = campaignID;
this.jobReference = jobReference;
this.paused = paused;
this.dailyCapped = dailyCapped;
this.deduped = deduped;
this.expired = expired;
this.priority = 10;
}
…snip...

}

Here is my Actor
package com.sillycat.jobsmonitorapi.akka.actor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import com.sillycat.jobsmonitorapi.akka.msg.OutOfBudgetJobMsg;
import com.sillycat.jobsmonitorapi.domain.JobCloud;
import com.sillycat.jobsmonitorapi.repository.JobCloudPartialRepositorySolr;
import akka.actor.UntypedActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;

@Component
@Scope("prototype")
public class OutOfBudgetActor extends UntypedActor {

    private final LoggingAdapter logger = Logging.getLogger(getContext().system(), "TaskProcessor");

    @Autowired
    JobCloudPartialRepositorySolr jobCloudPartialRepositorySolr;

    @Override
    public void onReceive(Object message) throws Exception {
        if (message instanceof OutOfBudgetJobMsg) {
            logger.debug("Message we receive is {}", message);
            OutOfBudgetJobMsg msg = (OutOfBudgetJobMsg) message;
            jobCloudPartialRepositorySolr.update(new JobCloud(msg.getId(), msg.getSourceID(), msg.getCampaignID(),
                    msg.getJobReference(), msg.getPaused(), msg.getDailyCapped(), msg.getDeduped(), msg.getExpired()),
                    false);
            // String id, Integer sourceID, Integer campaignID, String
            // jobReference, Boolean paused,
            // Boolean dailyCapped, Boolean deduped, Boolean expired
            logger.debug("Update the status back to SOLR ");
        } else {
            logger.error("outOfBudgetActor receive msg = {} msg type = {}", message, message.getClass());
            unhandled(message);
        }

    }

}

Here is my SupervisorActor
package com.sillycat.jobsmonitorapi.akka.actor;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import com.sillycat.jobsmonitorapi.akka.base.SpringExtension;
import com.sillycat.jobsmonitorapi.akka.msg.OutOfBudgetJobMsg;

import akka.actor.ActorRef;
import akka.actor.Terminated;
import akka.actor.UntypedActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;
import akka.routing.ActorRefRoutee;
import akka.routing.Routee;
import akka.routing.Router;
import akka.routing.SmallestMailboxRoutingLogic;

@Component
@Scope("prototype")
public class OutOfBudgetSupervisor extends UntypedActor {

    private final LoggingAdapter logger = Logging.getLogger(getContext().system(), "OutOfBudgetSupervisor");

    @Autowired
    private SpringExtension springExtension;

    private Router router;
   
    @Value("${outofBudgetActorCount}")
    private Integer outofBudgetActorCount;

    public void preStart() throws Exception {
        logger.info("Init the operation on OutOfBudget...");
        List<Routee> routees = new ArrayList<Routee>();
        for (int i = 0; i < this.outofBudgetActorCount; i++) {
            ActorRef actor = getContext().actorOf(springExtension.props("outOfBudgetActor"));
            getContext().watch(actor);
            routees.add(new ActorRefRoutee(actor));
        }
        router = new Router(new SmallestMailboxRoutingLogic(), routees);
        super.preStart();
        logger.info("Init the operation on OutOfBudget success!");
    }

    public void onReceive(Object msg) throws Exception {
        if (msg instanceof OutOfBudgetJobMsg) {
            router.route(msg, getSender());
        } else if (msg instanceof Terminated) {
            router = router.removeRoutee(((Terminated) msg).actor());
            ActorRef actor = getContext().actorOf(springExtension.props("outOfBudgetActor"));
            getContext().watch(actor);
            router = router.addRoutee(new ActorRefRoutee(actor));
        } else {
            logger.error("Unable to handle msg {}", msg);
        }
    }

    public void postStop() throws Exception {
        logger.info("Shutting down OutOfBudgetSupervisor");
        super.postStop();
    }
}

The configuration file application.conf will be as follow:
akka {

  loggers = ["akka.event.slf4j.Slf4jLogger"]

  # Log level used by the configured loggers (see "loggers") as soon
  # as they have been started; before that, see "stdout-loglevel"
  # Options: OFF, ERROR, WARNING, INFO, DEBUG
  loglevel = "DEBUG"

  # Log level for the very basic logger activated during ActorSystem startup.
  # This logger prints the log messages to stdout (System.out).
  # Options: OFF, ERROR, WARNING, INFO, DEBUG
  stdout-loglevel = "DEBUG"

  priority-mailbox {
    mailbox-type = "com.sillycat.jobsmonitorapi.akka.base.PriorityMailbox"
  }

}

References:
http://kimrudolph.de/blog/spring-boot-meets-akka
https://github.com/krudolph/akkaflow
https://www.slf4j.org/faq.html#logging_performance