Skip to content
GitLab
"src/main/vscode:/vscode.git/clone" did not exist on "31aff72628a4ac1bf3120fe1e82c434310b58247"
Commit e344509c authored by HuangBingGui's avatar HuangBingGui
Browse files

删除目录JeeSpringCloud

parent 51016ad9
Hide whitespace changes
Inline Side-by-side
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/HSQLDialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
import com.jeespring.common.persistence.dialect.Dialect;
/**
* Dialect for HSQLDB
*
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class HSQLDialect implements Dialect {
@Override
public boolean supportsLimit() {
return true;
}
@Override
public String getLimitString(String sql, int offset, int limit) {
return getLimitString(sql, offset, Integer.toString(offset),
Integer.toString(limit));
}
/**
* 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
* <pre>
* 如mysql
* dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
* select * from user limit :offset,:limit
* </pre>
*
* @param sql 实际SQL语句
* @param offset 分页开始纪录条数
* @param offsetPlaceholder 分页开始纪录条数－占位符号
* @param limitPlaceholder 分页纪录条数占位符号
* @return 包含占位符的分页sql
*/
public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
boolean hasOffset = offset > 0;
return
new StringBuffer(sql.length() + 10)
.append(sql)
.insert(sql.toLowerCase().indexOf("select") + 6, hasOffset ? " limit " + offsetPlaceholder + " " + limitPlaceholder : " top " + limitPlaceholder)
.toString();
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/MySQLDialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
import com.jeespring.common.persistence.dialect.Dialect;
/**
* Mysql方言的实现
*
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class MySQLDialect implements Dialect {
@Override
public String getLimitString(String sql, int offset, int limit) {
return getLimitString(sql, offset, Integer.toString(offset),
Integer.toString(limit));
}
public boolean supportsLimit() {
return true;
}
/**
* 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
* <pre>
* 如mysql
* dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
* select * from user limit :offset,:limit
* </pre>
*
* @param sql 实际SQL语句
* @param offset 分页开始纪录条数
* @param offsetPlaceholder 分页开始纪录条数－占位符号
* @param limitPlaceholder 分页纪录条数占位符号
* @return 包含占位符的分页sql
*/
public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
StringBuilder stringBuilder = new StringBuilder(sql);
stringBuilder.append(" limit ");
if (offset > 0) {
stringBuilder.append(offsetPlaceholder).append(",").append(limitPlaceholder);
} else {
stringBuilder.append(limitPlaceholder);
}
return stringBuilder.toString();
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/OracleDialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
/**
* Oracle的方言实现
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class OracleDialect implements Dialect {
@Override
public boolean supportsLimit() {
return true;
}
@Override
public String getLimitString(String sql, int offset, int limit) {
return getLimitString(sql, offset, Integer.toString(offset), Integer.toString(limit));
}
/**
* 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
* <pre>
* 如mysql
* dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
* select * from user limit :offset,:limit
* </pre>
*
* @param sql 实际SQL语句
* @param offset 分页开始纪录条数
* @param offsetPlaceholder 分页开始纪录条数－占位符号
* @param limitPlaceholder 分页纪录条数占位符号
* @return 包含占位符的分页sql
*/
public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
sql = sql.trim();
boolean isForUpdate = false;
if (sql.toLowerCase().endsWith(" for update")) {
sql = sql.substring(0, sql.length() - 11);
isForUpdate = true;
}
StringBuilder pagingSelect = new StringBuilder(sql.length() + 100);
if (offset > 0) {
pagingSelect.append("select * from ( select row_.*, rownum rownum_ from ( ");
} else {
pagingSelect.append("select * from ( ");
}
pagingSelect.append(sql);
if (offset > 0) {
String endString = offsetPlaceholder + "+" + limitPlaceholder;
pagingSelect.append(" ) row_ where rownum <= "+endString+") where rownum_ > ").append(offsetPlaceholder);
} else {
pagingSelect.append(" ) where rownum <= "+limitPlaceholder);
}
if (isForUpdate) {
pagingSelect.append(" for update");
}
return pagingSelect.toString();
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/PostgreSQLDialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
import com.jeespring.common.persistence.dialect.Dialect;
/**
* Postgre Sql的方言实现
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class PostgreSQLDialect implements Dialect {
public boolean supportsLimit() {
return true;
}
@Override
public String getLimitString(String sql, int offset, int limit) {
return getLimitString(sql, offset, Integer.toString(offset),
Integer.toString(limit));
}
/**
* 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
* <pre>
* 如mysql
* dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
* select * from user limit :offset,:limit
* </pre>
*
* @param sql 实际SQL语句
* @param offset 分页开始纪录条数
* @param offsetPlaceholder 分页开始纪录条数－占位符号
* @param limitPlaceholder 分页纪录条数占位符号
* @return 包含占位符的分页sql
*/
public String getLimitString(String sql, int offset,
String offsetPlaceholder, String limitPlaceholder) {
StringBuilder pageSql = new StringBuilder().append(sql);
pageSql = offset <= 0
? pageSql.append(" limit ").append(limitPlaceholder) :
pageSql.append(" limit ").append(limitPlaceholder).append(" offset ").append(offsetPlaceholder);
return pageSql.toString();
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/SQLServer2005Dialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
import org.apache.commons.lang3.StringUtils;
import com.jeespring.common.persistence.dialect.Dialect;
/**
* Sql 2005的方言实现
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class SQLServer2005Dialect implements Dialect {
@Override
public boolean supportsLimit() {
return true;
}
@Override
public String getLimitString(String sql, int offset, int limit) {
return getLimitString(sql, offset,
limit, Integer.toString(limit));
}
/**
* Add a LIMIT clause to the given SQL SELECT
* <p/>
* The LIMIT SQL will look like:
* <p/>
* WITH query AS
* (SELECT TOP 100 percent ROW_NUMBER() OVER (ORDER BY CURRENT_TIMESTAMP) as __row_number__, * from table_name)
* SELECT *
* FROM query
* WHERE __row_number__ BETWEEN :offset and :lastRows
* ORDER BY __row_number__
*
* @param querySqlString The SQL statement to base the limit query off of.
* @param offset Offset of the first row to be returned by the query (zero-based)
* @param limit Maximum number of rows to be returned by the query
* @param limitPlaceholder limitPlaceholder
* @return A new SQL statement with the LIMIT clause applied.
*/
private String getLimitString(String querySqlString, int offset, int limit, String limitPlaceholder) {
StringBuilder pagingBuilder = new StringBuilder();
String orderby = getOrderByPart(querySqlString);
String distinctStr = "";
String loweredString = querySqlString.toLowerCase();
String sqlPartString = querySqlString;
if (loweredString.trim().startsWith("select")) {
int index = 6;
if (loweredString.startsWith("select distinct")) {
distinctStr = "DISTINCT ";
index = 15;
}
sqlPartString = sqlPartString.substring(index);
}
pagingBuilder.append(sqlPartString);
// if no ORDER BY is specified use fake ORDER BY field to avoid errors
if (StringUtils.isEmpty(orderby)) {
orderby = "ORDER BY CURRENT_TIMESTAMP";
}
StringBuilder result = new StringBuilder();
result.append("WITH query AS (SELECT ")
.append(distinctStr)
.append("TOP 100 PERCENT ")
.append(" ROW_NUMBER() OVER (")
.append(orderby)
.append(") as __row_number__, ")
.append(pagingBuilder)
.append(") SELECT * FROM query WHERE __row_number__ BETWEEN ")
.append(offset + 1).append(" AND ").append(offset + limit)
.append(" ORDER BY __row_number__");
return result.toString();
}
static String getOrderByPart(String sql) {
String loweredString = sql.toLowerCase();
int orderByIndex = loweredString.indexOf("order by");
if (orderByIndex != -1) {
// if we find a new "order by" then we need to ignore
// the previous one since it was probably used for a subquery
return sql.substring(orderByIndex);
} else {
return "";
}
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/SQLServerDialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
import com.jeespring.common.persistence.dialect.Dialect;
/**
* MSSQLServer 数据库实现分页方言
*
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class SQLServerDialect implements Dialect {
public boolean supportsLimit() {
return true;
}
static int getAfterSelectInsertPoint(String sql) {
int selectIndex = sql.toLowerCase().indexOf("select");
final int selectDistinctIndex = sql.toLowerCase().indexOf("select distinct");
return selectIndex + (selectDistinctIndex == selectIndex ? 15 : 6);
}
public String getLimitString(String sql, int offset, int limit) {
return getLimit(sql, offset, limit);
}
/**
* 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
* <pre>
* 如mysql
* dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
* select * from user limit :offset,:limit
* </pre>
*
* @param sql 实际SQL语句
* @param offset 分页开始纪录条数
* @param limit 分页每页显示纪录条数
* @return 包含占位符的分页sql
*/
public String getLimit(String sql, int offset, int limit) {
if (offset > 0) {
throw new UnsupportedOperationException("sql server has no offset");
}
return new StringBuffer(sql.length() + 8)
.append(sql)
.insert(getAfterSelectInsertPoint(sql), " top " + limit)
.toString();
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/dialect/SybaseDialect.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.dialect;
import com.jeespring.common.persistence.dialect.Dialect;
/**
* Sybase数据库分页方言实现。
* 还未实现
*
* @author poplar.yfyang
* @version 1.0 2010-10-10 下午12:31
* @since JDK 1.5
*/
public class SybaseDialect implements Dialect {
public boolean supportsLimit() {
return false;
}
@Override
public String getLimitString(String sql, int offset, int limit) {
return null;
}
/**
* 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
* <pre>
* 如mysql
* dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
* select * from user limit :offset,:limit
* </pre>
*
* @param sql 实际SQL语句
* @param offset 分页开始纪录条数
* @param offsetPlaceholder 分页开始纪录条数－占位符号
* @param limit 分页每页显示纪录条数
* @param limitPlaceholder 分页纪录条数占位符号
* @return 包含占位符的分页sql
*/
public String getLimitString(String sql, int offset, String offsetPlaceholder, int limit, String limitPlaceholder) {
throw new UnsupportedOperationException("paged queries not supported");
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/interceptor/BaseInterceptor.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.interceptor;
import com.jeespring.common.config.Global;
import com.jeespring.common.persistence.Page;
import com.jeespring.common.persistence.dialect.*;
import com.jeespring.common.utils.Reflections;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.plugin.Interceptor;
import java.io.Serializable;
import java.util.Properties;
/**
* Mybatis分页拦截器基类
*
* @author poplar.yfyang / HuangBingGui
* @version 2013-8-28
*/
public abstract class BaseInterceptor implements Interceptor, Serializable {
private static final long serialVersionUID = 1L;
protected static final String PAGE = "page";
protected static final String DELEGATE = "delegate";
protected static final String MAPPED_STATEMENT = "mappedStatement";
protected Log log = LogFactory.getLog(this.getClass());
protected Dialect DIALECT;
/**
* 对参数进行转换和检查
*
* @param parameterObject 参数对象
* @param page 分页对象
* @return 分页对象
* @throws NoSuchFieldException 无法找到参数
*/
@SuppressWarnings("unchecked")
protected static Page<Object> convertParameter(Object parameterObject, Page<Object> page) {
try {
if (parameterObject instanceof Page) {
return (Page<Object>) parameterObject;
} else {
return (Page<Object>) Reflections.getFieldValue(parameterObject, PAGE);
}
} catch (Exception e) {
return null;
}
}
/**
* 设置属性，支持自定义方言类和制定数据库的方式
* <code>dialectClass</code>,自定义方言类。可以不配置这项
* <ode>dbms</ode> 数据库类型，插件支持的数据库
* <code>sqlPattern</code> 需要拦截的SQL ID
*
* @param p 属性
*/
protected void initProperties(Properties p) {
Dialect dialect = null;
String dbType = Global.getJdbcType();
if ("db2".equals(dbType)) {
dialect = new DB2Dialect();
} else if ("derby".equals(dbType)) {
dialect = new DerbyDialect();
} else if ("h2".equals(dbType)) {
dialect = new H2Dialect();
} else if ("hsql".equals(dbType)) {
dialect = new HSQLDialect();
} else if ("mysql".equals(dbType)) {
dialect = new MySQLDialect();
} else if ("oracle".equals(dbType)) {
dialect = new OracleDialect();
} else if ("postgre".equals(dbType)) {
dialect = new PostgreSQLDialect();
} else if ("mssql".equals(dbType) || "sqlserver".equals(dbType)) {
dialect = new SQLServer2005Dialect();
} else if ("sybase".equals(dbType)) {
dialect = new SybaseDialect();
}
if (dialect == null) {
log.error("user the mysql dialect");
dialect = new MySQLDialect();
}
DIALECT = dialect;
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/interceptor/PaginationInterceptor.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.interceptor;
import java.util.Properties;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import com.jeespring.common.persistence.Page;
import com.jeespring.common.utils.Reflections;
import com.jeespring.common.utils.StringUtils;
/**
* 数据库分页插件，只拦截查询语句.
* @author poplar.yfyang / HuangBingGui
* @version 2013-8-28
*/
@Intercepts({@Signature(type = Executor.class, method = "query",
args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class PaginationInterceptor extends BaseInterceptor {
private static final long serialVersionUID = 1L;
@Override
public Object intercept(Invocation invocation) throws Throwable {
final MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
// //拦截需要分页的SQL
//// if (mappedStatement.getId().matches(_SQL_PATTERN)) {
// if (StringUtils.indexOfIgnoreCase(mappedStatement.getId(), _SQL_PATTERN) != -1) {
Object parameter = invocation.getArgs()[1];
BoundSql boundSql = mappedStatement.getBoundSql(parameter);
Object parameterObject = boundSql.getParameterObject();
//获取分页参数对象
Page<Object> page = null;
if (parameterObject != null) {
page = convertParameter(parameterObject, page);
}
//如果设置了分页对象，则进行分页
if (page != null && page.getPageSize() != -1) {
if (StringUtils.isBlank(boundSql.getSql())){
return null;
}
String originalSql = boundSql.getSql().trim();
//得到总记录数
page.setCount(SQLHelper.getCount(originalSql, null, mappedStatement, parameterObject, boundSql, log));
//分页查询 本地化对象 修改数据库注意修改实现
String pageSql = SQLHelper.generatePageSql(originalSql, page, DIALECT);
// if (log.isDebugEnabled()) {
// log.debug("PAGE SQL:" + StringUtils.replace(pageSql, "\n", ""));
// }
invocation.getArgs()[2] = new RowBounds(RowBounds.NO_ROW_OFFSET, RowBounds.NO_ROW_LIMIT);
BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(), pageSql, boundSql.getParameterMappings(), boundSql.getParameterObject());
//解决MyBatis 分页foreach 参数失效 start
if (Reflections.getFieldValue(boundSql, "metaParameters") != null) {
MetaObject mo = (MetaObject) Reflections.getFieldValue(boundSql, "metaParameters");
Reflections.setFieldValue(newBoundSql, "metaParameters", mo);
}
//解决MyBatis 分页foreach 参数失效 end
MappedStatement newMs = copyFromMappedStatement(mappedStatement, new BoundSqlSqlSource(newBoundSql));
invocation.getArgs()[0] = newMs;
}
// }
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
super.initProperties(properties);
}
private MappedStatement copyFromMappedStatement(MappedStatement ms,
SqlSource newSqlSource) {
MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(),
ms.getId(), newSqlSource, ms.getSqlCommandType());
builder.resource(ms.getResource());
builder.fetchSize(ms.getFetchSize());
builder.statementType(ms.getStatementType());
builder.keyGenerator(ms.getKeyGenerator());
if (ms.getKeyProperties() != null) {
for (String keyProperty : ms.getKeyProperties()) {
builder.keyProperty(keyProperty);
}
}
builder.timeout(ms.getTimeout());
builder.parameterMap(ms.getParameterMap());
builder.resultMaps(ms.getResultMaps());
builder.cache(ms.getCache());
builder.useCache(ms.isUseCache());
return builder.build();
}
public static class BoundSqlSqlSource implements SqlSource {
BoundSql boundSql;
public BoundSqlSqlSource(BoundSql boundSql) {
this.boundSql = boundSql;
}
@Override
public BoundSql getBoundSql(Object parameterObject) {
return boundSql;
}
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/interceptor/PreparePaginationInterceptor.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.interceptor;
import java.sql.Connection;
import java.util.Properties;
import org.apache.ibatis.executor.statement.BaseStatementHandler;
import org.apache.ibatis.executor.statement.RoutingStatementHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import com.jeespring.common.persistence.Page;
import com.jeespring.common.utils.Reflections;
/**
* Mybatis数据库分页插件，拦截StatementHandler的prepare方法
* @author poplar.yfyang / HuangBingGui
* @version 2013-8-28
*/
@Intercepts({
@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class})
})
public class PreparePaginationInterceptor extends BaseInterceptor {
private static final long serialVersionUID = 1L;
public PreparePaginationInterceptor() {
super();
}
@Override
public Object intercept(Invocation ivk) throws Throwable {
if (ivk.getTarget().getClass().isAssignableFrom(RoutingStatementHandler.class)) {
final RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk.getTarget();
final BaseStatementHandler delegate = (BaseStatementHandler) Reflections.getFieldValue(statementHandler, DELEGATE);
final MappedStatement mappedStatement = (MappedStatement) Reflections.getFieldValue(delegate, MAPPED_STATEMENT);
// //拦截需要分页的SQL
//// if (mappedStatement.getId().matches(_SQL_PATTERN)) {
// if (StringUtils.indexOfIgnoreCase(mappedStatement.getId(), _SQL_PATTERN) != -1) {
BoundSql boundSql = delegate.getBoundSql();
//分页SQL<select>中parameterType属性对应的实体参数，即Mapper接口中执行分页方法的参数,该参数不得为空
Object parameterObject = boundSql.getParameterObject();
if (parameterObject == null) {
log.error("参数未实例化");
throw new NullPointerException("parameterObject尚未实例化！");
} else {
final Connection connection = (Connection) ivk.getArgs()[0];
final String sql = boundSql.getSql();
//记录统计
final int count = SQLHelper.getCount(sql, connection, mappedStatement, parameterObject, boundSql, log);
Page<Object> page = null;
page = convertParameter(parameterObject, page);
page.setCount(count);
String pagingSql = SQLHelper.generatePageSql(sql, page, DIALECT);
if (log.isDebugEnabled()) {
log.debug("PAGE SQL:" + pagingSql);
}
//将分页sql语句反射回BoundSql.
Reflections.setFieldValue(boundSql, "sql", pagingSql);
}
if (boundSql.getSql() == null || "".equals(boundSql.getSql())){
return null;
}
}
// }
return ivk.proceed();
}
@Override
public Object plugin(Object o) {
return Plugin.wrap(o, this);
}
@Override
public void setProperties(Properties properties) {
initProperties(properties);
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/interceptor/SQLHelper.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.interceptor;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.scripting.xmltags.ForEachSqlNode;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;
import com.jeespring.common.config.Global;
import com.jeespring.common.persistence.Page;
import com.jeespring.common.persistence.dialect.Dialect;
import com.jeespring.common.utils.Reflections;
import com.jeespring.common.utils.StringUtils;
/**
* SQL工具类
*
* @author poplar.yfyang / HuangBingGui
* @version 2013-8-28
*/
public class SQLHelper {
/**
* 对SQL参数(?)设值,参考org.apache.ibatis.executor.parameter.DefaultParameterHandler
*
* @param ps 表示预编译的 SQL 语句的对象。
* @param mappedStatement MappedStatement
* @param boundSql SQL
* @param parameterObject 参数对象
* @throws SQLException 数据库异常
*/
@SuppressWarnings("unchecked")
public static void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql, Object parameterObject) throws SQLException {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
Configuration configuration = mappedStatement.getConfiguration();
TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
MetaObject metaObject = parameterObject == null ? null :
configuration.newMetaObject(parameterObject);
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
PropertyTokenizer prop = new PropertyTokenizer(propertyName);
if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX) && boundSql.hasAdditionalParameter(prop.getName())) {
value = boundSql.getAdditionalParameter(prop.getName());
if (value != null) {
value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));
}
} else {
value = metaObject == null ? null : metaObject.getValue(propertyName);
}
@SuppressWarnings("rawtypes")
TypeHandler typeHandler = parameterMapping.getTypeHandler();
if (typeHandler == null) {
throw new ExecutorException("There was no TypeHandler found for parameter " + propertyName + " of statement " + mappedStatement.getId());
}
typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());
}
}
}
}
/**
* 查询总纪录数
*
* @param sql SQL语句
* @param connection 数据库连接
* @param mappedStatement mapped
* @param parameterObject 参数
* @param boundSql boundSql
* @return 总记录数
* @throws SQLException sql查询错误
*/
public static int getCount(final String sql, final Connection connection,
final MappedStatement mappedStatement, final Object parameterObject,
final BoundSql boundSql, Log log) throws SQLException {
String dbName = Global.getJdbcType();
final String countSql;
if ("oracle".equals(dbName)) {
countSql = "select count(1) from (" + sql + ") tmp_count";
} else {
countSql = "select count(1) from (" + removeOrders(sql) + ") tmp_count";
}
Connection conn = connection;
PreparedStatement ps = null;
ResultSet rs = null;
try {
if (log.isDebugEnabled()) {
log.debug("COUNT SQL: " + StringUtils.replaceEach(countSql, new String[]{"\n", "\t"}, new String[]{" ", " "}));
}
if (conn == null) {
conn = mappedStatement.getConfiguration().getEnvironment().getDataSource().getConnection();
}
ps = conn.prepareStatement(countSql);
BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql,
boundSql.getParameterMappings(), parameterObject);
//解决MyBatis 分页foreach 参数失效 start
if (Reflections.getFieldValue(boundSql, "metaParameters") != null) {
MetaObject mo = (MetaObject) Reflections.getFieldValue(boundSql, "metaParameters");
Reflections.setFieldValue(countBS, "metaParameters", mo);
}
//解决MyBatis 分页foreach 参数失效 end
SQLHelper.setParameters(ps, mappedStatement, countBS, parameterObject);
rs = ps.executeQuery();
int count = 0;
if (rs.next()) {
count = rs.getInt(1);
}
return count;
} finally {
if (rs != null) {
rs.close();
}
if (ps != null) {
ps.close();
}
if (conn != null) {
conn.close();
}
}
}
/**
* 根据数据库方言，生成特定的分页sql
*
* @param sql Mapper中的Sql语句
* @param page 分页对象
* @param dialect 方言类型
* @return 分页SQL
*/
public static String generatePageSql(String sql, Page<Object> page, Dialect dialect) {
if (dialect.supportsLimit()) {
return dialect.getLimitString(sql, page.getFirstResult(), page.getMaxResults());
} else {
return sql;
}
}
/**
* 去除qlString的select子句。
*
* @param qlString
* @return
*/
@SuppressWarnings("unused")
private static String removeSelect(String qlString) {
int beginPos = qlString.toLowerCase().indexOf("from");
return qlString.substring(beginPos);
}
/**
* 去除hql的orderBy子句。
*
* @param qlString
* @return
*/
private static String removeOrders(String qlString) {
Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(qlString);
StringBuffer sb = new StringBuffer();
while (m.find()) {
m.appendReplacement(sb, "");
}
m.appendTail(sb);
return sb.toString();
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/proxy/PageConfiguration.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.proxy;
import org.apache.ibatis.binding.MapperRegistry;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
/**
* <p>
* 自定义Mybatis的配置，扩展.
* </p>
*
* @author poplar.yfyang
* @version 1.0 2012-05-13 上午10:06
* @since JDK 1.5
*/
public class PageConfiguration extends Configuration {
protected MapperRegistry mapperRegistry = new PaginationMapperRegistry(this);
@Override
public <T> void addMapper(Class<T> type) {
mapperRegistry.addMapper(type);
}
@Override
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
@Override
public boolean hasMapper(Class<?> type) {
return mapperRegistry.hasMapper(type);
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/proxy/PaginationMapperMethod.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.proxy;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.binding.BindingException;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import com.jeespring.common.persistence.Page;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* <p>
* 执行代理类，扩展Mybatis的方式来让其Mapper接口来支持.
* </p>
*
* @author poplar.yfyang
* @version 1.0 2012-05-13 上午10:09
* @since JDK 1.5
*/
public class PaginationMapperMethod {
private final SqlSession sqlSession;
private final Configuration config;
private SqlCommandType type;
private String commandName;
private String commandCountName;
private final Class<?> declaringInterface;
private final Method method;
private Integer rowBoundsIndex;
private Integer paginationIndex;
private final List<String> paramNames;
private final List<Integer> paramPositions;
private boolean hasNamedParameters;
public PaginationMapperMethod(Class<?> declaringInterface, Method method,
SqlSession sqlSession) {
paramNames = new ArrayList<String>();
paramPositions = new ArrayList<Integer>();
this.sqlSession = sqlSession;
this.method = method;
this.config = sqlSession.getConfiguration();
this.declaringInterface = declaringInterface;
this.hasNamedParameters = false;
setupFields();
setupMethodSignature();
setupCommandType();
validateStatement();
}
/**
* 代理执行方法。
*
* @param args 参数信息
* @return 执行结果
*/
@SuppressWarnings("unchecked")
public Object execute(Object[] args) {
final Object param = getParam(args);
Page<Object> page;
RowBounds rowBounds;
if (paginationIndex != null) {
page = (Page<Object>) args[paginationIndex];
rowBounds = new RowBounds(page.getFirstResult(), page.getMaxResults());
} else if (rowBoundsIndex != null) {
rowBounds = (RowBounds) args[rowBoundsIndex];
page = new Page<Object>();
} else {
throw new BindingException("Invalid bound statement (not found rowBounds or pagination in paramenters)");
}
page.setCount(executeForCount(param));
page.setList(executeForList(param, rowBounds));
return page;
}
/**
* 执行总数的方法，调用方法执行计算总数，取得总结果
*
* @param param 参数信息
* @return 查询的总记录数
*/
private long executeForCount(Object param) {
Number result = (Number) sqlSession.selectOne(commandCountName, param);
return result.longValue();
}
/**
* 取得分页的执行结果，返回的是纪录信息
*
* @param param 参数
* @param rowBounds row
* @return 纪录列表
*/
private List<Object> executeForList(Object param, RowBounds rowBounds) {
return sqlSession.selectList(commandName, param, rowBounds);
}
/**
* 取得当前执行的参数信息
*
* @param args 参数
* @return 参数信息
*/
private Object getParam(Object[] args) {
final int paramCount = paramPositions.size();
if (args == null || paramCount == 0) {
return null;
} else if (!hasNamedParameters && paramCount == 1) {
return args[paramPositions.get(0)];
} else {
Map<String, Object> param = new HashMap<String, Object>();
for (int i = 0; i < paramCount; i++) {
param.put(paramNames.get(i), args[paramPositions.get(i)]);
}
return param;
}
}
private void setupMethodSignature() {
final Class<?>[] argTypes = method.getParameterTypes();
for (int i = 0; i < argTypes.length; i++) {
if (Page.class.isAssignableFrom(argTypes[i])) {
paginationIndex = i;
} else if (RowBounds.class.isAssignableFrom(argTypes[i])) {
rowBoundsIndex = i;
} else {
String paramName = String.valueOf(paramPositions.size());
paramName = getParamNameFromAnnotation(i, paramName);
paramNames.add(paramName);
paramPositions.add(i);
}
}
}
private String getParamNameFromAnnotation(int i, String paramName) {
Object[] annotations = method.getParameterAnnotations()[i];
for (Object annotation : annotations) {
if (annotation instanceof Param) {
hasNamedParameters = true;
paramName = ((Param) annotation).value();
}
}
return paramName;
}
/**
* 设置当前的查询总记录数的ID
*/
private void setupFields() {
commandName = declaringInterface.getName() + "." + method.getName();
commandCountName = commandName + "Count"; // 命名约定
}
/**
* 设置当前的参数的类型信息
*/
private void setupCommandType() {
MappedStatement ms = config.getMappedStatement(commandName);
type = ms.getSqlCommandType();
if (type != SqlCommandType.SELECT) {
throw new BindingException("Unsupport execution method for: " + commandName);
}
}
/**
* 验证Statement
*/
private void validateStatement() {
if (!config.hasStatement(commandName)) {
throw new BindingException("Invalid bound statement (not found): " + commandName);
}
if (!config.hasStatement(commandCountName)) {
throw new BindingException("Invalid bound statement (not found): " + commandCountName);
}
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/proxy/PaginationMapperProxy.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.proxy;
import org.apache.ibatis.binding.BindingException;
import org.apache.ibatis.binding.MapperMethod;
import org.apache.ibatis.session.SqlSession;
import com.jeespring.common.persistence.Page;
import com.jeespring.common.utils.Reflections;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashSet;
import java.util.Set;
/**
* <p>
* .
* </p>
*
* @author poplar.yfyang
* @version 1.0 2012-05-13 上午10:07
* @since JDK 1.5
*/
public class PaginationMapperProxy implements InvocationHandler {
private static final Set<String> OBJECT_METHODS = new HashSet<String>() {
private static final long serialVersionUID = -1782950882770203583L;
{
add("toString");
add("getClass");
add("hashCode");
add("equals");
add("wait");
add("notify");
add("notifyAll");
}
};
private boolean isObjectMethod(Method method) {
return OBJECT_METHODS.contains(method.getName());
}
private final SqlSession sqlSession;
private PaginationMapperProxy(final SqlSession sqlSession) {
this.sqlSession = sqlSession;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if (isObjectMethod(method)) {
return null;
}
final Class<?> declaringInterface = findDeclaringInterface(proxy, method);
if (Page.class.isAssignableFrom(method.getReturnType())) {
// 分页处理
return new PaginationMapperMethod(declaringInterface, method, sqlSession).execute(args);
}
// 原处理方式
final MapperMethod mapperMethod = new MapperMethod(declaringInterface, method, sqlSession.getConfiguration());
final Object result = mapperMethod.execute(sqlSession, args);
if (result == null && method.getReturnType().isPrimitive()) {
throw new BindingException(
"Mapper method '"
+ method.getName()
+ "' ("
+ method.getDeclaringClass()
+ ") attempted to return null from a method with a primitive return type ("
+ method.getReturnType() + ").");
}
return result;
}
private Class<?> findDeclaringInterface(Object proxy, Method method) {
Class<?> declaringInterface = null;
for (Class<?> mapperFaces : proxy.getClass().getInterfaces()) {
Method m = Reflections.getAccessibleMethod(mapperFaces,
method.getName(),
method.getParameterTypes());
if (m != null) {
declaringInterface = mapperFaces;
}
}
if (declaringInterface == null) {
throw new BindingException(
"Could not find interface with the given method " + method);
}
return declaringInterface;
}
@SuppressWarnings("unchecked")
public static <T> T newMapperProxy(Class<T> mapperInterface, SqlSession sqlSession) {
ClassLoader classLoader = mapperInterface.getClassLoader();
Class<?>[] interfaces = new Class[]{mapperInterface};
PaginationMapperProxy proxy = new PaginationMapperProxy(sqlSession);
return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/persistence/proxy/PaginationMapperRegistry.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
*/
package com.jeespring.common.persistence.proxy;
import org.apache.ibatis.binding.BindingException;
import org.apache.ibatis.binding.MapperRegistry;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
/**
* <p>
* .
* </p>
*
* @author poplar.yfyang
* @version 1.0 2012-05-13 上午10:06
* @since JDK 1.5
*/
public class PaginationMapperRegistry extends MapperRegistry {
public PaginationMapperRegistry(Configuration config) {
super(config);
}
@Override
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
if (!hasMapper(type)) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
return PaginationMapperProxy.newMapperProxy(type, sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/redis/JedisUtils.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright &copy; 2012-2016 <a href="https://www.jeespring.org>JeeSpring</a> All rights reserved.
*/
package com.jeespring.common.redis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.jeespring.common.utils.ObjectUtils;
import com.jeespring.common.utils.SpringContextHolder;
import com.jeespring.common.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.exceptions.JedisException;
/**
* Jedis Cache 工具类
*
* @author ThinkGem
* @version 2014-6-29
*/
public class JedisUtils {
private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);
private static JedisPool jedisPool = SpringContextHolder.getBean(JedisPool.class);
//public static final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");
/**
* 获取缓存
* @param key 键
* @return 值
*/
public static String get(String key) {
String value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.get(key);
value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
logger.debug("get {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("get {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 获取缓存
* @param key 键
* @return 值
*/
public static Object getObject(String key) {
Object value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
value = toObject(jedis.get(getBytesKey(key)));
logger.debug("getObject {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObject {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 设置缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String set(String key, String value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.set(key, value);
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("set {} = {}", key, value);
} catch (Exception e) {
logger.warn("set {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 设置缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String setObject(String key, Object value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.set(getBytesKey(key), toBytes(value));
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObject {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObject {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取List缓存
* @param key 键
* @return 值
*/
public static List<String> getList(String key) {
List<String> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.lrange(key, 0, -1);
logger.debug("getList {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 获取List缓存
* @param key 键
* @return 值
*/
public static List<Object> getObjectList(String key) {
List<Object> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
List<byte[]> list = jedis.lrange(getBytesKey(key), 0, -1);
value = Lists.newArrayList();
for (byte[] bs : list){
value.add(toObject(bs));
}
logger.debug("getObjectList {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 设置List缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setList(String key, List<String> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
jedis.del(key);
}
result = jedis.rpush(key, (String[])value.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setList {} = {}", key, value);
} catch (Exception e) {
logger.warn("setList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 设置List缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setObjectList(String key, List<Object> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
jedis.del(key);
}
List<byte[]> list = Lists.newArrayList();
for (Object o : value){
list.add(toBytes(o));
}
result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectList {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 向List缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static long listAdd(String key, String... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.rpush(key, value);
logger.debug("listAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("listAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 向List缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static long listObjectAdd(String key, Object... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
List<byte[]> list = Lists.newArrayList();
for (Object o : value){
list.add(toBytes(o));
}
result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
logger.debug("listObjectAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("listObjectAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取缓存
* @param key 键
* @return 值
*/
public static Set<String> getSet(String key) {
Set<String> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.smembers(key);
logger.debug("getSet {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 获取缓存
* @param key 键
* @return 值
*/
public static Set<Object> getObjectSet(String key) {
Set<Object> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
value = Sets.newHashSet();
Set<byte[]> set = jedis.smembers(getBytesKey(key));
for (byte[] bs : set){
value.add(toObject(bs));
}
logger.debug("getObjectSet {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 设置Set缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setSet(String key, Set<String> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
jedis.del(key);
}
result = jedis.sadd(key, (String[])value.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setSet {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 设置Set缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
jedis.del(key);
}
Set<byte[]> set = Sets.newHashSet();
for (Object o : value){
set.add(toBytes(o));
}
result = jedis.sadd(getBytesKey(key), (byte[][])set.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectSet {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 向Set缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static long setSetAdd(String key, String... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.sadd(key, value);
logger.debug("setSetAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSetAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 向Set缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static long setSetObjectAdd(String key, Object... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
Set<byte[]> set = Sets.newHashSet();
for (Object o : value){
set.add(toBytes(o));
}
result = jedis.rpush(getBytesKey(key), (byte[][])set.toArray());
logger.debug("setSetObjectAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSetObjectAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取Map缓存
* @param key 键
* @return 值
*/
public static Map<String, String> getMap(String key) {
Map<String, String> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.hgetAll(key);
logger.debug("getMap {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getMap {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 获取Map缓存
* @param key 键
* @return 值
*/
public static Map<String, Object> getObjectMap(String key) {
Map<String, Object> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
value = Maps.newHashMap();
Map<byte[], byte[]> map = jedis.hgetAll(getBytesKey(key));
for (Map.Entry<byte[], byte[]> e : map.entrySet()){
value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
}
logger.debug("getObjectMap {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectMap {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 设置Map缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String setMap(String key, Map<String, String> value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
jedis.del(key);
}
result = jedis.hmset(key, value);
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setMap {} = {}", key, value);
} catch (Exception e) {
logger.warn("setMap {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 设置Map缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String setObjectMap(String key, Map<String, Object> value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
jedis.del(key);
}
Map<byte[], byte[]> map = Maps.newHashMap();
for (Map.Entry<String, Object> e : value.entrySet()){
map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
}
result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectMap {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectMap {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 向Map缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static String mapPut(String key, Map<String, String> value) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hmset(key, value);
logger.debug("mapPut {} = {}", key, value);
} catch (Exception e) {
logger.warn("mapPut {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 向Map缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static String mapObjectPut(String key, Map<String, Object> value) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
Map<byte[], byte[]> map = Maps.newHashMap();
for (Map.Entry<String, Object> e : value.entrySet()){
map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
}
result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
logger.debug("mapObjectPut {} = {}", key, value);
} catch (Exception e) {
logger.warn("mapObjectPut {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 移除Map缓存中的值
* @param key 键
* @return
*/
public static long mapRemove(String key, String mapKey) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hdel(key, mapKey);
logger.debug("mapRemove {} {}", key, mapKey);
} catch (Exception e) {
logger.warn("mapRemove {} {}", key, mapKey, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 移除Map缓存中的值
* @param key 键
* @return
*/
public static long mapObjectRemove(String key, String mapKey) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hdel(getBytesKey(key), getBytesKey(mapKey));
logger.debug("mapObjectRemove {} {}", key, mapKey);
} catch (Exception e) {
logger.warn("mapObjectRemove {} {}", key, mapKey, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 判断Map缓存中的Key是否存在
* @param key 键
* @return
*/
public static boolean mapExists(String key, String mapKey) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hexists(key, mapKey);
logger.debug("mapExists {} {}", key, mapKey);
} catch (Exception e) {
logger.warn("mapExists {} {}", key, mapKey, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 判断Map缓存中的Key是否存在
* @param key 键
* @return
*/
public static boolean mapObjectExists(String key, String mapKey) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hexists(getBytesKey(key), getBytesKey(mapKey));
logger.debug("mapObjectExists {} {}", key, mapKey);
} catch (Exception e) {
logger.warn("mapObjectExists {} {}", key, mapKey, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 删除缓存
* @param key 键
* @return
*/
public static long del(String key) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)){
result = jedis.del(key);
logger.debug("del {}", key);
}else{
logger.debug("del {} not exists", key);
}
} catch (Exception e) {
logger.warn("del {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 删除缓存
* @param key 键
* @return
*/
public static long delObject(String key) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))){
result = jedis.del(getBytesKey(key));
logger.debug("delObject {}", key);
}else{
logger.debug("delObject {} not exists", key);
}
} catch (Exception e) {
logger.warn("delObject {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 缓存是否存在
* @param key 键
* @return
*/
public static boolean exists(String key) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.exists(key);
logger.debug("exists {}", key);
} catch (Exception e) {
logger.warn("exists {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 缓存是否存在
* @param key 键
* @return
*/
public static boolean existsObject(String key) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.exists(getBytesKey(key));
logger.debug("existsObject {}", key);
} catch (Exception e) {
logger.warn("existsObject {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取资源
* @return
* @throws JedisException
*/
public static Jedis getResource() throws JedisException {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
// logger.debug("getResource.", jedis);
} catch (JedisException e) {
logger.warn("getResource.", e);
returnBrokenResource(jedis);
throw e;
}
return jedis;
}
/**
* 归还资源
* @param jedis
*/
public static void returnBrokenResource(Jedis jedis) {
if (jedis != null) {
jedisPool.returnBrokenResource(jedis);
}
}
/**
* 释放资源
* @param jedis
*/
public static void returnResource(Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
}
/**
* 获取byte[]类型Key
* @return
*/
public static byte[] getBytesKey(Object object){
if(object instanceof String){
return StringUtils.getBytes((String)object);
}else{
return ObjectUtils.serialize(object);
}
}
/**
* 获取byte[]类型Key
* @param key
* @return
*/
public static Object getObjectKey(byte[] key){
try{
return StringUtils.toString(key);
}catch(UnsupportedOperationException uoe){
try{
return JedisUtils.toObject(key);
}catch(UnsupportedOperationException uoe2){
uoe2.printStackTrace();
}
}
return null;
}
/**
* Object转换byte[]类型
* @return
*/
public static byte[] toBytes(Object object){
return ObjectUtils.serialize(object);
}
/**
* byte[]型转换Object
* @return
*/
public static Object toObject(byte[] bytes){
return ObjectUtils.unserialize(bytes);
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/redis/RedisConfig.java deleted 100644 → 0
View file @ 51016ad9
package com.jeespring.common.redis;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import redis.clients.jedis.JedisPoolConfig;
@Configuration
@EnableAutoConfiguration
public class RedisConfig {
//private static Logger logger = Logger.getLogger(RedisConfig.class);
@Bean
@ConfigurationProperties(prefix="spring.redis")
public JedisPoolConfig getRedisConfig(){
JedisPoolConfig config = new JedisPoolConfig();
return config;
}
@Bean
@ConfigurationProperties(prefix="spring.redis")
public JedisConnectionFactory getConnectionFactory(){
JedisConnectionFactory factory = new JedisConnectionFactory();
JedisPoolConfig config = getRedisConfig();
factory.setPoolConfig(config);
//logger.info("JedisConnectionFactory bean init success.");
return factory;
}
@Bean
public RedisTemplate<?, ?> getRedisTemplate(){
RedisTemplate<?,?> template = new StringRedisTemplate(getConnectionFactory());
return template;
}
}
JeeSpringCloud/src/main/java/com/jeespring/common/redis/RedisRestController.java deleted 100644 → 0
View file @ 51016ad9
package com.jeespring.common.redis;
import com.jeespring.common.web.Result;
import com.jeespring.common.web.ResultFactory;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@RestController
@RequestMapping("/rest/redis")
@Api(value="Redis云数据缓存接口", description="Redis云数据缓存接口")
public class RedisRestController {
@Autowired
private RedisUtils redisUtils;
@RequestMapping(value = "/test",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis Test信息(Content-Type为text/html)", notes="Redis Test(Content-Type为text/html)")
public String test(){
redisUtils.set("Redis Test", "Redis Test");
String string= redisUtils.get("Redis Test").toString();
return string;
}
/**
* 批量删除对应的value
*
* @param keys
*/
@RequestMapping(value ="/removeList",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis remove接口(Content-Type为text/html)", notes="Redis remove接口(Content-Type为text/html)")
public Result removeList(@RequestParam(required=false) String keys) {
String [] keysList=keys.split(",");
for(String key:keysList) {
redisUtils.remove(key);
}
return ResultFactory.getSuccessResult("移除成功！");
}
/**
* 批量删除key
*
* @param pattern
*/
@RequestMapping(value ="/removePattern",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis remove pattern接口(Content-Type为text/html)", notes="Redis remove pattern接口接口(Content-Type为text/html)")
public Result removePattern(@RequestParam(required=false) String pattern) {
redisUtils.removePattern(pattern);
return ResultFactory.getSuccessResult("移除成功！");
}
@RequestMapping(value ="/removePatternShiroRedis",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis remove pattern Shiro Reids接口(Content-Type为text/html)", notes="Redis remove pattern Shiro Reids接口接口(Content-Type为text/html)")
public Result removePatternShiroReids(@RequestParam(required=false) String pattern) {
redisUtils.removePatternShiroReids(pattern);
return ResultFactory.getSuccessResult("移除成功！");
}
/**
* 删除对应的value
*
* @param key
*/
@RequestMapping(value ="/remove",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis remove接口(Content-Type为text/html)", notes="Redis remove接口(Content-Type为text/html)")
public Result remove(@RequestParam(required=false) String key) {
redisUtils.remove(key);
return ResultFactory.getSuccessResult("移除成功！");
}
/**
* 判断缓存中是否有对应的value
*
* @param key
* @return
*/
@RequestMapping(value ="/exists",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis exists接口(Content-Type为text/html)", notes="Redis exists接口(Content-Type为text/html)")
public Result exists(@RequestParam(required=false) String key) {
if(redisUtils.exists(key))
return ResultFactory.getSuccessResult("存在！");
else
return ResultFactory.getErrorResult("不存在！");
}
/**
* 读取缓存
*
* @param key
* @return
*/
@RequestMapping(value ="/get",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get接口(Content-Type为text/html)", notes="Redis get接口(Content-Type为text/html)")
public Result get(@RequestParam(required=false) String key) {
if(redisUtils.exists(key)){
Result result = ResultFactory.getSuccessResult();
Object obj=redisUtils.get(key);
if(obj!=null)
result.setResultObject(obj.toString());
return result;
}else{
return ResultFactory.getErrorResult("不存在！");
}
}
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
@RequestMapping(value ="/set",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis set接口(Content-Type为text/html)", notes="Redis set接口(Content-Type为text/html)")
public Result set(@RequestParam(required=false) String key,@RequestParam(required=false) String value) {
if(redisUtils.set(key,value)){
Result result = ResultFactory.getSuccessResult("添加/更新成功！");
return result;
}else{
return ResultFactory.getErrorResult("添加/更新失败！");
}
}
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
@RequestMapping(value ="/setExpireTime",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis set expireTime接口(Content-Type为text/html)", notes="Redis set expireTime接口接口(Content-Type为text/html)")
public Result set(@RequestParam(required=false) String key,@RequestParam(required=false) String value,@RequestParam(required=false) Long expireTime) {
if(redisUtils.set(key,value,expireTime)){
Result result = ResultFactory.getSuccessResult("添加/更新成功！");
return result;
}else{
return ResultFactory.getErrorResult("添加/更新失败！");
}
}
/**
* 获取keys
*
* @param pattern
*/
@RequestMapping(value ="/getKyes",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get kyes接口(Content-Type为text/html)", notes="Redis get kyes接口接口(Content-Type为text/html)")
public Result getKyes(@RequestParam(required=false) String pattern) {
Set<String> keys = redisUtils.getKyes(pattern);
Result result = ResultFactory.getSuccessResult("获取Keys成功！");
result.setResultObject(keys);
return result;
}
@RequestMapping(value ="/getKyesAll",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get kyes all接口(Content-Type为text/html)", notes="Redis get kyes all接口(Content-Type为text/html)")
public Result getKyesAll() {
Set<String> keys = redisUtils.getKyesAll();
Result result = ResultFactory.getSuccessResult("获取Keys成功！");
result.setResultObject(keys);
return result;
}
/**
* 获取keys
*
* @param pattern
*/
@RequestMapping(value ="/getCount",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get count接口(Content-Type为text/html)", notes="Redis get count接口(Content-Type为text/html)")
public Result getCount(@RequestParam(required=false) String pattern) {
Result result = ResultFactory.getSuccessResult("获取数量成功！");
result.setResultObject(redisUtils.getCount());
return result;
}
@RequestMapping(value ="/getCountShiro",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get count shiro接口(Content-Type为text/html)", notes="Redis get count shiro接口(Content-Type为text/html)")
public Result getCountShiro(@RequestParam(required=false) String pattern) {
Result result = ResultFactory.getSuccessResult("获取数量成功！");
result.setResultObject(redisUtils.getCountShiro());
return result;
}
/**
* 获取token的有效期（秒）
* @param key
*/
@RequestMapping(value ="/getExpireTime",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get ExpireTime接口(Content-Type为text/html)", notes="Redis get ExpireTime接口接口(Content-Type为text/html)")
public Result getExpireTime(@RequestParam(required=false) String key){
Result result = ResultFactory.getSuccessResult("获取token的有效期（秒）成功！");
result.setResultObject(redisUtils.getExpireTime(key));
return result;
}
/**
* 获取缓存有效期成功
*/
@RequestMapping(value ="/getExpire",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get getExpire(Content-Type为text/html)", notes="Redis get getExpire(Content-Type为text/html)")
public Result getExpire(){
Result result = ResultFactory.getSuccessResult("获取缓存有效期成功！");
result.setResultObject(RedisUtils.getExpire());
return result;
}
/**
* 获取单点登录缓存有效期成功
*/
@RequestMapping(value ="/getExpireShiro",method ={RequestMethod.POST,RequestMethod.GET})
@ApiOperation(value="Redis get getExpireShiro(Content-Type为text/html)", notes="Redis get getExpireShiro(Content-Type为text/html)")
public Result getExpireShiro(){
Result result = ResultFactory.getSuccessResult("获取单点登录缓存有效期成功！");
result.setResultObject(RedisUtils.getExpireShiro());
return result;
}
}
\ No newline at end of file
JeeSpringCloud/src/main/java/com/jeespring/common/redis/RedisUtils.java deleted 100644 → 0
View file @ 51016ad9
package com.jeespring.common.redis;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import com.jeespring.common.config.Global;
import com.jeespring.common.security.MD5Tools;
import com.sun.tools.javac.util.Convert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
/**
* redicache 工具类
* 在application.yml文件内的Spring-redis的run配置启动,true为启动;false为不启动;
*/
@SuppressWarnings("unchecked")
@Component
public class RedisUtils {
/**
* 日志对象
*/
private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);
public static String SHIRO_REDIS="shiro_redis_cache";
public static String SHIRO_REDIS_OBJECT="org.apache.shiro.subject.SimplePrincipalCollection";
public static String GET_ID =".get id=";
public static String TOTAL_KEY =".total key=";
public static String FIND_LIST_KEY =".findList key=";
public static String FIND_LIST_FIRST_KEY =".findListFirst key=";
public static String FIND_PAGE_KEY =".findPage key=";
public static String FIND_LIST_KEY_PATTERN =".findList key=*";
public static String FIND_LIST_FIRST_KEY_PATTERN =".findListFirst key=*";
public static String FIND_PAGE_KEY_PATTERN =".findPage key=*";
public static String KEY_PREFIX =Global.getConfig("spring.redis.keyPrefix");
public static Long expireTime= Long.parseLong(Global.getConfig("spring.redis.expireTime"));
public static Long expireTimeShiro= Long.parseLong(Global.getConfig("spring.redis.expireTimeShiro"));
public static String RUN_MESSAGE="请开启Redis服务,还有Redis密码配置是否有误，而且密码不能为空（为空时Redis服务会连接不上）。";
@SuppressWarnings("rawtypes")
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private StringRedisTemplate stringRedisTemplate;
public static String getExpire(){
if(expireTime!=null)
return String.valueOf(expireTime/60)+"分钟";
else
return "0分钟";
}
public static String getExpireShiro(){
if(expireTimeShiro!=null)
return String.valueOf(expireTimeShiro/60)+"分钟";
else
return "0分钟";
}
public static String getKey(String className,String keyName,String keyId){
if(className==null){className="";}
if(keyId==null){keyId="";}
return RedisUtils.KEY_PREFIX+className+keyName+keyId;
}
public static String getIdKey(String className,String keyId){
if(className==null){className="";}
if(keyId==null){keyId="";}
return RedisUtils.KEY_PREFIX+className+RedisUtils.GET_ID+keyId;
}
public static String getTotalKey(String className,String keyId){
if(className==null){className="";}
if(keyId==null){keyId="";}
return RedisUtils.KEY_PREFIX+className+RedisUtils.TOTAL_KEY+MD5Tools.MD5(keyId).substring(0,20);
}
public static String getFindListKey(String className,String keyId){
if(className==null){className="";}
if(keyId==null){keyId="";}
return RedisUtils.KEY_PREFIX+className+RedisUtils.FIND_LIST_KEY+MD5Tools.MD5(keyId).substring(0,20);
}
public static String getFindListFirstKey(String className,String keyId){
if(className==null){className="";}
if(keyId==null){keyId="";}
return RedisUtils.KEY_PREFIX+className+RedisUtils.FIND_LIST_FIRST_KEY+MD5Tools.MD5(keyId).substring(0,20);
}
public static String getFindPageKey(String className,String keyId){
if(className==null){className="";}
if(keyId==null){keyId="";}
return RedisUtils.KEY_PREFIX+className+RedisUtils.FIND_PAGE_KEY+MD5Tools.MD5(keyId).substring(0,20);
}
public static String getFindListKeyPattern(String className){
if(className==null){className="";}
return RedisUtils.KEY_PREFIX+className+FIND_LIST_KEY_PATTERN;
}
public static String getFinPageKeyPattern(String className){
if(className==null){className="";}
return RedisUtils.KEY_PREFIX+className+FIND_PAGE_KEY_PATTERN;
}
/**
* 获取token的有效期（秒）
* @param key
*/
public long getExpireTime(String key){
long time = redisTemplate.getExpire(key,TimeUnit.SECONDS);
return time;
}
/**
* 批量删除对应的value
*
* @param keys
*/
public void remove(final String... keys) {
if(!run()) { return; }
try{
for (String key : keys) {
remove(key);
}
} catch (Exception e) {
logger.error("RedisUtils remove:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
}
/**
* 批量删除key
*
* @param pattern
*/
public void removePattern(String pattern) {
if(!run()) { return;}
if(!listFlush()){
return ;
}
try{
if(pattern==null) pattern="";
Set<String> keys=getKyes(pattern);
if (keys.size() > 0)
redisTemplate.delete(keys);
} catch (Exception e) {
logger.error("RedisUtils removePattern:"+RUN_MESSAGE+e.getMessage(),RUN_MESSAGE+ e.getMessage());
}
}
public void removePatternShiroReids(String pattern){
if(!run()) { return;}
if(!listFlush()){
return ;
}
try{
if(pattern==null) pattern="";
Set<String> keys=getKyesShiroReids(pattern);
if (keys.size() > 0){
stringRedisTemplate.delete(keys);
redisTemplate.delete(keys);
}
} catch (Exception e) {
logger.error("RedisUtils removePattern:"+RUN_MESSAGE+e.getMessage(),RUN_MESSAGE+ e.getMessage());
}
}
/**
* 获取keys
*
* @param pattern
*/
public Set<String> getKyes(String pattern) {
if(!run()) { return null; }
try{
if(pattern==null){ pattern=""; }
Set<String> keys=stringRedisTemplate.keys("*"+pattern);
Set<String> keysnew=new HashSet<String>();
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
keysnew.add(it.next().substring(7));
}
return keysnew;
} catch (Exception e) {
logger.error("RedisUtils getKyes:"+RUN_MESSAGE+e.getMessage(), e.getMessage());
return null;
}
}
public Set<String> getKyesShiroReids(String pattern) {
if(!run()) { return null; }
try{
if(pattern==null){ pattern=""; }
Set<String> keys=stringRedisTemplate.keys("*"+pattern);
Set<String> keysnew=new HashSet<String>();
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
String tr = it.next();
if(tr.contains(SHIRO_REDIS))
keysnew.add(tr);
else if(tr.contains(SHIRO_REDIS_OBJECT))
keysnew.add(tr.substring(8));
}
return keysnew;
} catch (Exception e) {
logger.error("RedisUtils getKyes:"+RUN_MESSAGE+e.getMessage(), e.getMessage());
return null;
}
}
public Set<String> getKyesAll() {
if(!run()) { return null; }
try{
Set<String> keys=stringRedisTemplate.keys("*");
Set<String> keysnew=new HashSet<String>();
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
keysnew.add(it.next());
}
return keysnew;
} catch (Exception e) {
logger.error("RedisUtils getKyes:"+RUN_MESSAGE+e.getMessage(), e.getMessage());
return null;
}
}
/**
* 获取Count
*
*/
public int getCount() {
if(!run()) { return 0; }
try{
Set<String> keys=stringRedisTemplate.keys("*");
return keys.size();
} catch (Exception e) {
logger.error("RedisUtils getCount:"+RUN_MESSAGE+e.getMessage(), e.getMessage());
return 0;
}
}
public int getCountShiro() {
if(!run()) { return 0; }
try{
Set<String> keys=stringRedisTemplate.keys(SHIRO_REDIS+"*");
return keys.size();
} catch (Exception e) {
logger.error("RedisUtils getCount:"+RUN_MESSAGE+e.getMessage(), e.getMessage());
return 0;
}
}
/**
* 删除对应的value
*
* @param key
*/
public void remove(final String key) {
if(!run()) { return ; }
try{
if(key.contains(SHIRO_REDIS)) {
stringRedisTemplate.delete(key);
}else{
redisTemplate.delete(key);
}
} catch (Exception e) {
logger.error("RedisUtils exists:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
}
/**
* 判断缓存中是否有对应的value
*
* @param key
* @return
*/
public boolean exists(final String key) {
if(!run()) { return false; }
boolean retuslt=false;
try{
if(key.contains(SHIRO_REDIS))
retuslt= stringRedisTemplate.hasKey(key);
else
retuslt= redisTemplate.hasKey(key);
} catch (Exception e) {
logger.error("RedisUtils exists:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
return retuslt;
}
/**
* 读取缓存
*
* @param key
* @return
*/
public Object get(final String key) {
if(!run()) { return null; }
Object result = null;
try{
if(key.contains(SHIRO_REDIS)){
ValueOperations<String, String> operationsString = stringRedisTemplate.opsForValue();
result = operationsString.get(key);
}else {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
result = operations.get(key);
}
return result;
}catch (Exception e){
logger.error("RedisUtils get:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
return result;
}
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value) {
if(!run()) { return false; }
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
logger.error("RedisUtils set:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
return result;
}
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value, Long expireTime) {
if(!run()) { return false; }
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
logger.error("RedisUtils set:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
return result;
}
public boolean set(final String key, Object value, Long expireTime,TimeUnit unit) {
if(!run()) { return false; }
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, unit);
result = true;
} catch (Exception e) {
logger.error("RedisUtils set:"+RUN_MESSAGE+e.getMessage(), RUN_MESSAGE+e.getMessage());
}
return result;
}
private boolean run(){
if(Global.getConfig("spring.redis.run")=="true") {
return true;
}
return false;
}
public static boolean isRun(){
if(Global.getConfig("spring.redis.run")=="true") {
return true;
}
return false;
}
public static boolean isShireRedis(){
if(Global.getConfig("spring.redis.run")!="true") {
return false;
}
if(Global.getConfig("shiro.redis")!="true") {
return false;
}
return true;
}
private boolean listFlush(){
if(Global.getConfig("spring.redis.listFlush")=="true")
return true;
return false;
}
}
\ No newline at end of file
JeeSpringCloud/src/main/java/com/jeespring/common/security/Cryptos.java deleted 100644 → 0
View file @ 51016ad9
/**
* Copyright (c) 2005-2012 springside.org.cn
*/
package com.jeespring.common.security;
import java.io.UnsupportedEncodingException;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.util.Arrays;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import com.jeespring.common.utils.Encodes;
import com.jeespring.common.utils.Exceptions;
/**
* 支持HMAC-SHA1消息签名 及 DES/AES对称加密的工具类.
*
* 支持Hex与Base64两种编码方式.
*
* @author calvin
*/
public class Cryptos {
private static final String AES = "AES";
private static final String AES_CBC = "AES/CBC/PKCS5Padding";
private static final String HMACSHA1 = "HmacSHA1";
private static final String DEFAULT_URL_ENCODING = "UTF-8";
private static final int DEFAULT_HMACSHA1_KEYSIZE = 160; //RFC2401
private static final int DEFAULT_AES_KEYSIZE = 128;
private static final int DEFAULT_IVSIZE = 16;
private static final byte[] DEFAULT_KEY = new byte[]{-97,88,-94,9,70,-76,126,25,0,3,-20,113,108,28,69,125};
private static SecureRandom random = new SecureRandom();
//-- HMAC-SHA1 funciton --//
/**
* 使用HMAC-SHA1进行消息签名, 返回字节数组,长度为20字节.
*
* @param input 原始输入字符数组
* @param key HMAC-SHA1密钥
*/
public static byte[] hmacSha1(byte[] input, byte[] key) {
try {
SecretKey secretKey = new SecretKeySpec(key, HMACSHA1);
Mac mac = Mac.getInstance(HMACSHA1);
mac.init(secretKey);
return mac.doFinal(input);
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
/**
* 校验HMAC-SHA1签名是否正确.
*
* @param expected 已存在的签名
* @param input 原始输入字符串
* @param key 密钥
*/
public static boolean isMacValid(byte[] expected, byte[] input, byte[] key) {
byte[] actual = hmacSha1(input, key);
return Arrays.equals(expected, actual);
}
/**
* 生成HMAC-SHA1密钥,返回字节数组,长度为160位(20字节).
* HMAC-SHA1算法对密钥无特殊要求, RFC2401建议最少长度为160位(20字节).
*/
public static byte[] generateHmacSha1Key() {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance(HMACSHA1);
keyGenerator.init(DEFAULT_HMACSHA1_KEYSIZE);
SecretKey secretKey = keyGenerator.generateKey();
return secretKey.getEncoded();
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
//-- AES funciton --//
/**
* 使用AES加密原始字符串.
*
* @param input 原始输入字符数组
*/
public static String aesEncrypt(String input) {
try {
return Encodes.encodeHex(aesEncrypt(input.getBytes(DEFAULT_URL_ENCODING), DEFAULT_KEY));
} catch (UnsupportedEncodingException e) {
return "";
}
}
/**
* 使用AES加密原始字符串.
*
* @param input 原始输入字符数组
* @param key 符合AES要求的密钥
*/
public static String aesEncrypt(String input, String key) {
try {
return Encodes.encodeHex(aesEncrypt(input.getBytes(DEFAULT_URL_ENCODING), Encodes.decodeHex(key)));
} catch (UnsupportedEncodingException e) {
return "";
}
}
/**
* 使用AES加密原始字符串.
*
* @param input 原始输入字符数组
* @param key 符合AES要求的密钥
*/
public static byte[] aesEncrypt(byte[] input, byte[] key) {
return aes(input, key, Cipher.ENCRYPT_MODE);
}
/**
* 使用AES加密原始字符串.
*
* @param input 原始输入字符数组
* @param key 符合AES要求的密钥
* @param iv 初始向量
*/
public static byte[] aesEncrypt(byte[] input, byte[] key, byte[] iv) {
return aes(input, key, iv, Cipher.ENCRYPT_MODE);
}
/**
* 使用AES解密字符串, 返回原始字符串.
*
* @param input Hex编码的加密字符串
*/
public static String aesDecrypt(String input) {
try {
return new String(aesDecrypt(Encodes.decodeHex(input), DEFAULT_KEY), DEFAULT_URL_ENCODING);
} catch (UnsupportedEncodingException e) {
return "";
}
}
/**
* 使用AES解密字符串, 返回原始字符串.
*
* @param input Hex编码的加密字符串
* @param key 符合AES要求的密钥
*/
public static String aesDecrypt(String input, String key) {
try {
return new String(aesDecrypt(Encodes.decodeHex(input), Encodes.decodeHex(key)), DEFAULT_URL_ENCODING);
} catch (UnsupportedEncodingException e) {
return "";
}
}
/**
* 使用AES解密字符串, 返回原始字符串.
*
* @param input Hex编码的加密字符串
* @param key 符合AES要求的密钥
*/
public static byte[] aesDecrypt(byte[] input, byte[] key) {
return aes(input, key, Cipher.DECRYPT_MODE);
}
/**
* 使用AES解密字符串, 返回原始字符串.
*
* @param input Hex编码的加密字符串
* @param key 符合AES要求的密钥
* @param iv 初始向量
*/
public static byte[] aesDecrypt(byte[] input, byte[] key, byte[] iv) {
return aes(input, key, iv, Cipher.DECRYPT_MODE);
}
/**
* 使用AES加密或解密无编码的原始字节数组, 返回无编码的字节数组结果.
*
* @param input 原始字节数组
* @param key 符合AES要求的密钥
* @param mode Cipher.ENCRYPT_MODE 或 Cipher.DECRYPT_MODE
*/
private static byte[] aes(byte[] input, byte[] key, int mode) {
try {
SecretKey secretKey = new SecretKeySpec(key, AES);
Cipher cipher = Cipher.getInstance(AES);
cipher.init(mode, secretKey);
return cipher.doFinal(input);
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
/**
* 使用AES加密或解密无编码的原始字节数组, 返回无编码的字节数组结果.
*
* @param input 原始字节数组
* @param key 符合AES要求的密钥
* @param iv 初始向量
* @param mode Cipher.ENCRYPT_MODE 或 Cipher.DECRYPT_MODE
*/
private static byte[] aes(byte[] input, byte[] key, byte[] iv, int mode) {
try {
SecretKey secretKey = new SecretKeySpec(key, AES);
IvParameterSpec ivSpec = new IvParameterSpec(iv);
Cipher cipher = Cipher.getInstance(AES_CBC);
cipher.init(mode, secretKey, ivSpec);
return cipher.doFinal(input);
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
/**
* 生成AES密钥,返回字节数组, 默认长度为128位(16字节).
*/
public static String generateAesKeyString() {
return Encodes.encodeHex(generateAesKey(DEFAULT_AES_KEYSIZE));
}
/**
* 生成AES密钥,返回字节数组, 默认长度为128位(16字节).
*/
public static byte[] generateAesKey() {
return generateAesKey(DEFAULT_AES_KEYSIZE);
}
/**
* 生成AES密钥,可选长度为128,192,256位.
*/
public static byte[] generateAesKey(int keysize) {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance(AES);
keyGenerator.init(keysize);
SecretKey secretKey = keyGenerator.generateKey();
return secretKey.getEncoded();
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
/**
* 生成随机向量,默认大小为cipher.getBlockSize(), 16字节.
*/
public static byte[] generateIV() {
byte[] bytes = new byte[DEFAULT_IVSIZE];
random.nextBytes(bytes);
return bytes;
}
}
\ No newline at end of file
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment