Wie greift man in Grails auf zwei Datenbanken zu?

Question

Grails macht es in seiner Datei „DataSources.groovy“ sehr einfach, Datenquellen für verschiedene Umgebungen (Entwicklung, Test, Produktion) zu konfigurieren, aber es scheint keine Möglichkeit zu geben, mehrere Datenquellen in einer Umgebung zu konfigurieren.Was kann ich tun, wenn ich über dieselbe Grails-Anwendung auf mehrere Datenbanken zugreifen muss?

Answer 1

Es gibt jetzt ein Grails-Plugin, das die Verwendung mehrerer Datenquellen direkt mit der GORM-Ebene von Grails ermöglicht:http://burtbeckwith.com/blog/?p=70

Answer 2

Das Verbinden verschiedener Datenbanken in verschiedenen Domänenklassen ist in Grails 2.x.x sehr einfach.

Zum Beispiel

development {
    dataSource {//DEFAULT data source
      .
      .
    }
dataSource_admin { //Convention is dataSource_name
        url = "//db url"
        driverClassName = "oracle.jdbc.driver.OracleDriver" 
        username = "test"
        password = 'test123'
    }
dataSource_users {

    }
}

Sie können beliebige Datenquellen in Ihren Domänenklassen verwenden

class Role{
   static mapping = {
      datasource 'users'
   }
}

 class Product{
    static mapping = {
      datasource 'admin'
   }
 }

Weitere Einzelheiten finden Sie hier

Answer 3

Wenn Sie Grails 2.0 oder höher verwenden, ist das Plugin nicht erforderlich, es wird nativ unterstützt.

http://www.grails.org/doc/latest/guide/single.html#multipleDatasources

Answer 4

Grails 2.0 kann mehrere Datenquellen ohne Plugin verarbeiten:

Beispiel mit einer anderen Datenquelle für die Umgebungen dev(h2 dataSource) und test(mysql dataSource_mysql):

DataSource.groovy:

dataSource {
    pooled = true
    driverClassName = "org.h2.Driver"
    username = "sa"
    password = ""
}
dataSource_mysql {
    dialect = org.hibernate.dialect.MySQLInnoDBDialect
    driverClassName = 'com.mysql.jdbc.Driver'
    username = "user"
    password = "pass"
    url = "jdbc:mysql://mysqldb.com/DBNAME"
}
hibernate {
    cache.use_second_level_cache = true
    cache.use_query_cache = false
    cache.region.factory_class = 'net.sf.ehcache.hibernate.EhCacheRegionFactory'
}

// environment specific settings
environments {
    development {
        dataSource {
            configClass = HibernateFilterDomainConfiguration.class
            dbCreate = "update" // one of 'create', 'create-drop', 'update', 'validate', ''
            url = "jdbc:h2:file:../devDb;MVCC=TRUE"
            sqlLogging = true
        }
    }
    test {
        dataSource_mysql {
            configClass = HibernateFilterDomainConfiguration.class
            dbCreate = "create" // one of 'create', 'create-drop', 'update', 'validate', ''
            sqlLogging = true
        }
    }
    production {
        dataSource {
            dbCreate = "update"
            url = "jdbc:h2:prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000"
            pooled = true
            properties {
               maxActive = -1
               minEvictableIdleTimeMillis=1800000
               timeBetweenEvictionRunsMillis=1800000
               numTestsPerEvictionRun=3
               testOnBorrow=true
               testWhileIdle=true
               testOnReturn=true
               validationQuery="SELECT 1"
            }
        }
    }
}

Answer 5

Willst du das wirklich tun?Meiner Erfahrung nach ist hier das übliche Szenario:

1. Eine Anwendung verwaltet ihre eigenen Daten in ihrem eigenen Datenbankschema
2. Oft benötigt die Anwendung Daten aus anderen Quellen (zum Beispiel, damit Referenzdaten nicht kopiert und eingefügt werden).

Normalerweise hatte ich immer den Luxus, dass sich alle Schemata auf einer einzigen Datenbankinstanz befanden.Daher meine Bewerbung:

• hat nur eine Datenbankverbindung – nämlich zu dem Schema, das ihm gehört, und verfügt über Lese-/Schreibzugriff
• die anderen Anwendungen „exportieren“ ihre Daten über Ansichten
• Meine Anwendung hat Lesezugriff auf diese Ansichten und verfügt über ein Synonym für diese Ansicht, sodass sie lokal erscheint

Der Grund für die Verwendung von Ansichten liegt darin, dass die Anwendung die Daten verfügbar macht

1. weiß explizit, dass es exportiert wird und was exportiert wird
2. stellt die interne Struktur des Schemas nicht offen (wenn sich also die interne Struktur ändert, wissen die konsumierenden Apps nichts davon, solange die Ansicht korrekt ist)

Ich musste das eigentlich noch nicht mit einer Grails-Anwendung machen, aber der Ansatz sollte funktionieren.

Ein weiterer Ansatz zum anwendungsübergreifenden Teilen von Daten besteht darin, einen Webdienst zu erstellen, um die Daten verfügbar zu machen.Grails macht das einfach.

Ich hoffe, das hilft, aber dieser Ansatz ist möglicherweise nicht für alle Situationen anwendbar.

Answer 6

Der folgende Beitrag scheint die beste Informationsquelle zu diesem Thema zu sein:

So erhalten Sie Multi-DataSource in Grails

Es läuft darauf hinaus:

• Definieren Sie datasource1 in DevelopmentDataSource
• Definieren Sie datasource2 in resources.xml
• Schreiben Sie mithilfe von datasource2 ein DAO für CRUD der Domänenobjekte
• Listen Sie in hibernate.cfg.xml alle Domänenobjekte auf.

Nur die erste Datenquelle verfügt über dynamische Suchmethoden.

Wenn es sich um eine wirklich einfache Abfrage handelt und es Ihnen nichts ausmacht, nicht über die ORM-Funktionen zu verfügen, können Sie Groovy SQL oder die nativen SQL-Funktionen von Hibernate verwenden.