基於spring boot和mongodb打造一套完整的許可權架構（五）【整合使用者模組、選單模組、角色模組】

阿新 • • 發佈：2019-01-05

在第四章我們已經實現了對security的整合，我們已經實現了登陸到我們的系統中了，但是大家會發現我們登陸成功以後並沒有顯示左側的選單節點，本章我們將開始整合使用者模組、選單模組以及角色模組。

1、首先我們需要在sys的entity目錄底下建立Tree、QueryTree和QueryRole實體，以及修改user和UserRole實體內容如下：

Tree實體：

package com.mongo.sys.entity;

import net.sf.json.JSONObject;
import org.bson.types.ObjectId;

import java.util.List;

/**
 *@author linzf
 **/
public class Tree implements Comparable<Tree> {
	
	public Tree(){
		super();
	}

	public Tree(String id){
		this.id = new ObjectId(id);
	}



	private ObjectId id;
	private String code;
	private String icon;
	private String name;
	private ObjectId parentId;
	private long treeOrder;
	private String url;
	private String state;
	private boolean checked;
	private List<Tree> child;
	private Tree tree;

	public Tree getTree() {
		return tree;
	}

	public void setTree(Tree tree) {
		this.tree = tree;
	}

	public String getId() {
		if(id!=null){
			return id.toString();
		}else{
			return "";
		}
	}

	public void setId(String id) {
		this.id = new ObjectId(id);;
	}

	public String getParentId() {
		if(parentId!=null){
			return parentId.toString();
		}else{
			return "";
		}
	}

	public void setParentId(String parentId) {
		this.parentId = new ObjectId(parentId);;
	}

	public boolean isChecked() {
		return checked;
	}

	public void setChecked(boolean checked) {
		this.checked = checked;
	}

	public List<Tree> getChild() {
		return child;
	}

	public void setChild(List<Tree> child) {
		this.child = child;
	}



	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public String getIcon() {
		return icon;
	}

	public void setIcon(String icon) {
		this.icon = icon;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public long getTreeOrder() {
		return treeOrder;
	}

	public void setTreeOrder(long treeOrder) {
		this.treeOrder = treeOrder;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}

	/**
	 * 功能描述：實現集合根據treeOrder欄位進行排序的功能
	 * @param o
	 * @return
	 */
	@Override
	public int compareTo(Tree o) {
		long i = this.getTreeOrder() - o.getTreeOrder();
		return Integer.parseInt(i+"");
	}
}

QueryTree查詢實體：

package com.mongo.sys.entity;


import com.mongo.common.base.entity.QueryBase;

public class QueryTree extends QueryBase {
}

QueryRole查詢實體：

package com.mongo.sys.entity;


import com.mongo.common.base.entity.QueryBase;
import com.mongo.common.base.entity.QueryField;
import com.mongo.common.base.entity.QueryType;

public class QueryUserRole extends QueryBase {

    @QueryField(type = QueryType.LIKE)
    private String name;
    @QueryField(type = QueryType.LIKE)
    private String roleName;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
}

User修改以後實體內容如下：

package com.mongo.sys.entity;


import com.mongo.common.base.entity.QueryField;
import com.mongo.sys.dao.UserRoleDao;
import net.sf.json.JSONObject;
import org.bson.types.ObjectId;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;

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

/*
* 類描述：使用者實體類
* @auther linzf
* @create 2018/3/30 0030 
*/
public class User implements UserDetails {

    public static void main(String [] args){
        User user = new User();
        List<UserRole> roles = new ArrayList<UserRole>();
        UserRole userRole = new UserRole();
        userRole.setId("5ac0e051c053f4297804f42c");
        userRole.setName("ROLE_ADMIN");
        userRole.setRoleName("系統管理員");
        roles.add(userRole);
        user.setLogin("shyll");
        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        user.setPassword(passwordEncoder.encode("123456"));
        user.setRoles(roles);
        user.setId(ObjectId.get().toString());
        user.setState("1");
        System.out.println(JSONObject.fromObject(user).toString());

    }


    private ObjectId id;
    // 增加QueryField註解在buildBaseQuery構建Query查詢條件的時候會自動將其加入到Query查詢條件中
    @QueryField
    private String login;
    private String password;
    private String userName;
    private String address;
    private String job;
    private Date birthDate;
    private String city;
    private String district;
    private String province;
    private String streetAddress;
    private String state;
    private String type;
    private Date lastLoginDate;
    // 使用者角色資訊
    private List<UserRole> roles;
    // 角色資訊集合
    private String roleArray;

    public String getRoleArray() {
        return roleArray;
    }

    public void setRoleArray(String roleArray) {
        this.roleArray = roleArray;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<GrantedAuthority> auths = new ArrayList<GrantedAuthority>();
        if(this.getRoles()!=null){
            List<UserRole> roles=this.getRoles();
            for(UserRole role:roles){
                if(role.getName()!=null){
                    auths.add(new SimpleGrantedAuthority(role.getName()));
                }
            }
        }
        return auths;
    }

    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return this.getLogin();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public String getId() {
        return id.toString();
    }

    public void setId(String id) {
        this.id = new ObjectId(id);
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login) {
        this.login = login;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getDistrict() {
        return district;
    }

    public void setDistrict(String district) {
        this.district = district;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getStreetAddress() {
        return streetAddress;
    }

    public void setStreetAddress(String streetAddress) {
        this.streetAddress = streetAddress;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Date getLastLoginDate() {
        return lastLoginDate;
    }

    public void setLastLoginDate(Date lastLoginDate) {
        this.lastLoginDate = lastLoginDate;
    }

    public List<UserRole> getRoles() {
        return roles;
    }

    public void setRoles(List<UserRole> roles) {
        this.roles = roles;
    }

    /**
     * 功能描述：組裝角色資料集合
     * @param roleArray
     * @param userRoleDao
     */
    public void packagingRoles(String roleArray,UserRoleDao userRoleDao){
        List<UserRole> roles = new ArrayList<UserRole>();
        if(roleArray!=null){
            UserRole userRole = null;
            for(String roleId:roleArray.split(",")){
                if(!roleId.isEmpty()){
                    userRole = new UserRole();
                    roles.add(userRoleDao.get(roleId));
                }
            }
        }
        this.setRoles(roles);
    }

}

UserRole修改以後實體內容如下：

package com.mongo.sys.entity;


import com.mongo.common.base.entity.QueryField;
import org.bson.types.ObjectId;

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


/*
* 類描述：使用者角色實體類
* @auther linzf
* @create 2018/3/30 0030 
*/
public class UserRole {

    private ObjectId id;
    // 增加QueryField註解在buildBaseQuery構建Query查詢條件的時候會自動將其加入到Query查詢條件中
    @QueryField
    private String name;

    private String roleName;

    private List<Tree> treeList;

    // 臨時採訪選單數集合的資料
    private String treeArray;

    public List<Tree> getTreeList() {
        return treeList;
    }

    public void setTreeList(List<Tree> treeList) {
        this.treeList = treeList;
    }

    public String getTreeArray() {
        return treeArray;
    }

    public void setTreeArray(String treeArray) {
        this.treeArray = treeArray;
    }

    public String getId() {
        return id.toString();
    }

    public void setId(String id) {
        this.id = new ObjectId(id);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public void packagingTrees(String treeArray){
        Tree tree = null;
        List<Tree> trees = new ArrayList<>();
        for(String id:treeArray.split(",")){
            if(!id.isEmpty()){
                tree = new Tree(id);
                trees.add(tree);
            }
        }
        this.setTreeList(trees);
    }

}

2、建立好選單的實體、角色實體以後我們就要開始編寫我們的選單的dao層和角色的dao層。

TreeDao資料庫層操作類內容如下：

package com.mongo.sys.dao;


import com.mongo.common.base.dao.MongodbBaseDao;
import com.mongo.sys.entity.QueryTree;
import com.mongo.sys.entity.Tree;
import org.springframework.stereotype.Component;

@Component
public class TreeDao extends MongodbBaseDao<Tree,QueryTree> {

}

UserRoleDao資料庫層操作類內容如下：

package com.mongo.sys.dao;


import com.mongo.common.base.dao.MongodbBaseDao;
import com.mongo.sys.entity.QueryUserRole;
import com.mongo.sys.entity.UserRole;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class UserRoleDao extends MongodbBaseDao<UserRole,QueryUserRole> {

    /**
     * 功能描述：根據角色ID的集合來獲取所有的角色資料
     * @param roles
     * @return
     */
    public List<UserRole> getUserRoleByRoleId(List<UserRole> roles){
        Query query = new Query();
        String [] ids = new String[roles.size()];
        for(int i=0;i<roles.size();i++){
            ids[i] = roles.get(i).getId();
        }
        query.addCriteria(Criteria.where("id").in(ids));
        return mongoTemplate.find(query,UserRole.class);
    }

}

3、當我們編寫好我們的選單和角色的資料庫操作的dao層，首先我們要在util工具類底下建立一個選單節點遞迴類NodeUtil和使用者工具類UserInfo，主要是用於密碼加密以及獲取登陸的使用者資訊等，工具類程式碼如下：

NodeUtil工具類內容如下：

package com.mongo.common.util.node;







import com.mongo.sys.entity.Tree;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/*
* 類描述：
* @auther linzf
* @create 2017/9/20 0020 
*/
public class NodeUtil {

    private static List<Tree> returnList = new ArrayList<Tree>();

    /**
     * 根據父節點的ID獲取所有子節點
     * @param list 分類表
     * @param typeId 傳入的父節點ID
     * @return String
     */
    public static List<Tree> getChildNodes(List<Tree> list, String typeId) {
        returnList = new ArrayList<Tree>();
        if(list == null && typeId == null) return new ArrayList<Tree>();
        for (Iterator<Tree> iterator = list.iterator(); iterator.hasNext();) {
            Tree node = (Tree) iterator.next();
            // 一、根據傳入的某個父節點ID,遍歷該父節點的所有子節點
            if (node.getParentId().equals("5ac0c4a0c053f417ac310e3f") && typeId.equals(node.getId())) {
                recursionFn(list, node);
            }
            // 二、遍歷所有的父節點下的所有子節點
            if (node.getParentId().equals("5ac0c4a0c053f417ac310e3f")) {
                recursionFn(list, node);
            }
        }
        // 對頂層選單按照treeOrder從大到小進行進行排序
        Collections.sort(returnList);
        return returnList;
    }

    private static void recursionFn(List<Tree> list, Tree node) {
        List<Tree> childList = getChildList(list, node);// 得到子節點列表
        if (hasChild(list, node)) {// 判斷是否有子節點
            Iterator<Tree> it = childList.iterator();
            while (it.hasNext()) {
                Tree n = (Tree) it.next();
                if(hasChild(list,n)){// 判斷子節點是否還有相應的子節點，若有則再次遞迴遍歷
                    recursionFn(list, n);
                }
            }
            node.setChild(childList);
            returnList.add(node);
        }
    }

    // 得到子節點列表
    private static List<Tree> getChildList(List<Tree> list, Tree node) {
        List<Tree> nodeList = new ArrayList<Tree>();
        Iterator<Tree> it = list.iterator();
        while (it.hasNext()) {
            Tree n = (Tree) it.next();
            if (n.getParentId().equals(node.getId())) {
                nodeList.add(n);
            }
        }
        Collections.sort(nodeList);
        return nodeList;
    }

    // 判斷是否有子節點
    private static boolean hasChild(List<Tree> list, Tree node) {
        return getChildList(list, node).size() > 0 ? true : false;
    }

}

UserInfo工具類內容如下：

package com.mongo.common.util.user;




import com.mongo.common.util.node.NodeUtil;
import com.mongo.sys.entity.Tree;
import com.mongo.sys.entity.User;
import com.mongo.sys.entity.UserRole;
import com.mongo.sys.service.TreeService;
import com.mongo.sys.service.UserRoleService;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.*;

/**
 * @auher linzf
 * @since 2018-03-31
 */
public class UserInfo {

    /**
     * 功能描述：載入選單節點的資料
     * @return
     */
    public static List<Tree> loadUserTree(UserRoleService userRoleService, TreeService treeService){
        Map<String,Tree> treeMap = new HashMap<String,Tree>();
        User user = getUser();
        List<UserRole> userRoleList = userRoleService.getUserRoleByRoleId(user);
        for(UserRole userRole:userRoleList){
            for(Tree tree:userRole.getTreeList()){
                treeMap.put(tree.getId(),treeService.get(tree.getId()));
            }
        }
        List<Tree> treeList = NodeUtil.getChildNodes(new ArrayList<Tree>(treeMap.values()),"5ac0c4a0c053f417ac310e3f");
        return treeList;
    }

    /**
     * 功能描述：實現對密碼進行bcrypt加密
     * @param password
     * @return
     */
    public static String encode(String password){
        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        return passwordEncoder.encode(password);
    }

    /**
     * 功能描述：獲取當前登陸的使用者的資訊
     * 註釋：強轉一個null物件不會產生報錯
     * @return
     */
    public static User getUser(){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        SecurityContextImpl securityContextImpl = (SecurityContextImpl) request.getSession().getAttribute("SPRING_SECURITY_CONTEXT");
        return (User)Optional.ofNullable(securityContextImpl.getAuthentication().getPrincipal()).orElse(null);
    }

    /**
     * 功能描述：獲取當前登陸的使用者的許可權集合
     * @return
     */
    public static List<GrantedAuthority> getGrantedAuthority(){
        return (List<GrantedAuthority>)Optional.ofNullable(SecurityContextHolder.getContext().getAuthentication().getAuthorities()).orElse(new ArrayList<>());
    }

    /**
     * 功能描述：判斷當前的使用者是否包含某一個許可權
     * @param authority
     * 註釋：
     *      allMatch：Stream 中全部元素符合傳入的 predicate，返回 true
     *      anyMatch：Stream 中只要有一個元素符合傳入的 predicate，返回 true
     *      noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true
     * @return
     */
    public static boolean hasAuthority(String authority){
        return getGrantedAuthority().stream().anyMatch(obj->obj.getAuthority().equalsIgnoreCase(authority));
    }

}

4、編寫好我們的工具類以後我們就可以正式開始編寫我們的使用者、角色、選單的service業務實現類。

TreeService內容如下：

package com.mongo.sys.service;


import com.mongo.common.base.dao.MongodbBaseDao;
import com.mongo.common.base.service.MongodbBaseService;
import com.mongo.sys.dao.TreeDao;
import com.mongo.sys.entity.QueryTree;
import com.mongo.sys.entity.Tree;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TreeService extends MongodbBaseService<Tree,QueryTree> {

    @Autowired
    private TreeDao treeDao;

    @Override
    protected MongodbBaseDao<Tree, QueryTree> getDao() {
        return treeDao;
    }
}

UserRoleService內容如下：

package com.mongo.sys.service;


import com.mongo.common.base.dao.MongodbBaseDao;
import com.mongo.common.base.service.MongodbBaseService;
import com.mongo.sys.dao.UserRoleDao;
import com.mongo.sys.entity.QueryUserRole;
import com.mongo.sys.entity.User;
import com.mongo.sys.entity.UserRole;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserRoleService extends MongodbBaseService<UserRole,QueryUserRole> {

    @Autowired
    private UserRoleDao userRoleDao;

    @Override
    protected MongodbBaseDao<UserRole, QueryUserRole> getDao() {
        return userRoleDao;
    }

    @Override
    public UserRole save(UserRole entity) {
        entity.packagingTrees(entity.getTreeArray());
        return super.save(entity);
    }

    @Override
    public void updateById(String id, UserRole entity) {
        entity.packagingTrees(entity.getTreeArray());
        super.updateById(id, entity);
    }



    /**
     * 功能描述：根據使用者來獲取使用者相應的角色以及他的選單資料
     * @param user
     * @return
     */
    public List<UserRole> getUserRoleByRoleId(User user){
        return userRoleDao.getUserRoleByRoleId(user.getRoles());
    }
}

UserService內容如下：

package com.mongo.sys.service;


import com.mongo.common.base.dao.MongodbBaseDao;
import com.mongo.common.base.service.MongodbBaseService;
import com.mongo.common.util.user.UserInfo;
import com.mongo.sys.dao.UserDao;
import com.mongo.sys.dao.UserRoleDao;
import com.mongo.sys.entity.QueryUser;
import com.mongo.sys.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

/**
 * 功能描述:實現使用者管理的service
 */
@Service
public class UserService extends MongodbBaseService<User,QueryUser> {

    @Autowired
    private UserDao userDao;

    @Autowired
    private UserRoleDao userRoleDao;

    @Override
    protected MongodbBaseDao<User,QueryUser> getDao() {
        return userDao;
    }

    /**
     * 功能描述：更新使用者狀態為可用或者不可用
     * @param user
     * @return
     */
    public void userControl(User user){
        userDao.userControl(user);
    }


    @Override
    public void updateById(String id, User user) {
        user.packagingRoles(user.getRoleArray(),userRoleDao);
        super.updateById(id, user);
    }

    @Override
    public User save(User entity) {
        entity.setAddress(entity.getProvince()+entity.getCity()+entity.getDistrict()+entity.getStreetAddress());
        entity.setPassword(UserInfo.encode(entity.getPassword()));
        entity.setState("1");
        entity.packagingRoles(entity.getRoleArray(),userRoleDao);
        return super.save(entity);
    }

    /**
     * 功能描述：根據賬號來獲取使用者資訊
     * @param login
     * @return
     */
    public User findByLogin(String login){
        return userDao.findByLogin(login);
    }

}

5、編寫好了我們的業務實現類service，接著我們就開始編寫我們的controller控制層的實現類，UserController、TreeController、RoleController.

UserController:

package com.mongo.sys.controller;


import com.mongo.common.base.constant.SystemStaticConst;
import com.mongo.common.base.controller.MongodbBaseController;
import com.mongo.common.base.entity.Pagination;
import com.mongo.common.base.service.MongodbBaseService;
import com.mongo.common.util.user.UserInfo;
import com.mongo.sys.entity.QueryUser;
import com.mongo.sys.entity.Tree;
import com.mongo.sys.entity.User;
import com.mongo.sys.entity.UserRole;
import com.mongo.sys.service.TreeService;
import com.mongo.sys.service.UserRoleService;
import com.mongo.sys.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("/user")
public class UserController extends MongodbBaseController<User,QueryUser> {

    @Autowired
    private UserService userService;
    @Autowired
    private UserRoleService userRoleService;
    @Autowired
    private TreeService treeService;

    @Override
    protected MongodbBaseService<User,QueryUser> getService() {
        return userService;
    }


    /**
     * 功能描述：更新使用者狀態為禁用/啟用
     * @param entity
     * @return
     */
    @RequestMapping(value="/userControl")
    @ResponseBody
    public Map<String,Object> userControl(User entity) throws Exception{
        Map<String,Object> result = new HashMap<String, Object>();
        userService.userControl(entity);
        result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
        result.put(SystemStaticConst.MSG,"更新使用者狀態成功！");
        result.put("entity",entity);
        return result;
    }

    /**
     * 功能描述：載入所有的許可權資料
     * @return
     */
    @RequestMapping(value = "/loadRoles",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public Map<String,Object> loadRoles(){
        Map<String,Object> result = new HashMap<String, Object>();
        List<UserRole> userRoleList = userRoleService.find(new Query());
        result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
        result.put("list",userRoleList);
        return result;
    }

    /**
     * 功能描述：載入首頁選單節點的資料
     * @return
     */
    @RequestMapping(value="/mainTree",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public Map<String,Object> mainTree(){
        Map<String,Object> result = new HashMap<String, Object>();
        List<Tree> trees = UserInfo.loadUserTree(userRoleService,treeService);
        result.put("data",trees);
        result.put(SystemStaticConst.RESULT, SystemStaticConst.SUCCESS);
        return result;
    }


    /**
     * 功能描述：獲取使用者的分頁的資料
     * @param entity
     * @return
     */
    @RequestMapping(value = "/list",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public Map<String,Object> list(QueryUser entity){
        Map<String,Object> result = new HashMap<String, Object>();
        Pagination page = userService.findByPage(entity);
        result.put("totalCount",page.getTotalNumber());
        result.put("result",page.getItems());
        return result;
    }
}

TreeController

package com.mongo.sys.controller;


import com.mongo.common.base.constant.SystemStaticConst;
import com.mongo.common.base.controller.MongodbBaseController;
import com.mongo.common.base.service.MongodbBaseService;
import com.mongo.sys.entity.QueryTree;
import com.mongo.sys.entity.Tree;
import com.mongo.sys.service.TreeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.http.MediaType;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("/tree")
public class TreeController  extends MongodbBaseController<Tree,QueryTree> {

    @Autowired
    private TreeService treeService;

    @Override
    protected MongodbBaseService<Tree, QueryTree> getService() {
        return treeService;
    }

    /**
     * 功能描述：跳轉到修改選單節點的頁面
     * @param entity
     * @param model
     * @return
     * @throws Exception
     */
    @RequestMapping(value="/updateTreePage")
    public String updateTreePage(Tree entity,Model model) throws Exception{
        entity = treeService.get(entity.getId());
        Tree pTree = null;
        if(entity.getParentId().equals("5ac0c4a0c053f417ac310e3f")){
            pTree = new Tree();
            pTree.setId("5ac0c4a0c053f417ac310e3f");
            pTree.setName("頂層節點");
        }else{
            pTree = treeService.get(entity.getParentId());
        }
        entity.setTree(pTree);
        model.addAttribute("entity",entity);
        return getPageBaseRoot()+UPDATEPAGE;
    }

    /**
     * 功能描述：跳轉到增加選單節點的頁面
     * @param entity
     * @param model
     * @return
     * @throws Exception
     */
    @RequestMapping(value="/addTreePage")
    public String addPage(Tree entity,Model model) throws Exception{
        if(entity.getId().equals("5ac0c4a0c053f417ac310e3f")){
            entity = new Tree();
            entity.setId("5ac0c4a0c053f417ac310e3f");
            entity.setName("頂層節點");
        }else{
            entity = treeService.get(entity.getId());
        }
        model.addAttribute("entity",entity);
        return getPageBaseRoot()+ADDPAGE;
    }

    /**
     * 功能描述：直接載入整個選單樹的資料(且必須要有管理員許可權才可以載入該選單樹的資料)
     * @return
     */
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    @RequestMapping(value = "/loadUserTree",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public Map<String,Object> loadUserTree(){
        Map<String,Object> result = new HashMap<String, Object>();
        List<Tree> treeList = treeService.find(new Query());
        result.put(SystemStaticConst.RESULT, SystemStaticConst.SUCCESS);
        result.put(SystemStaticConst.MSG,"載入選單資料成功！");
        result.put("data",treeList);
        return result;
    }
}

RoleController

package com.mongo.sys.controller;


import com.mongo.common.base.constant.SystemStaticConst;
import com.mongo.common.base.controller.MongodbBaseController;
import com.mongo.common.base.entity.Pagination;
import com.mongo.common.base.service.MongodbBaseService;
import com.mongo.sys.entity.QueryUserRole;
import com.mongo.sys.entity.Tree;
import com.mongo.sys.entity.UserRole;
import com.mongo.sys.service.TreeService;
import com.mongo.sys.service.UserRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.http.MediaType;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("/role")
public class RoleController extends MongodbBaseController<UserRole,QueryUserRole> {

    @Autowired
    private UserRoleService userRoleService;

    @Autowired
    private TreeService treeService;

    @Override
    protected MongodbBaseService<UserRole, QueryUserRole> getService() {
        return userRoleService;
    }

    /**
     * 功能描述：獲取使用者的分頁的資料
     * @param entity
     * @return
     */
    @RequestMapping(value = "/list",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public Map<String,Object> list(QueryUserRole entity){
        Map<String,Object> result = new HashMap<String, Object>();
        Pagination<UserRole> page = userRoleService.findByPage(entity);
        result.put("totalCount",page.getTotalNumber());
        result.put("result",page.getItems());
        return result;
    }

    /**
     * 功能描述：根據使用者的許可權去載入角色資料
     * @return
     */
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    @RequestMapping(value = "/loadRoleTree",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public Map<String,Object> loadRoleTree(UserRole entity){
        entity = userRoleService.get(entity.getId()+"");
        List<Tree> treeList = treeService.find(new Query());
        if(entity!=null){
            for(Tree tree:entity.getTreeList()){
                treeList.stream().forEach(t->{
                    if(t.getId().equals(tree.getId())){
                        t.setChecked(true);
                    }
                });
            }
        }
        Map<String,Object> result = new HashMap<String, Object>();
        result.put(SystemStaticConst.RESULT, SystemStaticConst.SUCCESS);
        result.put("data",treeList);
        return result;
    }

}

到此處我們完成了這三個模組的整合工作，剩餘的組織架構和資料字典模組，就請大家自己去我的github上直接下載就好了，此處就不再進行累述了。

QQ交流群：578746866

基於spring boot和mongodb打造一套完整的許可權架構（五）【整合使用者模組、選單模組、角色模組】

在第四章我們已經實現了對security的整合，我們已經實現了登陸到我們的系統中了，但是大家會發現我們登陸成功以後並沒有顯示左側的選單節點，本章我們將開始整合使用者模組、選單模組以及角色模組。 1、首先我們需要在sys的entity目錄底下建立Tree、

基於spring boot和mongodb打造一套完整的許可權架構（二）【MAVEN依賴以及相應配置】

在上一章我們已經新建好整個專案了，在本章我們將講解我們的這套許可權架構所需要的maven依賴以及相關的配置，大家開啟我們的pom.xml增加完maven依賴以後的配置檔案如下：<?xml version="1.0" encoding="UTF-8"?>

基於spring boot 獨立開發的一套統一認證解決方案，易讀、易拓展

follow 公司登錄頁面跳轉所有不可權限 github 源碼公司需求搭建公司內部系統，需要使用到統一認證，在查看shiro等發現接入無頭緒，而且存在不可控性，對於認證系統高可用、可靠性會顯得無比重要，所以筆者決定手動擼一套統一認證解決方案。筆者通過sprin

基於SpringBoot開發一套完整的專案（二）準備工作

1.SpringBoot框架內容想了一下，覺得在開發之前應該先大致瞭解一下springboot框架的概括，然後在後面的開發過程中再進一步加深理解，做到知其然知其所以然！Spring Boot 是基於Spring 框架技術來構建的，所以Spring Boot 又

基於springboot+redis+bootstrap+mysql開發一套屬於自己的分散式springcloud雲許可權架構（九）【許可權架構生產者（角色管理）】

在第七章我們完成了對資料字典的整合，本章我們將完成角色管理的整合工作，首先開啟我們的rbac-produce工程，接著在com/produce/sys/dao目錄底下建立一個UserRoleDao.java介面內容如下：package com.produce.sy

基於Spring Boot和Spring Cloud實現微服務架構學習(一)-Spring框架介紹

總結看了幾周Spring相關框架的書籍和官方demo，是時候開始總結下這中間的學習感悟。首先，最想說的是，當你要學習一套最新的技術時，官網的英文文件是學習的最佳渠道。因為網上流傳的多數資料是官網翻譯而來，很多描述的重點也都偏向於作者自身碰到的問題，這樣就很容易讓你理解

基於Spring Boot和Spring Cloud實現微服務架構學習

發的附加引入所有應用集中式一個操作但是 onf Spring Cloud介紹 Spring Cloud是一個基於Spring Boot實現的雲應用開發工具，它為基於JVM的雲應用開發中的配置管理、服務發現、斷路器、智能路由、微代理、控制總線、全局鎖、決策競選、

基於Spring Boot和Spring Cloud實現微服務架構學習(四)

feign 方法調用規則實現 uri ati .com 阻止無法 Spring Cloud介紹 Spring Cloud是一個基於Spring Boot實現的雲應用開發工具，它為基於JVM的雲應用開發中的配置管理、服務發現、斷路器、智能路由、微代理、控制總線、全局鎖、

基於 spring boot 和 spring mvc 的快速開發框架 summer-boot

summer-boot 詳細介紹此專案目的在於提供一個簡化、簡潔、迅速的開發架構。它是基於spring boot和spring mvc高度封裝的快速開發框架，資料庫操作工具summerDao是基於jdbcTemplate高度封裝簡化、擁有超級簡單實用的O

輕輕鬆鬆學習SpringBoot2：第二十五篇： Spring Boot和Mongodb整合（完整版）

今天主要講的是Spring Boot和Mongodb整合我們先來回顧一下前面章節的相關內容前面我們講了SpringBoot和mysql整合，並且講了操作資料庫的幾種方式自動生成表資料庫操作操作篇回到正題，mongodb的安裝在這就不累述了，win版本的去官網下載，然後一直下一

基於Spring Boot和Shiro的後臺管理系統FEBS

bootstra title 樹形數據項目打包 redis監控開發框架 local 資源 FEBS是一個簡單高效的後臺權限管理系統。項目基礎框架采用全新的Java Web開發框架 —— Spring Boot 2.0.3，消除了繁雜的XML配置，使得

基於Spring Boot和Spring Cloud實現微服務架構學習(四)-Spring Cloud總結

Spring Cloud介紹 Spring Cloud是一個基於Spring Boot實現的雲應用開發工具，它為基於JVM的雲應用開發中的配置管理、服務發現、斷路器、智慧路由、微代理、控制匯流排、全域性鎖、決策競選、分散式會話和叢集狀態管理等操作提供了一種簡單的開發方式。

基於Spring Boot和Spring Cloud實現微服務架構學習(五)-Docker總結

介紹 Docker 是一個開源的應用容器引擎，讓開發者可以打包他們的應用以及依賴包到一個可移植的容器中，然後釋出到任何流行的 Linux 機器上，也可以實現虛擬化。容器是完全使用沙箱機制，相互之間不會有任何介面。 Docker在部署軟體方面解決了最困難的問題，將應用程式程式

基於Spring-Boot和Redis快取Mysql資料庫資料

@Configuration @EnableCaching public class CacheConfig extends CachingConfigurerSupport { @Value("${spring.redis.host}") private String host;

基於spring-boot和docker-java實現對docker容器的動態管理和監控[附完整原始碼下載]

（我是個封面） docker簡介 Docker 是一個開源的應用容器引擎，和傳統的虛擬機器技術相比，Docker 容器效能開銷極低，因此也廣受開發者喜愛。隨著基於docker的開發者越來越多，docker的映象也原來越豐富，未來各種企業級的完整解決方案都可以直接通過下載映象拿來即用。因此do

基於springboot+bootstrap+mysql+redis搭建一套完整的許可權架構【八】【完善整個專案】

上一章我們已經完成了選單模組的開發工作，那麼到了本章我們將完成我們角色管理模組的開發工作，在本章開始一個全新的模組進行開發的時候我們需要遵守一定的命名和開發規範如下： 1、我們的Controller的RequestMapping的命名要和我們的資料夾的命名一致，且增加的頁面要

Spring Boot（五）：整合Redis和使用Redis實現快取共享

Redis（REmote DIctionary Server）是一個key-value儲存系統，是當下網際網路公司最常用的NoSQL資料庫之一。支援儲存的value型別有string、list、set、zset(sorted set --有序集合)和hash。Redis的資料

基於springboot+bootstrap+mysql+redis搭建一套完整的許可權架構【五】【編寫基礎程式碼快速生成工具】

首先我們在我們的com.csdn包底下我們新建一個codeUtil包如下所示：首先我們新建一個我們的列的模型（ColumnModel.java）如下： /** * 列模型 */ public class ColumnModel { private bool

基於SpringBoot開發一套完整的專案（一）準備工作

1.1 SpringBoot簡介① 為所有Spring 開發提供一個更快更廣泛的人門體驗。② 零配置。無冗餘程式碼生成和XML 強制配置，遵循“約定大於配置” 。③ 集成了大量常用的第三方庫的配置， Spring Boot 應用為這些第三方庫提供了幾乎可以零配置的開箱即用的能

基於springboot+bootstrap+mysql+redis搭建一套完整的許可權架構【二】【整合springSecurity】

若需要整合我們的springSecurity，一種是直接使用springSecurity自帶的許可權架構，另外一種是使用我們自己設計的資料架構，本文所闡述的就是使用自己設計的RBAC許可權架構,因此我們要事先設計好使用者許可權架構的PDM如下圖所示，並建立我

基於spring boot和mongodb打造一套完整的許可權架構（五）【整合使用者模組、選單模組、角色模組】

相關推薦