Skip to content

wangming / kzy-oss

Go to a project
Commit 1a95d4a7 by wangming
Options

初始化

1 parent 20013c09
Expand all
Inline Side-by-side
Showing with 4880 additions and 0 deletions
kzy-oss.iml 0 → 100644
This diff is collapsed. Click to expand it.
mvnw 0 → 100644
#!/bin/sh
# ----------------------------------------------------------------------------
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ----------------------------------------------------------------------------
# ----------------------------------------------------------------------------
# Maven2 Start Up Batch script
#
# Required ENV vars:
# ------------------
# JAVA_HOME - location of a JDK home dir
#
# Optional ENV vars
# -----------------
# M2_HOME - location of maven2's installed home dir
# MAVEN_OPTS - parameters passed to the Java VM when running Maven
# e.g. to debug Maven itself, use
# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
# MAVEN_SKIP_RC - flag to disable loading of mavenrc files
# ----------------------------------------------------------------------------
if [ -z "$MAVEN_SKIP_RC" ] ; then
if [ -f /etc/mavenrc ] ; then
. /etc/mavenrc
fi
if [ -f "$HOME/.mavenrc" ] ; then
. "$HOME/.mavenrc"
fi
fi
# OS specific support. $var _must_ be set to either true or false.
cygwin=false;
darwin=false;
mingw=false
case "`uname`" in
CYGWIN*) cygwin=true ;;
MINGW*) mingw=true;;
Darwin*) darwin=true
# Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
# See https://developer.apple.com/library/mac/qa/qa1170/_index.html
if [ -z "$JAVA_HOME" ]; then
if [ -x "/usr/libexec/java_home" ]; then
export JAVA_HOME="`/usr/libexec/java_home`"
else
export JAVA_HOME="/Library/Java/Home"
fi
fi
;;
esac
if [ -z "$JAVA_HOME" ] ; then
if [ -r /etc/gentoo-release ] ; then
JAVA_HOME=`java-config --jre-home`
fi
fi
if [ -z "$M2_HOME" ] ; then
## resolve links - $0 may be a link to maven's home
PRG="$0"
# need this for relative symlinks
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG="`dirname "$PRG"`/$link"
fi
done
saveddir=`pwd`
M2_HOME=`dirname "$PRG"`/..
# make it fully qualified
M2_HOME=`cd "$M2_HOME" && pwd`
cd "$saveddir"
# echo Using m2 at $M2_HOME
fi
# For Cygwin, ensure paths are in UNIX format before anything is touched
if $cygwin ; then
[ -n "$M2_HOME" ] &&
M2_HOME=`cygpath --unix "$M2_HOME"`
[ -n "$JAVA_HOME" ] &&
JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
[ -n "$CLASSPATH" ] &&
CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
fi
# For Migwn, ensure paths are in UNIX format before anything is touched
if $mingw ; then
[ -n "$M2_HOME" ] &&
M2_HOME="`(cd "$M2_HOME"; pwd)`"
[ -n "$JAVA_HOME" ] &&
JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
# TODO classpath?
fi
if [ -z "$JAVA_HOME" ]; then
javaExecutable="`which javac`"
if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
# readlink(1) is not available as standard on Solaris 10.
readLink=`which readlink`
if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
if $darwin ; then
javaHome="`dirname \"$javaExecutable\"`"
javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
else
javaExecutable="`readlink -f \"$javaExecutable\"`"
fi
javaHome="`dirname \"$javaExecutable\"`"
javaHome=`expr "$javaHome" : '\(.*\)/bin'`
JAVA_HOME="$javaHome"
export JAVA_HOME
fi
fi
fi
if [ -z "$JAVACMD" ] ; then
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
else
JAVACMD="`which java`"
fi
fi
if [ ! -x "$JAVACMD" ] ; then
echo "Error: JAVA_HOME is not defined correctly." >&2
echo " We cannot execute $JAVACMD" >&2
exit 1
fi
if [ -z "$JAVA_HOME" ] ; then
echo "Warning: JAVA_HOME environment variable is not set."
fi
CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
# traverses directory structure from process work directory to filesystem root
# first directory with .mvn subdirectory is considered project base directory
find_maven_basedir() {
if [ -z "$1" ]
then
echo "Path not specified to find_maven_basedir"
return 1
fi
basedir="$1"
wdir="$1"
while [ "$wdir" != '/' ] ; do
if [ -d "$wdir"/.mvn ] ; then
basedir=$wdir
break
fi
# workaround for JBEAP-8937 (on Solaris 10/Sparc)
if [ -d "${wdir}" ]; then
wdir=`cd "$wdir/.."; pwd`
fi
# end of workaround
done
echo "${basedir}"
}
# concatenates all lines of a file
concat_lines() {
if [ -f "$1" ]; then
echo "$(tr -s '\n' ' ' < "$1")"
fi
}
BASE_DIR=`find_maven_basedir "$(pwd)"`
if [ -z "$BASE_DIR" ]; then
exit 1;
fi
export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
echo $MAVEN_PROJECTBASEDIR
MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
# For Cygwin, switch paths to Windows format before running java
if $cygwin; then
[ -n "$M2_HOME" ] &&
M2_HOME=`cygpath --path --windows "$M2_HOME"`
[ -n "$JAVA_HOME" ] &&
JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
[ -n "$CLASSPATH" ] &&
CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
[ -n "$MAVEN_PROJECTBASEDIR" ] &&
MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
fi
WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
exec "$JAVACMD" \
$MAVEN_OPTS \
-classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
"-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
mvnw.cmd 0 → 100644
@REM ----------------------------------------------------------------------------
@REM Licensed to the Apache Software Foundation (ASF) under one
@REM or more contributor license agreements. See the NOTICE file
@REM distributed with this work for additional information
@REM regarding copyright ownership. The ASF licenses this file
@REM to you under the Apache License, Version 2.0 (the
@REM "License"); you may not use this file except in compliance
@REM with the License. You may obtain a copy of the License at
@REM
@REM http://www.apache.org/licenses/LICENSE-2.0
@REM
@REM Unless required by applicable law or agreed to in writing,
@REM software distributed under the License is distributed on an
@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@REM KIND, either express or implied. See the License for the
@REM specific language governing permissions and limitations
@REM under the License.
@REM ----------------------------------------------------------------------------
@REM ----------------------------------------------------------------------------
@REM Maven2 Start Up Batch script
@REM
@REM Required ENV vars:
@REM JAVA_HOME - location of a JDK home dir
@REM
@REM Optional ENV vars
@REM M2_HOME - location of maven2's installed home dir
@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a key stroke before ending
@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
@REM e.g. to debug Maven itself, use
@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
@REM ----------------------------------------------------------------------------
@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
@echo off
@REM enable echoing my setting MAVEN_BATCH_ECHO to 'on'
@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO%
@REM set %HOME% to equivalent of $HOME
if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
@REM Execute a user defined script before this one
if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
@REM check for pre script, once with legacy .bat ending and once with .cmd ending
if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
:skipRcPre
@setlocal
set ERROR_CODE=0
@REM To isolate internal variables from possible post scripts, we use another setlocal
@setlocal
@REM ==== START VALIDATION ====
if not "%JAVA_HOME%" == "" goto OkJHome
echo.
echo Error: JAVA_HOME not found in your environment. >&2
echo Please set the JAVA_HOME variable in your environment to match the >&2
echo location of your Java installation. >&2
echo.
goto error
:OkJHome
if exist "%JAVA_HOME%\bin\java.exe" goto init
echo.
echo Error: JAVA_HOME is set to an invalid directory. >&2
echo JAVA_HOME = "%JAVA_HOME%" >&2
echo Please set the JAVA_HOME variable in your environment to match the >&2
echo location of your Java installation. >&2
echo.
goto error
@REM ==== END VALIDATION ====
:init
@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
@REM Fallback to current working directory if not found.
set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
set EXEC_DIR=%CD%
set WDIR=%EXEC_DIR%
:findBaseDir
IF EXIST "%WDIR%"\.mvn goto baseDirFound
cd ..
IF "%WDIR%"=="%CD%" goto baseDirNotFound
set WDIR=%CD%
goto findBaseDir
:baseDirFound
set MAVEN_PROJECTBASEDIR=%WDIR%
cd "%EXEC_DIR%"
goto endDetectBaseDir
:baseDirNotFound
set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
cd "%EXEC_DIR%"
:endDetectBaseDir
IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
@setlocal EnableExtensions EnableDelayedExpansion
for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
:endReadAdditionalConfig
SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
if ERRORLEVEL 1 goto error
goto end
:error
set ERROR_CODE=1
:end
@endlocal & set ERROR_CODE=%ERROR_CODE%
if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost
@REM check for post script, once with legacy .bat ending and once with .cmd ending
if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat"
if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd"
:skipRcPost
@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
if "%MAVEN_BATCH_PAUSE%" == "on" pause
if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE%
exit /B %ERROR_CODE%
pom.xml 0 → 100644
<?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">
<modelVersion>4.0.0</modelVersion>
<groupId>kzy-oss</groupId>
<artifactId>kzy-oss</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<name>kzy-oss</name>
<description>kln OSS</description>
<inceptionYear>2018</inceptionYear>
<organization>
<name>YXVZB Technical Team-</name>
<url>http://www.yxvzb.com</url>
</organization>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-netflix</artifactId>
<version>1.3.5.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j</artifactId>
<version>1.3.7.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.8</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
<version>1.3.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.1</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.39</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency>
<dependency>
<groupId>com.qiniu</groupId>
<artifactId>qiniu-java-sdk</artifactId>
<version>[7.2.0, 7.2.99]</version>
</dependency>
<!--<dependency>-->
<!--<groupId>com.basics-feign</groupId>-->
<!--<artifactId>basicsfeign</artifactId>-->
<!--<version>1.0</version>-->
<!--</dependency>-->
</dependencies>
<profiles>
<profile>
<id>105</id>
<properties>
<package.environment>105</package.environment>
</properties>
</profile>
<profile>
<id>online</id>
<properties>
<package.environment>online</package.environment>
</properties>
<!-- 设置默认使用的环境 -->
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
</profiles>
<build>
<!-- jar包名字,{名字+环境} -->
<finalName>sj_oss_${package.environment}</finalName>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>*.xml</include>
<include>**/*.xml</include>
<include>**/application.properties</include>
<include>banner.txt</include>
</includes>
<excludes>
<exclude>generatorConfig.xml</exclude>
<exclude>mbg/*</exclude>
</excludes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources/servers/${package.environment}</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<encoding>utf-8</encoding>
<useDefaultDelimiters>true</useDefaultDelimiters>
</configuration>
</plugin>
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.5</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>
</plugins>
</build>
</project>
src/main/java/com/server/Application.java 0 → 100644
package com.server;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@SpringBootApplication
@EnableTransactionManagement
@ServletComponentScan
@MapperScan("com.server.web.common.mapper")
public class Application {
public static void main(String[] args) {
SpringApplication application = new SpringApplication(Application.class);
application.run(args);
}
}
src/main/java/com/server/common/configure/ConfigMybatis.java 0 → 100644
package com.server.common.configure;
import com.github.pagehelper.PageHelper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Properties;
/**
* Created by dell on 2017/8/22.
*/
@Configuration
public class ConfigMybatis {
@Bean
public PageHelper pageHelper() {
System.out.println("MyBatisConfiguration.pageHelper()");
PageHelper pageHelper = new PageHelper();
Properties p = new Properties();
p.setProperty("offsetAsPageNum", "true");
p.setProperty("rowBoundsWithCount", "true");
p.setProperty("reasonable", "true");
pageHelper.setProperties(p);
return pageHelper;
}
}
src/main/java/com/server/common/configure/ConfigRedisSession.java 0 → 100644
package com.server.common.configure;
import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
/**
* Created by yinbin on 2018/1/11.
* session 共享配置类，通过使用redis共享session，默认过期时间1800秒
*/
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds=1800,redisNamespace = "sj_oss")
public class ConfigRedisSession {
}
\ No newline at end of file
src/main/java/com/server/common/configure/ConfigThreadPoolExecutor.java 0 → 100644
package com.server.common.configure;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
/**
* Created by yinbin on 2018/1/11.
* 线程池配置类
*/
@Configuration
@EnableAsync
public class ConfigThreadPoolExecutor implements AsyncConfigurer {
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor taskExecutor=new ThreadPoolTaskExecutor();
taskExecutor.setCorePoolSize(5);
taskExecutor.setMaxPoolSize(20);
taskExecutor.setQueueCapacity(25);
taskExecutor.initialize();
return taskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return null;
}
}
src/main/java/com/server/common/configure/ConfigWebApp.java 0 → 100644
package com.server.common.configure;
import com.server.web.interceptor.InterceptorLocal;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
/**
* Created by yinbin on 2018/1/9.
* web相关配置类
* 只配置了拦截器配置
*/
@Configuration
public class ConfigWebApp extends WebMvcConfigurerAdapter {
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 多个拦截器组成一个拦截器链
// addPathPatterns 用于添加拦截规则
// excludePathPatterns 用户排除拦截
registry.addInterceptor(new InterceptorLocal()).addPathPatterns("/**");
super.addInterceptors(registry);
}
}
src/main/java/com/server/common/configure/ScheduleConfig.java 0 → 100644
package com.server.common.configure;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
* Created by yinbin on 2018/1/16.
* 启用此配置，任务采用多线程执行
* 不启用所有任务串行执行，即单线程执行任务
*/
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.setScheduler(taskExecutor());
}
@Bean(destroyMethod="shutdown")
public Executor taskExecutor() {
return Executors.newScheduledThreadPool(100);
}
}
src/main/java/com/server/common/filter/ApiFilter.java 0 → 100644
package com.server.common.filter;
import com.server.common.filter.util.SecretUtil;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
/**
* Created by yinbin on 2018/1/9.
* 过滤器，过滤请求，此过滤器在为对外提供api时，签名过滤器
* Order其实不起作用，请注意
*/
@Order(10)
@WebFilter(urlPatterns = "/*", filterName = "apiFilter")
public class ApiFilter implements Filter {
final static Logger logger = LogManager.getLogger(ApiFilter.class);
@Value("${rest.api.debug}")
private String isdebug="false";
@Value("${rest.api.secretkey}")
private String secretKey;
@Value("${rest.api.charset}")
private String charset;
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
logger.info("API Filter");
if(isdebug.equals("false")) {
boolean flag=SecretUtil.signByMd5(servletRequest,secretKey,charset);
if(flag){
filterChain.doFilter(servletRequest, servletResponse);
}
}else {
filterChain.doFilter(servletRequest, servletResponse);
}
}
@Override
public void destroy() {
}
}
\ No newline at end of file
src/main/java/com/server/common/filter/SessionFilter.java 0 → 100644
package com.server.common.filter;
import com.server.shiro.constants.Constants;
import com.server.shiro.constants.ErrorEnum;
import com.server.shiro.persistent.bean.SysUser;
import com.server.shiro.persistent.repository.UserRepository;
import com.server.shiro.util.CommonUtil;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.SessionKey;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.session.mgt.WebSessionKey;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
/**
* Created by yinbin on 2018/1/9.
* 过滤器，session过滤器
* Order其实不起作用，请注意
*/
@Order(2)
@WebFilter(urlPatterns = "/*", filterName = "sessionFilter")
public class SessionFilter implements Filter {
final static Logger logger = LogManager.getLogger(ApiFilter.class);
private static final String AUTHORIZATION = "Authorization";
@Autowired
private UserRepository userRepository;
@Autowired
private DefaultWebSecurityManager securityManager;
@Override
public void init(FilterConfig filterConfig) throws ServletException {
// SysUser user= (SysUser) userRepository.getByUsernameIsAndPasswordIs("admin","123456");
// logger.info("user_name is :"+user.getUsername());
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// logger.info("SessionFilter Filter");
// HttpServletResponse response= (HttpServletResponse) servletResponse;
// HttpServletRequest request = (HttpServletRequest) servletRequest;
// String url = request.getRequestURI();
// if(url.equals("/rest/login/auth") || url.equals("/rest/detection/detection") || url.equals("/rest/medicine/updatePinyin")){
// filterChain.doFilter(servletRequest,servletResponse);
// }else {
// SysUser user = getActiveUser(servletRequest, servletResponse);
// if (user != null) {
// filterChain.doFilter(servletRequest, servletResponse);
// } else {
// response.setCharacterEncoding("UTF-8");
// response.setContentType("application/json; charset=utf-8");
// response.setHeader("Content-type", "application/json;charset=UTF-8");
// PrintWriter write = response.getWriter();
// write.print(CommonUtil.errorJson(ErrorEnum.E_501));
// write.close();
// }
// }
filterChain.doFilter(servletRequest,servletResponse);
}
/**
* 根据sessionid 获取用户信息
* 根据sessionid获取shirosession，再获取用户信息
*/
public SysUser getActiveUser(ServletRequest req,ServletResponse res){
HttpServletRequest request= (HttpServletRequest) req;
HttpServletResponse response= (HttpServletResponse) res;
String sessionID = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
SessionKey key = new WebSessionKey(sessionID,request,response);
SysUser user =null;
try {
Session se = securityManager.getSession(key);
user = (SysUser) se.getAttribute(Constants.SESSION_USER_INFO);
}catch (UnknownSessionException exception){
user=null;
logger.info("Session is Unavailability,Expired or Illegal ");
}
return user;
}
@Override
public void destroy() {
}
}
\ No newline at end of file
src/main/java/com/server/common/filter/util/SecretUtil.java 0 → 100644
package com.server.common.filter.util;
import org.apache.commons.codec.digest.DigestUtils;
import javax.servlet.ServletRequest;
import java.io.UnsupportedEncodingException;
import java.util.*;
/**
* Created by yinbin on 2018/1/12.
* 签名工具
*/
public class SecretUtil {
public static boolean signByMd5(ServletRequest servletRequest,String secretKey,String charset) throws UnsupportedEncodingException {
Map<String,String> params = new HashMap<String,String>();
Map<String,String[]> requestParams = servletRequest.getParameterMap();
for (Iterator<String> iter = requestParams.keySet().iterator(); iter.hasNext();) {
String name = (String) iter.next();
String[] values = (String[]) requestParams.get(name);
String valueStr = "";
for (int i = 0; i < values.length; i++) {
valueStr = (i == values.length - 1) ? valueStr + values[i]
: valueStr + values[i] + ",";
}
//乱码解决，这段代码在出现乱码时使用
valueStr = new String(valueStr.getBytes("ISO-8859-1"), charset);
params.put(name, valueStr);
}
return rsaCheckV1(params,secretKey,charset);
}
public static boolean rsaCheckV1(Map<String, String> params, String publicKey,
String charset) {
String sign = params.get("sign");
String content = getSignCheckContentV1(params);
return rsaCheckContent(content, sign, publicKey, charset);
}
public static boolean rsaCheckContent(String content, String sign, String publicKey,
String charset) {
String sign_check= DigestUtils.md5Hex(content + publicKey);
return sign.equals(sign_check)?true:false;
}
public static String getSignCheckContentV1(Map<String, String> params) {
if (params == null) {
return null;
}
params.remove("sign");
StringBuffer content = new StringBuffer();
List<String> keys = new ArrayList<String>(params.keySet());
Collections.sort(keys);
for (int i = 0; i < keys.size(); i++) {
String key = keys.get(i);
String value = params.get(key);
content.append((i == 0 ? "" : "&") + key + "=" + value);
}
return content.toString();
}
}
src/main/java/com/server/jobs/Jobs.java 0 → 100644
package com.server.jobs;
import com.server.jobs.executor.PersonJob;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
/**
* Created by yinbin on 2018/1/10.
* 定时任务配置类
*/
//@Component
public class Jobs {
final static Logger logger = LogManager.getLogger(PersonJob.class);
@Autowired
PersonJob personJob;
public final static long ONE_Minute = 10 * 1000;
@Scheduled(fixedDelay=ONE_Minute)
public void fixedDelayJob(){
logger.info("fixedDelay执行....");
}
@Scheduled(fixedRate=ONE_Minute)
public void fixedRateJob(){
logger.info(" >>fixedRate执行....");
personJob.countPerson();
}
@Scheduled(cron="0 15 3 * * ?")
public void cronJob(){
logger.info(new Date()+" >>cron执行....");
}
}
\ No newline at end of file
src/main/java/com/server/jobs/executor/PersonJob.java 0 → 100644
package com.server.jobs.executor;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
/**
* Created by yinbin on 2018/1/10.
*/
@Component
public class PersonJob {
final static Logger logger = LogManager.getLogger(PersonJob.class);
public void countPerson(){
logger.info("定时任务执行。。。 ");
}
}
src/main/java/com/server/shiro/ConfigShiro.java 0 → 100644
package com.server.shiro;
import com.server.shiro.filter.AjaxPermissionsAuthorizationFilter;
import com.server.shiro.persistent.bean.SysUser;
import com.server.shiro.persistent.repository.UserRepository;
import com.server.shiro.realm.UserRealm;
import com.server.shiro.session.OssSessionManager;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import javax.servlet.Filter;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
@Configuration
public class ConfigShiro {
private static final Logger logger = LoggerFactory.getLogger(ConfigShiro.class);
/**
* Shiro的Web过滤器Factory 命名:shiroFilter
*/
@Bean(name = "shiroFilter")
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
//Shiro的核心安全接口,这个属性是必须的
shiroFilterFactoryBean.setSecurityManager(securityManager);
Map<String, Filter> filterMap = new LinkedHashMap<>();
filterMap.put("authc", new AjaxPermissionsAuthorizationFilter());
shiroFilterFactoryBean.setFilters(filterMap);
/*定义shiro过滤链 Map结构
* Map中key(xml中是指value值)的第一个'/'代表的路径是相对于HttpServletRequest.getContextPath()的值来的
* anon：它对应的过滤器里面是空的,什么都没做,这里.do和.jsp后面的*表示参数,比方说login.jsp?main这种
* authc：该过滤器下的页面必须验证后才能访问,它是Shiro内置的一个拦截器org.apache.shiro.web.filter.authc.FormAuthenticationFilter
*/
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
/* 过滤链定义，从上向下顺序执行，一般将 / ** 放在最为下边:这是一个坑呢，一不小心代码就不好使了;
authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问 */
filterChainDefinitionMap.put("/", "anon");
filterChainDefinitionMap.put("/updateper", "anon");//测试使用，上线删除这行
filterChainDefinitionMap.put("/rest/kzy/oss/login/auth", "anon");
filterChainDefinitionMap.put("/rest/kzy/oss/login/logout", "anon");
filterChainDefinitionMap.put("/error", "anon");
filterChainDefinitionMap.put("/**", "authc");
filterChainDefinitionMap.put("/**/**", "authc");
filterChainDefinitionMap.put("/**/**/**", "authc");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilterFactoryBean;
}
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
return authorizationAttributeSourceAdvisor;
}
/**
* 不指定名字的话，自动创建一个方法名第一个字母小写的bean
*/
@Bean
public SecurityManager securityManager() {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(userRealm());
securityManager.setSessionManager(new OssSessionManager());
return securityManager;
}
/**
* Shiro Realm 继承自AuthorizingRealm的自定义Realm,即指定Shiro验证用户登录的类为自定义的
*/
@Bean
public UserRealm userRealm() {
UserRealm userRealm = new UserRealm();
// userRealm.setCredentialsMatcher(hashedCredentialsMatcher());
return userRealm;
}
/**
* 凭证匹配器
* （由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
* 所以我们需要修改下doGetAuthenticationInfo中的代码;
* ）
* 可以扩展凭证匹配器，实现 输入密码错误次数后锁定等功能，下一次
*/
public HashedCredentialsMatcher hashedCredentialsMatcher() {
HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
//散列算法:这里使用MD5算法;
hashedCredentialsMatcher.setHashAlgorithmName("md5");
//散列的次数，比如散列两次，相当于 md5(md5(""));
hashedCredentialsMatcher.setHashIterations(1);
//storedCredentialsHexEncoded默认是true，此时用的是密码加密用的是Hex编码；false时用Base64编码
hashedCredentialsMatcher.setStoredCredentialsHexEncoded(true);
return hashedCredentialsMatcher;
}
/**
* Shiro生命周期处理器
*/
@Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
}
/**
* 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
* 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
*/
@Bean
@DependsOn({"lifecycleBeanPostProcessor"})
public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
advisorAutoProxyCreator.setProxyTargetClass(true);
return advisorAutoProxyCreator;
}
}
src/main/java/com/server/shiro/PermissionInitialize.java 0 → 100644
package com.server.shiro;
import com.server.shiro.context.PermissionManage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
* 初始化全局权限，存储在缓存里或者上下文，
* 加快鉴权速度，而不是每次读取数据库
*/
@Component
public class PermissionInitialize implements ApplicationRunner {
@Autowired
private PermissionManage permissionManager;//定义一个名字"permissionManager"的bean并且继承PermissionManage接口
@Override
public void run(ApplicationArguments applicationArguments) throws Exception {
permissionManager.initPermission();
}
}
src/main/java/com/server/shiro/constants/Constants.java 0 → 100644
package com.server.shiro.constants;
import org.springframework.beans.factory.annotation.Value;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public class Constants {
public static final String USER_PERMISSION = "application_user_permission_key";
public static final String SUCCESS_CODE = "1";
public static final String SUCCESS_MSG = "请求成功";
/**
* session中存放用户信息的key值
*/
public static final String SESSION_USER_INFO = "userInfo";
}
src/main/java/com/server/shiro/constants/ErrorEnum.java 0 → 100644
package com.server.shiro.constants;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public enum ErrorEnum {
/*
* 错误信息
* */
E_501("501", "无登录信息,请重新登陆"),
E_502("502", "权限不足"),
E_503("503", "用户名或密码不正确"),
E_504("504", "服务器内部错误");
private String errorCode;
private String errorMsg;
ErrorEnum() {
}
ErrorEnum(String errorCode, String errorMsg) {
this.errorCode = errorCode;
this.errorMsg = errorMsg;
}
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMsg() {
return errorMsg;
}
public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}
}
src/main/java/com/server/shiro/context/ApplicationContextProvider.java 0 → 100644
package com.server.shiro.context;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
@Component
public class ApplicationContextProvider implements ApplicationContextAware {
/**
* 上下文对象实例
*/
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
/**
* 获取applicationContext
* @return
*/
public ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 通过name获取 Bean.
* @param name
* @return
*/
public Object getBean(String name){
return getApplicationContext().getBean(name);
}
/**
* 通过class获取Bean.
* @param clazz
* @param <T>
* @return
*/
public <T> T getBean(Class<T> clazz){
return getApplicationContext().getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
* @param name
* @param clazz
* @param <T>
* @return
*/
public <T> T getBean(String name,Class<T> clazz){
return getApplicationContext().getBean(name, clazz);
}
}
\ No newline at end of file
src/main/java/com/server/shiro/context/CachePermissionManager.java 0 → 100644
package com.server.shiro.context;
import com.server.shiro.constants.Constants;
import com.server.shiro.persistent.bean.SysUser;
import com.server.shiro.persistent.repository.UserRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;
import java.util.List;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
@Component("permissionManager")
//@Singleton
public class CachePermissionManager implements PermissionManage {
private static final Logger logger = LoggerFactory.getLogger(CachePermissionManager.class);
@Value("${spring.application.name}")
private String APPLICATION_NAME;
@Autowired
private UserRepository userRepository;
@Autowired
private RedisTemplate redisTemplate;
@Override
public void initPermission() {
List<SysUser> users = (List<SysUser>) userRepository.findAll();
String key=APPLICATION_NAME+"_"+Constants.USER_PERMISSION;
// redisTemplate.delete(key);
// redisTemplate.opsForList().leftPushAll(key,users);
logger.info("从数据库拉取<用户-权限>对象，存储到上下文里");
}
@Override
public void reloadPermission() {
initPermission();
logger.info("更新上下文里的<用户-权限>");
}
@Override
public Object pullPermission() {
String key=APPLICATION_NAME+"_"+Constants.USER_PERMISSION;
Long size=redisTemplate.opsForList().size(key);
List<SysUser> user= (List<SysUser>) redisTemplate.opsForList().range(key,0,size);
logger.info("从上下文里取<用户-权限>对象");
return user;
}
}
src/main/java/com/server/shiro/context/ContextPermissionManager.java 0 → 100644
package com.server.shiro.context;
import com.server.shiro.constants.Constants;
import com.server.shiro.persistent.bean.SysUser;
import com.server.shiro.persistent.repository.UserRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.context.WebApplicationContext;
import java.util.List;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
//@Component("permissionManager")
//@Singleton
public class ContextPermissionManager implements PermissionManage {
private static final Logger logger = LoggerFactory.getLogger(ContextPermissionManager.class);
@Value("${spring.application.name}")
private String APPLICATION_NAME;
@Autowired
private UserRepository userRepository;
@Autowired
private WebApplicationContext webApplicationContext;
@Override
public void initPermission() {
List<SysUser> user = (List<SysUser>) userRepository.findAll();
logger.info("从数据库拉取<用户-权限>对象，存储到上下文里");
webApplicationContext.getServletContext().setAttribute(APPLICATION_NAME+"_"+Constants.USER_PERMISSION,user);
}
@Override
public void reloadPermission() {
initPermission();
logger.info("更新上下文里的<用户-权限>");
}
@Override
public Object pullPermission() {
Object users_permission=webApplicationContext.getServletContext().getAttribute(APPLICATION_NAME+"_"+Constants.USER_PERMISSION);
logger.info("从上下文里取<用户-权限>对象");
return users_permission;
}
}
src/main/java/com/server/shiro/context/PermissionManage.java 0 → 100644
package com.server.shiro.context;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:动态获取权限和更新权限接口
*/
public interface PermissionManage {
//初始化全局权限
void initPermission();
//更新全局权限，例如在管理平台修改了用户角色，权限，资源希望及时生效时
void reloadPermission();
//获取当前系统全局权限，而不是初始化从数据库获取
Object pullPermission();
}
src/main/java/com/server/shiro/exception/AccountErrorException.java 0 → 100644
package com.server.shiro.exception;
import org.apache.shiro.authc.AuthenticationException;
/**
* Created by yinbinhome@163.com on 2018/2/24.
* description:
* 自定义异常类，用户名或者密码错误时抛出此异常，
* 不做用户存在或者不存在的错误判断
*/
public class AccountErrorException extends AuthenticationException {
public AccountErrorException(){
super();
}
public AccountErrorException(String message){
super(message);
}
}
src/main/java/com/server/shiro/exception/GlobalExceptionHandler.java 0 → 100644
package com.server.shiro.exception;
import com.alibaba.fastjson.JSONObject;
import com.server.shiro.constants.ErrorEnum;
import com.server.shiro.util.CommonUtil;
import org.apache.shiro.authz.UnauthenticatedException;
import org.apache.shiro.authz.UnauthorizedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
private Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
@ExceptionHandler(value = Exception.class)
public JSONObject defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception {
String errorPosition = "";
//如果错误堆栈信息存在
if (e.getStackTrace().length > 0) {
StackTraceElement element = e.getStackTrace()[0];
String fileName = element.getFileName() == null ? "未找到错误文件" : element.getFileName();
int lineNumber = element.getLineNumber();
errorPosition = fileName + ":" + lineNumber;
}
JSONObject jsonObject = new JSONObject();
jsonObject.put("returnCode", ErrorEnum.E_504.getErrorCode());
jsonObject.put("returnMsg", ErrorEnum.E_504.getErrorMsg());
JSONObject errorObject = new JSONObject();
errorObject.put("errorLocation", e.toString() + " 错误位置:" + errorPosition);
jsonObject.put("returnData", errorObject);
logger.error("异常", e);
return jsonObject;
}
/**
* 权限不足报错拦截
*
* @return
* @throws Exception
*/
@ExceptionHandler(UnauthorizedException.class)
public JSONObject unauthorizedExceptionHandler() throws Exception {
return CommonUtil.errorJson(ErrorEnum.E_502);
}
/**
* 未登录报错拦截
* 在请求需要权限的接口,而连登录都还没登录的时候,会报此错
*
* @return
* @throws Exception
*/
@ExceptionHandler(UnauthenticatedException.class)
public JSONObject unauthenticatedHandler() throws Exception {
return CommonUtil.errorJson(ErrorEnum.E_501);
}
/**
* GET/POST请求方法错误的拦截器
* 因为开发时可能比较常见,而且发生在进入controller之前,上面的拦截器拦截不到这个错误
* 所以定义了这个拦截器
*
* @return
* @throws Exception
*/
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public JSONObject httpRequestMethodHandler() throws Exception {
return CommonUtil.errorJson(ErrorEnum.E_501);
}
/**
*用户名密码不匹配时抛出的异常
* @return
* @throws Exception
*/
@ExceptionHandler(AccountErrorException.class)
public JSONObject accountErrorHandler() throws Exception {
return CommonUtil.errorJson(ErrorEnum.E_503);
}
}
src/main/java/com/server/shiro/filter/AjaxPermissionsAuthorizationFilter.java 0 → 100644
package com.server.shiro.filter;
import com.alibaba.fastjson.JSONObject;
import com.server.shiro.constants.ErrorEnum;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public class AjaxPermissionsAuthorizationFilter extends FormAuthenticationFilter {
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
JSONObject jsonObject = new JSONObject();
jsonObject.put("returnCode", ErrorEnum.E_501.getErrorCode());
jsonObject.put("returnMsg", ErrorEnum.E_501.getErrorMsg());
PrintWriter out = null;
HttpServletResponse res = (HttpServletResponse) response;
try {
res.setCharacterEncoding("UTF-8");
res.setContentType("application/json");
out = response.getWriter();
out.println(jsonObject);
} catch (Exception e) {
} finally {
if (null != out) {
out.flush();
out.close();
}
}
return false;
}
@Bean
public FilterRegistrationBean registration(AjaxPermissionsAuthorizationFilter filter) {
FilterRegistrationBean registration = new FilterRegistrationBean(filter);
registration.setEnabled(false);
return registration;
}
}
src/main/java/com/server/shiro/persistent/bean/MenuModel.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.util.List;
import java.util.Map;
/**
* Created by yinbinhome@163.com on 2018/3/1.
* description:
*/
public class MenuModel {
private String name;
private Long weight;
private List<Map<String,String>> menus;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Map<String, String>> getMenus() {
return menus;
}
public void setMenus(List<Map<String, String>> menus) {
this.menus = menus;
}
public Long getWeight() {
return weight;
}
public void setWeight(Long weight) {
this.weight = weight;
}
}
src/main/java/com/server/shiro/persistent/bean/SysMenu.java 0 → 100644
package com.server.shiro.persistent.bean;
import javax.persistence.*;
import java.io.Serializable;
import java.util.List;
/**
* 模块-文金龙
*/
@Entity
@Table(name = "sys_menu")
public class SysMenu implements Serializable {
@Id
@GeneratedValue
@Column(name = "id")
private Long id;
/**
* 菜单，vue的路由地址
*/
@Column(name = "menu_code")
private String menuCode;
/**
* 菜单名字，前台显示用
*/
@Column(name = "menu_name")
private String menuName;
/**
* 菜单地址
*/
@Column(name = "menu_url")
private String menuUrl;
/**
* null
*/
@Column(name = "remarks")
private String remarks;
/**
* null
*/
@Column(name = "status")
private Long status;
@Column(name="weight")
private Long weight;
@Column(name="level")
private Long level;
@Column(name="parentid")
private Long parentid;
@Transient
private List<SysMenu> subMenu;
public Long getLevel() {
return level;
}
public void setLevel(Long level) {
this.level = level;
}
public Long getParentid() {
return parentid;
}
public void setParentid(Long parentid) {
this.parentid = parentid;
}
public Long getWeight() {
return weight;
}
public void setWeight(Long weight) {
this.weight = weight;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getMenuCode() {
return menuCode;
}
public void setMenuCode(String menuCode) {
this.menuCode = menuCode;
}
public String getMenuName() {
return menuName;
}
public void setMenuName(String menuName) {
this.menuName = menuName;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
public Long getStatus() {
return status;
}
public void setStatus(Long status) {
this.status = status;
}
public List<SysMenu> getSubMenu() {
return subMenu;
}
public void setSubMenu(List<SysMenu> subMenu) {
this.subMenu = subMenu;
}
public String getMenuUrl() {
return menuUrl;
}
public void setMenuUrl(String menuUrl) {
this.menuUrl = menuUrl;
}
}
src/main/java/com/server/shiro/persistent/bean/SysMenuQuery.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.io.Serializable;
/**
* Created by dell on 2018/3/13.
*/
public class SysMenuQuery implements Serializable {
/**
* 菜单编码
*/
private String menuCode;
/**
* 菜单名字
*/
private String menuName;
/**
* 是否有效 1有效 2无效
*/
private String status;
public SysMenuQuery(){
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getMenuCode() {
return menuCode;
}
public void setMenuCode(String menuCode) {
this.menuCode = menuCode;
}
public String getMenuName() {
return menuName;
}
public void setMenuName(String menuName) {
this.menuName = menuName;
}
}
src/main/java/com/server/shiro/persistent/bean/SysPermission.java 0 → 100644
package com.server.shiro.persistent.bean;
import javax.persistence.*;
import java.io.Serializable;
/**
* 资源表 - 刘志强
*/
@Entity
@Table(name = "sys_permission")
public class SysPermission implements Serializable {
@Id
@GeneratedValue
@Column(name = "id")
private long id;
/**
* 权限的代码/通配符,对应代码中@RequiresPermissions 的value
*/
@Column(name = "permission_code")
private String permissionCode;
/**
* 本权限的中文释义
*/
@Column(name = "permission_name")
private String permissionName;
/**
* null
*/
@Column(name = "remarks")
private String remarks;
/**
* 是否本菜单必选权限, 1.必选 2非必选 通常是"列表"权限是必选
*/
@Column(name = "status")
private Long status;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getPermissionCode() {
return permissionCode;
}
public void setPermissionCode(String permissionCode) {
this.permissionCode = permissionCode;
}
public String getPermissionName() {
return permissionName;
}
public void setPermissionName(String permissionName) {
this.permissionName = permissionName;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
public Long getStatus() {
return status;
}
public void setStatus(Long status) {
this.status = status;
}
@Override
public boolean equals(Object obj) {
SysPermission p=(SysPermission)obj;
if (this == obj)
return true;
if (obj == null)
return false;
return p.getPermissionCode().equals(this.getPermissionCode());
}
}
src/main/java/com/server/shiro/persistent/bean/SysPermissionQuery.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.io.Serializable;
/**
* Created by dell on 2018/3/13.
*/
public class SysPermissionQuery implements Serializable {
/**
* 权限的代码/通配符,对应代码中@RequiresPermissions 的value
*/
private String permissionCode;
/**
* 本权限的中文释义
*/
private String permissionName;
/**
* 是否本菜单必选权限, 1.必选 2非必选 通常是"列表"权限是必选
*/
private String status;
public SysPermissionQuery(){
}
public String getPermissionCode() {
return permissionCode;
}
public void setPermissionCode(String permissionCode) {
this.permissionCode = permissionCode;
}
public String getPermissionName() {
return permissionName;
}
public void setPermissionName(String permissionName) {
this.permissionName = permissionName;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
src/main/java/com/server/shiro/persistent/bean/SysRole.java 0 → 100644
package com.server.shiro.persistent.bean;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Set;
/**
* 角色-文金龙
*/
@Entity
@Table(name = "sys_role")
public class SysRole implements Serializable {
@Id
@GeneratedValue
@Column(name = "id")
private long id;
/**
* 角色编码
*/
@Column(name = "role_code")
private String roleCode;
/**
* 角色名字
*/
@Column(name = "role_name")
private String roleName;
/**
* 角色备注
*/
@Column(name = "remarks")
private String remarks;
/**
* null
*/
@Column(name = "create_time")
private java.sql.Timestamp createTime;
/**
* null
*/
@Column(name = "update_time")
private java.sql.Timestamp updateTime;
/**
* 是否有效 1有效 2无效
*/
@Column(name = "status")
private String status;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "sys_role_rule",
joinColumns = { @JoinColumn(name = "sys_role_id",referencedColumnName="id") },
inverseJoinColumns = {@JoinColumn(name = "rule_id",referencedColumnName="id") })
private Set<SysRule> rules;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getRoleCode() {
return roleCode;
}
public void setRoleCode(String roleCode) {
this.roleCode = roleCode;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
public java.sql.Timestamp getCreateTime() {
return createTime;
}
public void setCreateTime(java.sql.Timestamp createTime) {
this.createTime = createTime;
}
public java.sql.Timestamp getUpdateTime() {
return updateTime;
}
public void setUpdateTime(java.sql.Timestamp updateTime) {
this.updateTime = updateTime;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Set<SysRule> getRules() {
return rules;
}
public void setRules(Set<SysRule> rules) {
this.rules = rules;
}
}
src/main/java/com/server/shiro/persistent/bean/SysRoleQuery.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.io.Serializable;
/**
* Created by dell on 2018/3/13.
*/
public class SysRoleQuery implements Serializable {
/**
* 角色编码
*/
private String roleCode;
/**
* 角色名字
*/
private String roleName;
/**
* 是否有效 1有效 2无效
*/
private String status;
public SysRoleQuery(){
}
public String getRoleCode() {
return roleCode;
}
public void setRoleCode(String roleCode) {
this.roleCode = roleCode;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
src/main/java/com/server/shiro/persistent/bean/SysRule.java 0 → 100644
package com.server.shiro.persistent.bean;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Set;
/**
* 权限表 - 刘志强
*/
@Entity
@Table(name = "sys_rule")
public class SysRule implements Serializable {
@Id
@GeneratedValue
@Column(name = "id")
private long id;
/**
* 权限编码
*/
@Column(name = "rule_code")
private String ruleCode;
/**
* 权限名字
*/
@Column(name = "rule_name")
private String ruleName;
/**
* 权限备注
*/
@Column(name = "remarks")
private String remarks;
/**
* null
*/
@Column(name = "create_time")
private java.sql.Timestamp createTime;
/**
* null
*/
@Column(name = "update_time")
private java.sql.Timestamp updateTime;
/**
* 是否有效 1有效 2无效
*/
@Column(name = "status")
private String status;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "sys_rule_permissions",
joinColumns = { @JoinColumn(name = "sys_rule_id",referencedColumnName="id") },
inverseJoinColumns = {@JoinColumn(name = "permissions_id",referencedColumnName="id") })
private Set<SysPermission> permissions;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getRuleCode() {
return ruleCode;
}
public void setRuleCode(String ruleCode) {
this.ruleCode = ruleCode;
}
public String getRuleName() {
return ruleName;
}
public void setRuleName(String ruleName) {
this.ruleName = ruleName;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
public java.sql.Timestamp getCreateTime() {
return createTime;
}
public void setCreateTime(java.sql.Timestamp createTime) {
this.createTime = createTime;
}
public java.sql.Timestamp getUpdateTime() {
return updateTime;
}
public void setUpdateTime(java.sql.Timestamp updateTime) {
this.updateTime = updateTime;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Set<SysPermission> getPermissions() {
return permissions;
}
public void setPermissions(Set<SysPermission> permissions) {
this.permissions = permissions;
}
}
src/main/java/com/server/shiro/persistent/bean/SysRuleQuery.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.io.Serializable;
/**
* Created by dell on 2018/3/13.
*/
public class SysRuleQuery implements Serializable {
/**
* 权限编码
*/
private String ruleCode;
/**
* 权限名字
*/
private String ruleName;
/**
* 是否有效 1有效 2无效
*/
private String status;
public SysRuleQuery(){
}
public String getRuleCode() {
return ruleCode;
}
public void setRuleCode(String ruleCode) {
this.ruleCode = ruleCode;
}
public String getRuleName() {
return ruleName;
}
public void setRuleName(String ruleName) {
this.ruleName = ruleName;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
src/main/java/com/server/shiro/persistent/bean/SysUser.java 0 → 100644
package com.server.shiro.persistent.bean;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.Set;
@Entity
@Table(name = "sys_user")
public class SysUser implements Serializable {
@Id
@GeneratedValue
@Column(name = "id")
private long id;
/**
* 用户名
*/
@Column(name = "username")
private String username;
/**
* 真实姓名
*/
@Column(name = "real_name")
private String realname;
/**
* 手机号
*/
@Column(name = "phone")
private String phone;
/**
* 密码
*/
@Column(name = "password")
private String password;
/**
* 备注
*/
@Column(name = "remarks")
private String remarks;
/**
* 创建时间
*/
@Column(name = "create_time")
private Date createTime;
/**
* 修改时间
*/
@Column(name = "update_time")
private Date updateTime;
/**
* 是否有效 1有效 2无效
*/
@Column(name = "status")
private Long status;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name="sys_user_menus",//中间表的名称
joinColumns={@JoinColumn(name="sys_user_id",referencedColumnName="id")},//中间表PRODUCT_ID字段关联PRODUCT的ID
inverseJoinColumns={@JoinColumn(name="menus_id",referencedColumnName="id")})//中间表CATEGORY_ID字段关联CATEGORY的ID
private Set<SysMenu> menus;
@ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)//级联保存、更新、删除、刷新;延迟加载
@JoinTable(name = "sys_user_roles",
joinColumns = { @JoinColumn(name = "sys_user_id",referencedColumnName="id") },
inverseJoinColumns = {@JoinColumn(name = "roles_id",referencedColumnName="id") })
private Set<SysRole> roles;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public Long getStatus() {
return status;
}
public void setStatus(Long status) {
this.status = status;
}
public Set<SysMenu> getMenus() {
return menus;
}
public void setMenus(Set<SysMenu> menus) {
this.menus = menus;
}
public Set<SysRole> getRoles() {
return roles;
}
public void setRoles(Set<SysRole> roles) {
this.roles = roles;
}
public void setRealname(String realname) {
this.realname = realname;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getRealname() {
return realname;
}
public String getPhone() {
return phone;
}
}
src/main/java/com/server/shiro/persistent/bean/SysUserQuery.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.io.Serializable;
/**
* Created by dell on 2018/3/13.
*/
public class SysUserQuery implements Serializable {
/**
* 权限编码
*/
private String username;
/**
* 权限名字
*/
private String realname;
/**
* 是否有效 1有效 2无效
*/
private String phone;
private Long status;
public SysUserQuery(){
}
public String getUsername() {
return username;
}
public String getRealname() {
return realname;
}
public String getPhone() {
return phone;
}
public Long getStatus() {
return status;
}
public void setUsername(String username) {
this.username = username;
}
public void setRealname(String realname) {
this.realname = realname;
}
public void setPhone(String phone) {
this.phone = phone;
}
public void setStatus(Long status) {
this.status = status;
}
}
src/main/java/com/server/shiro/persistent/bean/UserMenuModel.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.util.List;
import java.util.Map;
/**
* Created by yinbinhome@163.com on 2018/3/1.
* description:
*/
public class UserMenuModel {
private String name;
private Long weight;
private List<Map<String,String>> menus;
private int isSelect;
private Long id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Map<String, String>> getMenus() {
return menus;
}
public void setMenus(List<Map<String, String>> menus) {
this.menus = menus;
}
public Long getWeight() {
return weight;
}
public void setWeight(Long weight) {
this.weight = weight;
}
public int getIsSelect() {
return isSelect;
}
public void setIsSelect(int isSelect) {
this.isSelect = isSelect;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}
src/main/java/com/server/shiro/persistent/bean/UserModel.java 0 → 100644
package com.server.shiro.persistent.bean;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by yinbinhome@163.com on 2018/2/26.
* description:
*/
public class UserModel {
private String username;
private String sessionid;
private List<MenuModel> menus;
private List<String> rules;
public String getSessionid() {
return sessionid;
}
public void setSessionid(String sessionid) {
this.sessionid = sessionid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public List<MenuModel> getMenus() {
return menus;
}
public void setMenus(List<MenuModel> menus) {
this.menus = menus;
}
public List<String> getRules() {
return rules;
}
public void setRules(List<String> rules) {
this.rules = rules;
}
}
src/main/java/com/server/shiro/persistent/repository/MenuRepository.java 0 → 100644
package com.server.shiro.persistent.repository;
import com.server.shiro.persistent.bean.SysMenu;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 模块-文金龙
*/
@Service
public interface MenuRepository extends JpaRepository<SysMenu,Long>,JpaSpecificationExecutor<SysMenu> {
List<SysMenu> findByMenuCode(String ruleCode);
List<SysMenu> findByLevel(Long level);
List<SysMenu> findByParentid(Long parentId);
}
src/main/java/com/server/shiro/persistent/repository/RoleRepository.java 0 → 100644
package com.server.shiro.persistent.repository;
import com.server.shiro.persistent.bean.SysRole;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 角色-文金龙
*/
@Service
public interface RoleRepository extends JpaRepository<SysRole,Long>,JpaSpecificationExecutor<SysRole> {
List<SysRole> findByRoleCode(String ruleCode);
}
src/main/java/com/server/shiro/persistent/repository/SysPermissionRepository.java 0 → 100644
package com.server.shiro.persistent.repository;
import com.server.shiro.persistent.bean.SysPermission;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
/**
* 资源
*/
public interface SysPermissionRepository extends JpaRepository<SysPermission,Long>,JpaSpecificationExecutor<SysPermission> {
List<SysPermission> findByPermissionCode(String permissionCode);
}
src/main/java/com/server/shiro/persistent/repository/SysRuleRepository.java 0 → 100644
package com.server.shiro.persistent.repository;
import com.server.shiro.persistent.bean.SysRule;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
/**
* 权限
*/
public interface SysRuleRepository extends JpaRepository<SysRule,Long>,JpaSpecificationExecutor<SysRule> {
List<SysRule> findByRuleCode(String ruleCode);
}
src/main/java/com/server/shiro/persistent/repository/UserRepository.java 0 → 100644
package com.server.shiro.persistent.repository;
import com.server.shiro.persistent.bean.SysMenu;
import com.server.shiro.persistent.bean.SysUser;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* Created by yinbinhome@163.com on 2018/2/22.
* description:
*/
@Service
public interface UserRepository extends JpaRepository<SysUser,Long>, JpaSpecificationExecutor<SysUser> {
//查询用户名称包含username字符串的用户对象
List<SysUser> findByUsernameContaining(String username);
//获得单个用户对象，根据username和pwd的字段匹配
SysUser getByUsernameIsAndPasswordIs(String username, String pwd);
//精确匹配username的用户对象
SysUser getByUsernameIs(String username);
}
src/main/java/com/server/shiro/persistent/service/LoginService.java 0 → 100644
package com.server.shiro.persistent.service;
import com.alibaba.fastjson.JSONObject;
import com.server.shiro.persistent.bean.SysUser;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public interface LoginService {
/**
* 登录表单提交
*
* @param jsonObject
* @return
*/
JSONObject authLogin(JSONObject jsonObject);
/**
* 根据用户名和密码查询对应的用户
*
* @param username 用户名
* @param password 密码
* @return
*/
SysUser getUser(String username, String password);
/**
* 查询当前登录用户的权限等信息
*
* @return
*/
SysUser getInfo();
/**
* 退出登录
*
* @return
*/
void logout();
}
src/main/java/com/server/shiro/persistent/service/SysRoleService.java 0 → 100644
package com.server.shiro.persistent.service;
import com.server.shiro.persistent.bean.SysMenu;
import com.server.shiro.persistent.bean.SysMenuQuery;
import com.server.shiro.persistent.bean.SysRole;
import com.server.shiro.persistent.bean.SysRoleQuery;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
public interface SysRoleService {
//角色分页
Page<SysRole> findSysRolePage(Pageable pageable, SysRoleQuery roleQuery);
//菜单分页
Page<SysMenu> findSysMenuPage(Pageable pageable, SysMenuQuery menuQuery);
}
src/main/java/com/server/shiro/persistent/service/SysRuleService.java 0 → 100644
package com.server.shiro.persistent.service;
import com.server.shiro.persistent.bean.SysPermission;
import com.server.shiro.persistent.bean.SysPermissionQuery;
import com.server.shiro.persistent.bean.SysRule;
import com.server.shiro.persistent.bean.SysRuleQuery;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
/**
* Created by dell on 2018/3/13.
*/
public interface SysRuleService {
Page<SysRule> findSysRulePage(Pageable pageable, SysRuleQuery ruleQuery);
Page<SysPermission> findSysPermissionPage(Pageable pageable, SysPermissionQuery permissionQuery);
}
src/main/java/com/server/shiro/persistent/service/UserService.java 0 → 100644
package com.server.shiro.persistent.service;
import com.alibaba.fastjson.JSONObject;
import com.server.shiro.persistent.bean.*;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public interface UserService {
List<UserMenuModel> getMenu(SysUser user,List<SysMenu> list);
List<Map> getRole(SysUser user, List<SysRole> list);
Page<SysUser> findSysUserPage(Pageable pageable, SysUserQuery userQuery);
}
src/main/java/com/server/shiro/persistent/service/impl/LoginServiceImpl.java 0 → 100644
package com.server.shiro.persistent.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.server.shiro.constants.Constants;
import com.server.shiro.persistent.bean.*;
import com.server.shiro.persistent.repository.UserRepository;
import com.server.shiro.persistent.service.LoginService;
import com.server.shiro.util.CommonUtil;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.util.*;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
@Service
public class LoginServiceImpl implements LoginService {
private Logger logger = LoggerFactory.getLogger(LoginServiceImpl.class);
@Autowired
private UserRepository userRepository;
@PersistenceContext
private EntityManager entityManager;
/**
* 登录表单提交
*
* @param jsonObject
* @return
*/
@Override
public JSONObject authLogin(JSONObject jsonObject) {
String username = jsonObject.getString("username");
String password = jsonObject.getString("password");
Subject currentUser = SecurityUtils.getSubject();
Session session = currentUser.getSession();
String sessionId = session.getId().toString();
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
currentUser.login(token);
SysUser user= (SysUser) session.getAttribute(Constants.SESSION_USER_INFO);
UserModel usermodel=getModel(user);
usermodel.setSessionid(sessionId);
return CommonUtil.loginJson(usermodel);
}
/**
* 根据用户名和密码查询对应的用户
*
* @param username 用户名
* @param password 密码
* @return
*/
@Override
public SysUser getUser(String username, String password) {
userRepository.findAll();
return userRepository.getByUsernameIsAndPasswordIs(username, password);
}
/**
* 查询当前登录用户的权限等信息
*
* @return
*/
@Override
public SysUser getInfo() {
//从session获取用户信息
Session session = SecurityUtils.getSubject().getSession();
SysUser userInfo = (SysUser) session.getAttribute(Constants.SESSION_USER_INFO);
return userInfo;
}
/**
* 退出登录
*
* @return
*/
@Override
public void logout() {
try {
Subject currentUser = SecurityUtils.getSubject();
currentUser.logout();
} catch (Exception e) {
}
}
//根据SysUser转换前端Model
public UserModel getModel(SysUser user){
UserModel model=new UserModel();
model.setUsername(user.getUsername());
List<String> rules=new ArrayList<String>();
List<MenuModel> menus=getMenus(user.getMenus());
Set<SysRole> roles = (Set<SysRole>) user.getRoles();
for(SysRole r:roles){
for(SysRule rule:r.getRules()){
rules.add(rule.getRuleCode());
}
}
model.setMenus(menus);
model.setRules(rules);
return model;
}
public List<MenuModel> getMenus(Set<SysMenu> menus){
List<MenuModel> menu_1=new ArrayList<MenuModel>();
for(SysMenu menu:menus){
if(menu.getLevel()==1){
MenuModel model=new MenuModel();
model.setWeight(menu.getWeight());
model.setName(menu.getMenuName());
List<Map<String,String>> ms=new ArrayList<Map<String,String>>();
for(SysMenu m:menus){
if(m.getParentid()==menu.getId()){
Map<String,String> map=new HashMap<String,String>();
map.put("menu_name",m.getMenuName());
map.put("menu_code",m.getMenuCode());
map.put("menu_weight",m.getWeight()+"");
map.put("menu_url",m.getMenuUrl());
ms.add(map);
}
}
model.setMenus(ms);
menu_1.add(model);
}
}
return menu_1;
}
}
src/main/java/com/server/shiro/persistent/service/impl/SysRoleServiceImpl.java 0 → 100644
package com.server.shiro.persistent.service.impl;
import com.server.shiro.persistent.bean.SysMenu;
import com.server.shiro.persistent.bean.SysMenuQuery;
import com.server.shiro.persistent.bean.SysRole;
import com.server.shiro.persistent.bean.SysRoleQuery;
import com.server.shiro.persistent.repository.MenuRepository;
import com.server.shiro.persistent.repository.RoleRepository;
import com.server.shiro.persistent.service.SysRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;
/**
* Created by dell on 2018/3/13.
*/
@Service
public class SysRoleServiceImpl implements SysRoleService {
@Autowired
RoleRepository roleRepository;
@Autowired
MenuRepository menuRepository;
@Override
public Page<SysRole> findSysRolePage(Pageable pageable, SysRoleQuery RoleQuery) {
Page<SysRole> bookPage = roleRepository.findAll(new Specification<SysRole>() {
public Predicate toPredicate(Root<SysRole> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
List<Predicate> list = new ArrayList<Predicate>();
if (StringUtils.hasText(RoleQuery.getRoleName())) {
list.add(criteriaBuilder.like(root.get("roleName").as(String.class), "%"+RoleQuery.getRoleName()+"%"));
}
if (StringUtils.hasText(RoleQuery.getRoleCode())) {
list.add(criteriaBuilder.like(root.get("roleCode").as(String.class), "%"+RoleQuery.getRoleCode()+"%"));
}
if (StringUtils.hasText(RoleQuery.getStatus())) {
list.add(criteriaBuilder.equal(root.get("status").as(String.class), RoleQuery.getStatus()));
}
Predicate[] p = new Predicate[list.size()];
return criteriaBuilder.and(list.toArray(p));
}
}, pageable);
return bookPage;
}
@Override
public Page<SysMenu> findSysMenuPage(Pageable pageable, SysMenuQuery menuQuery) {
Page<SysMenu> bookPage = menuRepository.findAll(new Specification<SysMenu>() {
public Predicate toPredicate(Root<SysMenu> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
List<Predicate> list = new ArrayList<Predicate>();
if (StringUtils.hasText(menuQuery.getMenuName())) {
list.add(criteriaBuilder.like(root.get("menuName").as(String.class), "%"+menuQuery.getMenuName()+"%"));
}
if (StringUtils.hasText(menuQuery.getMenuCode())) {
list.add(criteriaBuilder.like(root.get("menuCode").as(String.class), "%"+menuQuery.getMenuCode()+"%"));
}
if (StringUtils.hasText(menuQuery.getStatus())) {
list.add(criteriaBuilder.equal(root.get("status").as(String.class), menuQuery.getStatus()));
}
Predicate[] p = new Predicate[list.size()];
return criteriaBuilder.and(list.toArray(p));
}
}, pageable);
return bookPage;
}
}
src/main/java/com/server/shiro/persistent/service/impl/SysRuleServiceImpl.java 0 → 100644
package com.server.shiro.persistent.service.impl;
import com.server.shiro.persistent.bean.SysPermission;
import com.server.shiro.persistent.bean.SysPermissionQuery;
import com.server.shiro.persistent.bean.SysRule;
import com.server.shiro.persistent.bean.SysRuleQuery;
import com.server.shiro.persistent.repository.SysPermissionRepository;
import com.server.shiro.persistent.repository.SysRuleRepository;
import com.server.shiro.persistent.service.SysRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;
/**
* Created by dell on 2018/3/13.
*/
@Service
public class SysRuleServiceImpl implements SysRuleService {
@Autowired
SysRuleRepository ruleRepository;
@Autowired
SysPermissionRepository sysPermissionRepository;
@Override
public Page<SysRule> findSysRulePage(Pageable pageable, SysRuleQuery ruleQuery) {
Page<SysRule> bookPage = ruleRepository.findAll(new Specification<SysRule>(){
public Predicate toPredicate(Root<SysRule> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
List<Predicate> list = new ArrayList<Predicate>();
if(StringUtils.hasText(ruleQuery.getRuleName())){
list.add(criteriaBuilder.like(root.get("ruleName").as(String.class), "%"+ruleQuery.getRuleName()+"%"));
}
if(StringUtils.hasText(ruleQuery.getRuleCode())){
list.add(criteriaBuilder.like(root.get("ruleCode").as(String.class), "%"+ruleQuery.getRuleCode()+"%"));
}
if(StringUtils.hasText(ruleQuery.getStatus())){
list.add(criteriaBuilder.equal(root.get("status").as(String.class), ruleQuery.getStatus()));
}
Predicate[] p = new Predicate[list.size()];
return criteriaBuilder.and(list.toArray(p));
}
},pageable);
return bookPage;
}
@Override
public Page<SysPermission> findSysPermissionPage(Pageable pageable, SysPermissionQuery permissionQuery) {
Page<SysPermission> bookPage = sysPermissionRepository.findAll(new Specification<SysPermission>(){
public Predicate toPredicate(Root<SysPermission> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
List<Predicate> list = new ArrayList<Predicate>();
if(StringUtils.hasText(permissionQuery.getPermissionName())){
list.add(criteriaBuilder.like(root.get("permissionName").as(String.class), "%"+permissionQuery.getPermissionName()+"%"));
}
if(StringUtils.hasText(permissionQuery.getPermissionCode())){
list.add(criteriaBuilder.like(root.get("permissionCode").as(String.class), "%"+permissionQuery.getPermissionCode()+"%"));
}
if(StringUtils.hasText(permissionQuery.getStatus())){
list.add(criteriaBuilder.equal(root.get("status").as(String.class), permissionQuery.getStatus()));
}
Predicate[] p = new Predicate[list.size()];
return criteriaBuilder.and(list.toArray(p));
}
},pageable);
return bookPage;
}
}
src/main/java/com/server/shiro/persistent/service/impl/UserServiceImpl.java 0 → 100644
package com.server.shiro.persistent.service.impl;
import com.server.shiro.persistent.bean.*;
import com.server.shiro.persistent.repository.UserRepository;
import com.server.shiro.persistent.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.*;
/**
*
*/
@Service
public class UserServiceImpl implements UserService {
private Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
@Autowired
private UserRepository userRepository;
@PersistenceContext
private EntityManager entityManager;
/**
* 用户模板绑定列表
* @param user
* @param list
* @return
*/
@Override
public List<UserMenuModel> getMenu(SysUser user,List<SysMenu> list){
List<UserMenuModel> menu_1=new ArrayList<UserMenuModel>();
Set<SysMenu> menus = user.getMenus();
for(SysMenu menu:list){
if(menu.getLevel()==1){
UserMenuModel menuModel = new UserMenuModel();
menuModel.setWeight(menu.getWeight());
menuModel.setName(menu.getMenuName());
menuModel.setId(menu.getId());
menuModel.setIsSelect(0);
for(SysMenu symMenu:menus){
if(menu.getId()==symMenu.getId()){ //判断当前用户是否有次菜单
menuModel.setIsSelect(1);
break;
}
}
List<Map<String,String>> ms=new ArrayList<Map<String,String>>();
for(SysMenu m:list){ //获取二级菜单
if(m.getParentid()==menu.getId()){
Map<String,String> map=new HashMap<String,String>();
map.put("name",m.getMenuName());
map.put("id",m.getId()+"");
map.put("weight",m.getWeight()+"");
map.put("isSelect","0");
for(SysMenu symMenu:menus){
if(m.getId()==symMenu.getId()){ //判断当前用户是否有次菜单
map.put("isSelect","1");
break;
}
}
ms.add(map);
}
}
menuModel.setMenus(ms);
menu_1.add(menuModel);
}
}
return menu_1;
}
/**
* 获取用户角色列表
* @param user
* @param list
* @return
*/
@Override
public List<Map> getRole(SysUser user, List<SysRole> list){
List<Map> role_1=new ArrayList<Map>();
Set<SysRole> roles = user.getRoles();
for (SysRole r:list){
Map<String,String> map=new HashMap<String,String>();
map.put("id",r.getId()+"");
map.put("roleCode",r.getRoleCode());
map.put("roleName",r.getRoleName());
map.put("remarks",r.getRemarks());
map.put("status",r.getStatus());
map.put("isSelect","0");
for (SysRole ur:roles){
if(r.getId()==ur.getId()){
map.put("isSelect","1");
break;
}
}
role_1.add(map);
}
return role_1;
}
/**
* 用户列表
* @param pageable
* @param userQuery
* @return
*/
@Override
public Page<SysUser> findSysUserPage(Pageable pageable, SysUserQuery userQuery){
Page<SysUser> bookPage = userRepository.findAll(new Specification<SysUser>(){
public Predicate toPredicate(Root<SysUser> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
List<Predicate> list = new ArrayList<Predicate>();
if(StringUtils.hasText(userQuery.getUsername())){
list.add(criteriaBuilder.like(root.get("username").as(String.class), "%"+userQuery.getUsername()+"%"));
}
if(StringUtils.hasText(userQuery.getRealname())){
list.add(criteriaBuilder.like(root.get("realname").as(String.class), "%"+userQuery.getRealname()+"%"));
}
if(StringUtils.hasText(userQuery.getPhone())){
list.add(criteriaBuilder.like(root.get("phone").as(String.class), "%"+userQuery.getPhone()+"%"));
}
if(null !=userQuery.getStatus()){
list.add(criteriaBuilder.equal(root.get("status").as(Long.class), userQuery.getStatus()));
}
Predicate[] p = new Predicate[list.size()];
return criteriaBuilder.and(list.toArray(p));
}
},pageable);
return bookPage;
}
}
src/main/java/com/server/shiro/realm/UserRealm.java 0 → 100644
package com.server.shiro.realm;
import com.server.shiro.context.ContextPermissionManager;
import com.server.shiro.constants.Constants;
import com.server.shiro.context.PermissionManage;
import com.server.shiro.exception.AccountErrorException;
import com.server.shiro.persistent.bean.SysPermission;
import com.server.shiro.persistent.bean.SysRole;
import com.server.shiro.persistent.bean.SysRule;
import com.server.shiro.persistent.bean.SysUser;
import com.server.shiro.persistent.repository.UserRepository;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public class UserRealm extends AuthorizingRealm {
private Logger logger = LoggerFactory.getLogger(UserRealm.class);
@Autowired
private UserRepository userRepository;
@Autowired
private PermissionManage permissionManager;
/**
* 权限认证，角色和权限
* 对url的认证，当前用户有哪些URL访问的权限
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String username= (String) principals.getPrimaryPrincipal();
Set<String> ps=new HashSet<String>();
//查询用户的权限
List<SysUser> up = (List<SysUser>) permissionManager.pullPermission();
for(SysUser user:up){
if(user.getUsername().equals(username)){
Set<SysRole> roles = (Set<SysRole>) user.getRoles();
for(SysRole r:roles){
for(SysRule rule:r.getRules()){
for(SysPermission p:rule.getPermissions()){
ps.add(p.getPermissionCode());
}
}
}
}
}
//为当前用户设置角色和权限
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
authorizationInfo.addStringPermissions(ps);
return authorizationInfo;
}
/**
* 用户认证，验证用户名和密码
* 验证当前登录的Subject
* LoginController.login()方法中执行Subject.login()时 执行此方法
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
String loginName = (String) authcToken.getPrincipal();
// 获取用户密码
String password = new String((char[]) authcToken.getCredentials());
SysUser user = userRepository.getByUsernameIsAndPasswordIs(loginName, password);
// SysUser user = userRepository.getByUsernameIs(loginName);
if (user == null) {
//没找到帐号
throw new AccountErrorException();
}
//交给AuthenticatingRealm使用CredentialsMatcher进行密码匹配，如果觉得人家的不好可以自定义实现
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
user.getUsername(),
user.getPassword(),
// ByteSource.Util.bytes("salt"),
getName()
);
//session中不需要保存密码
user.setPassword("");
SecurityUtils.getSubject().getSession().setAttribute(Constants.SESSION_USER_INFO, user);
return authenticationInfo;
}
}
src/main/java/com/server/shiro/session/OssSessionManager.java 0 → 100644
package com.server.shiro.session;
import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.util.StringUtils;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;
/**
* Created by yinbinhome@163.com on 2018/2/13.
* description:
*/
public class OssSessionManager extends DefaultWebSessionManager {
private static final String AUTHORIZATION = "Authorization";
private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";
public OssSessionManager() {
super();
}
@Override
protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
//如果请求头中有 Authorization 则其值为sessionId
if (!StringUtils.isEmpty(id)) {
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
return id;
} else {
//否则按默认规则从cookie取sessionId,按默认规则生成sessionId
return super.getSessionId(request, response);
}
}
}
\ No newline at end of file
src/main/java/com/server/shiro/session/SessionRedisManage.java 0 → 100644
package com.server.shiro.session;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.SimpleSession;
import org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO;
import java.io.*;
/**
* Created by yinbinhome@163.com on 2018/2/25.
* description:
*/
public class SessionRedisManage extends EnterpriseCacheSessionDAO {
// // 创建session，保存到数据库
// @Override
// protected Serializable doCreate(Session session) {
// Serializable sessionId = super.doCreate(session);
// RedisDb.setObject(sessionId.toString().getBytes(), sessionToByte(session));
//
// return sessionId;
// }
//
// // 获取session
// @Override
// protected Session doReadSession(Serializable sessionId) {
// // 先从缓存中获取session，如果没有再去数据库中获取
// Session session = super.doReadSession(sessionId);
// if(session == null){
// byte[] bytes = RedisDb.getObject(sessionId.toString().getBytes());
// if(bytes != null && bytes.length > 0){
// session = byteToSession(bytes);
// }
// }
// return session;
// }
//
// // 更新session的最后一次访问时间
// @Override
// protected void doUpdate(Session session) {
// super.doUpdate(session);
// RedisDb.setObject(session.getId().toString().getBytes(), sessionToByte(session));
// }
//
// // 删除session
// @Override
// protected void doDelete(Session session) {
// super.doDelete(session);
// RedisDb.delString(session.getId() + "");
// }
//
// // 把session对象转化为byte保存到redis中
// public byte[] sessionToByte(Session session){
// ByteArrayOutputStream bo = new ByteArrayOutputStream();
// byte[] bytes = null;
// try {
// ObjectOutputStream oo = new ObjectOutputStream(bo);
// oo.writeObject(session);
// bytes = bo.toByteArray();
// } catch (IOException e) {
// e.printStackTrace();
// }
// return bytes;
// }
//
// // 把byte还原为session
// public Session byteToSession(byte[] bytes){
// ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
// ObjectInputStream in;
// SimpleSession session = null;
// try {
// in = new ObjectInputStream(bi);
// session = (SimpleSession) in.readObject();
// } catch (ClassNotFoundException e) {
// e.printStackTrace();
// } catch (IOException e) {
// e.printStackTrace();
// }
//
// return session;
// }
}
src/main/java/com/server/shiro/util/CommonUtil.java 0 → 100644
package com.server.shiro.util;
import com.alibaba.fastjson.JSONObject;
import com.server.shiro.constants.Constants;
import com.server.shiro.constants.ErrorEnum;
import com.server.shiro.persistent.bean.SysUser;
import com.server.shiro.persistent.bean.UserModel;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.List;
/**
* Created by yinbinhome@163.com on 2018/2/23.
* description:
*/
public class CommonUtil {
/**
* 返回一个returnData为空对象的成功消息的json
*
* @return
*/
public static JSONObject successJson() {
return successJson(new JSONObject());
}
/**
* 返回一个返回码为100的json
*
* @param returnData json里的主要内容
* @return
*/
public static JSONObject successJson(Object returnData) {
JSONObject resultJson = new JSONObject();
resultJson.put("returnCode", Constants.SUCCESS_CODE);
resultJson.put("returnMsg", Constants.SUCCESS_MSG);
resultJson.put("returnData", returnData);
return resultJson;
}
/**
* 返回错误信息JSON
*
* @param errorEnum 错误码的errorEnum
* @return
*/
public static JSONObject errorJson(ErrorEnum errorEnum) {
JSONObject resultJson = new JSONObject();
resultJson.put("returnCode", errorEnum.getErrorCode());
resultJson.put("returnMsg", errorEnum.getErrorMsg());
resultJson.put("returnData", new JSONObject());
return resultJson;
}
/**
* 查询分页结果后的封装工具方法
*
* @param requestJson 请求参数json,此json在之前调用fillPageParam 方法时,已经将pageRow放入
* @param list 查询分页对象list
* @param totalCount 查询出记录的总条数
*/
public static JSONObject successPage(final JSONObject requestJson, List<JSONObject> list, int totalCount) {
int pageRow = requestJson.getIntValue("pageRow");
int totalPage = getPageCounts(pageRow, totalCount);
JSONObject result = successJson();
JSONObject returnData = new JSONObject();
returnData.put("list", list);
returnData.put("totalCount", totalCount);
returnData.put("totalPage", totalPage);
result.put("returnData", returnData);
return result;
}
/**
* 查询分页结果后的封装工具方法
*
* @param list 查询分页对象list
*/
public static JSONObject successPage(List<JSONObject> list) {
JSONObject result = successJson();
JSONObject returnData = new JSONObject();
returnData.put("list", list);
result.put("returnData", returnData);
return result;
}
/**
* 获取总页数
*
* @param pageRow 每页行数
* @param itemCount 结果的总条数
* @return
*/
public static int getPageCounts(int pageRow, int itemCount) {
if (itemCount == 0) {
return 1;
}
return itemCount % pageRow > 0 ?
itemCount / pageRow + 1 :
itemCount / pageRow;
}
/**
* 将request参数值转为json
*
* @param request
* @return
*/
public static JSONObject request2Json(HttpServletRequest request) {
JSONObject requestJson = new JSONObject();
Enumeration paramNames = request.getParameterNames();
while (paramNames.hasMoreElements()) {
String paramName = (String) paramNames.nextElement();
String[] pv = request.getParameterValues(paramName);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < pv.length; i++) {
if (pv[i].length() > 0) {
if (i > 0) {
sb.append(",");
}
sb.append(pv[i]);
}
}
requestJson.put(paramName, sb.toString());
}
return requestJson;
}
/**
* 在分页查询之前,为查询条件里加上分页参数
*
* @param paramObject 查询条件json
* @param defaultPageRow 默认的每页条数,即前端不传pageRow参数时的每页条数
*/
public static void fillPageParam(final JSONObject paramObject, int defaultPageRow) {
int pageNum = paramObject.getIntValue("pageNum");
pageNum = pageNum == 0 ? 1 : pageNum;
int pageRow = paramObject.getIntValue("pageRow");
pageRow = pageRow == 0 ? defaultPageRow : pageRow;
paramObject.put("offSet", (pageNum - 1) * pageRow);
paramObject.put("pageRow", pageRow);
paramObject.put("pageNum", pageNum);
//删除此参数,防止前端传了这个参数,pageHelper分页插件检测到之后,拦截导致SQL错误
paramObject.remove("pageSize");
}
/**
* 分页查询之前的处理参数
* 没有传pageRow参数时,默认每页10条.
*
* @param paramObject
*/
public static void fillPageParam(final JSONObject paramObject) {
fillPageParam(paramObject, 10);
}
public static JSONObject loginJson(UserModel user){
JSONObject resultJson = new JSONObject();
resultJson.put("code", Constants.SUCCESS_CODE);
resultJson.put("message", Constants.SUCCESS_MSG);
resultJson.put("status", "1");
JSONObject data=new JSONObject();
data.put("usermodel",user);
resultJson.put("returnData", data);
return resultJson;
}
}
src/main/java/com/server/utils/DateUtils.java 0 → 100644
package com.server.utils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
/**
*
* @author ZMS
*
*/
public class DateUtils {
public static long MINUTE_PER_HOUR = 60; // 一个小时有多少分钟
public static long MINUTE_PER_DAY = 1440; // 一天有多少分钟
public static long HOUT_PER_DAY = 24; // 一天有多少小时
public static long SECOND_PER_MINUTE = 60; // 一分钟有多少秒
public static long SECOND_PER_HOUR = 3600; // 一个小时有多少秒
public static long SECOND_PER_DAY = 86400; // 一天有多少秒
public static long MILLIS_PER_SECOND = 1000; // 一秒钟有多少毫秒
public static long MILLIS_PER_MINUTE = 60000; // 一分钟有多少毫秒
public static long MILLIS_PER_HOUR = 3600000; // 一个小时有多少毫秒
public static long MILLIS_PER_DAY = 86400000; // 一天有多少毫秒
public static long NANO_PER_MILLIS = 1000000; // 一毫秒有多少纳秒
/**
* formate date
*
* @param formatter
* @param time
* @return
*/
public static String format(String formatter, long time) {
return new SimpleDateFormat(formatter).format(new Date(time));
}
public static String format(String formatter, Date time) {
return new SimpleDateFormat(formatter).format(time);
}
public static String format(Date time) {
return new SimpleDateFormat("yyyy-MM-dd").format(time);
}
/**
* rawoffset
*
* @param time
* @return
*/
public static long getRawOffsetMils(long time) {
return time + TimeZone.getDefault().getRawOffset();
}
/**
* 拆分时间
*
* @param time
* @return
*/
public static long[] splitTime(long timeMils) {
if (timeMils <= 0) {
return new long[] { 0, 0, 0, 0 };
}
long day = timeMils / 86400000;
long hour = (timeMils % 86400000) / 3600000;
long min = (timeMils % 3600000) / 60000;
long sec = (timeMils % 60000) / 1000;
return new long[] { day, hour, min, sec };
}
public static Date parse(String format, String str) throws ParseException {
return new SimpleDateFormat(format).parse(str);
}
public static Date firstDayOfMonth() {
Calendar c = Calendar.getInstance();
c.set(Calendar.DAY_OF_MONTH, 1);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
return c.getTime();
}
public static Date lastDayOfMonth() {
Calendar c = Calendar.getInstance();
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
c.set(Calendar.HOUR_OF_DAY, c.getMaximum(Calendar.HOUR_OF_DAY));
c.set(Calendar.MINUTE, c.getMaximum(Calendar.MINUTE));
c.set(Calendar.SECOND, c.getMaximum(Calendar.SECOND));
c.set(Calendar.MILLISECOND, c.getMaximum(Calendar.MILLISECOND));
return c.getTime();
}
public static Date firstDayOfMonth(int year, int month) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, month);
c.set(Calendar.DAY_OF_MONTH, 1);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
return c.getTime();
}
public static Date lastDayOfMonth(int year, int month) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, month);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
c.set(Calendar.HOUR_OF_DAY, c.getMaximum(Calendar.HOUR_OF_DAY));
c.set(Calendar.MINUTE, c.getMaximum(Calendar.MINUTE));
c.set(Calendar.SECOND, c.getMaximum(Calendar.SECOND));
c.set(Calendar.MILLISECOND, c.getMaximum(Calendar.MILLISECOND));
return c.getTime();
}
public static int getMonthDayCount(int year, int month) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, month);
return c.getActualMaximum(Calendar.DAY_OF_MONTH);
}
public static long getStartTimeOfDate(long time) {
Calendar c = Calendar.getInstance();
c.setTimeInMillis(time);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
return c.getTimeInMillis();
}
public static long curDay() {
return getRawOffsetMils(System.currentTimeMillis()) / MILLIS_PER_DAY;
}
public static long curHour() {
return getRawOffsetMils(System.currentTimeMillis()) / MILLIS_PER_HOUR;
}
public static long curMinute() {
return getRawOffsetMils(System.currentTimeMillis()) / MILLIS_PER_MINUTE;
}
}
src/main/java/com/server/utils/ErrorCode.java 0 → 100644
package com.server.utils;
/**
* Created by dell on 2018/2/27.
*/
public enum ErrorCode {
SUCCESS("1", "操作成功"),
ERROR("0", "操作失败"),
ERROR_PARAM_DEFICIENCY("0", "操作失败，参数缺失");
private String code ;
private String message ;
private ErrorCode(String code , String message ){
this.code = code ;
this.message = message ;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
src/main/java/com/server/utils/FileStore.java 0 → 100644
package com.server.utils;
import com.server.utils.key.QiniuKey;
import com.server.utils.key.UploadUrlKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import javax.imageio.ImageIO;
import java.io.File;
import java.io.IOException;
/**
* 本地文件存储
*/
@Component
public class FileStore {
private Logger log = LoggerFactory.getLogger(FileStore.class);
@Autowired
UploadUrlKey uploadUrlKey;
@Autowired
QiniuKey qiniuKey;
public String storeImage(String path, MultipartFile file) {
return store(path, file);
}
public String getRealPath(String path) {
String ret = uploadUrlKey.getRealPath() + "/" + path;
return ret.replaceAll("\\\\/+", "/");
}
public String store(String path, MultipartFile file) {
String originalName = file.getOriginalFilename();
int index = originalName.lastIndexOf(".");
String ext = index > -1 ? originalName.substring(index + 1) : ContentType.getExtension(file.getContentType());
String filename = UploadUtils.generateFilename(getRealPath(path), ext);
File dest = new File(filename);
dest = UploadUtils.getUniqueFile(dest);
dest = store(file, dest);
filename = dest.getAbsolutePath();
return filename.substring(filename.indexOf(uploadUrlKey.getBasePath()));
}
private File store(MultipartFile file, File dest) {
UploadUtils.checkDirAndCreate(dest.getParentFile());
try {
file.transferTo(dest);
} catch (IOException e) {
log.error("Transfer file error when upload file", e);
}
//如果是图片尝试纠图片方向
if (isImage(dest)) {
dest = compressImage(dest);
}
return dest;
}
private File compressImage(File dest) {
try {
Image image = new Image(dest);
if (image.getWidth() > 860 || image.getHeight() > 860) {
image.resize(860, 860, true);
}
image.saveAs(dest,uploadUrlKey,qiniuKey);
} catch (Exception e) {
e.printStackTrace();
}
return dest;
}
private boolean isImage(File file) {
try {
java.awt.Image image = ImageIO.read(file);
return image != null;
} catch (IOException ex) {
return false;
}
}
}
src/main/java/com/server/utils/HTTPClientUtil.java 0 → 100644
package com.server.utils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
* Created by stone on 2017/6/14.
*/
public class HTTPClientUtil {
public static String getPublicService(Map<String, String> map, String url,String charset)
throws Exception {
HttpClient httpClient = null;
HttpPost httpPost = null;
String result = null;
try{
httpClient = new DefaultHttpClient();
httpPost = new HttpPost(url);
//设置参数
List<NameValuePair> list = new ArrayList<NameValuePair>();
Iterator iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Entry<String,String> elem = (Entry<String, String>) iterator.next();
list.add(new BasicNameValuePair(elem.getKey(),elem.getValue()));
}
if(list.size() > 0){
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list,charset);
httpPost.setEntity(entity);
}
HttpResponse response = httpClient.execute(httpPost);
if(response != null){
HttpEntity resEntity = response.getEntity();
if(resEntity != null){
result = EntityUtils.toString(resEntity,charset);
}
}
}catch(Exception ex){
ex.printStackTrace();
}
return result;
}
public static String getUrl(HttpServletRequest request){
StringBuffer url = request.getRequestURL();
String visitUrl = url.delete(url.length() - request.getRequestURI().length(), url.length()).toString();
return visitUrl;
}
}
src/main/java/com/server/utils/MD5.java 0 → 100644
package com.server.utils;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
/**
* MD5
*/
public final class MD5 {
private MD5() {
}
private static final char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
public static String md5(String txt) {
try {
return md5(txt.getBytes("UTF-8"));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static String md5(String... txt) {
return md5(StrUtils.joinString(",", txt));
}
public static String md5(byte[] data) {
try {
MessageDigest mdTemp = MessageDigest.getInstance("MD5");
byte[] bytes = data;
mdTemp.update(bytes);
byte[] md = mdTemp.digest();
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @param file
* @return
* @throws IOException
*/
public static String fileMd5(File file) throws Exception {
try (FileInputStream in = new FileInputStream(file)) {
MessageDigest md5 = MessageDigest.getInstance("MD5");
FileChannel fChannel = in.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(16 * 1024);
for (int count = fChannel.read(buffer); count != -1; count = fChannel.read(buffer)) {
buffer.flip();
md5.update(buffer);
if (!buffer.hasRemaining()) {
buffer.clear();
}
}
//
byte[] md = md5.digest();
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception ex) {
throw ex;
}
}
}
src/main/java/com/server/utils/Num62.java 0 → 100644
package com.server.utils;
/**
* 62进制数字
*/
public class Num62 {
/**
* 62个字母和数字，含大小写
*/
public static final char[] N62_CHARS = {'0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'x', 'y', 'z'};
/**
* 36个小写字母和数字
*/
public static final char[] N36_CHARS = {'0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'x', 'y', 'z'};
/**
* 长整型用N36表示的最大长度
*/
public static final int LONG_N36_LEN = 13;
/**
* 长整型用N62表示的最大长度
*/
public static final int LONG_N62_LEN = 11;
/**
* 长整型转换成字符串
*/
private static StringBuilder longToNBuf(long l, char[] chars) {
int upgrade = chars.length;
StringBuilder result = new StringBuilder();
int last;
while (l > 0) {
last = (int) (l % upgrade);
result.append(chars[last]);
l /= upgrade;
}
return result;
}
/**
* 长整数转换成N62
*/
public static String longToN62(long l) {
return longToNBuf(l, N62_CHARS).reverse().toString();
}
/**
* 长整型转换成N36
*/
public static String longToN36(long l) {
return longToNBuf(l, N36_CHARS).reverse().toString();
}
/**
* 长整数转换成N62
*
* @param length 如不足length长度，则补足0。
*/
public static String longToN62(long l, int length) {
StringBuilder sb = longToNBuf(l, N62_CHARS);
for (int i = sb.length(); i < length; i++) {
sb.append('0');
}
return sb.reverse().toString();
}
/**
* 长整型转换成N36
*
* @param length 如不足length长度，则补足0。
*/
public static String longToN36(long l, int length) {
StringBuilder sb = longToNBuf(l, N36_CHARS);
for (int i = sb.length(); i < length; i++) {
sb.append('0');
}
return sb.reverse().toString();
}
/**
* N62转换成整数
*/
public static long n62ToLong(String n62) {
return nToLong(n62, N62_CHARS);
}
/**
* N36转换成整数
*/
public static long n36ToLong(String n36) {
return nToLong(n36, N36_CHARS);
}
private static long nToLong(String s, char[] chars) {
char[] nc = s.toCharArray();
long result = 0;
long pow = 1;
for (int i = nc.length - 1; i >= 0; i--, pow *= chars.length) {
int n = findNIndex(nc[i], chars);
result += n * pow;
}
return result;
}
private static int findNIndex(char c, char[] chars) {
for (int i = 0; i < chars.length; i++) {
if (c == chars[i]) {
return i;
}
}
throw new RuntimeException("N62(N36)非法字符：" + c);
}
public static void main(String[] args) {
System.out.println(longToN62(Long.MAX_VALUE));
}
}
src/main/java/com/server/utils/RandomUtils.java 0 → 100644
package com.server.utils;
import java.util.concurrent.ThreadLocalRandom;
/**
* @author ZMS
*/
public final class RandomUtils {
public static int random(int i) {
return ThreadLocalRandom.current().nextInt(i);
}
public static int random() {
return ThreadLocalRandom.current().nextInt();
}
}
src/main/java/com/server/utils/SpringContextUtil.java 0 → 100644
package com.server.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext ctx;
public void setApplicationContext(ApplicationContext ctx) throws BeansException {
SpringContextUtil.ctx = ctx;
}
public static ApplicationContext getCtx() {
return ctx;
}
}
src/main/java/com/server/utils/StrUtils.java 0 → 100644
package com.server.utils;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author ZMS
*/
public final class StrUtils {
/**
* 是否是空白字符串
*
* @param str
* @return
*/
public static boolean isBlank(String str) {
if (str == null || str.trim().length() == 0) {
return true;
}
return false;
}
public static boolean isNotBlank(String str) {
return !isBlank(str);
}
/**
* null转换为空白字符
*
* @param str
* @return
*/
public static String null2Blank(String str) {
if (isBlank(str)) {
return "";
}
return str;
}
/**
* 首字母大写
*
* @param str
* @return
*/
public static String firstUpper(String str) {
StringBuilder ret = new StringBuilder();
if (str != null && str.length() > 0) {
ret.append(str.substring(0, 1).toUpperCase()).append(str.substring(1));
}
return ret.toString();
}
/**
* 首字母小写
*
* @param str
* @return
*/
public static String firstLower(String str) {
StringBuilder ret = new StringBuilder();
if (str != null && str.length() > 0) {
ret.append(str.substring(0, 1).toLowerCase()).append(str.substring(1));
}
return ret.toString();
}
/**
* 转换为boolean
*
* @param str
* @return
*/
public static boolean parseBoolean(String str) {
return "1".equals(str) || "true".equals(str);
}
/**
* 链接字符串
*
* @param delimiter
* @param strings
* @return
*/
public static String joinString(String delimiter, Object... strings) {
if (strings == null || strings.length == 0) {
return "";
}
StringBuilder sb = new StringBuilder();
boolean d = false;
for (Object s : strings) {
if (d) {
sb.append(delimiter);
} else {
d = true;
}
sb.append(s);
}
return sb.toString();
}
public static String joinString(String delimiter, String... strings) {
Object[] o = new Object[strings.length];
for (int i = 0; i < o.length; i++) {
o[i] = strings[i];
}
return joinString(delimiter, o);
}
/**
* 链接非空字符串
*
* @param delimiter
* @param strings
* @return
*/
public static String joinNotEmpty(String delimiter, String... strings) {
if (strings == null || strings.length == 0) {
return "";
}
StringBuilder sb = new StringBuilder();
boolean d = false;
for (String s : strings) {
if (s != null && !s.isEmpty()) {
if (d) {
sb.append(delimiter);
} else {
d = true;
}
sb.append(s);
}
}
return sb.toString();
}
/**
* 正则查找
*
* @param string
* @param reg
* @return
*/
public static String[] find(String string, String reg) {
List<String> list = new ArrayList<String>();
Pattern p = Pattern.compile(reg);
Matcher m = p.matcher(string);
while (m.find()) {
list.add(m.group());
}
return list.toArray(new String[list.size()]);
}
/**
* 统计正则个数
*
* @param string
* @param regex
* @return
*/
public static int countRegex(String string, String regex) {
if (StrUtils.isBlank(string)) {
return 0;
}
String[] para = StrUtils.find(string, regex);
return para.length;
}
public static String jsonSafe(String str) {
if (str == null) {
return "";
}
str = str.replaceAll("\n|\r|\r\n|\n\r", "");
str = str.replaceAll("\"|'", " ");
str = str.trim();
return str;
}
public static String formatLeftTime(long l) {
long[] time = DateUtils.splitTime(l);
String str = "";
if (time[0] > 0) {
str = str + time[0] + "day ";
}
if (time[1] > 0) {
str = str + time[1] + "hour ";
}
if (time[2] > 0) {
str = str + time[2] + "minute ";
}
if (time[3] > 0) {
str = str + time[3] + "second ";
}
return str;
}
public static String xssSafe(String str) {
str = str.replaceAll("<", "&lt;");
str = str.replaceAll(">", "&gt;");
str = str.replaceAll("\"", "&quot;");
str = str.replaceAll("'", "&apos;");
return str;
}
public static boolean isWord(String str) {
if (str == null) {
return false;
}
return str.matches("[a-zA-Z_0-9]+");
}
public static boolean isNumber(String str) {
return str != null && str.matches("[\\-\\+]?[0-9]*\\.?[0-9]+");
}
public static boolean isInteger(String str) {
return str != null && str.matches("[\\-\\+]?[0-9]+");
}
public static String join(String[] array, String token) {
if (array == null || array.length == 0) {
return "";
}
StringBuilder sb = new StringBuilder(array[0]);
for (int i = 1; i < array.length; i++) {
sb.append(token);
sb.append(array[i]);
}
return sb.toString();
}
public static boolean requireLength(String str, int min, int max) {
return str != null && str.length() >= min && str.length() <= max;
}
public static String firstLowerCase(String str) {
return str.substring(0, 1).toLowerCase() + str.substring(1);
}
public static boolean isEmail(String str) {
return str != null && str.matches("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*");
}
public static boolean isMobilePhone(String str) {
return str != null && str.matches("\\d{11}");
}
public static String reverse(String str) {
return new StringBuilder(str).reverse().toString();
}
/**
* 随机固定长度的数字
*
* @param length
* @return
*/
public static String randomNumber(int length) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(RandomUtils.random(10));
}
return sb.toString();
}
/**
* 随机固定长度
*
* @param length
* @return
*/
public static String randomString(int length) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
int val = RandomUtils.random(36);
if (val < 10) {
sb.append(val);
} else {
char c = (char) ('a' + (val - 10));
sb.append(c);
}
}
return sb.toString();
}
public static String formatPrice(double price) {
return formatDouble(price, 2);
}
public static String formatDouble(double num, int scale) {
BigDecimal bigDecimal = new BigDecimal(num);
bigDecimal = bigDecimal.setScale(scale, RoundingMode.HALF_UP);
num = Double.parseDouble(bigDecimal.toPlainString());
int value = new Double(num).intValue();
if (num - value < Math.pow(10, -scale)) {
return String.valueOf(value);
}
return String.valueOf(num);
}
public static boolean isIpV4Address(String str) {
String reg = "([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}";
return str != null && str.matches(reg);
}
public static String uuid() {
return UUID.randomUUID().toString().replace("-", "");
}
}
src/main/java/com/server/utils/UploadUtils.java 0 → 100644
package com.server.utils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import java.io.File;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Pattern;
public class UploadUtils {
/**
* 日期格式化对象
*/
public static final DateFormat MONTH_FORMAT = new SimpleDateFormat("/yyyyMM/ddHHmmss");
public static final DateFormat YEAR_MONTH_FORMAT = new SimpleDateFormat("yyyyMM");
public static String generateFilename(String path, String ext) {
String ret = path + MONTH_FORMAT.format(new Date()) + RandomStringUtils.random(4, Num62.N36_CHARS) + "." + ext;
return ret.replaceAll("/+", "/");
}
public static String generateMonthname() {
return YEAR_MONTH_FORMAT.format(new Date());
}
public static String generateByFilename(String path, String fileName, String ext) {
return path + fileName + "." + ext;
}
protected static final Pattern ILLEGAL_CURRENT_FOLDER_PATTERN = Pattern
.compile("^[^/]|[^/]$|/\\.{1,2}|\\\\|\\||:|\\?|\\*|\"|<|>|\\p{Cntrl}");
/**
* Sanitizes a filename from certain chars.<br />
* This method enforces the <code>forceSingleExtension</code> property and
* then replaces all occurrences of \, /, |, :, ?, *, &quot;, &lt;, &gt;,
* control chars by _ (underscore).
*
* @param filename a potentially 'malicious' filename
* @return sanitized filename
*/
public static String sanitizeFileName(final String filename) {
if (StringUtils.isBlank(filename))
return filename;
String name = forceSingleExtension(filename);
// Remove \ / | : ? * " < > 'Control Chars' with _
return name.replaceAll("\\\\|/|\\||:|\\?|\\*|\"|<|>|\\p{Cntrl}", "_");
}
/**
* Sanitizes a folder name from certain chars.<br />
* This method replaces all occurrences of \, /, |, :, ?, *, &quot;, &lt;,
* &gt;, control chars by _ (underscore).
*
* @param folderName a potentially 'malicious' folder name
* @return sanitized folder name
*/
public static String sanitizeFolderName(final String folderName) {
if (StringUtils.isBlank(folderName))
return folderName;
// Remove . \ / | : ? * " < > 'Control Chars' with _
return folderName.replaceAll(
"\\.|\\\\|/|\\||:|\\?|\\*|\"|<|>|\\p{Cntrl}", "_");
}
/**
* Checks whether a path complies with the FCKeditor File Browser <a href="http://docs.fckeditor.net/FCKeditor_2.x/Developers_Guide/Server_Side_Integration#File_Browser_Requests"
* target="_blank">rules</a>.
*
* @param path a potentially 'malicious' path
* @return <code>true</code> if path complies with the rules, else
* <code>false</code>
*/
public static boolean isValidPath(final String path) {
if(StringUtils.isBlank(path))
return false;
if (ILLEGAL_CURRENT_FOLDER_PATTERN.matcher(path).find())
return false;
return true;
}
/**
* Replaces all dots in a filename with underscores except the last one.
*
* @param filename filename to sanitize
* @return string with a single dot only
*/
public static String forceSingleExtension(final String filename) {
return filename.replaceAll("\\.(?![^.]+$)", "_");
}
/**
* Checks if a filename contains more than one dot.
*
* @param filename filename to check
* @return <code>true</code> if filename contains severals dots, else
* <code>false</code>
*/
public static boolean isSingleExtension(final String filename) {
return filename.matches("[^\\.]+\\.[^\\.]+");
}
/**
* Checks a directory for existence and creates it if non-existent.
*
* @param dir directory to check/create
*/
public static void checkDirAndCreate(File dir) {
if (!dir.exists())
dir.mkdirs();
}
/**
* Iterates over a base name and returns the first non-existent file.<br />
* This method extracts a file's base name, iterates over it until the first
* non-existent appearance with <code>basename(n).ext</code>. Where n is a
* positive integer starting from one.
*
* @param file base file
* @return first non-existent file
*/
public static File getUniqueFile(final File file) {
if (!file.exists())
return file;
File tmpFile = new File(file.getAbsolutePath());
File parentDir = tmpFile.getParentFile();
int count = 1;
String extension = FilenameUtils.getExtension(tmpFile.getName());
String baseName = FilenameUtils.getBaseName(tmpFile.getName());
do {
tmpFile = new File(parentDir, baseName + "(" + count++ + ")."
+ extension);
} while (tmpFile.exists());
return tmpFile;
}
}
src/main/java/com/server/utils/blob/BlobTypeHandler.java 0 → 100644
package com.server.utils.blob;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import java.sql.*;
/**
* Created by dell on 2017/7/19.
*/
public class BlobTypeHandler extends BaseTypeHandler<String> {
// 指定字符集
private static final String DEFAULT_CHARSET = "utf-8";
@Override
public void setNonNullParameter(PreparedStatement ps, int i,
String parameter, JdbcType jdbcType) throws SQLException
{
ByteArrayInputStream bis;
try
{
// 把String转化成byte流
bis = new ByteArrayInputStream(parameter.getBytes(DEFAULT_CHARSET));
} catch (UnsupportedEncodingException e)
{
throw new RuntimeException("Blob Encoding Error!");
}
ps.setBinaryStream(i, bis, parameter.length());
}
@Override
public String getNullableResult(ResultSet rs, String columnName)
throws SQLException
{
Blob blob = rs.getBlob(columnName);
byte[] returnValue = null;
String result = null;
if (null != blob)
{
returnValue = blob.getBytes(1, (int) blob.length());
}
try
{
if (null != returnValue)
{
// 把byte转化成string
result = new String(returnValue, DEFAULT_CHARSET);
}
} catch (UnsupportedEncodingException e)
{
throw new RuntimeException("Blob Encoding Error!");
}
return result;
}
@Override
public String getNullableResult(CallableStatement cs, int columnIndex)
throws SQLException
{
Blob blob = cs.getBlob(columnIndex);
byte[] returnValue = null;
String result = null;
if (null != blob)
{
returnValue = blob.getBytes(1, (int) blob.length());
}
try
{
if (null != returnValue)
{
result = new String(returnValue, DEFAULT_CHARSET);
}
} catch (UnsupportedEncodingException e)
{
throw new RuntimeException("Blob Encoding Error!");
}
return result;
}
/**
* @Description:
*
* @return
* @throws SQLException
*
* @see BaseTypeHandler#getNullableResult(ResultSet,
* int)
*
*/
@Override
public String getNullableResult(ResultSet rs, int columnName)
throws SQLException
{
String result = null;
Blob blob = rs.getBlob(columnName);
byte[] returnValue = null;
if (null != blob)
{
returnValue = blob.getBytes(1, (int) blob.length());
}
try
{
// 把byte转化成string
if (null != returnValue)
{
result = new String(returnValue, DEFAULT_CHARSET);
}
} catch (UnsupportedEncodingException e)
{
throw new RuntimeException("Blob Encoding Error!");
}
return result;
}
}
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!