在下面的代码中，我有一个模型，代表一个物理系统的状态。在这个模型中，我想有两个球通过Spring连接。

fn model(_app: &App) -> Model {
    let mut ball1 = Ball::new(-250.0, 0.0, 50.0);
    let mut ball2 = Ball::new(250.0, 0.0, 50.0);
    let spring = Spring::new(&mut ball1, &mut ball2, 0.1);
    Model {
        objs: vec![
            Box::new(ball1),
            Box::new(ball2),
            Box::new(spring),
        ],
    }
}

我的Model的定义如下：

struct Model {
    objs: Vec<Box<dyn PhysicsObject>>,
}

Spring和Spring::new()的定义为：

pub struct Spring<'a> {
    pub target_length: f32,
    pub a: &'a mut Ball,
    pub b: &'a mut Ball,
}
impl<'a> Spring<'a> {
    pub fn new(b1: &'a mut Ball, b2: &'a mut Ball, k: f32) -> Spring<'a>{
        Spring{
            target_length: (b1.position - b2.position).mag(),
            a: b1,
            b: b2,
        }
    }
}

我目前得到以下编译器错误，由于（我相信）将球引用传递给Spring，然后试图从函数返回它们（在一个框中）。

error[E0505]: cannot move out of `ball1` because it is borrowed
  --> src/main.rs:21:22
   |
18 |     let spring = Spring::new(&mut ball1, &mut ball2, 0.1);
   |                              ---------- borrow of `ball1` occurs here
...
21 |             Box::new(ball1),
   |                      ^^^^^ move out of `ball1` occurs here
22 |             Box::new(ball2),
23 |             Box::new(spring),
   |             ---------------- cast requires that `ball1` is borrowed for `'static`

（我在ball2中也遇到了同样的错误）我该如何重新构造代码以获得所需的行为呢？一个spring需要能够更新它所连接的球，并且多个spring应该能够连接到一个球上，这在目前是不可能的。我有一种感觉，这可能就是Rc的用途。但我真的不知道从何说起，谢谢
另外，我正在使用nannou，一个图形库，它就是App类型的来源。但是我不认为这与我的问题相关。
另外，这里是PhysicsObject和类型Ball的定义，如果两者都相关的话。

pub trait PhysicsObject {
    fn update(&mut self, dt: f32);

    fn show(&self, draw: &Draw);
}

pub struct Ball {
    pub color: Rgb<f64>,
    pub radius: f32,
    pub position: V2,
    pub velocity: V2,
    pub acceleration: V2,
    pub mass: f32,
}
impl Ball {
    pub fn new(x: f32, y: f32, r: f32) -> Ball {
        Ball {
            color: rgb(0.0, 0.0, 0.0),
            radius: r,
            position: v2(x, y),
            velocity: V2::zero(),
            acceleration: V2::zero(),
            mass: 1.0,
        }
    }
    pub fn applyForce(&mut self, f: V2) { //The function that `Spring` calls
        self.acceleration += f / self.mass;
    }
}