The JarClassLoader<\/TT> class extends java.net.URLClassLoader<\/TT>. As its name implies, URLClassLoader<\/TT> is designed to be used for loading classes and resources that are accessed by searching a set of URLs. The URLs can refer either to directories or to JAR files.
\nIn addition to subclassing URLClassLoader<\/TT>, JarClassLoader<\/TT> also makes use of features in two other new JAR-related APIs, the java.util.jar<\/TT> package and the java.net.JarURLConnection<\/TT> class. In this section, we’ll look in detail at the constructor and two methods of JarClassLoader<\/TT>. <\/P><\/BLOCKQUOTE>
\nThe JarClassLoader Constructor<\/H3>
\nThe constructor takes an instance of java.net.URL<\/TT> as an argument. The URL passed to this constructor will be used elsewhere in JarClassLoader<\/TT> to find the JAR file from which classes are to be loaded.
\npublic JarClassLoader(URL url) {
\n super(new URL[] { url });
\n this.url = url;
\n}
\n<\/PRE><\/BLOCKQUOTE>The URL<\/TT> object is passed to the constructor of the superclass, URLClassLoader<\/TT>, which takes a URL[]<\/TT> array, rather than a single URL<\/TT> instance, as an argument. <\/BLOCKQUOTE>
\nThe getMainClassName Method<\/H3>
\nOnce a JarClassLoader<\/TT> object is constructed with the URL of a JAR-bundled application, it’s going to need a way to determine which class in the JAR file is the application’s entry point. That’s the job of the getMainClassName<\/TT> method:
\npublic String getMainClassName() throws IOException {
\n URL u = new URL(“jar”, “”, url + “!\/”);
\n JarURLConnection uc = (JarURLConnection)u.openConnection();
\n Attributes attr = uc.getMainAttributes();
\n return attr != null
\n ? attr.getValue(Attributes.Name.MAIN_CLASS)
\n : null;
\n}
\n<\/PRE><\/BLOCKQUOTE>You may recall from a previous lesson<\/A> that a JAR-bundled application’s entry point is specified by the Main-Class<\/TT> header of the JAR file’s manifest. To understand how getMainClassName<\/TT> accesses the Main-Class<\/TT> header value, let’s look at the method in detail, paying special attention to the new JAR-handling features that it uses:
\nThe JarURLConnection class and JAR URLs<\/H3>The getMainClassName<\/TT> method uses the JAR URL format specified by the java.net.JarURLConnection<\/TT> class. The syntax for the URL of a JAR file is as in this example:
\njar:http:\/\/www.xxx.yyy\/jarfile.jar!\/
\n<\/PRE><\/BLOCKQUOTE>The terminating !\/<\/TT> separator indicates that the URL refers to an entire JAR file. Anything following the separator refers to specific JAR-file contents, as in this example:
\njar:http:\/\/www.xxx.yyy\/jarfile.jar!\/mypackage\/myclass.class
\n<\/PRE><\/BLOCKQUOTE>
\nThe first line in the getMainClassName<\/TT> method is: <\/P>
\nURL u = new URL(“jar”, “”, url + “!\/”);
\n<\/PRE><\/BLOCKQUOTE>This statement constructs a new URL<\/TT> object representing a JAR URL, appending the !\/<\/TT> separator to the URL that was used in creating the JarClassLoader<\/TT> instance.
\n<\/P>
\nThe java.net.JarURLConnection class<\/H3>This class represents a communications link between an application and a JAR file. It has methods for accessing the JAR file’s manifest. The second line of getMainClassName<\/TT> is:
\nJarURLConnection uc = (JarURLConnection)u.openConnection();
\n<\/PRE><\/BLOCKQUOTE>In this statement, URL<\/TT> instance created in the first line opens a URLConnection<\/TT>. The URLConnection<\/TT> instance is then cast to JarURLConnection<\/TT> so it can take advantage of JarURLConnection<\/TT>‘s JAR-handling features.
\nFetching Manifest Attributes: java.util.jar.Attributes<\/H3>With a JarURLConnection<\/TT> open to a JAR file, you can access the header information in the JAR file’s manifest by using the getMainAttributes<\/TT> method of JarURLConnection<\/TT>. This method returns an instance of java.util.jar.Attributes<\/TT>, a class that maps header names in JAR-file manifests with their associated string values. The third line in getMainClassName<\/TT> creates an Attributes<\/TT> object:
\nAttributes attr = uc.getMainAttributes();
\n<\/PRE><\/BLOCKQUOTE>
\nTo get the value of the manifest’s Main-Class<\/TT> header, the fourth line of getMainClassName<\/TT> invokes the Attributes.getValue<\/TT> method: <\/P>
\nreturn attr != null
\n ? attr.getValue(Attributes.Name.MAIN_CLASS)
\n : null;
\n<\/PRE><\/BLOCKQUOTE>
\n<\/P>The method’s argument, Attributes.Name.MAIN_CLASS<\/TT>, specifies that it’s the value of the Main-Class<\/TT> header that you want. (The Attributes.Name<\/TT> class also provides static fields such as MANIFEST_VERSION<\/TT>, CLASS_PATH<\/TT>, and SEALED<\/TT> for specifying other standard manifest headers.) <\/BLOCKQUOTE>
\nThe invokeClass Method<\/H3>
\nWe’ve seen how JarURLClassLoader<\/TT> can identify the main class in a JAR-bundled application. The last method to consider, JarURLClassLoader.invokeClass<\/TT>, enables that main class to be invoked to launch the JAR-bundled application:
\npublic void invokeClass(String name, String[] args)
\n throws ClassNotFoundException,
\n NoSuchMethodException,
\n InvocationTargetException
\n{
\n Class c = loadClass(name);
\n Method m = c.getMethod(“main”, new Class[] { args.getClass() });
\n m.setAccessible(true);
\n int mods = m.getModifiers();
\n if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||
\n !Modifier.isPublic(mods)) {
\n throw new NoSuchMethodException(“main”);
\n }
\n try {
\n m.invoke(null, new Object[] { args });
\n } catch (IllegalAccessException e) {
\n \/\/ This should not happen, as we have disabled access checks
\n }
\n}
\n<\/PRE><\/BLOCKQUOTE>
\nThe invokeClass<\/TT> method takes two arguments: the name of the application’s entry-point class and an array of string arguments to pass to the entry-point class’s main<\/TT> method. First, the main class is loaded: <\/P>
\nClass c = loadClass(name);
\n<\/PRE><\/BLOCKQUOTE>The loadClass<\/TT> method is inherited from java.lang.ClassLoader<\/TT>.
\n<\/P>
\nOnce the main class is loaded, the reflection API of the java.lang.reflect<\/TT> package is used to pass the arguments to the class and launch it. You can refer to the tutorial on The Reflection API<\/A> for a review of reflection. <\/P><\/BLOCKQUOTE>
\n<\/DIV><\/p>\n","protected":false},"excerpt":{"rendered":"The JarClassLoader Class The JarClassLoader class extends java.net.URLClassLoader. As its name implies, URLClassLoader is designed to be used for loading classes and resources that are accessed by searching a set of URLs. The URLs can refer either to directories or to JAR files. In addition to subclassing URLClassLoader, JarClassLoader also makes use of features in … Continue reading The JarClassLoader Class<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-371","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/www.strongd.net\/index.php?rest_route=\/wp\/v2\/posts\/371","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.strongd.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.strongd.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.strongd.net\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.strongd.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=371"}],"version-history":[{"count":0,"href":"https:\/\/www.strongd.net\/index.php?rest_route=\/wp\/v2\/posts\/371\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.strongd.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=371"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.strongd.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=371"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.strongd.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=371"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}