Android ORM 框架之greenDAO

最新推荐文章于 2024-03-27 19:17:08 发布

qq_39745566

最新推荐文章于 2024-03-27 19:17:08 发布

阅读量207

点赞数

greenDAO——greenRobot公司出品

dao：data access object，数据访问对象层，用于查询数据库并产生数据的层

使用流程：
导包：
一、在整个工程的build.gradle中配置插件的代码，一会将会使用插件自动生成一些我们需要的类。
二、在app文件夹下的build.gradle中配置

1、封装数据模型类bean，使用注解配置当前bean对应数据库的哪个表，bean中的属性对应表中的哪个列名
2、使用插件生成一些必要的类，自动生成的类都是根据bean自动创建
自动创建3个类：build -> Make Module 'app'。创建类的位置：app -> build -> generated -> source -> greendao -> 包名
DaoMaster：整个框架的主干类，用于产生DaoSession
DaoSession：会话，代表一次操作数据库的过程，用于产生XXXDao
（官方建议将初始化操作写在整个应用的全局环境中，即自定义Application类中）
XXXDao：数据模型类对应的dao对象，真正用于操作数据库的类，通过该类执行CRUD

3、创建数据库助手类DevOpenHelper，并且指定数据库文件名
4、使用助手创建对应的数据库对象
5、根据数据库对象创建对应的会话DaoSession，我们真正操作数据库的动作就是在会话环境中执行

6、根据会话获取真正操作数据库的dao对象，它就可以执行CRUD操作。

需要添加的依赖与配置：

// 配置greenDAO
greendao {
schemaVersion 2// 数据库版本号
}

Glide
compile 'com.github.bumptech.glide:glide:3.8.0'

Retrofit
compile 'com.squareup.retrofit2:converter-gson:2.3.0'

RxJava+Retrofit
compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
compile "io.reactivex.rxjava2:rxjava:2.1.5"
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

greenDAO
整个工程中的build.gradle中添加：
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'

app模块下的build.gradle中添加：
apply plugin: 'org.greenrobot.greendao'
compile 'org.greenrobot:greendao:3.2.2'

AVLoadingIndicatorView
compile 'com.wang.avi:library:1.0.0'

布局文件.xml：

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.greendao.activity.MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:id="@+id/insert_btn"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="插入数据"/>

        <Button
            android:id="@+id/delete_btn"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="删除数据"/>

        <Button
            android:id="@+id/update_btn"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="修改数据"/>

        <Button
            android:id="@+id/query_btn"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="查询数据"/>

    </LinearLayout>

    <android.support.v7.widget.RecyclerView
        android:background="#0f0"
        android:id="@+id/recycler_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layoutManager="android.support.v7.widget.LinearLayoutManager"/>

</LinearLayout>

item_food.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:orientation="vertical">

    <TextView
        android:id="@+id/title_tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <TextView
        android:id="@+id/price_tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</LinearLayout>

执行文件.java：

DBHelper.java

package com.example.greendao;

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

public class DBHelper extends SQLiteOpenHelper {
    public DBHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
        super(context, name, factory, version);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    // 监听数据库版本更新
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }
}

创建activity目录：

MainActivity.java

package com.example.greendao.activity;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.example.greendao.R;
import com.example.greendao.application.MyApplication;
import com.example.greendao.bean.FoodBean;

import com.example.greendao.adapter.FoodAdapter;
import com.example.greendao.application.MyApplication;
import com.example.greendao.bean.FoodBean;
import com.example.greendao.bean.FoodBeanDao;

import org.greenrobot.greendao.query.Query;
import org.greenrobot.greendao.query.QueryBuilder;

import java.util.List;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    protected Button mInsertBtn;
    protected Button mDeleteBtn;
    protected Button mUpdateBtn;
    protected Button mQueryBtn;
    protected RecyclerView mRecyclerView;
    private FoodBeanDao mDao;
    private FoodAdapter mAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.activity_main);
        initView();

        // 获取能够执行增删改查操作的dao对象
        mDao = MyApplication.getDaoSession()
                .getFoodBeanDao();
    }

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.insert_btn) {
            insertData();
        } else if (view.getId() == R.id.delete_btn) {
            deleteData();
        } else if (view.getId() == R.id.update_btn) {
            updateData();
        } else if (view.getId() == R.id.query_btn) {
            queryData();
        }
    }

    private void initView() {
        mInsertBtn = (Button) findViewById(R.id.insert_btn);
        mInsertBtn.setOnClickListener(MainActivity.this);
        mDeleteBtn = (Button) findViewById(R.id.delete_btn);
        mDeleteBtn.setOnClickListener(MainActivity.this);
        mUpdateBtn = (Button) findViewById(R.id.update_btn);
        mUpdateBtn.setOnClickListener(MainActivity.this);
        mQueryBtn = (Button) findViewById(R.id.query_btn);
        mQueryBtn.setOnClickListener(MainActivity.this);
        mRecyclerView = (RecyclerView) findViewById(R.id.recycler_view);

        mAdapter = new FoodAdapter(this);
        mRecyclerView.setAdapter(mAdapter);
    }

    // 插入数据
    // 判断数据库中是否存在数据，如果不存在则插入
    // 查询一遍数据库，如果能查询到菜名叫油焖大虾的数据，就不再插入重复数据了
    private void insertData() {
        // 查询数据，查询条件是name为油焖大虾
        Query<FoodBean> query = mDao.queryBuilder()
                // where查询条件
                // 哪个表的属性：哪个属性，值为多少多少
                // select * from FoodBean where Price = 998
                .where(FoodBeanDao.Properties.Price.eq(998))
                .build();
        // 查询一个foodbean对象，只要存在一个，就没必要重复插入了
        FoodBean queryBean = query.unique();
        // 如果数据库中不存在符合条件的数据，返回结果为null
        if (queryBean == null) {
            FoodBean insertBean = new FoodBean(System.currentTimeMillis(), "油焖大虾", 998);
            mDao.insert(insertBean);
            Toast.makeText(this, "插入成功", Toast.LENGTH_SHORT).show();
        }


    }

    // 删除数据
    // 删除大于500的food
    private void deleteData() {
        Query<FoodBean> query = mDao.queryBuilder()
                .where(FoodBeanDao.Properties.Price.gt(500))// 大于
                .build();
        List<FoodBean> foodBeanList = query.list();
        if (foodBeanList != null && foodBeanList.size() > 0) {
            for (FoodBean foodBean : foodBeanList) {
                mDao.delete(foodBean);
            }
        }
        Toast.makeText(this, "删除成功", Toast.LENGTH_SHORT).show();
    }

    // 修改数据，前提是数据库中能够找到要修改的数据
    // 修改价格大于等于500块的food
    private void updateData() {
        Query<FoodBean> query = mDao.queryBuilder()
                .where(FoodBeanDao.Properties.Price.ge(500))// 大于等于
                .build();
        List<FoodBean> foodBeanList = query.list();
        // 如果集合为null或者大小为0，没必要修改数据
        if (foodBeanList == null || foodBeanList.size() == 0) {
            return;
        }
        for (FoodBean foodBean : foodBeanList) {
            foodBean.setPrice(498);
            mDao.update(foodBean);
        }
        Toast.makeText(this, "修改成功", Toast.LENGTH_SHORT).show();
    }

    // 查询全部数据，降序
    private void queryData() {
        // 获取一个查询对象的构建者，使用构建者构建一个查询对象，并且将查询条件作为配置
        QueryBuilder<FoodBean> queryBuilder = mDao.queryBuilder();
        Query<FoodBean> query = queryBuilder
                .orderDesc(FoodBeanDao.Properties.Price)// order by Price desc
                .build();
        // 查询全部数据
        List<FoodBean> list = query.list();

        Log.d("1510", "size: " + list.size());

        mAdapter.addDatas(list);
    }

}

创建adapter目录：

FoodAdapter.java

package com.example.greendao.adapter;

import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import com.example.greendao.R;
import com.example.greendao.bean.FoodBean;

import java.util.ArrayList;
import java.util.List;

public class FoodAdapter extends RecyclerView.Adapter<FoodAdapter.ViewHolder> {

    private Context mContext;
    private List<FoodBean> mDatas;

    public FoodAdapter(Context context) {
        mContext = context;
        mDatas = new ArrayList<>();
    }

    // 添加数据
    public void addDatas(List<FoodBean> datas){
        mDatas.clear();
        mDatas.addAll(datas);
        notifyDataSetChanged();
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(mContext)
                .inflate(R.layout.item_food, parent, false);
        return new ViewHolder(itemView);
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        FoodBean food = mDatas.get(position);

        holder.mTitleTextView.setText(food.getName());
        holder.mPriceTextView.setText(food.getPrice() + "");
    }

    @Override
    public int getItemCount() {
        return mDatas== null ? 0 : mDatas.size();
    }

    static class ViewHolder extends RecyclerView.ViewHolder {

        TextView mTitleTextView;
        TextView mPriceTextView;

        public ViewHolder(View itemView) {
            super(itemView);

            mTitleTextView = ((TextView) itemView.findViewById(R.id.title_tv));
            mPriceTextView = ((TextView) itemView.findViewById(R.id.price_tv));
        }
    }

}

创建application目录：

MyApplication.java

package com.example.greendao.application;

import android.app.Application;
import android.util.Log;

import com.example.greendao.bean.DaoMaster;
import com.example.greendao.bean.DaoSession;

import org.greenrobot.greendao.database.Database;

public class MyApplication extends Application {

    public static final String DB_NAME = "my_database.db";

    // 一个工程中只创建一次会话即可，使用单例
    private static DaoSession sDaoSession;

    // 当app启动时最先执行该方法，通常执行一些初始化操作
    @Override
    public void onCreate() {
        super.onCreate();

        initGreenDAO();
    }

    private void initGreenDAO() {
        // 1、创建数据库助手实例，并且指定数据库文件名
        DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, DB_NAME) {

            // 数据库版本更新回调
            @Override
            public void onUpgrade(Database db, int oldVersion, int newVersion) {
                super.onUpgrade(db, oldVersion, newVersion);

                Log.d("1510", "old: " + oldVersion + ", new : " + newVersion);
            }
        };
        // 2、通过助手创建Database实例
        Database db = helper.getWritableDb();
        // 3、根据db主干创建Session会话，在会话中可以操作数据库
        sDaoSession = new DaoMaster(db).newSession();
    }

    public static DaoSession getDaoSession() {
        return sDaoSession;
    }
}

创建bean目录：

FoodBean.java

package com.example.greendao.bean;

import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.Generated;

@Entity
public class FoodBean {

    @Id(autoincrement = true)// greenDAO3设置自增无效，可以使用时间戳作为主键
    private long id;
    private String name;
    private int price;

    @Generated(hash = 1633110902)
    public FoodBean(long id, String name, int price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Generated(hash = 895705851)
    public FoodBean() {
    }

    public long getId() {
        return this.id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return this.price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

}