Quickstarters
How to Develop a CRUD Android Application Using Java?

27min
Overview
In this tutorial, you will learn how to build a fully functional CRUD (create, read, update, delete) application for Android using Java. 
We will use Back4app as our backend to easily manage data. This guide will walk you through setting up a Back4app project, designing your data schema, and coding CRUD functionalities in an Android environment.
Initially, you will establish a Back4app project titled Basic-CRUD-App-Android that provides a reliable backend solution. You’ll then define your data structures by creating the necessary classes and fields manually or by leveraging Back4app’s AI-driven schema generator.
Next, you’ll explore the Back4app Admin App—a user-friendly, drag-and-drop interface that simplifies data management. 
Finally, you will connect your Android app to Back4app using the Parse Android SDK, enabling secure CRUD operations and user authentication.
By the end of this guide, you will have developed a production-ready Android application that handles essential CRUD operations along with secure user management.
Essential Insights
Build an Android CRUD application integrated with a robust backend.
Understand how to structure a scalable backend and connect it with your Android app.
Utilize Back4app’s Admin App to effortlessly manage create, read, update, and delete operations.
Learn secure data handling and user authentication in an Android context.
﻿
Requirements
Before you begin, ensure you have:
A Back4app account with a newly configured project.
Need help? Visit Getting Started with Back4app.
An Android development setup.
Use Android Studio with Java support and ensure you have at least Android API 21.
Basic knowledge of Java, Android app development, and RESTful APIs.
Review the Android documentation if needed.
﻿
Step 1 – Setting Up Your Project
Establishing a New Back4app Project
Log into your Back4app account.
Select “New App” from your dashboard.
Name your project: Basic-CRUD-App-Android and follow the instructions to complete the setup.
Create New Project
﻿
After your project is set up, it will appear on your dashboard, ready for further configuration.
﻿
Step 2 – Crafting Your Data Schema
Defining Your Data Structures
For this Android CRUD application, you need to create several classes (collections) within your Back4app project. The examples below illustrate the main classes and their essential fields for supporting CRUD functionality.
1. Items Collection
This collection stores details about each item.
Field
Data Type
Purpose
_id
ObjectId
System-generated unique identifier.
title
String
Name or title of the item.
description
String
Brief overview of the item.
createdAt
Date
Timestamp when the item was added.
updatedAt
Date
Timestamp for the latest update.
2. Users Collection
This collection handles user credentials and authentication details.
Field
Data Type
Purpose
_id
ObjectId
Automatically assigned unique ID.
username
String
Unique username for the user.
email
String
Unique email address.
passwordHash
String
Securely stored password.
createdAt
Date
Account creation timestamp.
updatedAt
Date
Timestamp for account updates.
You can create these collections and their fields directly from the Back4app dashboard.
Create New Class
﻿
To add a new field, simply select the desired data type, enter the field name, set a default value if needed, and indicate whether it is required.
Create Column
﻿
Using the Back4app AI Assistant for Schema Creation
The integrated Back4app AI Assistant can automatically generate your schema from a brief description, expediting your project setup.
How to Use the AI Assistant:
Access the AI Assistant:
In your Back4app dashboard, find the AI Assistant under the project settings.
Describe Your Schema:
Enter a detailed description of the collections and fields you need.
Review and Confirm:
The AI Assistant will propose a schema. Review the details and confirm to implement the changes.
Example Prompt:
Text
Create two collections in my Back4app project:

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

2) Collection: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
Create two collections in my Back4app project:

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

2) Collection: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
﻿
This AI-assisted method saves time and ensures your data schema is optimized for CRUD operations.
﻿
Step 3 – Utilizing the Admin Console for Data Management
Getting to Know the Admin Console
The Back4app Admin Console provides a visual interface for managing your backend data without writing any code. Its drag-and-drop features make it easy to execute CRUD operations such as adding, modifying, and removing records.
Enabling the Admin Console
Open the “More” menu in your Back4app dashboard.
Choose “Admin App” and then click “Enable Admin App.”
Create your admin credentials by setting up your primary admin account. This process will also create system roles (like B4aAdminUser) and system classes.
Enable Admin App
﻿
Once activated, sign in to the Admin Console to manage your data.
Admin App Dashboard
﻿
Managing CRUD Operations via the Admin Console
Within the Admin Console you can:
Add New Records: Utilize the “Add Record” button in a collection (for example, Items) to insert new data.
View and Edit Records: Click on any entry to review or update its details.
Delete Records: Remove entries that are no longer needed.
This interface greatly simplifies the process of backend data management.
﻿
Step 4 – Connecting Your Android Application with Back4app
With your backend prepared, the next step is to link your Android application to Back4app.
Option A: Using the Parse Android SDK
Include the Parse Android SDK in Your Project:
Add the following dependency in your build.gradle file:
Text
implementation 'com.github.parse-community.Parse-SDK-Android:parse:1.26.0'
implementation 'com.github.parse-community.Parse-SDK-Android:parse:1.26.0'
﻿
Initialize Parse in Your Application Class:
Create an initializer (e.g., ParseInitializer.java):
Java
// ParseInitializer.java
import com.parse.Parse;
import android.app.Application;

public class ParseInitializer extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
            .applicationId("YOUR_APPLICATION_ID")
            .clientKey("YOUR_ANDROID_KEY")
            .server("https://parseapi.back4app.com")
            .build()
        );
    }
}
// ParseInitializer.java
import com.parse.Parse;
import android.app.Application;

public class ParseInitializer extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
            .applicationId("YOUR_APPLICATION_ID")
            .clientKey("YOUR_ANDROID_KEY")
            .server("https://parseapi.back4app.com")
            .build()
        );
    }
}
﻿
Implementing CRUD Operations in Your Android App:
For example, create a service class to manage item data:
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> fetchItems() {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            return query.find();
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void addItem(String title, String description) {
        ParseObject item = new ParseObject("Items");
        item.put("title", title);
        item.put("description", description);
        try {
            item.save();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    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();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public void removeItem(String objectId) {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            ParseObject item = query.get(objectId);
            item.delete();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
// ItemsService.java
import com.parse.ParseException;
import com.parse.ParseObject;
import com.parse.ParseQuery;
import java.util.List;

public class ItemsService {
    public List<ParseObject> fetchItems() {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            return query.find();
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void addItem(String title, String description) {
        ParseObject item = new ParseObject("Items");
        item.put("title", title);
        item.put("description", description);
        try {
            item.save();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    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();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public void removeItem(String objectId) {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Items");
        try {
            ParseObject item = query.get(objectId);
            item.delete();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
﻿
Option B: Using REST or GraphQL
If the Parse Android SDK isn’t suitable, you can execute CRUD tasks through REST calls. For instance, to retrieve items via REST:
Java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class RestClient {
    public static void getItems() {
        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 reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();
            System.out.println("Response: " + response.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class RestClient {
    public static void getItems() {
        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 reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();
            System.out.println("Response: " + response.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
﻿
Integrate these API calls within your Android classes as required.
﻿
Step 5 – Securing Your Backend
Implementing Access Control Lists (ACLs)
Ensure your data remains protected by configuring ACLs for your objects. For instance, to create an item that is only accessible to its owner:
Java
import com.parse.ParseACL;
import com.parse.ParseObject;
import com.parse.ParseUser;

public void createSecureItem(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();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
import com.parse.ParseACL;
import com.parse.ParseObject;
import com.parse.ParseUser;

public void createSecureItem(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();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
﻿
Setting Class-Level Permissions (CLPs)
In the Back4app dashboard, adjust the CLPs for your collections to ensure that only authenticated users can access sensitive data.
﻿
Step 6 – Implementing User Authentication in Your Android App
Configuring User Management
Back4app uses Parse’s built-in User collection for managing authentication. In your Android app, implement registration and login as follows:
Java
import com.parse.ParseException;
import com.parse.ParseUser;

public class AuthManager {
    public void registerUser(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("Registration successful!");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public void loginUser(String username, String password) {
        try {
            ParseUser user = ParseUser.logIn(username, password);
            System.out.println("Logged in as: " + user.getUsername());
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
import com.parse.ParseException;
import com.parse.ParseUser;

public class AuthManager {
    public void registerUser(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("Registration successful!");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public void loginUser(String username, String password) {
        try {
            ParseUser user = ParseUser.logIn(username, password);
            System.out.println("Logged in as: " + user.getUsername());
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
﻿
You can also implement additional features such as session management and password resets as needed.
﻿
Step 7 – Conclusion and Future Enhancements
Great job! You’ve successfully created a basic CRUD Android application using Java and integrated it with Back4app. 
In this tutorial, you set up a project called Basic-CRUD-App-Android, defined collections for Items and Users, and managed your data via the Back4app Admin Console. 
Moreover, you connected your Android app using the Parse Android SDK (or REST/GraphQL as an alternative) and implemented strong security measures.
Next Steps:
Expand Your Application:
Add new features like advanced search, detailed item views, or real-time notifications.
Enhance Backend Functionality:
Experiment with cloud functions, integrate third-party APIs, or set up role-based access.
Deepen Your Learning:
Visit the Back4app documentation for more tutorials and best practices.
Happy coding and enjoy building your Android CRUD application!
Field	Data Type	Purpose
_id	ObjectId	System-generated unique identifier.
title	String	Name or title of the item.
description	String	Brief overview of the item.
createdAt	Date	Timestamp when the item was added.
updatedAt	Date	Timestamp for the latest update.
Field	Data Type	Purpose
_id	ObjectId	Automatically assigned unique ID.
username	String	Unique username for the user.
email	String	Unique email address.
passwordHash	String	Securely stored password.
createdAt	Date	Account creation timestamp.
updatedAt	Date	Timestamp for account updates.
Updated 19 Feb 2025
Did this page help you?
How to Develop a CRUD App for iOS using Swift?
How to Create a CRUD Application with Ember.js?