Repository: cayenne-website
Updated Branches:
  refs/heads/master d6657b829 -> beec78b61


"features" section on the home page


Project: http://git-wip-us.apache.org/repos/asf/cayenne-website/repo
Commit: http://git-wip-us.apache.org/repos/asf/cayenne-website/commit/beec78b6
Tree: http://git-wip-us.apache.org/repos/asf/cayenne-website/tree/beec78b6
Diff: http://git-wip-us.apache.org/repos/asf/cayenne-website/diff/beec78b6

Branch: refs/heads/master
Commit: beec78b615bba7110b3bc85a72acddfe442b3711
Parents: d6657b8
Author: Andrus Adamchik <[email protected]>
Authored: Fri Dec 29 14:26:49 2017 +0100
Committer: Andrus Adamchik <[email protected]>
Committed: Fri Dec 29 14:26:49 2017 +0100

----------------------------------------------------------------------
 src/main/assets/images/cayenne-modeler1.png | Bin 0 -> 179853 bytes
 src/main/assets/images/crypto-protocol.png  | Bin 0 -> 56467 bytes
 src/main/site/content/_index.md             |  53 +++++++++--------------
 3 files changed, 21 insertions(+), 32 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cayenne-website/blob/beec78b6/src/main/assets/images/cayenne-modeler1.png
----------------------------------------------------------------------
diff --git a/src/main/assets/images/cayenne-modeler1.png 
b/src/main/assets/images/cayenne-modeler1.png
new file mode 100644
index 0000000..4f6be57
Binary files /dev/null and b/src/main/assets/images/cayenne-modeler1.png differ

http://git-wip-us.apache.org/repos/asf/cayenne-website/blob/beec78b6/src/main/assets/images/crypto-protocol.png
----------------------------------------------------------------------
diff --git a/src/main/assets/images/crypto-protocol.png 
b/src/main/assets/images/crypto-protocol.png
new file mode 100644
index 0000000..fe1c801
Binary files /dev/null and b/src/main/assets/images/crypto-protocol.png differ

http://git-wip-us.apache.org/repos/asf/cayenne-website/blob/beec78b6/src/main/site/content/_index.md
----------------------------------------------------------------------
diff --git a/src/main/site/content/_index.md b/src/main/site/content/_index.md
index b90c3d4..dd09f6b 100644
--- a/src/main/site/content/_index.md
+++ b/src/main/site/content/_index.md
@@ -96,71 +96,60 @@
                        <div class="tab-content  px-lg-5" id="myTabContent">
                                <div class="tab-pane fade show active" 
id="modeler" role="tabpanel" aria-labelledby="modeler-tab">
                                        <h4>Modeler</h4>
-                                       <p>Cayenne is distributed with 
CayenneModeler - a complete GUI mapping tool that supports reverse-engineering 
of RDBMS schemas, working with database mappings and generation of Java source 
code for the persistent objects.</p>
-                                       <figure class="highlight">
-                                               <pre><code 
class="language-xml">&lt;?xml version="1.0" encoding="utf-8"?&gt;
-&lt;!DOCTYPE web-app
-   PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
-   "http://java.sun.com/dtd/web-app_2_3.dtd"&gt;
-&lt;web-app&gt;
-    &lt;display-name&gt;Cayenne Tutorial&lt;/display-name&gt;
-    &lt;servlet&gt;
-        &lt;servlet-name&gt;cayenne-project&lt;/servlet-name&gt;
-        
&lt;servlet-class&gt;org.apache.cayenne.rop.ROPServlet&lt;/servlet-class&gt;
-        &lt;load-on-startup&gt;0&lt;/load-on-startup&gt;
-    &lt;/servlet&gt;
-    &lt;servlet-mapping&gt;
-        &lt;servlet-name&gt;cayenne-project&lt;/servlet-name&gt;
-        &lt;url-pattern&gt;/cayenne-service&lt;/url-pattern&gt;
-    &lt;/servlet-mapping&gt;
-&lt;/web-app&gt;</code></pre>
-                                       </figure>
-                                       <p>Persistent Java classes are 
generated and synchronized with the mapping using the Modeler or alternatively 
with Maven or Ant. A database SQL schema can be generated from the Modeler and 
also with simple API calls.</p>
+                                       <p>Cayenne is distributed with 
CayenneModeler - a complete GUI mapping tool that supports reverse-engineering 
of RDBMS schemas, editing object-relational mapping projects, generation of 
Java source code for the persistent objects and other functions.</p>
+                                       
+                           <img class="img-fluid  mb-2" 
src="img/cayenne-modeler1.png" alt="Cayenne Modeler" />
+
                                </div>
                                <div class="tab-pane fade" id="db-first-flow" 
role="tabpanel" aria-labelledby="db-first-flow-tab">
                                        <h4>DB-first-flow</h4>
-                                       <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
-                                       </p>
-                                       <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                       <p>Cayenne allows you to design your 
data model in a single place - the database. Other layers (OR mapping and Java 
objects) are synchronized automatically via CayenneModeler or a build script, 
so you don't have to repeat yourself. Such approach is called "database-first". 
It saves you development time and prevents errors by ensuring that your model 
is in sync across multiple layers. It is also quite flexible. It works well 
with common DB migrations frameworks like Liquibase or Flyway, allows object 
structure customizations and is designed for iterative schema evolution.
                                        </p>
                                </div>
                                <div class="tab-pane fade" 
id="transparent-transactions" role="tabpanel" 
aria-labelledby="transparent-transactions-tab">
                                        <h4>Transparent transactions</h4>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                               Most ORM frameworks require you 
to manage transactions manually or with external tools like Spring. Also you 
must always ensure you stay within transaction bounds when traversing 
relationships between objects. Cayenne takes a notably different approach, 
freeing you from writing lots of trivial code. Transaction management happens 
automatically behind the scenes. Object graph can be expanded lazily on demand 
without any special considerations. 
                                        </p>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                               At the same time Cayenne works 
well with external transaction managers. It also has its own transaction API 
that can be used to run multiple operations atomically in regards to DB 
commit/rollback. The good thing is that it is completely optional and should be 
used only when needed.
                                        </p>
                                </div>
                                <div class="tab-pane fade" id="objectcontext" 
role="tabpanel" aria-labelledby="objectcontext-tab">
                                        <h4>Object Context</h4>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                               At the heart of Cayenne 
persistence API lies ObjectContext. ObjectContext can be thought of as a unit 
of work. It  has its own copy of persistent objects. While vaguely similar to 
JPA EntityManager, ObjectContext is closer to a version control client. It is 
not connected to the database except when a read or write operation is in 
progress, it doesn't hold on to any resources (such as DB connections), and 
doesn't need to be closed. 
                                        </p>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                               As a result ObjectContexts are 
serializable and rather lightweight. Contexts can be nested (a child context 
can read/write from/to parent without affecting the DB). There is even a 
version of ObjectContext that can run in an entirely different JVM from the 
main app, and communicate with the app via a binary web service.
                                        </p>
                                </div>
                                <div class="tab-pane fade" id="extension-api" 
role="tabpanel" aria-labelledby="extension-api-tab">
                                        <h4>Extension API</h4>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                                Cayenne stack is built around 
a small dependency injection (DI) container responsible for configuring and 
binding all framework services. It provides a simple API to define custom 
implementations of core services and strategies or add extensions to the 
existing ones (e.g. custom value types). Additionally many things can be 
configured via system properties.
+                                       </p>
+                                       <p>
+                                               Cayenne is truly modular. The 
above-mentioned DI container supports autoloading of extra modules from 
classpath. Cayenne itself takes advantage of this, isolating various optional 
features and integrations into optional modules. You can do the same with your 
own code.
                                        </p>
                                </div>
                                <div class="tab-pane fade" id="generic-objects" 
role="tabpanel" aria-labelledby="generic-objects-tab">
                                        <h4>Generic Objects</h4>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                               Traditional Java ORMs depend on 
bytecode generation or dynamic proxies to "connect" persistent objects with the 
framework. In constrast, Cayenne objects implement a simple API contract to 
interact with the ORM runtime, but otherwise can be structured arbitrarily, not 
requiring any annotation or "enhancement".
+                                       </p>
+                                       <p>This opens up some interesting 
possibilities. E.g. Cayenne provides a Map-based "generic" persistent object 
that can be dynamically mapped to any entity. This means that ORM model can be 
created in runtime without recompiling the code. Combined with DB 
reverse-engineering feature, this allows building completely generic data tools 
and services.
                                        </p>
                                </div>
                                <div class="tab-pane fade" id="data-encryption" 
role="tabpanel" aria-labelledby="data-encryption-tab">
                                        <h4>Data Encryption</h4>
                                        <p>
-                                               Lorem ipsum dolor sit amet, 
consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. 
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur 
ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, 
sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet 
nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis 
vitae, justo. Nullam dictum felis eu pede mollis pretium.
+                                               Traditionally protecting DB 
data at rest stops at encrypting entire hard drive partitions. Cayenne goes a 
few steps further, offering a more secure and flexible solution - 
"cayenne-crypto" module with field-level data encryption. 
+                                       </p>
+                                       <p>
+                                                You can designate any number 
of columns in multiple tables in your model as encrypted, and Cayenne will 
transparently encrypt and decrypt data with minimal overhead. Default 
encryption algorithm is AES/CBC/PKCS#5 with 128 or 256-bit key. Other useful 
features are key revocation, data compression, HMAC signatures.
                                        </p>
+                           <img class="img-fluid  mb-2" 
src="img/crypto-protocol.png" alt="Cayenne Crypto Protocol" />
                                </div>
                        </div>
                </div>

Reply via email to