11111111111111111111111111111111111111111111111111111111111111111111111111111111111

11111111111111111111111
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"""""""""""""""""""""""
33333333333333333333333333333333333333333333333333333333333333333333333333333333333
33333333333333333333333
33333333333333333333333333333333333333333333333333333333333333333333333333333333333
33333333333333333333333
ch data)
-Declare a MongoClient @Bean[Like a DataSource] to be injected in a
MongoTemplate @Bean + Annotate with @Document instead of @Entity
1-Use MongoTemplate mt.save().....
2-@EnableMongoRepo in @configuration class then create repo interfaces that
extend MongoRepository
-repo.(findAll|count|delete...)
-You can also ADD CUSTOM QUERY METHODS by declaring new methods that
follow the method-naming convention
-You can also SPECIFY to specify a custom query for a repository method
with @Querry using "JSON" instead of "JPA Querry"
Redis: (Key-Value Store) A Persistent HashMap (use case LeaderBoard for Formulas)
You can store a value at a particular key, and you can fetch the value for a
particular key. That’s about it.
Spring Data’s automatic repository support doesn’t make a lot of sense!
-You need a RedisConnectionFactory @Bean
-cf.getConnection() / conn.set(key,value); conn.get(key); /// set &
get parameters are ALL Byte[]
-RedisTemplate<String, Product> redis = new RedisTemplate<String,
Product>(); redis.setConnectionFactory(cf);
-Then use a sub-api like opsForValue()
"redis.opsForValue().set(key,value)";
Microservices:
Architecture qui n'offre pas que des avantage
Pro: Scalability/Testing/Faster Deployment/Library conflicts
Con:
-Use Initializr or STS Plugin which are only REST Clients to Initializr
-Create a project for Eureka itself using Spring Initializr with a "Netflix-
Eureka-Server" dependency
-Annotate the main bootstrap class with @EnableEurekaServer
-Add a "Netflix-Eureka-Client" dependency in each Microservice
Service registry using Spring-Cloud-Netflix's Eureka
-Registere Service instances by name(Spring.application.name property)
with Eureka
-Some other Service request a Service by name and is given a list of
Service instances
-Use client-side load-balancing, like Netflix-Ribbon which
chooses an instance.
-Consume services using REST
Circuit breaker pattern to make services more resilient to failure
-Deploy as JAR to Iaas "AWS-ECS" Docker
-Use Spotify-Dockerfile-Plugin in Maven to create an Image for our JAR
$ mvnw package dockerfile:build
-Deploy as JAR to Paas "Cloud Foundry"
cf login pivotal-address
cf push service-name -p /target/service-name.jar
-You can even Deploy as WAR to Tomcat which doesn't make sense

&&&&&
Apps were used used using swing-gui clients(reason) then moved to all web
_____________ Hibernate _________
I usually use the common Jpa annotations to make it vendor-free
__________________________________
Boot:
-No matter how you initialize your project, you can run the application:
% java -jar demo.jar OR % java -jar demo.war OR % mvn spring-
boot:run
_______________ NoSql ____________
Didn't use Boot probably easier to as no need to create and manage infrastructure
beans
Usually 2 ways to work with (Template Access for common operation/Automatic repos
generation for non common operations)
MongoDB:(Rapports d'essais CAR signatures)(No Suitable for Relation-Rich data)
-Declare a MongoClient @Bean[Like a DataSource] to be injected in a
MongoTemplate @Bean + Annotate with @Document instead of @Entity
1-Use MongoTemplate mt.save().....
2-@EnableMongoRepo in @configuration class then create repo interfaces that
extend MongoRepository
-repo.(findAll|count|delete...)
-You can also ADD CUSTOM QUERY METHODS by declaring new methods that
follow the method-naming convention
-You can also SPECIFY to specify a custom query for a repository method
with @Querry using "JSON" instead of "JPA Querry"
Redis: (Key-Value Store) A Persistent HashMap (use case LeaderBoard for Formulas)
You can store a value at a particular key, and you can fetch the value for a
particular key. That’s about it.
Spring Data’s automatic repository support doesn’t make a lot of sense!
-You need a RedisConnectionFactory @Bean
-cf.getConnection() / conn.set(key,value); conn.get(key); /// set &
get parameters are ALL Byte[]
-RedisTemplate<String, Product> redis = new RedisTemplate<String,
Product>(); redis.setConnectionFactory(cf);
-Then use a sub-api like opsForValue()
"redis.opsForValue().set(key,value)";
Microservices:
Architecture qui n'offre pas que des avantage
Pro: Scalability/Testing/Faster Deployment/Library conflicts
Con:
-Use Initializr or STS Plugin which are only REST Clients to Initializr
-Create a project for Eureka itself using Spring Initializr with a "Netflix-
Eureka-Server" dependency
-Annotate the main bootstrap class with @EnableEurekaServer
-Add a "Netflix-Eureka-Client" dependency in each Microservice
Service registry using Spring-Cloud-Netflix's Eureka
-Registere Service instances by name(Spring.application.name property)
with Eureka
-Some other Service request a Service by name and is given a list of
Service instances
-Use client-side load-balancing, like Netflix-Ribbon which
chooses an instance.
-Consume services using REST
Circuit breaker pattern to make services more resilient to failure
-Deploy as JAR to Iaas "AWS-ECS" Docker
-Use Spotify-Dockerfile-Plugin in Maven to create an Image for our JAR
$ mvnw package dockerfile:build
-Deploy as JAR to Paas "Cloud Foundry"
cf login pivotal-address
cf push service-name -p /target/service-name.jar
-You can even Depl
Apps were used used using swing-gui clients(reason) then moved to all web
_____________ Hibernate _________
I usually use the common Jpa annotations to make it vendor-free
__________________________________
Boot:
-No matter how you initialize your project, you can run the application:
% java -jar demo.jar OR % java -jar demo.war OR % mvn spring-
boot:run
_______________ NoSql ____________
Didn't use Boot probably easier to as no need to create and manage infrastructure
beans
Usually 2 ways to work with (Template Access for common operation/Automatic repos
generation for non common operations)
MongoDB:(Rapports d'essais CAR signatures)(No Suitable for Relation-Rich data)
-Declare a MongoClient @Bean[Like a DataSource] to be injected in a
MongoTemplate @Bean + Annotate with @Document instead of @Entity
1-Use MongoTemplate mt.save().....
2-@EnableMongoRepo in @configuration class then create repo interfaces that
extend MongoRepository
-repo.(findAll|count|delete...)
-You can also ADD CUSTOM QUERY METHODS by declaring new methods that
follow the method-naming convention
-You can also SPECIFY to specify a custom query for a repository method
with @Querry using "JSON" instead of "JPA Querry"
Redis: (Key-Value Store) A Persistent HashMap (use case LeaderBoard for Formulas)
You can store a value at a particular key, and you can fetch the value for a
particular key. That’s about it.
Spring Data’s automatic repository support doesn’t make a lot of sense!
-You need a RedisConnectionFactory @Bean
-cf.getConnection() / conn.set(key,value); conn.get(key); /// set &
get parameters are ALL Byte[]
-RedisTemplate<String, Product> redis = new RedisTemplate<String,
Product>(); redis.setConnectionFactory(cf);
-Then use a sub-api like opsForValue()
"redis.opsForValue().set(key,value)";
Microservices:
Architecture qui n'offre pas que des avantage
Pro: Scalability/Testing/Faster Deployment/Library conflicts
Con:
-Use Initializr or STS Plugin which are only REST Clients to Initializr
-Create a project for Eureka itself using Spring Initializr with a "Netflix-
Eureka-Server" dependency
-Annotate the main bootstrap class with @EnableEurekaServer
-Add a "Netflix-Eureka-Client" dependency in each Microservice
Service registry using Spring-Cloud-Netflix's Eureka
-Registere Service instances by name(Spring.application.name property)
with Eureka
-Some other Service request a Service by name and is given a list of
Service instances
-Use client-side load-balancing, like Netflix-Ribbon which
chooses an instance.
-Consume services using REST
Circuit breaker pattern to make services more resilient to failure
-Deploy as JAR to Iaas "AWS-ECS" Docker
-Use Spotify-Dockerfile-Plugin in Maven to create an Image for our JAR
$ mvnw package dockerfile:build
-Deploy as JAR to Paas "Cloud Foundry"
cf login pivotal-address
cf push service-name -p /target/service-name.jar
 -You can even Depl
Apps were used used using swing-gui clients(reason) then moved to all web
_____________ Hibernate _________
I usually use the common Jpa annotations to make it vendor-free
__________________________________
Boot:
-No matter how you initialize your project, you can run the application:
% java -jar demo.jar OR % java -jar demo.war OR % mvn spring-
boot:run
_______________ NoSql ____________
Didn't use Boot probably easier to as no need to create and manage infrastructure
beans
Usually 2 ways to work with (Template Access for common operation/Automatic repos
generation for non common operations)
MongoDB:(Rapports d'essais CAR signatures)(No Suitable for Relation-Rich data)
-Declare a MongoClient @Bean[Like a DataSource] to be injected in a
MongoTemplate @Bean + Annotate with @Document instead of @Entity
1-Use MongoTemplate mt.save().....
2-@EnableMongoRepo in @configuration class then create repo interfaces that
extend MongoRepository
-repo.(findAll|count|delete...)
-You can also ADD CUSTOM QUERY METHODS by declaring new methods that
follow the method-naming convention
-You can also SPECIFY to specify a custom query for a repository method
with @Querry using "JSON" instead of "JPA Querry"
Redis: (Key-Value Store) A Persistent HashMap (use case LeaderBoard for Formulas)
You can store a value at a particular key, and you can fetch the value for a
particular key. That’s about it.
Spring Data’s automatic repository support doesn’t make a lot of sense!
-You need a RedisConnectionFactory @Bean
-cf.getConnection() / conn.set(key,value); conn.get(key); /// set &
get parameters are ALL Byte[]
-RedisTemplate<String, Product> redis = new RedisTemplate<String,
Product>(); redis.setConnectionFactory(cf);
-Then use a sub-api like opsForValue()
"redis.opsForValue().set(key,value)";
Microservices:
Architecture qui n'offre pas que des avantage
Pro: Scalability/Testing/Faster Deployment/Library conflicts
Con:
-Use Initializr or STS Plugin which are only REST Clients to Initializr
-Create a project for Eureka itself using Spring Initializr with a "Netflix-
Eureka-Server" dependency
-Annotate the main bootstrap class with @EnableEurekaServer
-Add a "Netflix-Eureka-Client" dependency in each Microservice
Service registry using Spring-Cloud-Netflix's Eureka
-Registere Service instances by name(Spring.application.name property)
with Eureka
-Some other Service request a Service by name and is given a list of
Service instances
-Use client-side load-balancing, like Netflix-Ribbon which
chooses an instance.
-Consume services using REST
Circuit breaker pattern to make services more resilient to failure
-Deploy as JAR to Iaas "AWS-ECS" Docker
-Use Spotify-Dockerfile-Plugin in Maven to create an Image for our JAR
$ mvnw package dockerfile:build
-Deploy as JAR to Paas "Cloud Foundry"
cf login pivotal-address
 cf push service-name -p /target/service-name.jar
-You can even Depl