El año pasado, comprendí un poco de cuán conveniente y rápido se desarrolló Springboot en varios canales. Pero no estudié mucho en ese momento. Después de todo, sentí que no era muy competente en Struts y SpringMVC. Sin embargo, después de leer muchas presentaciones sobre Springboot, no fue tan difícil como pensaba, así que comencé a prepararme para aprender Springboot. En mi tiempo libre, después de leer el combate real de Springboot y los blogs de algunos maestros sobre Springboot, comencé a escribir mi primer proyecto Springboot. Después de poder implementar funciones de Crud en Springboot con un desarrollo simple de interfaces de estilo RESTFUL, se creó esta publicación de blog.
Introducción a Springboot
Spring Boot es un nuevo marco proporcionado por el equipo fundamental. Está diseñado para simplificar el proceso inicial de construcción y desarrollo de las nuevas aplicaciones de resorte. El marco utiliza una forma específica de configurarlo, de modo que los desarrolladores ya no necesitan definir configuraciones de calderas.
En pocas palabras, puede desarrollar rápidamente un proyecto con solo unos pocos frascos y algunas configuraciones simples.
Si simplemente quiero desarrollar una interfaz externa, solo necesito el siguiente código.
Un programa principal comienza Springboot
@SpringBootApplicationPublic Aplolation {public static void main (string [] args) {springApplication.run (application.class, args); }}Capa de control
@RestControllerPublic Class HelloWOrldController {@RequestMapping ("/Hello") public String index () {return "Hello World"; }}Después de comenzar con éxito el programa principal, escriba la capa de control y luego ingrese http: // localhost: 8080 // Hola en el navegador para ver la información.
¡Siento que usar SpringBoot para desarrollar programas es muy simple!
En las palabras prácticas de Springboot:
No hay configuración aquí, ni Web.xml, ni instrucciones de compilación e incluso ningún servidor de aplicaciones, pero esa es toda la aplicación. SpringBoot hará toda la logística necesaria para ejecutar la aplicación, y solo necesita obtener el código de la aplicación.
Desarrolle un servicio relajante basado en springboot
Antes de desarrollar un programa, debe hacer algunos preparativos
Crear base de datos `springBoot`; use` springBoot`; table de caída si existe `t_user`; create tabla` t_user` (`id` int (11) no null auto_increment comment 'id',` name` varchar (10) comentario predeterminado nulo ', nombre', `edad` int (2) comentario predeterminado edad 'edad', tecla primaria (` `` `` `id`) Engine Nombre ', nombre', nombre ',` edad' int (2) NULL NULL COMENTAR 'Edad', clave primaria (`` `` `` `id`) Enlailer Nombre ', nombre', nombre ',` edad' int (2). Auto_increment = 12 Charset predeterminado = UTF8;
El frasco más central de Springboot
Spring-Boot-Starter: módulo central, que incluye soporte de configuración automática, registro y YAML;
<Parent> <MoupRoMID> org.springframework.boot </groupid> <artifactID> spring-boot-starter-parent </arfactid> <versers> 1.5.9.release </verversion> <relativepath/> </rent> <propiies> <ject.Build.SourceEnding> Utf-8 </project.build.sourcoding> <java.version> 1.7 </Java.version> <MyBatis-Spring-Boot> 1.2.0 </MyBatis-Spring-Boot> <MySQL-Connector> 5.1.39 </mysql-connector> </propiedades> <pendencies> <epardency> <grupid> org.springframework.boot </groupid> <artifactID> spring-boot-starter-web </artifactid> </pendency> <pendency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-thymeleaf </artifactid> </dependency> <epardency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-data-jpa </artifactid> </pendency> <pendency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot -devtools </artifactid> <pectional> true </ppectional> </dependency> <paperid> ogrools </artifactid> <spectional> true </ppectional> </dependency> <pendency> <grupid> ogrools </artifactid> <pectional> true </ppectional> </dependency> <pendency> <grupid> org.springFrameRwork. <artifactID> spring-boot-starter-test </artifactid> <cope> test </scope> </pendency> <!-Spring Boot MyBatis Dependency-> <Spendency> <MoupRupid> org.mybatis.spring.boot </groupId> <artifactid> mybatis-spring-boot-starter </artifactid> <version>${mybatis-spring-boot}</version> </dependency> <!-- MySQL connection driver dependency--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>${mysql-connector}</version> </dependency> </dependency> <build> <glugins> <!-Use el complemento SpringBoot para usar la aplicación Spring-Boot-Devtools. Cuando cambia el archivo en la classpath, ¡se reiniciará automáticamente! -> <glugin> <grupoD> org.springframework.boot </groupid> <artifactid> spring-boot-maven-plugin </arfactid> <figuration> <cutk> true </bork> </figuration> </glugin> </glugins> </dultuil> com.pancm.web - capa de controlador
com.pancm.dao - Data Operation Layer Dao
com.pancm.bean - clase de entidad
com.pancm.bean.service - Empresarial Logic Layer
Aplicación - Clase de inicio de la aplicación
Application.Properties - Archivo de configuración de la aplicación, la configuración será leída automáticamente mediante el inicio de la aplicación
En general, necesitamos algunas configuraciones personalizadas, como configurar la configuración de conexión de JDBC, donde podemos usar Application.Properties para configurarlo. La configuración real de la fuente de datos estará sujeta a la de todos.
## Configuración de la fuente de datos spring.dataSource.url = jdbc: mysql: // localhost: 3306/springBoot? useUnicode = true & caracterSencoding = utf8spring.dataSource.username = rootspring.dataSource.password = 123456spring.datasource.driver-class-name = com.mysql.J.Jiver Configuración de MyBatis# Configurar como com.pancm.Bean Point a la ruta del paquete de clase Entity. mybatis.typealiaspackage = com.pancm.bean# Configure el paquete mapper en la ruta classpath, * significa que todos los archivos XML serán escaneados. mybatis.mapperlocations = classpath/: mapper/*. xml
Es casi el momento de llegar al código clave.
Comenzamos escribiendo la clase POJO, correspondiente a la tabla T_user en la base de datos.
El código es el siguiente
Usuario de clase pública { / ** número* / private int id; / ** Nombre*/ Nombre de cadena privada; / ** edad*/ private int Age; Public User () {} Public Class User { / ** Number* / private int id; / ** Nombre*/ Nombre de cadena privada; / ** edad*/ private int Age; User público () {} // getter y setter omitido}En la capa DAO anterior, tanto Hibernate como MyBatis podrían usar anotaciones o archivos de configuración mapper. Aquí usamos el JPA de Spring para completar Crud.
ilustrar:
Generalmente hay dos formas de implementar la implementación de CRUD y la base de datos:
El primero es la configuración mapper de XML.
El segundo tipo es usar anotaciones, @insert, @select, @update, @delete y otras anotaciones. Este artículo usa el segundo tipo
importar org.apache.ibatis.annotations.delete; importar org.apache.ibatis.annotations.insert; import org.apache.ibatis.annotations.mapper; import org.apache.ibatis.annotations.result; import org.apache.ibatis.annotations.update; import org.springframework.data.repository.query.param; import com.pancm.bean.user; @mapperpublic Public Interface userDao { / *** Datos de usuario agregados* / @insert ("Insertar en t_user (id, nombre) Valores) (#{id},#{name},#{age}) ") void adduser (usuario de usuario); / *** Modificación de datos de usuario*/ @Update ("Update T_user set name =#{name}, Age =#{Age} Where id =#{id}") void UpdateUser (usuario de usuario); / *** Deleción de datos de usuario*/ @Delete ("Eliminar de t_user donde id =#{id}") void deleteuser (int id); / *** Información de usuario de consulta basada en el nombre de usuario**/ @select ("Seleccionar id, nombre, edad de t_user") // return Map Result Set @Results ({@Result (Propiedad = "ID", columna = "id"), @Result (Property = "Name", columna = "Nombre"), @Result (Property = "Age", columna = "Age"),}) UserByByName (@Param ("Name (" Name ("Name (" Name ") Nombre de usuario de cadena); / *** Información del usuario de consulta basada en ID de usuario**/ @select ("Seleccione ID, nombre, edad de T_USER") User FindById (@Param ("ID") int userId); / *** Información del usuario de consulta basada en la edad del usuario*/ @select ("Seleccione ID, nombre, edad de t_user donde age = #{userage}") user findByage (int userage);}Comprensión personal de las anotaciones utilizadas por esta interfaz:
MAPPER: Se agregó esta anotación a la interfaz para indicar que esta interfaz es un CRUD implementado basado en la anotación.
Resultados: El conjunto de resultados del mapa devuelto, la propiedad representa los campos de la clase de usuario y la columna representa los campos de la base de datos correspondiente.
Param: campo para la condición SQL.
Insertar, seleccionar, actualizar, eliminar: reclutar, modificar y eliminar las bases de datos correspondientes.
Esto es básicamente lo mismo que Hibernate y MyBatis.
El código es el siguiente:
interfaz
import com.pancm.bean.user;/**** Título: Userservice* Descripción: Interfaz de usuario* Versión: 1.0.0* @author pancm* @Date 9 de enero de 2018*/Public Interface Userservice {/*** Agregar usuario* @param user* @return*/boolean Adduser (usuario de usuario); / ** * modificar el usuario * @param user * @return */ boolean updateUser (usuario de usuario); / ** * Eliminar usuario * @param id * @return */ boolean deleteuser (int id); / *** Información de usuario de consulta basada en el nombre de usuario* @param UserName*/ User FindUserByName (String UserName); / *** Consulta información del usuario basada en ID de usuario* @param UserId*/ User FindUserById (int userId); / *** Consulta información del usuario basada en ID de usuario* @param userage*/ user finduserByage (int userage);}Clase de implementación
importar org.springframework.beans.factory.annotation.aUtowired; import org.springframework.stereotype.service; import @author pancm* @Date 9 de enero de 2018*/ @ServicePublic UserServiceImpl implementa UserService {@AUTOWIREDIREDIRED USERDAO USERDAO; @Override public boolean adduser (usuario de usuario) {boolean flag = false; intente {userdao.adduser (usuario); bandera = verdadero; } catch (Exception e) {E.PrintStackTrace (); } Bandera de retorno; } @Override public Boolean UpdateUser (usuario de usuario) {boolean flag = false; intente {userDao.UpdateUser (usuario); bandera = verdadero; } catch (Exception e) {E.PrintStackTrace (); } Bandera de retorno; } @Override public boolean DeleteUser (int id) {boolean flag = false; intente {userdao.deleteUser (id); bandera = verdadero; } catch (Exception e) {E.PrintStackTrace (); } Bandera de retorno; } @Override Public User FindUserByName (String UserName) {return userDao.findByName (UserName); } @Override Public User FindUserById (int userId) {return userDao.findById (userId); } @Override Public User FindUserByage (int userage) {return userDao.findbyage (userage); }}La capa de control es muy similar a SpringMVC, pero es mucho más simple que eso.
Mi comprensión personal de la anotación sobre la capa de control es la siguiente:
RESTCONTROLLER: Los métodos en la clase predeterminada se devolverán en formato JSON.
Requestmapping: Configuración de la ruta de interfaz.
Método: Formato de solicitud.
RequestParam: parámetros de solicitud.
La implementación específica es la siguiente:
importar org.springframework.beans.factory.annotation.aUtowired; import org.springframework.web.bind.annotation.requestMapping; import org.springframework.web.bind.annotation.requestmethod; import og.springframework.web.bind.annotation.requestparam; org.springframework.web.bind.annotation.restController; import com.pancm.bean.user; import com.pancm.service.userservice;/**** Título: userRestController* Descripción:* Interfaz de operación de datos de usuario* Versión: 1.0.0* @Author Pancm* @Date en enero, 2018*/REST "/API/USER") CLASE PÚBLICA USERRESTCONTROLLER {@AUTOWIREDREDEDRED USERSEVICE USER USEREBERSEVICE; @RequestMapping (value = "/adduser", método = requestmethod.post) public boolean adduser (usuario de usuario) {system.out.println ("comenzar a agregar ..."); devolver UserService.adduser (usuario); } @RequestMapping (valor = "/updateUser", método = requestmethod.put) public boolean UpdateUser (usuario de usuario) {System.out.println ("Comience a actualizar ..."); devolver UserService.UpdateUser (usuario); } @RequestMapping (value = "/deleteuser", método = requestmethod.delete) public boolean delete (@RequestParam (value = "username", requirir = true) int userId) {System.out.println ("Start DeLete ..."); devolver UserService.DeleteUser (UserId); } @RequestMapping (value = "/username", método = requestMethod.get) Usuario público FindByUsername (@RequestParam (value = "UserName", requirir = true) String UserName) {System.Println ("Inicio de la consulta ..."); return UserService.FinduserByName (nombre de usuario); } @RequestMapping (value = "/userId", método = requestmethod.get) Usuario público FindByUserId (@RequestParam (value = "userId", requerido = true) int userId) {System.out.println ("Iniciar Query ..."); devolver UserService.FinduserById (UserId); } @RequestMapping (value = "/userage", método = requestmethod.get) Usuario público FindByUserage (@RequestParam (value = "Userage", requería = true) int userage) {System.out.println ("Iniciar Query ..."); devolver UserService.FinduserById (Userage); }}SpringApplication es una clase utilizada para iniciar aplicaciones de resorte desde el método principal.
Por defecto, realiza los siguientes pasos:
1. Cree una instancia adecuada de aplicación de aplicación (dependiendo de classpath).
2. Registre un CommandLinePropertySource para usar los parámetros de la línea de comandos como propiedades de Spring.
3. Actualice el contexto de la aplicación y cargue todos los frijoles singleton.
4. Active todos los frijoles de CandenLinerunner.
Inicie esta clase directamente usando Main, y SpringBoot la configurará automáticamente.
PD: Incluso ahora sigo pensando que esto es realmente sorprendente.
Se explican algunas anotaciones para esta clase. :
SpringBootApplication: active el escaneo de componentes y la configuración automática.
MAPPERSCAN: Configuración del paquete de escaneo de clase de interfaz mapper
El código es el siguiente:
importar org.mybatis.spring.annotation.mapperscan; import org.springframework.boot.springapplication; import org.springframework.boot.autoconfigure.springbootapplication;/**** Título: Aplicación* Descripción:* Programa principal de torcio* Versión: 1.0.0.0* @Author Pancm* 2018*/@springbootapplication@mapperscan ("com.pancm.dao") aplicación de clase pública {public static void main (String [] args) {// inicia el tomcat integrado e inicializa el entorno de primavera y sus componentes de primavera springapplication.run (applicat.class, args); System.out.println ("El programa se está ejecutando ..."); }}Después de que se escribe el código, realizamos la prueba de código.
Después de iniciar la aplicación, use la herramienta Postman para probar la interfaz.
Los resultados de la prueba son los siguientes:
Solo se usa una prueba de Get and Post se usa aquí. Se han probado los métodos reales, pero creo que no hay necesidad de pegar el mapa.
Puse el proyecto en GitHub:
https://github.com/xuwujing/springboot
Resumir
Lo anterior es la introducción del editor para desarrollar un servicio RESTful basado en SpringBoot para implementar la función de agregar, eliminar, modificar y verificar. Espero que sea útil para todos. Si tiene alguna pregunta, déjame un mensaje y el editor responderá a todos a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!