+
+
+
+
Just for Inner Use.
* @@ -69,27 +78,29 @@ public abstract class CacheChannel implements Closeable , AutoCloseable { */ public CacheObject get(String region, String key, boolean...cacheNullObject) { + this.assertNotClose(); + CacheObject obj = new CacheObject(region, key, CacheObject.LEVEL_1); - obj.setValue(CacheProviderHolder.getLevel1Cache(region).get(key)); + obj.setValue(holder.getLevel1Cache(region).get(key)); if(obj.rawValue() != null) return obj; String lock_key = key + '%' + region; synchronized (_g_keyLocks.computeIfAbsent(lock_key, v -> new Object())) { - obj.setValue(CacheProviderHolder.getLevel1Cache(region).get(key)); + obj.setValue(holder.getLevel1Cache(region).get(key)); if(obj.rawValue() != null) return obj; try { obj.setLevel(CacheObject.LEVEL_2); - obj.setValue(CacheProviderHolder.getLevel2Cache(region).get(key)); - if (obj.rawValue() != null) - CacheProviderHolder.getLevel1Cache(region).put(key, obj.rawValue()); - else { - boolean cacheNull = (cacheNullObject.length>0)?cacheNullObject[0]: defaultCacheNullObject; - if(cacheNull) - set(region, key, newNullObject(), true); - } + obj.setValue(holder.getLevel2Cache(region).get(key)); + if (obj.rawValue() != null) { + holder.getLevel1Cache(region).put(key, obj.rawValue()); + }else { + boolean cacheNull = (cacheNullObject.length > 0) ? cacheNullObject[0] : defaultCacheNullObject; + if (cacheNull) + set(region, key, newNullObject(), true); + } } finally { _g_keyLocks.remove(lock_key); } @@ -107,6 +118,9 @@ public abstract class CacheChannel implements Closeable , AutoCloseable { * @return cache object */ public CacheObject get(String region, String key, Function+ * Licensed 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.
+ */
+package net.oschina.j2cache.lettuce;
+
+import io.lettuce.core.api.StatefulConnection;
+import io.lettuce.core.api.StatefulRedisConnection;
+import io.lettuce.core.api.sync.BaseRedisCommands;
+import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
+import net.oschina.j2cache.CacheException;
+import net.oschina.j2cache.Level2Cache;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+
+/**
+ * Lettuce 的基类，封装了普通 Redis 连接和集群 Redis 连接的差异
+ *
+ * @author Winter Lau(javayou@gmail.com)
+ */
+public abstract class LettuceCache implements Level2Cache {
+
+ protected String namespace;
+ protected String region;
+ protected GenericObjectPool PathMatcher implementation for Ant-style path patterns.
+ * Examples are provided below. Part of this mapping code has been kindly borrowed from
+ * Apache Ant.
+ *
+ * The mapping matches URLs using the following rules: Some examples: N.B.: This class was borrowed (with much appreciation) from the
+ * Spring Framework with modifications. We didn't want to reinvent the
+ * wheel of great work they've done, but also didn't want to force every Shiro user to depend on Spring As per the Apache 2.0 license, the original copyright notice and all author and copyright information have
+ * remained in tact. For example:
+ * Assumes that {@link #match} returns
+ * Licensed 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.
+ */
+package net.oschina.j2cache.util;
+
+import com.jfirer.fse.ByteArray;
+import com.jfirer.fse.Fse;
+
+/**
+ * 使用 fse 实现序列化
+ *
+ * @author whcrow (v@whcrow.com)
+ */
+public class FseSerializer implements Serializer {
+
+ @Override
+ public String name() {
+ return "fse";
+ }
+
+ @Override
+ public byte[] serialize(Object obj) {
+ ByteArray buf = ByteArray.allocate(100);
+ new Fse().serialize(obj, buf);
+ byte[] resultBytes = buf.toArray();
+ buf.clear();
+ return resultBytes;
+ }
+
+ @Override
+ public Object deserialize(byte[] bytes) {
+ if (bytes == null || bytes.length == 0) {
+ return null;
+ }
+ ByteArray buf = ByteArray.allocate(100);
+ buf.put(bytes);
+ Object result = new Fse().deSerialize(buf);
+ buf.clear();
+ return result;
+ }
+
+}
diff --git a/core/src/net/oschina/j2cache/util/PatternMatcher.java b/core/src/net/oschina/j2cache/util/PatternMatcher.java
new file mode 100644
index 0000000000000000000000000000000000000000..303ff737f520871702f7a58a0f0f06b83b14888d
--- /dev/null
+++ b/core/src/net/oschina/j2cache/util/PatternMatcher.java
@@ -0,0 +1,24 @@
+package net.oschina.j2cache.util;
+
+/**
+ * Interface for components that can match source strings against a specified pattern string.
+ *
+ * Licensed 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.
+ */
+package net.oschina.j2cache.hibernate5.log;
+
+import org.hibernate.internal.CoreMessageLogger;
+import org.jboss.logging.LogMessage;
+import org.jboss.logging.Logger.Level;
+import org.jboss.logging.Message;
+import org.jboss.logging.MessageLogger;
+
+@MessageLogger(projectCode = "HHH")
+public interface J2CacheMessageLogger extends CoreMessageLogger {
+
+
+ @LogMessage(level = Level.WARN)
+ @Message(
+ value = "Attempt to restart an already started J2CacheRegionFactory. Use sessionFactory.close() between " +
+ "repeated calls to buildSessionFactory. Using previously created J2CacheRegionFactory. If this " +
+ "behaviour is required, consider using org.hibernate.cache.j2cache.SingletonJ2CacheRegionFactory.",
+ id = 20001
+ )
+ void attemptToRestartAlreadyStartedJ2CacheProvider();
+
+ /**
+ * Log a message (WARN) about inability to find configuration file
+ *
+ * @param name The name of the configuration file
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(value = "Could not find configuration [%s]; using defaults.", id = 20002)
+ void unableToFindConfiguration(String name);
+
+ /**
+ * Log a message (WARN) about inability to find named cache configuration
+ *
+ * @param name The name of the cache configuration
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(value = "Could not find a specific J2Cache configuration for cache named [%s]; using defaults.", id = 20003)
+ void unableToFindJ2CacheConfiguration(String name);
+
+ /**
+ * Logs a message about not being able to resolve the configuration by resource name.
+ *
+ * @param configurationResourceName The resource name we attempted to resolve
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(
+ value = "A configurationResourceName was set to %s but the resource could not be loaded from the classpath. " +
+ "J2Cache will configure itself using defaults.",
+ id = 20004
+ )
+ void unableToLoadConfiguration(String configurationResourceName);
+
+ /**
+ * Logs a message (WARN) about attempt to use an incompatible
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(
+ value = "The default cache value mode for this J2Cache configuration is \"identity\". " +
+ "This is incompatible with clustered Hibernate caching - the value mode has therefore been " +
+ "switched to \"serialization\"",
+ id = 20005
+ )
+ void incompatibleCacheValueMode();
+
+ /**
+ * Logs a message (WARN) about attempt to use an incompatible
+ *
+ * @param cacheName The name of the cache whose config attempted to specify value mode.
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(value = "The value mode for the cache[%s] is \"identity\". This is incompatible with clustered Hibernate caching - "
+ + "the value mode has therefore been switched to \"serialization\"", id = 20006)
+ void incompatibleCacheValueModePerCache(String cacheName);
+
+ /**
+ * Log a message (WARN) about an attempt to specify read-only caching for a mutable entity
+ *
+ * @param entityName The name of the entity
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(value = "read-only cache configured for mutable entity [%s]", id = 20007)
+ void readOnlyCacheConfiguredForMutableEntity(String entityName);
+
+ /**
+ * Log a message (WARN) about expiry of soft-locked region.
+ *
+ * @param regionName The region name
+ * @param key The cache key
+ * @param lock The lock
+ */
+ @LogMessage(level = Level.WARN)
+ @Message(
+ value = "Cache[%s] Key[%s] Lockable[%s]\n" +
+ "A soft-locked cache entry was expired by the underlying J2Cache. If this happens regularly you " +
+ "should consider increasing the cache timeouts and/or capacity limits",
+ id = 20008
+ )
+ void softLockedCacheExpired(String regionName, Object key, String lock);
+
+}
\ No newline at end of file
diff --git a/modules/hibernate5/src/net/oschina/j2cache/hibernate5/log/J2CacheMessageLogger_$logger.java b/modules/hibernate5/src/net/oschina/j2cache/hibernate5/log/J2CacheMessageLogger_$logger.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d622713ae76c3b1d588f6d927cf8221a793bbe0
--- /dev/null
+++ b/modules/hibernate5/src/net/oschina/j2cache/hibernate5/log/J2CacheMessageLogger_$logger.java
@@ -0,0 +1,3522 @@
+/**
+ * Copyright (c) 2015-2017.
+ *
+ * Licensed 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.
+ */
+package net.oschina.j2cache.hibernate5.log;
+
+import org.hibernate.HibernateException;
+import org.hibernate.LockMode;
+import org.hibernate.cache.CacheException;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.engine.jdbc.dialect.spi.DialectResolver;
+import org.hibernate.engine.jndi.JndiException;
+import org.hibernate.engine.jndi.JndiNameException;
+import org.hibernate.engine.loading.internal.CollectionLoadContext;
+import org.hibernate.engine.loading.internal.EntityLoadContext;
+import org.hibernate.engine.spi.CollectionKey;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.id.IntegralDataTypeHolder;
+import org.hibernate.internal.CoreMessageLogger;
+import org.hibernate.type.BasicType;
+import org.hibernate.type.SerializationException;
+import org.hibernate.type.Type;
+import org.jboss.logging.BasicLogger;
+import org.jboss.logging.DelegatingBasicLogger;
+import org.jboss.logging.Logger;
+
+import javax.annotation.Generated;
+import javax.naming.NameNotFoundException;
+import javax.naming.NamingException;
+import javax.transaction.Synchronization;
+import javax.transaction.SystemException;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.util.*;
+
+@Generated(value = "org.jboss.logging.processor.generator.model.MessageLoggerImplementor", date = "2015-01-06T12:13:01-0800")
+public class J2CacheMessageLogger_$logger extends DelegatingBasicLogger implements Serializable, J2CacheMessageLogger, CoreMessageLogger, BasicLogger {
+
+ private static final long serialVersionUID = 1L;
+ private static final String FQCN = J2CacheMessageLogger_$logger.class.getName();
+ private static final Locale LOCALE;
+ private static final String attemptToRestartAlreadyStartedJ2CacheProvider = "HHH020001: Attempt to restart an already started J2CacheRegionFactory. Use sessionFactory.close() between repeated calls to buildSessionFactory. Using previously created J2CacheRegionFactory. If this behaviour is required, consider using org.hibernate.cache.ehcache.SingletonJ2CacheRegionFactory.";
+ private static final String unableToFindConfiguration = "HHH020002: Could not find configuration [%s]; using defaults.";
+ private static final String unableToFindJ2CacheConfiguration = "HHH020003: Could not find a specific ehcache configuration for cache named [%s]; using defaults.";
+ private static final String unableToLoadConfiguration = "HHH020004: A configurationResourceName was set to %s but the resource could not be loaded from the classpath. Ehcache will configure itself using defaults.";
+ private static final String incompatibleCacheValueMode = "HHH020005: The default cache value mode for this Ehcache configuration is \"identity\". This is incompatible with clustered Hibernate caching - the value mode has therefore been switched to \"serialization\"";
+ private static final String incompatibleCacheValueModePerCache = "HHH020006: The value mode for the cache[%s] is \"identity\". This is incompatible with clustered Hibernate caching - the value mode has therefore been switched to \"serialization\"";
+ private static final String readOnlyCacheConfiguredForMutableEntity = "HHH020007: read-only cache configured for mutable entity [%s]";
+ private static final String softLockedCacheExpired = "HHH020008: Cache[%s] Key[%s] Lockable[%s]\nA soft-locked cache entry was expired by the underlying Ehcache. If this happens regularly you should consider increasing the cache timeouts and/or capacity limits";
+ private static final String alreadySessionBound = "HHH000002: Already session bound on call to bind(); make sure you clean up your sessions!";
+ private static final String autoCommitMode = "HHH000006: Autocommit mode: %s";
+ private static final String autoFlushWillNotWork = "HHH000008: JTASessionContext being used with JDBC transactions; auto-flush will not operate correctly with getCurrentSession()";
+ private static final String batchContainedStatementsOnRelease = "HHH000010: On release of batch it still contained JDBC statements";
+ private static final String bytecodeProvider = "HHH000021: Bytecode provider name : %s";
+ private static final String c3p0ProviderClassNotFound = "HHH000022: c3p0 properties were encountered, but the %s provider class was not found on the classpath; these properties are going to be ignored.";
+ private static final String cachedFileNotFound = "HHH000023: I/O reported cached file could not be found : %s : %s";
+ private static final String cacheProvider = "HHH000024: Cache provider: %s";
+ private static final String callingJoinTransactionOnNonJtaEntityManager = "HHH000027: Calling joinTransaction() on a non JTA EntityManager";
+ private static final String closing = "HHH000031: Closing";
+ private static final String collectionsFetched = "HHH000032: Collections fetched (minimize this): %s";
+ private static final String collectionsLoaded = "HHH000033: Collections loaded: %s";
+ private static final String collectionsRecreated = "HHH000034: Collections recreated: %s";
+ private static final String collectionsRemoved = "HHH000035: Collections removed: %s";
+ private static final String collectionsUpdated = "HHH000036: Collections updated: %s";
+ private static final String columns = "HHH000037: Columns: %s";
+ private static final String compositeIdClassDoesNotOverrideEquals = "HHH000038: Composite-id class does not override equals(): %s";
+ private static final String compositeIdClassDoesNotOverrideHashCode = "HHH000039: Composite-id class does not override hashCode(): %s";
+ private static final String configurationResource = "HHH000040: Configuration resource: %s";
+ private static final String configuredSessionFactory = "HHH000041: Configured SessionFactory: %s";
+ private static final String configuringFromFile = "HHH000042: Configuring from file: %s";
+ private static final String configuringFromResource = "HHH000043: Configuring from resource: %s";
+ private static final String configuringFromUrl = "HHH000044: Configuring from URL: %s";
+ private static final String configuringFromXmlDocument = "HHH000045: Configuring from XML document";
+ private static final String connectionsObtained = "HHH000048: Connections obtained: %s";
+ private static final String containerProvidingNullPersistenceUnitRootUrl = "HHH000050: Container is providing a null PersistenceUnitRootUrl: discovery impossible";
+ private static final String containsJoinFetchedCollection = "HHH000051: Ignoring bag join fetch [%s] due to prior collection join fetch";
+ private static final String creatingSubcontextInfo = "HHH000053: Creating subcontext: %s";
+ private static final String definingFlushBeforeCompletionIgnoredInHem = "HHH000059: Defining %s=true ignored in HEM";
+ private static final String deprecatedForceDescriminatorAnnotation = "HHH000062: @ForceDiscriminator is deprecated use @DiscriminatorOptions instead.";
+ private static final String deprecatedOracle9Dialect = "HHH000063: The Oracle9Dialect dialect has been deprecated; use either Oracle9iDialect or Oracle10gDialect instead";
+ private static final String deprecatedOracleDialect = "HHH000064: The OracleDialect dialect has been deprecated; use Oracle8iDialect instead";
+ private static final String deprecatedUuidGenerator = "HHH000065: DEPRECATED : use [%s] instead with custom [%s] implementation";
+ private static final String disallowingInsertStatementComment = "HHH000067: Disallowing insert statement comment for select-identity due to Oracle driver bug";
+ private static final String duplicateGeneratorName = "HHH000069: Duplicate generator name %s";
+ private static final String duplicateGeneratorTable = "HHH000070: Duplicate generator table: %s";
+ private static final String duplicateImport = "HHH000071: Duplicate import: %s -> %s";
+ private static final String duplicateJoins = "HHH000072: Duplicate joins for class: %s";
+ private static final String duplicateListener = "HHH000073: entity-listener duplication, first event definition will be used: %s";
+ private static final String duplicateMetadata = "HHH000074: Found more than one
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * com/t?st.jsp - matches com/test.jsp but also
+ * com/tast.jsp or com/txst.jspcom/*.jsp - matches all .jsp files in the
+ * com directorycom/**/test.jsp - matches all test.jsp
+ * files underneath the com pathorg/apache/shiro/**/*.jsp - matches all .jsp
+ * files underneath the org/apache/shiro pathorg/**/servlet/bla.jsp - matches
+ * org/apache/shiro/servlet/bla.jsp but also
+ * org/apache/shiro/testing/servlet/bla.jsp and
+ * org/servlet/bla.jsppath against the given pattern.
+ *
+ * @param pattern the pattern to match against
+ * @param path the path String to test
+ * @param fullMatch whether a full pattern match is required
+ * (else a pattern match as far as the given base path goes is sufficient)
+ * @return true if the supplied path matched,
+ * false if it didn't
+ */
+ protected boolean doMatch(String pattern, String path, boolean fullMatch) {
+ if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
+ return false;
+ }
+
+ String[] pattDirs = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator);
+ String[] pathDirs = StringUtils.tokenizeToStringArray(path, this.pathSeparator);
+
+ int pattIdxStart = 0;
+ int pattIdxEnd = pattDirs.length - 1;
+ int pathIdxStart = 0;
+ int pathIdxEnd = pathDirs.length - 1;
+
+ // Match all elements up to the first **
+ while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ String patDir = pattDirs[pattIdxStart];
+ if ("**".equals(patDir)) {
+ break;
+ }
+ if (!matchStrings(patDir, pathDirs[pathIdxStart])) {
+ return false;
+ }
+ pattIdxStart++;
+ pathIdxStart++;
+ }
+
+ if (pathIdxStart > pathIdxEnd) {
+ // Path is exhausted, only match if rest of pattern is * or **'s
+ if (pattIdxStart > pattIdxEnd) {
+ return (pattern.endsWith(this.pathSeparator) ?
+ path.endsWith(this.pathSeparator) : !path.endsWith(this.pathSeparator));
+ }
+ if (!fullMatch) {
+ return true;
+ }
+ if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") &&
+ path.endsWith(this.pathSeparator)) {
+ return true;
+ }
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (!pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+ return true;
+ } else if (pattIdxStart > pattIdxEnd) {
+ // String not exhausted, but pattern is. Failure.
+ return false;
+ } else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) {
+ // Path start definitely matches due to "**" part in pattern.
+ return true;
+ }
+
+ // up to last '**'
+ while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ String patDir = pattDirs[pattIdxEnd];
+ if (patDir.equals("**")) {
+ break;
+ }
+ if (!matchStrings(patDir, pathDirs[pathIdxEnd])) {
+ return false;
+ }
+ pattIdxEnd--;
+ pathIdxEnd--;
+ }
+ if (pathIdxStart > pathIdxEnd) {
+ // String is exhausted
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (!pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ int patIdxTmp = -1;
+ for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) {
+ if (pattDirs[i].equals("**")) {
+ patIdxTmp = i;
+ break;
+ }
+ }
+ if (patIdxTmp == pattIdxStart + 1) {
+ // '**/**' situation, so skip one
+ pattIdxStart++;
+ continue;
+ }
+ // Find the pattern between padIdxStart & padIdxTmp in str between
+ // strIdxStart & strIdxEnd
+ int patLength = (patIdxTmp - pattIdxStart - 1);
+ int strLength = (pathIdxEnd - pathIdxStart + 1);
+ int foundIdx = -1;
+
+ strLoop:
+ for (int i = 0; i <= strLength - patLength; i++) {
+ for (int j = 0; j < patLength; j++) {
+ String subPat = (String) pattDirs[pattIdxStart + j + 1];
+ String subStr = (String) pathDirs[pathIdxStart + i + j];
+ if (!matchStrings(subPat, subStr)) {
+ continue strLoop;
+ }
+ }
+ foundIdx = pathIdxStart + i;
+ break;
+ }
+
+ if (foundIdx == -1) {
+ return false;
+ }
+
+ pattIdxStart = patIdxTmp;
+ pathIdxStart = foundIdx + patLength;
+ }
+
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (!pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Tests whether or not a string matches against a pattern.
+ * The pattern may contain two special characters:
+ * '*' means zero or more characters
+ * '?' means one and only one character
+ *
+ * @param pattern pattern to match against.
+ * Must not be null.
+ * @param str string which must be matched against the pattern.
+ * Must not be null.
+ * @return true if the string matches against the
+ * pattern, or false otherwise.
+ */
+ private boolean matchStrings(String pattern, String str) {
+ char[] patArr = pattern.toCharArray();
+ char[] strArr = str.toCharArray();
+ int patIdxStart = 0;
+ int patIdxEnd = patArr.length - 1;
+ int strIdxStart = 0;
+ int strIdxEnd = strArr.length - 1;
+ char ch;
+
+ boolean containsStar = false;
+ for (char aPatArr : patArr) {
+ if (aPatArr == '*') {
+ containsStar = true;
+ break;
+ }
+ }
+
+ if (!containsStar) {
+ // No '*'s, so we make a shortcut
+ if (patIdxEnd != strIdxEnd) {
+ return false; // Pattern and string do not have the same size
+ }
+ for (int i = 0; i <= patIdxEnd; i++) {
+ ch = patArr[i];
+ if (ch != '?') {
+ if (ch != strArr[i]) {
+ return false;// Character mismatch
+ }
+ }
+ }
+ return true; // String matches against pattern
+ }
+
+
+ if (patIdxEnd == 0) {
+ return true; // Pattern contains only '*', which matches anything
+ }
+
+ // Process characters before first star
+ while ((ch = patArr[patIdxStart]) != '*' && strIdxStart <= strIdxEnd) {
+ if (ch != '?') {
+ if (ch != strArr[strIdxStart]) {
+ return false;// Character mismatch
+ }
+ }
+ patIdxStart++;
+ strIdxStart++;
+ }
+ if (strIdxStart > strIdxEnd) {
+ // All characters in the string are used. Check if only '*'s are
+ // left in the pattern. If so, we succeeded. Otherwise failure.
+ for (int i = patIdxStart; i <= patIdxEnd; i++) {
+ if (patArr[i] != '*') {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // Process characters after last star
+ while ((ch = patArr[patIdxEnd]) != '*' && strIdxStart <= strIdxEnd) {
+ if (ch != '?') {
+ if (ch != strArr[strIdxEnd]) {
+ return false;// Character mismatch
+ }
+ }
+ patIdxEnd--;
+ strIdxEnd--;
+ }
+ if (strIdxStart > strIdxEnd) {
+ // All characters in the string are used. Check if only '*'s are
+ // left in the pattern. If so, we succeeded. Otherwise failure.
+ for (int i = patIdxStart; i <= patIdxEnd; i++) {
+ if (patArr[i] != '*') {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // process pattern between stars. padIdxStart and patIdxEnd point
+ // always to a '*'.
+ while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
+ int patIdxTmp = -1;
+ for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
+ if (patArr[i] == '*') {
+ patIdxTmp = i;
+ break;
+ }
+ }
+ if (patIdxTmp == patIdxStart + 1) {
+ // Two stars next to each other, skip the first one.
+ patIdxStart++;
+ continue;
+ }
+ // Find the pattern between padIdxStart & padIdxTmp in str between
+ // strIdxStart & strIdxEnd
+ int patLength = (patIdxTmp - patIdxStart - 1);
+ int strLength = (strIdxEnd - strIdxStart + 1);
+ int foundIdx = -1;
+ strLoop:
+ for (int i = 0; i <= strLength - patLength; i++) {
+ for (int j = 0; j < patLength; j++) {
+ ch = patArr[patIdxStart + j + 1];
+ if (ch != '?') {
+ if (ch != strArr[strIdxStart + i + j]) {
+ continue strLoop;
+ }
+ }
+ }
+
+ foundIdx = strIdxStart + i;
+ break;
+ }
+
+ if (foundIdx == -1) {
+ return false;
+ }
+
+ patIdxStart = patIdxTmp;
+ strIdxStart = foundIdx + patLength;
+ }
+
+ // All characters in the string are used. Check if only '*'s are left
+ // in the pattern. If so, we succeeded. Otherwise failure.
+ for (int i = patIdxStart; i <= patIdxEnd; i++) {
+ if (patArr[i] != '*') {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Given a pattern and a full path, determine the pattern-mapped part.
+ *
+ *
+ * /docs/cvs/commit.html' and '/docs/cvs/commit.html -> ''/docs/*' and '/docs/cvs/commit -> 'cvs/commit'/docs/cvs/*.html' and '/docs/cvs/commit.html -> 'commit.html'/docs/**' and '/docs/cvs/commit -> 'cvs/commit'/docs/**\/*.html' and '/docs/cvs/commit.html -> 'cvs/commit.html'/*.html' and '/docs/cvs/commit.html -> 'docs/cvs/commit.html'*.html' and '/docs/cvs/commit.html -> '/docs/cvs/commit.html'*' and '/docs/cvs/commit.html -> '/docs/cvs/commit.html'true for 'pattern'
+ * and 'path', but does not enforce this.
+ */
+ public String extractPathWithinPattern(String pattern, String path) {
+ String[] patternParts = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator);
+ String[] pathParts = StringUtils.tokenizeToStringArray(path, this.pathSeparator);
+
+ StringBuilder buffer = new StringBuilder();
+
+ // Add any path parts that have a wildcarded pattern part.
+ int puts = 0;
+ for (int i = 0; i < patternParts.length; i++) {
+ String patternPart = patternParts[i];
+ if ((patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) && pathParts.length >= i + 1) {
+ if (puts > 0 || (i == 0 && !pattern.startsWith(this.pathSeparator))) {
+ buffer.append(this.pathSeparator);
+ }
+ buffer.append(pathParts[i]);
+ puts++;
+ }
+ }
+
+ // Append any trailing path parts.
+ for (int i = patternParts.length; i < pathParts.length; i++) {
+ if (puts > 0 || i > 0) {
+ buffer.append(this.pathSeparator);
+ }
+ buffer.append(pathParts[i]);
+ }
+
+ return buffer.toString();
+ }
+
+}
+
diff --git a/core/src/net/oschina/j2cache/util/FseSerializer.java b/core/src/net/oschina/j2cache/util/FseSerializer.java
new file mode 100644
index 0000000000000000000000000000000000000000..850bef2e2daaffe8e56eb1589b8be56613b6db39
--- /dev/null
+++ b/core/src/net/oschina/j2cache/util/FseSerializer.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2015-2020, whcrow (v@whcrow.com).
+ * true if the given source matches the specified pattern,
+ * false otherwise.
+ *
+ * @param pattern the pattern to match against
+ * @param source the source to match
+ * @return true if the given source matches the specified pattern,
+ * false otherwise.
+ */
+ boolean matches(String pattern, String source);
+}
diff --git a/core/src/net/oschina/j2cache/util/SerializationUtils.java b/core/src/net/oschina/j2cache/util/SerializationUtils.java
index fbef193098beefa6d21b81e82eeebda08a19df44..5172a520547bb6266bc59d657e47082303cca1ad 100644
--- a/core/src/net/oschina/j2cache/util/SerializationUtils.java
+++ b/core/src/net/oschina/j2cache/util/SerializationUtils.java
@@ -55,6 +55,8 @@ public class SerializationUtils {
g_serializer = new FstJSONSerializer(props);
} else if ("fastjson".equals(ser)) {
g_serializer = new FastjsonSerializer();
+ } else if ("fse".equals(ser)) {
+ g_serializer = new FseSerializer();
} else {
try {
g_serializer = (Serializer) Class.forName(ser).newInstance();
@@ -63,7 +65,7 @@ public class SerializationUtils {
}
}
}
- log.info("Using Serializer -> [" + g_serializer.name() + ":" + g_serializer.getClass().getName() + ']');
+ log.info("Using Serializer -> [{}:{}]", g_serializer.name(), g_serializer.getClass().getName());
}
/**
diff --git a/core/src/net/oschina/j2cache/util/StringUtils.java b/core/src/net/oschina/j2cache/util/StringUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa3d4fc6faf5635a03b71300fb26acd93b81b939
--- /dev/null
+++ b/core/src/net/oschina/j2cache/util/StringUtils.java
@@ -0,0 +1,297 @@
+package net.oschina.j2cache.util;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+public class StringUtils {
+ public static final String EMPTY_STRING = "";
+ public static final char DEFAULT_DELIMITER_CHAR = ',';
+ public static final char DEFAULT_QUOTE_CHAR = '"';
+
+ public StringUtils() {
+ }
+
+ public static boolean hasText(String str) {
+ if (!hasLength(str)) {
+ return false;
+ } else {
+ int strLen = str.length();
+
+ for(int i = 0; i < strLen; ++i) {
+ if (!Character.isWhitespace(str.charAt(i))) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+ }
+
+ public static boolean hasLength(String str) {
+ return str != null && str.length() > 0;
+ }
+
+ public static boolean startsWithIgnoreCase(String str, String prefix) {
+ if (str != null && prefix != null) {
+ if (str.startsWith(prefix)) {
+ return true;
+ } else if (str.length() < prefix.length()) {
+ return false;
+ } else {
+ String lcStr = str.substring(0, prefix.length()).toLowerCase();
+ String lcPrefix = prefix.toLowerCase();
+ return lcStr.equals(lcPrefix);
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public static String clean(String in) {
+ String out = in;
+ if (in != null) {
+ out = in.trim();
+ if (out.equals("")) {
+ out = null;
+ }
+ }
+
+ return out;
+ }
+
+ public static String toString(Object[] array) {
+ return toDelimitedString(array, ",");
+ }
+
+ public static String toDelimitedString(Object[] array, String delimiter) {
+ if (array != null && array.length != 0) {
+ StringBuilder sb = new StringBuilder();
+
+ for(int i = 0; i < array.length; ++i) {
+ if (i > 0) {
+ sb.append(delimiter);
+ }
+
+ sb.append(array[i]);
+ }
+
+ return sb.toString();
+ } else {
+ return "";
+ }
+ }
+
+ public static String toDelimitedString(Collection c, String delimiter) {
+ return c != null && !c.isEmpty() ? join(c.iterator(), delimiter) : "";
+ }
+
+ public static String[] tokenizeToStringArray(String str, String delimiters) {
+ return tokenizeToStringArray(str, delimiters, true, true);
+ }
+
+ public static String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {
+ if (str == null) {
+ return null;
+ } else {
+ StringTokenizer st = new StringTokenizer(str, delimiters);
+ ArrayList tokens = new ArrayList();
+
+ while(true) {
+ String token;
+ do {
+ if (!st.hasMoreTokens()) {
+ return toStringArray(tokens);
+ }
+
+ token = st.nextToken();
+ if (trimTokens) {
+ token = token.trim();
+ }
+ } while(ignoreEmptyTokens && token.length() <= 0);
+
+ tokens.add(token);
+ }
+ }
+ }
+
+ public static String[] toStringArray(Collection collection) {
+ return collection == null ? null : (String[])collection.toArray(new String[collection.size()]);
+ }
+
+ public static String[] splitKeyValue(String aLine) throws ParseException {
+ String line = clean(aLine);
+ if (line == null) {
+ return null;
+ } else {
+ String[] split = line.split(" ", 2);
+ String msg;
+ if (split.length != 2) {
+ split = line.split("=", 2);
+ if (split.length != 2) {
+ msg = "Unable to determine Key/Value pair from line [" + line + "]. There is no space from which the split location could be determined.";
+ throw new ParseException(msg, 0);
+ }
+ }
+
+ split[0] = clean(split[0]);
+ split[1] = clean(split[1]);
+ if (split[1].startsWith("=")) {
+ split[1] = clean(split[1].substring(1));
+ }
+
+ if (split[0] == null) {
+ msg = "No valid key could be found in line [" + line + "] to form a key/value pair.";
+ throw new ParseException(msg, 0);
+ } else if (split[1] == null) {
+ msg = "No corresponding value could be found in line [" + line + "] for key [" + split[0] + "]";
+ throw new ParseException(msg, 0);
+ } else {
+ return split;
+ }
+ }
+ }
+
+ public static String[] split(String line) {
+ return split(line, ',');
+ }
+
+ public static String[] split(String line, char delimiter) {
+ return split(line, delimiter, '"');
+ }
+
+ public static String[] split(String line, char delimiter, char quoteChar) {
+ return split(line, delimiter, quoteChar, quoteChar);
+ }
+
+ public static String[] split(String line, char delimiter, char beginQuoteChar, char endQuoteChar) {
+ return split(line, delimiter, beginQuoteChar, endQuoteChar, false, true);
+ }
+
+ public static String[] split(String aLine, char delimiter, char beginQuoteChar, char endQuoteChar, boolean retainQuotes, boolean trimTokens) {
+ String line = clean(aLine);
+ if (line == null) {
+ return null;
+ } else {
+ List, which will only initialize entities (not as a proxy) as needed.";
+ private static final String deprecatedManyToManyFetch = "HHH000455: The fetch attribute on