Conectando banco de dados com aplicativos


Os principais comandos dependem da linguagem e do tipo do banco.
Vou te mostrar o essencial para conectar e usar no desenvolvimento profissional.

Estrutura básica de banco de dados

Quase todo app faz isso:

  1. Conecta no banco
  2. Cria tabelas/coleções
  3. Insere dados
  4. Busca dados
  5. Atualiza dados
  6. Remove dados

Principais comandos SQL

Usado em:

  • MySQL
  • PostgreSQL
  • SQLite

Criar banco

CREATE DATABASE app_db;

Selecionar banco

USE app_db;

Criar tabela

CREATE TABLE usuarios (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nome VARCHAR(100),
    email VARCHAR(100),
    senha VARCHAR(255)
);

Inserir dados

INSERT INTO usuarios (nome, email, senha)
VALUES ('Vinicius', 'teste@email.com', '123456');

Buscar dados

SELECT * FROM usuarios;

Buscar usuário específico:

SELECT * FROM usuarios
WHERE email = 'teste@email.com';

Atualizar dados

UPDATE usuarios
SET nome = 'Novo Nome'
WHERE id = 1;

Remover dados

DELETE FROM usuarios
WHERE id = 1;

Conexão com banco usando JavaScript (Node.js)

Muito usado para:

  • Apps web
  • APIs
  • Sistemas SaaS
  • Apps mobile backend

Instalar driver MySQL

npm install mysql2

Conectar MySQL

const mysql = require('mysql2');

const conexao = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: 'senha',
  database: 'app_db'
});

conexao.connect((erro) => {
  if (erro) {
    console.log('Erro conexão:', erro);
  } else {
    console.log('Banco conectado');
  }
});

Buscar dados em JavaScript

conexao.query(
  'SELECT * FROM usuarios',
  (erro, resultados) => {
    console.log(resultados);
  }
);

Inserir dados em JavaScript

conexao.query(
  'INSERT INTO usuarios (nome, email) VALUES (?, ?)',
  ['Vinicius', 'email@email.com']
);

Conexão PostgreSQL

Instalar

npm install pg

Conectar

const { Client } = require('pg');

const client = new Client({
  user: 'postgres',
  host: 'localhost',
  database: 'app_db',
  password: 'senha',
  port: 5432,
});

client.connect();

MongoDB (NoSQL)

Muito usado com:

  • Apps modernos
  • Chatbots
  • IA
  • Sistemas em tempo real

Instalar

npm install mongoose

Conectar MongoDB

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/app_db')
  .then(() => console.log('MongoDB conectado'));

Criar model MongoDB

const Usuario = mongoose.model('Usuario', {
  nome: String,
  email: String
});

Inserir dados MongoDB

const novo = new Usuario({
  nome: 'Vinicius',
  email: 'teste@email.com'
});

novo.save();

Firebase (Google)

Muito usado em:

  • Android
  • Apps mobile
  • Tempo real
  • Chat

Firebase Official

Instalar

npm install firebase

Conectar Firebase

import { initializeApp } from "firebase/app";

const firebaseConfig = {
  apiKey: "SUA_KEY",
  authDomain: "app.firebaseapp.com",
};

const app = initializeApp(firebaseConfig);

Arquitetura profissional moderna

Hoje muitos apps usam:

Frontend:

  • React
  • Flutter
  • Vue

Backend:

  • Node.js
  • Python
  • Java

Banco:

  • PostgreSQL
  • MongoDB

API:

  • REST
  • GraphQL

Cloud:

  • AWS
  • Google Cloud
  • Azure

Banco ideal para cada projeto

Projeto Melhor banco
Blog MySQL
Loja virtual PostgreSQL
Chat tempo real Firebase
IA / chatbot MongoDB
App offline SQLite
Sistema bancário PostgreSQL

Ferramentas profissionais

Gerenciar MySQL

Gerenciar PostgreSQL

MongoDB GUI

API Testing

Segurança importante

Nunca faça isso:

"SELECT * FROM usuarios WHERE email = '" + email + "'"

Isso causa:

  • SQL Injection
  • invasões
  • vazamento de dados

Use sempre:

WHERE email = ?

Estrutura recomendada para app moderno

APP
 ├── Frontend
 ├── Backend/API
 ├── Banco de Dados
 ├── Autenticação
 ├── Cache
 └── Cloud

Melhor stack atualmente para começar

Se quiser algo profissional e moderno:

  • Frontend → React
  • Backend → Node.js
  • Banco → PostgreSQL
  • ORM → Prisma
  • Auth → JWT
  • Cloud → Vercel + Railway

Ferramentas oficiais:

Exemplo profissional Android + Banco de Dados

Vou mostrar um exemplo moderno usando:

  • Android Studio
  • Java
  • API Node.js
  • Banco MySQL

Arquitetura correta:

Android App
     ↓
API REST (Node.js)
     ↓
Banco de Dados MySQL

Android normalmente NÃO conecta direto no banco por segurança.

Tecnologias usadas

Android

  • Java ou Kotlin

Backend

Banco

1. Criar banco MySQL

CREATE DATABASE app_db;

Criar tabela usuários

CREATE TABLE usuarios (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nome VARCHAR(100),
    email VARCHAR(100)
);

2. Criar API Node.js

Instalar dependências

npm init -y
npm install express mysql2 cors

Servidor API

server.js

const express = require('express');
const mysql = require('mysql2');
const cors = require('cors');

const app = express();

app.use(cors());
app.use(express.json());

const conexao = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'senha',
    database: 'app_db'
});

conexao.connect((erro) => {
    if (erro) {
        console.log(erro);
    } else {
        console.log('MySQL conectado');
    }
});

3. Criar rota inserir usuário

app.post('/usuarios', (req, res) => {

    const { nome, email } = req.body;

    const sql =
      'INSERT INTO usuarios (nome, email) VALUES (?, ?)';

    conexao.query(sql, [nome, email],
      (erro, resultado) => {

        if (erro) {
            res.status(500).json(erro);
        } else {
            res.json({
                mensagem: 'Usuário salvo'
            });
        }
    });

});

4. Criar rota listar usuários

app.get('/usuarios', (req, res) => {

    conexao.query(
      'SELECT * FROM usuarios',
      (erro, resultado) => {

        if (erro) {
            res.status(500).json(erro);
        } else {
            res.json(resultado);
        }
    });

});

Iniciar servidor

app.listen(3000, () => {
    console.log('Servidor rodando');
});

Rodar API

node server.js

5. Android Studio

Permissão internet

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET"/>

6. Adicionar biblioteca Retrofit

build.gradle

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

7. Classe Usuario.java

public class Usuario {

    private String nome;
    private String email;

    public Usuario(String nome, String email) {
        this.nome = nome;
        this.email = email;
    }

    public String getNome() {
        return nome;
    }

    public String getEmail() {
        return email;
    }
}

8. Interface API

ApiService.java

import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.POST;

public interface ApiService {

    @POST("usuarios")
    Call<Void> salvarUsuario(
        @Body Usuario usuario
    );
}

9. Configurar Retrofit

RetrofitClient.java

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {

    private static final String BASE_URL =
        "http://192.168.0.100:3000/";

    private static Retrofit retrofit;

    public static Retrofit getRetrofit() {

        if (retrofit == null) {

            retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(
                    GsonConverterFactory.create()
                )
                .build();
        }

        return retrofit;
    }
}

IMPORTANTE

Troque:

192.168.0.100

pelo IP do computador onde a API Node.js está rodando.

10. Enviar dados Android → MySQL

MainActivity.java

ApiService apiService =
    RetrofitClient
    .getRetrofit()
    .create(ApiService.class);

Usuario usuario =
    new Usuario(
        "Vinicius",
        "teste@email.com"
    );

Call<Void> call =
    apiService.salvarUsuario(usuario);

call.enqueue(new Callback<Void>() {

    @Override
    public void onResponse(
        Call<Void> call,
        Response<Void> response
    ) {

        Toast.makeText(
            MainActivity.this,
            "Salvo com sucesso",
            Toast.LENGTH_SHORT
        ).show();
    }

    @Override
    public void onFailure(
        Call<Void> call,
        Throwable t
    ) {

        Toast.makeText(
            MainActivity.this,
            t.getMessage(),
            Toast.LENGTH_SHORT
        ).show();
    }
});

Resultado

Fluxo funcionando:

Android
   ↓
Retrofit
   ↓
API Node.js
   ↓
MySQL

Melhorias profissionais

Autenticação JWT

Protege API.

HTTPS

Nunca use HTTP em produção.

ORM Prisma

Facilita banco de dados.

Firebase Auth

Login Google/email.

Estrutura profissional moderna

Android App
 ├── Login
 ├── API REST
 ├── JWT
 ├── MySQL/PostgreSQL
 ├── Upload Imagens
 ├── Push Notification
 └── Cloud

Alternativa MAIS FÁCIL hoje

Para Android moderno muitos usam:

  • Firestore
  • Login Google
  • Push notification
  • Storage

Sem precisar criar servidor backend.

Ferramentas oficiais