8002117067 徐梓涵 软件工程1702

什么是数据存储持久化技术？

  • 首先我们先了解一下什么是瞬时数据，瞬时数据是指在内存当中，可能由于程序关闭或者其他原因而导致的被内存回收的数据。
  • 而数据存储持久化技术就是为了将内存中的数据保存到存储设备之中，保证手机在关机的情况下数据仍然不会丢失。
  • 安卓中采用了三种的简单的方式来进行数据持久化的功能：
    1. 文件存储技术
    2. SharedPreference存储技术
    3. 数据库存储技术


由于前面两种比较简单，所以这里主要使用第三种方式，本篇读书笔记我将通过三种方式（1.简单使用SQLite; 2.LitePal框架；3.greenDAO）来演示操作数据库.

1.简单使用SQLite来完成数据库的增删改查：

Android提供了一个SQLiteOpenHelper来帮助创建数据库以及升级数据库，我们创建一个类来继承它，并且实现方法。这里如果多次点击创建数据库就会删除之前的数据库然后重新创建。

（1）使用SQLiteOpenHelper创建数据库，以及更新数据库

  • MyDatabaseHelper.java ```java package com.ncu.databasetest;

import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.widget.Toast;

import androidx.annotation.Nullable;

public class MyDatabaseHelper extends SQLiteOpenHelper {

  1. //创建表格Sql语句
  2. public static final String CREATE_BOOK = "create table Book ("
  3.         + "id integer primary key autoincrement, "
  4.         + "author text, "
  5.         + "price real, "
  6.         + "pages integer, "
  7.         + "name text)";
  9. public static final String CREATE_CATEGORY = "create table Category ("
  10.         + "id integer primary key autoincrement, "
  11.         + "category_name text, "
  12.         + "category_code integer)";
  14. private Context mContext;
  16. public MyDatabaseHelper(@Nullable Context context, @Nullable String name, @Nullable SQLiteDatabase.CursorFactory factory, int version) {
  17.     super(context, name, factory, version);
  18.     mContext = context;
  19. }
  21. @Override
  22. public void onCreate(SQLiteDatabase db) {
  23.     //添加图书基本
  24.     db.execSQL(CREATE_BOOK);
  25.     //添加查询详细信息
  26.     db.execSQL(CREATE_CATEGORY);
  27.     Toast.makeText(mContext, "Create succeeded", Toast.LENGTH_SHORT).show();
  28. }
  30. @Override
  31. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  32.     //为了每次都可以创建成功如果存在就删除掉
  33.     db.execSQL("drop table if exists Book");
  34.     db.execSQL("drop table if exists Category");
  35.     onCreate(db);
  36. }

}

  1. <a name="Cm2nt"></a>
  2. ### （2）修改XML文件方便后面实现功能
  4. - activity_main.xml
  5. ```xml
  6. <?xml version="1.0" encoding="utf-8"?>
  7. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
  8.     xmlns:app="http://schemas.android.com/apk/res-auto"
  9.     xmlns:tools="http://schemas.android.com/tools"
  10.     android:layout_width="match_parent"
  11.     android:layout_height="match_parent"
  12.     tools:context=".MainActivity">
  14.     <Button
  15.         android:id="@+id/button5"
  16.         android:layout_width="364dp"
  17.         android:layout_height="79dp"
  18.         android:text="SERCH DATA"
  19.         app:layout_constraintBottom_toBottomOf="parent"
  20.         app:layout_constraintEnd_toEndOf="parent"
  21.         app:layout_constraintHorizontal_bias="0.489"
  22.         app:layout_constraintStart_toStartOf="parent"
  23.         app:layout_constraintTop_toTopOf="parent"
  24.         app:layout_constraintVertical_bias="0.717" />
  26.     <Button
  27.         android:id="@+id/button2"
  28.         android:layout_width="364dp"
  29.         android:layout_height="79dp"
  30.         android:text="ADD DATA"
  31.         app:layout_constraintBottom_toBottomOf="parent"
  32.         app:layout_constraintEnd_toEndOf="parent"
  33.         app:layout_constraintHorizontal_bias="0.489"
  34.         app:layout_constraintStart_toStartOf="parent"
  35.         app:layout_constraintTop_toTopOf="parent"
  36.         app:layout_constraintVertical_bias="0.225" />
  38.     <Button
  39.         android:id="@+id/button3"
  40.         android:layout_width="364dp"
  41.         android:layout_height="79dp"
  42.         android:text="DELETE DATA"
  43.         app:layout_constraintBottom_toBottomOf="parent"
  44.         app:layout_constraintEnd_toEndOf="parent"
  45.         app:layout_constraintHorizontal_bias="0.489"
  46.         app:layout_constraintStart_toStartOf="parent"
  47.         app:layout_constraintTop_toTopOf="parent"
  48.         app:layout_constraintVertical_bias="0.392" />
  50.     <Button
  51.         android:id="@+id/button4"
  52.         android:layout_width="364dp"
  53.         android:layout_height="79dp"
  54.         android:text="UPDATA DATA"
  55.         app:layout_constraintBottom_toBottomOf="parent"
  56.         app:layout_constraintEnd_toEndOf="parent"
  57.         app:layout_constraintHorizontal_bias="0.489"
  58.         app:layout_constraintStart_toStartOf="parent"
  59.         app:layout_constraintTop_toTopOf="parent"
  60.         app:layout_constraintVertical_bias="0.553" />
  62.     <Button
  63.         android:id="@+id/button"
  64.         android:layout_width="364dp"
  65.         android:layout_height="79dp"
  66.         android:text="Create database"
  67.         app:layout_constraintBottom_toBottomOf="parent"
  68.         app:layout_constraintEnd_toEndOf="parent"
  69.         app:layout_constraintHorizontal_bias="0.498"
  70.         app:layout_constraintStart_toStartOf="parent"
  71.         app:layout_constraintTop_toTopOf="parent"
  72.         app:layout_constraintVertical_bias="0.046" />
  73. </androidx.constraintlayout.widget.ConstraintLayout>

显示出来的效果：
image.png

（3）接下来对对应的按键实现具体的功能

  • 实现创建数据库按钮功能

    1. Button createDatabase = (Button)findViewById(R.id.button);
    2.       createDatabase.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               dbHelper.getWritableDatabase();
    6.           }
    7.       });

  • 实现添加数据功能

    1. //添加数据
    2.       Button addData = (Button) findViewById(R.id.button2);
    3.       addData.setOnClickListener(new View.OnClickListener() {
    4.           @Override
    5.           public void onClick(View v) {
    6.               SQLiteDatabase db = dbHelper.getWritableDatabase();
    7.               //数据载体
    8.               ContentValues values = new ContentValues();
    9.               // 开始组装第一条数据
    10.               values.put("name", "The Da Vinci Code");
    11.               values.put("author", "Dan Brown");
    12.               values.put("pages", 454);
    13.               values.put("price", 16.96);
    14.               db.insert("Book", null, values); // 插入第一条数据
    15.               values.clear();
    16.               // 开始组装第二条数据
    17.               values.put("name", "The Lost Symbol");
    18.               values.put("author", "Dan Brown");
    19.               values.put("pages", 510);
    20.               values.put("price", 19.95);
    21.               db.insert("Book", null, values); // 插入第二条数据
    22.           }
    23.       });

  • 实现更新数据的功能

    1. Button updateData = (Button) findViewById(R.id.button3);
    2.       updateData.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               SQLiteDatabase db = dbHelper.getWritableDatabase();
    6.               ContentValues values = new ContentValues();
    7.               values.put("price", 10.99);
    8.               db.update("Book", values, "name = ?", new String[] { "The Da Vinci Code" });
    9.           }
    10.       });

  • 实现删除数据的功能

    1. Button deleteButton = (Button) findViewById(R.id.button4);
    2.       deleteButton.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               SQLiteDatabase db = dbHelper.getWritableDatabase();
    6.               db.delete("Book", "pages > ?", new String[] { "500" });
    7.           }
    8.       });

  • 实现查询数据的功能

    1. Button queryButton = (Button) findViewById(R.id.button5);
    2.       queryButton.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               SQLiteDatabase db = dbHelper.getWritableDatabase();
    6.               // 查询Book表中所有的数据,游标
    7.               Cursor cursor = db.query("Book", null, null, null, null, null, null);
    8.               if (cursor.moveToFirst()) {
    9.                   do {
    10.                       // 遍历Cursor对象，取出数据并打印
    11.                       String name = cursor.getString(cursor.getColumnIndex("name"));
    12.                       String author = cursor.getString(cursor.getColumnIndex("author"));
    13.                       int pages = cursor.getInt(cursor.getColumnIndex("pages"));
    14.                       double price = cursor.getDouble(cursor.getColumnIndex("price"));
    15.                       Log.d("MainActivity", "book name is " + name);
    16.                       Log.d("MainActivity", "book author is " + author);
    17.                       Log.d("MainActivity", "book pages is " + pages);
    18.                       Log.d("MainActivity", "book price is " + price);
    19.                   } while (cursor.moveToNext());
    20.               }
    21.               cursor.close();
    22.           }
    23.       });

  • 整体的MainActivity.java ```java package com.ncu.databasetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ContentValues; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button;

import pl.com.salsoft.sqlitestudioremote.SQLiteStudioService;

public class MainActivity extends AppCompatActivity { private MyDatabaseHelper dbHelper; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); SQLiteStudioService.instance().start(this); //现在的版本升级了 dbHelper = new MyDatabaseHelper(this,”BookStore.db”,null,2); Button createDatabase = (Button)findViewById(R.id.button); createDatabase.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { dbHelper.getWritableDatabase(); } }); //添加数据 Button addData = (Button) findViewById(R.id.button2); addData.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { SQLiteDatabase db = dbHelper.getWritableDatabase(); //数据载体 ContentValues values = new ContentValues(); // 开始组装第一条数据 values.put(“name”, “The Da Vinci Code”); values.put(“author”, “Dan Brown”); values.put(“pages”, 454); values.put(“price”, 16.96); db.insert(“Book”, null, values); // 插入第一条数据 values.clear(); // 开始组装第二条数据 values.put(“name”, “The Lost Symbol”); values.put(“author”, “Dan Brown”); values.put(“pages”, 510); values.put(“price”, 19.95); db.insert(“Book”, null, values); // 插入第二条数据 } }); Button updateData = (Button) findViewById(R.id.button3); updateData.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { SQLiteDatabase db = dbHelper.getWritableDatabase(); ContentValues values = new ContentValues(); values.put(“price”, 10.99); db.update(“Book”, values, “name = ?”, new String[] { “The Da Vinci Code” }); } }); Button deleteButton = (Button) findViewById(R.id.button4); deleteButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { SQLiteDatabase db = dbHelper.getWritableDatabase(); db.delete(“Book”, “pages > ?”, new String[] { “500” }); } }); Button queryButton = (Button) findViewById(R.id.button5); queryButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { SQLiteDatabase db = dbHelper.getWritableDatabase(); // 查询Book表中所有的数据,游标 Cursor cursor = db.query(“Book”, null, null, null, null, null, null); if (cursor.moveToFirst()) { do { // 遍历Cursor对象，取出数据并打印 String name = cursor.getString(cursor.getColumnIndex(“name”)); String author = cursor.getString(cursor.getColumnIndex(“author”)); int pages = cursor.getInt(cursor.getColumnIndex(“pages”)); double price = cursor.getDouble(cursor.getColumnIndex(“price”)); Log.d(“MainActivity”, “book name is “ + name); Log.d(“MainActivity”, “book author is “ + author); Log.d(“MainActivity”, “book pages is “ + pages); Log.d(“MainActivity”, “book price is “ + price); } while (cursor.moveToNext()); } cursor.close(); } }); } }

  2. - 实验效果演示：
  4. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588068923701-aa3eee68-2a24-4fa7-92b1-b67e9fbb488c.png#align=left&display=inline&height=897&margin=%5Bobject%20Object%5D&name=image.png&originHeight=897&originWidth=1440&size=67498&status=done&style=none&width=1440)
  6. - 这里说一下我使用的可视化数据库的工具是SQLiteStudio，这个工具我觉得非常的好用，只需要使用它提供的一个jar包（SQLiteStudioRemote.jar）导入到项目种，然后当项目正常运行的时候就可以通过这个工具连接上数据库，我后面也都会使用这个工具来查看数据库。
  7. - 接下来演示添加删除更新以及查询功能。
  9. （1）创建出来的数据库，以及表的结构：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588077877699-35f8e86b-aba7-409c-84d3-55a4a8913710.png#align=left&display=inline&height=826&margin=%5Bobject%20Object%5D&name=image.png&originHeight=826&originWidth=1359&size=90533&status=done&style=none&width=1359)<br />（2）添加功能，根据代码我写的内容将会添加上两条数据。<br />由于我之前插入过了数据，而数据的id我设置的是自动增加，所以现在是23，24。<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588078656390-be3f5785-e619-4f8b-9725-fc0ff463ea47.png#align=left&display=inline&height=283&margin=%5Bobject%20Object%5D&name=image.png&originHeight=283&originWidth=850&size=20984&status=done&style=none&width=850)<br />（3）新功能，点击更新数据来更新数据，根据我的代码功能会把书的名字为**The Da Vinci Code更新价格为10.99.**<br />**![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588078685770-3db4f8cf-501b-4bb8-9084-b7f0a932f648.png#align=left&display=inline&height=319&margin=%5Bobject%20Object%5D&name=image.png&originHeight=319&originWidth=733&size=22037&status=done&style=none&width=733)**<br />（4）删除功能，根据我写的代码，当页数大于500的时候就会删除掉这一项：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588079197908-46326d02-863b-4dcd-9100-5b275b1ab873.png#align=left&display=inline&height=334&margin=%5Bobject%20Object%5D&name=image.png&originHeight=334&originWidth=965&size=33403&status=done&style=none&width=965)<br />（5）最后是查询功能，现在还有一条数据，根据我写的代码会查询数据库种所有的数据，然后显示到我的Logcat中来：<br />如图：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588079394435-7f18c25e-8fff-4a61-8d81-7c9288dee744.png#align=left&display=inline&height=92&margin=%5Bobject%20Object%5D&name=image.png&originHeight=131&originWidth=1067&size=17250&status=done&style=none&width=746)
  11. ---
  13. <a name="q2mNi"></a>
  14. ## 2.使用LitePal来对SQLite数据库进行操作
  16. ---
  18. > LitePal介绍：
  19. > LitePal是一款开源的Android数据库框架，采用了对象关系映射(ORM)的模式，将平时开发时最常用的一些数据库功能进行了封装，使得开发者不用编写一行SQL语句就可以完成各种建表、増删改查的操作。并且LitePal很“轻”，jar包大小不到100k，而且近乎零配置，这一点和Hibernate这类的框架有很大区别。
  22. ---
  24. LitePal的使用比上一种的方法简单一些，下面就会对LitePal的介绍：
  25. <a name="RlpMg"></a>
  26. ### （1）配置使用LitePal
  28. - 修改build.gradle(Module:app)
  30. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588083429920-6ae6b8c8-c54c-42c3-b942-115eb91d847a.png#align=left&display=inline&height=256&margin=%5Bobject%20Object%5D&name=image.png&originHeight=256&originWidth=709&size=23026&status=done&style=none&width=709)
  32. - 创建一个资源包assets，创建一个litepal.xml:
  34.                                 ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588083631548-c555b4f8-b70e-4412-8aca-eb23441ec035.png#align=left&display=inline&height=488&margin=%5Bobject%20Object%5D&name=image.png&originHeight=488&originWidth=387&size=28502&status=done&style=none&width=387)<br />litepal.xml:
  35. ```xml
  36. <?xml version="1.0" encoding="utf-8"?>
  37. <litepal>
  38.     <dbname value="LitePal" ></dbname>
  40.     <version value="1" ></version>
  42.     <list>
  43.         <mapping class="com.ncu.litepaltest.Book"></mapping>
  44.         <mapping class="com.ncu.litepaltest.Category"></mapping>
  45.     </list>
  46. </litepal>

在这个litepal.xml文件中我们首先绑定了数据库LitePal,然后绑定了两个表。

  • 在AndroidMainifast.xml中加上一句话：

image.png
这样就已经配置好了。

（2）配置表

由于litepal是ORM对象映射模式，所以还需要有两个类来进行映射：

  • Book.java: ```xml package com.ncu.litepaltest;

import org.litepal.crud.DataSupport;

public class Book extends DataSupport {

  1. private int id;
  3. private String author;
  5. private double price;
  7. private int pages;
  9. private String name;
  11. private String press;
  13. public int getId() {
  14.     return id;
  15. }
  17. public void setId(int id) {
  18.     this.id = id;
  19. }
  21. public String getAuthor() {
  22.     return author;
  23. }
  25. public void setAuthor(String author) {
  26.     this.author = author;
  27. }
  29. public double getPrice() {
  30.     return price;
  31. }
  33. public void setPrice(double price) {
  34.     this.price = price;
  35. }
  37. public int getPages() {
  38.     return pages;
  39. }
  41. public void setPages(int pages) {
  42.     this.pages = pages;
  43. }
  45. public String getName() {
  46.     return name;
  47. }
  49. public void setName(String name) {
  50.     this.name = name;
  51. }
  53. public String getPress() {
  54.     return press;
  55. }
  57. public void setPress(String press) {
  58.     this.press = press;
  59. }

}

  2. - Category.java:
  3. ```java
  4. package com.ncu.litepaltest;
  6. import org.litepal.crud.DataSupport;
  8. public class Category extends DataSupport {
  10.     private int id;
  12.     private String categoryName;
  14.     private int categoryCode;
  16.     public void setId(int id) {
  17.         this.id = id;
  18.     }
  20.     public void setCategoryName(String categoryName) {
  21.         this.categoryName = categoryName;
  22.     }
  24.     public void setCategoryCode(int categoryCode) {
  25.         this.categoryCode = categoryCode;
  26.     }
  28. }

（3）完成增删改查功能

上面就已经配置完了，接下来就实现功能：

  • 连接创建数据库，由于上面都配置完了，所以我们只需要简单的数据库操作就可以实现创建数据库了：

    1. Button createDatabase = (Button) findViewById(R.id.button);
    2.       createDatabase.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               Connector.getDatabase();
    6.           }
    7.       });

  • 添加数据：

这里可以看到只需要save()就可以添加数据了，非常简单。

  1. Button addData = (Button) findViewById(R.id.button2);
  2.         addData.setOnClickListener(new View.OnClickListener() {
  3.             @Override
  4.             public void onClick(View v) {
  5.                 Book book = new Book();
  6.                 book.setName("The Da Vinci Code");
  7.                 book.setAuthor("Dan Brown");
  8.                 book.setPages(454);
  9.                 book.setPrice(16.96);
  10.                 book.setPress("Unknow");
  11.                 book.save();
  12.             }
  13.         });

  • 更新数据：

    1. Button updateData = (Button) findViewById(R.id.button4);
    2.       updateData.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               Book book = new Book();
    6.               book.setPrice(14.95);
    7.               book.setPress("Anchor");
    8.               book.updateAll("name = ? and author = ?", "The Da Vinci Code", "Dan Brown");
    9.           }
    10.       });

  • 删除数据：

    1. Button deleteButton = (Button) findViewById(R.id.button3);
    2.       deleteButton.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               DataSupport.deleteAll(Book.class, "price < ?", "15");
    6.           }
    7.       });

  • 查询数据：

    1. Button queryButton = (Button) findViewById(R.id.button5);
    2.       queryButton.setOnClickListener(new View.OnClickListener() {
    3.           @Override
    4.           public void onClick(View v) {
    5.               List<Book> books = DataSupport.findAll(Book.class);
    6.               for (Book book: books) {
    7.                   Log.d("MainActivity", "book name is " + book.getName());
    8.                   Log.d("MainActivity", "book author is " + book.getAuthor());
    9.                   Log.d("MainActivity", "book pages is " + book.getPages());
    10.                   Log.d("MainActivity", "book price is " + book.getPrice());
    11.                   Log.d("MainActivity", "book press is " + book.getPress());
    12.               }
    13.           }
    14.       });

  • 整个的MainActivity.java: ```java package com.ncu.litepaltest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button;

import org.litepal.crud.DataSupport; import org.litepal.tablemanager.Connector;

import java.util.List;

import pl.com.salsoft.sqlitestudioremote.SQLiteStudioService;

public class MainActivity extends AppCompatActivity {

  1. @Override
  2. protected void onCreate(Bundle savedInstanceState) {
  3.     super.onCreate(savedInstanceState);
  4.     setContentView(R.layout.activity_main);
  5.     SQLiteStudioService.instance().start(this);
  6.     Button createDatabase = (Button) findViewById(R.id.button);
  7.     createDatabase.setOnClickListener(new View.OnClickListener() {
  8.         @Override
  9.         public void onClick(View v) {
  10.             Connector.getDatabase();
  11.         }
  12.     });
  13.     Button addData = (Button) findViewById(R.id.button2);
  14.     addData.setOnClickListener(new View.OnClickListener() {
  15.         @Override
  16.         public void onClick(View v) {
  17.             Book book = new Book();
  18.             book.setName("The Da Vinci Code");
  19.             book.setAuthor("Dan Brown");
  20.             book.setPages(454);
  21.             book.setPrice(16.96);
  22.             book.setPress("Unknow");
  23.             book.save();
  24.         }
  25.     });
  26.     Button updateData = (Button) findViewById(R.id.button4);
  27.     updateData.setOnClickListener(new View.OnClickListener() {
  28.         @Override
  29.         public void onClick(View v) {
  30.             Book book = new Book();
  31.             book.setPrice(14.95);
  32.             book.setPress("Anchor");
  33.             book.updateAll("name = ? and author = ?", "The Da Vinci Code", "Dan Brown");
  34.         }
  35.     });
  36.     Button deleteButton = (Button) findViewById(R.id.button3);
  37.     deleteButton.setOnClickListener(new View.OnClickListener() {
  38.         @Override
  39.         public void onClick(View v) {
  40.             DataSupport.deleteAll(Book.class, "price < ?", "15");
  41.         }
  42.     });
  43.     Button queryButton = (Button) findViewById(R.id.button5);
  44.     queryButton.setOnClickListener(new View.OnClickListener() {
  45.         @Override
  46.         public void onClick(View v) {
  47.             List<Book> books = DataSupport.findAll(Book.class);
  48.             for (Book book: books) {
  49.                 Log.d("MainActivity", "book name is " + book.getName());
  50.                 Log.d("MainActivity", "book author is " + book.getAuthor());
  51.                 Log.d("MainActivity", "book pages is " + book.getPages());
  52.                 Log.d("MainActivity", "book price is " + book.getPrice());
  53.                 Log.d("MainActivity", "book press is " + book.getPress());
  54.             }
  55.         }
  56.     });
  57. }

}

  2. - 最后我们来看一下显示的效果：
  3. - 创建数据显示：
  5. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588089210977-ac780fea-6c2c-4000-a6d4-310782ff90ef.png#align=left&display=inline&height=826&margin=%5Bobject%20Object%5D&name=image.png&originHeight=826&originWidth=1359&size=103711&status=done&style=none&width=1359)
  7. - 添加数据：
  9. 这里添加了一条数据：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588089245076-29799fef-108d-4326-9101-44db98ebd80c.png#align=left&display=inline&height=826&margin=%5Bobject%20Object%5D&name=image.png&originHeight=826&originWidth=1359&size=84696&status=done&style=none&width=1359)
  11. - 更新数据，这里将价格进行修改为14.95：
  13. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588089374154-3a624ce4-73d5-4280-a2cb-192ff388516c.png#align=left&display=inline&height=285&margin=%5Bobject%20Object%5D&name=image.png&originHeight=285&originWidth=624&size=15120&status=done&style=none&width=624)
  15. - 查询数据：
  17. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588089418146-3b87da7e-c6c0-4ca3-a57a-1cf0ea2ad8f6.png#align=left&display=inline&height=123&margin=%5Bobject%20Object%5D&name=image.png&originHeight=149&originWidth=907&size=19458&status=done&style=none&width=746)
  19. - 删除数据：
  21. 这里数据被清空了。<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588089447625-81d68268-cbcd-4bfc-ac27-833ad639aa39.png#align=left&display=inline&height=231&margin=%5Bobject%20Object%5D&name=image.png&originHeight=231&originWidth=599&size=14151&status=done&style=none&width=599)<br />到此完成使用LitePal来使用数据库SQLite。
  23. ---
  26. <a name="kPEf1"></a>
  27. ## 3.使用GreenDao数据库来对SQLite进行操作
  29. ---
  31. > GreenDao介绍：
  32. > GreenDAO是一个**对象关系映射**（ORM Object RelationShop Mapping）的框架，能够提供一个**接口通过操作对象的方式**去操作关系型数据库，它能够让你操作数据库时更简单、更方便。
  33. > <br />> GreenDao的优点：
  34. > ①性能高，号称Android最快的关系型数据库，存取速度快
  35. > ②内存占用小
  36. > ③库文件比较小，小于100K，编译时间低，而且可以避免65K方法限制
  37. > ④支持数据库加密  greendao支持SQLCipher进行数据库加密
  38. > ⑤激活实体，支持缓存，代码自动生成。
  41. ---
  43. <a name="yLHhz"></a>
  44. ### （1）配置使用GreenDao
  46. - Project-gradle 配置
  48. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588090054734-76df77d4-8536-483f-9ae9-bb0fd2e977ce.png#align=left&display=inline&height=596&margin=%5Bobject%20Object%5D&name=image.png&originHeight=596&originWidth=891&size=37842&status=done&style=none&width=891)
  50. - app-gradle 配置
  52. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/489622/1588090113848-12d0cee4-720f-40d9-89dd-5330ab9e6b7d.png#align=left&display=inline&height=512&margin=%5Bobject%20Object%5D&name=image.png&originHeight=512&originWidth=1023&size=50527&status=done&style=none&width=1023)<br />注意这里的GreenDao的数据库已经在这里配置好了，而包名和文件夹名在后面的自动创建的文件就会使用到。
  53. <a name="dt8vw"></a>
  54. ### （2）创建表关联的类
  56. - 创建一个类User.java
  57. ```java
  58. @Entity
  59. public class User {
  61.     @Id(autoincrement = true)
  62.     private Long id;
  64.     private String name;
  66.     private int age;
  67. }
  • 然后Build一下：
    image.png
  • 神奇的一幕出现了，编译器帮我配置好了三个核心类

image.png

这三个类的意义： DevOpenHelper：创建SQLite数据库的SQLiteOpenHelper的具体实现 DaoMaster：GreenDao的顶级对象，作为数据库对象、用于创建表和删除表 DaoSession：管理所有的Dao对象，Dao对象中存在着增删改查等API

（3）创建DaoManager：

这个是用来创建数据库、创建数据库表、包含增删改查的操作以及数据库的升级的。

  1. package com.ncu.greendao;
  3. import android.content.Context;
  4. import android.view.View;
  6. import com.ncu.greendao.db.DaoMaster;
  7. import com.ncu.greendao.db.DaoSession;
  9. import org.greenrobot.greendao.query.QueryBuilder;
  11. //用于创建数据库、创建数据库表、包含增删改查的操作以及数据库的升级。
  12. public class DaoManager {
  13.     private DaoMaster.DevOpenHelper helper;
  14.     private DaoSession daoSession;
  15.     private DaoMaster daoMaster;
  16.     private static DaoManager greenDaoManager;
  17.     private String DBNAME = "GreenPal";
  19.     public DaoManager(){
  21.     }
  24.     public void init(Context context){
  25.         helper = new DaoMaster.DevOpenHelper(context,DBNAME);
  26.         daoMaster = new DaoMaster(helper.getWritableDb());
  27.         daoSession = daoMaster.newSession();
  28.     }
  30.     public static DaoManager getInstance(){
  31.         if (greenDaoManager == null){
  32.             greenDaoManager = new DaoManager();
  33.         }
  34.         return greenDaoManager;
  35.     }
  37.     public DaoMaster.DevOpenHelper getDevOpenHelper(){
  38.         return helper;
  39.     }
  41.     public DaoMaster getDaoMaster() {
  42.         return daoMaster;
  43.     }
  45.     public  DaoSession getDaoSession() {
  46.         return daoSession;
  47.     }
  49.     public void closeDB(){
  50.         if (helper != null){
  51.             helper.close();
  52.         }
  53.     }
  54. }

（4）创建UserDaoUtil：

这个是用来调用的工具类，里面写了我们增删改查的具体操作，这里有的用到了，有的没有用到：

  1. package com.ncu.greendao;
  3. import android.content.Context;
  4. import android.util.Log;
  6. import java.util.List;
  8. public class UserDaoUtil {
  9.     private static final String TAG = UserDaoUtil.class.getSimpleName();
  10.     private DaoManager mManager;
  12.     public UserDaoUtil(Context context){
  13.         mManager  = DaoManager.getInstance();
  14.         mManager.init(context);
  15.     }
  16.     //1.插入单条的人的数据
  17.     public boolean insertUser(User user){
  18.         boolean flag = false;
  19.         flag = mManager.getDaoSession().getUserDao().insert(user) == -1 ? false : true;
  20.         Log.i(TAG, "insert user :" + flag + "-->" + user.toString());
  21.         return flag;
  22.     }
  23.     //2.插入多条人的数据，在子线程中操作  插入形式List
  24.     public boolean insertMultUser(final List<User> userList) {
  25.         boolean flag = false;
  26.         try {
  27.             mManager.getDaoSession().runInTx(new Runnable() {
  28.                 @Override
  29.                 public void run() {
  30.                     for (User user : userList) {
  31.                         mManager.getDaoSession().insertOrReplace(user);
  32.                     }
  33.                 }
  34.             });
  35.             flag = true;
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         }
  39.         return flag;
  40.     }
  41.     //3.修改一条数据
  42.     public boolean updateUser(User user){
  43.         boolean flag = false;
  44.         try {
  45.             mManager.getDaoSession().update(user);
  46.             flag = true;
  47.         }catch (Exception e){
  48.             e.printStackTrace();
  49.         }
  50.         return flag;
  51.     }
  52.     //删除单条数据
  53.     public boolean deleteUser(User user){
  54.         boolean flag = false;
  55.         try {
  56.             //按照id删除
  57.             mManager.getDaoSession().delete(user);
  58.             flag = true;
  59.         }catch (Exception e){
  60.             e.printStackTrace();
  61.         }
  62.         return flag;
  63.     }
  64.     //删除所有的数据
  65.     public boolean deleteAll(){
  66.         boolean flag = false;
  67.         try {
  68.             //按照id删除
  69.             mManager.getDaoSession().deleteAll(User.class);
  70.             flag = true;
  71.         }catch (Exception e){
  72.             e.printStackTrace();
  73.         }
  74.         return flag;
  75.     }
  76.     //查询所有的数据
  77.     public List<User> queryAllUser(){
  78.         return mManager.getDaoSession().loadAll(User.class);
  79.     }
  80.     //根据主键id查询数据
  81.     public User queryUserById(long key){
  82.         return mManager.getDaoSession().load(User.class, key);
  83.     }
  85. }

（5）在MainActivity调用：

我们用这个来进行调用具体实现：

  1. package com.ncu.greendao;
  3. import androidx.appcompat.app.AppCompatActivity;
  5. import android.content.Context;
  6. import android.database.sqlite.SQLiteDatabase;
  7. import android.os.Bundle;
  8. import android.util.Log;
  9. import android.view.View;
  10. import android.widget.Button;
  11. import android.widget.Toast;
  13. import com.ncu.greendao.db.DaoMaster;
  14. import com.ncu.greendao.db.DaoSession;
  15. import com.ncu.greendao.db.UserDao;
  17. import pl.com.salsoft.sqlitestudioremote.SQLiteStudioService;
  19. public class MainActivity extends AppCompatActivity {
  20.     public static final String TAG="RightFragment";
  21.     UserDaoUtil userDaoUtil;
  22.     User user=null;
  23.     private DaoManager mManager;
  24.     @Override
  25.     protected void onCreate(Bundle savedInstanceState) {
  26.         super.onCreate(savedInstanceState);
  27.         setContentView(R.layout.activity_main);
  28.         SQLiteStudioService.instance().start(this);
  29.         userDaoUtil = new UserDaoUtil(this);
  30.         Button button = (Button)findViewById(R.id.button);
  31.         button.setOnClickListener(new View.OnClickListener() {
  32.             @Override
  33.             public void onClick(View v) {
  34.                 //创建数据库成功了
  36.             }
  37.         });
  38.         user = new User();//实例化
  39.         Button button2 = (Button)findViewById(R.id.button2);
  40.         button2.setOnClickListener(new View.OnClickListener() {
  41.             @Override
  42.             public void onClick(View v) {
  43.                 //由于自动增加所以其实可以不用传入id值
  44.                 user.setId(null);
  45.                 user.setAge(18);
  46.                 user.setName("xiaohong");
  47.                 userDaoUtil.insertUser(user);
  48.             }
  49.         });
  50.         Button button3 = (Button)findViewById(R.id.button3);
  51.         button3.setOnClickListener(new View.OnClickListener() {
  52.             @Override
  53.             public void onClick(View v) {
  54.                 //删除全部的
  55.                 userDaoUtil.deleteAll();
  56.             }
  57.         });
  58.         Button button4= (Button)findViewById(R.id.button4);
  59.         button4.setOnClickListener(new View.OnClickListener() {
  60.             @Override
  61.             public void onClick(View v) {
  62.                 user.setId((long) 1);
  63.                 user.setAge(19);
  64.                 user.setName("xiaobai");
  65.                 userDaoUtil.updateUser(user);
  66.             }
  67.         });
  68.         Button button5= (Button)findViewById(R.id.button5);
  69.         button5.setOnClickListener(new View.OnClickListener() {
  70.             @Override
  71.             public void onClick(View v) {
  72.                 user = userDaoUtil.queryUserById(1);
  73.                 Log.d(TAG,user.getName()+user.getAge());
  74.             }
  75.         });
  76.     }
  77. }
  • 最后我们来看一下具体实现的效果：
  • 创建的数据库：

image.png

  • 添加数据:

image.png

  • 修改数据：

image.png

  • 查询数据：

image.png

  • 删除数据：

image.png

以上就是本次的读书笔记