第一次提交

.gitignore

+### IDEA ###
+.idea/*
+*.iml
+*/target/*
+*/*.iml
\ No newline at end of file

README.md

+<h1 style="text-align: center">el-admin 后台管理系统</h1>
+<div style="text-align: center">
+
+[![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/elunez/eladmin/blob/master/LICENSE)
+[![star](https://gitee.com/elunez/eladmin/badge/star.svg?theme=white)](https://gitee.com/elunez/eladmin)
+[![GitHub stars](https://img.shields.io/github/stars/elunez/eladmin.svg?style=social&label=Stars)](https://github.com/elunez/eladmin)
+[![GitHub forks](https://img.shields.io/github/forks/elunez/eladmin.svg?style=social&label=Fork)](https://github.com/elunez/eladmin)
+
+</div>
+
+#### 项目简介
+eladmin基于 Spring Boot 2.1.0 、 Jpa、 Spring Security、redis、Vue的前后端分离的后台管理系统， 权限控制的方式为RBAC，项目支持数据字典与数据权限管理，支持一键生成前后端代码，支持前端菜单动态路由
+
+**开发文档**  [https://docs.auauz.net/](https://docs.auauz.net)
+
+**体验地址**  [https://auauz.net/](https://auauz.net/)
+
+**账号密码** ```admin/123456```(默认密码都是123456)
+
+#### 项目源码
+
+|     |   后端源码  |   前端源码  |
+|---  |--- | --- |
+|  github   |  https://github.com/elunez/eladmin   |  https://github.com/elunez/eladmin-web   |
+|  码云   |  https://gitee.com/elunez/eladmin   |  https://gitee.com/elunez/eladmin-web   |
+
+####  系统功能
+- 用户管理：提供用户的相关配置，新增用户后，默认密码为123456
+- 角色管理：对权限与菜单进行分配，可根据部门设置角色的数据权限
+- 菜单管理：已实现菜单动态路由，后端可配置化，支持多级菜单
+- 部门管理：可配置系统组织架构，树形表格展示
+- 岗位管理：配置各个部门的职位
+- 字典管理：应广大码友的要求加入字典管理，可维护常用一些固定的数据，如：状态，性别等
+- 操作日志：记录用户操作的日志
+- 异常日志：记录异常日志，方便开发人员定位错误
+- 系统缓存：使用jedis将缓存操作可视化，并提供对redis的基本操作，可根据需求自行扩展
+- SQL监控：采用druid 监控数据库访问性能，默认用户名admin，密码123456
+- 定时任务：整合Quartz做定时任务，加入任务日志，任务运行情况一目了然
+- 代码生成：高灵活度一键生成前后端代码，减少百分之80左右的工作任务
+- 邮件工具：配合富文本，发送html格式的邮件
+- 免费图床：使用sm.ms图床，用作公共图片上传使用
+- 七牛云存储：可同步七牛云存储的数据到系统，无需登录七牛云直接操作云数据
+- 支付宝支付：整合了支付宝支付并且提供了测试账号，可自行测试
+
+#### 项目结构
+项目采用按功能分模块开发方式，将通用的配置放在公共模块，```system```模块为系统核心模块也是项目入口模块，```logging``` 模块为系统的日志模块，```tools``` 为第三方工具模块，包含了图床、邮件、七牛云、支付宝，```generator``` 为系统的代码生成模块
+
+- eladmin-common 公共模块
+  - annotation 为系统自定义注解
+  - aspect 自定义注解的切面
+  - base 提供了Entity、DTO基类和mapstruct的通用mapper
+  - config 自定义权限实现、redis配置、swagger配置
+  - exception 项目统一异常的处理
+  - utils 系统通用工具类
+- eladmin-system 系统核心模块（系统启动入口）
+  - config 配置跨域与静态资源，与数据权限
+    - thread 线程池相关
+  - modules 系统相关模块(登录授权、系统监控、定时任务等)
+- eladmin-logging 系统日志模块
+- eladmin-tools 系统第三方工具模块
+- eladmin-generator 系统代码生成模块
+
+#### 系统预览
+<table>
+    <tr>
+        <td><img src="https://i.loli.net/2019/05/18/5cdf77fa8144d68788.png"/></td>
+        <td><img src="https://i.loli.net/2019/05/18/5cdf7763993e361778.png"/></td>
+    </tr>
+    <tr>
+        <td><img src="https://i.loli.net/2019/05/18/5cdf7763971d453615.png"/></td>
+        <td><img src="https://i.loli.net/2019/05/18/5cdf77632e85a60423.png"/></td>
+    </tr>
+    <tr>
+        <td><img src="https://i.loli.net/2019/05/18/5cdf77632b4b090165.png"/></td>
+        <td><img src="https://i.loli.net/2019/05/18/5cdf77639929277783.png"/></td>
+    </tr>
+    <tr>   
+ <td><img src="https://i.loli.net/2019/05/18/5cdf78969adc389599.png"/></td>
+    </tr>
+</table>
+
+#### 项目捐赠
+项目的发展离不开你的支持，请作者喝杯咖啡吧！ps：辣条也行 ☕！ [Donate](https://docs.auauz.net/#/jz)
+#### 反馈交流
+- QQ交流群：891137268

eladmin-common/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>eladmin</artifactId>
+        <groupId>me.zhengjie</groupId>
+        <version>2.3</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>eladmin-common</artifactId>
+    <name>公共模块</name>
+</project>
\ No newline at end of file

eladmin-common/src/main/java/me/zhengjie/annotation/AnonymousAccess.java

+package me.zhengjie.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author jacky
+ *  用于标记匿名访问方法
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AnonymousAccess {
+
+}

eladmin-common/src/main/java/me/zhengjie/annotation/Limit.java

+package me.zhengjie.annotation;
+
+import me.zhengjie.aspect.LimitType;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author jacky
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Limit {
+
+    // 资源名称，用于描述接口功能
+    String name() default "";
+
+    // 资源 key
+    String key() default "";
+
+    // key prefix
+    String prefix() default "";
+
+    // 时间的，单位秒
+    int period();
+
+    // 限制访问次数
+    int count();
+
+    // 限制类型
+    LimitType limitType() default LimitType.CUSTOMER;
+
+}

eladmin-common/src/main/java/me/zhengjie/annotation/Query.java

+package me.zhengjie.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-6-4 13:52:30
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Query {
+
+    // Dong ZhaoYang 2017/8/7 基本对象的属性名
+    String propName() default "";
+    // Dong ZhaoYang 2017/8/7 查询方式
+    Type type() default Type.EQUAL;
+
+    /**
+     * 连接查询的属性名，如User类中的dept
+     */
+    String joinName() default "";
+
+    /**
+     * 默认左连接
+     */
+    Join join() default Join.LEFT;
+
+    /**
+     * 多字段模糊搜索，仅支持String类型字段，多个用逗号隔开, 如@Query(blurry = "email,username")
+     */
+    String blurry() default "";
+
+    String[] orPropNames() default {};
+
+    String orPropVal() default "";
+
+    enum Type {
+        // jie 2019/6/4 相等
+        EQUAL
+        // Dong ZhaoYang 2017/8/7 大于等于
+        , GREATER_THAN
+        // Dong ZhaoYang 2017/8/7 小于等于
+        , LESS_THAN
+        // Dong ZhaoYang 2017/8/7 中模糊查询
+        , INNER_LIKE
+        // Dong ZhaoYang 2017/8/7 左模糊查询
+        , LEFT_LIKE
+        // Dong ZhaoYang 2017/8/7 右模糊查询
+        , RIGHT_LIKE
+        // Dong ZhaoYang 2017/8/7 小于
+        , LESS_THAN_NQ
+        // jie 2019/6/4 包含
+        , IN
+        // huang 2020/7/76 或者
+        , OR
+        // huang 2020/7/16 相等或者等于null
+        , CONTAINS_NULL
+
+    }
+
+    /**
+     * @author Zheng Jie
+     * 适用于简单连接查询，复杂的请自定义该注解，或者使用sql查询
+     */
+    enum Join {
+        /** jie 2019-6-4 13:18:30 左连接 */
+        LEFT
+        /** jie 2019-6-4 13:18:30 右连接 */
+        , RIGHT
+    }
+
+}
+

eladmin-common/src/main/java/me/zhengjie/aspect/LimitAspect.java

+package me.zhengjie.aspect;
+
+import com.google.common.collect.ImmutableList;
+import me.zhengjie.annotation.Limit;
+import me.zhengjie.exception.BadRequestException;
+import me.zhengjie.utils.RequestHolder;
+import me.zhengjie.utils.StringUtils;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.script.DefaultRedisScript;
+import org.springframework.data.redis.core.script.RedisScript;
+import org.springframework.stereotype.Component;
+import javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.Method;
+
+@Aspect
+@Component
+public class LimitAspect {
+
+    private final RedisTemplate<Object,Object> redisTemplate;
+    private static final Logger logger = LoggerFactory.getLogger(LimitAspect.class);
+
+    public LimitAspect(RedisTemplate<Object,Object> redisTemplate) {
+        this.redisTemplate = redisTemplate;
+    }
+
+    @Pointcut("@annotation(me.zhengjie.annotation.Limit)")
+    public void pointcut() {
+    }
+
+    @Around("pointcut()")
+    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+        HttpServletRequest request = RequestHolder.getHttpServletRequest();
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        Method signatureMethod = signature.getMethod();
+        Limit limit = signatureMethod.getAnnotation(Limit.class);
+        LimitType limitType = limit.limitType();
+        String key = limit.key();
+        if (StringUtils.isEmpty(key)) {
+            if (limitType == LimitType.IP) {
+                key = StringUtils.getIp(request);
+            } else {
+                key = signatureMethod.getName();
+            }
+        }
+
+        ImmutableList<Object> keys = ImmutableList.of(StringUtils.join(limit.prefix(), "_", key, "_", request.getRequestURI().replaceAll("/","_")));
+
+        String luaScript = buildLuaScript();
+        RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.class);
+        Number count = redisTemplate.execute(redisScript, keys, limit.count(), limit.period());
+        if (null != count && count.intValue() <= limit.count()) {
+            logger.info("第{}次访问key为 {}，描述为 [{}] 的接口", count, keys, limit.name());
+            return joinPoint.proceed();
+        } else {
+            throw new BadRequestException("访问次数受限制");
+        }
+    }
+
+    /**
+     * 限流脚本
+     */
+    private String buildLuaScript() {
+        return "local c" +
+                "\nc = redis.call('get',KEYS[1])" +
+                "\nif c and tonumber(c) > tonumber(ARGV[1]) then" +
+                "\nreturn c;" +
+                "\nend" +
+                "\nc = redis.call('incr',KEYS[1])" +
+                "\nif tonumber(c) == 1 then" +
+                "\nredis.call('expire',KEYS[1],ARGV[2])" +
+                "\nend" +
+                "\nreturn c;";
+    }
+}

eladmin-common/src/main/java/me/zhengjie/aspect/LimitType.java

+package me.zhengjie.aspect;
+
+/**
+ * 限流枚举
+ * @author /
+ */
+public enum LimitType {
+    // 默认
+    CUSTOMER,
+    //  by ip addr
+    IP;
+}

eladmin-common/src/main/java/me/zhengjie/base/BaseDTO.java

+package me.zhengjie.base;
+
+import lombok.Getter;
+import lombok.Setter;
+import java.io.Serializable;
+import java.sql.Timestamp;
+
+/**
+ * @author Zheng Jie
+ * @Date 2019年10月24日20:48:53
+ */
+@Getter
+@Setter
+public class BaseDTO  implements Serializable {
+
+    private Boolean isDelete;
+
+    private Timestamp createTime;
+
+    private Timestamp updateTime;
+}

eladmin-common/src/main/java/me/zhengjie/base/BaseEntity.java

+package me.zhengjie.base;
+
+import lombok.*;
+import org.apache.commons.lang3.builder.ToStringBuilder;
+import org.hibernate.annotations.CreationTimestamp;
+import org.hibernate.annotations.UpdateTimestamp;
+import javax.persistence.Column;
+import javax.persistence.MappedSuperclass;
+import java.io.Serializable;
+import java.sql.Timestamp;
+import java.lang.reflect.Field;
+
+/**
+ * @author Zheng Jie
+ * @Date 2019年10月24日20:46:32
+ */
+@Getter
+@Setter
+@MappedSuperclass
+public class BaseEntity implements Serializable {
+
+    // 删除标识
+    @Column(name = "is_delete", columnDefinition = "bit default 0")
+    private Boolean isDelete = false;
+
+    @Column(name = "create_time")
+    @CreationTimestamp
+    private Timestamp createTime;
+
+    @Column(name = "update_time")
+    @UpdateTimestamp
+    private Timestamp updateTime;
+
+    public @interface Update {}
+
+    @Override
+    public String toString() {
+        ToStringBuilder builder = new ToStringBuilder(this);
+        Field[] fields = this.getClass().getDeclaredFields();
+        try {
+            for (Field f : fields) {
+                f.setAccessible(true);
+                builder.append(f.getName(), f.get(this)).append("\n");
+            }
+        } catch (Exception e) {
+            builder.append("toString builder encounter an error");
+        }
+        return builder.toString();
+    }
+}

eladmin-common/src/main/java/me/zhengjie/base/BaseMapper.java

+package me.zhengjie.base;
+
+import java.util.List;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+public interface BaseMapper<D, E> {
+
+    /**
+     * DTO转Entity
+     */
+    E toEntity(D dto);
+
+    /**
+     * Entity转DTO
+     */
+    D toDto(E entity);
+
+    /**
+     * DTO集合转Entity集合
+     */
+    List <E> toEntity(List<D> dtoList);
+
+    /**
+     * Entity集合转DTO集合
+     */
+    List <D> toDto(List<E> entityList);
+}

eladmin-common/src/main/java/me/zhengjie/config/ElPermissionConfig.java

+package me.zhengjie.config;
+
+import me.zhengjie.utils.SecurityUtils;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.stereotype.Service;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service(value = "el")
+public class ElPermissionConfig {
+
+    public Boolean check(String ...permissions){
+        // 如果是匿名访问的，就放行
+        String anonymous = "anonymous";
+        if(Arrays.asList(permissions).contains(anonymous)){
+            return true;
+        }
+        // 获取当前用户的所有权限
+        List<String> elPermissions = SecurityUtils.getUserDetails().getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());
+        // 判断当前用户的所有权限是否包含接口上定义的权限
+        return elPermissions.contains("admin") || Arrays.stream(permissions).anyMatch(elPermissions::contains);
+    }
+}

eladmin-common/src/main/java/me/zhengjie/config/RedisConfig.java

+package me.zhengjie.config;
+
+import cn.hutool.core.lang.Assert;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.parser.ParserConfig;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.utils.StringUtils;
+import org.apache.commons.codec.digest.DigestUtils;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.cache.Cache;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.interceptor.CacheErrorHandler;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@Slf4j
+@Configuration
+@EnableCaching
+@ConditionalOnClass(RedisOperations.class)
+@EnableConfigurationProperties(RedisProperties.class)
+public class RedisConfig extends CachingConfigurerSupport {
+
+    /**
+     *  设置 redis 数据默认过期时间，默认6小时
+     *  设置@cacheable 序列化方式
+     */
+    @Bean
+    public RedisCacheConfiguration redisCacheConfiguration(){
+        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
+        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig();
+        configuration = configuration.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(fastJsonRedisSerializer)).entryTtl(Duration.ofHours(6));
+        return configuration;
+    }
+
+    @Bean(name = "redisTemplate")
+    @ConditionalOnMissingBean(name = "redisTemplate")
+    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
+        RedisTemplate<Object, Object> template = new RedisTemplate<>();
+        //序列化
+        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
+        // value值的序列化采用fastJsonRedisSerializer
+        template.setValueSerializer(fastJsonRedisSerializer);
+        template.setHashValueSerializer(fastJsonRedisSerializer);
+        // 全局开启AutoType，这里方便开发，使用全局的方式
+        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
+        // 建议使用这种方式，小范围指定白名单
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.domain");
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.modules.system.service.dto");
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.service.dto");
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.modules.system.domain");
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.modules.quartz.domain");
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.modules.monitor.domain");
+//        ParserConfig.getGlobalInstance().addAccept("me.zhengjie.modules.security.security");
+        // key的序列化采用StringRedisSerializer
+        template.setKeySerializer(new StringRedisSerializer());
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setConnectionFactory(redisConnectionFactory);
+        return template;
+    }
+
+    /**
+     * 自定义缓存key生成策略，默认将使用该策略
+     */
+    @Bean
+    @Override
+    public KeyGenerator keyGenerator() {
+        return (target, method, params) -> {
+            Map<String,Object> container = new HashMap<>();
+            Class<?> targetClassClass = target.getClass();
+            // 类地址
+            container.put("class",targetClassClass.toGenericString());
+            // 方法名称
+            container.put("methodName",method.getName());
+            // 包名称
+            container.put("package",targetClassClass.getPackage());
+            // 参数列表
+            for (int i = 0; i < params.length; i++) {
+                container.put(String.valueOf(i),params[i]);
+            }
+            // 转为JSON字符串
+            String jsonString = JSON.toJSONString(container);
+            // 做SHA256 Hash计算，得到一个SHA256摘要作为Key
+            return DigestUtils.sha256Hex(jsonString);
+        };
+    }
+
+    @Bean
+    @Override
+    public CacheErrorHandler errorHandler() {
+        // 异常处理，当Redis发生异常时，打印日志，但是程序正常走
+        log.info("初始化 -> [{}]", "Redis CacheErrorHandler");
+        return new CacheErrorHandler() {
+            @Override
+            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
+                log.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
+            }
+
+            @Override
+            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
+                log.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
+            }
+
+            @Override
+            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
+                log.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
+            }
+
+            @Override
+            public void handleCacheClearError(RuntimeException e, Cache cache) {
+                log.error("Redis occur handleCacheClearError：", e);
+            }
+        };
+    }
+
+}
+
+/**
+ * Value 序列化
+ *
+ * @author /
+ * @param <T>
+ */
+ class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
+
+    private Class<T> clazz;
+
+    FastJsonRedisSerializer(Class<T> clazz) {
+        super();
+        this.clazz = clazz;
+    }
+
+    @Override
+    public byte[] serialize(T t) {
+        if (t == null) {
+            return new byte[0];
+        }
+        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(StandardCharsets.UTF_8);
+    }
+
+    @Override
+    public T deserialize(byte[] bytes) {
+        if (bytes == null || bytes.length <= 0) {
+            return null;
+        }
+        String str = new String(bytes, StandardCharsets.UTF_8);
+        return JSON.parseObject(str, clazz);
+    }
+
+}
+
+/**
+ * 重写序列化器
+ *
+ * @author /
+ */
+class StringRedisSerializer implements RedisSerializer<Object> {
+
+    private final Charset charset;
+
+    StringRedisSerializer() {
+        this(StandardCharsets.UTF_8);
+    }
+
+    private StringRedisSerializer(Charset charset) {
+        Assert.notNull(charset, "Charset must not be null!");
+        this.charset = charset;
+    }
+
+    @Override
+    public String deserialize(byte[] bytes) {
+        return (bytes == null ? null : new String(bytes, charset));
+    }
+
+    @Override
+    public byte[] serialize(Object object) {
+        String string = JSON.toJSONString(object);
+        if (StringUtils.isBlank(string)) {
+            return null;
+        }
+        string = string.replace("\"", "");
+        return string.getBytes(charset);
+    }
+}

eladmin-common/src/main/java/me/zhengjie/config/SwaggerConfig.java

+package me.zhengjie.config;
+
+import com.fasterxml.classmate.TypeResolver;
+import com.google.common.base.Predicates;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.Ordered;
+import org.springframework.data.domain.Pageable;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.ParameterBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.schema.AlternateTypeRule;
+import springfox.documentation.schema.AlternateTypeRuleConvention;
+import springfox.documentation.schema.ModelRef;
+import springfox.documentation.service.ApiInfo;
+import springfox.documentation.service.Parameter;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+import java.util.ArrayList;
+import java.util.List;
+import static com.google.common.collect.Lists.newArrayList;
+import static springfox.documentation.schema.AlternateTypeRules.newRule;
+
+/**
+ * api页面 /swagger-ui.html
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+
+@Configuration
+@EnableSwagger2
+public class SwaggerConfig {
+
+    @Value("${jwt.header}")
+    private String tokenHeader;
+
+    @Value("${swagger.enabled}")
+    private Boolean enabled;
+
+    @Bean
+    @SuppressWarnings("all")
+    public Docket createRestApi() {
+        ParameterBuilder ticketPar = new ParameterBuilder();
+        List<Parameter> pars = new ArrayList<>();
+        ticketPar.name(tokenHeader).description("token")
+                .modelRef(new ModelRef("string"))
+                .parameterType("header")
+                .defaultValue("Bearer ")
+                .required(true)
+                .build();
+        pars.add(ticketPar.build());
+        return new Docket(DocumentationType.SWAGGER_2)
+                .enable(enabled)
+                .apiInfo(apiInfo())
+                .select()
+                .paths(Predicates.not(PathSelectors.regex("/error.*")))
+                .build()
+                .globalOperationParameters(pars);
+    }
+
+    private ApiInfo apiInfo() {
+        return new ApiInfoBuilder()
+                .title("eladmin 接口文档")
+                .version("2.3")
+                .build();
+    }
+
+}
+
+/**
+ *  将Pageable转换展示在swagger中
+ */
+@Configuration
+class SwaggerDataConfig {
+
+    @Bean
+    public AlternateTypeRuleConvention pageableConvention(final TypeResolver resolver) {
+        return new AlternateTypeRuleConvention() {
+            @Override
+            public int getOrder() {
+                return Ordered.HIGHEST_PRECEDENCE;
+            }
+
+            @Override
+            public List<AlternateTypeRule> rules() {
+                return newArrayList(newRule(resolver.resolve(Pageable.class), resolver.resolve(Page.class)));
+            }
+        };
+    }
+
+    @ApiModel
+    @Data
+    private static class Page {
+        @ApiModelProperty("页码 (0..N)")
+        private Integer page;
+
+        @ApiModelProperty("每页显示的数目")
+        private Integer size;
+
+        @ApiModelProperty("以下列格式排序标准：property[,asc | desc]。 默认排序顺序为升序。 支持多种排序条件：如：id,asc")
+        private List<String> sort;
+    }
+}

eladmin-common/src/main/java/me/zhengjie/exception/BadRequestException.java

+package me.zhengjie.exception;
+
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-23
+ * 统一异常处理
+ */
+@Getter
+public class BadRequestException extends RuntimeException{
+
+    private Integer status = BAD_REQUEST.value();
+
+    public BadRequestException(String msg){
+        super(msg);
+    }
+
+    public BadRequestException(HttpStatus status,String msg){
+        super(msg);
+        this.status = status.value();
+    }
+}

eladmin-common/src/main/java/me/zhengjie/exception/EntityExistException.java

+package me.zhengjie.exception;
+
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+public class EntityExistException extends RuntimeException {
+
+    public EntityExistException(Class clazz, String field, String val) {
+        super(EntityExistException.generateMessage(clazz.getSimpleName(), field, val));
+    }
+
+    private static String generateMessage(String entity, String field, String val) {
+        return StringUtils.capitalize(entity)
+                + " with " + field + " "+ val + " existed";
+    }
+}
\ No newline at end of file

eladmin-common/src/main/java/me/zhengjie/exception/EntityNotFoundException.java

+package me.zhengjie.exception;
+
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+public class EntityNotFoundException extends RuntimeException {
+
+    public EntityNotFoundException(Class clazz, String field, String val) {
+        super(EntityNotFoundException.generateMessage(clazz.getSimpleName(), field, val));
+    }
+
+    private static String generateMessage(String entity, String field, String val) {
+        return StringUtils.capitalize(entity)
+                + " with " + field + " "+ val + " does not exist";
+    }
+}
\ No newline at end of file

eladmin-common/src/main/java/me/zhengjie/exception/handler/ApiError.java

+package me.zhengjie.exception.handler;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+@Data
+class ApiError {
+
+    private Integer status = 400;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime timestamp;
+    private String message;
+
+    private ApiError() {
+        timestamp = LocalDateTime.now();
+    }
+
+    public static ApiError error(String message){
+        ApiError apiError = new ApiError();
+        apiError.setMessage(message);
+        return apiError;
+    }
+
+    public static ApiError error(Integer status, String message){
+        ApiError apiError = new ApiError();
+        apiError.setStatus(status);
+        apiError.setMessage(message);
+        return apiError;
+    }
+}
+
+

eladmin-common/src/main/java/me/zhengjie/exception/handler/GlobalExceptionHandler.java

+package me.zhengjie.exception.handler;
+
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.exception.BadRequestException;
+import me.zhengjie.exception.EntityExistException;
+import me.zhengjie.exception.EntityNotFoundException;
+import me.zhengjie.utils.ThrowableUtil;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import java.util.Objects;
+import static org.springframework.http.HttpStatus.*;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+@Slf4j
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    /**
+     * 处理所有不可知的异常
+     */
+    @ExceptionHandler(Throwable.class)
+    public ResponseEntity handleException(Throwable e){
+        // 打印堆栈信息
+        log.error(ThrowableUtil.getStackTrace(e));
+        return buildResponseEntity(ApiError.error(e.getMessage()));
+    }
+
+    /**
+     * 处理 接口无权访问异常AccessDeniedException
+     */
+    @ExceptionHandler(AccessDeniedException.class)
+    public ResponseEntity handleAccessDeniedException(AccessDeniedException e){
+        // 打印堆栈信息
+        log.error(ThrowableUtil.getStackTrace(e));
+        return buildResponseEntity(ApiError.error(FORBIDDEN.value(),e.getMessage()));
+    }
+
+    /**
+     * 处理自定义异常
+     */
+	@ExceptionHandler(value = BadRequestException.class)
+	public ResponseEntity<ApiError> badRequestException(BadRequestException e) {
+        // 打印堆栈信息
+        log.error(ThrowableUtil.getStackTrace(e));
+        return buildResponseEntity(ApiError.error(e.getStatus(),e.getMessage()));
+	}
+
+    /**
+     * 处理 EntityExist
+     */
+    @ExceptionHandler(value = EntityExistException.class)
+    public ResponseEntity<ApiError> entityExistException(EntityExistException e) {
+        // 打印堆栈信息
+        log.error(ThrowableUtil.getStackTrace(e));
+        return buildResponseEntity(ApiError.error(e.getMessage()));
+    }
+
+    /**
+     * 处理 EntityNotFound
+     */
+    @ExceptionHandler(value = EntityNotFoundException.class)
+    public ResponseEntity<ApiError> entityNotFoundException(EntityNotFoundException e) {
+        // 打印堆栈信息
+        log.error(ThrowableUtil.getStackTrace(e));
+        return buildResponseEntity(ApiError.error(NOT_FOUND.value(),e.getMessage()));
+    }
+
+    /**
+     * 处理所有接口数据验证异常
+     */
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<ApiError> handleMethodArgumentNotValidException(MethodArgumentNotValidException e){
+        // 打印堆栈信息
+        log.error(ThrowableUtil.getStackTrace(e));
+        String[] str = Objects.requireNonNull(e.getBindingResult().getAllErrors().get(0).getCodes())[1].split("\\.");
+        String message = e.getBindingResult().getAllErrors().get(0).getDefaultMessage();
+        if("不能为空".equals(message)){
+            message = str[1] + ":" + message;
+        }
+        return buildResponseEntity(ApiError.error(message));
+    }
+
+    /**
+     * 统一返回
+     */
+    private ResponseEntity<ApiError> buildResponseEntity(ApiError apiError) {
+        return new ResponseEntity<>(apiError, HttpStatus.valueOf(apiError.getStatus()));
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/ElAdminConstant.java

+package me.zhengjie.utils;
+
+/**
+ * 常用静态常量
+ * @author Zheng Jie
+ * @date 2018-12-26
+ */
+public class ElAdminConstant {
+
+    public static final String RESET_PASS = "重置密码";
+
+    public static final String RESET_MAIL = "重置邮箱";
+
+    /**
+     * 用于IP定位转换
+     */
+    static final String REGION = "内网IP|内网IP";
+
+    /**
+     * 常用接口
+     */
+    public static class Url{
+        public static final String SM_MS_URL = "https://sm.ms/api/upload";
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/EncryptUtils.java

+package me.zhengjie.utils;
+
+import org.springframework.util.DigestUtils;
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.DESKeySpec;
+import javax.crypto.spec.IvParameterSpec;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * 加密
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+public class EncryptUtils {
+
+    private static String strKey = "Passw0rd", strParam = "Passw0rd";
+
+    /**
+     * 对称加密
+     */
+    public static String desEncrypt(String source) throws Exception {
+        if (source == null || source.length() == 0){
+            return null;
+        }
+        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
+        DESKeySpec desKeySpec = new DESKeySpec(strKey.getBytes(StandardCharsets.UTF_8));
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
+        SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
+        IvParameterSpec iv = new IvParameterSpec(strParam.getBytes(StandardCharsets.UTF_8));
+        cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
+        return byte2hex(
+                cipher.doFinal(source.getBytes(StandardCharsets.UTF_8))).toUpperCase();
+    }
+
+    private static String byte2hex(byte[] inStr) {
+        String stmp;
+        StringBuilder out = new StringBuilder(inStr.length * 2);
+        for (byte b : inStr) {
+            stmp = Integer.toHexString(b & 0xFF);
+            if (stmp.length() == 1) {
+                // 如果是0至F的单位字符串，则添加0
+                out.append("0").append(stmp);
+            } else {
+                out.append(stmp);
+            }
+        }
+        return out.toString();
+    }
+
+    private static byte[] hex2byte(byte[] b) {
+        if ((b.length % 2) != 0){
+            throw new IllegalArgumentException("长度不是偶数");
+        }
+        byte[] b2 = new byte[b.length / 2];
+        for (int n = 0; n < b.length; n += 2) {
+            String item = new String(b, n, 2);
+            b2[n / 2] = (byte) Integer.parseInt(item, 16);
+        }
+        return b2;
+    }
+
+    /**
+     * 对称解密
+     */
+    public static String desDecrypt(String source) throws Exception {
+        if (source == null || source.length() == 0){
+            return null;
+        }
+        byte[] src = hex2byte(source.getBytes());
+        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
+        DESKeySpec desKeySpec = new DESKeySpec(strKey.getBytes(StandardCharsets.UTF_8));
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
+        SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
+        IvParameterSpec iv = new IvParameterSpec(strParam.getBytes(StandardCharsets.UTF_8));
+        cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
+        byte[] retByte = cipher.doFinal(src);
+        return new String(retByte);
+    }
+
+    /**
+     * 密码加密
+     */
+    public static String encryptPassword(String password){
+        return  DigestUtils.md5DigestAsHex(password.getBytes());
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/FileUtil.java

+package me.zhengjie.utils;
+
+import cn.hutool.core.codec.Base64;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.poi.excel.BigExcelWriter;
+import cn.hutool.poi.excel.ExcelUtil;
+import me.zhengjie.exception.BadRequestException;
+import org.springframework.web.multipart.MultipartFile;
+import javax.activation.MimetypesFileTypeMap;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+import java.io.*;
+import java.security.MessageDigest;
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * File工具类，扩展 hutool 工具包
+ * @author Zheng Jie
+ * @date 2018-12-27
+ */
+public class FileUtil extends cn.hutool.core.io.FileUtil {
+
+    /**
+     * 定义GB的计算常量
+     */
+    private static final int GB = 1024 * 1024 * 1024;
+    /**
+     * 定义MB的计算常量
+     */
+    private static final int MB = 1024 * 1024;
+    /**
+     * 定义KB的计算常量
+     */
+    private static final int KB = 1024;
+
+    /**
+     * 格式化小数
+     */
+    private static final DecimalFormat DF = new DecimalFormat("0.00");
+
+    /**
+     * MultipartFile转File
+     */
+    public static File toFile(MultipartFile multipartFile){
+        // 获取文件名
+        String fileName = multipartFile.getOriginalFilename();
+        // 获取文件后缀
+        String prefix="."+getExtensionName(fileName);
+        File file = null;
+        try {
+            // 用uuid作为文件名，防止生成的临时文件重复
+            file = File.createTempFile(IdUtil.simpleUUID(), prefix);
+            // MultipartFile to File
+            multipartFile.transferTo(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return file;
+    }
+
+    /**
+     * 获取文件扩展名，不带 .
+     */
+    public static String getExtensionName(String filename) {
+        if ((filename != null) && (filename.length() > 0)) {
+            int dot = filename.lastIndexOf('.');
+            if ((dot >-1) && (dot < (filename.length() - 1))) {
+                return filename.substring(dot + 1);
+            }
+        }
+        return filename;
+    }
+
+    /**
+     * Java文件操作 获取不带扩展名的文件名
+     */
+    public static String getFileNameNoEx(String filename) {
+        if ((filename != null) && (filename.length() > 0)) {
+            int dot = filename.lastIndexOf('.');
+            if ((dot >-1) && (dot < (filename.length()))) {
+                return filename.substring(0, dot);
+            }
+        }
+        return filename;
+    }
+
+    /**
+     * 文件大小转换
+     */
+    public static String getSize(long size){
+        String resultSize;
+        if (size / GB >= 1) {
+            //如果当前Byte的值大于等于1GB
+            resultSize = DF.format(size / (float) GB) + "GB   ";
+        } else if (size / MB >= 1) {
+            //如果当前Byte的值大于等于1MB
+            resultSize = DF.format(size / (float) MB) + "MB   ";
+        } else if (size / KB >= 1) {
+            //如果当前Byte的值大于等于1KB
+            resultSize = DF.format(size / (float) KB) + "KB   ";
+        } else {
+            resultSize = size + "B   ";
+        }
+        return resultSize;
+    }
+
+    /**
+     * inputStream 转 File
+     */
+    static File inputStreamToFile(InputStream ins, String name) throws Exception{
+        File file = new File(System.getProperty("java.io.tmpdir") + File.separator + name);
+        if (file.exists()) {
+            return file;
+        }
+        OutputStream os = new FileOutputStream(file);
+        int bytesRead;
+        byte[] buffer = new byte[8192];
+        while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
+            os.write(buffer, 0, bytesRead);
+        }
+        os.close();
+        ins.close();
+        return file;
+    }
+
+    /**
+     * 将文件名解析成文件的上传路径
+     */
+    public static File upload(MultipartFile file, String filePath) {
+        Date date = new Date();
+        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddhhmmssS");
+        String name = getFileNameNoEx(file.getOriginalFilename());
+        String suffix = getExtensionName(file.getOriginalFilename());
+        String nowStr = "-" + format.format(date);
+        try {
+            String fileName = name + nowStr + "." + suffix;
+            String path = filePath + fileName;
+            // getCanonicalFile 可解析正确各种路径
+            File dest = new File(path).getCanonicalFile();
+            // 检测是否存在目录
+            if (!dest.getParentFile().exists()) {
+                dest.getParentFile().mkdirs();
+            }
+            // 文件写入
+            file.transferTo(dest);
+            return dest;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static String fileToBase64(File file) throws Exception {
+        FileInputStream inputFile = new FileInputStream(file);
+        String base64;
+        byte[] buffer = new byte[(int)file.length()];
+        inputFile.read(buffer);
+        inputFile.close();
+        base64=Base64.encode(buffer);
+        return base64.replaceAll("[\\s*\t\n\r]", "");
+    }
+
+    /**
+     * 导出excel
+     */
+    public static void downloadExcel(List<Map<String, Object>> list, HttpServletResponse response) throws IOException {
+        String tempPath =System.getProperty("java.io.tmpdir") + IdUtil.fastSimpleUUID() + ".xlsx";
+        File file = new File(tempPath);
+        BigExcelWriter writer= ExcelUtil.getBigWriter(file);
+        // 一次性写出内容，使用默认样式，强制输出标题
+        writer.write(list, true);
+        //response为HttpServletResponse对象
+        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=utf-8");
+        //test.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
+        response.setHeader("Content-Disposition","attachment;filename=file.xlsx");
+        ServletOutputStream out=response.getOutputStream();
+        // 终止后删除临时文件
+        file.deleteOnExit();
+        writer.flush(out, true);
+        //此处记得关闭输出Servlet流
+        IoUtil.close(out);
+    }
+
+    public static String getFileType(String type) {
+        String documents = "txt doc pdf ppt pps xlsx xls docx";
+        String music = "mp3 wav wma mpa ram ra aac aif m4a";
+        String video = "avi mpg mpe mpeg asf wmv mov qt rm mp4 flv m4v webm ogv ogg";
+        String image = "bmp dib pcp dif wmf gif jpg tif eps psd cdr iff tga pcd mpt png jpeg";
+        if(image.contains(type)){
+            return "图片";
+        } else if(documents.contains(type)){
+            return "文档";
+        } else if(music.contains(type)){
+            return "音乐";
+        } else if(video.contains(type)){
+            return "视频";
+        } else {
+            return "其他";
+        }
+    }
+
+    public static String getFileTypeByMimeType(String type) {
+        String mimeType = new MimetypesFileTypeMap().getContentType("." + type);
+        return mimeType.split("/")[0];
+    }
+
+    public static void checkSize(long maxSize, long size) {
+        if(size > (maxSize * 1024 * 1024)){
+            throw new BadRequestException("文件超出规定大小");
+        }
+    }
+
+    /**
+     * 判断两个文件是否相同
+     */
+    public static boolean check(File file1, File file2) {
+        String img1Md5 = getMd5(file1);
+        String img2Md5 = getMd5(file2);
+        return img1Md5.equals(img2Md5);
+    }
+
+    /**
+     * 判断两个文件是否相同
+     */
+    public static boolean check(String file1Md5, String file2Md5) {
+        return file1Md5.equals(file2Md5);
+    }
+
+    private static byte[] getByte(File file) {
+        // 得到文件长度
+        byte[] b = new byte[(int) file.length()];
+        try {
+            InputStream in = new FileInputStream(file);
+            try {
+                in.read(b);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+            return null;
+        }
+        return b;
+    }
+
+    private static String getMd5(byte[] bytes) {
+        // 16进制字符
+        char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+        try {
+            MessageDigest mdTemp = MessageDigest.getInstance("MD5");
+            mdTemp.update(bytes);
+            byte[] md = mdTemp.digest();
+            int j = md.length;
+            char[] str = new char[j * 2];
+            int k = 0;
+            // 移位 输出字符串
+            for (byte byte0 : md) {
+                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
+                str[k++] = hexDigits[byte0 & 0xf];
+            }
+            return new String(str);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static String getMd5(File file) {
+        return getMd5(getByte(file));
+    }
+
+}

eladmin-common/src/main/java/me/zhengjie/utils/PageUtil.java

+package me.zhengjie.utils;
+
+import org.springframework.data.domain.Page;
+import java.util.*;
+
+/**
+ * 分页工具
+ * @author Zheng Jie
+ * @date 2018-12-10
+ */
+public class PageUtil extends cn.hutool.core.util.PageUtil {
+
+    /**
+     * List 分页
+     */
+    public static List toPage(int page, int size , List list) {
+        int fromIndex = page * size;
+        int toIndex = page * size + size;
+
+        if(fromIndex > list.size()){
+            return new ArrayList();
+        } else if(toIndex >= list.size()) {
+            return list.subList(fromIndex,list.size());
+        } else {
+            return list.subList(fromIndex,toIndex);
+        }
+    }
+
+    /**
+     * Page 数据处理，预防redis反序列化报错
+     */
+    public static Map<String,Object> toPage(Page page) {
+        Map<String,Object> map = new LinkedHashMap<>(2);
+        map.put("content",page.getContent());
+        map.put("totalElements",page.getTotalElements());
+        return map;
+    }
+
+    /**
+     * 自定义分页
+     */
+    public static Map<String,Object> toPage(Object object, Object totalElements) {
+        Map<String,Object> map = new LinkedHashMap<>(2);
+        map.put("content",object);
+        map.put("totalElements",totalElements);
+
+        return map;
+    }
+
+}

eladmin-common/src/main/java/me/zhengjie/utils/QueryHelp.java

+package me.zhengjie.utils;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.annotation.Query;
+import javax.persistence.criteria.*;
+import java.lang.reflect.Field;
+import java.util.*;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-6-4 14:59:48
+ */
+@Slf4j
+public class QueryHelp {
+
+    @SuppressWarnings("unchecked")
+    public static <R, Q> Predicate getPredicate(Root<R> root, Q query, CriteriaBuilder cb) {
+        List<Predicate> list = new ArrayList<>();
+
+        if(query == null){
+            return cb.and(list.toArray(new Predicate[0]));
+        }
+        try {
+            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
+            for (Field field : fields) {
+                boolean accessible = field.isAccessible();
+                field.setAccessible(true);
+                Query q = field.getAnnotation(Query.class);
+                if (q != null) {
+                    String propName = q.propName();
+                    String joinName = q.joinName();
+                    String blurry = q.blurry();
+                    String attributeName = isBlank(propName) ? field.getName() : propName;
+                    Class<?> fieldType = field.getType();
+                    Object val = field.get(query);
+                    if (ObjectUtil.isNull(val) || "".equals(val)) {
+                        continue;
+                    }
+                    Join join = null;
+                    // 模糊多字段
+                    if (ObjectUtil.isNotEmpty(blurry)) {
+                        String[] blurrys = blurry.split(",");
+                        List<Predicate> orPredicate = new ArrayList<>();
+                        for (String s : blurrys) {
+                            orPredicate.add(cb.like(root.get(s)
+                                    .as(String.class), "%" + val.toString() + "%"));
+                        }
+                        Predicate[] p = new Predicate[orPredicate.size()];
+                        list.add(cb.or(orPredicate.toArray(p)));
+                        continue;
+                    }
+                    if (ObjectUtil.isNotEmpty(joinName)) {
+                        String[] joinNames = joinName.split(">");
+                        for (String name : joinNames) {
+                            switch (q.join()) {
+                                case LEFT:
+                                    if(ObjectUtil.isNotNull(join)){
+                                        join = join.join(name, JoinType.LEFT);
+                                    } else {
+                                        join = root.join(name, JoinType.LEFT);
+                                    }
+                                    break;
+                                case RIGHT:
+                                    if(ObjectUtil.isNotNull(join)){
+                                        join = join.join(name, JoinType.RIGHT);
+                                    } else {
+                                        join = root.join(name, JoinType.RIGHT);
+                                    }
+                                    break;
+                                default: break;
+                            }
+                        }
+                    }
+                    switch (q.type()) {
+                        case EQUAL:
+                            list.add(cb.equal(getExpression(attributeName,join,root)
+                                    .as((Class<? extends Comparable>) fieldType),val));
+                            break;
+                        case GREATER_THAN:
+                            list.add(cb.greaterThanOrEqualTo(getExpression(attributeName,join,root)
+                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
+                            break;
+                        case LESS_THAN:
+                            list.add(cb.lessThanOrEqualTo(getExpression(attributeName,join,root)
+                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
+                            break;
+                        case LESS_THAN_NQ:
+                            list.add(cb.lessThan(getExpression(attributeName,join,root)
+                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
+                            break;
+                        case INNER_LIKE:
+                            list.add(cb.like(getExpression(attributeName,join,root)
+                                    .as(String.class), "%" + val.toString() + "%"));
+                            break;
+                        case LEFT_LIKE:
+                            list.add(cb.like(getExpression(attributeName,join,root)
+                                    .as(String.class), "%" + val.toString()));
+                            break;
+                        case RIGHT_LIKE:
+                            list.add(cb.like(getExpression(attributeName,join,root)
+                                    .as(String.class), val.toString() + "%"));
+                        case IN:
+                            if (CollUtil.isNotEmpty((Collection<Long>)val)) {
+                                list.add(getExpression(attributeName,join,root).in((Collection<Long>) val));
+                            }
+                            break;
+                        case OR:
+                            if (Boolean.valueOf(q.orPropVal())) {
+                                Predicate[] pArrays = (Predicate[]) Arrays.asList(q.orPropNames()).stream().map(
+                                        prop -> cb
+                                                .equal(getExpression(prop, null, root).as(String.class),
+                                                        q.orPropVal())).toArray();
+                                cb.or(pArrays);
+                            }
+                            break;
+                        case CONTAINS_NULL:
+                            List<Predicate> orPredicate = new ArrayList<>();
+                            orPredicate.add(cb.equal(getExpression(attributeName,join,root)
+                                    .as((Class<? extends Comparable>) fieldType),val));
+                            orPredicate.add(cb.isNull(getExpression(attributeName,join,root)));
+                            Predicate[] p = new Predicate[orPredicate.size()];
+                            list.add(cb.or(orPredicate.toArray(p)));
+                            break;
+                        default: break;
+                    }
+                }
+                field.setAccessible(accessible);
+            }
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
+        int size = list.size();
+        return cb.and(list.toArray(new Predicate[size]));
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T, R> Expression<T> getExpression(String attributeName, Join join, Root<R> root) {
+        if (ObjectUtil.isNotEmpty(join)) {
+            return join.get(attributeName);
+        } else {
+            return root.get(attributeName);
+        }
+    }
+
+    private static boolean isBlank(final CharSequence cs) {
+        int strLen;
+        if (cs == null || (strLen = cs.length()) == 0) {
+            return true;
+        }
+        for (int i = 0; i < strLen; i++) {
+            if (!Character.isWhitespace(cs.charAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static List<Field> getAllFields(Class clazz, List<Field> fields) {
+        if (clazz != null) {
+            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
+            getAllFields(clazz.getSuperclass(), fields);
+        }
+        return fields;
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/RequestHolder.java

+package me.zhengjie.utils;
+
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import javax.servlet.http.HttpServletRequest;
+import java.util.Objects;
+
+/**
+ * 获取 HttpServletRequest
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+public class RequestHolder {
+
+    public static HttpServletRequest getHttpServletRequest() {
+        return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/SecurityUtils.java

+package me.zhengjie.utils;
+
+import cn.hutool.json.JSONObject;
+import me.zhengjie.exception.BadRequestException;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.userdetails.UserDetails;
+
+/**
+ * 获取当前登录的用户
+ * @author Zheng Jie
+ * @date 2019-01-17
+ */
+public class SecurityUtils {
+
+    public static UserDetails getUserDetails() {
+        UserDetails userDetails;
+        try {
+            userDetails = (UserDetails) org.springframework.security.core.context.SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+        } catch (Exception e) {
+            throw new BadRequestException(HttpStatus.UNAUTHORIZED, "登录状态过期");
+        }
+        return userDetails;
+    }
+
+    /**
+     * 获取系统用户名称
+     * @return 系统用户名称
+     */
+    public static String getUsername(){
+        Object obj = getUserDetails();
+        return new JSONObject(obj).get("username", String.class);
+    }
+
+    /**
+     * 获取系统用户id
+     * @return 系统用户id
+     */
+    public static String getUserId(){
+        Object obj = getUserDetails();
+        return new JSONObject(obj).get("id", String.class);
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/SpringContextHolder.java

+package me.zhengjie.utils;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+/**
+ * @author Jie
+ * @date 2019-01-07
+ */
+@Slf4j
+public class SpringContextHolder implements ApplicationContextAware, DisposableBean {
+
+    private static ApplicationContext applicationContext = null;
+
+    /**
+     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T getBean(String name) {
+        assertContextInjected();
+        return (T) applicationContext.getBean(name);
+    }
+
+    /**
+     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
+     */
+    public static <T> T getBean(Class<T> requiredType) {
+        assertContextInjected();
+        return applicationContext.getBean(requiredType);
+    }
+
+    /**
+     * 检查ApplicationContext不为空.
+     */
+    private static void assertContextInjected() {
+        if (applicationContext == null) {
+            throw new IllegalStateException("applicaitonContext属性未注入, 请在applicationContext" +
+                    ".xml中定义SpringContextHolder或在SpringBoot启动类中注册SpringContextHolder.");
+        }
+    }
+
+    /**
+     * 清除SpringContextHolder中的ApplicationContext为Null.
+     */
+    private static void clearHolder() {
+        log.debug("清除SpringContextHolder中的ApplicationContext:"
+                + applicationContext);
+        applicationContext = null;
+    }
+
+    @Override
+    public void destroy(){
+        SpringContextHolder.clearHolder();
+    }
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        if (SpringContextHolder.applicationContext != null) {
+            log.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
+        }
+        SpringContextHolder.applicationContext = applicationContext;
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/StringUtils.java

+package me.zhengjie.utils;
+
+import cn.hutool.core.io.resource.ClassPathResource;
+import eu.bitwalker.useragentutils.Browser;
+import eu.bitwalker.useragentutils.UserAgent;
+import org.lionsoul.ip2region.DataBlock;
+import org.lionsoul.ip2region.DbConfig;
+import org.lionsoul.ip2region.DbSearcher;
+import javax.servlet.http.HttpServletRequest;
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Calendar;
+import java.util.Date;
+
+/**
+ * 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
+ */
+public class StringUtils extends org.apache.commons.lang3.StringUtils {
+
+    private static final char SEPARATOR = '_';
+
+    /**
+     * 驼峰命名法工具
+     *
+     * @return toCamelCase(" hello_world ") == "helloWorld"
+     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
+     * toUnderScoreCase("helloWorld") = "hello_world"
+     */
+    public static String toCamelCase(String s) {
+        if (s == null) {
+            return null;
+        }
+
+        s = s.toLowerCase();
+
+        StringBuilder sb = new StringBuilder(s.length());
+        boolean upperCase = false;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (c == SEPARATOR) {
+                upperCase = true;
+            } else if (upperCase) {
+                sb.append(Character.toUpperCase(c));
+                upperCase = false;
+            } else {
+                sb.append(c);
+            }
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * 驼峰命名法工具
+     *
+     * @return toCamelCase(" hello_world ") == "helloWorld"
+     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
+     * toUnderScoreCase("helloWorld") = "hello_world"
+     */
+    public static String toCapitalizeCamelCase(String s) {
+        if (s == null) {
+            return null;
+        }
+        s = toCamelCase(s);
+        return s.substring(0, 1).toUpperCase() + s.substring(1);
+    }
+
+    /**
+     * 驼峰命名法工具
+     *
+     * @return toCamelCase(" hello_world ") == "helloWorld"
+     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
+     * toUnderScoreCase("helloWorld") = "hello_world"
+     */
+    static String toUnderScoreCase(String s) {
+        if (s == null) {
+            return null;
+        }
+
+        StringBuilder sb = new StringBuilder();
+        boolean upperCase = false;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            boolean nextUpperCase = true;
+
+            if (i < (s.length() - 1)) {
+                nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
+            }
+
+            if ((i > 0) && Character.isUpperCase(c)) {
+                if (!upperCase || !nextUpperCase) {
+                    sb.append(SEPARATOR);
+                }
+                upperCase = true;
+            } else {
+                upperCase = false;
+            }
+
+            sb.append(Character.toLowerCase(c));
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * 获取ip地址
+     */
+    public static String getIp(HttpServletRequest request) {
+        String ip = request.getHeader("x-forwarded-for");
+        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getHeader("Proxy-Client-IP");
+        }
+        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getHeader("WL-Proxy-Client-IP");
+        }
+        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getRemoteAddr();
+        }
+        if (ip.contains(",")) {
+            ip = ip.split(",")[0];
+        }
+        if  ("127.0.0.1".equals(ip))  {
+            // 获取本机真正的ip地址
+            try {
+                ip = InetAddress.getLocalHost().getHostAddress();
+            } catch (UnknownHostException e) {
+                e.printStackTrace();
+            }
+        }
+        return ip;
+    }
+
+    /**
+     * 根据ip获取详细地址
+     */
+    public static String getCityInfo(String ip) {
+        try {
+            String path = "ip2region/ip2region.db";
+            String name = "ip2region.db";
+            DbConfig config = new DbConfig();
+            File file = FileUtil.inputStreamToFile(new ClassPathResource(path).getStream(), name);
+            DbSearcher searcher = new DbSearcher(config, file.getPath());
+            Method method;
+            method = searcher.getClass().getMethod("btreeSearch", String.class);
+            DataBlock dataBlock;
+            dataBlock = (DataBlock) method.invoke(searcher, ip);
+            String address = dataBlock.getRegion().replace("0|","");
+            if(address.charAt(address.length()-1) == '|'){
+                address = address.substring(0,address.length() - 1);
+            }
+            return address.equals(ElAdminConstant.REGION)?"内网IP":address;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return "";
+    }
+
+    public static String getBrowser(HttpServletRequest request){
+        UserAgent userAgent = UserAgent.parseUserAgentString(request.getHeader("User-Agent"));
+        Browser browser = userAgent.getBrowser();
+        return browser.getName();
+    }
+
+    /**
+     * 获得当天是周几
+     */
+    public static String getWeekDay(){
+        String[] weekDays = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(new Date());
+
+        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
+        if (w < 0){
+            w = 0;
+        }
+        return weekDays[w];
+    }
+}
\ No newline at end of file

eladmin-common/src/main/java/me/zhengjie/utils/ThrowableUtil.java

+package me.zhengjie.utils;
+
+import me.zhengjie.exception.BadRequestException;
+import org.hibernate.exception.ConstraintViolationException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+/**
+ * 异常工具 2019-01-06
+ * @author Zheng Jie
+ */
+public class ThrowableUtil {
+
+    /**
+     * 获取堆栈信息
+     */
+    public static String getStackTrace(Throwable throwable){
+        StringWriter sw = new StringWriter();
+        try (PrintWriter pw = new PrintWriter(sw)) {
+            throwable.printStackTrace(pw);
+            return sw.toString();
+        }
+    }
+
+    public static void throwForeignKeyException(Throwable e, String msg){
+        Throwable t = e.getCause();
+        while ((t != null) && !(t instanceof ConstraintViolationException)) {
+            t = t.getCause();
+        }
+        if (t != null) {
+            throw new BadRequestException(msg);
+        }
+        assert false;
+        throw new BadRequestException("删除失败：" + t.getMessage());
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/TranslatorUtil.java

+package me.zhengjie.utils;
+
+import cn.hutool.json.JSONArray;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLEncoder;
+
+public class TranslatorUtil {
+
+    public static String translate(String word){
+        try {
+            String url = "https://translate.googleapis.com/translate_a/single?" +
+                    "client=gtx&" +
+                    "sl=en" +
+                    "&tl=zh-CN" +
+                    "&dt=t&q=" + URLEncoder.encode(word, "UTF-8");
+
+            URL obj = new URL(url);
+            HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+            con.setRequestProperty("User-Agent", "Mozilla/5.0");
+
+            BufferedReader in = new BufferedReader(
+                    new InputStreamReader(con.getInputStream()));
+            String inputLine;
+            StringBuilder response = new StringBuilder();
+
+            while ((inputLine = in.readLine()) != null) {
+                response.append(inputLine);
+            }
+            in.close();
+            return parseResult(response.toString());
+        }catch (Exception e){
+          return  word;
+        }
+    }
+
+    private static String parseResult(String inputJson){
+        JSONArray jsonArray2 = (JSONArray) new JSONArray(inputJson).get(0);
+        StringBuilder result = new StringBuilder();
+        for (Object o : jsonArray2) {
+            result.append(((JSONArray) o).get(0).toString());
+        }
+        return result.toString();
+    }
+}

eladmin-common/src/main/java/me/zhengjie/utils/ValidationUtil.java

+package me.zhengjie.utils;
+
+import cn.hutool.core.util.ObjectUtil;
+import me.zhengjie.exception.BadRequestException;
+
+/**
+ * 验证工具
+ * @author Zheng Jie
+ * @date 2018-11-23
+ */
+public class ValidationUtil{
+
+    /**
+     * 验证空
+     */
+    public static void isNull(Object obj, String entity, String parameter , Object value){
+        if(ObjectUtil.isNull(obj)){
+            String msg = entity + " 不存在: "+ parameter +" is "+ value;
+            throw new BadRequestException(msg);
+        }
+    }
+
+    /**
+     * 验证是否为邮箱
+     */
+    public static boolean isEmail(String string) {
+        if (string == null){
+            return false;
+        }
+        String regEx1 = "^([a-z0-9A-Z]+[-|.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
+        return string.matches(regEx1);
+    }
+}

eladmin-common/src/test/java/me/zhengjie/utils/EncryptUtilsTest.java

+package me.zhengjie.utils;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+import static me.zhengjie.utils.EncryptUtils.*;
+
+public class EncryptUtilsTest {
+
+    /**
+     * 对称加密
+     */
+    @Test
+    public void testDesEncrypt() {
+        try {
+            assertEquals("7772841DC6099402", desEncrypt("123456"));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 对称解密
+     */
+    @Test
+    public void testDesDecrypt() {
+        try {
+            assertEquals("123456", desDecrypt("7772841DC6099402"));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

eladmin-common/src/test/java/me/zhengjie/utils/FileUtilTest.java

+package me.zhengjie.utils;
+
+import org.junit.Test;
+import org.springframework.mock.web.MockMultipartFile;
+
+import static org.junit.Assert.*;
+import static me.zhengjie.utils.FileUtil.*;
+
+public class FileUtilTest {
+
+    @Test
+    public void testToFile() {
+        long retval = toFile(new MockMultipartFile("foo", (byte[]) null)).getTotalSpace();
+        assertEquals(500695072768L, retval);
+    }
+
+    @Test
+    public void testGetExtensionName() {
+        assertEquals("foo", getExtensionName("foo"));
+        assertEquals("exe", getExtensionName("bar.exe"));
+    }
+
+    @Test
+    public void testGetFileNameNoEx() {
+        assertEquals("foo", getFileNameNoEx("foo"));
+        assertEquals("bar", getFileNameNoEx("bar.txt"));
+    }
+
+    @Test
+    public void testGetSize() {
+        assertEquals("1000B   ", getSize(1000));
+        assertEquals("1.00KB   ", getSize(1024));
+        assertEquals("1.00MB   ", getSize(1048576));
+        assertEquals("1.00GB   ", getSize(1073741824));
+    }
+}

eladmin-common/src/test/java/me/zhengjie/utils/StringUtilsTest.java

+package me.zhengjie.utils;
+
+import org.junit.Test;
+import org.springframework.mock.web.MockHttpServletRequest;
+
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+import static me.zhengjie.utils.StringUtils.*;
+import static org.junit.Assert.*;
+
+public class StringUtilsTest {
+
+    @Test
+    public void testToCamelCase() {
+        assertNull(toCamelCase(null));
+    }
+
+    @Test
+    public void testToCapitalizeCamelCase() {
+        assertNull(StringUtils.toCapitalizeCamelCase(null));
+        assertEquals("HelloWorld", toCapitalizeCamelCase("hello_world"));
+    }
+
+    @Test
+    public void testToUnderScoreCase() {
+        assertNull(StringUtils.toUnderScoreCase(null));
+        assertEquals("hello_world", toUnderScoreCase("helloWorld"));
+        assertEquals("\u0000\u0000", toUnderScoreCase("\u0000\u0000"));
+        assertEquals("\u0000_a", toUnderScoreCase("\u0000A"));
+    }
+
+    @Test
+    public void testGetWeekDay() {
+        SimpleDateFormat simpleDateformat = new SimpleDateFormat("E");
+        assertEquals(simpleDateformat.format(new Date()), getWeekDay());
+    }
+
+    @Test
+    public void testGetIP() {
+        assertEquals("127.0.0.1", getIp(new MockHttpServletRequest()));
+    }
+}
\ No newline at end of file

eladmin-generator/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>eladmin</artifactId>
+        <groupId>me.zhengjie</groupId>
+        <version>2.3</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>eladmin-generator</artifactId>
+    <name>代码生成模块</name>
+
+    <properties>
+        <configuration.version>1.9</configuration.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>me.zhengjie</groupId>
+            <artifactId>eladmin-common</artifactId>
+            <version>2.3</version>
+        </dependency>
+
+        <!--模板引擎-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-freemarker</artifactId>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/commons-configuration/commons-configuration -->
+        <dependency>
+            <groupId>commons-configuration</groupId>
+            <artifactId>commons-configuration</artifactId>
+            <version>${configuration.version}</version>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file

eladmin-generator/src/main/java/me/zhengjie/domain/GenConfig.java

+package me.zhengjie.domain;
+
+import lombok.Data;
+import javax.persistence.*;
+
+/**
+ * 代码生成配置
+ * @author Zheng Jie
+ * @date 2019-01-03
+ */
+@Data
+@Entity
+@Table(name = "gen_config")
+public class GenConfig {
+
+    @Id
+    private Long id;
+
+    // 包路径
+    private String pack;
+
+    // 模块名
+    @Column(name = "module_name")
+    private String moduleName;
+
+    // 前端文件路径
+    private String path;
+
+    // 前端文件路径
+    @Column(name = "api_path")
+    private String apiPath;
+
+    // 作者
+    private String author;
+
+    // 表前缀
+    private String prefix;
+
+    // 是否覆盖
+    private Boolean cover;
+}

eladmin-generator/src/main/java/me/zhengjie/domain/vo/ColumnInfo.java

+package me.zhengjie.domain.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 列的数据信息
+ * @author Zheng Jie
+ * @date 2019-01-02
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ColumnInfo {
+
+    // 数据库字段名称
+    private Object columnName;
+
+    // 允许空值
+    private Object isNullable;
+
+    // 数据库字段类型
+    private Object columnType;
+
+    // 数据库字段注释
+    private Object columnComment;
+
+    // 数据库字段键类型
+    private Object columnKey;
+
+    // 额外的参数
+    private Object extra;
+
+    // 查询 1:模糊 2：精确
+    private String columnQuery;
+
+    // 是否在列表显示
+    private String columnShow;
+}

eladmin-generator/src/main/java/me/zhengjie/domain/vo/TableInfo.java

+package me.zhengjie.domain.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 表的数据信息
+ * @author Zheng Jie
+ * @date 2019-01-02
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class TableInfo {
+
+    // 表名称
+    private Object tableName;
+
+    // 创建日期
+    private Object createTime;
+
+    // 数据库引擎
+    private Object engine;
+
+    // 编码集
+    private Object coding;
+
+    // 备注
+    private Object remark;
+
+
+}

eladmin-generator/src/main/java/me/zhengjie/repository/GenConfigRepository.java

+package me.zhengjie.repository;
+
+import me.zhengjie.domain.GenConfig;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-14
+ */
+public interface GenConfigRepository extends JpaRepository<GenConfig,Long> {
+}

eladmin-generator/src/main/java/me/zhengjie/rest/GenConfigController.java

+package me.zhengjie.rest;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import me.zhengjie.domain.GenConfig;
+import me.zhengjie.service.GenConfigService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-14
+ */
+@RestController
+@RequestMapping("/api/genConfig")
+@Api(tags = "系统：代码生成器配置管理")
+public class GenConfigController {
+
+    private final GenConfigService genConfigService;
+
+    public GenConfigController(GenConfigService genConfigService) {
+        this.genConfigService = genConfigService;
+    }
+
+    @ApiOperation("查询")
+    @GetMapping
+    public ResponseEntity get(){
+        return new ResponseEntity<>(genConfigService.find(), HttpStatus.OK);
+    }
+
+    @ApiOperation("修改")
+    @PutMapping
+    public ResponseEntity emailConfig(@Validated @RequestBody GenConfig genConfig){
+        return new ResponseEntity<>(genConfigService.update(genConfig),HttpStatus.OK);
+    }
+}

eladmin-generator/src/main/java/me/zhengjie/rest/GeneratorController.java

+package me.zhengjie.rest;
+
+import cn.hutool.core.util.PageUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import me.zhengjie.domain.vo.ColumnInfo;
+import me.zhengjie.exception.BadRequestException;
+import me.zhengjie.service.GenConfigService;
+import me.zhengjie.service.GeneratorService;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-02
+ */
+@RestController
+@RequestMapping("/api/generator")
+@Api(tags = "系统：代码生成管理")
+public class GeneratorController {
+
+    private final GeneratorService generatorService;
+
+    private final GenConfigService genConfigService;
+
+    @Value("${generator.enabled}")
+    private Boolean generatorEnabled;
+
+    public GeneratorController(GeneratorService generatorService, GenConfigService genConfigService) {
+        this.generatorService = generatorService;
+        this.genConfigService = genConfigService;
+    }
+
+    @ApiOperation("查询数据库元数据")
+    @GetMapping(value = "/tables")
+    public ResponseEntity getTables(@RequestParam(defaultValue = "") String name,
+                                    @RequestParam(defaultValue = "0")Integer page,
+                                    @RequestParam(defaultValue = "10")Integer size){
+        int[] startEnd = PageUtil.transToStartEnd(page+1, size);
+        return new ResponseEntity<>(generatorService.getTables(name,startEnd), HttpStatus.OK);
+    }
+
+    @ApiOperation("查询表内元数据")
+    @GetMapping(value = "/columns")
+    public ResponseEntity getTables(@RequestParam String tableName){
+        return new ResponseEntity<>(generatorService.getColumns(tableName), HttpStatus.OK);
+    }
+
+    @ApiOperation("生成代码")
+    @PostMapping
+    public ResponseEntity generator(@RequestBody List<ColumnInfo> columnInfos, @RequestParam String tableName){
+        if(!generatorEnabled){
+            throw new BadRequestException("此环境不允许生成代码！");
+        }
+        generatorService.generator(columnInfos,genConfigService.find(),tableName);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+}

eladmin-generator/src/main/java/me/zhengjie/service/GenConfigService.java

+package me.zhengjie.service;
+
+import me.zhengjie.domain.GenConfig;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-14
+ */
+public interface GenConfigService {
+
+    GenConfig find();
+
+    GenConfig update(GenConfig genConfig);
+}

eladmin-generator/src/main/java/me/zhengjie/service/GeneratorService.java

+package me.zhengjie.service;
+
+import me.zhengjie.domain.GenConfig;
+import me.zhengjie.domain.vo.ColumnInfo;
+import java.util.List;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-02
+ */
+public interface GeneratorService {
+
+    /**
+     * 查询数据库元数据
+     * @param name 表名
+     * @param startEnd 分页参数
+     * @return /
+     */
+    Object getTables(String name, int[] startEnd);
+
+    /**
+     * 得到数据表的元数据
+     * @param name 表名
+     * @return /
+     */
+    Object getColumns(String name);
+
+    /**
+     * 生成代码
+     * @param columnInfos 表字段数据
+     * @param genConfig 代码生成配置
+     * @param tableName 表名
+     */
+    void generator(List<ColumnInfo> columnInfos, GenConfig genConfig, String tableName);
+}

eladmin-generator/src/main/java/me/zhengjie/service/impl/GenConfigServiceImpl.java

+package me.zhengjie.service.impl;
+
+import me.zhengjie.domain.GenConfig;
+import me.zhengjie.repository.GenConfigRepository;
+import me.zhengjie.service.GenConfigService;
+import org.springframework.cache.annotation.CacheConfig;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+import java.io.File;
+import java.util.Optional;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-14
+ */
+@Service
+@CacheConfig(cacheNames = "genConfig")
+public class GenConfigServiceImpl implements GenConfigService {
+
+    private final GenConfigRepository genConfigRepository;
+
+    public GenConfigServiceImpl(GenConfigRepository genConfigRepository) {
+        this.genConfigRepository = genConfigRepository;
+    }
+
+    @Override
+    @Cacheable(key = "'1'")
+    public GenConfig find() {
+        Optional<GenConfig> genConfig = genConfigRepository.findById(1L);
+        return genConfig.orElseGet(GenConfig::new);
+    }
+
+    @Override
+    @CacheEvict(allEntries = true)
+    public GenConfig update(GenConfig genConfig) {
+        genConfig.setId(1L);
+        // 自动设置Api路径，注释掉前需要同步取消前端的注释
+        String separator = File.separator;
+        String[] paths;
+        if (separator.equals("\\")) {
+            paths = genConfig.getPath().split("\\\\");
+        } else paths = genConfig.getPath().split(File.separator);
+        StringBuilder api = new StringBuilder();
+        for (String path : paths) {
+            api.append(path);
+            api.append(separator);
+            if (path.equals("src")) {
+                api.append("api");
+                break;
+            }
+        }
+        genConfig.setApiPath(api.toString());
+        return genConfigRepository.save(genConfig);
+    }
+}

eladmin-generator/src/main/java/me/zhengjie/service/impl/GeneratorServiceImpl.java

+package me.zhengjie.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import me.zhengjie.domain.GenConfig;
+import me.zhengjie.domain.vo.ColumnInfo;
+import me.zhengjie.domain.vo.TableInfo;
+import me.zhengjie.exception.BadRequestException;
+import me.zhengjie.service.GeneratorService;
+import me.zhengjie.utils.GenUtil;
+import me.zhengjie.utils.PageUtil;
+import me.zhengjie.utils.StringUtils;
+import org.springframework.stereotype.Service;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-01-02
+ */
+@Service
+public class GeneratorServiceImpl implements GeneratorService {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    @Override
+    @SuppressWarnings("all")
+    public Object getTables(String name, int[] startEnd) {
+        // 使用预编译防止sql注入
+        String sql = "select table_name ,create_time , engine, table_collation, table_comment from information_schema.tables " +
+                "where table_schema = (select database()) " +
+                "and table_name like ? order by create_time desc";
+        Query query = em.createNativeQuery(sql);
+        query.setFirstResult(startEnd[0]);
+        query.setMaxResults(startEnd[1]-startEnd[0]);
+        query.setParameter(1, StringUtils.isNotBlank(name) ? ("%" + name + "%") : "%%");
+        List result = query.getResultList();
+        List<TableInfo> tableInfos = new ArrayList<>();
+        for (Object obj : result) {
+            Object[] arr = (Object[]) obj;
+            tableInfos.add(new TableInfo(arr[0],arr[1],arr[2],arr[3], ObjectUtil.isNotEmpty(arr[4])? arr[4] : "-"));
+        }
+        Query query1 = em.createNativeQuery("SELECT COUNT(*) from information_schema.tables where table_schema = (select database())");
+        Object totalElements = query1.getSingleResult();
+        return PageUtil.toPage(tableInfos,totalElements);
+    }
+
+    @Override
+    @SuppressWarnings("all")
+    public Object getColumns(String name) {
+        // 使用预编译防止sql注入
+        String sql = "select column_name, is_nullable, data_type, column_comment, column_key, extra from information_schema.columns " +
+                "where table_name = ? and table_schema = (select database()) order by ordinal_position";
+        Query query = em.createNativeQuery(sql);
+        query.setParameter(1, StringUtils.isNotBlank(name) ? name : null);
+        List result = query.getResultList();
+        List<ColumnInfo> columnInfos = new ArrayList<>();
+        for (Object obj : result) {
+            Object[] arr = (Object[]) obj;
+            columnInfos.add(new ColumnInfo(arr[0],arr[1],arr[2],arr[3],arr[4],arr[5],null,"true"));
+        }
+        return PageUtil.toPage(columnInfos,columnInfos.size());
+    }
+
+    @Override
+    public void generator(List<ColumnInfo> columnInfos, GenConfig genConfig, String tableName) {
+        if(genConfig.getId() == null){
+            throw new BadRequestException("请先配置生成器");
+        }
+        try {
+            GenUtil.generatorCode(columnInfos,genConfig,tableName);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

eladmin-generator/src/main/java/me/zhengjie/utils/ColUtil.java

+package me.zhengjie.utils;
+
+import org.apache.commons.configuration.*;
+
+/**
+ * sql字段转java
+ *
+ * @author Zheng Jie
+ * @date 2019-01-03
+ */
+public class ColUtil {
+
+    /**
+     * 转换mysql数据类型为java数据类型
+     * @param type 数据库字段类型
+     * @return String
+     */
+    static String cloToJava(String type){
+        Configuration config = getConfig();
+        assert config != null;
+        return config.getString(type,"unknowType");
+    }
+
+    /**
+     * 获取配置信息
+     */
+    public static PropertiesConfiguration getConfig() {
+        try {
+            return new PropertiesConfiguration("generator.properties" );
+        } catch (ConfigurationException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}

eladmin-generator/src/main/java/me/zhengjie/utils/GenUtil.java

+package me.zhengjie.utils;
+
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.template.*;
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.domain.GenConfig;
+import me.zhengjie.domain.vo.ColumnInfo;
+import org.springframework.util.ObjectUtils;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 代码生成
+ * @author Zheng Jie
+ * @date 2019-01-02
+ */
+@Slf4j
+public class GenUtil {
+
+    private static final String TIMESTAMP = "Timestamp";
+
+    private static final String BIGDECIMAL = "BigDecimal";
+
+    private static final String PK = "PRI";
+
+    private static final String EXTRA = "auto_increment";
+
+    /**
+     * 获取后端代码模板名称
+     * @return List
+     */
+    private static List<String> getAdminTemplateNames() {
+        List<String> templateNames = new ArrayList<>();
+        templateNames.add("Entity");
+        templateNames.add("Dto");
+        templateNames.add("Mapper");
+        templateNames.add("Repository");
+        templateNames.add("Service");
+        templateNames.add("ServiceImpl");
+        templateNames.add("QueryCriteria");
+        templateNames.add("Controller");
+        return templateNames;
+    }
+
+    /**
+     * 获取前端代码模板名称
+     * @return List
+     */
+    private static List<String> getFrontTemplateNames() {
+        List<String> templateNames = new ArrayList<>();
+        templateNames.add("api");
+        templateNames.add("index");
+        templateNames.add("eForm");
+        return templateNames;
+    }
+
+    /**
+     * 生成代码
+     * @param columnInfos 表元数据
+     * @param genConfig 生成代码的参数配置，如包路径，作者
+     */
+    public static void generatorCode(List<ColumnInfo> columnInfos, GenConfig genConfig, String tableName) throws IOException {
+        Map<String,Object> map = new HashMap<>();
+        map.put("package",genConfig.getPack());
+        map.put("moduleName",genConfig.getModuleName());
+        map.put("author",genConfig.getAuthor());
+        map.put("date", LocalDate.now().toString());
+        map.put("tableName",tableName);
+        String className = StringUtils.toCapitalizeCamelCase(tableName);
+        String changeClassName = StringUtils.toCamelCase(tableName);
+
+        // 判断是否去除表前缀
+        if (StringUtils.isNotEmpty(genConfig.getPrefix())) {
+            className = StringUtils.toCapitalizeCamelCase(StrUtil.removePrefix(tableName,genConfig.getPrefix()));
+            changeClassName = StringUtils.toCamelCase(StrUtil.removePrefix(tableName,genConfig.getPrefix()));
+        }
+        map.put("className", className);
+        map.put("upperCaseClassName", className.toUpperCase());
+        map.put("changeClassName", changeClassName);
+        map.put("hasTimestamp",false);
+        map.put("queryHasTimestamp",false);
+        map.put("queryHasBigDecimal",false);
+        map.put("hasBigDecimal",false);
+        map.put("hasQuery",false);
+        map.put("auto",false);
+
+        List<Map<String,Object>> columns = new ArrayList<>();
+        List<Map<String,Object>> queryColumns = new ArrayList<>();
+        for (ColumnInfo column : columnInfos) {
+            Map<String,Object> listMap = new HashMap<>();
+            listMap.put("columnComment",column.getColumnComment());
+            listMap.put("columnKey",column.getColumnKey());
+
+            String colType = ColUtil.cloToJava(column.getColumnType().toString());
+            String changeColumnName = StringUtils.toCamelCase(column.getColumnName().toString());
+            String capitalColumnName = StringUtils.toCapitalizeCamelCase(column.getColumnName().toString());
+            if(PK.equals(column.getColumnKey())){
+                map.put("pkColumnType",colType);
+                map.put("pkChangeColName",changeColumnName);
+                map.put("pkCapitalColName",capitalColumnName);
+            }
+            if(TIMESTAMP.equals(colType)){
+                map.put("hasTimestamp",true);
+            }
+            if(BIGDECIMAL.equals(colType)){
+                map.put("hasBigDecimal",true);
+            }
+            if(EXTRA.equals(column.getExtra())){
+                map.put("auto",true);
+            }
+            listMap.put("columnType",colType);
+            listMap.put("columnName",column.getColumnName());
+            listMap.put("isNullable",column.getIsNullable());
+            listMap.put("columnShow",column.getColumnShow());
+            listMap.put("changeColumnName",changeColumnName);
+            listMap.put("capitalColumnName",capitalColumnName);
+
+            // 判断是否有查询，如有则把查询的字段set进columnQuery
+            if(!StringUtils.isBlank(column.getColumnQuery())){
+                listMap.put("columnQuery",column.getColumnQuery());
+                map.put("hasQuery",true);
+                if(TIMESTAMP.equals(colType)){
+                    map.put("queryHasTimestamp",true);
+                }
+                if(BIGDECIMAL.equals(colType)){
+                    map.put("queryHasBigDecimal",true);
+                }
+                queryColumns.add(listMap);
+            }
+            columns.add(listMap);
+        }
+        map.put("columns",columns);
+        map.put("queryColumns",queryColumns);
+        TemplateEngine engine = TemplateUtil.createEngine(new TemplateConfig("template", TemplateConfig.ResourceMode.CLASSPATH));
+
+        // 生成后端代码
+        List<String> templates = getAdminTemplateNames();
+        for (String templateName : templates) {
+            Template template = engine.getTemplate("generator/admin/"+templateName+".ftl");
+            String filePath = getAdminFilePath(templateName,genConfig,className);
+
+            assert filePath != null;
+            File file = new File(filePath);
+
+            // 如果非覆盖生成
+            if(!genConfig.getCover() && FileUtil.exist(file)){
+                continue;
+            }
+            // 生成代码
+            genFile(file, template, map);
+        }
+
+        // 生成前端代码
+        templates = getFrontTemplateNames();
+        for (String templateName : templates) {
+            Template template = engine.getTemplate("generator/front/"+templateName+".ftl");
+            String filePath = getFrontFilePath(templateName,genConfig,map.get("changeClassName").toString());
+
+            assert filePath != null;
+            File file = new File(filePath);
+
+            // 如果非覆盖生成
+            if(!genConfig.getCover() && FileUtil.exist(file)){
+                continue;
+            }
+            // 生成代码
+            genFile(file, template, map);
+        }
+    }
+
+    /**
+     * 定义后端文件路径以及名称
+     */
+    private static String getAdminFilePath(String templateName, GenConfig genConfig, String className) {
+        String projectPath = System.getProperty("user.dir") + File.separator + genConfig.getModuleName();
+        String packagePath = projectPath + File.separator + "src" +File.separator+ "main" + File.separator + "java" + File.separator;
+        if (!ObjectUtils.isEmpty(genConfig.getPack())) {
+            packagePath += genConfig.getPack().replace(".", File.separator) + File.separator;
+        }
+
+        if ("Entity".equals(templateName)) {
+            return packagePath + "domain" + File.separator + className + ".java";
+        }
+
+        if ("Controller".equals(templateName)) {
+            return packagePath + "rest" + File.separator + className + "Controller.java";
+        }
+
+        if ("Service".equals(templateName)) {
+            return packagePath + "service" + File.separator + className + "Service.java";
+        }
+
+        if ("ServiceImpl".equals(templateName)) {
+            return packagePath + "service" + File.separator + "impl" + File.separator + className + "ServiceImpl.java";
+        }
+
+        if ("Dto".equals(templateName)) {
+            return packagePath + "service" + File.separator + "dto" + File.separator + className + "DTO.java";
+        }
+
+        if ("QueryCriteria".equals(templateName)) {
+            return packagePath + "service" + File.separator + "dto" + File.separator + className + "QueryCriteria.java";
+        }
+
+        if ("Mapper".equals(templateName)) {
+            return packagePath + "service" + File.separator + "mapper" + File.separator + className + "Mapper.java";
+        }
+
+        if ("Repository".equals(templateName)) {
+            return packagePath + "repository" + File.separator + className + "Repository.java";
+        }
+
+        return null;
+    }
+
+    /**
+     * 定义前端文件路径以及名称
+     */
+    private static String getFrontFilePath(String templateName, GenConfig genConfig, String apiName) {
+        String path = genConfig.getPath();
+
+        if ("api".equals(templateName)) {
+            return genConfig.getApiPath() + File.separator + apiName + ".js";
+        }
+
+        if ("index".equals(templateName)) {
+            return path  + File.separator + "index.vue";
+        }
+
+        if ("eForm".equals(templateName)) {
+            return path  + File.separator + File.separator + "form.vue";
+        }
+        return null;
+    }
+
+    private static void genFile(File file, Template template, Map<String, Object> map) throws IOException {
+        // 生成目标文件
+        Writer writer = null;
+        try {
+            FileUtil.touch(file);
+            writer = new FileWriter(file);
+            template.render(map, writer);
+        } catch (TemplateException | IOException e) {
+            throw new RuntimeException(e);
+        } finally {
+            assert writer != null;
+            writer.close();
+        }
+    }
+}

eladmin-logging/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>eladmin</artifactId>
+        <groupId>me.zhengjie</groupId>
+        <version>2.3</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>eladmin-logging</artifactId>
+    <name>日志模块</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>me.zhengjie</groupId>
+            <artifactId>eladmin-common</artifactId>
+            <version>2.3</version>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file

eladmin-logging/src/main/java/me/zhengjie/aop/log/Log.java

+package me.zhengjie.aop.log;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Log {
+	String value() default "";
+}

eladmin-logging/src/main/java/me/zhengjie/aspect/LogAspect.java

+package me.zhengjie.aspect;
+
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.domain.Log;
+import me.zhengjie.service.LogService;
+import me.zhengjie.utils.RequestHolder;
+import me.zhengjie.utils.SecurityUtils;
+import me.zhengjie.utils.StringUtils;
+import me.zhengjie.utils.ThrowableUtil;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@Component
+@Aspect
+@Slf4j
+public class LogAspect {
+
+    private final LogService logService;
+
+    private long currentTime = 0L;
+
+    public LogAspect(LogService logService) {
+        this.logService = logService;
+    }
+
+    /**
+     * 配置切入点
+     */
+    @Pointcut("@annotation(me.zhengjie.aop.log.Log)")
+    public void logPointcut() {
+        // 该方法无方法体,主要为了让同类中其他方法使用此切入点
+    }
+
+    /**
+     * 配置环绕通知,使用在方法logPointcut()上注册的切入点
+     *
+     * @param joinPoint join point for advice
+     */
+    @Around("logPointcut()")
+    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
+        Object result;
+        currentTime = System.currentTimeMillis();
+        result = joinPoint.proceed();
+        Log log = new Log("INFO",System.currentTimeMillis() - currentTime);
+        HttpServletRequest request = RequestHolder.getHttpServletRequest();
+        logService.save(getUsername(), StringUtils.getBrowser(request), StringUtils.getIp(request),joinPoint, log);
+        return result;
+    }
+
+    /**
+     * 配置异常通知
+     *
+     * @param joinPoint join point for advice
+     * @param e exception
+     */
+    @AfterThrowing(pointcut = "logPointcut()", throwing = "e")
+    public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
+        Log log = new Log("ERROR",System.currentTimeMillis() - currentTime);
+        log.setExceptionDetail(ThrowableUtil.getStackTrace(e).getBytes().toString());
+        HttpServletRequest request = RequestHolder.getHttpServletRequest();
+        logService.save(getUsername(), StringUtils.getBrowser(request), StringUtils.getIp(request), (ProceedingJoinPoint)joinPoint, log);
+    }
+
+    public String getUsername() {
+        try {
+            return SecurityUtils.getUsername();
+        }catch (Exception e){
+            return "";
+        }
+    }
+}

eladmin-logging/src/main/java/me/zhengjie/domain/Log.java

+package me.zhengjie.domain;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.CreationTimestamp;
+import javax.persistence.*;
+import java.io.Serializable;
+import java.sql.Timestamp;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@Entity
+@Data
+@Table(name = "base_jp_log")
+@NoArgsConstructor
+public class Log  implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    // 操作用户
+    private String username;
+
+    // 描述
+    private String description;
+
+    // 方法名
+    private String method;
+
+    // 参数
+    private String params;
+
+    // 日志类型
+    @Column(name = "log_type")
+    private String logType;
+
+    // 请求ip
+    @Column(name = "request_ip")
+    private String requestIp;
+
+    @Column(name = "address")
+    private String address;
+
+    private String browser;
+
+    // 请求耗时
+    private Long time;
+
+    // 异常详细
+    @Column(name = "exception_detail")
+    private String exceptionDetail;
+
+    // 创建日期
+    @CreationTimestamp
+    @Column(name = "create_time")
+    private Timestamp createTime;
+
+    public Log(String logType, Long time) {
+        this.logType = logType;
+        this.time = time;
+    }
+}

eladmin-logging/src/main/java/me/zhengjie/repository/LogRepository.java

+package me.zhengjie.repository;
+
+import me.zhengjie.domain.Log;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@Repository
+public interface LogRepository extends JpaRepository<Log,Long>, JpaSpecificationExecutor<Log> {
+
+    /**
+     * 获取一个时间段的IP记录
+     */
+    @Query(value = "select count(*) FROM (select request_ip FROM base_jp_log where create_time between ?1 and ?2 GROUP BY request_ip) as s",nativeQuery = true)
+    Long findIp(String date1, String date2);
+
+    @Query(value = "select l FROM base_jp_log l where l.id = ?1",nativeQuery = true)
+    Log findExceptionById(Long id);
+}

eladmin-logging/src/main/java/me/zhengjie/rest/LogController.java

+package me.zhengjie.rest;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import me.zhengjie.aop.log.Log;
+import me.zhengjie.service.LogService;
+import me.zhengjie.service.dto.LogQueryCriteria;
+import me.zhengjie.utils.SecurityUtils;
+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.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@RestController
+@RequestMapping("/api/logs")
+@Api(tags = "监控：日志管理")
+public class LogController {
+
+    private final LogService logService;
+
+    public LogController(LogService logService) {
+        this.logService = logService;
+    }
+
+    @Log("导出数据")
+    @ApiOperation("导出数据")
+    @GetMapping(value = "/download")
+    @PreAuthorize("@el.check()")
+    public void download(HttpServletResponse response, LogQueryCriteria criteria) throws IOException {
+        logService.download(logService.queryAll(criteria), response);
+    }
+
+    @GetMapping
+    @ApiOperation("日志查询")
+    @PreAuthorize("@el.check()")
+    public ResponseEntity getLogs(LogQueryCriteria criteria, Pageable pageable){
+        criteria.setLogType("INFO");
+        return new ResponseEntity<>(logService.queryAll(criteria,pageable), HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/user")
+    @ApiOperation("用户日志查询")
+    public ResponseEntity getUserLogs(LogQueryCriteria criteria, Pageable pageable){
+        criteria.setLogType("INFO");
+        criteria.setBlurry(SecurityUtils.getUsername());
+        return new ResponseEntity<>(logService.queryAllByUser(criteria,pageable), HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/error")
+    @ApiOperation("错误日志查询")
+    @PreAuthorize("@el.check()")
+    public ResponseEntity getErrorLogs(LogQueryCriteria criteria, Pageable pageable){
+        criteria.setLogType("ERROR");
+        return new ResponseEntity<>(logService.queryAll(criteria,pageable), HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/error/{id}")
+    @ApiOperation("日志异常详情查询")
+    @PreAuthorize("@el.check()")
+    public ResponseEntity getErrorLogs(@PathVariable Long id){
+        return new ResponseEntity<>(logService.findByErrDetail(id), HttpStatus.OK);
+    }
+}

eladmin-logging/src/main/java/me/zhengjie/service/LogService.java

+package me.zhengjie.service;
+
+import me.zhengjie.domain.Log;
+import me.zhengjie.service.dto.LogQueryCriteria;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.springframework.data.domain.Pageable;
+import org.springframework.scheduling.annotation.Async;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+public interface LogService {
+
+    Object queryAll(LogQueryCriteria criteria, Pageable pageable);
+
+    List<Log> queryAll(LogQueryCriteria criteria);
+
+    Object queryAllByUser(LogQueryCriteria criteria, Pageable pageable);
+
+    @Async
+    void save(String username, String browser, String ip, ProceedingJoinPoint joinPoint, Log log);
+
+    /**
+     * 查询异常详情
+     * @param id 日志ID
+     * @return Object
+     */
+    Object findByErrDetail(Long id);
+
+    void download(List<Log> queryAll, HttpServletResponse response) throws IOException;
+}

eladmin-logging/src/main/java/me/zhengjie/service/dto/LogErrorDTO.java

+package me.zhengjie.service.dto;
+
+import lombok.Data;
+import java.io.Serializable;
+import java.sql.Timestamp;
+
+/**
+* @author Zheng Jie
+* @date 2019-5-22
+*/
+@Data
+public class LogErrorDTO implements Serializable {
+
+    private Long id;
+
+    // 操作用户
+    private String username;
+
+    // 描述
+    private String description;
+
+    // 方法名
+    private String method;
+
+    // 参数
+    private String params;
+
+    private String browser;
+
+    // 请求ip
+    private String requestIp;
+
+    private String address;
+
+
+    // 创建日期
+    private Timestamp createTime;
+}
\ No newline at end of file

eladmin-logging/src/main/java/me/zhengjie/service/dto/LogQueryCriteria.java

+package me.zhengjie.service.dto;
+
+import lombok.Data;
+import me.zhengjie.annotation.Query;
+
+import java.sql.Timestamp;
+
+/**
+ * 日志查询类
+ * @author Zheng Jie
+ * @date 2019-6-4 09:23:07
+ */
+@Data
+public class LogQueryCriteria {
+
+    // 多字段模糊
+    @Query(blurry = "username,description,address,requestIp,method,params")
+    private String blurry;
+
+    @Query
+    private String logType;
+
+    @Query(type = Query.Type.GREATER_THAN,propName = "createTime")
+    private Timestamp startTime;
+
+    @Query(type = Query.Type.LESS_THAN,propName = "createTime")
+    private Timestamp endTime;
+}

eladmin-logging/src/main/java/me/zhengjie/service/dto/LogSmallDTO.java

+package me.zhengjie.service.dto;
+
+import lombok.Data;
+import java.io.Serializable;
+import java.sql.Timestamp;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-5-22
+ */
+@Data
+public class LogSmallDTO implements Serializable {
+
+    // 描述
+    private String description;
+
+    // 请求ip
+    private String requestIp;
+
+    // 请求耗时
+    private Long time;
+
+    private String address;
+
+    private String browser;
+
+    // 创建日期
+    private Timestamp createTime;
+}

eladmin-logging/src/main/java/me/zhengjie/service/impl/LogServiceImpl.java

+package me.zhengjie.service.impl;
+
+import cn.hutool.core.lang.Dict;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.json.JSONObject;
+import me.zhengjie.domain.Log;
+import me.zhengjie.repository.LogRepository;
+import me.zhengjie.service.LogService;
+import me.zhengjie.service.dto.LogQueryCriteria;
+import me.zhengjie.service.mapper.LogErrorMapper;
+import me.zhengjie.service.mapper.LogSmallMapper;
+import me.zhengjie.utils.FileUtil;
+import me.zhengjie.utils.PageUtil;
+import me.zhengjie.utils.QueryHelp;
+import me.zhengjie.utils.StringUtils;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-11-24
+ */
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class LogServiceImpl implements LogService {
+
+    private final LogRepository logRepository;
+
+    private final LogErrorMapper logErrorMapper;
+
+    private final LogSmallMapper logSmallMapper;
+
+    public LogServiceImpl(LogRepository logRepository, LogErrorMapper logErrorMapper, LogSmallMapper logSmallMapper) {
+        this.logRepository = logRepository;
+        this.logErrorMapper = logErrorMapper;
+        this.logSmallMapper = logSmallMapper;
+    }
+
+    @Override
+    public Object queryAll(LogQueryCriteria criteria, Pageable pageable){
+        Page<Log> page = logRepository.findAll(((root, criteriaQuery, cb) -> QueryHelp.getPredicate(root, criteria, cb)),pageable);
+        if ("ERROR".equals(criteria.getLogType())) {
+            return PageUtil.toPage(page.map(logErrorMapper::toDto));
+        }
+        return page;
+    }
+
+    @Override
+    public List<Log> queryAll(LogQueryCriteria criteria) {
+        return logRepository.findAll(((root, criteriaQuery, cb) -> QueryHelp.getPredicate(root, criteria, cb)));
+    }
+
+    @Override
+    public Object queryAllByUser(LogQueryCriteria criteria, Pageable pageable) {
+        Page<Log> page = logRepository.findAll(((root, criteriaQuery, cb) -> QueryHelp.getPredicate(root, criteria, cb)),pageable);
+        return PageUtil.toPage(page.map(logSmallMapper::toDto));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void save(String username, String browser, String ip, ProceedingJoinPoint joinPoint, Log log){
+
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        Method method = signature.getMethod();
+        me.zhengjie.aop.log.Log aopLog = method.getAnnotation(me.zhengjie.aop.log.Log.class);
+
+        // 方法路径
+        String methodName = joinPoint.getTarget().getClass().getName()+"."+signature.getName()+"()";
+
+        StringBuilder params = new StringBuilder("{");
+        //参数值
+        Object[] argValues = joinPoint.getArgs();
+        //参数名称
+        String[] argNames = ((MethodSignature)joinPoint.getSignature()).getParameterNames();
+        if(argValues != null){
+            for (int i = 0; i < argValues.length; i++) {
+                params.append(" ").append(argNames[i]).append(": ").append(argValues[i]);
+            }
+        }
+        // 描述
+        if (log != null) {
+            log.setDescription(aopLog.value());
+        }
+        assert log != null;
+        log.setRequestIp(ip);
+
+        String LOGINPATH = "login";
+        if(LOGINPATH.equals(signature.getName())){
+            try {
+                assert argValues != null;
+                username = new JSONObject(argValues[0]).get("username").toString();
+            }catch (Exception e){
+                e.printStackTrace();
+            }
+        }
+        log.setAddress(StringUtils.getCityInfo(log.getRequestIp()));
+        log.setMethod(methodName);
+        log.setUsername(username);
+        // log.setParams(params.toString() + " }");
+        log.setBrowser(browser);
+        logRepository.save(log);
+    }
+
+    @Override
+    public Object findByErrDetail(Long id) {
+        byte[] details = logRepository.findExceptionById(id).getExceptionDetail().getBytes();
+        return Dict.create().set("exception",new String(ObjectUtil.isNotNull(details) ? details : "".getBytes()));
+    }
+
+    @Override
+    public void download(List<Log> logs, HttpServletResponse response) throws IOException {
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (Log log : logs) {
+            Map<String,Object> map = new LinkedHashMap<>();
+            map.put("用户名", log.getUsername());
+            map.put("IP", log.getRequestIp());
+            map.put("IP来源", log.getAddress());
+            map.put("描述", log.getDescription());
+            map.put("浏览器", log.getBrowser());
+            map.put("请求耗时/毫秒", log.getTime());
+            // map.put("异常详情", new String(ObjectUtil.isNotNull(log.getExceptionDetail()) ? log.getExceptionDetail() : "".getBytes()));
+            map.put("创建日期", log.getCreateTime());
+            list.add(map);
+        }
+        FileUtil.downloadExcel(list, response);
+    }
+}

eladmin-logging/src/main/java/me/zhengjie/service/mapper/LogErrorMapper.java

+package me.zhengjie.service.mapper;
+
+import me.zhengjie.base.BaseMapper;
+import me.zhengjie.domain.Log;
+import me.zhengjie.service.dto.LogErrorDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-5-22
+ */
+@Mapper(componentModel = "spring",unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface LogErrorMapper extends BaseMapper<LogErrorDTO, Log> {
+
+}
\ No newline at end of file

eladmin-logging/src/main/java/me/zhengjie/service/mapper/LogSmallMapper.java

+package me.zhengjie.service.mapper;
+
+import me.zhengjie.base.BaseMapper;
+import me.zhengjie.domain.Log;
+import me.zhengjie.service.dto.LogSmallDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author Zheng Jie
+ * @date 2019-5-22
+ */
+@Mapper(componentModel = "spring",unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface LogSmallMapper extends BaseMapper<LogSmallDTO, Log> {
+
+}
\ No newline at end of file

eladmin-system/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>eladmin</artifactId>
+        <groupId>me.zhengjie</groupId>
+        <version>2.3</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <packaging>war</packaging>
+    <artifactId>eladmin-system</artifactId>
+    <name>核心模块</name>
+
+    <properties>
+        <jjwt.version>0.9.1</jjwt.version>
+        <junmp.version>1.0.0</junmp.version>
+    </properties>
+
+    <repositories>
+      <repository>
+        <id>junmp-public</id>
+        <name>junmp-public</name>
+        <url>http://maven.sothing.top/repository/junmp-public/</url>
+      </repository>
+    </repositories>
+
+
+    <dependencyManagement>
+        <dependencies>
+            <!--整合spring cloud-->
+            <dependency>
+                <groupId>org.springframework.cloud</groupId>
+                <artifactId>spring-cloud-dependencies</artifactId>
+                <version>Greenwich.SR2</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+            <!--整合spring cloud alibaba-->
+            <dependency>
+                <groupId>com.alibaba.cloud</groupId>
+                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
+                <version>2.1.0.RELEASE</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>me.zhengjie</groupId>
+            <artifactId>eladmin-generator</artifactId>
+            <version>2.3</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>me.zhengjie</groupId>
+                    <artifactId>eladmin-common</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>me.zhengjie</groupId>
+            <artifactId>eladmin-tools</artifactId>
+            <version>2.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.junmp.kernel</groupId>
+            <artifactId>junmp-jwt-starter</artifactId>
+            <version>${junmp.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.zl</groupId>
+            <artifactId>jwzhjar</artifactId>
+            <version>3.3.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.junmp</groupId>
+            <artifactId>jsonxml</artifactId>
+            <version>10</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.junmp</groupId>
+            <artifactId>http-sdk</artifactId>
+            <version>10</version>
+        </dependency>
+
+
+
+        <!-- sqlserver依赖 -->
+        <dependency>
+            <groupId>com.microsoft.sqlserver</groupId>
+            <artifactId>mssql-jdbc</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <!--nacos-->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>2.10.1</version>
+        </dependency>
+
+
+<!--        jwt-->
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt</artifactId>
+            <version>${jjwt.version}</version>
+        </dependency>
+
+        <!-- quartz -->
+        <dependency>
+            <groupId>org.quartz-scheduler</groupId>
+            <artifactId>quartz</artifactId>
+        </dependency>
+
+
+
+
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <!-- 跳过单元测试 -->
+<!--            <plugin>-->
+<!--                <groupId>org.apache.maven.plugins</groupId>-->
+<!--                <artifactId>maven-surefire-plugin</artifactId>-->
+<!--                <configuration>-->
+<!--                    <skipTests>true</skipTests>-->
+<!--                </configuration>-->
+<!--            </plugin>-->
+        </plugins>
+    </build>
+</project>

eladmin-system/src/main/java/me/zhengjie/AppRun.java

+package me.zhengjie;
+
+import me.zhengjie.utils.SpringContextHolder;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+/**
+ * @author Zheng Jie
+ * @date 2018/11/15 9:20:19
+ */
+@EnableAsync
+@SpringBootApplication
+@EnableTransactionManagement
+@EnableDiscoveryClient
+public class AppRun extends SpringBootServletInitializer  {
+
+    public static void main(String[] args) {
+        SpringApplication.run(AppRun.class, args);
+    }
+
+    @Override
+    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
+        return builder.sources(AppRun.class);
+    }
+}

eladmin-system/src/main/java/me/zhengjie/config/ConfigurerAdapter.java

+package me.zhengjie.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import java.nio.file.Paths;
+
+/**
+ * WebMvcConfigurer
+ *
+ * @author Zheng Jie
+ * @date 2018-11-30
+ */
+@Configuration
+@EnableWebMvc
+public class ConfigurerAdapter implements WebMvcConfigurer {
+
+    @Value("${file.path}")
+    private String path;
+
+    @Value("${file.avatar}")
+    private String avatar;
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowCredentials(true)
+                .allowedHeaders("*")
+                .allowedOrigins("*")
+                .allowedMethods("GET","POST","PUT","DELETE");
+
+    }
+
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        String avatarUtl = Paths.get(avatar).normalize().toUri().toASCIIString();
+        String pathUtl = Paths.get(path).normalize().toUri().toASCIIString();
+        registry.addResourceHandler("/avatar/**").addResourceLocations(avatarUtl).setCachePeriod(0);
+        registry.addResourceHandler("/file/**").addResourceLocations(pathUtl).setCachePeriod(0);
+        registry.addResourceHandler("/**").addResourceLocations("classpath:/META-INF/resources/").setCachePeriod(0);
+    }
+}

eladmin-system/src/main/java/me/zhengjie/config/DataScope.java

+package me.zhengjie.config;
+
+import me.zhengjie.modules.system.domain.BaseJpOrganization;
+import me.zhengjie.modules.system.domain.Dept;
+import me.zhengjie.modules.system.service.BaseJpOrganizationService;
+import me.zhengjie.modules.system.service.DeptService;
+import me.zhengjie.modules.system.service.RoleService;
+import me.zhengjie.modules.system.service.UserService;
+import me.zhengjie.modules.system.service.dto.*;
+import me.zhengjie.utils.SecurityUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.io.Serializable;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 数据权限配置
+ * @author Zheng Jie
+ * @date 2019-4-1
+ */
+@Component
+public class DataScope {
+
+    private final String[] scopeType = {"全部","本级","自定义"};
+
+    private final UserService userService;
+
+    private final RoleService roleService;
+
+    private final DeptService deptService;
+
+    private final BaseJpOrganizationService organizationService;
+
+    public DataScope(UserService userService, RoleService roleService, DeptService deptService,
+                     BaseJpOrganizationService organizationService) {
+        this.userService = userService;
+        this.roleService = roleService;
+        this.deptService = deptService;
+        this.organizationService = organizationService;
+    }
+
+    public Set<Long> getDeptIds() {
+
+        UserDTO user = userService.findByName(SecurityUtils.getUsername());
+
+        // 用于存储部门id
+        Set<Long> deptIds = new HashSet<>();
+
+        // 查询用户角色
+        List<RoleSmallDTO> roleSet = roleService.findByUsers_Id(user.getId());
+
+        for (RoleSmallDTO role : roleSet) {
+
+            if (scopeType[0].equals(role.getDataScope())) {
+                return new HashSet<>() ;
+            }
+
+            // 存储本级的数据权限
+            if (scopeType[1].equals(role.getDataScope())) {
+                deptIds.add(user.getDept().getId());
+            }
+
+            // 存储自定义的数据权限
+            if (scopeType[2].equals(role.getDataScope())) {
+                Set<Dept> depts = deptService.findByRoleIds(role.getId());
+                for (Dept dept : depts) {
+                    deptIds.add(dept.getId());
+                    List<Dept> deptChildren = deptService.findByPid(dept.getId());
+                    if (deptChildren != null && deptChildren.size() != 0) {
+                        deptIds.addAll(getDeptChildren(deptChildren));
+                    }
+                }
+            }
+        }
+        return deptIds;
+    }
+
+
+    public List<Long> getDeptChildren(List<Dept> deptList) {
+        List<Long> list = new ArrayList<>();
+        deptList.forEach(dept -> {
+                    if (dept!=null && dept.getEnabled()){
+                        List<Dept> depts = deptService.findByPid(dept.getId());
+                        if(deptList.size() != 0){
+                            list.addAll(getDeptChildren(depts));
+                        }
+                        list.add(dept.getId());
+                    }
+                }
+        );
+        return list;
+    }
+
+    public Set<String> getOrgChildren1(List<BaseJpOrganization> orgList) {
+        Set<String> ids = new HashSet<>();
+        for (BaseJpOrganization org : orgList) {
+            for (BaseJpOrganization it : orgList) {
+                if (it.getParentId().equals(org.getId())) {
+//                    if (org.getChildren() == null) {
+//                        org.setChildren(new ArrayList<>());
+//                    }
+//                    org.getChildren().add(it);
+                    ids.add(it.getId());
+                }
+            }
+        }
+        List<String> allIds  = orgList.stream().map(node -> node.getId()).collect(Collectors.toList());
+        return  ids;
+    }
+
+    public List<String> getOrgChildren(List<BaseJpOrganization> orgList) {
+        List<String> list = new ArrayList<>();
+        orgList.forEach(org -> {
+                    if (org != null) {
+                        // List<BaseJpOrganization> baseJpOrganizations = organizationService.findByPid(org.getId());
+                        List<BaseJpOrganization> baseJpOrganizations = org.getChildren();
+                        if(orgList.size() != 0) {
+                            list.addAll(getOrgChildren(baseJpOrganizations));
+                        }
+                        list.add(org.getId());
+                    }
+                }
+        );
+        return list;
+    }
+
+
+}

eladmin-system/src/main/java/me/zhengjie/config/thread/AsyncTaskExecutePool.java

+package me.zhengjie.config.thread;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.AsyncConfigurer;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ThreadPoolExecutor;
+
+/**
+ * 异步任务线程池装配类
+ * @author https://juejin.im/entry/5abb8f6951882555677e9da2
+ * @date 2019年10月31日15:06:18
+ */
+@Slf4j
+@Configuration
+public class AsyncTaskExecutePool implements AsyncConfigurer {
+
+    //注入配置类
+    private final AsyncTaskProperties config;
+
+    public AsyncTaskExecutePool(AsyncTaskProperties config) {
+        this.config = config;
+    }
+
+    @Override
+    public Executor getAsyncExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        //核心线程池大小
+        executor.setCorePoolSize(config.getCorePoolSize());
+        //最大线程数
+        executor.setMaxPoolSize(config.getMaxPoolSize());
+        //队列容量
+        executor.setQueueCapacity(config.getQueueCapacity());
+        //活跃时间
+        executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
+        //线程名字前缀
+        executor.setThreadNamePrefix("el-async-");
+        // setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务
+        // CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行
+        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+        executor.initialize();
+        return executor;
+    }
+
+    @Override
+    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
+        return (throwable, method, objects) -> {
+            log.error("===="+throwable.getMessage()+"====", throwable);
+            log.error("exception method:"+method.getName());
+        };
+    }
+}

eladmin-system/src/main/java/me/zhengjie/config/thread/AsyncTaskProperties.java

+package me.zhengjie.config.thread;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 线程池配置属性类
+ * @author https://juejin.im/entry/5abb8f6951882555677e9da2
+ * @date 2019年10月31日14:58:18
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "task.pool")
+public class AsyncTaskProperties {
+
+    private int corePoolSize;
+
+    private int maxPoolSize;
+
+    private int keepAliveSeconds;
+
+    private int queueCapacity;
+}

eladmin-system/src/main/java/me/zhengjie/config/thread/TheadFactoryName.java

+package me.zhengjie.config.thread;
+
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * 自定义线程名称
+ * @author Zheng Jie
+ * @date 2019年10月31日17:49:55
+ */
+@Component
+public class TheadFactoryName implements ThreadFactory {
+
+    private static final AtomicInteger poolNumber = new AtomicInteger(1);
+    private final ThreadGroup group;
+    private final AtomicInteger threadNumber = new AtomicInteger(1);
+    private final String namePrefix;
+
+    public TheadFactoryName() {
+        this("el-pool");
+    }
+
+    private TheadFactoryName(String name){
+        SecurityManager s = System.getSecurityManager();
+        group = (s != null) ? s.getThreadGroup() :
+                Thread.currentThread().getThreadGroup();
+        //此时namePrefix就是 name + 第几个用这个工厂创建线程池的
+        this.namePrefix = name +
+                poolNumber.getAndIncrement();
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+        //此时线程的名字 就是 namePrefix + -thread- + 这个线程池中第几个执行的线程
+        Thread t = new Thread(group, r,
+                namePrefix + "-thread-"+threadNumber.getAndIncrement(),
+                0);
+        if (t.isDaemon()) {
+            t.setDaemon(false);
+        }
+        if (t.getPriority() != Thread.NORM_PRIORITY) {
+            t.setPriority(Thread.NORM_PRIORITY);
+        }
+        return t;
+    }
+}

eladmin-system/src/main/java/me/zhengjie/config/thread/ThreadPoolExecutorUtil.java

+package me.zhengjie.config.thread;
+
+import me.zhengjie.utils.SpringContextHolder;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 用于获取自定义线程池
+ * @author Zheng Jie
+ * @date 2019年10月31日18:16:47
+ */
+public class ThreadPoolExecutorUtil {
+
+    public static ThreadPoolExecutor getPoll(){
+        AsyncTaskProperties properties = SpringContextHolder.getBean(AsyncTaskProperties.class);
+        return new ThreadPoolExecutor(
+                properties.getCorePoolSize(),
+                properties.getMaxPoolSize(),
+                properties.getKeepAliveSeconds(),
+                TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(properties.getQueueCapacity()),
+                new TheadFactoryName()
+        );
+    }
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/config/VisitsInitialization.java

+package me.zhengjie.modules.monitor.config;
+
+import me.zhengjie.modules.monitor.service.VisitsService;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+/**
+ * 初始化站点统计
+ * @author Zheng Jie
+ */
+@Component
+public class VisitsInitialization implements ApplicationRunner {
+
+    private final VisitsService visitsService;
+
+    public VisitsInitialization(VisitsService visitsService) {
+        this.visitsService = visitsService;
+    }
+
+    @Override
+    public void run(ApplicationArguments args){
+        System.out.println("--------------- 初始化站点统计，如果存在今日统计则跳过 ---------------");
+        visitsService.save();
+        System.out.println("--------------- 初始化站点统计完成 ---------------");
+    }
+}
\ No newline at end of file

eladmin-system/src/main/java/me/zhengjie/modules/monitor/domain/Visits.java

+package me.zhengjie.modules.monitor.domain;
+
+import lombok.Data;
+import org.hibernate.annotations.CreationTimestamp;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.sql.Timestamp;
+
+/**
+ * pv 与 ip 统计
+ *
+ * @author Zheng Jie
+ * @date 2018-12-13
+ */
+@Entity
+@Data
+@Table(name = "visits")
+public class Visits  implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(unique = true)
+    private String date;
+
+    @Column(name = "pv_counts")
+    private Long pvCounts;
+
+    @Column(name = "ip_counts")
+    private Long ipCounts;
+
+    @CreationTimestamp
+    @Column(name = "create_time")
+    private Timestamp createTime;
+
+    @Column(name = "week_day")
+    private String weekDay;
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/domain/vo/RedisVo.java

+package me.zhengjie.modules.monitor.domain.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.validation.constraints.NotBlank;
+import java.io.Serializable;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-10
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class RedisVo implements Serializable {
+
+    @NotBlank
+    private String key;
+
+    @NotBlank
+    private String value;
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/repository/VisitsRepository.java

+package me.zhengjie.modules.monitor.repository;
+
+import me.zhengjie.modules.monitor.domain.Visits;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-13
+ */
+@Repository
+public interface VisitsRepository extends JpaRepository<Visits,Long> {
+
+    /**
+     * findByDate
+     * @param date 日期
+     * @return Visits
+     */
+    Visits findByDate(String date);
+
+    /**
+     * 获得一个时间段的记录
+     * @param date1 日期1
+     * @param date2 日期2
+     * @return List
+     */
+    @Query(value = "select * FROM visits where create_time between ?1 and ?2",nativeQuery = true)
+    List<Visits> findAllVisits(String date1, String date2);
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/rest/LimitController.java

+package me.zhengjie.modules.monitor.rest;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import me.zhengjie.annotation.AnonymousAccess;
+import me.zhengjie.annotation.Limit;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ *
+ * 接口限流测试类
+ */
+@RestController
+@RequestMapping("/api/limit")
+@Api(tags = "系统：限流测试管理")
+public class LimitController {
+
+    private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger();
+
+    /**
+     * 测试限流注解，下面配置说明该接口 60秒内最多只能访问 10次，保存到redis的键名为 limit_test，
+     */
+    @GetMapping
+    @PreAuthorize("@el.check('anonymous')")
+    @ApiOperation("测试")
+    @Limit(key = "test", period = 60, count = 10, name = "testLimit", prefix = "limit")
+    public int testLimit() {
+        return ATOMIC_INTEGER.incrementAndGet();
+    }
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/rest/RedisController.java

+package me.zhengjie.modules.monitor.rest;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import me.zhengjie.aop.log.Log;
+import me.zhengjie.modules.monitor.domain.vo.RedisVo;
+import me.zhengjie.modules.monitor.service.RedisService;
+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.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-10
+ */
+@RestController
+@RequestMapping("/api/redis")
+@Api(tags = "系统：Redis缓存管理")
+public class RedisController {
+
+    private final RedisService redisService;
+
+    public RedisController(RedisService redisService) {
+        this.redisService = redisService;
+    }
+
+    @Log("查询Redis缓存")
+    @GetMapping
+    @ApiOperation("查询Redis缓存")
+    @PreAuthorize("@el.check('redis:list')")
+    public ResponseEntity getRedis(String key, Pageable pageable){
+        return new ResponseEntity<>(redisService.findByKey(key,pageable), HttpStatus.OK);
+    }
+
+    @Log("导出数据")
+    @ApiOperation("导出数据")
+    @GetMapping(value = "/download")
+    @PreAuthorize("@el.check('redis:list')")
+    public void download(HttpServletResponse response, String key) throws IOException {
+        redisService.download(redisService.findByKey(key), response);
+    }
+
+    @Log("删除Redis缓存")
+    @DeleteMapping
+    @ApiOperation("删除Redis缓存")
+    @PreAuthorize("@el.check('redis:del')")
+    public ResponseEntity delete(@RequestBody RedisVo resources){
+        redisService.delete(resources.getKey());
+        return new ResponseEntity(HttpStatus.OK);
+    }
+
+    @Log("清空Redis缓存")
+    @DeleteMapping(value = "/all")
+    @ApiOperation("清空Redis缓存")
+    @PreAuthorize("@el.check('redis:del')")
+    public ResponseEntity deleteAll(){
+        redisService.deleteAll();
+        return new ResponseEntity(HttpStatus.OK);
+    }
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/rest/VisitsController.java

+package me.zhengjie.modules.monitor.rest;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import me.zhengjie.modules.monitor.service.VisitsService;
+import me.zhengjie.utils.RequestHolder;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-13
+ */
+@RestController
+@RequestMapping("/api/visits")
+@Api(tags = "系统:访问记录管理")
+public class VisitsController {
+
+    private final VisitsService visitsService;
+
+    public VisitsController(VisitsService visitsService) {
+        this.visitsService = visitsService;
+    }
+
+    @PostMapping
+    @ApiOperation("创建访问记录")
+    public ResponseEntity create(){
+        visitsService.count(RequestHolder.getHttpServletRequest());
+        return new ResponseEntity(HttpStatus.CREATED);
+    }
+
+    @GetMapping
+    @ApiOperation("查询")
+    public ResponseEntity get(){
+        return new ResponseEntity<>(visitsService.get(),HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/chartData")
+    @ApiOperation("查询图表数据")
+    public ResponseEntity getChartData(){
+        return new ResponseEntity<>(visitsService.getChartData(),HttpStatus.OK);
+    }
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/service/RedisService.java

+package me.zhengjie.modules.monitor.service;
+
+import me.zhengjie.modules.monitor.domain.vo.RedisVo;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * 可自行扩展
+ * @author Zheng Jie
+ * @date 2018-12-10
+ */
+public interface RedisService {
+
+    /**
+     * findById
+     * @param key 键
+     * @return /
+     */
+    Page findByKey(String key, Pageable pageable);
+
+    /**
+     * findById
+     * @param key 键
+     * @return /
+     */
+    List<RedisVo> findByKey(String key);
+
+    /**
+     * 查询验证码的值
+     * @param key 键
+     * @return /
+     */
+    String getCodeVal(String key);
+
+    /**
+     * 保存验证码
+     * @param key 键
+     * @param val 值
+     */
+    void saveCode(String key, Object val);
+
+
+    /**
+     * 保存钉钉的登录token
+     * @param key
+     * @param val
+     */
+    void saveAccessToken(String key, Object val);
+
+    /**
+     * delete
+     * @param key 键
+     */
+    void delete(String key);
+
+    /**
+     * 清空缓存
+     */
+    void deleteAll();
+
+    /**
+     *
+     * @param redisVos /
+     * @param response /
+     */
+    void download(List<RedisVo> redisVos, HttpServletResponse response) throws IOException;
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/service/VisitsService.java

+package me.zhengjie.modules.monitor.service;
+
+import org.springframework.scheduling.annotation.Async;
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-13
+ */
+public interface VisitsService {
+
+    /**
+     * 提供给定时任务，每天0点执行
+     */
+    void save();
+
+    /**
+     * 新增记录
+     * @param request /
+     */
+    @Async
+    void count(HttpServletRequest request);
+
+    /**
+     * 获取数据
+     * @return /
+     */
+    Object get();
+
+    /**
+     * getChartData
+     * @return /
+     */
+    Object getChartData();
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/service/impl/RedisServiceImpl.java

+package me.zhengjie.modules.monitor.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import me.zhengjie.modules.monitor.domain.vo.RedisVo;
+import me.zhengjie.modules.monitor.service.RedisService;
+import me.zhengjie.utils.FileUtil;
+import me.zhengjie.utils.PageUtil;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-10
+ */
+@Service
+@SuppressWarnings({"unchecked","all"})
+public class RedisServiceImpl implements RedisService {
+
+    private final RedisTemplate redisTemplate;
+
+    @Value("${loginCode.expiration}")
+    private Long expiration;
+
+    @Value("${jwt.online}")
+    private String onlineKey;
+
+    @Value("${jwt.codeKey}")
+    private String codeKey;
+
+    public RedisServiceImpl(RedisTemplate redisTemplate) {
+        this.redisTemplate = redisTemplate;
+    }
+
+    @Override
+    public Page<RedisVo> findByKey(String key, Pageable pageable){
+        List<RedisVo> redisVos = findByKey(key);
+        return new PageImpl<RedisVo>(
+                PageUtil.toPage(pageable.getPageNumber(),pageable.getPageSize(),redisVos),
+                pageable,
+                redisVos.size());
+    }
+
+    @Override
+    public List<RedisVo> findByKey(String key) {
+        List<RedisVo> redisVos = new ArrayList<>();
+        if(!"*".equals(key)){
+            key = "*" + key + "*";
+        }
+        Set<String> keys = redisTemplate.keys(key);
+        for (String s : keys) {
+            // 过滤掉权限的缓存
+            if (s.contains("role::loadPermissionByUser") || s.contains("user::loadUserByUsername") || s.contains(onlineKey) || s.contains(codeKey)) {
+                continue;
+            }
+            RedisVo redisVo = new RedisVo(s, Objects.requireNonNull(redisTemplate.opsForValue().get(s)).toString());
+            redisVos.add(redisVo);
+        }
+        return redisVos;
+    }
+
+    @Override
+    public void delete(String key) {
+        redisTemplate.delete(key);
+    }
+
+    @Override
+    public void deleteAll() {
+        Set<String> keys = redisTemplate.keys(  "*");
+        redisTemplate.delete(keys.stream().filter(s -> !s.contains(onlineKey)).filter(s -> !s.contains(codeKey)).collect(Collectors.toList()));
+    }
+
+    @Override
+    public String getCodeVal(String key) {
+        try {
+            return Objects.requireNonNull(redisTemplate.opsForValue().get(key)).toString();
+        }catch (Exception e){
+            return "";
+        }
+    }
+
+    @Override
+    public void saveCode(String key, Object val) {
+        redisTemplate.opsForValue().set(key,val);
+        redisTemplate.expire(key, expiration, TimeUnit.MINUTES);
+    }
+
+    @Override
+    public void saveAccessToken(String key, Object val) {
+        redisTemplate.opsForValue().set(key,val);
+        redisTemplate.expire(key,7200000, TimeUnit.MINUTES);
+    }
+
+
+    @Override
+    public void download(List<RedisVo> redisVos, HttpServletResponse response) throws IOException {
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (RedisVo redisVo : redisVos) {
+            Map<String,Object> map = new LinkedHashMap<>();
+            map.put("key", redisVo.getKey());
+            map.put("value", redisVo.getValue());
+            list.add(map);
+        }
+        FileUtil.downloadExcel(list, response);
+    }
+}

eladmin-system/src/main/java/me/zhengjie/modules/monitor/service/impl/VisitsServiceImpl.java

+package me.zhengjie.modules.monitor.service.impl;
+
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.modules.monitor.domain.Visits;
+import me.zhengjie.modules.monitor.repository.VisitsRepository;
+import me.zhengjie.modules.monitor.service.VisitsService;
+import me.zhengjie.repository.LogRepository;
+import me.zhengjie.utils.StringUtils;
+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 javax.servlet.http.HttpServletRequest;
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @author Zheng Jie
+ * @date 2018-12-13
+ */
+@Slf4j
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class VisitsServiceImpl implements VisitsService {
+
+    private final VisitsRepository visitsRepository;
+
+    private final LogRepository logRepository;
+
+    public VisitsServiceImpl(VisitsRepository visitsRepository, LogRepository logRepository) {
+        this.visitsRepository = visitsRepository;
+        this.logRepository = logRepository;
+    }
+
+    @Override
+    public void save() {
+        LocalDate localDate = LocalDate.now();
+        Visits visits = visitsRepository.findByDate(localDate.toString());
+        if(visits == null){
+            visits = new Visits();
+            visits.setWeekDay(StringUtils.getWeekDay());
+            visits.setPvCounts(1L);
+            visits.setIpCounts(1L);
+            visits.setDate(localDate.toString());
+            visitsRepository.save(visits);
+        }
+    }
+
+    @Override
+    public void count(HttpServletRequest request) {
+        LocalDate localDate = LocalDate.now();
+        Visits visits = visitsRepository.findByDate(localDate.toString());
+        visits.setPvCounts(visits.getPvCounts()+1);
+        long ipCounts = logRepository.findIp(localDate.toString(), localDate.plusDays(1).toString());
+        visits.setIpCounts(ipCounts);
+        visitsRepository.save(visits);
+    }
+
+    @Override
+    public Object get() {
+        Map<String,Object> map = new HashMap<>();
+        LocalDate localDate = LocalDate.now();
+        Visits visits = visitsRepository.findByDate(localDate.toString());
+        List<Visits> list = visitsRepository.findAllVisits(localDate.minusDays(6).toString(),localDate.plusDays(1).toString());
+
+        long recentVisits = 0, recentIp = 0;
+        for (Visits data : list) {
+            recentVisits += data.getPvCounts();
+            recentIp += data.getIpCounts();
+        }
+        map.put("newVisits",visits.getPvCounts());
+        map.put("newIp",visits.getIpCounts());
+        map.put("recentVisits",recentVisits);
+        map.put("recentIp",recentIp);
+        return map;
+    }
+
+    @Override
+    public Object getChartData() {
+        Map<String,Object> map = new HashMap<>();
+        LocalDate localDate = LocalDate.now();
+        List<Visits> list = visitsRepository.findAllVisits(localDate.minusDays(6).toString(),localDate.plusDays(1).toString());
+        map.put("weekDays",list.stream().map(Visits::getWeekDay).collect(Collectors.toList()));
+        map.put("visitsData",list.stream().map(Visits::getPvCounts).collect(Collectors.toList()));
+        map.put("ipData",list.stream().map(Visits::getIpCounts).collect(Collectors.toList()));
+        return map;
+    }
+}

eladmin-system/src/main/java/me/zhengjie/modules/oauth/domain/JpGun.java

+package me.zhengjie.modules.oauth.domain;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.util.Date;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "jp_gun")
+public class JpGun implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "gun_name")
+    private String gunName;
+
+    @Column(name = "epc")
+    private String epc;
+
+    @Column(name = "status")
+    private String status;
+
+    @Column(name = "create_time")
+    private Date createTime;
+
+    @Column(name = "person_name")
+    private String personName;
+
+    @Column(name = "g_count")
+    private Integer gCount;
+
+}

eladmin-system/src/main/java/me/zhengjie/modules/oauth/domain/JpModule.java

+package me.zhengjie.modules.oauth.domain;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "jp_module")
+public class JpModule implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "pid")
+    private Long pid;
+
+    @Column(name = "pname")
+    private String pname;
+
+}

eladmin-system/src/main/java/me/zhengjie/modules/oauth/domain/JpModuleMateriel.java

+package me.zhengjie.modules.oauth.domain;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "jp_module_materiel")
+public class JpModuleMateriel implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @OneToOne
+    @JoinColumn(name = "module_id")
+    private JpModule jpModule;
+
+    @Column(name = "materiel_name")
+    private String materielName;
+
+    @Column(name = "g_count")
+    private Integer gCount;
+
+    @Column(name = "location")
+    private String location;
+
+}

eladmin-system/src/main/java/me/zhengjie/modules/oauth/repository/JpGunRepository.java

+package me.zhengjie.modules.oauth.repository;
+
+import me.zhengjie.modules.oauth.domain.JpGun;
+import me.zhengjie.modules.oauth.service.dto.JpGunPieDTO;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+public interface JpGunRepository extends JpaRepository<JpGun, String>, JpaSpecificationExecutor<JpGun> {
+
+    JpGun findByEpc(String epc);
+
+    @Modifying
+    @Transactional
+    @Query(value = "update jp_gun set status = ?2 , create_time = ?3 where epc = ?1",nativeQuery = true)
+    void updateStatus(String epc, String status, Date createTime);
+
+    @Query(value = "select * from jp_gun s1 where s1.status is not null order by s1.create_time desc",nativeQuery = true)
+    List<JpGun> findAll();
+
+    @Query(value = "SELECT s1.gun_name AS name,count(s1.id) AS value FROM jp_gun s1 WHERE s1.status is not null And datediff(day, s1.create_time,getdate())=0 GROUP BY s1.gun_name",nativeQuery = true)
+    List<Map<String, Integer>> getPie();
+
+    @Query(value ="SELECT count(*) AS lyCount FROM jp_gun s1 WHERE datediff(day, s1.create_time,getdate())=0",nativeQuery = true)
+    Map<String, Integer> getLyCount();
+
+    @Query(value ="SELECT count(*) AS inCount FROM jp_gun s1 WHERE datediff(day, s1.create_time,getdate())=0 AND status = '入库'",nativeQuery = true)
+    Map<String, Integer> getInCount();
+
+    @Query(value ="SELECT count(*) AS unReturnCount FROM jp_gun s1 WHERE status = '出库'",nativeQuery = true)
+    Map<String, Integer> getUnReturnCount();
+
+    @Query(value = "SELECT s1.gun_name AS name, count(s1.id) as value FROM jp_gun s1 WHERE s1.status='出库' GROUP BY s1.gun_name",nativeQuery = true)
+    List<Map<String, Integer>> getUnReturn();
+
+}

eladmin-system/src/main/java/me/zhengjie/modules/oauth/repository/JpModuleMaterielRepository.java

+package me.zhengjie.modules.oauth.repository;
+
+import me.zhengjie.modules.oauth.domain.JpModuleMateriel;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+public interface JpModuleMaterielRepository extends JpaRepository<JpModuleMateriel, String>, JpaSpecificationExecutor<JpModuleMateriel> {
+
+}

eladmin-system/src/main/java/me/zhengjie/modules/oauth/rest/OauthController.java

+package me.zhengjie.modules.oauth.rest;
+
+import io.swagger.annotations.Api;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * <pre>
+ *
+ * 描述：
+ * 版本：1.0.0
+ * 日期：2020-05-27 13:55
+ * 作者：ningzp@junmp.com.cn
+ * <br>修改记录
+ * <br>修改日期        修改人          修改内容
+ *
+ * </pre>
+ */
+@Slf4j
+@RestController
+@RequestMapping("/anno")
+@Api(value = "用户授权认证", tags = "登录接口")
+public class OauthController {
+
+//    @Autowired
+//    private ValidateCodeService validateCodeService;
+//
+//
+//    @Autowired
+//    private TokenUtil tokenUtil;
+//
+//
+//
+//    /**
+//     * 验证验证码
+//     *
+//     * @param key  验证码唯一uuid key
+//     * @param code 验证码
+//     * @return
+//     * @throws BizException
+//     */
+//    @ApiOperation(value = "验证验证码", notes = "验证验证码")
+//    @GetMapping(value = "/check")
+//    public ApiRes<Boolean> check(@RequestParam(value = "key") String key, @RequestParam(value = "code") String code) throws BizException {
+//        return this.validateCodeService.check(key, code);
+//    }
+//
+//
+//    /**
+//     * 生成验证码
+//     *
+//     * @param key 键
+//     */
+//    @ApiOperation(value = "验证码", notes = "验证码")
+//    @GetMapping(value = "/captcha", produces = "image/png")
+//    public void captcha(@RequestParam(value = "key") String key, HttpServletResponse response) throws IOException {
+//        this.validateCodeService.create(key, response);
+//    }
+//
+//    /**
+//     * 验证token
+//     *
+//     * @param token
+//     * @return
+//     * @throws Exception
+//     */
+//    @ApiOperation(value = "验证token", notes = "验证token")
+//    @GetMapping(value = "/verify")
+//    public ApiRes<ApiAuthInfo> verify(@RequestParam(value = "token") String token) throws BizException {
+//        return ApiRes.success(tokenUtil.getApiAuthInfo(token));
+//    }
+
+
+
+}