Android 数据库框架ormlite 使用

ormlite是什么？

首先可以去它的官网看看www.ormlite.com，它的英文全称是Object Relational Mapping，意思是对象关系映射；如果接触过Java EE开发的，一定知道Java Web开发就有一个类似的数据库映射框架——Hibernate。简单来说，就是我们定义一个实体类，利用这个框架，它可以帮我们吧这个实体映射到我们的数据库中，在Android中是SQLite，数据中的字段就是我们定义实体的成员变量。

为什么要用ormlite？

先说说优点

1. 轻量级
2. 使用简单，易上手
3. 封装完善
4. 文档全面

缺点

1. 基于反射，效率较低
2. 缺少中文翻译文档

如何使用？

第一种使用方式

导入jar包到项目libs文件夹下

到http://ormlite.com/releases/下载相应版本的jar，下载最新的，目前是最新版本4.49。我们下载稳定的4.48即可。

第二种使用方式

1.  
   implementation 'com.j256.ormlite:ormlite-android:5.0'
2.  
   implementation 'com.j256.ormlite:ormlite-core:5.0'

继承OrmLiteSqliteOpenHelper类定义数据库帮助类

1.  
   package youli.com.example.administrator.myview;
2.  
    
3.  
   import android.content.Context;
4.  
   import android.database.sqlite.SQLiteDatabase;
5.  
    
6.  
   import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
7.  
   import com.j256.ormlite.dao.Dao;
8.  
   import com.j256.ormlite.support.ConnectionSource;
9.  
   import com.j256.ormlite.table.TableUtils;
10.  
     
11.  
    import java.sql.SQLException;
12.  
    import java.util.HashMap;
13.  
    import java.util.Map;
14.  
     
15.  
     
16.  
    /**
17.  
    * 数据库操作管理工具类
18.  
    * <p>
19.  
    * 我们需要自定义一个类继承自ORMlite给我们提供的OrmLiteSqliteOpenHelper，创建一个构造方法，重写两个方法onCreate()和onUpgrade()
20.  
    * 在onCreate()方法中使用TableUtils类中的createTable()方法初始化数据表
21.  
    * 在onUpgrade()方法中我们可以先删除所有表，然后调用onCreate()方法中的代码重新创建表
22.  
    * <p>
23.  
    * 我们需要对这个类进行单例，保证整个APP中只有一个SQLite Connection对象
24.  
    * <p>
25.  
    * 这个类通过一个Map集合来管理APP中所有的DAO，只有当第一次调用这个DAO类时才会创建这个对象（并存入Map集合中）
26.  
    * 其他时候都是直接根据实体类的路径从Map集合中取出DAO对象直接调用
27.  
    */
28.  
     
29.  
    public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
30.  
     
31.  
    // 数据库名称
32.  
    public static final String DATABASE_NAME = "mydb.db";
33.  
    // 本类的单例实例
34.  
    private static DatabaseHelper instance;
35.  
    // 存储APP中所有的DAO对象的Map集合
36.  
    private Map<String, Dao> daos = new HashMap<>();
37.  
     
38.  
     
39.  
     
40.  
    // 获取本类单例对象的方法
41.  
    public static synchronized DatabaseHelper getInstance(Context context) {
42.  
    if (instance == null) {
43.  
    synchronized (DatabaseHelper.class) {
44.  
    if (instance == null) {
45.  
    instance = new DatabaseHelper(context);
46.  
    }
47.  
    }
48.  
    }
49.  
    return instance;
50.  
    }
51.  
     
52.  
    // 私有的构造方法
53.  
    private DatabaseHelper(Context context) {
54.  
    super(context, DATABASE_NAME, null, 1);
55.  
    }
56.  
     
57.  
     
58.  
    public DatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion) {
59.  
    super(context, databaseName, factory, databaseVersion);
60.  
    }
61.  
     
62.  
     
63.  
    // 根据传入的DAO的路径获取到这个DAO的单例对象（要么从daos这个Map中获取，要么新创建一个并存入daos）
64.  
    public synchronized Dao getDao(Class clazz) throws SQLException {
65.  
    Dao dao = null;
66.  
    String className = clazz.getSimpleName();
67.  
    if (daos.containsKey(className)) {
68.  
    dao = daos.get(className);
69.  
    }
70.  
    if (dao == null) {
71.  
    dao = super.getDao(clazz);
72.  
    daos.put(className, dao);
73.  
    }
74.  
    return dao;
75.  
    }
76.  
     
77.  
     
78.  
     
79.  
    @Override
80.  
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
81.  
    try {
82.  
    TableUtils.createTable(connectionSource, UserBean.class);
83.  
    TableUtils.createTable(connectionSource, ArticleBean.class);
84.  
    } catch (SQLException e) {
85.  
    e.printStackTrace();
86.  
    }
87.  
     
88.  
     
89.  
    }
90.  
     
91.  
    @Override
92.  
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
93.  
    try {
94.  
    TableUtils.dropTable(connectionSource, UserBean.class, true); //删除表格
95.  
    TableUtils.dropTable(connectionSource, ArticleBean.class, true);
96.  
    onCreate(database, connectionSource);
97.  
    } catch (SQLException e) {
98.  
    e.printStackTrace();
99.  
    }
100.  
     }
101.  
      
102.  
     // 释放资源
103.  
     @Override
104.  
     public void close() {
105.  
     super.close();
106.  
     for (String key : daos.keySet()) {
107.  
     Dao dao = daos.get(key);
108.  
     dao = null;
109.  
     }
110.  
     }
111.  
      
112.  
      
113.  
     }

定义实体类Bean，代表一张表

创建上面用到的Bean，在ormlite中，它代表数据库中的一张表，我们所定义的所有成员变量均可为表中的字段，只要我们按照它提供的注解方式来指定成员变量属性。

举个栗子：

UserBean：

1.  
   package youli.com.example.administrator.myview;
2.  
    
3.  
    
4.  
   import com.j256.ormlite.dao.ForeignCollection;
5.  
   import com.j256.ormlite.field.DatabaseField;
6.  
   import com.j256.ormlite.field.ForeignCollectionField;
7.  
   import com.j256.ormlite.table.DatabaseTable;
8.  
    
9.  
   import java.sql.Date;
10.  
     
11.  
    /**
12.  
    * UserBean实体类，存储数据库中user表中的数据
13.  
    * <p>
14.  
    * 注解：
15.  
    * DatabaseTable：通过其中的tableName属性指定数据库名称
16.  
    * DatabaseField：代表数据表中的一个字段
17.  
    * ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
18.  
    * <p>
19.  
    * 属性：
20.  
    * id：当前字段是不是id字段（一个实体类中只能设置一个id字段）
21.  
    * columnName：表示当前属性在表中代表哪个字段
22.  
    * generatedId：设置属性值在数据表中的数据是否自增
23.  
    * useGetSet：是否使用Getter/Setter方法来访问这个字段
24.  
    * canBeNull：字段是否可以为空，默认值是true
25.  
    * unique：是否唯一
26.  
    * defaultValue：设置这个字段的默认值
27.  
    */
28.  
    @DatabaseTable(tableName = "user") // 指定数据表的名称
29.  
    public class UserBean {
30.  
    // 定义字段在数据库中的字段名
31.  
    public static final String COLUMNNAME_ID = "id";
32.  
    public static final String COLUMNNAME_NAME = "name";
33.  
    public static final String COLUMNNAME_SEX = "sex";
34.  
    public static final String COLUMNNAME_BIRTHDAY = "birthday";
35.  
    public static final String COLUMNNAME_ADDRESS = "address";
36.  
     
37.  
     
38.  
    @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
39.  
    private int id;
40.  
    @DatabaseField(columnName = COLUMNNAME_NAME, useGetSet = true, canBeNull = false, unique = true)
41.  
    private String name;
42.  
    @DatabaseField(columnName = COLUMNNAME_SEX, useGetSet = true, defaultValue = "1")
43.  
    private String sex;
44.  
    @DatabaseField(columnName = COLUMNNAME_BIRTHDAY, useGetSet = true)
45.  
    private String birthday;
46.  
    @DatabaseField(columnName = COLUMNNAME_ADDRESS, useGetSet = true)
47.  
    private String address;
48.  
    @ForeignCollectionField(eager = true)
49.  
    //ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
50.  
    private ForeignCollection<ArticleBean> articles;
51.  
     
52.  
    public UserBean() {
53.  
     
54.  
    }
55.  
     
56.  
    public UserBean(String name, String sex, String birthday, String address) {
57.  
    this.name = name;
58.  
    this.sex = sex;
59.  
    this.birthday = birthday;
60.  
    this.address = address;
61.  
    }
62.  
     
63.  
    public int getId() {
64.  
    return id;
65.  
    }
66.  
     
67.  
    public void setId(int id) {
68.  
    this.id = id;
69.  
    }
70.  
     
71.  
    public String getName() {
72.  
    return name;
73.  
    }
74.  
     
75.  
    public void setName(String name) {
76.  
    this.name = name;
77.  
    }
78.  
     
79.  
    public String getSex() {
80.  
    return sex;
81.  
    }
82.  
     
83.  
    public void setSex(String sex) {
84.  
    this.sex = sex;
85.  
    }
86.  
     
87.  
    public String getBirthday() {
88.  
    return birthday;
89.  
    }
90.  
     
91.  
    public void setBirthday(String birthday) {
92.  
    this.birthday = birthday;
93.  
    }
94.  
     
95.  
    public String getAddress() {
96.  
    return address;
97.  
    }
98.  
     
99.  
    public void setAddress(String address) {
100.  
     this.address = address;
101.  
     }
102.  
      
103.  
     public ForeignCollection<ArticleBean> getArticles() {
104.  
     return articles;
105.  
     }
106.  
      
107.  
     public void setArticles(ForeignCollection<ArticleBean> articles) {
108.  
     this.articles = articles;
109.  
     }
110.  
      
111.  
     @Override
112.  
     public String toString() {
113.  
     return "UserBean{"
114.  
     "id=" id
115.  
     ", name='" name '\''
116.  
     ", sex=" sex
117.  
     ", birthday=" birthday
118.  
     ", address='" address '\''
119.  
     ", articles=" articles
120.  
     '}';
121.  
     }
122.  
      
123.  
     }
124.  
      

ArticleBean：

1.  
   package youli.com.example.administrator.myview;
2.  
    
3.  
   import com.j256.ormlite.field.DatabaseField;
4.  
   import com.j256.ormlite.table.DatabaseTable;
5.  
    
6.  
   /**
7.  
   * ArticleBean实体类，存储article数据表中的数据
8.  
   * 数据库中的article表和user表是关联的，因此我们需要在article表中配置外键
9.  
   * <p>
10.  
    * foreignColumnName：外键约束指向的类中的属性名
11.  
    * foreign：当前字段是否是外键
12.  
    * foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了
13.  
    */
14.  
    @DatabaseTable(tableName = "article")
15.  
    public class ArticleBean {
16.  
    // article表中各个字段的名称
17.  
    public static final String COLUMNNAME_ID = "id";
18.  
    public static final String COLUMNNAME_TITLE = "title";
19.  
    public static final String COLUMNNAME_CONTENT = "content";
20.  
    public static final String COLUMNNAME_USER = "user_id";
21.  
     
22.  
    @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
23.  
    private int id;
24.  
    @DatabaseField(columnName = COLUMNNAME_TITLE, useGetSet = true, canBeNull = false, unique = true)
25.  
    private String title;
26.  
    @DatabaseField(columnName = COLUMNNAME_CONTENT, useGetSet = true)
27.  
    private String content;
28.  
    @DatabaseField(columnName = COLUMNNAME_USER, foreign = true, foreignAutoRefresh = true, foreignAutoCreate = true, foreignColumnName = UserBean.COLUMNNAME_ID)
29.  
    private UserBean user_id;
30.  
     
31.  
    public ArticleBean() {
32.  
    }
33.  
     
34.  
    public ArticleBean(String title, String content, UserBean user) {
35.  
    this.title = title;
36.  
    this.content = content;
37.  
    this.user_id = user;
38.  
    }
39.  
     
40.  
    public int getId() {
41.  
    return id;
42.  
    }
43.  
     
44.  
    public void setId(int id) {
45.  
    this.id = id;
46.  
    }
47.  
     
48.  
    public String getTitle() {
49.  
    return title;
50.  
    }
51.  
     
52.  
    public void setTitle(String title) {
53.  
    this.title = title;
54.  
    }
55.  
     
56.  
    public String getContent() {
57.  
    return content;
58.  
    }
59.  
     
60.  
    public void setContent(String content) {
61.  
    this.content = content;
62.  
    }
63.  
     
64.  
    public UserBean getUser() {
65.  
    return user_id;
66.  
    }
67.  
     
68.  
    public void setUser(UserBean user) {
69.  
    this.user_id = user;
70.  
    }
71.  
     
72.  
    @Override
73.  
    public String toString() {
74.  
    return "ArticleBean{"
75.  
    "id=" id
76.  
    ", title='" title '\''
77.  
    ", content='" content '\''
78.  
    ", user=" user_id
79.  
    '}';
80.  
    }
81.  
    }

　从两个实体类中的代码来看，ORMLite和JavaWeb框架中的Hibernate相似，都是使用注解的方式来标注数据库中的表、字段、关联关系的，这也是ORMLite的工作原理：ORMLite是基于反射机制工作的，然而这也成为了ORMLite的一个非常致命的缺点，性能不好。因此，如果是对想能要求不高的项目，我们可以考虑使用ORMLite，而如果项目对性能要求较高，我们可以考虑使用GreenDAO。

　　至于各个标签、各个属性的用途，将在本贴的最后贴出。

　　现在让我们再来看ORMLite中的另一个比较重要的东西——DAO。DAO是用来将操作某张表的方法（增、删、改、查）封装起来的工具类。下面来看代码：

UserDao：

1.  
   package youli.com.example.administrator.myview;
2.  
    
3.  
   import android.content.Context;
4.  
    
5.  
   import com.j256.ormlite.dao.Dao;
6.  
    
7.  
   import java.sql.SQLException;
8.  
   import java.util.List;
9.  
    
10.  
    public class UserDao {
11.  
     
12.  
     
13.  
    public static UserDao userDao;
14.  
    private Context context;
15.  
    // ORMLite提供的DAO类对象，第一个泛型是要操作的数据表映射成的实体类；第二个泛型是这个实体类中ID的数据类型
16.  
    private Dao<UserBean, Integer> dao;
17.  
     
18.  
    public static UserDao getInstance(Context context) {
19.  
    if (userDao == null) {
20.  
    userDao = new UserDao(context);
21.  
    }
22.  
    return userDao;
23.  
     
24.  
    }
25.  
     
26.  
     
27.  
    public UserDao(Context context) {
28.  
    this.context = context;
29.  
    try {
30.  
    this.dao = DatabaseHelper.getInstance(context).getDao(UserBean.class);
31.  
    } catch (SQLException e) {
32.  
    e.printStackTrace();
33.  
    }
34.  
    }
35.  
     
36.  
     
37.  
    // 向user表中添加一条数据
38.  
    public void insert(UserBean data) {
39.  
    try {
40.  
    dao.create(data);
41.  
    } catch (SQLException e) {
42.  
    e.printStackTrace();
43.  
    }
44.  
    }
45.  
     
46.  
    // 删除user表中的一条数据
47.  
    public void delete(UserBean data) {
48.  
    try {
49.  
    dao.delete(data);
50.  
    } catch (SQLException e) {
51.  
    e.printStackTrace();
52.  
    }
53.  
    }
54.  
     
55.  
    // 删除指定id醒
56.  
    public void deleteById(int id) {
57.  
    try {
58.  
    dao.deleteById(id);
59.  
    } catch (SQLException e) {
60.  
    e.printStackTrace();
61.  
    }
62.  
    }
63.  
     
64.  
     
65.  
    // 修改user表中的一条数据
66.  
    public void update(UserBean data) {
67.  
    try {
68.  
    dao.update(data);
69.  
    } catch (SQLException e) {
70.  
    e.printStackTrace();
71.  
    }
72.  
    }
73.  
     
74.  
     
75.  
    // 查询user表中的所有数据
76.  
    public List<UserBean> selectAll() {
77.  
    List<UserBean> users = null;
78.  
    try {
79.  
    users = dao.queryForAll();
80.  
    } catch (SQLException e) {
81.  
    e.printStackTrace();
82.  
    }
83.  
    return users;
84.  
    }
85.  
     
86.  
    // 根据ID取出用户信息
87.  
    public UserBean queryById(int id) {
88.  
    UserBean user = null;
89.  
    try {
90.  
    user = dao.queryForId(id);
91.  
    } catch (SQLException e) {
92.  
    e.printStackTrace();
93.  
    }
94.  
    return user;
95.  
    }
96.  
     
97.  
     
98.  
    // 根据关键字查询用户信息
99.  
    public List<UserBean> querys(String key, String Value) {
100.  
     List<UserBean> users = null;
101.  
     try {
102.  
     users = dao.queryForEq(key, Value);
103.  
     } catch (SQLException e) {
104.  
     e.printStackTrace();
105.  
     }
106.  
     return users;
107.  
     }
108.  
     }

ArticleDao：

1.  
   package youli.com.example.administrator.myview;
2.  
    
3.  
    
4.  
   import android.content.Context;
5.  
    
6.  
   import com.j256.ormlite.dao.Dao;
7.  
    
8.  
   import java.sql.SQLException;
9.  
   import java.util.List;
10.  
     
11.  
    /**
12.  
    * 操作article表的DAO类
13.  
    */
14.  
    public class ArticleDao {
15.  
     
16.  
    private Context context;
17.  
     
18.  
    private static ArticleDao articleDao;
19.  
     
20.  
    // ORMLite提供的DAO类对象，第一个泛型是要操作的数据表映射成的实体类；第二个泛型是这个实体类中ID的数据类型
21.  
    private Dao<ArticleBean, Integer> dao;
22.  
     
23.  
     
24.  
    public static ArticleDao getInstance(Context context) {
25.  
    if (articleDao == null) {
26.  
    articleDao = new ArticleDao(context);
27.  
    }
28.  
    return articleDao;
29.  
    }
30.  
     
31.  
     
32.  
    public ArticleDao(Context context) {
33.  
    this.context = context;
34.  
    try {
35.  
    this.dao = DatabaseHelper.getInstance(context).getDao(ArticleBean.class);
36.  
    } catch (SQLException e) {
37.  
    e.printStackTrace();
38.  
    }
39.  
    }
40.  
     
41.  
    // 添加数据
42.  
    public void insert(ArticleBean data) {
43.  
    try {
44.  
    dao.create(data);
45.  
    } catch (SQLException e) {
46.  
    e.printStackTrace();
47.  
    }
48.  
    }
49.  
     
50.  
    // 删除数据
51.  
    public void delete(ArticleBean data) {
52.  
    try {
53.  
    dao.delete(data);
54.  
    } catch (SQLException e) {
55.  
    e.printStackTrace();
56.  
    }
57.  
    }
58.  
     
59.  
    // 修改数据
60.  
    public void update(ArticleBean data) {
61.  
    try {
62.  
    dao.update(data);
63.  
    } catch (SQLException e) {
64.  
    e.printStackTrace();
65.  
    }
66.  
    }
67.  
     
68.  
    // 通过ID查询一条数据
69.  
    public ArticleBean queryById(int id) {
70.  
    ArticleBean article = null;
71.  
    try {
72.  
    article = dao.queryForId(id);
73.  
    } catch (SQLException e) {
74.  
    e.printStackTrace();
75.  
    }
76.  
    return article;
77.  
    }
78.  
     
79.  
    // 通过条件查询文章集合（通过用户ID查找）
80.  
    public List<ArticleBean> queryByUserId(int user_id) {
81.  
    try {
82.  
    return dao.queryBuilder().where().eq(ArticleBean.COLUMNNAME_USER, user_id).query();
83.  
    } catch (SQLException e) {
84.  
    e.printStackTrace();
85.  
    }
86.  
    return null;
87.  
    }
88.  
     
89.  
    }

最后就是测试代码了。我们直接在MainActivity中写代码，然后运行看结果。在MainActivity中，我们首先创建两张表并向表中添加数据，然后从数据表中分别取出数据，展示到TextView中。代码如下：

layout:

1.  
   <?xml version="1.0" encoding="utf-8"?>
2.  
   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.  
   xmlns:app="http://schemas.android.com/apk/res-auto"
4.  
   xmlns:tools="http://schemas.android.com/tools"
5.  
   android:layout_width="match_parent"
6.  
   android:layout_height="match_parent"
7.  
   android:gravity="center_horizontal"
8.  
   android:orientation="vertical"
9.  
   tools:context=".MainActivity">
10.  
     
11.  
    <LinearLayout
12.  
    android:layout_width="match_parent"
13.  
    android:gravity="center"
14.  
    android:layout_height="wrap_content"
15.  
    android:orientation="horizontal">
16.  
     
17.  
    <Button
18.  
    android:id="@ id/btn1"
19.  
    android:layout_width="0dp"
20.  
    android:layout_weight="1"
21.  
    android:layout_height="wrap_content"
22.  
    android:text="添加用户" />
23.  
     
24.  
    <Button
25.  
    android:id="@ id/btn1_1"
26.  
    android:layout_width="0dp"
27.  
    android:layout_weight="1"
28.  
    android:layout_height="wrap_content"
29.  
    android:text="添加文章" />
30.  
     
31.  
    <Button
32.  
    android:id="@ id/btn2"
33.  
    android:layout_width="0dp"
34.  
    android:layout_weight="1"
35.  
    android:layout_height="wrap_content"
36.  
    android:text="查询" />
37.  
     
38.  
     
39.  
    <Button
40.  
    android:id="@ id/btn3"
41.  
    android:layout_width="0dp"
42.  
    android:layout_weight="1"
43.  
    android:layout_height="wrap_content"
44.  
    android:text="删除" />
45.  
     
46.  
    <Button
47.  
    android:id="@ id/btn4"
48.  
    android:layout_width="0dp"
49.  
    android:layout_weight="1"
50.  
    android:layout_height="wrap_content"
51.  
    android:text="修改" />
52.  
    </LinearLayout>
53.  
     
54.  
    <LinearLayout
55.  
    android:layout_width="match_parent"
56.  
    android:layout_height="wrap_content"
57.  
    android:layout_marginTop="10dp"
58.  
    android:orientation="horizontal">
59.  
     
60.  
    <EditText
61.  
    android:id="@ id/edit1"
62.  
    android:layout_width="0dp"
63.  
    android:layout_weight="1"
64.  
    android:layout_height="wrap_content"
65.  
    android:layout_margin="2dp"
66.  
    android:gravity="center"
67.  
    android:hint="姓名"
68.  
    android:text="李白"
69.  
    android:textSize="16dp" />
70.  
     
71.  
    <EditText
72.  
    android:id="@ id/edit2"
73.  
    android:layout_width="0dp"
74.  
    android:layout_weight="1"
75.  
    android:layout_height="wrap_content"
76.  
    android:layout_margin="2dp"
77.  
    android:gravity="center"
78.  
    android:hint="性别"
79.  
    android:text="男"
80.  
    android:textSize="16dp" />
81.  
     
82.  
    <EditText
83.  
    android:id="@ id/edit3"
84.  
    android:layout_width="0dp"
85.  
    android:layout_weight="1"
86.  
    android:layout_height="wrap_content"
87.  
    android:layout_margin="2dp"
88.  
    android:gravity="center"
89.  
    android:hint="生日"
90.  
    android:text="1996-02-02"
91.  
    android:textSize="16dp" />
92.  
     
93.  
    <EditText
94.  
    android:id="@ id/edit4"
95.  
    android:layout_width="0dp"
96.  
    android:layout_weight="1"
97.  
    android:layout_height="wrap_content"
98.  
    android:layout_margin="2dp"
99.  
    android:gravity="center"
100.  
     android:hint="住址"
101.  
     android:text="北京"
102.  
     android:textSize="16dp" />
103.  
     </LinearLayout>
104.  
      
105.  
      
106.  
     <LinearLayout
107.  
     android:layout_width="match_parent"
108.  
     android:layout_height="wrap_content"
109.  
     android:layout_marginTop="10dp"
110.  
     android:orientation="horizontal">
111.  
      
112.  
     <EditText
113.  
     android:id="@ id/edit5"
114.  
     android:layout_width="0dp"
115.  
     android:layout_weight="1"
116.  
     android:layout_height="wrap_content"
117.  
     android:layout_margin="2dp"
118.  
     android:gravity="center"
119.  
     android:hint="标题"
120.  
     android:text="望相思"
121.  
     android:textSize="16dp" />
122.  
      
123.  
     <EditText
124.  
     android:id="@ id/edit6"
125.  
     android:layout_width="0dp"
126.  
     android:layout_weight="3"
127.  
     android:layout_height="wrap_content"
128.  
     android:layout_margin="2dp"
129.  
     android:gravity="center"
130.  
     android:hint="内容"
131.  
     android:text="床前明月光"
132.  
     android:textSize="16dp" />
133.  
      
134.  
      
135.  
      
136.  
      
137.  
     </LinearLayout>
138.  
      
139.  
      
140.  
     <LinearLayout
141.  
     android:layout_width="match_parent"
142.  
     android:layout_height="match_parent">
143.  
     <ScrollView
144.  
     android:layout_width="match_parent"
145.  
     android:layout_height="match_parent">
146.  
      
147.  
     <TextView
148.  
     android:id="@ id/text1"
149.  
     android:layout_width="match_parent"
150.  
     android:layout_height="match_parent"
151.  
     android:layout_margin="2dp"
152.  
     android:gravity="center"
153.  
     android:textSize="16dp" />
154.  
      
155.  
     </ScrollView>
156.  
     </LinearLayout>
157.  
     </LinearLayout>

MainActivity:

1.  
   package youli.com.example.administrator.myview;
2.  
    
3.  
   import android.database.sqlite.SQLiteDatabase;
4.  
   import android.os.Bundle;
5.  
   import android.util.Log;
6.  
   import android.view.View;
7.  
   import android.widget.Button;
8.  
   import android.widget.EditText;
9.  
   import android.widget.TextView;
10.  
     
11.  
    import androidx.appcompat.app.AppCompatActivity;
12.  
     
13.  
    import com.j256.ormlite.dao.ForeignCollection;
14.  
    import com.j256.ormlite.stmt.DeleteBuilder;
15.  
     
16.  
    import java.util.ArrayList;
17.  
    import java.util.Date;
18.  
    import java.util.Iterator;
19.  
    import java.util.List;
20.  
     
21.  
    public class MainActivity extends AppCompatActivity implements View.OnClickListener {
22.  
     
23.  
    private EditText mEdit1;
24.  
    private EditText mEdit2;
25.  
    private EditText mEdit3;
26.  
    private EditText mEdit4;
27.  
    private EditText mEdit5;
28.  
    private EditText mEdit6;
29.  
    private Button mBtn1;
30.  
    private Button btn1_1;
31.  
    private Button mBtn2;
32.  
    private Button mBtn3;
33.  
    private Button mBtn4;
34.  
     
35.  
     
36.  
    private TextView text1;
37.  
     
38.  
    @Override
39.  
    protected void onCreate(Bundle savedInstanceState) {
40.  
    super.onCreate(savedInstanceState);
41.  
    setContentView(R.layout.activity_main);
42.  
    initView();
43.  
    }
44.  
     
45.  
    private void initView() {
46.  
    mEdit1 = (EditText) findViewById(R.id.edit1);
47.  
    mEdit2 = (EditText) findViewById(R.id.edit2);
48.  
    mEdit3 = (EditText) findViewById(R.id.edit3);
49.  
    mEdit4 = (EditText) findViewById(R.id.edit4);
50.  
    mEdit5 = (EditText) findViewById(R.id.edit5);
51.  
    mEdit6 = (EditText) findViewById(R.id.edit6);
52.  
    mBtn1 = (Button) findViewById(R.id.btn1);
53.  
    btn1_1 = (Button) findViewById(R.id.btn1_1);
54.  
    mBtn2 = (Button) findViewById(R.id.btn2);
55.  
    mBtn3 = (Button) findViewById(R.id.btn3);
56.  
    mBtn4 = (Button) findViewById(R.id.btn4);
57.  
    text1 = (TextView) findViewById(R.id.text1);
58.  
    btn1_1.setOnClickListener(this);
59.  
    mBtn1.setOnClickListener(this);
60.  
    mBtn2.setOnClickListener(this);
61.  
    mBtn3.setOnClickListener(this);
62.  
    mBtn4.setOnClickListener(this);
63.  
    }
64.  
     
65.  
    @Override
66.  
    public void onClick(View v) {
67.  
    switch (v.getId()) {
68.  
    case R.id.btn1: //新增用户
69.  
    getInsert();
70.  
    break;
71.  
    case R.id.btn1_1: //新增文章
72.  
    getInsert_wz();
73.  
    getInsert_wz1();
74.  
    break;
75.  
    case R.id.btn2: //查询
76.  
    // getQuery();
77.  
    getQuery1();
78.  
    break;
79.  
    case R.id.btn3: //删除
80.  
    getDelete();
81.  
    break;
82.  
    case R.id.btn4: //修改
83.  
    getUpdate();
84.  
    break;
85.  
    }
86.  
    }
87.  
     
88.  
     
89.  
    private void getInsert() { //新增用户
90.  
    String name = mEdit1.getText().toString().trim();
91.  
    String sex = mEdit2.getText().toString().trim();
92.  
    String birthday = mEdit3.getText().toString().trim();
93.  
    String address = mEdit4.getText().toString().trim();
94.  
    UserBean userData = new UserBean(name, sex, birthday, address); // 添加用户数据
95.  
    UserDao.getInstance(MainActivity.this).insert(userData);
96.  
    }
97.  
     
98.  
    private void getInsert_wz() { //新增文章
99.  
    String title = mEdit5.getText().toString().trim();
100.  
     String content = mEdit6.getText().toString().trim();
101.  
     UserBean userData = UserDao.getInstance(MainActivity.this).queryById(12);
102.  
     ArticleBean articleData = new ArticleBean(title, content, userData); // 添加文章数据
103.  
     ArticleDao.getInstance(MainActivity.this).insert(articleData);
104.  
     }
105.  
      
106.  
     private void getInsert_wz1() { //新增文章
107.  
     String title = mEdit5.getText().toString().trim();
108.  
     String content = mEdit6.getText().toString().trim();
109.  
     List<UserBean> list = UserDao.getInstance(MainActivity.this).querys("name", "李三思"); //唯一值 只有一条
110.  
     ArticleBean articleData = new ArticleBean(title, content, list.get(0)); // 添加文章数据
111.  
     ArticleDao.getInstance(MainActivity.this).insert(articleData);
112.  
     }
113.  
      
114.  
     /**
115.  
     * 根据文章查询 关联人的信息
116.  
     */
117.  
     private void getQuery() {
118.  
     StringBuffer contentBuffer = new StringBuffer();
119.  
     ArticleBean articleBean = new ArticleDao(MainActivity.this).queryById(1); // 从数据库中根据ID取出文章信息
120.  
     contentBuffer.append(articleBean.toString());
121.  
     List<UserBean> list = UserDao.getInstance(MainActivity.this).selectAll(); //根据取出的用户id查询用户信息
122.  
     if (list == null || list.size() < 0) {
123.  
     return;
124.  
     }
125.  
      
126.  
     UserBean userBean = new UserDao(MainActivity.this).queryById(6); // 从用户信息中取出关联的文章列表信息
127.  
     ForeignCollection<ArticleBean> articles = userBean.getArticles();
128.  
     Iterator<ArticleBean> iterator = articles.iterator();
129.  
     while (iterator.hasNext()) {
130.  
     ArticleBean article = iterator.next();
131.  
     contentBuffer.append(article.toString() "\n");
132.  
     }
133.  
     text1.setText(contentBuffer.toString()); // 设置TextView的文本
134.  
     }
135.  
      
136.  
      
137.  
     /**
138.  
     * 关键字查询跟人信息 与 关联的文章
139.  
     */
140.  
     private void getQuery1() {
141.  
      
142.  
     StringBuffer contentBuffer = new StringBuffer();
143.  
     List<UserBean> list = UserDao.getInstance(MainActivity.this).querys("name", "李三思");
144.  
      
145.  
     for (int i = 0; i < list.size(); i ) {
146.  
      
147.  
     ForeignCollection<ArticleBean> articles = list.get(i).getArticles();
148.  
     Iterator<ArticleBean> iterator = articles.iterator();
149.  
     while (iterator.hasNext()) {
150.  
     ArticleBean article = iterator.next();
151.  
     contentBuffer.append(article.toString() "\n");
152.  
     }
153.  
     }
154.  
     // 设置TextView的文本
155.  
     text1.setText(contentBuffer.toString());
156.  
     }
157.  
      
158.  
     private void getDelete() {
159.  
      
160.  
     //查询用户
161.  
     List<UserBean> list = UserDao.getInstance(MainActivity.this).querys("name", "李三思");
162.  
      
163.  
     //删除用户关联的文章
164.  
     for (int i = 0; i < list.size(); i ) {
165.  
     ForeignCollection<ArticleBean> articles = list.get(i).getArticles();
166.  
     Iterator<ArticleBean> iterator = articles.iterator();
167.  
     while (iterator.hasNext()) {
168.  
     ArticleBean article = iterator.next();
169.  
     ArticleDao.getInstance(this).delete(article);//删除
170.  
     }
171.  
     }
172.  
      
173.  
     //删除用户
174.  
     UserBean userBean = new UserBean();
175.  
     userBean.setId(7);
176.  
     UserDao.getInstance(MainActivity.this).delete(userBean);
177.  
      
178.  
     }
179.  
      
180.  
     private void getUpdate() {
181.  
     UserBean userBean = new UserBean();
182.  
     userBean.setId(5);
183.  
     userBean.setName("李三思");
184.  
     userBean.setSex("女");
185.  
     userBean.setBirthday("1996-03-03");
186.  
     userBean.setAddress("湖北");
187.  
     UserDao.getInstance(MainActivity.this).update(userBean);
188.  
      
189.  
     }
190.  
      
191.  
     @Override
192.  
     protected void onDestroy() {
193.  
     super.onDestroy();
194.  
     //DatabaseHelper.getInstance(this).close();
195.  
     }
196.  
      
197.  
      
198.  
     }
199.  
      

　运行结果如下图所示：

　　最后，贴出ORMLite中常用标签和各个属性代表的意义：

　常见标签：

 DatabaseTable：通过其中的tableName属性指定数据库名称
 DatabaseField：代表数据表中的一个字段
 ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
　　常见属性：

id：当前字段是不是id字段（一个实体类中只能设置一个id字段）
columnName：表示当前属性在表中代表哪个字段
generatedId：设置属性值在数据表中的数据是否自增
useGetSet：是否使用Getter/Setter方法来访问这个字段
canBeNull：字段是否可以为空，默认值是true
unique：是否唯一
defaultValue：设置这个字段的默认值
foreignColumnName：外键约束指向的类中的属性名
foreign：当前字段是否是外键
foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了

这篇好文章是转载于：学新通技术网