SCA Java User Guide (TUSCANY) edited by Simon Laws
Page:
http://cwiki.apache.org/confluence/display/TUSCANY/SCA+Java+User+Guide
Changes:
http://cwiki.apache.org/confluence/pages/diffpagesbyversion.action?pageId=44873&originalVersion=155&revisedVersion=156
Content:
---------------------------------------------------------------------
{panel:title=Apache Tuscany SCA User
Guide|borderStyle=solid|borderColor=#C3CDA1|titleBGColor=#C3CDA1|bgColor=#ECF4D1}
* [*About Tuscany User Guide*|#Intro]
* [*Create Your First Application*|#Create Your First Application]
** Single node, Tuscany standalone environment
* [*Create a Webservices component*|#webservices]
** Webservices as reference, Tuscany standalone envrionment
* [*Create a Distributed Application*|#distributed application]
** Multiple nodes, Tuscany standalone environment
* [*Deploying as Web
Application*|http://tuscany.apache.org/sca-java-web-applications.html]
* [*Create an enterprise Store Application*|#Create A Store Enterprise
Application]
** Multi node, presentation tier, web20 binding, web app
* [*Host Environments*|#Host Environments]
* [*Using Extensions*|#using Extensions]
* [*Running Tuscany with Java2 Security Enabled*|#security]
* [*Do I need all of Tuscany?*|#Tuscany dependencies]
\\
{panel}
{note:title:Notification}
{center}This page is undergoing complete re-write to be more like a user guide
than it is today. You are welcome to help review and complete it.
{center}
{note}
h2. {anchor:Intro}{bgcolor:#C3CDA1}About Tuscany User Guide{bgcolor}
It is assumed that by now you have browsed through the [introduction to
SCA|http://cwiki.apache.org/confluence/display/TUSCANY/Quick+Guide+to+SCA]
section or are familiar with SCA. This user guide helps you learn more about
SCA through Tuscany. It starts with building a simple application and
progresses into more advanced features through references to samples that
reside in Tuscany.
Before we start, let's emphasise that it is Tuscany's goal to provide an
implementaiton that avoids imposing rules and requirements on how you write
your applications. In fact the goal is to let you write application code
without being concerned about the technology you choose or the environment in
which it will be used. You focus on your business logic and Tuscany
infrastructure will handle the rest.
h2. {anchor:Create Your First Application}{bgcolor:#C3CDA1}Create Your First
Application{bgcolor}
This simple exercise provides you with a hands-on experience for creating an
SCA calculator application. Although this is a simple application, it will
cover the following items:
* Creating SCA POJO-based components
* Composing an application
* Deploying the application
* Modifying the application to use a different binding
Give [create a calculator application|Getting Started with Tuscany ( using the
Command Line)] a try.
h2. {anchor:webservices}{bgcolor:#C3CDA1}Create a Webservices component{bgcolor}
Learn how to expose your pojo components as webservices. This will cover
* Creating SCA POJO-based component and exposing it as a webservice
Give [Building your first web services using Tuscany|Build your first Web
Services with Tuscany] a try.
h2. {anchor:distributed application}{bgcolor:#C3CDA1}Create a Distributed
Application{bgcolor}
A Tuscany application can be run in a single or multi-node environment. Here we
introduce the Tuscany node and SCA domain and explain how the calculator
example can be distributed across multiple nodes. We will cover the following:
* What is a node?
* What is the SCA domain
* How to create and application that will run across multiple nodes in a domain
Take a look at [Distributed SCA Domain]
h2. {anchor:Create an enterprise Application}{bgcolor:#C3CDA1}Create a Store
Enterprise Application{bgcolor}
Now that you have created a simple calculator application, let's move on to a
more interesting application called store. This application is developed in
Eclipse enviromment and uses more advanced features that are offered in
Tuscany. You will notice that it is as simple to create this application as it
was to create the calculator application.
[Getting Started with Tuscany using a Tuscany Distribution In Eclipse|Getting
Started with Tuscany]
This is a quick getting started guide that go trough the steps of building the
store scenario using the Tuscany SCA distribution manually installed into
Eclipse
[Getting Started with Tuscany using the Tuscany Eclipse Plugin|Getting Started
with Tuscany (using Tuscany Eclipse Plugin)]
This is a quick getting started guide that go trough the steps of building the
store scenario using the Tuscany Eclipse plugin.
h2. {anchor:Host Environments}{bgcolor:#C3CDA1}Host Environments{bgcolor}
Tusncany applications can be run in a Tuscany standalone environment or in
multitude of different host environments. You have seen examples of how to run
in standalone environments in the previous sections. Here we cover other
platforms.
h3. Tomcat
Running a Tuscany SCA Java enabled webapp in Tomcat is as simple as copying the
webapp to the Tomcat webapps directory.
h3. Geronimo
(!) TODO ... get link from Vamsi
h3. WebSphere
Please see this blog entry to learn how to do this:
[http://jsdelfino.blogspot.com/2007/10/how-to-use-apache-tuscany-with.html]
h3. WebLogic
Please see this user's blog to learn how to do this:
[http://davesowerby.blogspot.com/2008/02/using-tuscany-with-weblogic.html]
h3. Eclipse
You can develop and run your applications in Eclipse environment.
[Getting Started with Tuscany using a Tuscany Distribution In Eclipse|Getting
Started with Tuscany]
Tuscany also provides a Tuscany Eclipse plug-in to facilitate the development
of SCA applications on Tuscany in the Eclipse environment.
[Getting Started with Tuscany using the Tuscany Eclipse Plugin|Getting Started
with Tuscany (using Tuscany Eclipse Plugin)]
h2. {anchor:using extensions}{bgcolor:#C3CDA1}Using Extensions {bgcolor}
What are extensions? Well, we call these extensions: bindings, implementation
types, interface types, policies. Think of SCA Java infrastructure as
providing the framework that supports all these pluggable functionality.
Bindings provide protocol handling, implementation types provide support for
different languages and programming models, interface types allow enable you to
define interfaces in different ways for example Java, WSDL and policies enable
you to choose which type of policies you want to apply to your application. You
can pick and choose what you need based on your requirements and the
technologies that you use. For a complete list of available extensions and
their documentation please check this link.
h2. {anchor:security}{bgcolor:#C3CDA1}Running Tuscany with Java2 Security
Enabled{bgcolor}
Tuscany can be enabled to run with Java2 security on.
[Running Tuscany with Java 2 Security Enabled|Running Tuscany with Java 2
Security Enabled]
h2. {anchor:Tuscany dependencies}{bgcolor:#C3CDA1}Do I need all of
Tuscany?{bgcolor}
Tuscany SCA has a very modular architecture. Think of it as building blocks.
You pick what you need for your particular application. In 1.x, there is one
binary distribution. you can get to a smaller subset through building the
source with the appropriate modules that you need. In 2.x code line, we are
aiming to provide smaller distributions. For more information about how you can
build a smaller distribution please see this
[link|http://cwiki.apache.org/confluence/display/TUSCANY/Build+Your+Own+Tuscany+Distribution]
---------------------------------------------------------------------
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
