• Java项目：ssm高校党员管理系统

    作者主页：源码空间站2022

     简介：Java领域优质创作者、Java项目、学习资料、技术互助

    文末获取源码

    项目介绍

    高校党员信息管理系统，分为普通用户和管理员两种角色。

    普通用户登录后主要功能有：

    我的中心:首页、个人资料、修改密码；
    党费信息:党费信息查询、党费缴纳；
    通知查询：查看通知；
    党员成绩信息：党课信息查询
    个人操作日志：个人操作日志；

    管理员登录后主要功能有:

    系统用户管理：首页、管理员账号管理、添加管理kmuu账号、修改密码；
    普通用户管理：用户信息查询、用户信息添加；
    党员信息管理：正式党员查询、预备党员查询、发展对象查询、入党积极分子查询、入党申请人查询；
    党组织管理：党组织查询、党组织添加；
    党员党课成绩：党课信息查询、党课添加；
    党费信息管理：党费信息管理
    党员成绩管理：党员成绩查询、党员成绩添加；
    通知信息管理：通知信息查询、通知信息添加；
    党员活动管理：活动信息查询、活动信息添加；
    操作日志管理：操作日志查询；

    数据备份：数据备份；

    环境需要

    1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
    2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
    3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
    4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
    5.是否Maven项目: 是；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目 
    6.数据库：MySql 5.7版本；

    技术栈

    1. 后端：Spring SpringMVC MyBatis
    2. 前端：JSP+Bootstrap+JQuery+AmazeUI

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
    2. 将项目中jdbc.properties配置文件中的数据库配置改为自己的配置
    3. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;
    若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat，然后运行；
    5. 运行项目，输入localhost:8081 登录

    运行截图

    相关代码 

    (Active)表控制层

    1. package com.bs.controller;
    2.  
    3. import com.bs.pojo.*;
    4. import com.bs.service.ActiveService;
    5. import com.bs.service.OptionService;
    6. import com.github.pagehelper.PageInfo;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Controller;
    9. import org.springframework.ui.Model;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.bind.annotation.RequestMethod;
    12. import org.springframework.web.bind.annotation.RequestParam;
    13. import org.springframework.web.bind.annotation.ResponseBody;
    14.  
    15. import javax.servlet.http.HttpSession;
    16. import java.util.Date;
    17.  
    18. /**
    19.  * (Active)表控制层
    20.  *
    21.  * @author makejava
    22.  * @since 2020-03-31 20:40:23
    23.  */
    24. @Controller
    25. @RequestMapping("active")
    26. public class ActiveController {
    27.     /**
    28.      * 服务对象
    29.      */
    30.     @Autowired
    31.     private ActiveService activeService;
    32.     private static Option option = new Option();
    33.     private static ResultBean resultBean = new ResultBean();
    34.     @Autowired
    35.     private OptionService optionService;
    36.  
    37.     /**
    38.      * 管理员操作方法
    39.      *
    40.      * @param rootUser
    41.      */
    42.     public void adminOption(Admin rootUser) {
    43.         option.setOptionUser(rootUser.getAdminAccount());
    44.         option.setRoleName(rootUser.getAdminRole());
    45.         option.setOptionTime(new Date());
    46.         option.setAdminId(rootUser.getAdminId());
    47.     }
    48.  
    49.     /**
    50.      * 超级管理员 查看所有课程信息
    51.      *
    52.      * @param page
    53.      * @param pageSize
    54.      * @param model
    55.      * @return
    56.      */
    57.     @RequestMapping("activeList")
    58.     public String activeList(@RequestParam(value = "page", defaultValue = "1") int page,
    59.                              @RequestParam(value = "pageSize", defaultValue = "5") int pageSize,
    60.                              Model model, HttpSession session, Active active) {
    61.         //当前登陆账号信息
    62.         Admin rootUser = (Admin) session.getAttribute("user");
    63.         System.out.println("当前登陆账号信息===" + rootUser);
    64.         //查询所有
    65.         PageInfo activePageInfo = activeService.queryAll(page, pageSize, active);
    66.         System.out.println("====所有信息===" + activePageInfo.getList());
    67.         if (rootUser != null) {
    68.             //添加操作日志
    69.             option.setOptionName("查看所有通知信息.");
    70.             //调用管理员操作方法
    71.             adminOption(rootUser);
    72.             optionService.insert(option);
    73.         }
    74.         model.addAttribute("activePageInfo", activePageInfo);
    75.         return "admin/active-list";
    76.     }
    77.  
    78.     /**
    79.      * 前往添加界面
    80.      *
    81.      * @return
    82.      */
    83.     @RequestMapping("goAdd")
    84.     public String goAdd(HttpSession session, Model model) {
    85.         session.removeAttribute("insertmessage");
    86.         session.removeAttribute("editmassage");
    87.         return "admin/add-active";
    88.     }
    89.  
    90.     /**
    91.      * 管理员添加
    92.      *
    93.      * @param active
    94.      * @param model
    95.      * @return
    96.      */
    97.     @RequestMapping(value = "addActive", method = RequestMethod.POST)
    98.     public String addActive(Active active, Model model, HttpSession session) {
    99.         //当前登陆账号信息
    100.         Admin rootUser = (Admin) session.getAttribute("user");
    101.         System.out.println("当前登陆账号信息===" + rootUser);
    102.         //添加操作
    103.         if (active != null) {
    104.             System.out.println("=====存入的信息====" + active);
    105.             active = activeService.insert(active);
    106.             if (rootUser != null) {
    107.                 //添加操作日志
    108.                 option.setOptionName("添加的活动为：" + active.getActiveTitle());
    109.                 //调用管理员操作方法
    110.                 adminOption(rootUser);
    111.                 optionService.insert(option);
    112.             }
    113.             session.setAttribute("insertmessage", "success");
    114.             return "redirect:/active/activeList";
    115.         } else {
    116.             session.setAttribute("insertmessage", "isEmpty");
    117.             return "redirect:/active/activeList";
    118.         }
    119.     }
    120.  
    121.     /**
    122.      * 管理员 前往修改界面
    123.      *
    124.      * @return
    125.      */
    126.     @RequestMapping("goEdit")
    127.     public String goEditGrade(Integer activeId, Model model, HttpSession session) {
    128.         session.removeAttribute("editmassage");
    129.         session.removeAttribute("insertmessage");
    130.         //当前信息
    131.         Active active = activeService.queryById(activeId);
    132.         System.out.println("当前信息===" + active);
    133.         model.addAttribute("activeInfo", active);
    134.         return "admin/edit-active";
    135.     }
    136.  
    137.     /**
    138.      * 管理员 查看-修改信息
    139.      *
    140.      * @param active
    141.      * @param model
    142.      * @param session
    143.      * @return
    144.      */
    145.     @RequestMapping(value = "editActive", method = RequestMethod.POST)
    146.     public String editActive(Active active, Model model, HttpSession session) {
    147.         //当前登陆账号信息
    148.         Admin rootUser = (Admin) session.getAttribute("user");
    149.         System.out.println("当前登陆账号信息===" + rootUser);
    150.         //修改操作
    151.         if (active != null) {
    152.             System.out.println("=======存入的信息为："+active);
    153.             active = activeService.update(active);
    154.             if (rootUser != null) {
    155.                 //添加操作日志操作
    156.                 option.setOptionName("修改标题为 " +active.getActiveTitle()+"的信息");
    157.                 //调用管理员操作方法
    158.                 adminOption(rootUser);
    159.                 optionService.insert(option);
    160.             }
    161.             session.setAttribute("editmassage", "success");
    162.             model.addAttribute("activeInfo", active);
    163.             return "redirect:/active/activeList";
    164.         } else {
    165.             session.setAttribute("editmassage", "isEmpty");
    166.             return "redirect:/active/activeList";
    167.         }
    168.     }
    169.  
    170.     /**
    171.      * 管理员删除
    172.      *
    173.      * @param activeId
    174.      * @param session
    175.      * @return
    176.      */
    177.     @RequestMapping(value = "remove", method = RequestMethod.POST)
    178.     @ResponseBody
    179.     public ResultBean remove(@RequestParam Integer activeId, HttpSession session) {
    180.         session.removeAttribute("editmassage");
    181.         session.removeAttribute("insertmessage");
    182.         //当前登陆账号信息
    183.         Admin rootUser = (Admin) session.getAttribute("user");
    184.         System.out.println("当前登陆账号信息===" + rootUser);
    185.         //删除普通管理员操作
    186.         if (activeId != null) {
    187.             Active queryById = activeService.queryById(activeId);
    188.             boolean delete = activeService.deleteById(activeId);
    189.             if (delete) {
    190.                 //添加操作日志操作
    191.                 option.setOptionName("移除标题为" + queryById.getActiveTitle() + "的信息");
    192.                 //调用管理员操作方法
    193.                 adminOption(rootUser);
    194.             }
    195.             optionService.insert(option);
    196.             resultBean.setErrno(0);
    197.             resultBean.setMessage("操作成功");
    198.         }
    199.         return resultBean;
    200.     }
    201.  
    202. }

    (Admin)表控制层

    1. package com.bs.controller;
    2.  
    3. import com.bs.pojo.Admin;
    4. import com.bs.pojo.Option;
    5. import com.bs.pojo.ResultBean;
    6. import com.bs.service.AdminService;
    7. import com.bs.service.OptionService;
    8. import com.github.pagehelper.PageInfo;
    9. import org.apache.shiro.SecurityUtils;
    10. import org.apache.shiro.authc.AuthenticationException;
    11. import org.apache.shiro.authc.UsernamePasswordToken;
    12. import org.apache.shiro.subject.Subject;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.stereotype.Controller;
    15. import org.springframework.ui.Model;
    16. import org.springframework.web.bind.annotation.RequestMapping;
    17. import org.springframework.web.bind.annotation.RequestMethod;
    18. import org.springframework.web.bind.annotation.RequestParam;
    19. import org.springframework.web.bind.annotation.ResponseBody;
    20.  
    21. import javax.servlet.http.HttpSession;
    22. import java.util.Date;
    23.  
    24. /**
    25.  * (Admin)表控制层
    26.  *
    27.  * @author makejava
    28.  * @since 2020-04-01 07:55:11
    29.  */
    30. @Controller
    31. @RequestMapping("admin")
    32. public class AdminController {
    33.  
    34.     private static Option option = new Option();
    35.  
    36.     private static ResultBean resultBean = new ResultBean();
    37.     /**
    38.      * 服务对象
    39.      */
    40.     @Autowired
    41.     private AdminService adminService;
    42.     @Autowired
    43.     private OptionService optionService;
    44.  
    45.     /**
    46.      * 验证码验证
    47.      *
    48.      * @param session
    49.      * @param message
    50.      * @return 指定页面
    51.      */
    52.     @RequestMapping("/loginView")
    53.     public String loginView(HttpSession session, String message) {
    54.         session.setAttribute("loginMsg", "登陆失败，验证码错误");
    55.         System.out.println("验证码错误");
    56.         return "redirect:/view/404";
    57.     }
    58.  
    59.     /**
    60.      * 登录
    61.      *
    62.      * @param admin
    63.      * @return
    64.      */
    65.     @RequestMapping("checkLogin")
    66.     public String checkLogin(Admin admin, Model model, HttpSession session) {
    67.         System.out.println("====================开始登陆=======" + admin);
    68. //        String password = new Md5Hash(admin.getAdminPassword(),admin.getAdminAccount(),1024).toString();
    69. //        System.out.println("========"+password);
    70.         try {
    71.             //1.认证 创建令牌
    72.             UsernamePasswordToken token = new UsernamePasswordToken(admin.getAdminAccount(), admin.getAdminPassword());
    73.             //2.获取主体对象
    74.             Subject subject = SecurityUtils.getSubject();
    75.             //3.登陆方法
    76.             subject.login(token);
    77.             if (subject.isAuthenticated()) {
    78.                 System.out.println("认证成功");
    79.                 Admin byAccount = adminService.queryByAccount(admin.getAdminAccount());
    80.                 if (byAccount.getFlag().equals(1)) {
    81.                     //数据传递是不带密码
    82.                     byAccount.setAdminPassword("");
    83.                     //添加操作日志
    84.                     option.setOptionName(byAccount.getAdminAccount() + ":登录.");
    85.                     //调用管理员操作方法
    86.                     adminOption(byAccount);
    87.                     optionService.insert(option);
    88.                     session.setAttribute("user", byAccount);
    89.                     session.setAttribute("loginMsg", "登录成功");
    90.                     return "redirect:/admin/index";
    91.                 }
    92.             }
    93.         } catch (AuthenticationException e) {
    94.             e.printStackTrace();
    95.             System.out.println("认证失败");
    96.         }
    97.         session.setAttribute("loginMsg", "账号或密码错误");
    98.         return "redirect:/view/404";
    99.     }
    100.  
    101.     /**
    102.      * 超级管理员 查看所有管理员信息
    103.      *
    104.      * @param page
    105.      * @param pageSize
    106.      * @param model
    107.      * @return
    108.      */
    109.     @RequestMapping("adminList")
    110.     public String adminList(@RequestParam(value = "page", defaultValue = "1") int page,
    111.                             @RequestParam(value = "pageSize", defaultValue = "5") int pageSize,
    112.                             Model model, HttpSession session, Admin admin) {
    113.         //当前登陆账号信息
    114.         Admin rootUser = (Admin) session.getAttribute("user");
    115.         System.out.println("当前登陆账号信息===" + rootUser);
    116.         //查询所有管理员
    117.         PageInfo adminPageInfo = adminService.queryAll(page, pageSize, admin);
    118.         System.out.println("====所有管理员===" + adminPageInfo.getList());
    119.         if (rootUser != null) {
    120.             //添加操作日志
    121.             option.setOptionName("查看所有管理员.");
    122.             //调用管理员操作方法
    123.             adminOption(rootUser);
    124.             optionService.insert(option);
    125.         }
    126.         model.addAttribute("adminPageInfo", adminPageInfo);
    127.         return "admin/admin-list";
    128.     }
    129.  
    130.     /**
    131.      * 前往添加管理员界面
    132.      *
    133.      * @return
    134.      */
    135.     @RequestMapping("goAddAdmin")
    136.     public String goAddAdmin(HttpSession session) {
    137.         session.removeAttribute("insertmessage");
    138.         return "admin/add-admin";
    139.     }
    140.  
    141.     /**
    142.      * 超级管理员添加其他管理员
    143.      *
    144.      * @param admin
    145.      * @param model
    146.      * @return
    147.      */
    148.     @RequestMapping("addAdmin")
    149.     public String addAdmin(Admin admin, Model model, HttpSession session) {
    150.         //当前登陆账号信息
    151.         Admin rootUser = (Admin) session.getAttribute("user");
    152.         System.out.println("当前登陆账号信息===" + rootUser);
    153.         //添加管理员操作
    154.         if (admin != null) {
    155.             Admin byAccount = adminService.queryByAccount(admin.getAdminAccount());
    156.             if (byAccount == null) {
    157.                 admin.setAddTime(new Date());
    158.                 admin = adminService.insert(admin);
    159.                 if (rootUser != null) {
    160.                     //添加操作日志
    161.                     option.setOptionName("添加管理员，账号为：" + admin.getAdminAccount());
    162.                     //调用管理员操作方法
    163.                     adminOption(rootUser);
    164.                     optionService.insert(option);
    165.                 }
    166.                 session.setAttribute("insertmessage", "success");
    167.                 return "redirect:/admin/adminList";
    168.             } else {
    169.                 session.setAttribute("insertmessage", "errorRepete");
    170.             }
    171.         } else {
    172.             session.setAttribute("insertmessage", "errorNull");
    173.         }
    174.         return "redirect:/admin/goAddAdmin";
    175.     }
    176.  
    177.     /**
    178.      * 前往修改管理员密码界面
    179.      *
    180.      * @return
    181.      */
    182.     @RequestMapping("goEditPassword")
    183.     public String goEditPassword(Model model, HttpSession session) {
    184.         session.removeAttribute("editmassage");
    185.         //当前登陆账号信息
    186.         Admin rootUser = (Admin) session.getAttribute("user");
    187.         System.out.println("当前登陆账号信息===" + rootUser);
    188.         model.addAttribute("adminInfo", rootUser);
    189.         return "admin/password";
    190.     }
    191.  
    192.     /**
    193.      * 修改密码
    194.      *
    195.      * @param admin
    196.      * @param model
    197.      * @param session
    198.      * @return
    199.      */
    200.     @RequestMapping("editPassword")
    201.     public String editPassword(Admin admin, Model model, HttpSession session) {
    202.         //当前登陆账号信息
    203.         Admin rootUser = (Admin) session.getAttribute("user");
    204.         System.out.println("当前登陆账号信息===" + rootUser);
    205.         //修改密码操作
    206.         if (admin != null) {
    207.             admin.setAdminId(rootUser.getAdminId());
    208.             System.out.println("=====修改的信息=====" + admin);
    209.             admin.setAddTime(new Date());
    210.             admin = adminService.update(admin);
    211.             if (rootUser != null) {
    212.                 //添加操作日志操作
    213.                 option.setOptionName("修改密码.");
    214.                 //调用管理员操作方法
    215.                 adminOption(rootUser);
    216.                 optionService.insert(option);
    217.             }
    218.             session.setAttribute("editmassage", "success");
    219.             model.addAttribute("adminInfo", admin);
    220.         }
    221.         return "redirect:/";
    222.     }
    223.  
    224.     /**
    225.      * 超级管理员修改普通管理员权限
    226.      *
    227.      * @param adminId
    228.      * @param flag
    229.      * @param session
    230.      * @return
    231.      */
    232.     @RequestMapping(value = "editFlag", method = RequestMethod.POST)
    233.     @ResponseBody
    234.     public ResultBean editFlag(@RequestParam Integer adminId, @RequestParam Integer flag, HttpSession session) {
    235.         //当前登陆账号信息
    236.         Admin rootUser = (Admin) session.getAttribute("user");
    237.         System.out.println("当前登陆账号信息===" + rootUser);
    238.         //授权操作
    239.         if (adminId != null && flag != null) {
    240.             Admin admin = new Admin();
    241.             admin.setAdminId(adminId);
    242.             admin.setFlag(flag);
    243.             admin.setAddTime(new Date());
    244.             System.out.println("=====修改的信息=====" + admin);
    245.             admin = adminService.update(admin);
    246.             if (rootUser != null && flag == 1) {
    247.                 //添加操作日志操作
    248.                 option.setOptionName("给管理员授权");
    249.                 //调用管理员操作方法
    250.                 adminOption(rootUser);
    251.             } else {
    252.                 //添加操作日志操作
    253.                 option.setOptionName("冻结管理员");
    254.                 //调用管理员操作方法
    255.                 adminOption(rootUser);
    256.             }
    257.             optionService.insert(option);
    258.             resultBean.setErrno(0);
    259.             resultBean.setMessage("操作成功");
    260.         }
    261.         return resultBean;
    262.     }
    263.  
    264.     /**
    265.      * 超级管理员删除普通管理员
    266.      *
    267.      * @param adminId
    268.      * @param session
    269.      * @return
    270.      */
    271.     @RequestMapping(value = "removeAdmin", method = RequestMethod.POST)
    272.     @ResponseBody
    273.     public ResultBean removeAdmin(@RequestParam Integer adminId, HttpSession session) {
    274.         //当前登陆账号信息
    275.         Admin rootUser = (Admin) session.getAttribute("user");
    276.         System.out.println("当前登陆账号信息===" + rootUser);
    277.         //删除普通管理员操作
    278.         if (adminId != null) {
    279.             Admin admin = adminService.queryById(adminId);
    280.             boolean delete = adminService.deleteById(adminId);
    281.             if (delete) {
    282.                 //添加操作日志操作
    283.                 option.setOptionName("移除管理员" + admin.getAdminAccount());
    284.                 //调用管理员操作方法
    285.                 adminOption(rootUser);
    286.             }
    287.             optionService.insert(option);
    288.             resultBean.setErrno(0);
    289.             resultBean.setMessage("操作成功");
    290.         }
    291.         return resultBean;
    292.     }
    293.  
    294.     /**
    295.      * 通过主键查询单条数据
    296.      *
    297.      * @param id 主键
    298.      * @return 单条数据
    299.      */
    300.     @RequestMapping("selectOne")
    301.     @ResponseBody
    302.     public Admin selectOne(Integer id) {
    303.         return adminService.queryById(id);
    304.     }
    305.  
    306.  
    307.     /**
    308.      * 查询多条数据
    309.      *
    310.      * @param page     页码
    311.      * @param pageSize 页大小
    312.      * @param admin    实体
    313.      * @return PageInfo 分页数据集合
    314.      */
    315.     @RequestMapping("searchAll")
    316.     @ResponseBody
    317.     public PageInfo searchAll(@RequestParam(value = "page", defaultValue = "1") int page,
    318.                                      @RequestParam(value = "pageSize", defaultValue = "5") int pageSize,
    319.                                      Admin admin) {
    320.         return adminService.queryAll(page, pageSize, admin);
    321.     }
    322.  
    323.     /**
    324.      * 管理员操作方法
    325.      *
    326.      * @param rootUser
    327.      */
    328.     public void adminOption(Admin rootUser) {
    329.         option.setOptionUser(rootUser.getAdminAccount());
    330.         option.setRoleName(rootUser.getAdminRole());
    331.         option.setOptionTime(new Date());
    332.         option.setAdminId(rootUser.getAdminId());
    333.     }
    334. }

    如果也想学习本系统，下面领取。关注并回复：026ssm 

  • 相关阅读:
    程序员基础能力系列（1）——vim快捷键总结
    MATLAB | 你是猫猫教还是狗狗教还是ikun
    抖音阳哥：选品师项目究竟能不能算蓝海项目？
    dfs + bfs 几类经典板子
    在MacOS上使用NSWindow展示了多种不同风格的窗口
    PVT：特征金字塔在Vision Transormer的首次应用，又快又好 | ICCV 2021
    嵌入式开发：软件启动清单给质量一个良好的开端
    冯唐成事心法笔记 —— 知世
    机器学习：基于Python实现人工神经网络训练过程
    Redis 事务
  • 原文地址：https://blog.csdn.net/m0_74967853/article/details/128156232