Spring Boot + Vue 多级目录的构建详解


1. 背景介绍

1.1 为何选择 Spring Boot + Vue？

在现代 Web 开发中，前后端分离已成为一种标准实践。Spring Boot 提供了强大的后端开发能力，尤其在构建企业级应用时，其轻量级、高效性和丰富的生态系统让开发者如虎添翼。而 Vue.js 则以其简单易学的语法和灵活的组件系统，成为前端开发的热门选择。结合这两个技术栈，我们可以轻松实现复杂的业务逻辑与优秀的用户体验。

1.2 多级目录的应用场景

多级目录广泛应用于后台管理系统、权限管理系统等场景。通过多级目录，用户可以层层递进地访问各个功能模块。想象一下，一个只有一级菜单的管理系统将多么混乱和不可维护，因此，多级目录的设计与实现显得尤为重要。

2. 数据库设计

2.1 数据库表结构设计

在设计多级目录时，数据库的表结构是整个系统的基础。我们需要为目录和菜单设计合理的数据表，以支持树状结构和层级关系。典型的表结构包括 menu 表，用于存储菜单的基本信息和层级关系。

Menu 表设计
CREATE TABLE menu (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    parent_id BIGINT,  -- 父级菜单的 ID
    name VARCHAR(100) NOT NULL,  -- 菜单名称
    url VARCHAR(255),  -- 菜单链接
    icon VARCHAR(50),  -- 菜单图标
    order_num INT,  -- 菜单排序
    level INT,  -- 菜单层级
    permission VARCHAR(255),  -- 关联的权限标识
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,  -- 创建时间
    update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP  -- 更新时间
);
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

在这个表结构中，parent_id 字段用于表示父级菜单，level 字段表示菜单的层级，通过这两个字段，我们可以轻松地实现树状结构。

2.2 多级目录数据的存储方案

为了实现多级目录，我们需要设计一个递归的结构。通过 parent_id 字段，我们可以为每个菜单项指定父级菜单，实现树形结构的存储。这种设计在查询时可能稍显复杂，但在实际应用中能够很好地支持多级目录的展示。

2.3 菜单与权限的关系设计

在实际项目中，菜单往往与权限系统挂钩。我们可以在 menu 表中增加一个 permission 字段，用于存储与该菜单关联的权限标识。这样，我们可以根据用户的权限动态生成菜单，确保用户只能看到自己有权限访问的部分。

3. 后端实现

3.1 Spring Boot 项目结构

在 Spring Boot 项目中，我们通常按照功能模块进行划分。在多级目录的实现中，我们可以创建 menu 模块来专门处理菜单相关的逻辑。项目结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── project
│   │               ├── controller  # 控制器层
│   │               ├── service  # 服务层
│   │               ├── repository  # 数据访问层
│   │               └── entity  # 实体类
│   └── resources
│       └── application.yml  # 配置文件
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

3.2 JPA 实现多级目录的数据操作

在数据访问层，我们使用 JPA 来操作数据库表。为了实现多级目录，我们可以通过递归查询来获取菜单的层级结构。以下是一个简单的 JPA 实现示例：

Menu 实体类
@Entity
@Table(name = "menu")
public class Menu {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "parent_id")
    private Long parentId;

    private String name;
    private String url;
    private String icon;
    private Integer orderNum;
    private Integer level;
    private String permission;

    // Getters and Setters
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
MenuRepository 接口
@Repository
public interface MenuRepository extends JpaRepository<Menu, Long> {

    List<Menu> findByParentId(Long parentId);

    @Query("SELECT m FROM Menu m WHERE m.permission IN :permissions")
    List<Menu> findByPermissions(@Param("permissions") List<String> permissions);
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

通过 findByParentId 方法，我们可以递归地查询子菜单，构建完整的目录结构。

3.3 权限管理与目录访问控制

在权限管理中，我们可以通过 permission 字段与用户的权限进行匹配。在实际应用中，可以通过拦截器或注解的方式来控制用户对不同菜单项的访问。以下是一个简单的权限控制实现：

权限拦截器
@Component
public class PermissionInterceptor extends HandlerInterceptorAdapter {

    @Autowired
    private MenuRepository menuRepository;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String userId = request.getHeader("UserId");
        // 获取用户权限
        List<String> userPermissions = getUserPermissions(userId);
        // 获取请求路径对应的菜单权限
        String requestUri = request.getRequestURI();
        Menu menu = menuRepository.findByUrl(requestUri);
        if (menu != null && !userPermissions.contains(menu.getPermission())) {
            response.sendError(HttpServletResponse.SC_FORBIDDEN);
            return false;
        }
        return true;
    }
    
    private List<String> getUserPermissions(String userId) {
        // 假设从数据库或缓存中获取用户权限
        return Arrays.asList("MENU_READ", "MENU_WRITE");
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.

4. 前端实现

4.1 Vue 路由与组件设计

在 Vue 中，多级目录的实现主要通过 Vue Router 进行。我们可以利用嵌套路由来实现层级结构，同时通过动态加载路由来提高应用性能。

路由配置示例
const routes = [
  {
    path: '/dashboard',
    component: Dashboard,
    children: [
      {
        path: 'analytics',
        component: Analytics,
      },
      {
        path: 'reports',
        component: Reports,
      },
    ],
  },
];
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

4.2 动态菜单生成

为了根据用户权限动态生成菜单，我们需要在 Vuex 中存储用户权限信息，并结合路由配置生成菜单树。以下是一个简单的 Vuex 生成菜单的例子：

export const generateMenu = (routes, permissions) => {
  const menu = routes.filter(route => {
    if (route.children) {
      route.children = generateMenu(route.children, permissions);
    }
    return permissions.includes();
  });
  return menu;
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

4.3 用户权限与菜单展示

在前端，我们可以通过 Vue Router 的导航守卫来检查用户的权限，并根据权限动态生成菜单。例如，可以在路由守卫中根据用户权限动态

加载可访问的路由。

5. 前后端联动

5.1 API 设计与数据交互

前后端的联动主要通过 API 实现。在设计 API 时，我们可以通过一个统一的接口来获取用户的菜单数据和权限信息，从而在前端生成动态菜单。

API 示例
@RestController
@RequestMapping("/api/menu")
public class MenuController {

    @Autowired
    private MenuService menuService;

    @GetMapping("/user-menus")
    public List<Menu> getUserMenus() {
        String userId = SecurityContextHolder.getContext().getAuthentication().getName();
        return menuService.getUserMenus(userId);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

5.2 JWT 认证与权限校验

为了确保安全性，我们通常会在 API 调用中加入 JWT 认证。在 Spring Boot 中，可以通过配置 JwtTokenFilter 来实现对请求的拦截和权限校验。

JwtTokenFilter 示例
public class JwtTokenFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String token = jwtTokenProvider.resolveToken(request);
        if (token != null && jwtTokenProvider.validateToken(token)) {
            Authentication auth = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(auth);
        }
        filterChain.doFilter(request, response);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

5.3 前后端数据一致性

为了保证前后端的数据一致性，我们需要在后端保证菜单数据和权限数据的同步更新，同时在前端根据用户权限动态加载菜单。

6. 总结与反思

一个成功的多级目录系统的实现不仅依赖于技术上的解决方案，还需要在系统设计、性能优化和用户体验之间取得平衡。希望本文的内容能为你在项目开发中提供一些有益的参考和启示。


posted @ 2024-09-18 11:05  繁依Fanyi  阅读(40)  评论(0)    收藏  举报  来源