Cosmin,
You did indeed answer your own question. Hibernate has (a currently beta) project that provides an annotations based way of doing the mappings. No hbm files are ever generated, there's a specific session factory implementation that constructs itself based on the annotations. Here's a simple class for illustration
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratorType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Transient;
import org.apache.commons.lang.StringUtils;
import net.fiveprime.domainmodel3.analysis.VectorAnalyzer ;
/**
* Representation of a probe on an Affy gene chip
*
* @author Jonny Wray
*
*/
@Entity()
@org.hibernate.annotations.Entity(mutable=false)
@Table(name = "probe")
public class AffyProbe implements Serializable {
private static final long serialVersionUID = 3258408447950467639L;
public static final AffyProbe NULL_OBJECT = new AffyProbe();
private String probeId = "";
private Set<AffyChip> chips = Collections.emptySet();
private Set<ChipExpression> bodyMap = Collections.emptySet();
private Set<AffyProbeMapping> probeMappings = Collections.emptySet();
@Id(generate=GeneratorType.NONE)
@Column(name="probe_id")
public String getId() {
return probeId;
}
public void setId(String id) {
this.probeId = id;
}
@OneToMany(mappedBy="affyProbe", fetch=FetchType.LAZY)
public Set<AffyProbeMapping> getProbeMappings(){
return probeMappings;
}
public void setProbeMappings(Set<AffyProbeMapping> probeMappings){
this.probeMappings = probeMappings;
}
@ManyToMany(fetch=FetchType.LAZY)
@JoinTable(
table=@Table(name="probe_on_chip"),
joinColumns={@JoinColumn(name="probe_id")},
inverseJoinColumns={@JoinColumn(name="chip_id")})
public Set<AffyChip> getChips() {
return chips;
}
public void setChips(Set<AffyChip> chips) {
this.chips = chips;
}
@Override
public String toString(){
return probeId;
}
@OneToMany(mappedBy="affyProbe", fetch=FetchType.LAZY)
public Set<ChipExpression> getBodyMap() {
return bodyMap;
}
public void setBodyMap(Set<ChipExpression> bodyMap) {
this.bodyMap = bodyMap;
}
@Transient
public String getProteinAnnotation(){
Set<String> annotations = new HashSet<String>();
for(AffyProbeMapping mapping: probeMappings){
annotations.add(mapping.getNrProtein().getAnnotati on());
}
return StringUtils.join(annotations.toArray(), "; ");
}
/**
* natural order is by probe id
*/
public int compareTo(Object o){
AffyProbe castObj = (AffyProbe)o;
return getId().compareTo(castObj.getId());
}
}
In fact, the annotations are an implementation of those from the upcoming EJB3 persistance specification. For most mappings you can be completely independent of hibernate. But, they do have some hibernate specific extensions that can be useful.
Also, so of the more esoteric mapping constructs maybe not supported. I haven't had a problem personally though. But, the new session factory allows you to mix and match annotations and hbm files. For example, when I was converting my classes from using the xdoclet/hbm approach to annotations I could convert a class at a time by using hbm files for the unconverted classes. So, if there's a mapping construct that's not yet supported by the annotations you can always fall back on using a hbm file for that specific class.
Jonny