A primeira parte: Aprenda principalmente o framework Spring e a integração do MyBatis e do framework Spring. A primeira é aprender como o Spring desenvolve projetos, como configurar arquivos pom.xml e arquivos applicationContext.xml.
Então aprenda a integração do framework MyBatis e Spring. O foco está nos pacotes dependentes exigidos pelo framework MyBatis, bem como nas classes de fábrica e nos métodos Mapper que o configuram. E aprendi a configuração do arquivo Mapper.xml. Por fim, estendi o arquivo de log log4.properties
Resultados da verificação: usar Spring para desenvolver projetos; usar Mybatis e Spring para integrar projetos de desenvolvimento.
A primeira parte é bem básica. Vamos falar sobre isso em detalhes. A segunda parte do aprendizado: a primeira metade fala sobre os detalhes do arquivo de mapeamento sql do mybatis. Principalmente a partir do terceiro ponto de conhecimento, o aprendizado do Spring MVC é muito importante.
1. Mapeador
Os mapeadores são arquivos de mapeamento SQL para MyBatis. Ele fala principalmente sobre o arquivo de configuração principal do MyBatis: mybatis-config.xml e o arquivo de mapeamento SQL: Mapper.xml.
Arquivo Mapper.xml: entenda principalmente esses cinco elementos
Instrução de consulta <select>, retorna um conjunto de resultados. Pode ser retornado por POJO ou resultMap (conjunto de resultados personalizados)
<inserir> retorna um inteiro.
<delete> retorna um inteiro.
<update> retorna um inteiro.
<resultMap> fornece regras de mapeamento. Comumente usado em relacionamentos em cascata (isso precisa ser aprendido em combinação com o conhecimento dos princípios do sistema de banco de dados)
Passando vários parâmetros (também conhecidos como POJOs para armazenar conjuntos de resultados):
O mainstream usa Java Bean para oferecer várias refeições e acomodações, que na verdade são aulas POJO (aulas persistentes). O princípio geral é atribuir dados obtidos do banco de dados a essas propriedades. (Costumamos usá-lo no aprendizado de Java Web, é um conjunto e, em seguida, um get)
Consulta em cascata (pontos críticos e difíceis): Recomenda-se voltar ao princípio do sistema do banco de dados de carteira de estudante.
Cascata um-para-um: Por exemplo, uma carteira de identidade corresponde a uma pessoa. Uma pessoa só pode corresponder a um cartão de identificação. (cassete através do id da pessoa e id do pedido)
Cascata de um para muitos: por exemplo, uma pessoa pode ter vários pedidos, mas um pedido pode pertencer a apenas uma pessoa. (cassete através do id da pessoa e id do pedido)
Cascata muitos-para-muitos: Na verdade, uma tabela intermediária é configurada e, em seguida, dividida em duas cascatas um-para-muitos. Mas esta tabela intermediária não precisa criar um PO de classe persistente.
Precisa dominar duas formas de cascata:
1. Resultados aninhados. Execute uma instrução SQL. Elementos usados: <resultMap> <select>
2. Consulta de conexão. (use POJO para armazenar o conjunto de resultados). Elementos usados: <selecione>
A colheita da primeira leitura: Por exemplo, crie uma classe POJO cuja função seja armazenar o conjunto de resultados. A classe persistente não é usada para armazenar o conjunto de resultados, ela pode representar o conteúdo de uma única tabela no banco de dados. Esta é uma pequena diferença.
Há também quando usamos para criar classes POJO, ou seja, quando precisamos armazenar o conjunto de resultados e gerar o conjunto de resultados.
Qual é a conexão deles? Quando há apenas uma única tabela, a classe persistente criada pode ser usada não apenas como uma classe POJO para armazenar conjuntos de resultados, mas também como uma tabela conectada ao banco de dados. Quando houver mais de duas tabelas e houver um relacionamento em cascata, será necessário criar uma classe POJO para armazenar o novo conjunto de resultados, que é diferente da classe persistente no momento.
Dito isso, quando for uma única tabela, a classe persistente pode precisar substituir o método toString. Mas quando há duas tabelas e há um relacionamento em cascata, a classe persistente não precisa reescrever o método toString, mas é entregue à classe POJO.
Formação prática (passe temporário): consulta do utilizador e do cordão do cartão de identificação associado de acordo com o UID através de cascata um-para-um.
Consulte a tabela de pedidos e a tabela de produtos associada com base no ID por meio da cascata muitos-para-muitos
2. SQL dinâmico (requer memória)
Ele explica principalmente como costurar as instruções SQL dinâmicas do MyBatis. Aprenda principalmente o uso de vários elementos. Esses elementos são muito usados. Consulte o livro p122 para começar a aprender. (Heartache: Originalmente, isso foi editado, mas a tela azul do computador não foi salva)
Existem alguns usos principais a serem observados:
<if> elemento base do elemento
elemento <onde>
elemento <set>
elemento <trim>
O elemento <foreach> geralmente é usado para percorrer ou manipular vários elementos (como excluir vários registros)
Método de referência de uso: (outros métodos são semelhantes em uso)
O elemento `<foreach>` é usado para gerar dinamicamente vários valores de parâmetro na instrução SQL e é frequentemente usado na instrução `IN`. Suas propriedades incluem principalmente `collection`, `item`, `index`, `open`, `separator` e `close`.
- `coleção`: Especifica a coleção a percorrer. Este atributo deve ser especificado, e é um objeto a ser foreach.
- `item`: Indica os elementos obtidos nesta iteração. Se a coleção for uma List, Set ou array, indica os elementos contidos nela, se a coleção for um mapa, indica o valor da chave-valor.
- `index`: índice, especifique um nome para indicar a posição de cada iteração durante o processo de iteração. Ao percorrer a lista, o índice é o índice. Ao percorrer o mapa, o índice representa a chave do mapa e o item é o valor do mapa.
- `open`: Indica com o que a instrução começa, o mais comumente usado é o colchete esquerdo '('. - `
separator`: Indica qual símbolo é usado como separador entre cada iteração.
- `close`: Indica com o que a instrução termina, o mais comumente usado é o colchete direito ')'.
Exemplo:
<!-- in查询 -->
<select id="selectUsers" resultType="User">
SELECT * FROM user
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</select>
<!-- 批量插入 -->
<insert id="insertUsers">
INSERT INTO user (name, age)
VALUES
<foreach collection="users" item="user" separator=",">
(#{user.name}, #{user.age})
</foreach>
</insert>
Parte-chave: 3. Introdução ao Spring MVC
Apresentei o MVC quando estava aprendendo conhecimento de Java Web e agora estou retornando ao MVC, principalmente aprendendo a combinação do framework Spring e do modelo MVC.
Modelo MVC: Model (modelo), View (visualização), Controller (controlador)
Padrão MVC baseado em Servlet:
Modelo: um ou mais objetos JavaBean para armazenamento de dados (modelo de entidade, criado pela classe JavaBean, ou seja, classe persistente ) e lógica de processamento de negócios (modelo de negócios, criado pela classe Java geral, dividida em camada dao e camada de serviço )
View: Uma ou mais páginas JSP, que enviam dados para o controlador e fornecem exibição de dados para o modelo. As páginas JSP usam principalmente tags HTML e tags JavaBean para exibir dados.
Controller: Um ou mais objetos Servlet , que são controlados de acordo com a requisição enviada pela view, ou seja, a requisição é encaminhada para o JavaBean que processa a lógica de negócio, e o resultado do processamento é armazenado no modelo de entidade JavaBean (ou seja, a classe POJO), e enviado para a view para exibição .
Revise os pontos de conhecimento aprendidos anteriormente:
Revise o desenvolvimento de projetos de servlet combinados com o framework Java Web:
Como funciona o Spring MVC: (ênfase)
Como mostrado na imagem :
O Spring MVC possui quatro interfaces: DispatcherServlet, HandlerMapping, Controller, ViewResolver
DispatcherServlet: O arquivo Web.xml implementa isso. Ele apontará para Springmvc.xml.
HandlerMapping: O arquivo Springmvc.xml é usado para mapear o controlador
Controlador: arquivo de classe, o que significa pular para a página de exibição (camada de lógica de negócios, classe Java geral)
ViewResolver: a configuração do arquivo Springmvc.xml é um elemento bean.
O primeiro aplicativo Spring MVC simples: (não use o controlador de anotação, escreva o mapeamento apontando para a classe do controlador em springmvc)
etapa:
A primeira etapa: ainda importar pacotes dependentes. (Sping web, Spring webmvc, javax. servlet)
Etapa 2: Escreva web.xml (este é o arquivo principal. No Springweb, o web.xml é lido. No Spring, o applicationContext.xml é lido.)
DispatcherServlet precisa ser implantado: (<servlet> especifica a fonte de dados - <init-param> especifica a localização de springmvc - <load-on-startup>1 significa inicialização padrão</> )
O mapeamento (mapeamento) precisa ser especificado: <servlet-mapping>
Etapa 3: Escreva JSP (recomenda-se colocá-lo na página inicial)
O caminho dos dois jsps é muito interessante aqui, usando a expressão EL, "${pageContext.request.contextPath} /login"
Etapa quatro: Escreva o código do controlador
A classe ModelAndView é usada aqui (deve ser algum tipo de objeto de retorno?, a função é desconhecida aqui) (esse tipo raramente é usado)
No entanto, você precisa se lembrar que o código do controlador precisa herdar a classe Controller
implementa Controller (observe que esta classe Controller é o pacote de importação de mvc.Controller)
Etapa 5: Escreva o arquivo de mapeamento springmvc e coloque o mapeamento neste arquivo antes do controlador com as anotações habilitadas.
Estrutura: Primeiramente, acesse o arquivo web.xml, depois o web.xml informa ao springmvc, e em seguida acessa o código.
Obs: Não existe arquivo applicationContex.xml (o acesso principal é o arquivo web.xml)
4. Suplementos para SpringMVC: (alguns métodos que podem melhorar a eficiência da codificação)
Ele apresenta principalmente os controladores baseados em anotação SpringMVC. Quanto à forma de aceitar/solicitar parâmetros. Aplique a camada de serviço para injeção de dependência.
Controlador baseado em anotação: (precisa modificar a configuração do springmvc e o código da classe do controlador)
A principal vantagem é que não requer mapeamentos de implantação em arquivos de configuração. (Como o primeiro exemplo SpringMVC acima, se você usar controladores anotados, não precisará escrever nada no springmvc. Claro, em um aplicativo springmvc um pouco mais complicado, esse arquivo de configuração (springmvc.xml) ainda é muito útil. Ele pode escrever um analisador de exibição )
Por exemplo: Depois de adicionar o controlador anotado, você precisa adicionar um scanner no arquivo spring.mvc para verificar o pacote onde a anotação está localizada para funcionar. Você também pode armazenar o analisador de exibição posteriormente para omitir o prefixo e o sufixo do mapeamento. (Antes não existe scanner e view parser, um arquivo spring.xml precisa de nome, e caminho, e o caminho é bem longo. Depois de adicionar essas configurações, o caminho só precisa escrever o nome, por exemplo: login e antes: /WEB-INF/jsp/login.jsp)
Alterações após adicionar o controlador de anotação: (A função principal é refletida na classe do controlador)
Alterações na classe do controlador
Antes: O caminho de retorno era um caminho completo: /WEB-INF/jsp/login.jsp
Depois: o retorno é o login. (O código precisa ser adicionado: <RequestMapping("/login")> é colocado na frente da classe (ou na frente do método da classe) , que é equivalente ao nome colocado anteriormente no arquivo de mapeamento. O nome é usado em jsp.)
alterações no arquivo springmvc.xml:
Scanner <context:component-scan> é necessário
Requer o resolvedor de visualização <bean id="" class="InternalResourceViewResolver">
Deve-se observar que a função de <RequestMapping( "/login" )> é equivalente a "${pageContext.request.contextPath} /login" usado em jsp (esses dois são correspondentes), portanto o nome pode ser personalizado, mas deve ser consistente com o nome do objeto retornado em jsp. (Principalmente porque jsp envia dados para o controlador ou troca dados entre si.)
Maneiras comuns de aceitar parâmetros de solicitação: (principalmente métodos usados por classes de controlador)
No primeiro aplicativo SpringMVC simples acima, o tipo ModelAndView foi mencionado na classe do controlador, que é um tipo de controlador tradicional.
O tipo retornado anteriormente é o tipo ModelAndView:
public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) gera exceção {}
Agora aprenda a retornar o tipo String.
string pública login() {}
A maneira mais comum de aceitar parâmetros é aceitar os dados do formulário passados pelo jsp.
Existem várias maneiras de obter parâmetros passados no controlador:
O primeiro método aceita parâmetros de solicitação por meio de um bean de entidade. (√)
Método: Crie uma classe POJO e, em seguida, mantenha o nome do formulário de envio JSP <input> e o nome do atributo da classe POJO iguais. Em seguida, use a classe POJO na classe do controlador e você pode usar seu método get para obtê-lo por meio de user.getUname().
(Parece muito estranho, desde que o nome da classe jsp e POJO permaneça o mesmo, ele pode ser obtido.)
O segundo método recebe parâmetros de solicitação por meio de HttpServletRequest. (Este método é o mesmo que aprendemos anteriormente no JavaWeb.)
String uname = HttpServletRequest.getParameter("uname");
A terceira maneira é receber parâmetros de solicitação por meio de @ModelAttribute. (Isso não obtém parâmetros, é apenas uma maneira simplificada de escrever o tipo de modelo)
É um pouco semelhante ao método do carrinho de compras da sessão aprendido em javaweb, mas é diferente. O método do carrinho de compras da sessão também pode ser usado aqui.
A função de @ModelAttribute é equivalente a model.addAttribute("userForm", user). O uso é semelhante à sessão. Mas pode atribuir o valor de tipo de usuário a userForm.
Quando @ModelAttribute é usado sozinho, também pode ser usado como uma permissão de login de controle. Veja o livro para detalhes: P156 O segundo ponto de conhecimento.
Aplicar @Autowired para injeção de dependência: (estrutura MVC, foco)
Ele incorpora principalmente a ideia do MVC (um tópico especial será dedicado a explicar a importância da estrutura MVC posteriormente), e a camada M (código do modelo) é separada do controlador, que é chamada de camada de serviço. Isso simplifica as responsabilidades do controlador e a camada de controle apenas troca dados com jsp.
A camada de serviço armazena a lógica de negócios e precisa usar @Service (a anotação é um serviço).
Treinamento prático: (importante)
1. Modifique no primeiro aplicativo SpringMVC, usando controladores baseados em anotação.
primeira pergunta:
A anotação @Controller deve ser usada na camada do controlador. Caso contrário, a anotação @RequestMapping da classe controller não será reconhecida em springmvc.xml
Resumo: controller é o nome que troca dados com jsp e é identificado por @RequestMapping.
2. Use o método Bean para passar parâmetros para realizar as páginas de registro e login. Ou use HttpServletRequest para obter os dados enviados pelo formulário.
emmmmm, ultrajante, estou procurando o motivo há muito tempo e sempre pensei que foi importado em algum lugar ou que uma determinada sintaxe era inútil. O motivo acabou sendo que escrevi errado no atributo upass correspondente a upass e Controller na página JSP. Como resultado, não consegui obter a senha . Portanto, o login está falhando! ! ! (upass foi escrito como pass por mim, não há correspondência)
Correção: Por favor, escreva um teste. A maneira que uso aqui é adicionar a função de log e adicionar o log a ela. Em seguida, verifique se os dados do formulário foram obtidos corretamente.
A segunda pergunta: sobre caracteres ilegíveis. Embora o conteúdo do log ("falha no registro") seja impresso, os caracteres chineses estão ilegíveis. Esta questão será discutida mais tarde.
3. Use a estrutura MVC para separar a lógica de negócios com base no segundo aplicativo. E implemente as páginas de registro e login.
O primeiro mal-entendido: escrever a camada Service usa String como o tipo de retorno. (O uso correto é usar o tipo booleano)
Aqui é necessário distinguir o papel da camada de serviço e da camada de controlador. Controller interage com jsp (view), ou seja, o objeto de retorno do Controller deve ser jsp. A camada de Serviço é para separar o negócio da camada de Controlador.
O negócio a ser separado aqui é login e registro. Em seguida, o Serviço entregará o resultado retornado ao Controlador para julgamento, que tipo deve ser?
Ele deve ser do tipo booleano e retornar true e false se o login for bem-sucedido para a camada Controller para julgar qual página JSP escolher.
O segundo ponto de conhecimento: a forma de injeção de dependência. Para injetar a camada de serviço na camada do controlador, você precisa adicionar um scanner no arquivo de configuração xml para verificar o pacote de serviço.
Existem alguns usos que requerem atenção adicional:
@ModelAttribute = Modelo modelo model.addAttribute（）；
Este uso é mais poderoso do que a sessão em tempo real. O uso do carrinho de compras da sessão deve ser salvo uma vez antes de poder ser usado e sempre será salvo no carrinho de compras. Não foi até mais tarde que os dados o substituíram.
No caso de ModelAttribute, ele é chamado uma vez e pode ser gerado usando expressões EL. Muito conveniente.
(Lembra-se do treinamento de código de verificação fornecido no aprendizado da Web Java? Naquela época, usávamos sessões para armazenar códigos de verificação e o resultado era que cada código de verificação de entrada era uma imagem do último código de verificação. É por isso que a sessão deve ser salva uma vez antes de poder ser usada. Agora, esse problema deve ser resolvido depois de aprender ModelAttribute.)
Cinco, tipo de conversão e formatação (pode ser ignorado, para aprender a vinculação de dados)
Geralmente, os dados enviados por formulários ou jsp são do tipo String, caso você queira convertê-los em int ou outros tipos. A conversão de tipo é necessária. No estudo anterior do Java Web, criamos o método da classe Servlet, no qual a conversão de tipo pode ser realizada por meio da conversão de tipo forte. Agora aprenda como implementá-lo na estrutura do Spring MVC.
No Spring MVC, não é a classe Servlet, mas sim a classe Controller. Ele fornece duas maneiras: Conversor (conversor de tipo embutido) e conversor de tipo personalizado. Liberdade de escolha.
O uso mais simples é na classe Controller, o tipo de parâmetro de entrada corresponde ao tipo JavaBean.
Por exemplo:
public String add(String name，double price，int number){ return "sucess"； }
(nome, preço e número são todos tipos correspondentes em JavaBean.)
Conversor de tipo personalizado: (não muito usado)
Precisa criar uma classe do tipo de conversão personalizada. Classe GoodsConverter (personalizada)
Em seguida, herde Converter<String, GoodsModel>
String é o tipo de dados enviado pelo formulário e GoodsModel é o tipo POJO. Converta todos os tipos String em tipos POJO.
Precisa usar: bens.setname(StringValues[0]),
bens.setPrice(Double.parseDouble(StringValues[0])) // A conversão de tipo forte ainda é usada
Por fim, no arquivo de configuração springmvc.xml, registre o conversor de tipo definido.
Dessa forma, você pode usar esse método em jsp.
6. Associação de dados e biblioteca de tags de formulário (ênfase)
A vinculação de dados é mais importante e geralmente é usada em combinação com bibliotecas de tags de formulário. Então vamos conversar juntos. Além disso, a interação de dados do JSON será expandida. (Essa interação JSON é, na verdade, o uso de AJAX. Também falamos sobre isso no Java Web, que é um aplicativo JavaScript criado em um arquivo JSP. Mas, como há mais controladores, seu uso aumentou.)
Ligação de dados combinada com biblioteca de tags de formulário:
A vantagem da vinculação de dados é que não há necessidade de realizar conversão de tipo de dados, ou seja, a parte de conhecimento acima pode ser ignorada. A execução da vinculação de dados pode corresponder um a um aos tipos de dados interativos do JSP e do controlador (conversão automática).
O método principal: insira a tag de vinculação na página JSP. Os dados do Make JSP podem ser vinculados ao controlador interno.
( Uma pequena dúvida , quando não aprendemos a ligação de dados anteriormente, os dados JSP foram originalmente interagidos com o Controlador, então qual é o significado de aprender a ligação de dados para sua ligação? Embora não seja muito compreensível agora, devo dizer que a maneira de usar a ligação de dados é o uso principal e ainda precisamos estudar esta parte com cuidado e nos acostumar com seu uso)
A vinculação de dados altera principalmente o código do JSP. Algumas tags são necessárias. precisa de memória
Etiqueta do formulário:
<form:form modelAttribute=" user" method="post" action=" "> (classe de ação do controlador correspondente)
modelAttribute é a associação de atributo. Geralmente, essa associação é o objeto da classe POJO (para que o tipo POJO e o tipo String carregado possam ser convertidos automaticamente).
etiqueta de entrada:
<form:input path="userName" />
O atributo path é vinculado ao atributo userName do objeto de usuário (o usuário é vinculado à tag de formulário anterior. userName é, na verdade, um atributo no POJO. Essa associação pode converter o tipo automaticamente.)
A senha, tags textarea e tags de entrada são usadas da mesma forma:
É substituir a entrada por seu próprio tipo.
<form:password path="userName" />
select tag: (no aprendizado de front-end, esta é uma caixa suspensa)
<form:select path="XXX" items="xxx" />
或者：<form:select path="XXX" items="xxx" > <option value="XXX" >XXX</option> </form:select>
Todos os itens ou marcas de opção especificam uma coleção e o conteúdo dessa coleção geralmente é inserido por você. Indica o conteúdo da caixa suspensa.
As caixas de seleção têm dois rótulos:
tag da caixa de seleção: você precisa inserir o conteúdo do valor um por um.
Uso: <form:checkbox path="xxx" value="xx"/> xx geralmente precisa escrever vários conteúdos
tag checkboxes: Este é um grupo de opções, você pode colocar todo o conteúdo no grupo de opções (simplifica a quantidade de código)
Uso: <form:checkbox path="xxx" items="xx"/> items é uma coleção
Resumo: path é especificar os atributos no POJO correspondente. itens ou valor é uma coleção ou um único conteúdo definido por si mesmo.
Treinamento:
Realize o aplicativo na página P175 do livro: Use formulários para realizar a vinculação de dados.
Análise de código:
Etapa 1: Importar dependências. (Observe, porque o conhecimento de tags JSTL é usado em userList.jsp, duas dependências adicionais precisam ser importadas: taglibs-standard-impl, pacote taglibs-standard-spec)
JSTL é na verdade: JSP Standard Tag Library
Etapa 2: Configure o arquivo web.xml e implemente o DispatcherServlet como antes. Um filtro de codificação é adicionado posteriormente para evitar que caracteres chineses ilegíveis apareçam nos dados trocados entre o JSP e o Controlador.
Etapa 3: Configure o POJO, a camada de serviço e a camada de controle. O método é quase o mesmo de antes. Aqui nós apresentamos principalmente dois pontos do Controller que precisam ser observados, um é sobre @ModelAttribute User user é equivalente a = model.addAttributer("user", new User());
Mas esse uso: Recomenda-se usar o último, pois um elemento que precisa ser usado no JSP é modelAttribute = "user". Este usuário é um objeto do POJO (classe User). Se você usar o método anterior, @ModelAttribute User user. Ele não pode obter o objeto do usuário no JSP.
O segundo ponto: Trata-se da associação entre o valor dos itens na biblioteca de tags em JSP e o Controller. Existem duas maneiras de especificar o valor de Items na classe Controller. Uma maneira de usar String[] no POJO, esse método precisa usar HashMap<String, String> (este é um relacionamento de par chave-valor). Um é representado por String em POJO, não por coleção. Então você precisa estar no Controller, new String[ ]{ "", "", ""};
(Observe que o último método é mais simples que o anterior e pode reduzir a quantidade de código.)
Passo 4: Configure a camada View. (O foco dos pontos de conhecimento nesta seção reflete principalmente as características da ligação de dados neste JSP.)
Um é o formulário de ligação (o atributo de resposta é o objeto da classe POJO declarada pelo Controlador)
Um é ${property} correspondente à propriedade da classe POJO.
Etapa 5: Configurar Spring.mvc. É o mesmo que a configuração do ponto de conhecimento na seção anterior.
Interação de dados JSON: Livro P183, leia o livro para aprender sobre ele. Não é muito usado e aprendi um pouco antes. Este é um aplicativo JavaScript.
Resumo: Os pontos de conhecimento da vinculação de dados são mais usados e precisam ser compreendidos. Principalmente o que está vinculado e o uso de model.addAttribute(" ", new POJO() ).