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

Quick Search    Search Deep

com.ibatis.common.* (31)com.ibatis.dao.* (35)com.ibatis.db.* (12)com.ibatis.sqlmap.* (160)

Package Samples:

com.ibatis.db.sqlmap
com.ibatis.db.sqlmap.upgrade
com.ibatis.db.jdbc
com.ibatis.db.dao.jdbc
com.ibatis.sqlmap.engine.type
com.ibatis.sqlmap.engine.accessplan
com.ibatis.sqlmap.engine.builder.xml
com.ibatis.sqlmap.engine.cache.fifo
com.ibatis.sqlmap.engine.cache.lru
com.ibatis.sqlmap.engine.cache.memory
com.ibatis.sqlmap.engine.cache.oscache
com.ibatis.sqlmap.engine.cache
com.ibatis.sqlmap.engine.datasource
com.ibatis.sqlmap.engine.exchange
com.ibatis.sqlmap.engine.execution
com.ibatis.sqlmap.engine.impl
com.ibatis.sqlmap.engine.mapping.parameter
com.ibatis.sqlmap.engine.mapping.result.loader
com.ibatis.sqlmap.engine.mapping.result
com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements

Classes:

SqlMapClient: A thread safe client for working with your SQL Maps (Start Here). This interface inherits transaction control and execution methods from the SqlMapTransactionManager and SqlMapExecutor interfaces. The SqlMapClient is the central class for working with SQL Maps. This class will allow you to run mapped statements (select, insert, update, delete etc.), and also demarcate transactions and work with batches. Once you have an SqlMapClient instance, everything you need to work with SQL Maps is easily available. The SqlMapClient can either be worked with directly as a multi-threaded client (internal session ...
DaoManager: This interface describes the DaoManager interface. It provides access to all DAOs it manages and also allows transactions to be committed and ended (possibly rolled back). DAO instances returned from the DAO Manager are proxied such that transactions can be automatically started, committed and ended (or rolled back). This is a similar semantic to the JDBC autocommit, but much more powerful. Alternatively, tranasctions can be controlled programmatically, allowing you to demarcate wider scope transactions as needed. Either way, transactions will only be started for those contexts that require them. ...
TypeHandlerCallback: A simple interface for implementing custom type handlers. Using this interface, you can implement a type handler that will perform customized processing before parameters are set on a PreparedStatement and after values are retrieved from a ResultSet. Using a custom type handler you can extend the framework to handle types that are not supported, or handle supported types in a different way. For example, you might use a custom type handler to implement proprietary BLOB support (e.g. Oracle), or you might use it to handle booleans using "Y" and "N" instead of the more typical 0/1. EXAMPLE Here's ...
SqlMapClientBuilder: Builds SqlMapClient instances from a supplied resource (e.g. XML configuration file) The SqlMapClientBuilder class is responsible for parsing configuration documents and building the SqlMapClient instance. Its current implementation works with XML configuration files (e.g. sql-map-config.xml). Example: Reader reader = Resources.getResourceAsReader("properties/sql-map-config.xml"); SqlMapClient client = SqlMapClientBuilder.buildSqlMapClient (reader); Examples of the XML document structure used by SqlMapClientBuilder can be found at the links below. Note: They might look big, but they're mostly comments! ...
ResultGetter: Allows values to be retrieved from the underlying result set. TypeHandlerCallback implementations use this interface to get values that they can subsequently manipulate before having them returned. Each of these methods has a corresponding method on the ResultSet (or CallableStatement) class, the only difference being that there is no need to specify the column name or index with these methods. NOTE: There is no need to implement this. The implementation will be passed into the TypeHandlerCallback automatically.
ParameterSetter: Allows parameters to be set on the underlying prepared statement. TypeHandlerCallback implementations use this interface to process values before they are set on the prepared statement. Each of these methods has a corresponding method on the PreparedStatement class, the only difference being that there is no need to specify the parameter index with these methods. NOTE: There is no need to implement this. The implementation will be passed into the TypeHandlerCallback automatically.
Dao: The interface that identifies and describes Data Access Objects. No methods are declared by this interface. However, if you provide a constructor with a single parameter of type DaoManager, that constructor will be used to instantiate the Dao such and the managing DaoManager instance will be passed in as a parameter. The DaoManager instance will allow you to easily access transactions and other DAOs.
SimpleDataSource: This is a simple, synchronous, thread-safe database connection pool. REQUIRED PROPERTIES ------------------- JDBC.Driver JDBC.ConnectionURL JDBC.Username JDBC.Password Pool.MaximumActiveConnections Pool.MaximumIdleConnections Pool.MaximumCheckoutTime Pool.TimeToWait Pool.PingQuery Pool.PingEnabled Pool.PingConnectionsOlderThan Pool.PingConnectionsNotUsedFor Pool.QuietMode
RowHandler: Event handler for row by row processing. The RowHandler interface is used by the SqlMapSession.queryWithRowHandler() method. Generally a RowHandler implementation will perform some row-by-row processing logic in cases where there are too many rows to efficiently load into memory. Example: sqlMap.queryWithRowHandler ("findAllEmployees", null, new MyRowHandler()));
SqlMapException: Thrown to indicate a problem with SQL Map configuration or state. Generally if an SqlMapException is thrown, something is critically wronge and cannot be corrected until a change to the configuration or the environment is made. Note: Generally this wouldn't be used to indicate that an SQL execution error occurred (that's what SQLException is for).
DaoTransaction: This interface marks a class as being a DaoTransaction. Some examples of DAO Transaction implementations would be JDBC, JTA, SQL Map and Hibernate. No methods are declared by this interface, but DAO templates are provided to simplify accessing implementation specific transaction artifacts such as JDBC connections etc.
ComplexBeanProbe: StaticBeanProbe provides methods that allow simple, reflective access to JavaBeans style properties. Methods are provided for all simple types as well as object types. Examples: StaticBeanProbe.setObject(object, propertyName, value); Object value = StaticBeanProbe.getObject(object, propertyName);
GenericProbe: StaticBeanProbe provides methods that allow simple, reflective access to JavaBeans style properties. Methods are provided for all simple types as well as object types. Examples: StaticBeanProbe.setObject(object, propertyName, value); Object value = StaticBeanProbe.getObject(object, propertyName);
NodeletParser: The NodeletParser is a callback based parser similar to SAX. The big difference is that rather than having a single callback for all nodes, the NodeletParser has a number of callbacks mapped to various nodes. The callback is called a Nodelet and it is registered with the NodeletParser against a specific XPath.
JdbcDaoTemplate: A DaoTemplate for JDBC implementations that provides a convenient method to access the JDBC Connection. Use this template for both JDBC and JTA transaction managers. It can also be used for any transaction manager that supports normal JDBC connections, including iBATIS SQL Maps and Hibernate.
OjbBrokerDaoTemplate: A DaoTemplate for OJB broker implementations that provides a convenient method to access the broker. This is the base class for OJB DAOs and provides the CRUD pattern necessary methods plus an additional method to retrieve all instances of a given class.
DocTypeReader: This class strips the doctype from an XML stream because java.xml.transform can't disable validation and/or loading of the DTD in a standard way, which causes problems for those running without a network. Line terminators are converted to a \n
SqlMapDaoTemplate: A DaoTemplate for SQL Map implementations that provides a convenient method to access the SqlMapExecutor. This class also provides SqlMapExecutor method wrappers that conveniently wrap SQLExceptions with DAO Exceptions.
DaoManagerBuilder: Builds a DaoManager given a Reader (dao.xml) and optionally a set of properties. The following is an example of a dao.xml file. The DAO Configuration file (dao.xml)
ToplinkDaoTransaction: The ToplinkDaoTransaction class represents an abstract DaoTransaction implemented using Toplink. Toplink provides transaction management methods to commit and rollback transactions.
SqlMapSession: A single threaded session for working with your SQL Maps. This interface inherits transaction control and execution methods from the SqlMapTransactionManager and SqlMapExecutor interfaces.
JtaDaoTemplate: DEPRECATED This is now exactly the same as the JdbcDaoTemplate, and therefore has beend deprecated. There is no behavioural difference between the two.
ClassInfo: This class represents a cached set of class definition information that allows for easy mapping between property names and getter/setter methods.

Home | Contact Us | Privacy Policy | Terms of Service