Quickstarters
How to Build a Basic CRUD App with Java?

34min
Introduction
In this guide, you'll learn to create a full-featured CRUD (create, read, update, delete) application using Java. 
We will leverage Back4app as the backend service to manage your data effortlessly. This tutorial demonstrates the core functionalities of a CRUD system, showing you how to set up a Back4app project, design a flexible data model, and implement CRUD operations with a Java application.
Initially, you'll configure a Back4app project called Basic-CRUD-App-Java which provides a robust non-relational data storage environment for your application. You will define your data model by creating classes and fields manually or with the assistance of Back4app's AI Agent.
Following that, you will manage your backend using the Back4app Admin App, a user-friendly drag and drop interface for data manipulation. 
Finally, you'll integrate your Java application with Back4app using the Parse Java SDK (or REST/GraphQL where needed) while implementing secure access controls.
By the end of this tutorial, you'll have developed a production-ready Java application that performs basic CRUD operations, including secure user authentication and data management.
Key Takeaways
Discover how to build a Java-based CRUD application with an efficient non-relational backend.
Gain insights into structuring a scalable backend and integrating it with a Java application.
Learn how to use Back4app’s intuitive Admin App to streamline create, read, update, and delete operations.
Explore deployment strategies, including Docker containerization, to deploy your Java application seamlessly.
﻿
Prerequisites
Before starting, ensure you have:
A Back4app account with a new project configured.
Need assistance? Check out Getting Started with Back4app.
A Java development environment.
Use an IDE like IntelliJ IDEA or Eclipse. Make sure you have Java 11 (or newer) installed.
Familiarity with Java, object-oriented programming, and REST APIs.
Review the Java documentation if necessary.
﻿
Step 1 – Project Setup
Creating a New Back4app Project
Sign in to your Back4app account.
Click the “New App” button on your dashboard.
Enter the project name: Basic-CRUD-App-Java and follow the prompts to finalize project creation.
Create New Project
﻿
Once your project is created, it will be listed on your dashboard, providing the groundwork for your backend configuration.
﻿
Step 2 – Designing the Data Model
Configuring Your Data Structures
For this CRUD application, you will define several classes (collections) in your Back4app project. The following examples outline the key classes and their fields necessary to support basic CRUD operations.
1. Items Class
This class holds details about each item.
Field
Data Type
Description
_id
ObjectId
Automatically generated unique identifier.
title
String
The name of the item.
description
String
A short summary of the item.
createdAt
Date
Timestamp when the item was created.
updatedAt
Date
Timestamp when the item was last modified.
2. Users Class
This class manages user credentials and authentication details.
Field
Data Type
Description
_id
ObjectId
Auto-generated unique identifier.
username
String
Unique identifier for the user.
email
String
Unique email address.
passwordHash
String
Encrypted password for authentication.
createdAt
Date
Timestamp when the account was created.
updatedAt
Date
Timestamp when the account was updated.
You can manually create these classes and define fields in the Back4app dashboard.
Create New Class
﻿
You can add fields by selecting a data type, specifying the field name, assigning a default value, and indicating if it is mandatory.
Create Column
﻿
Leveraging the Back4app AI Agent for Schema Setup
The Back4app AI Agent is a smart tool integrated into your dashboard that can automatically generate your data schema based on your description. This feature streamlines project setup and ensures that your data model supports the necessary CRUD operations.
Steps to Use the AI Agent:
Access the AI Agent:
Log in to your Back4app dashboard and locate the AI Agent under your project settings.
Describe Your Data Model:
Provide a detailed prompt outlining the classes and fields required.
Review and Apply:
After processing, the AI Agent will propose the schema setup. Review the details and confirm to implement the configuration.
Sample Prompt
Text
Create the following classes in my Back4app project:

1) Class: Items
- Fields:
  - _id: ObjectId (auto-generated)
  - title: String
  - description: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)

2) Class: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
Create the following classes in my Back4app project:

1) Class: Items
- Fields:
  - _id: ObjectId (auto-generated)
  - title: String
  - description: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)

2) Class: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
﻿
This AI-driven approach saves time and guarantees a consistent, optimized data model for your application.
﻿
Step 3 – Activating the Admin App & Managing CRUD Operations
Introduction to the Admin App
The Back4app Admin App offers a no-code interface for efficient backend data management. Its intuitive drag and drop functionality simplifies performing CRUD operations like creating, viewing, updating, and removing records.
Activating the Admin App
Navigate to the “More” menu in your Back4app dashboard.
Select “Admin App” and then click on “Enable Admin App.”
Set up your admin credentials by creating your initial admin account. This process will also establish roles (such as B4aAdminUser) and system classes.
Enable Admin App
﻿
Once enabled, log in to the Admin App to manage your application data.
Admin App Dashboard
﻿
Utilizing the Admin App for CRUD Tasks
Within the Admin App, you can:
Add Records: Use the “Add Record” option within a class (for example, Items) to insert new data.
View/Modify Records: Click on any record to examine details or edit fields.
Remove Records: Delete entries that are no longer necessary.
This streamlined interface enhances user experience by simplifying data management.
﻿
Step 4 – Integrating Your Java Application with Back4app
With your backend configured, the next step is to connect your Java application to Back4app.
Option A: Using the Parse Java SDK
Add the Parse Java SDK Dependency:
If you're using Maven, include the following in your pom.xml:
XML
<dependency>
  <groupId>com.parse</groupId>
  <artifactId>parse-sdk</artifactId>
  <version>1.18.0</version>
</dependency>

<dependency>
  <groupId>com.parse</groupId>
  <artifactId>parse-sdk</artifactId>
  <version>1.18.0</version>
</dependency>
﻿
Initialize Parse in Your Java Application:
Create a configuration class (e.g., ParseConfig.java):
Java
// ParseConfig.java
import com.parse.Parse;

public class ParseConfig {
    public static void initialize() {
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APPLICATION_ID")
                .clientKey("YOUR_JAVA_KEY")
                .server("https://parseapi.back4app.com")
                .build());
    }
}
// ParseConfig.java
import com.parse.Parse;

public class ParseConfig {
    public static void initialize() {
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APPLICATION_ID")
                .clientKey("YOUR_JAVA_KEY")
                .server("https://parseapi.back4app.com")
                .build());
    }
}
﻿
Implement CRUD Operations in a Java Class:
For instance, create a service to fetch and display items:
Java
// ItemsService.java
import com.parse.ParseException;
import com.parse.ParseObject;
import com.parse.ParseQuery;
import java.util.List;

public class ItemsService {
    public List<ParseObject> getItems() {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            return query.find();
        } catch (ParseException e) {
            System.err.println("Failed to fetch items: " + e.getMessage());
            return null;
        }
    }

    public void createItem(String title, String description) {
        ParseObject item = new ParseObject("Items");
        item.put("title", title);
        item.put("description", description);
        try {
            item.save();
            System.out.println("Item created successfully.");
        } catch (ParseException e) {
            System.err.println("Error creating item: " + e.getMessage());
        }
    }

    public void updateItem(String objectId, String newTitle, String newDescription) {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            ParseObject item = query.get(objectId);
            item.put("title", newTitle);
            item.put("description", newDescription);
            item.save();
            System.out.println("Item updated successfully.");
        } catch (ParseException e) {
            System.err.println("Error updating item: " + e.getMessage());
        }
    }

    public void deleteItem(String objectId) {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            ParseObject item = query.get(objectId);
            item.delete();
            System.out.println("Item deleted successfully.");
        } catch (ParseException e) {
            System.err.println("Error deleting item: " + e.getMessage());
        }
    }
}
// ItemsService.java
import com.parse.ParseException;
import com.parse.ParseObject;
import com.parse.ParseQuery;
import java.util.List;

public class ItemsService {
    public List<ParseObject> getItems() {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            return query.find();
        } catch (ParseException e) {
            System.err.println("Failed to fetch items: " + e.getMessage());
            return null;
        }
    }

    public void createItem(String title, String description) {
        ParseObject item = new ParseObject("Items");
        item.put("title", title);
        item.put("description", description);
        try {
            item.save();
            System.out.println("Item created successfully.");
        } catch (ParseException e) {
            System.err.println("Error creating item: " + e.getMessage());
        }
    }

    public void updateItem(String objectId, String newTitle, String newDescription) {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            ParseObject item = query.get(objectId);
            item.put("title", newTitle);
            item.put("description", newDescription);
            item.save();
            System.out.println("Item updated successfully.");
        } catch (ParseException e) {
            System.err.println("Error updating item: " + e.getMessage());
        }
    }

    public void deleteItem(String objectId) {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            ParseObject item = query.get(objectId);
            item.delete();
            System.out.println("Item deleted successfully.");
        } catch (ParseException e) {
            System.err.println("Error deleting item: " + e.getMessage());
        }
    }
}
﻿
Option B: Using REST or GraphQL
If the Parse Java SDK is not an option, you can perform CRUD operations via REST calls. For example, to fetch items using REST:
Java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class RestClient {
    public static void fetchItems() {
        try {
            URL url = new URL("https://parseapi.back4app.com/classes/Items");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("X-Parse-Application-Id", "YOUR_APPLICATION_ID");
            conn.setRequestProperty("X-Parse-REST-API-Key", "YOUR_REST_API_KEY");

            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            System.out.println("Response: " + response.toString());
        } catch (Exception e) {
            System.err.println("Error fetching items: " + e.getMessage());
        }
    }
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class RestClient {
    public static void fetchItems() {
        try {
            URL url = new URL("https://parseapi.back4app.com/classes/Items");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("X-Parse-Application-Id", "YOUR_APPLICATION_ID");
            conn.setRequestProperty("X-Parse-REST-API-Key", "YOUR_REST_API_KEY");

            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            System.out.println("Response: " + response.toString());
        } catch (Exception e) {
            System.err.println("Error fetching items: " + e.getMessage());
        }
    }
}
﻿
Integrate these API calls into your Java classes as needed.
﻿
Step 5 – Securing Your Backend
Access Control Lists (ACLs)
Protect your data by configuring ACLs for your objects. For example, to create an item visible only to its owner:
Java
import com.parse.ParseACL;
import com.parse.ParseUser;

public void createPrivateItem(String title, String description, ParseUser owner) {
    ParseObject item = new ParseObject("Items");
    item.put("title", title);
    item.put("description", description);

    ParseACL acl = new ParseACL();
    acl.setReadAccess(owner, true);
    acl.setWriteAccess(owner, true);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    item.setACL(acl);

    try {
        item.save();
        System.out.println("Private item created.");
    } catch (ParseException e) {
        System.err.println("Error saving item: " + e.getMessage());
    }
}
import com.parse.ParseACL;
import com.parse.ParseUser;

public void createPrivateItem(String title, String description, ParseUser owner) {
    ParseObject item = new ParseObject("Items");
    item.put("title", title);
    item.put("description", description);

    ParseACL acl = new ParseACL();
    acl.setReadAccess(owner, true);
    acl.setWriteAccess(owner, true);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    item.setACL(acl);

    try {
        item.save();
        System.out.println("Private item created.");
    } catch (ParseException e) {
        System.err.println("Error saving item: " + e.getMessage());
    }
}
﻿
Class-Level Permissions (CLPs)
Configure CLPs in your Back4app dashboard to enforce default access rules. This setup ensures that only authenticated users can access specific classes.
﻿
Step 6 – Implementing User Authentication
Configuring User Accounts
Back4app uses Parse’s built-in User class for managing authentication. In your Java application, manage user registration and login as shown below:
Java
import com.parse.ParseException;
import com.parse.ParseUser;

public class AuthService {
    public void signUp(String username, String password, String email) {
        ParseUser user = new ParseUser();
        user.setUsername(username);
        user.setPassword(password);
        user.setEmail(email);

        try {
            user.signUp();
            System.out.println("User successfully registered!");
        } catch (ParseException e) {
            System.err.println("Sign up error: " + e.getMessage());
        }
    }

    public void logIn(String username, String password) {
        try {
            ParseUser user = ParseUser.logIn(username, password);
            System.out.println("User logged in: " + user.getUsername());
        } catch (ParseException e) {
            System.err.println("Login failed: " + e.getMessage());
        }
    }
}
import com.parse.ParseException;
import com.parse.ParseUser;

public class AuthService {
    public void signUp(String username, String password, String email) {
        ParseUser user = new ParseUser();
        user.setUsername(username);
        user.setPassword(password);
        user.setEmail(email);

        try {
            user.signUp();
            System.out.println("User successfully registered!");
        } catch (ParseException e) {
            System.err.println("Sign up error: " + e.getMessage());
        }
    }

    public void logIn(String username, String password) {
        try {
            ParseUser user = ParseUser.logIn(username, password);
            System.out.println("User logged in: " + user.getUsername());
        } catch (ParseException e) {
            System.err.println("Login failed: " + e.getMessage());
        }
    }
}
﻿
A similar approach can be applied for session management, password resets, and additional authentication features.
﻿
Step 7 – Deploying Your Java Application
Back4app offers a streamlined deployment process. You can deploy your Java application using various methods, including Docker containerization.
7.1 Building Your Java Application
Compile and Package:
Use your build tool (such as Maven or Gradle) to compile and package your application.
For Maven, run:
Bash
mvn clean package
mvn clean package
﻿
Verify the Package:
Ensure that the generated .jar file contains all necessary classes and resources.
﻿
7.2 Organize Your Project Structure
A typical Java project structure may resemble:
Text
Basic-CRUD-App-Java/
|-- src/
|   |-- main/
|       |-- java/
|           |-- com/
|               |-- yourdomain/
|                   |-- App.java
|                   |-- ParseConfig.java
|                   |-- services/
|                       |-- ItemsService.java
|                       |-- AuthService.java
|       |-- resources/
|           |-- application.properties
|-- pom.xml
|-- README.md
Basic-CRUD-App-Java/
|-- src/
|   |-- main/
|       |-- java/
|           |-- com/
|               |-- yourdomain/
|                   |-- App.java
|                   |-- ParseConfig.java
|                   |-- services/
|                       |-- ItemsService.java
|                       |-- AuthService.java
|       |-- resources/
|           |-- application.properties
|-- pom.xml
|-- README.md
﻿
Example: ParseConfig.java
Java
// ParseConfig.java
import com.parse.Parse;

public class ParseConfig {
    public static void initialize() {
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APPLICATION_ID")
                .clientKey("YOUR_JAVA_KEY")
                .server("https://parseapi.back4app.com")
                .build());
    }
}
// ParseConfig.java
import com.parse.Parse;

public class ParseConfig {
    public static void initialize() {
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APPLICATION_ID")
                .clientKey("YOUR_JAVA_KEY")
                .server("https://parseapi.back4app.com")
                .build());
    }
}
﻿
7.3 Dockerizing Your Java Application
If you opt for containerized deployment, include a Dockerfile in your project root:
Dockerfile
# Use an OpenJDK image as the base
FROM openjdk:11-jre-slim

# Set the working directory
WORKDIR /app

# Copy the packaged jar into the container
COPY target/Basic-CRUD-App-Java.jar app.jar

# Expose the port (adjust if needed)
EXPOSE 8080

# Run the application
ENTRYPOINT ["java", "-jar", "app.jar"]
# Use an OpenJDK image as the base
FROM openjdk:11-jre-slim

# Set the working directory
WORKDIR /app

# Copy the packaged jar into the container
COPY target/Basic-CRUD-App-Java.jar app.jar

# Expose the port (adjust if needed)
EXPOSE 8080

# Run the application
ENTRYPOINT ["java", "-jar", "app.jar"]
﻿
7.4 Deploying with Back4app Web Deployment
Link Your GitHub Repository:
Ensure your Java project's source code is hosted on GitHub.
Configure Deployment Settings:
In your Back4app dashboard, select the Web Deployment feature, link your repository (e.g., Basic-CRUD-App-Java), and choose the appropriate branch.
Set Build and Output Commands:
Define the build command (e.g., mvn clean package) and specify the artifact location.
Deploy Your Application:
Click Deploy and monitor the deployment logs until your app is live.
﻿
Step 8 – Conclusion and Next Steps
Congratulations! You've successfully built a Java-based CRUD application integrated with Back4app. 
You set up a project named Basic-CRUD-App-Java, designed classes for Items and Users, and managed your data using the Back4app Admin App. 
Additionally, you connected your Java application via the Parse SDK (or REST/GraphQL) and implemented robust security measures.
Next Steps:
Enhance the Application:
Add more features such as advanced search, detailed views, or real-time updates.
Extend Backend Functionality:
Explore cloud functions, third-party API integrations, or role-based access controls.
Deepen Your Knowledge:
Check out the Back4app documentation and additional tutorials to further optimize your app.
Happy coding and best of luck with your Java CRUD application!
Field	Data Type	Description
_id	ObjectId	Automatically generated unique identifier.
title	String	The name of the item.
description	String	A short summary of the item.
createdAt	Date	Timestamp when the item was created.
updatedAt	Date	Timestamp when the item was last modified.
Field	Data Type	Description
_id	ObjectId	Auto-generated unique identifier.
username	String	Unique identifier for the user.
email	String	Unique email address.
passwordHash	String	Encrypted password for authentication.
createdAt	Date	Timestamp when the account was created.
updatedAt	Date	Timestamp when the account was updated.
Updated 15 Feb 2025
Did this page help you?
How to Develop a CRUD Application with Flask?
How to Build a Basic CRUD App with Golang?