This document describes an integration framework and its components. It includes:
- FUSE ESB as the integration bus based on JBI and OSGi standards.
- ActiveMQ as the message broker based on JMS.
- CXF for creating or consuming web services.
- Camel as the mediation router for creating integration patterns with a simple Java or XML DSL.
- Details on configuring ActiveMQ and Camel within a OSGi container.
- Code examples of using Camel routes and processors to integrate and transform messages between endpoints.
Clojure is a modern dynamically typed lisp. Dynamical typing is ofter associated with poor performance and runtime failures. In this talk, I'll present some of the lessons learned on building Clojure/Script systems that are both ridiculously fast and will fail fast on errors. Will compare the performance of mutable, persistent & zero-copy data structures and show how we can use interpreters and compilers to build beautiful and performant abstractions. A quick demo on how to build a simple non-blocking web server that runs idiomatic Clojure to serve millions of requests per sec.
Clojure is awesome, and it can be fast too.
Video: https://www.youtube.com/watch?v=3SSHjKT3ZmA
Python has been adding more and more async features to the language and the standard library. Starting with asyncio in python 3.4 and including the new async/await keywords in python 3.5, it’s difficult to understand how all these pieces fit together. More importantly, it’s hard to envision how to use these new language features in a real world application. In this talk we’re going to move beyond the basic examples of TCP echo servers and example servers that can add number together. Instead I’ll show you a realistic asyncio application. This application is a port of redis, a popular data structure server, written in python using asyncio. In addition to basic topics such as handling simple redis commands (GET, SET, RPUSH, etc), we’ll look at notifications using pub/sub, and how to implement blocking queues.
Tommi Reiman (https://twitter.com/ikitommi) will be presenting Malli
(https://github.com/metosin/malli) is a fresh new data-driven data
validation and specification library for Clojure/Script. In this talk,
Tommi will give a quick introduction to Malli, compare it to prior art
including Plumatic Schema and clojure.spec and demonstrate how to
elegantly solve real-world problems with it. Also, peek beyond the
runtime validation.
Malli is a new Clojure/Script library for elegant data-driven data modelling. It is born from the real world needs of dynamic, distributed and multi-tenant systems: Schemas to describe the data should be first-class data. They should drive the runtime value transformations, web forms, rules and processes. Configuration should be explicit – no magic, macros or mutability. We should be able to infer, create and modify the models at runtime, persist and load them back from database and share over the wire, for both Clojure and ClojureScript. Like JSON Schema, but for EDN & Clojure/Script.
In this talk, I’ll walk through the core concepts, features and the lessons learned on creating Malli. I’ll also demonstrate some cool new things we can do with literal data schemas and compare it to prior art, including clojure.spec, plumatic schema and JSON Schema.
탑크리에듀교육센터(www.topcredu.co.kr)제공
스프링프레임워크 & 마이바티스(Spring Framework, MyBatis)
18번째 자료입니다. 참고하시어 많은 도움되셨길 바랍니다.
교육 및 수강문의/기타문의사항은 홈페이지(www.topcredu.co.kr)를 통하여 하실 수 있습니다.^^
And now you have two problems. Ruby regular expressions for fun and profit by...Codemotion
A wise hacker said: Some people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems.
Regular expressions are a powerful tool in our hands and a first class citizen in ruby so it is tempting to overuse them. But knowing them and using them properly is a fundamental asset of every developer.
We’ll see hands-on examples of proper Reg Exps usage in ruby code, we’ll also look at bad and ugly cases and learn how to approach writing, testing and debugging regular expressions.
Ten common mistakes made with Functional Java JBCNConf18Brian Vermeer
Slides from my talk "Ten common mistakes made with Functional Java" @ JBCNConf 2018 Barcelona.
Beware that the slides are just here as a reference to people who attended this particular version of the talk. Please do not make assumptions purely from the slides alone ... there is a story with it ...really ;)
Too few projects demand good API design as a critical goal. A clean and
extensible API will pay for itself many times over in fostering a community of
plugins. We certainly cannot anticipate the ways in which our users will bend
our modules, but designing an extensible system alleviates the pain. There are
many lessons to be learned from Moose, HTTP::Engine and IM::Engine,
Dist::Zilla, KiokuDB, Fey, and TAEB.
The most important lesson is to decouple the core functionality from the
"fluff" such as sugar and middleware. This forces you to have a solid API that
ordinary users can extend. This also lets users write their own sugar and
middleware. In a tightly-coupled system, there is little hope for
extensibility.
In this talk, you will learn how to make very productive use of Moose's roles
to form the foundation of a pluggable system. Roles provide excellent means of
code reuse and safe composition. I will also demonstrate how to use
Sub::Exporter to construct a more useful and flexible sugar layer.
Just because Flask is a micro-framework doesn’t mean we still don’t want to have great AAA (authentication, authorization, and accounting), email services, simplified database access/migrations and form handling. Lets look at some of the most common libraries used to build the powerful simplicity of Flask into a full featured web application without having to reinvent the wheel each time.
Clojure is a modern dynamically typed lisp. Dynamical typing is ofter associated with poor performance and runtime failures. In this talk, I'll present some of the lessons learned on building Clojure/Script systems that are both ridiculously fast and will fail fast on errors. Will compare the performance of mutable, persistent & zero-copy data structures and show how we can use interpreters and compilers to build beautiful and performant abstractions. A quick demo on how to build a simple non-blocking web server that runs idiomatic Clojure to serve millions of requests per sec.
Clojure is awesome, and it can be fast too.
Video: https://www.youtube.com/watch?v=3SSHjKT3ZmA
Python has been adding more and more async features to the language and the standard library. Starting with asyncio in python 3.4 and including the new async/await keywords in python 3.5, it’s difficult to understand how all these pieces fit together. More importantly, it’s hard to envision how to use these new language features in a real world application. In this talk we’re going to move beyond the basic examples of TCP echo servers and example servers that can add number together. Instead I’ll show you a realistic asyncio application. This application is a port of redis, a popular data structure server, written in python using asyncio. In addition to basic topics such as handling simple redis commands (GET, SET, RPUSH, etc), we’ll look at notifications using pub/sub, and how to implement blocking queues.
Tommi Reiman (https://twitter.com/ikitommi) will be presenting Malli
(https://github.com/metosin/malli) is a fresh new data-driven data
validation and specification library for Clojure/Script. In this talk,
Tommi will give a quick introduction to Malli, compare it to prior art
including Plumatic Schema and clojure.spec and demonstrate how to
elegantly solve real-world problems with it. Also, peek beyond the
runtime validation.
Malli is a new Clojure/Script library for elegant data-driven data modelling. It is born from the real world needs of dynamic, distributed and multi-tenant systems: Schemas to describe the data should be first-class data. They should drive the runtime value transformations, web forms, rules and processes. Configuration should be explicit – no magic, macros or mutability. We should be able to infer, create and modify the models at runtime, persist and load them back from database and share over the wire, for both Clojure and ClojureScript. Like JSON Schema, but for EDN & Clojure/Script.
In this talk, I’ll walk through the core concepts, features and the lessons learned on creating Malli. I’ll also demonstrate some cool new things we can do with literal data schemas and compare it to prior art, including clojure.spec, plumatic schema and JSON Schema.
탑크리에듀교육센터(www.topcredu.co.kr)제공
스프링프레임워크 & 마이바티스(Spring Framework, MyBatis)
18번째 자료입니다. 참고하시어 많은 도움되셨길 바랍니다.
교육 및 수강문의/기타문의사항은 홈페이지(www.topcredu.co.kr)를 통하여 하실 수 있습니다.^^
And now you have two problems. Ruby regular expressions for fun and profit by...Codemotion
A wise hacker said: Some people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems.
Regular expressions are a powerful tool in our hands and a first class citizen in ruby so it is tempting to overuse them. But knowing them and using them properly is a fundamental asset of every developer.
We’ll see hands-on examples of proper Reg Exps usage in ruby code, we’ll also look at bad and ugly cases and learn how to approach writing, testing and debugging regular expressions.
Ten common mistakes made with Functional Java JBCNConf18Brian Vermeer
Slides from my talk "Ten common mistakes made with Functional Java" @ JBCNConf 2018 Barcelona.
Beware that the slides are just here as a reference to people who attended this particular version of the talk. Please do not make assumptions purely from the slides alone ... there is a story with it ...really ;)
Too few projects demand good API design as a critical goal. A clean and
extensible API will pay for itself many times over in fostering a community of
plugins. We certainly cannot anticipate the ways in which our users will bend
our modules, but designing an extensible system alleviates the pain. There are
many lessons to be learned from Moose, HTTP::Engine and IM::Engine,
Dist::Zilla, KiokuDB, Fey, and TAEB.
The most important lesson is to decouple the core functionality from the
"fluff" such as sugar and middleware. This forces you to have a solid API that
ordinary users can extend. This also lets users write their own sugar and
middleware. In a tightly-coupled system, there is little hope for
extensibility.
In this talk, you will learn how to make very productive use of Moose's roles
to form the foundation of a pluggable system. Roles provide excellent means of
code reuse and safe composition. I will also demonstrate how to use
Sub::Exporter to construct a more useful and flexible sugar layer.
Just because Flask is a micro-framework doesn’t mean we still don’t want to have great AAA (authentication, authorization, and accounting), email services, simplified database access/migrations and form handling. Lets look at some of the most common libraries used to build the powerful simplicity of Flask into a full featured web application without having to reinvent the wheel each time.
James McCutcheon from Foundry38 gives a compelling Twitter conversation about his discussions with the Windows Phone 7 Development Team at the MIX10 Conference
Apache Mesos abstracts CPU, memory, storage, and other compute resources away from machines (physical or virtual), enabling fault-tolerant and elastic distributed systems to easily be built and run effectively.
Session highlighting and demonstrating approaches to common challenges in modern portlet development. Topics include AJAX in JSR-168 and JSR-286 portlets, CSS and Javascript toolkits, security, and optimization of front-end resources. This session was presented at the Jasig Spring 2010 conference in San Diego, CA by Jennifer Bourey.
This is a presentation given on October 24 by Michael Uzquiano of Cloud CMS (http://www.cloudcms.com) at the MongoDB Boston conference.
In this presentation, we cover Hazelcast - an in-memory data grid that provides distributed object persistence across multiple nodes in a cluster. When backed by MongoDB, objects are naturally written to Mongo by Hazelcast. The integration points are clean and easy to implement.
We cover a few simple cases along with code samples to provide the MongoDB community with some ideas of how to integrate Hazelcast into their own MongoDB Java applications.
Burn down the silos! Helping dev and ops gel on high availability websitesLindsay Holmwood
HA websites are where the rubber meets the road - at 200km/h. Traditional separation of dev and ops just doesn't cut it.
Everything is related to everything. Code relies on performant and resilient infrastructure, but highly performant infrastructure will only get a poorly written application so far. Worse still, root cause analysis in HA sites will more often than not identify problems that don't clearly belong to either devs or ops.
The two options are collaborate or die.
This talk will introduce 3 core principles for improving collaboration between operations and development teams: consistency, repeatability, and visibility. These principles will be investigated with real world case studies and associated technologies audience members can start using now. In particular, there will be a focus on:
- fast provisioning of test environments with configuration management
- reliable and repeatable automated deployments
- application and infrastructure visibility with statistics collection, logging, and visualisation
This is my presentation from TechBeats #3 hosted by Applause about Server-Side Swift framework called Vapor.
Swift is a great language and possibility of using it also in backend is a huge benefit for any iOS developer out there. Using Vapor is a seamless experience. With this framework creating advance APIs by iOS developer is as easy as writing simple iOS app.
https://www.meetup.com/TechBeats-hosted-by-Applause/events/254910023/
Build powerfull and smart web applications with Symfony2Hugo Hamon
Symfony2 first stable release is scheduled for the first week of March 2011. During this session, we will have a look at the new framework architecture and most of its powerfull features.
We will show you how Symfony2 implements the MVC pattern and an HTTP request is processed and converted as a response for the end user. Of course, we will talk about the configuration principles and how it's easy to configure Symfony2 project parts like the routing system or the data model. We will also focus on other major components of the framework like the Doctrine2 integration, forms, security (authentication and authorizations) or HTTP cache management.
5. é
Apache ServiceMix : Bus d’intégration (Flux,
FUSE ESB processus techniques) basé sur JBI et OSGI
FUSE Message Apache ActiveMQ : Courtier de messagerie (MOM) basé
Broker sur JMS
FUSE Apache CXF : permet de créer ou consommer des
Services Services Web
Framework
FUSE Mediation Apache Camel : moteur de routage permettant de
Router créer des patterns d'intégration avec une formation
minimale grâce à un langage Java simple ou avec XML
6.
7.
8.
9.
10.
11.
12. #
# Framework selection properties
#
karaf.framework=equinox
#
# Location of the OSGi frameworks
#
karaf.framework.equinox=${karaf.default.repository}/org/eclipse/osgi/....
karaf.framework.felix=${karaf.default.repository}/org/apache/felix/.....
16. Expéditeur: Destinataire
Application Application
A B
Queue
Queue
Queue
17.
18. <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0"
xmlns:ext="http://aries.apache.org/blueprint/xmlns/blueprint-ext/v1.0.0"
xmlns:amq="http://activemq.apache.org/schema/core">
<!-- Allows us to use system properties as variables in this configuration file -->
<ext:property-placeholder />
<broker xmlns="http://activemq.apache.org/schema/core" brokerName="default" dataDirectory="${karaf.data}/activemq/default" useShutdownHook="false">
<destinationPolicy>
<policyMap>
<policyEntries>
<policyEntry topic=">" producerFlowControl="true" memoryLimit="1mb">
<pendingSubscriberPolicy>
<vmCursor />
</pendingSubscriberPolicy>
</policyEntry>
<policyEntry queue=">" producerFlowControl="true" memoryLimit="1mb">
</policyEntry>
</policyEntries>
</policyMap>
</destinationPolicy>
<!-- Use the following to configure how ActiveMQ is exposed in JMX -->
<managementContext>
<managementContext createConnector="false"/>
</managementContext>
<persistenceAdapter>
<kahaDB directory="${karaf.data}/activemq/default/kahadb"/>
</persistenceAdapter>
<!-- The transport connectors ActiveMQ will listen to -->
<transportConnectors>
<transportConnector name="openwire" uri="tcp://localhost:61616"/>
<transportConnector name="stomp" uri="stomp://localhost:61613"/>
</transportConnectors>
</broker>
<bean id="activemqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://localhost:61616" />
</bean>
<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
<property name="maxConnections" value="8" />
<property name="connectionFactory" ref="activemqConnectionFactory" />
</bean>
<bean id="resourceManager" class="org.apache.activemq.pool.ActiveMQResourceManager" init-method="recoverResource">
<property name="transactionManager" ref="transactionManager" />
<property name="connectionFactory" ref="activemqConnectionFactory" />
<property name="resourceName" value="activemq.default" />
</bean>
<reference id="transactionManager" interface="javax.transaction.TransactionManager" />
<service ref="pooledConnectionFactory" interface="javax.jms.ConnectionFactory">
<service-properties>
<entry key="name" value="localhost"/>
</service-properties>
</service>
</blueprint>
19.
20.
21.
22.
23. class MyRouteBuilder extends RouteBuilder {
"direct:a" --> "mock:a"
}
public class MyRouteBuilder extends RouteBuilder {
@Override
public void configure() throws Exception {
from("direct:a")
.to("mock:a");
}
}
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="direct:a"/>
<to uri="mock:a"/>
</route>
</camelContext>
24. public class MyRouteBuilder extends RouteBuilder {
public void configure() {
Processor myProcessor = new MyProcessor();
from("URI1")
.process(myProcessor)
...
.to("URI2");
}
}
public class MyProcessor implements Processor{
public void process(Exchange exchange) throws Exception {
//Use exchange methods for processing it ...
}
}
25.
26. log.info("Source : "+exchange.getFromEndpoint());
log.info("Pattern : "+exchange.getPattern());
log.info("Exchange ID : "+exchange.getExchangeId());
log.info("---------- Here Starts Headers ----------");
Map<String,Object> dictionnaire = exchange.getIn().getHeaders();
for (final String cle : dictionnaire.keySet()) {
log.info("Key : "+cle+" Value : "+dictionnaire.get(cle));
}
log.info("---------- Here Starts Properties -------");
Map<String,Object> dictionnaire2 = exchange.getProperties();
for (final String cle : dictionnaire2.keySet()) {
log.info("Key : "+cle+" Value : "+dictionnaire2.get(cle));
}
27. INFO Source : Endpoint[file://src/data/?fileName=livraison.csv&noop=true]
INFO Pattern : InOnly
INFO Exchange ID : ID-saad-local-51012-1303566625671-0-2
INFO ---------- Here Starts Headers ----------
INFO Key : camelfilenameonly Value : livraison.csv
INFO Key : camelfileparent Value : src/data
INFO Key : camelfilename Value : livraison.csv
INFO Key : camelfileabsolute Value : false
INFO Key : camelfilelength Value : 115
INFO Key : camelfilerelativepath Value : livraison.csv
INFO Key : camelfilepath Value : src/data/livraison.csv
INFO Key : camelfilelastmodified Value : Sat Apr 16 08:26:18 CEST 2011
INFO Key : camelfileabsolutepath Value : /users/saadrguig/Desktop/CAMEL-CSV-TEST/src/data/livraison.csv
INFO ---------- Here Starts Properties -------
INFO Key : CamelBatchComplete Value : true
INFO Key : CamelBatchSize Value : 1
INFO Key : CamelCreatedTimestamp Value : Sat Apr 23 15:50:27 CEST 2011
INFO Key : CamelFileExchangeFile Value : GenericFile[livraison.csv]
INFO Key : Propriete 1 Value : Contenu de La propriete 1
INFO Key : CamelBatchIndex Value : 0