#2020征文-手机#HarmonyOS对象关系映射数据库初体验

顶风少年

发布于 2021-1-6 22:16

2.1w浏览

1收藏

上一篇体验了关系型数据库，那一部分API允许我们自由的手写SQL。

这一篇的对象映射数据库是标准的ORM映射类似于Java中的hibernate框架，

将对象映射为表，更改对象就是更改表。

遇到问题

1 在删除和更改时手动创建一个对象传递过去，无法删除或者更改。

2 同一个对象多次添加会失败。

这一个图放上边，因为把注解开关放到了项目的gradle文件中导致我以为这个API不能用

实际上是放到模块的gradle文件中。

#2020征文-手机#HarmonyOS对象关系映射数据库初体验-鸿蒙开发者社区

这是一个数据库

package com.datang.myapplication.slice;

import ohos.data.orm.OrmDatabase;
import ohos.data.orm.annotation.Database;
import ohos.data.rdb.RdbOpenCallback;

@Database(entities = {User.class}, version = 1)
public class DB1 extends OrmDatabase {

    @Override
    public int getVersion() {
        return 0;
    }

    @Override
    public RdbOpenCallback getHelper() {
        return null;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

这是一个表

package com.datang.myapplication.slice;

import ohos.data.orm.OrmObject;
import ohos.data.orm.annotation.Entity;
import ohos.data.orm.annotation.PrimaryKey;

@Entity(tableName = "user")
public class User  extends OrmObject {

    // 此处将userId设为了自增的主键。注意只有在数据类型为包装类型时，自增主键才能生效。
    @PrimaryKey(autoGenerate = true)
    private Integer userId;
    private String name;
    private int age;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}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.

CRUD基本操作

package com.datang.myapplication.slice;

import com.datang.myapplication.ResourceTable;
import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.content.Intent;
import ohos.agp.components.Button;
import ohos.data.DatabaseHelper;
import ohos.data.orm.AllChangeToTarget;
import ohos.data.orm.OrmContext;
import ohos.data.orm.OrmObjectObserver;
import ohos.data.orm.OrmPredicates;
import ohos.data.rdb.*;
import ohos.data.resultset.ResultSet;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;

import java.util.List;

//关系型数据库
public class MainAbilitySlice2 extends AbilitySlice {

    HiLogLabel label = new HiLogLabel(HiLog.LOG_APP, 0x00201, "MY_TAG");
    OrmContext context = null;

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        super.setUIContent(ResourceTable.Layout_ability_main2);
        initDB();

        insert();
        select();
        delete();
        update();

        //注册 user 表监听事件 insert update delete 会触发
        context.registerEntityObserver("user", (o, a) -> {
            HiLog.info(label, "触发回调了》》》》》》》》》》》》》》》》》》");
        });
    }


    @Override
    public void onActive() {
        super.onActive();
    }

    public void initDB() {
        DatabaseHelper helper = new DatabaseHelper(this);
        context = helper.getOrmContext("DB1", "DB1.db", DB1.class);
    }

    //增加
    public void insert() {
        Button button = (Button) findComponentById(ResourceTable.Id_add);
        button.setClickedListener(e -> {

            for (int i = 1; i <= 10; i++) {
                //将这个对象添加进去,此外这里如果将User对象放到循环外，则会添加失败抛出异常
                //意味着不能对同一个对象做多次添加。就算属性都一样，也要创建多个。不知道是不是
                //bug
                User user = new User();
                user.setName("Zhang" + i);
                user.setAge(i);
                boolean isSuccessed = context.insert(user);
                //没有刷新添加不进去
                isSuccessed = context.flush();
                HiLog.info(label, "添加是否成功%{public}d,%{public}s", i, isSuccessed);
            }
        });


    }

    //查询
    public void select() {
        Button button2 = (Button) findComponentById(ResourceTable.Id_get);
        button2.setClickedListener(e -> {
            OrmPredicates query = context.where(User.class);
            List<User> users = context.query(query);
            users.forEach(c -> {
                HiLog.info(label, "查询结果%{public}s", users);
            });
        });
    }

    //删除
    public void delete() {
        Button button3 = (Button) findComponentById(ResourceTable.Id_del);
        button3.setClickedListener(e -> {
            // 删除数据 User{userId=1, name='Zhang1', age=1}
            //直接创建一个 user对象，属性全部设置也不会删除
//            User user = new User();
//            user.setUserId(1);
//            user.setName("Zhang1");
//            user.setAge(1);

            //User{userId=1, name='Zhang1', age=1}
            //从数据库查出来的却可以用，实际上和上边那个创建出来的属性一样
            OrmPredicates predicates = context.where(User.class);
            predicates.equalTo("userId", 1);
            List<User> users = context.query(predicates);
            User user = users.get(0);

            boolean delete = context.delete(user);
            //需要flush
            boolean flush = context.flush();
            HiLog.info(label, "是否删除%{public}s", flush);


            //这种删除方式就类似批量删除了，只给出删除条件，多少都删
            OrmPredicates predicates2 = context.where(User.class);
            predicates2.equalTo("name", "Zhang2");
            int delete2 = context.delete(predicates2);
            //并且不用flush
            //boolean flush = context.flush();
            HiLog.info(label, "是否删除%{public}d", delete2);
        });
    }


    //更改
    public void update() {
        Button button4 = (Button) findComponentById(ResourceTable.Id_upd);
        button4.setClickedListener(e -> {
            //同样手动创建的user也无法更改
//            User user = new User();
//            user.setUserId(1);
//            user.setName("李四特");
//            user.setAge(33);

            //查询出来
            OrmPredicates predicates = context.where(User.class);
            predicates.equalTo("userId", 1);
            List<User> users = context.query(predicates);
            User user = users.get(0);
            user.setName("李四特");
            //更改
            boolean update = context.update(user);
            //需要flush
            boolean flush = context.flush();
            HiLog.info(label, "更改成功:%{public}s", update);

            //这种方式也是批量更改，更改后的值在 ValuesBucket中存储
            OrmPredicates predicates2 = context.where(User.class);
            predicates2.equalTo("userId", 2);
            ValuesBucket valuesBucket = new ValuesBucket();
            valuesBucket.putInteger("age", 31);
            valuesBucket.putString("name", "王二麻子");
            context.update(predicates2, valuesBucket);
            //不需要flush
            //boolean flush = context.flush();
            HiLog.info(label, "更改成功:%{public}s", update);
        });
    }

}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.
152.
153.
154.
155.
156.
157.