Java ActiveAndroid多对多关系

我目前使用的是ActiveAndroid，在过去的几个小时里，我一直试图让多对多的关系发挥作用，但我就是无法让它发挥作用。我希望你能帮助我：

我有“学生”和“课程”两种模式，一个学生可以有很多课程，一个课程有很多学生。基本上，这就是我在“学生课程”模型中的内容：

 @Column(name = COURSE)
 public Course course;

 @Column(name = STUDENT)
 public Student student;

 public StudentCourse(Student student, Course course) {
 super();
 this.student = student;
 this.course = course;
 }
//
 public StudentCourse(){ }

 public List<Course> courses(){
 return getMany(Course.class, "StudentCourse");
 }
 public List<Student> students(){
 return getMany(Student.class, "StudentCourse");
 }

但是，我得到以下错误：

java.lang.ClassCastException:com.papinotas.models.StudentCourse不能强制转换为com.papinotas.models.Student

如果我将（学生）的演员阵容更改为（学生课程），则会出现以下错误：

android.database.sqlite.SQLiteException:没有这样的列：students.StudentCourse（代码1）：，编译时：SELECT*FROM students WHERE students.StudentCourse=1

我的主要目标是希望在一个查询中实现这一点。任何帮助都将不胜感激。提前谢谢

PS：我已经看过了几乎所有我能找到的东西：和

如果我将（学生）的演员阵容改为（学生课程），我会得到以下错误

实际上，演员阵容应该是

（List）

，但真正的问题在于这里模型的逻辑。您正在调用executeSingle（），但确实需要多个StudentCourse对象，以便获得课程的每个学生-课程关系。您的students（）和courses（）方法没有多大意义，因为一个StudentCourse对象只有一个Student和一个courses

我会这样做：

List<StudentCourse> enrolments = new Select().from(StudentCourse.class).where("course = ?",selectedCourse.getId()).execute();

List<Student> studentsInCourse = new ArrayList<Student>();
for(StudentCourse enrolment:enrolments)
    studentsInCourse.add(enrolment.student);

List enrolments=new Select（）.from（StudentCourse.class）.where（“course=？”，selectedCourse.getId（））.execute（）；
List studentsInCourse=new ArrayList（）；
学生（课程注册：入学人数）
学生在课程中。添加（注册人数。学生）；

我不会为此使用

getMany

。我会这样做：

return new Select()
    .from(Student.class)
    .innerJoin(StudentCourse.class).on("students.id = studentcourses.id")
    .where("studentcourses.course = ?", courseId)
    .execute();

---

像魅力一样工作：

客户端类

 @Table(name = "Client")
 public class Client extends Model{}

合同类

 @Table(name = "Contract")
 public class Contract extends Model{}

客户与合同的关系

 @Table(name = "ClientContract")
 public class ClientContract extends Model {

    @Column(name = "Client", onDelete = Column.ForeignKeyAction.CASCADE)
    public Client client;

    @Column(name = "Contract", onDelete = Column.ForeignKeyAction.CASCADE)
    public Contract contract;
}

数据库助手

public class DBHelper {

 public List<Contract> getRelatedContracts(Client client) {
        List<Contract> contracts = null;

        if (client != null && client.isCreated()) {
            contracts = new Select()
                    .from(Contract.class)
                    .innerJoin(ClientContract.class).on("ClientContract.Contract = Contract.id")
                    .where("ClientContract.Client = ?", client.getId())
                    .execute();
        }
        return contracts;
    }

    public List<Client> getRelatedClients(Contract contract) {
        List<Client> clients = null;

        if (contract != null && contract.isCreated()) {
            clients = new Select()
                    .from(Client.class)
                    .innerJoin(ClientContract.class).on("ClientContract.Client = Client.id")
                    .where("ClientContract.Contract = ?", contract.getId())
                    .execute();
        }
        return clients;
    }

    // get relation
    public ClientContract getClientContract(Client client, Contract contract) {
        ClientContract clientContract = null;
        if (client != null && contract != null && client.isCreated() && contract.isCreated()) {

            clientContract = new Select().from(ClientContract.class)
                    .where("Client = ?", client.getId())
                    .where("Contract = ?", contract.getId())
                    .executeSingle();
        }
        return clientContract;
    }

    // add relation
    public ClientContract addClientContract(Client client, Contract contract) {
        ClientContract clientContract = getClientContract(client, contract);

        if (client != null && contract != null && clientContract == null) {

            if (client.getId() == null)
                client.save();

            if (contract.getId() == null)
                contract.save();

            clientContract = new ClientContract();
            clientContract.client = client;
            clientContract.contract = contract;
            clientContract.save();

        }
        return clientContract;
    }

    // delete relation
    public void deleteClientContract(Client client, Contract contract) {
        ClientContract clientContract = getClientContract(client, contract);
        if (clientContract != null && contract.isCreated())
            clientContract.delete();
    }
}

公共类DBHelper{
公共列表getRelatedContracts（客户端）{
列表合同=空；
if（client！=null&&client.isCreated（））{
合同=新选择（）
.from（Contract.class）
.innerJoin（ClientContract.class）.on（“ClientContract.Contract=Contract.id”）
.where（“ClientContract.Client=？”，Client.getId（）
.execute（）；
}
归还合同；
}
公共列表GetRelatedClient（合同）{
列表客户端=null；
if（contract！=null&&contract.isCreated（））{
clients=newselect（）
.from（Client.class）
.innerJoin（ClientContract.class）.on（“ClientContract.Client=Client.id”）
.where（“ClientContract.Contract=？”，Contract.getId（）
.execute（）；
}
返回客户；
}
//获得关系
公共客户端合同getClientContract（客户端，合同）{
ClientContract ClientContract=null；
if（client！=null&&contract！=null&&client.isCreated（）&&contract.isCreated（））{
clientContract=new Select（）.from（clientContract.class）
.where（“Client=？”，Client.getId（）
.where（“Contract=？”，Contract.getId（）
.executeSingle（）；
}
返回客户合同；
}
//加法关系
public ClientContract addClientContract（客户端，合同）{
ClientContract ClientContract=getClientContract（客户，合同）；
if（client！=null&&contract！=null&&clientContract==null）{
if（client.getId（）==null）
client.save（）；
if（contract.getId（）==null）
contract.save（）；
clientContract=新的clientContract（）；
clientContract.client=client；
clientContract.contract=合同；
clientContract.save（）；
}
返回客户合同；
}
//删除关系
public void deleteClientContract（客户，合同）{
ClientContract ClientContract=getClientContract（客户，合同）；
if（clientContract！=null&&contract.isCreated（））
clientContract.delete（）；
}
}

我试图找到一种方法，通过一个查询获得所有学生；如果我没有弄错的话，这就可以进行N次查询PS：我理解你的观点，我同意这没有任何意义，我试图按照我上面发布的链接上的示例进行操作，但是它们并没有像我预期的那样工作。这是一个单选查询，但是它会做一些列表操作，这样你就可以得到一个学生的列表，而不是一个学生课程的列表。哦，“registration.student”不会对数据库进行查询，那么我相信你是对的！根据您使用它的目的，您可以将它保留为StudentCourse对象的列表（也可以更改适配器类或任何您使用它的目的）。如果您确实需要它作为一个学生对象列表，那么您可以执行SQL连接，使它能够更有效地扩展到大量学生。

public class DBHelper {

 public List<Contract> getRelatedContracts(Client client) {
        List<Contract> contracts = null;

        if (client != null && client.isCreated()) {
            contracts = new Select()
                    .from(Contract.class)
                    .innerJoin(ClientContract.class).on("ClientContract.Contract = Contract.id")
                    .where("ClientContract.Client = ?", client.getId())
                    .execute();
        }
        return contracts;
    }

    public List<Client> getRelatedClients(Contract contract) {
        List<Client> clients = null;

        if (contract != null && contract.isCreated()) {
            clients = new Select()
                    .from(Client.class)
                    .innerJoin(ClientContract.class).on("ClientContract.Client = Client.id")
                    .where("ClientContract.Contract = ?", contract.getId())
                    .execute();
        }
        return clients;
    }

    // get relation
    public ClientContract getClientContract(Client client, Contract contract) {
        ClientContract clientContract = null;
        if (client != null && contract != null && client.isCreated() && contract.isCreated()) {

            clientContract = new Select().from(ClientContract.class)
                    .where("Client = ?", client.getId())
                    .where("Contract = ?", contract.getId())
                    .executeSingle();
        }
        return clientContract;
    }

    // add relation
    public ClientContract addClientContract(Client client, Contract contract) {
        ClientContract clientContract = getClientContract(client, contract);

        if (client != null && contract != null && clientContract == null) {

            if (client.getId() == null)
                client.save();

            if (contract.getId() == null)
                contract.save();

            clientContract = new ClientContract();
            clientContract.client = client;
            clientContract.contract = contract;
            clientContract.save();

        }
        return clientContract;
    }

    // delete relation
    public void deleteClientContract(Client client, Contract contract) {
        ClientContract clientContract = getClientContract(client, contract);
        if (clientContract != null && contract.isCreated())
            clientContract.delete();
    }
}