Module io.ebean.api
Package io.ebean

Class BeanRepository<I,T>

java.lang.Object
io.ebean.BeanFinder<I,T>
io.ebean.BeanRepository<I,T>
Type Parameters:
I - The ID type
T - The Bean type
@NonNullApi public abstract class BeanRepository<I,T> extends BeanFinder<I,T>
Provides finder functionality for use with "Dependency Injection style" use of Ebean. 



 @Repository
 public class CustomerRepository extends BeanRepository<Long,Customer> {

   @Inject
   public CustomerRepository(Database server) {
     super(Customer.class, server);
   }

   // ... add customer specific finders and persist logic

   public List<Customer> findByName(String nameStart) {
     return query().where()
             .istartsWith("name", nameStart)
             .findList();
   }

 }

  • Constructor Details

    • BeanRepository

      protected BeanRepository(Class<T> type, Database server)
      Create with the given bean type and Database instance.

      Typically users would extend BeanRepository rather than BeanFinder. 

      

   @Inject
   public CustomerRepository(Database server) {
     super(Customer.class, server);
   }
      Parameters:
      type - The bean type
      server - The Database instance typically created via Spring factory or equivalent

  • Method Details

    • markAsDirty

      public void markAsDirty(T bean)
      Marks the entity bean as dirty.

      This is used so that when a bean that is otherwise unmodified is updated the version property is updated.

      An unmodified bean that is saved or updated is normally skipped and this marks the bean as dirty so that it is not skipped. 

      

 Customer customer = customerRepository.byId(id);

 // mark the bean as dirty so that a save() or update() will
 // increment the version property

 customerRepository.markAsDirty(customer);
 customerRepository.save(customer);
      See Also:

    • markPropertyUnset

      public void markPropertyUnset(T bean, String propertyName)
      Mark the property as unset or 'not loaded'.

      This would be used to specify a property that we did not wish to include in a stateless update. 

      

   // populate an entity bean from JSON or whatever
   Customer customer = ...;

   // mark the email property as 'unset' so that it is not
   // included in a 'stateless update'
   customerRepository.markPropertyUnset(customer, "email");

   customerRepository.update(customer);
      Parameters:
      propertyName - the name of the property on the bean to be marked as 'unset'

    • save

      public void save(T bean)
      Insert or update this entity depending on its state.

      Ebean will detect if this is a new bean or a previously fetched bean and perform either an insert or an update based on that.

      See Also:

    • saveAll

      public int saveAll(Collection<T> bean)
      Save all the beans in the collection.

    • update

      public void update(T bean)
      Update this entity.
      See Also:

    • insert

      public void insert(T bean)
      Insert this entity.
      See Also:

    • delete

      public boolean delete(T bean)
      Delete this bean.

      This will return true if the bean was deleted successfully or JDBC batch is being used.

      If there is no current transaction one will be created and committed for you automatically.

      If the Bean does not have a version property (or loaded version property) and the bean does not exist then this returns false indicating that nothing was deleted. Note that, if JDBC batch mode is used then this always returns true.

      See Also:

    • deleteAll

      public int deleteAll(Collection<T> beans)
      Delete all the beans in the collection.

    • deletePermanent

      public boolean deletePermanent(T bean)
      Delete a bean permanently without soft delete.

      This is used when the bean contains a @SoftDelete property and we want to perform a hard/permanent delete.

      See Also:

    • merge

      public void merge(T bean)
      Merge this entity using the default merge options.

      Ebean will detect if this is a new bean or a previously fetched bean and perform either an insert or an update based on that.

      See Also:

    • merge

      public void merge(T bean, MergeOptions options)
      Merge this entity using the specified merge options.

      Ebean will detect if this is a new bean or a previously fetched bean and perform either an insert or an update based on that.

      See Also:

    • refresh

      public void refresh(T bean)
      Refreshes this entity from the database.
      See Also: