干货 dbflow 多对多

本文对比分析了DbFlow与LitePal数据库框架的特点,详细介绍了DbFlow处理大数据量的优势及在多对多关系场景下的具体应用。通过实例演示了如何在DbFlow中配置和操作多对多关系,包括数据保存和查询。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一直没时间写东西,写个网上很少查得到的东西。这个也是研究了好几天dbflow api 才想到的方法。

首先比较下dbflow,litepal吧。litepal轻量级,跟傻瓜相机一样,简单易用,api很简单。

dbflow就比较重了,完全可以当后台数据库用(个人理解)。处理大量的数据也是很快的,但是litepal就比较慢了,3000多条数据的测试。少量数据,两者没啥区别。

下面是 每条狗有多种爱好,而每个爱好有多条狗的例子。当你配置完dbflow环境后,直接拷贝代码就可以用了,模仿写也是没啥问题的。

一、dbflow 使用说明

官方文档:https://agrosner.gitbooks.io/dbflow/content

本app中 数据库版本控制文件:AppDataBase.class

用法一对一 网上很多,不做赘述。

大数据量操作 开启事务文档:
https://agrosner.gitbooks.io/dbflow/content/StoringData.html

一对多:
创建如下三张表

@Table(database = AppDataBase.class)
public class Breed extends BaseModel {
    @PrimaryKey
    String name;

    public String getName() {
        return name;
    }

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



@Table(database = AppDataBase.class)
public class Dog extends BaseModel{

    @PrimaryKey(autoincrement = true)
    long id;

    @Column
    String name;

    @ForeignKey(stubbedRelationship = true)
    Breed breed; // tableClass only needed for single-field refs that are not Model.

    List<IntrestIng> intrestIngList;

    @OneToMany(methods = {OneToMany.Method.ALL},variableName = "intrestIngList")
    public List<IntrestIng> getIntrestIngList(){
        if(intrestIngList ==null||intrestIngList.size()==0){
            intrestIngList = SQLite.select().from(IntrestIng.class).where(IntrestIng_Table.dog_id.eq(id)).queryList();
        }
        return intrestIngList;
    }

    public String getName() {
        return name;
    }

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

    public Breed getBreed() {
        return breed;
    }

    public void setBreed(Breed breed) {
        this.breed = breed;
    }

    public void setList(List<IntrestIng> intrestIngList) {

        this.intrestIngList = intrestIngList;

    }
}

@Table(database = AppDataBase.class)
public class IntrestIng extends BaseModel {

    @PrimaryKey(autoincrement = true)
     int id;
    @Column
    String name;

    @ForeignKey(
            onUpdate = ForeignKeyAction.CASCADE,
            onDelete = ForeignKeyAction.CASCADE,
            stubbedRelationship = true,
            references = @ForeignKeyReference(columnName = "dog_id", foreignKeyColumnName ="id" )
    )
    public Dog dog;

    public String getName() {
        return name;
    }

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

    public long getId() {
        return id;
    }

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

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public IntrestIng(String name) {
        this.name = name;
    }

    public IntrestIng() {
    }
}


保存:

 Breed breed = new Breed();
                breed.setName("meta");
                Dog dog = new Dog();
                dog.setName("huang");
                dog.setBreed(breed);
                List<IntrestIng> list = new ArrayList<>();
                IntrestIng ing1 = new IntrestIng("shui");
                IntrestIng ing2 = new IntrestIng("chi");

                ing1.setDog(dog);
                ing2.setDog(dog);
                list.add(ing1);
                list.add(ing2);
                dog.setList(list);
            boolean save =dog.save();

查找:

List<Dog> dogList = SQLite.select().from(Dog.class).where(Dog_Table.name.eq("huang")).queryList();


 

 

 

### Java多线程技术的实现方式与并发控制的最佳实践 #### 1. 多线程的实现方式 Java提供了多种实现多线程的方式,主要包括继承`Thread`类和实现`Runnable`接口两种基本方法。通过这两种方式,开发者可以定义线程的行为逻辑。 - **继承 Thread 类** 继承`Thread`类并通过重写`run()`方法来定义线程的任务逻辑[^1]。这种方式简单直观,但由于Java不支持多重继承,因此可能会限制程序设计的灵活性。 - **实现 Runnable 接口** 更推荐的方式是实现`Runnable`接口,因为这不会占用类唯一的继承机会,适合复杂的面向对象设计场景[^2]。 ```java class MyRunnable implements Runnable { @Override public void run() { System.out.println("Running in a separate thread."); } } public class Main { public static void main(String[] args) { new Thread(new MyRunnable()).start(); } } ``` #### 2. 并发控制的方法 在多线程环境中,多个线程可能同时访问共享资源,从而引发数据竞争或一致性问题。以下是几种常用的并发控制手段: - **Synchronized 关键字** `synchronized`用于确保同一时间只有一个线程能进入被标记的方法或代码块,有效防止竞态条件。它可以通过修饰实例方法、静态方法或者作为代码块使用。 ```java public synchronized void criticalSection() { // 只有一个线程可执行此部分 } ``` - **Lock 接口及其子类** 相较于`synchronized`,`Lock`接口提供更灵活的功能,比如尝试锁定(`tryLock`)、定时等待锁释放等操作[^3]。常用的是`ReentrantLock`,允许同一线程多次获取相同的锁而不死锁。 ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Counter { private int count = 0; private final Lock lock = new ReentrantLock(); public void increment() { lock.lock(); // 获取锁 try { count++; } finally { lock.unlock(); // 确保最终解锁 } } } ``` - **原子变量 (Atomic Variables)** 利用`java.util.concurrent.atomic`包下的类(如`AtomicInteger`, `AtomicLong`),可以在无需显式加锁的情况下完成一些简单的更新操作,提高性能的同时减少死锁风险[^4]。 ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicCounter { private AtomicInteger count = new AtomicInteger(0); public void increment() { count.incrementAndGet(); // 原子化增加 } public int getCount() { return count.get(); } } ``` #### 3. 最佳实践建议 为了构建高效稳定的多线程应用,遵循以下几点最佳实践至关重要: - **优先考虑高级抽象工具** 尽量利用JDK内置的并发工具库,例如`ExecutorService`代替手动管理线程池,简化开发流程并降低错误率[^4]。 - **避免过度依赖全局锁** 过度使用单一锁可能导致严重的瓶颈效应;应根据实际需求划分细粒度锁区域[^5]。 - **合理规划线程数量** 创建过多线程会消耗大量内存空间,并带来上下文切换成本;反之不足则无法充分利用硬件资源。通常依据CPU核心数设定合理的线程上限是一个不错的选择。 - **测试与调试相结合** 鉴于多线程程序固有的不确定性特征,在正式部署前务必进行全面的压力测试验证其健壮性和稳定性[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值