ప్రాథమిక కీ

@Id ఉల్లేఖన

హైబర్నేట్‌లోని ప్రతి ఎంటిటీ తప్పనిసరిగా ఫీల్డ్‌ను కలిగి ఉండాలి, అది ప్రాథమిక కీ అవుతుంది: ఇది ఈ తరగతిలోని అన్ని ఆబ్జెక్ట్‌ల కోసం ప్రత్యేక విలువను కలిగి ఉంటుంది. సాధారణంగా, ఈ ఫీల్డ్ @Id ఉల్లేఖనంతో ఉల్లేఖించబడుతుంది .

సాధారణ రూపం:

@Id
Class Name;

ఉదాహరణ:

@Entity
@Table(name="user")
class User
{
   @Id
   @Column(name="id")
   public Integer id;

   @Embedded
   public UserAddress address;

   @Column(name="created_date")
   public Date createdDate;
}

ఉల్లేఖన స్థానం

మార్గం ద్వారా, మీరు ఫీల్డ్‌ల కోసం మాత్రమే కాకుండా, పద్ధతుల కోసం కూడా @కాలమ్ ఉల్లేఖనాలను వ్రాయవచ్చు: గెట్టర్‌లు లేదా సెట్టర్‌ల కోసం. ఉదాహరణ:

@Entity
@Table(name="user")
class User
{
    public Integer id;
    public Date createdDate;

   @Id
   @Column(name="id")
   public Integer getId() {
   	return this.id;
   }
   public void setId(Integer id)    {
  	this.id = id;
   }

   @Column(name="created_date")
   public Date getDate() {
  	return this.createdDate;
   }
   public void setCreatedDate(Date date) {
      this. createdDate = date;
   }
}

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

ముఖ్యమైనది! ఒక తరగతి @Entity ఉల్లేఖనాన్ని కలిగి ఉంటే , దాని ఫీల్డ్‌లన్నీ హైబర్నేట్ ద్వారా స్థిరమైన ఫీల్డ్‌లుగా పరిగణించబడతాయి (అవి @Transient ఉల్లేఖనాన్ని పేర్కొనకపోతే ). ఫీల్డ్‌లు ఎటువంటి ఉల్లేఖనాలను కలిగి లేనప్పటికీ: ఈ సందర్భంలో, నిలువు వరుస పేరు తరగతి ఫీల్డ్ పేరుకు సమానంగా పరిగణించబడుతుంది.

ఇక్కడ @Id ఉల్లేఖన ముఖ్యమైన పాత్ర పోషిస్తుంది. ఉల్లేఖనాన్ని క్లాస్ ఫీల్డ్‌లో ఉంచినట్లయితే, హైబర్నేట్ ఫీల్డ్‌ల పేర్లు మరియు రకాలను చూస్తుంది. @Id ఉల్లేఖనాన్ని ఒక పద్ధతిలో ఉంచినట్లయితే , హైబర్నేట్ పద్ధతుల పేర్లు మరియు రకాలను చూస్తుంది.

ఉదాహరణ 1:

@Entity
@Table(name="user")
class User
{
   @Id
    public Integer id;
    public Date createdDate;  //this field will be treated as if it had @Column(name=" createdDate ")

}

ఉదాహరణ 2:

@Entity
@Table(name="user")
class User
{
    public Integer id;
    public Date createdDate;

   @Id
   public Integer getId() {
   	return this.id;
   }
   public void setId(Integer id)    {
  	this.id = id;
   }

   public Date getDate() { //this field will be treated as if it had @Column(name=”date ”)
  	return this.createdDate;
   }
   public void setCreatedDate(Date date) {
  	this. createdDate = date;
   }

}

@GeneratedValue ఉల్లేఖన

మీరు మీ కొత్త వస్తువులకు ఒక IDని కేటాయించవచ్చు లేదా హైబర్నేట్ యొక్క దయతో దానిని వదిలివేయవచ్చు. హైబర్నేట్ మీ వస్తువులకు IDలను ఎలా కేటాయించాలో బాగా అర్థం చేసుకోవడానికి, దీనికి ప్రత్యేక ఉల్లేఖన ఉంది:

@GeneratedValue

ఈ ఉల్లేఖనం సాధారణంగా @Id ఉల్లేఖన వలె అదే ఫీల్డ్‌ను సూచిస్తుంది . ఆమెకు 4 సాధ్యమైన ID అసైన్‌మెంట్ వ్యూహాలు ఉన్నాయి:

• దానంతట అదే
• గుర్తింపు
• సీక్వెన్స్
• పట్టిక

పేర్కొన్న వ్యూహంతో ఉల్లేఖనానికి ఉదాహరణ:

@Entity
@Table(name="user")
class User
{
    @Id
	@GeneratedValue(strategy = GenerationType.AUTO)
    public Integer id;

    public Date createdDate;
}

విధాన విలువను పేర్కొనకపోతే, AUTO వ్యూహం ఎంపిక చేయబడుతుంది. AUTO వ్యూహం అంటే, హైబర్నేట్ అనేది ప్రాథమికంగా ID ఫీల్డ్ యొక్క డేటా రకం ఆధారంగా IDని కేటాయిస్తుంది.

ఎందుకు రకం మీద? అవును, ఎందుకంటే ID రకాలు చాలా భిన్నంగా ఉంటాయి, ఉదాహరణకు, స్ట్రింగ్ లేదా GUID. ఉదాహరణ:

@Entity
@Table(name="user")
class User
{
    @Id
	@GeneratedValue
    public UUID id;

    public Date createdDate;
}

గమనిక: జావాలోని GUIDని UUID అంటారు, చారిత్రాత్మకంగా చెప్పాలంటే. మరియు హైబర్నేట్ మీరు కోరితే మీ వస్తువుల కోసం ప్రత్యేకమైన UUIDలను రూపొందించవచ్చు.

వివిధ @GeneratedValue వ్యూహాలు

మీరు GeneratedValue(వ్యూహం = GenerationType.IDENTITY) రకాన్ని పేర్కొంటే , హైబర్నేట్ ID సెట్టింగ్‌ని డేటాబేస్ లేయర్‌కు డెలిగేట్ చేస్తుంది. సాధారణంగా, ఇది ప్రైమరీ కీ, ఆటోఇన్‌క్రిమెంట్ లేబుల్ చేయబడిన నిలువు వరుసను ఉపయోగిస్తుంది.

కానీ మీరు ప్రత్యేకంగా పేర్కొన్న అల్గారిథమ్ ప్రకారం మీ IDలు ప్రత్యేకంగా ఉండాలని మరియు రూపొందించబడాలని మీరు కోరుకుంటే, మీరు GeneratedValue(strategy = GenerationType.SEQUENCE) ఉల్లేఖనాన్ని ఉపయోగించవచ్చు , ఉదాహరణకు:

@Entity
@Table(name="user")
public class User {
	@Id
	@GeneratedValue(generator = "sequence-generator")
	@GenericGenerator(
  	name = "sequence-generator",
  	strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator",
  	parameters = {
    	@Parameter(name = "sequence_name", value = "user_sequence"),
    	@Parameter(name = "initial_value", value = "4"),
    	@Parameter(name = "increment_size", value = "1")
    	}
	)
	private long userId;

	// ...
}

IDని రూపొందించడానికి ఇంకా చాలా మార్గాలు ఉన్నాయి. ఉదాహరణకు, మీరు అనేక నిలువు వరుసలతో కూడిన మిశ్రమ ప్రత్యేక కీని కలిగి ఉండవచ్చు. మరియు డేటాబేస్కు ఒక వస్తువును వ్రాసేటప్పుడు, మీరు ఈ అన్ని నిలువు వరుసలను పూరించాలి.

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