Use the Android Arch Runtime framework to achieve data persistence in the Java library
Use the Android Arch Runtime framework to achieve data persistence in the Java library
Overview:
The Android Arch Runtime framework is a set of components developed for Android to help developers build a strong and scalable application.This includes components for data persistence, allowing developers to store data more easily on local devices.This article will introduce how to use Android Arch Runtime frameworks in the Java library to achieve data persistence.
Step 1: Add dependencies
First, add the following dependencies in the Gradle file of the Java class library project:
implementation 'android.arch.persistence.room:runtime:1.1.1'
annotationProcessor 'android.arch.persistence.room:compiler:1.1.1'
This will introduce the Android Arch Runtime framework to your project, as well as related compilers.
Step 2: Create a physical class
According to your application needs, create a physical class in the Java class library project.The physical class is the Java object used in the ORM (object relationship mapping) mode.For example, if your application needs to store user information, you can create a physical class called User and define the corresponding attributes and methods for it.
@Entity(tableName = "user")
public class User {
@PrimaryKey(autoGenerate = true)
private int id;
@ColumnInfo(name = "name")
private String name;
// Other attributes and methods
// getter and setter method
}
In the above code,@Entity annotations are used to define the physical class,@Primarykey annotations are used to specify the primary key, and the autogenerate attribute is used to represent self -growth.@Columninfo annotation is used to specify the name of the column.
Step 3: Create data access objects (DAO)
Next, create an interface called DataAccessObject (DAO) to define the method of interacting with databases.You can define the methods of insertion, querying, updating and other operations in it.
@Dao
public interface UserDao {
@Insert
void insert(User user);
@Query("SELECT * FROM user")
List<User> getAllUsers();
// Other methods
}
In the above code, the@Insert annotation indicates the insertion operation, and@query annotation is used to perform a custom query.You can define other methods required in the DAO interface according to your needs.
Step 4: Create a database
Then, create an abstract class inherited from the RoomDataBase to define the database.You can provide it with a singles instance and create an abstract method within it to return the defined DAO interface.
@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
private static AppDatabase instance;
public static synchronized AppDatabase getInstance(Context context) {
if (instance == null) {
instance = Room.databaseBuilder(context.getApplicationContext(),
AppDatabase.class, "app_database")
.fallbackToDestructiveMigration()
.build();
}
return instance;
}
public abstract UserDao userDao();
}
In the above code,@database annotations are used to define the database, and add the entity class created to the database through the Entities attribute.Version attribute represents the version number of the database, you can change according to the needs.GetinStance () method is used to provide a single example of the database and create an instance of the database.UserDao () method is used to return the defined DAO interface.
Step 5: Use data persistence
Now, in your Java library project, you can start using the data persistence function.
First, get the database instance in your activities or fragments:
AppDatabase appDatabase = AppDatabase.getInstance(context);
Then, by calling the method in the DAO interface, operate the database:
User user = new User();
user.setName("John");
appDatabase.userDao().insert(user);
List<User> userList = appDatabase.userDao().getAllUsers();
In the above code, we first obtained the database instance, and then obtained the DAO interface instance by calling the UserDao () method, and using the INSERT () method to insert a user object.Then, by calling the getallusers () method, we can query all users.
Summarize:
By using the Android Arch Runtime framework, we can easily achieve data persistence in the Java library project.We only need to define the physical class, DAO interface and database class to achieve data storage and access.This convenient characteristic makes us more focused on the business logic of the application without paying too much attention to the underlying database operation.
