tuscany-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From conflue...@apache.org
Subject [CONF] Apache Tuscany: SCA Java implementation.jpa (page edited)
Date Mon, 02 Feb 2009 21:28:00 GMT
SCA Java implementation.jpa (TUSCANY) edited by Luciano Resende
      Page: http://cwiki.apache.org/confluence/display/TUSCANY/SCA+Java+implementation.jpa
   Changes: http://cwiki.apache.org/confluence/pages/diffpagesbyversion.action?pageId=109001&originalVersion=1&revisedVersion=2






Content:
---------------------------------------------------------------------


{info:title=Disclaimer}
   Work in progress, or should I say : Ideas in progress
{info} 

h1.Injection of JPA Entity Manager Factory/Entity Manager

 The injection of JPA Entity Manager Factory/Entity Manager would allow sharing of EMFs across
multiple components, this would be useful in scenarios where you have conversation. In this
case, the runtime would be responsible for making sure the EM would be created and closed
transparently for the application developer based on the conversation.

h1. JPA Data Services

In this case, we would be extending the SCA programming model to expose services that interact
with a persistent layer in a declarative fashion hiding the implementation details from the
service developer.It's all about simplicity, allowing a service to be defined without explicitly
coding the persistence layer. This would be a new Tuscany Component Type named Implementaiton.JPA.
A developer would provide the business objects that would by JPA to do the OR mapping, and
a business interface that would be introspect by Tuscany to properly make the JPA calls to
the persistence layer to retrieve the information. Information on how to connect to the data
source would be done in the composite, and we could provide some annotations to read

h4. Business Object

 The business object can be defined as per JPA programming model. You can define it as a JPA
Entity and make use of JPA annotations, or use the ORM.xml as well.
{code}
@Entity
public class Customer {

    @Id    protected int id;
    @Basic protected String name;
    @Basic protected String phone;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}
{code}

h4. Business Interface

 The Business interface would define the access to the JPA entities, and we would introduce
Java Annotations to bind a specific method to a JPA query.
{code}
import org.osoa.sca.annotations.Remotable;

@Remotable
public interface CustomerService {

    Customer[] getCustomers();

    void setCustomer(Customer customer);

    @Query(SELECT c FROM customer c WHERE c.name = '" + name + "'")
    Customer queryCustomerByName(String name);

}
{code}

 We would use some Convention over Configuration to bind the interfaces methods to proper
database activities :

| Method | Correspondent db operation |
| createXXX | Insert a new entity on the db. A collection of new entities should also be supported
|
| getXXX | Read a given entity from the db \\  A method signature with no parameters read
a collection. |
| setXXX | Update a previously existent entity on the db. |
| deleteXXX | Remove a previously existent entity on the db. |
| queryXXX | Execute a query on the db. \\  We would introduce a Java Annotation to bind a
given query to the method invocation |

 Note that introspection will be required by the runtime to properly identify the operation
type being requested. Based on this introspection, the runtime will also be responsible for
any necessary conversion to the proper collection being expected as a result.

h4. Composite

{code}
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
     xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0"
     targetNamespace="http://sample/implementation.jpa"
     name="customer">

	<component name="CustomerServiceComponent">
		<tuscany:implementation.jpa>
			<tuscany:persistence-unit name="customer">
				<tuscany:class>assets.Customer</tuscany:class>
			</tuscany:persistence-unit>

                <tuscany:connectionInfo>
		      <tuscany:connectionProperties
			   driverClass="org.apache.derby.jdbc.EmbeddedDriver"
			   databaseURL="jdbc:derby:target/test-classes/customer; create = true"
			   loginTimeout="600000"/>
	        </tuscany:connectionInfo>
		</tuscany:implementation.jpa>
	</component>

</composite>
{code}


h1. Benefits

* Simplify the programming model for accessing data, hiding some of the API details required
for this kind of components
* Allow exposing data services trough multiple SCA Bindings (e.g ws, json-rpc, feeds, etc)


---------------------------------------------------------------------
CONFLUENCE INFORMATION
This message is automatically generated by Confluence

Unsubscribe or edit your notifications preferences
   http://cwiki.apache.org/confluence/users/viewnotifications.action

If you think it was sent incorrectly contact one of the administrators
   http://cwiki.apache.org/confluence/administrators.action

If you want more information on Confluence, or have a bug to report see
   http://www.atlassian.com/software/confluence



Mime
View raw message