Slaapstand Annotaties – Dat is beter, veld of goederen toegang?

Deze vraag is enigszins gerelateerd aan Slaapstand Annotatie Plaatsing Vraag.

Maar ik wil weten wat beter? Toegang via de eigenschappen van of de toegang via de velden?
Wat zijn de voordelen en nadelen van elk?



25 Replies
  1. 31

    Ik liever accessors, want ik kan het toevoegen van een aantal business logica naar mijn accessors wanneer ik nodig heb.
    Hier is een voorbeeld:

    @Entity
    public class Person {
    
      @Column("nickName")
      public String getNickName(){
         if(this.name != null) return generateFunnyNick(this.name);
         else return "John Doe";
      }
    }

    Trouwens, als je gooit een andere libs in de mix (zoals sommige JSON-converting-lib of BeanMapper of Dozer of andere bonen mapping/klonen lib gebaseerd op getter/setter eigenschappen) heeft u de garantie dat het lib is in sync met de persistentie manager (beide gebruik maken van de getter/setter).

    • Opmerking dit is over hoe het ORM toegang tot uw velden, eigenschappen en niet uw applicatie code. Met toegang tot veld uw getNickName() methode zou werken precies zoals je zou verwachten. Dit geldt niet als u de aanhoudende ‘eigenschappen’ van buiten getters/setters. Dat is waar je je problemen met eigendom toegang en lazy loading. Dus nee, ik ben het niet eens met dit argument in het algemeen. Echter, de laatste keer dat ik gecontroleerd Slaapstand problemen met toegang tot veld van @Id-velden.
    • dit antwoord is niet gerelateerd aan de vraag. Beste antwoord s door duffymo
    • er mag geen sprake zijn van business logica in accessors. dat is niet voor de hand liggende gedrag.
  2. 235

    Er zijn argumenten voor beide, maar de meeste van hen voortvloeien uit bepaalde eisen van de gebruiker “wat als je nodig hebt om toe te voegen logica voor”, of “xxxx breekt encapsulation”. Echter, niemand heeft echt commentaar op de theorie, en een goed beredeneerde argument.

    Wat is Hibernate/JPA eigenlijk doen als het blijft een object – en, is het voortduren van de TOESTAND van het object. Dat betekent dat het op te slaan op een manier dat het gemakkelijk kan worden gereproduceerd.

    Wat is de inkapseling? Inkapselingen betekent het inkapselen van de gegevens (of het land) met een interface die de toepassing/client kan gebruiken om toegang te krijgen tot de gegevens veilig te houden consistent en geldig.

    Denken van deze, zoals MS Word. MS Word onderhoudt een model van het document in het geheugen – de documenten STAAT. Het biedt een interface die de gebruiker kan gebruiken om te wijzigen van het document – een set van knoppen, tools, toetsenbord commando ‘ s enz. Echter, als u ervoor kiest om te blijven bestaan (Opslaan) dat document, het bespaart de interne toestand, niet de reeks toetsaanslagen en muisklikken gebruikt om de inhoud te genereren.

    Het opslaan van de interne staat van het voorwerp NIET breekt encapsulation (encapsulatie) – anders heb je niet echt begrijpen wat inkapseling betekent, en waarom het bestaat. Het is net als het object serialisation echt.

    Om deze reden, IN de MEESTE GEVALLEN blijven de VELDEN en niet de ACCESSORS. Dit betekent dat een object nauwkeurig kan worden gemaakt van de database precies de manier waarop het is opgeslagen. Het zou niet nodig moeten de validatie, omdat dit werd gedaan aan de oorspronkelijke wanneer het is gemaakt, en voordat het werd opgeslagen in de database (tenzij, God verhoede, u het opslaan van ongeldige gegevens in de DB!!!!!). Ook moet het niet nodig zijn voor het berekenen van waarden, als ze al waren, berekend vóór het object is opgeslagen. Het object moet kijken precies zoals het was voordat het werd opgeslagen. In feite, door het toevoegen van extra spullen in de getters/setters je eigenlijk toenemende het risico dat je opnieuw iets dat is niet een exacte kopie van het origineel.

    Natuurlijk, deze functionaliteit is toegevoegd voor een reden. Er kunnen een aantal geldig use cases voor het voortduren van de accessors, maar ze zullen meestal zeldzaam. Een voorbeeld kan zijn dat u wilt vermijden voortduren van een berekende waarde, maar wilt u misschien de vraag stellen waarom je niet berekenen op de vraag in de waarde van de getter, of lui initialiseren in de getter. Ik persoonlijk kan niet denken van een goede use case, en geen van de antwoorden hier echt geven een “Software Engineering” antwoord.

    • De software engineering antwoord is: met behulp van accessors in strijd is DROOG.
    • (en encapsulation)
    • Zeer goed. Voordat ik dit las had ik al aarzelen die te gebruiken.
    • Ik heb een vervolgvraag over de laatste alinea van je antwoord. Je schreef “Een voorbeeld kan zijn dat u wilt vermijden voortduren van een berekende waarde”. Hoe kun je voorkomen dat persisterende een berekende waarde door het hebben van een huis gebaseerde toegang? Ik weet dat je het argument om het niet te doen, maar ik krijg niet het punt hier. Kunt u uitleggen?
    • Nu lees ik het terug ik ben niet helemaal zeker van mezelf. Het is twee jaar geleden schreef ik dit antwoord. Ik denk dat een beter voorbeeld zou zijn wanneer u werkt met een verouderde database en de gegevens worden gepresenteerd op een andere manier om uw object model – accessors zou kunnen zorgen voor een koppeling tussen de twee.
    • Een goed use case voor het in kaart brengen accessors is wanneer je nodig hebt om toe te voegen afbeelding informatie toe aan de subklassen van derde-partij klassen die niet zijn gebonden aan enige persistentie uitvoering. Sinds velden zijn eigen in de klassen, moet u overschrijven accessors en toewijzing toevoegen van aantekeningen aan hen. Een andere optie is gebruik te maken van XML-toewijzing, maar sommige dingen zijn erg moeilijk te doen. Dus, als je wilt aantekeningen en kaart van derden klassen, subclassificering hen en het toevoegen van annotaties op accessors is de weg te gaan.
    • daar gaan we, een uitstekend voorbeeld. Bedankt.
    • Dit is het antwoord op de vraag, het toevoegen van de use case uit de reactie

  3. 77

    Ik liever gebied van de toegang, omdat op die manier ben ik niet gedwongen te bieden getter/setter voor elke eigenschap.

    Een korte enquête via Google stelt dat toegang tot veld is de meerderheid (bijv., http://java.dzone.com/tips/12-feb-jpa-20-why-accesstype).

    Ik geloof dat veld is het idioom aanbevolen door de Lente, maar ik kan niet vinden een verwijzing naar dat.

    Er is een verwante ZO vraag dat geprobeerd om de prestaties te meten en kwam tot de conclusie dat er “geen verschil”.

    • als je niet bieden setter getter in entiteit dan wat het gebruik van dat gebied…je kan het niet gebruiken anwyhere in de toepassing , omdat de velden zijn eigen
    • Is het niet verstrekken van een getter en setter voor de velden slecht praktijk?, Ik denk dat mijn reactie hier is niet altijd gelijk, want ik was in de veronderstelling van een openbaar veld, hoewel het uiteraard een privé-gebied dat wordt nooit gebruikt.
    • Ik voel dat ik moet echt adres uw vragen, dat is wat inkapseling is alles over. Idealiter alle velden moeten worden privé, en als het mogelijk is, moeten ze geen getters of setters – dat is het beste niveau van inkapseling je kunt hopen. Overweeg een wachtwoord checker. 2 eigen velden passwordHash en failedAttempts. Beide kunt u privé met geen getter / setter. Ze worden gebruikt door bool checkPassword(string password) die hashes, controles tegen passwordHash en dan updates failedAttempts en geeft een resultaat aan. Geen noodzaak voor een andere code om ooit de toegang tot deze twee velden.
    • opgemerkt moet worden dat in OOP, getters en setters zijn een anti-patroon, ze komen van procedureel programmeren, met een klas met hen breekt de inkapseling principe, en genereert een veel boilerplate code, dat is dezelfde soort van code herhaald over en weer. Objecten moeten worden gewijzigd, als de wijziging van de eigenschappen is vereist het moet worden gedaan door de methode die iets meer doen dan alleen het terugzenden van de waarde van de woning.
    • Niet dus. “Anti-pattern” in dit geval is het een kwestie van een mening, geen dogma ‘ s. Met dat gezegd, toegang tot veld is nog steeds de voorkeur. Een beter idee is om uit de weg ORM oplossingen helemaal. Leren hoe te schrijven juiste SQL.
    • nu snap ik het…na 2 jaar deed ik dit met ervaring ….onveranderlijke en veranderlijke beide hebben hun plaats in de object georiënteerde wereld…ook in de lente kader hebben we pojos om de toegang van de eigenschappen..die nodig zijn…zonder getters en setters…misschien hebben we een probleem…en als het niet goed gebruikt kunnen problemen veroorzaken…
    • helaas, alleen maar omdat een anti-patroon wordt gebruikt door deze kaders, betekent niet dat het een goede zaak en moet worden gebruikt. Ten koste van ons te bevrijden van de zorgen van het maken van de verbindingen of de injectie van onszelf, we vullen onze code met boilerplate code en de bestanden van de configuratie. Het is een win-verlies situatie

  4. 38

    Hier is een situatie waar je gebruik van de eigenschap accessors. Je hebt een ALGEMENE abstracte klasse met veel van de uitvoering goedheid erven in 8 concrete subklassen:

    public abstract class Foo<T extends Bar> {
    
        T oneThing;
        T anotherThing;
    
        //getters and setters ommited for brevity
    
        //Lots and lots of implementation regarding oneThing and anotherThing here
     }

    Nu precies, hoe moet je annoteren deze klasse? Het antwoord is dat JE NIET KUNT aantekeningen maken op alle gebied of goederen toegang, omdat je niet kunt geef het doel entiteit op dit punt. Je HEBT om aantekeningen te maken bij de concrete implementaties. Maar sinds de vastgelegde eigenschappen worden verklaard in deze superklasse, MOET u gebruikt goederen toegang in de subklassen.

    Toegang tot veld is niet een optie in een applicatie met abstracte generieke super-klassen.

    • touche. Ik had niet gedacht. Ik wed Slaapstand kicks uit een aantal gekke sql voor deze.
    • Dit probleem klinkt mechanisch moeilijk op te lossen zonder het annoteren van eigenschappen, maar ik heb nog nooit liep in een geval waar ik behoefte aan een abstracte algemene klasse met veel van de uitvoering dat ik ook wilde aanhouden. Meestal maak ik een klasse-hiërarchie te maken van mijn object polymorfe (waarin het maken van het generieke soort van breuken), en niet uitsluitend voor het hergebruik van code. En “heel veel van de uitvoering” vaak in strijd SRP hoe dan ook, in dat geval zou ik waarschijnlijk verhuizen in afzonderlijke klassen. Is er een concreet voorbeeld dat het maken van deze use case meer voor de hand?
    • Het enige concrete voorbeeld dat ik heb is mijn verzoek, dat ik niet kan beschrijven in een 500 karakter reactie 😉
    • U kunt gebruik maken van abstract T getOneThing(), en abstract void setOneThing(T thing), en gebruik het veld toegang.
  5. 33

    Ik de neiging om de voorkeur en het gebruik van eigendom accessors:

    • Ik kan de logica toevoegen als het nodig is (zoals vermeld in de geaccepteerde antwoord).
    • het stelt me in staat om te bellen foo.getId() zonder het initialiseren van een proxy (belangrijk bij het gebruik van de Slaapstand, tot HHH-3718 opgelost).

    Nadeel:

    • het maakt de code minder leesbaar, je hebt bijvoorbeeld te zoeken op een hele klas om te zien of er @Transient daar rond.
    • maar als u dan het gebruik van een JPA-provider die niet hebben “proxies” dan heb je dat probleem niet aka “uw JPA provider te leggen op je”.
  6. 13

    Dat hangt helemaal af van het specifieke geval-beide opties zijn beschikbaar voor een reden. IMO komt het neer op de volgende drie gevallen:

    1. setter heeft enige logica die niet mogen worden uitgevoerd op het tijdstip van het laden van een exemplaar van een databank; bijvoorbeeld, een bepaalde waarde validatie gebeurt in de setter, echter de gegevens uit de db geldig zou moeten zijn (anders zou het niet bereiken (: ); in dit geval toegang tot veld is het meest geschikt;
    2. setter heeft enige logica die altijd moet worden ingeroepen, zelfs tijdens het laden van een exemplaar van het db; bijvoorbeeld, de eigendom wordt geïnitialiseerd wordt gebruikt in de berekening van sommige berekend veld (bv. eigendom — een bedrag, berekend eigendom — totaal verschillende monetaire eigenschappen van hetzelfde exemplaar); in dit geval eigendom toegang is vereist.
    3. Geen van de bovenstaande gevallen, dan zijn beide opties van toepassing, blijf consequent (e.ik. als het veld van de toegang is de keuze in deze situatie gebruik het dan de hele tijd in een vergelijkbare situatie).
    • Ik ben nieuw op de Slaapstand en worstelen met dezelfde vraag. Ik denk dat dit bericht bevat de meest duidelijke antwoord. Dank u.
  7. 12

    Ik zou sterk aanbevelen toegang tot veld en NIET annotaties op de getters (eigendom) toegang als u wilt om iets meer te doen in de setters dan alleen het instellen van de waarde (bijv. Codering of berekening).

    Het probleem met de toegang tot eigenschap is dat de setters zijn ook wel wanneer het object wordt geladen. Dit werkte voor mij prima voor vele maanden tot we wilden introduceren encryptie. In onze gebruiken geval wilden we voor het coderen van een veld in de setter en decoderen in de getter.
    Het probleem nu met toegang tot eigenschap was dat wanneer de Slaapstand wordt geladen van het object het was ook het aanroepen van de setter voor het vullen van het veld en dus was het versleutelen van de gecodeerde waarde weer.
    Dit bericht vermeldt ook dit:
    Java-Slaapstand: Verschillende set-functie van gedrag, afhankelijk van wie er belt, het

    Deze reden heeft me hoofdpijn tot ik me herinnerde het verschil tussen veld toegang en toegang tot eigenschap. Nu heb ik verplaatst al mijn aantekeningen van de woning toegang tot het gebied toegang en het werkt prima nu.

    • Ja – ik heb ontdekt dat als je gebruik eigendom toegang tot je echt niets te doen is in uw setter naast het instellen van de veld-waarde.
    • +1 weg te Houden van getters/setters. Ik gebruik projectlombok.org en om hen verborgen van de ontwikkelaars.
  8. 9

    Ik werk liever met toegang tot veld om de volgende redenen:

    1. De eigendom toegang kan leiden tot zeer vervelende bugs bij de uitvoering is gelijk aan/hashCode en het verwijzen naar velden, direct (in tegenstelling door hun getters). Dit is omdat de proxy is alleen geïnitialiseerd wanneer de getters zijn toegankelijk, en een directe toegang tot veld zou gewoon terug null.

    2. De eigendom toegang vraagt u om annotate all utility methoden (bijv. addChild/removeChild) als @Transient.

    3. Met toegang tot veld kunnen we verbergen de @ – Versie veld door niet het ontmaskeren van een getter op alle. Een getter kan ook leiden tot het toevoegen van een setter en de version veld moet nooit handmatig worden ingesteld (wat kan leiden tot zeer vervelende problemen). Alle versie incrementation moet worden geactiveerd via OPTIMISTIC_FORCE_INCREMENT of PESSIMISTIC_FORCE_INCREMENT expliciete vergrendelen.

    • 1. Hoe werkt veld toegang strategie dit voorkomen? Dit lijkt een algemene valkuil met proxy ‘ s, ongeacht de toegang stijl. 2. weet u het zeker, moet het alleen nut getters? (maar een goed argument toch). 3. Bloot accessors voor version veld is het vaak nuttig in situaties waarin DTOs worden gebruikt in plaats van vrijstaande entiteiten.
    • 1. Want wanneer een Proxy wordt geïnitialiseerd. 2. 100% zeker. 3. Dat is een geldig punt.
    • Vergeef mij mijn onwetendheid en een mogelijk gebrek aan tekst interpretatie, (ik ben geen native speaker engels). Gewoon om te verduidelijken, toegang tot veld is wanneer er geen getter/setter methoden nodig zijn recht, dus voor een POJO, dat is holistisch gebruikt, worden de velden publiek? Maar u iets zeggen in de eerste topic en de gekoppelde blog post het tegendeel zeggen. Wat ik begreep was dat je het niet kan gebruiken is gelijk aan bij het gebruik van proxy ‘ s en toegang tot veld.
    • Nee. Toegang tot veld betekent dat de Slaapstand gebruikt de velden via reflecties te lezen entiteit kenmerken. Voor meer details, bekijk de Toegang Type gedeelte in de Slaapstand User Guide.
  9. 7

    Ik denk dat het annoteren van de goederen is beter, omdat het bijwerken van velden rechtstreeks breekt inkapseling, zelfs wanneer uw ORM doet.

    Hier is een goed voorbeeld van waar het zal je verbranden: wilt u waarschijnlijk uw aantekeningen voor de slaapstand validator & persistentie in dezelfde plaats (ofwel velden of eigenschappen). Als u wilt testen of de slaapstand-validator aangedreven validaties die worden geannoteerd op een veld, kunt u geen gebruik maken van een mock van uw entiteit te isoleren van uw unit test om de validator. Ouch.

    • Dat is de reden waarom je validator-annotaties op accessors en persistentie-annotaties op de velden
  10. 6

    Ik geloof eigendom toegang vs. toegang tot veld is enigszins anders zijn met betrekking tot het luie initialisatie.

    Rekening met de volgende toewijzingen voor 2 basic bonen:

    <hibernate-mapping package="org.nkl.model" default-access="field">
      <class name="FieldBean" table="FIELD_BEAN">
        <id name="id">
          <generator class="sequence" />
        </id>
        <property name="message" />
      </class>
    </hibernate-mapping>
    
    <hibernate-mapping package="org.nkl.model" default-access="property">
      <class name="PropBean" table="PROP_BEAN">
        <id name="id">
          <generator class="sequence" />
        </id>
        <property name="message" />
      </class>
    </hibernate-mapping>

    En de volgende unit tests:

    @Test
    public void testFieldBean() {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        FieldBean fb = new FieldBean("field");
        Long id = (Long) session.save(fb);
        tx.commit();
        session.close();
    
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        fb = (FieldBean) session.load(FieldBean.class, id);
        System.out.println(fb.getId());
        tx.commit();
        session.close();
    }
    
    @Test
    public void testPropBean() {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        PropBean pb = new PropBean("prop");
        Long id = (Long) session.save(pb);
        tx.commit();
        session.close();
    
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        pb = (PropBean) session.load(PropBean.class, id);
        System.out.println(pb.getId());
        tx.commit();
        session.close();
    }

    Zie je het subtiele verschil in de hiermee selecteert u nodig:

    Hibernate: 
        call next value for hibernate_sequence
    Hibernate: 
        insert 
        into
            FIELD_BEAN
            (message, id) 
        values
            (?, ?)
    Hibernate: 
        select
            fieldbean0_.id as id1_0_,
            fieldbean0_.message as message1_0_ 
        from
            FIELD_BEAN fieldbean0_ 
        where
            fieldbean0_.id=?
    0
    Hibernate: 
        call next value for hibernate_sequence
    Hibernate: 
        insert 
        into
            PROP_BEAN
            (message, id) 
        values
            (?, ?)
    1

    Dat is, belt fb.getId() vereist een select, terwijl pb.getId() niet.

    • Dit is grappig! 🙂 Maar het is een implementatie-specifieke gedrag, ben ik zeker van. Ik
    • Ja, ik denk dat dit te wijten is aan het feit dat alleen de persistente klassen worden geïnstrumenteerd. Het is jammer maar, omdat de id-veld is vaak het ene veld dat heeft geen waarde voor de onderneming en het zou niet nodig accessor.
  11. 2

    Een ander punt in het voordeel van toegang tot veld is dat anders bent u gedwongen om bloot setters voor verzamelingen en wat, voor mij, is een slecht idee als het veranderen van de permanente collectie-exemplaar van een object niet wordt beheerd door de Slaapstand zal zeker het einde van uw consistentie van de data.

    Dus ik geef de voorkeur hebben van collecties als beschermd velden geïnitialiseerd leeg implementaties in de default constructor en bloot alleen hun getters. Dan, alleen in geslaagd activiteiten zoals clear(), remove(), removeAll() etc mogelijk dat nooit zal Slaapstand niet op de hoogte van wijzigingen.

    • U bent niet gedwongen om bloot te leggen wat de setters kunnen worden beschermd. Ook die setters zijn geen onderdeel van de interface wordt geïmplementeerd, dus zelfs als ze waren openbaar, ze zijn niet gemakkelijk toegankelijk.
  12. 2

    Ik liever velden, maar ik heb uitgevoerd in een situatie die lijkt mij te dwingen om de aantekeningen op getters.

    Met de ‘Slaapstand’ – JPA-implementatie, @Embedded lijkt niet te werken op de velden. Dus dat is in te gaan op de getter. En als je dat op de getter, vervolgens de verschillende @Column annotaties te gaan op de getters ook. (Ik denk dat de Slaapstand niet wil mengen velden en getters hier.) En als je eenmaal bent @Column op getters in de klas, is het waarschijnlijk zinvol om dat te doen in het hele gebouw.

  13. 2

    Ik voorstander van het veld accessors. De code is nog veel schoner. Alle meldingen kunnen worden geplaatst in een
    gedeelte van een klasse en de code is veel makkelijker te lezen.

    Vond ik nog een probleem met de eigenschap accessors: als u getXYZ methoden op uw klas die NIET geannoteerd als verbonden met persistente eigenschappen, hibernate sql genereert om te proberen om die eigenschappen, die resulteert in een aantal zeer verwarrend fout berichten. Twee uren verspild. Ik heb het niet schrijven van deze code; ik heb altijd het veld accessors in het verleden en hebben nooit met dit probleem.

    Slaapstand versies die in deze app:

    <!-- hibernate -->
    <hibernate-core.version>3.3.2.GA</hibernate-core.version>
    <hibernate-annotations.version>3.4.0.GA</hibernate-annotations.version>
    <hibernate-commons-annotations.version>3.1.0.GA</hibernate-commons-annotations.version>
    <hibernate-entitymanager.version>3.4.0.GA</hibernate-entitymanager.version>
  14. 2

    Standaard JPA-aanbieders toegang krijgen tot de waarden van de entiteit velden en kaart van deze velden aan de database kolommen
    met behulp van de entiteit JavaBean eigendom accessor (getter) en mutator (setter) methoden. Als zodanig, de
    namen en types van de eigen velden in een entiteit niet uit te JPA. In plaats daarvan, JPA kijkt alleen
    de namen en typen retourneren van de JavaBean eigendom accessors. U kunt wijzigen met behulp van de @javax.persistence.Access annotatie, die u in staat stelt om uitdrukkelijk aan te geven dat de methode van toegang
    dat de PPV-provider moet gebruiken.

    @Entity
    @Access(AccessType.FIELD)
    public class SomeEntity implements Serializable
    {
    ...
    }

    De beschikbare opties voor de AccessType enum zijn EIGENDOM (de standaard) en in het VELD. Met
    ACCOMMODATIE de aanbieder krijgt en stelt veld waarden met behulp van de JavaBean eigendom methoden. VELD
    de aanbieder get en set-veld waarden met behulp van de aanleg van velden. Als een best practice, moet je gewoon de stick
    de standaard en het gebruik van JavaBean properties, tenzij u een dwingende reden is om anders te doen.

    U
    kan deze eigenschap aantekeningen op de eigen velden of de accessor methoden. Als
    u AccessType.PROPERTY (standaard) en aantekeningen te maken op de eigen velden in plaats van de JavaBean
    accessors, worden de veldnamen, moet overeenkomen met de JavaBean namen van de eigendommen. Echter, de namen niet
    aanpassen als u aantekeningen te maken op het JavaBean accessors. Ook als u AccessType.FIELD en
    aantekeningen de JavaBean accessors in plaats van de velden, de veld namen moet ook overeenkomen met de JavaBean
    namen van de eigendommen. In dit geval zijn ze niet hoeft te komen als je aantekeningen de velden. Het is het beste om gewoon
    consistente en aantekeningen te maken op het JavaBean accessors voor AccessType.PROPERTY en de velden voor
    AccessType.FIELD.

    Het is belangrijk dat je nooit moet mengen JPA eigendom van aantekeningen en JPA veld aantekeningen
    in dezelfde entiteit. Hierdoor resulteert in niet gespecificeerd gedrag en is zeer
    waarschijnlijk leiden tot fouten.

  15. 2

    Laat ik proberen samen te vatten de belangrijkste redenen voor het kiezen van veld-based toegang. Als u wilt om dieper te duiken, lees dan dit artikel op mijn blog: Toegang Strategieën in JPA en Hibernate – Dat is beter, veld of goederen toegang?

    Veld-based access is verreweg de betere optie. Hier zijn 5 redenen voor:

    Reden 1: een Betere leesbaarheid van de code

    Als u gebruik field-based access, u annoteren entiteit attributen met uw kaart annotaties. Door het plaatsen van de definitie van alle entiteit kenmerken op de top van je klas, je krijgt een relatief compacte weergave van alle attributen en hun toewijzingen.

    Reden 2: Weglaten getter /setter methoden die niet mogen worden genoemd door de toepassing

    Een ander voordeel van het veld-based access is dat je persistentie provider, bijvoorbeeld, de Slaapstand of EclipseLink, geen gebruik maakt van de getter en setter methoden van uw onderneming kenmerken. Dat betekent dat je niet nodig hebt om te bieden een methode die niet mogen worden gebruikt door uw business views-code. Dit is vaak het geval voor setter methoden van gegenereerd primaire sleutelattributen versie of kolommen. Uw doorzettingsvermogen provider beheert de waarden van deze kenmerken, en je moet niet ingesteld programmatisch.

    Reden 3: Flexibele uitvoering van de getter en setter methoden

    Vanwege uw volharding provider niet bellen met de getter en setter methoden, zijn ze niet verplicht om te voldoen aan alle externe eisen. U kunt het implementeren van deze methoden op welke manier je wilt. Dat kunt u de implementatie van business-specifieke regels voor gegevensvalidatie de aanzet te geven tot extra business logic of om te zetten van de entiteit attribuut in een ander gegevenstype.

    Kunt u bijvoorbeeld gebruiken om wikkel een optionele vereniging of een attribuut in een Java Optioneel.

    Reden 4: het is Niet nodig om mark utility methoden als @Transient

    Een ander voordeel van het veld-based access strategie is dat je niet hoeft te annoteren utility methoden met @Transient. Deze annotatie vertelt je persistentie provider die een methode of eigenschap is niet een onderdeel van de entiteit permanente status. En omdat met field-type toegang tot de permanente status wordt bepaald door de kenmerken van uw onderneming, uw JPA-implementatie negeert alle methoden van uw entiteit.

    Reden 5: Vermijd fouten bij het werken met volmachten

    Slaapstand proxy ‘ s gebruikt voor lui opgehaald op-één-verenigingen zodat het kan gebruikt worden voor de initialisatie van deze verenigingen. Die aanpak werkt goed in bijna alle situaties. Maar het introduceert een gevaarlijke valkuil als u goederen-based toegang.

    Als u goederen-gebaseerde toegang, Hibernate initialiseert de kenmerken van de proxy-object wanneer u een oproep naar de getter-methode. Dat is altijd het geval als u de proxy-object in uw business code. Maar heel veel van equals en hashCode implementaties toegang tot de kenmerken direct. Als dit de eerste keer dat u toegang tot een van de proxy kenmerken, deze kenmerken zijn nog niet geïnitialiseerd.

  16. 2

    Moet u kiest voor toegang via de velden over de toegang via eigenschappen.
    Met de velden die u kunt beperken van de verzonden en ontvangen gegevens.
    Met de via-eigenschappen u kunt meer gegevens als gastheer, en
    set G denominaties (die in de fabriek ingesteld meeste van de eigenschappen in totaal).

  17. 1

    We gemaakt entity beans en gebruikt getter annotaties. Het probleem dat we in rende is dit: sommige entiteiten hebben complexe regels voor een aantal eigenschappen met betrekking tot wanneer ze kunnen worden bijgewerkt. De oplossing was om een aantal business logica in elk setter die bepaalt of de actuele waarde is veranderd en zo ja, of de wijziging moet worden toegestaan. Natuurlijk, Hibernate kunt te allen tijde de eigenschappen ervan, zodat we uiteindelijk met twee groepen van zetters. Vrij lelijk.

    Het lezen van eerdere berichten, ik zie ook dat het verwijzen naar de eigenschappen van de binnenzijde van de entiteit zou leiden tot problemen met de collecties niet laden.

    Bottom line, ik zou leunen in de richting van het annoteren van de velden in de toekomst.

  18. 0

    Normaal bonen zijn POJO, dus ze hebben accessors toch.

    De vraag is dus niet “welke is beter?”, maar gewoon “te gebruiken wanneer toegang tot veld?”. En het antwoord is: “als u het niet nodig een setter/getter voor het veld!”.

    • Probleem is dat je niet kunt mixen veld toegang en toegang tot eigenschap in een POJO – je moet kiezen
    • Echt? Ik moet het vergeten bent. Hoe dan ook, ik gebruik altijd een POJO d accessors.
    • Merk op dat met JPA 2.0 (die was er niet, toen deze vraag werd gevraagd) u kunt nu de mix toegang typen met behulp van het @AccessType annotatie.
  19. 0

    ik over nagedacht en ik kies methode accesor

    waarom?

    omdat het veld en methos accesor is hetzelfde
    maar als later moet ik wat logica in te laden veld, bespaar ik verplaats alle aantekening geplaatst in velden

    betreft

    Grubhart

  20. 0

    Om uw lessen cleaner, zet de aantekening in het veld gebruik dan @Toegang(AccessType.EIGENDOM)

  21. 0

    AccessType.EIGENDOM: De EJB persistentie uitvoering wordt geladen, staat in uw klas via JavaBean “setter” – methoden, en het ophalen van de staat van uw klasse met behulp van JavaBean “getter” methoden. Dit is de standaardinstelling.

    AccessType.VELD: de Staat is geladen en opgehaald direct uit de klasse’ velden. U hoeft niet te schrijven JavaBean “getters” en “setters”.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *