Miért rossz az @Annotáció?

A JPA fos a natív Hibernate-hez képest :)
Sok mindenre jó a Hibernate, a 2nd level cache-el egészen szépen lehet objektum-orientáltan dolgozni vele, persze nem mindig érdemes használni: nem szabad mindent szögnek nézni.

Szerintem a Hibernate-tel a problémák azok, hogy kissé heavyweight, nem könnyű keverni más módszerekkel, illetve sok fejlesztő baszik elolvasni a dokumentációt aztán csodálkoznak hogy miért ilyen rohadt lassú, meg szivatják magukat a rosszul beállított cascade-al.

Bevallom, a videot nem neztem meg, csak a cikkeket olvastam el, amiket linkeltel.
Viszont nekem az jon le azokbol, hogy mivel a cikkiro(k) latta(k) kozelrol a springet, valamint egyeb libek eroszakolt annotaciohasznalatat, ezert az annotacio, mint nyelvi elem, "rossz", es nem szabadna hasznalni.
Ezzel szemben az en velemenyem az, hogy az annotaciok hasznalatanak megvan a helye es modja, es baromi sok problemara jo megoldast nyujtanak.

Azzal az allitassal is vitatkoznek, hogy az OOP programozo legjobb fegyvere object letrehozasra a new operator. Egyreszt factoryk builderek is vannak a vilagon. Masreszt a program mukodesenek nem resze az objektumgrafom kvazi bootstrapje; a business objektumaimat termeszetesen szivesen letrehozom new-val. Tovabb az sem resze a programom speckojanak, hogy technikailag hogyan hozok letre adatbaziskapcsolatot (poolozom vagy sem?), melyik servicem melyik tavoli servicet proxyzza, milyen mediatype-ot general az endpointom, stb. Ez mind nem resze az uzleti specifikaciojanak. Akkor miert is kellene kitalalnom es implementalnom mindezt? Miert kell kodot irnom hozza? Meghozza nem is keveset. Inkabb annotalok ha valaszthatok. Es ha autokereskedesnek irok szoftvert vagy jegyertekesitonek, akkor miben is fog kulonbozni a 2 esetben a fenti technikai resz? Kb semmiben? Az en implementaciom garantaltan bugosabb lesz, mint amit a springes fiuk kitalaltak. Vagy a JAX-RS kontenerimplementaciok.

Szoval igen, full control on object creation, no magic behind the scenes, composability, meg kiskutya pocse, de ennek mind ara van. Es szerintem nem kisebb teher a sajat "okos" kododat megerteni egy juniornak vagy neked karbantartani, mint a springgel szopni mondjuk adott esetben. Vagy annotaciokkal es EE kontenerekkel.
Ezek mind csak egy-egy uj absztrakcios szint, amik valami miatt elkeszultek. Amikor okos emberek 100adszorra csinaltak meg ugyanazt, csak a business logika volt mas, akkor irtak ra egy frameworkot. Amit egyreszt tudni kell hasznalni, masreszt pedig akkor kell hasznalni, ha illeszkedik a te problemadra.

Ja, bocs, ezt néztem:
https://www.yegor256.com/2014/12/01/orm-offensive-anti-pattern.html

final class PgPosts implements Posts {
  private final Source dbase;
  public PgPosts(DataSource data) {
    this.dbase = data;
  }
  public Iterable<Post> iterate() {
    return new JdbcSession(this.dbase)
      .sql("SELECT id FROM post")
      .select(
        new ListOutcome<Post>(
          new ListOutcome.Mapping<Post>() {
            @Override
            public Post map(final ResultSet rset) {
              return new PgPost(
                this.dbase,
                rset.getInt(1)
              );
            }
          }
        )
      );
  }
  public Post add(Date date, String title) {
    return new PgPost(
      this.dbase,
      new JdbcSession(this.dbase)
        .sql("INSERT INTO post (date, title) VALUES (?, ?)")
        .set(new Utc(date))
        .set(title)
        .insert(new SingleOutcome<Integer>(Integer.class))
    );
  }
}