initial backend with GET and POST routes

Author: Bradley

backend/pom.xml

@@ -14,5 +14,36 @@
       <version>3.8.1</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>com.sparkjava</groupId>
+      <artifactId>spark-core</artifactId>
+      <version>2.6.0</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.gson</groupId>
+      <artifactId>gson</artifactId>
+      <version>2.8.1</version>
+    </dependency>
   </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.6.1</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>exec-maven-plugin</artifactId>
+        <version>1.6.0</version>
+        <configuration>
+          <mainClass>merhoo.backend.App</mainClass>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
 </project>

backend/src/main/java/merhoo/backend/App.java

@@ -1,66 +1,85 @@
-package edu.lehigh.cse216.mfs409.admin;
+package merhoo.backend;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.util.Map;
+// Import the Spark package, so that we can make use of the "get" function to
+// create an HTTP GET route
+import spark.Spark;
+
+// Import Google's JSON library
+import com.google.gson.*;
 
 /**
- * App is our basic admin app.  For now, all it does is connect to the database
- * and then disconnect
+ * For now, our app creates an HTTP server that can only get and add data.
  */
 public class App {
-    /**
-     * The main routine reads arguments from the environment and then uses those
-     * arguments to connect to the database.
-     */
-    public static void main(String[] argv) {
-        // get the Postgres configuration from the environment
-        Map<String, String> env = System.getenv();
-        String ip = env.get("POSTGRES_IP");
-        String port = env.get("POSTGRES_PORT");
-        String user = env.get("POSTGRES_USER");
-        String pass = env.get("POSTGRES_PASS");
+    public static void main(String[] args) {
 
-        // Some students find that they need the following lines
-        // *before DriverManager.getConnection* in order to get the postgres
-        // driver to load
+        // gson provides us with a way to turn JSON into objects, and objects
+        // into JSON.
+        //
+        // NB: it must be final, so that it can be accessed from our lambdas
+        //
+        // NB: Gson is thread-safe.  See
+        // https://stackoverflow.com/questions/10380835/is-it-ok-to-use-gson-instance-as-a-static-field-in-a-model-bean-reuse
+        final Gson gson = new Gson();
 
-        // try {
-        //     Class.forName("org.postgresql.Driver");
-        // } catch (ClassNotFoundException cnfe) {
-        //     System.out.println("Unable to find postgresql driver");
-        //     return;
-        // }
+        // dataStore holds all of the data that has been provided via HTTP
+        // requests
+        //
+        // NB: every time we shut down the server, we will lose all data, and
+        //     every time we start the server, we'll have an empty dataStore,
+        //     with IDs starting over from 0.
+        final DataStore dataStore = new DataStore();
 
-        // conn is a connection to the database.  In this simple example, it is
-        // a local variable, though in a realistic program it might not be
-        Connection conn = null;
+        // GET route that returns all message titles and Ids.  All we do is get
+        // the data, embed it in a StructuredResponse, turn it into JSON, and
+        // return it.  If there's no data, we return "[]", so there's no need
+        // for error handling.
+        Spark.get("/messages", (request, response) -> {
+            // ensure status 200 OK, with a MIME type of JSON
+            response.status(200);
+            response.type("application/json");
+            return gson.toJson(new StructuredResponse("ok", null, dataStore.readAll()));
+        });
 
-        // Connect to the database or fail
-        System.out.print("Connecting to " + ip + ":" + port);
-        try {
-            // Open a connection, fail if we cannot get one
-            conn = DriverManager.getConnection("jdbc:postgresql://" + ip + ":" + port + "/", user, pass);
-            if (conn == null) {
-                System.out.println("\n\tError: DriverManager.getConnection() returned a null object");
-                return;
+        // GET route that returns everything for a single row in the DataStore.
+        // The ":id" suffix in the first parameter to get() becomes
+        // request.params("id"), so that we can get the requested row ID.  If
+        // ":id" isn't a number, Spark will reply with a status 500 Internal
+        // Server Error.  Otherwise, we have an integer, and the only possible
+        // error is that it doesn't correspond to a row with data.
+        Spark.get("/messages/:id", (request, response) -> {
+            int idx = Integer.parseInt(request.params("id"));
+            // ensure status 200 OK, with a MIME type of JSON
+            response.status(200);
+            response.type("application/json");
+            DataRow data = dataStore.readOne(idx);
+            if (data == null) {
+                return gson.toJson(new StructuredResponse("error", idx + " not found", null));
+            } else {
+                return gson.toJson(new StructuredResponse("ok", null, data));
             }
-        } catch (SQLException e) {
-            System.out.println("\n\tError: DriverManager.getConnection() threw a SQLException");
-            e.printStackTrace();
-            return;
-        }
-        System.out.println(" ... successfully connected");
+        });
 
-        System.out.print("Disconnecting from database");
-        try {
-            conn.close();
-        } catch (SQLException e) {
-            System.out.println("\n\tError: close() threw a SQLException");
-            e.printStackTrace();
-            return;
-        }
-        System.out.println(" ...  connection successfully closed");
+        // POST route for adding a new element to the DataStore.  This will read
+        // JSON from the body of the request, turn it into a SimpleRequest
+        // object, extract the title and message, insert them, and return the
+        // ID of the newly created row.
+        Spark.post("/messages", (request, response) -> {
+            // NB: if gson.Json fails, Spark will reply with status 500 Internal
+            // Server Error
+            SimpleRequest req = gson.fromJson(request.body(), SimpleRequest.class);
+            // ensure status 200 OK, with a MIME type of JSON
+            // NB: even on error, we return 200, but with a JSON object that
+            //     describes the error.
+            response.status(200);
+            response.type("application/json");
+            // NB: createEntry checks for null title and message
+            int newId = dataStore.createEntry(req.mTitle, req.mMessage);
+            if (newId == -1) {
+                return gson.toJson(new StructuredResponse("error", "error performing insertion", null));
+            } else {
+                return gson.toJson(new StructuredResponse("ok", "" + newId, null));
+            }
+        });
     }
 }

backend/src/main/java/merhoo/backend/DataRow.java

@@ -0,0 +1,66 @@
+package merhoo.backend;
+
+import java.util.Date;
+
+/**
+ * DataRow holds a row of information.  A row of information consists of
+ * an identifier, strings for a "title" and "content", and a creation date.
+ *
+ * Because we will ultimately be converting instances of this object into JSON
+ * directly, we need to make the fields public.  That being the case, we will
+ * not bother with having getters and setters... instead, we will allow code to
+ * interact with the fields directly.
+ */
+public class DataRow {
+    /**
+     * The unique identifier associated with this element.  It's final, because
+     * we never want to change it.
+     */
+    public final int mId;
+
+    /**
+     * The title for this row of data
+     */
+    public String mTitle;
+
+    /**
+     * The content for this row of data
+     */
+    public String mContent;
+
+    /**
+     * The creation date for this row of data.  Once it is set, it cannot be
+     * changed
+     */
+    public final Date mCreated;
+
+    /**
+     * Create a new DataRow with the provided id and title/content, and a
+     * creation date based on the system clock at the time the constructor was
+     * called
+     *
+     * @param id The id to associate with this row.  Assumed to be unique
+     *           throughout the whole program.
+     *
+     * @param title The title string for this row of data
+     *
+     * @param content The content string for this row of data
+     */
+    DataRow(int id, String title, String content) {
+        mId = id;
+        mTitle = title;
+        mContent = content;
+        mCreated = new Date();
+    }
+
+    /**
+     * Copy constructor to create one datarow from another
+     */
+    DataRow(DataRow data) {
+        mId = data.mId;
+        // NB: Strings and Dates are immutable, so copy-by-reference is safe
+        mTitle = data.mTitle;
+        mContent = data.mContent;
+        mCreated = data.mCreated;
+    }
+}

backend/src/main/java/merhoo/backend/DataRowLite.java

@@ -0,0 +1,29 @@
+package merhoo.backend;
+
+/**
+ * DataRowLite is for communicating back a subset of the information in a
+ * DataRow.  Specifically, we only send back the id and title.  Note that
+ * in order to keep the client code as consistent as possible, we ensure
+ * that the field names in DataRowLite match the corresponding names in
+ * DataRow.  As with DataRow, we plan to convert DataRowLite objects to
+ * JSON, so we need to make their fields public.
+ */
+public class DataRowLite {
+    /**
+     * The id for this row; see DataRow.mId
+     */
+    public int mId;
+
+    /**
+     * The title string for this row of data; see DataRow.mTitle
+     */
+    public String mTitle;
+
+    /**
+     * Create a DataRowLite by copying fields from a DataRow
+     */
+    public DataRowLite(DataRow data) {
+        this.mId = data.mId;
+        this.mTitle = data.mTitle;
+    }
+}

backend/src/main/java/merhoo/backend/DataStore.java

@@ -0,0 +1,86 @@
+package merhoo.backend;
+
+import java.util.ArrayList;
+
+/**
+ * DataStore provides access to a set of objects, and makes sure that each has
+ * a unique identifier that remains unique even after the object is deleted.
+ *
+ * We follow the convention that member fields of a class have names that start
+ * with a lowercase 'm' character, and are in camelCase.
+ *
+ * NB: The methods of DataStore are synchronized, since they will be used from a
+ * web framework and there may be multiple concurrent accesses to the DataStore.
+ */
+public class DataStore {
+    /**
+     * The rows of data in our DataStore
+     */
+    private ArrayList<DataRow> mRows;
+
+    /**
+     * A counter for keeping track of the next ID to assign to a new row
+     */
+    private int mCounter;
+
+    /**
+     * Construct the DataStore by resetting its counter and creating the
+     * ArrayList for the rows of data.
+     */
+    DataStore() {
+        mCounter = 0;
+        mRows = new ArrayList<>();
+    }
+
+    /**
+     * Add a new row to the DataStore
+     *
+     * Note: we return -1 on an error.  There are many good ways to handle an
+     * error, to include throwing an exception.  In robust code, returning -1
+     * may not be the most appropriate technique, but it is sufficient for this
+     * tutorial.
+     *
+     * @param title The title for this newly added row
+     * @param content The content for this row
+     * @return the ID of the new row, or -1 if no row was created
+     */
+    public synchronized int createEntry(String title, String content) {
+        if (title == null || content == null)
+            return -1;
+        // NB: we can safely assume that id is greater than the largest index in
+        //     mRows, and thus we can use the index-based add() method
+        int id = mCounter++;
+        DataRow data = new DataRow(id, title, content);
+        mRows.add(id, data);
+        return id;
+    }
+
+    /**
+     * Get one complete row from the DataStore using its ID to select it
+     *
+     * @param id The id of the row to select
+     * @return A copy of the data in the row, if it exists, or null otherwise
+     */
+    public synchronized DataRow readOne(int id) {
+        if (id >= mRows.size())
+            return null;
+        DataRow data = mRows.get(id);
+        if (data == null)
+            return null;
+        return new DataRow(data);
+    }
+
+    /**
+     * Get all of the ids and titles that are present in the DataStore
+     * @return An ArrayList with all of the data
+     */
+    public synchronized ArrayList<DataRowLite> readAll() {
+        ArrayList<DataRowLite> data = new ArrayList<>();
+        // NB: we copy the data, so that our ArrayList only has ids and titles
+        for (DataRow row : mRows) {
+            if (row != null)
+                data.add(new DataRowLite(row));
+        }
+        return data;
+    }
+}

backend/src/main/java/merhoo/backend/SimpleRequest.java

@@ -0,0 +1,20 @@
+package merhoo.backend;
+
+/**
+ * SimpleRequest provides a format for clients to present title and message
+ * strings to the server.
+ *
+ * NB: since this will be created from JSON, all fields must be public, and we
+ *     do not need a constructor.
+ */
+public class SimpleRequest {
+    /**
+     * The title being provided by the client.
+     */
+    public String mTitle;
+
+    /**
+     * The message being provided by the client.
+     */
+    public String mMessage;
+}