1. En NetBeans 8.

2 creamos un nuevo proyecto Java Application de la categoría Maven

2. Digitamos como nombre del proyecto Spring

3. Al finalizar la creación del proyecto se generan las siguientes carpetas

4. Buscamos el archivo pom.xml, en el cual vamos a llamar las dependencias y configuraciones que se necesitan para
la ejecución del proyecto.

5. Editamos el archivo pom.xml primero borrando la etiqueta propiedades.

6. Borrada la etiqueta <properties>, seguido de la etiqueta <packaging>, copiamos el siguiente código.

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.0.RELEASE</version>
</parent>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.33</version>
 </dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

7. Guardamos el archivo para que automáticamente se empiezen a descargar en la carpeta del proyecto
Dependencies, las dependencias que acabamos de declarar en el archivo pom.xml

8. Para indicarle a Spring como accederemos a la base de datos necesitamos crear un archivo de configuración al
cual llamaremos application.properties y lo ubicamos en src/main/resources
 9. Agregamos el siguiente código al archivo application.properties el cual configura la conexión a la base de datos,
no olvidar guardar el archivo.
# Configurar la coneccion a la base de datos
spring.datasource.url = jdbc:mysql://localhost:3306/datos
spring.datasource.username = root
spring.datasource.password = 1234
spring.datasource.driverClassName = com.mysql.jdbc.Driver

# Indicar el DBMS
spring.jpa.database: MYSQL

# Indica si debe mostrar el log de las consultas sql ejecutadas

# Bueno a la hora de depurar
spring.jpa.show-sql: false

# Configurar Hibernate
spring.jpa.hibernate.ddl-auto: update
spring.jpa.hibernate.dialect: org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
10. Ahora creamos la clase Usuario.java que estará alojada en el paqueta cma.test.datosmysql, la cual va a persistir
los datos en la entidad Usuario de la base de datos “datos”
 11. Copiamos el siguiente código en la clase Usuario.java

package cma.test.datosmysql;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Usuario implements Serializable {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

private String nombre;

private String apellido;
private Integer edad;

public Usuario() {
}

public Usuario(String nombre, String apellido, Integer edad) {

this.nombre = nombre;
this.apellido = apellido;
this.edad = edad;
}

public Long getId() {

return id;
}

public void setId(Long id) {

this.id = id;
}

public String getNombre() {

return nombre;
}
 public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getApellido() {

return apellido;
}

public void setApellido(String apellido) {

this.apellido = apellido;
}

public Integer getEdad() {

return edad;
}

public void setEdad(Integer edad) {

this.edad = edad;
}

@Override
public String toString() {
return this.nombre + " " + this.apellido + " - " + this.edad;
}

12. Lo siguiente que necesitamos es el acceso a la entidad, queremos poder crear, editar, eliminar y buscar elementos
en nustro conjunto de datos, Spring provee mecanismos para crear repositorios de manera rápida y sencilla,
usando la interface CrudReposytory, para esto creamos un archivo Java Interface con el nombre
UsuarioRepository.java.
 13. Copiamos el siguiente código en el archivo de interfaz UsuarioRepository.java
package cma.test.datosmysql;

import java.util.List;
import org.springframework.data.repository.CrudRepository;

public interface UsuarioRepository extends CrudRepository<Usuario, Long> {

// Obtener una lista de usuarios con el apellido indicado

List<Usuario> findByApellido(String apellido);

// Obtener una lista de los usuarios con edad menor a la indicada

List<Usuario> findByEdadLessThan(Integer edad);

}
14. Ahora creamos la clase principal, la cual llamaremos Application.java, con la que podremos crear, eliminar, editar
y buscar usuarios en la base de datos MySQL mediante la clase UsuarioRepository que acabamos de crear.
 15. Agregamos el siguiente código a la clase principal Application.java
package cma.test.datosmysql;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
public class Application {

public static void main(String[] args) {

ConfigurableApplicationContext context =
SpringApplication.run(Application.class);
UsuarioRepository repository = context.getBean(UsuarioRepository.class);

// Guardar un conjunto de usuarios

//repository.save(new Usuario("Juan", "Perez", 25));
//repository.save(new Usuario("Maria", "Lozz", 15));
//repository.save(new Usuario("Lina", "Ruixs", 23));
repository.save(new Usuario("Bob", "Esponja", 10));

// findAll heredado de la interface CrudRepository

Iterable<Usuario> todos = repository.findAll();
System.out.println("Listar todos los Usuarios:");
for (Usuario usr : todos) {
System.out.println("\t" + usr);
}
System.out.println();

// findByEdadLessThan devuelve todos los usuarios con edades menores a la

indicada
Iterable<Usuario> edades = repository.findByEdadLessThan(21);
System.out.println("Usuarios con edad menor a 21");
for (Usuario usr : edades) {
System.out.println("\t" + usr);
}
System.out.println();

context.close();
}
}
16. Ya creadas la clases y los archivos de configuración, nos disponemos a Limpiar y Construir el proyecto Spring

17. Si todo esta bien el resultado seria el siguiente

18. Ahora ejecutamos la clase principal Application.java

19. Al ejecutar la clase principal se carga el framework Spring y podemos observar que se están persistiendo datos en
la base de datos elegida.