Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

Source code: com/ibatis/sqlmap/client/extensions/TypeHandlerCallback.java


1   /*
2    *  Copyright 2004 Clinton Begin
3    *
4    *  Licensed under the Apache License, Version 2.0 (the "License");
5    *  you may not use this file except in compliance with the License.
6    *  You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *  Unless required by applicable law or agreed to in writing, software
11   *  distributed under the License is distributed on an "AS IS" BASIS,
12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *  See the License for the specific language governing permissions and
14   *  limitations under the License.
15   */
16  package com.ibatis.sqlmap.client.extensions;
17  
18  import java.sql.SQLException;
19  
20  /**
21   * A simple interface for implementing custom type handlers.
22   * <p/>
23   * Using this interface, you can implement a type handler that
24   * will perform customized processing before parameters are set
25   * on a PreparedStatement and after values are retrieved from
26   * a ResultSet.  Using a custom type handler you can extend
27   * the framework to handle types that are not supported, or
28   * handle supported types in a different way.  For example,
29   * you might use a custom type handler to implement proprietary
30   * BLOB support (e.g. Oracle), or you might use it to handle
31   * booleans using "Y" and "N" instead of the more typical 0/1.
32   * <p/>
33   * <b>EXAMPLE</b>
34   * <p>Here's a simple example of a boolean handler that uses "Yes" and "No".</p>
35   * <pre>
36   * public class YesNoBoolTypeHandlerCallback implements TypeHandlerCallback {
37   * <p/>
38   *   private static final String YES = "Yes";
39   *   private static final String NO = "No";
40   * <p/>
41   *   public Object getResult(ResultGetter getter) throws SQLException {
42   *     String s = getter.getString();
43   *     if (YES.equalsIgnoreCase(s)) {
44   *       return new Boolean (true);
45   *     } else if (NO.equalsIgnoreCase(s)) {
46   *       return new Boolean (false);
47   *     } else {
48   *       throw new SQLException ("Unexpected value " + s + " found where "+YES+" or "+NO+" was expected.");
49   *     }
50   *   }
51   * <p/>
52   *   public void setParameter(ParameterSetter setter, Object parameter) throws SQLException {
53   *     boolean b = ((Boolean)parameter).booleanValue();
54   *     if (b) {
55   *       setter.setString(YES);
56   *     } else {
57   *       setter.setString(NO);
58   *     }
59   *   }
60   * <p/>
61   *   public Object valueOf(String s) {
62   *     if (YES.equalsIgnoreCase(s)) {
63   *       return new Boolean (true);
64   *     } else if (NO.equalsIgnoreCase(s)) {
65   *       return new Boolean (false);
66   *     } else {
67   *       throw new SQLException ("Unexpected value " + s + " found where "+YES+" or "+NO+" was expected.");
68   *     }
69   *   }
70   * <p/>
71   * }
72   * </pre>
73   */
74  public interface TypeHandlerCallback {
75  
76    /**
77     * Performs processing on a value before it is used to set
78     * the parameter of a PreparedStatement.
79     *
80     * @param setter    The interface for setting the value on the PreparedStatement.
81     * @param parameter The value to be set.
82     * @throws SQLException If any error occurs.
83     */
84    public void setParameter(ParameterSetter setter, Object parameter)
85        throws SQLException;
86  
87    /**
88     * Performs processing on a value before after it has been retrieved
89     * from a ResultSet.
90     *
91     * @param getter The interface for getting the value from the ResultSet.
92     * @return The processed value.
93     * @throws SQLException If any error occurs.
94     */
95    public Object getResult(ResultGetter getter)
96        throws SQLException;
97  
98    /**
99     * Casts the string representation of a value into a type recognized by
100    * this type handler.  This method is used to translate nullValue values
101    * into types that can be appropriately compared.  If your custom type handler
102    * cannot support nullValues, or if there is no reasonable string representation
103    * for this type (e.g. File type), you can simply return the String representation
104    * as it was passed in.  It is not recommended to return null, unless null was passed
105    * in.
106    *
107    * @param s A string representation of a valid value for this type.
108    * @return One of the following:
109    *         <ol>
110    *         <li>the casted repersentation of the String value,</li>
111    *         <li>the string as is,</li>
112    *         <li>null, only if null was passed in.</li>
113    *         </ol>
114    */
115   public Object valueOf(String s);
116 
117 }