Frühling DAO gegen Frühling ORM gegen Frühling JDBC

Ich habe Datenzugriffstechnologien durchlaufen, die von Spring unterstützt werden, und festgestellt, dass mehrere Optionen erwähnt werden, und ich bin mir über den Unterschied zwischen diesen nicht sicher:

• Spring-DAO ( http://docs.spring.io/spring/docs/2.0.8/reference/dao.html )
• Spring-ORM ( http://docs.spring.io/spring/docs/3.0.x/spring-framework-reference/html/orm.html )
• Spring-JDBC ( http://docs.spring.io/spring/docs/3.0.x/spring-framework-reference/html/jdbc.html )

Soweit ich weiß, bietet Spring JDBC Vorlagen zum Reduzieren des Boilerplate-Codes für den Zugriff auf eine Datenbank auf einfache Weise - Sie schreiben Ihre eigenen SQL-Abfragen.

Spring-ORM bietet vereinfachte Vorlagen für den Zugriff auf Datenbanken über ORM-Technologien wie Hibernate, My (i) Batis usw.

Spring-DAO gemäß Spring-Website:

Die DAO-Unterstützung (Data Access Object) im Frühjahr soll die einheitliche Arbeit mit Datenzugriffstechnologien wie JDBC, Hibernate oder JDO vereinfachen

Ich bin mir ein bisschen klar über ORM vs JDBC, da sie auf verschiedene Arten des Zugriffs auf die Datenbank abzielen. Aber Spring-DAO ist einfach nur verwirrend!

Könnte jemand bitte klarstellen, was genau die Unterschiede zwischen diesen drei sind? Welches sollte in welchen Szenarien bevorzugt werden?

Es gibt auch ein anderes Projekt Spring-DATA( http://projects.spring.io/spring-data/ ). Ist es nun eine Art übergeordnetes Projekt für alle von Spring unterstützten Datenzugriffstechniker oder ist es nur ein neuer Name für Spring -DAO?

Hier finden Sie eine Einführung in jede der genannten Technologien.

Spring-DAO

Spring-DAO ist kein Federmodul im engeren Sinne, sondern Konventionen, die Sie dazu verpflichten sollten, DAO zu schreiben und sie gut zu schreiben. Daher bietet es weder Schnittstellen noch Implementierungen oder Vorlagen für den Zugriff auf Ihre Daten. Wenn Sie ein DAO schreiben, sollten Sie diese mit Anmerkungen versehen, @Repositorydamit Ausnahmen, die mit der zugrunde liegenden Technologie (JDBC, Hibernate, JPA usw.) verknüpft sind, konsistent in die richtige DataAccessExceptionUnterklasse übersetzt werden.

Angenommen, Sie verwenden jetzt den Ruhezustand und Ihre Service-Schicht wird abgefangen, HibernateExceptionum darauf zu reagieren. Wenn Sie zu JPA wechseln, sollten sich Ihre DAOs-Schnittstellen nicht ändern, und die Service-Schicht wird weiterhin mit HibernateExceptionabfangenden Blöcken kompiliert. Sie werden diese Blöcke jedoch niemals eingeben, da Ihre DAOs jetzt JPA auslösen PersistenceException. Bei Verwendung @Repositoryin Ihrem DAO werden die mit der zugrunde liegenden Technologie verknüpften Ausnahmen in Spring übersetzt DataAccessException. Ihre Service-Schicht fängt diese Ausnahmen ab. Wenn Sie sich entscheiden, die Persistenz-Technologie zu ändern, DataAccessExceptionswird immer noch derselbe Frühling ausgelöst, da der Frühling native Ausnahmen übersetzt hat.

Beachten Sie jedoch, dass dies aus folgenden Gründen nur eingeschränkt verwendet werden kann:

1. Sie sollten normalerweise keine Persistenzausnahmen abfangen, da der Anbieter die Transaktion möglicherweise zurückgesetzt hat (abhängig vom genauen Ausnahmesubtyp), und Sie sollten die Ausführung daher nicht mit einem alternativen Pfad fortsetzen.
2. Die Hierarchie der Ausnahmen ist in Ihrem Provider normalerweise umfangreicher als in Spring, und es gibt keine endgültige Zuordnung von einem Provider zum anderen. Sich darauf zu verlassen ist gefährlich. Dies ist jedoch eine gute Idee, um Ihre DAOs mit Anmerkungen zu versehen @Repository, da die Beans beim Scanvorgang automatisch hinzugefügt werden. Darüber hinaus kann Spring der Anmerkung weitere nützliche Funktionen hinzufügen.

Spring-JDBC

Spring-JDBC bietet die JdbcTemplate-Klasse, mit der Installationscode entfernt wird und Sie sich auf die SQL-Abfrage und -Parameter konzentrieren können. Sie müssen es nur mit a konfigurieren DataSourceund können dann Code wie folgt schreiben:

int nbRows = jdbcTemplate.queryForObject("select count(1) from person", Integer.class);

Person p = jdbcTemplate.queryForObject("select first, last from person where id=?", 
             rs -> new Person(rs.getString(1), rs.getString(2)), 
             134561351656L);

Spring-JDBC bietet auch einen JdbcDaoSupport, den Sie erweitern können, um Ihr DAO zu entwickeln. Grundsätzlich werden zwei Eigenschaften definiert: eine DataSource und eine JdbcTemplate, mit denen beide die DAO-Methoden implementieren können. Es bietet auch einen Ausnahmeübersetzer von SQL-Ausnahmen zu Spring DataAccessExceptions.

Wenn Sie planen, einfaches JDBC zu verwenden, ist dies das Modul, das Sie verwenden müssen.

Spring-ORM

Spring-ORM ist ein Dachmodul, das viele Persistenztechnologien abdeckt, nämlich JPA, JDO, Hibernate und iBatis. Für jede dieser Technologien bietet Spring Integrationsklassen an, sodass jede Technologie gemäß den Spring-Konfigurationsprinzipien verwendet werden kann und sich nahtlos in das Spring-Transaktionsmanagement integrieren lässt.

Für jede Technologie besteht die Konfiguration im Wesentlichen darin, eine DataSourceBohne in eine Art von SessionFactoryoder zu injizierenEntityManagerFactory usw. Bohne. Für reines JDBC sind solche Integrationsklassen (außer JdbcTemplate) nicht erforderlich, da JDBC nur auf einer DataSource basiert.

Wenn Sie ein ORM wie JPA oder Hibernate verwenden möchten, benötigen Sie nicht spring-jdbc, sondern nur dieses Modul.

Federdaten

Spring-Data ist ein Dachprojekt, das eine gemeinsame API bereitstellt, um zu definieren, wie allgemeiner auf Daten (DAO + -Anmerkungen) zugegriffen werden soll, wobei sowohl SQL- als auch NOSQL-Datenquellen abgedeckt werden.

Die ursprüngliche Idee besteht darin, eine Technologie bereitzustellen, mit der der Entwickler die Schnittstelle für ein DAO (Finder-Methoden) und die Entitätsklassen technologieunabhängig und nur basierend auf der Konfiguration (Anmerkungen zu DAOs & Entitäten + Federkonfiguration) schreibt xml- oder java-basiert), entscheidet über die Implementierungstechnologie, sei es JPA (SQL) oder Redis, Hadoop usw. (NOSQL).

Wenn Sie die durch spring definierten Namenskonventionen für die Finder-Methodennamen befolgen, müssen Sie in den einfachsten Fällen nicht einmal die Abfragezeichenfolgen angeben, die den Finder-Methoden entsprechen. In anderen Situationen müssen Sie die Abfragezeichenfolge in Anmerkungen zu den Finder-Methoden angeben.

Wenn der Anwendungskontext geladen wird, stellt spring Proxys für die DAO-Schnittstellen bereit, die den gesamten Boilerplate-Code für die Datenzugriffstechnologie enthalten, und ruft die konfigurierten Abfragen auf.

Spring-Data konzentriert sich auf Nicht-SQL-Technologien, bietet jedoch weiterhin ein Modul für JPA (die einzige SQL-Technologie).

Was kommt als nächstes

Wenn Sie das alles wissen, müssen Sie jetzt entscheiden, was Sie auswählen möchten. Die gute Nachricht hier ist, dass Sie keine endgültige Entscheidung für die Technologie treffen müssen. Hier liegt Spring Power tatsächlich: Als Entwickler konzentrieren Sie sich beim Schreiben von Code auf das Geschäft, und wenn Sie es gut machen, ist das Ändern der zugrunde liegenden Technologie ein Implementierungs- oder Konfigurationsdetail.

1. Definieren Sie ein Datenmodell mit POJO-Klassen für die Entitäten und rufen Sie Methoden ab, um die Entitätsattribute und die Beziehungen zu anderen Entitäten darzustellen. Sie müssen sicherlich die Entitätsklassen und -felder basierend auf der Technologie mit Anmerkungen versehen, aber für den Moment reichen POJOs aus, um damit zu beginnen. Konzentrieren Sie sich vorerst nur auf die Geschäftsanforderungen.
2. Definieren Sie Schnittstellen für Ihre DAOs. 1 DAO deckt genau 1 Entität ab, aber Sie benötigen sicherlich nicht für jede Entität ein DAO, da Sie in der Lage sein sollten, zusätzliche Entitäten durch Navigieren in den Beziehungen zu laden. Definieren Sie die Finder-Methoden nach strengen Namenskonventionen.
3. Auf dieser Grundlage kann eine andere Person mit der Arbeit an der Serviceschicht beginnen, mit Verspottungen für Ihre DAOs.
4. Sie lernen die verschiedenen Persistenztechnologien (SQL, No-SQL) kennen, um die beste Lösung für Ihre Anforderungen zu finden, und wählen eine davon aus. Auf dieser Grundlage kommentieren Sie die Entitäten und implementieren die DAOs (oder lassen sie von Spring für Sie implementieren, wenn Sie Spring-Daten verwenden).
5. Wenn sich die Geschäftsanforderungen ändern und Ihre Datenzugriffstechnologie nicht ausreicht, um sie zu unterstützen (z. B. Sie haben mit JDBC und einigen Entitäten begonnen, benötigen jetzt jedoch ein umfassenderes Datenmodell und JPA ist die bessere Wahl), müssen Sie die Implementierung ändern Fügen Sie von Ihren DAOs einige Anmerkungen zu Ihren Entitäten hinzu und ändern Sie die Federkonfiguration (fügen Sie eine EntityManagerFactory-Definition hinzu). Der Rest Ihres Geschäftscodes sollte keine anderen Auswirkungen Ihrer Änderung sehen.

Hinweis: Transaktionsmanagement

Spring bietet eine API für das Transaktionsmanagement. Wenn Sie Spring für den Datenzugriff verwenden möchten, sollten Sie Spring auch für das Transaktionsmanagement verwenden, da diese sehr gut zusammenpassen. Für jede von spring unterstützte Datenzugriffstechnologie gibt es einen passenden Transaktionsmanager für lokale Transaktionen, oder Sie können JTA auswählen, wenn Sie verteilte Transaktionen benötigen. Alle implementieren dieselbe API, sodass die Wahl der Technologie (erneut) nur eine Frage der Konfiguration ist, die ohne weitere Auswirkungen auf den Geschäftscode geändert werden kann.

Hinweis: Federdokumentation

Die von Ihnen erwähnten Links zur Spring-Dokumentation sind ziemlich alt. Hier ist die Dokumentation der neuesten Version (4.1.6, die alle Themen abdeckt):

• Einzelne HTML-Seite: http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/
• PDF: http://docs.spring.io/spring/docs/current/spring-framework-reference/pdf/spring-framework-reference.pdf

Spring-Daten sind nicht Teil des Spring-Frameworks. Es gibt ein allgemeines Modul, das Sie zuerst lesen sollten, um sich an die Prinzipien zu gewöhnen. Dokumentation finden Sie hier:

• Einzelne HTML-Seite: http://docs.spring.io/spring-data/data-commons/docs/1.9.2.RELEASE/reference/html/
• PDF: http://docs.spring.io/spring-data/data-commons/docs/1.9.2.RELEASE/reference/pdf/spring-data-commons-reference.pdf

Spring DAO ( D ata A ccess O bject): ist ein Objekt, das eine abstrakte Schnittstelle zu JDBC-Implementierungsframeworks bietet. Spring DAO ist ein allgemeines Konzept für den Zugriff auf JDBC und Hibernate, MyBatis, JPA, JDO mithilfe seiner einzelnen Supportklassen. Durch die Definition von Anmerkungen wird eine verallgemeinerte Ausnahmehierarchie @Repositorybereitgestellt. Diese Anmerkung definiert den Spring-Container für die SQL-Ausnahmeübersetzung von SQLExceptionin die strategieunabhängige DataAccessExceptionHierarchie der Datenzugriffsstrategie von Spring .

Das heißt, plattformspezifische Ausnahmen sind Fänge und werden dann als eine der nicht aktivierten Ausnahmen für den Datenzugriff von Spring erneut ausgelöst.

Spring JDBC : Für einfaches JDBC verwenden wir dieses Modul, das nur von DataSourceund Template-Klassen wie (Wraps ) abhängt JdbcTemplate, und um Querschnittsprobleme zu reduzieren. NamedParameterJdbcTemplateJdbcTemplateSimpleJdbcTemplate

public class EmployeeDao {  
private JdbcTemplate jdbcTemplate;  

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
    this.jdbcTemplate = jdbcTemplate;  
}  

public int saveEmployee(Employee e){  
    return jdbcTemplate.update(query);  
}  
public int updateEmployee(Employee e){  
    return jdbcTemplate.update(query);  
}  
public int deleteEmployee(Employee e){  
       return jdbcTemplate.update(query);  
}  

}  

und im Frühjahr XML:

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

Frühling JDBC bietet auch JdbcDaoSupport, NamedParameterJdbcDaoSupport, SimpleJdbcDaoSupport,, die Unterstützung (dh bequem ) Weg , um unsere eigene zu erweitern und zu entwickeln DAO abstrakte Schnittstelle wie folgt:

public interface EmployeeDao {

    public void saveEmployee(Employee emp);
}

public class EmployeeDaoImpl extends JdbcDaoSupport implements EmployeeDao{

    @Override
    public void saveEmployee(Employee emp) {

        Object[] inputs = new Object[] {emp.getName(), emp.getSalary(), emp.getDept()};
        getJdbcTemplate().update(query, inputs);
    }
}

und im Frühjahr XML:

<bean id="employeeDAO" class="EmployeeDaoImpl">
        <property name="dataSource" ref="dataSource" />
    </bean>

Spring ORM: Für ORM-Tools wie Hibernate, JPA, MyBatis ... lässt sich Spring problemlos integrieren, indem DataSourcefolgende Klassen und entsprechende DaoSupportKlassen injiziert werden.

• SessionFactory für den Ruhezustand
• EntityManagerFactory für JPA,
• SqlSessionFactory für MyBatis

Die spring-dao lib wurde in Version 2.0.8 (Januar 2008) gestoppt. Die Klassen in Spring-Dao wurden nach Spring-TX kopiert. Wenn Sie also eine Klasse benötigen, die Sie in spring-dao finden, fügen Sie stattdessen die Abhängigkeit zu spring-tx hinzu . ( Quelle .)

Sie erstellen eine Schnittstelle wie SomeObjectDaound erstellen dann verschiedene Implementierungen dieser Schnittstelle wie JdbcSomeObjectDao, HibernateSomeObjectDao. Dann werden Sie in Ihrer SomeObjectServiceKlasse an der SomeObjectDaoSchnittstelle arbeiten und dort eine der konkreten Implementierungen einfügen. Also jede Implementierung vonSomeObjectDao werden also die Details ausgeblendet, unabhängig davon, ob Sie JDBC oder ORM usw. verwenden.

Normalerweise lösen JDBC und verschiedene Implementierungen von ORM verschiedene Arten von Ausnahmen aus. Die DAO-Unterstützung von Spring kann diese verschiedenen technologiespezifischen Ausnahmen allgemeinen Spring DAO-Ausnahmen zuordnen. Sie sind also mehr von der eigentlichen Implementierung entkoppelt. Auch die DAO-Unterstützung von Spring bietet eine Reihe von abstrakten *DataSupportKlassen, die bei der DAO-Entwicklung noch mehr helfen. Neben der Implementierung Ihrer SomeObjectDaoSchnittstelle können Sie also eine der Spring- *DataSupportKlassen erweitern.

Als zusätzliche Info. Ich schlage vor, Sie verwenden Spring Data JPA. Verwenden von Anmerkungen wie: @Repository, @Service. Ich zeige Ihnen ein Beispiel:

@Repository("customerEntitlementsRepository")
public interface CustomerEntitlementsRepository extends CrudRepository<BbsExerul, BbsExerulPK> {

  @Query(value = "SELECT " + "CONTRACT_NUMBER, EXECUTIVE_NUMBER, " + "GROUP_VALUE, " + "CODE, "
      + "SUBCODE, " + "CURRENCY " + "FROM BBS_EXERUL " + "WHERE CONTRACT_NUMBER =:clientId AND "
      + "EXECUTIVE_NUMBER =:representativeId", nativeQuery = true)
  Collection<CustomerEntitlementsProjection> getFieldsExerul(@Param("clientId") String clientId,
      @Param("representativeId") String representativeId);

}

Wenn CustomerEntitlementsProjection eine Spring-Projektion ist, die mit Ihrer Entität oder Ihrem DTO-Pojo verknüpft ist.

@Projection(name = "customerEntitlementsProjection", types = { BbsExerul.class })
public interface CustomerEntitlementsProjection {

  String getContractNumber();

  String getExecutiveNumber();