Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Can you find all classes in a package using reflection?
A beginner question about reflection, I suppose: Is it possible to find all classes or interfaces in a given package? (Quickly looking at e.g. Package, it would seem like no.)
2. Classloader issues - How to determine which library versions (jar-files) are loaded
I've just solved another I-though-I-was-using-this-version-of-a-library-but-apparently-my-app-server-has-already-loaded-an-older-version-of-this-library-issue (sigh). Does anybody know a good way to verify (or monitor) whether your application has access to all the appropriate jar-files, or loaded class-versions? Thanks in advance! [P.S. A very good reason to start using the OSGi module arch...
3. In Java, how can I include dynamic version information in a log file?
From a Java application I can log a string, using a custom logging framework, as follows: logger.info("Version 1.2 of the application is currently running"); Therefore when a user sends me a log file I can easily see what version of the application they are running. The problem with the code above is that the version is hardcoded in the string literal and someone needs to remember to update...
4. Finding annotated packages in Java?
What is the cleanest way to find all packages annotated with a particular package-level annotation in their package-info.java?.
5. How do I enumerate the groovy classes in a specific package?
If I have a package (foo.bar), is there some groovy sugar that makes it easy for me to enumerate all the classes in said package?
6. Difference between class and package
What is the difference between a class and a package in Java ?
7. Get current JNLP information
I'm running an application from a jnlp file that contains useful information such as the vendor, a description, and other field. What is the most reasonable way to get this data at Runtime in order to build an "About" dialog ? Is there a way to detect that the application has been launched without Java Web Start ? Thanks for your help. Pierre 
1
  /*
2
   * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.lang;
27
 
30
 
32
 import java.io.File;
36
 import java.net.URL;
40
 
46
 import java.util.Map;
49
 
51
 
Package objects contain version information about the implementation and specification of a Java package. This versioning information is retrieved and made available by the ClassLoader instance that loaded the class(es). Typically, it is stored in the manifest that is distributed with the classes.

The set of classes that make up the package may implement a particular specification and if so the specification title, version number, and vendor strings identify that specification. An application can ask if the package is compatible with a particular version, see the isCompatibleWith(java.lang.String) method for details.

Specification version numbers use a syntax that consists of nonnegative decimal integers separated by periods ".", for example "2.0" or "1.2.3.4.5.6.7". This allows an extensible number to be used to represent major, minor, micro, etc. versions. The version specification is described by the following formal grammar:

SpecificationVersion:
Digits RefinedVersionopt

RefinedVersion:
. Digits
. Digits RefinedVersion

Digits:
Digit
Digits

Digit:
any character for which Character.isDigit(char) returns true, e.g. 0, 1, 2, ...

The implementation title, version, and vendor strings identify an implementation and are made available conveniently to enable accurate reporting of the packages involved when a problem occurs. The contents all three implementation strings are vendor specific. The implementation version strings have no specified syntax and should only be compared for equality with desired version identifiers.

Within each ClassLoader instance all classes from the same java package have the same Package object. The static methods allow a package to be found by name or the set of all packages known to the current class loader to be found.

See also:
ClassLoader.definePackage(java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.net.URL)
108
public class Package implements java.lang.reflect.AnnotatedElement {
    
Return the name of this package.

Returns:
The fully-qualified name of this package as defined in the Java Language Specification, Third Edition §6.5.3, for example, java.lang
117
    public String getName() {
118
        return ;
119
    }


    
Return the title of the specification that this package implements.

Returns:
the specification title, null is returned if it is not known.
126
    public String getSpecificationTitle() {
127
        return ;
128
    }

    
Returns the version number of the specification that this package implements. This version string must be a sequence of nonnegative decimal integers separated by "."'s and may have leading zeros. When version strings are compared the most significant numbers are compared.

Returns:
the specification version, null is returned if it is not known.
139
    public String getSpecificationVersion() {
140
        return ;
141
    }

    
Return the name of the organization, vendor, or company that owns and maintains the specification of the classes that implement this package.

Returns:
the specification vendor, null is returned if it is not known.
149
    public String getSpecificationVendor() {
150
        return ;
151
    }

    
Return the title of this package.

Returns:
the title of the implementation, null is returned if it is not known.
157
    public String getImplementationTitle() {
158
        return ;
159
    }

    
Return the version of this implementation. It consists of any string assigned by the vendor of this implementation and does not have any particular syntax specified or expected by the Java runtime. It may be compared for equality with other package version strings used for this implementation by this vendor for this package.

Returns:
the version of the implementation, null is returned if it is not known.
170
    public String getImplementationVersion() {
171
        return ;
172
    }

    
Returns the name of the organization, vendor or company that provided this implementation.

Returns:
the vendor that implemented this package..
179
    public String getImplementationVendor() {
180
        return ;
181
    }

    
Returns true if this package is sealed.

Returns:
true if the package is sealed, false otherwise
188
    public boolean isSealed() {
189
        return  != null;
190
    }

    
Returns true if this package is sealed with respect to the specified code source url.

Parameters:
url the code source url
Returns:
true if this package is sealed with respect to url
199
    public boolean isSealed(URL url) {
200
        return url.equals();
201
    }

    
Compare this package's specification version with a desired version. It returns true if this packages specification version number is greater than or equal to the desired version number.

Version numbers are compared by sequentially comparing corresponding components of the desired and specification strings. Each component is converted as a decimal integer and the values compared. If the specification value is greater than the desired value true is returned. If the value is less false is returned. If the values are equal the period is skipped and the next pair of components is compared.

Parameters:
desired the version string of the desired version.
Returns:
true if this package's version number is greater than or equal to the desired version number
Throws:
NumberFormatException if the desired or current version is not of the correct dotted form.
225
    public boolean isCompatibleWith(String desired)
226
        throws NumberFormatException
227
    {
228
        if ( == null || .length() < 1) {
229
            throw new NumberFormatException("Empty version string");
230
        }
232
        String [] sa = .split("\\.", -1);
233
        int [] si = new int[sa.length];
234
        for (int i = 0; i < sa.length; i++) {
235
            si[i] = Integer.parseInt(sa[i]);
236
            if (si[i] < 0)
237
                throw NumberFormatException.forInputString("" + si[i]);
238
        }
240
        String [] da = desired.split("\\.", -1);
241
        int [] di = new int[da.length];
242
        for (int i = 0; i < da.length; i++) {
243
            di[i] = Integer.parseInt(da[i]);
244
            if (di[i] < 0)
245
                throw NumberFormatException.forInputString("" + di[i]);
246
        }
248
        int len = Math.max(di.length, si.length);
249
        for (int i = 0; i < len; i++) {
250
            int d = (i < di.length ? di[i] : 0);
251
            int s = (i < si.length ? si[i] : 0);
252
            if (s < d)
253
                return false;
254
            if (s > d)
255
                return true;
256
        }
257
        return true;
258
    }

    
Find a package by name in the callers ClassLoader instance. The callers ClassLoader instance is used to find the package instance corresponding to the named class. If the callers ClassLoader instance is null then the set of packages loaded by the system ClassLoader instance is searched to find the named package.

Packages have attributes for versions and specifications only if the class loader created the package instance with the appropriate attributes. Typically, those attributes are defined in the manifests that accompany the classes.

Parameters:
name a package name, for example, java.lang.
Returns:
the package of the requested name. It may be null if no package information is available from the archive or codebase.
276
    public static Package getPackage(String name) {
277
        ClassLoader l = ClassLoader.getCallerClassLoader();
278
        if (l != null) {
279
            return l.getPackage(name);
280
        } else {
281
            return getSystemPackage(name);
282
        }
283
    }

    
Get all the packages currently known for the caller's ClassLoader instance. Those packages correspond to classes loaded via or accessible by name to that ClassLoader instance. If the caller's ClassLoader instance is the bootstrap ClassLoader instance, which may be represented by null in some implementations, only packages corresponding to classes loaded by the bootstrap ClassLoader instance will be returned.

Returns:
a new array of packages known to the callers ClassLoader instance. An zero length array is returned if none are known.
297
    public static Package[] getPackages() {
298
        ClassLoader l = ClassLoader.getCallerClassLoader();
299
        if (l != null) {
300
            return l.getPackages();
301
        } else {
302
            return getSystemPackages();
303
        }
304
    }

    
Get the package for the specified class. The class's class loader is used to find the package instance corresponding to the specified class. If the class loader is the bootstrap class loader, which may be represented by null in some implementations, then the set of packages loaded by the bootstrap class loader is searched to find the package.

Packages have attributes for versions and specifications only if the class loader created the package instance with the appropriate attributes. Typically those attributes are defined in the manifests that accompany the classes.

Parameters:
class the class to get the package of.
Returns:
the package of the class. It may be null if no package information is available from the archive or codebase.
323
    static Package getPackage(Class c) {
324
        String name = c.getName();
325
        int i = name.lastIndexOf('.');
326
        if (i != -1) {
327
            name = name.substring(0, i);
328
            ClassLoader cl = c.getClassLoader();
329
            if (cl != null) {
330
                return cl.getPackage(name);
331
            } else {
332
                return getSystemPackage(name);
333
            }
334
        } else {
335
            return null;
336
        }
337
    }

    
Return the hash code computed from the package name.

Returns:
the hash code computed from the package name.
343
    public int hashCode(){
344
        return .hashCode();
345
    }

    
Returns the string representation of this Package. Its value is the string "package " and the package name. If the package title is defined it is appended. If the package version is defined it is appended.

Returns:
the string representation of the package.
354
    public String toString() {
355
        String spec = ;
356
        String ver =  ;
357
        if (spec != null && spec.length() > 0)
358
            spec = ", " + spec;
359
        else
360
            spec = "";
361
        if (ver != null && ver.length() > 0)
362
            ver = ", version " + ver;
363
        else
364
            ver = "";
365
        return "package " +  + spec + ver;
366
    }
368
    private Class<?> getPackageInfo() {
369
        if ( == null) {
370
            try {
371
                 = Class.forName( + ".package-info", false, );
372
            } catch (ClassNotFoundException ex) {
373
                // store a proxy for the package info that has no annotations
374
                class PackageInfoProxy {}
375
                 = PackageInfoProxy.class;
376
            }
377
        }
378
        return ;
379
    }

    

Throws:
NullPointerException
Since:
1.5
385
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
386
        return getPackageInfo().getAnnotation(annotationClass);
387
    }

    

Throws:
NullPointerException
Since:
1.5
393
    public boolean isAnnotationPresent(
394
        Class<? extends Annotation> annotationClass) {
395
        return getPackageInfo().isAnnotationPresent(annotationClass);
396
    }

    

Since:
1.5
401
    public Annotation[] getAnnotations() {
402
        return getPackageInfo().getAnnotations();
403
    }

    

Since:
1.5
408
    public Annotation[] getDeclaredAnnotations()  {
409
        return getPackageInfo().getDeclaredAnnotations();
410
    }

    
Construct a package instance with the specified version information.

Parameters:
pkgName the name of the package
spectitle the title of the specification
specversion the version of the specification
specvendor the organization that maintains the specification
impltitle the title of the implementation
implversion the version of the implementation
implvendor the organization that maintains the implementation
Returns:
a new package for containing the specified information.
424
    Package(String name,
425
            String spectitle, String specversion, String specvendor,
426
            String impltitle, String implversion, String implvendor,
427
            URL sealbase, ClassLoader loader)
428
    {
429
         = name;
430
         = impltitle;
431
         = implversion;
432
         = implvendor;
433
         = spectitle;
434
         = specversion;
435
         = specvendor;
436
         = sealbase;
437
        this. = loader;
438
    }
440
    /*
441
     * Construct a package using the attributes from the specified manifest.
442
     *
443
     * @param name the package name
444
     * @param man the optional manifest for the package
445
     * @param url the optional code source url for the package
446
     */
447
    private Package(String name, Manifest man, URL url, ClassLoader loader) {
448
        String path = name.replace('.', '/').concat("/");
449
        String sealed = null;
450
        String specTitle= null;
451
        String specVersion= null;
452
        String specVendor= null;
453
        String implTitle= null;
454
        String implVersion= null;
455
        String implVendor= null;
456
        URL sealBase= null;
457
        Attributes attr = man.getAttributes(path);
458
        if (attr != null) {
459
            specTitle   = attr.getValue(.);
460
            specVersion = attr.getValue(.);
461
            specVendor  = attr.getValue(.);
462
            implTitle   = attr.getValue(.);
463
            implVersion = attr.getValue(.);
464
            implVendor  = attr.getValue(.);
465
            sealed      = attr.getValue(.);
466
        }
467
        attr = man.getMainAttributes();
468
        if (attr != null) {
469
            if (specTitle == null) {
470
                specTitle = attr.getValue(.);
471
            }
472
            if (specVersion == null) {
473
                specVersion = attr.getValue(.);
474
            }
475
            if (specVendor == null) {
476
                specVendor = attr.getValue(.);
477
            }
478
            if (implTitle == null) {
479
                implTitle = attr.getValue(.);
480
            }
481
            if (implVersion == null) {
482
                implVersion = attr.getValue(.);
483
            }
484
            if (implVendor == null) {
485
                implVendor = attr.getValue(.);
486
            }
487
            if (sealed == null) {
488
                sealed = attr.getValue(.);
489
            }
490
        }
491
        if ("true".equalsIgnoreCase(sealed)) {
492
            sealBase = url;
493
        }
494
         = name;
495
        this. = specTitle;
496
        this. = specVersion;
497
        this. = specVendor;
498
        this. = implTitle;
499
        this. = implVersion;
500
        this. = implVendor;
501
        this. = sealBase;
502
        this. = loader;
503
    }
505
    /*
506
     * Returns the loaded system package for the specified name.
507
     */
508
    static Package getSystemPackage(String name) {
509
        synchronized () {
510
            Package pkg = (Package).get(name);
511
            if (pkg == null) {
512
                name = name.replace('.', '/').concat("/");
513
                String fn = getSystemPackage0(name);
514
                if (fn != null) {
515
                    pkg = defineSystemPackage(name, fn);
516
                }
517
            }
518
            return pkg;
519
        }
520
    }
522
    /*
523
     * Return an array of loaded system packages.
524
     */
525
    static Package[] getSystemPackages() {
526
        // First, update the system package map with new package names
527
        String[] names = getSystemPackages0();
528
        synchronized () {
529
            for (int i = 0; i < names.length; i++) {
530
                defineSystemPackage(names[i], getSystemPackage0(names[i]));
531
            }
532
            return (Package[]).values().toArray(new Package[.size()]);
533
        }
534
    }
536
    private static Package defineSystemPackage(final String iname,
537
                                               final String fn)
538
    {
539
        return (Package) AccessController.doPrivileged(new PrivilegedAction() {
540
            public Object run() {
541
                String name = iname;
542
                // Get the cached code source url for the file name
543
                URL url = (URL).get(fn);
544
                if (url == null) {
545
                    // URL not found, so create one
546
                    File file = new File(fn);
547
                    try {
548
                        url = ParseUtil.fileToEncodedURL(file);
549
                    } catch (MalformedURLException e) {
550
                    }
551
                    if (url != null) {
552
                        .put(fn, url);
553
                        // If loading a JAR file, then also cache the manifest
554
                        if (file.isFile()) {
555
                            .put(fn, loadManifest(fn));
556
                        }
557
                    }
558
                }
559
                // Convert to "."-separated package name
560
                name = name.substring(0, name.length() - 1).replace('/', '.');
561
                Package pkg;
562
                Manifest man = (Manifest).get(fn);
563
                if (man != null) {
564
                    pkg = new Package(name, man, url, null);
565
                } else {
566
                    pkg = new Package(name, null, null, null,
567
                                      null, null, null, null, null);
568
                }
569
                .put(name, pkg);
570
                return pkg;
571
            }
572
        });
573
    }
575
    /*
576
     * Returns the Manifest for the specified JAR file name.
577
     */
578
    private static Manifest loadManifest(String fn) {
579
        try {
580
            FileInputStream fis = new FileInputStream(fn);
581
            JarInputStream jis = new JarInputStream(fis, false);
582
            Manifest man = jis.getManifest();
583
            jis.close();
584
            return man;
585
        } catch (IOException e) {
586
            return null;
587
        }
588
    }
590
    // The map of loaded system packages
591
    private static Map pkgs = new HashMap(31);
593
    // Maps each directory or zip file name to its corresponding url
594
    private static Map urls = new HashMap(10);
596
    // Maps each code source url for a jar file to its manifest
597
    private static Map mans = new HashMap(10);
599
    private static native String getSystemPackage0(String name);
600
    private static native String[] getSystemPackages0();
602
    /*
603
     * Private storage for the package name and attributes.
604
     */
605
    private final String pkgName;
606
    private final String specTitle;
607
    private final String specVersion;
608
    private final String specVendor;
609
    private final String implTitle;
610
    private final String implVersion;
611
    private final String implVendor;
612
    private final URL sealBase;
613
    private transient final ClassLoader loader;
614
    private transient Class packageInfo;
New to GrepCode? Check out our FAQ X