@MappedSuperclass
public abstract class AbstractEntity<PK extends Serializable> implements
      Serializable {

   protected transient final Log LOG = LogFactory.getLog(getClass());


   @Id
   @GeneratedValue(generator = IdGen.NAME)
   protected PK id;


   protected Date timeStamp;


   protected boolean deleted;


   public AbstractEntity() {
      this(null);
   }


   public AbstractEntity(PK id) {
      super();
      this.id = id;
   }


   @Override
   public String toString() {
      return id.toString();
   }


   @Override
   public boolean equals(final Object that) {
      return EqualsBuilder.reflectionEquals(this, that);
   }


   @Override
   public int hashCode() {
      return HashCodeBuilder.reflectionHashCode(this);
   }

// getters & setters
}

public class IdGen {

   public static final String NAME                 = "CustomIdGenerator";
   public static final String MANUAL          = "assigned";
   public static final String AUTO       = "identity";
}

@Entity
@GenericGenerator(name=IdGen.NAME, strategy=IdGen.AUTO)
public class AutoLongPK extends AbstractEntity<Long> {

   private static final long serialVersionUID = 1L;

   private String prop1;

   private String prop2;
// getters & setters
}

@Entity
@GenericGenerator(name=IdGen.NAME, strategy=IdGen.MANUAL)
public class ManualStringPK extends AbstractEntity<String> {

   private static final long serialVersionUID = 1L;

   private String prop1;

   private String prop2;
// getters & setters
}

/**
* Abstract base class for all database entities.  Keeps track
* of creation date, last modification date, allows 'deleted' objects
* to remain in the database w/o destroying existing relationships.
* Primary key property is flexible in terms of type, generation strategy
* and custom attributes.
*
* The main purposes of this class are to keep common properties in one
* place, give the middle layer a better bound to go by than <? extends Object>,
* have proper implementations of equals and hashcode for collections, and
* most importantly not impose any constraints on the identity property for the
* end user.
*
* Subclasses must define getId() & place all annotations on getter
* methods.
*/
@MappedSuperclass
public abstract class AbstractEntity<PK extends Serializable> implements
      Serializable {

   // log4j is available to all subclasses
   protected transient final Log LOG = LogFactory.getLog(getClass());


   protected PK id;         // the objects primary key
   @Transient               // marked as transient so hibernate won't
   public abstract PK getId();   // think this is the ID (crashes w/o it)


   protected Date created;      // when the entity was originally persisted


   protected Date modified;   // last time it was modifiied


   protected Boolean deleted;   // whether or not the object is deleted,
                        // useful for retaining exsisting relationships
                        // and not showing deleted stuff to the user


   /**
    * We employ some intelligence in here, if
    * deleted was a boolean and the column is null
    * it fails.  So we use a Boolean which permits nulls,
    * and just treat null = false.
    */
   public void setDeleted(Boolean deleted) {
      this.deleted = (deleted == null ? false : deleted);
   }


   /**
    * Default constructor, does nothing
    */
   public AbstractEntity() {
      this(null);
   }


   /**
    * Construct a new entity with a given PK
    * @param id the primary key
    */
   public AbstractEntity(PK id) {
      super();
      this.id = id;
   }


   /**
    * Stripes likes the id for toString to populate
    * select boxes.  This can be overridden if not needed.
    */
   @Override
   public String toString() {
      return getId().toString();
   }


   /**
    * Use commons-lang for a reflexive equals
    */
   @Override
   public boolean equals(final Object that) {
      return EqualsBuilder.reflectionEquals(this, that);
   }


   /**
    * Use commons-lang for reflexive hashCode
    */
   @Override
   public int hashCode() {
      return HashCodeBuilder.reflectionHashCode(this);
   }



   // useless accessor methods


   public Date getCreated() {
      return this.created;
   }



   public void setCreated(Date created) {
      this.created = created;
   }



   public Boolean getDeleted() {
      return this.deleted;
   }



   public void setId(PK id) {
      this.id = id;
   }



   public Date getModified() {
      return this.modified;
   }



   public void setModified(Date modified) {
      this.modified = modified;
   }
}

/**
* Base entity that has a default identifier specification.
* Extends AbstractEntity to have all those properties, main
* purpose of this class was to alleviate the burden of
* defining the identifier property on the end user.
*
* Class techincally should not be abstract since there
* are not any abstract methods - it is a complete entity.
* However it is useless to have this in the database by
* itself so the constructor is kept protected.
*
*/
@MappedSuperclass
public class IdEntity<PK extends Serializable> extends
      AbstractEntity<PK> {

   private static final long serialVersionUID = 1L;

   /**
    * Default identifier property, no specified
    * sql or attributes.
    */
   @Override
   @Id
   @GeneratedValue(generator = IdGen.NAME)
   @Column(name="id", nullable=false, insertable=false, updatable=false)
   public PK getId() {
      return this.id;
   }


   /**
    * Constructors are protected, class
    * must be extended to use.
    */
   protected IdEntity()  {
      this(null);
   }

   protected IdEntity(PK id)  {
      super(id);
   }
}