Pembangunan Aplikasi Mudah Alih Flutter · Pelajaran

Integrasi Pangkalan Data SQLite

Integrasikan pangkalan data SQLite ke dalam aplikasi Flutter menggunakan pakej `sqflite` untuk penyimpanan data berstruktur dan hubungan.

Pelajaran 2 daripada 412 langkah

Integrasi Pangkalan Data SQLite ialah pelajaran Pembangunan Aplikasi Mudah Alih Flutter percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pembangunan Aplikasi Mudah Alih Flutter, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pembangunan Aplikasi Mudah Alih Flutter merangkumi sejumlah 4 pelajaran.

Menyimpan Data dengan SQLite

Selamat datang! Dalam pelajaran ini, kita akan mempelajari cara mengintegrasikan pangkalan data setempat ke dalam aplikasi Flutter anda menggunakan SQLite.

SQLite ialah enjin pangkalan data hubungan yang ringan, tanpa pelayan, kendiri dan bertransaksi. Ia sesuai untuk menyimpan data berstruktur terus pada peranti pengguna tanpa memerlukan proses pelayan yang berasingan.

Menyediakan `sqflite`

Untuk menggunakan SQLite dalam Flutter, kita bergantung pada pakej sqflite yang popular. Pakej ini menyediakan antara muka yang kukuh kepada pangkalan data SQLite.

Mula-mula, tambahkannya (bersama-sama path_provider dan path untuk pengurusan fail pangkalan data) pada fail pubspec.yaml anda di bawah kebergantungan:

dependencies:
flutter:
sdk: flutter
sqflite: ^2.3.0
path_provider: ^2.1.1
path: ^1.8.3

Jalankan flutter pub get dalam terminal anda selepas menambahkannya.

Kelas Pembantu Pangkalan Data

Amalan terbaik ialah mencipta kelas "pembantu" khusus untuk mengurus operasi pangkalan data anda. Ini memusatkan logik untuk membuka, mencipta dan melaksanakan pertanyaan.

Kelas ini biasanya mengendalikan perkara berikut:

Memulakan dan membuka sambungan pangkalan data.
Mencipta jadual apabila pangkalan data dibuka buat kali pertama.
Menyediakan satu tika (singleton) pangkalan data untuk seluruh aplikasi.
Mengabstrakkan pertanyaan SQL secara langsung.

Memulakan Pangkalan Data

Mari kita mula membina DatabaseHelper kita. Fungsi openDatabase sangat penting. Fungsi ini menerima laluan fail pangkalan data dan panggilan balik onCreate untuk persediaan awal.

Begini cara membuka atau mencipta pangkalan data anda:

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// NOTE: getDatabasesPath() requires Flutter context.
// This main method is for demonstration.
// In a real Flutter app, _initDatabase would be called
// from a StatefulWidget or similar.

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;

  factory DatabaseHelper() {
    return _instance;
  }

  DatabaseHelper._internal();

  Future<Database> get database async {
    if (_database != null) return _database!;
    _database = await _initDatabase();
    return _database!;
  }

  Future<Database> _initDatabase() async {
    // Get the default databases location for the platform
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');

    return await openDatabase(
      dbPath,
      version: 1,
      onCreate: (db, version) {
        // Table creation logic will go here
        print('Database created or opened.');
      },
    );
  }
}

void main() async {
  // This main is illustrative. sqflite operations need a
  // running Flutter app context to fully function (e.g. for getDatabasesPath).
  // When run in a Flutter app, DatabaseHelper().database
  // would ensure the DB is initialized.
  print('DatabaseHelper class defined.');
}

Mencipta Jadual Pertama Anda

Dalam panggilan balik onCreate bagi _initDatabase, kita mentakrifkan skema pangkalan data menggunakan SQL standard. Mari cipta jadual items yang ringkas.

Setiap item akan mempunyai id (kunci utama), name (teks) dan quantity (integer).

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        // SQL to create the items table
        await db.execute(
          '''
          CREATE TABLE items(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT,
            quantity INTEGER
          )
          '''
        );
        print('Table "items" created successfully.');
      },
    );
  }
}

void main() async {
  // This main is illustrative. In a Flutter app,
  // calling DatabaseHelper().database would trigger
  // _initDatabase and the onCreate callback.
  print('Database helper configured for table creation.');
}

Mencipta Model Data

Untuk bekerja dengan rekod pangkalan data dengan mudah, takrifkan kelas Dart yang mencerminkan struktur jadual anda. Ini membantu memetakan data antara objek Dart dan baris pangkalan data (yang biasanya diwakili sebagai Map).

Berikut ialah model Item kita dengan kaedah toMap() dan fromMap():

class Item {
  final int? id;
  final String name;
  final int quantity;

  Item({this.id, required this.name, required this.quantity});

  // Convert an Item into a Map. Keys must match DB column names.
  Map<String, dynamic> toMap() {
    return {
      'id': id,
      'name': name,
      'quantity': quantity,
    };
  }

  // Create an Item object from a Map (database row).
  static Item fromMap(Map<String, dynamic> map) {
    return Item(
      id: map['id'],
      name: map['name'],
      quantity: map['quantity'],
    );
  }

  @override
  String toString() {
    return 'Item(id: $id, name: $name, quantity: $quantity)';
  }
}

void main() {
  final myItem = Item(id: 1, name: 'Apple', quantity: 5);
  print('Created Item: ${myItem.toString()}');
  print('Converted to Map: ${myItem.toMap()}');

  final itemMap = {'id': 2, 'name': 'Banana', 'quantity': 3};
  final itemFromMap = Item.fromMap(itemMap);
  print('Item from Map: ${itemFromMap.toString()}');
}

Memasukkan Data

Sekarang mari tambah kaedah pada DatabaseHelper kita untuk memasukkan item baharu. Kaedah insert menerima nama jadual dan Map (daripada Item.toMap() kita).

Kaedah ini mengembalikan id baris yang baru dimasukkan.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (from previous scene, for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<int> insertItem(Item item) async {
    final db = await database;
    return await db.insert(
      'items',
      item.toMap(),
      conflictAlgorithm: ConflictAlgorithm.replace, // Replace if ID exists
    );
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // final newItem = Item(name: 'Milk', quantity: 2);
  // int id = await dbHelper.insertItem(newItem);
  // print('Inserted item with id: $id');
  print('Item insertion logic defined in DatabaseHelper.');
}

Membuat Pertanyaan Data

Untuk membaca data, gunakan kaedah query. Kaedah ini mengembalikan List>, yang kemudiannya anda tukarkan semula kepada objek Dart Item menggunakan Item.fromMap().

Anda boleh membuat pertanyaan untuk semua item atau item tertentu menggunakan klausa where.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<List<Item>> getItems() async {
    final db = await database;
    // Query all the items from the table
    final List<Map<String, dynamic>> maps = await db.query('items');

    // Convert the List<Map<String, dynamic>> into a List<Item>.
    return List.generate(maps.length, (i) {
      return Item.fromMap(maps[i]);
    });
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // await dbHelper.insertItem(Item(name: 'Bread', quantity: 1));
  // final items = await dbHelper.getItems();
  // print('Retrieved items: $items');
  print('Item query logic defined in DatabaseHelper.');
}

Mengemas Kini Data

Untuk menukar rekod sedia ada, gunakan kaedah update. Anda memberikan nama jadual, data baharu sebagai Map dan klausa where untuk menentukan rekod yang hendak dikemas kini.

Sentiasa gunakan whereArgs dengan ruang letak (?) untuk menghantar nilai dengan selamat dan mencegah suntikan SQL.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<int> updateItem(Item item) async {
    final db = await database;
    return await db.update(
      'items',
      item.toMap(),
      where: 'id = ?', // Specify which item to update
      whereArgs: [item.id],
    );
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // // Assume item with id 1 exists
  // var updatedItem = Item(id: 1, name: 'Milk', quantity: 3);
  // int count = await dbHelper.updateItem(updatedItem);
  // print('Updated $count item(s).');
  print('Item update logic defined in DatabaseHelper.');
}

Memadam Data

Untuk mengalih keluar rekod daripada pangkalan data anda, gunakan kaedah delete. Seperti update, anda memberikan nama jadual serta klausa where dengan whereArgs untuk menentukan rekod yang hendak dialih keluar.

Kaedah ini mengembalikan bilangan baris yang dipadam.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<int> deleteItem(int id) async {
    final db = await database;
    return await db.delete(
      'items',
      where: 'id = ?',
      whereArgs: [id],
    );
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // // Assume item with id 1 exists
  // int count = await dbHelper.deleteItem(1);
  // print('Deleted $count item(s).');
  print('Item deletion logic defined in DatabaseHelper.');
}

Kuiz Operasi SQLite

Pertimbangkan jadual items dengan lajur id (INTEGER), name (TEXT) dan quantity (INTEGER).

Apakah kaedah sqflite yang akan anda gunakan untuk mendapatkan semua item yang kuantitinya lebih besar daripada 10?

Jawab dalam pelajaran interaktif

Imbas Kembali: SQLite & `sqflite`

Syabas! Anda telah mempelajari asas mengintegrasikan SQLite ke dalam aplikasi Flutter menggunakan pakej sqflite.

Perkara penting:

SQLite ialah pangkalan data hubungan setempat yang ringan.
Pakej sqflite menyediakan API Dart untuk SQLite.
Kelas DatabaseHelper memusatkan operasi pangkalan data seperti mencipta, membuka dan mengurus jadual.
Anda boleh melaksanakan operasi CRUD standard (Cipta, Baca, Kemas Kini, Padam) menggunakan kaedah insert, query, update dan delete.
Menggunakan kelas model data (seperti Item) memudahkan pemetaan data antara objek Dart dan baris pangkalan data.

Pengetahuan ini penting untuk membina aplikasi Flutter yang kukuh dengan pengekalan data setempat!

Percuma untuk bermula

Pelajari Dart dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 88

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Integrasi Pangkalan Data SQLite” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Pembangunan Aplikasi Mudah Alih Flutter, termasuk “Integrasi Pangkalan Data SQLite”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Pembangunan Aplikasi Mudah Alih Flutter merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Integrasi Pangkalan Data SQLite”?

Integrasikan pangkalan data SQLite ke dalam aplikasi Flutter menggunakan pakej `sqflite` untuk penyimpanan data berstruktur dan hubungan. Anda berlatih Pembangunan Aplikasi Mudah Alih Flutter menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pembangunan Aplikasi Mudah Alih Flutter?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pembangunan Aplikasi Mudah Alih Flutter di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Integrasi Pangkalan Data SQLite” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pembangunan Aplikasi Mudah Alih Flutter ini?

Ya. Setiap pelajaran Pembangunan Aplikasi Mudah Alih Flutter menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pembangunan Aplikasi Mudah Alih Flutter