如何打破循环依赖并成为规范？

Question

我在 2 个模型之间存在循环依赖关系，但从使用的角度来看，这不是真正的依赖关系。

• 建筑物归业主所有
• 租户住在大楼里

根据用户的类型，与建筑物的关系有所不同。

public enum UserType
{
    TENANT,
    OWNER
}

用户：

public class User extends Model
{
    @ManyToOne
    private Building building;

    private UserType type;
}

建筑：

public class Building extends Model
{
    @ManyToOne
    private User owner;
}

它是否被认为是真正的循环依赖？我应该如何避免这种情况？

编辑：

我使用 Play Framework（使用 Guice）进行依赖注入，这也让我很头疼。代码可以编译，但没有运行。

public class BuildingRepository
{
    @Inject
    private UserRepository userRepository;

    private final Finder<Long, Building> find = new Finder<>(Building.class);

    public void save(Building building)
    {
        building.save();
    }

    public void update(Building building)
    {
        building.update();
    }

    public boolean delete(Building building)
    {
        // check if there is tenants in the building
        if (userRepository.countByBuilding(building) > 0)
        {
            return false;
        }
      
        return building.delete();
    }

    public List<Building> findFor(User user)
    {
        if (user.getType() == UserType.OWNER)
        {
            return find.query().where()
                .eq("owner.id", user.getId())
                .findList();
        }
   
        return new ArrayList<>();
    }
}

UserRepository 使用BuildingRepository，但仅适用于特定类型的用户。

public class UserRepository
{
    @Inject
    private BuildingRepository buildingRepository;

    private final Finder<Long, User> find = new Finder<>(User.class);

    public void save(User user)
    {
        user.save();
    }

    public void update(User user)
    {
        user.update();
    }

    public boolean delete(User user)
    {
        if (user.getType() == UserType.OWNER)
        {
            // remove the owner on the buildings
            for (Building building : buildingRepository.findFor(user))
            {
                if (user.equals(building.getOwner()))
                {
                    building.setOwner(null);
                    buildingRepository.update(building);
                }
            }
        }

        return user.delete();
    }

    public int countByBuilding(Building building)
    {
        return find.query().where()
            .eq("building.id", building.getId())
            .eq("status", true)
            .findCount();
    }
}

Answer 1

警告可能来自 JSON 序列化。如果您使用这些对象直接映射到 json，则没有什么可以阻止将所有者的建筑物添加为租户类的建筑物。这是有道理的，如果业主住在他自己的大楼里。理论上你可以得到一个结构：

{
  user: {
    building: {
      owner: {
        building: {
          owner: {    
            building: {
              owner: {
                ...
}

您可以通过不递归地序列化建筑物的所有者来修复 JSON 递归。

public class Building extends Model
{
    @ManyToOne
    @JsonIgnore
    private User owner;
}

对于您实际需要所有者信息的情况，您可以创建 DTO 类以仅包含您需要的信息：

public class BuildingDTO
{
    private String ownerName;
}

编辑：

要修复存储库中的循环，您可以执行以下操作：

public class SafeDeleteService
{
    @Inject
    private UserRepository userRepository;
    @Inject
    private BuildingRepository buildingRepository;

    public boolean safeDelete(User user)
    {
        if (user.getType() == UserType.OWNER)
        {
            // remove the owner on the buildings
            for (Building building : buildingRepository.findFor(user))
            {
                if (user.equals(building.getOwner()))
                {
                    building.setOwner(null);
                    buildingRepository.update(building);
                }
            }
        }

        return userRepository.unsafeDelete(user);
    }
}

public class UserRepository
{
    public boolean unsafeDelete(User user)
    {
        return user.delete();
    }
}