Ormlite 基本使用（关联表）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

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 +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

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 +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

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());
    }
}