Nas postagens anteriores do blog, concluímos todas as funções do módulo de usuário; portanto, nas próximas postagens do blog, concluiremos o módulo de função de gerenciamento de classificação.
Vamos primeiro olhar para os pontos funcionais do gerenciamento de classificação no back -end
O gerenciamento da categoria de back-end é na verdade um gerenciamento de produtos, que é dividido principalmente em adicionar categorias, atualizar nomes de categorias, obtendo nós de categoria no mesmo nível e obtendo IDs de categoria e categorias de sub-nó.
1. Módulo de gerenciamento de classificação-implementação de funções de categoria adicionadas
Vejamos primeiro a camada de serviço
// Adicionar categoria public serverResponse addCategory (categoryName de string, número inteiro parentid) {if (parentid == null || stringUtils.isblank (categoryName)) {return serverResponse.createByerRormessage ("erro de parâmetro"); } Categoria categoria = nova categoria (); category.setName (categoryName); category.setParentID (ParentID); category.setStatus (true); int rowCount = categorymapper.insert (categoria); if (rowcount> 0) {return serverResponse.createbysucesMessage ("Adicionar categoria com sucesso"); } retornar serverResponse.createbyerRorMessage ("Adicionar falha na categoria"); }É relativamente simples adicionar categorias. É um pouco semelhante à lógica de registro anterior. Primeiro, verifique se existe o nome da categoria e o pai transmitido do front end. Se não existir, o erro do parâmetro será solicitado. Caso contrário, continue usando as instâncias do Javabean para aumentar a categoria. Da mesma forma, depois de adicioná -lo ao Javabean, insira o resultado no banco de dados. Se o número de linhas efetivas retornadas for maior que 0, a categoria será adicionada com sucesso, caso contrário, a categoria será adicionada falhará.
Vejamos a camada do controlador
/ ** * Gerencie categoria-add category * @param categoryName * @param parentid * @param sessão * @return */ @requestMapping (value = "add_category.do") @ResponseBody Public ServerResponse AddClateGory (string categoryName, @requestParam (value = "" ParentId ", defensor". (Usuário) session.getAttribute (const.current_user); if (user == null) {return serverResponse.createbyerrorCodemessage (Responsecode.need_login.getCode (), "o usuário não está conectado, faça o login"); } // Verifique se é um administrador if (iuserService.checkadmin (usuário) .issuccess ()) {return iticegoryservice.addcategory (categoryName, parentid); } else {return ServerResponse.CreateByerRorMessage ("Sem operação de permissão, faça login no administrador"); }}Primeiro de tudo, existe um lugar diferente com o valor do valor do requestMapping, que possui apenas um nome de interface, mas não especifica o método de solicitação de interface, porque o módulo de gerenciamento de categoria é um gerenciamento de plano de fundo do administrador do site e pertence ao módulo de segundo plano. Para módulos de segundo plano, eles são usados por funcionários internos da empresa e não precisam ser divulgados ao mundo exterior, para que você possa usar o método GET padrão para solicitar.
A lógica geral do gerenciamento de funções em segundo plano é primeiro verificar se o usuário está no estado de login. Se o usuário estiver no estado de login, verifique se o login atualmente é um administrador do site. Se não for um administrador, você não tem o direito de executar operações de gerenciamento relevantes. Se for um administrador, você pode executar o gerenciamento de segundo plano. Na lógica do gerenciamento de funções em segundo plano, geralmente é suficiente retornar diretamente o processamento de métodos resulta na camada de serviço.
No método acima, é necessário determinar o status de login do usuário, por isso é necessário introduzir serviços de usuário e depois chamar diretamente o método correspondente.
2. Classificação Módulo de gerenciamento de implementação da função de nome da categoria de atualização
Vejamos primeiro a camada de serviço
// Atualizar nome da categoria Public ServerResponse UpdateCategoryName (string categoryName, categoryId inteiro) {if (categoryId == null || stringUtils.isblank (categoryName)) {return serverResponse.createByerRormessage ("Atualizar o parâmetro de parâmetros da categoria"); } Categoria categoria = nova categoria (); category.setId (categoryId); category.setName (categoryName); int rowCount = categorymapper.UpDateByPrimaryKeySelective (categoria); if (rowcount> 0) {return serverResponse.createbysucesMessage ("Nome da categoria de atualização com sucesso"); } retornar serverResponse.createbyerRorMessage ("Nome da categoria de atualização falhou"); }É exatamente o mesmo que a lógica de processamento anterior, e não entrarei em detalhes aqui.
Vejamos a camada do controlador
/ ** * Gerencie o nome da categoria de update de categoria * @param categoryName * @param categoryId * @param sessão * @return */ @requestMapping (value = "update_category_name") @ResponseBody Public ServerResponse UpdateNameName (string categoryName, categoryid, htppsess) (Usuário) session.getAttribute (const.current_user); if (user == null) {return serverResponse.createbyerrorCodemessage (Responsecode.need_login.getCode (), "o usuário não está conectado, faça o login"); } if (iuserService.checkadmin (user) .issuccess ()) {return iicategoryservice.updateCategoryName (categoryName, categoryId); } else {return ServerResponse.CreateByerRorMessage ("Sem operação de permissão, faça login no administrador"); }}É exatamente o mesmo que a lógica de processamento anterior, e não entrarei em detalhes aqui.
3. Módulo de gerenciamento de classificação-implementação da função de obter o nó da categoria horizontal (pesquisa de produto de back-end)
Camada de serviço
// categoria de consulta parental-nó nó public serverResponse <list <category>> getChildrenParalCategory (categoryId inteiro) {list <category> categoryList = categorymapper.SelectCategoryChildrenbyparentId (categoryId); if (collectionutils.isEmpty (categoryList)) {Logger.info ("A subcategoria da classificação atual não foi encontrada"); } retornar serverResponse.createbysuccess (categorylist); }Ao processar um conjunto de informações do produto, ele geralmente usa o método de coleta. Seu aplicativo é diferente, dependendo do tipo de coleção. Aqui, estou usando coleções de listas. Primeiro, considerando que as coleções de listas são convenientes para operações e gerenciamento de travessia. Por ser para gerenciar produtos, o tipo genérico da coleção de listas é especificado como categoria, e a consulta de ID do produto é realizada através do método SelectCategoryChildrenbyparentid do categorymapper. No julgamento lógico, use a classe de ferramentas Coleção encapsulada em Java para determinar se o resultado do retorno da coleção está vazio. Se estiver vazio, imprima uma linha de logs, caso contrário, a execução bem -sucedida do resultado da lista categoria poderá ser retornada. O Logger aqui é uma ferramenta de impressão de log que você encapsula. Deixe -me mencionar brevemente seu uso.
private org.slf4j.Logger logger = LoggerFactory.getLogger(CategoryServiceImpl.class);
Observe que este madeireiro usa o pacote SLF4J, não exporte o pacote errado e, em seguida, LoggerFactory.getLogger (classe), você precisa passar por um parâmetro, que é a classe que atualmente precisa imprimir o log, como categoryServiceImpl.class aqui. Você pode ver os resultados da impressão do log no console.
Camada do controlador
/ ** * Gerencie os nós da categoria-ganha da mesma categoria * @param categoryId * @param session * @return */ @requestMapping (value = "get_category.do") @ResponseBody Public ServerResponse getChildRenparalCategory (@RequestParam (value "categoryId", defaultalue = ")") " (Usuário) session.getAttribute (const.current_user); if (user == null) {return serverResponse.createbyerrorCodemessage (Responsecode.need_login.getCode (), "o usuário não está conectado, faça o login"); } if (iuserService.checkadmin (user) .issuccess ()) {return iticeGoryService.getChildrenParalCategory (categoryId); } else {return ServerResponse.CreateByerRorMessage ("Sem operação de permissão, faça login no administrador"); }}Por razões práticas, quando a quantidade de mercadorias é 0, não há necessidade de gerenciar a categoria de produto, portanto, o defaultValue = "0" anotado pelo requestParam é usado para especificar o valor padrão de um parâmetro. O restante da lógica é exatamente o mesmo de antes.
4. Módulo de gerenciamento de classificação Retira a implementação do ID da categoria e das funções de subordinados
Olhe para a camada de serviço
public ServerResponse <Lista <Teger>> SelectCategoryandChildrenById (categoryId inteiro) {Set <Category> categorySet = Sets.NewHashSet (); findChildCategory (categoryId, categoryset); Lista <Teger> categoryIdList = lists.newArrayList (); if (categoryId! = null) {for (categorys categoryiTem: categorySet) {categoryidlist.add (categoryiTem.getId ()); }} retornar serverResponse.createBySuccess (categoryIdlist); } // algoritmo recursivo para calcular o conjunto privado do nó filho <categoria> findChildCategory (categoryId inteiro, set <category> categorySet) {category category = categorymapper.selectByPrimaryKey (categoryId); if (categoria! = null) {categorySet.add (categoria); } // Encontre a lista de nós filhos <category> categoryList = categorymapper.SelectCategoryChildrenbyparentId (categoryId); para (categoria categoryItem: categorylist) {findChildCategory (categoryiTem.getId (), categoryset); } Return CategorySet; }O método principal é o SelectCategoryandChildrenbyId, e o método auxiliar é o FindChildCategory, que calcula os nós filhos por recursivamente. No método auxiliar, as informações de ID do produto são consultadas através da categoryID e adicionadas à coleção de conjuntos e, em seguida, os nós da criança do produto são percorridos pelo loop foreach e, finalmente, o conjunto de categorias é retornado. No método principal, o método auxiliar é chamado, o ID do produto e os nós filhos são encontrados e, em seguida, o ID do produto e os nós filhos são colocados na coleção de listas, e o resultado que queremos é percorrer o loop foreach e, finalmente, a categoryidlist é retornada diretamente.
Camada do controlador
/ ** * Gerencie categoria ID da categoria e do nó filho * @param categoryId * @param sessão * @return */ @requestMapping (value = "get_deep_category.do") @ResponseBody Public ServerResponse getCateGoryandDeepChildRencateGory (@requestParam (value = "categoryIdid" sessão) {user user = (user) session.getAttribute (const.current_user); if (user == null) {return serverResponse.createbyerrorCodemessage (Responsecode.need_login.getCode (), "o usuário não está conectado, faça o login"); } if (iuserService.checkadmin (usuário) .issuccess ()) {return iicateGoryService.SelectCategoryandChildrenById (categoryId); } else {return ServerResponse.CreateByerRorMessage ("Sem operação de permissão, faça login no administrador"); }}É exatamente o mesmo que o processamento lógico anterior de obter os nós de mesmo nível na categoria, para que não entre em detalhes aqui.
5. Módulo de usuário suplementar
No módulo de gerenciamento de categoria de segundo plano, um método para verificar se o usuário atualmente conectado é um administrador é usado. Isso está escrito no módulo de usuário. Esqueci de escrever antes, então farei um suplemento aqui.
Camada de serviço do módulo de usuário
// Antecedentes do usuário - Verifique se é um administrador public serverResponse checkadmin (usuário do usuário) {if (user! = Null && user.getRole (). Intvalue () == const.role.role_admin) {return serverResponse.createBySuccess (); } retornar serverResponse.createbyerror (); }Como está relacionado aos administradores, ele só precisa executar processamento lógico na camada de serviço e não precisa ser declarado no controlador. Este método passa em um objeto de usuário e faz julgamentos de permissão através da interface de função encapsulada. Se o valor de retorno for admin, é considerado um administrador e o retornará diretamente, caso contrário, falhará.
Tendo escrito isso, o módulo de gerenciamento de categoria em segundo plano está concluído. Como o módulo possui menos interfaces funcionais, demorou muito tempo para escrevê -las em uma postagem no blog, o que também facilita para todos aprender o módulo de gerenciamento de categoria de back -end ao mesmo tempo.
Na próxima postagem do blog, continuaremos promovendo o progresso do projeto e traremos o desenvolvimento de módulos de produtos de back-end. Esperamos que todos acompanhem o progresso.
Se você encontrar algum problema na sua postagem anterior, deixe uma mensagem e feedback e tentarei o meu melhor para resolver o problema para você.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.