Explicação detalhada da biblioteca de tags lógicas do Struts

1.lógica:vazia
A tag logic:empty é usada para determinar se está vazio. Se estiver vazio, o conteúdo incorporado no corpo da tag será processado. Esta tag é usada nas seguintes situações:
Quando o objeto Java é nulo Quando o objeto String é "" Quando isEmpty() no objeto java.util.Collection retorna true Quando isEmpty() no objeto java.util.Map retorna true O exemplo de código a seguir ilustra a lógica: O tag vazia determina se a coleção pessoas está vazia:
<logic:empty name="listForm" propriedade = "pessoas">
<div>A coleção de pessoas está vazia!</div>
</logic:vazio>

2.lógica: não vazia
A aplicação desta tag é exatamente o oposto da tag logic:empty.

3. lógica: igual
Esta tag é o operador de comparação igual.
por exemplo,1. Compare o atributo de status do usuário para ver se é 1. Se for 1, produza "habilitado";
por exemplo,2. Se o valor no exemplo acima for obtido dinamicamente, por exemplo, ele precisa ser gerado por meio de bean:write, porque o struts não suporta aninhamento de rótulos, EL pode ser usado para resolver esse problema.
lógica: igual
O que queremos apresentar aqui não é apenas a tag logic:equal(=), mas um tipo de tags que completam operações de comparação, incluindo:
lógica: igual (=)
lógica:notEqual(!=)
lógica:maiorIgual(>=)
lógica:menosIgual(<=)
lógica: ralador que (>)
lógica: menos que (<)
O uso deste tipo de tag é semelhante. Apresentamos apenas a tag logic:equal e deixamos o resto com você.
logic:equal é usado para determinar se eles são iguais. Se for igual, o conteúdo incorporado no corpo da tag será processado. Esta tag é usada nas seguintes situações:
Compara se o valor do cookie especificado pelo atributo cookie desta tag é igual ao valor do atributo value desta tag.
Compara se o valor do cabeçalho especificado pelo atributo header da tag é igual ao valor do atributo value da tag.
Compara se o JSP Bean especificado pelo atributo name da tag é igual ao atributo value da tag (o atributo property não aparece) ou compara se o valor do atributo property do JSP Bean especificado pelo atributo name da tag é igual ao atributo value da tag Os valores são iguais.
Compara se o valor do parâmetro especificado pelo atributo de parâmetro da tag (na solicitação) é igual ao atributo de valor da tag.

4. lógica: notEqual
O significado desta tag é oposto a logic:equal, e seu uso é semelhante, o que é omitido.

5. lógica:avançar
Esta tag é usada para implementar a orientação da página e encontrar o encaminhamento global dos arquivos de configuração. Redirecionamento global no arquivo struts-config.xml
por exemplo.

6. lógica: maiorIgual
É o operador de comparação maior ou igual.
por exemplo. Quando a pontuação de um aluno é maior ou igual a 60, produza "aprovado":
<logic:greaterEqual name="student" property="scores" value="60">
passar
</logic:greaterEqual>

7. lógica: maior que
Este é o operador de comparação maior que e seu uso é o mesmo que logic:greaterEqual;

8. lógica: menos igual
Este é um operador de comparação menor ou igual e seu uso é o mesmo que logic:greaterEqual;

9. lógica: menos que
Este é um operador de comparação menor e seu uso é o mesmo que logic:greaterEqual;

10. lógica:correspondência
Esta tag compara objetos quanto à igualdade;
A tag logic:match é usada para lidar com problemas de correspondência de substring.
Se o valor especificado corresponder à tag, o conteúdo do corpo da tag será criado. Esta tag é usada nas seguintes situações:
Verifica se o cookie com o nome especificado corresponde ao valor desta tag.
Verifica se o cabeçalho com o nome especificado corresponde ao valor desta tag.
Verifica se o JSP Bean com o nome especificado corresponde ao valor da tag ou verifica se o valor do atributo de propriedade no JSP Bean com o nome especificado corresponde ao valor da tag.
Verifica se o valor do parâmetro do nome especificado na solicitação corresponde ao valor da tag.
O código a seguir ilustra o uso típico da tag logic:match:
por exemplo0.

eg1. Verifique se o atributo name no escopo da solicitação contém a string "hello":

por exemplo2. Verifique se o atributo name no escopo da solicitação tem "hello" como string inicial:

por exemplo3.

11. lógica:notMatch
A aplicação da tag logic:notMatch é exatamente o oposto da tag logic:match.
Esta tag é usada para comparar se os objetos são diferentes. Ela tem o significado oposto de logic:match e seu uso é semelhante.

12. lógica: mensagemPresente
Esta tag é usada para determinar se o objeto ActionMessages/ActionErrors existe;
A tag logic:messagesPresent é usada nas seguintes situações:
Há um objeto ActionMessages no escopo da solicitação e o atributo de propriedade do rótulo corresponde à propriedade em ActionMessages.
Há um objeto ActionErrors no escopo da solicitação e o atributo de propriedade do rótulo corresponde à propriedade em ActionErrors.
Existe um objeto String, converta-o (construa-o) em ActionMessage e adicione-o a ActionMessages.
Existe um objeto String Array, converta cada String na matriz em um ActionMessage e, em seguida, adicione-o a ActionMessages.
Quando o valor do atributo message da tag for verdadeiro, Globals.MESSAGE_KEY será utilizado como chave para busca de Message no escopo da requisição. não aparecer, o valor padrão é Globals.ERROR_KEY.
O código a seguir ilustra o uso típico da tag logic:messagesPresent:
por exemplo1.

por exemplo2.
Se existirem informações de erro, produza tudo isso:

13. lógica: mensagensNotPresent
A aplicação do rótulo logic:messagesNotPresent é exatamente o oposto da aplicação de logic:messagesPresent.
Esta tag é usada para determinar se o objeto ActionMessages/ActionErrors não existe. O método de uso é semelhante a logic:messagePresent.

14. lógica: presente
Esta tag é usada para determinar se os parâmetros passados ​​pelo objeto de solicitação existem.
Se o valor especificado aparecer, a tag criará o conteúdo do corpo da tag. Esta tag é usada nas seguintes situações:
Verifica se um cookie com o nome especificado está presente.
Verifica se aparece um cabeçalho com o nome especificado.
Verifica se o JSP Bean com o nome especificado aparece ou verifica se o atributo de propriedade no JSP Bean com o nome especificado aparece.
Verifique se o parâmetro com o nome especificado na solicitação aparece.
Verifica se o usuário atualmente autenticado está associado à função de segurança especificada.
Verifica se o assunto atualmente autenticado possui o nome especificado.
eg1. Quando o objeto de usuário e seu atributo name existem na solicitação, a string correspondente é gerada:

por exemplo,2. Se houver um JavaBean chamado "hello", produza a string correspondente:
<logic:present name="olá" >
Existe um JavaBean chamado "olá".
</logic:presente>
por exemplo3.
<logic:present header="user-agent">
obtivemos um cabeçalho de agente de usuário.
</logic:presente>
por exemplo4.
O exemplo de código a seguir mostra a tag logic:present verificando se um cabeçalho com o nome especificado User-Agent está presente:
<logic:present header="User-Agent">
Seu navegador é <bean:header id="userAgent" name="User-Agent"/>
<bean:write name="userAgent"/>. <br/>
</logic:presente>
15. lógica: não presente
Esta tag é usada para determinar se os parâmetros passados ​​pelo objeto de solicitação não existem. O significado é oposto a logic:present e o método de uso é semelhante.
A aplicação da tag logic:notPresent é exatamente o oposto da tag logic:present.
16. lógica: iterador
Usado para exibir valores de listas como coleções (List, ArrayList, HashMap, etc.).
A tag logic:iterate é usada para iterar uma coleção. Você pode usar o seguinte método para especificar a coleção a ser iterada para esta tag:
Use uma expressão de tempo de execução cujo valor seja um conjunto.
Use o atributo name para fazer referência a um Bean JSP, que por si só é uma coleção.
Utilize o atributo name para fazer referência a um JSP Bean Um dos atributos deste JSP Bean é uma coleção. Nesse caso, você pode utilizar a propriedade em combinação para especificar a coleção.
A coleção mencionada acima pode ser:
Matriz de tipo de objeto ou tipo atômico.
Implementação de java.util.Collection, incluindo ArrayList, Vector.
Implementação de java.util.Enumeration.
Implementação de java.util.Iterator.
Implementação de java.util.Map, incluindo HashMap, Hashtable e TreeMap.
Se a coleção que você itera contém valores nulos, você precisa tomar certas medidas porque logic:iterate não criará objetos no escopo da página. Geralmente, use a tag <logic:present> ou <logic:notPresent> para julgar.
A seguir está o relacionamento de referência do objeto e parte do código para um exemplo de lógica: iterar iterando ArrayList:
Figura 3. Referências a objetos em logic:iterate A lista de pessoas no diagrama é preenchida em ListAction. Aqui, três objetos Person são simplesmente adicionados. O código específico é o seguinte:

O resultado da saída do rótulo é:
00001 -> Zhao Chen
00002-->Li Weifang
00003 -> Wang Wei
por exemplo,1. Mostre os nomes dos usuários na lista de usuários (empList) um por um:
<logic:iterate id="emp" name="empList">
<bean:write name="emp" property="name"/><br>
</logic:iterar>
por exemplo,2. Produza os nomes de dois usuários começando em 1 da lista de usuários.
<logic:iterate id="emp" name="empList" indexId="index" offset="1" length="2">
<bean:write name="index"/>.<bean:write name="emp" property="name"/><br>
</logic:iterar>
ex.3. Exemplo aninhado de tag logic:iterator
<logic:iterate id="emp" indexId="index" name="empList">
<bean:write name="index"/>. <bean:write name="emp" property="name"/><br>.
<logic:iterate id="address" name="emp" property="addressList" length="3" offset="1">
<bean:write nome="endereço"/><br>
</logic:iterar>
</logic:iterar>
17. lógica: redirecionar
Esta tag é usada para implementar o redirecionamento de página e pode passar parâmetros.
por exemplo.
18. Comparação de lógica:forward e lógica:redirect
-------------------------------------------------- -------------------------------------------------- ----------
Colocar as duas ações adiante e redirecionar juntas é mais propício à compreensão. Por esse motivo, as duas tags logic:forward e logic:redirect também são introduzidas aqui.

Vamos ver a diferença entre essas duas ações:
O encaminhamento é executado dentro do servlet. O navegador não terá conhecimento dessa ação e o URL original não será alterado. Se o navegador for recarregado, ele simplesmente repetirá a solicitação original.
O redirecionamento é dividido em duas etapas: a primeira etapa é que o aplicativo da web informe ao navegador o segundo URL e, em seguida, o navegador envie uma solicitação para o segundo URL.
O redirecionamento é mais lento que o encaminhamento porque o navegador precisa fazer uma segunda solicitação. Observe também que os beans no primeiro escopo de solicitação (escopo da solicitação) não são visíveis para a segunda solicitação.
Depois de entender as diferenças descritas acima, você saberá quando usar a tag logic:forward e quando usar a tag logic:redirect.
A tag logic:forward completa PageContext.forward() ou HttpServletResponse.sendRedirect(). A tag logic:redirect completa HttpServletResponse.sendRedirect().
Ao usar a tag logic:redirect, podemos construir os parâmetros baseurl e de consulta da mesma forma que usamos html:link. Se você estiver interessado, pode consultar a tag html:link.