spring-boot
Een spring-boot-applicatie verbinden met MySQL

Invoering

Opmerkingen

Spring-boot sample met behulp van MySQL

We volgen de officiële gids voor spring-boot en spring-data-jpa . We zullen de applicatie bouwen met behulp van gradle.

1. Maak het gradle-buildbestand

   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. Creëer de klantentiteit

   src / main / java / hallo / 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. Maak repositories

   src / main / java / hallo / 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. Maak het bestand application.properties aan

   ################### 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. Maak het bestand PersistenceConfig.java

In stap 5 bepalen we hoe de gegevensbron wordt geladen en hoe onze applicatie verbinding maakt met MySQL. Het bovenstaande fragment is de absolute minimale configuratie die we nodig hebben om verbinding te maken met MySQL. Hier bieden we twee bonen:

@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 Dit geeft ons grip op de configuraties van EntityManagerFactory en stelt ons in staat om aanpassingen te doen. Het stelt ons ook in staat om PersistenceContext in onze componenten te injecteren zoals hieronder:

@PersistenceContext
private EntityManager em;

• DataSource Hier retourneren we een exemplaar van de DriverManagerDataSource . Het is een eenvoudige implementatie van de standaard JDBC DataSource-interface, het configureren van een gewoon oud JDBC-stuurprogramma via bean-eigenschappen en het retourneren van een nieuwe verbinding voor elke getConnection-oproep. Let op: ik raad aan dit strikt te gebruiken voor testdoeleinden, omdat er betere alternatieven zoals BasicDataSource beschikbaar zijn. Raadpleeg hier voor meer informatie

6. Maak een toepassingsklasse

   src / main / java / hallo / 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. De toepassing uitvoeren

Als u een IDE zoals STS gebruikt , kunt u eenvoudig met de rechtermuisknop op uw project klikken -> Uitvoeren als -> Gradle (STS) Build ... Typ bootRun en Run in de takenlijst.

Als u gradle op de opdrachtregel gebruikt , kunt u de toepassing eenvoudig als volgt uitvoeren:

./gradlew bootRun

Je zou zoiets moeten zien:

== 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']