Een SerialBlob versus byte gebruiken[]

Je hebt gelijk dat de SerialBlob is slechts een dunne abstractie rond een byte[] , maar:

• Werk je in een team?
• Maak je soms fouten?
• Ben je lui met het schrijven van opmerkingen?
• Vergeet je soms wat je code van een jaar geleden eigenlijk doet?

Als u een van de bovenstaande vragen met ja heeft beantwoord , moet u waarschijnlijk SeriëleBlob .

Het is in principe hetzelfde met elke andere abstractie rond een eenvoudige datastructuur (denk aan ByteBuffer , bijvoorbeeld) of een andere klasse. Je wilt het gebruiken over byte[] , omdat:

1. Het is meer beschrijvend. Een byte[] kan een soort cache zijn, het kan een cirkelvormige buffer zijn, het kan een soort integriteitscontrolemechanisme zijn dat fout is gegaan. Maar als u SerialBlob . gebruikt , het is duidelijk dat dit slechts een klodder binaire gegevens uit de database is / die in de database moet worden opgeslagen.

   In plaats van handmatige array-afhandeling, gebruik je methoden voor de klasse, wat opnieuw gemakkelijker te lezen is als je de code niet kent. Zelfs triviale array-manipulatie moet worden begrepen door de lezer van uw code. Een methode met een goede naam is zelfbeschrijvend.

   Dit is handig voor je teamgenoten en ook voor jou als je deze code over een jaar zult lezen.

2. Het is meer foutbestendig. Elke keer dat je een nieuwe code schrijft, is de kans groot dat je er een bug in hebt gemaakt. Het is in het begin misschien niet zichtbaar, maar het zit er waarschijnlijk wel in. De SerialBlob code is getest door duizenden mensen over de hele wereld en het is veilig om te zeggen dat er geen bugs aan verbonden zijn.

   Zelfs als je zeker weet dat je de byte-array goed hebt afgehandeld, omdat het zo eenvoudig is, wat als iemand anders je code binnen een half jaar vindt en begint met het "optimaliseren" van dingen? Wat als hij een oude klodder hergebruikt, of je magische array-padding verknoeit? Elke afzonderlijke fout bij het manipuleren van de index zal uw gegevens beschadigen en dat wordt mogelijk niet meteen gedetecteerd (u bent eenheidstests schrijven, nietwaar?).

3. Het beperkt u tot slechts een handvol mogelijke interacties. Dit lijkt misschien een minpunt, maar dat is het niet! Het zorgt ervoor dat u uw blob niet als een lokale tijdelijke variabele gebruikt nadat u er klaar mee bent. Het zorgt ervoor dat je geen String . probeert te maken uit of iets geks. Het zorgt ervoor dat je het alleen als een klodder gebruikt. Nogmaals, duidelijkheid en veiligheid.

4. Het is al geschreven en ziet er altijd hetzelfde uit. Je hoeft niet voor elk project een nieuwe implementatie te schrijven, of tien verschillende implementaties in tien verschillende projecten te lezen. Als je ooit een SerialBlob . zult zien in ieders project zal het gebruik u duidelijk zijn. Iedereen gebruikt dezelfde.

TL; DR: Een paar jaar geleden (of misschien nog steeds in C), met een byte[] zou goed zijn. Probeer in Java (en OOP in het algemeen) een specifieke klasse te gebruiken die voor de taak is ontworpen in plaats van een primitieve (laag niveau) structuur, omdat deze uw bedoelingen duidelijker beschrijft, minder fouten produceert en de lengte van uw code op de lange termijn vermindert .