Package com.google.common.flogger.backend.system

Class BackendFactory

  • Direct Known Subclasses:
    SimpleBackendFactory
    public abstract class BackendFactory
extends java.lang.Object
    An API to create logger backends for a given class name. This is implemented as an abstract class (rather than an interface) to reduce to risk of breaking existing implementations if the API changes.

    Essential Implementation Restrictions

    Any implementation of this API MUST follow the rules listed below to avoid any risk of re-entrant code calling during logger initialization. Failure to do so risks creating complex, hard to debug, issues with Flogger configuration.
    1. Implementations MUST NOT attempt any logging in static methods or constructors.
    2. Implementations MUST NOT statically depend on any unknown code.
    3. Implementations MUST NOT depend on any unknown code in constructors.

    Note that logging and calling arbitrary unknown code (which might log) are permitted inside the instance methods of this API, since they are not called during platform initialization. The easiest way to achieve this is to simply avoid having any non-trivial static fields or any instance fields at all in the implementation.

    While this sounds onerous it's not difficult to achieve because this API is a singleton, and can delay any actual work until its methods are called. For example if any additional state is required in the implementation, it can be held via a "lazy holder" to defer initialization.

    This is a service type

    This type is considered a service type and implemenations may be loaded from the classpath via ServiceLoader provided the proper service metadata is included in the jar file containing the implementation. When creating an implementation of this class, you can provide serivce metadata (and thereby allow users to get your implementation just by including your jar file) by either manually including a META-INF/services/com.google.common.flogger.backend.system.BackendFactory file containing the name of your implementation class or by annotating your implementation class using @AutoService(BackendFactory.class). See the documentation of both ServiceLoader and DefaultPlatform for more information.

    • Constructor Summary

      Constructors 
      Constructor Description
      BackendFactory()  

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      abstract com.google.common.flogger.backend.LoggerBackend create​(java.lang.String loggingClassName)
      Creates a logger backend of the given class name for use by a Fluent Logger.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Constructor Detail

      • BackendFactory

        public BackendFactory()

    • Method Detail

      • create

        public abstract com.google.common.flogger.backend.LoggerBackend create​(java.lang.String loggingClassName)
        Creates a logger backend of the given class name for use by a Fluent Logger. Note that the returned backend need not be unique; one backend could be used by multiple loggers. The given class name must be in the normal dot-separated form (e.g., "com.example.Foo$Bar") rather than the internal binary format "com/example/Foo$Bar").
        Parameters:
        loggingClassName - the fully-qualified name of the Java class to which the logger is associated. The logger name is derived from this string in a backend specific way.