• 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.  * 
    19.  * 我们需要自定义一个类继承自ORMlite给我们提供的OrmLiteSqliteOpenHelper，创建一个构造方法，重写两个方法onCreate()和onUpgrade()
    20.  * 在onCreate()方法中使用TableUtils类中的createTable()方法初始化数据表
    21.  * 在onUpgrade()方法中我们可以先删除所有表，然后调用onCreate()方法中的代码重新创建表
    22.  * 
    23.  * 我们需要对这个类进行单例，保证整个APP中只有一个SQLite Connection对象
    24.  * 
    25.  * 这个类通过一个Map集合来管理APP中所有的DAO，只有当第一次调用这个DAO类时才会创建这个对象（并存入Map集合中）
    26.  * 其他时候都是直接根据实体类的路径从Map集合中取出DAO对象直接调用
    27.  */
    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.  * 
    14.  * 注解：
    15.  * DatabaseTable：通过其中的tableName属性指定数据库名称
    16.  * DatabaseField：代表数据表中的一个字段
    17.  * ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
    18.  * 
    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.     }
    123. }
    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.  * 
    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 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 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()方法了

  • 相关阅读:
    吃透阿里大佬私藏的这本 Java 进阶核心手册, 侥幸入职 P7
    Kubernetes调度器：资源分配与优化之道
    docker搭建Confluence(wiki)
    flutter实用笔记
    Time Travel Queries｜在 RisingWave 中访问历史数据
    FPGA高端项目：解码索尼IMX327 MIPI相机+图像缩放+视频拼接+HDMI输出，提供开发板+工程源码+技术支持
    《Go Web 编程》之第7章 Go Web服务
    分布式架构介绍
    Matlab：绘制日期时间
    Sentinel源码剖析之执行流程
  • 原文地址：https://blog.csdn.net/hdhhd/article/details/127774316