Android SQLite模型类的良好实践？

在SQLiteOpenHelper（和Room）的示例中，定义了一个Java“model”类（例如Customer.Java）来表示数据库中的一个表。对于简单的查询，例如“SELECT*fromcustomer”，我可以看到创建Customer.java类是多么有用。但是，一个查询组合来自多个表（例如，Order&Customer）的数据，或者一个返回汇总数据记录的聚合查询。。。当您的查询将来自多个表的信息连接在一起，并且结果记录结构是来自多个表的字段的mashup时，“model”类很快开始降级

模型类结构/命名是否有一个标准或良好的实践，它在Java代码中清晰地反映了返回表的结构（例如：带有SelectAllCustomerOrdersRecord类的SelectAllCustomerOrders（）方法？）。非常感谢他人所做的一切

对于模型类结构/命名，是否有一个标准或良好的实践可以在Java代码中清晰地反映返回表的结构

例如，您将有一个Customer类和一个Order类，订单将与客户相关。因此，您不能拥有CustomerOrders类，或者也可以选择CustomerWithOrders类。这些将是POJO而不是实体（表）

mashup是通过利用@Embedded注释和@Relation注释来克服的

下面是一个使用客户和订单的示例：-

实体客户和订单

@Entity
class Customer {
    @PrimaryKey
    Long customerId;
    String customerName;
    String customerUnitNumber;
    String customerAddress;
    String customerPostalCode;
    // etc

    Customer() {}
    @Ignore
    Customer(String customerName, String customerUnitNumber, String customerAddress, String customerPostalCode) {
        this.customerId = null;
        this.customerName = customerName;
        this.customerUnitNumber = customerUnitNumber;
        this.customerAddress = customerAddress;
        this.customerPostalCode = customerPostalCode;
    }

    ....
}

及

根据上述情况，客户订单可以是：-

class CustomerOrders {
    @Embedded
    Customer customer;
    @Relation(entity = Order.class, parentColumn = "customerId", entityColumn = "customerReference")
    List<Order> orderList;
}

然后考虑以下内容（在主线程上运行简洁和方便）：-< /P> 我认为以上内容都很整洁，而不是混搭

然而，事情开始变得稍微复杂一点的地方是，例如，如果你想得到客户和他们的订单，但只有当数量是特定数量或大于或小于某个数量时

使用：-

@Query("SELECT * FROM customer WHERE quantity = :x")
List<CustomerOrders> CustomerWithOrdersOfX(int x);

预期只提取订单ID 20（数量为4），因为这是唯一的订单ID为4

但是，@Relation获取属于@Embedded的所有子项。要克服这个问题，事情就可以开始混搭了

@Dao
interface AllDao {

    @Insert
    long insertCustomer(Customer customer);
    @Insert
    long[] insertManyCustomers(Customer...customers);
    @Insert
    long insertOrder(Order order);
    @Insert
    long[] insertManyOrders(Order...orders);

    @Query("SELECT * FROM customer")
    List<Customer> getAllCustomers();
    @Query("SELECT * FROM customer WHERE customerId = :customerId")
    Customer getCustomerById(long customerId);
    @Query("SELECT * FROM `order`")
    List<Order> getAllOrders();
    @Query("SELECT * FROM `order` WHERE orderId = :orderId")
    Order getOrderById(long orderId);

    @Query("SELECT count(*) FROM customer")
    long getCustomerCount();
    @Query("SELECT count(*) FROM `order`")
    long getOrderCount();

    @Query("SELECT * FROM customer")
    List<CustomerOrders> getAllCustomersWithTheirOrders();
    @Query("SELECT * FROM customer WHERE customerId = :customerId")
    CustomerOrders getCustomerWithAllOrders(long customerId);

}

@Database(entities = {Customer.class,Order.class},version = 1)
abstract class TheDatabase extends RoomDatabase {
    abstract AllDao getAllDao();
}

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "DBINFO";
    TheDatabase db;
    AllDao dao;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        db = Room.databaseBuilder(this,TheDatabase.class,"thedatabase.db")
                .allowMainThreadQueries()
                .build();
        dao = db.getAllDao();

        // Add some data
        long[] customersAdded = dao.insertManyCustomers(
                new Customer("Fred","Unit x","Blah Street","1234"),
                new Customer("Mary","Unit Z","Other Lane","4321")
                );
        for(long customerId: customersAdded) {
            int limit = (new Random()).nextInt(10) + 1;
            for(int ii = 0; ii < ((new Random()).nextInt(10) + 1); ii++) {
                dao.insertOrder(new Order(customerId,5));
            }
        }

        // Get counts writing them to the log
        Log.d(TAG,"There are " + dao.getCustomerCount() + " customers in the Database");
        Log.d(TAG,"There are " + dao.getOrderCount() + " orders in the Database");
        // Get Customers with their orders writing info to the log
        for(CustomerOrders co: dao.getAllCustomersWithTheirOrders()) {
            Log.d(TAG,"Customer is " + co.customer.customerName + " " + co.customer.getCustomerUnitNumber() + " etc.");
            for(Order o: co.orderList) {
                 Log.d(TAG,"Order Id is " + o.getOrderId());
            }
        }
    }
}

2021-05-08 07:09:14.183 D/DBINFO: There are 2 customers in the Database
2021-05-08 07:09:14.184 D/DBINFO: There are 7 orders in the Database
2021-05-08 07:09:14.189 D/DBINFO: Customer is Fred Unit x etc.
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 1
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 2
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 3
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 4
2021-05-08 07:09:14.189 D/DBINFO: Customer is Mary Unit Z etc.
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 5
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 6
2021-05-08 07:09:14.189 D/DBINFO: Order Id is 7

@Query("SELECT * FROM customer WHERE quantity = :x")
List<CustomerOrders> CustomerWithOrdersOfX(int x);

AllDao.java:41: error: There is a problem with the query: [SQLITE_ERROR] SQL error or missing database (no such column: quantity)
List<CustomerOrders> CustomerWithOrdersOfX(int x);

@Query("SELECT * FROM customer JOIN `order` ON `order`.customerReference = customerId WHERE quantity = :x")
List<CustomerOrders> getCustomersWithOrdersOfX(int x);

D/DBINFO: Number of Customers with Orders that have a quantity of 4 is 1
D/DBINFO: Customer = Mary
D/DBINFO: OrderID is 18 Qnty = 0
D/DBINFO: OrderID is 19 Qnty = 1
D/DBINFO: OrderID is 20 Qnty = 4
D/DBINFO: OrderID is 21 Qnty = 2
D/DBINFO: OrderID is 22 Qnty = 0