`timeToIdleSeconds` enables cached object to be kept in as long as it is requested in periods shorter than `timeToIdleSeconds`. `timeToLiveSeconds` will make the cached object be invalidated after that many seconds regardless of how many times or when it was requested.

Let&#39;s say that `timeToIdleSeconds = 3`. Then the object will be invalidated if it hasn&#39;t been requested for 4 seconds.

If `timeToLiveSeconds = 90`, then the object will be removed from cache after 90 seconds, even if it has been requested few milliseconds in the 90th second of its short life. 

If you set both, the `expirationTime` will be `Math.min(ttlExpiry, ttiExpiry)`, where 

    ttlExpiry = creationTime + timeToLive
    ttiExpiry = mostRecentTime + timeToIdle

Full source code [here][1].


  [1]: http://grepcode.com/file/repo1.maven.org/maven2/net.sf.ehcache/ehcache-core/2.5.0/net/sf/ehcache/Element.java#Element.getExpirationTime%28%29


From the [old 1.1 documentation][1] (available in Google Cache, which is easier to browse and more informative than the current docs AFAIK):

&gt; **timeToIdleSeconds**
&gt; 
&gt; This is an optional attribute.
&gt; 
&gt; Legal values are integers between 0 and Integer.MAX_VALUE.
&gt; 
&gt; It is the number of seconds that an Element should live since it was
&gt; last used. Used means inserted or accessed. 
&gt; 
&gt; 0 has a special meaning, which is not to check the Element for time to
&gt; idle, i.e. it will idle forever.
&gt; 
&gt; The default value is 0.
&gt; 
&gt; **timeToLiveSeconds**
&gt; 
&gt; This is an optional attribute.
&gt; 
&gt; Legal values are integers between 0 and Integer.MAX_VALUE.
&gt; 
&gt; It is the number of seconds that an Element should live since it was
&gt; created. Created means inserted into a cache using the Cache.put
&gt; method.
&gt; 
&gt; 0 has a special meaning, which is not to check the Element for time to
&gt; live, i.e. it will live forever.
&gt; 
&gt; The default value is 0.


  [1]: http://webcache.googleusercontent.com/search?q=cache:HAY-qhRmmYsJ:ehcache.org/documentation/documentation-1_1.html%20ehcache%20timeToLiveSeconds%20infinite&amp;cd=2&amp;hl=en&amp;ct=clnk&amp;gl=au&amp;source=www.google.com.au

does anyone have a good definition for what a binary protocol is? and what is a text protocol actually? how do these compare to each other in terms of bits sent on the wire? 

here&#39;s what wikipedia says about binary protocols:

A binary protocol is a protocol which is intended or expected to be read by a machine rather than a human being (http://en.wikipedia.org/wiki/Binary_protocol)

oh come on! 

to be more clear, if I have jpg file how would that be sent through a binary protocol and how through a text one? in terms of bits/bytes sent on the wire of course. 

at the end of the day if you look at a string it is itself an array of bytes so the distinction between the 2 protocols should rest on what actual data is being sent on the wire. in other words, on how the initial data (jpg file) is encoded before being sent.



binary protocols v. text protocols

[I watched the video][1] and I know the general principles - hot happens even when nobody is subscribed, cold happens &quot;on demand&quot;.
Also, Publish() converts cold to hot and Defer() converts hot to cold.

But still, I feel I am missing the details. Here are some questions I&#39;d like to have answered:

 - Can you give a comprehensive definition for these terms?
 - Does it ever make sense to call Publish on a hot observable or Defer on a cold?
 - What are the aspects of Hot/Cold conversions - do you lose messages, for example?
 - Are there differences between hot and cold definitions for IObservable and IEnumerable?
 - What are the general principles you should take into account when programming for cold or hot?
 - Any other tips on hot/cold observables?

  [1]: http://channel9.msdn.com/posts/J.Van.Gogh/Rx-API-in-depth-Hot-and-Cold-observables/

What are the Hot and Cold observables?

The docs on ehache says:

    timeToIdleSeconds: Sets the time to idle for an element before it expires.
    i.e. The maximum amount of time between accesses before an element expires
    
    timeToLiveSeconds: Sets the time to live for an element before it expires.
    i.e. The maximum time between creation time and when an element expires.

I understand **timeToIdleSeconds**

But does it means that after the creation &amp; first access of a cache item, the **timeToLiveSeconds** is not applicable anymore ?


How to differentiate between time to live and time to idle in ehcache

The docs on ehache says:
<pre><code class="hljs language-sql">timeToIdleSeconds: Sets the time to idle for an element before it expires.
i.e. The maximum amount of time between accesses before an element expires

timeToLiveSeconds: Sets the time to live for an element before it expires.
i.e. The maximum time between creation time and when an element expires.
</code></pre>
I understand timeToIdleSeconds
But does it means that after the creation &#x26; first access of a cache item, the timeToLiveSeconds is not applicable anymore ?

In the example section of the [`@OneToMany` JPA annotation reference][1]:

**Example 1-59 @OneToMany - Customer Class With Generics**
    
    @Entity
    public class Customer implements Serializable {
        ...
        @OneToMany(cascade=ALL, mappedBy=&quot;customer&quot;)
        public Set&lt;Order&gt; getOrders() { 
            return orders; 
        }
        ...
    }
    
**Example 1-60 @ManyToOne - Order Class With Generics**
    
    @Entity
    public class Order implements Serializable {
        ...
        @ManyToOne
        @JoinColumn(name=&quot;CUST_ID&quot;, nullable=false)
        public Customer getCustomer() { 
            return customer; 
        }
        ...
    }

It seems to me that the `Customer` entity is the owner of the association. However, in the explanation for the `mappedBy` attribute in the same document, it is written that:

&gt; if the relationship is bidirectional,
&gt; then set the mappedBy element on the
&gt; inverse (non-owning) side of the
&gt; association to the name of the field
&gt; or property that owns the relationship
&gt; as Example 1-60 shows.

However, if I am not wrong, it looks like in the example, the `mappedBy` is actually specified on the owning side of the association, rather than the non-owning side.

So my question is basically:

 1. In a bidirectional (one-to-many/many-to-one) association, which of the entities is the owner? How can we designate the One side as the owner? How can we designate the Many side as the owner?

 2. What is meant by &quot;the inverse side of the association&quot;? How can we designate the One side as the inverse? How can we designate the Many side as the inverse?

  [1]: https://docs.oracle.com/javaee/7/api/javax/persistence/OneToMany.html

What is “the inverse side of the association” in a bidirectional JPA OneToMany/ManyToOne association?

Our toolkit has over 15000 [JUnit][1] tests, and many tests are known to fail if some other test fails. For example, if the method X.foo() uses functionality from Y.bar() and YTest.testBar() fails, then XTest.testFoo() will fail too. Obviously, XTest.testFoo() can also fail because of problems specific to X.foo().

While this is fine and I still want both tests run, it would be nice if one could annotate a test dependency with XTest.testFoo() pointing to YTest.testBar(). This way, one could immediately see what functionality used by X.foo() is also failing, and what not.

Is there such annotation available in JUnit or elsewhere? Something like:

    public XTest {

      @Test
      @DependsOn(method=org.example.tests.YTest#testBar)
      public void testFoo() {
         // Assert.something();
      }
    
    }


  [1]: http://www.junit.org/

How can I specify JUnit test dependencies?

Recently a co-worker of mine wrote in some code to catch a null pointer exception around an entire method, and return a single result. I pointed out how there could&#39;ve been any number of reasons for the null pointer, so we changed it to a defensive check for the one result.

However, catching NullPointerException just seemed wrong to me. In my mind, Null pointer exceptions are the result of bad code and not to be an expected exception in the system.

Are there any cases where it makes sense to catch a null pointer exception? 

Is Catching a Null Pointer Exception a Code Smell?

A good example of when exactly to use interfaces specifically in Java would be ideal and any specific rulings that apply.

When should I use an interface in java?

I am a newbie in java and wanted to use curl in java. What is my question is curl built-in in java or I have to install it from any 3rd party source to use with Java. If so, how to install curl in java. I have been googling for a long time but didnt find any help. Hope anyone can help me out there. 

Thanks in advance.

How to use cURL in Java?

Question is clear as you see in the title, it would be appreciated to hear your ideas about adv./disadv. differences between them.

**UPDATE:**
I have decided to use Hazelcast because of the advantages like distributed caching/locking mechanism as well as the extremely easy configuration while adapting it to your application.  

hazelcast vs ehcache

I&#39;m working on developing a web application with Spring 3 and Hibernate 3.6. At the moment I try to understand how Caching with Spring and Hibernate works. I found some sources about Caching with Hibernate and some about Spring and I try to bring my information together now. I still got some questions to both frameworks and I&#39;d be glad if someone could answer them or tell me if the facts listed here are correct.

Most of the time, short answers (yes/no) would be sufficient. I think that this list can be useful for others too, who want to understand how caching with spring and hibernate works.

`General`

**1)** Hibernate supports the following Caches: 1st Level Cache, 2nd Level Cache, Query Cache

**2)** Spring itself supports the following Caching possibilities: just Method Caching 

`1st Level Cache`

**3)** The 1st Level Cache is part of EVERY Hibernate application. 

**4)** The 1st Level Cache is created for EVERY hibernate-session. 

**5)** What is saved in the 1st Level Cache? Objects or just the values of their properties? queries and their results?

`2nd Level Cache`

**6)** I found out: the 2nd Level Cache is used ONCE per application. isn&#39;t that false? isn&#39;t it used ONCE per `SessionFactory`? and: multiple sessionfactorys = multiple 2nd level caches possible?

**7)** what is saved in the 2nd Level Cache: in my opinion just the values belonging to one record, not the objects itself.

**8)** when storing values from one record in 2nd Level Cache, its possible to store related values (from objects connected over a foreign key) with it too?

**9)** when updating the values of one object in the 2nd level cache, it&#39;s possible to update the values of objects connected with it in the cache too?

**10)** when values of an object are changing, how can I update the 2nd level cache? flush? can I just update a part of the cache or must the whole cache be updated?

**11)** where does the 2nd level cache make sense and where doesn&#39;t it?

**12)** the Cache Mode: does each cache mode provide a different strategy of caching? for example with cache mode &quot;read-only&quot; no synchronization of database and cache is ever necessary? do other cache modes provide synchronization? I thought synchronization must be done by the developer himself?

`Query Cache`

**13)** what is the difference between the Query Cache and the 2nd Level Cache? in my opinion: in the Query Cache result sets are saved, but not with their values, just with their ids. when the query is used again and the result set is still &quot;correct&quot;, the values belonging to the ids are queried from the 2nd Level Cache

**14)** For the Query Cache a 2nd Level Cache MUST be used?

**15)** where does the Query Cache make sense and where doesn&#39;t it?

`Spring`

**16)** Does Spring provide more Caching possibilities than method caching?

**17)** method caching is not linked to hibernate caching

**18)** but: for method caching the 2nd level is necessary, like Ehcache (which can be used by hibernate too)

**19)** can method caching be used without database queries?

`Getting mixed up`

**20)** if using ehcache for hibernate as 2nd level cache and Ehcache for spring for method caching, can I use the same Ehcache-instance? is there a chance that something gets mixed up?

**21)** when using 1st level cache and 2nd level cache, can they get mixed up? when querying the database, where does the result then come from, the 1st or 2nd level cache? does the 1st level cache work with the 2nd level cache?

**22)** anything else that can get mixed up by using the caches I mentioned? :-)

Thanks for answering, no matter what question! :-)


Caching with Hibernate + Spring - some Questions

Ehcache [talks about][1] on-heap and off-heap memory. What is the difference? What JVM args are used to configure them?


  [1]: http://ehcache.org/documentation/offheap_store.html#Storage

Difference between &quot;on-heap&quot; and &quot;off-heap&quot;

This is what happens when I run my junit tests...


    Another CacheManager with same name &#39;cacheManager&#39; already exists in the same VM. Please 
    provide unique names for each CacheManager in the config or do one of following:
    1. Use one of the CacheManager.create() static factory methods to reuse same
       CacheManager with same name or create one if necessary
    2. Shutdown the earlier cacheManager before creating new one with same name.
    
    The source of the existing CacheManager is: 
     DefaultConfigurationSource [ ehcache.xml or ehcache-failsafe.xml ]


What&#39;s the reason behind the exception. Could there be more than 1 cacheManager running simultaneously?

This is how I configured the cachManager using Sping 3.1.1. It sets explicitly the scope of the cacheManager to &quot;singleton&quot;

    &lt;ehcache:annotation-driven /&gt;

    &lt;bean
        id=&quot;cacheManager&quot;
        class=&quot;org.springframework.cache.ehcache.EhCacheManagerFactoryBean&quot;
        scope=&quot;singleton&quot;
        /&gt;




The ehcache.xml looks like


    &lt;ehcache xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
         xsi:noNamespaceSchemaLocation=&quot;http://ehcache.org/ehcache.xsd&quot;
         updateCheck=&quot;false&quot;
         maxBytesLocalHeap=&quot;100M&quot; 
         name=&quot;cacheManager&quot;
         &gt;
     ....
     &lt;/ehcache&gt;


Finally my class 


    @Component
    public class BookingCache implements CacheWrapper&lt;String, BookingUIBean&gt; {

         @Autowired
         private CacheManager ehCacheManager;
          ....
    }

I&#39;m very sure that I&#39;m dealing with only one cacheManager in my code base. Something else is probably running the n-th instance.

Another unnamed CacheManager already exists in the same VM (ehCache 2.5)

From the [spring documentation][1] :

    @Cacheable(value=&quot;bookCache&quot;, key=&quot;isbn&quot;)
    public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)


How can I specify `@Cachable` to use `isbn` and `checkWarehouse` as key?


  [1]: http://static.springsource.org/spring/docs/3.1.0.M1/spring-framework-reference/html/cache.html

Content Type	Original Author	Original Content on Stackoverflow
Question	Jacques René Mesrine	View Question on Stackoverflow
Solution 1 - Java	Boris Pavlović	View Answer on Stackoverflow
Solution 2 - Java	Lee Chee Kiam	View Answer on Stackoverflow
Solution 3 - Java	Damo	View Answer on Stackoverflow

How to differentiate between time to live and time to idle in ehcache

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

What are the Hot and Cold observables?

binary protocols v. text protocols

Attributions