/** * cache disabled * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver cacheDisabled(ClassLoader classLoader) { return new ClassLoaderClassResolver(defaultClassLoader(classLoader)); }
@Override protected void writeStreamHeader() throws IOException { writeByte(STREAM_VERSION); }
/** * aggressive non-concurrent cache * good for non-shared cache, when we're not worried about class unloading * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver softCachingResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new SoftReferenceMap<String, Class<?>>(new HashMap<String, Reference<Class<?>>>())); }
/** * non-aggressive non-concurrent cache * good for non-shared default cache * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver weakCachingResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new WeakReferenceMap<String, Class<?>>(new HashMap<String, Reference<Class<?>>>())); }
@Override public Object readObject() throws ClassNotFoundException, IOException { int dataLen = readInt(); if (dataLen <= 0) { throw new StreamCorruptedException("invalid data length: " + dataLen); } if (dataLen > maxObjectSize) { throw new StreamCorruptedException( "data length too big: " + dataLen + " (max: " + maxObjectSize + ')'); } return new CompactObjectInputStream(in, classResolver).readObject(); }
@Override public Class<?> resolve(String className) throws ClassNotFoundException { // Query the cache first. Class<?> clazz; clazz = classCache.get(className); if (clazz != null) { return clazz; } // And then try to load. clazz = delegate.resolve(className); classCache.put(className, clazz); return clazz; }
@Override public V get(Object key) { return unfold(delegate.get(key)); }
@Override protected void readStreamHeader() throws IOException { int version = readByte() & 0xFF; if (version != STREAM_VERSION) { throw new StreamCorruptedException( "Unsupported version: " + version); } }
/** * aggressive concurrent cache * good for shared cache, when we're not worried about class unloading * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver softCachingConcurrentResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new SoftReferenceMap<String, Class<?>>( PlatformDependent.<String, Reference<Class<?>>>newConcurrentHashMap())); }
/** * non-aggressive concurrent cache * good for shared cache, when we're worried about class unloading * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver weakCachingConcurrentResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new WeakReferenceMap<String, Class<?>>( PlatformDependent.<String, Reference<Class<?>>>newConcurrentHashMap())); }
@Override public Object readObject() throws ClassNotFoundException, IOException { int dataLen = readInt(); if (dataLen <= 0) { throw new StreamCorruptedException("invalid data length: " + dataLen); } if (dataLen > maxObjectSize) { throw new StreamCorruptedException( "data length too big: " + dataLen + " (max: " + maxObjectSize + ')'); } return new CompactObjectInputStream(in, classResolver).readObject(); }
/** * cache disabled * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver cacheDisabled(ClassLoader classLoader) { return new ClassLoaderClassResolver(defaultClassLoader(classLoader)); }
@Override protected void writeStreamHeader() throws IOException { writeByte(STREAM_VERSION); }
@Override public V remove(Object key) { return unfold(delegate.remove(key)); }
/** * aggressive non-concurrent cache * good for non-shared cache, when we're not worried about class unloading * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver softCachingResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new SoftReferenceMap<String, Class<?>>(new HashMap<String, Reference<Class<?>>>())); }
/** * non-aggressive non-concurrent cache * good for non-shared default cache * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver weakCachingResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new WeakReferenceMap<String, Class<?>>(new HashMap<String, Reference<Class<?>>>())); }
/** * cache disabled * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver cacheDisabled(ClassLoader classLoader) { return new ClassLoaderClassResolver(defaultClassLoader(classLoader)); }
/** * aggressive concurrent cache * good for shared cache, when we're not worried about class unloading * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver softCachingConcurrentResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new SoftReferenceMap<String, Class<?>>( PlatformDependent.<String, Reference<Class<?>>>newConcurrentHashMap())); }
/** * non-aggressive concurrent cache * good for shared cache, when we're worried about class unloading * * @param classLoader - specific classLoader to use, or null if you want to revert to default * @return new instance of class resolver */ public static ClassResolver weakCachingConcurrentResolver(ClassLoader classLoader) { return new CachingClassResolver( new ClassLoaderClassResolver(defaultClassLoader(classLoader)), new WeakReferenceMap<String, Class<?>>( PlatformDependent.<String, Reference<Class<?>>>newConcurrentHashMap())); }