h2lc example

      EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory( "h2" );
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      SessionFactoryImplementor sessionFactory = (SessionFactoryImplementor) ((Session)entityManager.getDelegate()).getSessionFactory();

      final String BEFORE = "before";

      TransactionUtil2.inTransaction(
            sessionFactory,
            session -> {

               ReadWriteCacheableItem readWriteCacheableItem = new ReadWriteCacheableItem( BEFORE );
               readWriteCacheableItem.getTags().add( "Hibernate" );
               readWriteCacheableItem.getTags().add( "ORM" );
               session.persist( readWriteCacheableItem );

               ReadWriteVersionedCacheableItem readWriteVersionedCacheableItem = new ReadWriteVersionedCacheableItem( BEFORE );
               readWriteVersionedCacheableItem.getTags().add( "Hibernate" );
               readWriteVersionedCacheableItem.getTags().add( "ORM" );
               session.persist( readWriteVersionedCacheableItem );

               NonStrictReadWriteCacheableItem nonStrictReadWriteCacheableItem = new NonStrictReadWriteCacheableItem( BEFORE );
               nonStrictReadWriteCacheableItem.getTags().add( "Hibernate" );
               nonStrictReadWriteCacheableItem.getTags().add( "ORM" );
               session.persist( nonStrictReadWriteCacheableItem );

               NonStrictReadWriteVersionedCacheableItem nonStrictReadWriteVersionedCacheableItem = new NonStrictReadWriteVersionedCacheableItem( BEFORE );
               nonStrictReadWriteVersionedCacheableItem.getTags().add( "Hibernate" );
               nonStrictReadWriteVersionedCacheableItem.getTags().add( "ORM" );
               session.persist( nonStrictReadWriteVersionedCacheableItem );
            }
      );

      TransactionUtil2.inTransaction(
            sessionFactory,
            s1 -> {
               final String AFTER = "after";

               ReadWriteCacheableItem readWriteCacheableItem1 = s1.get( ReadWriteCacheableItem.class, 1L );
               readWriteCacheableItem1.setName( AFTER );
               readWriteCacheableItem1.getTags().remove("ORM");

               ReadWriteVersionedCacheableItem readWriteVersionedCacheableItem1 = s1.get( ReadWriteVersionedCacheableItem.class, 1L );
               readWriteVersionedCacheableItem1.setName( AFTER );
               readWriteVersionedCacheableItem1.getTags().remove("ORM");

               NonStrictReadWriteCacheableItem nonStrictReadWriteCacheableItem1 = s1.get( NonStrictReadWriteCacheableItem.class, 1L );
               nonStrictReadWriteCacheableItem1.setName( AFTER );
               nonStrictReadWriteCacheableItem1.getTags().remove("ORM");

               NonStrictReadWriteVersionedCacheableItem nonStrictReadWriteVersionedCacheableItem1 = s1.get( NonStrictReadWriteVersionedCacheableItem.class, 1L );
               nonStrictReadWriteVersionedCacheableItem1.setName( AFTER );
               nonStrictReadWriteVersionedCacheableItem1.getTags().remove("ORM");

               s1.flush();
               s1.refresh( readWriteCacheableItem1 );
               s1.refresh( readWriteVersionedCacheableItem1 );
               s1.refresh( nonStrictReadWriteCacheableItem1 );
               s1.refresh( nonStrictReadWriteVersionedCacheableItem1 );

               assertEquals( AFTER, readWriteCacheableItem1.getName() );
               assertEquals( 1, readWriteCacheableItem1.getTags().size() );
               assertEquals( AFTER, readWriteVersionedCacheableItem1.getName() );
               assertEquals( 1, readWriteVersionedCacheableItem1.getTags().size() );
               assertEquals( AFTER, nonStrictReadWriteCacheableItem1.getName() );
               assertEquals( 1, nonStrictReadWriteCacheableItem1.getTags().size() );
               assertEquals( AFTER, nonStrictReadWriteVersionedCacheableItem1.getName() );
               assertEquals( 1, nonStrictReadWriteVersionedCacheableItem1.getTags().size() );

               TransactionUtil2.inTransaction(
                     sessionFactory,
                     s2 -> {
                        ReadWriteCacheableItem readWriteCacheableItem2 = s2.get( ReadWriteCacheableItem.class, 1L );
                        ReadWriteVersionedCacheableItem readWriteVersionedCacheableItem2 = s2.get( ReadWriteVersionedCacheableItem.class, 1L );
                        NonStrictReadWriteCacheableItem nonStrictReadWriteCacheableItem2 = s2.get( NonStrictReadWriteCacheableItem.class, 1L );
                        NonStrictReadWriteVersionedCacheableItem nonStrictReadWriteVersionedCacheableItem2 = s2.get( NonStrictReadWriteVersionedCacheableItem.class, 1L );

                        assertEquals( BEFORE, readWriteCacheableItem2.getName() );
                        assertEquals( 2, readWriteCacheableItem2.getTags().size() );
                        assertEquals( BEFORE, readWriteVersionedCacheableItem2.getName() );
                        assertEquals( 2, readWriteVersionedCacheableItem2.getTags().size() );

                        // AFTER because there is no locking to block the put from the second session

                        assertEquals( AFTER, nonStrictReadWriteCacheableItem2.getName() );
                        assertEquals( 1, nonStrictReadWriteCacheableItem2.getTags().size());
                        assertEquals( AFTER, nonStrictReadWriteVersionedCacheableItem2.getName() );
                        assertEquals( 1, nonStrictReadWriteVersionedCacheableItem2.getTags().size() );
                     }
               );
            }
      );

      TransactionUtil2.inTransaction(
            sessionFactory,
            s -> {
               s.delete( s.getReference( ReadWriteCacheableItem.class, 1L ) );
               s.delete( s.getReference( ReadWriteVersionedCacheableItem.class, 1L ) );
               s.delete( s.getReference( NonStrictReadWriteCacheableItem.class, 1L ) );
               s.delete( s.getReference( NonStrictReadWriteVersionedCacheableItem.class, 1L ) );
            }
      );