No ano passado, eu entendi um pouco de quão conveniente e rápido o trampolim foi desenvolvido em vários canais. Mas eu não estudei duro naquela época. Afinal, senti que não era muito proficiente em suportes e springmvc. No entanto, depois de ler muitas apresentações sobre o Springboot, não foi tão difícil quanto eu pensava, então comecei a me preparar para aprender o Springboot. No meu tempo livre, depois de ler o combate real do Springboot e alguns blogs de mestrado sobre o Springboot, comecei a escrever meu primeiro projeto de trampolim. Depois de poder implementar funções CRUD no Springboot com algum desenvolvimento simples de interfaces de estilo repouso, esta postagem no blog foi criada.
Introdução ao Springboot
A Spring Boot é uma nova estrutura fornecida pela equipe crucial. Ele foi projetado para simplificar o processo inicial de construção e desenvolvimento de novas aplicações de primavera. A estrutura usa uma maneira específica de configurá -la, para que os desenvolvedores não precisem mais definir configurações de caldeira.
Simplificando, você pode desenvolver rapidamente um projeto com apenas alguns frascos e algumas configurações simples.
Se eu quiser simplesmente desenvolver uma interface externa, só preciso do código a seguir.
Um programa principal inicia o trampolim
@SpringbooTApplicationPublic Classe Application {public static void main (string [] args) {springapplication.run (application.class, args); }}Camada de controle
@RestControllerPublic Classe HelloworldController {@RequestMapping ("/hello") public String Index () {return "Hello World"; }}Depois de iniciar com sucesso o programa principal, escreva a camada de controle e digite http: // localhost: 8080 // Olá no navegador para visualizar as informações.
Eu sinto que usar o trampolim para desenvolver programas é muito simples!
Nas palavras práticas do Springboot:
Não há configuração aqui, nem web.xml, sem instruções de construção e até nenhum servidor de aplicativos, mas esse é o aplicativo inteiro. O Springboot fará toda a logística necessária para executar o aplicativo e você só precisa obter o código do aplicativo.
Desenvolva um serviço RESTful baseado no Springboot
Antes de desenvolver um programa, você deve fazer alguns preparativos
Crie banco de dados `Springboot`; use` Springboot`; soltar tabela se existir `t_user`; crie tabela` t_user` (`id` int (11) não nulo auto_increntlement comentário 'id),` name `name' varchar (10) default comentário '', '` idade'), `name null null null (10) default comentário '',` idade '). Auto_increment = 12 charset padrão = utf8;
O pote mais central do trampolim
Spring-Boot-Starter: Módulo Core, incluindo suporte automático de configuração, log e YAML;
<Parent> <puperid> org.springframework.boot </frugiD> <ArtifactId> Spring-boot-Starter-Parent </ArtifactId> <Versão> 1.5.9.Release </si versption> <lorthath/> </parent> <Perperts> <Project.build.sourceEncoding> utf-8 </ <Java.Version> 1.7 </java.version> <mybatis-spring-boot> 1.2.0 </mybatis-spring-boot> <ysql-conector> 5.1.39 </mysql-connector> </properties> <pendências> <pendency> <proupid> ourg.sringfringfringfringfringfringfringfringfringfringfringfringfringfringfringfringfringfringfringfringfring> <pendency> <pusency> <poundid> org.springfring> </dependências> <Pupers> <Punders> <pusent> </GroupId> </mysql-conconsector> </dependências <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <TeRtifactId> Spring-boot-Starter-Data-jpa </starfactId> </dependency> <pendence> <puperid> org.springframework.boot </frugid> <TrAtifactId> Spring-Boot-devtools </Artifactid> <putional> Verdadeiro </opcional> </dependência> <GrupID> org.springframework.boot </frugiD> <TRARFACTID> Spring-Boot-Starter-test </stutifactId> <cope> test </cope> </dependency> <!-Spring Boot Mybatis Dependência-> <Dependência> <Grupid> Org.mybatis.spring.bot <rives </ArtifactId> mybatis-spring-boot-starter </stutifactId> <versão> $ {mybatis-spring-boot} </version> </dependency> <!-MySQL Connection driver dependência-> <pendence> <roupidId> mysql </grupid> <TROtifactId> mysqla-conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Conn-Connl- <versão> $ {mysql-conector} </version> </pendesicency> </dependency> <brupt> <luckins> <!-use o plug-in de troca para usar o aplicativo módulo Spring-Boot-Devtools. Quando o arquivo no caminho de classe mudar, ele será reiniciado automaticamente! -> <lugin> <puperiD> org.springframework.boot </groupiD> <TRATIFACTID> Spring-boot-maven-plugin </ArtifactId> <figuration> <bour> true </fork> </figuration> </plugin> </flugins> </filt> com.pancm.web - camada de controlador
COM.PANCM.DAO - Camada de operação de dados DAO
com.Pancm.Bean - Classe de entidade
com.pancm.bean.service - camada lógica de negócios
Aplicativo - Classe de inicialização do aplicativo
Application.Properties - Arquivo de configuração do aplicativo, a configuração será lida automaticamente pela inicialização do aplicativo
Geralmente, precisamos de algumas configurações personalizadas, como configurar a configuração de conexão do JDBC, onde podemos usar o aplicativo.properties para configurá -lo. A configuração real da fonte de dados deve estar sujeita a todos.
Configuração da fonte de dados spring.datasource.url=jdbc:mysql://localhost:3306/springBoot?useUnicode=true&characterEncoding=utf8spring.datasource.username=rootspring.datasource.password=123456spring.datasource.driver-class-name=com.mysql.jdbc.Driver## Mybatis Configuration# Configure como com.pancm.bean aponte para o caminho do pacote da classe Entidade. mybatis.typealiasespackage = com.pancm.bean# Configure o pacote Mapper sob o caminho da classe, * significa que todos os arquivos XML serão digitalizados. mybatis.mapperlocations = ClassPath/: mapper/*. xml
Está quase na hora de chegar ao código -chave.
Começamos escrevendo a classe Pojo, correspondendo à tabela T_USER no banco de dados.
O código é o seguinte
public class Usuário { / ** Número* / Private Int ID; / ** Nome*/ Nome de String Private; / ** Idade*/ Idade privada; public user () {} public class User { / ** número* / private int id; / ** Nome*/ Nome de String Private; / ** Idade*/ Idade privada; public user () {} // getter e setter omitido}Na camada DAO anterior, o Hibernate e o Mybatis poderiam usar anotações ou arquivos de configuração do Mapper. Aqui usamos o JPA da Spring para completar Crud.
ilustrar:
Geralmente, existem duas maneiras de implementar a implementação do CRUD e do banco de dados:
O primeiro é a configuração do mapeador do XML.
O segundo tipo deve usar anotações, @insert, @select, @update, @Delete e outras anotações. Este artigo usa o segundo tipo
importar org.apache.ibatis.annotações.delete; importar org.apache.ibatis.annotações.insert; importar org.apache.ibatis.annotações.mapper; import org.apache.ibatis.annotations.Result; importação org.apache.ibibis.anTações.ResultsSssSssssRes.mports ousults ousults; import.AnTaPAcheAcTis.isats.Mresults; Importssults; Importsults Orgesult; Import.Apache.ibibis.isats.ResultsSssSs; org.apache.ibatis.annotações.Update; importar org.springframework.data.repository.query.param; importar com.pancm.bean.user; @mapperpublic interface userdao { / *** dados adicionados* / @insert ("insert em t_user (id, idéias, names, dia), names). (#{id},#{name},#{idade}) ") void adduser (usuário do usuário); / *** Modificação de dados do usuário*/ @UpDate ("Atualize t_user Set Name =#{nome}, Age =#{AGE} onde id =#{id}") void updateUser (usuário do usuário); / *** DELIÇÃO DE DADOS DO USUÁRIO*/ @DELETE ("Exclua do t_user onde id =#{id}") void DeleteUser (int id); /** * Query user information based on user name* */ @Select("SELECT id,name,age FROM t_user") // Return Map result set @Results({ @Result(property = "id", column = "id"), @Result(property = "name", column = "name"), @Result(property = "age", column = "age"), }) User FindByName (@param ("name") string userName); / *** Consulta as informações do usuário com base no ID do usuário**/ @Select ("Selecione ID, nome, idade do T_USER") Usuário findbyId (@param ("id") int userID); / *** Informações do usuário da consulta com base na idade do usuário*/ @select ("Selecione ID, nome, idade de t_user Where Age = #{Useragem}") Usuário FindByage (Int Userage);}Entendimento pessoal das anotações usadas por esta interface:
Mapper: Adicionado esta anotação à interface para indicar que essa interface é um CRUD implementado com base na anotação.
Resultados: o conjunto de resultados do mapa retornado, a propriedade representa os campos da classe de usuário e a coluna representa os campos do banco de dados correspondente.
Param: Campo para condição SQL.
Insira, selecione, atualize, exclua: recrute, modifique e exclua bancos de dados correspondentes.
Isso é basicamente o mesmo que Hibernate e Mybatis.
O código é o seguinte:
interface
importar com.panc.Bean.User;/**** Título: UserService* Descrição: Interface do usuário* Versão: 1.0.0* @Author Pancm* @Date 9 de janeiro de 2018*/interface pública Usuários Service {/*** Adicione usuário* @param User* @return*/boolean addUser (usuário); / ** * Modifique o usuário * @param usuário * @return */ boolean updateUser (usuário do usuário); / ** * Exclua usuário * @param id * @return */ boolean DeleteUser (int id); / *** Informações do usuário da consulta com base no nome do usuário* @param nome de usuário*/ usuário findUserByName (string userName); / *** Informações do usuário da consulta com base no ID do usuário* @param userID*/ usuário findUserById (int userID); / *** Informações do usuário da consulta com base no ID do usuário* @param Useragem*/ Usuário findUserByage (Int Userage);}Classe de implementação
importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.service; importar com.panc.Bean.User; @Author Pancm* @Date 9 de janeiro de 2018*/ @ServicePublic Classe UserServiceImpl implementa UserService {@AUTOWIRED PRIVADO UserDAO Userdao; @Override public boolean adduser (usuário do usuário) {bandeira booleana = false; tente {userdao.adduser (usuário); bandeira = true; } catch (Exceção e) {e.printStackTrace (); } retornar sinalizador; } @Override public boolean updateUser (usuário do usuário) {bandeira booleana = false; tente {userdao.updateUser (usuário); bandeira = true; } catch (Exceção e) {e.printStackTrace (); } retornar sinalizador; } @Override public boolean DeleteUser (int id) {sinalizador booleano = false; tente {userdao.deleteUser (id); bandeira = true; } catch (Exceção e) {e.printStackTrace (); } retornar sinalizador; } @Override Public User FindUserByName (String UserName) {return userdao.findbyname (nome de usuário); } @Override Public User FindUserById (int userID) {return userdao.findbyId (userID); } @Override Public User FindUserByage (INTRAGE INT) {return userdao.findbyage (usuário); }}A camada de controle é muito semelhante ao SpringMVC, mas é muito mais simples que isso.
Meu entendimento pessoal da anotação sobre a camada de controle é a seguinte:
RestController: Os métodos na classe padrão serão retornados no formato JSON.
RequestMapping: Configuração do caminho da interface.
Método: Formato de solicitação.
RequestParam: Parâmetros de solicitação.
A implementação específica é a seguinte:
importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.web.bind.annotation.requestMapping; importar org.springframework.web.bind.annotation.requestmindod; import.springfringfringfringfring.web.bind.annotation.requestMindod; import.springfringfringfringfring.web.bind.anotation.requestMindod; import.springfringfringfringFring.Web.web.Bind.RequestMindod; org.springframework.web.bind.annotation.restcontroller; importar com.pancm.bean.user; importar com.pancm.service.userService;/**** título: @Author Pancm* @WANTANCMATE* @Dados da operação do usuário* Versão: 1.0.0* "/api/user") classe pública userrestcontroller {@autowired private UserService UserService; @RequestMapping (Value = "/addUser", Method = requestMethod.post) public boolean adduser (usuário do usuário) {System.out.println ("comece a adicionar ..."); return userservice.adduser (usuário); } @ReQuestMapping (value = "/updateUser", método = requestMethod.put) public boolean updateUser (usuário do usuário) {System.out.println ("Start a atualizar ..."); return userservice.updateUser (usuário); } @RequestMapping (value = "/DeleteUser", Method = requestMethod.delete) public boolean Delete (@RequestParam (value = "nome de usuário", requerido = true) int userID) {System.out.println ("Start Delete ..."); return userservice.deleteUser (userID); } @ReQuestMapping (value = "/nome de usuário", método = requestmethod.get) public user findbyuserName (@requestParam (value = "nome de usuário", requerido = true) string userr) {System.out.println ("start query ..."); return userservice.findUserbyName (nome de usuário); } @ReQuestMapping (value = "/userID", método = requestMethod.get) public user findbyUserId (@RequestParam (value = "userID", requerir = true) int userID) {System.out.println ("Start Query ..."); return userservice.findUserById (UserID); } @ReQuestMapping (value = "/userage", método = requestMethod.get) public user findByUseRage (@RequestParam (value = "userage", requerir = true) intrage) {System.out.println ("Start Query ..."); return userservice.findUserbyId (usuário); }}SpringApplication é uma classe usada para iniciar aplicativos de mola do método principal.
Por padrão, ele executa as seguintes etapas:
1. Crie uma instância ApplicationContext adequada (dependendo do ClassPath).
2. Registre um commandLinePropertySource para usar os parâmetros da linha de comando como propriedades da mola.
3. Atualize o contexto do aplicativo e carregue todos os feijões singleton.
4. Ative todos os grãos commandlinerunner.
Inicie esta classe diretamente usando o Main, e o Springboot o configurará automaticamente.
PS: Mesmo agora eu ainda acho isso realmente incrível.
Algumas anotações para esta classe são explicadas. :
SpringBootApplication: ligue a varredura de componentes e a configuração automática.
Mapperscan: Configuração do pacote de digitalização da classe de interface do mapeador
O código é o seguinte:
importar org.mybatis.spring.annotation.mapperscan; importar org.springframework.boot.springApplication; importar org.springframework.boot.autoconfigure.springbootApplication;/********************************************************************************************************************************* *. 2018*/@springbootapplication@mapperscan ("com.pancm.dao") public class Application {public static void main (string [] args) {// inicie o tomcat incorporado e inicialize o ambiente da mola e seus componentes da mola SpringApplication.run (application.class, args); System.out.println ("Programa está em execução ..."); }}Depois que o código for gravado, realizamos o teste de código.
Após iniciar o aplicativo, use a ferramenta Postman para testar a interface.
Os resultados dos testes são os seguintes:
Apenas um recebe e pós -teste é usado aqui. Os métodos reais foram testados, mas sinto que não há necessidade de colocar o mapa.
Eu coloquei o projeto no Github:
https://github.com/xuwujing/springboot
Resumir
O exposto acima é a introdução do editor para desenvolver um serviço RESTful baseado no Springboot para implementar a função de adicionar, excluir, modificar e verificar. Espero que seja útil para todos. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a todos a tempo. Muito obrigado pelo seu apoio ao site wulin.com!