给定一个仅在程序设置中使用的假设实用程序类:
class MyUtils {
private static MyObject myObject = new MyObject();
/*package*/static boolean doStuff(Params... params) {
// do stuff with myObject and params...
}
}
当myObject不再被使用时,它会被垃圾收集,还是会在程序的生命周期中保留？
我正试图让我的应用程序的"行走骨架"将使用S3进行持久化.我想使用假的S3服务,这样每个开发人员的桌面都可以随意读/写.
我认为mocks3会很完美,因为我可以在我的jUnit测试中得到一个码头服务器.问题是mocks3不允许任何写入.据我所知,甚至没有设置它.
那么别人怎么做呢？
增长面向对象软件这本书在jMock中给出了几个例子,其中状态是明确的,而不是通过API公开它.我真的喜欢这个主意.在Mockito有办法做到这一点吗？
这是本书的一个例子
public class SniperLauncherTest {
private final States auctionState = context.states("auction state")
.startsAs("not joined");
@Test public void addsNewSniperToCollectorAndThenJoinsAuction() {
final String itemId = "item 123";
context.checking(new Expectations() {{
allowing(auctionHouse).auctionFor(itemId); will(returnValue(auction));
oneOf(sniperCollector).addSniper(with(sniperForItem(item)));
when(auctionState.is("not joined"));
oneOf(auction).addAuctionEventListener(with(sniperForItem(itemId)));
when(auctionState.is("not joined"));
one(auction).join(); then(auctionState.is("joined"));
}});
launcher.joinAuction(itemId);
}
}
据我所知,随着Java 7中MethodHandle的引入,引入了编译器生成的方法重载.
MethodHandle的javadoc状态(我已经修剪了示例):
以下是一些用法示例:
Run Code Online (Sandbox Code Playgroud)Object x, y; String s; int i; mh = ... // (Ljava/lang/String;CC)Ljava/lang/String; // (String, char, char) -> String s = (String) mh.invokeExact("daddy",'d','n'); // (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; // (Object, Object, Object) -> Object x = mh.invokeExact((Object)1, (Object)2, (Object)3); // (Ljava/util/List;)I // (List) -> int i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3)); // (Ljava/io/PrintStream;Ljava/lang/String;)V // (PrintStream, String) -> void mh.invokeExact(System.out, "Hello, world.");上述每个调用都会生成一个invokevirtual指令,其名称为invoke,注释中指示的类型描述符.参数类型直接取自实际参数,而返回类型取自立即应用于调用的强制转换.这个演员可能是一个原始人.如果缺少,则如果在使用返回值的上下文中发生调用,则类型默认为Object.如果调用作为语句发生,则转换是不可能的,并且没有返回类型; 电话无效.
实际上,invokeExact和friends的行为就好像每个可能的参数组合和返回类型都有重载.
我听说MethodHandles正在为Java 8中的功能做准备,比如lambdas.(我知道它们对脚本语言已经很有用了.)
[/介绍]
那么,是否有更多这些编译器生成的重载隐藏在Java中？是否有提示将来会有更多这些提示(例如,使用扩展方法)？为什么首先需要它？仅速度？它如何帮助lambdas(我认为lambdas会编译成一个匿名的内部类)？
简而言之,理由是什么; 为什么它们(生成的重载)现在和将来都有用？
更新:我在这里称之为编译器生成的重载,Oracle人称之为签名多态.
我正在通过CompletableFuture收到服务电话的回复.我想处理服务返回的一些已知异常 - 例如乐观并发控制冲突.
这就是我所拥有的.有没有更好的方法来做这个不包装异常或使用SneakyThrows？包装异常意味着其他异常处理程序必须检查因果链而不仅仅是使用instanceof.
someService.call(request)
.handle((response, error) -> {
if (error == null)
return CompletableFuture.completedFuture(response);
else if (error instanceof OCCException)
return CompletableFuture.completedFuture(makeDefaultResponse());
CompletableFuture<Response> errorFuture = new CompletableFuture<>();
errorFuture.completeExceptionally(error);
return errorFuture;
}).thenCompose(Function.identity());
同样的,有没有办法复制番石榴withFallback没有包装解开？
CompletableFuture<T> withFallback(CompletableFuture<T> future,
Function<Throwable, ? extends CompletableFuture<T>> fallback) {
return future.handle((response, error) -> {
if (error == null)
return CompletableFuture.completedFuture(response);
else
return fallback.apply(error);
}).thenCompose(Function.identity());
}
...
// Here's the first part of the question implemented using withFallback.
// It's a little cleaner, but it …我在我的项目中使用了lombok,有很多课程@RequiredArgsConstructors.我希望这些构造函数能够自动用于guice.
一个可行的选择是使用,@RequiredArgsConstructors(onConstructor=@__(@Inject))但这既丑陋又实验性(读:未来可能会从lombok中消失).
我正在考虑做的是制作一个自定义注入注释,比如说@InjectOnlyConstructor我的类定义并使用guice的SPI来绑定这些类型.但我无法弄清楚如何在SPI中发现这些类型.
我怎样才能查看guice的元素并绑定到这些构造函数,而guice会默认拒绝？
我希望类看起来像的示例:
@Singleton
@InjectOnlyConstructor
@RequiredArgsConstructor
public class CatPictureService {
private final WebServiceClient client;
// Cool stuff that would make facebook cry
}
作为备份计划,我可以使用一个模块来扫描项目的包并自动绑定这些类型.
我有一系列异步服务调用,我想取消.嗯,实际上,我有两个并行的服务调用链,如果一个成功,我想取消另一个.
有了番石榴的未来,我习惯于通过取消最后一个来取消整个期货连锁店.看来我不能用java-8的未来做到这一点.除非有人对如何做好.
你是任务,如果你选择接受它,就是告诉我是否可以保持我漂亮的语法并取消链条.否则,我将编写自己的链接未来包装 - 特别是在这个问题之后.
我自己的测试和尝试如下.
@Test
public void shouldCancelOtherFutures() {
// guava
ListenableFuture<String> as = Futures.immediateFuture("a");
ListenableFuture<String> bs = Futures.transform(as, (AsyncFunction<String, String>) x -> SettableFuture.create());
ListenableFuture<String> cs = Futures.transform(bs, (AsyncFunction<String, String>) x -> SettableFuture.create());
ListenableFuture<String> ds = Futures.transform(cs, Functions.<String>identity());
ds.cancel(false);
assertTrue(cs.isDone()); // succeeds
// jdk 8
CompletableFuture<String> ac = CompletableFuture.completedFuture("a");
CompletableFuture<String> bc = ac.thenCompose(x -> new CompletableFuture<>());
CompletableFuture<String> cc = bc.thenCompose(x -> new CompletableFuture<>());
CompletableFuture<String> dc = cc.thenApply(Function.identity());
dc.cancel(false);
assertTrue(cc.isDone()); // fails
} …我的印象就是这个
// short syntax
def foo(bar: Bar)(baz: Baz): Quux
这是语法糖
// long syntax
def foo(bar: Bar): (Baz) => Quux
但在继承方面,我似乎无法将两者混为一谈.整个树必须用短语法或长语法定义; 从来没有.
例如:
case class Context
case class Work
trait ContextualWorker {
def workWithContext(ctxt: Context)(work: Work): Traversable[Work]
}
class ShortConcreteWorker extends ContextualWorker {
override def workWithContext(ctxt: Context)(work: Work) = Nil
}
class LongConcreteWorker extends ContextualWorker {
// error on next line: method workWithContext overrides nothing <-------------
override def workWithContext(ctxt: Context): (Work) => Traversable[Work] = {
val setupCode = 1
{ work …我发现自己处于使用大量JavaBeans的不幸位置.我说不幸,因为我不喜欢他们是可变的.因此,在我创建bean之后(我使用Jackson从JSON转换它们),我想在指定的时刻"冻结"bean,以确保它们不会在线下变异.
我没有能力编写每个bean的Mutable/Immutable版本,也没有自定义Jackson工厂的版本,因此我正在寻找一个类似于Collections.unmodifiableCollection(...);bean 的库或函数调用.
(是的,我知道如果原始的豆子被泄漏,它并没有真正冻结它.但是我会在创建后立即包装或冻结它们,而不再使用原件.)
有任何想法吗？
是否建议使用我自己的异步函数扩展core.async的功能？
信道的异步是由处理put!和take!其接受回调,但协议嵌套在async.impl.protocols命名空间.是否IMPL意味着置身事外!在这种情况下,还是可以实现它们？
例如,我可以将netty通道或java套接字包装为ReadPort和WritePort.