About Terracotta Documentation
This documentation is about Terracotta DSO, an advanced distributed-computing technology aimed at meeting special clustering requirements.
Terracotta products without the overhead and complexity of DSO meet the needs of almost all use cases and clustering requirements. To learn how to migrate from Terracotta DSO to standard Terracotta products, see Migrating From Terracotta DSO. To find documentation on non-DSO (standard) Terracotta products, see Terracotta Documentation. Terracotta release information, such as release notes and platform compatibility, is found in Product Information.
- How DSO Clustering Works
- Platform Concepts
- Hello Clustered World
- Setup and Configuration
- Planning for a Clustered App
- Configuring Terracotta DSO
- Configuration Reference
- Using Annotations
- Cluster Events
- Data Locality Methods
- Distributed Cache
- Clustered Async Data Processing
- Tool Guides
- Developer Console
- Operations Center
- tim-get (TIM Management Tool)
- Platform Statistics Recorder
- Eclipse Plugin
- Sessions Configurator
- Clustering Spring Webapp with Sessions Configurator
- Testing, Tuning, and Deployment
- Top 5 Tuning Tips
- Testing a Clustered App
- Tuning a Clustered App
- Deployment Guide
- Operations Guide
- FAQs and Troubleshooting
- General FAQ
- DSO Technical FAQ
- Troubleshooting Guide
- Non-portable Classes
- Migrating From DSO
- Concept and Architecture Guide
- Examinator Reference Application
- Clustered Data Structures Guide
- Integrating Terracotta DSO
- Clustering Spring Framework
- Integration Modules Manual
- AspectWerkz Pattern Language
Publish Date: November, 2011
Terracotta configuration can normally be implemented by identifying classes in your application that need to be instrumented and locked using the appropriate XML in your
Annotations, however, provide a mechanism for developers to mark class instrumentation, root configuration, transient fields, and locking directly in your Java class files.
The advantages to using Annotations are that the Terracotta definitions for your classes will stay with your code, thus improving the readability of your application (all information about a class, including it's Terracotta nature, is encapsulated in the class file) and the ability to refactor (refactoring classes with Annotations does not require changing the
tc-config.xml file accordingly).
To use annotations, you will need the annotations TIM. This can be retrieved from the [Terracotta Forge]:
- tim-annotations: tim-annotations
You can install this TIM into your Terracotta kit using the [TIM Update Center] with a simple command, e.g.:
Of course, your versions may differ, the versions listed above are for a pre-release version of Terracotta 2.7.
tim-annotations, you must add the TIM to your
tc-config.xml file. Again, the TIM Update Center can help us with this task:
Configuration section lists the appropriate configuration required to configure Terracotta to use this TIM. Add it to the
clients section of your
After you have installed and configured
tim-annotations you are ready to use your annotations.
TIM-Annotations defines Java annotations, which means your application must include TIM-Annotations as a normal Java library. If you are using Maven, this is done simply by adding the appropriate maven configuration to your
pom.xml file, e.g.:
and (it wouldn't be Maven if it didn't require tons of XML would it?) you'll have to configure the appropriate repository:
If you have Eclipse, or Idea, or just plain old Vi, you will need to configure the dependency like any other Java library.
There are currently 8 total annotations, each corresponds to a configuration element in the
tc-config.xml file. They are:
Use this annotation to mark a class instrumented.
Use this annotation to honor transient fields in the instrumented class.
Use this annotation to mark a field as a root.
Use the AutolockXXX annotations to autolock methods.
Use the DMI annotation to mark a method for DMI.