spring-boot
Connecter une application Spring-Boot à MySQL

Introduction

Remarques

Exemple de démarrage à l'aide de MySQL

Nous suivrons le guide officiel pour Spring-Boot et Spring-Data-Jpa . Nous allons construire l'application en utilisant gradle.

1. Créer le fichier de construction graduel

   build.gradle

   buildscript {
       repositories {
           mavenCentral()
       }
       dependencies {
           classpath("org.springframework.boot:spring-boot-gradle-plugin:1.4.3.RELEASE")
       }
   }
   
   apply plugin: 'java'
   apply plugin: 'eclipse'
   apply plugin: 'idea'
   apply plugin: 'org.springframework.boot'
   
   jar {
       baseName = 'gs-accessing-data-jpa'
       version =  '0.1.0'
   }
   
   repositories {
       mavenCentral()
       maven { url "https://repository.jboss.org/nexus/content/repositories/releases" }
   }
   
   sourceCompatibility = 1.8
   targetCompatibility = 1.8
   
   dependencies {
       compile("org.springframework.boot:spring-boot-starter-data-jpa")
       runtime('mysql:mysql-connector-java')
       testCompile("junit:junit")
   }
   

2. Créer l'entité client

   src / main / java / hello / Customer.java

   @Entity
   public class Customer {
   
       @Id
       @GeneratedValue(strategy=GenerationType.AUTO)
       private Long id;
       private String firstName;
       private String lastName;
   
       protected Customer() {}
   
       public Customer(String firstName, String lastName) {
           this.firstName = firstName;
           this.lastName = lastName;
       }
   
       @Override
       public String toString() {
           return String.format(
                   "Customer[id=%d, firstName='%s', lastName='%s']",
                   id, firstName, lastName);
       }
   }
   

3. Créer des référentiels

   src / main / java / hello / CustomerRepository.java

   import java.util.List;
   import org.springframework.data.repository.CrudRepository;
   
   public interface CustomerRepository extends CrudRepository<Customer, Long> {
       List<Customer> findByLastName(String lastName);
   }
   

4. Créer le fichier application.properties

   ################### DataSource Configuration ##########################
   jdbc.driverClassName=com.mysql.jdbc.Driver
   jdbc.url=jdbc:mysql://localhost:3306/your_database_name
   jdbc.username=username
   jdbc.password=password
   
   init-db=false
   
   ################### Hibernate Configuration ##########################
   
   hibernate.dialect=org.hibernate.dialect.MySQLDialect
   hibernate.show_sql=true
   hibernate.hbm2ddl.auto=update
   

5. Créez le fichier PersistenceConfig.java

A l'étape 5, nous définirons comment la source de données sera chargée et comment notre application se connecte à MySQL. L'extrait ci-dessus est la configuration minimale nécessaire à la connexion à MySQL. Ici nous fournissons deux haricots:

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages="hello")
public class PersistenceConfig 
{
    @Autowired
    private Environment env;
 
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory()
    {
        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
 
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(Boolean.TRUE);
        vendorAdapter.setShowSql(Boolean.TRUE);
 
        factory.setDataSource(dataSource());
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setPackagesToScan("hello");
 
        Properties jpaProperties = new Properties();
        jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
        factory.setJpaProperties(jpaProperties);
 
        factory.afterPropertiesSet();
        factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
        return factory;
    }
     
    @Bean
    public DataSource dataSource()
    {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
        dataSource.setUrl(env.getProperty("jdbc.url"));
        dataSource.setUsername(env.getProperty("jdbc.username"));
        dataSource.setPassword(env.getProperty("jdbc.password"));
        return dataSource;
    }
      
}

• LocalContainerEntityManagerFactoryBean Cela nous permet de gérer les configurations EntityManagerFactory et nous permet de faire des personnalisations. Cela nous permet également d'injecter le PersistenceContext dans nos composants comme ci-dessous:

@PersistenceContext
private EntityManager em;

• DataSource Ici, nous retournons une instance de DriverManagerDataSource . Il s'agit d'une implémentation simple de l'interface JDBC DataSource standard, qui permet de configurer un ancien pilote JDBC via les propriétés du bean, et de renvoyer une nouvelle connexion pour chaque appel getConnection. Notez que je recommande d'utiliser ceci strictement à des fins de test car il existe de meilleures alternatives comme BasicDataSource disponible. Reportez-vous ici pour plus de détails

6. Créer une classe d'application

   src / main / java / hello / Application.java

    @SpringBootApplication
    public class Application {
   
        private static final Logger log = LoggerFactory.getLogger(Application.class);
    
        @Autowired
        private CustomerRepository repository;
    
        public static void main(String[] args) {
            SpringApplication.run(TestCoreApplication.class, args);
        }
    
        @Bean
        public CommandLineRunner demo() {
            return (args) -> {
                // save a couple of customers
                repository.save(new Customer("Jack", "Bauer"));
                repository.save(new Customer("Chloe", "O'Brian"));
                repository.save(new Customer("Kim", "Bauer"));
                repository.save(new Customer("David", "Palmer"));
                repository.save(new Customer("Michelle", "Dessler"));
    
                // fetch all customers
                log.info("Customers found with findAll():");
                log.info("-------------------------------");
                for (Customer customer : repository.findAll()) {
                    log.info(customer.toString());
                }
                log.info("");
    
                // fetch an individual customer by ID
                Customer customer = repository.findOne(1L);
                log.info("Customer found with findOne(1L):");
                log.info("--------------------------------");
                log.info(customer.toString());
                log.info("");
    
                // fetch customers by last name
                log.info("Customer found with findByLastName('Bauer'):");
                log.info("--------------------------------------------");
                for (Customer bauer : repository.findByLastName("Bauer")) {
                    log.info(bauer.toString());
            }
            log.info("");
        };
    }
   

   }

7. Lancer l'application

Si vous utilisez un IDE tel que STS , vous pouvez simplement faire un clic droit sur votre projet -> Exécuter en tant que -> Gradle (STS) Build ... Dans la liste des tâches, tapez bootRun et Run.

Si vous utilisez gradle sur la ligne de commande , vous pouvez simplement exécuter l'application comme suit:

./gradlew bootRun

Vous devriez voir quelque chose comme ceci:

== Customers found with findAll():
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']

== Customer found with findOne(1L):
Customer[id=1, firstName='Jack', lastName='Bauer']

== Customer found with findByLastName('Bauer'):
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']