Hozzon létre egy egyéni automatikus konfigurációt a tavaszi indítással

1. Áttekintés

Egyszerűen fogalmazva: a Spring Boot automatikus konfigurációja lehetővé teszi a Spring alkalmazás automatikus konfigurálását az osztályúton lévő függőségek alapján.

Ez gyorsabbá és könnyebbé teheti a fejlesztést azáltal, hogy nem szükséges meghatározni bizonyos babokat, amelyek az automatikus konfigurációs osztályokba tartoznak.

A következő részben megnézzük egyedi Spring Boot automatikus konfigurációnk létrehozása.

2. Maven-függőségek

Kezdjük a szükséges függőségekkel:

 org.springframework.boot spring-boot-starter-data-jpa 2.2.2. NYOMTATÁS mysql mysql-connector-java 8.0.19 

A spring-boot-starter-data-jpa és a mysql-connector-java legújabb verziói letölthetők a Maven Centralról.

3. Egyéni automatikus konfiguráció létrehozása

Egyéni automatikus konfiguráció létrehozásához létre kell hoznunk egy osztályt, amelynek megjegyzései: @ Konfiguráció és regisztrálja.

Hozzunk létre egy egyedi konfigurációt a MySQL adatforrás:

@Configuration nyilvános osztály MySQLAutoconfiguration {// ...}

A következő kötelező lépés az osztály automatikus konfigurációs jelöltként történő regisztrálása, az osztály nevének hozzáadásával a kulcs alá org.springframework.boot.autoconfigure.EnableAutoConfiguration a standard fájlban erőforrások / META-INF / tavasz.gyárak:

org.springframework.boot.autoconfigure.EnableAutoConfiguration = \ com.baeldung.autoconfiguration.MySQLAutoconfiguration

Ha azt akarjuk, hogy az automatikus konfigurációs osztály elsőbbséget élvezzen más automatikus konfigurációs jelöltekkel szemben, hozzáadhatjuk a @AutoConfigureOrder (Rendelt.HIGHEST_PRECEDENCE) annotáció.

Az automatikus konfigurálást osztályokkal és babokkal jelölték, amelyek @Feltételes megjegyzéseket, hogy az automatikus konfiguráció vagy annak egyes részei kicserélhetők legyenek.

Vegye figyelembe, hogy az automatikus konfiguráció csak akkor érvényes, ha az alkalmazásban nincs meghatározva az automatikusan konfigurált bab. Ha definiálja a babot, akkor az alapértelmezett felül lesz írva.

3.1. Osztályfeltételek

Az osztályfeltételek lehetővé teszik adja meg, hogy egy konfigurációs komponens bekerüljön, ha egy meghatározott osztály van jelen használni a @ConditionalOnClass kommentár, vagy ha egy osztály hiányzik használni a @ConditionalOnMissingClass annotáció.

Pontosítsuk, hogy a mi MySQLConfiguration csak akkor töltődik be, ha az osztály Adatforrás jelen van, ebben az esetben feltételezhetjük, hogy az alkalmazás adatbázist fog használni:

@Configuration @ConditionalOnClass (DataSource.class) nyilvános osztály MySQLAutoconfiguration {// ...}

3.2. Babfeltételek

Ha akarjuk csak akkor tartalmazhat babot, ha egy meghatározott bab van jelen vagy sem, használhatjuk a @ConditionalOnBean és @ConditionalOnMissingBean annotációk.

Ennek példájául adjunk hozzá egy entitásManagerFactory konfigurációs osztályunkba, és adja meg, hogy ezt a babot csak akkor akarjuk létrehozni, ha egy babot hívunk adatforrás jelen van, és ha egy babot hívnak entitásManagerFactory még nincs meghatározva:

@Bean @ConditionalOnBean (név = "dataSource") @ConditionalOnMissingBean nyilvános LocalContainerEntityManagerFactoryBean entitásManagerFactory () {LocalContainerEntityManagerFactoryBean em = új LocalContainerEntityManagerFactoryBean (); em.setDataSource (dataSource ()); em.setPackagesToScan ("com.baeldung.autoconfiguration.example"); em.setJpaVendorAdapter (új HibernateJpaVendorAdapter ()); if (továbbiProperties ()! = null) {em.setJpaProperties (additionalProperties ()); } return em; }

Konfiguráljuk a tranzakciókezelő bab, amelyet csak akkor töltenek be, ha egy típusú bab JpaTransactionManager még nincs meghatározva:

@Bean @ConditionalOnMissingBean (type = "JpaTransactionManager") JpaTransactionManager tranzakciókezelő (EntityManagerFactory entitásManagerFactory) {JpaTransactionManager tranzakciókezelő = új JpaTransactionManager (); tranzakcióManager.setEntityManagerFactory (entitásManagerFactory); visszatérési tranzakcióManager; }

3.3. Tulajdoni feltételek

A @ConditionalOnProperty annotáció szokott adja meg, hogy egy konfiguráció betöltődik-e a Spring Environment tulajdonság jelenléte és értéke alapján.

Először adjunk hozzá egy tulajdonságforrás fájlt a konfigurációnkhoz, amely meghatározza, hogy a tulajdonságok honnan lesznek olvashatók:

@PropertySource ("classpath: mysql.properties") nyilvános osztály MySQLAutoconfiguration {// ...}

Beállíthatjuk a főt Adatforrás komponens, amellyel olyan kapcsolatokat lehet létrehozni az adatbázissal, hogy csak akkor töltse be, ha egy tulajdonság meghívásra kerül usemysql jelen van.

Használhatjuk az attribútumot havingValue hogy meghatározzuk a usemysql tulajdonság, amelyet meg kell egyezni.

Határozzuk meg a adatforrás nevű helyi adatbázishoz csatlakozó alapértelmezett értékekkel myDb ha a usemysql tulajdonság beállítása helyi:

@Bean @ConditionalOnProperty (név = "usemysql", havingValue = "helyi") @ConditionalOnMissingBean nyilvános DataSource dataSource () {DriverManagerDataSource dataSource = új DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / myDb? createDatabaseIfNotExist = true"); dataSource.setUsername ("mysqluser"); dataSource.setPassword ("mysqlpass"); return dataSource; }

Ha a usemysql tulajdonság értéke egyedi, a adatforrás A bab konfigurálása az adatbázis URL-jének, felhasználójának és jelszavának egyedi tulajdonságainak használatával történik:

@Bean (név = "dataSource") @ConditionalOnProperty (név = "usemysql", havingValue = "custom") @ConditionalOnMissingBean nyilvános DataSource dataSource2 () {DriverManagerDataSource dataSource = új DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl (env.getProperty ("mysql.url")); dataSource.setUsername (env.getProperty ("mysql.user")! = null? env.getProperty ("mysql.user"): ""); dataSource.setPassword (env.getProperty ("mysql.pass")! = null? env.getProperty ("mysql.pass"): ""); return dataSource; }

A mysql.tulajdonságok fájl tartalmazza a usemysql ingatlan:

usemysql = helyi

Ha egy alkalmazás, amely a MySQLAutokonfiguráció felül akarja írni az alapértelmezett tulajdonságokat, csak annyit kell tennie, hogy különböző értékeket ad hozzá a mysql.url, mysql.user és mysql.pass tulajdonságai és a usemysql = egyedi sor a mysql.tulajdonságok fájl.

3.4. Erőforrás-feltételek

A @ConditionalOnResource annotáció azt jelenti, hogy a A konfiguráció csak akkor töltődik be, ha egy adott erőforrás van.

Határozzuk meg az úgynevezett metódust továbbiTulajdonságok () hogy visszatér a Tulajdonságok a Hibernate-specifikus tulajdonságokat tartalmazó objektum, amelyet a entitásManagerFactory bab, csak akkor, ha az erőforrás fájl mysql.tulajdonságok jelen van:

@ConditionalOnResource (resources = "classpath: mysql.properties") @Conditional (HibernateCondition.class) Properties additionalProperties () {Properties hibernateProperties = new Properties (); hibernateProperties.setProperty ("hibernate.hbm2ddl.auto", env.getProperty ("mysql-hibernate.hbm2ddl.auto"); hibernateProperties.setProperty ("hibernate.dialect", env.getProperty ("mysql-hibernate.dialect")); hibernateProperties.setProperty ("hibernate.show_sql", env.getProperty ("mysql-hibernate.show_sql")! = null? env.getProperty ("mysql-hibernate.show_sql"): "hamis"); return hibernateProperties; }

Hozzáadhatjuk a hibernált állapot specifikus tulajdonságait a mysql.tulajdonságok fájl:

mysql-hibernate.dialect = org.hibernate.dialect.MySQLDialect mysql-hibernate.show_sql = true mysql-hibernate.hbm2ddl.auto = create-drop

3.5. Egyedi feltételek

Ha nem akarjuk használni a Spring Boot egyik rendelkezésre álló feltételét, akkor azt is használhatjuk meghatározza az egyéni feltételeket a SpringBootCondition osztály és felülírja a getMatchOutcome () módszer.

Hozzunk létre egy nevű feltételt Hibernált állapot a mi továbbiTulajdonságok () módszer, amely ellenőrzi, hogy a HibernateEntityManager osztály az osztályúton van:

a statikus osztály HibernateCondition kiterjeszti a SpringBootCondition {private static String [] CLASS_NAMES = {"org.hibernate.ejb.HibernateEntityManager", "org.hibernate.jpa.HibernateEntityManager"}; @Orride public conditionOutcome getMatchOutcome (ConditionContext context, AnnotatedTypeMetadata metadata) {ConditionMessage.Builder message = ConditionMessage.forCondition ("Hibernate"); return Arrays.stream (CLASS_NAMES) .filter (className -> ClassUtils.isPresent (className, context.getClassLoader ())) .map (className -> ConditionOutcome .match (message.found ("class") .items (Style.NORMAL) , className))) .findAny () .orElseGet (() -> ConditionOutcome .noMatch (message.didNotFind ("class", "class") .items (Style.NORMAL, Arrays.asList (CLASS_NAMES)))); }}

Ezután hozzáadhatjuk a feltételt a további tulajdonságok () módszer:

@Conditional (HibernateCondition.class) Properties additionalProperties () {// ...}

3.6. Alkalmazási feltételek

Azt is megtehetjük adja meg, hogy a konfiguráció csak webkontextuson belül vagy kívül tölthető be, a @ConditionalOnWebApplication vagy @ConditionalOnNotWebApplication annotáció.

4. Az automatikus konfiguráció tesztelése

Készítsünk egy nagyon egyszerű példát az automatikus konfiguráció tesztelésére. Létrehozunk egy entitásosztályt MyUser, és a MyUserRepository felület a Spring Data segítségével:

@Entity public class MyUser {@Id private String e-mail; // szabványos kivitelező, mérőeszközök, beállítók}
nyilvános felület A MyUserRepository kiterjeszti a JpaRepository {}

Az automatikus konfigurálás engedélyezéséhez használhatjuk a következők egyikét @SpringBootApplication vagy @EnableAutoConfiguration kommentárok:

@SpringBootApplication public class AutoconfigurationApplication {public static void main (String [] args) {SpringApplication.run (AutoconfigurationApplication.class, args); }}

Ezután írjunk egy JUnit teszt, amely megment a MyUser entitás:

@RunWith (SpringJUnit4ClassRunner.class) @SpringBootTest (osztályok = AutoconfigurationApplication.class) @EnableJpaRepositories (basePackages = {"com.baeldung.autoconfiguration.example"}) nyilvános osztály AutoconfigurationTest {@Autorepository Saját felhasználó @Test public void whenSaveUser_thenOk () {MyUser user = new MyUser ("[email protected]"); userRepository.save (felhasználó); }}

Mivel nem definiáltuk a sajátunkat Adatforrás konfigurációhoz, az alkalmazás az általunk létrehozott automatikus konfigurációt fogja használni a MySQL nevű adatbázis myDb.

A kapcsolati karakterlánc tartalmazza a createDatabaseIfNotExist = true tulajdonság, ezért az adatbázisnak nem kell léteznie. A felhasználó azonban mysqluser vagy a mysql.user ha van, akkor létre kell hozni.

Az alkalmazásnaplóban ellenőrizhetjük, hogy a MySQL adatforrást használunk:

web - 2017-04-12 00: 01: 33,956 [main] INFO o.s.j.d.DriverManagerDataSource - Betöltött JDBC illesztőprogram: com.mysql.cj.jdbc.Driver

5. Az automatikus konfigurációs osztályok letiltása

Ha akarnánk zárja ki az automatikus konfiguráció betöltését, hozzátehetnénk a @EnableAutoConfiguration annotáció azzal kizárni vagy kizárNév attribútum egy konfigurációs osztályhoz:

@Configuration @EnableAutoConfiguration (kizárva = {MySQLAutoconfiguration.class}) nyilvános osztály AutoconfigurationApplication {// ...}

Egy másik lehetőség az automatikus konfigurációk letiltására a tavasz.autokonfigurálás.kizár ingatlan:

spring.autoconfigure.exclude = com.baeldung.autoconfiguration.MySQLAutoconfiguration

6. Következtetések

Ebben az oktatóanyagban bemutattuk, hogyan hozhat létre egyéni Spring Boot automatikus konfigurációt. A példa teljes forráskódja megtalálható a GitHub oldalon.

A JUnit teszt a. Segítségével futtatható autokonfiguráció profil: mvn clean install -Pautoconfiguration.