如何打破圆形的依赖和经典

如何解决如何打破圆形的依赖和经典

我在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框架（使用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();
    }
}

解决方法

警告可能来自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();
    }
}