Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p>I find the code honestly hard to follow and understand. It's full of <code>static</code> which is usually a bad sign in OO design and it's hard to follow with the generics. </p> <p>Wouldn't something simpler like this work as well?</p> <pre><code>private static &lt;T&gt; T getter(Future&lt;T&gt; src) { try { return src.get(); } catch (InterruptedException e) { handle( "some text"); } catch (ExecutionException e) { handle( e ) } return null; } </code></pre> <p>You can implement as many <code>handle</code> method as necessary in a base class (or in a static utility class) and use them in the catch block as necessary. Methods will be selected based on the signature, so if you want to print the text, you pass the string, if you want the stack trace you pass the exception (or both). Which leads to the combinations:</p> <pre><code>handle( String msg ) handle( Exception e ) handle( Exception e, String msg ) </code></pre> <p>This solution has less <code>if</code>, which is usually a good sign as well.</p> <p>But I have maybe missed a point, given that the code you published is just an excerpt of the whole code.</p> <p>Have a look otherwise at this question, which is also related: <a href="https://stackoverflow.com/questions/2236063/pluggable-error-handling-strategy/2236437#2236437">Pluggable Error Handling Strategy</a></p> <p><strong>EDIT</strong></p> <p>If the solution I proposed above is too simple for your need, here are two other ways:</p> <pre><code>public class AbstractGetter&lt;From&gt; implements Function&lt;Future&lt;? extends From&gt;, From&gt; { private abstract handleInterrupt( Exception e ); private abstract handleExecution( Exception e ); private static &lt;T&gt; T getter(Future&lt;T&gt; src ) { try { return src.get(); } catch (InterruptedException e) { handleInterrupt(e) } catch (ExecutionException e) { handleExecution(e) } return null; } } </code></pre> <p>And you implement the X concrete class that correspond the various exception handling strategies. That's essentially the <a href="http://en.wikipedia.org/wiki/Template_method_pattern" rel="nofollow noreferrer">template</a> pattern.</p> <p>You can still use delegation, but at a more coarse-grained level. Instead of providing individual handler, you provide a handler strategy. That's kind of variation of the <a href="http://en.wikipedia.org/wiki/Strategy_pattern" rel="nofollow noreferrer">strategy</a> pattern then.</p> <pre><code> public interface ErrorStrategy { public void handleInterrupt(Exception e); public void handleExecution(Exception e); } public class Getter&lt;From&gt; implements Function&lt;Future&lt;? extends From&gt;, From&gt; { ErrorStrategy handler = new DefaultErrorStrategy(). // default one public Getter&lt;From&gt;() { } public Getter&lt;From&gt;( ErrorStrategy h ) { this.handler = h. } private static &lt;T&gt; T getter(Future&lt;T&gt; src ) { try { return src.get(); } catch (InterruptedException e) { handler.handleInterrupt(e) } catch (ExecutionException e) { handler.handleExecution(e) } return null; } } </code></pre> <p>You can create the X error handling strategies that you need. </p>
    singulars
    1. This table or related slice is empty.
    1. POJava Exception Handling via Strategy Pattern?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USCommunity
    1. USewernli
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    1. COah, the statics are mostly sugar to avoid the huge constructor calls with a generic argument (e.g., Getter<List<Set<Foo>>> bar = new Getter<List<Set<Foo>>>() vs. Getter<List<Set<Foo>>> bar = Getter.make() ). the private method is static mostly as a reminder that all Getter's do the same thing, so they can use one method, but some delegation is required to wrangle generics/inheritance.
      singulars
      1. PO
      1. USCarl
    2. COYes. I was more speaking about the generics related to exception handling only.
      singulars
      1. PO
      1. USewernli
    3. COre:edit: that seems very similar to what I'm doing currently - ExceptionHandler is a strategy for handling a specific type of Exception. In my example case, the default strategies are specified in the base class, with the option to provide specific strategies when constructing that class.
      singulars
      1. PO
      1. USCarl
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload