In Android app development, SQLite is a widely used database for storing and retrieving data. It is a lightweight and embedded database that comes bundled with Android. This blog post will guide you on how to use SQLite database in your Android apps using both Kotlin and Java.
Setting up SQLite Database
To use SQLite database in Android apps, you need to perform the following steps:
-
Create a Database Helper Class: First, create a class that extends
SQLiteOpenHelper. This class will handle the creation and upgrading of the database. In this class, you need to overrideonCreate()andonUpgrade()methods. -
Create a Contract Class: Create a contract class that defines the table structure and constants for the database. This class will define the table name, column names, and other necessary constants.
-
Implement CRUD Operations: Implement the necessary operations for managing the database, such as inserting, updating, deleting, and querying data.
-
Open and Close Database: Open the database connection when needed and close it after performing the operations.
Using SQLite Database in Kotlin
Here's an example of how to use SQLite database in an Android app using Kotlin.
Step 1: Create a Database Helper Class
class DatabaseHelper(context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
override fun onCreate(db: SQLiteDatabase) {
// Create the table using SQL CREATE statement
val createTable =
"CREATE TABLE $TABLE_NAME ($COLUMN_ID INTEGER PRIMARY KEY AUTOINCREMENT, $COLUMN_NAME TEXT NOT NULL)"
db.execSQL(createTable)
}
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
// Implement upgrade logic here if needed
}
companion object {
private const val DATABASE_NAME = "MyDatabase.db"
private const val DATABASE_VERSION = 1
private const val TABLE_NAME = "MyTable"
private const val COLUMN_ID = "id"
private const val COLUMN_NAME = "name"
}
}
Step 2: Create a Contract Class
object DatabaseContract {
object MyTable {
const val TABLE_NAME = "MyTable"
const val COLUMN_ID = "id"
const val COLUMN_NAME = "name"
}
}
Step 3: Implement CRUD Operations
class DatabaseManager(private val context: Context) {
fun insertData(name: String) {
val dbHelper = DatabaseHelper(context)
val db = dbHelper.writableDatabase
val values = ContentValues()
values.put(DatabaseContract.MyTable.COLUMN_NAME, name)
db.insert(DatabaseContract.MyTable.TABLE_NAME, null, values)
db.close()
}
fun retrieveData(): MutableList<String> {
val dbHelper = DatabaseHelper(context)
val db = dbHelper.readableDatabase
val projection = arrayOf(DatabaseContract.MyTable.COLUMN_NAME)
val cursor = db.query(
DatabaseContract.MyTable.TABLE_NAME,
projection,
null,
null,
null,
null,
null
)
val dataList = mutableListOf<String>()
while (cursor.moveToNext()) {
val name = cursor.getString(cursor.getColumnIndexOrThrow(DatabaseContract.MyTable.COLUMN_NAME))
dataList.add(name)
}
cursor.close()
db.close()
return dataList
}
}
Step 4: Open and Close Database
class MainActivity : AppCompatActivity() {
private lateinit var databaseManager: DatabaseManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// Open the database connection
databaseManager = DatabaseManager(this)
// Perform database operations
databaseManager.insertData("John Doe")
val data = databaseManager.retrieveData()
// Close the database connection
databaseManager.close()
}
}
Using SQLite Database in Java
Here's an example of how to use SQLite database in an Android app using Java.
Step 1: Create a Database Helper Class
public class DatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "MyDatabase.db";
private static final int DATABASE_VERSION = 1;
private static final String TABLE_NAME = "MyTable";
private static final String COLUMN_ID = "id";
private static final String COLUMN_NAME = "name";
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
// Create the table using SQL CREATE statement
String createTable =
"CREATE TABLE " + TABLE_NAME + " (" +
COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
COLUMN_NAME + " TEXT NOT NULL" +
")";
db.execSQL(createTable);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// Implement upgrade logic here if needed
}
}
Step 2: Create a Contract Class
public final class DatabaseContract {
private DatabaseContract() {}
public static final class MyTable {
public static final String TABLE_NAME = "MyTable";
public static final String COLUMN_ID = "id";
public static final String COLUMN_NAME = "name";
}
}
Step 3: Implement CRUD Operations
public class DatabaseManager {
private final Context context;
public DatabaseManager(Context context) {
this.context = context;
}
public void insertData(String name) {
DatabaseHelper dbHelper = new DatabaseHelper(context);
SQLiteDatabase db = dbHelper.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(DatabaseContract.MyTable.COLUMN_NAME, name);
db.insert(DatabaseContract.MyTable.TABLE_NAME, null, values);
db.close();
}
public List<String> retrieveData() {
DatabaseHelper dbHelper = new DatabaseHelper(context);
SQLiteDatabase db = dbHelper.getReadableDatabase();
String[] projection = {DatabaseContract.MyTable.COLUMN_NAME};
Cursor cursor = db.query(
DatabaseContract.MyTable.TABLE_NAME,
projection,
null,
null,
null,
null,
null
);
List<String> dataList = new ArrayList<>();
while (cursor.moveToNext()) {
String name = cursor.getString(cursor.getColumnIndexOrThrow(DatabaseContract.MyTable.COLUMN_NAME));
dataList.add(name);
}
cursor.close();
db.close();
return dataList;
}
}
Step 4: Open and Close Database
public class MainActivity extends AppCompatActivity {
private DatabaseManager databaseManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Open the database connection
databaseManager = new DatabaseManager(this);
// Perform database operations
databaseManager.insertData("John Doe");
List<String> data = databaseManager.retrieveData();
// Close the database connection
databaseManager.close();
}
}
That's all! Now you know how to use SQLite database in Android apps using both Kotlin and Java. SQLite provides a simple and efficient way to persist data in a mobile app. Start building your own database-powered Android app now!
本文来自极简博客，作者：魔法星河，转载请注明原文链接：How to Use SQLite Database in Android Apps
