Package hudson

Class BulkChange

  • All Implemented Interfaces:
    Closeable, AutoCloseable
    public class BulkChange
extends Object
implements Closeable
    Transaction-like object that can be used to make a bunch of changes to an object, and defer the Saveable.save() until the end.

    The usage of BulkChange needs to follow a specific closure-like pattern, namely: 

     try (BulkChange bc = new BulkChange(someObject)) {
    ... make changes to 'someObject'
    bc.commit();
 }

    Use of this method is optional. If BulkChange is not used, individual mutator will perform the save operation, and things will just run somewhat slower.

    Cooperation from Saveable

    For this class to work as intended, Saveable implementations need to co-operate. Namely,

    1. Mutator methods should invoke this.save() so that if the method is called outside a BulkChange, the result will be saved immediately.
    2. In the save() method implementation, use contains(Saveable) and only perform the actual I/O operation when this method returns false.

    See Jenkins.save() as an example if you are not sure how to implement Saveable.

    Since:
    1.249
    Author:
    Kohsuke Kawaguchi

    • Constructor Detail

      • BulkChange

        public BulkChange​(Saveable saveable)

    • Method Detail

      • abort

        public void abort()
        Exits the scope of BulkChange without saving the changes.

        This can be used when a bulk change fails in the middle. Note that unlike a real transaction, this will not roll back the state of the object.

        The abort method can be called after the commit method, in which case this method does nothing. This is so that BulkChange can be used naturally in the try/finally block.

      • current

        public static BulkChange current()
        Gets the BulkChange instance currently in scope for the current thread.

      • contains

        public static boolean contains​(Saveable s)
        Checks if the given Saveable is currently in the bulk change.

        The expected usage is from the Saveable.save() implementation to check if the actual persistence should happen now or not.