java – 密封.jar时密封哪些特定的包？

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java – 密封.jar时密封哪些特定的包？，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5182字，纯文字阅读大概需要8分钟。

内容图文

当密封.jar文件(整个.jar,而不是特定的包)时,哪些包实际上是密封的？是仅包含.class文件的包,还是包含父包和子包？

举一个例子,假设我有一个包含单个.class文件com.company.city.london.class的.jar,是否只有密封的com.company.city包？

JVM是否允许我在.jar之外创建和实例化com.company.city.building.house.class类？

JVM是否允许我在.jar之外创建和实例化com.company.world.class类？

解决方法:

好的,在编写测试应用程序后,我有答案.在阅读文档后,它们并不是我所期望的.

我将以下两个类打包成一个已密封的.jar：

TestClass.java：

package com.company.testjar;

public class TestClass {
}

TestClass2.java：

package com.company.testjar2;

public class TestClass2 {
}

.jar清单看起来像这样：

Manifest-Version: 1.0
Ant-Version: Apache Ant 1.9.3
Created-By: 1.8.0_40-b26 (Oracle Corporation)
Implementation-Vendor: Company
Implementation-Title: Test Jar
Implementation-Version: 6.4.0.0
Sealed: true

根据文档,密封整个.jar密封.jar中的所有包.但是,正如我所发现的那样,这种说法含糊不清.

然后我编写了一些JUnit测试用例,以查看我可以定义的其他类,而不会导致密封的.jar出现问题.

对于我的单元测试,我还添加了以下三个测试类.请注意,这些不是在.jar中定义的,而是使用相同的包结构 – 这对于测试很重要.

Bogus.java：

package com.company.testjar;

public class Bogus {
}

SubBogus.java

package com.company.testjar.subpackage;

public class SubBogus {
}

ParentBogus.java：

package com.company;

public class ParentBogus {
}

JUnit测试：

package com.company.test;

import static org.junit.Assert.*;

import org.junit.Test;

import com.company.ParentBogus;
import com.company.testjar.Bogus;
import com.company.testjar.TestClass;
import com.company.testjar.subpackage.SubBogus;
import com.company.testjar2.TestClass2;

/**
 * A set of tests for testing the effects of .jar sealing.
 * 
 * These tests rely on a built .jar named TestJar.jar which is built from the command line.
 * 
 * Only one of these tests can be run at a time because one a package has been loaded, it cannot
 * be unloaded again. Because of this, each test must be run separately.
 */
public class TestPackages {

    @Test
    public void SealedFail1() {
        // Instantiate instance of TestClass from sealed .jar.
        TestClass t = new TestClass();

        // Following should blow up because package com.company.testjar has already
        // been loaded by instantiating TestClass above.
        try {
            new Bogus();

            // Should not get here. Throw if we do.
            assertFalse(true);
        } catch (SecurityException ex) {
            // Expected.
        }
    }

    @Test
    public void SealedFail2() {
        Bogus b = new Bogus();

        // Following should blow up because package com.company.testjar has already
        // been loaded by instantiating Bogus above.
        try {
            new TestClass();

            // Should not get here. Throw if we do.
            assertFalse(true);
        } catch (SecurityException ex) {
            // Expected.
        }
    }

    /**
     * Test to see if instantiating object from package in a sealed .jar will effectively
     * load and seal all packages in that .jar.
     */
    @Test
    public void SealedFail3() {
        // Instantiate object from com.company.testjar2 package. This package will now be
        // loaded and sealed.
        TestClass2 t2 = new TestClass2();

        // Instantiate object from com.company.testjar package NOT from sealed .jar.
        // This should work because this package has not been sealed yet!
        Bogus b = new Bogus();

        // This should now throw because the com.company.testjar package has already
        // been loaded by instantiating Bogus above, and the TestClass is from that
        // same package from the sealed .jar.
        try {
            new TestClass();

            // Should not get here. Throw if we do.
            assertFalse(true);
        } catch (SecurityException ex) {
            // Expected.
        }
    }

    /**
     * Test to see if instantiating an object from a sealed .jar prevents us from then
     * instantiating an instance of an object from a sub-package NOT defined in the
     * same .jar.
     */
    @Test
    public void SubPackage() {
        // Instantiate instance of TestClass from sealed .jar. Loads and seals the
        // com.company.testjar package.
        TestClass t = new TestClass();

        // Now attempt to instantiate an instance of an object from a sub-package of
        // com.company.testjar which is not defined in the same .jar.
        new SubBogus();
    }

    /**
     * Test to see if instantiating an object from a sealed .jar prevents us from then
     * instantiating an instance of an object from a parent package NOT defined in the
     * same .jar.
     */
    @Test
    public void ParentPackage() {
        // Instantiate instance of TestClass from sealed .jar. Loads and seals the
        // com.company.testjar package.
        TestClass t = new TestClass();

        // Now attempt to instantiate an instance of an object from the parent-package of
        // com.company.testjar which is not defined in the same .jar.
        new ParentBogus();
    }
}

各个测试应该独立运行,因为一旦加载了包,我不会再次卸载它并且会影响测试的结果.如果您一次运行所有测试,则会出现故障,因为第一次测试会加载包并保持加载状态.

单独运行时,所有测试都通过.

从这些测试中,我们可以确定以下内容：

>密封整个.jar不会封闭空的父包.所以下面的空包没有密封：’com’和’com.company’.仅密封包含类的包.请参阅测试ParentPackage().
>如果通过从中实例化类来从.jar加载包,然后尝试从.jar外部的同一包中加载类,则会失败.请参阅测试SealedFail1().
>如果通过实例化与.jar中的.class共享相同包名的类从.jar外部加载包,则尝试从同一包中的密封.jar实例化类将失败.请参阅测试SealedFail2().
>从密封的.jar实例化对象只加载(并密封)该特定类所在的包.同一时间不会加载来自同一.jar的其他包.请参阅测试SealedFail3().
>您可以成功地从.jar中实例化已经密封和加载的包的子包中定义的对象而不会出现问题.请参阅测试SubPackage().

内容总结

以上是互联网集市为您收集整理的java – 密封.jar时密封哪些特定的包？全部内容，希望文章能够帮你解决java – 密封.jar时密封哪些特定的包？所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端