US7984082B2 - Provision of connections for program components - Google Patents
Provision of connections for program components Download PDFInfo
- Publication number
- US7984082B2 US7984082B2 US11/437,532 US43753206A US7984082B2 US 7984082 B2 US7984082 B2 US 7984082B2 US 43753206 A US43753206 A US 43753206A US 7984082 B2 US7984082 B2 US 7984082B2
- Authority
- US
- United States
- Prior art keywords
- persistence
- connection
- transaction
- environment
- manager
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active, expires
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/466—Transaction processing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/4493—Object persistence
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/541—Interprogram communication via adapters, e.g. between incompatible applications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/14—Session management
Definitions
- Embodiments of the invention generally relate to the field of computer systems and, more particularly, to a method and apparatus for provision of connections to program components.
- the program components may include enterprise JavaBeans (EJBs) that exist in a Java 2 Platform, Enterprise Edition (J2EE) environment or in a standalone operation in the Java 2 Platform, Standard Edition (J2SE).
- EJBs enterprise JavaBeans
- J2EE Java 2 Platform, Enterprise Edition
- J2SE Java 2 Platform, Standard Edition
- the persistence of such components is governed by the standards for an EJB, including the Enterprise JavaBean Specification 3.0 (referred to herein as the EJB 3.0 Specification).
- EJB 3.0 Enterprise JavaBean Specification 3.0
- a component of the core persistence engine needs to access the underlying database, it requires a connection, such as a JDBC (Java database connectivity) connection for an EJB.
- JDBC Java database connectivity
- connections are obtained and managed.
- JDBC connections are obtained and managed is different in a J2EE enterprise environment and in a J2SE standalone environment.
- the processes for connections may vary depending on the environment encountered, thereby making the task of the developer of a system more difficult because a separate process may be required for each possible environment.
- a method and apparatus for management of provision of connections for program components A method and apparatus for management of provision of connections for program components.
- a method and apparatus for provision of connections to program components In an embodiment of a method, a call is received from a persistence engine, the call requesting a connection to a database. A method is called to obtain the connection from a data source. The connection is provided to the persistence engine. The method further includes providing the connection to the persistence engine. Other embodiments are also disclosed and claimed.
- FIG. 1 is an illustration of persistence elements in an embodiment of the invention
- FIG. 2 is an illustration of an embodiment of a persistence engine for distributed transactions and container-managed EntityManagers
- FIG. 3 is an illustration of an embodiment of a persistence engine for distributed transactions and application-managed EntityManagers
- FIG. 4 is an illustration of an embodiment of a persistence engine for resource-local transactions and application-managed EntityManagers
- FIG. 5 illustrates a persistence context matrix in an embodiment of the invention
- FIG. 6 illustrates the interaction between the entity manager, the environment manager and the persistence context in an embodiment of the invention
- FIG. 7 illustrates an embodiment of a process for retrieving and using a connection for program components
- FIG. 8 is an illustration of a computer system in an embodiment of the invention.
- Embodiments of the invention are generally directed to a method and apparatus for provision of connections for program components.
- a “software component” or “component” is a reusable set of code or program block that can be combined with other components to form an application.
- a component may represent a software bundle of variables and related methods that is utilized in object-oriented programming.
- “Component” includes a JavaBean in Java application development.
- an “enterprise JavaBean” or “EJB” is a JavaBean component provided for the Java 2 Platform, Enterprise Edition (J2EE) environment.
- EJBs include “session beans”, which are not persistent, and “entity beans”, which represent business objects in a persistent storage mechanism. Session beans may be “stateful” or “stateless”.
- a stateful session bean is an EJB that acts as a server-side extension of the client that uses it. The stateful session bean is created by a client and will work for only that client until the client connection is dropped or the bean is explicitly removed, with the state being retained for the duration of the client-bean session. If the client removes the bean or terminates, the session ends and the state disappears.
- a stateless session bean does not maintain a conversational state for a particular client.
- the bean's instance variables may contain a state, but only for the duration of the invocation.
- the state is no longer retained.
- persistence is the quality of a program component to exist beyond an application or process.
- an entity bean may be referred to as persistent because the state of the entity bean may exist beyond the lifetime of an application or a J2EE server process.
- persistence may include container-managed persistence, where an EJB container handles all database access required by the entity bean and is responsible for saving the state of the bean, and bean-managed persistence, where the entity bean handles database access is directly responsible for saving its own state.
- a “container” is an application program or subsystem in which a component is run.
- a container represents an interface between a component, such as a JavaBean, and the low-level platform-specific functionality that supports the component.
- Containers include EJB containers, which manages the execution of EJBs for J2EE applications.
- Enterprise JavaBeans and their container run on a J2EE server.
- connection is a link between a program object and a database.
- a connection object represents a connection with a database.
- a single application may have one or more connections with a single database, or it may have connections with multiple different databases.
- a component or agent referred to herein as an environment manager, provides connections to program components in a computer environment.
- an environment manager provides a common interface to a core persistence engine for the purpose of obtaining connections for components.
- an environment manager may be used to simplify the process of product development. For example, the question of whether the connection participates in a distributed transaction or not varies in different circumstances. In an embodiment of the invention, a developer does not need to be concerned with whether the connection participates in a distributed transaction when getting a connection from the environment manager. In an embodiment of the invention, the environment manager provides the same interface in both cases.
- JavaBeans such as enterprise JavaBeans (EJBs).
- EJBs enterprise JavaBeans
- applications in and enterprise environment such as J2EE or a standalone environment such as J2SE.
- the persistence of EJB components may be governed by the EJB 3.0 specification.
- the EJB 3.0 specification provides a persistence API (application program interface) that is supported in the enterprise environment and may also be supported in a standalone environment.
- An entity manager is associated with a persistence context.
- a persistence context is a set of entity instances in which, for any persistent entity identity, there is a unique entity instance.
- the entity instances and the lifecycle of such instances are managed within a persistence context.
- an entity manager API defines the methods that are used to interact with the persistence context.
- the entity manager API is used to create and remove persistent entity instances, to find such, and to make queries regarding such entities.
- the set of entities that are managed by an entity manger instance are defined by a persistence unit.
- the persistence unit defines the set of all classes that are related or grouped by an application. Persistence is then handled by the core persistence engine.
- the core persistence engine may include the entity manager factory, the entity manager, and the persistence context.
- the core persistence engine is coupled with the persistence unit.
- an environment manager supports the operation of the core persistence engine.
- the new entity beans may be viewed as being essentially POJOs (plain old Java objects) with added annotations, and as such are not inherently persistent entities.
- An entity instance becomes persistent once it is associated with an entity manager and becomes part of a persistence context.
- the persistence context implicitly coexists with a transaction's scope. Entity relationships are also defined through annotations.
- the EJB persistence provider can be used in both J2EE (enterprise) and J2SE (standalone) environments. Both cases differ fundamentally in the management of resources like transactions and database connections.
- a separate component called an environment manager hides these differences and provides a common interface to the core persistence engine. The environment manager collaborates with the resource management system of the persistence engine to accomplish this.
- the relationship between an entity manager and the persistence context is not static, but instead depends on the configuration of the involved objects and the current transaction state.
- the configuration may include whether the entity manager is container-managed or application-managed, whether JTA (Java transaction API) transactions or resource-local transactions are used, and whether the persistence contexts are transaction-scoped or extended.
- the environment manager decouples the core persistence implementation from these dependencies by encapsulating the logic for the dynamic association between the entity manager and the persistence context.
- the entity manager instead of keeping a reference to the persistence context, the entity manager requests a persistence context object from the environment manager at the beginning of each method. The entity manager operates on this persistence context, and then returns the persistence context, after usage of the persistence context.
- transactions may be managed and controlled in various ways, which affects operations such as persistence.
- a transaction may be controlled by a transactions manager or similar entity and managed by a container.
- a transaction may be managed by the application itself.
- JTA transactions are managed by a transaction manager. These may be contrasted with resource-local transactions, which are managed by the application.
- the JTA specifies standard Java interfaces between a transaction manager and the parties involved in a distributed transaction system, such parties being the resource manager, the application server, and the transactional applications.
- the JTA API specifically allows a developer to demarcate transactions in a manner that is independent of the transaction manager implementation.
- the J2EE SDK software developer's kit
- a JTA transaction is specifically controlled by the J2EE transaction manager.
- the jta-data-source element indicates that the transactions in which the entity manager takes part are JTA transactions, meaning that transactions are managed by the container.
- a developer may use resource-local transactions, which are transactions controlled by the application itself. The choices between such transactions are based on the particular application being developed. For example, web application developers commonly use JTA transactions to avoid the need to manually manage the life cycle of the entity manager instance.
- the environment manager provides the core persistence engine with persistence contexts and JDBC connections, with both tasks requiring knowledge about the current transactional state.
- the environment manager must interoperate with the underlying transactions.
- the EJB 3.0 specification provides that persistence supports both JTA transactions and resource-local transactions, but the mechanism to integrate with transactions is different for these transactions.
- the EJB 3.0 specification separates these transaction types.
- an entity manager factory and thus all dependent objects, such as an entity manager
- different implementations of the environment manager interface may be provided for JTA transactions and resource-local transactions.
- Entity manager factory Element used to generate entity manager instances.
- the entity manager factory is configured to work with exactly one persistence unit and transaction type (JTA or resource-local).
- Entity manager The central interface to the client, used to manipulate persistent entities. It does not hold any data itself, but works on the objects managed in the persistence context.
- the entity manager does not store the reference to the persistence context, but retrieves the persistence context from the environment manager at the beginning of each method call.
- Persistence context Holds the managed entity bean instances and guarantees their uniqueness within the context. Entities within the persistence context are synchronized to the database. This synchronization requires an active transaction (either JTA or resource-local).
- Query A query to execute EJB QL (query language) statements.
- the entities returned by the query are under control of the persistence core engine, i.e. contained in the persistence context.
- the Environment manager Provides persistence contexts and JDBC connections to the core persistence engine. Abstracts from the engine's resource management and encapsulates the dependencies from the current environment.
- An JTA-aware implementation of the environment manager may reuse an existing J2EE-engine's proprietary internal contract between the EJB container or the web container, respectively for different operations, and the connector service's resource system that manages all transactional resources, such as JDBC, JMS (Java message service), and JCA (J2EE connector architecture) resources.
- the containers control any kind of resources in a uniform way using this contract.
- An integral part of this contract is the resource context.
- the resource context is a construct that can hold resources and a transaction object.
- Each EJB component has its own resource context associated. For web components, a different resource context is associated for each request.
- the EJB container replaces the resource context that is currently associated with the thread by its own resource context, and it puts the original resource context into place once the EJB call stack returns. While a JTA transaction is active, it is associated with the thread's actual resource context.
- Persistence contexts are handled as resources like JDBC connections or any other transactional resource.
- the environment manager is able to decide whether the method getPersistenceContext should return a new persistence context object or an already existing one, according to the requirements.
- another responsibility of the environment manager is to guarantee that the persistence context takes part in JTA transactions to have it synchronized with the database at commit time. In an embodiment, this is achieved by registering the persistence context as a listener to the appropriate JTA transaction events. To be able to do so, the persistence context must implement the javax.transaction.Synchronization interface. The event mechanism will then notify a registered persistence context right before and after the transaction ends by calling the persistence context's beforeCompletion and afterCompletion method, respectively. On beforeCompletion, the persistence context flushes its current state to the database, whereas on afterCompletion the persistence context may be closed if appropriate.
- an environment manager for resource-local transactions may be implemented in a straightforward manner, with a 1:1 relationship between the environment manager, the entity manager, the entity transaction, and the persistence context.
- the environment manager has access to the corresponding entity transaction object to get information about the transactional state.
- the environment manager uses this information to return on a getPersistenceContext call either a new or an already existing persistence context object, according to the requirements.
- a component of a core persistence engine When a component of a core persistence engine needs to access an underlying database, it requires a connection to such database. For example, in J2EE and J2SE environments a JDBC connection is required. However, the manner in which JDBC connections are obtained and managed is different in J2EE and J2SE environments.
- the environment manager in order to abstract from these dependencies, the environment manager provides a method to obtain a JDBC connection. In this embodiment, within the scope of either a JTA or resource-local transaction, the environment manager will return the same connection in each case. The connection is then closed at the end of the transaction.
- JDBC connections are obtained and managed is different in J2EE and J2SE environments.
- the environment manager abstracts from these dependencies, and provides a method to obtain a JDBC connection for both circumstances.
- JTA or resource-local the environment manager always returns the same connection. The connection is closed at the end of the transaction.
- the environment manager uses the data source that is configured in the persistence unit to create a JDBC connection when required. Connections created within the scope of an active transaction are closed by the transaction object when the transaction ends. Connections created outside a transaction are related with a persistence context that serves a single entity manager call only and are closed when the corresponding persistence context object is closed.
- an environment manager API may include the following methods:
- getPersistenceContext Returns the persistence context associated with the current transaction and/or entity manager instance.
- the persistence context may be either an already existing shared one, or it may be newly created as a shared or unshared one.
- closePersistenceContext Informs the environment manager that the persistence context is no longer needed. Depending on the current situation (e.g. whether the transaction is currently active, whether the persistence context is extended, or other circumstances), the environment manager will decide to physically close the persistence context or to ignore the call.
- the persistence context should be closed if there is no active transaction and if the persistence context is transaction-scoped. In all other cases, the method should be a no-op (No operation).
- releaseConnection Hands a connection that is no longer needed back to the environment manager.
- the environment manager may close the connection if appropriate, as in when an entity is transaction-scoped and is outside the transaction.
- isTransactionActive Returns true if and only if there is a transaction associated that is in an active state.
- markTransactionForRollback Marks the current transaction so that the only possible outcome of the transaction is for the transaction to be rolled back.
- rollback Triggers a rollback of the current transaction.
- joinTransaction Associates the EntityManager with the current distributed transaction. (For implementation targeted at distributed transactions only)
- getEntityManagerFactory Returns the entity manager factory with which this environment manager is associated.
- getTransaction Returns the resource-local transaction object (For implementation targeted at resource-local transactions only)
- FIG. 1 is an illustration of persistence elements in an embodiment of the invention.
- a persistence unit 110 defines a set of entities that are managed by an entity manger instance.
- the persistence unit defines the set of all classes that are related or grouped by an application.
- Persistence is then handled by a core persistence engine 105 .
- the core persistence engine varies with different embodiments, but may include an entity manager factory, an entity manager, and a persistence context.
- the core persistence engine 105 is coupled with the persistence unit 110 .
- an environment manager 115 supports the operation of the core persistence engine.
- the environment manager abstracts the different environments that may be faced by the core persistence engine 105 , thereby providing a consistent process for the operation of persistence contexts for program components.
- FIGS. 2 , 3 , and 4 illustrate the relationship between the environment manager and the components of the core persistence engine in varying embodiments of the invention.
- FIG. 2 is an illustration of an embodiment of a persistence engine for distributed transactions and application-managed entity managers.
- the EJB 3.0 specification defines the concept of persistence context propagation within the scope of a JTA transaction.
- Container-managed entity managers that have been created using the same entity manager factory share the same persistence context object if they are called within the same JTA transaction.
- FIG. 2 illustrates a core persistence engine 205 coupled with a persistence unit 210 and an environment manager 215 .
- the environment manager 215 includes certain operations 220 , including an operation to get a persistence context and to get a connection.
- the core persistence engine includes an entity manager factory 225 to generate some number of instances of entity managers 230 .
- Each entity manage may be associated with a persistence context 235 .
- Each entity manager 230 may generate one or more queries 240 regarding persistence.
- the environment manager can thus manage the persistence contexts and JDBC connections for all entity managers obtained from the particular entity manager factory.
- FIG. 3 is an illustration of an embodiment of a persistence engine for distributed transactions and application-managed entity managers.
- FIG. 3 illustrates a core persistence engine 305 coupled with a persistence unit 310 and an environment manager 315 .
- the environment manager 315 again includes certain operations 320 , including an operation to get a persistence context and to get a connection.
- the core persistence engine includes an entity manager factory 325 to generate some number of instances of entity managers 330 .
- Each entity manager may be associated with a persistence context 335 .
- Each entity manager 330 may generate one or more queries 340 regarding persistence.
- FIG. 4 is an illustration of an embodiment of a persistence engine for resource-local transactions.
- resource-local transactions different entity manager instances are completely separated from each other.
- Each entity manager uses its own entity transaction object. Different entity managers therefore can't run in the same transactional context, and thus never share persistence context objects with each other. Since there is no need to manage persistence contexts and JDBC connections globally on the level of the entity manager factory, as is true with JTA transactions, one environment manager instance may be provided per entity manager instance.
- FIG. 4 illustrates a core persistence engine 405 coupled with a persistence unit 410 and an environment manager 415 .
- the environment manager 415 includes certain operations 420 , including an operation to get a persistence context and to get a connection.
- the core persistence engine includes an entity manager factory 425 to generate some number of instances of entity managers 430 .
- Each entity manager may be associated with a persistence context 435 .
- Each entity manager 430 may generate one or more queries 440 regarding persistence, and is associated with a single entity transaction 445 .
- FIG. 5 illustrates a persistence context matrix in an embodiment of the invention.
- the environment manager provides persistence contexts and connections to the core persistence engine. This task is complex because many parameters influence the management of those objects.
- the persistence context matrix is intended to summarize the applicable degrees of freedom in an embodiment of the invention and how these degrees of freedom affect persistence contexts and connections.
- FIG. 5 illustrates entries for persistence context (PC) control 505 and persistence context scope 510 .
- the operation may be container-managed 525 or application managed 530 .
- entity managers retrieved via injection or JNDI (Java naming and directory interface) lookup are container-managed, and they are thus created and closed automatically by the container.
- Entity managers obtained from EntityManagerFactory.createEntityManager( ) are application-managed, which are closed explicitly by the application using the method EntityManager.close( ).
- the container-managed PC control 525 results in a container-managed entity manager 555 , for which there is persistence context propagation, while the application managed PC control 530 results in an application managed entity manager 560 , for which there is no persistence context propagation.
- Container-managed entity managers support persistence context propagation, which means that different entity managers that have been obtained from the same entity manager factory and that are called within the same JTA transaction share the same persistence context.
- Application-managed entity managers do not share any persistence contexts, with each entity manager using its own persistence context.
- an operation may be viewed as having transaction scope 515 or extended scope 520 .
- This property controls the lifetime of the persistence context.
- Transaction-scoped persistence contexts are created when the entity manager is called for the first time within a particular transaction and the persistence contexts are closed when the corresponding transaction ends (with commit or rollback).
- Extended persistence contexts exist beyond transaction boundaries.
- An extended persistence context is bound to a particular entity manager, the persistence context being created when the entity manager is created and it is closed when the entity manager is closed, either by the container or the application, depending on who controls the entity manager's lifecycle.
- the scope of the persistence context for container-managed entity managers is either provided by an annotation or XML tag. Application-managed entity managers always use a persistence context with extended scope.
- FIG. 5 then illustrates the transaction type, JTA transactions or resource-local transactions, that be used in each circumstance.
- container-managed entity managers 555 support JTA transactions only, case (a) 535 and case (b) 545 .
- the transaction type depends on the configuration of the entity manager factory, and thus as illustrated may be either resource-local or JTA, case (c) 550 .
- Additional degrees of freedom that are not depicted in the matrix may also exist.
- the runtime environment is relevant.
- EJBs the issue is whether EJB 3.0 persistence is used inside a J2EE application server or in a J2SE (standalone) environment.
- J2SE scenarios JTA transactions are not supported, and only resource-local transactions can be used.
- there is a transactional state in an operation this state describing whether the entity manager is called within the scope of an active transaction or rather outside a transaction.
- Case (a) 535 Outside a JTA transaction, a new persistence context is created to serve one EM method call only. Afterwards, it gets closed, i.e. its entities become detached. Inside the JTA transaction, the persistence context is shared between all participating entity managers, i.e., there is a 1:1 relationship between transaction and persistence context. Any call to one of the participating entity managers within the same JTA transaction operates on the same persistence context. The shared persistence context is created upon the first method call of an EM. Once the transaction ends by commit or rollback, the persistence context is synchronized with the database (commit only) and closed. To achieve this, the persistence context is registered upon creation as a listener to the JTA transaction manager's beforeCompletion event (for database synchronization) and afterCompletion event (for closing).
- Case (c) 545 This case is only eligible for stateful session beans.
- An extended persistence context is created upon the creation of its corresponding entity manager and destroyed when this entity manager is closed (i.e., when the stateful session bean's @Remove method is called).
- the entity manager uses the same persistence context instance throughout its entire lifecycle.
- a persistence context is associated with a transaction upon request, for example using the joinTransaction command.
- the persistence context will be associated automatically (eagerly) with the next transaction opened on the same thread; no explicit call of the EntityManager API is be needed for this.
- the persistence context is shared between all participating entity managers in the same way as in case (a) 535 .
- extended persistence contexts however, a collision of different persistence contexts within the same transaction is possible, which leads to an IllegalStateException.
- a stateful session bean with an extended persistence context cannot call another stateful session bean with a different extended persistence context in the same transaction. Due to the eager association of the persistence context with the transaction, the collision occurs immediately at the beginning of a new transaction.
- Case (c) 550 This is the same case as case (b) 545 , except for the sharing of persistence contexts. In this case, there is no persistence context propagation, so each entity manager working within the same JTA transaction uses its own persistence context object throughout its entire lifetime.
- entity manager factory There is a 1:1 relationship between entity manager factory and persistence context factory. In the JTA case, there is also a 1:1 relationship between entity manager factory and environment manager, while for the resource-local case, there is one environment manager instance per entity manager.
- FIG. 6 illustrates the interaction between the entity manager, the environment manager and the persistence context in an embodiment of the invention.
- the entity manager (EM) 610 delegates the management of the persistence contexts to the environment manager 615 .
- the entity manager 610 uses the persistence context for one method call only and calls the persistence context's close method immediately afterwards.
- a client 605 provides an operation 625 to an entity manager 610 .
- the entity manage makes a call to get the persistence context 630 to the environment manager 615 .
- the environment manager 615 makes a call to create the persistence context 635 to the persistence context factory 620 , or in the alternative reuses an existing persistence context.
- the persistence context factory 620 creates 640 the persistence context 645 , which is returned to the environment manager 615 and to the entity manager 650 .
- the entity manager 610 utilizes the persistence manager 645 for some action 650 , and then takes action to close the persistence context 655 .
- the environment manager may then call a close method 660 if the operation is transaction scoped and outside the transaction.
- FIG. 7 illustrates an embodiment of a process for retrieving and using a connection.
- a process is illustrated in which the persistence context, or any other class that needs a connection, interacts with the environment manager to retrieve and return a JDBC connection.
- the persistence context does not close the connection itself, but simply returns the connection to the environment manager, who is then responsible for closing the connection, if appropriate.
- the persistence context (PC) 705 makes a request to the environment manager 710 to get a connection 720 .
- the environment manager 710 makes a connection request 725 to the data source 715 , or the environment manager 710 reuses and existing connection.
- the connection 730 is returned and the persistence context 705 makes a request for some action (doSomething) 735 via the connection 730 .
- the persistence context 705 then makes a request to release the connection 740 to the environment manager.
- the environment manager 710 then request that the connection be closed 745 if appropriate and if outside the transaction.
- FIG. 8 is an illustration of a computer system in an embodiment of the invention. As illustrated, a computing system 800 can execute program code stored by an article of manufacture. The computing system illustrated in FIG. 8 is only one of various possible computing system architectures, and is a simplified illustration that does include many well-known elements.
- a computer system 800 includes one or more processors 805 and memory 810 coupled to a bus system 820 .
- the bus system 820 is an abstraction that represents any one or more separate physical buses, point-to-point connections, or both connected by appropriate bridges, adapters, or controllers.
- the bus system 820 may include, for example, a system bus, a Peripheral Component Interconnect (PCI) bus, a HyperTransport or industry standard architecture (ISA) bus, a small computer system interface (SCSI) bus, a universal serial bus (USB), or an Institute of Electrical and Electronics Engineers (IEEE) standard 1394 bus, sometimes referred to as “Firewire”. (“Standard for a High Performance Serial Bus” 1394-1995, IEEE, published Aug. 30, 1996, and supplements thereto)
- PCI Peripheral Component Interconnect
- ISA HyperTransport or industry standard architecture
- SCSI small computer system interface
- USB universal serial bus
- IEEE Institute of Electrical and Electronics Engineers
- the processors 805 are central processing units (CPUs) of the computer system 800 and control the overall operation of the computer system 800 .
- the processors 805 execute software stored in memory 810 .
- a processor 805 may be, or may include, one or more programmable general-purpose or special-purpose microprocessors, digital signal processors (DSPs), programmable controllers, application specific integrated circuits (ASICs), programmable logic devices (PLDs), or the like, or a combination of such devices.
- DSPs digital signal processors
- ASICs application specific integrated circuits
- PLDs programmable logic devices
- Memory 810 is or includes the main memory of the computer system 800 .
- Memory 810 represents any form of random access memory (RAM), read-only memory (ROM), flash memory, or the like, or a combination of such devices.
- RAM random access memory
- ROM read-only memory
- flash memory or the like, or a combination of such devices.
- Memory 810 stores, among other things, the operating system 815 of the computer system 800 .
- Internal mass storage devices 825 may be or may include any conventional medium for storing large volumes of instructions and data 830 in a non-volatile manner, such as one or more magnetic or optical based disks.
- the network adapter 835 provides the computer system 800 with the ability to communicate with remote devices, over a network 850 and may be, for example, an Ethernet adapter.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
Description
Claims (19)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/437,532 US7984082B2 (en) | 2006-05-18 | 2006-05-18 | Provision of connections for program components |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/437,532 US7984082B2 (en) | 2006-05-18 | 2006-05-18 | Provision of connections for program components |
Publications (2)
Publication Number | Publication Date |
---|---|
US20070271351A1 US20070271351A1 (en) | 2007-11-22 |
US7984082B2 true US7984082B2 (en) | 2011-07-19 |
Family
ID=38713223
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/437,532 Active 2027-02-04 US7984082B2 (en) | 2006-05-18 | 2006-05-18 | Provision of connections for program components |
Country Status (1)
Country | Link |
---|---|
US (1) | US7984082B2 (en) |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20130086119A1 (en) * | 2011-09-30 | 2013-04-04 | Oracle International Corporation | Systems and methods for composite persistence units |
US8954461B2 (en) | 2011-09-30 | 2015-02-10 | Oracle International Corporation | Systems and methods for object to relational mapping extensions |
US9054886B2 (en) | 2011-07-11 | 2015-06-09 | Oracle International Corporation | System and method for using a multicast group to support a flooding mechanism in a middleware machine environment |
US9542432B2 (en) | 2011-09-30 | 2017-01-10 | Oracle International Corporation | Systems and methods for multitenancy data |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8032560B2 (en) * | 2006-05-18 | 2011-10-04 | Sap Ag | Provision of persistence context to program components |
JP4445993B2 (en) * | 2007-11-27 | 2010-04-07 | 株式会社日立製作所 | Cell culture equipment |
Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20020032775A1 (en) * | 2000-08-28 | 2002-03-14 | Ramesh Venkataramaiah | System and method for transmitting and retrieving data via a distributed persistence framework |
US20030028682A1 (en) * | 2001-08-01 | 2003-02-06 | Sutherland James Bryce | System and method for object persistence life-cycle and object caching integration |
US20060031388A1 (en) * | 2004-06-03 | 2006-02-09 | Tankov Nikolai D | Connection resource system |
US20070271210A1 (en) | 2006-05-18 | 2007-11-22 | Sabine Heider | Provision of persistence context to program components |
-
2006
- 2006-05-18 US US11/437,532 patent/US7984082B2/en active Active
Patent Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20020032775A1 (en) * | 2000-08-28 | 2002-03-14 | Ramesh Venkataramaiah | System and method for transmitting and retrieving data via a distributed persistence framework |
US20030028682A1 (en) * | 2001-08-01 | 2003-02-06 | Sutherland James Bryce | System and method for object persistence life-cycle and object caching integration |
US20060031388A1 (en) * | 2004-06-03 | 2006-02-09 | Tankov Nikolai D | Connection resource system |
US20070271210A1 (en) | 2006-05-18 | 2007-11-22 | Sabine Heider | Provision of persistence context to program components |
Non-Patent Citations (25)
Cited By (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9054886B2 (en) | 2011-07-11 | 2015-06-09 | Oracle International Corporation | System and method for using a multicast group to support a flooding mechanism in a middleware machine environment |
US20130086119A1 (en) * | 2011-09-30 | 2013-04-04 | Oracle International Corporation | Systems and methods for composite persistence units |
US8954461B2 (en) | 2011-09-30 | 2015-02-10 | Oracle International Corporation | Systems and methods for object to relational mapping extensions |
US9177033B2 (en) * | 2011-09-30 | 2015-11-03 | Oracle International Corporation | Systems and methods for composite persistence units |
US9542432B2 (en) | 2011-09-30 | 2017-01-10 | Oracle International Corporation | Systems and methods for multitenancy data |
Also Published As
Publication number | Publication date |
---|---|
US20070271351A1 (en) | 2007-11-22 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
DeMichiel et al. | Enterprise javabeans tm specification, version 2.0 | |
US6442620B1 (en) | Environment extensibility and automatic services for component applications using contexts, policies and activators | |
US8661410B2 (en) | Managed enterprise software components as dynamic services | |
US5872971A (en) | Data processing systems and methods providing interoperability between data processing resources | |
US8856734B2 (en) | Type-safe dependency injection of services into enterprise components | |
US6349342B1 (en) | Methods and apparatus for managing computer processes | |
US20050251809A1 (en) | System and method for software component plug-in framework | |
US20090300093A1 (en) | Server computer | |
US20120246316A1 (en) | Automatic Registration of Enterprise Resources in a Dynamic Module System Services Registry | |
US7984082B2 (en) | Provision of connections for program components | |
US8032560B2 (en) | Provision of persistence context to program components | |
US7770159B2 (en) | Virtual types | |
US20070285993A1 (en) | Systems and methods for common instance handling of providers in a plurality of frameworks | |
US8046731B2 (en) | Timer service computer program components | |
Keith et al. | Pro JPA 2 | |
US20040015851A1 (en) | Method and system for maintaining data integrity for transactional resources | |
US7584454B1 (en) | Semantic-based transactional support and recovery for nested composite software services | |
US20060031388A1 (en) | Connection resource system | |
US20060010026A1 (en) | Transaction polymorphism | |
Prochazka | Advanced transactions in enterprise javabeans | |
US20050289212A1 (en) | Non-transactional resource reference | |
Cheng et al. | Interoperability with distributed objects through Java wrapper | |
Jungmann et al. | Enterprise Applications | |
Little et al. | The evolution of the arjuna transaction processing system | |
Denninger et al. | Session Beans |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: SAP AG, GERMANY Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:HEIDER, SABINE;KUEFER, MARKUS J.;TANKOV, NIKOLAI;REEL/FRAME:018146/0940;SIGNING DATES FROM 20060714 TO 20060728 Owner name: SAP AG, GERMANY Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:HEIDER, SABINE;KUEFER, MARKUS J.;TANKOV, NIKOLAI;SIGNING DATES FROM 20060714 TO 20060728;REEL/FRAME:018146/0940 |
|
FEPP | Fee payment procedure |
Free format text: PAYOR NUMBER ASSIGNED (ORIGINAL EVENT CODE: ASPN); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
AS | Assignment |
Owner name: SAP SE, GERMANY Free format text: CHANGE OF NAME;ASSIGNOR:SAP AG;REEL/FRAME:033625/0334 Effective date: 20140707 |
|
FPAY | Fee payment |
Year of fee payment: 4 |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 8TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1552); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 8 |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 12TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1553); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 12 |