Construimos una aplicación SpringBoot simple en el artículo anterior, que introducirá el uso de Spring-Data-JPA para operar la base de datos.
Cree una nueva base de datos MySQL, donde la base de datos se llama SpringBoot, y cree una tabla de datos user_info como objeto de tabla para nuestra operación de ejemplo.
La información user_info es la siguiente:
Tabla de caída si existe `User_info`; Crear tabla` user_info` (`id` int (11) no nulo automo_increment,` username` varchar (255) NULL predeterminado, `contraseña` varChar (255) NULL, tecla primaria (` id`)) Engine = myIsam Auto_increment = 3 Charset predeterminado = UTF8;-------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------
Después de que la base de datos y las tablas se creen con éxito, regrese a nuestro proyecto
Paso 0: Primero, introduzca los paquetes de dependencia de Maven de MySQL y JPA:
<Spendency> <MoupRoD> MySQL </GroupID> <artifactId> mysql-confonnector-java </artifactId> </pendency> <pendency> <MoupRupid> org.springframework.boot </proupId> <AtifactID> spring-boot-data-data-jpa </artifactid> </dependency>
El primer paso es configurar la información de conexión de la base de datos en el archivo de configuración de YML:
Primavera: DataSource: Driver-Class-Name: com.mysql.jdbc.driver url: jdbc: mysql: // localhost: 3306/springboot? useUnicode = true & caracterSencoding = utf-8 & Usessl = falso nombre de usuario: contraseña root: 1011 JPA: show-sql: true: true
El segundo paso es crear una clase de entidad correspondiente al mapa de entidad de la tabla de datos:
paquete com.javazhiyin; import javax.persistence.entity; import javax.persistence.generatedValue; import javax.persistence.generationType; import javax.persistence.id;/*** creado por 57783 en 2018/7/4.*/@entitypublic de clase urbana @id @id @id @id @idvalue (estrategia = GenerationType.Identity) ID de entero privado; nombre de usuario de cadena privada; contraseña de cadena privada; public Integer getId () {return id; } public void setid (ID de entero) {this.id = id; } public String getUsername () {return UserName; } public void setUsername (String UserName) {this.Username = username; } public String getPassword () {return Password; } public void setPassword (String Password) {this.password = contraseña; } public userInfo () {}}El tercer paso es crear una clase de repositorio y heredar la clase jParepository:
paquete com.javazhiyin; import org.springframework.data.jpa.repository.jparpository;/*** creado por 57783 en 2018/7/4.*/Public Interface UserinForeSpository extiende jParepository <userInfo, Integer> {}Aquí heredamos la clase JParepository, que encapsula algunos métodos básicos para las operaciones de bases de datos. Verifiquemos qué métodos están disponibles en jParepository a través del código fuente:
///// Código fuente recreado de un archivo .class por IntelliJ Idea // (alimentado por Fernflower Decompiler) // paquete org.springframework.data.repository; importe java.util.optional; @NorepositoryBeanPeanPublic Interface Interface Interface Interface Interface InterfaceMository <T, Id> Extends Repository <T, it> {<<<<<<<<<<<<<<<R. <S extiende t> iterable <s> saveall (iterable <s> var1); Opcional <T> findById (id var1); boolean existByid (ID var1); Iterable <t> findall (); Iterable <t> findallById (ITerable <id> var1); recuento largo (); void deletyById (ID var1); Eliminar void (t var1); void deleteall (iterable <? extiende t> var1); void deleteall ();}Paso 4: Cree un nuevo controlador para implementar la operación de agregar, eliminar, modificar y verificar la base de datos:
paquete com.javazhiyin; import org.springframework.beans.factory.annotation.auTowired; import org.springframework.web.bind.annotation.*; import java.util.list;/*** creado por 57783 en 2018/7/4.*/@restcontrollerpsolerpublic UserinfoController { UserInForePository UserInForePository; /*** check* @return*/@getmapping (valor = "/lista") Lista pública <SererInfo> getUserList () {return userEnForePository.findall (); }/** * Agregar * @param username * @param contraseña * @return */@postmapping (valor = "/adduser") público userInfo addUser (@RequestParam ("username") String UserName, @RequestParam ("Contraseña") String Password) {UserInfo User = New UserInfo (); user.setUsername (nombre de usuario); user.setPassword (contraseña); devolver userInForePository.save (usuario); }/** * Cambiar * @param id * @param username * @param contraseña * @return */@putmapping (value = "upduser/{id}") público userInfo upduser (@PathVariable ("id") ID de entero, @requestparam ("username") string username, @requestparam ("contraseña") string contraseña) string) UserInfo (); user.setID (id); user.setUsername (nombre de usuario); user.setPassword (contraseña); devolver userInForePository.save (usuario); }/*** Eliminar* @param id*/@DeletEmapping (value = "deluser/{id}") public void deluser (@PathVariable ("ID") ID de Integer) {userInfo user = new UserInfo (); user.setID (id); userInForePository.Delete (usuario); }}Para probar el código anterior, usamos Postman para probarlo, lo cual es muy conveniente:
Prueba de consulta:
Nuevas pruebas:
Modificar la prueba:
Eliminar la prueba:
Podemos ver que todas las pruebas se pueden pasar. SpringBoot utiliza Spring-Data-JPA para agregar, eliminar, modificar y verificar las operaciones son bastante convenientes.
Varias preguntas:
1. ¿Cuál es el concepto y el uso de la anotación @GeneratedValue en la clase de mapeo de entidades de objetos?
JPA requiere que cada entidad de entidad tenga y solo tenga una clave principal, y la anotación @GeneratedValue generará una clave primaria identificada de forma única para una entidad.
JPA proporciona cuatro estrategias de generación de claves principales, que se definen en la generación de clases de enumeración, a saber:
GenerationType.table
Use una tabla de base de datos específica para guardar la clave primaria, y el motor de persistencia genera la clave primaria a través de una tabla específica en la base de datos relacional. La ventaja de esta estrategia es que no depende de la implementación específica del entorno externo y la base de datos, y se puede portar fácilmente entre diferentes bases de datos. Sin embargo, dado que no puede utilizar completamente las características de la base de datos, no se utilizará primero.
GenerationType.Sequence
El crecimiento propio de la clave principal no es compatible en algunas bases de datos, como Oracle. Proporciona un mecanismo llamado "secuencia" para generar claves primarias. En este momento, GenerationType.Sequence se puede utilizar como la política de generación de clave principal. Las deficiencias de esta estrategia son exactamente lo opuesto a la tabla. Dado que solo algunas bases de datos (Oracle, PostgreSQL, DB2) de soporte de objetos de secuencia, esta estrategia generalmente no se aplica a otras bases de datos.
GenerationType.identidad
Estrategia de auto-crecimiento de la clave primaria. Cuando la base de datos inserta datos, asignará automáticamente valores a la clave primaria. Por ejemplo, MySQL puede declarar "auto_increment" al crear una tabla para especificar el crecimiento de la clave principal. Esta política es compatible con la mayoría de las bases de datos (métodos o palabras clave especificadas pueden ser diferentes), pero todavía hay algunas bases de datos que no lo admiten, por lo que es un poco menos portátil.
GenerationType.auto
Deje la estrategia de generación clave principal al motor de persistencia. El motor de persistencia seleccionará una de las tres estrategias de generación de claves principales anteriores en función de la base de datos. Esta estrategia de generación de clave primaria se usa más comúnmente. Dado que la estrategia de generación predeterminada de JPA es GenerationType.auto, puede especificar explícitamente @GeneratedValue (Strategy = GenerationType.auto) cuando usa esta estrategia o @GeneratedValue directamente.
2. ¿Qué interfaces proporciona los datos de Spring JPA y qué funciones se pueden implementar?
El código fuente que se puede ejecutar en este artículo: https://github.com/javazhiyin/springboot/tree/master/bootdemo_01
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.