spring-boot
Conectando una aplicación de arranque de primavera a MySQL

Introducción

Observaciones

Ejemplo de arranque de primavera usando MySQL

Seguiremos la guía oficial para spring-boot y spring-data-jpa . Vamos a construir la aplicación utilizando Gradle.

1. Crear el archivo de compilación de Gradle

   construir.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. Crea la entidad cliente

   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. Crea Repositorios

   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. Crear el archivo 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. Crea el archivo PersistenceConfig.java

En el paso 5, definiremos cómo se cargará la fuente de datos y cómo nuestra aplicación se conecta a MySQL. El fragmento de código anterior es la configuración mínima que necesitamos para conectarnos a MySQL. Aquí ofrecemos dos frijoles:

@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 Esto nos permite controlar las configuraciones de EntityManagerFactory y nos permite realizar personalizaciones. También nos permite inyectar el PersistenceContext en nuestros componentes de la siguiente manera:

@PersistenceContext
private EntityManager em;

• Fuente de datos Aquí devolvemos una instancia de DriverManagerDataSource . Es una implementación simple de la interfaz JDBC DataSource estándar, que configura un controlador JDBC antiguo y sencillo a través de las propiedades del bean, y devuelve una nueva conexión para cada llamada de getConnection. Tenga en cuenta que recomiendo usar esto estrictamente para propósitos de prueba, ya que hay mejores alternativas como BasicDataSource disponibles. Consulte aquí para más detalles.

6. Crear una clase de aplicación

   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. Ejecutando la aplicación

Si está utilizando un IDE como STS , puede simplemente hacer clic derecho en su proyecto -> Ejecutar como -> Generar Gradle (STS) ... En la lista de tareas, escriba bootRun y ​​Ejecutar.

Si está utilizando gradle en la línea de comandos , simplemente puede ejecutar la aplicación de la siguiente manera:

./gradlew bootRun

Debería ver algo como esto:

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