<dependencyManagement><dependencies><dependency><groupId>com.google.http-client</groupId><artifactId>google-http-client-bom</artifactId><version>1.43.3</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement>
import com.github.benmanes.caffeine.cache.Cache;
Cache<String, String> cache = Caffeine.newBuilder().build();
cache.put("key", "value");
cache.getIfPresent("key");Cache<String, String> cache = Caffeine.newBuilder()
.recordStats() // Enabled statistics collection
.build();
// Add to the cache
cache.put("1", "value_1");
cache.put("2", "value_2");
// Simulate hit and miss from cache
cache.getIfPresent("1");
cache.getIfPresent("3");
System.out.println(cache.stats());"CacheStats"{
hitCount=1,
missCount=1,
loadSuccessCount=0,
loadFailureCount=0,
totalLoadTime=0,
evictionCount=0,
evictionWeight=0
}<dependency><groupId>com.github.ben-manes.caffeine</groupId><artifactId>caffeine</artifactId><version>3.1.6</version></dependency>
The main difference is because Caffeine uses ring buffers to record & replay events, whereas Guava uses ConcurrentLinkedQueue. The intent was always to migrate Guava over and it made sense to start simpler, but unfortunately there was never interest in accepting those changes. The ring buffer approach avoids allocation, is bounded (lossy), and cheaper to operate against.Thread
Caffeine, like Guava, does not create threads so it cannot schedule work outside of user activity.Caffeine AsyncCache Arayüzü CompletableFuture nesnesi döner. Bu arayüz ise gerçek nesne döner.
Guava performs expiration on calling threads, so nothing occurs until the next access. You could use Caffeine with a configured scheduler which will perform the work on a background thread.
import com.google.common.reflect.ClassPath;
ClassPath classPath = ClassPath.from(BuggyAppLoader.class.getClassLoader());Set<ClassInfo> classes = classPath.getAllClasses();for(ClassInfo classInfo : classes) {logger.info(classInfo.getName());}
Q : How does Guice inject classes without an @Inject-annotated constructor?
A : Guice bindings that are not declared in modules are known as Just-in-time Bindings, and by default Guice is willing to call constructors that take zero arguments:
...
If you haven't required explicit bindings and you have a public no-arg constructor, Guice will call it as if you had marked it with @Inject. This is in contrast to Dagger, which will only call @Inject-annotated constructors:
class ExplicitBindingModule extends AbstractModule {@Overrideprotected void configure() {binder().requireExplicitBindings();}}
public class ServiceClass { @Inject public ServiceClass(DepA depA, DepB depB) { ... } } @Provides public DepA provideDepA() { //constructs DepA object and returns it }
Aynı arayüzü gerçekleştiren tüm sınıfları Set olarak alabilmemizi sağlar. List olarak @Inject edemeyiz.import com.google.inject.multibindings.Multibinder;
Multibinder<Action> actionBinder = Multibinder.newSetBinder(binder(), Action.class); actionBinder.addBinding().to(FooAction.class); actionBinder.addBinding().to(BarAction.class);Şöyle yaparız
@Inject public Foo(Set<Action> actions) { ... }Örnek
public abstract class ActionModule extends AbstractModule {
private Multibinder<Action> actionBinder;
@Override
protected void configure() {
actionBinder = Multibinder.newSetBinder(binder(), Action.class);
configureActions();
}
//Override this method to call {@link #bindAction}.
protected abstract void configureActions();
protected final LinkedBindingBuilder<Action> bindAction() {
return actionBinder.addBinding();
}
}public final class MyStandardActionModule extends ActionModule {
@Override
protected void configureActions() {
bindAction().to(FooAction.class);
bindAction().to(BarAction.class);
// If you need to instantiate an action through a Provider, do this.
bindAction().toProvider(BazActionProvider.class);
// You can also scope stuff:
bindAction().to(MySingletonAction.class).in(Singleton.class);
}
}import com.google.inject.AbstractModule;
Guice DSL syntax Mental modelbind(key).toInstance(value) map.put(key, () -> value) (instance binding)bind(key).toProvider(provider) map.put(key, provider) (provider binding)bind(key).to(anotherKey) map.put(key, map.get(anotherKey)) (linked binding)@Provides Foo provideFoo() {...} map.put(Key.get(Foo.class), module::provideFoo) (provider (method binding)
public class BasicModule extends AbstractModule { @Override protected void configure() { bind(Communicator.class).to(DefaultCommunicatorImpl.class); } }
public class BasicModule extends AbstractModule {
DefaultCommunicatorImpl communicator = ...;
@Override protected void configure() { bind(Communicator.class).to(communicator);
} }
public class BasicModule extends AbstractModule {
@Override protected void configure() {
bind(Communication.class).toInstance(new Communication(true)); } }
public class BasicModule extends AbstractModule {
@Override protected void configure() { bind(Boolean.class).toInstance(true); bind(Communication.class).toConstructor( Communication.class.getConstructor(Boolean.TYPE)); } }
class TextEditorModule extends AbstractModule {
@Override protected void configure() { install (new MyCommonModule(); } }
import com.google.inject.Injector;
class ForeverModule extends AbstractModule {...}class TemporaryModule extends AbstractModule {...}Injector foreverInjector = Guice.createInjector(new ForeverModule());Injector injector = foreverInjector.createChildInjector(new TemporaryModule());/** Do stuff with the injector as you would normally. When you* get bored of that injector, create a replacement injector* as a child of the long-lived injector.*/
Injector injector = Guice.createInjector(new BasicModule()); Communication comms = injector.getInstance(Communication.class);
<dependency><groupId>com.google.inject</groupId><artifactId>guice</artifactId><version>4.1.0</version></dependency>
Injector injector = Guice.createInjector(new BasicModule()); Communication comms = injector.getInstance(Communication.class);
@Singleton class SpellCheckerImpl implements SpellChecker { @Override public void checkSpelling() { ... } } class TextEditorModule extends AbstractModule {
@Override protected void configure() { bind(SpellChecker.class).to(SpellCheckerImpl.class); } }
class TextEditorModule extends AbstractModule {
@Override protected void configure() { bind(SpellChecker.class).to(SpellCheckerImpl.class).in(Singleton.class); } }
class TextEditorModule extends AbstractModule { @Override protected void configure() {} @Provides @Singleton public SpellChecker provideSpellChecker() { SpellChecker spellChecker = new SpellCheckerImpl(); return spellChecker; } }
Örnek... the annotation itself does not prevent production code from calling the annotated method
class Foo {
...
@VisibleForTesting
static class Bar {
}
}import com.google.common.util.concurrent.ServiceManager;
public class ManagedGuavaServices implements Managed {
@Inject
private ServiceManager serviceManager;
@Inject
public ManagedGuavaServices(ServiceManager serviceManager) {
this.serviceManager = serviceManager;
}
@Override
public void start() throws Exception {
serviceManager.startAsync();
serviceManager.awaitHealthy(2, TimeUnit.SECONDS);
}
@Override
public void stop() throws Exception {
serviceManager.stopAsync();
serviceManager.awaitStopped(2, TimeUnit.SECONDS);
}
}Iterable over the nodes reachable from any of the startNodes, in the order of a breadth-first traversal
Iterable over the nodes reachable from startNode, in the order of a breadth-first traversal
Node root = new Node("root");MutableGraph<Node> myGraph = GraphBuilder.directed().build();Node node1=new Node(" 1 ");Node node2=new Node(" 2 ");Node node3=new Node(" 3 ");Node node4=new Node(" 4 ");Node node5=new Node(" 5 ");myGraph.putEdge(root, node1);myGraph.putEdge(node1, node2);myGraph.putEdge(node1, node3);myGraph.putEdge(node2, node4);myGraph.putEdge(node2, node5);//Print the nodes Depth FirstTraverser.forGraph(myGraph).breadthFirst(root).forEach(x->System.out.println(x));
13 2 5 4
Iterable over the nodes reachable from any of the startNodes, in the order of a depth-first post-order traversal
Node root = new Node("root");MutableGraph<Node> myGraph = GraphBuilder.directed().build();Node node1=new Node(" 1 ");Node node2=new Node(" 2 ");Node node3=new Node(" 3 ");Node node4=new Node(" 4 ");Node node5=new Node(" 5 ");myGraph.putEdge(root, node1);myGraph.putEdge(node1, node2);myGraph.putEdge(node1, node3);myGraph.putEdge(node2, node4);myGraph.putEdge(node2, node5);//Print the nodes Depth FirstTraverser.forGraph(myGraph).depthFirstPostOrder(root).forEach(x->System.out.println(x));
13542
Iterable over the nodes reachable from startNode, in the order of a depth-first post-order traversal
Node root = new Node("root");
Graph<Node> graph = GraphBuilder.directed()
.nodeOrder(ElementOrder.insertion())
.<Node>immutable()
.putEdge(root, new Node("one"))
.putEdge(root, new Node("two"))
.putEdge(root, new Node("three"))
.build();
//Print the nodes in traversal order.
Traverser.forGraph(graph).depthFirstPostOrder(root)
.forEach(x->System.out.println(x));Iterable over the nodes reachable from any of the startNodes, in the order of a depth-first pre-order traversal
Creates a new traverser for the given general graph.
Creates a new traverser for a directed acyclic graph that has at most one path from the start node(s) to any node reachable from the start node(s), and has no paths from any start node to any other start node, such as a tree or forest