eladmin 1.0 版本发布

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

+package me.zhengjie.common.utils;
+
+import org.springframework.data.domain.Page;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 分页工具
+ *
+ * @author jie
+ * @date 2018-12-10
+ */
+public class PageUtil {
+
+    /**
+     * List 分页
+     * @param page
+     * @param size
+     * @param list
+     * @return
+     */
+    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反序列化报错
+     * @param page
+     * @return
+     */
+    public static Map toPage(Page page) {
+        Map map = new HashMap();
+
+        map.put("content",page.getContent());
+        map.put("totalElements",page.getTotalElements());
+
+        return map;
+    }
+
+}

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

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

src/main/java/me/zhengjie/common/utils/TimeUtil.java

+package me.zhengjie.common.utils;
+
+import java.util.Calendar;
+import java.util.Date;
+
+/**
+ * @author jie
+ * @date 2018-12-13
+ *
+ * 日期工具
+ */
+public class TimeUtil {
+
+    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];
+    }
+}

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

+package me.zhengjie.common.utils;
+
+import me.zhengjie.common.exception.BadRequestException;
+import java.util.Optional;
+
+/**
+ * 验证工具
+ * @author jie
+ * @date 2018-11-23
+ */
+public class ValidationUtil {
+
+    /**
+     * 验证空
+     * @param optional
+     */
+    public static void isNull(Optional optional, String entity,String parameter , Object value){
+        if(!optional.isPresent()){
+            String msg = entity
+                         + " 不存在 "
+                         +"{ "+ parameter +":"+ value.toString() +" }";
+            throw new BadRequestException(msg);
+        }
+    }
+
+    /**
+     * 验证是否为邮箱
+     * @param string
+     * @return
+     */
+    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);
+    }
+}

src/main/java/me/zhengjie/core/config/CorsConfig.java

+package me.zhengjie.core.config;
+
+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;
+
+/**
+ * 跨域请求
+ *
+ * @author jie
+ * @date 2018-11-30
+ */
+@Configuration
+@EnableWebMvc
+public class CorsConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        //设置允许跨域的路径
+        registry.addMapping("/**")
+                //设置允许跨域请求的域名
+                .allowedOrigins("*")
+                //是否允许证书 不再默认开启
+                .allowCredentials(true)
+                //设置允许的方法
+                .allowedMethods("*")
+                //跨域允许时间
+                .maxAge(3600);
+    }
+
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        registry.addResourceHandler("/**").addResourceLocations("classpath:/META-INF/resources/").setCachePeriod(0);
+    }
+}

src/main/java/me/zhengjie/core/config/WebSecurityConfig.java

+package me.zhengjie.core.config;
+
+import me.zhengjie.core.security.JwtAuthenticationEntryPoint;
+import me.zhengjie.core.security.JwtAuthorizationTokenFilter;
+import me.zhengjie.core.service.JwtUserDetailsService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.builders.WebSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@Configuration
+@EnableWebSecurity
+@EnableGlobalMethodSecurity(prePostEnabled = true)
+public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+
+    @Autowired
+    private JwtAuthenticationEntryPoint unauthorizedHandler;
+
+    @Autowired
+    private JwtUserDetailsService jwtUserDetailsService;
+
+    /**
+     * 自定义基于JWT的安全过滤器
+     */
+    @Autowired
+    JwtAuthorizationTokenFilter authenticationTokenFilter;
+
+    @Value("${jwt.header}")
+    private String tokenHeader;
+
+    @Value("${jwt.auth.path}")
+    private String authenticationPath;
+
+    @Autowired
+    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
+        auth
+            .userDetailsService(jwtUserDetailsService)
+            .passwordEncoder(passwordEncoderBean());
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoderBean() {
+        return new BCryptPasswordEncoder();
+    }
+
+    @Bean
+    @Override
+    public AuthenticationManager authenticationManagerBean() throws Exception {
+        return super.authenticationManagerBean();
+    }
+
+    @Override
+    protected void configure(HttpSecurity httpSecurity) throws Exception {
+        httpSecurity
+
+            // 禁用 CSRF
+            .csrf().disable()
+
+            // 授权异常
+            .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
+
+            // 不创建会话
+            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
+
+            .authorizeRequests()
+
+            .antMatchers("/auth/**").permitAll()
+
+            .antMatchers("/druid/**").anonymous()
+            // swagger start
+            .antMatchers("/swagger-ui.html").anonymous()
+            .antMatchers("/swagger-resources/**").anonymous()
+            .antMatchers("/webjars/**").anonymous()
+            .antMatchers("/*/api-docs").anonymous()
+            // swagger end
+
+            .antMatchers(HttpMethod.OPTIONS, "/**").anonymous()
+
+            // 所有请求都需要认证
+            .anyRequest().authenticated();
+
+        httpSecurity
+            .addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
+    }
+
+    @Override
+    public void configure(WebSecurity web) throws Exception {
+        // AuthenticationTokenFilter will ignore the below paths
+        web
+            .ignoring()
+            .antMatchers(
+                HttpMethod.POST,
+                authenticationPath
+            )
+
+            // allow anonymous resource requests
+            .and()
+            .ignoring()
+            .antMatchers(
+                HttpMethod.GET,
+                "/*.html",
+                "/**/*.html",
+                "/**/*.css",
+                "/**/*.js"
+            );
+    }
+}

src/main/java/me/zhengjie/core/rest/AuthenticationController.java

+package me.zhengjie.core.rest;
+
+import lombok.extern.slf4j.Slf4j;
+import me.zhengjie.common.aop.log.Log;
+import me.zhengjie.core.security.AuthenticationToken;
+import me.zhengjie.core.security.AuthorizationUser;
+import me.zhengjie.core.utils.JwtTokenUtil;
+import me.zhengjie.core.security.JwtUser;
+import me.zhengjie.core.utils.EncryptUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AccountExpiredException;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.web.bind.annotation.*;
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ * 授权、根据token获取用户详细信息
+ */
+@Slf4j
+@RestController
+@RequestMapping("auth")
+public class AuthenticationController {
+
+    @Value("${jwt.header}")
+    private String tokenHeader;
+
+    @Autowired
+    private AuthenticationManager authenticationManager;
+
+    @Autowired
+    private JwtTokenUtil jwtTokenUtil;
+
+    @Autowired
+    @Qualifier("jwtUserDetailsService")
+    private UserDetailsService userDetailsService;
+
+    /**
+     * 登录授权
+     * @param authorizationUser
+     * @return
+     */
+    @Log(description = "用户登录")
+    @PostMapping(value = "${jwt.auth.path}")
+    public ResponseEntity<?> authenticationLogin(@RequestBody AuthorizationUser authorizationUser){
+
+        final UserDetails userDetails = userDetailsService.loadUserByUsername(authorizationUser.getUsername());
+
+        if(!userDetails.getPassword().equals(EncryptUtils.encryptPassword(authorizationUser.getPassword()))){
+            throw new AccountExpiredException("密码错误");
+        }
+
+        if(!userDetails.isEnabled()){
+            throw new AccountExpiredException("账号已停用，请联系管理员");
+        }
+
+        // 生成令牌
+        final String token = jwtTokenUtil.generateToken(userDetails);
+
+        // 返回 token
+        return ResponseEntity.ok(new AuthenticationToken(token));
+    }
+
+    /**
+     * 获取用户信息
+     * @param request
+     * @return
+     */
+    @GetMapping(value = "${jwt.auth.account}")
+    public ResponseEntity getUserInfo(HttpServletRequest request){
+        JwtUser jwtUser = (JwtUser)userDetailsService.loadUserByUsername(jwtTokenUtil.getUserName(request));
+        return ResponseEntity.ok(jwtUser);
+    }
+}

src/main/java/me/zhengjie/core/security/AuthenticationToken.java

+package me.zhengjie.core.security;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import java.io.Serializable;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ * 返回token
+ */
+@Getter
+@AllArgsConstructor
+public class AuthenticationToken implements Serializable {
+
+    private final String token;
+}

src/main/java/me/zhengjie/core/security/AuthorizationUser.java

+package me.zhengjie.core.security;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+/**
+ * @author jie
+ * @date 2018-11-30
+ */
+@Getter
+@Setter
+public class AuthorizationUser {
+
+    @NotBlank
+    private String username;
+
+    @NotBlank
+    private String password;
+
+    @Override
+    public String toString() {
+        return "{username=" + username  + ", password= ******}";
+    }
+}

src/main/java/me/zhengjie/core/security/JwtAuthenticationEntryPoint.java

+package me.zhengjie.core.security;
+
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.AuthenticationEntryPoint;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.Serializable;
+
+@Component
+public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {
+
+    private static final long serialVersionUID = -8970718410437077606L;
+
+    @Override
+    public void commence(HttpServletRequest request,
+                         HttpServletResponse response,
+                         AuthenticationException authException) throws IOException {
+        /**
+         * 当用户尝试访问安全的REST资源而不提供任何凭据时，将调用此方法发送401 响应
+         */
+        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, authException==null?"Unauthorized":authException.getMessage());
+    }
+}

src/main/java/me/zhengjie/core/security/JwtAuthorizationTokenFilter.java

+package me.zhengjie.core.security;
+
+import io.jsonwebtoken.ExpiredJwtException;
+import me.zhengjie.core.utils.JwtTokenUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+@Component
+public class JwtAuthorizationTokenFilter extends OncePerRequestFilter {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    private final UserDetailsService userDetailsService;
+    private final JwtTokenUtil jwtTokenUtil;
+    private final String tokenHeader;
+
+    public JwtAuthorizationTokenFilter(@Qualifier("jwtUserDetailsService") UserDetailsService userDetailsService, JwtTokenUtil jwtTokenUtil, @Value("${jwt.header}") String tokenHeader) {
+        this.userDetailsService = userDetailsService;
+        this.jwtTokenUtil = jwtTokenUtil;
+        this.tokenHeader = tokenHeader;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
+        logger.debug("processing authentication for '{}'", request.getRequestURL());
+
+        final String requestHeader = request.getHeader(this.tokenHeader);
+
+        String username = null;
+        String authToken = null;
+        if (requestHeader != null && requestHeader.startsWith("Bearer ")) {
+            authToken = requestHeader.substring(7);
+            try {
+                username = jwtTokenUtil.getUsernameFromToken(authToken);
+            } catch (ExpiredJwtException e) {
+               logger.error(e.getMessage());
+            }
+        } else {
+            logger.warn("couldn't find bearer string, will ignore the header");
+        }
+
+        logger.debug("checking authentication for user '{}'", username);
+
+        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+            logger.debug("security context was null, so authorizating user");
+
+            // It is not compelling necessary to load the use details from the database. You could also store the information
+            // in the token and read it from it. It's up to you ;)
+            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
+
+            // For simple validation it is completely sufficient to just check the token integrity. You don't have to call
+            // the database compellingly. Again it's up to you ;)
+            if (jwtTokenUtil.validateToken(authToken, userDetails)) {
+                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
+                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+                logger.info("authorizated user '{}', setting security context", username);
+                SecurityContextHolder.getContext().setAuthentication(authentication);
+            }
+        }
+        chain.doFilter(request, response);
+    }
+}

src/main/java/me/zhengjie/core/security/JwtUser.java

+package me.zhengjie.core.security;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import java.util.*;
+
+/**
+ * @author jie
+ * @date 2018-11-23
+ */
+@Getter
+@AllArgsConstructor
+public class JwtUser implements UserDetails {
+
+    @JsonIgnore
+    private final Long id;
+
+    private final String username;
+
+    @JsonIgnore
+    private final String password;
+
+    private final String avatar;
+
+    private final String email;
+
+    @JsonIgnore
+    private final Collection<? extends GrantedAuthority> authorities;
+
+    private final boolean enabled;
+
+    @JsonIgnore
+    private final Date lastPasswordResetDate;
+
+    @JsonIgnore
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @JsonIgnore
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @JsonIgnore
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @JsonIgnore
+    @Override
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    /**
+     * 在我们保存权限的时候加上了前缀ROLE_，因此在这里需要处理下数据
+     * @return
+     */
+    public Collection getRoles() {
+        Set<String> roles = new LinkedHashSet<>();
+        for (GrantedAuthority authority : authorities) {
+            roles.add(authority.getAuthority().substring(5));
+        }
+        return roles;
+    }
+}

src/main/java/me/zhengjie/core/service/JwtUserDetailsService.java

+package me.zhengjie.core.service;
+
+import me.zhengjie.common.exception.EntityNotFoundException;
+import me.zhengjie.common.utils.ValidationUtil;
+import me.zhengjie.core.security.JwtUser;
+import me.zhengjie.system.domain.Permission;
+import me.zhengjie.system.domain.Role;
+import me.zhengjie.system.domain.User;
+import me.zhengjie.system.repository.PermissionRepository;
+import me.zhengjie.system.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.CacheConfig;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * @author jie
+ * @date 2018-11-22
+ */
+@Service
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
+public class JwtUserDetailsService implements UserDetailsService {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private PermissionRepository permissionRepository;
+
+    @Override
+    public UserDetails loadUserByUsername(String username){
+
+        User user = null;
+        if(ValidationUtil.isEmail(username)){
+            user = userRepository.findByEmail(username);
+        } else {
+            user = userRepository.findByUsername(username);
+        }
+
+        if (user == null) {
+            throw new EntityNotFoundException(User.class, "name", username);
+        } else {
+            return create(user);
+        }
+    }
+
+    public UserDetails create(User user) {
+        return new JwtUser(
+                user.getId(),
+                user.getUsername(),
+                user.getPassword(),
+                user.getAvatar(),
+                user.getEmail(),
+                mapToGrantedAuthorities(user.getRoles(),permissionRepository),
+                user.getEnabled(),
+                user.getLastPasswordResetTime()
+        );
+    }
+
+    private static List<GrantedAuthority> mapToGrantedAuthorities(Set<Role> roles,PermissionRepository permissionRepository) {
+
+        Set<Permission> permissions = new HashSet<>();
+        for (Role role : roles) {
+            Set<Role> roleSet = new HashSet<>();
+            roleSet.add(role);
+            permissions.addAll(permissionRepository.findByRoles(roleSet));
+        }
+
+        return permissions.stream()
+                .map(permission -> new SimpleGrantedAuthority("ROLE_"+permission.getName()))
+                .collect(Collectors.toList());
+    }
+}

src/main/java/me/zhengjie/core/utils/EncryptUtils.java

+package me.zhengjie.core.utils;
+
+import org.springframework.util.DigestUtils;
+
+/**
+ * 加密
+ * @author jie
+ * @date 2018-11-23
+ */
+public class EncryptUtils {
+
+    /**
+     * 密码加密
+     * @param password
+     * @return
+     */
+    public static String encryptPassword(String password){
+        return  DigestUtils.md5DigestAsHex(password.getBytes());
+    }
+
+    public static void main(String[] args) {
+        System.out.println(encryptPassword("e10adc3949ba59abbe56e057f20f883e"));
+    }
+}

src/main/java/me/zhengjie/core/utils/JwtTokenUtil.java

+package me.zhengjie.core.utils;
+
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.impl.DefaultClock;
+import me.zhengjie.common.exception.BadRequestException;
+import me.zhengjie.core.security.JwtUser;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AccountExpiredException;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import javax.servlet.http.HttpServletRequest;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+import static org.springframework.http.HttpStatus.UNAUTHORIZED;
+
+@Component
+public class JwtTokenUtil implements Serializable {
+
+    static final String CLAIM_KEY_USERNAME = "sub";
+    static final String CLAIM_KEY_CREATED = "iat";
+    private static final long serialVersionUID = -3301605591108950415L;
+    private Clock clock = DefaultClock.INSTANCE;
+
+    @Value("${jwt.secret}")
+    private String secret;
+
+    @Value("${jwt.expiration}")
+    private Long expiration;
+
+    @Value("${jwt.header}")
+    private String tokenHeader;
+
+    public String getUsernameFromToken(String token) {
+        return getClaimFromToken(token, Claims::getSubject);
+    }
+
+    public Date getIssuedAtDateFromToken(String token) {
+        return getClaimFromToken(token, Claims::getIssuedAt);
+    }
+
+    public Date getExpirationDateFromToken(String token) {
+        return getClaimFromToken(token, Claims::getExpiration);
+    }
+
+    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
+        final Claims claims = getAllClaimsFromToken(token);
+        return claimsResolver.apply(claims);
+    }
+
+    private Claims getAllClaimsFromToken(String token) {
+        return Jwts.parser()
+                .setSigningKey(secret)
+                .parseClaimsJws(token)
+                .getBody();
+    }
+
+    private Boolean isTokenExpired(String token) {
+        final Date expiration = getExpirationDateFromToken(token);
+        return expiration.before(clock.now());
+    }
+
+    private Boolean isCreatedBeforeLastPasswordReset(Date created, Date lastPasswordReset) {
+        return (lastPasswordReset != null && created.before(lastPasswordReset));
+    }
+
+    private Boolean ignoreTokenExpiration(String token) {
+        // here you specify tokens, for that the expiration is ignored
+        return false;
+    }
+
+    public String generateToken(UserDetails userDetails) {
+        Map<String, Object> claims = new HashMap<>();
+        return doGenerateToken(claims, userDetails.getUsername());
+    }
+
+    private String doGenerateToken(Map<String, Object> claims, String subject) {
+        final Date createdDate = clock.now();
+        final Date expirationDate = calculateExpirationDate(createdDate);
+
+        return Jwts.builder()
+                .setClaims(claims)
+                .setSubject(subject)
+                .setIssuedAt(createdDate)
+                .setExpiration(expirationDate)
+                .signWith(SignatureAlgorithm.HS512, secret)
+                .compact();
+    }
+
+    public Boolean canTokenBeRefreshed(String token, Date lastPasswordReset) {
+        final Date created = getIssuedAtDateFromToken(token);
+        return !isCreatedBeforeLastPasswordReset(created, lastPasswordReset)
+                && (!isTokenExpired(token) || ignoreTokenExpiration(token));
+    }
+
+    public String refreshToken(String token) {
+        final Date createdDate = clock.now();
+        final Date expirationDate = calculateExpirationDate(createdDate);
+
+        final Claims claims = getAllClaimsFromToken(token);
+        claims.setIssuedAt(createdDate);
+        claims.setExpiration(expirationDate);
+
+        return Jwts.builder()
+                .setClaims(claims)
+                .signWith(SignatureAlgorithm.HS512, secret)
+                .compact();
+    }
+
+    public Boolean validateToken(String token, UserDetails userDetails) {
+        JwtUser user = (JwtUser) userDetails;
+        final String username = getUsernameFromToken(token);
+        final Date created = getIssuedAtDateFromToken(token);
+        //final Date expiration = getExpirationDateFromToken(token);
+        return (
+                username.equals(user.getUsername())
+                        && !isTokenExpired(token)
+                        && !isCreatedBeforeLastPasswordReset(created, user.getLastPasswordResetDate())
+        );
+    }
+    public  String getUserName(HttpServletRequest request){
+
+        String authToken = request.getHeader(tokenHeader);
+
+        if(StringUtils.isEmpty(authToken)||authToken.length()<7){
+            throw new AccountExpiredException("令牌已过期或无效");
+        }
+
+        final String token = authToken.substring(7);
+        String username = null;
+        try {
+            username = getUsernameFromToken(token);
+        } catch (ExpiredJwtException e){
+            throw new AccountExpiredException("令牌已过期或无效");
+        }
+
+        if(StringUtils.isEmpty(username)){
+            throw new AccountExpiredException("令牌已过期或无效");
+        }
+
+        return username;
+    }
+
+    private Date calculateExpirationDate(Date createdDate) {
+        return new Date(createdDate.getTime() + expiration);
+    }
+}
+

src/main/java/me/zhengjie/monitor/domain/Logging.java

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

src/main/java/me/zhengjie/monitor/domain/Visits.java

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

src/main/java/me/zhengjie/monitor/domain/vo/RedisVo.java

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

src/main/java/me/zhengjie/monitor/repository/LoggingRepository.java

+package me.zhengjie.monitor.repository;
+
+import me.zhengjie.monitor.domain.Logging;
+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;
+
+import java.util.List;
+
+/**
+ * @author jie
+ * @date 2018-11-24
+ */
+@Repository
+public interface LoggingRepository extends JpaRepository<Logging,Long>, JpaSpecificationExecutor {
+
+    /**
+     * 获取一个时间段的IP记录
+     * @param date1
+     * @param date2
+     * @return
+     */
+    @Query(value = "select count(*) FROM (select * FROM log where createTime between ?1 and ?2 GROUP BY requestIp) as s",nativeQuery = true)
+    Long findIp(String date1, String date2);
+}

src/main/java/me/zhengjie/monitor/repository/VisitsRepository.java

+package me.zhengjie.monitor.repository;
+
+import me.zhengjie.monitor.domain.Visits;
+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;
+
+import java.util.List;
+
+/**
+ * @author jie
+ * @date 2018-12-13
+ */
+@Repository
+public interface VisitsRepository extends JpaRepository<Visits,Long> {
+
+    /**
+     * findByDate
+     * @param date
+     * @return
+     */
+    Visits findByDate(String date);
+
+    /**
+     * 获得一个时间段的记录
+     * @param date1
+     * @param date2
+     * @return
+     */
+    @Query(value = "select * FROM visits where " +
+            "createTime between ?1 and ?2",nativeQuery = true)
+    List<Visits> findAllVisits(String date1, String date2);
+}