Spark Framework
Spark - A tiny Sinatra inspired framework for creating web applications in Java 8 with minimal effort

Spark - a Sinatra inspired web framework

For more detailed documentation please go to: http://sparkjava.com

NEWS: Spark 2.3 is now available on Maven central! :

    <dependency>
        <groupId>com.sparkjava</groupId>
        <artifactId>spark-core</artifactId>
        <version>2.3</version>
    </dependency>

NEWS: Spark google group created: https://groups.google.com/d/forum/sparkjava

Temporary API Docs: http://spark.screenisland.com

Built for Productivity

Spark Framework is a simple and lightweight Java web framework built for rapid development.

Spark's intention isn't to compete with Sinatra, or the dozen of similar web frameworks in different languages, but to provide a pure Java alternative for developers that want to, or are required to, develop their web application in Java.

Spark focuses on being as simple and straight-forward as possible, without the need for cumbersome (XML) configuration, to enable very fast web application development in pure Java with minimal effort.

It’s a totally different paradigm when compared to the overuse of annotations for accomplishing pretty trivial stuff seen in other web frameworks, for example, JAX-RS implementations.

Why Use Spark? GitHub

If you're a Java developer with neither the urge nor time to learn a new programming language, then Spark might be a great web framework for you. It will have you up and running in minutes, and you won't have to think too much about configuration and boilerplate code (like you often have to in other Java web frameworks, like Spring or Vaadin).

Why Not Use Sinatra?

If you're an experienced Ruby developer, or have experience with languages with similar syntax, you should probably use Sinatra. However, if you're a Java developer and want to get the benefits you get from Sinatra without having to learn a new language, Spark is a very good alternative. Spark is a simple and lightweight Java web framework that doesn't get in your way!

Why Not Go with JAX-RS?

JAX-RS made life easier for Java web developers when it arrived. However, it's a bit messy due to the overuse of annotations for accomplishing pretty trivial things. The annotation magic also makes things more implicit, and it's not always easy to get a clear understanding of what's going on. For people who are new to web frameworks and REST, Spark will have you up and running much faster than using one of the JAX-RS implementations

https://sparktutorials.github.io/

Quick Start

import static spark.Spark.*;

public class HelloWorld {
    public static void main(String[] args) {
        get("/hello", (req, res) -> "Hello World");
    }
}

Run and View

http://localhost:4567/hello

How to connect to database using spark java framework.

Spark and Databases: Configuring Spark to work with Sql2o in a testable way

Designing the Model

Let’s assume you have access to a database. During development I would suggest to use a MySQL server running in a Docker container:

if you are already using Docker do not miss the tutorial on running Spark inside a Docker container
if you are new to Docker you could check out a tutorial I wrote about getting started with Docker from a developer point of view .

Docker or non Docker, I would assume you can now connect to your database.
Now let’s start to setup the dependencies in Maven: In addition to the Spark dependencies, you should add Sql2o and the jdbc extension specific to the database you are going to connect to. In my case I choose MySQL:

<dependency>

 <groupId>org.sql2o</groupId> 
     

 <artifactId>sql2o</artifactId> 
     

 <version>1.5.4</version> 
 

</dependency> 
 

<dependency>
   <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.37</version>
</dependency>

Create Table in database

This is the schema we are going to use:

CREATE USER team_lead WITH PASSWORD 'sparkMicroSvc';
CREATE DATABASE team_lead;
\connect team_lead
GRANT ALL PRIVILEGES ON DATABASE team_leadTO team_lead;

CREATE TABLE IF NOT EXISTS `teams` (
  `TEAM_ID` int(11) NOT NULL AUTO_INCREMENT,

 `TEAM_NAME` varchar(255) DEFAULT NULL,
  `PLAYER_NAME` varchar(255) DEFAULT NULL,
  `CREATED_ON` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `UPDATED_ON` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`TEAM_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO team_lead;

Now, let’s start by defining a Model interface and one interface for each table

of the database, with no references to the library we are going to use (Sql2o).

The rest of your code will depend on this interface, not on the concrete implementation

based on Sql2o that we are going to build.

This will permit us to have testable code.

For example we could use in our tests a dummy implementation storing data in memory.

public interface Model {
    Integer createTeam(String teamName, String playerName);
    List getAllTeams();
    Team getTeam(Integer teamId);
}

@Data
public class Team{
    private Integer team_id;
    private String team_name;
    private String player_name;
    private Timestamp created_on;
    private Timestamp updated_on;
}

Implement the Model using Sql2o

Great! It is now time to write some code that could actually integrate with a real database. The code it is pretty straightforward, if you know your SQL:

public class Sql2oModel implements Model {

private Sql2o sql2o;

      public Sql2oModel(Sql2o sql2o) {

this.sql2o = sql2o;
}

       @Override

       public Integer createTeam(String teamName, String playerName) {
        try (

            Connection conn = sql2o.open()) {
            conn.createQuery("insert into TEAMS(team_name,player_name,created_on,updated_on) VALUES (:teamName, :playerName, :created_on, :updated_on)")
                    .addParameter("team_name", teamName)
                    .addParameter("player_name", playerName)
                    .addParameter("created_on", System.currentTimeMillis())
                    .addParameter("updated_on", System.currentTimeMillis())
                   .executeUpdate();
            Integer teamId = conn.createQuery("select team_id from TEAMS where team_name = :teamName and player_name = :playerName");

            return teamId;
        }

    @Override
    public List<Team> getAllTeams() {
        try (

            Connection conn = sql2o.open()) {

            List<Team> teams = conn.createQuery("select * from teams").executeAndFetch(Team.class);

            return teams;
        }
    }

    @Override
    public Team getTeam(Integer teamId) {
        try (

              Connection conn = sql2o.open()) {

              Team team = conn.createQuery("select * from teams where team_id = :teamId")

              .addParameter("team_id",teamId);

              .executeAndFetch(Team.class);

              return teams;
        }
    }
  }

A few comments:

when we want to execute several operations atomically (i.e., so if one fails no changes are persisted) we use a transaction, otherwise we just open a connection. We use the try-resource mechanism introduced in Java 8, so whatever happens transactions and connections are closed for us.
our queries a micro-templates where values preceded by a colon are replaced by the values specified using addParameter
when we do a select we can use executeAndFetch and Sql2o will auto-magically map the result, creating a list of objects of the given type and setting the fields corresponding to the names of the columns. We can also map to simple types like a Strings when we have just one column

This is probably all you need to know about Sql2o to write pretty complex services. Maybe you just need to refresh your SQL.

Controllers

At this point we just need to use our model. Let’s see how to write the main method of our application:

public static void main( String[] args) {
    CommandLineOptions options = new CommandLineOptions();
    new JCommander(options, args);

    logger.finest("Options.debug = " + options.debug);
    logger.finest("Options.database = " + options.database);
    logger.finest("Options.dbHost = " + options.dbHost);
    logger.finest("Options.dbUsername = " + options.dbUsername);
    logger.finest("Options.dbPort = " + options.dbPort);
    logger.finest("Options.servicePort = " + options.servicePort);

    port(options.servicePort);

    Sql2o sql2o = new Sql2o("jdbc:mysql://" + options.dbHost + ":" + options.dbPort + "/" + options.database,
            options.dbUsername, options.dbPassword, null);

    Model model = new Sql2oModel(sql2o);

    // insert a team (using HTTP post method)
    post("/teams", (request, response) -> {
        ObjectMapper mapper = new ObjectMapper();
        Team creation = mapper.readValue(request.body(), Team.class);
        if (!creation.isValid()) {
            response.status(HTTP_BAD_REQUEST);
            return "";
        }
        Integer teamId = model.createTeam(creation.getTeamName(), creation.getPlayerName());
        response.status(200);
        response.type("application/json");
        return teamId;
    });

    // get all team (using HTTP get method)
    get("/teams", (request, response) -> {
        response.status(200);
        response.type("application/json");
        return dataToJson(model.getAllTeams());
    });

    get("/teams/:teamId", (request, response) -> {
        Team team = model.getTeam(request.params(":teamId"));
        if (!model.getTeam(teamId)) {
            response.status(400);
            return "";
        }
        response.status(200);
        response.type("application/json");
        return dataToJson(model.getTeam(teamId));
    });

 }