Vytvorte si vlastnú automatickú konfiguráciu pomocou Spring Boot

1. Prehľad

Jednoducho povedané, automatická konfigurácia Spring Boot predstavuje spôsob, ako automaticky nakonfigurovať jarnú aplikáciu na základe závislostí, ktoré sú prítomné v triede.

To môže umožniť rýchlejší a ľahší vývoj elimináciou potreby definovať určité fazule, ktoré sú zahrnuté v triedach automatickej konfigurácie.

V nasledujúcej časti sa pozrieme na vytváranie našej vlastnej automatickej konfigurácie Spring Boot.

2. Maven závislosti

Začnime závislosťami, ktoré potrebujeme:

 org.springframework.boot spring-boot-starter-data-jpa 2.2.2. RELEASE mysql mysql-connector-java 8.0.19 

Najnovšie verzie súborov spring-boot-starter-data-jpa a mysql-connector-java si môžete stiahnuť z Maven Central.

3. Vytvorenie vlastnej automatickej konfigurácie

Ak chcete vytvoriť vlastnú automatickú konfiguráciu, musíme vytvoriť triedu s poznámkami ako @ Konfigurácia a zaregistruj to.

Poďme vytvoriť vlastnú konfiguráciu pre MySQL dátový zdroj:

@ Konfigurácia verejnej triedy MySQLAutoconfiguration {// ...}

Ďalším povinným krokom je registrácia triedy ako kandidáta na automatickú konfiguráciu pridaním názvu triedy pod kľúč org.springframework.boot.autoconfigure.EnableAutoConfiguration v štandardnom spise resources / META-INF / spring.factories:

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

Ak chceme, aby mala naša trieda automatickej konfigurácie prednosť pred ostatnými kandidátmi na automatickú konfiguráciu, môžeme pridať @AutoConfigureOrder (objednané.HIGHEST_PRECEDENCE) anotácia.

Automatická konfigurácia je navrhnutá pomocou tried a fazúľ označených @ Podmienené anotácie, aby bolo možné nahradiť automatickú konfiguráciu alebo jej konkrétne časti.

Upozorňujeme, že automatická konfigurácia je účinná, iba ak v aplikácii nie sú definované automaticky nakonfigurované fazule. Ak definujete svoju fazuľu, predvolená bude prepísaná.

3.1. Podmienky triedy

Podmienky triedy nám to umožňujú určiť, že bude zahrnutá konfiguračná fazuľa, ak existuje zadaná trieda pomocou @ConditionalOnClass anotácia, alebo ak trieda absentuje pomocou @ConditionalOnMissingClass anotácia.

Upresnime, že náš MySQLConfiguration budú načítané iba v prípade, že trieda Dátový zdroj je prítomný, v takom prípade môžeme predpokladať, že aplikácia použije databázu:

@Configuration @ConditionalOnClass (DataSource.class) verejná trieda MySQLAutoconfiguration {// ...}

3.2. Podmienky fazule

Ak chceme zahrnúť fazuľu, iba ak je uvedená fazuľa prítomná alebo nie, môžeme použiť @ConditionalOnBean a @ConditionalOnMissingBean anotácie.

Na ilustráciu toho pridajme entityManagerFactory bean do našej konfiguračnej triedy a určíme, že chceme, aby sa tento bean vytvoril iba vtedy, ak sa bean volá dátový zdroj je prítomný a ak sa volá fazuľa entityManagerFactory ešte nie je definované:

@Bean @ConditionalOnBean (name = "dataSource") @ConditionalOnMissingBean public LocalContainerEntityManagerFactoryBean entityManagerFactory () {LocalContainerEntityManagerFactoryBean em = nový LocalContainerEntityManagerFactoryBean (); em.setDataSource (dataSource ()); em.setPackagesToScan ("com.baeldung.autoconfiguration.example"); em.setJpaVendorAdapter (nový HibernateJpaVendorAdapter ()); if (additionalProperties ()! = null) {em.setJpaProperties (additionalProperties ()); } vrátiť em; }

Nakonfigurujme tiež a transactionManager fazuľa, ktorá sa načíta iba ak je fazuľa typu JpaTransactionManager ešte nie je definované:

@Bean @ConditionalOnMissingBean (type = "JpaTransactionManager") JpaTransactionManager transactionManager (EntityManagerFactory entityManagerFactory) {JpaTransactionManager transactionManager = nový JpaTransactionManager (); transactionManager.setEntityManagerFactory (entityManagerFactory); return transactionManager; }

3.3. Majetkové podmienky

The @ConditionalOnProperty anotácia je zvyknutá na určiť, či sa konfigurácia načíta na základe prítomnosti a hodnoty vlastnosti jarného prostredia.

Najskôr pridajme zdrojový súbor vlastností pre našu konfiguráciu, ktorý určí, odkiaľ sa budú vlastnosti čítať:

@PropertySource ("classpath: mysql.properties") verejná trieda MySQLAutoconfiguration {// ...}

Môžeme nakonfigurovať hlavné Dátový zdroj fazuľa, ktorá sa použije na vytvorenie pripojení k databáze takým spôsobom, že sa načíta, iba ak sa volá vlastnosť usemysql je prítomný.

Môžeme použiť atribút havingValue určiť určité hodnoty usemysql majetok, ktorý je potrebné spárovať.

Definujme dátový zdroj fazuľa s predvolenými hodnotami, ktoré sa pripájajú k lokálnej databáze s názvom myDb ak usemysql vlastnosť je nastavená na miestne:

@Bean @ConditionalOnProperty (name = "usemysql", havingValue = "local") @ConditionalOnMissingBean public DataSource dataSource () {DriverManagerDataSource dataSource = nový DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / myDb? createDatabaseIfNotExist = true"); dataSource.setUsername ("mysqluser"); dataSource.setPassword ("mysqlpass"); vrátiť dátový zdroj; }

Ak usemysql vlastnosť je nastavená na zvyk, the dátový zdroj bean sa nakonfiguruje pomocou hodnôt vlastných vlastností pre adresu URL databázy, používateľa a heslo:

@Bean (name = "dataSource") @ConditionalOnProperty (name = "usemysql", havingValue = "custom") @ConditionalOnMissingBean public DataSource dataSource2 () {DriverManagerDataSource dataSource = nový 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"): ""); vrátiť dátový zdroj; }

The mysql.properties súbor bude obsahovať usemysql nehnuteľnosť:

usemysql = miestne

Ak aplikácia, ktorá používa Automatická konfigurácia MySQLA chce prepísať predvolené vlastnosti, všetko, čo musí urobiť, je pridať rôzne hodnoty pre mysql.url, mysql.user a mysql.pass vlastnosti a usemysql = zvyk linka v mysql.properties spis.

3.4. Podmienky zdroja

Pridáva sa @ConditionalOnResource anotácia znamená, že konfigurácia sa načíta, iba ak je k dispozícii zadaný zdroj.

Definujme metódu s názvom additionalProperties () že vráti a Vlastnosti objekt obsahujúci vlastnosti špecifické pre režim dlhodobého spánku, ktorý má používať server entityManagerFactory fazuľa, iba ak je to zdrojový súbor mysql.properties je prítomný:

@ConditionalOnResource (resources = "classpath: mysql.properties") @Conditional (HibernateCondition.class) Vlastnosti additionalProperties () {Vlastnosti hibernateProperties = nové Vlastnosti (); 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"): "false"); vrátiť hibernateProperties; }

Môžeme pridať špecifické vlastnosti režimu dlhodobého spánku do mysql.properties spis:

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

3.5. Vlastné podmienky

Ak nechceme použiť niektorú z podmienok dostupných v Spring Boot, môžeme tiež definovať vlastné podmienky rozšírením SpringBootCondition triedy a prvoradý getMatchOutcome () metóda.

Vytvorme podmienku s názvom Podmienka hibernácie pre naše additionalProperties () metóda, ktorá overí, či a HibernateEntityManager trieda je prítomná v triede:

statická trieda HibernateCondition rozširuje SpringBootCondition {private static String [] CLASS_NAMES = {"org.hibernate.ejb.HibernateEntityManager", "org.hibernate.jpa.HibernateEntityManager"}; @Override public ConditionOutcome getMatchOutcome (kontext ConditionContext, metadáta AnnotatedTypeMetadata) {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", "classes") .items (Style.NORMAL, Arrays.asList (CLASS_NAMES)))); }}

Potom môžeme podmienku pridať do additionalProperties () metóda:

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

3.6. Podmienky žiadosti

Môžeme tiež upresnite, že konfiguráciu je možné načítať iba vo vnútri / mimo webového kontextu, pridaním @ConditionalOnWebApplication alebo @ConditionalOnNotWebApplication anotácia.

4. Testovanie automatickej konfigurácie

Vytvorme si veľmi jednoduchý príklad na otestovanie našej automatickej konfigurácie. Vytvoríme triedu entít s názvom MyUsera MyUserRepository rozhranie pomocou Spring Data:

@Entity public class MyUser {@Id private String email; // štandardný konštruktor, getre, setre}
verejné rozhranie MyUserRepository rozširuje JpaRepository {}

Na povolenie automatickej konfigurácie môžeme použiť jednu z @SpringBootApplication alebo @EnableAutoConfiguration anotácie:

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

Ďalej napíšeme a JUnit test, ktorý zachráni a MyUser subjekt:

@RunWith (SpringJUnit4ClassRunner.class) @SpringBootTest (classes = AutoconfigurationApplication.class) @EnableJpaRepositories (basePackages = {"com.baeldung.autoconfiguration.example"}) verejná trieda AutoconfigurationTest {@Autowired private MyUser @Test public void whenSaveUser_thenOk () {MyUser user = new MyUser ("[email protected]"); userRepository.save (užívateľ); }}

Pretože sme nedefinovali svoje Dátový zdroj konfigurácia, aplikácia použije automatickú konfiguráciu, ktorú sme vytvorili na pripojenie k a MySQL databáza volaná myDb.

Pripojovací reťazec obsahuje createDatabaseIfNotExist = true vlastníctvo, takže databáza nemusí existovať. Avšak užívateľ mysqluser alebo ten, ktorý je uvedený v mysql.user majetok, ak je prítomný, je potrebné ho vytvoriť.

Môžeme skontrolovať denník aplikácií a zistiť, či MySQL používa sa zdroj údajov:

web - 2017-04-12 00: 01: 33 956 [hlavný] INFO o.s.j.d.DriverManagerDataSource - načítaný ovládač JDBC: com.mysql.cj.jdbc.Driver

5. Zakázanie tried automatickej konfigurácie

Keby sme chceli vylúčiť načítanie automatickej konfigurácie, mohli by sme pridať @EnableAutoConfiguration anotácia s vylúčiť alebo vylúčiťMeno atribút konfiguračnej triedy:

@Configuration @EnableAutoConfiguration (vylúčiť = {MySQLAutoconfiguration.class}) verejná trieda AutoconfigurationApplication {// ...}

Ďalšou možnosťou, ako zakázať konkrétne automatické konfigurácie, je nastavenie pružina.autokonfigurácia.vylúčiť nehnuteľnosť:

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

6. Závery

V tomto tutoriáli sme si ukázali, ako vytvoriť vlastnú automatickú konfiguráciu Spring Boot. Celý zdrojový kód príkladu nájdete na GitHub.

Test JUnit je možné spustiť pomocou autokonfigurácia profil: mvn clean install -Pautoconfiguration.