小编mer*_*ike的帖子

反序列化不受信任的数据是否安全,前提是我的代码不对反序列化对象的状态或类进行假设,或者仅仅反序列化的行为是否会引起不希望的操作？

(威胁模型:攻击者可以自由修改序列化数据,但这就是他所能做的)

为什么Servlet规范定义了两种不同的方式(上下文参数和环境条目)来为Web应用程序提供配置参数？

这些方法各自的优点是什么(什么时候应该优先选择)？

这似乎是一个简单的要求,但我还没有找到一个简单的解决方案:

在JSF 1.2/Richfaces 3.3 webapp中,我有一个表单,其中包含各种类型的输入组件,后跟一个<a4j:commandButton>和一个<h:commandButton>.前者重置表单,第二个对输入的数据执行一些操作.

我的目标是在用户输入数据时按下回车键时触发此操作.我怎样才能做到这一点？

编辑:一般来说,<h:commandButton>每个人有一个以上<form>.我想指定一个特定的默认操作.此外,我希望解决方案与AJAX(我们广泛使用)相得益彰.

如果使用注释对类进行批注,那么该批注的定义是否必须位于运行时类路径中才能使用该类？例如,给出注释

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Retention;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {}

我可以执行该程序吗？

@Component
public class Test {
    public static void main(String[] args) {
        System.out.println("It worked!");
    }
}

没有在类路径中的Component.class？(在我的测试中,我可以,但这个行为是由规范定义的吗？)

我问,因为使用库中的注释是否会创建对该库的依赖性存在冲突.

考虑该计划:

public class Test {

    public static void main(String[] args) {
        if (Arrays.asList(args).contains("--withFoo")) {
            use(new Foo());
        }
    }

    static void use(Foo foo) {
        // do something with foo
    }
}

如果在没有参数的情况下启动程序,那么运行时类路径中是否需要Foo？

研究

报告链接错误时,Java语言规范相当模糊:

该规范允许实现灵活性,以便何时发生链接活动(以及由于递归,加载),只要遵循Java编程语言的语义,在初始化之前完全验证和准备类或接口,并且在链接期间检测到的错误被抛出到程序中的某个点,在该点上程序可能需要链接到错误中涉及的类或接口.

我的测试表明只有在我实际使用时才会抛出LinkageErrors Foo:

$ rm Foo.class

$ java Test

$ java Test --withFoo

Exception in thread "main" java.lang.NoClassDefFoundError: Foo
        at Test.main(Test.java:11)
Caused by: java.lang.ClassNotFoundException: Foo
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source) …

我注意到与使用WinZip等本机工具相比,Java中的解压缩工具非常慢.

是否有可用于Java的第三方库更高效？开源是首选.

编辑

这是使用Java内置解决方案vs 7zip的速度比较.我在原始解决方案中添加了缓冲输入/输出流(感谢Jim,这确实产生了很大的不同).

Zip文件大小:800K Java解决方案:2.7秒7Zip解决方案:204毫秒

以下是使用内置Java解压缩的修改代码:

/** Unpacks the give zip file using the built in Java facilities for unzip. */
@SuppressWarnings("unchecked")
public final static void unpack(File zipFile, File rootDir) throws IOException
{
  ZipFile zip = new ZipFile(zipFile);
  Enumeration<ZipEntry> entries = (Enumeration<ZipEntry>) zip.entries();
  while(entries.hasMoreElements()) {
    ZipEntry entry = entries.nextElement();
    java.io.File f = new java.io.File(rootDir, entry.getName());
    if (entry.isDirectory()) { // if its a directory, create it
      continue;
    }

    if (!f.exists()) {
      f.getParentFile().mkdirs();
      f.createNewFile();
    }

    BufferedInputStream bis = new BufferedInputStream(zip.getInputStream(entry)); …

eclipse编译器拒绝编译以下代码,声明字段s不可见.(IBM的Aspect J编译器也拒绝,说"无法解决")为什么会这样？

public class Test {

    String s;

    void foo(Object o) {
        String os = getClass().cast(o).s;
    }
}

Java语言规范声明:

否则,我们说存在默认访问权限,只有在声明类型的包中发生访问时才允许访问.

我理解它的方式,该字段在同一个编译单元中声明和访问,因此在同一个包中,因此应该是可访问的.

更奇怪的是,从增加一个垂头丧气? extends Test,以Test使现场可见,即下面的代码编译:

public class Test {

    String s;

    void foo(Object o) {
        Test t = getClass().cast(o);
        String os = t.s;
    }
}

我偶然发现了编译器错误,或者误解了Java规范吗？

编辑: 我现在在另一台电脑上.在这里,javac接受代码,但eclipse仍然没有.这台机器上的版本:

Eclipse平台

版本:3.4.2构建ID:M20090211-1700

JDK 1.6.0

编辑2 确实,javac接受了代码.我通过运行ant build来测试,它使用了IBM的Ascpect J编译器......

这可能听起来很尴尬......
但我不明白.

为什么我们有compile-time error而不是compile-time exception在java？

我的意思是说我们从不说compile-time exception.
我们倾向于说它compile-time error.

是否有任何具体原因？
欢迎任何建议......

谢谢 !

在“领域驱动设计：解决软件核心的复杂性”中，埃文斯定义了

的骨料是相关联的对象的簇，我们把作为数据更改的目的的单元。

显然，这意味着必须在单个事务中更新聚合。

但是，事务是否必须只更新单个聚合？如果是这样，为什么？

我的研究

我问是因为，在“实施领域驱动设计”，第 360 页，弗农写道：

不得在同一事务中修改引用聚合和被引用聚合。在单个事务中只能修改一个或另一个。

但没有给出这个规则的理由。

我知道如果业务规则需要单个事务，这表示隐藏的不变量，这将要求实体成为同一聚合的一部分。但是，如果业务不在乎，而开发人员只是觉得方便怎么办？

在第 437 页，弗农还写道：

注意不要仅仅因为它在单元测试环境中工作就过度使用在单个事务中提交对多个聚合的修改的能力。如果您不小心，在开发和测试中运行良好的方法可能会由于并发问题而在生产中严重失败。

那些并发问题是什么？

代码

class TestException extends Exception {

}

interface Task<E extends Exception> {
    void call() throws E;
}

public class TaskPerformer {

    /** performs a task in the proper context, rethrowing any exceptions the task declares */
    private <E extends Exception> void perform(Task<E> task) throws E {
        beforeTask();
        try {
            task.call();
        } finally {
            afterTask();
        }
    }

    private void afterTask() {
        // implementation elided (does not matter)
    }

    private void beforeTask() {
        // implementation elided (does not matter)
    }

    public static …