డేటా రిఫ్రెష్ నిర్వహణ

5.1 డేటా మార్పు సమయం

మీరు అనేక సంవత్సరాలపాటు వివిధ రికార్డులను డేటాబేస్లో నిల్వ చేసినప్పుడు, తరచుగా రెండు ప్రశ్నలు తలెత్తుతాయి:

• డేటాబేస్‌కు ఈ ఎంట్రీ ఎప్పుడు జోడించబడింది?
• ఈ ఎంట్రీని చివరిగా ఎప్పుడు మార్చారు?

డేటాబేస్‌లోని దాదాపు ప్రతి టేబుల్‌కి రెండు నిలువు వరుసలు జోడించబడే చాలా తరచుగా పనులు ఇవి:

• సృష్టించిన_సమయం
• updated_time

మొదటిది రికార్డ్ సృష్టించబడిన తేదీ మరియు సమయాన్ని నిల్వ చేస్తుంది మరియు రెండవది చివరిగా సవరించిన తేదీ మరియు సమయాన్ని నిల్వ చేస్తుంది. మరియు ప్రతి ఎంటిటీ క్లాస్ ఫీల్డ్‌లను కలిగి ఉంటుంది:

@Entity
@Table(name = "entities")	
public class Entity {
  ...
 
  @Column(name="created_time")
  private Date created;
 
  @Column(name="updated_time")
  private Date updated;
}

డేటాబేస్‌లోని వస్తువులు రెండు ఉల్లేఖనాలతో నవీకరించబడినప్పుడు నియంత్రించే అన్ని పనిని హైబర్నేట్ చేయగలదు @CreationTimestampమరియు @UpdateTimestamp.

ఉదాహరణ:

@Entity
@Table(name = "entities")
public class Entity {
  ...

	@CreationTimestamp
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "create_date")
    private Date createDate;

	@UpdateTimestamp
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "modify_date")
	private Date modifyDate;
}

ఈ ఉల్లేఖనాలతో గుర్తించబడిన నిలువు వరుసలు ఎల్లప్పుడూ ఆబ్జెక్ట్ సృష్టించబడిన సరైన సమయాన్ని మరియు చివరిగా సవరించబడిన సమయాన్ని నిల్వ చేస్తాయి.

5.2 @PrePersist ఉల్లేఖన

వస్తువు యొక్క సమయాన్ని నియంత్రించడానికి మీకు మరికొన్ని సంక్లిష్టమైన స్క్రిప్ట్‌లు అవసరమైతే, హైబర్నేట్ ఈ సందర్భంలో కూడా ఉల్లేఖనాలను కలిగి ఉంటుంది. వారు తరగతి పద్ధతులను గుర్తించగలరు మరియు హైబర్నేట్ ఆబ్జెక్ట్‌ను డేటాబేస్‌లో సేవ్ చేసినప్పుడు ఈ పద్ధతులను కాల్ చేస్తుంది. మొత్తం 7 అటువంటి ఉల్లేఖనాలు ఉన్నాయి:

తరగతికి దాని ఆబ్జెక్ట్‌లను సృష్టించడానికి మరియు అప్‌డేట్ చేయడానికి సరైన సమయాన్ని చెప్పే ఉదాహరణను వ్రాద్దాం:

@Entity
@Table(name = "entities")
public class Entity {
  ...

  @Column(name="created_time")
  private Date created;

  @Column(name="updated_time")
  private Date updated;

  @PrePersist
  protected void onCreate() {
    created = new Date();
  }

  @PreUpdate
  protected void onUpdate() {
  updated = new Date();
  }
}

హైబర్నేట్ మొదటిసారి ఆబ్జెక్ట్‌ను సేవ్ చేస్తే, అది తో ఉల్లేఖించిన పద్ధతిని కాల్ చేస్తుంది @PrePersist. ఇది డేటాబేస్‌లో ఇప్పటికే ఉన్న ఆబ్జెక్ట్‌ను అప్‌డేట్ చేస్తే, అది ఉల్లేఖనతో గుర్తించబడిన పద్ధతిని కాల్ చేస్తుంది @PreUpdate.

5.3 మా EntityListeners జోడించడం

మీకు నిజంగా అవసరమైతే, హైబర్నేట్ కాల్ చేసే పద్ధతులను అది కాల్ చేసే వస్తువు నుండి వేరు చేయవచ్చు. JPA స్పెసిఫికేషన్ ఎంటిటీ ఆబ్జెక్ట్‌లను ప్రాసెస్ చేస్తున్నప్పుడు నిర్దిష్ట సమయాల్లో పిలవబడే శ్రోతల తరగతులను ప్రకటించడానికి మిమ్మల్ని అనుమతిస్తుంది.

మీ వద్ద చాలా సారూప్య ఎంటిటీ ఆబ్జెక్ట్‌లు ఉంటే, మీరు వాటిలో కొన్నింటిని బేస్ క్లాస్‌కి తరలించవచ్చు మరియు వారి ప్రవర్తనను నియంత్రించే లిజనర్‌ని జోడించవచ్చు. ఉదాహరణ:

@MappedSuperclass
public abstract class BaseEntity {
 
    private Timestamp createdOn;
 
    private Timestamp updatedOn;
 
}


@Entity
public class User extends BaseEntity {
 
     @Id
     private Long id;
 
     private String name;
}

అప్పుడు BaseEntity తరగతి కోసం, మీరు ఒక ప్రత్యేక శ్రోత తరగతిని సృష్టించవచ్చు:

public class TimeEntityListener {
 
    public void onPersist(Object entity) {
    	if (entity instanceof BaseEntity) {
        	BaseEntity baseEntity = (BaseEntity) entity;
        	baseEntity.createdOn = now();
    	}
    }
 
    public void onUpdate(Object entity) {
    	if (entity instanceof BaseEntity) {
        	BaseEntity baseEntity = (BaseEntity) entity;
        	baseEntity.updatedOn = now();
    	}
    }
 
    private Timestamp now() {
    	return Timestamp.from(LocalDateTime.now().toInstant(ZoneOffset.UTC)   );
    }
}

మరియు మీరు రెండు ఉల్లేఖనాలను ఉపయోగించి వినియోగదారు తరగతిని మరియు దాని శ్రోతను కనెక్ట్ చేయవచ్చు:

@Entity
@EntityListeners(class= TimeEntityListener.class)
public class User extends BaseEntity {
 
     @Id
     private Long id;
 
     private String name;
}