Ormlite 基本使用（关联表）

建立Bean类

UserBean表


import com.j256.ormlite.dao.ForeignCollection;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.field.ForeignCollectionField;
import com.j256.ormlite.table.DatabaseTable;

import java.util.Date;

/**
 * UserBean实体类，存储数据库中user表中的数据
 * <p>
 * 注解：
 * DatabaseTable：通过其中的tableName属性指定数据库名称
 * DatabaseField：代表数据表中的一个字段
 * ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
 * <p>
 * 属性：
 * id：当前字段是不是id字段（一个实体类中只能设置一个id字段）
 * columnName：表示当前属性在表中代表哪个字段
 * generatedId：设置属性值在数据表中的数据是否自增
 * useGetSet：是否使用Getter/Setter方法来访问这个字段
 * canBeNull：字段是否可以为空，默认值是true
 * unique：是否唯一
 * defaultValue：设置这个字段的默认值
 */
@DatabaseTable(tableName = "user") // 指定数据表的名称
public class UserBean {
    // 定义字段在数据库中的字段名
    public static final String COLUMNNAME_ID = "id";

    @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID)
    private int id;
    @DatabaseField(columnName = "name",unique = true)
    private String name;
    @DatabaseField(columnName = "sex",  defaultValue = "1")
    private char sex;
    @DatabaseField(columnName = "birthday")
    private Date birthday;
    @DatabaseField(columnName = "address")
    private String address;
    @ForeignCollectionField(eager = true)
    private ForeignCollection<ArticleBean> articles;

    public UserBean() {
    }

    public UserBean(String name, char sex, Date birthday, String address) {
        this.name = name;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public ForeignCollection<ArticleBean> getArticles() {
        return articles;
    }

    public void setArticles(ForeignCollection<ArticleBean> articles) {
        this.articles = articles;
    }

    @Override
    public String toString() {
        return "UserBean{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                ", articles=" + articles +
                '}';
    }
}

关联表 ArticleBean


import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;

/**
 * ArticleBean实体类，存储article数据表中的数据
 * 数据库中的article表和user表是关联的，因此我们需要在article表中配置外键
 * <p>
 * foreignColumnName：外键约束指向的类中的属性名
 * foreign：当前字段是否是外键
 * foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了
 */
@DatabaseTable(tableName = "article")
public class ArticleBean {
    @DatabaseField(generatedId = true, columnName = "id")
    private int id;
    @DatabaseField(columnName = "title")
    private String title;
    @DatabaseField(columnName = "content")
    private String content;
    @DatabaseField(columnName = "user_id", foreign = true, foreignAutoRefresh = true, foreignAutoCreate = true,
            foreignColumnName = UserBean.COLUMNNAME_ID)
    private UserBean user_id;

    public ArticleBean() {
    }

    public ArticleBean(String title, String content, UserBean user) {
        this.title = title;
        this.content = content;
        this.user_id = user;
    }

    public int getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public UserBean getUser() {
        return user_id;
    }

    public void setUser(UserBean user) {
        this.user_id = user;
    }

    @Override
    public String toString() {
        return "ArticleBean{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", user=" + user_id +
                '}';
    }
}

构建Bean对应的dao

UserDao：


import android.content.Context;

import com.j256.ormlite.dao.Dao;

import java.sql.SQLException;
import java.util.List;

import cn.tsou.ormlite.bean.UserBean;
import cn.tsou.ormlite.manager.DatabaseHelper;

/**
 * 操作User数据表的Dao类，封装这操作User表的所有操作
 * 通过DatabaseHelper类中的方法获取ORMLite内置的DAO类进行数据库中数据的操作
 * <p>
 * 调用dao的create()方法向表中添加数据
 * 调用dao的delete()方法删除表中的数据
 * 调用dao的update()方法修改表中的数据
 * 调用dao的queryForAll()方法查询表中的所有数据
 */
public class UserDao {
    // ORMLite提供的DAO类对象，第一个泛型是要操作的数据表映射成的实体类；第二个泛型是这个实体类中ID的数据类型
    private Dao<UserBean, Integer> dao;

    public UserDao(Context context) {
        try {
            this.dao = DatabaseHelper.getInstance(context).getDao(UserBean.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 向user表中添加一条数据
    public void insert(UserBean data) {
        try {
            dao.createIfNotExists(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 删除user表中的一条数据
    public void delete(UserBean data) {
        try {
            dao.delete(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 修改user表中的一条数据
    public void update(UserBean data) {
        try {
            dao.update(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 查询user表中的所有数据
    public List<UserBean> queryAll() {
        List<UserBean> users = null;
        try {
            users = dao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return users;
    }

    // 根据ID取出用户信息
    public UserBean queryById(int id) {
        UserBean user = null;
        try {
            user = dao.queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }
}

ArticleDao：


import android.content.Context;

import com.j256.ormlite.dao.Dao;

import java.sql.SQLException;
import java.util.List;

import cn.tsou.ormlite.bean.ArticleBean;
import cn.tsou.ormlite.manager.DatabaseHelper;

/**
 * 操作article表的DAO类
 */
public class ArticleDao {
    private Context context;
    // ORMLite提供的DAO类对象，第一个泛型是要操作的数据表映射成的实体类；第二个泛型是这个实体类中ID的数据类型
    private Dao<ArticleBean, Integer> dao;

    public ArticleDao(Context context) {
        this.context = context;
        try {
            this.dao = DatabaseHelper.getInstance(context).getDao(ArticleBean.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 添加数据
    public void insert(ArticleBean data) {
        try {
            dao.create(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 删除数据
    public void delete(ArticleBean data) {
        try {
            dao.delete(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 修改数据
    public void update(ArticleBean data) {
        try {
            dao.update(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 通过ID查询一条数据
    public ArticleBean queryById(int id) {
        ArticleBean article = null;
        try {
            article = dao.queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return article;
    }

    // 通过条件查询文章集合（通过用户ID查找）
    public List<ArticleBean> queryByUserId(int user_id) {
        try {
            return dao.queryBuilder().where().eq("id", user_id).query();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试


import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import com.j256.ormlite.dao.ForeignCollection;

import java.util.Date;
import java.util.Iterator;
import java.util.List;

import cn.tsou.ormlite.bean.ArticleBean;
import cn.tsou.ormlite.bean.UserBean;
import cn.tsou.ormlite.dao.ArticleDao;
import cn.tsou.ormlite.dao.UserDao;

public class Main2Activity extends AppCompatActivity {

    private UserDao userDao;
    private ArticleDao articleDao;
    private UserBean userData;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        userDao = new UserDao(this);
        articleDao = new ArticleDao(this);
    }

    /**
     * 添加一条数据
     *
     * @param view
     */
    public void add(View view) {
        // 添加用户数据
        userData = new UserBean("张三1", '1', new Date(), "北京");
        userDao.insert(userData);
        // 添加文章数据
        ArticleBean articleData = new ArticleBean("标题4", "内容内容内容内容内容内容", userData);
        ArticleBean articleData1 = new ArticleBean("标题5", "内容内容内容内容内容内容", userData);
        ArticleBean articleData2 = new ArticleBean("标题6", "内容内容内容内容内容内容", userData);
        articleDao.insert(articleData1);
        articleDao.insert(articleData2);
        articleDao.insert(articleData);


    }


    /**
     * 添加子表一条数据
     *
     * @param view
     */
    public void add2(View view) {
        UserBean userBean = userDao.queryById(1);
        ArticleBean articleData = new ArticleBean("标题新", "内容内容内容内容内容内容新", userBean);
        ArticleBean articleData1 = new ArticleBean("标题新1", "内容内容内容内容内容内容新1", userBean);
        articleDao.insert(articleData);
        articleDao.insert(articleData1);
    }

    /**
     * 删除
     *
     * @param view
     */
    public void delete(View view) {
        UserBean userBean = userDao.queryById(1);
        ForeignCollection<ArticleBean> articles = userBean.getArticles();
        Iterator<ArticleBean> iterator = articles.iterator();
        while (iterator.hasNext()) {
            ArticleBean article = iterator.next();
            articleDao.delete(article);
        }
        userDao.delete(userBean);
    }

    /**
     * 删除子表
     *
     * @param view
     */
    public void delete2(View view) {
        articleDao.delete(articleDao.queryById(2));
    }

    /**
     * 更新
     *
     * @param view
     */
    public void updata(View view) {
        UserBean userBean = userDao.queryById(1);
        if (userBean == null) {
            return;
        }
        userBean.setName("我被更新啦");
        userDao.update(userBean);
    }

    /**
     * 更新子表
     *
     * @param view
     */
    public void updata2(View view) {
        ArticleBean articleBean = articleDao.queryById(2);
        if (articleBean == null) {
            return;
        }
        articleBean.setTitle("我被更新啦");
        articleDao.update(articleBean);
    }

    /**
     * 查询user表中的所有数据
     *
     * @param view
     */
    public void queryAll(View view) {
        List<UserBean> userBeans = userDao.queryAll();
        if (userBeans == null) {
            return;
        }
        for (int i = 0; i < userBeans.size(); i++) {
            Log.d("huangxiaoguo", userBeans.get(i).toString());
            ForeignCollection<ArticleBean> articles = userBeans.get(i).getArticles();
            Iterator<ArticleBean> iterator = articles.iterator();
            while (iterator.hasNext()) {
                ArticleBean article = iterator.next();
                Log.d("huangxiaoguo", article.toString());
            }
        }
    }

    /**
     * 查询子表中的数据
     *
     * @param view
     */
    public void queryAll2(View view) {
        List<ArticleBean> articleBeans = articleDao.queryByUserId(2);
        Log.d("huangxiaoguo", articleBeans.toString());
    }
}

DatabaseHelper和更详细的介绍请查看：Ormlite基本使用

Ormlite 基本使用（关联表）

猜你喜欢