Quickstarters
Cara Membangun Backend untuk Android?

46min
Pendahuluan
Dalam tutorial ini, Anda akan belajar bagaimana membangun backend lengkap untuk sebuah Android (Java) aplikasi menggunakan Back4App. 
Kami akan membahas integrasi fitur-fitur penting Back4App—seperti manajemen database, Cloud Code Functions, REST dan GraphQL APIs, otentikasi pengguna, dan kueri waktu nyata (Live Queries)—untuk membuat backend yang aman, skalabel, dan kuat yang berkomunikasi dengan klien Android Anda secara mulus.
Anda juga akan melihat bagaimana pengaturan cepat dan lingkungan intuitif Back4App dapat secara drastis mengurangi waktu dan usaha dibandingkan dengan mengonfigurasi server dan database secara manual. 
Sepanjang jalan, Anda akan mendapatkan pengalaman langsung dengan fungsionalitas kunci, termasuk fitur keamanan lanjutan, penjadwalan tugas dengan Cloud Jobs, dan pengaturan webhook untuk integrasi eksternal.
Pada akhir tutorial ini, Anda akan siap untuk meningkatkan pengaturan dasar ini menjadi aplikasi siap produksi, atau dengan mudah menggabungkan logika kustom dan API pihak ketiga sesuai kebutuhan.
Prasyarat
Untuk menyelesaikan tutorial ini, Anda akan membutuhkan:
Akun Back4App dan proyek Back4App baru
Memulai dengan Back4App.
Jika Anda tidak memiliki akun, Anda dapat membuat satu secara gratis. Ikuti panduan di atas untuk menyiapkan proyek Anda.
Lingkungan pengembangan Android (Java) dasar
Anda dapat mengatur ini menggunakan Android Studio atau alat serupa. Pastikan Anda memiliki SDK Android terbaru yang terinstal.
Java (versi 8 atau lebih tinggi)
Anda akan memerlukan Java untuk mengompilasi dan menjalankan proyek Android Anda.
Keterampilan dalam Java dan konsep dasar Android
Dokumentasi Pengembang Android.
Jika Anda baru di Android, tinjau dokumen resmi atau tutorial pemula sebelum memulai.
Pastikan Anda memiliki semua prasyarat ini sebelum Anda mulai. Memiliki proyek Back4App Anda yang disiapkan dan lingkungan Android lokal Anda yang siap akan membantu Anda mengikuti dengan lebih mudah.
Langkah 1 – Menyiapkan Proyek Back4App
Buat Proyek Baru
Langkah pertama dalam membangun backend Android Anda di Back4App adalah membuat proyek baru. Jika Anda belum membuatnya, ikuti langkah-langkah ini:
Masuk ke akun Back4App Anda.
Klik tombol “Aplikasi Baru” di dasbor Back4App Anda.
Beri nama aplikasi Anda (misalnya, “Android-Backend-Tutorial”).
﻿
Setelah proyek dibuat, Anda akan melihatnya terdaftar di dasbor Back4App Anda. Proyek ini akan menjadi dasar untuk semua konfigurasi backend yang dibahas dalam tutorial ini.
Hubungkan Parse SDK
Back4App bergantung pada Platform Parse untuk mengelola data Anda, menyediakan fitur waktu nyata, menangani otentikasi pengguna, dan lainnya. Menghubungkan aplikasi Android Anda ke Back4App melibatkan pemasangan Parse Android SDK dan menginisialisasinya dengan kredensial dari dasbor Back4App Anda.
Ambil Kunci Parse Anda:
Di dasbor Back4App Anda, navigasikan ke bagian “Pengaturan Aplikasi” atau “Keamanan & Kunci” aplikasi Anda untuk menemukan ID Aplikasi dan Kunci Klien (atau Kunci JavaScript jika ditunjukkan). Anda juga akan menemukan URL Server Parse (sering dalam format https://parseapi.back4app.com).
﻿
Instal Parse SDK di proyek Android Anda dengan menambahkan baris ini ke module-level build.gradle:
Text
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
﻿
Jika Anda memerlukan repositori Jitpack di root build.gradle:
Text
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
﻿
Inisialisasi Parse di aplikasi Android Anda:
Buat kelas Application kustom (misalnya, App.java) dan konfigurasikan AndroidManifest.xml:
Java
package com.example.app;

import android.app.Application;
import com.parse.Parse;

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")       // from Back4App
                .clientKey("YOUR_CLIENT_KEY")       // from Back4App
                .server("https://parseapi.back4app.com/")
                .build()
        );
    }
}
package com.example.app;

import android.app.Application;
import com.parse.Parse;

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")       // from Back4App
                .clientKey("YOUR_CLIENT_KEY")       // from Back4App
                .server("https://parseapi.back4app.com/")
                .build()
        );
    }
}
﻿
Kemudian, tambahkan kelas Application kustom ini di AndroidManifest.xml:
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:name=".App"
        ... >
        ...
    </application>
</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:name=".App"
        ... >
        ...
    </application>
</manifest>
﻿
Dengan menyelesaikan langkah ini, Anda telah membangun koneksi yang aman antara front-end Android Anda dan backend Back4App. Semua permintaan dan transaksi data dialihkan dengan aman melalui SDK ini, mengurangi kompleksitas panggilan REST atau GraphQL manual (meskipun Anda masih dapat menggunakannya jika diperlukan).
Langkah 2 – Menyiapkan Database
Menyimpan dan Mengambil Data
Dengan proyek Back4App Anda yang sudah disiapkan dan SDK Parse terintegrasi ke dalam aplikasi Android Anda, sekarang Anda dapat mulai menyimpan dan mengambil data. Cara umum untuk membuat dan menyimpan catatan adalah dengan menggunakan ParseObject kelas:
Java
ParseObject gameScore = new ParseObject("GameScore");
gameScore.put("score", 1337);
gameScore.put("playerName", "Sean Plott");
gameScore.put("cheatMode", false);
gameScore.saveInBackground(e -> {
    if (e == null) {
        // Success!
    } else {
        // Failed
    }
});
ParseObject gameScore = new ParseObject("GameScore");
gameScore.put("score", 1337);
gameScore.put("playerName", "Sean Plott");
gameScore.put("cheatMode", false);
gameScore.saveInBackground(e -> {
    if (e == null) {
        // Success!
    } else {
        // Failed
    }
});
﻿
Untuk mengquery data:
Java
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Sean Plott");
query.findInBackground((objects, e) -> {
    if (e == null) {
        // objects now contains the results
    } else {
        // something went wrong
    }
});
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Sean Plott");
query.findInBackground((objects, e) -> {
    if (e == null) {
        // objects now contains the results
    } else {
        // something went wrong
    }
});
﻿
Sebagai alternatif, Anda dapat menggunakan REST API dari Back4App:
Curl
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"score": 1337, "playerName": "Sean Plott", "cheatMode": false}' \
  https://parseapi.back4app.com/classes/GameScore
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"score": 1337, "playerName": "Sean Plott", "cheatMode": false}' \
  https://parseapi.back4app.com/classes/GameScore
﻿
Back4App juga menyediakan antarmuka GraphQL:
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
Opsi yang beragam ini memungkinkan Anda mengintegrasikan operasi data dengan cara yang paling sesuai dengan proses pengembangan Anda—baik itu melalui Parse Android SDK, REST, atau GraphQL.
Desain Skema dan Tipe Data
Secara default, Parse memungkinkan pembuatan skema secara langsung, tetapi Anda juga dapat mendefinisikan kelas dan tipe data Anda di dasbor Back4App untuk kontrol yang lebih baik:
Navigasikan ke bagian “Database” di dasbor Back4App Anda.
Buat kelas baru (misalnya, “GameScore”) dan tambahkan kolom yang relevan.
Buat Kelas Baru
﻿
Back4App juga mendukung berbagai tipe data: String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, dan Polygon. Anda dapat memilih tipe yang sesuai untuk setiap field.
Buat Kolom
﻿
Back4App menawarkan Agen AI yang dapat membantu Anda merancang model data Anda:
Buka Agen AI dari Dasbor Aplikasi Anda atau di menu.
Deskripsikan model data Anda dalam bahasa sederhana (misalnya, “Tolong buat aplikasi ToDo baru dengan skema kelas yang lengkap.”).
Biarkan Agen AI membuat Skema untuk Anda.
﻿
Data Relasional
Jika Anda memiliki data relasional—katakanlah, sebuah Kategori objek yang menunjuk ke beberapa GameScore objek—Anda dapat menggunakan Pointers atau Relations di Parse. Misalnya:
Java
// Linking a GameScore to a Category with a pointer
public void createGameScoreForCategory(String categoryObjectId, int scoreValue) {
    ParseObject gameScore = new ParseObject("GameScore");
    // Construct a pointer to the category
    ParseObject categoryPointer = ParseObject.createWithoutData("Category", categoryObjectId);
    // Set fields
    gameScore.put("score", scoreValue);
    gameScore.put("category", categoryPointer);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // Success
        } else {
            // Error
        }
    });
}
// Linking a GameScore to a Category with a pointer
public void createGameScoreForCategory(String categoryObjectId, int scoreValue) {
    ParseObject gameScore = new ParseObject("GameScore");
    // Construct a pointer to the category
    ParseObject categoryPointer = ParseObject.createWithoutData("Category", categoryObjectId);
    // Set fields
    gameScore.put("score", scoreValue);
    gameScore.put("category", categoryPointer);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // Success
        } else {
            // Error
        }
    });
}
﻿
Ketika Anda melakukan query, Anda dapat menyertakan data pointer:
Java
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.include("category");
query.findInBackground((scores, e) -> {
    if (e == null) {
        // scores now has category details
    }
});
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.include("category");
query.findInBackground((scores, e) -> {
    if (e == null) {
        // scores now has category details
    }
});
﻿
Query Langsung
Untuk pembaruan waktu nyata, Back4App menyediakan Live Queries. Anda dapat berlangganan perubahan dalam kelas tertentu dari aplikasi Android Anda:
Aktifkan Live Queries di dasbor Back4App Anda di bawah Pengaturan Server aplikasi Anda.
Inisialisasi Live Query dalam kode Anda.
Di Android, Anda biasanya bergantung pada perpustakaan Parse LiveQuery Android untuk berlangganan. Langkah-langkahnya mirip dengan platform lain, tetapi Anda akan mengintegrasikan LiveQueryClient:
Text
dependencies {
    implementation "com.github.parse-community:ParseLiveQuery-Android:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community:ParseLiveQuery-Android:latest.version.here"
}
﻿
Kemudian:
Java
LiveQueryClient liveQueryClient = new LiveQueryClient.Builder("wss://YOUR_SUBDOMAIN_HERE.b4a.io", 443)
        .build();
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
SubscriptionHandling<ParseObject> subscriptionHandling = liveQueryClient.subscribe(query);

subscriptionHandling.handleEvents((query1, event, gameScore) -> {
    switch (event) {
        case CREATE:
            // a new GameScore object was created
            break;
        case UPDATE:
            // existing GameScore updated
            break;
        case DELETE:
            // existing GameScore deleted
            break;
        default:
            break;
    }
});
LiveQueryClient liveQueryClient = new LiveQueryClient.Builder("wss://YOUR_SUBDOMAIN_HERE.b4a.io", 443)
        .build();
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
SubscriptionHandling<ParseObject> subscriptionHandling = liveQueryClient.subscribe(query);

subscriptionHandling.handleEvents((query1, event, gameScore) -> {
    switch (event) {
        case CREATE:
            // a new GameScore object was created
            break;
        case UPDATE:
            // existing GameScore updated
            break;
        case DELETE:
            // existing GameScore deleted
            break;
        default:
            break;
    }
});
﻿
Dengan berlangganan, Anda menerima notifikasi waktu nyata setiap kali catatan baru dibuat, diperbarui, atau dihapus. Fitur ini sangat berharga untuk aplikasi kolaboratif atau dinamis di mana banyak pengguna perlu melihat data terbaru tanpa menyegarkan halaman.
Langkah 3 – Menerapkan Keamanan dengan ACL dan CLP
Mekanisme Keamanan Back4app
Back4App menganggap keamanan dengan serius dengan menyediakan Daftar Kontrol Akses (ACL) dan Izin Tingkat Kelas (CLP). Fitur-fitur ini memungkinkan Anda membatasi siapa yang dapat membaca atau menulis data berdasarkan objek atau kelas, memastikan hanya pengguna yang berwenang yang dapat memodifikasi data Anda.
﻿
Daftar Kontrol Akses (ACL)
Sebuah ACL diterapkan pada objek individu untuk menentukan pengguna, peran, atau publik mana yang dapat melakukan operasi baca/tulis. Sebagai contoh:
Java
public void createPrivateScore(int scoreValue, ParseUser ownerUser) {
    ParseObject gameScore = new ParseObject("GameScore");
    gameScore.put("score", scoreValue);
    ParseACL acl = new ParseACL(ownerUser);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    gameScore.setACL(acl);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // success
        } else {
            // failed
        }
    });
}
public void createPrivateScore(int scoreValue, ParseUser ownerUser) {
    ParseObject gameScore = new ParseObject("GameScore");
    gameScore.put("score", scoreValue);
    ParseACL acl = new ParseACL(ownerUser);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    gameScore.setACL(acl);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // success
        } else {
            // failed
        }
    });
}
﻿
Edit ACL
﻿
Izin Tingkat Kelas (CLP)
CLP mengatur izin default seluruh kelas, seperti apakah kelas tersebut dapat dibaca atau ditulis secara publik, atau jika hanya peran tertentu yang dapat mengaksesnya.
Pergi ke Dasbor Back4app Anda, pilih aplikasi Anda, dan buka Database bagian.
Pilih sebuah kelas (misalnya, “GameScore”).
Buka izin tingkat kelas tab.
Konfigurasikan default Anda.
﻿
Izin ini menetapkan dasar, sementara ACL menyempurnakan izin untuk objek individu. Model keamanan yang kuat biasanya menggabungkan baik CLP (pembatasan luas) dan ACL (pembatasan halus per objek). Untuk informasi lebih lanjut, kunjungi Pedoman Keamanan Aplikasi.
Langkah 4 – Menulis dan Menerapkan Fungsi Kode Cloud
Mengapa Cloud Code
Cloud Code adalah fitur dari lingkungan Parse Server yang memungkinkan Anda menjalankan kode JavaScript kustom di sisi server—tanpa perlu mengelola server atau infrastruktur Anda. Dengan menulis Cloud Code, Anda dapat memperluas backend Back4App Anda dengan logika bisnis tambahan, validasi, pemicu, dan integrasi yang berjalan dengan aman dan efisien di Parse Server.
Contoh fungsi
Fungsi Cloud Code sederhana yang menghitung panjang string teks yang dikirim dari klien:
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Penerapan
Back4App CLI:
Dasbor:
Di dasbor aplikasi Anda, pergi ke Cloud Code > Fungsi. Salin/tempel kode Anda ke main.js dan klik Terapkan.
﻿
Memanggil Fungsi Anda
Dari Android (Java) menggunakan Parse SDK:
Java
HashMap<String, Object> params = new HashMap<>();
params.put("text", "Hello Back4App");
ParseCloud.callFunctionInBackground("calculateTextLength", params, (result, e) -> {
    if (e == null) {
        // result is a HashMap; get the length
        Map<?, ?> mapResult = (Map<?, ?>) result;
        Object lengthVal = mapResult.get("length");
        // cast to number, etc.
    } else {
        // handle error
    }
});
HashMap<String, Object> params = new HashMap<>();
params.put("text", "Hello Back4App");
ParseCloud.callFunctionInBackground("calculateTextLength", params, (result, e) -> {
    if (e == null) {
        // result is a HashMap; get the length
        Map<?, ?> mapResult = (Map<?, ?>) result;
        Object lengthVal = mapResult.get("length");
        // cast to number, etc.
    } else {
        // handle error
    }
});
﻿
Anda juga dapat memanggilnya melalui REST atau GraphQL. Fleksibilitas ini memungkinkan Anda untuk mengintegrasikan logika kustom Anda ke dalam frontend Android Anda atau klien lain yang mendukung REST atau GraphQL.
Langkah 5 – Mengonfigurasi Autentikasi Pengguna
Autentikasi Pengguna di Back4app
Back4App memanfaatkan kelas Parse User sebagai dasar untuk autentikasi. Secara default, Parse menangani hashing kata sandi, token sesi, dan penyimpanan yang aman. Ini berarti Anda tidak perlu mengatur alur keamanan yang kompleks secara manual.
Mengatur Autentikasi Pengguna
Dalam aplikasi Android yang menggunakan Java, Anda dapat membuat pengguna baru:
Java
ParseUser user = new ParseUser();
user.setUsername("myUsername");
user.setPassword("myPassword");
user.setEmail("[email protected]");
user.signUpInBackground(e -> {
    if (e == null) {
        // Sign up success
    } else {
        // Sign up failed
    }
});
ParseUser user = new ParseUser();
user.setUsername("myUsername");
user.setPassword("myPassword");
user.setEmail("email@example.com");
user.signUpInBackground(e -> {
    if (e == null) {
        // Sign up success
    } else {
        // Sign up failed
    }
});
﻿
Masuk sebagai pengguna yang sudah ada:
Java
ParseUser.logInInBackground("myUsername", "myPassword", (parseUser, e) -> {
    if (e == null) {
        // Logged in successfully
    } else {
        // Login failed
    }
});
ParseUser.logInInBackground("myUsername", "myPassword", (parseUser, e) -> {
    if (e == null) {
        // Logged in successfully
    } else {
        // Login failed
    }
});
﻿
Melalui REST, login mungkin terlihat seperti:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Manajemen Sesi
Setelah login berhasil, Parse membuat sebuah token sesi yang disimpan pada objek pengguna. Anda dapat memeriksa pengguna yang saat ini masuk:
Java
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
    // user is logged in
} else {
    // no user is logged in
}
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
    // user is logged in
} else {
    // no user is logged in
}
﻿
Anda dapat keluar:
Java
ParseUser.logOut();
ParseUser.logOut();
﻿
Integrasi Login Sosial
Back4app dan Parse dapat terintegrasi dengan penyedia OAuth populer seperti Google atau Facebook. Sebagai contoh, Anda dapat mengatur Facebook login dengan mengonfigurasi Facebook App ID dan menggunakan Parse FacebookUtils khusus untuk Android. Instruksi rinci bervariasi, jadi silakan merujuk ke Dokumentasi Login Sosial.
Verifikasi Email dan Reset Kata Sandi
Untuk mengaktifkan verifikasi email dan reset kata sandi:
Navigasikan ke Pengaturan Email di dasbor Back4App Anda.
Aktifkan verifikasi email.
Konfigurasikan alamat Dari dan template email.
Ini membantu memastikan email pengguna Anda valid dan menyediakan metode pemulihan kata sandi yang aman.
Langkah 6 – Menangani Penyimpanan File
Mengunggah dan Mengambil File
Parse menyertakan kelas ParseFile untuk menangani unggahan file, yang disimpan dengan aman oleh Back4app:
Java
File file = new File("/path/to/image.jpg");
byte[] data = ... // read file as bytes
ParseFile parseFile = new ParseFile("image.jpg", data);
parseFile.saveInBackground(e -> {
    if (e == null) {
        // File saved
    } else {
        // error
    }
});
File file = new File("/path/to/image.jpg");
byte[] data = ... // read file as bytes
ParseFile parseFile = new ParseFile("image.jpg", data);
parseFile.saveInBackground(e -> {
    if (e == null) {
        // File saved
    } else {
        // error
    }
});
﻿
Lampirkan file ke objek:
Java
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
﻿
Ambil URL file:
Java
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
﻿
Keamanan File
Parse Server menyediakan konfigurasi fleksibel untuk mengelola keamanan unggahan file, termasuk mengontrol apakah pengguna anonim atau terautentikasi dapat mengunggah file. Pastikan untuk memeriksa dokumen untuk konfigurasi yang lebih lanjut.
Langkah 7 – Verifikasi Email dan Reset Kata Sandi
Ikhtisar
Verifikasi email memastikan pengguna baru memiliki alamat email yang digunakan untuk mendaftar. Reset kata sandi memungkinkan pengguna memulihkan akun mereka dengan aman.
Konfigurasi Dasbor Back4App
Aktifkan verifikasi email: Di Dasbor aplikasi Anda, pergi ke Pengaturan Email.
Aktifkan reset kata sandi: Konfigurasi alur email reset kata sandi.
Kode/Implementasi
Memicu reset kata sandi dalam Java:
Java
ParseUser.requestPasswordResetInBackground("[email protected]", e -> {
    if (e == null) {
        // Email sent
    } else {
        // Something went wrong
    }
});
ParseUser.requestPasswordResetInBackground("email@example.com", e -> {
    if (e == null) {
        // Email sent
    } else {
        // Something went wrong
    }
});
﻿
Langkah 8 – Penjadwalan Tugas dengan Cloud Jobs
Cloud Jobs
Gunakan Cloud Jobs di Back4App untuk menjadwalkan tugas berulang, seperti membersihkan data lama atau mengirim email harian. Contoh:
JS
Parse.Cloud.job('cleanupOldScores', async (request) => {
  const GameScore = Parse.Object.extend('GameScore');
  const query = new Parse.Query(GameScore);
  // e.g., remove scores older than 30 days
  // ...
});
Parse.Cloud.job('cleanupOldScores', async (request) => {
  const GameScore = Parse.Object.extend('GameScore');
  const query = new Parse.Query(GameScore);
  // e.g., remove scores older than 30 days
  // ...
});
﻿
Jadwalkan di Dasbor Back4App > Pengaturan Aplikasi > Pengaturan Server > Tugas Latar Belakang.
Jadwal Pekerjaan Cloud
﻿
Langkah 9 – Mengintegrasikan Webhook
Webhook memungkinkan aplikasi Back4App Anda mengirim permintaan HTTP ke layanan eksternal setiap kali peristiwa tertentu terjadi, misalnya, mengirim data ke layanan pihak ketiga seperti Stripe.
Navigasi ke Webhook di dasbor Back4App Anda > Lainnya > WebHooks.
Tambahkan Webhook dengan endpoint eksternal Anda.
Konfigurasi pemicu untuk peristiwa yang relevan.
Menambahkan Webhook
﻿
Langkah 10 – Menjelajahi Panel Admin Back4App
Aplikasi Admin Back4app adalah antarmuka manajemen berbasis web yang dirancang untuk pengguna non-teknis. Ini memungkinkan operasi CRUD cepat dan manajemen data rutin tanpa menulis kode.
Mengaktifkan Aplikasi Admin
Pergi ke Dasbor Aplikasi > Lainnya > Aplikasi Admin dan klik Aktifkan Aplikasi Admin.
Aktifkan Aplikasi Admin
﻿
Buat Pengguna Admin Pertama dan subdomain, dan Anda akan memiliki UI web untuk administrasi data.
Kesimpulan
Dengan mengikuti tutorial komprehensif ini, Anda telah:
Membuat backend yang aman untuk aplikasi Android (Java) di Back4App.
Mengonfigurasi database dengan skema kelas, tipe data, dan hubungan.
Mengintegrasikan kueri waktu nyata (Kueri Langsung) untuk pembaruan data segera.
Menerapkan langkah-langkah keamanan menggunakan ACL dan CLP untuk melindungi dan mengelola akses data.
Menerapkan Cloud Code fungsi untuk menjalankan logika bisnis kustom di sisi server.
Mengatur otentikasi pengguna dengan dukungan untuk verifikasi email dan pengaturan ulang kata sandi.
Mengelola unggahan file dan pengambilan, dengan kontrol keamanan file opsional.
Menjadwalkan Pekerjaan Cloud untuk tugas latar belakang otomatis.
Menggunakan Webhooks untuk mengintegrasikan dengan layanan eksternal.
Menjelajahi Panel Admin Back4App untuk manajemen data.
Dengan frontend Android yang solid (Java) dan backend Back4App yang kuat, Anda sekarang siap untuk mengembangkan aplikasi yang kaya fitur, skalabel, dan aman. Teruslah menjelajahi fungsionalitas yang lebih canggih, integrasikan logika bisnis Anda, dan manfaatkan kekuatan Back4App untuk menghemat waktu Anda dalam administrasi server dan database. Selamat coding!
Langkah Selanjutnya
Bangun aplikasi Android yang siap produksi dengan memperluas backend ini untuk menangani model data yang lebih kompleks, strategi caching, dan optimisasi kinerja.
Integrasikan fitur-fitur canggih seperti alur autentikasi khusus, kontrol akses berbasis peran, atau API eksternal (seperti gerbang pembayaran).
Periksa dokumentasi resmi Back4app untuk penjelasan lebih dalam tentang keamanan canggih, penyetelan kinerja, dan analisis log.
Jelajahi tutorial lainnya tentang aplikasi chat real-time, dasbor IoT, atau layanan berbasis lokasi. Anda dapat menggabungkan teknik yang dipelajari di sini dengan API pihak ketiga untuk membuat aplikasi kompleks di dunia nyata.
﻿
Diperbarui 24 Jan 2025
Apakah halaman ini membantu Anda?
SEBELUMNYA
Cara Membangun Backend untuk Kotlin?
BERIKUTNYA
Cara Membangun Backend untuk Remix?