1# Tutorial - Erstellen einer Login/Register App mit MySQL/Php

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • 1# Tutorial - Erstellen einer Login/Register App mit MySQL/Php

      Guten Tag liebe Community


      Dies ist das erste einer vielzahl von Tutorial's wie man eine App für sein Forum erstellt.
      In diesen Tutorials gezeigen Code's sind abweichend von dem Orginalcode der M-Core App!


      1. Erstellen der MySQL Datenbank

      Ihr solltet euch zuerst eine MySQL Datenbank erstellen (Navicat,..). Dazu installiert ihr nun zuerst Xampp und danach Navicat (Downloadlink's sind unten zu finden). Öffnet nun die Console in Navicat in dem Ihr rechtsklickt auf eure Verbindung und auf Console klickt. Dort gebt ihr nun folgende SQL Code's ein.

      Quellcode

      1. create database android_api

      Quellcode

      1. use android_api

      Quellcode

      1. create table users(
      2. uid int(11) primary key auto_increment,
      3. unique_id varchar(23) not null unique,
      4. name varchar(50) not null,
      5. email varchar(100) not null unique,
      7. encrypted_password varchar(80) not null,
      8. salt varchar(10) not null,
      10. created_at datetime,
      11. updated_at datetime null
      Alles anzeigen


      2. Erstellen der PHP API Klassen

      Diese Funktion wird allgemein in jeder Standartverbindung der PHP API Klassen verwendet.

      Erstellt nun einen Ordner in eurem xampp/htdocs namens "android_login_api" und in diesem Ordner einen Ordner namens "include"
      Die folgenden PHP File's müssen in folgende Ordner:

      config.php - In den "include" Ordner
      DB_Connect.php - In den "include" Ordner
      DB_Functions.php - In den "include" Ordner
      index.php - In den "android_login_api" Ordner

      config.php - Einstellung zur Verbindung der Datenbank

      Quellcode

      1. define("DB_HOST", "");
      2. define("DB_USER", "");
      4. define("DB_PASSWORD", "");
      5. define("DB_DATABASE", "");
      7. ?>


      DB_Connect.php - Verbindung und schließen der Sitzung

      PHP-Quellcode

      1. <?php
      3. class DB_Connect {
      5. // constructor
      6. function __construct() {
      8. }
      10. // destructor
      11. function __destruct() {
      12. // $this->close();
      13. }
      15. // Connecting to database
      16. public function connect() {
      17. require_once 'config.php';
      18. // connecting to mysql
      19. $con = mysql_connect(DB_HOST, DB_USER, DB_PASSWORD);
      20. // selecting database
      21. mysql_select_db(DB_DATABASE);
      23. // return database handler
      24. return $con;
      25. }
      27. // Closing database connection
      28. public function close() {
      29. mysql_close();
      30. }
      32. }
      34. ?>
      Alles anzeigen

      DB_Functions.php -Diese Datei enthält Funktionen, um Benutzer in der Datenbank zu speichern etc.

      PHP-Quellcode

      1. <?php
      3. class DB_Functions {
      5. private $db;
      7. //put your code here
      8. // constructor
      9. function __construct() {
      10. require_once 'DB_Connect.php';
      11. // connecting to database
      12. $this->db = new DB_Connect();
      13. $this->db->connect();
      14. }
      16. // destructor
      17. function __destruct() {
      19. }
      21. /**
      22. * Storing new user
      23. * returns user details
      24. */
      25. public function storeUser($name, $email, $password) {
      26. $uuid = uniqid('', true);
      27. $hash = $this->hashSSHA($password);
      28. $encrypted_password = $hash["encrypted"]; // encrypted password
      29. $salt = $hash["salt"]; // salt
      30. $result = mysql_query("INSERT INTO users(unique_id, name, email, encrypted_password, salt, created_at) VALUES('$uuid', '$name', '$email', '$encrypted_password', '$salt', NOW())");
      31. // check for successful store
      32. if ($result) {
      33. // get user details
      34. $uid = mysql_insert_id(); // last inserted id
      35. $result = mysql_query("SELECT * FROM users WHERE uid = $uid");
      36. // return user details
      37. return mysql_fetch_array($result);
      38. } else {
      39. return false;
      40. }
      41. }
      43. /**
      44. * Get user by email and password
      45. */
      46. public function getUserByEmailAndPassword($email, $password) {
      47. $result = mysql_query("SELECT * FROM users WHERE email = '$email'") or die(mysql_error());
      48. // check for result
      49. $no_of_rows = mysql_num_rows($result);
      50. if ($no_of_rows > 0) {
      51. $result = mysql_fetch_array($result);
      52. $salt = $result['salt'];
      53. $encrypted_password = $result['encrypted_password'];
      54. $hash = $this->checkhashSSHA($salt, $password);
      55. // check for password equality
      56. if ($encrypted_password == $hash) {
      57. // user authentication details are correct
      58. return $result;
      59. }
      60. } else {
      61. // user not found
      62. return false;
      63. }
      64. }
      66. /**
      67. * Check user is existed or not
      68. */
      69. public function isUserExisted($email) {
      70. $result = mysql_query("SELECT email from users WHERE email = '$email'");
      71. $no_of_rows = mysql_num_rows($result);
      72. if ($no_of_rows > 0) {
      73. // user existed
      74. return true;
      75. } else {
      76. // user not existed
      77. return false;
      78. }
      79. }
      81. /**
      82. * Encrypting password
      83. * @param password
      84. * returns salt and encrypted password
      85. */
      86. public function hashSSHA($password) {
      88. $salt = sha1(rand());
      89. $salt = substr($salt, 0, 10);
      90. $encrypted = base64_encode(sha1($password . $salt, true) . $salt);
      91. $hash = array("salt" => $salt, "encrypted" => $encrypted);
      92. return $hash;
      93. }
      95. /**
      96. * Decrypting password
      97. * @param salt, password
      98. * returns hash string
      99. */
      100. public function checkhashSSHA($salt, $password) {
      102. $hash = base64_encode(sha1($password . $salt, true) . $salt);
      104. return $hash;
      105. }
      107. }
      109. ?>
      Alles anzeigen


      index.php Diese Datei spielt die Rolle akzeptierte anfragen Antworten zu geben.

      PHP-Quellcode

      1. <?php
      2. /**
      3. * File to handle all API requests
      4. * Accepts GET and POST
      5. *
      6. * Each request will be identified by TAG
      7. * Response will be JSON data
      9. /**
      10. * check for POST request
      11. */
      12. if (isset($_POST['tag']) && $_POST['tag'] != '') {
      13. // get tag
      14. $tag = $_POST['tag'];
      16. // include db handler
      17. require_once 'include/DB_Functions.php';
      18. $db = new DB_Functions();
      20. // response Array
      21. $response = array("tag" => $tag, "success" => 0, "error" => 0);
      23. // check for tag type
      24. if ($tag == 'login') {
      25. // Request type is check Login
      26. $email = $_POST['email'];
      27. $password = $_POST['password'];
      29. // check for user
      30. $user = $db->getUserByEmailAndPassword($email, $password);
      31. if ($user != false) {
      32. // user found
      33. // echo json with success = 1
      34. $response["success"] = 1;
      35. $response["uid"] = $user["unique_id"];
      36. $response["user"]["name"] = $user["name"];
      37. $response["user"]["email"] = $user["email"];
      38. $response["user"]["created_at"] = $user["created_at"];
      39. $response["user"]["updated_at"] = $user["updated_at"];
      40. echo json_encode($response);
      41. } else {
      42. // user not found
      43. // echo json with error = 1
      44. $response["error"] = 1;
      45. $response["error_msg"] = "Incorrect email or password!";
      46. echo json_encode($response);
      47. }
      48. } else if ($tag == 'register') {
      49. // Request type is Register new user
      50. $name = $_POST['name'];
      51. $email = $_POST['email'];
      52. $password = $_POST['password'];
      54. // check if user is already existed
      55. if ($db->isUserExisted($email)) {
      56. // user is already existed - error response
      57. $response["error"] = 2;
      58. $response["error_msg"] = "User already existed";
      59. echo json_encode($response);
      60. } else {
      61. // store user
      62. $user = $db->storeUser($name, $email, $password);
      63. if ($user) {
      64. // user stored successfully
      65. $response["success"] = 1;
      66. $response["uid"] = $user["unique_id"];
      67. $response["user"]["name"] = $user["name"];
      68. $response["user"]["email"] = $user["email"];
      69. $response["user"]["created_at"] = $user["created_at"];
      70. $response["user"]["updated_at"] = $user["updated_at"];
      71. echo json_encode($response);
      72. } else {
      73. // user failed to store
      74. $response["error"] = 1;
      75. $response["error_msg"] = "Error occured in Registartion";
      76. echo json_encode($response);
      77. }
      78. }
      79. } else {
      80. echo "Invalid Request";
      81. }
      82. } else {
      83. echo "Access Denied";
      84. }
      85. ?>
      Alles anzeigen


      3. Das Android Projekt starten

      Zuerst sollten wir nun Eclipse starten zum Programmieren der App, den Download findet ihr unten.

      Erstellt nun ein neues Projekt indem ihr auf File -> New Android Projekt klicken. Danach füllt ihr alle Felder aus und habt nun ein neues Projekt.
      Als nächstes erstellen wie ein neues Package für unsere ganzen library files. Dazu macht ihr einen Rechtsklick auf src -> New -> Package und nennt diese "library"

      JSON Parser Klasse

      Als nächtes brauchen wir eine Parser Klasse um die JSON zu analysieren und zu antworten.
      Dazu erstellt ihr eine Neue Klasse in eurer library und nennt diese "JSONParser.java" und fügt folgenden Code unter eurem

      Quellcode

      1. package com.example....;
      .

      Java-Quellcode

      1. import java.io.BufferedReader;
      2. import java.io.IOException;
      3. import java.io.InputStream;
      4. import java.io.InputStreamReader;
      5. import java.io.UnsupportedEncodingException;
      6. import java.util.List;
      8. import org.apache.http.HttpEntity;
      9. import org.apache.http.HttpResponse;
      10. import org.apache.http.NameValuePair;
      11. import org.apache.http.client.ClientProtocolException;
      12. import org.apache.http.client.entity.UrlEncodedFormEntity;
      13. import org.apache.http.client.methods.HttpPost;
      14. import org.apache.http.impl.client.DefaultHttpClient;
      15. import org.json.JSONException;
      16. import org.json.JSONObject;
      18. import android.util.Log;
      20. public class JSONParser {
      22. static InputStream is = null;
      23. static JSONObject jObj = null;
      24. static String json = "";
      26. // constructor
      27. public JSONParser() {
      29. }
      31. public JSONObject getJSONFromUrl(String url, List<NameValuePair> params) {
      33. // Making HTTP request
      34. try {
      35. // defaultHttpClient
      36. DefaultHttpClient httpClient = new DefaultHttpClient();
      37. HttpPost httpPost = new HttpPost(url);
      38. httpPost.setEntity(new UrlEncodedFormEntity(params));
      40. HttpResponse httpResponse = httpClient.execute(httpPost);
      41. HttpEntity httpEntity = httpResponse.getEntity();
      42. is = httpEntity.getContent();
      44. } catch (UnsupportedEncodingException e) {
      45. e.printStackTrace();
      46. } catch (ClientProtocolException e) {
      47. e.printStackTrace();
      48. } catch (IOException e) {
      49. e.printStackTrace();
      50. }
      52. try {
      53. BufferedReader reader = new BufferedReader(new InputStreamReader(
      54. is, "iso-8859-1"), 8);
      55. StringBuilder sb = new StringBuilder();
      56. String line = null;
      57. while ((line = reader.readLine()) != null) {
      58. sb.append(line + "n");
      59. }
      60. is.close();
      61. json = sb.toString();
      62. Log.e("JSON", json);
      63. } catch (Exception e) {
      64. Log.e("Buffer Error", "Error converting result " + e.toString());
      65. }
      67. // try parse the string to a JSON object
      68. try {
      69. jObj = new JSONObject(json);
      70. } catch (JSONException e) {
      71. Log.e("JSON Parser", "Error parsing data " + e.toString());
      72. }
      74. // return JSON String
      75. return jObj;
      78. }
      79. }
      Alles anzeigen


      SQL Database Handler Klasse

      Ich benutze in der Anwendung eine SQLite Datenbank zum speicher von Benutzerdaten. Doch es bleibt euch überlasse welche Ihr wählt.

      Erstellt nun wieder ein neues package namens "DatabaseHandler.java" und füge folgenden Code hinzu nach

      Quellcode

      1. package com.example....;
      .

      Java-Quellcode

      1. import java.util.HashMap;
      3. import android.content.ContentValues;
      4. import android.content.Context;
      5. import android.database.Cursor;
      6. import android.database.sqlite.SQLiteDatabase;
      7. import android.database.sqlite.SQLiteOpenHelper;
      9. public class DatabaseHandler extends SQLiteOpenHelper {
      11. // All Static variables
      12. // Database Version
      13. private static final int DATABASE_VERSION = 1;
      15. // Database Name
      16. private static final String DATABASE_NAME = "android_api";
      18. // Login table name
      19. private static final String TABLE_LOGIN = "login";
      21. // Login Table Columns names
      22. private static final String KEY_ID = "id";
      23. private static final String KEY_NAME = "name";
      24. private static final String KEY_EMAIL = "email";
      25. private static final String KEY_UID = "uid";
      26. private static final String KEY_CREATED_AT = "created_at";
      28. public DatabaseHandler(Context context) {
      29. super(context, DATABASE_NAME, null, DATABASE_VERSION);
      30. }
      32. // Creating Tables
      33. @Override
      34. public void onCreate(SQLiteDatabase db) {
      35. String CREATE_LOGIN_TABLE = "CREATE TABLE " + TABLE_LOGIN + "("
      36. + KEY_ID + " INTEGER PRIMARY KEY,"
      37. + KEY_NAME + " TEXT,"
      38. + KEY_EMAIL + " TEXT UNIQUE,"
      39. + KEY_UID + " TEXT,"
      40. + KEY_CREATED_AT + " TEXT" + ")";
      41. db.execSQL(CREATE_LOGIN_TABLE);
      42. }
      44. // Upgrading database
      45. @Override
      46. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
      47. // Drop older table if existed
      48. db.execSQL("DROP TABLE IF EXISTS " + TABLE_LOGIN);
      50. // Create tables again
      51. onCreate(db);
      52. }
      54. /**
      55. * Storing user details in database
      56. * */
      57. public void addUser(String name, String email, String uid, String created_at) {
      58. SQLiteDatabase db = this.getWritableDatabase();
      60. ContentValues values = new ContentValues();
      61. values.put(KEY_NAME, name); // Name
      62. values.put(KEY_EMAIL, email); // Email
      63. values.put(KEY_UID, uid); // Email
      64. values.put(KEY_CREATED_AT, created_at); // Created At
      66. // Inserting Row
      67. db.insert(TABLE_LOGIN, null, values);
      68. db.close(); // Closing database connection
      69. }
      71. /**
      72. * Getting user data from database
      73. * */
      74. public HashMap<String, String> getUserDetails(){
      75. HashMap<String,String> user = new HashMap<String,String>();
      76. String selectQuery = "SELECT * FROM " + TABLE_LOGIN;
      78. SQLiteDatabase db = this.getReadableDatabase();
      79. Cursor cursor = db.rawQuery(selectQuery, null);
      80. // Move to first row
      81. cursor.moveToFirst();
      82. if(cursor.getCount() > 0){
      83. user.put("name", cursor.getString(1));
      84. user.put("email", cursor.getString(2));
      85. user.put("uid", cursor.getString(3));
      86. user.put("created_at", cursor.getString(4));
      87. }
      88. cursor.close();
      89. db.close();
      90. // return user
      91. return user;
      92. }
      94. /**
      95. * Getting user login status
      96. * return true if rows are there in table
      97. * */
      98. public int getRowCount() {
      99. String countQuery = "SELECT * FROM " + TABLE_LOGIN;
      100. SQLiteDatabase db = this.getReadableDatabase();
      101. Cursor cursor = db.rawQuery(countQuery, null);
      102. int rowCount = cursor.getCount();
      103. db.close();
      104. cursor.close();
      106. // return row count
      107. return rowCount;
      108. }
      110. /**
      111. * Re crate database
      112. * Delete all tables and create them again
      113. * */
      114. public void resetTables(){
      115. SQLiteDatabase db = this.getWritableDatabase();
      116. // Delete All Rows
      117. db.delete(TABLE_LOGIN, null, null);
      118. db.close();
      119. }
      121. }
      Alles anzeigen


      User Function Klasse

      Erstellt nun wieder eine neue Klasse unter dem library package und nennt diese "UserFunctions.java"
      fügt wieder folgenden Code hinzu nach:

      Quellcode

      1. package com.example....;
      .

      Java-Quellcode

      1. import java.util.ArrayList;
      2. import java.util.List;
      4. import org.apache.http.NameValuePair;
      5. import org.apache.http.message.BasicNameValuePair;
      6. import org.json.JSONObject;
      8. import android.content.Context;
      10. public class UserFunctions {
      12. private JSONParser jsonParser;
      14. // Testing in localhost using wamp or xampp
      15. // use [URL]http://10.0.2.2/[/URL] to connect to your localhost ie [URL="http://localhost/"]BlackEvolution - Coming Soon[/URL]
      16. private static String loginURL = "[URL]http://10.0.2.2/ah_login_api/[/URL]";
      17. private static String registerURL = "[URL]http://10.0.2.2/ah_login_api/[/URL]";
      19. private static String login_tag = "login";
      20. private static String register_tag = "register";
      22. // constructor
      23. public UserFunctions(){
      24. jsonParser = new JSONParser();
      25. }
      27. /**
      28. * function make Login Request
      29. * @param email
      30. * @param password
      31. * */
      32. public JSONObject loginUser(String email, String password){
      33. // Building Parameters
      34. List<NameValuePair> params = new ArrayList<NameValuePair>();
      35. params.add(new BasicNameValuePair("tag", login_tag));
      36. params.add(new BasicNameValuePair("email", email));
      37. params.add(new BasicNameValuePair("password", password));
      38. JSONObject json = jsonParser.getJSONFromUrl(loginURL, params);
      39. // return json
      40. // Log.e("JSON", json.toString());
      41. return json;
      42. }
      44. /**
      45. * function make Login Request
      46. * @param name
      47. * @param email
      48. * @param password
      49. * */
      50. public JSONObject registerUser(String name, String email, String password){
      51. // Building Parameters
      52. List<NameValuePair> params = new ArrayList<NameValuePair>();
      53. params.add(new BasicNameValuePair("tag", register_tag));
      54. params.add(new BasicNameValuePair("name", name));
      55. params.add(new BasicNameValuePair("email", email));
      56. params.add(new BasicNameValuePair("password", password));
      58. // getting JSON Object
      59. JSONObject json = jsonParser.getJSONFromUrl(registerURL, params);
      60. // return json
      61. return json;
      62. }
      64. /**
      65. * Function get Login status
      66. * */
      67. public boolean isUserLoggedIn(Context context){
      68. DatabaseHandler db = new DatabaseHandler(context);
      69. int count = db.getRowCount();
      70. if(count > 0){
      71. // user logged in
      72. return true;
      73. }
      74. return false;
      75. }
      77. /**
      78. * Function to logout user
      79. * Reset Database
      80. * */
      81. public boolean logoutUser(Context context){
      82. DatabaseHandler db = new DatabaseHandler(context);
      83. db.resetTables();
      84. return true;
      85. }
      87. }
      Alles anzeigen


      Teil 2 wird nächste Woche kommen und dort werde ich euch zeigen, wie man das Design der Android App mit den Funktionen verbindet.
      Bis dahin

      Euer Armin ♥

      [HR][/HR]
      Downloadlinks

      Xampp
      Navicat
      Eclipse

      Alle Downloadlinks sind von Chip.de und enthalten keinerlei Vieren etc.

      [HR][/HR]
      Credits


      Ein besonderes Dankeschön geht an meine Kollegen von Androhive.info die mit mir daran gearbeiten haben und mir die möglichkeit geben haben solch tolle funktionen gemeinsam mit Ihnen zu erstellen. Natürlich möchte ich mein Team "LAZY" nicht vergessen die mir die bekanntschaft gemacht haben.[HR][/HR]

    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )

      • Die mysql Erweiterung sollte in neueren Projekten nicht mehr verwendet werden ... In der PHP Dokumentation wird zu mysqli oder PDO geraten.
      • In DB_Connect config.php einzubinden und mit diesen globalen Variablen die Datenbankverbindung herzustellen ist extrem unflexibel. Deine Klasse ist nicht nur an eine andere Datei gebunden, sie kann auch nur zu einer einzigen Datenbank verbinden, ist also alles andere als wiederverwendbar. Schlechter Stil.
      • Auch wenn du die Verbindung in einer Klasse herstellst, ist dein Code so nicht objektorientiert. Würdest du die Methode von DB_Connect static machen (das würde bei der mangelnden Flexibilität keinen Unterschied machen), könntest du auch einfach Funktionen nehmen.
      • Teilweise schreibst du das public vor die Methoden, teilweise nicht (schlechter Stil). Zudem hast du leere Konstruktore und Desktuktore. Die brauchst du nicht ...
      • DB_Functions ist ebenso unflexibel. Wieso übergibst du das DB_Connect-Objekt nicht dem Konstruktor oder einem Setter? Dann könntest du wenigstens die Datenbankverbindung austauschen (wenn DB_Connect zu verschiedenen Datenbanken verbinden könnten). Mag sein, dass ich das übertrieben kritisere, aber ich mag einfach keinen prozeduralen Quelltext, der in Klassen gepresst wurde. OOP steigert die Codequalität nicht immer ...
      • Du wechselst ständig zwischen Anführungszeichen und Hochkommas für Strings. Schlechter Stil ...
      • Ganz wichtig: Dein Code ist nicht gegen SQL Injections gesichert!
      • Der Stacktrace sollte im Release nicht mehr ausgegeben werden ... (JSON"Parser")
      • DatabaseHandler: Du bezeichnest die Klasse als Paket. Du kennst aber den Unterschied?!
      • Zum Android-Code kann ich nichts sagen, ich programmiere keine Apps ...
      • Wieso bezeichnest du das hier als Tutorial? Du erklärst nur, welcher Quelltext in welche angelegte Datei kopiert werden soll. Ähm ja, wenn man das dann mal auswendig kann ist man ja schon fast ein Guru ...

    • Gebe ich dir in manchen Punkten recht, doch die meisten kennen sich nicht sogut aus wie du und ich, und wissen nicht was eine SQL Injection etc ist. Dies hier dient nur zu lernzwecken und soll keine App für Microsoft werden. Mann kann ja Anfänger nicht direkt mit jedem einzelen Punkt konfrontieren, und ich bin auch nicht in der Lage wie die richtigen Spezialisten alles genaustens zu erklären. Denn auch ich bin kein Profi und muss ab und zu mal nachschlagen in Büchern bzw google.

      Außerdem geht es ja nicht um die PHP Funktion, sondern um die App allgemein, denn dort wird alles durch die sogenannten Injection's mehr oder weniger geschützt. Da man ja schlecht mit einem Android Gerät sich in eine Datenbank hacken kann..

    • Na ja, die Sicherheitslücke besteht im PHP Skript, und das kann auch vom PC aufgerufen werden.

      Es mag richtig sein, dass es für einen Anfänger kaum relevant ist, wie sicher sein Skript ist. Aber sobald er dann an etwas arbeitet, das er veröffentlichen oder online stellen möchte, ist das ein sehr wichtiges Thema. Bei deinem Quelltext kann ein Angreifer so gut wie alles mit deiner Datenbank anstellen. Er kann sich mit jedem beliebigen Account anmelden, sich alle Benutzerdaten anschauen, sie löschen, ... Das ist eine wirklich fatale Sicherheitslücke. Um die Kritik etwas konstruktiver zu machen: Du kannst die Sicherheitslücke schließen, indem du prepared statements von mysqli nutzt oder indem du jede Variable, die du in einem Query verwendest und die Eingaben des Benutzers erhält, mit mysql_real_escape_string() sicherst.

      Gebe ich dir in manchen Punkten recht, doch die meisten kennen sich nicht sogut aus wie du und ich, und wissen nicht was eine SQL Injection etc ist.

      Dann solltest du aber einen Hinweis darauf geben, dass der Quelltext auf keinen Fall so verwendet werden sollte.