Java项目:校园交友系统(java+Springboot+Vue+ElementUI+Layui+mysql)

源码获取：俺的博客首页 "资源" 里下载！ 

项目介绍

基于SpringBoot Vue的校园交友

角色：管理员、用户

管理员：管理员登录系统后，可以对首页、个人中心、用户管理、线下活动管理、交友信息管理、活动报名管理、交流论坛、系统管理等功能进行相应操作

用户：用户登录进入系统，校园交友网站，在网站首页可以查看首页、线下活动、交友信息、交流论坛、公告信息、个人中心、后台管理等内容、可以对首页、个人中心、交友信息管理、活动报名管理等功能进行相应操作

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
3.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
4.数据库：MySql 5.7/8.0版本均可；
5.是否Maven项目：是；

技术栈

后端：SpringBoot+Mybaits

前端：Vue+ElementUI+Layui+HTML+CSS+JS

使用说明

项目运行：
1. 使用Navicat或者其它工具，在mysql中创建对应sql文件名称的数据库，并导入项目的sql文件；
2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令，然后运行；
3. 将项目中application.yml配置文件中的数据库配置改为自己的配置;

文档介绍（课题背景与意义、系统实现功能、课题研究现状、系统相关技术、java技术、B/S架构、Mysql介绍、Mysql环境配置、Springboot框架、系统需求分析、系统功能、可行性研究、经济可行性、技术可行性、运行可行性、事件可行性、系统业务过程分析、系统业务过程分析、系统用例图、系统设计、数据库设计、系统整体设计、系统设计思想、系统流程图、系统详情设计、系统功能模块、系统功能模块、管理员功能模块）：

首页展示： 

线下活动展示页面：

活动信息详情：

后台功能管理-活动报名管理展示： 

线下活动功能列表：

用户管理控制层：

@Validated
@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;

    /**
     * 用户列表页面跳转
     * @param userName
     * @param roleName
     * @param flag
     * @param pageNum
     * @param pageSize
     * @param model
     * @return
     */
    @RequiresRoles("0")
    @RequiresPermissions("user:list")
    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public String list(String userName,String roleName, @RequestParam(name="flag",defaultValue="0")Integer flag,
                       @RequestParam(value = "pn",defaultValue = "1") Integer pageNum,
                       @RequestParam(name = "pSize", defaultValue = "5") Integer pageSize, Model model){
        Map<String, Object> params = new HashMap<>();
        params.put("userName",userName);
        params.put("roleName",roleName);
        params.put("flag",flag);
        model.addAttribute("page", PageHelper.startPage(pageNum,pageSize));
        model.addAttribute("users", userService.findUserRoles(params));
        model.addAttribute("roles", roleService.findRoleColumns());
        return "user/list";
    }

    /**
     * 分配用户角色
     * @param userId
     * @param roleId
     * @return
     */
    @RequiresRoles("0")
    @RequiresPermissions("user:list")
    @RequestMapping(value = "/assignUserRole",method = RequestMethod.POST)
    @ResponseBody
    public String editUserGrade(@NotBlank(message = "{user.userid.notblank}") @Pattern(regexp = "^([1-9][0-9]*){1,2}$",message = "{user.userid.notblank}") String userId,
                                @NotBlank(message = "{user.userroleid.notblank}") @Pattern(regexp = "^([1-9][0-9]*){1,2}$",message = "{user.userroleid.notblank}") String roleId){
        return userService.assignUserRole(Integer.parseInt(roleId),Integer.parseInt(userId))?"success":"fail";
    }


    /**
     * 修改密码页面跳转
     * @return
     */
    @RequestMapping(value = "/editPwd",method = RequestMethod.GET)
    public String toEditPwd(){
        return "user/editPwd";
    }

    /**
     * 修改密码
     * @param userPassword
     * @param br
     * @param session
     * @param model
     * @return
     */
    @RequestMapping(value = "/editPwd",method = RequestMethod.POST)
    public String editPwd(@Valid UserPassword userPassword, BindingResult br, HttpSession session, Model model){
        ValidationUtil.validateData(br);
        if ("success".equals(this.confirminitPwd(userPassword.getInitPassword()))) {
            if (!userPassword.compareNewPassword()) {
                if (userPassword.compareConfirmPassword()) {
                    //进行盐值加密
                    EncryptedData encryptedData = EncryptDataUtil.encryptPasswrod(userPassword.getNewPassword());
                    UserParam user = new UserParam((String) session.getAttribute("username"), encryptedData.getEncryptedPwd(),encryptedData.getSalt());
                    userService.editUserPassword(user);
                    //重新设置subject保存对象中的值
                    UserFind u = (UserFind)SecurityUtils.getSubject().getPrincipal();
                    u.setUserPassword(encryptedData.getEncryptedPwd());
                    u.setSalt(encryptedData.getSalt());
                    return "success";
                }
                model.addAttribute("msg","两次输入密码不一致");
            }else {
                model.addAttribute("msg","新密码与原密码一致");
            }
        } else {
            model.addAttribute("msg","原密码输入不正确");
        }
        return "user/editPwd";
    }

    /**
     * 用户信息删除
     * @param id
     * @return
     */
    @RequiresRoles("0")
    @RequiresPermissions("user:list")
    @RequestMapping(value = "/remove",method = RequestMethod.POST)
    @ResponseBody
    public String removeUser(Integer id){
        return this.userService.removeUser(id)?"success":"fail";
    }

    /**
     * 用户信息恢复
     * @param id
     * @return
     */
    @RequiresRoles("0")
    @RequiresPermissions("user:list")
    @RequestMapping(value = "/recover",method = RequestMethod.POST)
    @ResponseBody
    public String recoverUser(Integer id){
        return this.userService.recoverUser(id)?"success":"fail";
    }

    /**
     * 用户信息批量删除
     * @param ids
     * @return
     */
    @RequiresRoles("0")
    @RequiresPermissions("user:list")
    @RequestMapping(value = "/removes",method = RequestMethod.POST)
    @ResponseBody
    public String removeUsers(Integer[] ids){
        return this.userService.batchRemoveUsers(Arrays.asList(ids))?"success":"fail";
    }

    /**
     * 用户信息批量恢复
     * @param ids
     * @return
     */
    @RequiresRoles("0")
    @RequiresPermissions("user:list")
    @RequestMapping(value = "/recovers",method = RequestMethod.POST)
    @ResponseBody
    public String recoverUsers(Integer[] ids){
        return this.userService.batchRecoverUsers(Arrays.asList(ids))?"success":"fail";
    }

    /**
     * 验证用户名
     * @param userName
     * @return
     */
    @RequestMapping(value = "/confirmUsername",method = RequestMethod.POST)
    @ResponseBody
    public String confirmUsername(String userName){
        return userService.checkUserName(userName)?"success":"fail";
    }

    /**
     * 验证原密码
     * @param initPwd
     * @return
     */
    @RequestMapping(value = "/confirminitPwd",method = RequestMethod.POST)
    @ResponseBody
    public String confirminitPwd(String initPwd){
        UserFind u = (UserFind) SecurityUtils.getSubject().getPrincipal();
        String encryptPassword = new SimpleHash("md5",initPwd,u.getSalt(),3).toHex();
        return u.getUserPassword().equals(encryptPassword)?"success":"fail";
    }
}

角色管理控制层： 

@Controller
@RequiresRoles("0")
@RequestMapping("/role")
public class RoleController {
    @Autowired
    private RoleService roleService;
    @Autowired
    private MenuService menuService;

    /**
     * 角色信息页面跳转
     * @param pageNum
     * @param pageSize
     * @param model
     * @return
     */
    @RequiresPermissions("role:list")
    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public String list(@RequestParam(name="flag",defaultValue="0")Integer flag,
                       @RequestParam(name="pn",defaultValue="1")Integer pageNum,
                       @RequestParam(name = "pSize", defaultValue = "5") Integer pageSize, Model model){
        model.addAttribute("page",PageHelper.startPage(pageNum,pageSize));
        model.addAttribute("roles",this.roleService.findRoles(flag));
        return "system/roleList";
    }

    /**
     * 角色信息录入
     * @param role
     * @param br
     * @return
     */
    @RequiresPermissions("role:add")
    @RequestMapping(value = "/add",method = RequestMethod.POST)
    @ResponseBody
    public String addRole(@Valid RoleParam role, BindingResult br){
        ValidationUtil.validateData(br);
        this.roleService.addRole(role);
        return "success";
    }

    /**
     * 角色信息修改页面跳转
     * @param roleId
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/edit",method = RequestMethod.GET)
    @ResponseBody
    public RoleFind toEditRole(Integer roleId){
        return this.roleService.findRole(roleId);
    }

    /**
     * 角色信息修改
     * @param role
     * @param br
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/edit",method = RequestMethod.POST)
    @ResponseBody
    public String editRole(@Valid RoleParam role, BindingResult br){
        ValidationUtil.validateData(br);
        this.roleService.editRole(role);
        return "success";
    }

    /**
     * 角色信息删除
     * @param id
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/remove",method = RequestMethod.POST)
    @ResponseBody
    public String removeRole(Integer id){
        return this.roleService.removeRole(id)?"success":"fail";
    }

    /**
     * 角色信息恢复
     * @param id
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/recover",method = RequestMethod.POST)
    @ResponseBody
    public String recoverRole(Integer id){
        return this.roleService.recoverRole(id)?"success":"fail";
    }

    /**
     * 角色信息批量删除
     * @param ids
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/removes",method = RequestMethod.POST)
    @ResponseBody
    public String removeRoles(Integer[] ids){
        return this.roleService.batchRemoveRoles(Arrays.asList(ids))?"success":"fail";
    }

    /**
     * 角色信息批量恢复
     * @param ids
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/recovers",method = RequestMethod.POST)
    @ResponseBody
    public String recoverRoles(Integer[] ids){
        return this.roleService.batchRecoverRoles(Arrays.asList(ids))?"success":"fail";
    }

    /**
     * 分配角色菜单信息查询
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/assign",method = RequestMethod.GET)
    @ResponseBody
    public List<MenuTree> toAssign(Integer roleId){
        if (roleId==null) {
            return null;
        }
        //查询所有一级菜单
        List<MenuTree> firstMenu = menuService.findMenuByPid(0);
        //查询该角色分配的菜单
        List<Integer> roleAssignMenu = menuService.findAssignMenuIdsByRoleId(roleId);
        //给一级菜单判断二级菜单
        for (MenuTree m : firstMenu) {
            List<MenuTree> childMenu = menuService.findMenuByPid(m.getMenuId());
            for (Integer rm : roleAssignMenu) {
                if (m.getMenuId().equals(rm)) {
                    m.setChecked(true);
                    m.setOpen(true);
                }
                for (MenuTree cm : childMenu) {
                    if (cm.getMenuId().equals(rm)) {
                        cm.setChecked(true);
                        cm.setOpen(true);
                    }
                }
            }
            m.setChildren(childMenu);
        }
        return firstMenu;
    }

    /**
     * 分配角色菜单
     * @param roleId
     * @param menuIds
     * @return
     */
    @RequiresPermissions(value = {"role:list","role:add"},logical = Logical.AND)
    @RequestMapping(value = "/assign",method = RequestMethod.POST)
    @ResponseBody
    public String assign(Integer roleId, Integer[] menuIds){
        return this.roleService.assignRoleToMenu(roleId,Arrays.asList(menuIds))?"success":"fail";
    }

}

验证信息管理控制层：

@ControllerAdvice
public class GlobalExceptionHandle {
    @Autowired
    private SyslogService syslogService;
    @Autowired
    private RoleService roleService;

    /**
     * 验证异常处理
     * @param attr
     * @param request
     * @param ex
     * @return
     */
    @ExceptionHandler(ValidationException.class)
    public String validationHandle(RedirectAttributes attr,HttpServletRequest request, ValidationException ex) {
        if(ex instanceof ConstraintViolationException){
            ConstraintViolationException exs = (ConstraintViolationException) ex;
            Set<ConstraintViolation<?>> violations = exs.getConstraintViolations();
            violations.forEach((item)-> {
                String key = item.getPropertyPath().toString();
                attr.addFlashAttribute(key.substring(key.lastIndexOf(".")+1),item.getMessage());
            });
        }else if(ex instanceof ValidationException){
            Arrays.asList(ex.getMessage().split(";")).forEach((item)->{
                String[] message = item.split(":");
                String msg = message[1].indexOf("FormatException")>0?"数据输入不合法":message[1];
                attr.addFlashAttribute(message[0],msg);
            });
        }else{
            System.out.println("exception");
        }
        return "redirect:"+request.getRequestURI();
    }

    /**
     * 重复数据异常处理
     * @param attr
     * @param request
     * @param ex
     * @return
     */
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public String sqlHandle(RedirectAttributes attr,HttpServletRequest request, Exception ex) {
        if(ex instanceof DuplicateKeyException){
            attr.addFlashAttribute("msg","您输入的数据已存在");
        }
        return "redirect:"+request.getRequestURI();
    }

    /**
     * 数据类型不匹配异常处理
     * @param attr
     * @param request
     * @param ex
     * @return
     */
    @ExceptionHandler(BindException.class)
    public String bindHandle(RedirectAttributes attr,HttpServletRequest request, Exception ex) {
        if(ex instanceof BindException){
            attr.addFlashAttribute("msg","数据输入不合法");
        }
        return "redirect:"+request.getRequestURI();
    }
    @ExceptionHandler(TypeMismatchException.class)
    public String methodBindHandle(RedirectAttributes attr,HttpServletRequest request, Exception ex) {
        if(ex instanceof MethodArgumentTypeMismatchException){
            attr.addFlashAttribute("msg","数据输入不合法");
        }
        return "redirect:"+request.getRequestURI();
    }

    /**
     * 授权异常处理
     * @param request
     * @param model
     * @param ex
     * @return
     */
    @ExceptionHandler(AuthorizationException.class)
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    public String authorizationHandle(HttpServletRequest request,Model model, Exception ex) {
        if(ex instanceof AuthorizationException){
            //添加越界操作登录日志
            UserFind u = (UserFind) SecurityUtils.getSubject().getPrincipal();
            if (u != null) {
                String roleName = roleService.findRole(u.getRoleId()).getRoleName();
                String logName = "loginUser:"+u.getUserName()+"=>roleName:"+roleName+"=>exception:未授权越界操作!!!";
                String addrIp = request.getRemoteAddr();
                syslogService.addSyslog(new SyslogParam(logName,addrIp,new Date()));
            }
        }
        model.addAttribute("status",401);
        return "/error";
    }

}

源码获取：俺的博客首页 "资源" 里下载！