用SpringMVC 框架权限 导航菜单和 增加新用户 给新用户角色 给角色增加权限

SpringMVC实现用户角色管理(springmvc角色权限管理) SpringMVC实现用户角色管理(springmvc角色权限管理) SpringMVC用户管理实现 通过SpringMVC与JSP实现用户角色管理 SpringMVC实现用户角色管理(springmvc角色权限管理 立即下载

实体类:

users用户表:

package com.app.project.mode;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

import www.appfast.cc.base.BaseEntity;
import java.sql.Timestamp;

@Table(name = "t_users")
public class UserModel extends BaseEntity {
    @Id
    @GeneratedValue
    @Column(name = "id", unique = true, nullable = false)
    Integer id;
    String account;
    String showname;
    String password;
    Timestamp crt_time;
    String crt_user;
    String it_serv_zone;
    String phone;
    String status;
    String serviceproviderid;
    String token;
    Timestamp login_time;
    Integer current_roleid;
    Integer vendor;
    Integer assettype_power;
    @Transient
    String roletype;
    public String getRoletype() {
        return roletype;
    }
    public void setRoletype(String roletype) {
        this.roletype = roletype;
    }
    /*String rolename;
    public String getRolename() {
        return rolename;
    }
    public void setRolename(String rolename) {
        this.rolename = rolename;
    }*/
    public Integer getCurrent_roleid() {
        return current_roleid;
    }
    public void setCurrent_roleid(Integer current_roleid) {
        this.current_roleid = current_roleid;
    }
    public Timestamp getLogin_time() {
        return login_time;
    }
    public void setLogin_time(Timestamp login_time) {
        this.login_time = login_time;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getAccount() {
        return account;
    }
    public void setAccount(String account) {
        this.account = account;
    }
    public String getShowname() {
        return showname;
    }
    public void setShowname(String showname) {
        this.showname = showname;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Timestamp getCrt_time() {
        return crt_time;
    }
    public void setCrt_time(Timestamp crt_time) {
        this.crt_time = crt_time;
    }
    public String getCrt_user() {
        return crt_user;
    }
    public void setCrt_user(String crt_user) {
        this.crt_user = crt_user;
    }
    public String getIt_serv_zone() {
        return it_serv_zone;
    }
    public void setIt_serv_zone(String it_serv_zone) {
        this.it_serv_zone = it_serv_zone;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    public String getServiceproviderid() {
        return serviceproviderid;
    }
    public void setServiceproviderid(String serviceproviderid) {
        this.serviceproviderid = serviceproviderid;
    }
    public String getToken() {
        return token;
    }
    public void setToken(String token) {
        this.token = token;
    }
    public Integer getVendor() {
        return vendor;
    }
    public void setVendor(Integer vendor) {
        this.vendor = vendor;
    }
    public Integer getAssettype_power() {
        return assettype_power;
    }
    public void setAssettype_power(Integer assettype_power) {
        this.assettype_power = assettype_power;
    }
    

}

用户角色关联表实体类:

package com.app.project.mode;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import www.appfast.cc.base.BaseEntity;

@Table(name = "t_roleusers")
public class UserRoleModule extends BaseEntity {
    @Id
    @GeneratedValue
    @Column(name = "id", unique = true, nullable = false)
    String id;
    Integer it_serv_zone;
    Integer user_id;
    Integer role_id;
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public Integer getIt_serv_zone() {
        return it_serv_zone;
    }
    public void setIt_serv_zone(Integer it_serv_zone) {
        this.it_serv_zone = it_serv_zone;
    }
    public Integer getUser_id() {
        return user_id;
    }
    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }
    public Integer getRole_id() {
        return role_id;
    }
    public void setRole_id(Integer role_id) {
        this.role_id = role_id;
    }
}

角色表实体类:

package com.app.project.mode;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import www.appfast.cc.base.BaseEntity;

@Table(name = "t_role")
public class RoleModule extends BaseEntity {
    @Id
    @GeneratedValue
    @Column(name = "id", unique = true, nullable = false)
    String id;
    String powertype;
    String rolename;
    String viewstatus;
    Integer rejectstatus;
    Integer approvestatus;
    String fees_viewstatus;
    Integer fees_rejectstatus;
    Integer fees_approvestatus;
    String examine;
    String viewquestionsstatus;
    String willappointstatus;
    String willtracestatus;
    String donestatus;
    public String getDonestatus() {
        return donestatus;
    }
    public void setDonestatus(String donestatus) {
        this.donestatus = donestatus;
    }
    public String getWilltracestatus() {
        return willtracestatus;
    }
    public void setWilltracestatus(String willtracestatus) {
        this.willtracestatus = willtracestatus;
    }
    public String getWillappointstatus() {
        return willappointstatus;
    }
    public void setWillappointstatus(String willappointstatus) {
        this.willappointstatus = willappointstatus;
    }
    public String getViewquestionsstatus() {
        return viewquestionsstatus;
    }
    public void setViewquestionsstatus(String viewquestionsstatus) {
        this.viewquestionsstatus = viewquestionsstatus;
    }
    public Integer getFees_rejectstatus() {
        return fees_rejectstatus;
    }
    public void setFees_rejectstatus(Integer fees_rejectstatus) {
        this.fees_rejectstatus = fees_rejectstatus;
    }
    public Integer getFees_approvestatus() {
        return fees_approvestatus;
    }
    public void setFees_approvestatus(Integer fees_approvestatus) {
        this.fees_approvestatus = fees_approvestatus;
    }
    public String getFees_viewstatus() {
        return fees_viewstatus;
    }
    public void setFees_viewstatus(String fees_viewstatus) {
        this.fees_viewstatus = fees_viewstatus;
    }

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getPowertype() {
        return powertype;
    }
    public void setPowertype(String powertype) {
        this.powertype = powertype;
    }
    public String getRolename() {
        return rolename;
    }
    public void setRolename(String rolename) {
        this.rolename = rolename;
    }
    public String getViewstatus() {
        return viewstatus;
    }
    public void setViewstatus(String viewstatus) {
        this.viewstatus = viewstatus;
    }
    public Integer getRejectstatus() {
        return rejectstatus;
    }
    public void setRejectstatus(Integer rejectstatus) {
        this.rejectstatus = rejectstatus;
    }
    public Integer getApprovestatus() {
        return approvestatus;
    }
    public void setApprovestatus(Integer approvestatus) {
        this.approvestatus = approvestatus;
    }
    public String getExamine() {
        return examine;
    }
    public void setExamine(String examine) {
        this.examine = examine;
    }
}

角色权限表实体类:

package com.app.project.mode;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import www.appfast.cc.base.BaseEntity;

@Table(name = "t_rolepermission")
public class RolePermissionModule extends BaseEntity {
    @Id
    @Column(name = "id")
    Integer id;
    String role_id;
    String power_id;

    public Integer getId() {
        return id;
    }

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

    public String getRole_id() {
        return role_id;
    }

    public void setRole_id(String role_id) {
        this.role_id = role_id;
    }

    public String getPower_id() {
        return power_id;
    }

    public void setPower_id(String power_id) {
        this.power_id = power_id;
    }

}

权限表实体类:

package com.app.project.mode;

import java.util.List;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

import www.appfast.cc.base.BaseEntity;

@Table(name = "t_permission")
public class Permission extends BaseEntity{
    @Id
    @Column(name = "id")
    Integer id;
    String name;
    String url;
    String text;
    String parent_id;
    //二级菜单
    @Transient
    private List<Permission> data;
    //三级菜单
    @Transient
    private List<Permission> 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 String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
    public String getParent_id() {
        return parent_id;
    }
    public void setParent_id(String parent_id) {
        this.parent_id = parent_id;
    }
    
    public List<Permission> getData() {
        return data;
    }
    public void setData(List<Permission> data) {
        this.data = data;
    }
    public List<Permission> getChildren() {
        return children;
    }
    public void setChildren(List<Permission> children) {
        this.children = children;
    }
    

}

seriver层

package com.app.project.service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import www.appfast.cc.base.BaseService;
import www.appfast.cc.util.BaseJunitTest;
import www.appfast.cc.util.CommonUtil;
import www.appfast.cc.util.DateUtil;
import www.appfast.cc.util.Page;

import com.app.project.mode.DataDicModule;
import com.app.project.mode.Permission;
import com.app.project.mode.RoleModule;
import com.app.project.mode.RolePermissionModule;
import com.app.project.mode.UserAreaModule;
import com.app.project.mode.UserModel;
import com.app.project.mode.UserRoleModule;

@Service
public class PermissionService extends BaseJunitTest {
    @Resource
    BaseService baseService;

    public UserModel findUserModel(String token) {
        // TODO Auto-generated method stub
        String sql = "select * from t_users where token = " + "'" + token + "'";
        UserModel user = baseService.getModel(sql, UserModel.class);
        return user;
    }

    public List<RolePermissionModule> findpermissionid(Integer roleid) {
        // TODO Auto-generated method stub
        String sql = "select * from t_rolepermission where role_id = '"+roleid+"'";
        System.out.println(sql);
        List<RolePermissionModule> rolepermission = baseService.getListModels(sql, RolePermissionModule.class);
        return rolepermission;
    }

    public List<Permission> findPermission(String firstsql) {
        List<Permission> firstPermission = baseService.getListModels(firstsql, Permission.class);
        return firstPermission;
    }

    public List<UserModel> findAllUsers(String name,Page pg) {
        List<UserModel> userLists = null;
        try {
            StringBuffer sql = new StringBuffer("select * from t_users tu");
            if(CommonUtil.isNotNull(name)){
                sql.append(" where tu.account like '%"+name+"%' or showname like '%"+name+"%'");
            }
            String pageSql = baseService.getSqlWithPage(sql.toString(), pg);
            userLists = baseService.getListModels(pageSql, UserModel.class);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return userLists;
    }
    
    public List<UserRoleModule> findUserRoleByUser(String roleSql) {
        // TODO Auto-generated method stub
        return baseService.getListModels(roleSql, UserRoleModule.class);
    }
    
    public List<RoleModule> findAllRoles(String roleName,Page pg){
        List<RoleModule> roleList = null;
        try {
            StringBuffer sql = new StringBuffer("select * from t_role");
            if(CommonUtil.isNotNull(roleName)){
                sql.append(" where rolename like '%"+roleName+"%'");
            }
            String pageSql = baseService.getSqlWithPage(sql.toString(), pg);
            roleList = baseService.getListModels(pageSql, RoleModule.class);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return roleList;
    }
    
    public List<Permission> findAllPermissions(String text,Page pg){
        List<Permission> permissionList = null;
        try {
            StringBuffer sql = new StringBuffer("select a.id," +
                    "(select b.text as name from t_permission b where b.id=a.parent_id)," +
                        "a.url,a.text,a.parent_id from t_permission a");
            if(CommonUtil.isNotNull(text)){
                sql.append(" where a.text like '%"+text+"%'");
            }
            String pageSql = baseService.getSqlWithPage(sql.toString(), pg);
            permissionList = baseService.getListModels(pageSql, Permission.class);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return permissionList;
    }
    
    public List<DataDicModule> findAllAreas(String data,Page pg){
        List<DataDicModule> areaList = null;
        try {
            StringBuffer sql = new StringBuffer("select * from t_datadic where data_type = 'area'");
            if(CommonUtil.isNotNull(data)){
                sql.append(" and data like '%"+data+"%'");
            }
            String pageSql = baseService.getSqlWithPage(sql.toString(), pg);
            areaList = baseService.getListModels(pageSql, DataDicModule.class);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return areaList;
    }
    
    public boolean addUser(UserModel user){
        boolean result = false;
        try {
            if(user!=null){
                String name = user.getShowname();
                if(CommonUtil.isNotNull(name)){
                    user.setShowname(name);
                }
                user.setCrt_time(DateUtil.getTimestampByDate(new Date()));
                if(baseService.save(user)==1){
                    result = true;
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean updUser(UserModel user){
        boolean result = false;
        try {
            if(user!=null){
                UserModel userModel = null;
                if(user.getId()!=null){
                    String sql = "select * from t_users tu where tu.id = " + user.getId();
                    userModel = baseService.getModel(sql, UserModel.class);
                }
                if(userModel!=null){
                    //userModel.setAccount(user.getAccount());
                    String name = user.getShowname();
                    if(name!=null && !("").equals(name)){
                        userModel.setShowname(name);
                    }
                    userModel.setPhone(user.getPhone());
                    if(baseService.update(userModel)==1){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean delUser(String[] idsArray){
        boolean result = false;
        try {
            if(CommonUtil.isNotNull(idsArray)){
                String ids = CommonUtil.arrayToStr(idsArray);
                //先判断中间表是否存在关联关系
                String fsql = "select * from t_roleusers where user_id in ("+ids+")";
                List<UserRoleModule> roleUserList = baseService.getListModels(fsql, UserRoleModule.class);
                if(CommonUtil.isNotNull(roleUserList)){
                    result = false;
                }else{
                    String sql = "delete from t_users u where u.id in ("+ids+")";
                    if(baseService.update(sql)>0){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean addPermission(Permission permission){
        boolean result = false;
        try {
            if(permission!=null){
                String text = permission.getText();
                if(CommonUtil.isNotNull(text)){
                    permission.setText(text);
                }
                String url = permission.getUrl();
                if(CommonUtil.isNotNull(url)){
                    permission.setUrl(url);
                }
                permission.setParent_id(permission.getParent_id());
                String sql = "select max(id) from t_permission";
                String id = baseService.getSingleResult(sql);
                permission.setId(Integer.parseInt(id)+1);
                if(baseService.save(permission)==1){
                    result = true;
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean updPermission(Permission permission){
        boolean result = false;
        try {
            if(permission!=null){
                Permission per = null;
                if(permission.getId()!=null){
                    String sql = "select * from t_permission tp where tp.id = '" + permission.getId()+"'";
                    per = baseService.getModel(sql, Permission.class);
                }
                if(per!=null){
                    String text = permission.getText();
                    if(CommonUtil.isNotNull(text)){
                        per.setText(text);
                    }
                    per.setUrl(permission.getUrl());
                    String parentId = permission.getParent_id();
                    if(CommonUtil.isNotNull(parentId)){
                        per.setParent_id(parentId);
                    }else{
                        per.setParent_id("0");
                    }
                    
                    String sql = "update t_permission set text='"+ per.getText()+"',url='"+ per.getUrl()+"'," +
                            "        parent_id = '"+ per.getParent_id()+"' where id = '"+ per.getId()+"'";
                    if(baseService.update(sql)==1){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean delPermission(String[] idsArray){
        boolean result = false;
        try {
            if(idsArray!=null && idsArray.length>0){
                String ids = CommonUtil.arrayToStr(idsArray);
                //先判断中间表是否存在关联关系
                String fsql = "select * from t_rolepermission where power_id in ("+ids+")";
                List<RolePermissionModule> rolePerList = baseService.getListModels(fsql, RolePermissionModule.class);
                if(CommonUtil.isNotNull(rolePerList)){
                    result = false;
                }else{
                    String sql = "delete from t_permission tp where tp.id in ("+ids+")";
                    if(baseService.update(sql)>0){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public List<Permission> getParentPermission(){
        List<Permission>  perList = null;
        try {
                String sql = "select * from t_permission where parent_id  = '0' " +
                        "or parent_id in (select id from t_permission where parent_id = '0')";
                perList = baseService.getListModels(sql, Permission.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return perList;
    }
    
    public boolean addRole(RoleModule role){
        boolean result = false;
        try {
            if(role!=null){
                String powerType = role.getPowertype();
                if(CommonUtil.isNotNull(powerType)){
                    role.setPowertype(powerType);
                }
                String roleName = role.getRolename();
                if(CommonUtil.isNotNull(roleName)){
                    role.setRolename(roleName);
                }
                role.setExamine("无");
                if(baseService.save(role)==1){
                    result = true;
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean updRole(RoleModule role){
        boolean result = false;
        try {
            if(role!=null){
                RoleModule roleMoule = null;
                if(role.getId()!=null){
                    String sql = "select * from t_role tp where tp.id = '" + role.getId()+"'";
                    roleMoule = baseService.getModel(sql, RoleModule.class);
                }
                if(roleMoule!=null){
                    String powerType = role.getPowertype();
                    if(CommonUtil.isNotNull(powerType)){
                        roleMoule.setPowertype(powerType);
                    }
                    String roleName = role.getRolename();
                    if(CommonUtil.isNotNull(roleName)){
                        roleMoule.setRolename(roleName);
                    }
                    String sql = "update t_role set rolename='"+ roleMoule.getRolename()+"'," +
                            "powertype='"+ roleMoule.getPowertype()+"'where id = '"+ roleMoule.getId()+"'";;
                    if(baseService.update(sql)==1){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean delRole(String[] idsArray){
        boolean result = false;
        try {
            if(idsArray!=null && idsArray.length>0){
                String ids = CommonUtil.arrayToStr(idsArray);
                //先判断中间表是否存在关联关系
                String fsql = "select * from t_rolepermission where role_id in ("+ids+")";
                List<RolePermissionModule> rolePerList = baseService.getListModels(fsql, RolePermissionModule.class);
                String ssql = "select * from t_roleusers where role_id in ("+ids+")";
                List<UserRoleModule> userRoleList = baseService.getListModels(ssql, UserRoleModule.class);
                if(CommonUtil.isNotNull(rolePerList) && CommonUtil.isNotNull(userRoleList)){
                    result = false;
                }else{
                    String sql = "delete from t_role tr where tr.id in ("+ids+")";
                    if(baseService.update(sql)>0){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean delRolePerByRoleId(String roleId){
        boolean result = false;
        try {
            String sql = "delete from t_rolepermission rp where rp.role_id = '"+roleId+"'";
            baseService.update(sql);
            result = true;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean delUserRoleByUserId(String userId){
        boolean result = false;
        try {
            String sql = "delete from t_roleusers ru where ru.user_id = '"+userId+"'";
            baseService.update(sql);
            result = true;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean delUserAreaByUserId(String userId){
        boolean result = false;
        try {
            String sql = "delete from t_userarea where user_id = '"+userId+"'";
            baseService.update(sql);
            result = true;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean editUserRole(String[] idsArray,String userId){
        boolean result = false;
        try {
            if(delUserRoleByUserId(userId)){
                for (String roleId : idsArray) {
                    UserRoleModule userRole = new UserRoleModule();
                    userRole.setUser_id(Integer.parseInt(userId));
                    userRole.setRole_id(Integer.parseInt(roleId));
                    if(baseService.save(userRole)==1){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean editRolePermission(String[] idsArray,String roleId){
        boolean result = false;
        try {
            if(delRolePerByRoleId(roleId)){
                for (String powerId : idsArray) {
                    RolePermissionModule rolePer = new RolePermissionModule();
                    rolePer.setRole_id(roleId);
                    rolePer.setPower_id(powerId);
                    String sql = "select max(id) from t_rolepermission";
                    String id = baseService.getSingleResult(sql);
                    rolePer.setId((Integer.parseInt(id)+1));
                    if(baseService.save(rolePer)==1){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
    
    public List<String> getPermissionByRoleId(String roleId){
        List<String> strArr = new ArrayList<String>();
        try {
            String sql = "select power_id from t_rolepermission where role_id = '"+roleId+"'";
            List<RolePermissionModule> rolePerList =  baseService.getListModels(sql, RolePermissionModule.class);
            if(CommonUtil.isNotNull(rolePerList)){
                for (RolePermissionModule rolePer : rolePerList) {
                    strArr.add(rolePer.getPower_id());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return strArr;
    }
    
    public List<Integer> getRoleByUserId(String userId){
        List<Integer> strArr = new ArrayList<Integer>();
        try {
            String sql = "select role_id from t_roleusers where user_id = '"+userId+"'";
            List<UserRoleModule> userRoleList =  baseService.getListModels(sql, UserRoleModule.class);
            if(CommonUtil.isNotNull(userRoleList)){
                for (UserRoleModule userRole : userRoleList) {
                    strArr.add(userRole.getRole_id());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return strArr;
    }
    
    public boolean isSuperManager(String userId){
        boolean result = false;
        try {
            String sql = "select * from t_roleusers where user_id = '"+userId+"' and role_id = '1'";
            if(baseService.getModel(sql, UserRoleModule.class)!=null){
                result = true;
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return result;
    }
    
    public boolean isExistAccount(String account){
        boolean result = false;
        try {
            String sql = "select * from t_users where account = '"+account+"'";
            if(baseService.getModel(sql, UserRoleModule.class)!=null){
                result = true;
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return result;
    }
    
    public List<String> getAreaByUserId(String userId){
        List<String> strArr = new ArrayList<String>();
        try {
            String fsql = "select area_id from t_userarea where user_id = '"+userId+"'";
            List<UserAreaModule> userAreaList =  baseService.getListModels(fsql, UserAreaModule.class);
            String areaIds = "";
            if(CommonUtil.isNotNull(userAreaList)){
                for (UserAreaModule userAreaModule : userAreaList) {
                    areaIds += "'"+userAreaModule.getArea_id()+"',";
                }
                areaIds = areaIds.substring(0, areaIds.length()-1);
            }
            if(CommonUtil.isNotNull(areaIds)){
                String sql = "select * from  t_datadic where val in ("+areaIds+") and data_type = 'area'";
                List<DataDicModule> dataList =  baseService.getListModels(sql, DataDicModule.class);
                if(CommonUtil.isNotNull(dataList)){
                    for (DataDicModule data : dataList) {
                        strArr.add(data.getId());
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return strArr;
    }
    
    public boolean editUserArea(String[] idsArray,String userId){
        boolean result = false;
        try {
            if(delUserAreaByUserId(userId)){
                for (String areaVal : idsArray) {
                    UserAreaModule userArea = new UserAreaModule();
                    userArea.setUser_id(userId);
                    userArea.setArea_id(areaVal);
                    if(baseService.save(userArea)==1){
                        result = true;
                    }
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
}

然后是action层:

package com.app.project.action;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.poi.ss.usermodel.Row;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import www.appfast.cc.util.Datagrid;
import www.appfast.cc.util.ExcelUtil;
import www.appfast.cc.util.Page;
import www.appfast.cc.util.UploadUtil;

import com.app.project.mode.DataDicModule;
import com.app.project.mode.Permission;
import com.app.project.mode.RoleModule;
import com.app.project.mode.UserModel;
import com.app.project.mode.UserRoleModule;
import com.app.project.service.PermissionService;



@Controller
@RequestMapping("/permissionService")
public class PermissionAction {
    @Resource
    PermissionService permissionService;
    
    
    @RequestMapping(value = "/getPermission")
    @ResponseBody
    public List<Permission> getPermission(HttpServletRequest request){
        List<Permission> allMenu = new ArrayList<Permission>();
        String token = request.getParameter("token");
        UserModel user = permissionService.findUserModel(token);
        
        String roleSql = "select * from t_roleusers ru where ru.user_id = "+user.getId();
        
        List<UserRoleModule> userRoleList = permissionService.findUserRoleByUser(roleSql);
        String roleIds = "";
        List<Permission> allPermission = null;
        if(userRoleList!=null && userRoleList.size()>0){
            for(UserRoleModule userRole : userRoleList){
                roleIds += "'"+userRole.getRole_id()+"',";
            }
            roleIds = roleIds.substring(0, roleIds.length()-1);
            //获取用户角色下所有权限
            StringBuffer sql = new StringBuffer("select p.* from t_permission p where p.id in " +
                    "(select rp.power_id from t_rolepermission rp where rp.role_id in ("+roleIds+"))");
            //获取一级菜单sql
            String firstsql = sql.append(" ORDER BY cast(id as integer ) ASC").toString();
            //查询所有菜单
            allPermission = permissionService.findPermission(firstsql);
            for(Permission fp : allPermission){
                //获取二级菜单
                List<Permission> secondMenu = new ArrayList<Permission>();
                String fpPId = fp.getParent_id();
                String fpId = fp.getId().toString();
                if("0".equals(fpPId)){
                    for (Permission sp : allPermission) {
                        //获取三级菜单
                        List<Permission> thirdMenu = new ArrayList<Permission>();
                        String spId = sp.getId().toString();
                        String spPId = sp.getParent_id();
                        if(spPId.equals(fpId)){
                            for (Permission tp : allPermission) {
                                String tpPId = tp.getParent_id();
                                if(tpPId.equals(spId)){
                                    thirdMenu.add(tp);
                                }
                            }
                            sp.setChildren(thirdMenu);
                            secondMenu.add(sp);
                        }
                    }
                    fp.setChildren(secondMenu);
                    allMenu.add(fp);
                }
            }
        }
        return allMenu;
    }
    @RequestMapping(value = "/returnUsers")
    @ResponseBody
    public Datagrid<UserModel> getUserList(String name,Page pg){
        List<UserModel> rows = permissionService.findAllUsers(name,pg);
        pg.setFlag(false);
        int total = permissionService.findAllUsers(name,pg).size();
        Datagrid<UserModel> datagrid = new Datagrid<UserModel>(total,rows);
        return datagrid;
    }
    
    /**
     * 得到所有角色
     * @return roleList
     */
    @RequestMapping(value = "/returnRoles")
    @ResponseBody
    public Datagrid<RoleModule> getRoleList(String roleName,Page pg){
        List<RoleModule> rows = permissionService.findAllRoles(roleName,pg);
        pg.setFlag(false);
        int total = permissionService.findAllRoles(roleName,pg).size();
        Datagrid<RoleModule> datagrid = new Datagrid<RoleModule>(total,rows);
        return datagrid;
    }
    
    /**
     * 得到所有权限
     * @return list
     */
    @RequestMapping(value = "/returnPermissions")
    @ResponseBody
    public Datagrid<Permission> getPermissionList(String text,Page pg){
        List<Permission> rows = permissionService.findAllPermissions(text,pg);
        pg.setFlag(false);
        int total = permissionService.findAllPermissions(text,pg).size();
        Datagrid<Permission> datagrid = new Datagrid<Permission>(total,rows);
        return datagrid;
    }
    
    /**
     * 得到所有区域
     * @return list
     */
    @RequestMapping(value = "/returnAreas")
    @ResponseBody
    public List<DataDicModule> getAreaList(String data,Page pg){
        List<DataDicModule> list = permissionService.findAllAreas(data,pg);
        return list;
    }
    
    /**
     * 新增用户
     * @param user
     * @return boolean
     */
    @RequestMapping(value = "/addUser")
    @ResponseBody
    public boolean addUser(HttpServletRequest request,UserModel user){
        String token = request.getParameter("token");
        UserModel userModel = permissionService.findUserModel(token);
        if(userModel!=null){
            user.setCrt_user(userModel.getAccount());
        }
        return permissionService.addUser(user);
    }
    
    /**
     * 修改用户
     * @param user
     * @return boolean
     */
    @RequestMapping(value = "/updateUser")
    @ResponseBody
    public boolean updUser(UserModel user){
        return permissionService.updUser(user);
    }
    
    /**
     * 删除用户
     * @param ids
     * @return boolean
     */
    @RequestMapping(value = "/deleteUser")
    @ResponseBody
    public boolean delUser(String[] ids){
        return permissionService.delUser(ids);
    }
    
    /**
     * 新增权限
     * @param permission
     * @return
     */
    @RequestMapping(value = "/addPermission")
    @ResponseBody
    public boolean addPermission(Permission permission){
        return permissionService.addPermission(permission);
    }
    
    /**
     * 修改权限
     * @param permission
     * @return
     */
    @RequestMapping(value = "/updatePermission")
    @ResponseBody
    public boolean updatePermission(Permission permission){
        return permissionService.updPermission(permission);
    }
    
    /**
     * 删除权限
     * @param idsArray
     * @return
     */
    @RequestMapping(value = "/deletePermission")
    @ResponseBody
    public boolean deletePermission(String[] ids){
        return permissionService.delPermission(ids);
    }
    
    /**
     * 获取一级二级权限菜单
     * @return
     */
    @RequestMapping(value = "/getParentPermission")
    @ResponseBody
    public List<Permission> getParentPermission(){
        return permissionService.getParentPermission();
    }
    
    /**
     * 新增角色
     * @param role
     * @return
     */
    @RequestMapping(value = "/addRole")
    @ResponseBody
    public boolean addRole(RoleModule role){
        return permissionService.addRole(role);
    }
    
    /**
     * 修改角色
     * @param role
     * @return
     */
    @RequestMapping(value = "/updateRole")
    @ResponseBody
    public boolean updateRole(RoleModule role){
        return permissionService.updRole(role);
    }
    
    /**
     * 删除角色
     * @param idsArray
     * @return
     */
    @RequestMapping(value = "/deleteRole")
    @ResponseBody
    public boolean deleteRole(String[] ids){
        return permissionService.delRole(ids);
    }
    
    /**
     * 设置角色
     * @param idsArray userId
     * @return
     */
    @RequestMapping(value = "/addOrdelUserRole")
    @ResponseBody
    public boolean addOrdelUserRole(String[] ids,String userId){
        return permissionService.editUserRole(ids,userId);
    }

    /**
     * 设置权限
     * @param idsArray roleId
     * @return
     */
    @RequestMapping(value = "/addOrdelRolePermission")
    @ResponseBody
    public boolean addOrdelRolePermission(String[] ids,String roleId){
        return permissionService.editRolePermission(ids,roleId);
    }
    
    /**
     * 通过id查询Permission
     * @param roleId
     * @return
     */
    @RequestMapping(value = "/getPermissionByRoleId")
    @ResponseBody
    public List<String> getPermissionByRoleId(String roleId){
        return permissionService.getPermissionByRoleId(roleId);
    }
    
    /**
     * 通过id查询role
     * @param userId
     * @return
     */
    @RequestMapping(value = "/getRoleByUserId")
    @ResponseBody
    public List<Integer> getRoleByUserId(String userId){
        return permissionService.getRoleByUserId(userId);
    }
    
    /**
     * 通过userId判断是否为管理员
     * @param boolean
     * @return
     */
    @RequestMapping(value = "/isSuperManager")
    @ResponseBody
    public boolean isSuperManager(String userId){
        return permissionService.isSuperManager(userId);
    }
    
    /**
     * 判断登录名是否存在
     * @param account
     * @return boolean
     */
    @RequestMapping(value = "/isExistAccount")
    @ResponseBody
    public boolean isExistAccount(String account){
        return permissionService.isExistAccount(account);
    }
    
    /**
     * 通过id查询area
     * @param userId
     * @return
     */
    @RequestMapping(value = "/getAreaByUserId")
    @ResponseBody
    public List<String> getAreaByUserId(String userId){
        return permissionService.getAreaByUserId(userId);
    }
    
    /**
     * 新增用户区域关系
     * @param boolean
     * @return
     */
    @RequestMapping(value = "/addOrdelUserArea")
    @ResponseBody
    public boolean addOrdelUserArea(String[] ids,String userId){
        return permissionService.editUserArea(ids,userId);
    }
    
    /*
     *采用spring提供的上传文件的方法
     */
    @RequestMapping("importUser")
    @ResponseBody
    public boolean  importUser(HttpServletRequest request) throws IllegalStateException, IOException{
        boolean result = false;
        try {
            String file = UploadUtil.springUpload(request);
            ExcelUtil eu = new ExcelUtil();
            eu.setExcelPath(file);  
            eu = eu.RestoreSettings();//还原设定  
            eu.setStartReadPos(3);  
            List<Row> rows = eu.readExcel();
            for (Row row : rows) {
                UserModel user = new UserModel();
                user.setAccount(row.getCell(0).getStringCellValue());
                user.setPassword(row.getCell(1).getStringCellValue());
                user.setShowname(row.getCell(2).getStringCellValue());
                if(permissionService.addUser(user)){
                    result = true;
                }
            }
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
        return result;
    }
}


配置 NVIDIA RTX 5090 + sm_120 + flashattention,已跑通一个大模型 ~~ 本文介绍了在Ubuntu 22.04系统下为NVIDIA RTX 50系显卡搭建深度学习环境的完整流程。重点包括:1)安装适配50系显卡(sm_120架构)的CUDA 12.9驱动和Toolkit,需注意禁用系统自带驱动;2)配置环境变量解决nvcc命令识别问题;3)通过源码编译方式安装支持sm_120的PyTorch nightly版本(cu129),解决官方二进制包不兼容问题。整个过程涉及显卡驱动安装、CUDA环境配置、PyTorch适配等关键步骤,并提供了详细的验证方法和常见问题解决方案。文中特别强调 阅读详情

相关推荐

直流有刷电机控制 - 驱动电路(二)

1.如图所示为最常见的推挽驱动电路,我附加了具有正反转功能的电机驱动控制,正反转是由两个继电器组成。使用推挽电路来驱动NMOS管时充电电流和放电电流都很大,因此NMOS管导通快,关断也快,而且NMOS温度不会很高。下面来介绍一下该电路的原理。(1)PWM_MCU是由单片机给出的PWM波信号,该信号是由一些列高低电平的方波构成。当信号为高电平的时候Q3导通,经过R47再到Q5的g极,此时mos导通,如果是K1闭合是正转那么K2闭合就是反转。(2)当PWM低电平时使得Q3关断,Q6导通。

u011030644的博客 4720

SpringBoot+SpringMVC实现增删改查

【代码】SpringBoot+SpringMVC实现新增和查询。

walking的博客 229

在虚拟机上搭建FTP服务器

chroot_list_file=/etc/vsftpd/chroot_list # 对chroot_list下用户限制。[root@localhost ~]# vim /etc/vsftpd/vsftpd.conf #打开配置文件。# 指定用户的shell: -s /usr/bin/nologin。# 在配置文件中找到以下几行代码, 去掉注释(去掉 "#"号)# 指定用户主目录:/data/ftp/ftpuser -M。(2)修改配置文件,路径/etc/vsftpd/ 下的文件。

weixin_70753380的博客 3209

(Spring笔记)SpringFrameWork复习第3节——Spring框架完善MVC模拟用户添加业务

Spring框架完善MVC模拟用户添加业务

张松的博客 504

XCP实战系列介绍09-基于Vehicle Spy进行XCP测量步骤详解

详细介绍如何使用Vehicle Spy进行XCP测量

initiallizer的博客 1393

51单片机最强模块化封装(3)

本篇文章将带大家继续封装我们的代码。这里我们会封装数码管的操作函数。我们又封装了一个模块啦,不知道现在大家有没有感受到模块化的强大呢。B站。

m0_49476241的博客 4061

基于 Spring Mvc 一个简单项目的基本流程 <用户注册功能>(教学版)

基本流程声名一、创建与配置1. 项目创建2. 依赖配置2.1 配置pom.xml2.2 配置application.properties二、项目后端1. 创建数据库表单2. 搭建项目目录3. 创建实体类3.1 自动生成po实体类3.2 创建dto实体类4. 操作数据库4.1 创建接口文件4.2 创建映射文件4.3 测试后端三、项目前端1. 创建界面文件1.1 Html部分1.2 Css部分1.3 Js部分(1) 配置jQuery(2) 编码2. 创建控制器3. 创建业务逻辑四、运行 声名 提示:本博客

weixin_45928161的博客 2609

github创建账号第一步始终出错

github创建账号总结:第一次注册GitHub,填好用户名邮箱密码后进入下一步就卡在哪里,上面还提示Unable to verify your captcha response等,进入网址的解决办法以及下载其他的浏览器也无法解决,用手机浏览器抱着试一试的心态竟然成功了,分享给大家。手机下载谷歌浏览器,进入GitHub正常注册,能向下继续,邮箱验证完以后再用电脑登陆就ok啦

计算机毕业论文源码,学生个人网页制作html源码。贴近用户做网络推广和互联网优化。 4376

使用springboot+springmvc+mybatis框架实现一个简单的添加用户

首先新建一个maven project,此处不必多说 修改pom.xml文件,代码如下 &lt;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/PO...

注定风是不羁旅人 671

【72】【OpenCV C++ & C#】 将cv::Mat 图像转换成imgINFO 传给c#在winform上显示,OpenCV C++如何将处理后的图像传给C#呢? 如何获取图像信息呢?

本文介绍了通过OpenCV C++处理图像后传递给C#的方法。首先定义了一个结构体imgINFO存储图像信息(数据指针、宽高、通道数等),然后通过getImgInfo函数将cv::Mat转换为该结构体。文章特别指出当图像宽度不能被4整除时可能出现失真问题,并给出了两种解决方案:调整输入图像或创建新的对齐图像。此外还解释了img.step和img.cols*img.elemSize()的关系,说明它们在大多数情况下是相等的。最后提到需要通过DLL将结构体传递给C#(具体方法参见其他文章)。

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 697

CANoe制作网关实现CAN(FD)报文故障注入(报文长度/timeout/信号错误/E2E)2

CANoe制作网关实现CAN报文故障注入(报文长度/timeout/信号错误/E2E) 2.新建CANoe工程 3.透传功能 4.故障注入panel面板 5.CAPL代码 5.1故障注入开始、停止、定时 5.2DLC故障注入 5.3 Timeout故障注入 5.4 信号故障注入

天赐好车的博客 3675

使用spring mvc和ajax写一个简单的用户管理系统

话不多说,步入正题。 需求分析: 一个简单的用户管理系统,输入用户信息,点击添加则添加,点击删除则删除,并把结果事实更新至当前页面。效果图如下: 实现步骤: 搭建spring mvc环境 编写jsp页面 实现控制器 完成ajax的回调函数 搭建spring mvc环境 1.创建一个maven webapp项目。 2.导入响应依赖项,这里需要servlet,springMVC,fastjson...

The_Love_Juice的博客 523

uniapp(全端兼容) - 超详细接入百度统计功能,给uniapp全平台各端项目引入添加百度统计的插件统计流量详细的步骤教程(提供最新的百度统计源代码,详细的示例代码复制粘贴即可快速搞定!)

uniapp h5 app 使用加入接入百度统计,uniapp百度统计,uniapp详细引入百度统计的教程,uniapp接入百度统计,uniapp如何实现加入百度的统计代码,uniapp怎么植入百度统计详细教程,uniapp如何对接百度统计,uniapp百度统计不生效怎么办,uniapp使用百度统计不生效常见问题,uniapp引入百度统计后没有生效,uniapp h5网页接入百度统计代码后没有统计无效,uniapp最新接入使用百度统计功能,uniapp增加百度统计代码,uniapp app如何接入百度统计,

✅ 精选推荐文章 1万+

SSM框架实现后台管理系统权限管理(用户、菜单、角色)

后台管理系统开发 功能模块:用户登录、权限管理(用户管理、菜单管理、角色管理) 技术应用:SSM框架+Mysql5.7+jsp+前端layui和EasyUI框架 项目工具:Maven+tomcat9.0+jdk1.8+GIT 开发工具:IDEA 测试环境:window7+搜狗浏览器10.0   一、数据库表结构设计 基础权限管理需要五张表:菜单、用户、角色、角色权限、用户角色 创建数据库 CREATE DATABASE IF NOT EXISTS exam; 1、菜单表menu 描述 字

java编程学习_java基础教程_booyzhang的博客 2万+

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

extjs springMVC实现动态树形菜单

最近由于项目需要,做一个树形动态菜单,用extjs3 来做,结合springMVC,实现从后台动态的加载数据形成权限菜单。 一、数据表设计 首先是数据库的设计,数据库表是一张权限表(即菜单表),我把它设计成一张递归表,实现能显示父级菜单和子菜单的树形菜单, 表的设计如下: 使用pri_Id为外键,引用本表的主键,实现一张递归表。 二、Java代码中po类的设计 po类的设计对应

maojycom的专栏 5111

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Java spring MVC+easyUI+mybatis实现网站后台管理系统(菜单管理、操作员管理、角色管理、操作员授权)

博客目录spring MVC+easyUI+mybatis实现网站后台管理系统功能实现截图技术点介绍主要代码写在最后 spring MVC+easyUI+mybatis实现网站后台管理系统 最近开发一个通用的后台管理系统,管理员登录后,可以对角色、菜单按钮进行控制和管理,十分的方便 功能实现截图 登录页面: 修改用户密码: 菜单管理: 操作员管理: 角色管理: 操作员授权: 编辑菜单: 编辑角色: 技术点介绍 使用Java平台,采用SpringMVC+Mybatis等主流框架 数据库:使用免

anmu4200的博客 859

基于Spring+SpringMvc实现的足球队管理系统

系统功能结构图: 管理员(球队经理)用例图: 教练组用例图: 球员组用例图: 1.登录模块 登录主界面: 登录异常处理: 一共设置了4种情况: 1.账号密码错误 2.账号密码正确,却没有登录权限 3.网络异常 4.正常登录 2.主界面 管理员主界面: 教练组主界面 : ...

软件开发实战项目分享 2104

通用权限设计(springmvc + mybatis + ligerui)

通用权限系统基础平台,实现动态管理菜单,权限,用户,角色等信息 使用代码生成器,快速生成框架代码 对ligerui进行封装,快速进行开发

骆宏的专栏 6427

Java Web 管理系统开发全解

服务端开发中Java一直作为主流语言,最近几年随着大数据的发展,Java涉及到的领域也越来越多,而且前端工程化的兴起也进一步促进了Java的发展。这里介绍一个前后端分离的后台管理系统,后端数据接口基于SpringMVC的框架,前端采用nodejs+webpack+vuejs+iView的框架开发(这是目前很流行的一套前端开发框架)。整套demo是完整可运行的(包括数据库表结构)。废话不多少,直接上...

现场喷口水的专栏 4691

基于springmvc+mybatis搭建的J2EE快速开发框架

kensite 快速开发框架完整开源版J2EE代码平台简介KenSite是基于多个优秀的开源项目,高度整合封装而成的高效,高性能,强安全性的**开源**Java EE快速开发平台。KenSite本身是以Spring Framework为核心容器,Spring MVC为模型视图控制器,MyBatis为数据访问层, Apache Shiro为权限授权层,Ehcahe对常用数据进行缓存,Quartz为定

github_38215430的博客 3262

springmvc+mybatis+easyui+velocity开源模板后台J2EE框架

         J2ee开源模板后台是基于 springmvc+mybatis+easyui+velocity 技术实现的一套模板后台,把一些通用的功能模板化,可以在线打包生成整站源码包括 jsp页面,为开发人员节省时间 ,生成的功能有增删改查,查询包括按列查询,高级查询可以自己选择条件 。也算为开源做点贡献吧    菜单管理 添加菜单可以选择是功能还是菜单,如果选择添加菜单刷新页面后...

xiaosasha的专栏 436

springmvc+mybatis+easyui+velocity开源后台J2EE框架

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34117522的博客 124

基于SpringMVC的宠物之家管理系统的设计和实现-计算机毕设 【课程设计】 31845

为应对上述问题,本文深入剖析当前宠物管理行业面临的挑战,运用 Spring Boot、Java、MySQL 等技术搭建系统基础架构。在开发进程中,不仅实现了系统的各项基础功能,像普通用户的首页展示、通知公告查看、宠物资讯获取,以及管理员的后台首页管理、系统用户管理等,还着重优化了各业务流程。对于普通用户,打造流畅的商城管理流程,涵盖购物车、订单及地址管理;提供便捷的宠物信息查询、领养寄养等功能。对于管理员,实现全面且精细的宠物分类、信息、领养归还及寄养等管理功能。同时,创新性地将多种实用功能与业务流程深度融

WeiXin_DZbishe的博客 1705

基于Spring+SpringMvc实现的足球队管理系统,java技术经理岗位职责

1.账号密码错误 2.账号密码正确,却没有登录权限 3.网络异常 4.正常登录 2.主界面 管理员主界面: 教练组主界面 : 球员组主界面: 干事组主界面: 说明:不同角色登录后展示的主界面各不同,其次不角色 点击菜单后呈现的效果也更不多,例如:查看评价结果那一块,管理员能看评价人的信息而且能对评价结果进行操作,而其他角色只能看见评价得分信息。 **3.**用户管理+角色管理: 用户管理: 工作人员列表 球员列表 教练列表 停职员工 说明:基本的增删改查+分页查

m0_65484584的博客 298

SpringMVC+Mybatis+Html5 bootStrap,SOA架构,全新UI商业运营框架

该框架为全新商业运营中的SpringMVC+Mybatis+Html5 bootStrap SOA架构 webservices 模块化框架 该框架模拟大型互联网的SOA架构,做到高并发,大数据处理,整个项目使用定制化服务思想,提供原子化、模块化的方案,将功能模块进行拆分,可以公用到所有的项目...

chongbengdi1358的博客 250
上一篇: 用户权限树的建立及递归算法思路原则
下一篇: Android sqlite数据删除解决自增id问题
WhtBk
博客等级 码龄11年 12粉丝 8原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值