[Java] J2SE 1.5 Wie gebruikt Annotation en waarvoor?

[ronaldmathies]

Ik heb me vandaag maar eens verdiept in de nieuwe mogelijkheden van Annotations. En ik vindt dit opzich een erg mooie techniek.

Ik heb bijvoorbeeld eens het stuk op sun doorgelezen over validatie dmv Annotations en zelf een variant hierop gemaakt, en dan krijg je pas echt het idee van de mogelijkheden.

Maar waar het mij nu om gaat is het volgende, zijn er mensen die reeds ge-experimenteerd hebben met Annotations en met welk doel, wat wil of wou men ermee bereiken.

Ik ben gewoon geïntreseerd in toepassings gebieden.
(Ik ben op de hoogte van het feit dat EJB 3 gebruik gaat maken van Annotations)

[Alarmnummer]

Annotations kun je schuiven onder de categorie declaratief programmeren, je specificeerd alleen wat je wilt, maar niet hoe je het wilt. Annotaties zijn daarom extreem breed in te zetten.

Ik gebruik zelf annotations (wel de commons attribute syntax en nog niet de 1.5) om transacties en security declaratief toe te voegen. Je zou ze verder ook perfect kunnen gebruiken om remoting hints te gaan geven (ik geloof dat je met 1.5 mbv annotaties ook erg eenvoudig rmi proxies op kunt zetten).

[edit]
Nog een opmerking over EJB3.0. Eindelijk is het niet meer zo gecompliceerd en onnatuurlijk om mee te werken (EJB 2 bepaalt hoe jouw software eruit komt te zien ipv andersom). Maar ik denk dat ze nu wel aan de erg late kant zijn, er zijn intussen al andere alternatieven. De enigste voordelen die ik nog van EJB zie zijn Session beans ivm hun security en transacties en dat kan je met Spring ook perfect. En clustering.. tja... 1) hoeveel applicaties hebben dat nodig.. 2) als je een loadbalancer voor een cluster van applicatieservers plaats zonder onderlinge relatie afgezien van de db... kun je denk ik ook al een heel eind komen.. Weet jij nog meer voordelen aan EJB?

[ Voor 42% gewijzigd door Alarmnummer op 16-03-2005 22:41 ]

[ronaldmathies]

Ik wil voorop stellen dat ik wil voorkomen dat er hier een EJB / Spring / Etc.. discussie ontstaat omdat het mij nu even alleen om de Annotation gaat.

Het hele Spring verhaal ken ik niet dus daar kan ik niet over oordelen. Wat ik zelf merk met EJB dat het stabiel en snel werkt. Ook programmeer technisch is het makkelijk om goede software te maken.

Dat de deployment descriptors voor veel mensen moeilijk zijn heeft ook voor een deel te maken met ervaring en het werkelijk begrijpen. Wij doen op het moment alles met Session en Entity beans. Daarbij hebben we geen last van trage performance e.d. omdat we veel gebuik maken van de JBoss hints e.d. (load-groups, read strategy's), het duurt even voordat je het doorhebt maar vervolgens is het wel heel snel te krijgen.

Daarnaast hebben we inmiddels drie jaar ervaring met EJB's, waardoor we er ook erg goed in zijn. Zouden we nu bijvoorbeeld overstappen op iets wat in feite hetzelfde doet dan zie ik daar op het moment geen voordeel van in. Ik heb de laatste tijd veel topics gelezen waarin Spring in naar voren kwam met alle voors en tegens en dat heeft mij nog niet overtuigt in de voordelen ervan. Mischien dat die er wel zijn maar we hebben er op het moment geen belang bij.

[Alarmnummer]

Ok. laten we even on topic blijven

Afgezien van de validatie, had je het zelf nog ergens voor in gedachten? Alle projecten die op dit moment door XDoclet gedaan worden, kunnen zometeen ook perfect vertaald worden naar de annotatie syntax. Aangezien het erg (misschien wel te) lang heeft geduurt dat java met metadata aan kwam zetten, zijn er oplossingen bedacht om annotaties toe te voegen en dat kan dus met XDoclet.. via je javadoc kan je attributes simuleren. Dus bv ook je hibernate stuff... of je deployment descriptors

[edit]
Annotaties/Metadata/Attributes zijn imho de taafeature van 1.5.. Generics is fijn... forloop is leuk.. (de rest kan om mij gestolen worden), maar Metadata is wel de meest waardevolle feature..

[ Voor 17% gewijzigd door Alarmnummer op 16-03-2005 23:37 ]

[ronaldmathies]

Mwoa, onderschat autoboxing niet, het is in basis niet veel bijzonder maar het scheelt je een hoop tiep werk. Generics vindt ik ook erg handig met name omdat het compile time checks geeft. En de enums bieden zeker veel mogelijkheden (je zal het niet veel gebruiken maar het zijn wel erg handige dingen). De printf functionaliteit heb ik altijd al gemist in Java, eigenlijk ook nooit begrepen waarom het er niet meteen in zat, deze functionaliteit zit er al sinds jaar en dag in C++. De variable arguments vindt ik ook handig, zal niet snel gebruikt worden maar het kan je een hoop code schelen.

XDoclet gaat volgens mij ook over op Annotations. Het nadeel van XDoclet vindt ik is dat het vaak achterloopt op de specificaties. Waardoor het langer duurt voordat je de volledige potentie kan gebruiken. Je kan wel merge files creëren maar in bepaalde situaties werkt dit ook niet meer.

Daarnaast is het hele XDoclet verhaal redelijk basic, speciale functionaliteit van JBoss is er niet in op te nemen waardoor XDoclet al snel afvalt. Voor ons laatste project bijvoorbeeld hebben we XDoclet alleen nog voor JSP/Taglib en Struts gedaan. Maar voor de EJB laag niet meer, dit gaf teveel problemen.

Dat software als Hibernate, Spring, EJB, XDoclet, Javadoc gebruik gaan maken van Annotations lijkt me niets meer dan logisch. Ik heb alleen het gevoel dat het op het moment nog erg weinig gebruikt word (en dan heb ik het niet over de net genoemde producten want dat duurt gewoon langer), maar met name door ontwikkelaars zoals ik die gewoon aan producten werkt.

[Verwijderd]

Ik gebruik Annonations nu voor zelf gemaakt validatie frameworkje. Je duidt aan (lees: je voegt een annonation toe) aan de methode die jij wilt aanduiden als "grafisch inzetbaar".
Voorbeeld: je heb een validatieklasse met regex. Aan de methode setRegEx voeg je een annotation aan toe. Deze kan dan worden uitgelezen door een gui klasse om dynamisch een veldje te creëren om dit aan te passen.

Generics kan je gebruiken om een typed collection terug te geven! Zeer handig!

[Alarmnummer]

ronaldmathies schreef op woensdag 16 maart 2005 @ 23:51:
Mwoa, onderschat autoboxing niet, het is in basis niet veel bijzonder maar het scheelt je een hoop tiep werk. Generics vindt ik ook erg handig met name omdat het compile time checks geeft. En de enums bieden zeker veel mogelijkheden (je zal het niet veel gebruiken maar het zijn wel erg handige dingen).

Tja.. ik heb liever class met een aantal instanties ervan omdat je toch vaak wat extra`s wilt.

De printf functionaliteit heb ik altijd al gemist in Java, eigenlijk ook nooit begrepen waarom het er niet meteen in zat, deze functionaliteit zit er al sinds jaar en dag in C++. De variable arguments vindt ik ook handig, zal niet snel gebruikt worden maar het kan je een hoop code schelen.

Die was ik helemaal vergeten... dat is idd erg handig.

Ik vind vooral de static import en autoboxing/unboxing erg onduidelijk (vooral bij static imports zit je zo van.. hmm.. waar komt deze methode vandaan). Bij sommige dingen is het wel duidelijk, sin,max etc... maar ik heb zelf wel eens lopen zoeken...

Maar wat ik duidelijk wou maken is dat annotations en generics in mindere mate, een bepaalde invloed uitoefenen op ontwerp dat tot op een veel hoger nivo merkbaar is dan die andere features. Daarom vind ik ze persoonlijk veel belangrijker. Varargs, autoboxing zijn handigheidjes, meer niet.. generics en annotations zijn veel meer dan handigheidjes.

Dat software als Hibernate, Spring, EJB, XDoclet, Javadoc gebruik gaan maken van Annotations lijkt me niets meer dan logisch. Ik heb alleen het gevoel dat het op het moment nog erg weinig gebruikt word (en dan heb ik het niet over de net genoemde producten want dat duurt gewoon langer), maar met name door ontwikkelaars zoals ik die gewoon aan producten werkt.

Dat is zo. Maar vergeet niet dat veel bedrijven pas erg laat over gaan stappen op 1.5.

[ Voor 11% gewijzigd door Alarmnummer op 17-03-2005 08:13 ]

[ronaldmathies]

Alarmnummer schreef op donderdag 17 maart 2005 @ 07:55:
Tja.. ik heb liever class met een aantal instanties ervan omdat je toch vaak wat extra`s wilt.
[...]

Dit is wat ik geprobreerd heb met enums, en daaruit concludeer ik dat het nog redelijk flexibel is.

code:

public enum MyEnum {
    
    Januari(30),
    Februari(28),
    Maart(30),
    April(31),
    Mei(30),
    Juni(31),
    Juli(30),
    Augustus(31),
    September(30),
    Oktober(31) {
        public boolean myBirthDay() {
            return true;
        }
    },
    November(30),
    December(31);
    
    private int days;
    
    MyEnum(int days) {
        this.days = days;
    }

    
    public boolean myBirthDay() {
        return false;
    }
    
    public int getDays() {
        return days;
    }
    
}

Ik vind vooral de static import en autoboxing/unboxing erg onduidelijk (vooral bij static imports zit je zo van.. hmm.. waar komt deze methode vandaan). Bij sommige dingen is het wel duidelijk, sin,max etc... maar ik heb zelf wel eens lopen zoeken...

De static import kan naar mijn idee inderdaad erg onduidelijk zijn, het is denk ik ook meer bedoeld als je een bepaalde static veel gaat gebruiken. Dat autoboxing/unboxing vindt ik persoonlijk niet onduidelijk. Het is ook meer dat men gewend is om bijvoorbeeld de Integer.valueOf e.d. te gebruiken.

Maar wat ik duidelijk wou maken is dat annotations en generics in mindere mate, een bepaalde invloed uitoefenen op ontwerp dat tot op een veel hoger nivo merkbaar is dan die andere features. Daarom vind ik ze persoonlijk veel belangrijker. Varargs, autoboxing zijn handigheidjes, meer niet.. generics en annotations zijn veel meer dan handigheidjes.

Helemaal mee eens.

Dat is zo. Maar vergeet niet dat veel bedrijven pas erg laat over gaan stappen op 1.5.

Wat ik er meer mee bedoelde was dat XDoclet wel de basale functionaliteit ondersteund maar als je wat dieper wilt gaan dan gaat het vaak niet meer, daarnaast zijn de wat ongebruikelijke dingen in XDoclet niet altijd goed uitgewerkt waardoor je problemen krijgt. Binnen de JSP/Struts/Taglib gaat het allemaal wel goed maar op het gebied van EJB's schiet het gewoon te kort.

Zolang je niks moeilijks wilt doen met EJB's is het geen probleem maar verwacht niet dat je vendor specifieke functionaliteit aan zal treffen die verder gaan dan het minimale (JBoss wordt bijvoorbeeld wel ondersteund in XDoclet maar load-groups en read strategy's weer niet, en dat is gewoon jammer), en dat maakt XDoclet voor ons op het gebied van EJB's meestal onbruikbaar.

[ronaldmathies]

Verwijderd schreef op donderdag 17 maart 2005 @ 00:48:
Ik gebruik Annonations nu voor zelf gemaakt validatie frameworkje.

Op de Sun site staat nu een heel mooi stukje over validatie m.b.v. Annotations, daarnaast leveren ze ook nog eens een vrij uitgebreide voorbeeld erbij.

http://java.sun.com/devel...straints/annotations.html