जावा बिटसेट को डीबी

Question

जेपीए के साथ काम करना, मैं डीबी में बिटसेट को सहेजने और इसे वापस खींचने में सक्षम होना चाहता हूं।

मान लीजिए मैं:

@Entity 
@Table(name = "myTable") 
public class MyClass { 

    @Id 
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    @Column(name = "Object_Id") 
    protected long id; 

    @Column(name = "Tags") 
    protected BitSet tags; 

... getters & setters etc... 
} 

एक "columnDefinition" को परिभाषित करना चाहिए और साथ ही? मैं वास्तव में समझ में नहीं आता कि यह कैसे जारी रहता है (toString() का उपयोग कर?) और इसके अलावा यह डीबी से वापस कैसे लोड हो जाता है।

क्या आप कृपया इस के साथ मेरी मदद कर सकते हैं?

धन्यवाद!

Answer 1

डिफ़ॉल्ट रूप से जेपीए अज्ञात Serializable प्रकारों के गुणों को बनाए रखने के लिए जावा क्रमबद्धता का उपयोग करता है (ताकि आपके पास एक क्रमबद्ध प्रतिनिधित्व byte[] के रूप में संग्रहीत हो)।

आमतौर पर यह वही नहीं है जो आप चाहते हैं, क्योंकि आपके डेटा का प्रतिनिधित्व करने के लिए और अधिक प्रभावी तरीके हो सकते हैं। उदाहरण के लिए, BitSet कुशलतापूर्वक एक संख्या के रूप में प्रदर्शित किया जा सकता है (यदि इसका आकार बाध्य है), या byte[], या कुछ और (दुर्भाग्य से, BitSet इन रूपांतरणों को करने के तरीके प्रदान नहीं करता है, इसलिए आपको उन्हें मैन्युअल रूप से लागू करने की आवश्यकता है)।

जब आपने तय किया कि डेटा में डेटा का क्या प्रतिनिधित्व करना है, तो आपको आवश्यक रूपांतरण लागू करने के लिए जेपीए को बताया जाना चाहिए। दो विकल्प हैं:

• गेटर्स और सेटर्स में रूपांतरण लागू करें। उदाहरण के लिए, के रूप में इस प्रकार है:

  @Entity 
  @Table(name = "myTable") 
  @Access(AccessType.FIELD) 
  public class MyClass { 
      ... 
      @Transient // Do not store this field 
      protected BitSet tags; 
  
      @Access(AccessType.PROPERTY) // Store the property instead 
      @Column(name = "Tags") 
      byte[] getTagsInDbRepresentation() { 
       ... // Do conversion 
      } 
  
      void setTagsInDbRepresentation(byte[] data) { 
       ... // Do conversion 
      } 
      ... 
  } 
  

• उपयोग प्रदाता-विशिष्ट एक्सटेंशन रूपांतरण परोक्ष (उदाहरण के लिए, custom types हाइबरनेट में) करने के लिए। यह दृष्टिकोण आपको विभिन्न प्रकारों में अपने प्रकार के रूपांतरण तर्क का पुन: उपयोग करने की अनुमति देता है।

Answer 2

अधिक कारगर तरीका (कि का उपयोग करता है byte[] के बजाय int) एक बहुत सरल कस्टम वर्ग की आवश्यकता है:

@Entity 
@Access(AccessType.FIELD) 
public class SampleEntity { 

    @Transient 
    private IntBitSet isolationLevel = new IntBitSet(0); 

    public static final int USER_BIT = 0; 
    public static final int DEVICE_BIT = 1; 
    // 2, 3, 4, ... 

    public boolean isUserIsolated() { 
     return isolationLevel.bitGet(USER_BIT); 
    } 

    public boolean isDeviceIsolated() { 
     return isolationLevel.bitGet(DEVICE_BIT); 
    } 

    public void setUserIsolated(boolean b) { 
     isolationLevel.bitSet(USER_BIT, b); 
    } 

    public void setDeviceIsolated(boolean b) { 
     isolationLevel.bitSet(DEVICE_BIT, b); 
    } 

    @Access(AccessType.PROPERTY) 
    @Column 
    public int getIsolationLevel() { 
     return isolationLevel.getValue(); 
    } 

    public void setIsolationLevel(int isolationLevel) { 
     this.isolationLevel = new IntBitSet(isolationLevel); 
    } 

    private static class IntBitSet { 
     private int value; 

     public IntBitSet(int value) { 
      this.value = value; 
     } 

     public int getValue() { 
      return value; 
     } 

     public boolean bitGet(int i) { 
      return ((value >> i) & 1) == 1; 
     } 

     public void bitSet(int i, boolean b) { 
      if (b) { 
       bitSet(i); 
      } else { 
       bitUnset(i); 
      } 
     } 
     private void bitSet(int i) { 
      value = value | (1 << i); 
     } 
     private void bitUnset(int i) { 
      value = value & ~(1 << i); 
     } 
    } 
}