Como Desenvolver um Aplicativo CRUD para Android Usando Java?

27min
Visão Geral
Neste tutorial, você aprenderá como construir uma aplicação CRUD (criar, ler, atualizar, deletar) totalmente funcional para Android usando Java.
Usaremos o Back4app como nosso backend para gerenciar dados facilmente. Este guia irá orientá-lo na configuração de um projeto Back4app, no design do seu esquema de dados e na codificação das funcionalidades CRUD em um ambiente Android.
Inicialmente, você estabelecerá um projeto Back4app intitulado Basic-CRUD-App-Android que fornece uma solução de backend confiável. Você então definirá suas estruturas de dados criando as classes e campos necessários manualmente ou aproveitando o gerador de esquema impulsionado por IA do Back4app.
Em seguida, você explorará o Back4app Admin App—uma interface amigável de arrastar e soltar que simplifica o gerenciamento de dados.
Finalmente, você conectará seu aplicativo Android ao Back4app usando o Parse Android SDK, permitindo operações CRUD seguras e autenticação de usuários.
Ao final deste guia, você terá desenvolvido uma aplicação Android pronta para produção que lida com operações CRUD essenciais juntamente com gerenciamento seguro de usuários.
Insights Essenciais
Construa uma aplicação Android CRUD integrada a um backend robusto.
Entenda como estruturar um backend escalável e conectá-lo ao seu aplicativo Android.
Utilize o Admin App do Back4app para gerenciar facilmente operações de criar, ler, atualizar e deletar.
Aprenda a manipular dados de forma segura e autenticação de usuários em um contexto Android.
﻿
Requisitos
Antes de começar, certifique-se de que você tem:
Uma conta Back4app com um projeto recém-configurado.
Precisa de ajuda? Visite Introdução ao Back4app.
Uma configuração de desenvolvimento Android.
Use o Android Studio com suporte a Java e certifique-se de ter pelo menos a API Android 21.
Conhecimento básico de Java, desenvolvimento de aplicativos Android e APIs RESTful.
Revise a documentação do Android se necessário.
﻿
Passo 1 – Configurando Seu Projeto
Estabelecendo um Novo Projeto Back4app
Faça login na sua conta Back4app.
Selecione “Novo App” no seu painel.
Nomeie seu projeto: Basic-CRUD-App-Android e siga as instruções para concluir a configuração.
Criar Novo Projeto
﻿
Após a configuração do seu projeto, ele aparecerá no seu painel, pronto para mais configurações.
﻿
Passo 2 – Elaborando Seu Esquema de Dados
Definindo Suas Estruturas de Dados
Para este aplicativo CRUD Android, você precisa criar várias classes (coleções) dentro do seu projeto Back4app. Os exemplos abaixo ilustram as principais classes e seus campos essenciais para suportar a funcionalidade CRUD.
1. Coleção de Itens
Esta coleção armazena detalhes sobre cada item.
Campo
Tipo de Dados
Propósito
_id
ObjectId
Identificador único gerado pelo sistema.
título
String
Nome ou título do item.
descrição
String
Visão geral do item.
criadoEm
Data
Timestamp quando o item foi adicionado.
atualizadoEm
Data
Timestamp da última atualização.
2. Coleção de Usuários
Esta coleção lida com credenciais de usuário e detalhes de autenticação.
Campo
Tipo de Dados
Propósito
_id
ObjectId
ID único atribuído automaticamente.
nome de usuário
String
Nome de usuário único para o usuário.
email
String
Endereço de e-mail único.
hashDaSenha
String
Senha armazenada com segurança.
criadoEm
Data
Timestamp de criação da conta.
atualizadoEm
Data
Timestamp para atualizações de conta.
Você pode criar essas coleções e seus campos diretamente do painel do Back4app.
Criar Nova Classe
﻿
Para adicionar um novo campo, basta selecionar o tipo de dado desejado, inserir o nome do campo, definir um valor padrão se necessário e indicar se é obrigatório.
Criar Coluna
﻿
Usando o Assistente de IA Back4app para Criação de Esquema
O Assistente de IA integrado do Back4app pode gerar automaticamente seu esquema a partir de uma breve descrição, acelerando a configuração do seu projeto.
Como Usar o Assistente de IA:
Acesse o Assistente de IA:
No seu painel do Back4app, encontre o Assistente de IA nas configurações do projeto.
Descreva Seu Esquema:
Insira uma descrição detalhada das coleções e campos que você precisa.
Revise e Confirme:
O Assistente de IA proporá um esquema. Revise os detalhes e confirme para implementar as mudanças.
Exemplo de 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)
﻿
Esse método assistido por IA economiza tempo e garante que seu esquema de dados esteja otimizado para operações CRUD.
﻿
Passo 3 – Utilizando o Console de Administração para Gerenciamento de Dados
Conhecendo o Console de Administração
O Console de Administração do Back4app fornece uma interface visual para gerenciar seus dados de backend sem escrever nenhum código. Seus recursos de arrastar e soltar facilitam a execução de operações CRUD, como adicionar, modificar e remover registros.
Habilitando o Console de Administração
Abra o menu “Mais” no seu painel do Back4app.
Escolha “Admin App” e depois clique em “Habilitar Admin App.”
Crie suas credenciais de administrador configurando sua conta de administrador principal. Esse processo também criará funções de sistema (como B4aAdminUser) e classes de sistema.
Habilitar Admin App
﻿
Uma vez ativado, faça login no Console de Administração para gerenciar seus dados.
Painel do Admin App
﻿
Gerenciando Operações CRUD via o Console de Administração
Dentro do Console de Administração você pode:
Adicionar Novos Registros: Utilize o botão “Adicionar Registro” em uma coleção (por exemplo, Itens) para inserir novos dados.
Visualizar e Editar Registros: Clique em qualquer entrada para revisar ou atualizar seus detalhes.
Excluir Registros: Remova entradas que não são mais necessárias.
Essa interface simplifica muito o processo de gerenciamento de dados de backend.
﻿
Passo 4 – Conectando Seu Aplicativo Android com Back4app
Com seu backend preparado, o próximo passo é vincular seu aplicativo Android ao Back4app.
Opção A: Usando o SDK Android do Parse
Inclua o SDK Android do Parse em seu projeto:
Adicione a seguinte dependência no seu build.gradle arquivo:
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'
﻿
Inicialize o Parse em sua classe de aplicativo:
Crie um inicializador (por exemplo, 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()
        );
    }
}
﻿
Implementando operações CRUD em seu aplicativo Android:
Por exemplo, crie uma classe de serviço para gerenciar os dados dos itens:
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();
        }
    }
}
﻿
Opção B: Usando REST ou GraphQL
Se o SDK Android do Parse não for adequado, você pode executar tarefas CRUD através de chamadas REST. Por exemplo, para recuperar itens 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();
        }
    }
}
﻿
Integre essas chamadas de API dentro de suas classes Android conforme necessário.
﻿
Passo 5 – Protegendo Seu Backend
Implementando Listas de Controle de Acesso (ACLs)
Garanta que seus dados permaneçam protegidos configurando ACLs para seus objetos. Por exemplo, para criar um item que é acessível apenas ao seu proprietário:
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();
    }
}
﻿
Configurando Permissões em Nível de Classe (CLPs)
No painel do Back4app, ajuste os CLPs para suas coleções para garantir que apenas usuários autenticados possam acessar dados sensíveis.
﻿
Passo 6 – Implementando Autenticação de Usuário em Seu App Android
Configurando Gerenciamento de Usuários
O Back4app utiliza a coleção de Usuários embutida do Parse para gerenciar autenticação. Em seu app Android, implemente registro e login da seguinte forma:
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();
        }
    }
}
﻿
Você também pode implementar recursos adicionais, como gerenciamento de sessão e redefinições de senha, conforme necessário.
﻿
Passo 7 – Conclusão e Melhorias Futuras
Ótimo trabalho! Você criou com sucesso um aplicativo Android CRUD básico usando Java e o integrou com o Back4app.
Neste tutorial, você configurou um projeto chamado Basic-CRUD-App-Android, definiu coleções para Itens e Usuários e gerenciou seus dados através do Console de Administração do Back4app.
Além disso, você conectou seu aplicativo Android usando o SDK Android Parse (ou REST/GraphQL como alternativa) e implementou medidas de segurança robustas.
Próximos Passos:
Expanda Seu Aplicativo:
Adicione novos recursos como pesquisa avançada, visualizações detalhadas de itens ou notificações em tempo real.
Aprimore a Funcionalidade do Backend:
Experimente com funções em nuvem, integre APIs de terceiros ou configure acesso baseado em funções.
Aprofunde Seu Aprendizado:
Visite a documentação do Back4app para mais tutoriais e melhores práticas.
Feliz codificação e aproveite a construção do seu aplicativo Android CRUD!
Campo	Tipo de Dados	Propósito
_id	ObjectId	Identificador único gerado pelo sistema.
título	String	Nome ou título do item.
descrição	String	Visão geral do item.
criadoEm	Data	Timestamp quando o item foi adicionado.
atualizadoEm	Data	Timestamp da última atualização.
Campo	Tipo de Dados	Propósito
_id	ObjectId	ID único atribuído automaticamente.
nome de usuário	String	Nome de usuário único para o usuário.
email	String	Endereço de e-mail único.
hashDaSenha	String	Senha armazenada com segurança.
criadoEm	Data	Timestamp de criação da conta.
atualizadoEm	Data	Timestamp para atualizações de conta.
Como desenvolver um app CRUD para iOS usando Swift?
Como criar um app CRUD com Ember.js?