Java 类目树形结构查询

最新推荐文章于 2024-05-22 22:42:44 发布
最新推荐文章于 2024-05-22 22:42:44 发布
阅读量2.2k 收藏 18
点赞数 1
分类专栏： 基础框架 文章标签： mybatis 查询类目树形结构 List转树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37583655/article/details/117518611
版权

Java 类目树形结构查询

1. 初始化数据库

1.1 类目表初始化

-- -------------------------------------
-- 类目测试 Table structure for category
-- -------------------------------------
DROP TABLE IF EXISTS `category`;
CREATE TABLE `category`  (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID主键',
  `name` varchar(64) COMMENT '名称',
  `pid` bigint(20) NOT NULL COMMENT '上级id',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '类目' ROW_FORMAT = Dynamic;

select * from category;
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (1, '电子产品', 0);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (2, '手机', 1);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (3, '小米手机', 2);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (4, '苹果手机', 2);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (5, '电脑', 1);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (6, '联想电脑', 5);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (7, '戴尔电脑', 5);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (8, '家用电器', 0);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (9, '空调', 8);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (10, '美的空调', 9);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (11, '格力空调', 9);

2. 构建项目

2.1 项目结构

在这里插入图片描述

2.2 代码文件

CategoryController

package com.example.category.controller;

import com.example.category.entity.Category;
import com.example.category.entity.CategoryVo;
import com.example.category.service.CategoryService;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;
import com.example.category.entity.Response;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.annotation.Resource;

import static org.apache.ibatis.ognl.DynamicSubscript.all;

/**
 * (Category)控制层
 *
 * @author makejava
 * @since 2021-06-03 07:20:41
 */
@RestController
@RequestMapping("/category")
public class CategoryController {
    /**
     * 服务对象
     */
    @Resource
    private CategoryService categoryService;

    /**
     * 通过主键查询单条数据
     *
     * @param category 参数对象
     * @return 单条数据
     */
    @RequestMapping(value = "get", method = RequestMethod.GET)
    public Response<Category> selectOne(Category category) {
        Category result = categoryService.selectById(category.getId());
        if (result != null) {
            return Response.createSuccessResponse("查询成功", result);
        }
        return Response.createErrorResponse("查询失败");
    }

    /**
     * 新增一条数据
     *
     * @param category 实体类
     * @return Response对象
     */
    @RequestMapping(value = "insert", method = RequestMethod.POST)
    public Response<Category> insert(@RequestBody Category category) {
        int result = categoryService.insert(category);
        if (result > 0) {
            return Response.createSuccessResponse("新增成功", category);
        }
        return Response.createErrorResponse("新增失败");
    }

    /**
     * 修改一条数据
     *
     * @param category 实体类
     * @return Response对象
     */
    @RequestMapping(value = "update", method = RequestMethod.PUT)
    public Response<Category> update(@RequestBody Category category) {
        Category result = categoryService.update(category);
        if (result != null) {
            return Response.createSuccessResponse("修改成功", result);
        }
        return Response.createErrorResponse("修改失败");
    }

    /**
     * 删除一条数据
     *
     * @param category 参数对象
     * @return Response对象
     */
    @RequestMapping(value = "delete", method = RequestMethod.DELETE)
    public Response<Category> delete(Category category) {
        int result = categoryService.deleteById(category.getId());
        if (result > 0) {
            return Response.createSuccessResponse("删除成功", null);
        }
        return Response.createErrorResponse("删除失败");
    }

    /**
     * 查询全部
     *
     * @return Response对象
     */
    @RequestMapping(value = "selectAll", method = RequestMethod.GET)
    public Response<List<Category>> selectAll() {
        List<Category> categorys = categoryService.selectAll();
        if (categorys != null) {
            return Response.createSuccessResponse("查询成功", categorys);
        }
        return Response.createErrorResponse("查询失败");
    }

    /**
     * 查询树形结构
     *
     * @return Response对象
     */
    @RequestMapping(value = "selectTree", method = RequestMethod.GET)
    public Response<List<CategoryVo>> selectTree() {
        List<CategoryVo> categoryVoList = categoryService.selectTree();
        if (categoryVoList != null) {
            return Response.createSuccessResponse("查询成功", categoryVoList);
        }
        return Response.createErrorResponse("查询失败");
    }

    /**
     * 分页查询
     *
     * @param start 偏移
     * @param limit 条数
     * @return Response对象
     */
    @RequestMapping(value = "selectPage", method = RequestMethod.GET)
    public Response<List<Category>> selectPage(Integer start, Integer limit) {
        List<Category> categorys = categoryService.selectPage(start, limit);
        if (categorys != null) {
            return Response.createSuccessResponse("查询成功", categorys);
        }
        return Response.createErrorResponse("查询失败");
    }

}

Category

package com.example.category.entity;

import java.io.Serializable;

/**
 * (Category)实体类
 *
 * @author makejava
 * @since 2021-06-03 07:20:41
 */
public class Category implements Serializable {
    private static final long serialVersionUID = 404235573904070855L;
    /**
    * 主键ID
    */
    private Integer id;
    /**
    * 名称
    */
    private String name;
    /**
    * 上级id
    */
    private Integer pid;

    public Category() {
    }

    public Category(Integer id, String name, Integer pid) {
        this.id = id;
        this.name = name;
        this.pid = pid;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    @Override
    public String toString(){
        return "Category {" +
            "id : " + id + ", " +
            "name : " + name + ", " +
            "pid : " + pid + ", " +
        '}';
    }
}

CategoryVo

package com.example.category.entity;

import java.util.List;

/**
 * @author zrj
 * @date 2021/6/3
 * @since V1.0
 **/
public class CategoryVo {

    /**
     * 主键ID
     */
    private Integer id;
    /**
     * 名称
     */
    private String name;
    /**
     * 上级id
     */
    private Integer pid;

    /**
     * 子节点
     */
    private List<CategoryVo> children;

    public CategoryVo() {
    }

    public CategoryVo(Integer id, String name, Integer pid, List<CategoryVo> children) {
        this.id = id;
        this.name = name;
        this.pid = pid;
        this.children = children;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public List<CategoryVo> getChildren() {
        return children;
    }

    public void setChildren(List<CategoryVo> children) {
        this.children = children;
    }

    @Override
    public String toString() {
        return "CategoryVo{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pid=" + pid +
                ", children=" + children +
                '}';
    }
}

Response

package com.example.category.entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author zrj
 * @date 2021/6/2
 * @since V1.0
 **/
@Component
public class Response<T> {

    private static ResponseCode responseCode;
    /**
     * 提示消息
     */
    private String message;

    /**
     * 具体返回的数据
     */
    private T data;

    /**
     * 状态码
     */
    private String code;

    private Response(String code, String message, T data) {
        this.message = message;
        this.code = code;
        this.data = data;
    }

    private Response(String code, String msg) {
        this.message = msg;
        this.code = code;
    }

    @Autowired
    public Response(ResponseCode responseCode) {
        Response.responseCode = responseCode;
    }

    /**
     * 返回成功Response对象
     *
     * @param successMessage 成功提示信息
     * @param data           需要返回的数据
     * @return 成功信息
     */
    public static <T> Response<T> createSuccessResponse(String successMessage, T data) {
        return new Response<>( responseCode.getSuccessCode(), successMessage, data );
    }


    /**
     * 返回错误Response对象
     *
     * @param errorMessage 错误信息
     * @return 错误信息
     */
    public static <T> Response<T> createErrorResponse(String errorMessage) {
        return new Response<>( responseCode.getErrorCode(), errorMessage );
    }

    public Response() {
    }

    /**
     * 返回未登录状态码
     *
     * @param message 提示信息
     * @return Response
     */
    public static <T> Response<T> createUnLoginResponse(String message) {
        return new Response<>( responseCode.getAuthErrorCode(), message );
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

}

ResponseCode

package com.example.category.entity;

import org.springframework.stereotype.Component;

/**
 * @author zrj
 * @date 2021/6/2
 * @since V1.0
 **/
@Component
public class ResponseCode {
    private String successCode = "200";

    private String errorCode = "500";

    private String authErrorCode = "300";

    public String getSuccessCode() {
        return successCode;
    }

    public void setSuccessCode(String successCode) {
        this.successCode = successCode;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getAuthErrorCode() {
        return authErrorCode;
    }

    public void setAuthErrorCode(String authErrorCode) {
        this.authErrorCode = authErrorCode;
    }
}

CategoryService

package com.example.category.service;

import com.example.category.entity.Category;
import com.example.category.entity.CategoryVo;

import java.util.List;
import java.util.Map;

/**
 * (Category)表服务接口
 *
 * @author makejava
 * @since 2021-06-03 07:20:43
 */
public interface CategoryService {

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    Category selectById(Integer id);

    /**
     * 分页查询
     *
     * @param start 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    List<Category> selectPage(int start, int limit);

    /**
     * 查询全部
     *
     * @return 对象列表
     */
    List<Category> selectAll();

    /**
     * 查询全部
     *
     * @return 对象列表
     */
    List<CategoryVo> selectTree();
    
    /**
     * 通过实体作为筛选条件查询
     *
     * @param category 实例对象
     * @return 对象列表
     */
    List<Category> selectList(Category category);

    /**
     * 新增数据
     *
     * @param category 实例对象
     * @return 影响行数
     */
    int insert(Category category);
	
	/**
     * 批量新增
     *
     * @param categorys 实例对象的集合
     * @return 影响行数
     */
	int batchInsert(List<Category> categorys);
	
    /**
     * 修改数据
     *
     * @param category 实例对象
     * @return 修改
     */
    Category update(Category category);

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 影响行数
     */
    int deleteById(Integer id);
    
    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
    int count();
}

CategoryServiceImpl

package com.example.category.service.impl;

import com.example.category.entity.Category;
import com.example.category.entity.CategoryVo;
import com.example.category.mapper.CategoryMapper;
import com.example.category.service.CategoryService;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * (Category表)服务实现类
 *
 * @author makejava
 * @since 2021-06-03 07:20:44
 */
@Service("categoryService")
public class CategoryServiceImpl implements CategoryService {
    @Resource
    private CategoryMapper categoryMapper;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public Category selectById(Integer id) {
        return this.categoryMapper.selectById(id);
    }

    /**
     * 分页查询
     *
     * @param start 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    @Override
    public List<Category> selectPage(int start, int limit) {
        return this.categoryMapper.selectPage(start, limit);
    }

    /**
     * 查询所有
     *
     * @return 实例对象的集合
     */
     @Override
     public List<Category> selectAll() {
        return this.categoryMapper.selectAll();
     }

    @Override
    public List<CategoryVo> selectTree() {
         // 查询全部数据
        List<Category> categoryList = categoryMapper.selectAll();

        // categoryList转换为categoryVoList
        List<CategoryVo> categoryVoList = categoryList.stream().map(category -> {
            CategoryVo categoryVo = new CategoryVo();
            BeanUtils.copyProperties(category, categoryVo);
            return categoryVo;
        }).collect(Collectors.toList());

        //获取得所有parentId为0的数据，也就是一级目录
        //用于封装数据，取得他的孩子（也就是下级目录）的数据
        List<CategoryVo> categoryVoTree = categoryVoList.stream()
                .filter(categoryVo -> categoryVo.getPid().equals(0))
                .map((categoryVoParent) -> {
                    categoryVoParent.setChildren(getChildrenData(categoryVoParent, categoryVoList));
                    return categoryVoParent;
                }).collect(Collectors.toList());

        return categoryVoTree;
    }

    /**
     * 获取孩子（下级目录）的方法，递归实现
     */
    private List<CategoryVo> getChildrenData(CategoryVo root, List<CategoryVo> all) {
        List<CategoryVo> children = all.stream().filter(categoryVo ->
                categoryVo.getPid().equals(root.getId())
        ).map(categoryVo -> {
            categoryVo.setChildren(getChildrenData(categoryVo, all));
            return categoryVo;
        }).collect(Collectors.toList());
        return children;
    }

    /**
     * 根据条件查询
     *
     * @return 实例对象的集合
     */
    @Override
    public List<Category> selectList(Category category) {
        return this.categoryMapper.selectList(category);
    }
    
    /**
     * 新增数据
     *
     * @param category 实例对象
     * @return 实例对象
     */
    @Override
    public int insert(Category category) {
        return this.categoryMapper.insert(category);
    }

    /**
     * 批量新增
     *
     * @param categorys 实例对象的集合
     * @return 生效的条数
     */
    @Override
    public int batchInsert(List<Category> categorys) {
        return this.categoryMapper.batchInsert(categorys);
    }

    /**
     * 修改数据
     *
     * @param category 实例对象
     * @return 实例对象
     */
    @Override
    public Category update(Category category) {
        this.categoryMapper.update(category);
        return this.selectById(category.getId());
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public int deleteById(Integer id) {
        return this.categoryMapper.deleteById(id);
    }
    
    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
     @Override
     public int count(){
        return this.categoryMapper.count();
     }
}

CategoryMapper

package com.example.category.mapper;

import com.example.category.entity.Category;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;

/**
 * (Category)表数据库访问层
 *
 * @author makejava
 * @since 2021-06-03 07:22:32
 */
public interface CategoryMapper {

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    Category selectById(Integer id);
	
    /**
     * 分页查询
     *
     * @param start 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    List<Category> selectPage(@Param("start") int start, @Param("limit") int limit);

    /**
     * 查询全部
     *
     * @return 对象列表
     */
    List<Category> selectAll();
    
    /**
     * 通过实体作为筛选条件查询
     *
     * @param category 实例对象
     * @return 对象列表
     */
    List<Category> selectList(Category category);

    /**
     * 新增数据
     *
     * @param category 实例对象
     * @return 影响行数
     */
    int insert(Category category);
	
	/**
     * 批量新增
     *
     * @param categorys 实例对象的集合
     * @return 影响行数
     */
	int batchInsert(List<Category> categorys);
	
    /**
     * 修改数据
     *
     * @param category 实例对象
     * @return 影响行数
     */
    int update(Category category);

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 影响行数
     */
    int deleteById(Integer id);

    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
    int count();
}

CategoryMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.category.mapper.CategoryMapper">
    <!-- 结果集 -->
    <resultMap type="com.example.category.entity.Category" id="CategoryMap">
        <result property="id" column="id" jdbcType="INTEGER"/>
        <result property="name" column="name" jdbcType="VARCHAR"/>
        <result property="pid" column="pid" jdbcType="INTEGER"/>
    </resultMap>
    
    <!-- 基本字段 -->
    <sql id="Base_Column_List">
        id, name, pid    </sql>
    
    <!-- 查询单个 -->
    <select id="selectById" resultMap="CategoryMap">
        select
          <include refid="Base_Column_List" />
        from category
        where id = #{id}
    </select>

    <!-- 分页查询 -->
    <select id="selectPage" resultMap="CategoryMap">
        select
        <include refid="Base_Column_List" />
        from category
        limit #{start},#{limit}
    </select>

    <!-- 查询全部 -->
    <select id="selectAll" resultMap="CategoryMap">
        select
        <include refid="Base_Column_List" />
        from category
    </select>

    <!--通过实体作为筛选条件查询-->
    <select id="selectList" resultMap="CategoryMap">
        select
        <include refid="Base_Column_List" />
        from category
        <where>
                    <if test="id != null">
                and id = #{id}
            </if>
                    <if test="name != null and name != ''">
                and name = #{name}
            </if>
                    <if test="pid != null">
                and pid = #{pid}
            </if>
                </where>
    </select>

    <!-- 新增所有列 -->
    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        insert into category(id, name, pid)
        values ( #{id}, #{name}, #{pid})
    </insert>
    
    <!-- 批量新增 -->
    <insert id="batchInsert">
        insert into category(id, name, pid)
        values 
        <foreach collection="categorys" item="item" index="index" separator=",">
        (
                        #{item.id},             #{item.name},             #{item.pid}         )
         </foreach>
    </insert>

    <!-- 通过主键修改数据 -->
    <update id="update">
        update category.category
        <set>
                    <if test="name != null and name != ''">
                name = #{name},
            </if>
                    <if test="pid != null">
                pid = #{pid},
            </if>
                </set>
        where id = #{id}
    </update>

    <!--通过主键删除-->
    <delete id="deleteById">
        delete from category where id = #{id}
    </delete>
    
    <!-- 总数 -->
    <select id="count" resultType="int">
        select count(*) from category
    </select>
</mapper>

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

server:
  port: 8080

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/category?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  type-aliases-package: com.example.category

#showSql
logging:
  level:
    com:
      example:
        mapper : debug

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>category</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>category</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1.1-jre</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3. 运行结果

在这里插入图片描述
GitHub地址：查询类目菜单树(https://github.com/zrj-coder/category)

靖节先生
关注
专栏目录
Java小技能：多级菜单排序并返回树结构
iOS逆向与安全
11-24 2664
框架： SpringBoot+MybatisPlus 对数据表中的菜单进行排序并返回树形Json格式的菜单列表。实现思路：先获取全部菜单，然后再对菜单进行装配，生成树形结构。先获取一级菜单，再递归获取子节点。需求： 服务商角色配置权限管理。
vue里的三级树形结构
qq_41552648的博客
07-16 723
vue三级树形结构
JAVA根据条件查询出树结构的数据
煜城的博客
06-15 3759
需求是根据调度中心的id一层一层的查询出最顶层的数据。 表结构有层级关系，parentId: 这个地方查询的时候涉及到动态sql，每次查询都需要更改sql的查询信息》 server:代码： public List<Function> findByRoleId(String roleId) { List<Function> functio...
java实现树形查询
ljh981124的博客
06-01 2702
首先这个树形查询，你肯定不能用他内置sql语句吧，所以这里我们自己在dao层写一句sql语句进行查询： @Query(value = "select * from TB_UIM_MENU_TEST t START WITH t.PID IS NULL" + " CONNECT BY PRIOR t.ID = t.PID order by t.PID NULLS first,t.MENU_SORT ASC",nativeQuery = true) List<MenuTestDTO>
java树形结构数据搜索
程序猿的博客
04-20 1740
public static List<TreeNode> search(List<TreeNode> data, String text) { List<TreeNode> res = new ArrayList<>(); for (TreeNode treeNode : data) { List<TreeNode> children = treeNode.getChildren()...
java 数据库树形结构查询
jj2320711457的博客
03-07 3632
1.什么是树形结构 见明知意，和大树差不多的结构，首先是有根，根下面有树枝，树枝下面又有叶子，一层包着一层 在项目中，一般菜单栏会用到这种结构 ...
idea快捷键第三弹-查看某个类的树结构
有上进心的阿龙
12-19 823
idea快捷键第三弹-查看某个类的树结构 ctrl+H
java树形结构递归查询
09-04
* 根据等级查询类目树 * * @param level * @return */ @Override public List<CategoryTreeDTO> queryCategoryTree(Integer level) { //查询当前级别下类目 List<CategoryDO> list = categoryDAO.list...
电商项目——如何查出所有三级分类，并以树形结构组装起来？
qq_44891295的博客
10-10 3865
文章目录1：查出所有三级分类，并以树形结构组装起来1.1 思路分析1.2 完整的代码演示 1：查出所有三级分类，并以树形结构组装起来 三级分类（电商里面经常用到的功能）：所有的数据都是来源于数据库，我们要对三级分类进行维护，进行增删改查，我们首先就必须要后台管理系统来可以维护我们的整个数据。所以我们引出了下面的问题，解决了下面问题，我们就可以在搭建前端界面进行前后端连接 问题：如何查出所有三级分类以及子分类，并以树形结构组装起来？，我们看下面的思路分析 1.1 思路分析 思路： 首先我们要明确一点使用j
数据库树形结构，EasyUI Tree 树
Camel
01-26 749
通过 $.fn.tree.defaults 重写默认的 defaults。 树（tree）在网页中以树形结构显示分层数据。它向用户提供展开、折叠、拖拽、编辑和异步加载功能。 树的数据格式（Tree Data Format） 每个节点可以包括下列属性： id：节点的 id，它对于加载远程数据很重要。 --对应id text：要显示的节点文本。----对应name state：节点状态，‘open’...
Java目录树控件
05-13
java 实现系统目录树结构，显示文件夹下的文件。树结构
树形结构数据根据ID查找name
Machangzhi_1115的博客
04-22 747
let tree = [ { id: 0, name: "0", children: [ { id: 01, name: "01", children: [ { id: 011, name: "011", children: [] } ] }, { id:
JAVA查询菜单树形结构
qq_43410909的博客
02-14 1429
1.创建最简单的菜单数据结构 SET FOREIGN_KEY_CHECKS=0; – Table structure for t_menu DROP TABLE IF EXISTS t_menu; CREATE TABLE t_menu ( id int(20) NOT NULL AUTO_INCREMENT COMMENT ‘菜单id’, name varchar(255) DEFAULT NULL COMMENT ‘菜单名称’, icon varchar(255) DEFAULT NULL COM
实现多级树形结构查询 比如分类（父分类、子分类）
最新发布
努力学习，努力爱你！
05-22 456
实现多级树形结构查询 比如分类（父分类、子分类） 数据库表结构 CREATE TABLE `course_category` ( `id` varchar(20) NOT NULL COMMENT '主键', `name` varchar(32) NOT NULL COMMENT '分类名称', `label` varchar(32) DEFAULT NULL COMMENT '分类标签默认和名称一样', `parentid` varchar(20) NOT NULL DEFAULT '0'
获取某分类的目录树。
IT技术宅-北方的刀郎
03-21 477
/** * 获取在smarty中使用的“某个”类别的数组 * @param $table 表名 * @param $nid “某类别”的ID号 * wison 整理于2010-06-29 */function treer($table,$nid=2){ global $db; $db->Query("rs","SELECT * FROM $table WHERE `parent` = '$nid'
java获取树行结构菜单
qq_29539827的博客
07-09 822
项目中免不了会遇到树形结构的查询，今天分享一下我写的一个查询方法。 先看数据库的数据，主要有id，parentId，name三个字段（可能还有其他本次无用的很多字段），根节点的父id设置为0 实现的效果 下面是业务层的实现代码，主要是递归的思想 实体和返回对象 创建表语句......
树形结构java查询
qq_38945918的博客
06-25 678
查询某一父节点下所有子节点信息,查询某一子节点的所有父节点信息输入父节点查询所有子节点输入子节点查询所有的父节点 输入父节点查询所有子节点 /** * 查询当前节点下的所有子节点信息,包含当前节点 * @param id * @param list * @return */ @Override public List<Dustbin> findChil(Long id, List<Dustbin> list){
Java常用写法-类目树的生成与遍历
lyk1184919379的博客
05-28 269
类目树的基本操作
java 树的表示,基于表示层次结构的字符串列表的java对象树
weixin_35426202的博客
03-11 100
有很多可能的解决方案。没有复杂性，它可能看起来像：public void testHierarchy() {List hierarchies = new ArrayList();hierarchies.add("1#");hierarchies.add("1#2#");hierarchies.add("1#2#3#");hierarchies.add("1#2#4#");hierarchies.a...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值