eladmin 1.0 版本发布

src/main/java/me/zhengjie/system/rest/MenuController.java

+package me.zhengjie.system.rest;
+
+import me.zhengjie.common.aop.log.Log;
+import me.zhengjie.common.exception.BadRequestException;
+import me.zhengjie.core.utils.JwtTokenUtil;
+import me.zhengjie.system.domain.Menu;
+import me.zhengjie.system.domain.User;
+import me.zhengjie.system.service.MenuService;
+import me.zhengjie.system.service.UserService;
+import me.zhengjie.system.service.dto.MenuDTO;
+import me.zhengjie.system.service.query.MenuQueryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import javax.servlet.http.HttpServletRequest;
+import java.util.List;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@RestController
+@RequestMapping("api")
+public class MenuController {
+
+    @Autowired
+    private JwtTokenUtil jwtTokenUtil;
+
+    @Autowired
+    private MenuService menuService;
+
+    @Autowired
+    private MenuQueryService menuQueryService;
+
+    @Autowired
+    private UserService userService;
+
+    private static final String ENTITY_NAME = "menu";
+
+    @GetMapping(value = "/menus/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','MENU_ALL','MENU_SELECT')")
+    public ResponseEntity getMenus(@PathVariable Long id){
+        return new ResponseEntity(menuService.findById(id), HttpStatus.OK);
+    }
+
+    /**
+     * 构建前端路由所需要的菜单
+     * @return
+     */
+    @GetMapping(value = "/menus/build")
+    public ResponseEntity buildMenus(HttpServletRequest request){
+        User user = userService.findByName(jwtTokenUtil.getUserName(request));
+
+        List<MenuDTO> menuDTOList = menuService.findByRoles(user.getRoles());
+        return new ResponseEntity(menuService.buildMenus((List<MenuDTO>)menuService.buildTree(menuDTOList).get("content")),HttpStatus.OK);
+    }
+
+    /**
+     * 返回全部的菜单
+     * @return
+     */
+    @GetMapping(value = "/menus/tree")
+    @PreAuthorize("hasAnyRole('ADMIN','MENU_ALL','MENU_SELECT')")
+    public ResponseEntity getMenuTree(){
+        return new ResponseEntity(menuService.getMenuTree(menuService.findByPid(0L)),HttpStatus.OK);
+    }
+
+    @Log(description = "查询菜单")
+    @GetMapping(value = "/menus")
+    @PreAuthorize("hasAnyRole('ADMIN','MENU_ALL','MENU_SELECT')")
+    public ResponseEntity getMenus(@RequestParam(required = false) String name){
+        List<MenuDTO> menuDTOList = menuQueryService.queryAll(name);
+        return new ResponseEntity(menuService.buildTree(menuDTOList),HttpStatus.OK);
+    }
+
+    @Log(description = "新增菜单")
+    @PostMapping(value = "/menus")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_CREATE')")
+    public ResponseEntity create(@Validated @RequestBody Menu resources){
+        if (resources.getId() != null) {
+            throw new BadRequestException("A new "+ ENTITY_NAME +" cannot already have an ID");
+        }
+        return new ResponseEntity(menuService.create(resources),HttpStatus.CREATED);
+    }
+
+    @Log(description = "修改菜单")
+    @PutMapping(value = "/menus")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_EDIT')")
+    public ResponseEntity update(@Validated @RequestBody Menu resources){
+        if (resources.getId() == null) {
+            throw new BadRequestException(ENTITY_NAME +" ID Can not be empty");
+        }
+        menuService.update(resources);
+        return new ResponseEntity(HttpStatus.NO_CONTENT);
+    }
+
+    @Log(description = "删除菜单")
+    @DeleteMapping(value = "/menus/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_DELETE')")
+    public ResponseEntity delete(@PathVariable Long id){
+        menuService.delete(id);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+}

src/main/java/me/zhengjie/system/rest/PermissionController.java

+package me.zhengjie.system.rest;
+
+import me.zhengjie.common.aop.log.Log;
+import me.zhengjie.common.exception.BadRequestException;
+import me.zhengjie.system.domain.Permission;
+import me.zhengjie.system.service.PermissionService;
+import me.zhengjie.system.service.dto.PermissionDTO;
+import me.zhengjie.system.service.query.PermissionQueryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@RestController
+@RequestMapping("api")
+public class PermissionController {
+
+    @Autowired
+    private PermissionService permissionService;
+
+    @Autowired
+    private PermissionQueryService permissionQueryService;
+
+    private static final String ENTITY_NAME = "permission";
+
+    @GetMapping(value = "/permissions/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_SELECT')")
+    public ResponseEntity getPermissions(@PathVariable Long id){
+        return new ResponseEntity(permissionService.findById(id), HttpStatus.OK);
+    }
+
+    /**
+     * 返回全部的权限，新增角色时下拉选择
+     * @return
+     */
+    @GetMapping(value = "/permissions/tree")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','ROLE_ALL','ROLE_ADD','ROLE_EDIT')")
+    public ResponseEntity getRoleTree(){
+        return new ResponseEntity(permissionService.getPermissionTree(permissionService.findByPid(0L)),HttpStatus.OK);
+    }
+
+    @Log(description = "查询权限")
+    @GetMapping(value = "/permissions")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_SELECT')")
+    public ResponseEntity getPermissions(@RequestParam(required = false) String name){
+        List<PermissionDTO> permissionDTOS = permissionQueryService.queryAll(name);
+        return new ResponseEntity(permissionService.buildTree(permissionDTOS),HttpStatus.OK);
+    }
+
+    @Log(description = "新增权限")
+    @PostMapping(value = "/permissions")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_CREATE')")
+    public ResponseEntity create(@Validated @RequestBody Permission resources){
+        if (resources.getId() != null) {
+            throw new BadRequestException("A new "+ ENTITY_NAME +" cannot already have an ID");
+        }
+        return new ResponseEntity(permissionService.create(resources),HttpStatus.CREATED);
+    }
+
+    @Log(description = "修改权限")
+    @PutMapping(value = "/permissions")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_EDIT')")
+    public ResponseEntity update(@Validated @RequestBody Permission resources){
+        if (resources.getId() == null) {
+            throw new BadRequestException(ENTITY_NAME +" ID Can not be empty");
+        }
+        permissionService.update(resources);
+        return new ResponseEntity(HttpStatus.NO_CONTENT);
+    }
+
+    @Log(description = "删除权限")
+    @DeleteMapping(value = "/permissions/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','PERMISSION_ALL','PERMISSION_DELETE')")
+    public ResponseEntity delete(@PathVariable Long id){
+        permissionService.delete(id);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+}

src/main/java/me/zhengjie/system/rest/RoleController.java

+package me.zhengjie.system.rest;
+
+import me.zhengjie.common.aop.log.Log;
+import me.zhengjie.common.exception.BadRequestException;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.service.RoleService;
+import me.zhengjie.system.service.dto.RoleDTO;
+import me.zhengjie.system.service.query.RoleQueryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@RestController
+@RequestMapping("api")
+public class RoleController {
+
+    @Autowired
+    private RoleService roleService;
+
+    @Autowired
+    private RoleQueryService roleQueryService;
+
+    private static final String ENTITY_NAME = "role";
+
+    @GetMapping(value = "/roles/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','ROLE_ALL','ROLE_SELECT')")
+    public ResponseEntity getRoles(@PathVariable Long id){
+        return new ResponseEntity(roleService.findById(id), HttpStatus.OK);
+    }
+
+    /**
+     * 返回全部的角色，新增用户时下拉选择
+     * @return
+     */
+    @GetMapping(value = "/roles/tree")
+    @PreAuthorize("hasAnyRole('ADMIN','ROLE_ALL','USER_ALL','USER_ADD','USER_EDIT')")
+    public ResponseEntity getRoleTree(){
+        return new ResponseEntity(roleService.getRoleTree(),HttpStatus.OK);
+    }
+
+    @Log(description = "查询角色")
+    @GetMapping(value = "/roles")
+    @PreAuthorize("hasAnyRole('ADMIN','ROLE_ALL','ROLE_SELECT')")
+    public ResponseEntity getRoles(RoleDTO resources, Pageable pageable){
+        return new ResponseEntity(roleQueryService.queryAll(resources,pageable),HttpStatus.OK);
+    }
+
+    @Log(description = "新增角色")
+    @PostMapping(value = "/roles")
+    @PreAuthorize("hasAnyRole('ADMIN','ROLE_ALL','ROLE_CREATE')")
+    public ResponseEntity create(@Validated @RequestBody Role resources){
+        if (resources.getId() != null) {
+            throw new BadRequestException("A new "+ ENTITY_NAME +" cannot already have an ID");
+        }
+        return new ResponseEntity(roleService.create(resources),HttpStatus.CREATED);
+    }
+
+    @Log(description = "修改角色")
+    @PutMapping(value = "/roles")
+    @PreAuthorize("hasAnyRole('ADMIN','ROLE_ALL','ROLE_EDIT')")
+    public ResponseEntity update(@Validated @RequestBody Role resources){
+        if (resources.getId() == null) {
+            throw new BadRequestException(ENTITY_NAME +" ID Can not be empty");
+        }
+        roleService.update(resources);
+        return new ResponseEntity(HttpStatus.NO_CONTENT);
+    }
+
+    @Log(description = "删除角色")
+    @DeleteMapping(value = "/roles/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','ROLE_ALL','ROLE_DELETE')")
+    public ResponseEntity delete(@PathVariable Long id){
+        roleService.delete(id);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+}

src/main/java/me/zhengjie/system/rest/UserController.java

+package me.zhengjie.system.rest;
+
+import me.zhengjie.common.aop.log.Log;
+import me.zhengjie.common.exception.BadRequestException;
+import me.zhengjie.system.domain.User;
+import me.zhengjie.system.service.UserService;
+import me.zhengjie.system.service.dto.UserDTO;
+import me.zhengjie.system.service.query.UserQueryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@RestController
+@RequestMapping("api")
+public class UserController {
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private UserQueryService userQueryService;
+
+    private static final String ENTITY_NAME = "user";
+
+    @GetMapping(value = "/users/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','USER_ALL','USER_SELECT')")
+    public ResponseEntity getUser(@PathVariable Long id){
+        return new ResponseEntity(userService.findById(id), HttpStatus.OK);
+    }
+
+    @Log(description = "查询用户")
+    @GetMapping(value = "/users")
+    @PreAuthorize("hasAnyRole('ADMIN','USER_ALL','USER_SELECT')")
+    public ResponseEntity getUsers(UserDTO userDTO, Pageable pageable){
+        return new ResponseEntity(userQueryService.queryAll(userDTO,pageable),HttpStatus.OK);
+    }
+
+    @Log(description = "新增用户")
+    @PostMapping(value = "/users")
+    @PreAuthorize("hasAnyRole('ADMIN','USER_ALL','USER_CREATE')")
+    public ResponseEntity create(@Validated @RequestBody User resources){
+        if (resources.getId() != null) {
+            throw new BadRequestException("A new "+ ENTITY_NAME +" cannot already have an ID");
+        }
+        return new ResponseEntity(userService.create(resources),HttpStatus.CREATED);
+    }
+
+    @Log(description = "修改用户")
+    @PutMapping(value = "/users")
+    @PreAuthorize("hasAnyRole('ADMIN','USER_ALL','USER_EDIT')")
+    public ResponseEntity update(@Validated @RequestBody User resources){
+        if (resources.getId() == null) {
+            throw new BadRequestException(ENTITY_NAME +" ID Can not be empty");
+        }
+        userService.update(resources);
+        return new ResponseEntity(HttpStatus.NO_CONTENT);
+    }
+
+    @Log(description = "删除用户")
+    @DeleteMapping(value = "/users/{id}")
+    @PreAuthorize("hasAnyRole('ADMIN','USER_ALL','USER_DELETE')")
+    public ResponseEntity delete(@PathVariable Long id){
+        userService.delete(id);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+}

src/main/java/me/zhengjie/system/service/MenuService.java

+package me.zhengjie.system.service;
+
+import me.zhengjie.system.domain.Menu;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.service.dto.MenuDTO;
+import org.springframework.cache.annotation.CacheConfig;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author jie
+ * @date 2018-12-17
+ */
+@CacheConfig(cacheNames = "menu")
+public interface MenuService {
+
+    /**
+     * get
+     * @param id
+     * @return
+     */
+    @Cacheable(key = "#p0")
+    MenuDTO findById(long id);
+
+    /**
+     * create
+     * @param resources
+     * @return
+     */
+    @CacheEvict(allEntries = true)
+    MenuDTO create(Menu resources);
+
+    /**
+     * update
+     * @param resources
+     */
+    @CacheEvict(allEntries = true)
+    void update(Menu resources);
+
+    /**
+     * delete
+     * @param id
+     */
+    @CacheEvict(allEntries = true)
+    void delete(Long id);
+
+    /**
+     * permission tree
+     * @return
+     */
+    @Cacheable(key = "'tree'")
+    Object getMenuTree(List<Menu> menus);
+
+    /**
+     * findByPid
+     * @param pid
+     * @return
+     */
+    @Cacheable(key = "'pid:'+#p0")
+    List<Menu> findByPid(long pid);
+
+    /**
+     * build Tree
+     * @param menuDTOS
+     * @return
+     */
+    Map buildTree(List<MenuDTO> menuDTOS);
+
+    /**
+     * findByRoles
+     * @param roles
+     * @return
+     */
+    List<MenuDTO> findByRoles(Set<Role> roles);
+
+    /**
+     * buildMenus
+     * @param byRoles
+     * @return
+     */
+    Object buildMenus(List<MenuDTO> byRoles);
+}

src/main/java/me/zhengjie/system/service/PermissionService.java

+package me.zhengjie.system.service;
+
+import me.zhengjie.system.domain.Permission;
+import me.zhengjie.system.service.dto.PermissionDTO;
+import org.springframework.cache.annotation.CacheConfig;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import java.util.List;
+
+/**
+ * @author jie
+ * @date 2018-12-08
+ */
+@CacheConfig(cacheNames = "permission")
+public interface PermissionService {
+
+    /**
+     * get
+     * @param id
+     * @return
+     */
+    @Cacheable(key = "#p0")
+    PermissionDTO findById(long id);
+
+    /**
+     * create
+     * @param resources
+     * @return
+     */
+    @CacheEvict(allEntries = true)
+    PermissionDTO create(Permission resources);
+
+    /**
+     * update
+     * @param resources
+     */
+    @CacheEvict(allEntries = true)
+    void update(Permission resources);
+
+    /**
+     * delete
+     * @param id
+     */
+    @CacheEvict(allEntries = true)
+    void delete(Long id);
+
+    /**
+     * permission tree
+     * @return
+     */
+    @Cacheable(key = "'tree'")
+    Object getPermissionTree(List<Permission> permissions);
+
+    /**
+     * findByPid
+     * @param pid
+     * @return
+     */
+    @Cacheable(key = "'pid:'+#p0")
+    List<Permission> findByPid(long pid);
+
+    /**
+     * build Tree
+     * @param permissionDTOS
+     * @return
+     */
+    Object buildTree(List<PermissionDTO> permissionDTOS);
+}

src/main/java/me/zhengjie/system/service/RoleService.java

+package me.zhengjie.system.service;
+
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.service.dto.RoleDTO;
+import me.zhengjie.system.service.dto.UserDTO;
+import org.springframework.cache.annotation.CacheConfig;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@CacheConfig(cacheNames = "role")
+public interface RoleService {
+
+    /**
+     * get
+     * @param id
+     * @return
+     */
+    @Cacheable(key = "#p0")
+    RoleDTO findById(long id);
+
+    /**
+     * create
+     * @param resources
+     * @return
+     */
+    @CacheEvict(allEntries = true)
+    RoleDTO create(Role resources);
+
+    /**
+     * update
+     * @param resources
+     */
+    @CacheEvict(allEntries = true)
+    void update(Role resources);
+
+    /**
+     * delete
+     * @param id
+     */
+    @CacheEvict(allEntries = true)
+    void delete(Long id);
+
+    /**
+     * role tree
+     * @return
+     */
+    @Cacheable(key = "'tree'")
+    Object getRoleTree();
+}

src/main/java/me/zhengjie/system/service/UserService.java

+package me.zhengjie.system.service;
+
+import me.zhengjie.system.domain.User;
+import me.zhengjie.system.service.dto.UserDTO;
+import org.springframework.cache.annotation.CacheConfig;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@CacheConfig(cacheNames = "user")
+public interface UserService {
+
+    /**
+     * get
+     * @param id
+     * @return
+     */
+    @Cacheable(key = "#p0")
+    UserDTO findById(long id);
+
+    /**
+     * create
+     * @param resources
+     * @return
+     */
+    @CacheEvict(allEntries = true)
+    UserDTO create(User resources);
+
+    /**
+     * update
+     * @param resources
+     */
+    @CacheEvict(allEntries = true)
+    void update(User resources);
+
+    /**
+     * delete
+     * @param id
+     */
+    @CacheEvict(allEntries = true)
+    void delete(Long id);
+
+    /**
+     * findByName
+     * @param userName
+     * @return
+     */
+    @Cacheable(key = "'findByName'+#p0")
+    User findByName(String userName);
+}

src/main/java/me/zhengjie/system/service/dto/MenuDTO.java

+package me.zhengjie.system.service.dto;
+
+import lombok.Data;
+import java.sql.Timestamp;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author jie
+ * @date 2018-12-17
+ */
+@Data
+public class MenuDTO {
+
+    private Long id;
+
+    private String name;
+
+    private Long soft;
+
+    private String path;
+
+    private String component;
+
+    private Long pid;
+
+    private Boolean iFrame;
+
+    private String icon;
+
+    private Set<RoleDTO> roles;
+
+    private List<MenuDTO> children;
+
+    private Timestamp createTime;
+}

src/main/java/me/zhengjie/system/service/dto/PermissionDTO.java

+package me.zhengjie.system.service.dto;
+
+import lombok.Data;
+import java.io.Serializable;
+import java.sql.Timestamp;
+import java.util.List;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@Data
+public class PermissionDTO implements Serializable{
+
+	private Long id;
+
+	private String name;
+
+	private Long pid;
+
+	private String alias;
+
+	private Timestamp createTime;
+
+	private List<PermissionDTO>  children;
+
+	@Override
+	public String toString() {
+		return "Permission{" +
+				"id=" + id +
+				", name='" + name + '\'' +
+				", pid=" + pid +
+				", alias='" + alias + '\'' +
+				", createTime=" + createTime +
+				'}';
+	}
+}

src/main/java/me/zhengjie/system/service/dto/RoleDTO.java

+package me.zhengjie.system.service.dto;
+
+import lombok.Data;
+import java.io.Serializable;
+import java.sql.Timestamp;
+import java.util.Set;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Data
+public class RoleDTO implements Serializable {
+
+    private Long id;
+
+    private String name;
+
+    private String remark;
+
+    private Set<PermissionDTO> permissions;
+
+    private Timestamp createTime;
+}

src/main/java/me/zhengjie/system/service/dto/UserDTO.java

+package me.zhengjie.system.service.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import java.io.Serializable;
+import java.sql.Timestamp;
+import java.util.Date;
+import java.util.Set;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Data
+public class UserDTO implements Serializable {
+
+    private Long id;
+
+    private String username;
+
+    private String avatar;
+
+    private String email;
+
+    private Boolean enabled;
+
+    @JsonIgnore
+    private String password;
+
+    private Timestamp createTime;
+
+    private Date lastPasswordResetTime;
+
+    private Set<RoleDTO> roles;
+}

src/main/java/me/zhengjie/system/service/impl/MenuServiceImpl.java

+package me.zhengjie.system.service.impl;
+
+import cn.hutool.core.util.StrUtil;
+import me.zhengjie.common.exception.EntityExistException;
+import me.zhengjie.common.utils.ValidationUtil;
+import me.zhengjie.system.domain.Menu;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.domain.vo.MenuMetaVo;
+import me.zhengjie.system.domain.vo.MenuVo;
+import me.zhengjie.system.repository.MenuRepository;
+import me.zhengjie.system.service.MenuService;
+import me.zhengjie.system.service.dto.MenuDTO;
+import me.zhengjie.system.service.mapper.MenuMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class MenuServiceImpl implements MenuService {
+
+    @Autowired
+    private MenuRepository menuRepository;
+
+    @Autowired
+    private MenuMapper menuMapper;
+
+    @Override
+    public MenuDTO findById(long id) {
+        Optional<Menu> menu = menuRepository.findById(id);
+        ValidationUtil.isNull(menu,"Menu","id",id);
+        return menuMapper.toDto(menu.get());
+    }
+
+    @Override
+    public List<MenuDTO> findByRoles(Set<Role> roles) {
+        Set<Menu> menus = menuRepository.findByRoles(roles);
+        return menus.stream().map(menuMapper::toDto).collect(Collectors.toList());
+    }
+
+    @Override
+    public MenuDTO create(Menu resources) {
+        if(menuRepository.findByName(resources.getName()) != null){
+            throw new EntityExistException(Menu.class,"name",resources.getName());
+        }
+        return menuMapper.toDto(menuRepository.save(resources));
+    }
+
+    @Override
+    public void update(Menu resources) {
+        Optional<Menu> optionalPermission = menuRepository.findById(resources.getId());
+        ValidationUtil.isNull(optionalPermission,"Permission","id",resources.getId());
+
+        Menu menu = optionalPermission.get();
+        Menu menu1 = menuRepository.findByName(resources.getName());
+
+        if(menu1 != null && !menu1.getId().equals(menu.getId())){
+            throw new EntityExistException(Menu.class,"name",resources.getName());
+        }
+
+        menu.setName(resources.getName());
+        menu.setIcon(resources.getIcon());
+        menu.setIFrame(resources.getIFrame());
+        menu.setPid(resources.getPid());
+        menu.setSoft(resources.getSoft());
+        menuRepository.save(menu);
+    }
+
+    @Override
+    public void delete(Long id) {
+        List<Menu> menuList = menuRepository.findByPid(id);
+        for (Menu menu : menuList) {
+            menuRepository.delete(menu);
+        }
+        menuRepository.deleteById(id);
+    }
+
+    @Override
+    public Object getMenuTree(List<Menu> menus) {
+        List<Map<String,Object>> list = new LinkedList<>();
+        menus.forEach(menu -> {
+                    if (menu!=null){
+                        Map<String,Object> map = new HashMap<>();
+                        map.put("id",menu.getId());
+                        map.put("label",menu.getName());
+                        list.add(map);
+                    }
+                }
+        );
+        return list;
+    }
+
+    @Override
+    public List<Menu> findByPid(long pid) {
+        return menuRepository.findByPid(pid);
+    }
+
+    @Override
+    public Map buildTree(List<MenuDTO> menuDTOS) {
+        List<MenuDTO> trees = new ArrayList<MenuDTO>();
+
+        for (MenuDTO menuDTO : menuDTOS) {
+
+            if ("0".equals(menuDTO.getPid().toString())) {
+                trees.add(menuDTO);
+            }
+
+            for (MenuDTO it : menuDTOS) {
+                if (it.getPid().equals(menuDTO.getId())) {
+                    if (menuDTO.getChildren() == null) {
+                        menuDTO.setChildren(new ArrayList<MenuDTO>());
+                    }
+                    menuDTO.getChildren().add(it);
+                }
+            }
+        }
+
+        Integer totalElements = menuDTOS!=null?menuDTOS.size():0;
+        Map map = new HashMap();
+        map.put("content",trees.size() == 0?menuDTOS:trees);
+        map.put("totalElements",totalElements);
+        return map;
+    }
+
+    @Override
+    public List<MenuVo> buildMenus(List<MenuDTO> menuDTOS) {
+        List<MenuVo> list = new LinkedList<>();
+        menuDTOS.forEach(menuDTO -> {
+            if (menuDTO!=null){
+                List<MenuDTO> menuDTOList = menuDTO.getChildren();
+                MenuVo menuVo = new MenuVo();
+                menuVo.setName(menuDTO.getName());
+                menuVo.setPath(menuDTO.getPath());
+                if(!menuDTO.getIFrame()){
+                    if(menuDTO.getPid().equals(0L)){
+                        //一级目录需要加斜杠，不然访问不了
+                        menuVo.setPath("/" + menuDTO.getPath());
+                    }
+                    menuVo.setComponent(StrUtil.isEmpty(menuDTO.getComponent())?"Layout":menuDTO.getComponent());
+                }
+                menuVo.setMeta(new MenuMetaVo(menuDTO.getName(),menuDTO.getIcon()));
+                if(menuDTOList!=null && menuDTOList.size()!=0){
+                    menuVo.setAlwaysShow(true);
+                    menuVo.setChildren(buildMenus(menuDTOList));
+                }
+                list.add(menuVo);
+            }
+        }
+        );
+        return list;
+    }
+}

src/main/java/me/zhengjie/system/service/impl/PermissionServiceImpl.java

+package me.zhengjie.system.service.impl;
+
+import me.zhengjie.common.exception.EntityExistException;
+import me.zhengjie.common.utils.ValidationUtil;
+import me.zhengjie.system.domain.Permission;
+import me.zhengjie.system.repository.PermissionRepository;
+import me.zhengjie.system.service.PermissionService;
+import me.zhengjie.system.service.dto.PermissionDTO;
+import me.zhengjie.system.service.mapper.PermissionMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class PermissionServiceImpl implements PermissionService {
+
+    @Autowired
+    private PermissionRepository permissionRepository;
+
+    @Autowired
+    private PermissionMapper permissionMapper;
+
+    @Override
+    public PermissionDTO findById(long id) {
+        Optional<Permission> permission = permissionRepository.findById(id);
+        ValidationUtil.isNull(permission,"Permission","id",id);
+        return permissionMapper.toDto(permission.get());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public PermissionDTO create(Permission resources) {
+        if(permissionRepository.findByName(resources.getName()) != null){
+            throw new EntityExistException(Permission.class,"name",resources.getName());
+        }
+        return permissionMapper.toDto(permissionRepository.save(resources));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void update(Permission resources) {
+        Optional<Permission> optionalPermission = permissionRepository.findById(resources.getId());
+        ValidationUtil.isNull(optionalPermission,"Permission","id",resources.getId());
+
+        Permission permission = optionalPermission.get();
+        Permission permission1 = permissionRepository.findByName(resources.getName());
+
+        if(permission1 != null && !permission1.getId().equals(permission.getId())){
+            throw new EntityExistException(Permission.class,"name",resources.getName());
+        }
+
+        permission.setName(resources.getName());
+        permission.setAlias(resources.getAlias());
+        permission.setPid(resources.getPid());
+        permissionRepository.save(permission);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Long id) {
+        List<Permission> permissionList = permissionRepository.findByPid(id);
+        for (Permission permission : permissionList) {
+            permissionRepository.delete(permission);
+        }
+        permissionRepository.deleteById(id);
+    }
+
+    @Override
+    public Object getPermissionTree(List<Permission> permissions) {
+        List<Map<String,Object>> list = new LinkedList<>();
+        permissions.forEach(permission -> {
+                    if (permission!=null){
+                        List<Permission> permissionList = permissionRepository.findByPid(permission.getId());
+                        Map<String,Object> map = new HashMap<>();
+                        map.put("id",permission.getId());
+                        map.put("label",permission.getAlias());
+                        if(permissionList!=null && permissionList.size()!=0){
+                            map.put("children",getPermissionTree(permissionList));
+                        }
+                        list.add(map);
+                    }
+                }
+        );
+        return list;
+    }
+
+    @Override
+    public List<Permission> findByPid(long pid) {
+        return permissionRepository.findByPid(pid);
+    }
+
+    @Override
+    public Object buildTree(List<PermissionDTO> permissionDTOS) {
+
+        List<PermissionDTO> trees = new ArrayList<PermissionDTO>();
+
+        for (PermissionDTO permissionDTO : permissionDTOS) {
+
+            if ("0".equals(permissionDTO.getPid().toString())) {
+                trees.add(permissionDTO);
+            }
+
+            for (PermissionDTO it : permissionDTOS) {
+                if (it.getPid().equals(permissionDTO.getId())) {
+                    if (permissionDTO.getChildren() == null) {
+                        permissionDTO.setChildren(new ArrayList<PermissionDTO>());
+                    }
+                    permissionDTO.getChildren().add(it);
+                }
+            }
+        }
+
+        Integer totalElements = permissionDTOS!=null?permissionDTOS.size():0;
+
+        Map map = new HashMap();
+        map.put("content",trees.size() == 0?permissionDTOS:trees);
+        map.put("totalElements",totalElements);
+        return map;
+    }
+}

src/main/java/me/zhengjie/system/service/impl/RoleServiceImpl.java

+package me.zhengjie.system.service.impl;
+
+import me.zhengjie.common.exception.EntityExistException;
+import me.zhengjie.common.utils.ValidationUtil;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.repository.RoleRepository;
+import me.zhengjie.system.service.RoleService;
+import me.zhengjie.system.service.dto.RoleDTO;
+import me.zhengjie.system.service.mapper.RoleMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @author jie
+ * @date 2018-12-03
+ */
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class RoleServiceImpl implements RoleService {
+
+    @Autowired
+    private RoleRepository roleRepository;
+
+    @Autowired
+    private RoleMapper roleMapper;
+
+    @Override
+    public RoleDTO findById(long id) {
+        Optional<Role> role = roleRepository.findById(id);
+        ValidationUtil.isNull(role,"Role","id",id);
+        return roleMapper.toDto(role.get());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public RoleDTO create(Role resources) {
+        if(roleRepository.findByName(resources.getName()) != null){
+            throw new EntityExistException(Role.class,"username",resources.getName());
+        }
+        return roleMapper.toDto(roleRepository.save(resources));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void update(Role resources) {
+        Optional<Role> optionalRole = roleRepository.findById(resources.getId());
+        ValidationUtil.isNull(optionalRole,"Role","id",resources.getId());
+
+        Role role = optionalRole.get();
+        Role role1 = roleRepository.findByName(resources.getName());
+
+        if(role1 != null && !role1.getId().equals(role.getId())){
+            throw new EntityExistException(Role.class,"username",resources.getName());
+        }
+
+        role.setName(resources.getName());
+        role.setRemark(resources.getRemark());
+        role.setPermissions(resources.getPermissions());
+        roleRepository.save(role);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Long id) {
+        roleRepository.deleteById(id);
+    }
+
+    @Override
+    public Object getRoleTree() {
+
+        List<Role> roleList = roleRepository.findAll();
+
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (Role role : roleList) {
+            Map<String, Object> map = new HashMap<>();
+            map.put("id",role.getId());
+            map.put("label",role.getName());
+            list.add(map);
+        }
+        return list;
+    }
+}

src/main/java/me/zhengjie/system/service/impl/UserServiceImpl.java

+package me.zhengjie.system.service.impl;
+
+import me.zhengjie.common.exception.BadRequestException;
+import me.zhengjie.common.exception.EntityExistException;
+import me.zhengjie.common.exception.EntityNotFoundException;
+import me.zhengjie.common.utils.ValidationUtil;
+import me.zhengjie.core.utils.EncryptUtils;
+import me.zhengjie.system.domain.User;
+import me.zhengjie.system.repository.UserRepository;
+import me.zhengjie.system.service.UserService;
+import me.zhengjie.system.service.dto.UserDTO;
+import me.zhengjie.system.service.mapper.UserMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.Optional;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class UserServiceImpl implements UserService {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private UserMapper userMapper;
+
+    @Override
+    public UserDTO findById(long id) {
+        Optional<User> user = userRepository.findById(id);
+        ValidationUtil.isNull(user,"User","id",id);
+        return userMapper.toDto(user.get());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public UserDTO create(User resources) {
+
+        if(userRepository.findByUsername(resources.getUsername())!=null){
+            throw new EntityExistException(User.class,"username",resources.getUsername());
+        }
+
+        if(userRepository.findByEmail(resources.getEmail())!=null){
+            throw new EntityExistException(User.class,"email",resources.getEmail());
+        }
+
+        if(resources.getRoles() == null || resources.getRoles().size() == 0){
+            throw new BadRequestException("角色不能为空");
+        }
+
+        // 默认密码 123456
+        resources.setPassword("14e1b600b1fd579f47433b88e8d85291");
+        resources.setAvatar("https://i.loli.net/2018/12/06/5c08894d8de21.jpg");
+        return userMapper.toDto(userRepository.save(resources));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void update(User resources) {
+
+        Optional<User> userOptional = userRepository.findById(resources.getId());
+        ValidationUtil.isNull(userOptional,"User","id",resources.getId());
+
+        User user = userOptional.get();
+
+        User user1 = userRepository.findByUsername(user.getUsername());
+        User user2 = userRepository.findByEmail(user.getEmail());
+
+        if(resources.getRoles() == null || resources.getRoles().size() == 0){
+            throw new BadRequestException("角色不能为空");
+        }
+
+        if(user1 !=null&&!user.getId().equals(user1.getId())){
+            throw new EntityExistException(User.class,"username",resources.getUsername());
+        }
+
+        if(user2!=null&&!user.getId().equals(user2.getId())){
+            throw new EntityExistException(User.class,"email",resources.getEmail());
+        }
+
+        user.setUsername(resources.getUsername());
+        user.setEmail(resources.getEmail());
+        user.setEnabled(resources.getEnabled());
+        user.setRoles(resources.getRoles());
+
+        userRepository.save(user);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Long id) {
+        userRepository.deleteById(id);
+    }
+
+    @Override
+    public User findByName(String userName) {
+        User user = null;
+        if(ValidationUtil.isEmail(userName)){
+            user = userRepository.findByEmail(userName);
+        } else {
+            user = userRepository.findByUsername(userName);
+        }
+
+        if (user == null) {
+            throw new EntityNotFoundException(User.class, "name", userName);
+        } else {
+            return user;
+        }
+    }
+}

src/main/java/me/zhengjie/system/service/mapper/MenuMapper.java

+package me.zhengjie.system.service.mapper;
+
+import me.zhengjie.common.mapper.EntityMapper;
+import me.zhengjie.system.domain.Menu;
+import me.zhengjie.system.service.dto.MenuDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author jie
+ * @date 2018-12-17
+ */
+@Mapper(componentModel = "spring",uses = {RoleMapper.class},unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface MenuMapper extends EntityMapper<MenuDTO, Menu> {
+
+}

src/main/java/me/zhengjie/system/service/mapper/PermissionMapper.java

+package me.zhengjie.system.service.mapper;
+
+import me.zhengjie.common.mapper.EntityMapper;
+import me.zhengjie.system.domain.Permission;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.service.dto.PermissionDTO;
+import me.zhengjie.system.service.dto.RoleDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Mapper(componentModel = "spring",unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface PermissionMapper extends EntityMapper<PermissionDTO, Permission> {
+
+}

src/main/java/me/zhengjie/system/service/mapper/RoleMapper.java

+package me.zhengjie.system.service.mapper;
+
+import me.zhengjie.common.mapper.EntityMapper;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.service.dto.RoleDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Mapper(componentModel = "spring", uses = {PermissionMapper.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface RoleMapper extends EntityMapper<RoleDTO, Role> {
+
+}

src/main/java/me/zhengjie/system/service/mapper/UserMapper.java

+package me.zhengjie.system.service.mapper;
+
+import me.zhengjie.common.mapper.EntityMapper;
+import me.zhengjie.system.domain.User;
+import me.zhengjie.system.service.dto.UserDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Mapper(componentModel = "spring",uses = {RoleMapper.class},unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface UserMapper extends EntityMapper<UserDTO, User> {
+
+}