This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel-website.git
The following commit(s) were added to refs/heads/master by this push:
new 383dd4d Add blog of whats new in Camel 3
383dd4d is described below
commit 383dd4d472a6b2da8873e283256140c9a36fbecb
Author: Claus Ibsen <[email protected]>
AuthorDate: Mon Dec 2 12:52:47 2019 +0100
Add blog of whats new in Camel 3
---
content/blog/Camel3-Whatsnew/camel3-3humps.png | Bin 0 -> 84398 bytes
.../blog/Camel3-Whatsnew/camel3-core-vs-engine.png | Bin 0 -> 22436 bytes
content/blog/Camel3-Whatsnew/camel3-projects.png | Bin 0 -> 88043 bytes
content/blog/Camel3-Whatsnew/camel3-quarkus.png | Bin 0 -> 737648 bytes
content/blog/Camel3-Whatsnew/camel3-website.png | Bin 0 -> 130976 bytes
content/blog/Camel3-Whatsnew/index.md | 171 +++++++++++++++++++++
6 files changed, 171 insertions(+)
diff --git a/content/blog/Camel3-Whatsnew/camel3-3humps.png
b/content/blog/Camel3-Whatsnew/camel3-3humps.png
new file mode 100644
index 0000000..e5bf73c
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-3humps.png
differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-core-vs-engine.png
b/content/blog/Camel3-Whatsnew/camel3-core-vs-engine.png
new file mode 100644
index 0000000..ef2959f
Binary files /dev/null and
b/content/blog/Camel3-Whatsnew/camel3-core-vs-engine.png differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-projects.png
b/content/blog/Camel3-Whatsnew/camel3-projects.png
new file mode 100644
index 0000000..6c9e720
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-projects.png
differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-quarkus.png
b/content/blog/Camel3-Whatsnew/camel3-quarkus.png
new file mode 100644
index 0000000..a06a9db
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-quarkus.png
differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-website.png
b/content/blog/Camel3-Whatsnew/camel3-website.png
new file mode 100644
index 0000000..3cee196
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-website.png
differ
diff --git a/content/blog/Camel3-Whatsnew/index.md
b/content/blog/Camel3-Whatsnew/index.md
new file mode 100644
index 0000000..20e5c50
--- /dev/null
+++ b/content/blog/Camel3-Whatsnew/index.md
@@ -0,0 +1,171 @@
+---
+title: "Apache Camel 3 Whats New (top 10)"
+date: 2019-12-02
+author: Claus Ibsen
+categories: ["Release"]
+preview: Top 10 of whats new in Apache Camel 3
+---
+
+Apache Camel 3 was released last thursday November 28th 2019, which also
happens to be the day of the US Thanksgiving. This was not intentionally but we
can say its a big thanks from us to the community with a brand new major
version of Camel - this does not come often by. In fact its 10 years since
Camel 2 hit the streets. So this 3rd generation is long overdue.
+
+{{< image "camel3-3humps.png" "Apache Camel 3" >}}
+
+
+This blog post highlights the noteworthy new features and improvements in
Camel v3.
+
+### 1) Camel is now a family of projects
+
+Apache Camel, is now a family of projects (3 at this time of writing).
+- [Camel 3](https://github.com/apache/camel):
+ **Integration Framework** _Swiss knife of integration_
+- [Camel K](https://github.com/apache/camel-k/):
+ **Lightweight Serverless Integration Platform** _Camel on Kubernetes &
Knative_
+- [Camel Quarkus](https://github.com/apache/camel-quarkus):
+ **Camel extensions for Quarkus** _Optimized JVM & Native compiled Java
(GraalVM)_
+
+{{< image "camel3-projects.png" "Camel 3 projects" >}}
+
+The Camel code-base is very large, and we have setup sub-projects for new
innovative projects using Camel. The first sub-project was to run Camel as
cloud-native on Kubernetes in a serverless manner which became Camel K. Then
Camel Quarkus came to make Java and Camel with very fast startup and very small
memory footprint primary for container based deployments.
+
+
+### 2) New Website
+
+{{< image "camel3-website.png" "Camel 3 website" >}}
+
+A major goal for Camel 3 was to finally revamp the old aging website to use
modern technologies and be able to auto-generate content from the source code.
This has taken years to get to this point as we have built tools over the last
many Camel 2.x releases that could take us closer.
+At end of 2019 then the Camel community and others stepped up and provided the
new art-work, logo, and look and feel for the new website - thank you very
much!.
+
+For Camel 3.x we will continue to improve the website and the documentation.
This is much easier for us to do, and also for people to contribute changes as
its just a regular github PR to provide updates. We love contributions.
+
+Zoran had some fun with the new look and feel and he added a little gem; if
you stare at the front page, then you should see a little animation of the
curved bezel ;)
+
+
+### 3) Java 11
+
+Camel 3 is the first official release that supports Java 11. Java 8 will still
be supported for the first number of 3.x releases, but is expected to be
dropped later in 2020. However we wanted to provide Java 8 support to help
migrate Camel 2.x users whom may be restricted to Java 8 for some time to come.
+
+
+### 4) Modularized camel-core
+
+The camel-core has been modularized from 1 JAR to 33 JARs. The core
functionality has been splitup into:
+
+| JAR | JAR | JAR |
+|---- |---- |----
+| **camel-api** | camel-core-osgi | camel-management-api |
+| camel-base | camel-core-xml | camel-management-impl |
+| camel-caffeine-lrucache | camel-endpointdsl | **camel-support** |
+| camel-cloud | camel-headersmap | camel-util |
+| camel-core | camel-jaxp | camel-util-json |
+| camel-core-engine | camel-main |
+
+For Camel end users then only a few JARs is relevant. **camel-api** contains
the public API for Camel (eg interfaces such as CamelContext, Endpoint,
Exchange, Message, and son on). **camel-support** contains the base classes and
`RouteBuilder` which you would use to build Camel routes and applications. This
JAR is also contains necessary base classes for building custom Camel
components, and other kinds of plugins.
+
+The components that resided in camel-core has also be externalized into
individual components:
+
+| JAR | JAR | JAR |
+|---- |---- |----
+| came-bean | camel-log | camel-stub |
+| camel-browse | camel-mock | camel-timer |
+| camel-controlbus | camel-properties | camel-validator |
+| camel-dataformat | camel-ref | camel-vm |
+| camel-direct | camel-rest | camel-xpath |
+| camel-directvm | camel-saga | camel-xslt |
+| camel-file | camel-scheduler | camel-zip-deflater |
+| camel-language | camel-seda | |
+
+Camel end users can then pick and choose exactly only what they need, or keep
using everything.
+
+Therefore we have `camel-core` and `camel-core-engine` as two starting
dependencies.
+You can use `camel-core` which gives you all the JARs which is similar to
Camel 2.x.
+When you use `camel-core-engine` you get the minimum set of JARs that makes a
functional Camel.
+
+{{< image "camel3-core-vs-engine.png" "Camel 3 core vs engine" >}}
+
+`camel-core` contains 33 JARs and `camel-core-engine` contains 12 JARs.
+
+
+### 5) Faster startup and lower footprint
+
+We have reduced the size of core Camel and the number of classes loaded. For
example in Camel 2 about 5200 classes was loaded, which has been reduced to
about 4300 loaded classes in Camel 3.
+
+We have also done many smaller optimizations in the core, to reduce the number
of allocated Java objects, and speeup initialization and other means. We have
used JVM profiling tools to assist and find the bottlenecks.
+
+Another area of improvement is to reduce Java reflections. In Camel 2 then all
the configuration of Camel components, endpoints, and routes are reflection
based. In Camel 3
+we have source code generated Java code for configuration that allows us to
use direct Java calls instead of reflections.
+
+Another similar area is Camel's type converters which in Camel 2 are Java
reflection based (you could build custom type converts that was not reflection
based. In Camel 3 we also generate Java source code which means that type
converting is direct Java calls at runtime.
+
+We have also moved initialization logic to earlier phases when it was
possible. For example there is a new build phase which allows Camel to do
special initialization during building your project (this requires Camel
Quarkus).
+
+All this optimization improves the startup performance of Camel and reduces
the memory overhead. With Camel Quarkus you can native compiled your Camel
application and make it startup in 30 milli seconds and consume only 10mb of
memory (RSS) with a full blow HTTP REST server and health-checks and metrics.
+
+{{< image "camel3-quarkus.png" "Camel 3 Quarkus native compiled" >}}
+
+There are still a few items still on the agenda that we want to work on in
Camel 3.x to further optimize Camel core.
+
+
+### 6) Type Safe Endpoint DSL
+
+Camel end users whom has configured endpoints using URI strings, would all
have experience the problem when you make a configuration mistake in the
endpoint, which then makes Camel fail on startup.
+
+In Camel 3, we have a new type-safe DSL for endpoints which you can use in
Java routes.
+You can continue to use the classic URI strings, but if you want to try the
endpoint DSL, then you need to add `camel-endpointdsl` to your classpath. Then
you should extend `EndpointRouteBuilder` instead of `RouteBuilder` to access
the endpoint DSL.
+
+Here is a basic example without and with the endpoint DSL:
+
+```
+from("timer:click?period=3000&fixedRate=true")
+ .to("seda:foo?blockWhenFull=true");
+
+from(timer("click").period(3000).fixedRate(true))
+ .to(seda("foo").blockWhenFull(true));
+```
+
+You can also find a [little
example](https://github.com/apache/camel/tree/master/examples/camel-example-cafe-endpointdsl)
in the source code.
+
+
+### 7) Reactive Routing Engine
+
+The routing engine in Camel has internally been reactive'fied and all EIPs has
been retrofitted to work in a reactive manner. However this is internal only,
and the Camel API for both end users and component developers are based on
existing callback behavior.
+
+We will later introduce and work on a client-side facing reactive API after we
have jumped to Java 11 as minimum version (then we can support Java 9 flowable
API).
+
+Camel already have integration with reactive frameworks such as Vert.X, RxJava
and Reactor Core in the dedicated Camel components.
+
+
+### 8) Camel Main
+
+We have introduced `camel-main` as a standalone JAR that makes it easier to
run just Camel.
+There are a [couple of
examples](https://github.com/apache/camel/blob/master/examples/camel-example-main/readme.adoc)
with the source code that demonstrates how to do that.
+
+We also use `camel-main` to have common code to configure and bootstrap Camel
for standalone, Spring Boot, Camel K, and Camel Quarkus. This allows us to
share the same code, and configuration options.
+
+
+### 9) Camel Microprofile
+
+Camel 3 now integrates better with Eclipse Microprofile and we have Camel
components for Microprofile configuration, metrics, health checks, and fault
tolerance (on the way).
+
+More components to come in upcoming Camel releases. These microprofile
components are also used by Camel Quarkus.
+
+
+### 10) Miscellaneous improvements
+
+Camel 3 now supports JUnit 5 for unit tests, with the test components that has
-junit5 as suffix.
+
+The Camel `Registry` is now also writeable, so you can add beans to the
registry at runtime, or from unit tests etc.
+
+You can also configure endpoints (producer) to lazy start. By default Camel
works in a fail-fast mode, which means that Camel components that fails to
connect to external systems during startup may cause the route to fail on
startup. For Camel 3 you can now configure these endpoints to lazy start, which
means the route will startup and they will first fail when a message is routed
to the endpoint.
+
+Camel also allows to configure your routes to be supervised during startup,
which allows Camel to more intelligently start routes in a more safe manner, by
restarting routes that failed.
+
+
+### 11) Migrating to Camel 3
+
+We have of course cleaned up the code base, such as removing all deprecated
APIs and components. We have also adjusted some APIs to make them easier to use
from end users, and more Java 8 lambda friendly.
+
+Internally we have also adjusted the route model, to make it easier to extend
into new DSLs; and there is a YAML DSL on the way which was initiated in Camel
K.
+
+In terms of backwards compatibility then Camel 3 is mostly compatibility for
regular Camel applications. However if you are using some of the more advanced
and other plugins in Camel then migration is needed. Also custom components
must be migrated and recompiled. There are other adjustments such as Spring
Boot users must use `org.apache.camel.springboot` as groupId instead of
`org.apache.camel` etc. All details can be seen in the [migration
guide](https://camel.apache.org/manual/latest/ [...]
+
+
+Good luck with your migration if you decide to continue your Camel journey.
And for new users to Camel then good luck getting onboard.
\ No newline at end of file
