Posto de gasolina Dark Horse SpringBoot-Knowledge

Índice

1.Teclas de atalho de ideias

CTRL + F12: IDEA vem com a capacidade de visualizar os atributos e métodos desta classe

CTRL+h: IDEA vem com a visualização de classes de implementação relacionadas

2. Oculte arquivos especificados ou arquivos de tipos especificados no Idea

Configuração → Tipos de arquivo → Arquivos e pastas ignorados
Insira o nome do arquivo a ser ocultado. O caractere curinga * é suportado.
Pressione Enter para confirmar a adição

3. Copie o projeto

Resumo das Notas

Copie o projeto correspondente na área de trabalho e modifique o nome do projeto

Exclua os arquivos de configuração relacionados ao Idea e mantenha apenas o diretório src e o arquivo pom.xml

Modifique o artefatoId no arquivo pom.xml para ser igual ao novo nome do projeto/módulo

Remover tag de nome (opcional)

Mantenha projetos de backup para uso posterior

em princípio

Preservar a infraestrutura de engenharia
Apague vestígios de engenharia original

Nota: Ao modificar o arquivo pom, você precisa excluir o nome e a descrição, caso contrário, ocorrerá um erro de índice maven.

Ou seja, a ordem está errada.

4. Estilo REST

4.1 Introdução ao REST

Resumo das Notas

DESCANSAR

4 ações

Consulta GET

POSTAR novo/salvar

Aumento PUT

EXCLUIR Excluir

Repousante

REST (Transferência de Estado Representacional), transferência de estado representacional

Formulário de descrição de recurso de estilo tradicional

http://localhost/usuário/ obter ById?id=1

http: // localhost/usuário/ salvar usuário
Formulário de descrição do estilo REST

http://localhost/usuário/1

http://localhost/usuário

vantagem:

Ocultar o comportamento de acesso dos recursos. É impossível saber quais operações são realizadas nos recursos através do endereço.
Simplifique a escrita

O estilo REST simplifica o formato URL da barra de endereço, que desempenha um determinado papel na proteção da segurança e dificulta a identificação.

Ao acessar recursos no estilo REST, utilize ações comportamentais para distinguir quais operações foram executadas nos recursos.

Insira a descrição da imagem aqui

Perceber:

O comportamento acima é uma convenção, a convenção não é uma especificação e pode ser quebrada, por isso é chamada de estilo REST, não de especificação REST.
O nome da descrição do módulo geralmente é plural, ou seja, a descrição do formato com s adicionados, indicando isso tipo de recurso em vez de um único recurso, por exemplo: usuários, livros, contas…

O acesso a recursos de acordo com o estilo REST é denominado RESTful

4.2 Caso de entrada RESTful

Resumo das Notas

1. Caso introdutório
2. Configuração do método de solicitação
3. Solicitar parâmetros de caminho

1. Nome: @RequestMapping

Tipo: anotação de método
Localização: Acima da definição do método do controlador SpringMVC
Função: Defina o caminho de acesso da solicitação do método do controlador atual

exemplo:

@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public string save(@RequestBody User user){
      
      
    system.out.println( "user save. . ." + user);
    return "{ ' module' : 'user save' }";
}

Atributos
- valor (padrão): solicitar caminho de acesso
- método: ação de solicitação http, ação padrão (GET/POST/PUT/DELETE)

2. Nome: @PathVariable

Tipo: anotação formal de parâmetro
Posição: na frente da definição do parâmetro do método do controlador SpringMVC
Função: vincular o relacionamento entre os parâmetros do caminho e os parâmetros formais do método do processador, exigindo correspondência um-para-um entre os nomes dos parâmetros do caminho e os nomes dos parâmetros formais

exemplo:

@RequestMapping(value = "/users/{id}" ,method = RequestMethod.DELETE)
@ResponseBody
public string delete(@PathVariable Integer id){
      
      
    system.out.print1n( "user delete. . ." + id);
    return "{ ' module ' : 'user delete' }" ;
}

3.@RequestBody @RequestParam @PathVariable

a diferença
- @RequestParam é usado para receber parâmetros de endereço URL ou parâmetros de formulário.
- @RequestBody é usado para receber dados json
- @PathVariable é usado para receber parâmetros de caminho, use **{nome do parâmetro}** para descrever os parâmetros de caminho
aplicativo
- No desenvolvimento posterior, quando mais de um parâmetro de solicitação é enviado , o formato json é o principal e @RequestBody é amplamente utilizado.
- Se estiver enviando dados em formato não json, use @RequestParam para receber parâmetros de solicitação.
- Use RESTful para desenvolvimento. Quando o número de parâmetros é pequeno, como 1 , você pode usar **@PathVariable** para receber a variável do caminho da solicitação, que geralmente é usada para passar o valor do id.

Definir ação de solicitação http (verbo)

//增加
@RequestMapping(value = "/users",method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user){
      
      
    System.out.println("user save..."+user);
    return "{'module':'user save...'}";
}

//修改
@RequestMapping(value = "/users",method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user){
      
      
    System.out.println("user update..."+user);
    return "{'module':'user update...'}";
}

Definir parâmetros de solicitação (variáveis de caminho)

//删除
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id){
      
      
    System.out.println("user delete...");
    return "{'module':'user delete...'}";
}

Palavra-chave @PathVariable, tome cuidado para não esquecer de adicionar caracteres {id} ao caminho

Exemplo:

//RESTful
@Controller
public class BookController {
    
    

    //增加
    @RequestMapping(value = "/users",method = RequestMethod.POST)
    @ResponseBody
    public String save(@RequestBody User user){
    
    
        System.out.println("user save...post");
        return "{'module':'user save...post'}";
    }

    //删除
    @RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
    @ResponseBody
    public String delete(@PathVariable Integer id){
    
    
        System.out.println("user delete...");
        return "{'module':'user delete...'}";
    }

    //修改
    @RequestMapping(value = "/users",method = RequestMethod.PUT)
    @ResponseBody
    public String update(@RequestBody User user){
    
    
        System.out.println("user update..."+user);
        return "{'module':'user update...'}";
    }

    //查询--查询所有
    @RequestMapping(value ="/users",method = RequestMethod.GET)
    @ResponseBody
    public String getAll(){
    
    
        System.out.println("user getAll...");
        return "{'module':'user getAll...'}";
    }
    //查询--根据id查询
    @RequestMapping(value ="/users/{id}",method = RequestMethod.GET)
    @ResponseBody
    public String getById(@PathVariable Integer id){
    
    
        System.out.println("user getById..."+id);
        return "{'module':'user getById...'}";
    }

}

4.3REST rápido desenvolvimento

Resumo das Notas

1. Desenvolvimento rápido RESTful (desenvolvimento padrão)
2. @RestController
3. Mapeamento de ação de solicitação padrão (4 tipos)

1. Nome:@RestController

Tipo: anotação de classe
Posição: Acima da definição de classe do controlador de desenvolvimento RESTful baseada em SpringMVC
Função: Defina a classe do controlador atual para o estilo RESTful, que é equivalente à função combinada de duas anotações @Controller e @ResponseBody

exemplo:

@RestController
public class BookController {
      
      
    
}

2. Nome: @GetMapping@PostMapping@PutMapping@DelgteMapping

Tipo: anotação de método
Posição: Acima da definição do método do controlador de desenvolvimento RESTful baseado em SpringMVC
Função: Defina o caminho de acesso de solicitação do método do controlador atual e a ação de solicitação, cada uma correspondendo a uma ação de solicitação, por exemplo, @GetNapping corresponde à solicitação GET

exemplo:

@GetMapping("/{id}")
public string getById(@PathVariable Integer id){
      
      
    system.out.println("book getById. . . "+id);
    return "{ ' module' : ' book getById ' }" ;
}

Valor do atributo
(padrão): Solicitar caminho de acesso

Exemplo:

@RestController
@RequestMapping("/users")
public class BookController2 {
    
    

    //增加
    @PostMapping
    public String save(@RequestBody User user) {
    
    
        System.out.println("user save..." + user);
        return "{'module':'user save...'}";
    }

    //删除
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id) {
    
    
        System.out.println("user delete...");
        return "{'module':'user delete...'}";
    }

    //修改
    @PutMapping
    public String update(@RequestBody User user) {
    
    
        System.out.println("user update..." + user);
        return "{'module':'user update...'}";
    }

    //查询--查询所有
    @GetMapping
    public String getAll() {
    
    
        System.out.println("user getAll...");
        return "{'module':'user getAll...'}";
    }

    //查询--根据id查询
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id) {
    
    
        System.out.println("user getById..." + id);
        return "{'module':'user getById...'}";
    }

}

5. Modelo de desenvolvimento Java Rest

Restful é um estilo de arquitetura de software e estilo de design, não um padrão. Ele fornece apenas um conjunto de princípios e restrições de design. Usado principalmente para software interativo cliente-servidor.O software projetado com base nesse estilo pode ser mais simples, mais em camadas e mais fácil de implementar mecanismos de cache.

Solicitações de estilo repousante usam "método url + solicitação" para expressar o propósito de uma solicitação. Os quatro verbos no protocolo HTTP que indicam o modo de operação são os seguintes:

Obter: Obtenha recursos
Postagem: Crie um novo recurso
Colocar: atualizar recurso
Excluir: excluir recurso

Implemente o modo Rest por meio de anotações:

@RestController: @ResponseBody + @Controller, o que significa que os dados retornados estão no formato json ;

(A anotação @RestController é equivalente à combinação de @ResponseBody e @Controller)
@Controller
@ResponseBody
public class MyController {
     
      }

@RestController
public class MyRestController {
     
      }
@ResponseBody

1. Na operação real, precisamos apenas usar a anotação @RequestBody na camada Controller para desserializar o objeto;

2. Se precisar serializar os métodos do Controller, precisamos usar @ResponseBody no valor de retorno, você também pode anotar @ResponseBody na classe Controller, para que todos os métodos desta classe possam ser serializados.

@Controlador

@Controller é uma classe @Component especializada. Na operação real, @Controller é usado para indicar se uma classe Spring pode aceitar solicitações HTTP. Geralmente está vinculado a @ResponseBody.

@Componente

1. Instancie POJO comum (Plain Ordinary Java Object simple java object) no contêiner Spring, que é equivalente ao arquivo de configuração

2. Geralmente se refere a componentes.Quando os componentes são difíceis de classificar, você pode usar a anotação @Component para anotação.

@GetMapping, @PostMapping, @DeletMapping, @PutMapping: correspondem a quatro métodos de operação respectivamente.

Exemplo:

//Rest模式
@RestController 
@RequestMapping("/books")
public class BookController {
    
    
 
    @GetMapping 
    public String getById() {
    
    
        System.out.println("springboot is running...");
        return "springboot is running...";
    }
 
    @DeletMapping("/{id}")
    public String getById() {
    
    
        System.out.println("springboot is running...");
        return "springboot is running...";
    }
 
}

Materiais de referência: Uma breve análise do blog CSDN do Java @RestController annotations_bit&y

6. Solução para o desaparecimento da função de lembrete automático

Resumo das Notas

Especifique o arquivo de configuração do SpringBoot

Configuração → Estrutura do Projeto → Facetas

Selecione o projeto/projeto correspondente

Personalizar inicialização Spring

selecione o perfil

Insira a descrição da imagem aqui

Suplemento: Após o idea2022 ser lançado nos recursos, ele será reconhecido automaticamente. Se não for reconhecido, clique em atualização do Maven.

7.@Anotação Autowired

O que é?

Quando as anotações @Repository, @Component e @Service são usadas, a verificação de componente do Spring irá descobri-lo automaticamente e inicializá-lo como um bean no contexto do aplicativo Spring .

Quando precisar usar este bean, adicione a anotação @Autowired e o bean será criado.

Suplemento: A inicialização é baseada no construtor sem argumentos.

qual é o efeito?

O padrão é baseado no tipo de atributo e o Spring injeta automaticamente o valor do atributo correspondente.

Como usar?

A anotação @Autowired pode ser anotada em propriedades, métodos e construtores

Recomendação: Anote o construtor, conforme mostrado na figura, marque a anotação @Autowired no construtor.

Insira a descrição da imagem aqui

Neste momento, a ordem de inicialização dos membros da classe é diferente. A ordem é membros estáticos -> inicializar variáveis com valores padrão -> construtor -> atribuir valores às variáveis.

Se a anotação estiver em uma propriedade, as propriedades e métodos desta propriedade (objeto) não poderão ser utilizados no construtor.

Link de referência: Explicação detalhada das anotações @Autowired - super detalhadas e fáceis de entender_The Blog of Never Sleeping in Time-CSDN Blog_@autowired

8.@Repository、@Component、@Service、@Constroller注解

Sua função é entregar objetos ao gerenciamento de primavera.

A função da anotação @Repository não é apenas identificar a classe como um Bean, mas também encapsular as exceções de acesso a dados lançadas na classe anotada no tipo de exceção de acesso a dados do Spring. O próprio Spring fornece uma rica estrutura de exceção de acesso a dados que é independente de tecnologia específica de acesso a dados, usada para encapsular exceções lançadas por diferentes estruturas de camada de persistência, tornando as exceções independentes da estrutura subjacente.

Eles são usados em diferentes níveis do sistema de software:

@Component é um conceito generalizado que representa apenas um componente (Bean) e pode ser usado em qualquer nível.
@Service geralmente funciona na camada de negócios.
@Controller geralmente funciona na camada de controle.
@Repository geralmente funciona na camada de persistência.

Ao usar as anotações @Repository, @Component, @Service e @Constroller na classe, o Spring criará automaticamente o objeto BeanDefinition correspondente e o registrará no ApplicationContext. Essas classes se tornam componentes gerenciados pelo Spring. Essas três anotações atuam em classes em diferentes níveis de software e seu uso é exatamente o mesmo do @Repository.

9.@Substituir anotação

Diga ao leitor que este método foi substituído. Usado para verificar se o método da classe pai foi substituído corretamente.
O compilador pode verificar se o nome do método em @Override pertence à sua classe pai e, caso contrário, um erro será relatado.

10.SSM

O conjunto de estruturas SSM (Spring+SpringMVC+MyBatis) é composto por duas estruturas de código aberto, Spring e MyBatis (SpringMVC faz parte do Spring).É frequentemente usado como estrutura para projetos web com fontes de dados relativamente simples.

11. Como escrever dois pontos duplos em Java::

1. Expressão: person -> person.getName(); pode ser substituída por: Person::getName

2. Expressão: () -> new HashMap<>(); pode ser substituída por: HashMap::new

Insira a descrição da imagem aqui

12.A diferença entre solicitações de colocação e postagem

Em http, put é definido como um método idempotente e post não é um método idempotente.

Idempotente: Um termo em matemática. Para um método de operação de entrada única ou sem entrada, se o resultado for sempre o mesmo, é idempotente. Em outras palavras, se uma rede for executada múltiplas vezes e o efeito for o mesmo, ela é idempotente.

publicar
- Usado para enviar solicitações, pode atualizar ou criar recursos e não é idempotente.
- Quando um usuário se registra, uma conta de usuário é criada para cada envio. Neste caso, use post
colocar
- Usado para enviar recursos atualizados para o URL especificado, que é idempotente.
- Ainda é um módulo de usuário, como alterar uma senha. Embora o nome da conta e a senha sejam enviados, cada envio apenas atualiza a senha do usuário e cada solicitação apenas substitui o valor do protótipo. Nesse caso, use put

usar postar ou colocar

Se os resultados de múltiplas chamadas para a URL correspondente à atualização forem consistentes, use put
Se você enviar sempre o mesmo conteúdo e o resultado final for inconsistente, use post

Resumir

O efeito de solicitação é gerado: se a última solicitação substituir a solicitação anterior, use put, e se a última solicitação sobrepor a solicitação anterior, use post.

Materiais de referência: A diferença entre PUT e POST - Tencent Cloud Developer Community - Tencent Cloud (tencent.com)

Entenda a postagem e coloque em um minuto (perspectiva de segurança e idempotência)_ Blog "Desconectado"-blog CSDN_Qual é mais seguro, colocar ou postar?

13.Qual é a diferença entre @Component e @Bean?

Os objetos de ação são diferentes: @Componentas anotações atuam nas classes, enquanto @Beanas anotações atuam nos métodos,
@ComponentGeralmente é detectado automaticamente e montado automaticamente no contêiner Spring por meio de varredura de caminho (podemos usar @ComponentScananotações para definir o caminho a ser verificado para descobrir as classes que precisam ser montadas e instalá-las automaticamente no contêiner Spring bean). @BeanAs anotações geralmente definem o bean no método marcado com a anotação, @Beaninformando ao Spring que esta é uma instância de uma determinada classe, e o retornam para mim quando precisarmos usá-lo.
@BeanAs anotações @Componentsão mais customizáveis que as anotações, e em muitos lugares só podemos @Beanregistrar beans através de anotações. Por exemplo, quando referenciamos uma classe em uma biblioteca de terceiros e precisamos montá-la no contêiner Spring, isso só pode ser @Beanfeito por meio do .

Link de referência: Qual é a diferença entre as anotações Spring @bean e @component? - Zhihu(zhihu.com)

[SpringBoot - Explicação detalhada do uso das anotações @Configuration e @Bean (implementação da classe de configuração) (hangge.com)](https://www.hangge.com/blog/cache/detail_2506.html#:~:text =1, Instruções de uso 1% A anotação 40Bean atua no método 2% 40Bean indica que um método retorna um Spring, 5% O escopo padrão da anotação 40Bean é o escopo singleton, que pode ser definido como escopo de protótipo por meio de% 40Scope ("protótipo") )

14.A diferença entre Controller e RestController

O que eles têm em comum: todos são usados para indicar se uma determinada classe Spring pode receber solicitações HTTP.

Diferenças: @Controller: identifica uma classe Spring como um processador controlador Spring MVC, @RestController: @RestController é uma combinação de @Controller e @ResponseBody, o efeito combinado das duas anotações. Os métodos na classe @Controller podem ir diretamente para jsp, ftl, html e outras páginas de modelo retornando String. Adicionar a anotação @ResponseBody ao método também pode retornar objetos de entidade. Todos os métodos da classe @RestController só podem retornar objetos de entidade, como String, Object e Json, e não podem pular para a página do modelo.

Link de referência: A diferença entre Controller e RestController_Linux Resource Station's blog-CSDN blog_A diferença entre controller e restcontroller

MockMvc

Ao realizar testes de integração no módulo, esperamos poder testar o controlador inserindo a URL. Se iniciarmos o servidor e estabelecermos um cliente http para teste, isso tornará o teste muito problemático. Por exemplo, a velocidade de inicialização é lento, a verificação do teste é inconveniente e o ambiente de rede depende, etc., portanto, para testar o controlador, introduzimos o MockMVC.

MockMvc implementa a simulação de solicitações HTTP. Ele pode usar diretamente o formulário de rede e convertê-lo na chamada do Controlador. Isso pode tornar o teste rápido e não depende do ambiente de rede. Ele também fornece um conjunto de ferramentas de verificação, o que pode tornar a verificação da solicitação uniforme e conveniente.

Link de referência: [Explicação detalhada de MockMvc - Xingchao - Blog Park (cnblogs.com) Minha participação ] (https://www.cnblogs.com/jpfss/p/10950904.html#:~:text=MockMvc é sólido, unificado e muito conveniente.)

Construtores MockMvcRequest

15.A diferença entre @Component, @Repository e @Service

Links de referência: a diferença entre @Component, @Repository e o blog-CSDN blog_@repository de @Service_fansili

anotação	significado
@Componente	Os componentes mais comuns podem ser injetados no recipiente de mola para gerenciamento
@Repositório	Atua na camada de persistência
@Serviço	Atua na camada de lógica de negócios
@Controlador	Atua na camada de apresentação (anotações spring-mvc)

16. Introdução ao Druida

Druid é antes de tudo um pool de conexões de banco de dados. Druid é atualmente o melhor pool de conexões de banco de dados, superando outros pools de conexões de banco de dados em termos de funcionalidade, desempenho e escalabilidade, incluindo DBCP, C3P0, BoneCP, Proxool e JBoss DataSource. O Druid foi implantado em mais de 600 aplicativos no Alibaba e passou no rigoroso teste de implantação em larga escala em ambientes de produção por mais de um ano. Druid é um pool de conexão de banco de dados desenvolvido pelo Alibaba chamado para monitoramento!

Links de referência: O que é Druida e uma introdução ao blog Druid_A java novice em seu caminho de crescimento-blog CSDN_O que o druida faz?

17. Estratégia de eliminação de dados

Configurações relacionadas que afetam a eliminação de dados

Detectar dados voláteis (conjunto de dados server.db[i].expires que podem expirar)

volátil-lru: Selecione os dados usados menos recentemente para eliminação
volátil-lfu: selecione os dados menos usados recentemente e elimine-os
volátil-ttl: selecione os dados que estão prestes a expirar e elimine-os
volátil-aleatório: selecione dados aleatoriamente para eliminação

Insira a descrição da imagem aqui

LFU: Selecione os dados menos utilizados dentro de um período de tempo para eliminação.

LRU: Selecione os dados usados menos recentemente dentro de um período de tempo para eliminação·