Java Doc for HibernateTransactionManager.java in  » J2EE » spring-framework-2.5 » org » springframework » orm » hibernate3 » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » J2EE » spring framework 2.5 » org.springframework.orm.hibernate3 
Source Cross Reference  Class Diagram Java Document (Java Doc) 


java.lang.Object
   org.springframework.transaction.support.AbstractPlatformTransactionManager
      org.springframework.orm.hibernate3.HibernateTransactionManager

HibernateTransactionManager
public class HibernateTransactionManager extends AbstractPlatformTransactionManager implements ResourceTransactionManager,BeanFactoryAware,InitializingBean(Code)
org.springframework.transaction.PlatformTransactionManager implementation for a single Hibernate org.hibernate.SessionFactory . Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread-bound Session per factory. SessionFactoryUtils and HibernateTemplate are aware of thread-bound Sessions and participate in such transactions automatically. Using either of those or going through SessionFactory.getCurrentSession() is required for Hibernate access code that needs to support this transaction handling mechanism.

Supports custom isolation levels, and timeouts that get applied as Hibernate transaction timeouts.

This transaction manager is appropriate for applications that use a single Hibernate SessionFactory for transactional data access, but it also supports direct DataSource access within a transaction (i.e. plain JDBC code working with the same DataSource). This allows for mixing services which access Hibernate and services which use plain JDBC (without being aware of Hibernate)! Application code needs to stick to the same simple Connection lookup pattern as with org.springframework.jdbc.datasource.DataSourceTransactionManager (i.e. org.springframework.jdbc.datasource.DataSourceUtils.getConnection or going through a org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy ).

Note: To be able to register a DataSource's Connection for plain JDBC code, this instance needs to be aware of the DataSource ( HibernateTransactionManager.setDataSource ). The given DataSource should obviously match the one used by the given SessionFactory. To achieve this, configure both to the same JNDI DataSource, or preferably create the SessionFactory with LocalSessionFactoryBean and a local DataSource (which will be autodetected by this transaction manager).

JTA (usually through org.springframework.transaction.jta.JtaTransactionManager ) is necessary for accessing multiple transactional resources within the same transaction. The DataSource that Hibernate uses needs to be JTA-enabled in such a scenario (see container setup). Normally, JTA setup for Hibernate is somewhat container-specific due to the JTA TransactionManager lookup, required for proper transactional handling of the SessionFactory-level read-write cache.

Fortunately, there is an easier way with Spring: SessionFactoryUtils (and thus HibernateTemplate ) registers synchronizations with Spring's org.springframework.transaction.support.TransactionSynchronizationManager (as used by org.springframework.transaction.jta.JtaTransactionManager ), for proper after-completion callbacks. Therefore, as long as Spring's JtaTransactionManager drives the JTA transactions, Hibernate does not require any special configuration for proper JTA participation. Note that there are special restrictions with EJB CMT and restrictive JTA subsystems: See org.springframework.transaction.jta.JtaTransactionManager 's javadoc for details.

On JDBC 3.0, this transaction manager supports nested transactions via JDBC 3.0 Savepoints. The HibernateTransactionManager.setNestedTransactionAllowed "nestedTransactionAllowed"} flag defaults to "false", though, as nested transactions will just apply to the JDBC Connection, not to the Hibernate Session and its cached objects. You can manually set the flag to "true" if you want to use nested transactions for JDBC access code which participates in Hibernate transactions (provided that your JDBC driver supports Savepoints). Note that Hibernate itself does not support nested transactions! Hence, do not expect Hibernate access code to semantically participate in a nested transaction.

Requires Hibernate 3.1 or later, as of Spring 2.5.
author:
   Juergen Hoeller
since:
   1.2
See Also:   HibernateTransactionManager.setSessionFactory
See Also:   HibernateTransactionManager.setDataSource
See Also:   LocalSessionFactoryBean
See Also:   SessionFactoryUtils.getSession
See Also:   SessionFactoryUtils.applyTransactionTimeout
See Also:   SessionFactoryUtils.releaseSession
See Also:   HibernateTemplate
See Also:   org.hibernate.SessionFactory.getCurrentSession
See Also:   org.springframework.jdbc.datasource.DataSourceUtils.getConnection
See Also:   org.springframework.jdbc.datasource.DataSourceUtils.applyTransactionTimeout
See Also:   org.springframework.jdbc.datasource.DataSourceUtils.releaseConnection
See Also:   org.springframework.jdbc.core.JdbcTemplate
See Also:   org.springframework.jdbc.datasource.DataSourceTransactionManager
See Also:   org.springframework.transaction.jta.JtaTransactionManager




Constructor Summary
public  HibernateTransactionManager()
     Create a new HibernateTransactionManager instance.
public  HibernateTransactionManager(SessionFactory sessionFactory)
     Create a new HibernateTransactionManager instance.

Method Summary
public  voidafterPropertiesSet()
    
protected  DataAccessExceptionconvertHibernateAccessException(HibernateException ex)
     Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.
protected  DataAccessExceptionconvertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)
     Convert the given Hibernate JDBCException to an appropriate exception from the org.springframework.dao hierarchy, using the given SQLExceptionTranslator.
protected  voiddoBegin(Object transaction, TransactionDefinition definition)
    
protected  voiddoCleanupAfterCompletion(Object transaction)
    
protected  voiddoCommit(DefaultTransactionStatus status)
    
protected  ObjectdoGetTransaction()
    
protected  voiddoResume(Object transaction, Object suspendedResources)
    
protected  voiddoRollback(DefaultTransactionStatus status)
    
protected  voiddoSetRollbackOnly(DefaultTransactionStatus status)
    
protected  ObjectdoSuspend(Object transaction)
    
public  DataSourcegetDataSource()
     Return the JDBC DataSource that this instance manages transactions for.
protected synchronized  SQLExceptionTranslatorgetDefaultJdbcExceptionTranslator()
     Obtain a default SQLExceptionTranslator, lazily creating it if necessary.
public  InterceptorgetEntityInterceptor()
     Return the current Hibernate entity interceptor, or null if none.
public  SQLExceptionTranslatorgetJdbcExceptionTranslator()
     Return the JDBC exception translator for this transaction manager, if any.
public  ObjectgetResourceFactory()
    
public  SessionFactorygetSessionFactory()
     Return the SessionFactory that this instance should manage transactions for.
protected  booleanisExistingTransaction(Object transaction)
    
protected  booleanisSameConnectionForEntireSession(Session session)
     Return whether the given Hibernate Session will always hold the same JDBC Connection.
public  voidsetAutodetectDataSource(boolean autodetectDataSource)
     Set whether to autodetect a JDBC DataSource used by the Hibernate SessionFactory, if set via LocalSessionFactoryBean's setDataSource.
public  voidsetBeanFactory(BeanFactory beanFactory)
     The bean factory just needs to be known for resolving entity interceptor bean names.
public  voidsetDataSource(DataSource dataSource)
     Set the JDBC DataSource that this instance should manage transactions for. The DataSource should match the one used by the Hibernate SessionFactory: for example, you could specify the same JNDI DataSource for both.

If the SessionFactory was configured with LocalDataSourceConnectionProvider, i.e.

public  voidsetEntityInterceptor(Interceptor entityInterceptor)
     Set a Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database. Will get applied to any new Session created by this transaction manager.

Such an interceptor can either be set at the SessionFactory level, i.e.

public  voidsetEntityInterceptorBeanName(String entityInterceptorBeanName)
     Set the bean name of a Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database. Will get applied to any new Session created by this transaction manager.

Requires the bean factory to be known, to be able to resolve the bean name to an interceptor instance on session creation.

public  voidsetJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)
     Set the JDBC exception translator for this transaction manager.
public  voidsetPrepareConnection(boolean prepareConnection)
     Set whether to prepare the underlying JDBC Connection of a transactional Hibernate Session, that is, whether to apply a transaction-specific isolation level and/or the transaction's read-only flag to the underlying JDBC Connection.

Default is "true".

public  voidsetSessionFactory(SessionFactory sessionFactory)
     Set the SessionFactory that this instance should manage transactions for.


Constructor Detail
HibernateTransactionManager
public HibernateTransactionManager()(Code)
Create a new HibernateTransactionManager instance. A SessionFactory has to be set to be able to use it.
See Also:   HibernateTransactionManager.setSessionFactory



HibernateTransactionManager
public HibernateTransactionManager(SessionFactory sessionFactory)(Code)
Create a new HibernateTransactionManager instance.
Parameters:
  sessionFactory - SessionFactory to manage transactions for




Method Detail
afterPropertiesSet
public void afterPropertiesSet()(Code)



convertHibernateAccessException
protected DataAccessException convertHibernateAccessException(HibernateException ex)(Code)
Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.

Will automatically apply a specified SQLExceptionTranslator to a Hibernate JDBCException, else rely on Hibernate's default translation.
Parameters:
  ex - HibernateException that occured a corresponding DataAccessException
See Also:   SessionFactoryUtils.convertHibernateAccessException
See Also:   HibernateTransactionManager.setJdbcExceptionTranslator




convertJdbcAccessException
protected DataAccessException convertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)(Code)
Convert the given Hibernate JDBCException to an appropriate exception from the org.springframework.dao hierarchy, using the given SQLExceptionTranslator.
Parameters:
  ex - Hibernate JDBCException that occured
Parameters:
  translator - the SQLExceptionTranslator to use a corresponding DataAccessException



doBegin
protected void doBegin(Object transaction, TransactionDefinition definition)(Code)



doCleanupAfterCompletion
protected void doCleanupAfterCompletion(Object transaction)(Code)



doCommit
protected void doCommit(DefaultTransactionStatus status)(Code)



doGetTransaction
protected Object doGetTransaction()(Code)



doResume
protected void doResume(Object transaction, Object suspendedResources)(Code)



doRollback
protected void doRollback(DefaultTransactionStatus status)(Code)



doSetRollbackOnly
protected void doSetRollbackOnly(DefaultTransactionStatus status)(Code)



doSuspend
protected Object doSuspend(Object transaction)(Code)



getDataSource
public DataSource getDataSource()(Code)
Return the JDBC DataSource that this instance manages transactions for.



getDefaultJdbcExceptionTranslator
protected synchronized SQLExceptionTranslator getDefaultJdbcExceptionTranslator()(Code)
Obtain a default SQLExceptionTranslator, lazily creating it if necessary.

Creates a default org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator for the SessionFactory's underlying DataSource.




getEntityInterceptor
public Interceptor getEntityInterceptor() throws IllegalStateException, BeansException(Code)
Return the current Hibernate entity interceptor, or null if none. Resolves an entity interceptor bean name via the bean factory, if necessary.
throws:
  IllegalStateException - if bean name specified but no bean factory set
throws:
  BeansException - if bean name resolution via the bean factory failed
See Also:   HibernateTransactionManager.setEntityInterceptor
See Also:   HibernateTransactionManager.setEntityInterceptorBeanName
See Also:   HibernateTransactionManager.setBeanFactory



getJdbcExceptionTranslator
public SQLExceptionTranslator getJdbcExceptionTranslator()(Code)
Return the JDBC exception translator for this transaction manager, if any.



getResourceFactory
public Object getResourceFactory()(Code)



getSessionFactory
public SessionFactory getSessionFactory()(Code)
Return the SessionFactory that this instance should manage transactions for.



isExistingTransaction
protected boolean isExistingTransaction(Object transaction)(Code)



isSameConnectionForEntireSession
protected boolean isSameConnectionForEntireSession(Session session)(Code)
Return whether the given Hibernate Session will always hold the same JDBC Connection. This is used to check whether the transaction manager can safely prepare and clean up the JDBC Connection used for a transaction.

Default implementation checks the Session's connection release mode to be "on_close". Unfortunately, this requires casting to SessionImpl, as of Hibernate 3.1. If that cast doesn't work, we'll simply assume we're safe and return true.
Parameters:
  session - the Hibernate Session to check
See Also:   org.hibernate.impl.SessionImpl.getConnectionReleaseMode
See Also:   org.hibernate.ConnectionReleaseMode.ON_CLOSE




setAutodetectDataSource
public void setAutodetectDataSource(boolean autodetectDataSource)(Code)
Set whether to autodetect a JDBC DataSource used by the Hibernate SessionFactory, if set via LocalSessionFactoryBean's setDataSource. Default is "true".

Can be turned off to deliberately ignore an available DataSource, in order to not expose Hibernate transactions as JDBC transactions for that DataSource.
See Also:   HibernateTransactionManager.setDataSource
See Also:   LocalSessionFactoryBean.setDataSource




setBeanFactory
public void setBeanFactory(BeanFactory beanFactory)(Code)
The bean factory just needs to be known for resolving entity interceptor bean names. It does not need to be set for any other mode of operation.
See Also:   HibernateTransactionManager.setEntityInterceptorBeanName



setDataSource
public void setDataSource(DataSource dataSource)(Code)
Set the JDBC DataSource that this instance should manage transactions for. The DataSource should match the one used by the Hibernate SessionFactory: for example, you could specify the same JNDI DataSource for both.

If the SessionFactory was configured with LocalDataSourceConnectionProvider, i.e. by Spring's LocalSessionFactoryBean with a specified "dataSource", the DataSource will be auto-detected: You can still explictly specify the DataSource, but you don't need to in this case.

A transactional JDBC Connection for this DataSource will be provided to application code accessing this DataSource directly via DataSourceUtils or JdbcTemplate. The Connection will be taken from the Hibernate Session.

The DataSource specified here should be the target DataSource to manage transactions for, not a TransactionAwareDataSourceProxy. Only data access code may work with TransactionAwareDataSourceProxy, while the transaction manager needs to work on the underlying target DataSource. If there's nevertheless a TransactionAwareDataSourceProxy passed in, it will be unwrapped to extract its target DataSource.
See Also:   HibernateTransactionManager.setAutodetectDataSource
See Also:   LocalDataSourceConnectionProvider
See Also:   LocalSessionFactoryBean.setDataSource
See Also:   org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy
See Also:   org.springframework.jdbc.datasource.DataSourceUtils
See Also:   org.springframework.jdbc.core.JdbcTemplate




setEntityInterceptor
public void setEntityInterceptor(Interceptor entityInterceptor)(Code)
Set a Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database. Will get applied to any new Session created by this transaction manager.

Such an interceptor can either be set at the SessionFactory level, i.e. on LocalSessionFactoryBean, or at the Session level, i.e. on HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager. It's preferable to set it on LocalSessionFactoryBean or HibernateTransactionManager to avoid repeated configuration and guarantee consistent behavior in transactions.
See Also:   LocalSessionFactoryBean.setEntityInterceptor
See Also:   HibernateTemplate.setEntityInterceptor
See Also:   HibernateInterceptor.setEntityInterceptor




setEntityInterceptorBeanName
public void setEntityInterceptorBeanName(String entityInterceptorBeanName)(Code)
Set the bean name of a Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database. Will get applied to any new Session created by this transaction manager.

Requires the bean factory to be known, to be able to resolve the bean name to an interceptor instance on session creation. Typically used for prototype interceptors, i.e. a new interceptor instance per session.

Can also be used for shared interceptor instances, but it is recommended to set the interceptor reference directly in such a scenario.
Parameters:
  entityInterceptorBeanName - the name of the entity interceptor inthe bean factory
See Also:   HibernateTransactionManager.setBeanFactory
See Also:   HibernateTransactionManager.setEntityInterceptor




setJdbcExceptionTranslator
public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)(Code)
Set the JDBC exception translator for this transaction manager.

Applied to any SQLException root cause of a Hibernate JDBCException that is thrown on flush, overriding Hibernate's default SQLException translation (which is based on Hibernate's Dialect for a specific target database).
Parameters:
  jdbcExceptionTranslator - the exception translator
See Also:   java.sql.SQLException
See Also:   org.hibernate.JDBCException
See Also:   org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator
See Also:   org.springframework.jdbc.support.SQLStateSQLExceptionTranslator




setPrepareConnection
public void setPrepareConnection(boolean prepareConnection)(Code)
Set whether to prepare the underlying JDBC Connection of a transactional Hibernate Session, that is, whether to apply a transaction-specific isolation level and/or the transaction's read-only flag to the underlying JDBC Connection.

Default is "true". If you turn this flag off, the transaction manager will not support per-transaction isolation levels anymore. It will not call Connection.setReadOnly(true) for read-only transactions anymore either. If this flag is turned off, no cleanup of a JDBC Connection is required after a transaction, since no Connection settings will get modified.

It is recommended to turn this flag off if running against Hibernate 3.1 and a connection pool that does not reset connection settings (for example, Jakarta Commons DBCP). To keep this flag turned on, you can set the "hibernate.connection.release_mode" property to "on_close" instead, or consider using a smarter connection pool (for example, C3P0).
See Also:   java.sql.Connection.setTransactionIsolation
See Also:   java.sql.Connection.setReadOnly




setSessionFactory
public void setSessionFactory(SessionFactory sessionFactory)(Code)
Set the SessionFactory that this instance should manage transactions for.



Fields inherited from org.springframework.transaction.support.AbstractPlatformTransactionManager
final public static int SYNCHRONIZATION_ALWAYS(Code)(Java Doc)
final public static int SYNCHRONIZATION_NEVER(Code)(Java Doc)
final public static int SYNCHRONIZATION_ON_ACTUAL_TRANSACTION(Code)(Java Doc)
protected transient Log logger(Code)(Java Doc)

Methods inherited from org.springframework.transaction.support.AbstractPlatformTransactionManager
final public void commit(TransactionStatus status) throws TransactionException(Code)(Java Doc)
protected int determineTimeout(TransactionDefinition definition)(Code)(Java Doc)
abstract protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException(Code)(Java Doc)
protected void doCleanupAfterCompletion(Object transaction)(Code)(Java Doc)
abstract protected void doCommit(DefaultTransactionStatus status) throws TransactionException(Code)(Java Doc)
abstract protected Object doGetTransaction() throws TransactionException(Code)(Java Doc)
protected void doResume(Object transaction, Object suspendedResources) throws TransactionException(Code)(Java Doc)
abstract protected void doRollback(DefaultTransactionStatus status) throws TransactionException(Code)(Java Doc)
protected void doSetRollbackOnly(DefaultTransactionStatus status) throws TransactionException(Code)(Java Doc)
protected Object doSuspend(Object transaction) throws TransactionException(Code)(Java Doc)
final public int getDefaultTimeout()(Code)(Java Doc)
final public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException(Code)(Java Doc)
final public int getTransactionSynchronization()(Code)(Java Doc)
final protected void invokeAfterCompletion(List synchronizations, int completionStatus)(Code)(Java Doc)
protected boolean isExistingTransaction(Object transaction) throws TransactionException(Code)(Java Doc)
final public boolean isFailEarlyOnGlobalRollbackOnly()(Code)(Java Doc)
final public boolean isGlobalRollbackOnParticipationFailure()(Code)(Java Doc)
final public boolean isNestedTransactionAllowed()(Code)(Java Doc)
final public boolean isRollbackOnCommitFailure()(Code)(Java Doc)
protected DefaultTransactionStatus newTransactionStatus(TransactionDefinition definition, Object transaction, boolean newTransaction, boolean newSynchronization, boolean debug, Object suspendedResources)(Code)(Java Doc)
protected void registerAfterCompletionWithExistingTransaction(Object transaction, List synchronizations) throws TransactionException(Code)(Java Doc)
final protected void resume(Object transaction, SuspendedResourcesHolder resourcesHolder) throws TransactionException(Code)(Java Doc)
final public void rollback(TransactionStatus status) throws TransactionException(Code)(Java Doc)
final public void setDefaultTimeout(int defaultTimeout)(Code)(Java Doc)
final public void setFailEarlyOnGlobalRollbackOnly(boolean failEarlyOnGlobalRollbackOnly)(Code)(Java Doc)
final public void setGlobalRollbackOnParticipationFailure(boolean globalRollbackOnParticipationFailure)(Code)(Java Doc)
final public void setNestedTransactionAllowed(boolean nestedTransactionAllowed)(Code)(Java Doc)
final public void setRollbackOnCommitFailure(boolean rollbackOnCommitFailure)(Code)(Java Doc)
final public void setTransactionSynchronization(int transactionSynchronization)(Code)(Java Doc)
final public void setTransactionSynchronizationName(String constantName)(Code)(Java Doc)
protected boolean shouldCommitOnGlobalRollbackOnly()(Code)(Java Doc)
final protected SuspendedResourcesHolder suspend(Object transaction) throws TransactionException(Code)(Java Doc)
final protected void triggerBeforeCommit(DefaultTransactionStatus status)(Code)(Java Doc)
final protected void triggerBeforeCompletion(DefaultTransactionStatus status)(Code)(Java Doc)
protected boolean useSavepointForNestedTransaction()(Code)(Java Doc)

Methods inherited from java.lang.Object
native protected Object clone() throws CloneNotSupportedException(Code)(Java Doc)
public boolean equals(Object obj)(Code)(Java Doc)
protected void finalize() throws Throwable(Code)(Java Doc)
final native public Class getClass()(Code)(Java Doc)
native public int hashCode()(Code)(Java Doc)
final native public void notify()(Code)(Java Doc)
final native public void notifyAll()(Code)(Java Doc)
public String toString()(Code)(Java Doc)
final native public void wait(long timeout) throws InterruptedException(Code)(Java Doc)
final public void wait(long timeout, int nanos) throws InterruptedException(Code)(Java Doc)
final public void wait() throws InterruptedException(Code)(Java Doc)

www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.