Kunnen we een externe MySQL-database in Android verbinden met JDBC?

Kortom:u kunt verbinding maken met uw MySQL-server (of wat u ook gebruikt), maar dat zou u niet moeten doen doe dit rechtstreeks vanuit uw Android-applicatie.

Redenen:

1. Android-applicaties kunnen worden gedecompileerd en de client heeft inloggegevens voor toegang tot uw database. Als je de juiste hacktools gebruikt, zoals Backtrack , dan kan deze kwaadwillende client de gegevens in uw database openen, verbinden en exploiteren.

2. Als uw toepassing voor klanten over de hele wereld is, moeten de clients per bewerking of reeks bewerkingen een verbinding met uw database openen en onderhouden. Het openen van een fysieke databaseverbinding kost veel tijd, zelfs wanneer uw pc-client zich in een LAN naast de database-engine-server bevindt. Stel je nu voor dat je een verbinding opent vanuit een land aan de andere kant van de wereld, b.v. China of Japan of uit een land in Zuid-Amerika zoals Brazilië of Peru (waar ik woon).

Om deze 2 redenen die ik kan bedenken, is het een slecht idee om zelfs maar rechtstreeks vanaf je telefoon verbinding te maken met MySQL of een andere database-engine.

Hoe dit probleem op te lossen? Gebruik een servicegeoriënteerde architectuur waar u ten minste twee toepassingen zult hebben:

1. Serviceprovider applicatie. Deze applicatie zal webservices maken en publiceren (bij voorkeur RESTful) en kan beleid opstellen om de webservices te gebruiken, zoals gebruikersauthenticatie en autorisatie. Deze applicatie zal ook verbinding maken met de database en er CRUD-bewerkingen tegen uitvoeren.

2. Service consument applicatie. Dit zou je Android (of een andere mobiele) applicatie zijn.

Vanuit uw vraag concentreert u zich op punt 1. Zoals ik in mijn opmerkingen heb gezegd, kunt u een webtoepassing in Java maken, daar een REST-service maken, wat neerkomt op een POJO (gewoon oud java-object) dat heeft een methode per dienst. Omdat het bij deze methode toch gewoon Java is, kun je andere functionaliteit toevoegen, zoals JDBC-gebruik.

Hier is een voorbeeld van een kick-off met Jersey, Jackson (JSON-bibliotheek) en JDBC:

@Path("/product")
public class ProductRestService {

    @GET
    @Path("/list")
    @Produces(MediaType.APPLICATION_JSON)
    public List<Product> getProducts() {
        List<Product> productList = new ArrayList<>();
        Connection con = ...; //retrieve your database connection
        Statement stmt = con.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT id, name FROM product");
        while (rs.next()) {
            Product product = new Product();
            product.setId(rs.getInt("id"));
            product.setName(rs.getString("name"));
            productList.add(product);
        }
        //ALWAYS close the resources
        rs.close();
        stmt.close();
        conn.close();
        return productList;
    }
}

U kunt controleren op verdere configuraties van de Java-webtoepassing in een zelfstudie zoals mkyong's of Vogella's of iets anders dat je leuk vindt (het is te veel informatie om in dit antwoord te plaatsen).

Merk op dat deze applicatie dan kan evolueren naar een gelaagde applicatie, en de JDBC-code zal in een DAO-klasse gaan, en dan de ProductRestService class heeft toegang tot de database via deze DAO-klasse. Hier is nog een voorbeeld van een kick-off:

public class ProductDao {
    public List<Product> getProducts() {
        List<Product> productList = new ArrayList<>();
        Connection con = ...; //retrieve your database connection
        //the rest of the code explained above...
        return productList;
    }
}

@Path("/product")
public class ProductRestService {
    @GET
    @Path("/list")
    @Produces(MediaType.APPLICATION_JSON)
    public List<Product> getProducts() {
        ProductDao productDao = new ProductDao();
        return productDao.getProducts();
    }
}

En u kunt andere wijzigingen toepassen op dit project dat zich ook ontwikkelt.