Question

this question is similar to this other question I’ve asked, but slightly different.

I have this:

class A{

  private List<B> bs;

  ...
}

class B{

  private Long id;
  private C c;
  ...
} 

class C{

  private Long id;
  private String name;
  ...
} 

---

And I’d like to have this:

class A{

  // the map should have b.c.name as key
  private Map<String,B> bs;

  ...
}

class B{

  private Long id;
  private C c;
  private A a;
  ...
} 

class C{

  private Long id;
  private String name;
  ...
} 

---

I don’t know if it is clear what I’d like to do, but it is as simple as mapping a one to many relationship to a Map with the name of C as the key of the map and b as the value.

Thanks in advance,
Neuquino

Answer 1

Short answer is you can’t do this.

But a here is solution that may be suitable for your problem:

In entity A still defined relation to entity B as List (or even better as Set, so that the same B cannot be contained more than once).

@OneToMany(mappedBy="a")
private Set<B> bs;

As you don’t want to expose the plain list, omit getter and setter for as.

Then you can define a getter for you map that builds the map on the fly:

// a transient field to cache the map
private transient Map<String, B> bsMappedByCName;

public Map<String, B> getBsMappedByCName() {
  if(bsMappedByCName == null) {
    bsMappedByCName = new HashMap<String, B>();
    for(B b : bs) {
      mapB(b);
    }
  }
  // return as unmodifiable map so that it is immutable for clients
  return Collections.unmodifiableMap(bsMappedByCName);
}

private void mapB(B b) {
  // we assume here that field c in class B and likely also field name in class C are not nullable. Further more both of this fields sould be immutable (i.e. have no setter).
  if(bsMappedByCName.put(b.getC().getName(), b) != null) {
    // multiple bs with same CName, this is an inconsistency you may handle 
  }      
}

The last issue to address is how do we add a new B to A or remove one. With the strategy to return the map as unmodifiable, we must provide some add and remover methods in class A:

public void addB(B b) {
  bs.add(b);
  mapB(b);
}

public void removeB(B b) {
  bs.remove(b);
  bsMappedByCName.remove(b.getC().getName());
}

An other option is to replace return Collections.unmodifiableMap(...) with (inspired from ObservaleCollection from apache):

return new Map<String, B>() {
  // implement all methods that add or remove elements in map with something like this
  public B put(String name, B b) {
    // check consistency
    if(!b.getC().getName().equals(name)) { 
      // this sould be handled as an error
    }
    B oldB = get(name);
    mapB(b);
    return oldB;
  }

  // implement all accessor methods like this
  public B get(String name) {
    return bsMappedByCName.get(name);
  }

  // and so on...
};