我有两个独立的实体:
public enum Rule implements Validatable, StringRepresentable{
//...
}
和
public inteface Filter extends Validatable, StringRepresentable{
//...
}
哪里
public inteface Validatable{
public GenericValidator getValidator();
}
和
public interface StringRepresentable{
public String getStringRepresentation();
}
GenericValidator是一个抽象类,有许多我不希望用户直接访问的子类.我该如何更好地处理这些事情？
我不明白何时创建类似的更好
public class ValidatorFactory{
public Validator getRuleValidator(Rule r){ ... }
public Validator getFilterValidator(Filter f){ ... }
}
而不是Validatable如前所示实现接口.
难道没有人解释我怎样才能做出正确的决定？什么潜在的情况需要执行FactoryMethod一个错误的决定,什么时候真的很好？
UPD:
public interface Validator{
public ErrorCode validate();
}
public abstract class GenericValidator implements Validator{
//...
}
本ErrorCode类封装了验证的结果(null如果valiadtion的succsfully完成).
我写了以下代码:
public class Test<T> {
public void method(){
B b = new B();
}
public class B{ }
}
//Some method in some class contains the following lines
Test<Integer> t = null;
Test.B b = t.new B(); //warning Test.B is a raw type
为什么我收到这个警告？内部类型的declation B不包含类型参数,因此它不是泛型类型.此外,规范给出了以下内容:
如果一个类声明了一个或多个类型变量,则它是通用的
该类B未声明类型变量.那为什么它是通用类型？
Mojarra 2.2.12
以下是接管FacesContext实例化的代码片段:
FacesContext context = facesContextFactory.getFacesContext
(servletConfig.getServletContext(), request, response, lifecycle);
表达非常清楚.获得请求后,我们从中获取全局信息并FacesContext使用它创建实例.因此,为每个请求创建实例.但在facesContextFactory我看来,获得这种感觉更加棘手.
// Acquire our FacesContextFactory instance
try {
facesContextFactory = (FacesContextFactory)
FactoryFinder.getFactory
(FactoryFinder.FACES_CONTEXT_FACTORY);
} catch (FacesException e) {
//others
}
哪里
String javax.faces.FactoryFinder.FACES_CONTEXT_FACTORY = "javax.faces.context.FacesContextFactory"
JavaDocs用于FactoryFinder描述所谓的
JavaServer Faces API中指定的所有工厂对象的标准发现算法.
这就是我感到困惑的地方.
现在,让我们考虑创建工厂实例的实际方法:javax.faces.FactoryFinderInstance #getFactory(String factoryName)
try {
factoryOrList = factories.get(factoryName);
if (!(factoryOrList instanceof List)) {
return factoryOrList;
}
} finally {
lock.readLock().unlock();
}
该factories字段初始化如下copyInjectionProviderFromFacesContext():
private void copyInjectionProviderFromFacesContext() { …我正在阅读J. Bloch有效的Java,他说以下内容:
一旦界面发布并广泛实施,几乎不可能改变.
所以,现在考虑DAO模式的简单接口:
public interface UserDao{
public User getById(int id);
public Collection<User> getAll();
public boolean delete(int userId);
public boolean update(User u);
}
这是我的Dao界面首次发布时的样子.到那时,我不得不向用户添加一些功能,以便通过它registration_date或类似的东西聚合所有用户.所以,我需要在DAO-interface中添加相应的方法声明并实现它.
此外,我现在无法想象 - 接口DAO可能或多或少是稳定的,因为添加一些新的DAO操作经常发生.
也许这是我的DAO设计灾难,或者界面几乎不适合DAOs？
我正在阅读B. Goetz 的 Java concurrency in Pratice，现在我正在阅读有关锁定的部分。他说过
每个对象都有一个内置锁这一事实只是为了方便，因此您无需显式创建锁对象。 9
9 回想起来，这个设计决定可能是一个糟糕的决定：它不仅会令人困惑，而且会迫使 JVM 实现者在对象大小和锁定性能之间做出权衡。
因为，我是并发的新手，所以他在谈论什么设计决策并不明显。从性能的角度来看，创建显式锁定对象很糟糕，不是吗？
我有一些误解的合同的thenCompose(Function<? super T,? extends CompletionStage<U>> fn)。这是那里所说的：
返回一个新的
CompletionStage，当这个阶段正常完成时，将这个阶段作为提供函数的参数执行。
该函数似乎接受 this 的结果CompletionStage，而不是它CompletionStage本身。那么他们是什么意思呢？
那么返回的 代表的任务CompletableFuture呢？
Runnable r;
ExecutorService es;
Function<Void, CompletableFuture<Void>>f;
//...
CompletableFuture.runAsync(r, es)
.thenCompose(f);
这是否意味着，由CompletableFuture返回的任务thenCompose将ThreadPool与Runnable r?
我在接受采访时被问到以下问题.给定以下代码,如果方法add和doAction多个线程调用,我们如何NullPointerException在打印时获得toString？**
public class Test{
private List<Object> obj = new ArrayList<Object>();
public void add(Object o){
obj.add(o);
}
public void doAction(){
for(Object o: obj){
System.out.println(o.toString()); // maybe NPE, why?
}
}
}
切断所有其他多线程问题.
我计划从多个线程同时加载缓存.最简单的形式是:
IgniteCache<Integer, Integer> cache = ignite.getOrCreateCache("ints");
ExecutorService es = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
for (int i = 0; i < 20000000; i++) {
int t = i;
es.submit(() -> {
cache.put(t, t);
});
}
这样做是否安全？我阅读了该方法的文档:
将指定的值与缓存中的指定键相关联.如果Cache先前包含键的映射,则旧值将替换为指定的值.(当且仅当c.containsKey(k)返回true时,缓存c才包含密钥k的映射.)
关于线程安全没有任何说法.IgniteCache同时放入是否安全？
我对装配很新,现在我想了解它的cmp工作原理.以下是wiki中的内容:
cmp arg2, arg1
在arg1和arg2之间执行比较操作.通过从arg1中减去arg2的(带符号)来执行比较,其结果可以称为Temp.然后丢弃温度.
什么意思"然后丢弃温度"？它存放在哪里？如何访问此比较结果？有人可以解释一下吗？
我正在解决leetcode 问题以找到二叉树的最大深度。递归解决方案相当简单，因此我尝试实现迭代 DFS 方法。这是我的想法：
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
public TreeNode() {}
public TreeNode(int val) { this.val = val; }
public TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
public static int maxDepthDfs(TreeNode root){
Deque<TreeNode> stack = new LinkedList<>();
Deque<Integer> depths = new LinkedList<>();
TreeNode current = root;
int maxDepth = 0;
int currentDepth = 0;
while(!stack.isEmpty() || current != null){
if(current == …