View Javadoc

    1   /***
    2    * @(#)IbatisServiceImpl.java
    3    *
    4    * JFoxSOAF, Service-Oriented Application Framework
    5    *
    6    * Copyright(c) JFoxSOAF Team
    7    *
    8    * Licensed under the GNU LGPL, Version 2.1 (the "License");
    9    * you may not use this file except in compliance with the License.
    10   * You may obtain a copy of the License at
    11   *
    12   * http://www.gnu.org/copyleft/lesser.html
    13   *
    14   * Unless required by applicable law or agreed to in writing, software
    15   * distributed under the License is distributed on an "AS IS" BASIS,
    16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    17   * See the License for the specific language governing permissions and
    18   * limitations under the License.
    19   *
    20   * For more information, please visit:
    21   * http://www.jfox.cn/confluence/display/JFoxSOAF/Home
    22   * http://www.huihoo.org/jfox/jfoxsoaf
    23   */
    24
    25  package org.huihoo.jfox.soaf.services.persistence;
    26
    27  import java.io.Reader;
    28  import java.sql.SQLException;
    29  import java.util.List;
    30  import java.util.Map;
    31
    32  import org.apache.commons.logging.Log;
    33  import org.apache.commons.logging.LogFactory;
    34  import org.huihoo.jfox.soaf.exception.DAOException;
    35  import org.huihoo.jfox.soaf.exception.IbatisConfigurationException;
    36  import org.picocontainer.Startable;
    37
    38  import com.ibatis.common.resources.Resources;
    39  import com.ibatis.common.util.PaginatedList;
    40  import com.ibatis.dao.client.DaoManager;
    41  import com.ibatis.dao.client.DaoManagerBuilder;
    42  import com.ibatis.sqlmap.client.SqlMapClient;
    43  import com.ibatis.sqlmap.client.SqlMapClientBuilder;
    44  import com.ibatis.sqlmap.client.SqlMapSession;
    45  import com.ibatis.sqlmap.client.event.RowHandler;
    46
    47  /***
    48   * <p>
    49   * Ibatis persistence service wrapper.
    50   * </p>
    51   *
    52   * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
    53   * @version $Revision: 1.6 $ $Date: 2005/01/17 14:18:14 $
    54   * @version Revision: 1.0
    55   */
    56
    57  public class IbatisServiceImpl implements IbatisService, Startable {
    58
    59      private final Log logger = LogFactory.getLog(getClass());
    60
    61      private static final String IBATIS_DAO_RESOURCE = "ibatis-dao.xml";
    62
    63      private static final String IBATIS_SQLMAP_RESOURCE = "ibatis-sqlmap-config.xml";
    64
    65      private DaoManager daoManager;
    66
    67      private SqlMapClient sqlMapClient;
    68
    69      private SqlMapSession session;
    70
    71      /***
    72       * Defalut Constructor.
    73       */
    74      public IbatisServiceImpl() {
    75      }
    76
    77      /***
    78       * @see org.huihoo.jfox.soaf.services.persistence.IbatisService#getDaoManager()
    79       */
    80      public DaoManager getDaoManager() {
    81          return this.daoManager;
    82      }
    83
    84      private SqlMapClient getSqlMapClient() {
    85          return this.sqlMapClient;
    86      }
    87
    88      /***
    89       * Returns a single threaded SqlMapSession implementation for use by one
    90       * user.
    91       *
    92       * @see org.huihoo.jfox.soaf.services.persistence.IbatisService#openSession()
    93       */
    94      public SqlMapSession openSession() throws SQLException {
    95          if (session != null) {
    96              session = getSqlMapClient().openSession();
    97              session.startTransaction();
    98          }
    99          return session;
    100     }
    101
    102     /***
    103      * @see org.huihoo.jfox.soaf.services.persistence.IbatisService#commit()
    104      */
    105     public void commit() throws SQLException {
    106         if (session != null) {
    107             session.commitTransaction();
    108         }
    109     }
    110
    111     /***
    112      * @see org.huihoo.jfox.soaf.services.persistence.IbatisService#closeSession()
    113      */
    114     public void closeSession() throws SQLException {
    115         if (session != null) {
    116             session.endTransaction();
    117             session.close();
    118             session = null;
    119         }
    120     }
    121
    122     /***
    123      * @see org.picocontainer.Startable#start()
    124      */
    125     public void start() {
    126         try {
    127             Reader reader = Resources.getResourceAsReader(IBATIS_DAO_RESOURCE);
    128             Reader sqlMapClientReader = Resources
    129                     .getResourceAsReader(IBATIS_SQLMAP_RESOURCE);
    130             daoManager = DaoManagerBuilder.buildDaoManager(reader);
    131             sqlMapClient = SqlMapClientBuilder
    132                     .buildSqlMapClient(sqlMapClientReader);
    133         } catch (Exception e) {
    134             throw new IbatisConfigurationException(
    135                     "Failed to initialize Ibatis DaoConfig.  Cause: " + e);
    136         }
    137         logger.info("Start ibatis service successful.");
    138     }
    139
    140     /***
    141      * @see org.picocontainer.Startable#stop()
    142      */
    143     public void stop() {
    144     }
    145
    146     /***
    147      * Executes a mapped SQL INSERT statement. Insert is a bit different from
    148      * other update methods, as it provides facilities for returning the primary
    149      * key of the newly inserted row (rather than the effected rows). This
    150      * functionality is of course optional.
    151      *
    152      * @param id
    153      * @param parameterObject
    154      * @return The primary key of the newly inserted row. This might be
    155      *         automatically generated by the RDBMS, or selected from a sequence
    156      *         table or other source.
    157      * @throws SQLException
    158      * @throws DAOException
    159      */
    160     public Object insert(String id, Object parameterObject)
    161             throws SQLException, DAOException {
    162         SqlMapSession session;
    163         Object object;
    164         try {
    165             session = openSession();
    166             object = session.insert(id, parameterObject);
    167             commit();
    168         } catch (Exception e) {
    169             throw new DAOException("Failed to insert - id [" + id
    170                     + "], parameterObject [" + parameterObject + "]. Cause: "
    171                     + e, e);
    172         } finally {
    173             session = null;
    174             closeSession();
    175         }
    176         return object;
    177     }
    178
    179     /***
    180      * Executes a mapped SQL UPDATE statement. Update can also be used for any
    181      * other update statement type, such as inserts and deletes. Update returns
    182      * the number of rows effected.
    183      *
    184      * @param id
    185      * @param parameterObject
    186      * @return The number of rows effected.
    187      * @throws SQLException
    188      * @throws DAOException
    189      */
    190     public int update(String id, Object parameterObject) throws SQLException,
    191             DAOException {
    192         SqlMapSession session;
    193         int rowsNum;
    194         try {
    195             session = openSession();
    196             rowsNum = session.update(id, parameterObject);
    197             commit();
    198         } catch (Exception e) {
    199             throw new DAOException("Failed to update - id [" + id
    200                     + "], parameterObject [" + parameterObject + "]. Cause: "
    201                     + e, e);
    202         } finally {
    203             session = null;
    204             closeSession();
    205         }
    206         return rowsNum;
    207     }
    208
    209     /***
    210      * Executes a mapped SQL DELETE statement. Delete returns the number of rows
    211      * effected.
    212      *
    213      * @param id
    214      * @param parameterObject
    215      * @return The number of rows effected
    216      * @throws SQLException
    217      * @throws DAOException
    218      */
    219     public int delete(String id, Object parameterObject) throws SQLException,
    220             DAOException {
    221         SqlMapSession session;
    222         int rowsNum;
    223         try {
    224             session = openSession();
    225             rowsNum = session.delete(id, parameterObject);
    226             commit();
    227         } catch (Exception e) {
    228             throw new DAOException("Failed to delete - id [" + id
    229                     + "], parameterObject [" + parameterObject + "]. Cause: "
    230                     + e, e);
    231         } finally {
    232             session = null;
    233             closeSession();
    234         }
    235         return rowsNum;
    236     }
    237
    238     /***
    239      * Executes a mapped SQL SELECT statement that returns data to populate a
    240      * single object instance. <p/>The parameter object is generally used to
    241      * supply the input data for the WHERE clause parameter(s) of the SELECT
    242      * statement.
    243      *
    244      * @param id The name of the statement to execute.
    245      * @param parameterObject The parameter object (e.g. JavaBean, Map, XML
    246      *            etc.).
    247      * @return The single result object populated with the result set data.
    248      */
    249     public Object queryForObject(String id, Object parameterObject)
    250             throws SQLException, DAOException {
    251         SqlMapSession session;
    252         Object object;
    253         try {
    254             session = openSession();
    255             object = session.queryForObject(id, parameterObject);
    256             commit();
    257         } catch (Exception e) {
    258             throw new DAOException("Failed to execute queryForObject - id ["
    259                     + id + "], parameterObject [" + parameterObject
    260                     + "].  Cause: " + e, e);
    261         } finally {
    262             session = null;
    263             closeSession();
    264         }
    265         return object;
    266     }
    267
    268     /***
    269      * Executes a mapped SQL SELECT statement that returns data to populate the
    270      * supplied result object.
    271      *
    272      * @param id
    273      * @param parameterObject
    274      * @param resultObject
    275      * @return The single result object as supplied by the resultObject
    276      *         parameter, populated with the result set data.
    277      * @throws SQLException
    278      * @throws DAOException
    279      */
    280     public Object queryForObject(String id, Object parameterObject,
    281             Object resultObject) throws SQLException, DAOException {
    282         SqlMapSession session;
    283         Object object;
    284         try {
    285             session = openSession();
    286             object = session.queryForObject(id, parameterObject, resultObject);
    287             commit();
    288         } catch (Exception e) {
    289             throw new DAOException("Failed to execute queryForObject - id ["
    290                     + id + "], parameterObject [" + parameterObject
    291                     + "].  Cause: " + e, e);
    292         } finally {
    293             session = null;
    294             closeSession();
    295         }
    296         return object;
    297     }
    298
    299     /***
    300      * Executes a mapped SQL SELECT statement that returns data to populate a
    301      * number of result objects.
    302      *
    303      * @param id
    304      * @param parameterObject
    305      * @return A List of result objects.
    306      * @throws SQLException
    307      * @throws DAOException
    308      */
    309     public List queryForList(String id, Object parameterObject)
    310             throws SQLException, DAOException {
    311         SqlMapSession session;
    312         List list;
    313         try {
    314             session = openSession();
    315             list = session.queryForList(id, parameterObject);
    316             commit();
    317         } catch (Exception e) {
    318             throw new DAOException("Failed to queryForList - id [" + id
    319                     + "], parameterObject [" + parameterObject + "].  Cause: "
    320                     + e, e);
    321         } finally {
    322             session = null;
    323             closeSession();
    324         }
    325         return list;
    326     }
    327
    328     /***
    329      * Executes a mapped SQL SELECT statement that returns data to populate a
    330      * number of result objects within a certain range.
    331      *
    332      * @param id
    333      * @param parameterObject
    334      * @param skip
    335      * @param max
    336      * @return A List of result objects.
    337      * @throws SQLException
    338      * @throws DAOException
    339      */
    340     public List queryForList(String id, Object parameterObject, int skip,
    341             int max) throws SQLException, DAOException {
    342         SqlMapSession session;
    343         List list;
    344         try {
    345             session = openSession();
    346             list = session.queryForList(id, parameterObject, skip, max);
    347             commit();
    348         } catch (Exception e) {
    349             throw new DAOException("Failed to queryForList - id [" + id
    350                     + "], parameterObject [" + parameterObject + "], skip ["
    351                     + skip + "], max [" + max + "].  Cause: " + e, e);
    352         } finally {
    353             session = null;
    354             closeSession();
    355         }
    356         return list;
    357     }
    358
    359     /***
    360      * Executes a mapped SQL SELECT statement that returns a number of result
    361      * objects that will be handled one at a time by a RowHandler.
    362      *
    363      * @param id
    364      * @param parameterObject
    365      * @param rowHandler
    366      * @throws SQLException
    367      * @throws DAOException
    368      */
    369     public void queryWithRowHandler(String id, Object parameterObject,
    370             RowHandler rowHandler) throws SQLException, DAOException {
    371         SqlMapSession session;
    372         List list;
    373         try {
    374             session = openSession();
    375             session.queryWithRowHandler(id, parameterObject, rowHandler);
    376             commit();
    377         } catch (Exception e) {
    378             throw new DAOException("Failed to queryForList - id [" + id
    379                     + "], parameterObject [" + parameterObject
    380                     + "], rowHandler [ " + rowHandler + "].  Cause: " + e, e);
    381         } finally {
    382             session = null;
    383             closeSession();
    384         }
    385     }
    386
    387     /***
    388      * Executes a mapped SQL SELECT statement that returns data to populate a
    389      * number of result objects a page at a time.
    390      *
    391      * @param id
    392      * @param parameterObject
    393      * @param pageSize
    394      * @return A PaginatedList of result objects.
    395      * @throws SQLException
    396      * @throws DAOException
    397      */
    398     public PaginatedList queryForPaginatedList(String id,
    399             Object parameterObject, int pageSize) throws SQLException,
    400             DAOException {
    401         SqlMapSession session;
    402         PaginatedList list;
    403         try {
    404             session = openSession();
    405             list = session.queryForPaginatedList(id, parameterObject, pageSize);
    406             commit();
    407         } catch (Exception e) {
    408             throw new DAOException("Failed to queryForPaginatedList - id ["
    409                     + id + "], parameterObject [" + parameterObject
    410                     + "], pageSize [" + pageSize + "].  Cause: " + e, e);
    411         } finally {
    412             session = null;
    413             closeSession();
    414         }
    415         return list;
    416     }
    417
    418     /***
    419      * Executes a mapped SQL SELECT statement that returns data to populate a
    420      * number of result objects that will be keyed into a Map.
    421      *
    422      * @param id
    423      * @param parameterObject
    424      * @param keyProp
    425      * @return A Map keyed by keyProp with values being the result object
    426      *         instance.
    427      * @throws SQLException
    428      * @throws DAOException
    429      */
    430     public Map queryForMap(String id, Object parameterObject, String keyProp)
    431             throws SQLException, DAOException {
    432         SqlMapSession session;
    433         Map map;
    434         try {
    435             session = openSession();
    436             map = session.queryForMap(id, parameterObject, keyProp);
    437             commit();
    438         } catch (Exception e) {
    439             throw new DAOException("Failed to queryForMap - id [" + id
    440                     + "], parameterObject [" + parameterObject + "], keyProp ["
    441                     + keyProp + "].  Cause: " + e, e);
    442         } finally {
    443             session = null;
    444             closeSession();
    445         }
    446         return map;
    447     }
    448
    449     /***
    450      * Executes a mapped SQL SELECT statement that returns data to populate a
    451      * number of result objects from which one property will be keyed into a
    452      * Map.
    453      *
    454      * @param id
    455      * @param parameterObject
    456      * @param keyProp
    457      * @param valueProp
    458      * @return A Map keyed by keyProp with values of valueProp.
    459      * @throws SQLException
    460      * @throws DAOException
    461      */
    462     public Map queryForMap(String id, Object parameterObject, String keyProp,
    463             String valueProp) throws SQLException, DAOException {
    464         SqlMapSession session;
    465         Map map;
    466         try {
    467             session = openSession();
    468             map = session.queryForMap(id, parameterObject, keyProp, valueProp);
    469             commit();
    470         } catch (Exception e) {
    471             throw new DAOException("Failed to queryForMap - id [" + id
    472                     + "], parameterObject [" + parameterObject + "], keyProp ["
    473                     + keyProp + "], valueProp [" + valueProp + "].  Cause: "
    474                     + e, e);
    475         } finally {
    476             session = null;
    477             closeSession();
    478         }
    479         return map;
    480     }
    481
    482 }