使用SSM开发一个校友联络的平台系统

作者主页：编程指南针

 简介：Java领域优质创作者、CSDN博客专家  Java项目、简历模板、学习资料、面试题库、技术互助

文末获取源码

项目编号：BS-PT-019

后台开发技术：SSM框架

前端开发技术：Bootstrap+Jquery+Ajax

开发工具：IDEA / ECLIPSE

基于MAVEN开发

数据库：MYSQL5.7

JDK：1.8

本项目基于SSM实现的校友录平台，功能完整：主要包含校友通讯录模块，论坛模块，新闻模块，招聘模块，校内各组织管理模块，班级管理模块等，功能还是比较完整的，运行无误。数据库采用MYSQL，开发工具为IDEA或Eclipse.

下面展示一下系统的部分功能；

访问http://localhost:8080/ar-portal/index.action

输入密码： black  /  12345678

 登陆：

首页

新闻中心

班级通讯录

校友组织：

校友论坛

职业招聘

校园服务

个人后台管理中心

我的班级

我的论坛

我的招聘

系统管理员进入：

http://localhost:8080/ar-portal/index.action

sa  /  12345678

后台管理主界面

信息中心

组织管理

招聘管理

用户管理

权限管理

数据字典管理

本系统功能完整，全面，运行无误，结构清晰，使用SSM框架开发，适合做毕业设计使用。

部分核心实现代码：

package com.xzit.ar.manage.controller.user;

import com.xzit.ar.common.base.BaseController;
import com.xzit.ar.common.exception.UtilException;
import com.xzit.ar.common.page.Page;
import com.xzit.ar.common.po.user.User;
import com.xzit.ar.common.util.CommonUtil;
import com.xzit.ar.manage.service.user.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import javax.annotation.Resource;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;


@Controller
@RequestMapping("/user")
public class UserController extends BaseController {

    @Resource
    private UserService userService;

    
    @RequestMapping("")
    public String index() {

        return "user/user-index";
    }

    
    @RequestMapping("/queryUser")
    public String queryUser(Model model, String query, String state, String isAdmin) {
        // 分页类
        Page> page = new Page<>(getPageIndex(), getPageSize());
        Map user = new HashMap<>();
        // 参数校验
        if (CommonUtil.isNotEmpty(query)) {
            user.put("query", "%" + query + "%");
        }
        if (CommonUtil.isNotEmpty(state)) {
            user.put("state", state);
        }
        if (CommonUtil.isNotEmpty(isAdmin)) {
            user.put("isAdmin", isAdmin);
        }
        page.setQueryMap(user);
        // 查询用户
        userService.queryUser(page);
        // 数据返回
        model.addAttribute("page", page);
        model.addAttribute("query", query);
        model.addAttribute("state", state);
        model.addAttribute("isAdmin", isAdmin);

        return "user/user-query";
    }

    @RequestMapping("/add")
    public String userAddPage(Model model) {
        model.addAttribute("sex", false);
        return "user/user-add";
    }

    @RequestMapping(value = "/add/submit", method = RequestMethod.POST)
    public String userAddSubmit(Model model,
                                @RequestParam("account") String account,
                                @RequestParam("trueName") String trueName,
                                @RequestParam("isAdmin") String isAdmin,
                                @RequestParam("email") String email,
                                @RequestParam("introduce") String introduce) throws UtilException {
        if (CommonUtil.isNotEmpty(account)) {
            Map _user = userService.getUserByAccount(account);
            if (_user != null) {
                setMessage(account + " 已存在");
                System.out.println(account + " 已存在");
                return "redirect:/user.action";
            } else {
                User user = new User();
                user.setAccount(account);
                user.setTrueName(trueName);
                user.setEmail(email);
                user.setIsAdmin(isAdmin);
                user.setIntroduce(introduce);
                user.setState("A");
                user.setPassword(CommonUtil.md5("12345678"));
                user.setImageId(1);
                user.setStateTime(new Date());
                user.setCreateTime(new Date());
                userService.addUser(user);
            }
        }

        return "redirect:/user.action";
    }
}

package com.xzit.ar.manage.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.xzit.ar.common.base.BaseController;
import com.xzit.ar.common.constant.WebConstant;


@Controller
@RequestMapping("")
public class ManageController extends BaseController {

	
	@RequestMapping(value = "/manage", method = RequestMethod.GET)
	public String index(ModelMap map) throws Exception {
		return "main/index";
	}

	
	@RequestMapping("/manage/welcome")
	public String welcomeManage(Model model) {

		return "main/welcome";
	}

	
	@RequestMapping(method = RequestMethod.GET, value = "/error/{errCode}")
	public String error(@PathVariable("errCode") String errCode) {
		return "404".equals(errCode) ? WebConstant.PAGE_ERROR_404 : WebConstant.PAGE_ERROR_500;
	}
}

package com.xzit.ar.manage.controller.right;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.xzit.ar.common.base.BaseController;
import com.xzit.ar.common.exception.ServiceException;
import com.xzit.ar.common.page.Page;
import com.xzit.ar.common.po.role.Right;
import com.xzit.ar.common.util.privilege.PrivilegeUtil;
import com.xzit.ar.manage.service.right.RightService;


@Controller
@RequestMapping("/right")
public class RightController extends BaseController {

    @Resource
    private RightService rightService;

    
    @RequestMapping("/indexRight")
    public String indexRight() {
        return "authority/right/right-index";
    }

    @RequestMapping("/queryRights")
    public String queryRights(Model model, String queryInput) throws ServiceException {
        Page page = new Page();
        page.setPageIndex(getPageIndex());
        page.setPageSize(getPageSize());
        rightService.queryRights(page, queryInput);

        model.addAttribute("page", page);
        model.addAttribute("queryInput", queryInput);

        return "authority/right/right-query";
    }

    
    @RequestMapping("/addRight")
    public String addRight() {

        return null;
    }

    @RequestMapping("/updateRight")
    public String updateRight(Model model, @RequestParam("rightId") Integer rightId) throws ServiceException {
        Right right = rightService.selectById(rightId);
        model.addAttribute("right", right);
        setMessage(model, "只能改变权限名、是否公开");

        return "authority/right/right-update";
    }

    @RequestMapping("/updateRightSubmit")
    public String updateRightSubmit(Model model, Right right) throws ServiceException {
        int row = 0;
        if (right != null) {
            // 更新操作
            row = rightService.updateRight(right);
        }
        // 结果判断
        if (row < 1) {
            setMessage(model, "修改失败！");
        } else {
            setMessage(model, "修改成功！");
        }

        return "forward:queryRights.action";
    }

    
    @RequestMapping("/scanAddRights")
    public String scanAddRights(Model model) throws ServiceException {
        int newRights = 0;
        // 索引当前所有权限url
        List rightUrlList = PrivilegeUtil.detectAllRightURL();
        for (String rightUrl : rightUrlList) {
            // 判断是否存在
            if (rightService.selectByRightUrl(rightUrl) == null) {
                // 生成默认格式right
                Right right = PrivilegeUtil.makeDefaultRight(rightUrl);
                // 持久化right
                if (rightService.saveRight(right) > 0) {
                    newRights++;
                }
            }
        }
        if (newRights > 0) {
            setMessage(model, "新增权限" + newRights + "条权限");
        } else {
            setMessage(model, "没有新增权限");
        }
        return "forward:queryRights.action";
    }
}

package com.xzit.ar.manage.controller.right;

import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;

import com.xzit.ar.common.base.BaseController;
import com.xzit.ar.common.exception.ServiceException;
import com.xzit.ar.common.page.Page;
import com.xzit.ar.common.po.role.Right;
import com.xzit.ar.common.po.role.Role;
import com.xzit.ar.common.util.CommonUtil;
import com.xzit.ar.manage.service.right.RightService;
import com.xzit.ar.manage.service.right.RoleService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
@RequestMapping("/role")
public class RoleController extends BaseController {

    @Resource
    private RoleService roleService;

    @Resource
    private RightService rightService;

    @RequestMapping("")
    public String index() {
        return "authority/role/role-index";
    }

    @RequestMapping("/queryRole")
    public String queryRole(Model model) throws ServiceException {
        Page page = new Page<>(getPageIndex(), getPageSize());
        // 传递数据
        model.addAttribute("page", roleService.queryRole(page));

        return "authority/role/role-query";
    }

    @RequestMapping("/edit")
    public String edit(Model model) {
        return "";
    }

    @RequestMapping("/editSubmit")
    public String editSubmit() {
        return "";
    }

    @RequestMapping("/add")
    public String add() {
        return "";
    }

    @RequestMapping("/addSubmit")
    public String addSubmit() {
        return "";
    }

    @RequestMapping("/allot")
    public String allot(Model model, Integer roleId) throws ServiceException {
        // 传递数据
        model.addAttribute("role", roleService.getRoleById(roleId));
        // 所有权限
        model.addAttribute("rightList", rightService.getIsNotPublicRights());
        // 角色已分配的权限
        List roleRights = roleService.getRightsByRole(roleId);
        List rightIds = new ArrayList<>();
        for (Right right : roleRights) {
            rightIds.add(right.getRightId());
        }
        model.addAttribute("roleRights", roleRights);
        model.addAttribute("rightIds", rightIds);

        return "authority/role/role-allot";
    }

    @RequestMapping("/allotSubmit")
    public String allotSubmit(Model model, String rightIds, Integer roleId) throws ServiceException {
        List idList = CommonUtil.splitIds(rightIds);
        if (roleService.updateRoleRights(roleId, idList) > 0) {
            setMessage(model, "更新成功");
        } else {
            setMessage(model, "更新失败");
        }
        return "forward:queryRole.action";
    }
}