Use the ORMLITE CORE framework for the definition and mapping of the data model
ORMLITE CORE is a lightweight object relationship mapping (ORM) framework for Java development.It provides a simple and powerful way to define and mappore data models, enabling developers to operate databases in an object -oriented manner.
Before using ORMLITE CORE, we first need to add related to our projects.You can open the construction file of the project (such as pom.xml) and add the following dependencies:
<dependencies>
<dependency>
<groupId>com.j256.ormlite</groupId>
<artifactId>ormlite-core</artifactId>
<version>5.5</version>
</dependency>
<dependency>
<groupId>com.j256.ormlite</groupId>
<artifactId>ormlite-jdbc</artifactId>
<version>5.5</version>
</dependency>
<!-If you need to use in the Android project, add the following dependencies->
<!--
<dependency>
<groupId>com.j256.ormlite</groupId>
<artifactId>ormlite-android</artifactId>
<version>5.5</version>
</dependency>
-->
</dependencies>
Next, we can start to define our data model.Considering that this is a Chinese knowledge article, we take the article as an example. Suppose we have a Article class that contains title (Title), Author (Author) and Content:
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;
@DatabaseTable(tableName = "articles")
public class Article {
@DatabaseField(generatedId = true)
private int id;
@DatabaseField
private String title;
@DatabaseField
private String author;
@DatabaseField
private String content;
// It must include a non -ginseng constructor for the ORM framework
public Article() {
}
public Article(String title, String author, String content) {
this.title = title;
this.author = author;
this.content = content;
}
// getter and setter method
}
In the above code, we use the @DataBasetable annotation to specify the name of the database table, and use the @DataBaseField annotation to define each field.In this example, we use the generatedid = true to specify the generated ID field as the main key of the growth.
Once we define the data model, we can use the ORMLite Core API to perform the database operation.Here are some basic example code:
import com.j256.ormlite.dao.DaoManager;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.jdbc.JdbcPooledConnectionSource;
import java.sql.SQLException;
import java.util.List;
public class Main {
public static void main(String[] args) {
try (JdbcPooledConnectionSource connectionSource = new JdbcPooledConnectionSource("jdbc:h2:mem:test")) {
// Create the Article table
Dao<Article, Integer> articleDao = DaoManager.createDao(connectionSource, Article.class);
TableUtils.createTableIfNotExists(connectionSource, Article.class);
// Insert data
Article Article1 = New Article ("ORMLITE CORE Introduction", "Zhang San", "ORMLITE core is a lightweight ORM framework ...");););););););););););););););););););););
Article Article2 = New Article ("Example of" ORMLITE CORE "," Li Si "," The following is an example of some ORMLITE CORE ... ");););
articleDao.create(article1);
articleDao.create(article2);
// Query data
List<Article> articles = articleDao.queryForAll();
for (Article article : articles) {
System.out.println ("Title:" + Article.gettitle ());
System.out.println ("author:" + article.getauthor ());
System.out.println ("Contents:" + Article.getContent ());
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
Through the above code, we created a memory database and used the API of ORMLITE CORE to create the Article table, insert data, and perform query operations.
To sum up, the ORMLITE CORE is a powerful and simple object relationship mapping (ORM) framework. Through it, we can easily define and map data models, and use object -oriented methods for database operations.Whether it is for daily Java development or in the Android project, the ORMLITE CORE is a reliable choice.
