Spring Boot Multiple Datasource

Je suis tout à fait nouveau au démarrage du spring et je voudrais créer une source de données multiple pour mon projet. Voici mon cas actuel J’ai deux packages pour l’entité pour plusieurs bases de données. Disons

com.test.entity.db.mysql ; for entities that belong to MySql com.test.entity.db.h2 ; for entities that belong to H2 Databases 

Donc, j’ai actuellement deux classes d’entités

UserMySql.java

 @Entity @Table(name="usermysql") public class UserMysql{ @Id @GeneratedValue public int id; public Ssortingng name; } 

UserH2.java

 @Entity @Table(name="userh2") public class Userh2 { @Id @GeneratedValue public int id; public Ssortingng name; } 

Je voudrais réaliser une configuration où, si je crée un utilisateur à partir de UserMySql, il sera enregistré dans la firebase database MySql et si je crée un utilisateur à partir de Userh2, il sera enregistré dans les bases de données H2. Donc, j’ai aussi deux DBConfig, disons MySqlDbConfig et H2DbConfig.

(com.test.model est un package dans lequel je vais mettre ma classe Repositories. Il sera défini ci-dessous)

MySqlDbConfig.java

 @Configuration @EnableJpaRepositories( basePackages="com.test.model", entityManagerFactoryRef = "mysqlEntityManager") public class MySqlDBConfig { @Bean @Primary @ConfigurationProperties(prefix="datasource.test.mysql") public DataSource mysqlDataSource(){ return DataSourceBuilder .create() .build(); } @Bean(name="mysqlEntityManager") public LocalContainerEntityManagerFactoryBean mySqlEntityManagerFactory( EntityManagerFactoryBuilder builder){ return builder.dataSource(mysqlDataSource()) .packages("com.test.entity.db.mysql") .build(); } } 

H2DbConfig.java

 @Configuration @EnableJpaRepositories( entityManagerFactoryRef = "h2EntityManager") public class H2DbConfig { @Bean @ConfigurationProperties(prefix="datasource.test.h2") public DataSource h2DataSource(){ return DataSourceBuilder .create() .driverClassName("org.h2.Driver") .build(); } @Bean(name="h2EntityManager") public LocalContainerEntityManagerFactoryBean h2EntityManagerFactory( EntityManagerFactoryBuilder builder){ return builder.dataSource(h2DataSource()) .packages("com.test.entity.db.h2") .build(); } } 

Mon fichier application.properties

 #DataSource settings for mysql datasource.test.mysql.jdbcUrl = jdbc:mysql://127.0.0.1:3306/test datasource.test.mysql.username = root datasource.test.mysql.password = root datasource.test.mysql.driverClassName = com.mysql.jdbc.Driver #DataSource settings for H2 datasource.test.h2.jdbcUrl = jdbc:h2:~/test datasource.test.h2.username = sa # DataSource settings: set here configurations for the database connection spring.datasource.url = jdbc:mysql://127.0.0.1:3306/test spring.datasource.username = root spring.datasource.password = root spring.datasource.driverClassName = com.mysql.jdbc.Driver spring.datasource.validation-query=SELECT 1 # Specify the DBMS spring.jpa.database = MYSQL # Show or not log for each sql query spring.jpa.show-sql = true # Hibernate settings are prefixed with spring.jpa.hibernate.* spring.jpa.hibernate.ddl-auto = update spring.jpa.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect spring.jpa.hibernate.naming_strategy = org.hibernate.cfg.ImprovedNamingStrategy spring.jpa.hibernate.show_sql = true spring.jpa.hibernate.format_sql = true server.port=8080 endpoints.shutdown.enabled=false 

Et puis pour crud j’ai UserMySqlDao et UserH2Dao

UserMySqlDao.java

 @Transactional @Repository public interface UserMysqlDao extends CrudRepository{ public UserMysql findByName(Ssortingng name); } 

UserH2Dao.java

 @Transactional @Repositories public interface UserH2Dao extends CrudRepository{ public Userh2 findByName(Ssortingng name); } 

Et pour finir, j’ai un UserController comme point d’access pour accéder à mon service

UserController.java

 @Controller @RequestMapping("/user") public class UserController { @Autowired private UserMysqlDao userMysqlDao; @Autowired private UserH2Dao userH2Dao; @RequestMapping("/createM") @ResponseBody public Ssortingng createUserMySql(Ssortingng name){ UserMysql user = new UserMysql(); try{ user.name = name; userMysqlDao.save(user); return "Success creating user with Id: "+user.id; }catch(Exception ex){ return "Error creating the user: " + ex.toSsortingng(); } } @RequestMapping("/createH") @ResponseBody public Ssortingng createUserH2(Ssortingng name){ Userh2 user = new Userh2(); try{ user.name = name; userH2Dao.save(user); return "Success creating user with Id: "+user.id; }catch(Exception ex){ return "Error creating the user: " + ex.toSsortingng(); } } } 

Application.java

 @Configuration @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) @EntityScan(basePackages="com.test.entity.db") @ComponentScan public class Application { public static void main(Ssortingng[] args) { System.out.println("Entering spring boot"); ApplicationContext ctx = SpringApplication.run(Application.class, args); System.out.println("Let's inspect the beans provided by Spring Boot:"); Ssortingng[] beanNames = ctx.getBeanDefinitionNames(); Arrays.sort(beanNames); for (Ssortingng beanName : beanNames) { System.out.print(beanName); System.out.print(" "); } System.out.println(""); } } 

Avec cette configuration, mon démarrage de Spring fonctionne bien, mais quand j’accède

 http://localhost/user/createM?name=myname it writes an exception Error creating the user: org.springframework.dao.InvalidDataAccessResourceUsageException: could not execute statement; SQL [n/a]; nested exception is org.hibernate.exception.SQLGrammarException: could not execute statement 

J’ai fait des recherches sur Google et je n’ai pas encore de solution. Des idées pourquoi cette exception se produit? Et est-ce la meilleure façon d’implémenter plusieurs sources de données pour mettre en œuvre mon cas ci-dessus? Je suis ouvert au refactoring complet si nécessaire.

Merci

Je pense que vous pouvez le trouver utile

http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-two-datasources

Il montre comment définir plusieurs sources de données et en assigner une primaire.

Voici un exemple assez complet, contient également des transactions de dissortingbution – si vous en avez besoin.

http://fabiomaffioletti.me/blog/2014/04/15/dissortingbuted-transactions-multiple-databases-spring-boot-spring-data-jpa-atomikos/

Ce dont vous avez besoin, c’est de créer 2 classes de configuration, de séparer les packages du modèle / référentiel, etc. pour faciliter la configuration.

En outre, dans l’exemple ci-dessus, il crée les sources de données manuellement. Vous pouvez éviter cela en utilisant la méthode sur spring doc, avec l’annotation @ConfigurationProperties. Voici un exemple de ceci:

http://xantorohara.blogspot.com.tr/2013/11/spring-boot-jdbc-with-multiple.html

J’espère que ces aides.

J’ai fait face au même problème il y a quelques jours, j’ai suivi le lien mentionné ci-dessous et j’ai pu surmonter le problème

http://www.baeldung.com/spring-data-jpa-multiple-databases

J’ai résolu le problème (Comment connecter plusieurs bases de données en utilisant Spring et Hibernate) de cette façon, j’espère que cela aidera 🙂

REMARQUE: J’ai ajouté le code approprié, veuillez utiliser le dao à l’aide de l’impl I utilisé dans le code mentionné ci-dessous.

web.xml

   MultipleDatabaseConnectivityInSpring  index.jsp   dispatcher org.springframework.web.servlet.DispatcherServlet 1   org.springframework.web.context.ContextLoaderListener   contextConfigLocation  /WEB-INF/dispatcher-servlet.xml    dispatcher *.htm   30   

persistence.xml

    org.hibernate.ejb.HibernatePersistence in.india.entities.CustomerDetails              org.hibernate.ejb.HibernatePersistence in.india.entities.CompanyDetails              

répartiteur-servlet

           /WEB-INF/jsp/   .jsp                            

classe java à persister dans une firebase database

 package in.india.service.dao.impl; import in.india.entities.CompanyDetails; import in.india.service.CompanyService; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.springframework.transaction.annotation.Transactional; public class CompanyServiceImpl implements CompanyService { @PersistenceContext(unitName = "entityManagerFactoryTwo") EntityManager entityManager; @Transactional("manager2") @Override public boolean companyService(CompanyDetails companyDetails) { boolean flag = false; try { entityManager.persist(companyDetails); flag = true; } catch (Exception e) { flag = false; } return flag; } } 

classe java à persister dans une autre firebase database

 package in.india.service.dao.impl; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.springframework.transaction.annotation.Transactional; import in.india.entities.CustomerDetails; import in.india.service.CustomerService; public class CustomerServiceImpl implements CustomerService { @PersistenceContext(unitName = "localPersistenceUnitOne") EntityManager entityManager; @Override @Transactional(value = "manager1") public boolean customerService(CustomerDetails companyData) { boolean flag = false; entityManager.persist(companyData); return flag; } } 

customer.jsp

 <%@page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>     Insert title here   

SpringWithMultipleDatabase's

First Name
Last Name
Email Id
Profession
Address
Age

société.jsp

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>     ScheduleJobs   

SpringWithMultipleDatabase's

Company Name
Company Strength
Company Location

index.jsp

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>     Home   

Multiple Database Connectivity In Spring sdfsdsd

Click here to go on Customer page
Click here to go on Company page

succès.jsp

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>     ScheduleJobs   

SpringWithMultipleDatabase

Successfully Saved

CompanyController

 package in.india.controller; import in.india.bean.CompanyBean; import in.india.entities.CompanyDetails; import in.india.service.CompanyService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.ModelAtsortingbute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; @Controller public class CompanyController { @Autowired CompanyService companyService; @RequestMapping(value = "/https://stackoverflow.com/questions/27614301/spring-boot-multiple-datasource/companyRequest.htm", method = RequestMethod.GET) public ModelAndView addStudent(ModelMap model) { CompanyBean companyBean = new CompanyBean(); model.addAtsortingbute(companyBean); return new ModelAndView("company"); } @RequestMapping(value = "/addCompany.htm", method = RequestMethod.GET) public ModelAndView companyController(@ModelAtsortingbute("companyBean") CompanyBean companyBean, Model model) { CompanyDetails companyDetails = new CompanyDetails(); companyDetails.setCompanyLocation(companyBean.getCompanyLocation()); companyDetails.setCompanyName(companyBean.getCompanyName()); companyDetails.setCompanyStrength(companyBean.getCompanyStrength()); companyService.companyService(companyDetails); return new ModelAndView("success"); } } 

CustomerController

 package in.india.controller; import in.india.bean.CustomerBean; import in.india.entities.CustomerDetails; import in.india.service.CustomerService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.ModelAtsortingbute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; @Controller public class CustomerController { @Autowired CustomerService customerService; @RequestMapping(value = "/https://stackoverflow.com/questions/27614301/spring-boot-multiple-datasource/customerRequest.htm", method = RequestMethod.GET) public ModelAndView addStudent(ModelMap model) { CustomerBean customerBean = new CustomerBean(); model.addAtsortingbute(customerBean); return new ModelAndView("customer"); } @RequestMapping(value = "/addCustomer.htm", method = RequestMethod.GET) public ModelAndView customerController(@ModelAtsortingbute("customerBean") CustomerBean customer, Model model) { CustomerDetails customerDetails = new CustomerDetails(); customerDetails.setAddress(customer.getAddress()); customerDetails.setAge(customer.getAge()); customerDetails.setEmailId(customer.getEmailId()); customerDetails.setFirstName(customer.getFirstName()); customerDetails.setLastName(customer.getLastName()); customerDetails.setProfession(customer.getProfession()); customerService.customerService(customerDetails); return new ModelAndView("success"); } } 

SociétéDétails Entité

 package in.india.entities; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.SequenceGenerator; import javax.persistence.Table; @Entity @Table(name = "company_details") public class CompanyDetails { @Id @SequenceGenerator(name = "company_details_seq", sequenceName = "company_details_seq", initialValue = 1, allocationSize = 1) @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "company_details_seq") @Column(name = "company_details_id") private Long companyDetailsId; @Column(name = "company_name") private Ssortingng companyName; @Column(name = "company_strength") private Long companyStrength; @Column(name = "company_location") private Ssortingng companyLocation; public Long getCompanyDetailsId() { return companyDetailsId; } public void setCompanyDetailsId(Long companyDetailsId) { this.companyDetailsId = companyDetailsId; } public Ssortingng getCompanyName() { return companyName; } public void setCompanyName(Ssortingng companyName) { this.companyName = companyName; } public Long getCompanyStrength() { return companyStrength; } public void setCompanyStrength(Long companyStrength) { this.companyStrength = companyStrength; } public Ssortingng getCompanyLocation() { return companyLocation; } public void setCompanyLocation(Ssortingng companyLocation) { this.companyLocation = companyLocation; } } 

Entité CustomerDetails

 package in.india.entities; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.SequenceGenerator; import javax.persistence.Table; @Entity @Table(name = "customer_details") public class CustomerDetails { @Id @SequenceGenerator(name = "customer_details_seq", sequenceName = "customer_details_seq", initialValue = 1, allocationSize = 1) @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "customer_details_seq") @Column(name = "customer_details_id") private Long customerDetailsId; @Column(name = "first_name ") private Ssortingng firstName; @Column(name = "last_name ") private Ssortingng lastName; @Column(name = "email_id") private Ssortingng emailId; @Column(name = "profession") private Ssortingng profession; @Column(name = "address") private Ssortingng address; @Column(name = "age") private int age; public Long getCustomerDetailsId() { return customerDetailsId; } public void setCustomerDetailsId(Long customerDetailsId) { this.customerDetailsId = customerDetailsId; } public Ssortingng getFirstName() { return firstName; } public void setFirstName(Ssortingng firstName) { this.firstName = firstName; } public Ssortingng getLastName() { return lastName; } public void setLastName(Ssortingng lastName) { this.lastName = lastName; } public Ssortingng getEmailId() { return emailId; } public void setEmailId(Ssortingng emailId) { this.emailId = emailId; } public Ssortingng getProfession() { return profession; } public void setProfession(Ssortingng profession) { this.profession = profession; } public Ssortingng getAddress() { return address; } public void setAddress(Ssortingng address) { this.address = address; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 

Il y a un exemple avec deux bases de données, la firebase database est mysql et orm est mybatis.Hope peut vous aider.

https://github.com/jinjunzhu/spring-boot-mybatis.git

Utilisez plusieurs sources de données ou réalisez la séparation entre lecture et écriture. Vous devez avoir une connaissance de la classe AbstractRoutingDataSource que supporte la source de données dynamic.

Voici mes datasource.yaml et je sais comment résoudre ce cas. Vous pouvez vous référer à ce projet spring-boot + quartz . J’espère que ceci vous aidera.

 dbServer: default: localhost:3306 read: localhost:3306 write: localhost:3306 datasource: default: type: com.zaxxer.hikari.HikariDataSource pool-name: default continue-on-error: false jdbc-url: jdbc:mysql://${dbServer.default}/schedule_job?useSSL=true&verifyServerCertificate=false&useUnicode=true&characterEncoding=utf8 username: root password: lh1234 connection-timeout: 30000 connection-test-query: SELECT 1 maximum-pool-size: 5 minimum-idle: 2 idle-timeout: 600000 destroy-method: shutdown auto-commit: false read: type: com.zaxxer.hikari.HikariDataSource pool-name: read continue-on-error: false jdbc-url: jdbc:mysql://${dbServer.read}/schedule_job?useSSL=true&verifyServerCertificate=false&useUnicode=true&characterEncoding=utf8 username: root password: lh1234 connection-timeout: 30000 connection-test-query: SELECT 1 maximum-pool-size: 5 minimum-idle: 2 idle-timeout: 600000 destroy-method: shutdown auto-commit: false write: type: com.zaxxer.hikari.HikariDataSource pool-name: write continue-on-error: false jdbc-url: jdbc:mysql://${dbServer.write}/schedule_job?useSSL=true&verifyServerCertificate=false&useUnicode=true&characterEncoding=utf8 username: root password: lh1234 connection-timeout: 30000 connection-test-query: SELECT 1 maximum-pool-size: 5 minimum-idle: 2 idle-timeout: 600000 destroy-method: shutdown auto-commit: false 

En utilisant deux sources de données, vous avez besoin de leurs propres gestionnaires de transactions.

 @Configuration public class MySqlDBConfig { @Bean @Primary @ConfigurationProperties(prefix="datasource.test.mysql") public DataSource mysqlDataSource(){ return DataSourceBuilder .create() .build(); } @Bean("mysqlTx") public DataSourceTransactionManager mysqlTx() { return new DataSourceTransactionManager(mysqlDataSource()); } // same for another DS } 

Et puis utilisez-le en conséquence dans @Transaction

 @Transactional("mysqlTx") @Repository public interface UserMysqlDao extends CrudRepository{ public UserMysql findByName(Ssortingng name); } 

Merci à tous pour votre aide, mais ce n’est pas si compliqué que cela. presque tout est géré en interne par SpringBoot.

Dans mon cas, je veux utiliser Mysql et Mongodb et la solution consistait à utiliser les annotations EnableMongoRepositories et EnableJpaRepositories sur ma classe d’applications.

 @SpringBootApplication @EnableTransactionManagement @EnableMongoRepositories(includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = MongoRepository)) @EnableJpaRepositories(excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = MongoRepository)) class TestApplication { ... 

NB: Toutes les entités mysql doivent étendre JpaRepository et les mongos doivent étendre MongoRepository .

Les configs de sources de données sont simples comme présenté par la documentation de spring:

 //mysql db config spring.datasource.url= jdbc:mysql://localhost:3306/tangio spring.datasource.username=test spring.datasource.password=test #mongodb config spring.data.mongodb.host=localhost spring.data.mongodb.port=27017 spring.data.mongodb.database=tangio spring.data.mongodb.username=tangio spring.data.mongodb.password=tangio spring.data.mongodb.repositories.enabled=true 

Une fois que vous commencez à travailler avec jpa et qu’un pilote est dans votre chemin de classe, le démarrage à la ligne le place immédiatement comme source de données (par ex. h2) pour utiliser la source de données defult.

 spring.datasource.url= jdbc:mysql://localhost:3306/ spring.datasource.username=test spring.datasource.password=test 

si nous allons un peu plus loin et que nous voulons en utiliser deux, je recommanderais d’utiliser deux sources de données telles qu’expliquées ici: Configurer Spring Boot et utiliser deux sources de données

Mise à jour 2018-01-07 avec Spring Boot 1.5.8.RELEASE

Si vous voulez savoir comment le configurer, comment l’utiliser et comment contrôler les transactions. J’ai peut-être des réponses pour vous.

Vous pouvez voir l’exemple exécutable et quelques explications dans https://www.surasint.com/spring-boot-with-multiple-databases-example/

J’ai copié du code ici.

Tout d’abord, vous devez définir application.properties comme ceci

 #Database database1.datasource.url=jdbc:mysql://localhost/testdb database1.datasource.username=root database1.datasource.password=root database1.datasource.driver-class-name=com.mysql.jdbc.Driver database2.datasource.url=jdbc:mysql://localhost/testdb2 database2.datasource.username=root database2.datasource.password=root database2.datasource.driver-class-name=com.mysql.jdbc.Driver 

Puis définissez-les comme fournisseurs (@Bean) comme ceci:

 @Bean(name = "datasource1") @ConfigurationProperties("database1.datasource") @Primary public DataSource dataSource(){ return DataSourceBuilder.create().build(); } @Bean(name = "datasource2") @ConfigurationProperties("database2.datasource") public DataSource dataSource2(){ return DataSourceBuilder.create().build(); } 

Notez que j’ai @Bean (name = “datasource1”) et @Bean (name = “datasource2”), alors vous pouvez l’utiliser lorsque vous avez besoin d’une source de données comme @Qualifier (“datasource1”) et @Qualifier (“datasource2”), par exemple

 @Qualifier("datasource1") @Autowired private DataSource dataSource; 

Si vous vous souciez de la transaction, vous devez définir DataSourceTransactionManager pour les deux, comme ceci:

 @Bean(name="tm1") @Autowired @Primary DataSourceTransactionManager tm1(@Qualifier ("datasource1") DataSource datasource) { DataSourceTransactionManager txm = new DataSourceTransactionManager(datasource); return txm; } @Bean(name="tm2") @Autowired DataSourceTransactionManager tm2(@Qualifier ("datasource2") DataSource datasource) { DataSourceTransactionManager txm = new DataSourceTransactionManager(datasource); return txm; } 

Ensuite, vous pouvez l’utiliser comme

 @Transactional //this will use the first datasource because it is @primary 

ou

 @Transactional("tm2") 

Cela devrait suffire. Voir exemple et détail dans le lien ci-dessus.

MySqlBDConfig.java

 @Configuration @EnableTransactionManagement @EnableJpaRepositories(basePackages = "PACKAGE OF YOUR CRUDS USING MYSQL DATABASE",entityManagerFactoryRef = "mysqlEmFactory" ,transactionManagerRef = "mysqlTransactionManager") public class MySqlBDConfig{ @Autowired private Environment env; @Bean(name="mysqlProperities") @ConfigurationProperties(prefix="spring.mysql") public DataSourceProperties mysqlProperities(){ return new DataSourceProperties(); } @Bean(name="mysqlDataSource") public DataSource interfaceDS(@Qualifier("mysqlProperities")DataSourceProperties dataSourceProperties){ return dataSourceProperties.initializeDataSourceBuilder().build(); } @Primary @Bean(name="mysqlEmFactory") public LocalContainerEntityManagerFactoryBean mysqlEmFactory(@Qualifier("mysqlDataSource")DataSource mysqlDataSource,EntityManagerFactoryBuilder builder){ return builder.dataSource(mysqlDataSource).packages("PACKAGE OF YOUR MODELS").build(); } @Bean(name="mysqlTransactionManager") public PlatformTransactionManager mysqlTransactionManager(@Qualifier("mysqlEmFactory")EntityManagerFactory factory){ return new JpaTransactionManager(factory); } } 

H2DBConfig.java

 @Configuration @EnableTransactionManagement @EnableJpaRepositories(basePackages = "PACKAGE OF YOUR CRUDS USING MYSQL DATABASE",entityManagerFactoryRef = "dsEmFactory" ,transactionManagerRef = "dsTransactionManager") public class H2DBConfig{ @Autowired private Environment env; @Bean(name="dsProperities") @ConfigurationProperties(prefix="spring.h2") public DataSourceProperties dsProperities(){ return new DataSourceProperties(); } @Bean(name="dsDataSource") public DataSource dsDataSource(@Qualifier("dsProperities")DataSourceProperties dataSourceProperties){ return dataSourceProperties.initializeDataSourceBuilder().build(); } @Bean(name="dsEmFactory") public LocalContainerEntityManagerFactoryBean dsEmFactory(@Qualifier("dsDataSource")DataSource dsDataSource,EntityManagerFactoryBuilder builder){ LocalContainerEntityManagerFactoryBean em = builder.dataSource(dsDataSource).packages("PACKAGE OF YOUR MODELS").build(); HibernateJpaVendorAdapter ven = new HibernateJpaVendorAdapter(); em.setJpaVendorAdapter(ven); HashMap prop = new HashMap<>(); prop.put("hibernate.dialect", env.getProperty("spring.jpa.properties.hibernate.dialect")); prop.put("hibernate.show_sql", env.getProperty("spring.jpa.show-sql")); em.setJpaPropertyMap(prop); em.afterPropertiesSet(); return em; } @Bean(name="dsTransactionManager") public PlatformTransactionManager dsTransactionManager(@Qualifier("dsEmFactory")EntityManagerFactory factory){ return new JpaTransactionManager(factory); } } 

application.properties

 #---mysql DATASOURCE--- spring.mysql.driverClassName = com.mysql.jdbc.Driver spring.mysql.url = jdbc:mysql://127.0.0.1:3306/test spring.mysql.username = root spring.mysql.password = root #---------------------- #---H2 DATASOURCE---- spring.h2.driverClassName = org.h2.Driver spring.h2.url = jdbc:h2:file:~/test spring.h2.username = root spring.h2.password = root #--------------------------- #------JPA----- spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.H2Dialect spring.jpa.show-sql=true spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults = false spring.jpa.hibernate.ddl-auto = update spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true 

Application.java

 @SpringBootApplication public class Application { public static void main(Ssortingng[] args) { ApplicationContext ac=SpringApplication.run(KeopsSageInvoiceApplication.class, args); UserMysqlDao userRepository = ac.getBean(UserMysqlDao.class) //for exemple save a new user using your repository userRepository.save(new UserMysql()); } }