Datasets:

h1alexbel

/

github-readmes

like 1

dapr/quickstarts

Dapr quickstart code samples and tutorials showcasing core Dapr capabilities

2019-09-19T17:48:03Z

# Dapr Quickstarts and Tutorials [](https://github.com/dapr/quickstarts/actions?workflow=samples) [](https://discord.com/channels/778680217417809931/778680217417809934) [](https://www.apache.org/licenses/LICENSE-2.0) If you are new to Dapr and haven't done so already, it is recommended you go through the Dapr [Getting Started](https://docs.dapr.io/getting-started/install-dapr-cli/) instructions. ### Quickstarts Pick a building block API (for example, PubSub, state management, etc) and rapidly try it out in your favorite language SDK (recommended), or via HTTP. Visit the [Dapr Docs Quickstarts Guide](https://docs.dapr.io/getting-started/quickstarts/) for a comprehensive walkthrough of each example. | Dapr Quickstart | Description | |:--------:|:--------:| | [Publish and Subscribe](./pub_sub) | Asynchronous communication between two services using messaging | | [Service Invocation](./service_invocation) | Synchronous communication between two services using HTTP | | [State Management](./state_management/) | Store a service's data as key/value pairs in supported state stores | | [Bindings](./bindings/) | Work with external systems using input bindings to respond to events and output bindings to call operations | | [Secrets Management](./secrets_management/) | Securely fetch secrets | | [Actors](./actors) | Create stateful, long running objects with identity | | [Configuration](./configuration) | Get configuration items as key/value pairs or subscribe to changes whenever a configuration item changes | | [Cryptography](./cryptography) | Perform cryptographic operations without exposing keys to your application | | [Resiliency](./resiliency) | Define and apply fault-tolerant policies (retries/back-offs, timeouts and circuit breakers) to your Dapr API requests | | [Workflow](./workflows) | Dapr Workflow enables you to create long running, fault-tolerant, stateful applications | ### Tutorials Go deeper into a topic or scenario, oftentimes using building block APIs together to solve problems (for example, build a distributed calculator, build and deploy an app to Kubernetes). | Tutorials | Description | |------|------| | [Hello-world](./tutorials/hello-world) | Demonstrates how to run Dapr locally. Highlights service invocation and state management. | | [Hello-kubernetes](./tutorials/hello-kubernetes) | Demonstrates how to run Dapr in Kubernetes. Highlights service invocation and state management. | | [Distributed-calculator](./tutorials/distributed-calculator) | Demonstrates a distributed calculator application that uses Dapr services to power a React web app. Highlights polyglot (multi-language) programming, service invocation and state management. | | [Pub-sub](./tutorials/pub-sub) | Demonstrates how to use Dapr to enable pub-sub applications. Uses Redis as a pub-sub component. | | [Bindings](./tutorials/bindings) | Demonstrates how to use Dapr to create input and output bindings to other components. Uses bindings to Kafka.| | [Observability](./tutorials/observability) | Demonstrates Dapr tracing capabilities. Uses Zipkin as a tracing component. | | [Secret Store](./tutorials/secretstore) | Demonstrates the use of Dapr Secrets API to access secret stores. | ## Code of Conduct Please refer to our [Dapr Community Code of Conduct](https://github.com/dapr/community/blob/master/CODE-OF-CONDUCT.md)

okta/samples-java-spring

Spring Boot samples

2017-01-24T18:13:08Z

# Spring Security OAuth Sample Applications for Okta This repository contains several sample applications that show you how to integrate various Okta use-cases into your Java application that uses the Spring framework. Note: Samples would need minimum JDK 17 or above. Please find the sample that fits your use-case from the table below. | Sample | Description | Use-Case | |--------|-------------|----------| | [Okta-Hosted Login](/okta-hosted-login) | An application server that uses the hosted login page on your Okta org, then creates a cookie session for the user in the Spring application. | Traditional web applications with server-side rendered pages. | | [Custom Login Page](/custom-login) | An application server that uses the Okta Sign-In Widget on a custom login page within the application, then creates a cookie session for the user in the Spring application. | Traditional web applications with a custom login page and server-side rendered pages. | | [Resource Server](/resource-server) | This is a sample API resource server that shows you how to authenticate requests with access tokens that have been issued by Okta. | Single-Page applications. | | [Front End](/front-end) (bonus) | A simple static Single-Page application that can be used with the resource-server | Test the above resource server |

corda/samples-java

This repository contains multiple sample apps, from CorDapps that help you get started, all the way to demonstrating specific features and advanced usage.

2020-04-01T16:42:39Z

# CorDapp Samples - Java <p align="center"> <img src="https://www.corda.net/wp-content/uploads/2016/11/fg005_corda_b.png" alt="Corda" width="500"> </p> ## Introduction This repository contains multiple sample apps, from CorDapps that help you get started, all the way to demonstrating specific features and advanced usage. If you are new to Corda and/or would like to learn all of the fundamentals in a guided and incremental manner please visit the Corda [documentation](https://docs.r3.com/) site. To get started explore the [Basic](./Basic) folder, or navigate to the [Advanced](./Advanced) and [Features](./Features) folders to see a description of whats available. You can find the exact same set of CorDapp demonstration in Kotlin language at [link](https://github.com/corda/samples-kotlin). ## Directories The samples are divided into 5 sections with the following desciption: * [Accounts](./Accounts): These samples showcases how to utilize Corda Accounts Libray to build CorDapps which aim to have massive user volume * [Advanced](./Advanced): In these samples, we demonstrate more complex and sophisticated features of Corda. * [Basic](./Basic): They demonstrate fundamental and useful techniques for CorDapp development. * [BusinessNetworks](./BusinessNetworks): These include Business Network Extension related samples. Learn more at [bn-extension](https://github.com/corda/bn-extension). * [Features](./Features): These samples demonstrate specific Corda functionalities. * [Tokens](./Tokens): These include TokenSDK related samples. Learn more at TokenSDK.

JetBrains/intellij-samples

Code that demonstrates various IntelliJ IDEA features

2012-04-04T16:28:08Z

[](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub) # IntelliJ IDEA Samples for Tips and Tricks, Features, etc. This repository contains code that demonstrates IntelliJIDEA features. The classes and methods are largely named after the functionality that they're supposed to demonstrate. This code can be updated or added to as features in IntelliJ IDEA are added or updated. A large number of the features are demoed in this presentation: https://youtu.be/9AMcN-wkspU The code has been used in a number of shorter tip videos: http://youtube.com/Intellijidea These examples currently show features all the way up to IntelliJ IDEA 2020.1, and Java 15. There are also some basic samples for Spring and for Web/JavaScript features. See also: https://github.com/trishagee/groovy-samples

EventStore/samples

Samples showing practical aspect of EventStoreDB, Event Sourcing

2021-05-27T13:28:09Z

# EventStoreDB samples [EventStoreDB](https://www.eventstore.com/) is an industrial-strength database technology used for event-sourcing. It is open source and runs on most platforms or as SaaS in [Event Store Cloud](https://www.eventstore.com/event-store-cloud). This repository provides practical samples that demonstrate features of [EventStoreDB](https://www.eventstore.com/) and its client SDKs. Common operations and samples are in the [client repositories](https://github.com/EventStore?q=EventStore+Client) ## Contributing Feel free to [create a GitHub issue](https://github.com/EventStore/samples/issues/new) if you have any questions or request for more explanation or samples. We're open to any contribution! If you noticed some inconsistency, missing piece, or you'd like to extend existing samples - we're happy to [get your Pull Request](https://github.com/EventStore/samples/compare). Read more in the [Contribution Guidelines](./CONTRIBUTING.md) ## Samples Samples are organized by topics in dedicated directories by programming languages/environments. ### Quickstart Quickstart guides have been created that show you how to stand up a sample Hello World application that appends to and reads from a stream in EventStoreDB. Find the sample for your preferred client language below: - .NET: [ASP.NET Core sample](/Quickstart/Dotnet/esdb-sample-dotnet) - Go: [Gin sample](/Quickstart/Go/esdb-sample-go) - Java: [Spring Boot sample](Quickstart/Java/esdb-sample-springboot) - Node.js: [Express.js sample](/Quickstart/Nodejs/esdb-sample-nodejs) - Python: [Flask sample](/Quickstart/Python/esdb-sample-python) - Rust: [Rocket sample](/Quickstart/Rust/esdb-sample-rust) ### **[CQRS flow](./CQRS_Flow/)** - [.NET](./CQRS_Flow/Dotnet/) **Description**: - Demonstrates typical event sourcing with CQRS flow - Stores events in EventStoreDB - Shows how to handle the write model and read model - Builds read models using [Subscription to `$all`](https://developers.eventstore.com/clients/grpc/subscribing-to-streams/#subscribing-to-all) - Shows how to store read models as ElasticSearch documents - Shows how to write unit and integration tests - [Java](./CQRS_Flow/Java/) **Description**: - Demonstrates typical event sourcing with CQRS flow - Stores events in EventStoreDB - Shows how to handle the write model and read model - Builds read models using [Subscription to `$all`](https://developers.eventstore.com/clients/grpc/subscribing-to-streams/#subscribing-to-all) - Shows how to store read models as Postgres documents - Shows how to write unit and integration tests The examples show 2 variations of handling business logic: - [Aggregate pattern](./CQRS_Flow/Java/event-sourcing-esdb-aggregates) - [Command handlers as pure functions](./CQRS_Flow/Java/event-sourcing-esdb-simple) ### **[Crypto Shredding](./Crypto_Shredding/)** - [.NET](./Crypto_Shredding/Dotnet/) **Description**: - Shows how to protect sensitive data (e.g. for [European General Data Protection Regulation](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation)) in Event-Sourced Systems. - Shows how to use the .NET `System.Security.Cryptography` library with [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) algorithm to encrypt and decrypt events' data. - Stores events in EventStoreDB ### **[Sending EventStoreDB logs to Elasticsearch](./Logging/Elastic/)** **Description** These samples show how to configure various ways of sending logs from EventStoreDB to Elasticsearch: - [Logstash](./Logging/Elastic/Logstash/), - [Filebeat](./Logging/Elastic/Filebeat/), - [FilebeatWithLogstash](./Logging/Elastic/FilebeatWithLogstash/) ## Running samples locally Check the `README.md` file in the specific sample folder for detailed instructions. ## Support Information on EventStoreDB support: https://eventstore.com/support/. EventStoreDB Documentation: https://developers.eventstore.com/

gradescope/autograder_samples

Examples of autograders for running on Gradescope

2016-02-25T19:59:10Z

docs/README.md

lenve/oauth2-samples

2020-04-13T01:47:50Z

# oauth2-samples ### 跟着松哥学 Spring Cloud Security OAuth2 扫码加微信（微信ID：**a_java_boy2**），备注 OAuth2，进群讨论。  #### 本仓库所有 Demo 都有配套文章 |Demo|文章| |:---|:---| |authorization_code|[这个案例写出来，还怕跟面试官扯不明白 OAuth2 登录流程？](https://mp.weixin.qq.com/s/GXMQI59U6uzmS-C0WQ5iUw)| |client_credentials|[死磕 OAuth2，教练我要学全套的！](https://mp.weixin.qq.com/s/33Oxu6YMjwco3WRE07_IiQ)| |implicit|[死磕 OAuth2，教练我要学全套的！](https://mp.weixin.qq.com/s/33Oxu6YMjwco3WRE07_IiQ)| |password|[死磕 OAuth2，教练我要学全套的！](https://mp.weixin.qq.com/s/33Oxu6YMjwco3WRE07_IiQ)| |authorization_code_redis|[OAuth2 令牌还能存入 Redis ？越玩越溜！](https://mp.weixin.qq.com/s/cGopy8hDPtkn8Q7HUYabbA)| |jwt|[想让 OAuth2 和 JWT 在一起愉快玩耍？请看松哥的表演](https://mp.weixin.qq.com/s/xEIWTduDqQuGL7lfiP735w)| |oauth2-sso|[Spring Boot+OAuth2，一个注解搞定单点登录！](https://mp.weixin.qq.com/s/EyAMTbKPqNNnEtZACIsMVw)| |github_login|[分分钟让自己的网站接入 GitHub 第三方登录功能](https://mp.weixin.qq.com/s/tq4Q306J3hJFEtGL1EpOBA)| ### 案例配套视频（付费） 链接:https://pan.baidu.com/s/184jGNKlrDYkdqRS8igYL_Q 密码:1tgf 付费视频介绍：[Spring Boot + Vue 系列视频教程](https://mp.weixin.qq.com/s/1k4CZ6_re11fQM_6_00jCw)

agoncal/agoncal-sample-cdi

Samples about CDI

2012-10-17T22:09:56Z

# Samples - CDI Several samples about EJBs : * 01-Bootstrapping : Bootstrap CDI in several environments * 02-JavaEE6 : Differences between Java EE inection (@Resource…) and CDI @Inject * 03-Injection : CDI injection with qualifiers * 04-Injection : Different injection points (attributes, setter, constructor) * 05-Producers : CDI producers # Licensing <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-sa/3.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/">Creative Commons Attribution-ShareAlike 3.0 Unported License</a>. <div class="footer"> <span class="footerTitle"><span class="uc">a</span>ntonio <span class="uc">g</span>oncalves</span> </div>

roghughe/captaindebug

Samples from Captain Debug's Blog

2011-09-20T11:49:34Z

octo-technology/RoboSpice-samples

All samples of the RoboSpice library.

2012-12-31T14:54:16Z

# RoboSpice-samples All samples of the RoboSpice library. ## Convert samples to Ant projects ```bash #go to the sample of your choice. cd samples/robospice-sample-core #1. create ant files for current project android update project -p . #2. use maven to copy dependencies to the libs-for-ant folder mvn clean install -Pant #3. move all maven dependencies to the libs folder for ant mv libs-for-ant libs #build the project with ant ant clean debug install ``` your project is now ant-ready, the libs folder contains all needed dependencies to add robospice and extensions modules to your project. This method works for every sample project. Once you got all the needed jar files, you can move them to your own projects. **Note** : you will need to define the `ANDROID_HOME` environment variable to point to you android SDK home folder for maven to work.

gupaoedu-tom/design-samples

《设计模式就该这样学，基于经典框架源码和真实业务场景》随书代码示例工程

2020-03-10T08:56:53Z

# 《设计模式就该这样学，基于经典框架源码和真实业务场景》 ### 已全面开启预售！！！ ### 京东购买链接：[https://item.jd.com/12699413.html](https://item.jd.com/12699413.html) ### 当当购买链接：[http://product.dangdang.com/28994943.html](http://product.dangdang.com/28994943.html) Design Patterns: Elements of Reusable Object-Oriented Software（以下简称《设计模式》），一书由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides合著（Addison-Wesley，1995）。这四位作者常被称为“四人组（Gang of Four）”，而这本书也就被称为“四人组（或 GoF）”书。他们首次给我们总结出一套软件开发可以反复使用的经验，帮助我们提高代码的可重用性、系统的可维护性等，解决软件开发中的复杂问题。 设计模式已诞生20多年，其间相继出版的关于设计模式的经典著作不计其数。如果说GoF的《设计模式》是设计模式领域的“圣经”，那么之后出版的各种关于设计模式的书籍可称为“圣经”的“批注版”或者“白话版”。本书正是基于GoF的《设计模式》来编写的。 本书可以作为笔者对“圣经”实践的精华总结，是一本可以真正能够落地的“设计模式”之书，也是目前唯一一本结合框架源码如何落地“设计模式”这个角度来理解设计模式的书。本书会结合JDK、Spring、MyBatis、Tomcat、Netty等经典框架源码展开对设计模式的分析。当然，本书还会结合笔者多年的“踩坑填坑”经验和“教学答疑”经验，用比“圣经”更深刻、更全面、更通俗、更生动、更有趣、更接地气的方式并且结合真实的业务场景来分析每种设计模式的优缺点，治愈“设计模式选择困难症”。选择设计模式时就像相亲选对象，一旦做好了接受TA缺点的准备，那TA就一定属于你。所以，本书对于日常开发而言更具有指导意义。 书中部分观点若有不妥之处，恳请纠正，共同进步！ # 关于我 ### 为什么都叫我“文艺汤”？ 我自幼爱好书法和美术，长了一双能书会画的手，而且手指又长又白，因此以前的艺名叫“玉手藝人”。中学期间，曾获市级书法竞赛一等奖，校园美术竞赛一等奖，校园征文比赛二等奖。担任过学生会宣传部长，负责校园黑板报，校园刊物的编辑、排版和设计。 2008年参加工作后，我做过家具建模、平面设计等工作，亲自设计了咕泡学院的 Logo。做讲师之后，我给自己起了一个跟姓氏谐音的英文名字“Tom”，江湖人称“编程界写字写得最好的、书法界编程最牛的文艺汤”。 ### 我的技术生涯 我的 IT 技术生涯应该算是从 2009 年开始的，在此之前做过 UI 设计，做过前端网页，到2009年才真正开始参与Java后台开发。在这里要感谢所有帮助我入门编程的同事和老师。从2010年至2014年担任过项目组长、项目经理、架构师、技术总监，对很多的开源框架建立了自己的独特见解。我会习惯性地用形象思维来理解抽象世界。譬如：看到二进制数 0 和 1，我会想到《周易》中的两仪——阴和阳；看到颜色值用 RGB 表示，我会想到美术理论中的太阳光折射三原色；下班回家看到炒菜流程，我会想到模板方法模式；坐公交车看到学生卡、老人卡、爱心卡，我会想到策略模式；等等。大家看到的这本书，很多地方都融入了这种形象思维。 ### 众多图书之下为什么写此书？ 首先，自《Spring 5核心原理与30个类手写实战》和《Netty 4核心原理与手写RPC框架实战》出版以来，各位“汤粉”给我带来了非常多惊喜。这些惊喜给我带来的不仅仅是个人名誉，更多的是一种更大的社会责任。非常感谢各位“汤粉”的大力支持和认可，大家也非常喜欢我的“形象思维”。 其次，我传播知识的宗旨是：将抽象的知识形象化，将枯燥的知识趣味化，将难懂的知识通俗化。而设计模式又是大家公认的最为枯燥的知识，也是很难落地的。这一次，我将压箱底多年的干货都掏空，以此奉献社会，回馈社会。我总结多年实战经验，并结合经典框架源码分析设计模式，让设计模式真正能够为我所用，真正可以用来解决实际问题。 最后，再次感谢各位“汤粉”的支持，感谢为本书手稿提出宝贵修改意见的学员，也感谢电子社责任编辑董英团队的辛勤付出。 # 技术交流  ### 推荐《[Spring 5核心原理与30个类手写实战](https://github.com/gupaoedu-tom/spring5-samples)》，4个月销量破万，连续占据畅销榜。 ### 推荐《[Netty 4核心原理与手写RPC框架实战](https://github.com/gupaoedu-tom/netty4-samples)》，上架3个月，销量突破10000册。

ibm-messaging/event-streams-samples

2015-10-13T17:50:25Z

# event-streams-samples IBM Event Streams for IBM Cloud is a scalable, distributed, high throughput message bus to unite your on-premise and off-premise cloud technologies. You can wire micro-services together using open protocols, connect stream data to analytics to realize powerful insight and feed event data to multiple applications to react in real time. This repository is for samples which interact with the Event Streams for IBM Cloud service. Currently, there are samples for the Kafka and MQ Light APIs. Information and instructions regarding the use of these samples can be found in their respective directories. ## Aim of the Samples The aim of the samples is to help you get started with Event Streams for IBM Cloud within minutes. They are not production-ready applications but should give you useful pointers at how to build, package and deploy applications as well as how to make basic API calls against us with error handling. We did all the heavy lifting so you can focus on developing exciting code with value! ## Provisioning your Event Streams for IBM Cloud Cluster In order to provision an Event Streams for IBM Cloud cluster, please visit the [IBM Cloud® catalog](https://cloud.ibm.com/catalog/). Please also familiarise yourself with Event Streams for IBM Cloud and Apache Kafka basics and terminology. [Our documentation](https://cloud.ibm.com/docs/services/EventStreams?topic=eventstreams-getting_started) is a good starting point. ### Pricing plans IBM Event Streams can be provisioned on IBM Cloud® in various pricing plans. Please refer to our [documentation](https://cloud.ibm.com/docs/services/EventStreams?topic=eventstreams-plan_choose#plan_choose) to help choose a plan that works for you. __Important Note__: Provisioning an Event Streams service in IBM Cloud® incurs a fee. Please review pricing before provisioning. The samples in this repository will create topic(s) on your behalf - creating a topic might also incur a fee. For more information, please consult the IBM Cloud® documentation if necessary. ## Connecting to your Event Streams for IBM Cloud Cluster In each sample, we demonstrate a single connection path for our Standard/Enterprise plans respectively. The aim was to get you started quickly. However your client's needs might be different. Therefore we wrote a [guide](https://cloud.ibm.com/docs/services/EventStreams?topic=eventstreams-connecting#connecting) that discusses credential generation in detail and showing you all possible ways of doing this. ## Our APIs and Sample Applications ### Kafka API (recommended): * [kafka-java-console-sample](/kafka-java-console-sample/README.md) : Sample Java console application using the Event Streams for IBM Cloud Kafka API * [kafka-java-liberty-sample](/kafka-java-liberty-sample/README.md) : Sample IBM Websphere Liberty profile application using the Event Streams for IBM Cloud Kafka API * [kafka-nodejs-console-sample](kafka-nodejs-console-sample/README.md) : Sample Node.js console application using the Event Streams for IBM Cloud Kafka API * [kafka-python-console-sample](/kafka-python-console-sample/README.md) : Sample Python console application using the Event Streams for IBM Cloud Kafka API * [kafka-connect](/kafka-connect/README.md) : Sample Docker image with Kafka Connect * [kafka-mirrormaker](/kafka-mirrormaker/README.md) : Sample Docker image with Kafka Mirror Maker ### Spring Kafka: * [spring kafka tutorial](https://developer.ibm.com/tutorials/use-spring-kafka-to-access-an-event-streams-service/) : Tutorial to quickly get you up and running using IBM Event Streams. * [spring-kafka](https://github.com/wkorando/event-stream-kafka) : Sample app to connect to Event Streams using Spring Kafka ### Utilities: * [kafka-topic-stats](/kafka-topic-stats/README.md): Utility for displaying Kafka topic usage and configuration. ## Get Further Assistance If you have any issues, just ask us a question (tagged with `ibm-eventstreams`) on [StackOverflow.com](http://stackoverflow.com/questions/tagged/ibm-eventstreams). For more information regarding IBM Event Streams for IBM Cloud, [view the documentation on IBM Cloud](https://cloud.ibm.com/docs/services/EventStreams?topic=eventstreams-getting_started).

FirebaseExtended/custom-auth-samples

Samples showcasing how to sign in Firebase using additional Identity Providers

2016-10-04T20:16:23Z

# Samples: Sign In Firebase with additional auth providers using Custom auth tokens This repo contains samples that demonstrate how to use Custom auth tokens to Sign In Firebase with Identity Providers other than the ones with build-in support (Google, Facebook, Twitter and GitHub). We currently have the following samples: - [Instagram](instagram) for Web - [LINE Login](Line) for iOS & Android - [Kakao Login](kakao) for iOS & Android You can find [additional examples for Web](https://github.com/firebase/functions-samples#authorize-with-linkedin-spotify-instagram-line-or-basic-auth) in another repository. ## Status  This sample is no longer actively maintained and is left here for reference only. ## Contributing We'd love that you contribute to the project. Before doing so please read our [Contributor guide](CONTRIBUTING.md). ## License © Google, 2016. Licensed under an [Apache-2](LICENSE) license.

spring-projects/spring-ws-samples

2013-11-07T11:32:34Z

gmazza/blog-samples

Source code for the tutorials on my blog.

2012-05-05T21:01:38Z

blog-samples ============ This download holds the source code for tutorials in my blog listed at https://glenmazza.net/blog/entry/blog-index. Use at own risk. :)

burrsutter/9stepsawesome

The exercises/samples repo for bit.ly/9stepsawesome presentation

2018-07-29T20:16:34Z

spring-guides/getting-started-guides

Getting Started Guide template :: The template for new guides and also the place to request them.

2013-10-28T20:59:08Z

winterbe/java8-tutorial

Modern Java - A Guide to Java 8

2014-03-16T17:25:43Z

# Modern Java - A Guide to Java 8 _This article was originally posted on [my blog](http://winterbe.com/posts/2014/03/16/java-8-tutorial/)._ > **You should also read my [Java 11 Tutorial](https://winterbe.com/posts/2018/09/24/java-11-tutorial/) (including new language and API features from Java 9, 10 and 11).** Welcome to my introduction to [Java 8](https://jdk8.java.net/). This tutorial guides you step by step through all new language features. Backed by short and simple code samples you'll learn how to use default interface methods, lambda expressions, method references and repeatable annotations. At the end of the article you'll be familiar with the most recent [API](http://download.java.net/jdk8/docs/api/) changes like streams, functional interfaces, map extensions and the new Date API. **No walls of text, just a bunch of commented code snippets. Enjoy!** --- <p align="center"> ★★★ Like this project? Leave a star, <a href="https://twitter.com/winterbe_">follow on Twitter</a> or <a href="https://www.paypal.me/winterbe">donate</a> to support my work. Thanks! ★★★ </p> --- ## Table of Contents * [Default Methods for Interfaces](#default-methods-for-interfaces) * [Lambda expressions](#lambda-expressions) * [Functional Interfaces](#functional-interfaces) * [Method and Constructor References](#method-and-constructor-references) * [Lambda Scopes](#lambda-scopes) * [Accessing local variables](#accessing-local-variables) * [Accessing fields and static variables](#accessing-fields-and-static-variables) * [Accessing Default Interface Methods](#accessing-default-interface-methods) * [Built-in Functional Interfaces](#built-in-functional-interfaces) * [Predicates](#predicates) * [Functions](#functions) * [Suppliers](#suppliers) * [Consumers](#consumers) * [Comparators](#comparators) * [Optionals](#optionals) * [Streams](#streams) * [Filter](#filter) * [Sorted](#sorted) * [Map](#map) * [Match](#match) * [Count](#count) * [Reduce](#reduce) * [Parallel Streams](#parallel-streams) * [Sequential Sort](#sequential-sort) * [Parallel Sort](#parallel-sort) * [Maps](#maps) * [Date API](#date-api) * [Clock](#clock) * [Timezones](#timezones) * [LocalTime](#localtime) * [LocalDate](#localdate) * [LocalDateTime](#localdatetime) * [Annotations](#annotations) * [Where to go from here?](#where-to-go-from-here) ## Default Methods for Interfaces Java 8 enables us to add non-abstract method implementations to interfaces by utilizing the `default` keyword. This feature is also known as [virtual extension methods](http://stackoverflow.com/a/24102730). Here is our first example: ```java interface Formula { double calculate(int a); default double sqrt(int a) { return Math.sqrt(a); } } ``` Besides the abstract method `calculate` the interface `Formula` also defines the default method `sqrt`. Concrete classes only have to implement the abstract method `calculate`. The default method `sqrt` can be used out of the box. ```java Formula formula = new Formula() { @Override public double calculate(int a) { return sqrt(a * 100); } }; formula.calculate(100); // 100.0 formula.sqrt(16); // 4.0 ``` The formula is implemented as an anonymous object. The code is quite verbose: 6 lines of code for such a simple calculation of `sqrt(a * 100)`. As we'll see in the next section, there's a much nicer way of implementing single method objects in Java 8. ## Lambda expressions Let's start with a simple example of how to sort a list of strings in prior versions of Java: ```java List<String> names = Arrays.asList("peter", "anna", "mike", "xenia"); Collections.sort(names, new Comparator<String>() { @Override public int compare(String a, String b) { return b.compareTo(a); } }); ``` The static utility method `Collections.sort` accepts a list and a comparator in order to sort the elements of the given list. You often find yourself creating anonymous comparators and pass them to the sort method. Instead of creating anonymous objects all day long, Java 8 comes with a much shorter syntax, **lambda expressions**: ```java Collections.sort(names, (String a, String b) -> { return b.compareTo(a); }); ``` As you can see the code is much shorter and easier to read. But it gets even shorter: ```java Collections.sort(names, (String a, String b) -> b.compareTo(a)); ``` For one line method bodies you can skip both the braces `{}` and the `return` keyword. But it gets even shorter: ```java names.sort((a, b) -> b.compareTo(a)); ``` List now has a `sort` method. Also the java compiler is aware of the parameter types so you can skip them as well. Let's dive deeper into how lambda expressions can be used in the wild. ## Functional Interfaces How does lambda expressions fit into Java's type system? Each lambda corresponds to a given type, specified by an interface. A so called _functional interface_ must contain **exactly one abstract method** declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface. We can use arbitrary interfaces as lambda expressions as long as the interface only contains one abstract method. To ensure that your interface meet the requirements, you should add the `@FunctionalInterface` annotation. The compiler is aware of this annotation and throws a compiler error as soon as you try to add a second abstract method declaration to the interface. Example: ```java @FunctionalInterface interface Converter<F, T> { T convert(F from); } ``` ```java Converter<String, Integer> converter = (from) -> Integer.valueOf(from); Integer converted = converter.convert("123"); System.out.println(converted); // 123 ``` Keep in mind that the code is also valid if the `@FunctionalInterface` annotation would be omitted. ## Method and Constructor References The above example code can be further simplified by utilizing static method references: ```java Converter<String, Integer> converter = Integer::valueOf; Integer converted = converter.convert("123"); System.out.println(converted); // 123 ``` Java 8 enables you to pass references of methods or constructors via the `::` keyword. The above example shows how to reference a static method. But we can also reference object methods: ```java class Something { String startsWith(String s) { return String.valueOf(s.charAt(0)); } } ``` ```java Something something = new Something(); Converter<String, String> converter = something::startsWith; String converted = converter.convert("Java"); System.out.println(converted); // "J" ``` Let's see how the `::` keyword works for constructors. First we define an example class with different constructors: ```java class Person { String firstName; String lastName; Person() {} Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } } ``` Next we specify a person factory interface to be used for creating new persons: ```java interface PersonFactory<P extends Person> { P create(String firstName, String lastName); } ``` Instead of implementing the factory manually, we glue everything together via constructor references: ```java PersonFactory<Person> personFactory = Person::new; Person person = personFactory.create("Peter", "Parker"); ``` We create a reference to the Person constructor via `Person::new`. The Java compiler automatically chooses the right constructor by matching the signature of `PersonFactory.create`. ## Lambda Scopes Accessing outer scope variables from lambda expressions is very similar to anonymous objects. You can access final variables from the local outer scope as well as instance fields and static variables. ### Accessing local variables We can read final local variables from the outer scope of lambda expressions: ```java final int num = 1; Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3 ``` But different to anonymous objects the variable `num` does not have to be declared final. This code is also valid: ```java int num = 1; Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3 ``` However `num` must be implicitly final for the code to compile. The following code does **not** compile: ```java int num = 1; Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num); num = 3; ``` Writing to `num` from within the lambda expression is also prohibited. ### Accessing fields and static variables In contrast to local variables, we have both read and write access to instance fields and static variables from within lambda expressions. This behaviour is well known from anonymous objects. ```java class Lambda4 { static int outerStaticNum; int outerNum; void testScopes() { Converter<Integer, String> stringConverter1 = (from) -> { outerNum = 23; return String.valueOf(from); }; Converter<Integer, String> stringConverter2 = (from) -> { outerStaticNum = 72; return String.valueOf(from); }; } } ``` ### Accessing Default Interface Methods Remember the formula example from the first section? Interface `Formula` defines a default method `sqrt` which can be accessed from each formula instance including anonymous objects. This does not work with lambda expressions. Default methods **cannot** be accessed from within lambda expressions. The following code does not compile: ```java Formula formula = (a) -> sqrt(a * 100); ``` ## Built-in Functional Interfaces The JDK 1.8 API contains many built-in functional interfaces. Some of them are well known from older versions of Java like `Comparator` or `Runnable`. Those existing interfaces are extended to enable Lambda support via the `@FunctionalInterface` annotation. But the Java 8 API is also full of new functional interfaces to make your life easier. Some of those new interfaces are well known from the [Google Guava](https://code.google.com/p/guava-libraries/) library. Even if you're familiar with this library you should keep a close eye on how those interfaces are extended by some useful method extensions. ### Predicates Predicates are boolean-valued functions of one argument. The interface contains various default methods for composing predicates to complex logical terms (and, or, negate) ```java Predicate<String> predicate = (s) -> s.length() > 0; predicate.test("foo"); // true predicate.negate().test("foo"); // false Predicate<Boolean> nonNull = Objects::nonNull; Predicate<Boolean> isNull = Objects::isNull; Predicate<String> isEmpty = String::isEmpty; Predicate<String> isNotEmpty = isEmpty.negate(); ``` ### Functions Functions accept one argument and produce a result. Default methods can be used to chain multiple functions together (compose, andThen). ```java Function<String, Integer> toInteger = Integer::valueOf; Function<String, String> backToString = toInteger.andThen(String::valueOf); backToString.apply("123"); // "123" ``` ### Suppliers Suppliers produce a result of a given generic type. Unlike Functions, Suppliers don't accept arguments. ```java Supplier<Person> personSupplier = Person::new; personSupplier.get(); // new Person ``` ### Consumers Consumers represent operations to be performed on a single input argument. ```java Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName); greeter.accept(new Person("Luke", "Skywalker")); ``` ### Comparators Comparators are well known from older versions of Java. Java 8 adds various default methods to the interface. ```java Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); Person p1 = new Person("John", "Doe"); Person p2 = new Person("Alice", "Wonderland"); comparator.compare(p1, p2); // > 0 comparator.reversed().compare(p1, p2); // < 0 ``` ## Optionals Optionals are not functional interfaces, but nifty utilities to prevent `NullPointerException`. It's an important concept for the next section, so let's have a quick look at how Optionals work. Optional is a simple container for a value which may be null or non-null. Think of a method which may return a non-null result but sometimes return nothing. Instead of returning `null` you return an `Optional` in Java 8. ```java Optional<String> optional = Optional.of("bam"); optional.isPresent(); // true optional.get(); // "bam" optional.orElse("fallback"); // "bam" optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b" ``` ## Streams A `java.util.Stream` represents a sequence of elements on which one or more operations can be performed. Stream operations are either _intermediate_ or _terminal_. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Streams are created on a source, e.g. a `java.util.Collection` like lists or sets (maps are not supported). Stream operations can either be executed sequentially or parallely. > Streams are extremely powerful, so I wrote a separate [Java 8 Streams Tutorial](http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/). **You should also check out [Sequency](https://github.com/winterbe/sequency) as a similiar library for the web.** Let's first look how sequential streams work. First we create a sample source in form of a list of strings: ```java List<String> stringCollection = new ArrayList<>(); stringCollection.add("ddd2"); stringCollection.add("aaa2"); stringCollection.add("bbb1"); stringCollection.add("aaa1"); stringCollection.add("bbb3"); stringCollection.add("ccc"); stringCollection.add("bbb2"); stringCollection.add("ddd1"); ``` Collections in Java 8 are extended so you can simply create streams either by calling `Collection.stream()` or `Collection.parallelStream()`. The following sections explain the most common stream operations. ### Filter Filter accepts a predicate to filter all elements of the stream. This operation is _intermediate_ which enables us to call another stream operation (`forEach`) on the result. ForEach accepts a consumer to be executed for each element in the filtered stream. ForEach is a terminal operation. It's `void`, so we cannot call another stream operation. ```java stringCollection .stream() .filter((s) -> s.startsWith("a")) .forEach(System.out::println); // "aaa2", "aaa1" ``` ### Sorted Sorted is an _intermediate_ operation which returns a sorted view of the stream. The elements are sorted in natural order unless you pass a custom `Comparator`. ```java stringCollection .stream() .sorted() .filter((s) -> s.startsWith("a")) .forEach(System.out::println); // "aaa1", "aaa2" ``` Keep in mind that `sorted` does only create a sorted view of the stream without manipulating the ordering of the backed collection. The ordering of `stringCollection` is untouched: ```java System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1 ``` ### Map The _intermediate_ operation `map` converts each element into another object via the given function. The following example converts each string into an upper-cased string. But you can also use `map` to transform each object into another type. The generic type of the resulting stream depends on the generic type of the function you pass to `map`. ```java stringCollection .stream() .map(String::toUpperCase) .sorted((a, b) -> b.compareTo(a)) .forEach(System.out::println); // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1" ``` ### Match Various matching operations can be used to check whether a certain predicate matches the stream. All of those operations are _terminal_ and return a boolean result. ```java boolean anyStartsWithA = stringCollection .stream() .anyMatch((s) -> s.startsWith("a")); System.out.println(anyStartsWithA); // true boolean allStartsWithA = stringCollection .stream() .allMatch((s) -> s.startsWith("a")); System.out.println(allStartsWithA); // false boolean noneStartsWithZ = stringCollection .stream() .noneMatch((s) -> s.startsWith("z")); System.out.println(noneStartsWithZ); // true ``` #### Count Count is a _terminal_ operation returning the number of elements in the stream as a `long`. ```java long startsWithB = stringCollection .stream() .filter((s) -> s.startsWith("b")) .count(); System.out.println(startsWithB); // 3 ``` ### Reduce This _terminal_ operation performs a reduction on the elements of the stream with the given function. The result is an `Optional` holding the reduced value. ```java Optional<String> reduced = stringCollection .stream() .sorted() .reduce((s1, s2) -> s1 + "#" + s2); reduced.ifPresent(System.out::println); // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2" ``` ## Parallel Streams As mentioned above streams can be either sequential or parallel. Operations on sequential streams are performed on a single thread while operations on parallel streams are performed concurrently on multiple threads. The following example demonstrates how easy it is to increase the performance by using parallel streams. First we create a large list of unique elements: ```java int max = 1000000; List<String> values = new ArrayList<>(max); for (int i = 0; i < max; i++) { UUID uuid = UUID.randomUUID(); values.add(uuid.toString()); } ``` Now we measure the time it takes to sort a stream of this collection. ### Sequential Sort ```java long t0 = System.nanoTime(); long count = values.stream().sorted().count(); System.out.println(count); long t1 = System.nanoTime(); long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); System.out.println(String.format("sequential sort took: %d ms", millis)); // sequential sort took: 899 ms ``` ### Parallel Sort ```java long t0 = System.nanoTime(); long count = values.parallelStream().sorted().count(); System.out.println(count); long t1 = System.nanoTime(); long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); System.out.println(String.format("parallel sort took: %d ms", millis)); // parallel sort took: 472 ms ``` As you can see both code snippets are almost identical but the parallel sort is roughly 50% faster. All you have to do is change `stream()` to `parallelStream()`. ## Maps As already mentioned maps do not directly support streams. There's no `stream()` method available on the `Map` interface itself, however you can create specialized streams upon the keys, values or entries of a map via `map.keySet().stream()`, `map.values().stream()` and `map.entrySet().stream()`. Furthermore maps support various new and useful methods for doing common tasks. ```java Map<Integer, String> map = new HashMap<>(); for (int i = 0; i < 10; i++) { map.putIfAbsent(i, "val" + i); } map.forEach((id, val) -> System.out.println(val)); ``` The above code should be self-explaining: `putIfAbsent` prevents us from writing additional if null checks; `forEach` accepts a consumer to perform operations for each value of the map. This example shows how to compute code on the map by utilizing functions: ```java map.computeIfPresent(3, (num, val) -> val + num); map.get(3); // val33 map.computeIfPresent(9, (num, val) -> null); map.containsKey(9); // false map.computeIfAbsent(23, num -> "val" + num); map.containsKey(23); // true map.computeIfAbsent(3, num -> "bam"); map.get(3); // val33 ``` Next, we learn how to remove entries for a given key, only if it's currently mapped to a given value: ```java map.remove(3, "val3"); map.get(3); // val33 map.remove(3, "val33"); map.get(3); // null ``` Another helpful method: ```java map.getOrDefault(42, "not found"); // not found ``` Merging entries of a map is quite easy: ```java map.merge(9, "val9", (value, newValue) -> value.concat(newValue)); map.get(9); // val9 map.merge(9, "concat", (value, newValue) -> value.concat(newValue)); map.get(9); // val9concat ``` Merge either put the key/value into the map if no entry for the key exists, or the merging function will be called to change the existing value. ## Date API Java 8 contains a brand new date and time API under the package `java.time`. The new Date API is comparable with the [Joda-Time](http://www.joda.org/joda-time/) library, however it's [not the same](http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html). The following examples cover the most important parts of this new API. ### Clock Clock provides access to the current date and time. Clocks are aware of a timezone and may be used instead of `System.currentTimeMillis()` to retrieve the current time in milliseconds since Unix EPOCH. Such an instantaneous point on the time-line is also represented by the class `Instant`. Instants can be used to create legacy `java.util.Date` objects. ```java Clock clock = Clock.systemDefaultZone(); long millis = clock.millis(); Instant instant = clock.instant(); Date legacyDate = Date.from(instant); // legacy java.util.Date ``` ### Timezones Timezones are represented by a `ZoneId`. They can easily be accessed via static factory methods. Timezones define the offsets which are important to convert between instants and local dates and times. ```java System.out.println(ZoneId.getAvailableZoneIds()); // prints all available timezone ids ZoneId zone1 = ZoneId.of("Europe/Berlin"); ZoneId zone2 = ZoneId.of("Brazil/East"); System.out.println(zone1.getRules()); System.out.println(zone2.getRules()); // ZoneRules[currentStandardOffset=+01:00] // ZoneRules[currentStandardOffset=-03:00] ``` ### LocalTime LocalTime represents a time without a timezone, e.g. 10pm or 17:30:15. The following example creates two local times for the timezones defined above. Then we compare both times and calculate the difference in hours and minutes between both times. ```java LocalTime now1 = LocalTime.now(zone1); LocalTime now2 = LocalTime.now(zone2); System.out.println(now1.isBefore(now2)); // false long hoursBetween = ChronoUnit.HOURS.between(now1, now2); long minutesBetween = ChronoUnit.MINUTES.between(now1, now2); System.out.println(hoursBetween); // -3 System.out.println(minutesBetween); // -239 ``` LocalTime comes with various factory methods to simplify the creation of new instances, including parsing of time strings. ```java LocalTime late = LocalTime.of(23, 59, 59); System.out.println(late); // 23:59:59 DateTimeFormatter germanFormatter = DateTimeFormatter .ofLocalizedTime(FormatStyle.SHORT) .withLocale(Locale.GERMAN); LocalTime leetTime = LocalTime.parse("13:37", germanFormatter); System.out.println(leetTime); // 13:37 ``` ### LocalDate LocalDate represents a distinct date, e.g. 2014-03-11. It's immutable and works exactly analog to LocalTime. The sample demonstrates how to calculate new dates by adding or subtracting days, months or years. Keep in mind that each manipulation returns a new instance. ```java LocalDate today = LocalDate.now(); LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS); LocalDate yesterday = tomorrow.minusDays(2); LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4); DayOfWeek dayOfWeek = independenceDay.getDayOfWeek(); System.out.println(dayOfWeek); // FRIDAY ``` Parsing a LocalDate from a string is just as simple as parsing a LocalTime: ```java DateTimeFormatter germanFormatter = DateTimeFormatter .ofLocalizedDate(FormatStyle.MEDIUM) .withLocale(Locale.GERMAN); LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter); System.out.println(xmas); // 2014-12-24 ``` ### LocalDateTime LocalDateTime represents a date-time. It combines date and time as seen in the above sections into one instance. `LocalDateTime` is immutable and works similar to LocalTime and LocalDate. We can utilize methods for retrieving certain fields from a date-time: ```java LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59); DayOfWeek dayOfWeek = sylvester.getDayOfWeek(); System.out.println(dayOfWeek); // WEDNESDAY Month month = sylvester.getMonth(); System.out.println(month); // DECEMBER long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY); System.out.println(minuteOfDay); // 1439 ``` With the additional information of a timezone it can be converted to an instant. Instants can easily be converted to legacy dates of type `java.util.Date`. ```java Instant instant = sylvester .atZone(ZoneId.systemDefault()) .toInstant(); Date legacyDate = Date.from(instant); System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014 ``` Formatting date-times works just like formatting dates or times. Instead of using pre-defined formats we can create formatters from custom patterns. ```java DateTimeFormatter formatter = DateTimeFormatter .ofPattern("MMM dd, yyyy - HH:mm"); LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter); String string = formatter.format(parsed); System.out.println(string); // Nov 03, 2014 - 07:13 ``` Unlike `java.text.NumberFormat` the new `DateTimeFormatter` is immutable and **thread-safe**. For details on the pattern syntax read [here](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html). ## Annotations Annotations in Java 8 are repeatable. Let's dive directly into an example to figure that out. First, we define a wrapper annotation which holds an array of the actual annotations: ```java @interface Hints { Hint[] value(); } @Repeatable(Hints.class) @interface Hint { String value(); } ``` Java 8 enables us to use multiple annotations of the same type by declaring the annotation `@Repeatable`. ### Variant 1: Using the container annotation (old school) ```java @Hints({@Hint("hint1"), @Hint("hint2")}) class Person {} ``` ### Variant 2: Using repeatable annotations (new school) ```java @Hint("hint1") @Hint("hint2") class Person {} ``` Using variant 2 the java compiler implicitly sets up the `@Hints` annotation under the hood. That's important for reading annotation information via reflection. ```java Hint hint = Person.class.getAnnotation(Hint.class); System.out.println(hint); // null Hints hints1 = Person.class.getAnnotation(Hints.class); System.out.println(hints1.value().length); // 2 Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class); System.out.println(hints2.length); // 2 ``` Although we never declared the `@Hints` annotation on the `Person` class, it's still readable via `getAnnotation(Hints.class)`. However, the more convenient method is `getAnnotationsByType` which grants direct access to all annotated `@Hint` annotations. Furthermore the usage of annotations in Java 8 is expanded to two new targets: ```java @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE}) @interface MyAnnotation {} ``` ## Where to go from here? My programming guide to Java 8 ends here. If you want to learn more about all the new classes and features of the JDK 8 API, check out my [JDK8 API Explorer](http://winterbe.com/projects/java8-explorer/). It helps you figuring out all the new classes and hidden gems of JDK 8, like `Arrays.parallelSort`, `StampedLock` and `CompletableFuture` - just to name a few. I've also published a bunch of follow-up articles on my [blog](http://winterbe.com) that might be interesting to you: - [Java 8 Stream Tutorial](http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/) - [Java 8 Nashorn Tutorial](http://winterbe.com/posts/2014/04/05/java8-nashorn-tutorial/) - [Java 8 Concurrency Tutorial: Threads and Executors](http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-examples/) - [Java 8 Concurrency Tutorial: Synchronization and Locks](http://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/) - [Java 8 Concurrency Tutorial: Atomic Variables and ConcurrentMap](http://winterbe.com/posts/2015/05/22/java8-concurrency-tutorial-atomic-concurrent-map-examples/) - [Java 8 API by Example: Strings, Numbers, Math and Files](http://winterbe.com/posts/2015/03/25/java8-examples-string-number-math-files/) - [Avoid Null Checks in Java 8](http://winterbe.com/posts/2015/03/15/avoid-null-checks-in-java/) - [Fixing Java 8 Stream Gotchas with IntelliJ IDEA](http://winterbe.com/posts/2015/03/05/fixing-java-8-stream-gotchas-with-intellij-idea/) - [Using Backbone.js with Java 8 Nashorn](http://winterbe.com/posts/2014/04/07/using-backbonejs-with-nashorn/) You should [follow me on Twitter](https://twitter.com/winterbe_). Thanks for reading!

sofastack-guides/sofa-boot-guides

Guides for SOFABoot

2019-10-17T08:35:13Z

# SOFABoot 案例工程 * [SOFABoot 示例工程](sofaboot-sample) * [SOFABoot 示例工程（包含类隔离能力）](sofaboot-sample-with-isolation) * [SOFABoot 示例工程（包含模块化开发能力）](sofaboot-sample-with-isle) * [SOFABoot 示例工程（使用 SOFARPC）](sofaboot-sample-with-rpc) * [SOFABoot 示例工程（使用定时任务）](sofaboot-scheduler-batch-sample)

RameshMF/spring-boot-tutorial

100+ Spring Boot Articles, Tutorials, Video tutorials, Projects, Guides, Source code examples etc

2018-09-17T07:25:55Z

<h1>YouTube Channel - Spring Boot Tutorial</h1> <p>Subscribe for future video and updates</p> <a href="https://www.youtube.com/playlist?list=PLGRDMO4rOGcNSBOJOlrgQqGpIgo6_VZgR" target="_blank">Spring Boot Tutorial on YouTube </a> # Newly published spring boot tutorials (2020) <ul style="text-align: left;"> <li><a href="https://www.javaguides.net/2021/07/react-js-react-hooks-spring-boot.html" target="_blank">React JS ( React Hooks) + Spring Boot Tutorial</a><br></li><li><a href="https://www.javaguides.net/2021/07/spring-boot-tutorial-for-beginners.html" target="_blank">Spring Boot Tutorial for Beginners Step by Step</a><br></li><li><a href="https://www.javaguides.net/2021/07/spring-boot-tutorial-build-employee-management-project.html" target="_blank">Spring Boot Tutorial - Build Employee Management Project from Scratch using Spring Boot + Spring Security + Thymeleaf and MySQL Database</a><br></li><li><a href="https://www.javaguides.net/2021/06/configure-jwt-with-spring-boot-and-swagger.html" target="_blank">Configure JWT with Spring Boot and Swagger UI</a><br></li><li><a href="https://www.javaguides.net/2021/06/spring-boot-rest-api-documentation-with-swagger.html" target="_blank">Spring Boot REST API Documentation with Swagger</a><br></li><li><a href="https://www.javaguides.net/2021/05/spring-boot-crud-tutorial.html" target="_blank">Spring Boot CRUD Tutorial with Spring MVC, Spring Data JPA, Thymeleaf, Hibernate, MySQL</a><br></li><li><a href="https://www.javaguides.net/2021/04/spring-boot-project-employee-management.html" target="_blank">Spring Boot Project - Employee Management System | Project for Final Year Students</a><br></li><li><a href="https://www.javaguides.net/2021/04/deploy-spring-boot-mysql-crud-rest-api-Application-on-aws.html" target="_blank">Deploy Spring Boot MySQL CRUD REST API Application on AWS | Elastic Beanstalk | AWS RDS</a><br></li><li><a href="https://www.javaguides.net/2021/04/spring-boot-dto-validation-example.html" target="_blank">Spring Boot DTO Validation Example</a><br></li><li><a href="https://www.javaguides.net/2021/04/deploy-spring-boot-application-on-aws.html" target="_blank">Deploy a Spring Boot Application on AWS | Elastic Beanstalk</a><br></li><li><a href="https://www.javaguides.net/2021/04/deploy-spring-boot-mvc-application-on-aws.html" target="_blank">Deploy Spring Boot MVC Application on AWS | Elastic Beanstalk</a><br></li><li><a href="https://www.javaguides.net/2021/04/deploy-spring-boot-war-file-on-tomcat-in-aws.html" target="_blank">Deploy Spring Boot WAR file on Tomcat in AWS | Elastic Beanstalk</a></li><li><a href="https://www.javaguides.net/2021/03/validation-in-spring-boot-rest-api-with-hibernate-validator.html" target="_blank">Validation in Spring Boot REST API with Hibernate Validator (Java Bean Validation Annotations)</a><br></li><li><a href="Spring Boot DTO Example - Entity To DTO Conversion" target="_blank">Spring Boot DTO Example - Entity To DTO Conversion</a><br></li><li><a href="https://www.javaguides.net/2021/01/prerequisites-to-learn-spring-boot.html" target="_blank">Prerequisites to Learn Spring Boot</a><br></li><li><a href="https://www.javaguides.net/2021/01/angular-spring-boot-rest-api-example.html" target="_blank">Angular + Spring Boot REST API Example Tutorial</a><br></li><li><a href="https://www.javaguides.net/2020/11/jsp-vs-thymeleaf-support-in-spring-boot.html" target="_blank">JSP vs Thymeleaf Support in Spring Boot</a><br></li><li><a href="https://www.javaguides.net/2020/11/spring-professional-certification-topics-and-questions.html" target="_blank">Spring Professional Certification Topics and Questions</a><br></li><li><a href="https://www.javaguides.net/2020/07/spring-boot-react-js-crud-example-tutorial.html" target="_blank">Spring Boot + React JS CRUD Example Tutorial</a></li> <li><a href="https://www.javaguides.net/2020/07/spring-boot-angular-10-crud-example-tutorial.html" target="_blank">Spring Boot + Angular 10 CRUD Example Tutorial</a></li> <li><a href="https://www.javaguides.net/2020/07/react-js-spring-boot-rest-api-example-tutorial.html" target="_blank">React JS + Spring Boot REST API Example Tutorial</a></li> <li><a href="https://www.javaguides.net/2020/07/spring-boot-project-architecture.html" target="_blank">Spring Boot Project Architecture</a></li> <li><a href="https://www.javaguides.net/2020/07/how-spring-mvc-works-internally.html" target="_blank">How Spring MVC Works Internally</a></li> <li><a href="https://www.javaguides.net/2020/07/three-tier-three-layer-architecture-in-spring-mvc-web-application.html" target="_blank">Three Tier (Three Layer) Architecture in Spring MVC Web Application</a></li> <li><a href="https://www.javaguides.net/2020/06/best-practice-to-develop-persistence-or-dao-layer.html" target="_blank">Best Practice to Develop Persistence or DAO Layer</a></li> <li><a href="https://www.javaguides.net/2020/06/best-youtube-channels-to-learn-spring-boot.html" target="_blank">Best YouTube Channels to learn Spring Boot</a></li> <li><a href="https://www.javaguides.net/2020/06/pagination-and-sorting-with-spring-boot-thymeleaf-spring-data-jpa-hibernate-mysql.html" target="_blank">Pagination and Sorting with Spring Boot, ThymeLeaf, Spring Data JPA, Hibernate, MySQL</a></li> <li><a href="https://www.javaguides.net/2020/06/free-spring-boot-microservices-open-source-projects-github.html" target="_blank">Free Spring Boot Microservices Open Source Projects | GitHub | Download</a></li> <li><a href="https://www.javaguides.net/2020/06/spring-security-tutorial-with-spring-boot-spring-data-jpa-thymeleaf-and-mysql-database.html" target="_blank">Spring Security Tutorial with Spring Boot, Spring Data JPA, Thymeleaf and MySQL Database</a></li> <li><a href="https://www.javaguides.net/2020/06/free-spring-boot-angular-open-source-projects-github.html" target="_blank">Free Spring Boot Angular Open Source Projects | GitHub</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-crud-web-application-with-thymeleaf.html" target="_blank">Spring Boot CRUD Web Application with Thymeleaf, Spring MVC, Spring Data JPA, Hibernate, MySQL</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part1.html" target="_blank"></a><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part1.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 1</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part2.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 2</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part3.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 3</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part4.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 4</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part5.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 5</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part6.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 6</a>&nbsp;</li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-crud-database-real-time-project-part7.html" target="_blank">Spring Boot Thymeleaf CRUD Database Real-Time Project - PART 7</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-jsp-example-tutorial.html" target="_blank">Spring Boot JSP Example Tutorial</a></li> <li><a href="https://www.javaguides.net/2020/05/spring-boot-thymeleaf-example-tutorial.html" target="_blank">Spring Boot Thymeleaf Example Tutorial</a></li> <li><a href="https://www.javaguides.net/2020/04/jpa-hibernate-one-to-many-mapping-example-with-spring-boot.html" target="_blank">JPA, Hibernate One to Many Mapping Example with Spring Boot and MySQL Database</a></li> <li><a href="https://www.javaguides.net/2020/04/deploying-spring-boot-war-file-with-jsp-to-tomcat.html" target="_blank">Deploying Spring Boot WAR file with JSP to Tomcat</a></li> <li><a href="https://www.javaguides.net/2020/04/jpa-and-hibernate-many-to-many-mapping-spring-boot.html" target="_blank">JPA and Hibernate Many to Many Mapping with Spring Boot - @ManyToMany and @JoinTable</a></li> <li><a href="https://www.javaguides.net/2020/04/spring-boot-file-upload-download-rest-api-example.html" target="_blank">Spring Boot File Upload / Download Rest API Example</a></li> <li><a href="https://www.javaguides.net/2020/04/spring-boot-mysql-jpa-hibernate-restful-crud-api-tutorial.html" target="_blank">Spring Boot, MySQL, JPA, Hibernate Restful CRUD API Tutorial</a></li> <li><a href="https://www.javaguides.net/2020/04/spring-boot-h2-jpa-hibernate-restful-crud-api-tutorial.html" target="_blank">Spring Boot, H2, JPA, Hibernate Restful CRUD API Tutorial</a></li> </ul> <h1> Spring Boot Tutorials/Articles/Guides </h1> <div dir="ltr" style="text-align: left;" trbidi="on"> <h2 style="text-align: left;"> Spring Boot Basics</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/getting-started-with-spring-boot.html">Getting Started with Spring Boot</a></li> <li><a href="http://www.javaguides.net/2018/09/installing-spring-boot-with-maven-and-gradle.html">Installing Spring Boot with Maven and Gradle</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-building-restful-web-service.html">Spring Boot 2 Hello World Application</a></li> <li><a href="http://www.javaguides.net/2018/09/overview-of-spring-boot-starter-parent.html">Overview of Spring Boot Starter Parent</a></li> <li><a href="http://www.javaguides.net/2018/09/important-spring-boot-starters-with-examples.html">Important Spring Boot Starters with Examples</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-how-to-change-port-and-context-path.html">Spring Boot How to Change Port and Context Path</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-deploy-war-file-to-external-tomcat.html">Spring Boot 2 Deploy WAR file to External Tomcat</a></li> <li><a href="http://www.javaguides.net/2018/09/different-ways-of-running-spring-boot-appilcation.html">Different Ways of Running Spring Boot Application</a></li> <li><a href="https://www.baeldung.com/spring-boot-migration">Migrating from Spring to Spring Boot</a></li> <li><a href="http://www.javaguides.net/2018/10/spring-boot-annotations.html">Spring Boot Annotations</a></li> </ul> <h2 style="text-align: left;"> Spring Boot REST API Development</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-hibernate-5-mysql-crud-rest-api-tutorial.html">Spring Boot 2 Hibernate 5 MySQL CRUD REST API Tutorial</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-jpa-mysql-crud-example.html">Spring Boot 2 JPA MySQL CRUD Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-building-restful-web-service.html">Spring Boot 2 Hello World Application</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-crud-rest-apis-validation-example.html">Spring Boot 2 CRUD REST APIs Validation Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-data-jpa-auditing-with-spring-boot2-and-mysql-example.html">Spring Data JPA Auditing with Spring Boot 2 and MySQL Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-exception-handling-for-rest-apis.html">Spring Boot 2 Exception Handling for REST APIs</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-logging-slf4j-logback-and-log4j-example.html">Spring Boot 2 Logging SLF4j Logback and LOG4j2 Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-jersey-rest-jpa-hibernate-5-crud-rest-apis-example.html">Spring Boot 2 + Jersey REST + JPA + Hibernate 5 CRUD REST APIs Example</a></li> <li><a href="http://www.javaguides.net/2018/10/spring-boot-2-scheduling-tasks.html">Spring Boot 2 - Scheduling Tasks</a></li> <li><a href="http://www.javaguides.net/2018/10/spring-boot-2-restful-api-documentation-with-swagger2-tutorial.html">Spring Boot 2 RESTful API Documentation with Swagger 2 Tutorial</a></li> <li><a href="http://www.javaguides.net/2018/11/spring-boot-2-file-upload-and-download-rest-api-tutorial.html">Spring Boot 2 - File Upload and Download Rest API Tutorial</a> // LATEST</li> </ul> <h2 style="text-align: left;"> Spring Boot Web Application Development</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-mvc-using-spring-boot2-jsp-jpa-hibernate5-mysql-example.html">Spring MVC + Spring Boot2 + JSP + JPA + Hibernate 5 + MySQL Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot2-mvc-web-application-thymeleaf-jpa-mysql-example.html">Spring Boot 2 MVC Web Application Thymeleaf JPA MySQL Example</a></li> <li><a href="http://www.javaguides.net/2018/10/spring-boot-spring-mvc-validating-form.html">Spring Boot 2 - Spring MVC + Thymeleaf Input Form Validation</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-jpa-multiple-data-sources-example.html">Spring Boot JPA Multiple Data Sources Example</a></li> </ul> <h2 style="text-align: left;"> Spring Boot with Spring Security</h2> <div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-boot-spring-mvc-role-based-spring-security-jpa-thymeleaf-mysql-tutorial.html">Spring Boot 2 + Spring MVC + Role Based Spring Security + JPA + Thymeleaf + MySQL Tutorial</a></li> <li><a href="https://spring.io/guides/gs/authenticating-ldap/">Authenticating a User with LDAP using Spring Boot and Spring Security</a></li> <li><a href="http://www.javaguides.net/2018/10/user-registration-module-using-springboot-springmvc-springsecurity-hibernate5-thymeleaf-mysql.html">User Registration Module using Spring Boot 2 + Spring MVC + Spring Security + Hibernate 5 + Thymeleaf + MySQL</a></li> </ul> <h2 style="text-align: left;"> Spring Boot Configuration</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-boot-java-based-configuration-example.html">Spring Boot 2 Java Based Configuration Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-xml-configuration-example.html">Spring Boot 2 XML Configuration Example</a></li> <li><a href="https://www.baeldung.com/spring-boot-migration">Migrating from Spring to Spring Boot</a></li> </ul> <h2 style="text-align: left;"> Spring Boot Testing</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-data-jpa-repository-testing-using-spring-boot-datajpatest.html">Spring Data JPA Repository Testing using Spring Boot @DataJpaTest</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-rest-apis-integration-testing.html">Spring Boot 2 REST APIs Integration Testing</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-with-junit-5-testing.html">Spring Boot 2 with JUnit 5 Testing Example</a></li> </ul> <h2 style="text-align: left;"> Spring Boot Annotations</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-boot-enableautoconfiguration-annotation-with-example.html">Spring Boot @EnableAutoConfiguration Annotation with Example</a></li> <li><a href="http://www.javaguides.net/2018/09/spring-boot-springbootapplication-annotation-with-example.html">Spring Boot @SpringBootApplication Annotation with Example</a></li> <li><a href="http://www.javaguides.net/2018/10/spring-boot-annotations.html">Spring Boot Annotations</a></li> <li><a href="http://www.javaguides.net/2018/10/spring-boot-creating-asynchronous-methods-using-async-annotation.html">Spring Boot - Creating Asynchronous Methods using @Async Annotation</a></li> </ul> <h2 style="text-align: left;"> Configure Spring Boot with PostgreSQL</h2> </div> <div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2019/01/springboot-postgresql-jpa-hibernate-crud-restful-api-tutorial.html">Spring Boot + PostgreSQL + JPA/Hibernate CRUD Restful API Tutorial</a></li> </ul> <h2 style="text-align: left;"> Spring Boot Mini Projects</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/mini-todo-management-project-using-spring-boot-springmvc-springsecurity-jsp-hibernate-mysql.html">Mini Todo Management Project using Spring Boot + Spring MVC + Spring Security + JSP + Hibernate + MySQL</a></li> <li><a href="http://www.javaguides.net/2018/10/user-registration-module-using-springboot-springmvc-springsecurity-hibernate5-thymeleaf-mysql.html">User Registration Module using Spring Boot + Spring MVC + Spring Security + Hibernate 5 + Thymeleaf + MySQL</a></li> </ul> </div> </div> <h1>Spring Boot + Angular 9 Tutorials // Latest </h1> <ul style="text-align: left;"><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-example-tutorial.html"></a> <li><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-example-tutorial.html"></a><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-example-tutorial.html">Spring Boot + Angular 9 CRUD Example Tutorial</a> - Main Tutorial</li> <li><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-part-1-develop-springboot-crud-rest-apis.html">Spring Boot + Angular 9 CRUD Tutorial - Part 1 - Develop Spring Boot CRUD Rest APIs</a></li> <li><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-part-2-create-angular-9-app.html">Spring Boot + Angular 9 CRUD - Part 2 - Create an Angular 9 App</a></li> <li><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-part-3-develop-angular-9-crud-operations.html">Spring Boot + Angular 9 CRUD - Part 3 - Develop Angular 9 CRUD Operations</a></li> <li><a href="https://www.javaguides.net/2020/01/spring-boot-angular-9-crud-part-4-angular-9-crud-app-configuration.html">Spring Boot + Angular 9 CRUD, Part 4 - Angular 9 CRUD App Configuration</a></li> <li><a href="https://www.javaguides.net/2020/01/spring-boot-angular-8-crud-part-5-running-angular-9-crud-app.html">Spring Boot 2 + Angular 9 CRUD, Part 5 - Running Angular 9 CRUD App</a></li> </ul> <h1> Spring Boot + MongoDB </h1> <ul style="text-align: left;"><b><a href="https://www.javaguides.net/2019/12/spring-boot-angular-mongodb-crud-example-tutorial.html"></a> <li><a href="https://www.javaguides.net/2019/12/spring-boot-angular-mongodb-crud-example-tutorial.html"><b></b></a><b><a href="https://www.javaguides.net/2019/12/spring-boot-angular-mongodb-crud-example-tutorial.html">Spring Boot + Angular + MongoDB CRUD Example Tutorial</a></b></li> <li><b><a href="https://www.javaguides.net/2019/12/spring-boot-mongodb-crud-example-tutorial.html">Spring Boot + MongoDB CRUD Tutorial</a></b></li> </b></ul>

AnoyiX/spring-security-demos

Spring Security DEMO & Guides

2017-06-07T02:45:15Z

Spring Security Guides ----- Protects your application with comprehensive and extensible authentication and authorization support.

Adobe-Marketing-Cloud/aem-guides

AEM Guides contains multiple AEM Maven projects that are code companions for a corresponding tutorial found on helpx.adobe.com

2017-01-11T21:46:48Z

# AEM Guides AEM Guides contains multiple AEM Maven projects that are code companions for a corresponding tutorial found on [helpx.adobe.com](https://helpx.adobe.com/support/experience-manager.html) ## Current Guides ### [SPA Editor HelloWorld Guide](https://github.com/Adobe-Marketing-Cloud/aem-guides/tree/master/spa-helloworld-guide) Highlights the steps needed to map a SPA component to an AEM component to enable in-context editing by building a simple HelloWorld component. ### [Simple Search Guide](https://github.com/Adobe-Marketing-Cloud/aem-guides/tree/master/simple-search-guide) Site search implementation that features full-text, predicate filtering, pagination, and auto-complete functionality ### [Projects and Tasks Guide](https://github.com/Adobe-Marketing-Cloud/aem-guides/tree/master/projects-tasks-guide) Creates a custom Project Template and simple approval workflow that leverages Project Tasks ### [Asset Insights Guide](https://github.com/Adobe-Marketing-Cloud/aem-guides/tree/master/asset-insights-guide) Provides two examples of extending foundation and core Image components to add tags to support Asset Insights. ### [Deprecated] [WKND Sites Guide](https://github.com/Adobe-Marketing-Cloud/aem-guides/tree/master/wknd-sites-guide) * This project has moved to [aem-guides-wknd](https://github.com/Adobe-Marketing-Cloud/aem-guides-wknd)

gradle/guides

The Gradle Guides at https://guides.gradle.org.

2016-07-07T07:48:55Z

All content from this repository has been moved to the [Gradle User Manual](https://docs.gradle.org/current/). The Gradle User Manual sources are located here: https://github.com/gradle/gradle/tree/master/subprojects/docs

project-travel-mate/Travel-Mate

A complete travel guide!

2016-01-30T13:42:30Z

# Travel Mate [](https://travis-ci.org/project-travel-mate/Travel-Mate) [](https://www.uplabs.com/posts/travel-mate) [](http://makeapullrequest.com) Travel Mate is an android app for travellers. It provides features like **choosing the correct destination**, **making bookings**, and **organizing the trip**. It provides solutions for every problem a traveller might face during their journey. It provides a comprehensive list of information about a destination: current weather, best places to hangout, and city's current trends. Checkout [Features list](#features) for a detailed feature description. | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/all_cities.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/one_city.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/city_here.png" width="200px"> | | - | - | - | ## Download [<img src="https://play.google.com/intl/en_us/badges/images/generic/en-play-badge.png" height="80">](https://play.google.com/store/apps/details?id=io.github.project_travel_mate) [<img src="https://f-droid.org/badge/get-it-on.png" height="80">](https://f-droid.org/packages/io.github.project_travel_mate/) ## Support Us We are not running any ads in the app and the source code is available for free on [GitHub](https://github.com/project-travel-mate). It costs us to keep the servers up all the time. Support us to make sure we continue to help travellers. <a href="https://www.buymeacoffee.com/qITGMWB" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a> ## Quick Links + **[Journey of a hackathon project to a Summer of Code Project](https://medium.com/@prabhakar267/6a1b8c1d5e3e)** + **[Features](#features)** + [Destinations](#destinations) + [My Trips](#my-trips) + [Travel](#travel) + [Utility](#utility) + **[Contributing](#contributing)** + **[Join Travel Mate Beta Testing](https://play.google.com/apps/testing/io.github.project_travel_mate)** ## Features ### Destinations Travel Mate helps decide the destination by providing tourist spots, interesting trivia, local trends, weather and much more about over 10k cities. | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/one_city.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/trend.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/fact.png" width="200px"> | | - | - | - | ### My Trips Travel Mate allows users to store their travel history. They can add their Travel Mate friends to trip and share their history with others. They always have option to keep their trips private. | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/travel.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/shopping.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/mytrip_info.png" width="200px"> | | - | - | - | ### Travel Travel Mate provides real-time information about monuments, restaurants, hotels, medical centres, etc. for travellers explore unfamiliar cities. | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/hotel_book.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/trips.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/here.png" width="200px"> | | - | - | - | ### Utility Travel Mate gives a bunch of helpful utilities in one app including World Clock, checklists, share your contact. | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/world_clock.jpeg" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/share_my_contact.png" width="200px"> | <img src="https://raw.githubusercontent.com/project-travel-mate/Travel-Mate/master/.github/screenshots/checklist.png" width="200px"> | | - | - | - | ### Contributing Check out the [Getting Started](GETTING_STARTED.md) page to add an awesome new feature or bash some bugs. If you're new to open-source, we recommend you to checkout our [Contributing Guidelines](CONTRIBUTING.md). Feel free to fork the project and send us a pull request or even open a [new issue](https://github.com/project-travel-mate/Travel-Mate/issues/new) to start discussion. ## Stargazers over time [](https://starchart.cc/project-travel-mate/Travel-Mate)

hellokoding/hellokoding-courses

HelloKoding provides practical coding guides series of Spring Boot, Java, Algorithms, and other topics on software engineering

2019-02-19T05:13:23Z

# HelloKoding - Practical Coding Guides HelloKoding provides practical coding guides series of Spring Boot, Java, Algorithms and other topics on software engineering https://hellokoding.com

awsdocs/aws-lambda-developer-guide

Supplementary resources for the AWS Lambda Developer Guide

2017-12-12T00:13:19Z

## AWS Lambda Developer Guide This repository contains additional resources for the AWS Lambda developer guide. - [iam-policies](./iam-policies) - Sample permissions policies for cross-service use cases. - [sample-apps](./sample-apps) - Sample applications that demonstrate features and use cases for the AWS Lambda service and managed runtimes. - [templates](./templates) - AWS CloudFormation templates for creating functions and VPC network resources. ## License Summary The sample code within this repo is made available under a modified MIT license. See the [LICENSE](./LICENSE) file.

RameshMF/Hibernate-ORM-Tutorials

40+ source code Examples/Tutorials/Guides of Hibernate ORM Framework

2018-11-22T13:15:38Z

# Hibernate-ORM-Tutorials Tutorials/guides/examples of Hibernate ORM Framework <div dir="ltr" style="text-align: left;" trbidi="on"> <div class="font-family-page"> <div class="separator" style="clear: both; text-align: center;"> <a href="https://3.bp.blogspot.com/-LZZRjsO24YI/W_qbPQkNsTI/AAAAAAAAE9o/Urok6r0IKbkPtRU6V7r5ty5eMOcaKiKAgCLcBGAs/s1600/hibernate-logo.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="139" data-original-width="491" src="https://3.bp.blogspot.com/-LZZRjsO24YI/W_qbPQkNsTI/AAAAAAAAE9o/Urok6r0IKbkPtRU6V7r5ty5eMOcaKiKAgCLcBGAs/s1600/hibernate-logo.jpg"></a></div> <div class="separator" style="clear: both; text-align: center;"> </div> <div class="separator" style="clear: both; text-align: center;"> </div> <div> This tutorial is designed for all those Java programmers who would like to understand the Hibernate framework and its API. All the examples in this tutorial&nbsp;have been developed using Hibernate 5.3 +.</div> <h2 style="text-align: left;"> 1. Hibernate Getting Started</h2> <div> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-framework-overview-architecture-bascis.html" target="_blank">Hibernate Framework Overview - Architecture and Basics</a>&nbsp;- In this article, b<span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">efore getting started with Hibernate framework, let's familiar with a few basic concepts of the hibernate framework, it's architecture, it's benefits and advantages over JDBC etc.</span></li> </ul> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-hello-world-tutorial.html">Hibernate 5 - Hello World Tutorial</a>&nbsp;- In this Hibernate hello world tutorial, we will show you how to create a Hibernate Application to connect MySQL database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/12/hibernate-transaction-management-tutorial.html" target="_blank">Hibernate Transaction Management Tutorial</a>&nbsp;- In this tutorial, we will learn how to manage transactions in Hibernate applications.</li> </ul> </div> <h2 style="text-align: left;"> 2. Bootstrap</h2> <h3 style="text-align: left;"> 2.1 Native Bootstrapping</h3> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-xml-configuration-example.html" style="font-family: inherit;">Hibernate 5 XML Configuration Example</a><span style="font-family: inherit;"> - In this article, we will show you how to create a Hibernate Application using hibernate.cfg.xml configuration to connect MySQL database.</span></li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-java-configuration-example.html" style="font-family: inherit;">Hibernate 5 Java Configuration Example</a><span style="font-family: inherit;"> - In this article, we will show you how to create a Hibernate Application using Java configuration without using hibernate.cfg.xml to connect MySQL database.</span></li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-configurations-quick-references.html" style="font-family: inherit; font-size: 16px;" target="_blank">Hibernate Configurations Quick References [Snippets]</a><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;">&nbsp;-&nbsp;</span><span style="color: #24292e; font-family: inherit; font-size: 16px;">This post is&nbsp;a quick</span><span style="color: #24292e; font-family: inherit; font-size: 16px;">&nbsp;reference to Hibernate XML or Java-based configuration.</span></li> </ul> </div> <h3 style="text-align: left;"> 2.2 JPA Bootstrapping</h3> <div class="font-family-page"> <div> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/jpa-with-hibernate-5-bootstrapping-example.html" target="_blank">JPA 2 with Hibernate 5 Bootstrapping Example</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">In this post, we will show you how to create or configure a simple JPA application with Hibernate.</span></li> </ul> <h2 style="text-align: left;"> 3. Domain Model</h2> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/guide-to-jpa-and-hibernate-cascade-types.html" target="_blank">Guide to JPA and Hibernate Cascade Types</a>&nbsp;- J</span><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;">PA allows you to propagate the state transition from a parent entity to a child. This article describes all cascade types with an example.</span></li> </ul> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;"><a href="http://www.javaguides.net/2018/12/hibernatejpa-primary-key-generation-stratergies.html" target="_blank">Hibernate/JPA - Primary Key Generation Strategies</a>&nbsp;- Let's discuss&nbsp;</span><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;">4 different primary key generation strategies which generate the primary key values programmatically or use database features, like auto-incremented columns or sequences.</span></li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-enum-type-mapping-example.html">Hibernate 5 - Enum Type Mapping Example</a>&nbsp;- In this article, we will show you how a Java enum type is persisted into a database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-component-mapping-using-embeddable-embedded-annotation.html" target="_blank">Hibernate Component Mapping Using @Embeddable and @Embedded Annotation</a>&nbsp;-&nbsp;<span style="background-color: white; color: #24292e; font-size: 16px;">With Hibernate we can use the&nbsp;</span><span style="background-color: rgba(27 , 31 , 35 , 0.05); color: #d73a49; font-family: &quot;consolas&quot; , &quot;liberation mono&quot; , &quot;courier&quot; , monospace; font-size: 14.4px; padding: 0.2em 0.4em;">@Embeddable</span><span style="background-color: white; color: #24292e; font-size: 16px;">&nbsp;annotation to mark a class to be eligible as an embeddable class.</span></li> </ul> <span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"></span></div> <h2 style="text-align: left;"> 4. Hibernate Database Operations (Session Methods)</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-save-an-entity-example.html">Hibernate 5 - Save an Entity Example</a> - In this article, we will create a simple Hibernate application to demonstrate how to save an entity into a database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-persist-entity-example.html">Hibernate 5 - Persist an Entity Example</a> - In this article, we will create a simple Hibernate application to demonstrate how to persist an entity into a database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-saveorupdate-method-example.html">Hibernate 5 - saveOrUpdate() Method Example</a> - In this article, we will create a simple Hibernate application to demonstrate how to save or update an entity in the database using the saveOrUpdate() method.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-get-load-and-byid-method-examples.html">Hibernate 5 - get(), load() and byId() Method Examples</a> - In this article, we will show you how to use Session.get(), Session.load() and Session.byId() methods to retrieve an entity from database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-merge-example.html">Hibernate 5 - merge() Example</a> - In this article, we will show you how to use Session.merge() method to merge an entity in Hibernate Application.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-delete-or-remove-entity.html">Hibernate 5 - Delete or Remove an Entity Example</a> - In Hibernate, an entity can be removed from a database by calling the Session.delete() or Session.remove(). Using these methods, we can remove a transient or persistent object from datastore.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-load-method-example.html">Hibernate 5 - load() Method Example</a> - In this article, we will create a simple Hibernate application using Java configuration without using hibernate.cfg.xml to demonstrates the usage of Session.load() method.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-c3p0-connection-pool-example.html">Hibernate 5 c3p0 Connection Pool Example</a> - In this article, we will show how to use c3p0 connection pooling in hibernate applications.</li> </ul> <h2 style="text-align: left;"> 5. Inheritance Mapping</h2> <div style="text-align: left;"> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-inheritance-mapping.html" target="_blank">Hibernate 5 - Inheritance Mapping</a>&nbsp;- In this article, we will learn 4 inheritance<span style="background-color: white; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">&nbsp;strategies with examples.</span></li> </ul> <ul style="text-align: left;"> <li><span style="background-color: white; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/hibernate-jpa-mappedsuperclass-inheritance-example.html" target="_blank">Hibernate/JPA MappedSuperclass Inheritance Example</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">The JPA standard specification defines the&nbsp;</span><a href="https://docs.oracle.com/javaee/7/api/javax/persistence/MappedSuperclass.html" style="color: #3d85c6; font-size: 16px;" target="_blank">@MappedSuperclass</a><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">&nbsp;annotation to allow an entity to inherit properties from a base class.</span></li> </ul> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/hibernatejpa-single-table-inheritance.html" target="_blank">Hibernate/JPA Single Table Inheritance Example</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">&nbsp;</span><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">In this article, we will discuss The single table strategy which maps all entities of the inheritance structure to the same database table.</span></li> </ul> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/hibernate-jpa-joined-table-inheritance-example.html" target="_blank">Hibernate JPA Joined Table Inheritance Example</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">In this article, we will discuss The Joined table strategy or table-per-subclass mapping strategy.</span></li> </ul> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/hibernatejpa-table-per-class-inheritance-example.html" target="_blank">Hibernate/JPA Table Per Class Inheritance Example</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;">In this article, we’ll look into Hibernate/JPA table per class inheritance.</span></li> </ul> </div> <span style="background-color: white; color: #24292e; font-family: , &quot;blinkmacsystemfont&quot; , &quot;segoe ui&quot; , &quot;helvetica&quot; , &quot;arial&quot; , sans-serif , &quot;apple color emoji&quot; , &quot;segoe ui emoji&quot; , &quot;segoe ui symbol&quot;; font-size: 16px;"></span></div> <div class="font-family-page"> <h2 style="text-align: left;"> 6. Hibernate Query Language</h2> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-query-language-basics.html">Hibernate Query Language Basics</a> - This article describes the basics of HQL.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-query-language-insert-update.html">Hibernate Query Language INSERT, UPDATE, SELECT and DELETE Example</a> - In this article, we will discuss how to create simple Hibernate Query Language INSERT, UPDATE, SELECT and DELETE Example.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-hql-crud-example-snippets.html">Hibernate 5 - HQL CRUD Example [Snippets]</a> - In this article, we will see quick snippets or examples of Hibernate 5 HQL CRUD Example.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-named-query-tutorial-with-examples.html">Hibernate 5 Named Query Tutorial with Examples</a> - This tutorial shows you how to use the named queries annotations in hibernation application.</li> </ul> <div class="font-family-page"> <h2 style="text-align: left;"> 7. Hibernate 5 with Java 8</h2> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-5-persist-java-8-localdate-localdatetime-and-duration-example.html">Hibernate 5 - Persist Java 8 LocalDate, LocalDateTime and Duration Example</a>&nbsp;- In this article, we will learn how to persist Java 8 LocalDate, LocalDateTime, and Duration with&nbsp;<a href="http://www.javaguides.net/p/hibernate-tutorial.html">Hibernate 5</a>.</li> </ul> <ul style="text-align: left;"> <li><a href="https://thoughts-on-java.org/use-java-8-optional-hibernate/" target="_blank">How to use Java 8’s Optional with Hibernate</a>&nbsp;- This article show you how to use Java 8 Optional Class to handle&nbsp;<i>NullPointerException</i>.</li> </ul> <ul style="text-align: left;"> <li><a href="https://thoughts-on-java.org/get-query-results-stream-hibernate-5/">How to get query results as a Stream with Hibernate 5.2</a>&nbsp;- This post shows you how to use stream() method that allows you to process the query results as a Java 8 Stream.</li> </ul> </div> <div class="font-family-page"> <h2 style="text-align: left;"> 8. Database</h2> <div> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/guide-to-hibernate-5-schema-generation.html" target="_blank">Guide to Hibernate 5 Schema Generation</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;">In this guide, You will learn how does Hibernate allows you to generate the database from the entity mappings. In this guide, we will following&nbsp;points.</span></li> </ul> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/guide-to-hibernate-native-sql-queries.html" target="_blank">Guide to Hibernate Native SQL Queries</a>&nbsp;-&nbsp;</span><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;">Let's learn more about Hibernate native SQL queries with examples snippets.</span></li> </ul> <ul style="text-align: left;"> <li><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;"><a href="http://www.javaguides.net/2018/11/hibernate-5-using-stored-procedures-for.html" target="_blank">Hibernate 5 - Using Stored Procedures for Querying</a>&nbsp;-&nbsp;&nbsp;</span><span style="font-family: inherit;">Hibernate</span><span style="background-color: white; color: #24292e; font-family: inherit; font-size: 16px;">&nbsp;provides support for queries via stored procedures and functions</span></li> </ul> <h2 style="text-align: left;"> <span style="color: #24292e;">Hibernate Annotations</span></h2> </div> <div> <div style="text-align: left;"> </div> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/12/all-hibernate-mapping-annotations.html" target="_blank">All Hibernate Annotations: Mapping Annotations</a>&nbsp;- A quick reference to all Hibernate mapping annotations.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/all-jpa-annotations-mapping-annotations.html" target="_blank">All JPA Annotations: Mapping Annotations</a>&nbsp;- A quick reference to all JPA mapping annotations.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/hibernate-component-mapping-using-embeddable-embedded-annotation.html" target="_blank">Hibernate Component Mapping Using @Embeddable and @Embedded Annotation</a>&nbsp;-&nbsp;<span style="background-color: white; color: #24292e; font-size: 16px;">With Hibernate we can use the&nbsp;</span><span style="background-color: rgba(27 , 31 , 35 , 0.05); color: #d73a49; font-family: &quot;consolas&quot; , &quot;liberation mono&quot; , &quot;courier&quot; , monospace; font-size: 14.4px; padding: 0.2em 0.4em;">@Embeddable</span><span style="background-color: white; color: #24292e; font-size: 16px;">&nbsp;annotation to mark a class to be eligible as an embeddable class.</span></li> </ul> <br> <div> <br></div> </div> </div> <div class="separator" style="clear: both; text-align: center;"> <a href="https://3.bp.blogspot.com/-sZpG0bMK5xQ/W_qZl9AuksI/AAAAAAAAE9U/2aimw3DF5pUZzeAOmN7xiLc59GTqRaNIQCEwYBhgL/s1600/spring-hibernate.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="282" data-original-width="600" src="https://3.bp.blogspot.com/-sZpG0bMK5xQ/W_qZl9AuksI/AAAAAAAAE9U/2aimw3DF5pUZzeAOmN7xiLc59GTqRaNIQCEwYBhgL/s1600/spring-hibernate.jpg"></a></div> <br> <h2 style="text-align: left;"> 9. Spring Boot 2 + Hibernate 5 Tutorials</h2> <div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-boot-2-hibernate-5-mysql-crud-rest-api-tutorial.html">Spring Boot 2 Hibernate 5 MySQL CRUD REST API Tutorial</a> - In this tutorial, we will learn how to develop CRUD RESTFul API using Spring boot 2, Hibernate 5, JPA, Maven, and MySQL database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/09/spring-mvc-using-spring-boot2-jsp-jpa-hibernate5-mysql-example.html">Spring MVC + Spring Boot2 + JSP + JPA + Hibernate 5 + MySQL Example</a> - In this article, we will learn how to develop a Spring MVC web application using Spring MVC, Spring boot 2, JSP, Hibernate 5, JPA, Maven, and MySQL database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/spring-boot-spring-mvc-spring-security-hibernate-mysql-tutorial.html">Spring Boot + Spring MVC + Spring Security + Hibernate + MySQL Tutorial</a> - In this article, we discuss how to create a user registration form with Spring Boot, Spring Security, Hibernate and Thymeleaf. We will develop a simple User Registration Module using Role-based Spring security which can use in any spring MVC based projects.</li> </ul> </div> <h2 style="text-align: left;"> 10. Spring MVC 5 + Hibernate 5 Tutorials</h2> <div> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/spring-mvc-5-hibernate-5-jsp-mysql-crud-tutorial.html">Spring MVC 5 + Hibernate 5 + JSP + MySQL CRUD Tutorial</a> - In this spring hibernate integration tutorial, we will learn how to create <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC </a>5 web application, handle form submission, integrate hibernate 5 to connect to the backend database. In this tutorial, we will integrate <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC 5+</a> with Hibernate ORM framework using Java-based configuration without any XML configuration.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/spring-mvc-5-spring-data-jpa-hibernate-jsp-mysql-tutorial.html">Spring MVC 5 + Spring Data JPA + Hibernate 5 + JSP + MySQL Tutorial</a> - In this tutorial, we will discuss the integration of <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC 5</a>, <a href="http://www.javaguides.net/p/spring-data-jpa-tutorial.html">Spring Data JPA</a>, Hibernate 5 and MySQL CRUD example. We will demonstrate CRUD(Create, Retrieve, Update, Delete) operations on a Customer entity as well as display list of customers from the MySQL database.</li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/11/spring-mvc-5-hibernate-5-xml-based-configuration-example.html">Spring MVC 5 + Hibernate 5 XML Based Configuration Example</a> - In this tutorial, we will integrate <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC </a>with Hibernate ORM framework using XML-based configuration.</li> </ul> </div> </div> </div>

microsoft/azure-spring-apps-training

Guides and tutorials to make the most out of Azure Spring Apps

2019-09-28T00:20:34Z

--- page_type: sample languages: - java --- # Azure Spring Apps training You will find here a full workshop on Azure Spring Apps, including guides and demos. You can run this workshop with the monthly free grant from Azure Spring Apps. [Learn More](https://aka.ms/costs-less) This lab is open-source, and under the [MIT license](LICENSE.txt). All Contributions are more then welcome! [Learn more at contribution guidelines.](CONTRIBUTING.md) <a href="https://github.com/microsoft/azure-spring-apps-training/graphs/contributors"> <img src="https://contrib.rocks/image?repo=microsoft/azure-spring-apps-training" /> </a> ## What you should expect This is not the official documentation but an opinionated training. It is a hands-on training, and it will use the command line extensively. The idea is to get coding very quickly and play with the platform, from a simple demo to far more complex examples. After completing all the guides, you should have a fairly good understanding of everything that Azure Spring Apps offers. ## Symbols >🛑 - __Manual Modification Required__. When this symbol appears in front of one or more commands, you will need to modify the commands as indicated prior to running them. >🚧 - __Preview-specific__. This symbol indicates steps that are only necessary while Azure Spring Apps is in preview. >💡 - __Frustration Avoidance Tip__. These will help you avoid potential pitfalls. ## [00 - Prerequisites and Setup](00-setup-your-environment/README.md) Prerequisites and environment setup. ## [01 - Create an Azure Spring Apps cluster](01-create-an-azure-spring-cloud-instance/README.md) Basics on creating a cluster and configuring the CLI to work efficiently. ## [02 - Build a simple Spring Boot microservice](02-build-a-simple-spring-boot-microservice/README.md) Build the simplest possible Spring Boot microservice using the Spring Initializr. ## [03 - Configure application logs](03-configure-monitoring/README.md) Access Spring Boot applications logs to understand common issues. ## [04 - Configure a Spring Cloud Config server](04-configure-a-spring-cloud-config-server/README.md) Configure a [Spring Cloud Config Server](https://cloud.spring.io/spring-cloud-config), that will be entirely managed and supported by Azure Spring Apps, to be used by Spring Boot microservices. ## [05 - Build a Spring Boot microservice using Spring Cloud features](05-build-a-spring-boot-microservice-using-spring-cloud-features/README.md) Build a Spring Boot microservice that is cloud-enabled: it uses a Spring Cloud Service Registry and a [Spring Cloud Config Server](https://cloud.spring.io/spring-cloud-config) which are both managed and supported by Azure Spring Apps. ## [06 - Build a reactive Spring Boot microservice using Cosmos DB](06-build-a-reactive-spring-boot-microservice-using-cosmosdb/README.md) Build a reactive Spring Boot microservice, that uses the [Spring reactive stack](https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html) and is bound to a [Cosmos DB database](https://docs.microsoft.com/en-us/azure/cosmos-db/?WT.mc_id=azurespringcloud-github-judubois) in order to access a globally-distributed database with optimum performance. ## [07 - Build a Spring Boot microservice using MySQL](07-build-a-spring-boot-microservice-using-mysql/README.md) Build a classical Spring Boot application that uses JPA to access a [MySQL database managed by Azure](https://docs.microsoft.com/en-us/azure/mysql/?WT.mc_id=azurespringcloud-github-judubois). ## [08 - Build a Spring Cloud Gateway](08-build-a-spring-cloud-gateway/README.md) Build a [Spring Cloud Gateway](https://spring.io/projects/spring-cloud-gateway) to route HTTP requests to the correct Spring Boot microservices. ## [09 - Putting it all together, a complete microservice stack](09-putting-it-all-together-a-complete-microservice-stack/README.md) Use a front-end to access graphically our complete microservice stack. Monitor our services with Azure Spring Apps's distributed tracing mechanism and scale our services depending on our needs. ## [10 - Blue/Green deployment](10-blue-green-deployment/README.md) Deploy new versions of applications in a staging environment and switch between staging and production with Azure Spring Apps. ## [11 - Configure CI/CD](11-configure-ci-cd/README.md) Configure a Continuous Integration / Continuous Deployment platform using GitHub Actions, so our Spring Boot microservices are automatically deployed. ## [12 - Making Microservices Talk to Each Other](12-making-microservices-talk-to-each-other/README.md) Creating a microservice that talks to other microservices. ## [Conclusion](99-conclusion/README.md) --- ## Legal Notices Microsoft and any contributors grant you a license to the Microsoft documentation and other content in this repository under the [Creative Commons Attribution 4.0 International Public License](https://creativecommons.org/licenses/by/4.0/legalcode), see the [LICENSE](LICENSE) file, and grant you a license to any code in the repository under the [MIT License](https://opensource.org/licenses/MIT), see the [LICENSE-CODE](LICENSE-CODE) file. Microsoft, Windows, Microsoft Azure and/or other Microsoft products and services referenced in the documentation may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries. The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks. Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653. Privacy information can be found at https://privacy.microsoft.com/en-us/ Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents, or trademarks, whether by implication, estoppel or otherwise.

micronaut-projects/micronaut-guides

Guides and Tutorials on how to use Micronaut including sample code

2021-01-05T12:04:44Z

# Micronaut Guides This is the main repository for the [Micronaut Guides](https://guides.micronaut.io). ## Build the guides To build all the guides run: ```shell $ ./gradlew build ``` This will generate all the projects and guides in `build/dist` and this is what needs to be published to GitHub Pages. To build a single guide, run the dynamic task created by `GuidesPlugin`; convert the kabab case guide directory name to lowerCamelCase and add "Build", e.g. to build `micronaut-http-client`, run ```shell ./gradlew micronautHttpClientBuild ``` ## Create a new guide For a high level overview of the Guides Infrastructure, take a look at this [blog post](https://micronaut.io/2021/04/12/improving-the-micronaut-guides-infrastructure/). All the guides leverage [Micronaut Starter](https://github.com/micronaut-projects/micronaut-starter) core to create the projects. The idea is that one guide can generate up to six different projects, one per language (Java, Groovy and Kotlin) and build tool (Gradle and Maven). ### Guide structure All the guides are in the `guides` directory in separate subdirectories. Inside the directory, the main file is `metadata.json` that describes the guide. All the fields are declared in [GuideMetadata](https://github.com/micronaut-projects/micronaut-guides/blob/master/buildSrc/src/main/groovy/io/micronaut/guides/GuideMetadata.groovy) class. ```json { "title": "Micronaut HTTP Client", "intro": "Learn how to use Micronaut low-level HTTP Client. Simplify your code with the declarative HTTP client.", "authors": ["Sergio del Amo", "Iván López"], "tags": ["client", "rx", "flowable", "json-streams"], "category": "Getting Started", "publicationDate": "2018-07-02", "apps": [ { "name": "default", "features": ["graalvm", "reactor"] } ] } ``` Besides, the obvious fields that doesn't need any further explanation, the other are: - `tags`: List of tags added to the guide. You don't need to include the language here because it is added automatically when generating the json file for the Guides webpage. - `category`: Needs to be a valid value from the [Category](https://github.com/micronaut-projects/micronaut-guides/blob/master/buildSrc/src/main/java/io/micronaut/guides/Category.java) enum. - `buildTools`: By default we generate the code in the guides for Gradle and Maven. If a guide is specific only for a build tool, define it here. - `languages`: The guides should be written in the three languages. Sometimes we only write guides in one language or the guide only supports a specific language. - `testFramework`: By default Java and Kotlin applications are tested with JUnit5 and Groovy applications with Spock. In some cases we have Java guides that are tested with Spock. Use this property to configure it. - `skipGradleTests`: Set it to `true` to skip running the tests for the Gradle applications for the guide. This is useful when it's not easy to run tests on CI, for example for some cloud guides. - `skipMavenTests`: Same as `skipGradleTests` but for Maven applications. - `minimumJavaVersion`: If the guide needs a minimum Java version (for example JDK 17 for Records), define it in this property. - `maximumJavaVersion`: If the guide needs a maximum Java version (for example JDK 11 for Azure Functions), define it in this property. - `zipIncludes`: List of additional files to include in the generated zip file for the guide. - `publish`: defaults to true for regular guides; set to false for partial/base guides - `base`: defaults to null; if set, indicates directory name of the base guide to copy before copying the current - `apps`: List of pairs `name`-`features` for the generated application. There are two types of guides, most of the guides only generate one application (single-app). In this case the name of the applications needs to be `default`. There are a few guides that generate multiple applications, so they need to be declared here: ```json ... "apps": [ { "name": "bookcatalogue", "features": ["tracing-jaeger", "management"] }, { "name": "bookinventory", "features": ["tracing-jaeger", "management"] }, { "name": "bookrecommendation", "features": ["tracing-jaeger", "management", "reactor"] } ] ``` The features need to be **valid** features from Starter because the list is used directly when generating the applications using Starter infrastructure. If you need a feature that is not available on Starter, create it in `buildSrc/src/main/java/io/micronaut/guides/feature`. Also declare the GAV coordinates and version in `buildSrc/src/main/resources/pom.xml`. Dependabot is configured in this project to look for that file and send pull requests to update the dependencies. Inside the specific guide directory there should be a directory per language with the appropriate directory structure. All these files will be copied into the final guide directory after the guide is generated. ```shell micronaut-http-client ├── groovy │ └── src │ ├── main │ │ └── groovy │ │ └── example │ │ └── micronaut │ └── test │ └── groovy │ └── example │ └── micronaut ├── java │ └── src │ ├── main │ │ └── java │ │ └── example │ │ └── micronaut │ └── test │ └── java │ └── example │ └── micronaut ├── kotlin │ └── src │ ├── main │ │ └── kotlin │ │ └── example │ │ └── micronaut │ └── test │ └── kotlin │ └── example │ └── micronaut └── src └── main └── resources ``` For multi-applications guides there needs to be an additional directory with the name of the application declared in `metadata.json` file: ```shell micronaut-microservices-distributed-tracing-zipkin ├── bookcatalogue │ ├── groovy │ │ ... │ ├── java │ │ ... │ └── kotlin │ ... ├── bookinventory │ ├── groovy │ │ ... │ ├── java │ │ ... │ └── kotlin │ ... └── bookrecommendation ├── groovy │ ... ├── java │ ... └── kotlin ``` ### Writing the guide There is only one Asciidoctor file per guide in the root directory of the guide (sibling to `metadata.json`). This unique file is used to generate all the combinations for the guide (language and build tool) so we need to take that into account when writing the guide. Name the Asciidoctor file the same as the directory, with an "adoc" extension, e.g. `micronaut-http-client.adoc` for the `micronaut-http-client` guide directory. We don't really write a valid Asciidoctor file but our "own" Asciidoctor with custom kind-of-macros. Then during the build process we render the final HTML for the guide in two phases. In the first one we evaluate all of our custom macros and include and generate a new language-build tool version of the guide in `src/doc/asciidoc`. This directory is excluded from source control and needs to be considered temporary. Then we render the final HTML of the (up to) six guides from that generated and valid Asciidoctor file. #### Placeholders You can use the following placeholders while writing a guide: * `@language@` * `@guideTitle@` * `@guideIntro@` * `@micronaut@` * `@lang@` * `@build@` * `@testFramework@` * `@authors@` * `@languageextension@` * `@testsuffix@` * `@sourceDir@` * `@minJdk@` * `@api@` * `@features@` * `@features-words@` #### Common snippets We have small pieces of text that are used in different guides. To avoid the duplication we have common snippets in the `src/docs/common` directory. For example the file `common-header-top.adoc`: ```asciidoc = @guideTitle@ @guideIntro@ Authors: @authors@ Micronaut Version: @micronaut@ ``` Will render the title, description, authors and version of all the guides. The variables defined between `@` signs will be evaluated and replaced during the first stage of the asciidoctor render. For example, for the Micronaut HTTP Client guide, the previous common snippet will generate: ```asciidoc // Start: common-header-top.adoc = Micronaut HTTP Client Learn how to use Micronaut low-level HTTP Client. Simplify your code with the declarative HTTP client. Authors: Sergio del Amo, Iván López Micronaut Version: 3.2.7 // End: common-header-top.adoc ``` #### Custom macros There are a number of custom macros available to make it easy writing a single asciidoctor file for all the guides and include the necessary source files, resources,... This is really important because when we include a source code snippet the base directory will change for every language the guide is written. The following snippet from the HTTP Client guide: ```asciidoc source:GithubConfiguration[] ``` Will generate the following Asciidoctor depending on the language of the guide: - Java: ```asciidoc [source,java] .src/main/java/example/micronaut/GithubConfiguration.java ---- include::{sourceDir}/micronaut-http-client-gradle-java/src/main/java/example/micronaut/GithubConfiguration.java[] ---- ``` - Groovy: ```asciidoc [source,groovy] .src/main/groovy/example/micronaut/GithubConfiguration.groovy ---- include::{sourceDir}/micronaut-http-client-gradle-groovy/src/main/groovy/example/micronaut/GithubConfiguration.groovy[] ---- ``` - Kotlin: ```asciidoc [source,kotlin] .src/main/kotlin/example/micronaut/GithubConfiguration.kt ---- include::{sourceDir}/micronaut-http-client-gradle-kotlin/src/main/kotlin/example/micronaut/GithubConfiguration.kt[] ---- ``` As you can see, the macro takes care of the directories (`src/main/java` vs `src/main/groovy` vs `src/main/kotlin`) and the file extension. Following this same approach there are macros like: - `source`: Already explained. - `resource`: To include a file from the `src/main/resources` directory. - `test`: To include a file from the `src/main/test` directory. This macro also takes care of the suffix depending on the test framework. For example, with `test:GithubControllerTest[]` the macro will reference the file `GithubControllerTest.java` (or .kt) for Java and Kotlin and `GithubControllerSpec.groovy` for Groovy. - `testResource`: To include a file from the `src/main/test/resources` directory. - `callout`: To include a common callout snippet. In all the cases it is possible to pass additional parameters to the macros to customise them. For example, to extract a custom tag from a snippet, we can do `resource:application.yml[tag=githubconfig]`. Look for usages of those macros in the `guides` directory to find more examples. #### Special custom blocks There are also special custom blocks to exclude some code to be included in the generated guide based on some condition. This is useful when explaining something specific of the build tool (like how to run the tests with Gradle or Maven) or to exclude something depending on the language (for example do not render the GraalVM section in Groovy guides, as Groovy is not compatible with GraalVM). Example: ```asciidoc :exclude-for-languages:kotlin <2> The Micronaut framework will not load the bean unless configuration properties are set. :exclude-for-languages: :exclude-for-languages:java,groovy <2> Kotlin doesn't support runtime repeatable annotations (see https://youtrack.jetbrains.com/issue/KT-12794[KT-12794]. We use a custom condition to enable the bean where appropriate. :exclude-for-languages: ``` For Java and Groovy guides the first block will be included. For Kotlin guide, the second block will be included. Example for build tool: ```asciidoc :exclude-for-build:maven Now start the application. Execute the `./gradlew run` command, which will start the application on port 8080. :exclude-for-build: :exclude-for-build:gradle Now start the application. Execute the `./mvnw mn:run` command, which will start the application on port 8080. :exclude-for-build: ``` For a Gradle guide, the first block will be included. For a Maven guide, the second one will be included. As before, look for usages of the macro in the `guides` directory for more examples. ### New Guide Template To create a new guide use the following template as the base asciidoc file: ```asciidoc common:header.adoc[] common:requirements.adoc[] common:completesolution.adoc[] common:create-app.adoc[] TODO: Describe the user step by step how to write the app. Use includes to reference real code: Example of a Controller source:HelloController[] Example of a Test test:HelloControllerTest[] common:testApp.adoc[] common:runapp.adoc[] common:graal-with-plugins.adoc[] :exclude-for-languages:groovy TODO describe how you consume the endpoints exposed by the native executable with curl :exclude-for-languages: TODO Use the generic next step common:next.adoc[] TODO or a personalised guide for the guide: == Next steps TODO: link to the documentation modules you used in the guide ``` ### Testing the guide When working on a new guide, generate it as explained before. The guide will be available in the `build/dist` directory and the applications will be in the `build/code` directory. You can open any directory in `build/code` directly in your IDE to make any changes but keep in mind copying the code back to the appropriate directory. In the `build/code` directory a file `test.sh` is created to run all the tests for the guides generated. Run it locally to make sure it passes before submitting a new pull request. You can run this test with a gradle task ```bash ./gradlew :____RunTestScript ``` where `____` is the camel-case name of your guide. eg: ```bash ./gradlew micronautFlywayRunTestScript ``` to run all the tests for the `micronaut-flyway` guide. ## Upgrade Micronaut version When a new Micronaut version is released, update the [version.txt](https://github.com/micronaut-projects/micronaut-guides/blob/master/version.txt) file in the root directory. Submit a new pull request and if the build passes, merge it. A few minutes later all the guides will be upgraded to the new version. ## Deployment Guides are published to [gh-pages](https://pages.github.com) following the same branch structure as Micronaut Core: - One directory per Micronaut minor version: `3.0.x`, `3.1.x`, `3.2.x`,... - One directory with the latest version of the guide: `latest` ## GitHub Actions There are two main jobs: - Java CI: Run everytime we send a pull request or something is merged in `master`. The `test.sh` script explained before is executed. - Java CI SNAPSHOT: There is a cronjob that runs daily the tests for the new Micronaut patch and minor versions to make sure everything will work when we release new versions in the future.

awsdocs/aws-doc-sdk-examples

Welcome to the AWS Code Examples Repository. This repo contains code examples used in the AWS documentation, AWS SDK Developer Guides, and more. For more information, see the Readme.md file below.

2016-08-18T19:06:57Z

[](https://github.com/awsdocs/aws-doc-sdk-examples/actions) [](https://github.com/marketplace/actions/super-linter) ![[]](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue) # AWS SDK Code Examples This repository contains code examples that demonstrate how to use the [AWSK SDKs](https://aws.amazon.com/developer/tools/) to interact with [AWS services](https://aws.amazon.com/products). Many examples are injected into the [AWS Documentation](https://docs.aws.amazon.com). ## How this repository is organized Code examples for each language's SDK can be found within the following subdirectories. The examples here demonstrate the most common uses of the SDK for each language. | SDK | folder | SDK version | |:----------:|:-----------------:|:-----------:| | .NET | [dotnetv3/](dotnetv3) | 3.5+ | | .NET | [dotnet/](.dotnet) | <3.5 | | C++ | [cpp/](cpp) | 1 | | Go | [gov2/](gov2) | 2 | | Go | [go/](go) | 1 | | Java | [javav2/](javav2) | 2 | | Java | [java/](java) | 1 | | JavaScript | [javascriptv3/](javascriptv3) | 3 | | JavaScript | [javascript/](javascriptv) | 2 | | Kotlin | [kotlin/](kotlin) | 1 | | PHP | [php/](php) | 3 | | Python | [python/](python) | 3 | | Ruby | [ruby/](ruby) | 3 | | Rust | [rustv1/](rustv1) | 1 | | Swift | [swift/](swift) | preview | Within each directory, you will find SDK-specific instructions for understanding and invoking example code. ### NOTE In alignment with our SDKs and Tools Maintenance Policy, the AWS SDK for Java v1.x will enter maintenance mode on July 31, 2024, and reach end-of-support on December 31, 2025. For more information, see [Announcing end-of-support for AWS SDK for Java v1.x](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/). ### Additional directories | directory | purpose | usage | |-------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [/applications](applications) | Contains the non-language-specific components of example applications, which show how the SDKs can be used in the context of a production-like application. | To view the language-specific components for each example application, see the `cross-service` folder in the sub-directory for your desired language (such as `python/cross-service`). | | [/test](test) | Contains all components supporting the custom test automation framework used to routinely test the code in this repository. | Deploys to AWS as a polyglot container-based integration testing solution. WARNING: Still under active construction as of 2023. | | [/resources](resources) | Contains shared components used by many code examples across this repository. | Deploys as frontend ([/clients](/resources/clients)) or backend ([/cdk](/resources/cdk) or [/cfn](/resources/cfn)) components. ## Invoke example code To invoke this example code, you must have an AWS account. For more information about creating an account, see [AWS Free Tier](https://aws.amazon.com/free/). You must also have AWS credentials configured. For steps on using the AWS Command Line Interface (AWS CLI) to configure credentials, see [CLI Configuration basics](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html) ## ⚠️ Usage disclaimer These code examples interact with services that may incur charges to your AWS account. For more information, see [AWS Pricing](https://aws.amazon.com/pricing/). Additionally, example code might theoretically modify or delete existing AWS resources. As a matter of due diligence, do the following: - Be aware of the resources that these examples create or delete. - Be aware of the costs that might be charged to your account as a result. - Back up your important data. # Contributing This repository thrives on your contributions! ❤️ To get involved, see the [CONTRIBUTING.md](CONTRIBUTING.md). 🙏 ## Tributaries The AWS Documentation includes source code examples from several additional sources. These sources are called tributaries, flowing into the "river" of AWS Documentation. * [awsdocs/aws-doc-sdk-examples](https://github.com/awsdocs/aws-doc-sdk-examples) * [aws-samples/serverless-snippets](https://github.com/aws-samples/serverless-snippets) * [aws/aws-tools-for-powershell](https://github.com/aws/aws-tools-for-powershell) # Copyright and license All content in this repository, unless otherwise stated, is Copyright © Amazon Web Services, Inc. or its affiliates. All rights reserved. Except where otherwise noted, all examples in this collection are licensed under the [Apache license, version 2.0](https://www.apache.org/licenses/LICENSE-2.0) (the "License"). The full license text is provided in the `LICENSE` file accompanying this repository.

chenmudu/open-telemetry-java-guides

Java OpenTelemetry 测试指南 ：Open-Telemetry-Java-Guides 案例，用于测试常用中间件支持及 Otel 相关组件的使用情况。 可观察性Sig: https://i.cloudnative.to/observability/

2020-12-13T10:31:07Z

### Open-Telemetry-Java-Guides 案例工程 > Open-Telemetry-Java-Guides案例，用于测试常用中间件支持及Otel相关组件的使用情况。关于更多Otel请访问Otel官网。 必读部分：[数据展示](#数据展示)、 [前言](#前言)、[环境准备](#环境准备)、[参数设置](#参数设置)， [启动测试服务](#启动测试服务)、[结果观测](#结果观测)、[测试服务列表](#测试服务列表)、[测试环境](#测试环境)、[测试库及框架列表](#测试库及框架列表). > 🔈：希望各位先fork，后clone,这样关于我新提交的东西您就可以观测到。如果仅仅clone，我的最新提交您可能感知不到。 个人无偿测试和搭建不易，麻烦赏颗星星，感谢您。🙇‍。 #### 数据展示 Otel-Col Info By ItSelf :  App-Trace Info By Jaeger:  App-Jvm-Metrics Info By Prometheus And Prometheus Gateway:  - 关于业务日志, 借助对应的日志框架实现自定义即可，后将数据对接至Otel-Collector即可。 - 中心化管控：Biz Logging, Trace, Metrics 较为方便。~~还未尝试Otel让 个人 最惊喜的Tail-Base-Smaple规则。~~ - 关于Otel-Col的Tailed Base采样已尝鲜，值得注意的是，该功能的局限性： 1. 基于尾部采样仅仅适合在单个 Collector 内可成功运行，多个Collector之间组成的集群官方及个人均未测试。 1. 基于尾部采样的规则，目前仅仅适用于Trace，其实个人觉得更重要的是业务的Logging数据。 #### 前言 - Open Telemetry(下面简称 Otel(与Open Tracing 的Ot做区分))[相关资料及文档](https://opentelemetry.io/docs/java/getting_started/)。 - 搭建最小测试版的guides服务，仅仅是为了体验和测试Otel，故此数据仅存于内存中。 - arch:  #### 环境准备 1. ~~暂时不~~选择Otel-Collector，选择使用最小版Jaeger进行观测。关于[如何安装All in One](https://www.jaegertracing.io/docs/1.16/getting-started/)的Jaeger。 2. 下载[Otel-Javaagent.jar](https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/download/v0.12.0/opentelemetry-javaagent-all.jar)至磁盘目录下,[关于Latest release](https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases) ，目前[最新版本为Beta 0.12.0](https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/tag/v0.12.0)。 3. 拉取[Otel-Col-Docker-Image](https://hub.docker.com/search?q=otel&type=image). 4. 关于docker 安装相关组件请移步[这儿](https://github.com/chenmudu/open-telemetry-java-guides/tree/master/config/others.properties) #### 参数设置 1. 设置VmOptions,指向磁盘中的otel-javaagent.jar的置放目录。 ```sh java -javaagent:path/to/opentelemetry-javaagent-all.jar ``` 2. 设置VmOptions,关于Exporter,otel默认为自己的OTLP Exporter,这里我们选择~~使用zipkin作为默认Exporter，其兼容jaeger的RestApi。使用Http方式上报至Jaeger的Collector中(~~也可以使用Otel-Collector~~)~~。 ```sh // 省略此步骤，当你使用Otel-Collector的时候。 -Dotel.exporter=zipkin ``` 3. 向Environment variable添加参数对： ```sh OTEL_RESOURCE_ATTRIBUTES=service.name=otel-simple-moudlename ``` 4. 关于[Otel官方参数设置。](https://github.com/open-telemetry/opentelemetry-java-instrumentation#getting-started) #### 关于Otel-Collector 1. Docker/Windows 安装 Otel-Collector即可。 2. 向Environment variable添加参数对： ```sh OTEL_RESOURCE_ATTRIBUTES=service.name=your service name ``` 3. 关于[Otel-Collector-Design](https://github.com/open-telemetry/opentelemetry-collector/blob/master/docs/design.md) #### 启动测试服务 git clone 当前项目. 选择测试的模块(确保[环境准备](#环境准备)、[参数设置](#参数设置)已经完成)。详情请进入子模块测试服务read me file,启动子模块。 #### 结果观测 1. 确保[环境准备](#环境准备)、[参数设置](#参数设置)，[启动测试服务](#启动测试服务)已按步完成。 2. 访问Jaeger-Ui即可观测结果，按步完成后UI默认地址为:http://localhost:16686/。 #### 测试服务列表 * [Open-Telemetry-Java 示例工程（基于 Spring MVC 示例WebMvc）](otel-simple-webmvc) * [Open-Telemetry-Java 示例工程（基于 Spring MVC 示例Tail Based采样）](otel-simple-tailbase) * [Open-Telemetry-Java 示例工程（基于 Rest Clients 示例RestClient）](otel-simple-restclient) * [Open-Telemetry-Java 示例工程（基于 Spring Webflux 示例WebFlux）](otel-simple-webflux) * [Open-Telemetry-Java 示例工程（基于 Spring Rdb 示例Rdb）](otel-simple-rdb) * [Open-Telemetry-Java 示例工程（基于 Spring Async 示例Async）](otel-simple-async) * [Open-Telemetry-Java 示例工程（基于 Spring Data 示例Data系列）](otel-simple-spring-data) * [Open-Telemetry-Java 示例工程（基于 Spring Amqp 示例RabbitMq）](otel-simple-rabbit) * [Open-Telemetry-Java 示例工程（基于 Spring Kafka 示例KafkaMq）](otel-simple-kafka) * [Open-Telemetry-Java 示例工程（基于 Spring Neo4j 示例Neo4j）](otel-simple-neo4j) * [Open-Telemetry-Java 示例工程（关于 Otel Collector 个人配置参考）](https://github.com/chenmudu/open-telemetry-java-guides/tree/master/config/otel-col-config.yaml) #### 测试环境 - JDK Version: 1.8.0_171 & Open-Jdk:11-2018.09.25 - Otel Java Agent Version: 0.12.0 & 0.14.1 - Otel Collector Win10 Version: 0.16.0 - Otel Collector Docker Version: 0.16.0-Dev - Otel Collector Contrib Docker Version: 0.17.0-Dev - Maven Version: 3.3.9 - IDEA Version: 2018.1.5 x64 - OS Version: Win10 - Docker Version: 19.03.13 - JVM Info: Java HotSpot(TM) 64-Bit Server VM (25.171-b11, mixed mode) - Others：Prometheus, Prometheus Gateway, Jaeger All In One, Grafana ... #### 测试库及框架列表 | Library/Framework | Versions |Test Result |官方最低版本支持 | |---------------------------|--------------------------------|--------------------------|-----------------| | Servlet | 4.0 |Y | 2.2+ | | WebMvc | 5.1.15 |Y | 3.1+ | | WebFlux | 5.1.15 |Y | 5.0+ | | RestTemplate(sync & async)| 5.1.15 |N/Y(错当rest temeplate为http client. 且不支持 async resttemplate.)故此推荐，如果生产使用RestTemplate，将其底层替换为HttpClient，包括连接池、其他参数等| 官方无支持| | ApacheHttpClient(sync & async) | 4.5.12/4.1.4 |Y | 2.0+/1.9+ (not including 2.x yet)| | HttpUrlConnection | java8 |Y | Java 7+ | | OkHttp(sync & async) | 3.6.0 |Y | 3.0+ | | JdbcMysqlConnector | 8.0.22 |Y | 无 | | Spring-Data-Jdbc | 2.1.14(1.0.17.RELEASE) |Y | 1.8+ | | Spring-Data-Jpa | 2.1.14(2.1.17.RELEASE) |Y | 1.8+ | | Spring-Data-Rest | 2.1.14(3.1.17.RELEASE) |Y | 1.8+ | | Spring-Data-Mongo | 2.1.14(2.1.17.RELEASE) |Y | 1.8+ | | Spring-data-Redis | 2.1.14(2.1.17.RELEASE) |Y | 1.8+ | | lettuce-core | 5.1.8.RELEASE |Y | 4.0+ (not including 6.x yet) | | Jedis-Client | 2.9.0 |Y | 1.4+ | | Redisson-Client | 0.0.0 |N 还未测试 | 3.0+ | | Spring-data-Es | 2.1.14(3.1.17.RELEASE) |Y | 1.8+ | | Spring-data-Neo4j | 2.1.14(5.1.17.RELEASE) |N 还未测试 | 1.8+ | | Spring-Rabbit | 2.1.14(2.1.14.RELEASE) |Y | 无 | | Rabbit-Client | 5.4.3 |Y | 2.7+ | | Spring-Kafka | 2.1.13 |Y | 无 | | Kafka-Client | 2.0.1 |Y | 0.11+ | | ....... | ..... |Y | | #### 关于其他 - 单个服务应当部署单独的Otel-Agent去收集你的Logging、Trace、Metrics。 - 在每条业务架设对应的Otel-Col-Gateway去做总线收集较为妥当(划分依据参考自身业务)。 - 至于更大的集群模式，请自行尝试。暂时切莫用于生产，待官方发布GA版本，个人将预先尝试。

xujijun/spring-boot-101

Guides to spring-boot configurations, such as mybatis, redis, cache, etc.

2016-04-26T03:15:57Z

# spring-boot-101 A handy code guidance of spring-boot. ## Functionality List - Web configuration and static page support - log4j2 configuration - mySql and myBatis configuration - mongoDB configuration - Redis Cluster configuration - Caffeine Cache configuration - RESTful API - Different configuration profiles for different environments - Retrieve properties from application.yml (refer to: read-properties) - Velocity template (deprecated) - FreeMarker template - Mail - Scheduler - @Async configuration - Actuator: service status monitor - AOP, interceptor - web-socket: server(java) and client(html with vue.js)

sofastack-guides/sofa-tracer-guides

2019-10-17T07:20:17Z

# SOFATracer 案例工程 * [SOFATracer 示例工程（基于 Spring MVC 示例落地日志）](tracer-sample-with-springmvc) * [SOFATracer 示例工程（基于 Spring MVC 示例远程上报 Zipkin）](tracer-sample-with-zipkin) * [SOFATracer 示例工程（基于 SOFA RPC 示例落地日志）](tracer-sample-with-sofarpc) * [SOFATracer 示例工程（基于日志编程接口 SLF4J 示例打印 traceId）](tracer-sample-with-slf4j) * [SOFATracer 示例工程（基于 DataSource 示例落地日志）](tracer-sample-with-h2) * [SOFATracer 示例工程（基于 HttpClient 示例落地日志）](tracer-sample-with-httpclient) * [SOFATracer 示例工程（SOFATracer 采样策略）](tracer-sample-with-sampler) * [SOFATracer 示例工程（SOFATracer 集成 SpringCloud）](tracer-sample-with-openfeign) * [SOFATracer 示例工程（SOFATracer 集成 Dubbo）](tracer-sample-with-dubbo) * [SOFATracer 示例工程（SOFATracer 集成 RestTemplate）](tracer-sample-with-resttemplate) * [SOFATracer 示例工程（SOFATracer 监听收集摘要日志）](tracer-sample-with-catchbiz)

vert-x3/vertx-guide-for-java-devs

Vert.x 3 guide for Java developers

2017-06-09T08:07:34Z

larsgeorge/hbase-book

Contains the code used in the HBase: The Definitive Guide book.

2010-08-12T18:42:44Z

RameshMF/spring-mvc-tutorial

Spring MVC 5 Tutorial - Guide to spring mvc framework

2018-10-15T07:22:41Z

<div dir="ltr" style="text-align: left;" trbidi="on"> <div class="font-family-page"> This is beginners to expert Spring MVC Tutorial. We have used the latest release of Spring Framework 5+ in all examples. This tutorial gives you all the possible Spring MVC features that are required to build a Spring-based enterprise J2EE web applications or RESTful APIs.<br> <div class="separator" style="clear: both; text-align: center;"> <a href="https://2.bp.blogspot.com/-B8_PfyFtwJI/W-qRXEMCV_I/AAAAAAAAErw/TtY7bf8xxBoj5ldGe_nRJlXJZ9-0w-klQCLcBGAs/s1600/spring-mvc-tutorial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="240" data-original-width="480" src="https://2.bp.blogspot.com/-B8_PfyFtwJI/W-qRXEMCV_I/AAAAAAAAErw/TtY7bf8xxBoj5ldGe_nRJlXJZ9-0w-klQCLcBGAs/s1600/spring-mvc-tutorial.png"></a></div> <div class="separator" style="clear: both; text-align: center;"> </div> <br> In this tutorial, you will learn Spring MVC with Spring Boot, Spring MVC with Spring Security, Spring MVC with Hibernate and JPA etc.<br> <br> <b>The source code examples of each article are developed using latest Spring 5.1.0 RELEASE, JDK 8 and Maven 3.2+.</b><br> <h2 style="text-align: left;"> Spring MVC Getting Started/Basics</h2> <a href="http://www.javaguides.net/2018/10/spring-mvc-5-hello-world-example.html">Spring MVC 5 - Hello World Example</a> - In this article, we will learn how to create a simple Hello World Spring MVC Application using Spring MVC 5 +, JSP, Maven build tool and Eclipse IDE<br> <br> <div> <a href="http://www.javaguides.net/2018/10/spring-mvc-sign-up-form-handling.html">Spring MVC 5 - Sign Up Form Handling Example</a> - In this article, we will learn how to create and submit a simple form (signup form) in Spring MVC application using Spring MVC 5+, Maven build tool, JSP and Eclipse IDE or STS.<br> <br> <a href="http://www.javaguides.net/2018/10/spring-mvc-jsp-form-tags-tutorial.html">Spring MVC JSP Form Tags Tutorial</a> - In this tutorial, we're going discuss all Spring MVC form tags and we will use important spring MVC form tags such as form tag, text fields tag, select tag, check-box(s), radio box(s), password tag, button tag, errors tag etc.<br> <br> <a href="http://www.javaguides.net/2018/10/spring-mvc-form-validation-with-annotations-tutorial.html">Spring MVC 5 Form Validation with Annotations Tutorial</a> - In this quick tutorial, we're going to learn about Spring MVC form validation using annotations like @NotNull, @Size, @Min, @Max, @Email, @Pattern etc.<br> <h2 style="text-align: left;"> Spring MVC 5 and Hibernate 5 Integration</h2> <div> <a href="http://www.javaguides.net/2018/11/spring-mvc-5-hibernate-5-jsp-mysql-crud-tutorial.html" target="_blank">Spring MVC 5 + Hibernate 5 + JSP + MySQL CRUD Tutorial</a>&nbsp;- In this spring hibernate integration tutorial, we will learn how to create <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC </a>5 web application, handle form submission, integrate hibernate 5 to connect to the backend database. In this tutorial, we will integrate <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC 5+</a> with Hibernate ORM framework using Java-based configuration without any XML configuration.</div> <div> <br></div> <div> <a href="http://www.javaguides.net/2018/11/spring-mvc-5-spring-data-jpa-hibernate-jsp-mysql-tutorial.html" target="_blank">Spring MVC 5 + Spring Data JPA + Hibernate 5 + JSP + MySQL Tutorial</a>&nbsp;-&nbsp;In this tutorial, we will discuss the integration of <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC 5</a>, <a href="http://www.javaguides.net/p/spring-data-jpa-tutorial.html">Spring Data JPA</a>, Hibernate 5 and MySQL CRUD example. We will demonstrate CRUD(Create, Retrieve, Update, Delete) operations on a Customer entity as well as display list of customers from the MySQL database.</div> <div> <br></div> <div> <a href="http://www.javaguides.net/2018/09/spring-mvc-using-spring-boot2-jsp-jpa-hibernate5-mysql-example.html">Spring MVC + Spring Boot2 + JSP + JPA + Hibernate 5 + MySQL Example</a>&nbsp;- In this article, we will learn how to develop a Spring MVC web application using Spring MVC, Spring boot 2, JSP, Hibernate 5, JPA, Maven, and MySQL database.<br> <br> <a href="http://www.javaguides.net/2018/09/spring-boot2-mvc-web-application-thymeleaf-jpa-mysql-example.html">Spring Boot 2 MVC Web Application Thymeleaf JPA MySQL Example</a>&nbsp;- In this article, we will learn how to develop a Spring MVC web application using Spring boot 2, Thymeleaf, Hibernate 5, JPA, Maven, and MySQL database.<br> <br> <a href="http://www.javaguides.net/2018/11/spring-mvc-5-hibernate-5-xml-based-configuration-example.html" target="_blank">Spring MVC 5 + Hibernate 5 XML Based Configuration Example</a>&nbsp;-&nbsp;<span style="background-color: white; color: #24292e; font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Helvetica, Arial, sans-serif, &quot;Apple Color Emoji&quot;, &quot;Segoe UI Emoji&quot;, &quot;Segoe UI Symbol&quot;; font-size: 16px;">I</span>n this tutorial, we will integrate <a href="http://www.javaguides.net/p/spring-mvc-tutorial.html">Spring MVC </a> with Hibernate ORM framework using XML-based configuration.</div> </div> <div> <h2 style="text-align: left;"> Spring MVC + Spring Boot Articles</h2> </div> <a href="http://www.javaguides.net/2018/09/spring-mvc-using-spring-boot2-jsp-jpa-hibernate5-mysql-example.html">Spring MVC + Spring Boot2 + JSP + JPA + Hibernate 5 + MySQL Example</a> - In this article, we will learn how to develop a Spring MVC web application using Spring MVC, Spring boot 2, JSP, Hibernate 5, JPA, Maven, and MySQL database.<br> <br> <a href="http://www.javaguides.net/2018/09/spring-boot2-mvc-web-application-thymeleaf-jpa-mysql-example.html">Spring Boot 2 MVC Web Application Thymeleaf JPA MySQL Example</a> - In this article, we will learn how to develop a Spring MVC web application using Spring boot 2, Thymeleaf, Hibernate 5, JPA, Maven, and MySQL database.<br> <br> <a href="http://www.javaguides.net/2018/10/spring-boot-spring-mvc-validating-form.html">Spring Boot 2 - Spring MVC + Thymeleaf Input Form Validation</a> - In this quick article, we will discuss the process of configuring a web application form to support validation. We will use latest Spring boot 2.0.5 RELEASE, Hibernate validator with Thymeleaf to develop simple Spring MVC web application. We get Hibernate Validator for free when we use Spring Boot Starter Web.<br> <div> <h2 style="text-align: left;"> Spring MVC + Spring Boot&nbsp; + Spring Security</h2> </div> <a href="http://www.javaguides.net/2018/09/spring-boot-spring-mvc-role-based-spring-security-jpa-thymeleaf-mysql-tutorial.html">Spring Boot 2 + Spring MVC + Role Based Spring Security + JPA + Thymeleaf + MySQL Tutorial</a> -In this tutorial, we will learn how to use the Spring Boot Security Starter to secure SpringMVC-based web applications. We will develop step by step Message Storing Spring MVC web application(securing with spring security) using spring boot, spring MVC, role-based spring security, JPA, thymeleaf, and MySQL.<br> <br> <a href="https://spring.io/guides/gs/authenticating-ldap/">Authenticating a User with LDAP using Spring Boot and Spring Security</a> - This guide walks you through the process creating an application and securing it with the <a href="https://projects.spring.io/spring-security/">Spring Security</a> LDAP module.<br> <br> <a href="http://www.javaguides.net/2018/10/user-registration-module-using-springboot-springmvc-springsecurity-hibernate5-thymeleaf-mysql.html">User Registration Module using Spring Boot 2 + Spring MVC + Spring Security + Hibernate 5 + Thymeleaf + MySQL</a> - In this article, we discuss how to create a user registration form with Spring Boot, Spring Security, Hibernate and Thymeleaf. We validate the user registration fields with hibernate validator annotations and a custom field matching validator to validate if the email and/or password fields match. We will create Role-based Spring security with a MySQL database.<br> <div> <h2> Spring MVC Annotations</h2> <a href="http://www.javaguides.net/2018/11/the-spring-controller-and-restcontroller-annotations-with-examples.html">The Spring @Controller and @RestController Annotations with Examples</a>&nbsp;- In this quick article, we’ll discuss the difference between @Controller and @RestController annotations in Spring MVC.<br> <br></div> <div> <a href="http://www.javaguides.net/2018/11/spring-requestbody-and-responsebody-annotations.html">Spring @RequestBody and @ResponseBody Annotations</a>&nbsp;- In this quick article, we will discuss usage Spring @RequestBody and @ResponseBody annotations with examples.@RequestBody and @ResponseBody annotations are used to bind the HTTP request/response body with a domain object in method parameter or return type. Behind the scenes, these annotation uses HTTP Message converters to convert the body of HTTP request/response to domain objects.<br> <br> <a href="http://www.javaguides.net/2018/11/spring-getmapping-postmapping-putmapping-deletemapping-patchmapping.html">Spring @GetMapping, @PostMapping, @PutMapping, @DeleteMapping&nbsp;and&nbsp;@PatchMapping</a>&nbsp;- In this article, we will discuss Spring 4.3. introduced HTTP method specific shortcut variants of @RequestMappingare @GetMapping, @PostMapping, @PutMapping, @DeleteMapping and @PatchMapping annotations with sample code examples.<br> <br> <a href="http://www.javaguides.net/2018/11/spring-web-mvc-annotations.html">Spring Web MVC Annotations</a>&nbsp;- In this tutorial, we’ll explore Spring Web annotations from the&nbsp;<a href="https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/">org.springframework.web.bind.annotation</a>&nbsp;package.</div> <div> <div class="font-family-page"> <h2 style="text-align: left;"> Spring MVC + Spring Boot Mini Projects</h2> <a href="http://www.javaguides.net/2018/09/mini-todo-management-project-using-spring-boot-springmvc-springsecurity-jsp-hibernate-mysql.html">Mini Todo Management Project using Spring Boot + Spring MVC + Spring Security + JSP + Hibernate + MySQL</a> - In this article, we will learn how to develop Spring MVC Todo Management web application using Spring Boot, Spring MVC, Spring Security, JSP, JPA and MySQL as a database.<br> <br> <a href="http://www.javaguides.net/2018/10/user-registration-module-using-springboot-springmvc-springsecurity-hibernate5-thymeleaf-mysql.html">User Registration Module using Spring Boot + Spring MVC + Spring Security + Hibernate 5 + Thymeleaf + MySQL</a> - In this article, we discuss how to create a user registration form with Spring Boot, Spring Security, Hibernate and Thymeleaf. We validate the user registration fields with hibernate validator annotations and a custom field matching validator to validate if the email and/or password fields match. We will create Role-based Spring security with a MySQL database.</div> <div class="font-family-page"> <br></div> <a href="http://www.javaguides.net/2018/10/20-free-open-source-projects-using-spring-framework.html">20+ Free Open Source Projects Using Spring Framework</a>&nbsp;// Very Useful<br> <h2 style="text-align: left;"> Useful Links and Resources</h2> <div> <a href="https://stackoverflow.com/questions/6827752/whats-the-difference-between-component-repository-service-annotations-in" target="_blank">What's the difference between @Component, @Repository &amp; @Service annotations in Spring?</a></div> <div> <a href="https://stackoverflow.com/questions/3153546/how-does-autowiring-work-in-spring" target="_blank">How does autowiring work in Spring?</a></div> <div> <a href="https://www.baeldung.com/spring-component-repository-service" target="_blank">@Component vs @Repository and @Service in Spring</a></div> <div> <a href="https://stackoverflow.com/questions/3423262/what-is-modelattribute-in-spring-mvc" target="_blank">What is @ModelAttribute in Spring MVC?</a></div> <div> <a href="https://stackoverflow.com/questions/25242321/difference-between-spring-controller-and-restcontroller-annotation" target="_blank">Difference between spring @Controller and @RestController annotation</a></div> <div> <a href="https://stackoverflow.com/questions/13715811/requestparam-vs-pathvariable" target="_blank">@RequestParam vs @PathVariable</a></div> <div> <a href="https://stackoverflow.com/questions/2513031/multiple-spring-requestmapping-annotations" target="_blank">Multiple Spring @RequestMapping annotations</a></div> <div> <a href="https://stackoverflow.com/questions/2769467/what-is-dispatcher-servlet-in-spring" target="_blank">What is Dispatcher Servlet in Spring?</a></div> <div> <a href="https://stackoverflow.com/questions/21827548/spring-get-current-applicationcontext" target="_blank">Spring get current ApplicationContext</a></div> <div> <a href="https://stackoverflow.com/questions/17955777/redirect-to-an-external-url-from-controller-action-in-spring-mvc" target="_blank">Redirect to an external URL from controller action in Spring MVC</a></div> <div> <a href="https://stackoverflow.com/questions/2746598/alternatives-to-jsp-for-spring-mvc-view-layer" target="_blank">Alternatives to JSP for Spring MVC view layer</a></div> <div> <a href="https://stackoverflow.com/questions/42944777/difference-between-jax-rs-and-spring-rest" target="_blank">Difference between JAX-RS and Spring Rest</a></div> <div class="font-family-page"> <h2 style="text-align: left;"> Spring Framework Related Tutorials</h2> <blockquote class="tr_bq"> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/p/spring-boot-tutorial.html">Spring Boot 2 Tutorial</a></li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/p/spring-core-tutorial.html">Spring Core 5 Tutorial</a></li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/p/spring-data-jpa-tutorial.html">Spring Data JPA Tutorial</a></li> </ul> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/p/spring-framework.html">Spring Framework 5</a></li> </ul> </blockquote> </div> </div> </div> </div>

Hanope/spring-guides

http://spring.io/guides/ 예제 번역작업 프로젝트

2018-10-19T14:03:02Z

# 프로젝트 소개 `spring-guides` 프로젝트는 영어가 어려워 spring에서 제공하는 공식 레퍼런스를 읽기 힘드신 분들을 위해 한글화 작업을 진행하는 프로젝트입니다. 번역이 일회성으로 끝나는 것이 아닌 많은 분들과 함께 진행하여 가이드 또는 레퍼런스가 업데이트됐을 때 최신 번역 자료를 많은 분들께 제공하고자 합니다. 이미 훌륭한 분들께서 레퍼런스를 작업을 하셨지만, 개인 블로그나 저장소에 흩어져 있으며, 특정 버전의 번역 작업만 이루어져 있고 (특정 버전 1회성 번역으로 끝남) 최신 버전의 내용은 번역이 안되고 있는 것 같습니다. `spring-guides` 번역 프로젝트를 통해 한국 spring 개발자 분들을 위해 최신의 가이드와 레퍼런스 자료를 제공하는 것이 목표입니다. 우선은 [spring-guides](https://spring.io/guides/)를 먼저 번역을 시작하고자 합니다. 이 작업이 끝나면 `spring reference` 번역 작업을 진행하고자 합니다. 많은 분들과 함께 번역 작업을 진행하여 최신 자료들을 빠르게 반영하고, 번역 작업을 진행하면서 발생하는 오타 및 오역을 바로잡고 우수한 자료를 만들고자 오픈소스 프로젝트를 진행하기로 하였습니다. 번역 작업이 까다롭고 시간도 오래 걸리겠지만, 영어가 어려운 국내 개발자분들을 위해 도움을 주실 수 있으면 좋겠습니다. 여러분들의 `contribution`은 언제나 환영입니다. # 컨트리뷰션 하는 방법 [issue](https://github.com/Hanope/spring-guides/issues) 페이지에 [spring.io](https://spring.io)에 등록된 가이드들이 있습니다. 번역에 관심 있는 `issue`에 `comment` 혹은 `관심`을 표해주시고 번역 작업을 진행해 주시면 됩니다. [issue](https://github.com/Hanope/spring-guides/issues)에 등록된 가이드들의 영문 자료는 각 폴더에 README.md 파일로 등록이 되어있습니다. 해당 파일을 번역하여 Pull Request 주시면 됩니다.

CodeIntelligenceTesting/jazzer

Coverage-guided, in-process fuzzing for the JVM

2021-01-28T19:08:19Z

<div align="center"> <a href="https://code-intelligence.com"><img src="https://www.code-intelligence.com/hubfs/Logos/CI%20Logos/Jazzer_einfach.png" height=150px alt="Jazzer by Code Intelligence"> </a> <h1>Jazzer</h1> <p>Fuzz Testing for the JVM</p> <a href="https://github.com/CodeIntelligenceTesting/jazzer/releases"> <img src="https://img.shields.io/github/v/release/CodeIntelligenceTesting/jazzer" alt="Releases"> </a> <a href="https://search.maven.org/search?q=g:com.code-intelligence%20a:jazzer"> <img src="https://img.shields.io/maven-central/v/com.code-intelligence/jazzer" alt="Maven Central"> </a> <a href="https://github.com/CodeIntelligenceTesting/jazzer/actions/workflows/run-all-tests.yml?query=branch%3Amain"> <img src="https://img.shields.io/github/actions/workflow/status/CodeIntelligenceTesting/jazzer/run-all-tests.yml?branch=main&logo=github" alt="CI status"> </a> <a href="https://github.com/CodeIntelligenceTesting/jazzer/blob/main/LICENSE"> <img src="https://img.shields.io/github/license/CodeIntelligenceTesting/jazzer" alt="License"> </a> <a href="https://github.com/CodeIntelligenceTesting/jazzer/blob/main/CONTRIBUTING.md"> <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs welcome" /> </a> <br /> <a href="https://www.code-intelligence.com/" target="_blank">Website</a> | <a href="https://www.code-intelligence.com/blog" target="_blank">Blog</a> | <a href="https://twitter.com/CI_Fuzz" target="_blank">Twitter</a> </div> > [!IMPORTANT] > Hello Jazzer/Jazzer.js users! > > We stopped maintaining Jazzer/Jazzer.js as open source. > But we'd be happy to try and understand what you're trying to achieve with it, and help you if we can! > > We already added significant new value to our CI Fuzz solution, which includes Jazzer and Jazzer.js. > Learn more on how to turbocharge your Java Fuzz Testing with [Jazzer Pro](https://www.code-intelligence.com/introducing-jazzer-pro). > > Visit [code-intelligence.com](https://code-intelligence.com) for more information, or get in contact with us via [sales@code-intelligence.com](mailto:sales@code-intelligence.com). > > Thanks, > > The Code Intelligence team Jazzer is a coverage-guided, in-process fuzzer for the JVM platform developed by [Code Intelligence](https://code-intelligence.com). It is based on [libFuzzer](https://llvm.org/docs/LibFuzzer.html) and brings many of its instrumentation-powered mutation features to the JVM. Jazzer currently supports the following platforms: * Linux x86_64 * macOS 12+ x86_64 & arm64 * Windows x86_64 ## Quick start You can use Docker to try out Jazzer's Autofuzz mode, in which it automatically generates arguments to a given Java function and reports unexpected exceptions and detected security issues: ``` docker run -it cifuzz/jazzer-autofuzz \ com.mikesamuel:json-sanitizer:1.2.0 \ com.google.json.JsonSanitizer::sanitize \ --autofuzz_ignore=java.lang.ArrayIndexOutOfBoundsException ``` Here, the first two arguments are the Maven coordinates of the Java library and the fully qualified name of the Java function to be fuzzed in "method reference" form. The optional `--autofuzz_ignore` flag takes a list of uncaught exception classes to ignore. After a few seconds, Jazzer should trigger an `AssertionError`, reproducing a bug it found in this library that has since been fixed. ## Using Jazzer via... ### JUnit 5 The following steps assume that JUnit 5.9.0 or higher is set up for your project, for example based on the official [junit5-samples](https://github.com/junit-team/junit5-samples). 1. Add a dependency on `com.code-intelligence:jazzer-junit:<latest version>`. All Jazzer Maven artifacts are signed with [this key](deploy/maven.pub). 2. Add a new *fuzz test* to a new or existing test class: a method annotated with [`@FuzzTest`](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-junit/com/code_intelligence/jazzer/junit/FuzzTest.html) and at least one parameter. Using a single parameter of type [`FuzzedDataProvider`](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html), which provides utility functions to produce commonly used Java values, or `byte[]` is recommended for optimal performance and reproducibility of findings. 3. Assuming your test class is called `com.example.MyFuzzTests`, create the *inputs directory* `src/test/resources/com/example/MyFuzzTestsInputs`. 4. Run a fuzz test with the environment variable `JAZZER_FUZZ` set to `1` to let the fuzzer rapidly try new sets of arguments. If the fuzzer finds arguments that make your fuzz test fail or even trigger a security issue, it will store them in the inputs directory. In this mode, only a single fuzz test is executed per test run (see [#599](https://github.com/CodeIntelligenceTesting/jazzer/issues/599) for details). 5. Run the fuzz test without `JAZZER_FUZZ` set to execute it only on the inputs in the inputs directory. This mode, which behaves just like a traditional unit test, ensures that issues previously found by the fuzzer remain fixed and can also be used to debug the fuzz test on individual inputs. A simple property-based fuzz test could look like this (excluding imports): ```java class ParserTests { @Test void unitTest() { assertEquals("foobar", SomeScheme.decode(SomeScheme.encode("foobar"))); } @FuzzTest void fuzzTest(FuzzedDataProvider data) { String input = data.consumeRemainingAsString(); assertEquals(input, SomeScheme.decode(SomeScheme.encode(input))); } } ``` A complete Maven example project can be found in [`examples/junit`](examples/junit). ### GitHub releases You can also use GitHub release archives to run a standalone Jazzer binary that starts its own JVM configured for fuzzing: 1. Download and extract the latest release from the [GitHub releases page](https://github.com/CodeIntelligenceTesting/jazzer/releases). 2. Add a new class to your project with a <code>public static void fuzzerTestOneInput(<a href="https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html">FuzzedDataProvider</a> data)</code> method. 3. Compile your fuzz test with `jazzer_standalone.jar` on the classpath. 4. Run the `jazzer` binary (`jazzer.exe` on Windows), specifying the classpath and fuzz test class: ```shell ./jazzer --cp=<classpath> --target_class=<fuzz test class> ``` If you see an error saying that `libjvm.so` has not been found, make sure that `JAVA_HOME` points to a JDK. The [`examples`](examples/src/main/java/com/example) directory includes both toy and real-world examples of fuzz tests. ### Docker The "distroless" Docker image [cifuzz/jazzer](https://hub.docker.com/r/cifuzz/jazzer) includes a recent Jazzer release together with OpenJDK 17. Mount a directory containing your compiled fuzz target into the container under `/fuzzing` and use it like a GitHub release binary by running: ```sh docker run -v path/containing/the/application:/fuzzing cifuzz/jazzer --cp=<classpath> --target_class=<fuzz test class> ``` If Jazzer produces a finding, the input that triggered it will be available in the same directory. ### Bazel Support for Jazzer is available in [rules_fuzzing](https://github.com/bazelbuild/rules_fuzzing), the official Bazel rules for fuzzing. See [the README](https://github.com/bazelbuild/rules_fuzzing#java-fuzzing) for instructions on how to use Jazzer in a Java Bazel project. ### OSS-Fuzz [Code Intelligence](https://code-intelligence.com) and Google have teamed up to bring support for Java, Kotlin, and other JVM-based languages to [OSS-Fuzz](https://github.com/google/oss-fuzz), Google's project for large-scale fuzzing of open-souce software. Read [the OSS-Fuzz guide](https://google.github.io/oss-fuzz/getting-started/new-project-guide/jvm-lang/) to learn how to set up a Java project. ## Building from source Information on building and testing Jazzer for development can be found in [CONTRIBUTING.md](CONTRIBUTING.md) ## Further documentation * [Common options and workflows](docs/common.md) * [Advanced techniques](docs/advanced.md) ## Findings A list of security issues and bugs found by Jazzer is maintained [here](docs/findings.md). If you found something interesting and the information is public, please send a PR to add it to the list. ## Credit The following developers have contributed to Jazzer before its public release: [Sergej Dechand](https://github.com/serj), [Christian Hartlage](https://github.com/dende), [Fabian Meumertzheim](https://github.com/fmeum), [Sebastian Pöplau](https://github.com/sebastianpoeplau), [Mohammed Qasem](https://github.com/mohqas), [Simon Resch](https://github.com/simonresch), [Henrik Schnor](https://github.com/henrikschnor), [Khaled Yakdan](https://github.com/kyakdan) The LLVM-style edge coverage instrumentation for JVM bytecode used by Jazzer relies on [JaCoCo](https://github.com/jacoco/jacoco). Previously, Jazzer used AFL-style coverage instrumentation as pioneered by [kelinci](https://github.com/isstac/kelinci). <p align="center"> <a href="https://www.code-intelligence.com"><img src="https://www.code-intelligence.com/hubfs/Logos/CI%20Logos/CI_Header_GitHub_quer.jpeg" height=50px alt="Code Intelligence logo"></a> </p> [`FuzzedDataProvider`]: https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html

syt0438/Guides

Java 知识体系学习与总结，提供脑图和文档版本

2019-06-12T10:19:04Z

Guides ====== Java 知识体系学习与总结，提供脑图和文档版本。 目前还缺很多内容，后期会继续不断努力的对其进行完善。 ------ ## 目录 - [Java](#Java) - [基础](#基础) - [集合](#容器) - [并发](#并发) - [JVM](#JVM) - [GC](#GC) - [网络相关](#网络相关) ## Java ### 基础 ### 集合 ### 并发 #### 源码分析版 * [(JDK7) ConcurrentHashMap 源码分析](public/code/src/main/java/edu/linshu/personal/source/jdk/ConcurrentHashMap_7.java) #### 脑图版 * [多线程基础知识及线程安全和线程通讯机制](https://www.processon.com/view/link/5d18de92e4b02f3e4dae0d0d) * [CAS 机制和锁的相关知识点](https://www.processon.com/view/link/5d195cefe4b0e16a8ecb74e2) * [AQS 队列同步器](https://www.processon.com/view/link/5d195ca2e4b0beaf6b9f53dd) * [Executor 线程池](https://www.processon.com/view/link/5d195da5e4b0fbffddf9f6af) * [Java 内存模型](https://www.processon.com/view/link/5d195f05e4b04452ec7f629a) * [CPU 性能优化策略](https://www.processon.com/view/link/5d196082e4b014412aa8bbb7) ### JVM #### 脑图版 * [类加载器](https://www.processon.com/view/link/5d178234e4b0a916e8f864d7) * [Java 对象模型](https://www.processon.com/view/link/5d17a023e4b0cd6dd6dfd8ec) * [JVM 运行时数据区](https://www.processon.com/view/link/5d1886e4e4b0beaf6b9f0733) * [JIT 编译器](https://www.processon.com/view/link/5d1779a5e4b0cd6dd6dfcbb2) * [Java 性能调优相关](https://www.processon.com/view/link/5d188de2e4b0e16a8ecb2b44) ### GC #### 脑图版 * [GC 相关知识](https://www.processon.com/view/link/5d18a2f9e4b0cd6dd6e048fa) * [Java 垃圾回收器](https://www.processon.com/view/link/5d18d396e4b0a7e304f95a63) ### 网络相关 #### 脑图版 * [NIO](https://www.processon.com/view/link/5d1c84c6e4b0f42d06760ae6) * [TCP 和 UDP 相关内容](https://www.processon.com/view/link/5d19624be4b04452ec7f66cb) * [Netty 相关内容](https://www.processon.com/view/link/5d1962dce4b02f3e4dae26bb)

arquillian/arquillian-examples

This repository hosts the example projects that are covered in the Arquillian Guides as well as several additional examples.

2010-08-01T20:29:17Z

# Arquillian Examples This repository hosts the example projects that are covered in the [Arquillian Guides](http://arquillian.org/guides/). These projects can be identified by the word "tutorial" in the name. There are several additional examples that demonstrate other functionality in Arquillian. All the projects in this repository are self-contained (they do not use parent projects). To see an even more comprehensive set of example tests, browse the [Arquillian Showcase](https://github.com/arquillian/arquillian-showcase) repository. ## What is Arquillian? Arquillian is an innovative and highly extensible testing platform for the JVM that enables developers to easily create automated integration, functional and acceptance tests for Java middleware. Find at more at http://arquillian.org ## Project Index Below is an index of the projects in this repository paired with a brief description. ### [arquillian-tutorial](https://github.com/arquillian/arquillian-examples/tree/master/arquillian-tutorial) This project is a starting point for using Arquillian. It has a simple CDI test case that runs against Weld EE Embedded (default), Embedded GlassFish 3.1 (default) and Managed JBoss AS 7.1. ### [arquillian-tutorial-rinse-repeat](https://github.com/arquillian/arquillian-examples/tree/master/arquillian-tutorial-rinse-repeat) This project is a follow-up to the arquillian-tutorial project. It demonstrates the integration of CDI and EJB with a test case that runs against GlassFish Embedded 3.1 (default), Remote JBoss AS 7.1, Remote GlassFish 3.1 and Managed JBoss AS 7.1. ### [arquillian-persistence-tutorial](https://github.com/arquillian/arquillian-examples/tree/master/arquillian-persistence-tutorial) This project contains a JPA 2 integration test that runs against Embedded GlassFish 3.1 (default), Remote GlassFish 3.1, Managed JBoss AS 7.1 and Remote JBoss AS 7.1. ### [arquillian-drone-tutorial](https://github.com/arquillian/arquillian-examples/tree/master/arquillian-drone-tutorial) This project demonstrates the use of Arquillian Drone to drive a Selenium test. It runs against Embedded GlassFish 3.1 (default), Managed JBoss AS 7.1 and Remote JBoss AS 7.1. ### ejb31-gfembedded This project contains EJB3.1 integration test and runs against Glassfish Embedded 3 container. The projects target is to provide simplest possible setup for this test combination. ### ejb31-jbembedded This project contains EJB3.1 integration test and runs against JBoss AS 6 Embedded container. The projects target is to provide simplest possible setup for this test combination. ### ejb3-openejb This project contains EJB3 integration test and runs against Apache OpenEJB 3.1 Embedded container. The projects target is to provide simplest possible setup for this test combination. ### quickstart This is a simple startup project with contains both tests for POJO and EJB running against a variety of containers. ### jpalab This project is a JPA 1.x lab that experiments with functionality and boundaries of transaction-scoped and extended persistence contexts. It can be run on the OpenEJB 3.1 Embedded container with either OpenJPA, Hibernate or EclipseLink as the JPA provider. ### jsfunit-servlet This project demonstrates how to use JSFUnit with a Servlet container. ### xa This project demonstrates the use of XA DataSources that enlist in a distributed transaction within an Arquillian test.

guobinhit/akka-guide

🌴 A chinese guide of Akka, based on Java.

2019-01-17T14:45:35Z

# Akka 中文指南  > **更轻松地构建强大的反应式、并发和分布式应用程序** Akka 是一个用 Scala 编写的库，用于在 JVM 平台上简化编写具有可容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用，其同时提供了Java 和 Scala 的开发接口。Akka 允许我们专注于满足业务需求，而不是编写初级代码。在 Akka 中，Actor 之间通信的唯一机制就是消息传递。Akka 对 Actor 模型的使用提供了一个抽象级别，使得编写正确的并发、并行和分布式系统更加容易。Actor 模型贯穿了整个 Akka 库，为我们提供了一致的理解和使用它们的方法。 - [Gitter Chat](https://gitter.im/akka/akka?source=orgpage)，Akka 在线交流平台； - [Akka Forums](https://discuss.lightbend.com/c/akka/)，Akka 论坛； - [Akka in GitHub](https://github.com/akka/akka)，Akka 开源项目仓库； - [Akka Official Website](https://akka.io/)，Akka 官网； - [Akka Java API](https://doc.akka.io/japi/akka/2.6/overview-summary.html)，Akka 应用程序编程接口。 ## 快速入门指南 - [快速入门 Akka Java 指南](https://github.com/guobinhit/akka-guide/blob/master/articles/qucikstart-akka-java.md) - [快速入门 Akka Scala 指南](https://developer.lightbend.com/guides/akka-quickstart-scala/) ## 目录 - [安全公告](https://github.com/guobinhit/akka-guide/blob/master/articles/security-announcements.md) - [入门指南](https://doc.akka.io/docs/akka/current/guide/index.html) - [Akka 简介](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/introduction-to-akka.md) - [为什么现代系统需要新的编程模型](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/actors-motivation.md) - [Actor 模型如何满足现代分布式系统的需求](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/actor-intro.md) - [Akka 库和模块概述](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/modules.md) - [Akka 应用程序示例简介](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/tutorial.md) - [第 1 部分: Actor 的体系结构](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/tutorial_1.md) - [第 2 部分: 创建第一个 Actor](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/tutorial_2.md) - [第 3 部分: 使用设备 Actors](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/tutorial_3.md) - [第 4 部分: 使用设备组](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/tutorial_4.md) - [第 5 部分: 查询设备组](https://github.com/guobinhit/akka-guide/blob/master/articles/getting-started-guide/tutorial_5.md) - [一般概念](https://doc.akka.io/docs/akka/current/general/index.html) - [术语及概念](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/terminology.md) - [Actor 系统](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/actor-systems.md) - [什么是 Actor？](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/actors.md) - [监督和监控](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/supervision.md) - [Actor 引用、路径和地址](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/addressing.md) - [位置透明](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/remoting.md) - [Akka 和 Java 内存模型](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/jmm.md) - [消息传递可靠性](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/message-delivery-reliability.md) - [配置](https://github.com/guobinhit/akka-guide/blob/master/articles/general-concepts/configuration.md) - [Actors](https://doc.akka.io/docs/akka/current/index-actors.html) - [Actors](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/actors.md)（详述了 Akka 中常见的 API 操作，**强烈推荐阅读**） - [容错](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/fault-tolerance.md) - [调度器](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/dispatchers.md) - [邮箱](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/mailboxes.md) - [路由](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/routing.md) - [FSM](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/fsm.md) - [持久化](https://github.com/guobinhit/akka-guide/blob/master/articles/actors/persistence.md) - [持久化 - 模式演化](https://doc.akka.io/docs/akka/current/persistence-schema-evolution.html) - [持久化查询](https://doc.akka.io/docs/akka/current/persistence-query.html) - [LevelDB 的持久化查询](https://doc.akka.io/docs/akka/current/persistence-query-leveldb.html) - [持久化 FSM](https://doc.akka.io/docs/akka/current/persistence-fsm.html) - [持久化 - 构建存储后端](https://doc.akka.io/docs/akka/current/persistence-journals.html) - [测试 Actor 系统](https://doc.akka.io/docs/akka/current/testing.html) - [Akka 类型](https://doc.akka.io/docs/akka/current/typed/index.html) - [入门指南](https://doc.akka.io/docs/akka/current/typed/guide/index.html) - [Actors](https://doc.akka.io/docs/akka/current/typed/actors.html) - [调度器](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/dispatchers.md) - [共存](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/coexisting.md) - [Actor 生命周期](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/actor-lifecycle.md) - [交互模式](https://doc.akka.io/docs/akka/current/typed/interaction-patterns.html) - [容错](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/fault-tolerance.md) - [Actor 发现](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/actor-discovery.md) - [路由](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/routers.md) - [Stash](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/stash.md) - [流](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/stream.md) - [分布式数据](https://doc.akka.io/docs/akka/current/typed/distributed-data.html) - [集群单例](https://doc.akka.io/docs/akka/current/typed/cluster-singleton.html) - [集群分片](https://doc.akka.io/docs/akka/current/typed/cluster-sharding.html) - [持久性](https://doc.akka.io/docs/akka/current/typed/persistence.html) - [作为 FSM 的行为](https://github.com/guobinhit/akka-guide/blob/master/articles/typed/fsm.md) - [测试](https://doc.akka.io/docs/akka/current/typed/testing.html) - [集群](https://doc.akka.io/docs/akka/current/index-cluster.html) - [集群规范](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-specification.md) - [集群的使用方法](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-usage.md) - [集群感知路由器](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-routing.md) - [集群单例](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-singleton.md) - [集群中的分布式发布订阅](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/distributed-pub-sub.md) - [集群客户端](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-client.md) - [集群分片](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-sharding.md) - [集群度量扩展](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-metrics.md) - [分布式数据](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/distributed-data.md) - [跨多个数据中心集群](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/cluster-dc.md) - [多虚拟机测试](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/multi-jvm-testing.md) - [多节点测试](https://github.com/guobinhit/akka-guide/blob/master/articles/clustering/multi-node-testing.md) - [流](https://doc.akka.io/docs/akka/current/stream/index.html) - [网络](https://doc.akka.io/docs/akka/current/index-network.html) - [远程处理](https://doc.akka.io/docs/akka/current/remoting.html) - [远程处理（代号动脉）](https://doc.akka.io/docs/akka/current/remoting-artery.html) - [序列化](https://doc.akka.io/docs/akka/current/serialization.html) - [I/O](https://doc.akka.io/docs/akka/current/io.html) - [使用 TCP](https://doc.akka.io/docs/akka/current/io-tcp.html) - [使用 UDP](https://doc.akka.io/docs/akka/current/io-udp.html) - [DNS 扩展](https://doc.akka.io/docs/akka/current/io-dns.html) - [Camel](https://doc.akka.io/docs/akka/current/camel.html) - [发现](https://github.com/guobinhit/akka-guide/blob/master/articles/discovery-index.md) - [协作](https://github.com/guobinhit/akka-guide/blob/master/articles/coordination.md) - [Futures 和 Agents](https://doc.akka.io/docs/akka/current/index-futures.html) - [Futures](https://doc.akka.io/docs/akka/current/futures.html) - [Agents](https://github.com/guobinhit/akka-guide/blob/master/articles/index-futures/agents.md) - [工具](https://doc.akka.io/docs/akka/current/index-utilities.html) - [事件总线](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/event-bus.md) - [日志记录](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/logging.md) - [调度程序](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/scheduler.md) - [持续时间](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/duration.md) - [断路器](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/circuitbreaker.md) - [Java 8 兼容性](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/java8-compat.md) - [Akka 扩展](https://github.com/guobinhit/akka-guide/blob/master/articles/index-utilities/extending-akka.md) - [其他 Akka 模块](https://doc.akka.io/docs/akka/current/common/other-modules.html) - [Akka HTTP](https://doc.akka.io/docs/akka-http/current/?language=java) - [Alpakka](https://doc.akka.io/docs/alpakka/current/) - [Alpakka Kafka Connector](http://doc.akka.io/docs/akka-stream-kafka/current/home.html) - [Akka 持久化的 Cassandra 插件](https://github.com/akka/akka-persistence-cassandra) - [Akka 持久化的 Couchbase 插件](https://doc.akka.io/docs/akka-persistence-couchbase/current/) - [Akka 管理](http://developer.lightbend.com/docs/akka-management/current/) - [Akka gRPC](https://doc.akka.io/docs/akka-grpc/current/) - [社区项目](https://doc.akka.io/docs/akka/current/common/other-modules.html) - [Lightbend 赞助的相关项目](https://doc.akka.io/docs/akka/current/common/other-modules.html) - [Play 框架](https://www.playframework.com) - [Lagom](https://www.lagomframework.com) - [如何：常见模式](https://github.com/guobinhit/akka-guide/blob/master/articles/howto.md) - [项目信息](https://doc.akka.io/docs/akka/current/project/index.html) - [迁移指南](https://github.com/guobinhit/akka-guide/blob/master/articles/project/migration-guides.md) - [滚动更新](https://github.com/guobinhit/akka-guide/blob/master/articles/project/rolling-update.md) - [问题追踪](https://github.com/guobinhit/akka-guide/blob/master/articles/project/issue-tracking.md) - [许可证](https://github.com/guobinhit/akka-guide/blob/master/articles/project/licenses.md) - [项目](https://github.com/guobinhit/akka-guide/blob/master/articles/project/links.md) - [附加信息](https://doc.akka.io/docs/akka/current/additional/index.html) - [二进制兼容规则](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/binary-compatibility-rules.md) - [模块标记为“可能改变”](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/may-change.md) - [如何部署 Akka?](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/deploy.md) - [常见问题](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/faq.md) - [IDE 提示](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/ide.md) - [书籍和视频](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/books.md) - [OSGi 中的 Akka](https://github.com/guobinhit/akka-guide/blob/master/articles/additional/osgi.md) ---------- **English Original Editon**: [Akka Documentation](https://doc.akka.io/docs/akka/current/index.html)

ScottOaks/JavaPerformanceTuning

Examples for O'Reilly & Associates Java Performance Tuning: The Definitive Guide

2014-03-14T02:32:44Z

dtpublic/examples

DataTorrent code samples for guides, tutorials, blogs

2015-10-07T18:29:18Z

# DataTorrent Application Examples DataTorrent RTS, powered by Apache Apex, provides a high-performing, fault-tolerant, scalable, easy to use data processing platform for both batch and streaming data. It includes advanced management, monitoring, development, visualization, data ingestion and distribution features. For more information on Apache Apex, please go to https://apex.apache.org/ This repository contains examples for new users to start developing data pipelines as an application. The complete documentation along with prerequisites, setup guide and tutorial is available on http://docs.datatorrent.com/ ##Contact DataTorrent is at https://www.datatorrent.com/ Apache Apex is at http://apex.apache.org and [subscribe](http://apex.apache.org/community.html) to the mailing lists. There is an active user community at http://stackoverflow.com/. Please tag the question with "apache-apex".

rohanpadhye/JQF

JQF + Zest: Coverage-guided semantic fuzzing for Java.

2017-02-23T01:27:45Z

# JQF + Zest: Semantic Fuzzing for Java [](https://github.com/rohanpadhye/JQF/actions/workflows/ci.yml) [ISSTA'19 paper]: https://rohan.padhye.org/files/zest-issta19.pdf [ISSTA'18 paper]: https://rohan.padhye.org/files/perffuzz-issta18.pdf [ISSTA'19 tool paper]: https://rohan.padhye.org/files/jqf-issta19.pdf [ICSE'20 paper]: https://rohan.padhye.org/files/rlcheck-icse20.pdf [ASE'20 paper]: https://rohan.padhye.org/files/bigfuzz-ase20.pdf [ICSE'21 paper]: https://rohan.padhye.org/files/bonsai-icse21.pdf [ISSTA'23 paper]: https://dx.doi.org/10.1145/3597926.3598107 JQF is a feedback-directed fuzz testing platform for Java (think: AFL/LibFuzzer but for JVM bytecode). JQF uses the abstraction of *property-based testing*, which makes it nice to write fuzz drivers as parameteric JUnit test methods. JQF is built on top of [junit-quickcheck](https://github.com/pholser/junit-quickcheck). JQF enables running junit-quickcheck style parameterized unit tests with the power of **coverage-guided** fuzzing algorithms such as **Zest**. [Zest][ISSTA'19 paper] is an algorithm that biases coverage-guided fuzzing towards producing *semantically valid* inputs; that is, inputs that satisfy structural and semantic properties while maximizing code coverage. Zest's goal is to find deep semantic bugs that cannot be found by conventional fuzzing tools, which mostly stress error-handling logic only. By default, JQF runs Zest via the simple command: `mvn jqf:fuzz`. JQF is a modular framework, supporting the following pluggable fuzzing front-ends called *guidances*: * Binary fuzzing with [AFL](http://lcamtuf.coredump.cx/afl) ([tutorial](https://github.com/rohanpadhye/jqf/wiki/Fuzzing-with-AFL)) * Semantic fuzzing with **[Zest](http://arxiv.org/abs/1812.00078)** [[ISSTA'19 paper]] ([tutorial 1](https://github.com/rohanpadhye/jqf/wiki/Fuzzing-with-Zest)) ([tutorial 2](https://github.com/rohanpadhye/jqf/wiki/Fuzzing-a-Compiler)) * Complexity fuzzing with **[PerfFuzz](https://github.com/carolemieux/perffuzz)** [[ISSTA'18 paper]] * Reinforcement learning with **[RLCheck](https://github.com/sameerreddy13/rlcheck)** (based on a fork of JQF) [[ICSE'20 paper]] * Mutation-analysis-guided fuzzing with **[Mu2](https://github.com/cmu-pasta/mu2)** [[ISSTA'23 paper]] JQF has been successful in [discovering a number of bugs in widely used open-source software](#trophies) such as OpenJDK, Apache Maven and the Google Closure Compiler. ### Zest Research Paper To reference Zest in your research, we request you to cite our [ISSTA'19 paper]: > Rohan Padhye, Caroline Lemieux, Koushik Sen, Mike Papadakis, and Yves Le Traon. 2019. **Semantic Fuzzing with Zest**. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’19), July 15–19, 2019, Beijing, China. ACM, New York, NY, USA, 12 pages. https://doi.org/10.1145/3293882.3330576 #### JQF Tool Paper If you are using the JQF framework to build new fuzzers, we request you to cite our [ISSTA'19 tool paper] as follows: > Rohan Padhye, Caroline Lemieux, and Koushik Sen. 2019. **JQF: Coverage-Guided Property-Based Testing in Java**. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA ’19), July 15–19, 2019, Beijing, China. ACM, New York, NY, USA, 4 pages. https://doi.org/10.1145/3293882.3339002 ## Overview ### What is *structure-aware fuzzing*? Binary fuzzing tools like [AFL](http://lcamtuf.coredump.cx/afl) and [libFuzzer](https://llvm.org/docs/LibFuzzer.html) treat the input as a sequence of bytes. If the test program expects highly structured inputs, such as XML documents or JavaScript programs, then mutating byte-arrays often results in syntactically invalid inputs; the core of the test program remains untested. **Structure-aware fuzzing** tools leverage domain-specific knowledge of the input format to produce inputs that are *syntactically valid* by construction. There are some nice articles on structure-aware fuzzing of [C++](https://github.com/google/fuzzing/blob/master/docs/structure-aware-fuzzing.md) and [Rust](https://rust-fuzz.github.io/book/cargo-fuzz/structure-aware-fuzzing.html) programs using libFuzzer. ### What is *generator-based* fuzzing (QuickCheck)? Structure-aware fuzzing tools need a way to understand the input structure. Some other tools use declarative specifications of the input format such as [context-free grammars](https://embed.cs.utah.edu/csmith/) or [protocol buffers](https://github.com/google/libprotobuf-mutator). **JQF** uses QuickCheck's imperative approach for specifying the space of inputs: arbitrary ***generator*** programs whose job is to generate a single random input. A `Generator<T>` provides a method for producing random instances of type `T`. For example, a generator for type `Calendar` returns randomly-generated `Calendar` objects. One can easily write generators for more complex types, such as [XML documents](examples/src/main/java/edu/berkeley/cs/jqf/examples/xml/XmlDocumentGenerator.java), [JavaScript programs](examples/src/main/java/edu/berkeley/cs/jqf/examples/js/JavaScriptCodeGenerator.java), [JVM class files](examples/src/main/java/edu/berkeley/cs/jqf/examples/bcel/JavaClassGenerator.java), SQL queries, HTTP requests, and [many more](https://github.com/pholser/junit-quickcheck/tree/master/examples/src/test/java/com/pholser/junit/quickcheck/examples) -- this is **generator-based fuzzing**. However, simply sampling random inputs of type `T` is not usually very effective, since the generator does not know if the inputs that it produces are any good. ### What is *semantic fuzzing* (Zest)? JQF supports the **[*Zest algorithm*][ISSTA'19 paper], which uses code-coverage and input-validity feedback to bias a QuickCheck-style generator** towards generating structured inputs that can reveal deep semantic bugs. JQF extracts code coverage using bytecode instrumentation, and input validity using JUnit's [`Assume`](https://junit.org/junit4/javadoc/4.12/org/junit/Assume.html) API. An input is valid if no assumptions are violated. ## Example Here is a JUnit-Quickcheck test for checking a property of the [PatriciaTrie](https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/trie/PatriciaTrie.html) class from [Apache Commons Collections](https://commons.apache.org/proper/commons-collections/). The property tests that if a `PatriciaTrie` is initialized with an input JDK `Map`, and if the input map already contains a key, then that key should also exist in the newly constructed `PatriciaTrie`. ```java @RunWith(JQF.class) public class PatriciaTrieTest { @Fuzz /* The args to this method will be generated automatically by JQF */ public void testMap2Trie(Map<String, Integer> map, String key) { // Key should exist in map assumeTrue(map.containsKey(key)); // the test is invalid if this predicate is not true // Create new trie with input `map` Trie trie = new PatriciaTrie(map); // The key should exist in the trie as well assertTrue(trie.containsKey(key)); // fails when map = {"x": 1, "x\0": 2} and key = "x" } } ``` Running `mvn jqf:fuzz` causes JQF to invoke the `testMap2Trie()` method repeatedly with automatically generated values for `map` and `key`. After about 5 seconds on average (~5,000 inputs), JQF will report an assertion violation. It finds [a bug in the implementation of `PatriciaTrie`](https://issues.apache.org/jira/browse/COLLECTIONS-714) that is unresolved as of v4.4. Random sampling of `map` and `key` values is unlikely to find the failing test case, which is a very special corner case (see the comments next to the assertion in the code above). JQF finds this violation easily using a coverage-guided called [**Zest**][ISSTA'19 paper]. To run this example as a standalone Maven project, check out the [jqf-zest-example repository](https://github.com/rohanpadhye/jqf-zest-example). In the above example, the generators for `Map` and `String` were synthesized automatically by JUnitQuickCheck. It is also possible to specify generators for structured inputs manually. See the [tutorials](#tutorials) below. ## Documentation * The [JQF Maven Plugin](https://github.com/rohanpadhye/JQF/wiki/JQF-Maven-Plugin) documentation shows how to run `mvn jqf:fuzz` and `mvn jqf:repro`. * [Writing a JQF Test](https://github.com/rohanpadhye/JQF/wiki/Writing-a-JQF-test) demonstrates the creation of a JUnit-based parameterized test method for JQF. * [The Guidance interface](https://github.com/rohanpadhye/jqf/wiki/The-Guidance-interface) docs show how JQF works internally, which is useful for researchers wishing to build custom guidance algorithms on top of JQF. * [API docs](https://rohanpadhye.github.io/JQF/apidocs) are published at every major release, which is again useful for researchers wishing to extend JQF. ### Tutorials * [Zest 101](https://github.com/rohanpadhye/jqf/wiki/Fuzzing-with-Zest): A basic tutorial for fuzzing a standalone toy program using command-line scripts. Walks through the process of writing a test driver and structured input generator for `Calendar` objects. * [Fuzzing a compiler with Zest](https://github.com/rohanpadhye/jqf/wiki/Fuzzing-a-Compiler): A tutorial for fuzzing a non-trivial program -- the [Google Closure Compiler](https://github.com/google/closure-compiler) -- using a generator for JavaScript programs. This tutorial makes use of the [JQF Maven plugin](https://github.com/rohanpadhye/jqf/wiki/JQF-Maven-Plugin). * [Fuzzing with AFL](https://github.com/rohanpadhye/jqf/wiki/Fuzzing-with-AFL): A tutorial for fuzzing a Java program that parses binary data, such as PNG image files, using the AFL binary fuzzing engine. * [Fuzzing with ZestCLI](https://gitlab.com/gitlab-org/security-products/demos/coverage-fuzzing/java-fuzzing-example): A tutorial of fuzzing a Java program with ZestCLI ### Continuous Fuzzing [GitLab](https://docs.gitlab.com/ee/user/application_security/coverage_fuzzing/) supports running JQF in CI/CD ([tutorial](https://gitlab.com/gitlab-org/security-products/demos/coverage-fuzzing/java-fuzzing-example)), though they have recently rolled out their own custom Java fuzzer for this purpose. ## Research and Tools based on JQF * **[Zest](https://github.com/rohanpadhye/jqf-zest-example)** 🍝 [[ISSTA'19 paper]] - Semantic Fuzzing * **[BigFuzz](https://github.com/UCLA-SEAL/BigFuzz)** 🍝 [[ASE'20 paper]] - Spark Fuzzing * **[MoFuzz](https://github.com/hub-se/MoFuzz)** [[ASE'20 paper](https://doi.org/10.1145/3324884.3416668)] - Model-driven software * **[RLCheck](https://github.com/sameerreddy13/rlcheck)** 🍝 [[ICSE'20 paper]] - Reinforcement learning * **[Bonsai](https://github.com/vasumv/bonsai-fuzzing)** 🍝 [[ICSE'21 paper]] - Concise test generation * **[Confetti](https://github.com/neu-se/CONFETTI)** [[ICSE'22 paper](https://doi.org/10.1145/3510003.3510628)] - Concolic / taint tracking with global hinting * **[BeDivFuzz](https://github.com/hub-se/BeDivFuzz)** [[ICSE'22 paper](https://doi.org/10.1145/3510003.3510182)]- Behaviorial diversity * **[ODDFuzz](https://github.com/ODDFuzz/ODDFuzz)** [[IEEE S&P'23 paper](https://arxiv.org/pdf/2304.04233.pdf)] - Deserialization vulnerabilities * **[GCMiner](https://github.com/GCMiner/GCMiner)** [[ICSE'23 paper](https://arxiv.org/pdf/2303.07593.pdf)] - Gadget chain mining * **[Intender](https://github.com/purseclab/intender)** [[USENIX Security'23 paper](https://www.usenix.org/system/files/sec23fall-prepub-285_kim-jiwon.pdf)] - Intent-based networking * **[Mu2](https://github.com/cmu-pasta/mu2)** 🍝 [[ISSTA'23 paper]] - Mutation testing as guidance * **[TOAST](http://dx.doi.org/10.1007/s11390-021-1693-1)** [[JCST'22 paper](https://link.springer.com/article/10.1007/s11390-021-1693-1)] - Testing dynamic software updates * **[Poracle](https://github.com/PLaSE-UNIST/poracle-tool)** [[TOSEM'23 paper](http://www.jooyongyi.com/papers/TOSEM23.pdf)] - Patch testing using differential fuzzing * **[SPIDER](https://arxiv.org/abs/2209.04026)** 🍝 [[arxiv preprint](https://arxiv.org/abs/2209.04026)] - Stateful performance issues in SDN * **[FuzzDiff](https://github.com/akashpatil7/FuzzDiff)** [[Dissertation](https://www.scss.tcd.ie/publications/theses/diss/2022/TCD-SCSS-DISSERTATION-2022-134.pdf)] - Dynamic program equivalence checking 🍝 = Involves at least one of the original JQF authors. ## Contact the developers If you've found a bug in JQF or are having trouble getting JQF to work, please open an issue on the [issue tracker](https://github.com/rohanpadhye/jqf/issues). You can also use this platform to post feature requests. If it's some sort of fuzzing emergency you can always send an email to the main developer: [Rohan Padhye](https://rohan.padhye.org). ## Trophies If you find bugs with JQF and you comfortable with sharing, We would be happy to add them to this list. Please send a PR for README.md with a link to the bug/cve you found. - [google/closure-compiler#2842](https://github.com/google/closure-compiler/issues/2842): IllegalStateException in VarCheck: Unexpected variable - [google/closure-compiler#2843](https://github.com/google/closure-compiler/issues/2843): NullPointerException when using Arrow Functions in dead code - [google/closure-compiler#3173](https://github.com/google/closure-compiler/issues/3173): Algorithmic complexity / performance issue on fuzzed input - [google/closure-compiler#3220](https://github.com/google/closure-compiler/issues/3220): ExpressionDecomposer throws IllegalStateException: Object method calls can not be decomposed - [JDK-8190332](https://bugs.openjdk.java.net/browse/JDK-8190332): PngReader throws NegativeArraySizeException when width is too large - [JDK-8190511](https://bugs.openjdk.java.net/browse/JDK-8190511): PngReader throws OutOfMemoryError for very small malformed PNGs - [JDK-8190512](https://bugs.openjdk.java.net/browse/JDK-8190512): PngReader throws undocumented IllegalArgumentException: "Empty Region" instead of IOException for malformed images with negative dimensions - [JDK-8190997](https://bugs.openjdk.java.net/browse/JDK-8190997): PngReader throws NullPointerException when PLTE section is missing - [JDK-8191023](https://bugs.openjdk.java.net/browse/JDK-8191023): PngReader throws NegativeArraySizeException in parse_tEXt_chunk when keyword length exceeeds chunk size - [JDK-8191076](https://bugs.openjdk.java.net/browse/JDK-8191076): PngReader throws NegativeArraySizeException in parse_zTXt_chunk when keyword length exceeds chunk size - [JDK-8191109](https://bugs.openjdk.java.net/browse/JDK-8191109): PngReader throws NegativeArraySizeException in parse_iCCP_chunk when keyword length exceeds chunk size - [JDK-8191174](https://bugs.openjdk.java.net/browse/JDK-8191174): PngReader throws undocumented llegalArgumentException with message "Pixel stride times width must be <= scanline stride" - [JDK-8191073](https://bugs.openjdk.java.net/browse/JDK-8191073): JpegImageReader throws IndexOutOfBoundsException when reading malformed header - [JDK-8193444](https://bugs.openjdk.java.net/browse/JDK-8193444): SimpleDateFormat throws ArrayIndexOutOfBoundsException when format contains long sequences of unicode characters - [JDK-8193877](https://bugs.openjdk.java.net/browse/JDK-8193877): DateTimeFormatterBuilder throws ClassCastException when using padding - [mozilla/rhino#405](https://github.com/mozilla/rhino/issues/405): FAILED ASSERTION due to malformed destructuring syntax - [mozilla/rhino#406](https://github.com/mozilla/rhino/issues/406): ClassCastException when compiling malformed destructuring expression - [mozilla/rhino#407](https://github.com/mozilla/rhino/issues/407): java.lang.VerifyError in bytecode produced by CodeGen - [mozilla/rhino#409](https://github.com/mozilla/rhino/issues/409): ArrayIndexOutOfBoundsException when parsing '<!-' - [mozilla/rhino#410](https://github.com/mozilla/rhino/issues/410): NullPointerException in BodyCodeGen - [COLLECTIONS-714](https://issues.apache.org/jira/browse/COLLECTIONS-714): PatriciaTrie ignores trailing null characters in keys - [COMPRESS-424](https://issues.apache.org/jira/browse/COMPRESS-424): BZip2CompressorInputStream throws ArrayIndexOutOfBoundsException(s) when decompressing malformed input - [LANG-1385](https://issues.apache.org/jira/browse/LANG-1385): StringIndexOutOfBoundsException in NumberUtils.createNumber - [**CVE-2018-11771**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-11771): Infinite Loop in Commons-Compress ZipArchiveInputStream ([found by Tobias Ospelt](https://www.floyd.ch/?p=1090)) - [MNG-6375](https://issues.apache.org/jira/browse/MNG-6375) / [plexus-utils#34](https://github.com/codehaus-plexus/plexus-utils/issues/34): NullPointerException when pom.xml has incomplete XML tag - [MNG-6374](https://issues.apache.org/jira/browse/MNG-6374) / [plexus-utils#35](https://github.com/codehaus-plexus/plexus-utils/issues/35): ModelBuilder hangs with malformed pom.xml - [MNG-6577](https://issues.apache.org/jira/browse/MNG-6577) / [plexus-utils#57](https://github.com/codehaus-plexus/plexus-utils/issues/57): Uncaught IllegalArgumentException when parsing unicode entity ref - [Bug 62655](https://bz.apache.org/bugzilla/show_bug.cgi?id=62655): Augment task: IllegalStateException when "id" attribute is missing - [BCEL-303](https://issues.apache.org/jira/browse/BCEL-303): AssertionViolatedException in Pass 3A Verification of invoke instructions - [BCEL-307](https://issues.apache.org/jira/browse/BCEL-307): ClassFormatException thrown in Pass 3A verification - [BCEL-308](https://issues.apache.org/jira/browse/BCEL-308): NullPointerException in Verifier Pass 3A - [BCEL-309](https://issues.apache.org/jira/browse/BCEL-309): NegativeArraySizeException when Code attribute length is negative - [BCEL-310](https://issues.apache.org/jira/browse/BCEL-310): ArrayIndexOutOfBounds in Verifier Pass 3A - [BCEL-311](https://issues.apache.org/jira/browse/BCEL-311): ClassCastException in Verifier Pass 2 - [BCEL-312](https://issues.apache.org/jira/browse/BCEL-312): AssertionViolation: INTERNAL ERROR Please adapt StringRepresentation to deal with ConstantPackage in Verifier Pass 2 - [BCEL-313](https://issues.apache.org/jira/browse/BCEL-313): ClassFormatException: Invalid signature: Ljava/lang/String)V in Verifier Pass 3A - [**CVE-2018-8036**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-8036): Infinite Loop leading to OOM in PDFBox's AFMParser ([found by Tobias Ospelt](https://www.floyd.ch/?p=1090)) - [PDFBOX-4333](https://issues.apache.org/jira/browse/PDFBOX-4333): ClassCastException when loading PDF (found by Robin Schimpf) - [PDFBOX-4338](https://issues.apache.org/jira/browse/PDFBOX-4338): ArrayIndexOutOfBoundsException in COSParser (found by Robin Schimpf) - [PDFBOX-4339](https://issues.apache.org/jira/browse/PDFBOX-4339): NullPointerException in COSParser (found by Robin Schimpf) - [**CVE-2018-8017**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-8017): Infinite Loop in IptcAnpaParser - [**CVE-2018-12418**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-12418): Infinite Loop in junrar ([found by Tobias Ospelt](https://www.floyd.ch/?p=1090)) - [**CVE-2019-17359**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-17359): Attempt to trigger a large allocation leads to OOM in Bouncycastle ASN.1 parser ([found by Tobias Ospelt](https://www.youtube.com/watch?v=RaBGEgQiE-4))

Nightonke/WoWoViewPager

Combine ViewPager and Animations to provide a simple way to create applications' guide pages.

2016-03-03T04:29:28Z

# WoWoViewPager [](https://github.com/Nightonke) [](https://github.com/Nightonke/WoWoViewPager#demo) [](https://bintray.com/nightonke/maven/wowo-viewpager) [](https://www.apache.org/licenses/LICENSE-2.0) <img src="https://github.com/Nightonke/WoWoViewPager/blob/master/Pictures/GuidePage1.gif"> <img src="https://github.com/Nightonke/WoWoViewPager/blob/master/Pictures/GuidePage2.gif"> WoWoViewPager combines ViewPager and Animations to provide a simple way to create applications' guide pages. When users are dragging WoWoViewPager, they become the director of the applications. The above gifs show how WoWoViewPager looks like, it supports some simple animations like translation, scale, alpha, background color animations, and moreover, some complicate animations like gif-playing, svg-drawing and path-drawing animations with corresponding custom views. ## Note 1. Here comes the 2.0.0 version! The old versions(1.0.2 or below) are deprecated. The new version provides plenty features for convenient usage and efficiency improvement. 1. Thanks [SCViewPager](https://github.com/sacot41/SCViewPager) for giving me inspiration for codes. 1. Thanks [JazzHands](https://github.com/IFTTT/JazzHands) for giving me inspiration for animations. 1. Thanks [konmik](https://github.com/konmik) for providing a better HSV-animation. ## Gradle & Maven ``` compile 'com.nightonke:wowoviewpager:2.0.0' ``` ``` <dependency> <groupId>com.nightonke</groupId> <artifactId>wowoviewpager</artifactId> <version>2.0.0</version> <type>pom</type> </dependency> ``` ## Demo <img src="https://github.com/Nightonke/WoWoViewPager/blob/master/Apk/WoWo%20in%20Fir.png" width="200"> Or by link: [WoWoViewPager V2.0.0 in Github](https://github.com/Nightonke/WoWoViewPager/blob/master/Apk/WoWo%20V2.0.0.apk?raw=true) [WoWoViewPager V2.0.0 in Fir](http://fir.im/wowoviewpager) ## Wiki Check the [wiki](https://github.com/Nightonke/WoWoViewPager/wiki) to use WoWoViewPager. ### Documentation Chapters #### [Basic Usage](https://github.com/Nightonke/WoWoViewPager/wiki/Basic-Usage) #### [Ease](https://github.com/Nightonke/WoWoViewPager/wiki/Ease) #### [Chameleon](https://github.com/Nightonke/WoWoViewPager/wiki/Chameleon) #### [Typewriter](https://github.com/Nightonke/WoWoViewPager/wiki/Typewriter) #### Basic Animations 1. [Position Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Position-Animation) 1. [Position 3D Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Position-3D-Animation) 1. [Translation Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Translation-Animation) 1. [Translation 3D Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Translation-3D-Animation) 1. [Scale Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Scale-Animation) 1. [Alpha Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Alpha-Animation) 1. [Rotation Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Rotation-Animation) 1. [Elevation Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Elevation-Animation) #### TextView Animations 1. [TextView TextSize Animation](https://github.com/Nightonke/WoWoViewPager/wiki/TextView-TextSize-Animation) 1. [TextView TextColor Animation](https://github.com/Nightonke/WoWoViewPager/wiki/TextView-TextColor-Animation) 1. [TextView Text Animation](https://github.com/Nightonke/WoWoViewPager/wiki/TextView-Text-Animation) #### Color Animations 1. [Background Color Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Background-Color-Animation) 1. [Shape Color Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Shape-Color-Animation) 1. [State-List Color Animation](https://github.com/Nightonke/WoWoViewPager/wiki/State-List-Color-Animation) 1. [Layer-List Color Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Layer-List-Color-Animation) #### [Path Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Path-Animation) #### [WoWoViewPager Attributes](https://github.com/Nightonke/WoWoViewPager/wiki/WoWoViewPager-Attributes) #### Interface Expansibility 1. [Custom Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Custom-Animation) 1. [Interface Animation](https://github.com/Nightonke/WoWoViewPager/wiki/Interface-Animation) 1. [SVG Animation](https://github.com/Nightonke/WoWoViewPager/wiki/SVG-Animation) 1. [GIF Animation](https://github.com/Nightonke/WoWoViewPager/wiki/GIF-Animation) #### [Version History](https://github.com/Nightonke/WoWoViewPager/wiki/Version-History) #### [How WoWoViewPager Works](https://github.com/Nightonke/WoWoViewPager/wiki/How-WoWoViewPager-Works) ## Issues & Feedbacks Try to tell me the bugs or enhancements about WoWoViewPager, or contact me with Nightonke@outlook.com / 2584541288@qq.com. Before doing that, having a careful read on [read-me](https://github.com/Nightonke/WoWoViewPager), [wiki](https://github.com/Nightonke/WoWoViewPager/wiki) and [issues](https://github.com/Nightonke/WoWoViewPager/issues) is really helpful. ## About Versions Version 1.0.2 or below use the old api of WoWoViewPager. From version 2.0.0, builder-pattern was used in WoWoViewPager and gif-playing, svg-drawing animations and more features are supported. I strongly suggest to use version 2.0.0 or above. If you still want to use version 1.0.2 or below, try to check the old documents([English](https://github.com/Nightonke/WoWoViewPager/blob/master/DEPRECATED-README-EN.md)|[中文文档](https://github.com/Nightonke/WoWoViewPager/blob/master/DEPRECATED-README-ZH.md)). ## About Me [Nightonke](http://huangweiping.me/)

PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java

The Complete Coding Interview Guide in Java, published by Packt

2020-01-20T06:25:15Z

# The Complete Coding Interview Guide in Java <a href="https://www.packtpub.com/product/the-complete-coding-interview-guide-in-java/9781839212062"><img src="https://static.packt-cdn.com/products/9781839212062/cover/smaller" alt="The Complete Coding Interview Guide in Java " height="256px" align="right"></a> This is the code repository for [The Complete Coding Interview Guide in Java ](https://www.packtpub.com/product/the-complete-coding-interview-guide-in-java/9781839212062), published by Packt. **An effective guide for aspiring Java developers to ace their programming interviews** ## What is this book about? Java is one of the most sought-after programming languages in the job market, but cracking the coding interview in this challenging economy might not be easy. This comprehensive guide will help you to tackle various challenges faced in a coding job interview and avoid common interview mistakes, and will ultimately guide you toward landing your job as a Java developer. This book covers the following exciting features: Solve the most popular Java coding problems efficiently Tackle challenging algorithms that will help you develop robust and fast logic Practice answering commonly asked non-technical interview questions that can make the difference between a pass and a fail Get an overall picture of prospective employers' expectations from a Java developer Solve various concurrent programming, functional programming, and unit testing problems If you feel this book is for you, get your [copy](https://www.packtpub.com/product/the-complete-coding-interview-guide-in-java/9781839212062) today! ## Instructions and Navigations All of the code is organized into folders. For example, Chapter02. The code will look like the following: ``` "@RunWith(JUnitPlatform.class) public class NestedTest { private static final Logger log = Logger.getLogger(NestedTest.class.getName());, ``` **Following is what you need for this book:** This book is for students, programmers, and employees who want to be invited to and pass interviews given by top companies. The book assumes high school mathematics and basic programming knowledge. With the following software and hardware list you can run all code files present in the book (Chapter 1-19). ### Software and Hardware List | No | Software required | OS required | | -------- | ------------------------------------ | ----------------------------------- | | 1 | JDK 8+ | Windows, Mac OS X, and Linux (Any) | | 2 | IDE (Eclipse, IntelliJ IDEA) | Windows, Mac OS X, and Linux (Any) | We also provide a PDF file that has color images of the screenshots/diagrams used in this book. [Click here to download it](https://static.packt-cdn.com/downloads/9781839212062_ColorImages.pdf). ### Related products * Java Coding Problems [[Packt]](https://www.packtpub.com/product/java-coding-problems/9781789801415) [[Amazon]](https://www.amazon.com/Java-Coding-Problems-Programming-real-world-ebook/dp/B07Y9BPV4W) * Learn Java 12 Programming [[Packt]](https://www.packtpub.com/product/learn-java-12-programming/9781789957051) [[Amazon]](https://www.amazon.com/Learn-Java-Programming-step-step-ebook/dp/B07PJRVZLG) ## Get to Know the Author **Anghel Leonard** is a chief technology strategist with more than 20 years’ experience in the Java ecosystem. In his daily work, he is focused on architecting and developing Java-distributed applications that empower robust architectures, clean code, and high performance. He is also passionate about coaching, mentoring, and technical leadership. ### Suggestions and Feedback [Click here](https://docs.google.com/forms/d/e/1FAIpQLSdy7dATC6QmEL81FIUuymZ0Wy9vH1jHkvpY57OiMeKGqib_Ow/viewform) if you have any feedback or suggestions. ### Download a free PDF <i>If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.<br>Simply click on the link to claim your free PDF.</i> <p align="center"> <a href="https://packt.link/free-ebook/9781839212062">https://packt.link/free-ebook/9781839212062 </a> </p>

spring-guides/quoters

Spring Boot quotation service to support REST-based guides

2014-08-19T22:10:28Z

bitstorm/Wicket-tutorial-examples

Code examples for the offcial Wicket user guide

2012-09-18T20:27:19Z

Wicket-tutorial-examples ======================== This repository contains the example projects used in the [Wicket user guide](http://wicket.apache.org/learn/#guide). ## Building the project The project is a multi-module Maven project. To compile it run 'mvn compile' from the root directory. To run the examples locally follows these steps: * run 'mvn install' from the root directory * go into project StarterExamples and run 'mvn jetty:run' or 'mvn tomcat:run' To run a single example project you have to install first project BootstrapCommon ('mvn install'). Then go into the folder of the project you want to run, type 'mvn jetty:run' or 'mvn tomcat:run' and then point your browser to http://localhost:8080 ## See the examples on line The examples can be explored on line at [http://wicket-tutorial-examples.it:8080/](http://wicket-tutorial-examples.it:8080/) (courtesy of [Host.it](https://host.it/)). NOTE: examples are hosted on a free account, so you might need to wait few seconds before server responds. ## Contributing to this guide If you want to contribute to the guide with corrections or new contents, you can find how to do it [here](http://wicket.apache.org/contribute/userguide.html). ## The author My name is Andrea Del Bene and I'm a passionate enterprise web developer and an advocate of Apache Wicket. I started programming in Java since version 1.2 and I'm a strong supporter of open source technologies. If you like this project and want to support me, you can offer me a beer :-) : <p> <a href="https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&amp;hosted_button_id=RGHPTV2QDK8VN" rel="nofollow"><img src="https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif"></a> </p>

mapsme/travelguide

Offline GuideWithMe travel guides based on Wikivoyage articles.

2015-12-05T08:31:58Z

oktadev/okta-spring-boot-authz-server-example

Spring Security OAuth 2.0 Guide

2019-03-01T06:32:55Z

# Spring Security OAuth 2.0 Guide This example shows how to create a Authorization Server with Spring Security and OAuth 2.0. Please read [A Quick Guide to OAuth 2.0 with Spring Security](https://developer.okta.com/blog/2019/03/12/oauth2-spring-security-guide) for a tutorial that shows you how to build the applications in this repo. **Prerequisites:** [Java 8 or 11](https://adoptopenjdk.net/). > [Okta](https://developer.okta.com/) has Authentication and User Management APIs that reduce development time with instant-on, scalable user infrastructure. Okta's intuitive API and expert support make it easy for developers to authenticate, manage and secure users and roles in any application. * [Getting Started](#getting-started) * [Help](#help) * [Links](#links) * [License](#license) ## Getting Started To install this example application, run the following commands: ```bash git clone https://github.com/oktadeveloper/okta-spring-boot-authz-server-example.git cd okta-spring-boot-authz-server-example ``` ### Create an Okta Developer Account If you don't have one, [create an Okta Developer account](https://developer.okta.com/signup/). After you've completed the setup process, log in to your account and navigate to **Applications** > **Add Application**. Click **Web** and **Next**. On the next page, enter a name for your app (e.g., "Okta OAuth Client"), then click **Done**. Update the `OktaOAuthClient/src/main/resources/application.yml` to have your new app's settings: ```yaml okta: oauth2: issuer: https://{yourOktaDomain}/oauth2/default client-id: {yourClientId} client-secret: {yourClientSecret} ``` Start the `OktaOAuthClient` app using Gradle. ```shell cd OktaOAuthClient ./gradlew bootRun ``` After everything starts, you should be able to log in with your credentials at `http://localhost:8080`. ## Links This example uses the following open source projects: * [Okta Spring Boot Starter](https://github.com/okta/okta-spring-boot) * [Spring Boot](https://spring.io/projects/spring-boot) * [Spring Security](https://spring.io/projects/spring-security) ## Help Please post any questions as comments on this repo's [blog post](https://developer.okta.com/blog/2019/03/12/oauth2-spring-security-guide), or visit our [Okta Developer Forums](https://devforum.okta.com/). ## License Apache 2.0, see [LICENSE](LICENSE).

salaboy/jBPM5-Developer-Guide

jBPM5 Developer Guide Source Code

2011-12-26T14:29:45Z

feuyeux/jax-rs2-atup

jax-rs2-guide atup sample

2013-10-31T07:22:09Z

soumyadip007/SpringBoot-Angular8-Login-Registration-for-JavaGuides.net

Repository based on a Login & Registration form using Spring Boot, Spring Security, Angular8, Hibernate-JPA, & Restful web services (Database used : MySql). This content is created for Commercial Purpose , For more info visit https://www.javaguides.net

2019-07-13T05:41:56Z

# SpringBoot-Angular8-Login-Registration # Repository based on a Login & Registration form using Spring Boot, Spring Security, Angular8, Hibernate-JPA, & Restful web services (Database used : MySql). This content is created for Commercial Purpose , For more info visit https://www.javaguides.net

RameshMF/jersey-tutorial

Guide to Jersey Rest API development

2018-06-11T07:36:40Z

<div dir="ltr" style="text-align: left;" trbidi="on"> <div class="separator" style="clear: both; text-align: center;"> <a href="https://1.bp.blogspot.com/-WOHCb0mOckM/Wyfq1VBss7I/AAAAAAAACf0/IkzIiSkdscg_iKp4cUk8tXn65VXa3TBewCLcBGAs/s1600/jersey_logo.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><span style="font-family: &quot;verdana&quot; , sans-serif;"><img border="0" data-original-height="55" data-original-width="64" src="https://1.bp.blogspot.com/-WOHCb0mOckM/Wyfq1VBss7I/AAAAAAAACf0/IkzIiSkdscg_iKp4cUk8tXn65VXa3TBewCLcBGAs/s1600/jersey_logo.png"></span></a></div> <h2 style="text-align: left;"> <span style="color: red; font-family: &quot;verdana&quot; , sans-serif;">Jersey 2.27 Developer Guide</span></h2> <h3 style="text-align: left;"> </h3> <hr> <h4 style="text-align: left;"> <span style="font-family: &quot;verdana&quot; , sans-serif;">Table of Contents</span></h4> <div style="text-align: left;"> <span style="font-family: &quot;verdana&quot; , sans-serif;"><b>1. Getting Started</b></span></div> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/06/jersey-rest-hello-world-example.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Jersey Rest Hello World Example</span></a></li> </ul> <b><span style="font-family: &quot;verdana&quot; , sans-serif;">2. JAX-RS Application, Resources, and Sub-Resources</span></b><br> <ul style="text-align: left;"> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/2018/06/guide-to-core-jax-rs-concepts.html" target="_blank">Guide to Core JAX-RS Concepts</a></span></li> </ul> <span style="font-family: &quot;verdana&quot; , sans-serif;"><b>3. JAX-RS Annotations</b></span><br> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/06/guide-to-standard-jax-rs-annotations.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Guide to Standard JAX-RS Annotations</span></a></li> <li><a href="http://www.javaguides.net/2018/06/jax-rs-parameter-annotations.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">JAX-RS Parameter Annotations</span></a></li> <li><a href="http://www.javaguides.net/2018/06/jax-rs-context-annotation-with-examples.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">JAX-RS @Context Annotation with Examples</span></a></li> </ul> <b><span style="font-family: &quot;verdana&quot; , sans-serif;">4. Client API</span></b><br> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/06/overview-of-jersey-jax-rs-client-api.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Overview of Jersey JAX-RS Client API</span></a></li> <li><a href="http://www.javaguides.net/2018/06/jersey-jax-rs-client-for-crud-restful-web-services.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Jersey JAX-RS Client for CRUD Restful Web Services</span></a></li> <li><a href="http://www.javaguides.net/2018/06/jersey-jax-rs-client-api-examples.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Jersey JAX-RS Client API Examples</span></a></li> </ul> <b><span style="font-family: &quot;verdana&quot; , sans-serif;">5. Logging</span></b><br> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/06/jersey-rest-logging-using-loggingfeature.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Jersey Rest Logging using LoggingFeature</span></a></li> <li><a href="http://www.javaguides.net/2018/06/guide-to-jersey-logging-on-server-and.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Guide to Jersey logging on Server and Client side</span></a></li> </ul> <b><span style="font-family: &quot;verdana&quot; , sans-serif;">6. Spring DI</span></b><br> <ul style="text-align: left;"> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/2018/06/jersey-spring-integration-crud-example.html" target="_blank">Jersey Spring Integration CRUD Example</a></span></li> </ul> <span style="font-family: &quot;verdana&quot; , sans-serif;"><b>7. Jersey Test Framework</b></span><br> <ul style="text-align: left;"> <li><a href="http://www.javaguides.net/2018/06/guide-to-jersey-test-framework-basics.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Guide to Jersey Test Framework Basics</span></a></li> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/2018/06/how-to-test-jersey-rest-api-with-junit.html" target="_blank">How to test Jersey Rest API with JUnit</a></span></li> </ul> <span style="font-family: &quot;verdana&quot; , sans-serif;"><b>8. Jersey Rest Examples</b></span><br> <ul style="text-align: left;"> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/2018/06/jersey-jax-rs-restful-crud-web-services-example.html" target="_blank">Jersey JAX-RS Restful CRUD Web Services Example</a></span></li> <li><a href="http://www.javaguides.net/2018/06/jax-rs-filters-and-interceptors.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">JAX RS Filters and Interceptors</span></a></li> </ul> <span style="font-family: &quot;verdana&quot; , sans-serif;"><b>9. Rest API Design Best Practices</b></span><br> <ul style="text-align: left;"> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/2018/06/restful-api-design-best-practices.html" target="_blank">Restful API Design Best Practices</a></span></li> </ul> <div> <b><span style="font-family: &quot;verdana&quot; , sans-serif;">10. REST Basics</span></b></div> <div> <ul style="background-color: white; color: #24292e;"> <li><a href="http://www.javaguides.net/2018/06/overview-of-rest.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">Overview of REST</span></a></li> </ul> <ul style="background-color: white; color: #24292e;"> <li><a href="http://www.javaguides.net/2018/06/rest-architectural-constraints.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">REST Architectural Constraints</span></a></li> </ul> <ul style="background-color: white; color: #24292e;"> <li><a href="http://www.javaguides.net/2018/06/rest-architectural-properties.html" target="_blank"><span style="font-family: &quot;verdana&quot; , sans-serif;">REST Architectural Properties</span></a></li> </ul> <ul style="background-color: white; color: #24292e;"> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/2018/06/rest-architectural-elements.html" target="_blank">REST Architectural Elements</a></span></li> </ul> </div> <div> <span style="font-family: &quot;verdana&quot; , sans-serif;"><br></span> <b><span style="font-family: &quot;verdana&quot; , sans-serif;">Important Java Developer Guides</span></b><br> <div style="text-align: left;"> </div> <ul style="text-align: left;"> <li><span style="font-family: &quot;verdana&quot; , sans-serif; font-size: 16px;"><a href="http://www.javaguides.net/search/label/Java%20Best%20Practices" style="font-size: 16px;" target="_blank">Java/J2EE Best Practices</a></span></li> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/p/jersey-rest.html" target="_blank">Jersey Rest Developer Guide</a></span></li> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/p/core-java.html" target="_blank">Core Java Developer Guide</a></span></li> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/p/java-8.html" target="_blank">Java 8 Developer Guide</a></span></li> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/p/spring-framework.html" target="_blank">Spring Developer Guide</a></span></li> <li><span style="font-family: &quot;verdana&quot; , sans-serif;"><a href="http://www.javaguides.net/p/maven.html" target="_blank">Maven developers Guide</a></span></li> </ul> </div> <div> <br></div> </div>

Apress/def-guide-spring-batch

Source Code for The Definitive Guide to Spring Batch by Michael Minella

2018-04-11T14:35:42Z

# Apress Source Code This repository accompanies [*The Definitive Guide to Spring Batch*](https://www.apress.com/9781484237236) by Michael T. Minella (Apress, 2019). [comment]: #cover  Download the files as a zip using the green button, or clone the repository to your machine using Git. ## Releases Release v1.0 corresponds to the code in the published book, without corrections or updates. ## Contributions See the file Contributing.md for more information on how you can contribute to this repository.

OpenLiberty/guide-maven-intro

An introductory guide on how to build applications using Maven on Open Liberty: https://openliberty.io/guides/maven-intro.html

2017-09-05T19:50:55Z

ThomasVitale/spring-tutorials

The repo for my articles, tutorials and guides about the Spring Framework, Spring Boot, Spring Security.

2019-12-14T22:29:42Z

# Spring Tutorials The repo for my articles, tutorials and guides about the Spring Framework. ## How to enable HTTPS in a Spring Boot Java application * Article: [How to enable HTTPS in a Spring Boot Java application](https://www.thomasvitale.com/https-spring-boot-ssl-certificate/) * Project: [`spring-boot-https`](https://github.com/ThomasVitale/spring-tutorials/tree/master/spring-boot-https) ## Multitenancy in a Spring Boot application (work in progress) * Article: _Work in progress_ * Project: [`spring-boot-multitenancy`](https://github.com/ThomasVitale/spring-tutorials/tree/master/spring-boot-multitenancy) ## Centralized Configuration with Spring Cloud Config * Article: [Centralized Configuration with Spring Cloud Config](https://www.thomasvitale.com/spring-cloud-config-basics/) * Project: [`spring-cloud-config`](https://github.com/ThomasVitale/spring-tutorials/tree/master/spring-cloud-config) ## Spring Native: Getting started with GraalVM native images * Article: [Spring Native: Getting started with GraalVM native images](https://www.thomasvitale.com/spring-native-graalvm-getting-started/) * Project: [`spring-native-graalvm`](https://github.com/ThomasVitale/spring-tutorials/tree/master/spring-native-graalvm)

TeamAmeriFrance/Guide-API

An Open-Source API to make your own ingame guides.

2015-02-07T21:31:31Z

# Guide-API [](http://tehnut.info/jenkins/job/Guide-API/job/1.7.10/) Library mod for easy creation of guide books. Also allows book creation via JSON files. ## Useful Links * [Jenkins](http://tehnut.info/jenkins/job/Guide-API/) * [CurseForge](http://minecraft.curseforge.com/mc-mods/228832-guide-api) * [Javadocs](http://tehnut.info/jenkins/job/Guide-API/javadoc/) * [ReadTheDocs](http://guide-api.readthedocs.org/en/latest/) ## Mods that support Guide-API The ones we know of at least * [Sanguimancy](https://minecraft.curseforge.com/projects/sanguimancy) * [Creative Concoctions](https://github.com/TeamAmeriFrance/CreativeConcoctions) * [Overlord](https://minecraft.curseforge.com/projects/overlord) * [Mechanical Soldiers](https://minecraft.curseforge.com/projects/mechanical-soldiers) * [Blood Magic](https://minecraft.curseforge.com/projects/blood-magic) (*In progress*) * [Crossroads](https://github.com/Da-Technomancer/Crossroads) ## Issue Reporting Please include the following: * Minecraft version * Guide-API version * Forge version/build * Versions of any mods potentially related to the issue * Any relevant screenshots are greatly appreciated * For crashes: * Steps to reproduce * Latest Forge log or crash log ## Developer Information This section has been moved [here](http://guide-api.readthedocs.org/en/latest/). ## Modpack Permissions For full details, view our license. Distributor rights are automatically given to any user who wishes to include the mod in their modpack if the intent is not malicious and/or commercial. We reserve the right to change this section as needed.

marianbuenosayres/jBPM6-Developer-Guide

jBPM6 Developer Guide Source Code

2013-12-21T04:52:55Z

jBPM6 Developer Guide Source Code ================================= This repository contains the source code related to the jBPM6 Developer Guide Book. The master branch now contains the most updated examples. In the future a tag will be created when the book is published with a stable version of this examples provided. All the examples are divided by chapter and you can build all of them using: mvn clean install On the main directory. Contributions ------------- If you want to contribute with this examples to make a better book, feel free to clone this repository with: git clone git://github.com/marianbuenosayres/jBPM6-Developer-Guide.git And send me your pull requests :) Any comments, issues or feedback is more than welcome! For updates about the book visit: http://marianbuenosayres.wordpress.com or follow us on twitter: http://www.twitter.com/marianbuenosayr jBPM6 Developer Guide 2014

sujana-kamasany/javacodes

A repository that will guide in making your first contribution.

2022-02-06T07:00:54Z

# Java Programs # A Repository that will guide you in making your first contribution. <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section --> [](https://github.com/ellerbrock/open-source-badges/) [](http://makeapullrequest.com)   ## How to contribute 1. Fork the project 2. Make any changes in your forked repo 3. On this repo, click `Pull Requests` and raise a `Pull Request` selecting your fork on the right drop down # STEPS TO CONTRIBUTE 1. `Fork` this Repository 2. `Clone` it locally (Use github Desktop to make things easier) 3. or Do it locally using the commands below ## How to clone repo and make changes locally ``` click on the clone button (green in colour). This gives you a copy of the project. Its now yours to play around with ``` - Using git on your local machine. Do this to download the forked copy of this repo to your computer ``` git clone https://github.com/yourGithubUsername/javacodes ``` - switch to the cloned folder. This can be done with Gitbash or the integrated terminal in the VSCode editor ``` cd javacodes ``` - Make a new branch. Your name would make a good branch because it's unique! ``` git checkout -b <name of new branch> ``` - Create a new folder and submit your java code - Stage your changes ``` git add yourprogramname.java ``` or ``` git add . ``` - Commit the changes ``` git commit -m "Add <your-Java_program >" ``` - Check the status of your repository ``` git status ``` - Pushing your repository to github ``` git push origin <name of your branch> ``` or ``` git branch -M main git push -u origin main git push origin main --force ``` - Navigate to your fork, on the top of the files section you'll notice a new section containing, a contribute button! - Click on the contribute button, it will open a drop down, click the pull request button on the drop down Note: A pull request allows your changes to be merged with the original project. - Wait for your changes to be merged Hurray! You made your contribution!! Don't forget to star this repo if it was helpful to you!  <h1 align=center> THANK YOU FOR CONTRIBUTING✨ </h1> <p align="center"> <a href="https://github.com/sujana-kamasany/javacodes/graphs/contributors"> <img src="https://contrib.rocks/image?repo=sujana-kamasany/javacodes" /> </a>

awsdocs/amazon-opensearch-service-developer-guide

Content for the Amazon OpenSearch Service Developer Guide. Issues and pull requests appreciated.

2018-02-09T18:02:05Z

# Amazon OpenSearch Service Developer Guide Content for the [Amazon OpenSearch Service Developer Guide](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). Issues and pull requests appreciated. # License Summary The documentation is made available under the Creative Commons Attribution-ShareAlike 4.0 International License. See the LICENSE file. The sample code within this documentation is made available under a modified MIT license. See the LICENSE-SAMPLECODE file.

Nepxion/DiscoveryGuide

☀️ Nepxion Discovery Guide is a guide example for Nepxion Discovery 蓝绿灰度发布、路由、限流、熔断、降级、隔离、追踪、流量染色、故障转移、多活的指南示例

2019-05-25T07:40:53Z

 # Discovery【探索】云原生微服务解决方案  [](https://tokei.rs/b1/github/Nepxion/Discovery?category=lines) [](https://github.com/Nepxion/Discovery/blob/6.x.x/LICENSE) [](https://search.maven.org/artifact/com.nepxion/discovery) [](http://www.javadoc.io/doc/com.nepxion/discovery-plugin-framework-starter) [](https://github.com/Nepxion/Discovery/actions) [](https://www.codacy.com/gh/Nepxion/Discovery/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Nepxion/Discovery&amp;utm_campaign=Badge_Grade) [](https://github.com/Nepxion/Discovery/stargazers) [](https://gitee.com/Nepxion/Discovery/stargazers) [](https://github.com/Nepxion/Discovery/wiki) [](https://gitee.com/nepxion/Discovery/wikis/pages?sort_id=3993615&doc_id=1124387) [](http://nepxion.gitee.io/discovery/docs/link-doc/discovery-ppt.html) [](http://nepxion.gitee.io/discovery/) [](http://nepxion.gitee.io/discoveryplatform) [](http://polaris-paas.gitee.io/polaris-sdk) <a href="https://github.com/Nepxion" tppabs="#" target="_blank"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/github.png"></a>&nbsp; <a href="https://gitee.com/Nepxion" tppabs="#" target="_blank"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/gitee.png"></a>&nbsp; <a href="https://search.maven.org/search?q=g:com.nepxion" tppabs="#" target="_blank"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/maven.png"></a>&nbsp; <a href="http://nepxion.gitee.io/discovery/docs/contact-doc/wechat.jpg" tppabs="#" target="_blank"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/wechat.png"></a>&nbsp; <a href="http://nepxion.gitee.io/discovery/docs/contact-doc/dingding.jpg" tppabs="#" target="_blank"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/dingding.png"></a>&nbsp; <a href="http://nepxion.gitee.io/discovery/docs/contact-doc/gongzhonghao.jpg" tppabs="#" target="_blank"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/gongzhonghao.png"></a>&nbsp; <a href="mailto:1394997@qq.com" tppabs="#"><img width="25" height="25" src="http://nepxion.gitee.io/discovery/docs/icon-doc/email.png"></a> 如果您觉得本框架具有一定的参考价值和借鉴意义，请帮忙在页面右上角 [**Star**] ## 简介 ### 作者简介 - Nepxion开源社区创始人 - 2020年阿里巴巴中国云原生峰会出品人 - 2020年被Nacos和Spring Cloud Alibaba纳入相关开源项目 - 2021年阿里巴巴技术峰会上海站演讲嘉宾 - 2021年荣获陆奇博士主持的奇绩资本，进行风险投资的关注和调研 - 2021年入选Gitee最有价值开源项目 - 阿里巴巴官方书籍《Nacos架构与原理》作者之一 - Spring Cloud Alibaba Steering Committer、Nacos Group Member - Spring Cloud Alibaba、Nacos、Sentinel、OpenTracing Committer & Contributor <img src="http://nepxion.gitee.io/discovery/docs/discovery-doc/CertificateGVP.jpg" width="43%"><img src="http://nepxion.gitee.io/discovery/docs/discovery-doc/AwardNacos1.jpg" width="28%"><img src="http://nepxion.gitee.io/discovery/docs/discovery-doc/AwardSCA1.jpg" width="28%"> ### 商业合作 ① Discovery系列 | 框架名称 | 框架版本 | 支持Spring Cloud版本 | 使用许可 | | --- | --- | --- | --- | | Discovery | 1.x.x ~ 6.x.x | Camden ~ Hoxton | 开源，永久免费 | | DiscoveryX | 7.x.x ~ 10.x.x | 2020 ~ 2023 | 闭源，商业许可 | ② Polaris系列 Polaris为Discovery高级定制版，特色功能 - 基于Nepxion Discovery集成定制 - 多云、多活、多机房流量调配 - 跨云动态域名、跨环境适配 - DCN、DSU、SET单元化部署 - 组件灵活装配、配置对外屏蔽 - 极简低代码PaaS平台 | 框架名称 | 框架版本 | 支持Discovery版本 | 支持Spring Cloud版本 | 使用许可 | | --- | --- | --- | --- | --- | | Polaris | 1.x.x | 6.x.x | Finchley ~ Hoxton | 闭源，商业许可 | | Polaris | 2.x.x | 7.x.x ~ 10.x.x | 2020 ~ 2023 | 闭源，商业许可 | 有商业版需求的企业和用户，请添加微信1394997，联系作者，洽谈合作事宜 ### 入门资料  Discovery【探索】企业级云原生微服务开源解决方案 ① 快速入门 - [快速入门Github版](https://github.com/Nepxion/Discovery/wiki) - [快速入门Gitee版](https://gitee.com/Nepxion/Discovery/wikis/pages) ② 解决方案 - [解决方案WIKI版](http://nepxion.com/discovery) - [解决方案PPT版](http://nepxion.gitee.io/discovery/docs/link-doc/discovery-ppt.html) ③ 最佳实践 - [最佳实践PPT版](http://nepxion.gitee.io/discovery/docs/link-doc/discovery-ppt-1.html) ④ 平台界面 - [平台界面WIKI版](http://nepxion.com/discovery-platform) ⑤ 框架源码 - [框架源码Github版](https://github.com/Nepxion/Discovery) - [框架源码Gitee版](https://gitee.com/Nepxion/Discovery) ⑥ 指南示例源码 - [指南示例源码Github版](https://github.com/Nepxion/DiscoveryGuide) - [指南示例源码Gitee版](https://gitee.com/Nepxion/DiscoveryGuide) ⑦ 指南示例说明 - Spring Cloud Finchley ~ Hoxton版本 - [极简版指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/6.x.x-simple)，分支为6.x.x-simple - [极简版域网关部署指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/6.x.x-simple-domain-gateway)，分支为6.x.x-simple-domain-gateway - [极简版非域网关部署指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/6.x.x-simple-non-domain-gateway)，分支为6.x.x-simple-non-domain-gateway - [集成版指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/6.x.x)，分支为6.x.x - [高级版指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/6.x.x-complex)，分支为6.x.x-complex - Spring Cloud 202x版本 - [极简版指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/master-simple)，分支为master-simple - [极简版本地化指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/master-simple-native)，分支为master-simple-native - [集成版指南示例](https://github.com/Nepxion/DiscoveryGuide/tree/master)，分支为master  Polaris【北极星】企业级云原生微服务商业解决方案 ① 解决方案 - [解决方案WIKI版](http://nepxion.com/polaris) ② 框架源码 - [框架源码Github版](https://github.com/polaris-paas/polaris-sdk) - [框架源码Gitee版](https://gitee.com/polaris-paas/polaris-sdk) ③ 指南示例源码 - [指南示例源码Github版](https://github.com/polaris-paas/polaris-guide) - [指南示例源码Gitee版](https://gitee.com/polaris-paas/polaris-guide) ④ 指南示例说明 - Spring Cloud Finchley ~ Hoxton版本 - [指南示例](https://github.com/polaris-paas/polaris-guide/tree/1.x.x)，分支为1.x.x - Spring Cloud 202x版本 - [指南示例](https://github.com/polaris-paas/polaris-guide/tree/master)，分支为master ## 请联系我 微信、钉钉、公众号和文档  ## Star走势图 [](https://starchart.cc/Nepxion/Discovery)

davidarchanjo/spring-certified-developer-study-guide

My study guide for the Spring Certified Developer certification

2021-12-21T05:51:50Z

 </br></br> # TABLE OF CONTENTS 1. <a href="#1-introduction-" id="1">INTRODUCTION</a> 2. <a href="#2-exam-overview-" id="2">EXAM OVERVIEW</a> 3. <a href="#3-rest-concepts-" id="3">REST CONCEPTS</a> 4. <a href="#4-spring-core-concepts-" id="4">SPRING CORE CONCEPTS</a> 5. <a href="#5-spring-boot-basics-and-auto-configuration-" id="5">SPRING BOOT BASICS AND AUTO-CONFIGURATION</a> 6. <a href="#6-aspect-oriented-programming-" id="6">ASPECT-ORIENTED PROGRAMMING</a> 7. <a href="#7-data-management-jdbc-transactions-" id="7">DATA MANAGEMENT: JDBC, TRANSACTIONS</a> 8. <a href="#8-spring-data-jpa-" id="8">SPRING DATA JPA</a> 9. <a href="#9-spring-mvc-" id="9">SPRING MVC</a> 10. <a href="#10-spring-security-" id="10">SPRING SECURITY</a> 11. <a href="#11-spring-boot-actuator-" id="11">SPRING BOOT ACTUATOR</a> 12. <a href="#12-spring-boot-testing-" id="12">SPRING BOOT TESTING</a> 13. <a href="#13-build-test-" id="13">BUILD & TEST</a> </br></br> # 1. INTRODUCTION <a id="1-introduction-" href="#1"></a> This guide walks through some technical notes and references about the Spring Framework, with focus on the Spring Boot Framework, serving as a _supporting material_ for whoever is preparing to take the [Spring Certified Professional](https://www.vmware.com/education-services/certification/vcp-spring-exam.html) exam. I came up with this guide in order to consolidate my knowledge throughout my studies, hence all the content presented here are by no means definitive and exhaustive so that someone only based on what I present here can take the exam fully prepared. Ultimately this guide contains many sources for relevant technical documentations, tutorials and notes, and also offers a structured and concise study planning to help on your preparation. </br></br> # 2. EXAM OVERVIEW <a id="2-exam-overview-" href="#2"></a> The **Spring Certified Professional** certification offered by VMWare is an exam scaled on a range from 100-500, with the determined raw cut score scaled to a value of 300. The exam may contain unscored questions in addition to the scored questions, this is a standard testing practice used by VMWare. We can't know which questions are unscored and the final result will reflect the scored questions only. This certification exam is designed to test and validate the overall understanding and familiarity with core aspects of Spring and Spring Boot frameworks as follows: - Container, Dependency, and IoC - Aspect-Oriented Programming (AOC) - Data Management: JDBC, Transactions - Spring Data JPA - Spring MVC Basics - Spring MVC REST - Security - Testing - Spring Boot Basics - Spring Boot Auto Configuration - Spring Boot Actuator - Spring Boot Testing ## EXAM INFO **Duration:** 90 Minutes </br> **Number of Questions:** 50 Questions </br> **Passing Score:** 300 </br> **Format:** Multiple Choice, Multiple Choice Multiple Selection, Drag and Drop, Matching </br></br> # 3. REST CONCEPTS <a id="3-rest-concepts-" href="#3"></a> ## REFERENCES - https://restfulapi.net - https://restapitutorial.com ## OVERVIEW **REST** stands for **RE**presentational **S**tate **T**ransfer and it is a software architectural style introduced by [Roy Fielding](https://en.wikipedia.org/wiki/Roy_Fielding) on 2000 as a design guide to the WEB on its early days. Any web API that conforms to [The REST Principles](https://en.wikipedia.org/wiki/Representational_state_transfer) is classified as **RESTful**. The data and its functionalities provided by a RESTful API are referred _resources_ and are accessed through **Uniform Resource Identifiers**. ## HTTP METHODS REST API resources are manipulated by HTTP methods and the most-commonly-used HTTP methods are POST, GET, PUT and DELETE. These methods correspond, respectively, to **C**reate, **R**ead, **U**pdate, and **D**elete operations and those actions are commonlly referred by the **CRUD** acronym. The following summarises the use of those HTTP methods: | Method | Action | | :----- | :----- | | POST | Create a resource | | GET | Retrieve information about a specific resource or a collection | | PUT | Update a resource | | DELETE | Delete a resource or related component | ## HTTP STATUS In REST APIs, HTTP status codes are used to inform the consumer about the request's result. The status codes are divided into five categories:</br> | Category | Description | | :--------- | :---------- | | 1xx Status | Indicates that the server received the request and is continuing the process | | 2xx Status | Indicates that the client’s request was accepted successfully | | 3xx Status | Indicates that the client must take some additional action in order to complete the request | | 4xx Status | Indicates that the client's request contains erros or bad syntax | | 5xx Status | Indicates that the client's request was unable to be performed due to a server-side error | ## API CONVENTIONS The key principles of REST involves separating the API into _logical resources_ and manipulate them through HTTP requests where every HTTP method (GET, POST, PUT, DELETE etc) performs a specific operation. The functionalities provided by an API are related to _resources_ and by convention the resources are represented on URIs as **nouns in the plural**. All operation made available via URI should be mapped to a HTTP method that corresponds to the action is intended to be carried out. Follows some common examples of mapping correspondence between the HTTP method, operation type and URI format:</br> | Method | URL | Operation | | :----- | :--------- | :-------- | | GET | `/todos` | Retrieves a list of all todos | GET | `/todos/{id}` | Retrieves todo referenced by `id` | POST | `/todos` | Creates a new todo | PUT | `/todos/{id}` | Fully updates todo referenced by `id` | PATCH | `/todos/{id}` | Partially updates todo referenced by `id` | DELETE | `/todos/{id}` | Deletes todo referenced by `id` </br> # 4. SPRING CORE CONCEPTS <a id="4-spring-core-concepts-" href="#4"></a> ## SAMPLE PROJECTS - [spring-bean](./spring-bean/) - [spring-bean-factory-post-processor](./spring-bean-factory-post-processor/) - [spring-bean-lifecycle-callback-order](./spring-bean-lifecycle-callback-order/) - [spring-bean-post-processor](./spring-bean-post-processor/) - [spring-spel](./spring-spel/) - [spring-startup](./spring-startup/) ## REFERENCES - https://www.baeldung.com/inversion-control-and-dependency-injection-in-spring - https://knpcode.com/spring/spring-ioc-container-types-applicationcontext-and-beanfactory - https://www.journaldev.com/2410/spring-dependency-injection - https://www.baeldung.com/spring-bean - https://www.baeldung.com/spring-bean-scopes - https://dzone.com/articles/spring-bean-lifecycle - https://www.geeksforgeeks.org/bean-life-cycle-in-java-spring - https://knpcode.com/spring/spring-bean-lifecycle-callback-methods - https://www.baeldung.com/spring-core-annotations - https://www.baeldung.com/spring-expression-language - https://asyncstream.com/tutorials/spring-initmethod-or-initializingbean/ - https://programmer.help/blogs/after-properties-set-and-init-method-postconstruct-of-spring-initializing-bean.html - https://www.dineshonjava.com/writing-beanpostprocessor-in-spring/ - https://www.dev2qa.com/spring-expression-language-example-vs/ ## OVERVIEW **Bean** is an object that is instantiated and managed from creation to destruction by the **Spring IoC Container**. **Spring IoC Container** is responsible for instantiating beans, wiring dependencies and managing the bean lifecycle from its instantiation till destruction. Spring have two IoC container implementations: [BeanFactory](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/BeanFactory.html) and [ApplicationContext](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/ApplicationContext.html). **Inversion of Control (IoC)** is a process in which an object defines its dependencies without creating them explicitly. The object delegates the construction/instantiation job of its dependencies to the IoC container. **Dependency Injection** is a pattern used to implement IoC, where the control being inverted is the setting and injection of object's dependencies. ## SPRING EXPRESSION LANGUAGE The Spring Expression Language (SpEL for short) is used to query property values from properties file or to manipulate Java objects and its attributes at runtime. @Value annotation is the most used way to process SpEL. A SpEL expression begins with `#` and is enclosed by braces, e.g. `#{2 + 2}`. Properties can be referenced in a similar fashion with `$`, and are enclosed by braces too, e.g. `${foo.bar}`. Property placeholders cannot contain SpEL expressions, but expressions can, e.g. `#{'${foo.bar}' + 2}`. **Notice that to access the property contained in the properties file from SpEL, is mandatory to reference the property enclosed by single quotes**. SpEL provides two special built-in variables: `systemProperties` and `systemEnvironment`: - **systemProperties** – a java.util.Properties object which provides runtime environment properties, like `os.name`, or JVM argument; - **systemEnvironment** – a java.util.Properties object which provides access to environment variables; ## STARTUP INTERFACES Spring Boot provides two interfaces to run specific pieces of code as soon as the application starts: [CommandLineRunner](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/CommandLineRunner.html) and [ApplicationRunner](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/ApplicationRunner.html). > 📌 When defining multiple beans of both types ***in the same configuration class*** (@SpringBootApplication or @Configuration), beans of ApplicationRunner type will be executed before beans of CommandLineRunner type. That rule also applies when they are defined individually as components (@Component). However when defined as components, that default execution order can be changed through the use of [@Order](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/Order.html) annotation. ## FACTORY HOOK INTERFACES [BeanFactoryPostProcessor](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/config/BeanFactoryPostProcessor.html) - used to modify the definition of any bean before it get created/instantiated by working on its configuration metadata phase, such as loading value from external property files. [BeanPostProcessor](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/config/BeanPostProcessor.html) - Factory hook interface that allows for custom modification of new bean instances _before_ and _after_ properties are set from initialization callbacks. [InitializingBean](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/InitializingBean.html) - interface to be implemented by beans that need to react once all their properties have been set by overriding the [afterPropertiesSet](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/InitializingBean.html#afterPropertiesSet--) method. [DisposableBean](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/DisposableBean.html) - interface to be implemented by beans that want to release resources upon their destruction by overriding the [destroy](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/DisposableBean.html#destroy--) method. ### BEAN STATE ANNOTATIONS [@PostConstruct](https://docs.oracle.com/javaee/7/api/javax/annotation/PostConstruct.html) - used on beans to mark a method to be executed, like a callback, after the dependency injection is done. [@PreDestroy](https://docs.oracle.com/javaee/7/api/javax/annotation/PreDestroy.html) - used on beans to mark a method as a callback to signal the instance is in the process of being removed from the container; ### CALLBACK ORDER EXECUTION If all lifecycle callbacks, annotations and a BeanPostProcessor implementation are used in conjuction, the execution sequence goes like this: <br> ➡️ **Bean's constructor**<br> ➡️ **BeanPostProcessor's postProcessBeforeInitialization**<br> ➡️ **@PostConstruct method**<br> ➡️ **InitializingBean's afterPropertiesSet**<br> ➡️ **Bean's init-method**<br> ➡️ **BeanPostProcessor's postProcessAfterInitialization**<br> ➡️ **@PreDestroy method**<br> ➡️ **DisposableBean's destroy**<br> ➡️ **Bean's destroy-method** ## KEY ANNOTATIONS [@Bean](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Bean.html) - used on factory methods to indicate that the produced object will be managed by the Spring container; > 📌 If from a bean definition method another bean definition method is invoked, both within the same configuration class, and the called method is set to have SINGLETON scope then the returned object will always be the same, regardless of the number of invocations; i.e. even on direct calls, the scope defined for the bean determines whether the returning object has to be reused or a new one has to be created. [@Scope](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Scope.html) - used to indicate the scope for instances of the annotated bean; [@Autowired](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Autowired.html) - used at constructors, methods and fields to indicate that the injection (i.e. instantiation) will be managed by the Spring container dinamically; > 📌 @Autowired can not be used to inject primitive and string values. It only works with reference objects. > 📌 @Autowired, when processing field injection, first looks for a bean which type is the same as the field to be injected. If multiple beans of the same type are found, then it may require further qualifications like the bean name or @Qualifier to determine the correct bean to be injected. [@Qualifier](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Qualifier.html) - used to specify the id of the bean that have to be used for injection when more than one type is eligible, i.e. when there are multiple beans resulting in ambiguity; [@Primary](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Primary.html) - used to indicate that a bean must be given preference when multiple candidates are qualified to autowire a single-valued dependency, i.e. is used to set higher preference for a given bean when there are multiple ones of the same type; > 📌 When the injection of a field/parameter marked to be autowired is going to be via its type and there are many candidate instances for the given type, an [NoUniqueBeanDefinitionException](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/NoUniqueBeanDefinitionException.html) will be thrown. To solve, we can either add @Primary to one of the bean definition or add @Qualifier to the field/parameter specifying the name from one of the matching candidate beans [@Lazy](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Lazy.html) - used to indicate whether a bean is to be lazily initialized, i.e. if present on a @Component or @Bean definition and set to `true`, the bean or component will not be initialized until referenced by another bean or explicitly retrieved from the enclosing [BeanFactory](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/BeanFactory.html). This annotation may also be placed on injection points marked with @Autowired, like constructor parameters, method parameters etc; [@Profile](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Profile.html) - used to indicate that a component class or bean is eligiable for registration when the specified profile(s) are active; [@Component](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/stereotype/Component.html) - generic stereotype annotation used to indicate that a class is a managed component, registering as a bean; [@Repository](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/stereotype/Repository.html) - is a @Component stereotype annotation used to indicate that a class defines a data repository. Enables automatic translation of exceptions thrown from the underlying persistence layer; [@Service](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/stereotype/Service.html) - is a @Component stereotype annotation used to indicate that a class defines business logic; [@Configuration](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html) - used to mark a class as a source of bean definitions. > 📌 Spring creates dynamic proxies for classes annotated with @Configuration and uses CGLIB to extend those class to create proxies. Hence, @Configuration classes must not be final, because final classes cannot be extended, i.e. cannot be subclassed; [@Import](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Import.html) - used to indicate one or more component class to import — typically from @Configuration classes. [@ImportAutoConfiguration](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/ImportAutoConfiguration.html) - used to disable the default autoconfiguration flow performed by @EnableAutoConfiguration, importing only the configuration classes provided in the annotation. [@Value](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Value.html) - used at field or method/constructor parameter level to inject value from properties located at .properties/.yml files, SpEL, classpath's resources etc; [@PropertySource](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/PropertySource.html) - used to load values from property files — the values can be accessed from [Environment](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/env/Environment.html) or injected by the @Value annotation; [@ConfigurationProperties](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/context/properties/ConfigurationProperties.html) - used to map resource files such as properties or YAML files to Java Bean object. [@EnableConfigurationProperties](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/context/properties/EnableConfigurationProperties.html) - enables support for @ConfigurationProperties annotated classes in our application. </br></br> # 5. SPRING BOOT BASICS AND AUTO-CONFIGURATION <a id="5-spring-boot-basics-and-auto-configuration-" href="#5"></a> ## SAMPLE PROJECTS - [spring-conditional](./spring-conditional/) ## REFERENCES - https://www.baeldung.com/spring-boot-annotations - https://www.baeldung.com/spring-conditional-annotations - https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/using-boot-auto-configuration.html - https://www.marcobehler.com/guides/spring-boot - https://www.baeldung.com/spring-component-scanning - https://reflectoring.io/spring-boot-conditionals - https://zetcode.com/springboot/conditionalbeans - https://www.baeldung.com/spring-boot-custom-starter ## AUTO-CONFIGURATION Auto-configuration is a mechanism in which Spring automatically configures an application based on the dependencies found on its classpath. When every Spring application boots up, Spring tries to read in properties from 17 locations in addition to the `spring.factories` file in the classpath. `spring.factories` file is a special file that Spring automatically loads when booting up. It contains reference to a lot of @Configuration class mappings which Spring will try to run. The `spring.factories` file is located in `META-INF` of the [org.springframework.boot:spring-boot-autoconfigure](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure) dependency. @Conditional-based annotations are one of the key pieces that makes Spring auto-configuartion mechanism work. We can apply @Conditional-based annotations to common Spring components, like @Bean, @Component, @Service, @Repository and @Controller. [@Conditional](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Conditional.html) - used to indicate that a given component is only eligible for registration when all specified condition match; [@ConditionalOnBean](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnBean.html) - used to condition the registration of the annotated component when beans of all classes specified are contained in the BeanFactory; [@ConditionalOnMissingBean](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnMissingBean.html) - used to condition the registration of the annotated component when none of the bean class specified is contained in the BeanFactory; [@ConditionalOnClass](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnClass.html) used to condition the registration of the annotated component only if the specified classes are on the classpath; [@ConditionalOnMissingClass](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnMissingClass.html) - used to condition the registration of the annotated component only if none of the specified classes are on the classpath; [@ConditionalOnExpression](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnExpression.html) - used to condition the registration of the annotated component only if the specified SpEL expression returns true; [@ConditionalOnProperty](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnProperty.html) - used to condition the registration of the annotated component only if the specified property is set; [@ConditionalOnResource](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnResource.html) - used to condition the registration of the annotated component only if the specified resources exist; [@ConditionalOnJava](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnJava.html) - used to condition the registration of the annotated component only if the application is running on the specified JVM version. By default returns true if the running JVM version is equal to or greater than the specified version; [@ConditionalOnJndi](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnJndi.html) - used to condition the registration of the annotated component only if the specified JNDI context exists; [@ConditionalOnWebApplication](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnWebApplication.html) - used to condition the registration of the annotated component only if the application is a web application (SERVLET or REACTIVE); [@ConditionalOnNotWebApplication](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnNotWebApplication.html) - used to condition the registration of the annotated component only if the application is not a web application; [@ConditionalOnWarDeployment](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnWarDeployment.html) - used to condition the registration of the annotated component only if the application is a traditional WAR deployment. For applications with embedded servers, this condition will always return `false`. [@ConditionalOnSingleCandidate](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnSingleCandidate.html) - used to condition the registration of the annotated component only if a bean of the specified class is already contained in the BeanFactory and only a single candidate can be determined; [@ConditionalOnCloudPlatform](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/ConditionalOnCloudPlatform.html) - used to condition the registration of the annotated component only if the specified cloud platform is active; ### CUSTOM CONDITION We can define a custom logic to be used as criteria for registering a component. To do so we should create a class that implements the [Condition](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Condition.html) interface, overrides its [matches](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Condition.html#matches-org.springframework.context.annotation.ConditionContext-org.springframework.core.type.AnnotatedTypeMetadata-) method with our custom logic, and then specify our class as parameter for the @Conditional annotation. ### COMBINE CONDITIONS We can combine @Conditional-based annotations along with custom conditions in order to implement complex OR or AND logical operation. To apply OR operation, we have to create a custom condition extending the [AnyNestedCondition](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/condition/AnyNestedCondition.html) class, then uses it as argument in the @Conditional annotation. For that purpose I created the [HmlOrPrdEnvironmentCondition](/spring-conditional/src/main/java/io/davidarchanjo/HmlOrPrdEnvironmentCondition.java) custom condition and applied it [here](/spring-conditional/src/main/java/io/davidarchanjo/Config.java#L44). To apply AND operation, we can group custom conditions in the @Conditional and additionally set others @Conditional-based annotations to the component. I demonstrate this operation [here](/spring-conditional/src/main/java/io/davidarchanjo/Config.java#L51). ## External Application Properties By default, Spring Boot will find and load `application.[properties|yml]` files from the following locations when your application boots up. **This list is ordered by precedence with values from lower items overriding earlier ones**: > 📌 Spring applications have in its classpath the `src/main/resource` folder location by default. > 📌 If we have the `application.properties` and `application.yml` files in the same location and a given property is defined in both, the value from _application.properties_ will take precedence over the value at application.yml. > 📌 Command line properties, JVM arguments and OS environment variables will always take precedence over (same) properties defined from application.properties or application.yml. 1. From command-line and OS environment: - OS environment variable, e.g. `export server.port=9090`; - JVM argument, e.g. `-Dserver.port=9090`; - command-line argument, e.g. `--server-port=9090`; 2. From the classpath: - The classpath root, e.g. `/resources` folder by default; - The classpath `/config` folder, i.e. `/resources/config`; 3. From the current directory: - The current directory; - The `/config` subdirectory in the current directory; - Immediate child directories of the `/config` subdirectory, according to system default folder ordering; With that in mind, if a property is defined in `/resources/application.properties` and there is a definition for the same property in `/resources/config/application.properties` with a different value, the value from the latter location will take precedence over the former. </br> ## KEY ANNOTATIONS [@SpringBootApplication](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/SpringBootApplication.html) - is a combination of @Configuration, @EnableAutoConfiguration, and @ComponentScan annotations with their default attributes; [@EnableAutoConfiguration](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html) – used to indicates to ApplicationContext to add beans based on the dependencies on the classpath automatically; [@ComponentScan](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/ComponentScan.html) – used to indicate to ApplicationContext to scan for other components, configurations and beans in the same package as the Application class and below; [@SpringBootConfiguration](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/SpringBootConfiguration.html) - used to indicate that a class provides Spring Boot application @Configuration. Can be used as an alternative to @Configuration annotation so that configuration can be found automatically; </br></br> # 6. ASPECT-ORIENTED PROGRAMMING <a id="6-aspect-oriented-programming-" href="#6"></a> ## SAMPLE PROJECTS - [spring-aop](./spring-aop/) ## REFERENCES - https://www.javatpoint.com/spring-aop-tutorial - https://docs.spring.io/spring-framework/docs/3.0.x/reference/aop.html - https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop - https://www.journaldev.com/2583/spring-aop-example-tutorial-aspect-advice-pointcut-joinpoint-annotations - https://howtodoinjava.com/spring-aop-tutorial/ - https://www.baeldung.com/spring-aop-pointcut-tutorial - https://www.tutorialandexample.com/spring-aop-pointcut-expressions/ - https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/package-summary.html ## OVERVIEW Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the _class_ whereas in AOP the unit of modularity is the _aspect_. ### CORE CONCEPTS * **Cross-Cutting Concerns** - are common functions that span on multiple points of an application, such as logging, transaction management, data validation, etc; * **Join Point** - is any point during the execution of a program, such as a method execution, an exception handling or a field access. In Spring AOP, a join point always represents a method execution; * **Pointcut** - is an expression language from AOP that matches **Joint Point**. Spring uses the AspectJ pointcut expression language by default; * **Advice** - is an action(s) taken by an **Aspect** at a particular **Join Point**; * **Aspect** - is a class that contains Advices, Join Points etc; * **Introduction** - is a means to declare additional methods and fields for a type, allowing to introduce new interface to any advised object; * **Target Object** - is the object being advised by one or more **Aspects**, i.e. the object on which advices are applied. It is known as proxied objects in Spring; * **Interceptor** - is an Aspect that contains only one advice; * **AOP Proxy** - is an object created by the AOP framework in order to implement the aspect contracts. In Spring, an AOP proxy will be a _proxied object_; * **Weaving** - is the process of linking aspects with other application types or objects to create an advised object. Weaving can be done at compile time, load time or runtime. Spring AOP performs weaving at runtime; ## KEY INTERFACE [JoinPoint](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/aopalliance/intercept/Joinpoint.html) - provides reflective access to both the state available at a join point and static information about it. [ProceedingJoinPoint](https://www.javadoc.io/doc/org.aspectj/aspectjrt/latest/org/aspectj/lang/ProceedingJoinPoint.html) - extends from JointPoint and exposes the `proceed(..)` method in order to support @Around advice. ## KEY ANNOTATIONS [@Aspect](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/Aspect.html) - used to mark a @Component class as an aspect declaration; [@Pointcut](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/Pointcut.html) - used in methods to declare pointcut, which can be availed by advice annotations on refering to that pointcut; [@Before](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/Before.html) - used to mark a method to be executed before the matching joint point; [@After](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/After.html) - used to mark a method to be executed after the matching join point finishes, whether normally or by throwing an exception; [@AfterReturning](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/AfterReturning.html) - used to mark a method to be executed after (only if) the matching joint point completes normally without throwing exception; [@AfterThrowing](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/AfterThrowing.html) - used to mark a method to be executed after (only if) the matching join point exits due to an exception; [@Around](https://www.eclipse.org/aspectj/doc/next/aspectj5rt-api/org/aspectj/lang/annotation/Around.html) - used to mark a method to be executed before and after a Joint Point. </br></br> # 7. DATA MANAGEMENT: JDBC, TRANSACTIONS <a id="7-data-management-jdbc-transactions-" href="#7"></a> ## SAMPLE PROJECTS - [spring-datasource](./spring-datasource/) - [spring-jdbctemplate](./spring-jdbctemplate/) - [spring-transaction](./spring-transaction/) ## REFERENCES - https://www.javainuse.com/spring/boot-transaction - https://www.baeldung.com/spring-transactional-propagation-isolation - https://www.marcobehler.com/guides/spring-transaction-management-transactional-in-depth - https://www.byteslounge.com/tutorials/spring-transaction-propagation-tutorial - https://www.byteslounge.com/tutorials/spring-transaction-isolation-tutorial ## TRANSACTIONS <p> <b>Transaction</b> is a single logical unit of work which could be composed by one or many actions that potentially modify the content of a database, i.e. a sequence of actions that are considered as a single logical unit by the application. For an application, if any action running into a transactional context fails then all other actions gets rolled back. In Spring, database transaction is by default <code>auto-commit</code>, i.e. every SQL statement runs in its own transaction and will commit after execution. <i>With @Transactional in place, by default Spring will only rolls back on <b>unchecked exceptions</b> (RuntimeException and its subclasses)</i>. To make a transaction rolls back on checked exception we have to specify it on the @Transaction's <code>rollbakFor</code> parameter. </p> <p> <b>Transaction Propagation</b> is a mechanism used to indicate if a given action will or will not participate in a transactional context as well as how it will behave when called from a context which already has or not a transaction in place. </p> > 📌 The default transaction propagation type is `REQUIRED` > 📌 Read-only transaction is **a transaction which does not modify any data**. If we use the @Transactional's `readOnly` attribute set to `true` on a method which is performing create or update operation then we will not have any created or updated record into the database but rather an exception > 📌 If we have many @Transaction methods in the same class defined with different propagation types and if they are called sequentially, in practice only the propagation configuration of the first method in the flow will be considered. That is because Spring creates a proxy upon detecting the @Transactional annotation when we are calling any internal method, it will bypass the proxy > 📌 If we manually handle exceptions (including unchecked exceptions) via try-catch from a transactional context and an exception pops up, the rollback mechanism won't work and the current transaction will execute and commit normally > 📌 To make transaction suspension works across nested method calls, the methods must belong to different object instances > 📌 The @Transactional annotation at the class level will be applied to all of its public method. However, if a method is annotated with @Transactional its settings will overwrite the transactional settings defined at the class level ### TYPES OF TRANSACTION PROPAGATION | Propagation | Behaviour | |:--------------| :-------- | | [REQUIRED](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#REQUIRED) | Always executes in a transaction. If there is an active transaction it is used otherwise a new one is created | | [REQUIRES_NEW](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#REQUIRES_NEW) | Always executes in a new transaction. If there is an active transaction it gets suspended before stars a new one | | [NESTED](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#NESTED) | Participates in the existing transaction by creating _subtransaction_ which sets _savepoints_ between nested method invocations so that these subtransactions can roll back independently of the outer transaction upon failure | | [SUPPORTS](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#SUPPORTS) | If a physical transaction exists then it makes use otherwise the method will continue its execution in a non-transactional context | | [NOT_SUPPORTED](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#NOT_SUPPORTED) | Always executes outside of a transactional context. If there is a transaction in place it gets suspended until the end of the method execution | | [NEVER](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#NEVER) | Must execute outside of a transactional context. If there is an active transaction an [IllegalTransactionStateException](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/IllegalTransactionStateException.html) is thrown | | [MANDATORY](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html#MANDATORY) | Must execute inside a transactional context. If no active transaction is found an [IllegalTransactionStateException](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/IllegalTransactionStateException.html) is thrown | > 📌 If we try to use `NESTED` propagation with Hibernate JPA we will get a [NestedTransactionNotSupportedException](https://www.javadoc.io/doc/org.springframework/spring-tx/latest/org/springframework/transaction/NestedTransactionNotSupportedException.html) exception with the following message: `JpaDialect does not support savepoints - check your JPA provider capabilities`. That happens because of the Hibernate JPA implementation which does not support nested transcations. To solve, we can use [JdbcTemplate](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/jdbc/core/JdbcTemplate.html) or a JPA provider that supports nested transactions, or use [JOOQ](https://www.jooq.org/). <p> <b>Transaction Isolation</b> is a mechanism used to indicate how changes made to data by one transaction affect other concurrent transactions as well as how and when changed data becomes available to other concurrent transactions, i.e. how changes applied on data by concurrent transactions are visible to each other. </p> ### TYPES OF TRANSACTION ISOLATION | Isolation | Behaviour | | :--------------- | :-------- | | [DEFAULT](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Isolation.html#DEFAULT) | Indicates that for any transaction the default isolation level of the underlying RDBMS will be used | | [READ_COMMITTED](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Isolation.html#READ_COMMITTED) | Indicates that a transaction can only read data that is committed by concurrent transactions | | [READ_UNCOMMITTED](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Isolation.html#READ_UNCOMMITTED) | Indicates that a transaction **may** read data that is still uncommitted by concurrent transactions | | [REPEATABLE_READ](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Isolation.html#REPEATABLE_READ) | Indicates that if a transaction reads one record from the database multiple times the result of all reading must always be the same | | [SERIALIZABLE](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Isolation.html#SERIALIZABLE) | Indicates that transactions must be executed with locking at all levels (read, range and write locking) so that they behave as if they were executed in a serialized way, i.e. concurrent execution of a group of transactions should have the same result as if they are executed sequentially | > 📌 In Spring with JPA if we try to use an isolation level that is different from the DEFAULT isolation type which the transaction manager implementation does not support, we will get an [InvalidIsolationLevelException](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/InvalidIsolationLevelException.html) exception with the following message: `Standard JPA does not support custom isolation levels - use a special JpaDialect for your JPA implementation`. One way to solve this problem is implement a custom JPA dialect. ## KEY INTERFACES [ResultSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.sql/java/sql/ResultSet.html) - is used to access data produced by the execution of database queries. It provides getter methods (getBoolean, getLong, and so on) for retrieving column values (by name or column's index) from the current row. [RowMapper](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/jdbc/core/RowMapper.html) - is used by JdbcTemplate for mapping rows of a ResultSet to Java object _on a per-row basis_. ## KEY ANNOTATIONS [@Transactional](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Transactional.html) - used to indicate declaratively control over transaction boundaries on managed beans, usually for @Service classes which contain business logic; [@EnableTransactionManagement](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/EnableTransactionManagement.html) - used on @Configuration classes to enable the Spring's annotation-driven declarative transaction management capabilities. This annotation is **optional** in Spring Boot application as long as one of spring-data-* modules is configured on the project; </br></br> # 8. SPRING DATA JPA <a id="8-spring-data-jpa-" href="#8"></a> ## SAMPLE PROJECTS - [spring-data-jpa](./spring-data-jpa/) ## REFERENCES - https://spring.io/guides/gs/accessing-data-jpa/ - https://knpcode.com/spring/spring-data-tutorial/ - https://www.baeldung.com/the-persistence-layer-with-spring-data-jpa - https://www.baeldung.com/spring-data-jpa-query ## OVERVIEW Spring Boot configures Hibernate as the default JPA provider, and auto-configures a DataSource bean if there's in-memory database dependency of type H2, HSQLDB or Derby present on the classpath. Spring Boot applications may be configured with mutiple databases of different types. Spring Boot allows to configure DataSource in two ways: programmatically via a @Configuration class or from properties configuration file. ## KEY INTERFACES [CrudRepository](http://static.springsource.org/spring-data/data-commons/docs/current/api/org/springframework/data/repository/CrudRepository.html) - provides CRUD operations on a repository [PagingAndSortingRepository](http://static.springsource.org/spring-data/data-commons/docs/current/api/org/springframework/data/repository/PagingAndSortingRepository.html) - extends from CrudRepository and provides methods for pagination and sorting records [JpaRepository](http://static.springsource.org/spring-data/data-jpa/docs/current/api/org/springframework/data/jpa/repository/JpaRepository.html) - extends from PagingAndSortingRepository and additionally provides JPA related methods such as flushing the persistence context and delete records in a batch ## TESTING By default, transactions in JUnit tests are flagged for rollback when they start. However, if the method is annotated with @Commit or @Rollback(false), they start flagged for commit instead. By default @DataJpaTest autoconfigures an in-memory database like H2 to be used on testing, as long as one of that type is found in the classpath. To avoid stars an embedded database and use a real one like Postgres we must annotate the test class with `@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)`. ## KEY ANNOTATIONS [@Entity](https://javaee.github.io/javaee-spec/javadocs/javax/persistence/Entity.html) - used to specify that the annotated class maps a database entity. If we forget to mark a domain class that will map a database entity with @Entity annotation, we will get an IllegalArgumentException since Spring will not be able to invocate the init method in a not managed type; [@Table](https://javaee.github.io/javaee-spec/javadocs/javax/persistence/Table.html) - used to specify the table's details, like name, schema etc, that will map the entity in the database. It's not mandatory to use @Table on mapping an entity class, and in its absence, the table name will be taken from the class name; [@Id](https://javaee.github.io/javaee-spec/javadocs/javax/persistence/Id.html) - used to mark a property in a entity class as the primary key. If no @Column annotation is specified, the primary key column name is assumed to be the name of the property; [@GeneratedValue](https://javaee.github.io/javaee-spec/javadocs/javax/persistence/GeneratedValue.html) - used to specify the primary key generation strategy which by default is autoincrement; [@Column](https://javaee.github.io/javaee-spec/javadocs/javax/persistence/Column.html) - used to specify database column details like name, constraint etc to which a property will be mapped. If no @Column annotation is specified, then the field name will be used for mapping; [@Query](https://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/Query.html) - used to declare custom queries on repository methods to execute both JPQL or native SQL queries; [@Modifying](https://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/Modifying.html) - used to indicate that a @Query annotated repository method executes a modifying JPQL or native SQL such as a INSERT, UPDATE, DELETE or DDL statement; [@EntityScan](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/domain/EntityScan.html) - used on @Configuration classes to indicate to Spring where is located entity classes when they are not placed under the main application package or its sub-packages; [@EnableJpaRepositories](https://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/config/EnableJpaRepositories.html) - used on @Configuration classes to indicate to Spring where is located JPA repository classes when they are not placed in the same package of the main application class or under its sub-packages; </br></br> # 9. SPRING MVC <a id="9-spring-mvc-" href="#9"></a> ## SAMPLE PROJECTS - [spring-crud](./spring-crud/) - [spring-mvc](./spring-mvc/) - [spring-web](./spring-web/) ## REFERENCES - https://www.marcobehler.com/guides/spring-mvc - https://www.baeldung.com/spring-mvc-tutorial - https://spring.io/guides/gs/serving-web-content - https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/mvc.html - https://howtodoinjava.com/spring-boot2/resttemplate/spring-restful-client-resttemplate-example ## KEY INTERFACES [Model](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/ui/Model.html) - used to pass values required for rendering views; [ModelMap](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/ui/ModelMap.html) - used to pass values to render a view, with the advantage to pass a collection of values like a Map. [ModelAndView](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/ModelAndView.html) - used to pass all the information, i.e. model and view, required to process page rendering; ## KEY ANNOTATIONS [@ModelAttribute](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/ModelAttribute.html) - used to bind method parameter or method return value to a named model attribute, exposed in a web view. [@GetMapping](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/GetMapping.html) - used to map HTTP GET requests onto specific handler method. It is a shortcut for <code>@RequestMapping(method = RequestMethod.GET)</code>; [@PostMapping](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/PostMapping.html) - used to map HTTP POST requests onto specific handler method. It is a shortcut for <code>@RequestMapping(method = RequestMethod.POST)</code>; [@PutMapping](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/PutMapping.html) - used to map HTTP PUT requests onto specific handler method. It is a shortcut for <code>@RequestMapping(method = RequestMethod.PUT)</code>; [@DeleteMapping](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/DeleteMapping.html) - used to map HTTP DELETE requests onto specific handler method. It is a shortcut for <code>@RequestMapping(method = RequestMethod.DELETE)</code>; [@PatchMapping](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/PatchMapping.html) - used to map HTTP PATCH requests onto specific handler method. It is a shortcut for <code>@RequestMapping(method = RequestMethod.PATCH)</code>; [@RequestMapping](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestMapping.html) - used to map web requests onto methods in request-handling classes with flexible method signatures. @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, and @PatchMapping are different variants of @RequestMapping for handling the specific HTTP operation by these annotations. By default @RequestMapping maps all HTTP operations; [@PathVariable](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/PathVariable.html) - used to bind a named URI path parameter into a method argument; [@RequestParam](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestParam.html) - used to bind a URI query parameter to a method argument; [@RequestHeader](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestHeader.html) - used to bind a request header to a method parameter; [@RequestPart](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestPart.html) - used to associate a part of a multipart request with a method argument; [@CookieValue](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/CookieValue.html) - used to indicate that a method parameter is bound to an HTTP cookie; [@RequestBody](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestBody.html) - used to bind the payload body from the request onto a method argument; [@ResponseBody](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/ResponseBody.html) - used to indicate that the result of a request handler method is the response itself. If a class is annotated with @ResponseBody, all of its request handler methods will be functioning like that; [@ResponseStatus](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/ResponseStatus.html) - used to specify the HTTP response status of a request handler method; [@Controller](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/stereotype/Controller.html) - is a @Component stereotype annotation used to mark a class as a source of request method handlers; [@RestController](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RestController.html) - combines the @Controller and @ResponseBody annotations, making all request handler methods in the annotated class assumes @ResponseBody by default; > 📌 We can assign URI template variables or query parameters directly to objects without having to specify the @PathVariable and @RequetParam annotations, respectively; as long as the given object has matching getters/setters > 📌 @RequestMapping's `headers` and `params` attributes are used to narrow requests that contain specific headers or query parameters, respectively > 📌 @RequestMapping methods mapped to "GET" are also implicitly mapped to "HEAD", i.e. there is no need to have "HEAD" explicitly declared. An HTTP HEAD request is processed as if it were an HTTP GET except instead of writing the body only the number of bytes are counted and the "Content-Length" header set. > 📌 @RequestMapping methods have built-in support for HTTP OPTIONS. By default an HTTP OPTIONS request is handled by setting the "Allow" response header to the HTTP methods explicitly declared on all @RequestMapping methods with matching URL patterns. When no HTTP methods are explicitly declared the "Allow" header is set to "GET,HEAD,POST,PUT,PATCH,DELETE,OPTIONS" > 📌 If @RequestMapping is used along with any of its variant annotations in a handler method definition, its configuration will take precedence over the descendant annotation, i.e. only the @RequestMapping settings (e.g. [method](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestMapping.html#method--), [path](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestMapping.html#path--), [query parameters](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestMapping.html#params--), [headers](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestMapping.html#headers--)) will be taken into account. </br></br> # 10. SPRING SECURITY <a id="10-spring-security-" href="#10"></a> ## REFERENCES - https://www.toptal.com/spring/spring-security-tutorial - https://spring.io/guides/topicals/spring-security-architecture - https://www.marcobehler.com/guides/spring-security - https://www.baeldung.com/spring-security-expressions - https://www.section.io/engineering-education/springboot-antmatchers - https://levelup.gitconnected.com/learn-how-to-build-a-token-based-authentication-server-using-spring-boot-and-spring-security-14a82d186f88 - https://medium.com/wolox/securing-applications-with-jwt-spring-boot-da24d3d98f83 - https://medium.com/geekculture/spring-security-authentication-process-authentication-flow-behind-the-scenes-d56da63f04fa ## OVERVIEW <p>Spring Security by default actives both HTTP security filters and the Security Filter Chain and configures/enforces session-based basic authentication for all URLs.</p> <p>The Spring Security framework provides two options to set up authorization schema configuration: URL-based and Annotation-based. * **AuthenticationManager** - works like a coordinator where authentication providers are registered. * **AuthenticationProvider** - processes specific types of authentication. * **UserDetailsService** - core interface that loads user-specific data in the Spring Security flow. * **antMatcher()** - method used to configure URL access restrictions by using [ant patterns](https://ant.apache.org/manual/dirtasks.html#patterns) so that they are only invoked if the given pattern matches. * **mvcMatcher()** - serves for the same purpose as antMatcher but is designed to apply precisely to what the Spring MVC @RequestMapping and related annotations understand, e.g. <code>"mvcMatcher(/hello)"</code> will also match <code>/hello</code> and <code>/hello/</code>, while with antMatcher() only the former will match. ## CORE CONCEPTS * **Authentication** - refers to the process of verifying the identity of a user, based on provided credentials. A common example is entering a username and a password when you log in to a website. You can think of it as an answer to the question: _Who are you?_. * **Authorization** - refers to the process of determining if a user has proper permission to perform a particular action or access particular data, assuming that the user is successfully authenticated. You can think of it as an answer to the question: _Can a user do/access this?_. * **Principle** - refers to the currently authenticated user. * **Granted Authority** - refers to the permission of the authenticated user. * **Role** - refers to a group of permissions which the authenticated user have. ## NOTES - Double wildcard pattern (`**`) will match **the current path (directory) and below**. For instance, the following rule will match `api/public`, `api/public/users`, `api/public/users/1` and so forth: ```java .mvcMatchers("/api/public/**") ``` - Single wildcard pattern (`*`) will match **the path under the specified directory and below**. For instance, the following rule will match `api/public/users`, `api/public/users/1` and so forth: ```java .mvcMatchers("/api/public/*") ``` - URL pattern definitions with role access association should be defined from most to less specific. For instance, in the following definition the pattern `/api/public/get` should be put ideally before `/api/public/**`: ```java .mvcMatchers("/api/public/**").hasRole(Roles.USER_ADMIN) .mvcMatchers("/api/public/get").hasRole(Roles.AUTHOR_ADMIN) ``` ### PATTERN DEFINITION SCENARIOS - Scenario #1<br> **Logged as**: AUTHOR_ADMIN<br> **Pattern:** ```java .antMatchers("/api/public/get").hasRole(Roles.AUTHOR_ADMIN) .antMatchers("/api/public/**").hasRole(Roles.USER_ADMIN) ``` | Path | Status | | :---------------- | :----: | | `/api/public` | 403 | | `/api/public/get` | 200 | - Scenario #2<br> **Logged as**: AUTHOR_ADMIN<br> **Pattern:** ```java .antMatchers("/api/public/**").hasRole(Roles.USER_ADMIN) .antMatchers("/api/public/get").hasRole(Roles.AUTHOR_ADMIN) ``` | Path | Status | | :---------------- | :----: | | `/api/public` | 403 | | `/api/public/get` | 403 | - Scenario #3<br> **Logged as**: AUTHOR_ADMIN<br> **Pattern:** ```java .antMatchers("/api/public/*").hasRole(Roles.USER_ADMIN) .antMatchers("/api/public/get").hasRole(Roles.AUTHOR_ADMIN) ``` | Path | Status | | :---------------- | :----: | | `/api/public` | 200 | | `/api/public/get` | 403 | - Scenario #4<br> **Logged as**: AUTHOR_ADMIN<br> **Pattern:** ```java .antMatchers("/api/public/get").hasRole(Roles.AUTHOR_ADMIN) .antMatchers("/api/public/*").hasRole(Roles.USER_ADMIN) ``` | Path | Status | | :---------------- | :----: | | `/api/public` | 200 | | `/api/public/get` | 200 | <br> ## KEY ANNOTATIONS [@EnableWebSecurity](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/config/annotation/web/configuration/EnableWebSecurity.html) - marks a @Configuration class as a source of web access security configuration. Usually such class extends the [WebSecurityConfigurerAdapter](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/config/annotation/web/configuration/WebSecurityConfigurerAdapter.html) class and overrides its methods for a more granular configuration; [@EnableGlobalMethodSecurity](https://docs.spring.io/spring-security/site/docs/5.6.0-M1/api/org/springframework/security/config/annotation/method/configuration/EnableGlobalMethodSecurity.html) / [@EnableMethodSecurity](https://docs.spring.io/spring-security/site/docs/5.6.0-M1/api/org/springframework/security/config/annotation/method/configuration/EnableMethodSecurity.html) - both are used to configure security on method level through annotations. They have the following attributes: <ol> <li><code>securedEnabled</code></li> <span>If set to true enables @Secured annotation. Default is false</span> <li><code>jsr250Enabled</code></li> <span>If set to true enables @RolesAllowed annotation. Default is false</span> <li><code>prePostEnabled</code></li> <span>If set to true enables @PreAuthorize, @PostAuthorize, @PreFilter, @PostFilter annotations. Default is false</span> </ol> [@PreAuthorize](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/access/prepost/PreAuthorize.html) - supports SpEL and is used to provide expression-based access control before executing the method; [@PostAuthorize](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/access/prepost/PostAuthorize.html) - supports SpEL and is used to provide expression-based access control after executing the method and provides the ability to access/alter the method's result; [@PreFilter](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/access/prepost/PreFilter.html) - supports SpEL and is used to filter the collection or arrays before executing the method based on custom security rules we define; [@PostFilter](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/access/prepost/PostFilter.html) - supports SpEL and is used to filter the returned collection or arrays after executing the method based on custom security rules we define (provides the ability to access the method result); [@Secured](https://docs.spring.io/spring-security/site/docs/3.2.8.RELEASE/apidocs/org/springframework/security/access/annotation/Secured.html) - does not support SpEL and is used to specify a list of roles which the logged user must have in order to access the annotated method; [@RolesAllowed](https://javaee.github.io/javaee-spec/javadocs/javax/annotation/security/RolesAllowed.html) - does not support SpEL and is the [JSR-250](https://jcp.org/en/jsr/detail?id=250)’s equivalent annotation of the @Secured annotation; [@WithMockUser](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/test/context/support/WithMockUser.html) - can be added to a test method to emulate running with a mocked user; [@WithUserDetails](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/test/context/support/WithUserDetails.html) - can be added to a test to emulate a UserDetails instance which is returned from the UserDetailsService according to the given username; [@WithAnonymousUser](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/test/context/support/WithAnonymousUser.html) - can be added to a test method to emulate running with an anonymous user. This is useful when a user wants to run a majority of tests as a specific user and override a few methods to be anonymous; [@WithSecurityContext](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/test/context/support/WithSecurityContext.html) - determines what SecurityContext to use, and all three annotations described above are based on it. If we have a specific use case, we can create our own annotation that uses @WithSecurityContext to create any SecurityContext we want; </br></br> # 11. SPRING BOOT ACTUATOR <a id="11-spring-boot-actuator-" href="#11"></a> ## SAMPLE PROJECTS - [spring-actuator](./spring-actuator/) ### REQUIRIMENT TO USE THE SAMPLE PROJECTS - PostgreSQL > 📌 To spin up a PostgreSQL instance by Docker, you can use the following command: <br> `docker run --name postgres-14.1 -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres -p 5432:5432 --rm -it postgres:14.1-alpine` ## REFERENCES - https://www.baeldung.com/spring-actuators - https://www.baeldung.com/spring-boot-health-indicators - https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html# - https://lightrun.com/best-practices/getting-started-with-spring-actuator - https://www.javadevjournal.com/spring-boot/spring-actuator-custom-endpoint - https://dimitr.im/mastering-spring-boot-actuator ## OVERVIEW Spring Boot Actuator provides resources so we can monitor and manage our application's health and availability. It is mainly used to expose operational information about the running application, such as health, metrics, info, dump, environment, loggers etc. ## BUILT-IN ENDPOINTS By default, Spring Boot Actuator comes with all built-in endpoints disabled, except `/health`. A given endpoint is considered _available_ when it is both _enabled_ and _exposed_. Spring Boot Actuator's endpoints are exposed over REST endpoints and JMX. Table of built-in endpoints provided out of the box: | ENDPOINT | DESCRIPTION | | :------------------ | :---------- | | `/auditevents` | Returns audit event information for the current application | | `/beans` | Returns a complete list of all Spring beans in the current application | | `/caches` | Returns available caches | | `/conditions` | Returns a report of all conditions around autoconfiguration | | `/configprops` | Returns a grouped list of all @ConfigurationProperties | | `/env` | Returns the current environment properties from Spring’s ConfigurableEnvironment | | `/health` | Returns application health information | | `/httptrace` | Returns HTTP trace informations (last 100 HTTP request-response exchanges by default) | | `/info` | Returns arbitrary application information | | `/integrationgraph` | Returns the Spring integration graph. Requires a spring-integration-core dependency | | `/loggers` | Returns the configuration of all loggers in the application. Can be used to modify at run time a logger level | | `/metrics` | Returns metrics information for the current app | | `/mappings` | Returns a grouped list of all your application's APIs | | `/scheduledtasks` | Returns the tasks scheduled in your application | | `/sessions` | Returns retrieval and deletion of user sessions from a Spring Session supported session store. Requires a Servlet-based web application using Spring Session | | `/shutdown` | Disables the application. It is not enabled by default (To enable `management.endpoint.shutdown.enabled=true`)| | `/startup` | Returns the startup step data collected by ApplicationStartup | | `/threaddump` | Performs a thread dump | ## INFO ENDPOINT To expose custom information on `/actuator/info` we should set them as property entries starting with `info.*` at `application.yml` or `application.properties`. Also, it's required to set `management.info.env.enabled` to `true` because the Spring Actuator's `InfoContributor` is disabled by default. > 📌 The `/info` endpoint comes disable by default. To enable it we have to set the property `management.endpoints.web.exposure.include` including it as entry. ### GIT & BUILD INFORMATION To get git and build details returned on `/actuator/info`, we have to add the following to the plugin section: ```xml <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <executions> <execution> <goals> <goal>build-info</goal> </goals> </execution> </executions> </plugin> <plugin> <groupId>pl.project13.maven</groupId> <artifactId>git-commit-id-plugin</artifactId> </plugin> ``` ## HEALTH ENDPOINT ### HEALTH INDICATOR Health indicators can used to report the healthiness and availability of inner components as well as third-party services required for the application. Spring Boot Actuator comes with predefined health indicators which provide specific status. Such built-in indicators are: [DiskSpaceHealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/system/DiskSpaceHealthIndicator.html), [PingHealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/health/PingHealthIndicator.html), [LivenessStateHealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/availability/LivenessStateHealthIndicator.html) and [ReadinessStateHealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/availability/ReadinessStateHealthIndicator.html). Some health indicators are registered and added automatically according to the existence of specific dependencies on the classpath or when other conditions are satisfied. For instance, [DataSourceHealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/jdbc/DataSourceHealthIndicator.html will be available if any relational database driver dependency is found; [RedisHealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/redis/RedisHealthIndicator.html) will be available if the Redis dependency module is found on the classpath. Table of Health Indicators provided out of the box: | HEALTH INDICATOR | ENDPOINT | | :------------------------------- | :------- | | CassandraHealthIndicator | `/actuator/health/cassandra` | | CouchbaseHealthIndicator | `/actuator/health/couchbase` | | DataSourceHealthIndicator | `/actuator/health/db` | | DiskSpaceHealthIndicator | `/actuator/health/diskSpace` | | ElasticsearchRestHealthIndicator | `/actuator/health/elasticsearch` | | HazelcastHealthIndicator | `/actuator/health/hazelcast` | | InfluxDbHealthIndicator | `/actuator/health/influx` | | JmsHealthIndicator | `/actuator/health/jms` | | LdapHealthIndicator | `/actuator/health/ldap` | | LivenessStateHealthIndicator | `/actuator/health/liveliness` | | MailHealthIndicator | `/actuator/health/mail` | | MongoHealthIndicator | `/actuator/health/mongo` | | Neo4jHealthIndicator | `/actuator/health/neo4j` | | PingHealthIndicator | `/actuator/health/ping` | | RabbitHealthIndicator | `/actuator/health/rabbit` | | ReadinessStateHealthIndicator | `/actuator/health/readiness` | | RedisHealthIndicator | `/actuator/health/readiness` | | SolrHealthIndicator | `/actuator/health/solr` | The Liveness and Readiness HTTP probe statuses are returned by default on `/actuator/health` for applications running on Kubernetes. To enable them to be exposed otherwise we have to set the property `management.health.probes.enabled` to `true`. By default `/actuator/health` does not return detailed informations about the available indicators. To get them exposed, we have to set both properties `management.endpoint.health.show-components` and `management.endpoint.health.show-details` to `always`. By default there are four types of health status: `UP`, `DOWN`, `OUT_OF_SERVICE` and `UNKNOWN`, and for each there is a corresponding associated HTTP code. | STATUS | HTTP_CODE | MEANING | | :------------- | :--------: | :------ | | UP | 200 | The component or subsystem is functioning as expected | | DOWN | 503 | The component or subsystem has suffered an unexpected failure | | OUT_OF_SERVICE | 503 | The component or subsystem has been taken out of service and should not be used | | UNKNOWN | 200 | The component or subsystem is in an unknown state | The application's **overall status** is an aggregation of all health indicators statuses, i.e. from all built-in (db, diskSpace, ping, livenessState, readiness etc) and custom health indicators. If one of them is in failure or unknown state, _the root status will be reported as DOWN_. ### CUSTOM HEALTH INDICATORS To register a custom health indicator we have to create a @Component class that implements the [HealthIndicator](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/health/HealthIndicator.html) interface and overrides the `health()` method. To generate a composite health check indicator in order to combine many indicators we have to create a @Component class that implements the [CompositeHealthContributor](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/health/CompositeHealthContributor.html) interface; mark each of the contributing health indicators with the [HealthContributor](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/health/HealthContributor.html) interface; and override the `iterator()` method in the CompositeHealthContributor implementation component class with the list of health contributors (component class that implements HealthContributor) ## METRICS The Spring Actuator exposes the `/actuator/metrics` endpoint which returns performance and operational measurements. To collect and gather metrics Spring Actuator relies on the [Micrometer](https://micrometer.io/) framework, which acts as a facade – an intermediate layer – between the application and some of the more popular monitoring tools, like Prometheus, Elastic, DataDog, Dynatrace etc. ### METRIC TYPES #### COUNTERS A [Counter](https://javadoc.io/doc/io.micrometer/micrometer-core/latest/io/micrometer/core/instrument/Counter.html) represents a value that will always get incremented. It is applicable to measure a number of events or actions that is supposed to only increases, and never decreases. #### GAUGES A [Gauge](https://javadoc.io/doc/io.micrometer/micrometer-core/latest/io/micrometer/core/instrument/Gauge.html) represents a value that may go up or down, and that have fixed upper bounds. #### TIMERS A [Timer](https://javadoc.io/doc/io.micrometer/micrometer-core/latest/io/micrometer/core/instrument/Timer.html) is used to track how long certain method, action or request takes to execute. ## LOGGER ENDPOINT Spring Actuator provides the `/actuator/loggers` endpoint which returns all the loggers, and their configured log levels, existing in the application. To check details for an individual logger we access the endpoint http://localhost:8081/actuator/loggers/{logger.name}, where `{logger.name}` should be the name of the desired logger. For instance, http://localhost:8081/actuator/loggers/io.davidarchanjo would output the following: ```json { "configuredLevel": "null", "effectiveLevel": "INFO" } ``` ### CHANGING LOGGING LEVEL Spring Actuator also provides a way to change the current log level at run time. To change we issue a POST request specificing the logger with the desired new log level. For instance, to set the log level to `TRACE` of the package `io.davidarchanjo` the request goes as below: ```shell $ curl -X POST \ localhost:8081/actuator/loggers/io.davidarchanjo \ -H 'content-type: application/json' \ -d '{"configuredLevel":"TRACE"}' ``` ## KEY ANNOTATIONS [@Endpoint](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/endpoint/annotation/Endpoint.html) - used to indicate a type as being an actuator endpoint that provides information about the running application; [@RestControllerEndpoint](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/endpoint/web/annotation/RestControllerEndpoint.html) - used to indicate a type as being a REST endpoint that is only exposed over Spring MVC or Spring WebFlux; [@Selector](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/endpoint/annotation/Selector.html) - works like @PathVariable annotation by binding a named URI actuator endpoint path parameter into an argument; [@ReadOperation](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/endpoint/annotation/ReadOperation.html) – used to indicate a method on an @Endpoint component class as read operation (HTTP GET accessible); [@WriteOperation](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/endpoint/annotation/WriteOperation.html) – used to indicate a method on an @Endpoint component class as write operation (HTTP POST accessible); [@DeleteOperation](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/actuate/endpoint/annotation/DeleteOperation.html) – used to indicate a method on an @Endpoint component class as delete operation (HTTP DELETE accessible); </br></br> # 12. SPRING BOOT TESTING <a id="12-spring-boot-testing-" href="#12"></a> ## SAMPLE PROJECTS - [spring-testing](./spring-testing/) ## REFERENCES - https://spring.io/guides/gs/testing-web/ - https://howtodoinjava.com/spring-boot2/testing/springboot-test-configuration/ - https://howtodoinjava.com/spring-boot2/testing/junit5-with-spring-boot2/ - https://newbedev.com/unit-test-or-integration-test-in-spring-boot - https://docs.spring.io/spring-framework/docs/current/reference/html/testing.html - https://reflectoring.io/spring-boot-test/ - https://rieckpil.de/spring-boot-unit-and-integration-testing-overview/ - https://rieckpil.de/spring-boot-test-slices-overview-and-usage/ - https://rieckpil.de/guide-to-springboottest-for-spring-boot-integration-tests/ - https://rieckpil.de/difference-between-mock-and-mockbean-spring-boot-applications/ - https://rieckpil.de/fix-no-qualifying-spring-bean-error-for-spring-boot-tests/ ## KEY ANNOTATIONS [@ExtendWith](https://junit.org/junit5/docs/5.0.3/api/org/junit/jupiter/api/extension/ExtendWith.html) - JUnit annotation that is used to register extensions for the annotated test class or test method. [Prior to Spring 2.1 release](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.1-Release-Notes#junit-5), `@ExtendWith(SpringExtension.class)` was necessary to be specified at the test class-level in order to enable Spring support, but as of then is no longer needed because it is included as a meta annotation in the Spring Boot test annotations like @DataJpaTest, @WebMvcTest, and @SpringBootTest. [@SpringBootTest](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/context/SpringBootTest.html) - used to bootstrap a complete application context for testing. @SpringBootTest by default starts searching in the current package of the annotated test class and then searches upwards through the package structure, looking for a class annotated with @SpringBootConfiguration from which it reads the configuration to create an application context. This class is usually the main application class since the @SpringBootApplication annotation includes the @SpringBootConfiguration annotation. It then creates an application context very similar to the one that would be started in a production environment. [@ContextConfiguration](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/test/context/ContextConfiguration.html) - used to load <ins>component classes</ins><a href="#note1" id="note1ref">¹</a> in order to configure an ApplicationContext for integration test. [@WebMvcTest](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/autoconfigure/web/servlet/WebMvcTest.html) - used to set up an application context with just enough components and configurations required to test the **Web MVC Controller Layer**. It disables full auto-configuration and instead apply only configuration relevant to MVC tests. [@DataJpaTest](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/autoconfigure/orm/jpa/DataJpaTest.html) - used to set up an application context specificaly to test the **Persistence Layer**, by configuring entities, repositories. @DataJpaTest by default autoconfigures an in-memory/embedded database like H2. [@Commit](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/test/annotation/Commit.html) - *test annotation* used to indicate that changes performed on database from a test method should be committed before it ends. When used at class-level, all test methods will commit changes to the database. [@Rollback](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/test/annotation/Rollback.html) - *test annotation* used to indicate that changes performed on database from a test method should be roll backed before it ends. When used at class-level, all test methods will behave in that way. [@TestConfiguration](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/context/TestConfiguration.html) - used to define additional beans or override existing beans in the Spring application context in order to add specialized configuration for testing. Configuration classes annotated with @TestConfiguration are excluded from component scanning. Configuration classes with bean definition annotated with @TestConfiguration can be imported by @Import or declared as static inner classes. It is required to set the property <code>spring.main.allow-bean-definition-overriding=true</code> in order to enable bean overriding feature during testing. [@MockBean](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/mock/mockito/MockBean.html) - part of the Spring Test Framework and used to create mocks for beans whenever running tests targeted to the _Spring Test context_ (i.e. testing with @SpringBootTest, @WebMvcTest, @DataJpaTest and so on). [@Mock](https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html) - part of the [Mockito Framework](https://site.mockito.org) and used to create a mock for a class or interface. It is a shorhand for the <code>Mockito.mock()</code>. [@InjectMocks](https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/InjectMocks.html) - part of the [Mockito Framework](https://site.mockito.org) and used to create a mock for the marked field and injects all dependencies annotated with @Mock into it. ## NOTES ### @SpringBootTest vs @ContextConfiguration - Even though both can be used to specify how to load an application context in integration test, @ContextConfiguration doesn’t take full advantage of Spring Boot features, like logging or additional property loading. ### @MockBean vs @Mock - For any test that doesn’t need any dependencies from the Spring Boot container (application context), @Mock should be used as it is fast and favours the isolation of the tested component; - If a test relies on the Spring Boot container (application context) and it's also needed to add or mock one of the container beans, @MockBean should be used; - As a rule of thumb, @Mock should be used when testing services components where business logic are implemented, and @MockBean should be used when doing sliced context testing like on the controller (@WebMvcTest) or repository (@DataJpaTest) layer, or when running backed Spring context tests (@SpringBootTest). </br></br> # 13. BUILD & TEST <a id="13-build-test-" href="#13"></a> ### BUILD ALL PROJECTS ```shell $ ./mvnw package ``` ### BUILD ALL PROJECTS SKIPPING TEST ```shell $ ./mvnw package -DskipTests ``` ### BUILD INDIVIDUAL PROJECT ```shell $ ./mvnw package -pl spring-crud ``` ### BUILD INDIVIDUAL PROJECT SKIPPING TEST ```shell $ ./mvnw package -DskipTests -pl spring-crud ``` ### RUN INDIVIDUAL PROJECT - Option 1: ```shell $ ./mvnw spring-boot:run -pl spring-crud ``` - Option 2: ```shell $ java -jar spring-crud/target/spring-crud-0.0.1.jar ``` ### RUN ALL PROJECTS TEST ```shell $ ./mvnw test ``` ### RUN INDIVIDUAL PROJECT TEST ```shell $ ./mvnw test -pl spring-crud ``` ### RUN SINGLE TEST CLASS FROM INDIVIDUAL PROJECT ```shell $ ./mvnw test -pl spring-crud -Dtest=io.davidarchanjo.controller.ToDoControllerTest ``` ### RUN SINGLE TEST METHOD FROM A TEST CLASS OF AN INDIVIDUAL PROJECT ```shell $ ./mvnw test -pl spring-crud -Dtest=io.davidarchanjo.controller.ToDoControllerTest#shouldCreateNewToDo_WithSuccess ``` </br></br> <a id="note1" href="#note1ref">¹</a> <ins>component classes</ins> - is any class annotated with @Configuration or @Component (including any of its stereotype like @Service, @Repository etc) as well as any JSR-330 compliant class that is annotated with javax.inject annotations.

mikeroyal/AWS-Guide

Amazon Web Services (AWS) Guide. Learn all about Amazon Web Services Tools, Services, and Certifications.

2021-04-11T21:07:16Z

<h1 align="center"> <img src="https://user-images.githubusercontent.com/45159366/114322508-7d8c7280-9ad5-11eb-807e-4dc63c9bc0e1.png"> <br /> Amazon Web Services (AWS) Guide </h1> <a href="https://github.com/mikeroyal?tab=followers"> <img alt="followers" title="Follow me on Github for Updates" src="https://custom-icon-badges.demolab.com/github/followers/mikeroyal?color=236ad3&labelColor=1155ba&style=for-the-badge&logo=person-add&label=Follow&logoColor=white"/></a>   #### A guide for getting started with AWS including the Tools and Applications that will make you a better and more efficient engineer with AWS. **Note: You can easily convert this markdown file to a PDF in [VSCode](https://code.visualstudio.com/) using this handy extension [Markdown PDF](https://marketplace.visualstudio.com/items?itemName=yzane.markdown-pdf).** <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/114321716-048b1c00-9ad1-11eb-828d-a5a5f2a3c726.png"> <br /> </p> # Table of Contents 1. [AWS Learning Resources](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#AWS-learning-resources) - [Developer Resources](#developer-resources) - [AWS Training & Courses](#certifications--courses) - [AWS Books](#books) - [YouTube Tutorials](#youtube-tutorials) 2. [AWS Tools](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#AWS-tools) 3. [AWS Devops Tools Integration](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#AWS-devops-tools-integration) 4. [Networking](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#networking) 5. [Databases](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#databases) 6. [Telco 5G](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#telco-5g) 7. [Open Source Security](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#open-source-security) 8. [Kubernetes](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#kubernetes) 9. [Machine Learning](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#machine-learning) 10. [Node.js Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#nodejs-development) 11. [C/C++ Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#cc-development) 12. [Java Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#java-development) 13. [Go Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#go-development) 14. [Python Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#python-development) 15. [TypeScript Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#typescript-development) 16. [.NET Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#net-development) 17. [Ruby Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#ruby-development) 18. [PHP Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#php-development) 19. [Bash/PowerShell Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#bashpowershell-development) 20. [Rust Development](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#rust-development) # AWS Learning Resources [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) [Amazon Web Services](https://aws.amazon.com/about-aws/) is a reliable, scalable, and inexpensive on-demand cloud computing platforms, services and APIs to individuals, companies, and governments, on a metered pay-as-you-go basis. <img src="https://user-images.githubusercontent.com/45159366/114321714-02c15880-9ad1-11eb-95ac-441aac6b438d.png"> **Amazon Web Services Architecture. Source: [AWS](https://aws.amazon.com/architecture/)** ### Developer Resources [Back to the Top](https://github.com/mikeroyal/AWS-Guide#table-of-contents) - [Know Before You Go: An AWS Partner's Guide to re:Invent 2023](https://aws.amazon.com/blogs/apn/know-before-you-go-an-aws-partners-guide-to-reinvent-2023/) - [Cloud Events, Webinars and Conferences - AWS](https://aws.amazon.com/events/) - [AWS Developer Center](https://aws.amazon.com/developer/) - [AWS Pricing Calculator](https://calculator.aws/) - [AWS Sample Code & Libraries](http://aws.amazon.com/code/Amazon-SimpleDB) - [AWS Developer Tools](http://aws.amazon.com/developertools/Amazon-SimpleDB) - [What's New with AWS - Latest updates on AWS products and features.](https://aws.amazon.com/new/) - [AWS Articles & Tutorials](http://aws.amazon.com/articles/Amazon-SimpleDB) - [Amazon VPC Resources](https://aws.amazon.com/vpc/developer-resources/) - [AWS Community Forum](https://forums.aws.amazon.com/forum.jspa?forumID=38) - [AWS General Reference Guide (PDF)](https://docs.aws.amazon.com/general/latest/gr/aws-general.pdf) - [Introduction to DevOps on AWS (PDF)](https://d1.awsstatic.com/whitepapers/AWS_DevOps.pdf) - [Getting Started with Amazon Web Services (AWS)](https://aws.amazon.com/getting-started/) - [Hands-On Tutorials for Amazon Web Services (AWS)](https://aws.amazon.com/getting-started/hands-on/) - [AWS Training and Certification](https://aws.amazon.com/training/) - [AWS Cost Management introduces visual Savings Plans recommendations](https://aws.amazon.com/savingsplans/) - [Amazon OpenSearch Service Developer Guide](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless.html) - [Getting started with AWS IoT Core](https://docs.aws.amazon.com/iot/latest/developerguide/iot-gs.html) - [Working with 64-bit ARM workloads on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-arm64.html) - [AWS Batch User Guide](https://docs.aws.amazon.com/batch/latest/userguide/what-is-batch.html) - [Amazon S3 Backups Guide](https://docs.aws.amazon.com/aws-backup/latest/devguide/s3-backups.html) ### Certifications & Courses [Back to the Top](https://github.com/mikeroyal/AWS-Guide#table-of-contents) - [AWS Training and Certification](https://aws.amazon.com/training/) - [AWS Academy - Amazon Web Services (AWS)](https://aws.amazon.com/training/awsacademy/) - [AWS Educate](https://aws.amazon.com/education/awseducate/) - [Architecting on AWS Classroom Training](https://aws.amazon.com/training/classroom/architecting-on-aws/) - [DevOps Engineering on AWS from AWS Training](https://aws.amazon.com/training/course-descriptions/devops-engineering/) - [AWS Certified DevOps Engineer - Professional from A Cloud Guru](https://acloud.guru/learn/aws-certified-devops-engineer-professional) - [AWS Internet of Things Foundation Series Training](https://www.aws.training/Details/Curriculum?id=27289) - [AWS Certified Security - Specialty Certification](https://aws.amazon.com/certification/certified-security-specialty/) - [AWS Certification Training Courses on Udemy](https://www.udemy.com/topic/aws-certification/) - [Amazon Web Services Courses on Coursera](https://www.coursera.org/aws) - [Amazon Web Services Courses on edX](https://www.edx.org/school/aws) ### Books [Back to the Top](https://github.com/mikeroyal/AWS-Guide#table-of-contents) - [AWS Certified Machine Learning Study Guide: Specialty (MLS-C01) Exam](https://www.amazon.com/Certified-Machine-Learning-Study-Guide/dp/1119821002/ref=sr_1_6?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062121&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-6) - [Data Science on AWS: Implementing End-to-End, Continuous AI and Machine Learning Pipelines](https://www.amazon.com/Data-Science-AWS-End-End/dp/1492079391/ref=sr_1_7?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062121&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-7) - [Mastering Machine Learning on AWS: Advanced machine learning in Python using SageMaker, Apache Spark, and TensorFlow](https://www.amazon.com/Mastering-Machine-Learning-AWS-TensorFlow/dp/1789349796/ref=sr_1_9?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062121&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-9) - [Learning AWS: Design, build, and deploy responsive applications using AWS cloud components](https://www.amazon.com/Learning-AWS-Aurobindo-Sarkar/dp/1784394637/ref=sr_1_20?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062240&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-20) - [AWS: AMAZON WEB SERVICES: The Complete Guide From Beginners For Amazon Web Services](https://www.amazon.com/AWS-SERVICES-Complete-Beginners-Services/dp/1696347831/ref=sr_1_20?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062240&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-20) - [AWS Cookbook: Recipes for Success on AWS](https://www.amazon.com/AWS-Cookbook-Recipes-Success/dp/1492092606/ref=sr_1_21?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062240&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-21) - [Solutions Architect's Handbook: Kick-start your career as a solutions architect by learning architecture design principles and strategies, 2nd Edition](https://www.amazon.com/Solutions-Architects-Handbook-Kick-start-architecture/dp/1801816611/ref=sr_1_24?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062240&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-24) - [Data Engineering with AWS: Learn how to design and build cloud-based data transformation pipelines using AWS](https://www.amazon.com/Data-Engineering-AWS-Gareth-Eagar/dp/1800560419/ref=sr_1_25?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062240&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-25) - [Learn Amazon SageMaker: A guide to building, training, and deploying machine learning models for developers and data scientists, 2nd Edition](https://www.amazon.com/Learn-Amazon-SageMaker-developers-scientists/dp/1801817952/ref=sr_1_27?crid=1JKUFONBXR8MZ&keywords=learning+aws&qid=1654062240&s=books&sprefix=learning+aw%2Cstripbooks%2C153&sr=1-27) ### YouTube Tutorials [Back to the Top](#table-of-contents) [](https://www.youtube.com/watch?v=e1I5v6uX_As&list=RDCMUCd6MoB9NC6uYN2grvUNT-Zg&start_radio=1) [](https://www.youtube.com/watch?v=JIbIYCM48to) [](https://www.youtube.com/watch?v=bX95Ga3rbkA) [](https://www.youtube.com/watch?v=Uq5w1lnKzlk) # AWS Tools [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) [AWS Pricing Calculator](https://calculator.aws/) [AWS Marketplace](https://aws.amazon.com/) is a digital catalog with thousands of software listings from independent software vendors that make it easy to find, test, buy, and deploy software that runs on AWS. [AWS Cloud9](https://aws.amazon.com/cloud9/) is a cloud-based integrated development environment (IDE) that lets you write, run, and debug your code with just a browser. It includes a code editor, debugger, and terminal. Cloud9 comes prepackaged with essential tools for popular programming languages, including JavaScript, Python, PHP, and more, so you don’t need to install files or configure your development machine to start new projects. [AWS Command Line Interface (CLI)](https://aws.amazon.com/cli/) is a unified tool to manage your AWS services through the command line interface. [AWS Amplify Command Line Interface (CLI)](https://docs.amplify.aws/cli) is a unified toolchain to create, integrate, and manage the AWS cloud services for your app. [AWS Serverless Application Model (SAM) CLI](https://github.com/aws/aws-sam-cli) is a command line tool for an open-source framework for building serverless applications. It provides shorthand syntax to express functions, APIs, databases, and event source mappings. With just a few lines of configuration, you can define the application you want and model it. [Amazon Q in QuickSight](https://aws.amazon.com/quicksight/q/) is an AI Chabot(similar to OpenAI ChatGPT) service for business intelligence (BI) where users can build, discover, and share actionable insights and narratives in seconds using intuitive natural language experiences. [AWS Copilot command line interface (CLI)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Copilot.html) is a command line tool that simplifies building, releasing, and operating production-ready containerized applications on Amazon ECS from a local development environment. The AWS Copilot CLI aligns with developer workflows that support modern application best practices: from using infrastructure as code to creating a CI/CD pipeline provisioned on behalf of a user. [Amazon Elastic Container Service (Amazon ECS) command line interface (CLI)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI.html) is a command line tool that provides high-level commands to simplify creating, updating, and monitoring clusters and tasks from a local development environment. The Amazon ECS CLI supports Docker Compose files, a popular open-source specification for defining and running multi-container applications. [AWS ECS](https://aws.amazon.com/ecs/) is a highly scalable, high-performance container orchestration service that supports Docker containers and allows you to easily run and scale containerized applications on AWS. Amazon ECS eliminates the need for you to install and operate your own container orchestration software, manage and scale a cluster of virtual machines, or schedule containers on those virtual machines. [Amazon Simple Storage Service (Amazon S3)](https://aws.amazon.com/s3/) is an object storage service that offers industry-leading scalability, data availability, security, and performance. This means customers of all sizes and industries can use it to store and protect any amount of data for a range of use cases, such as data lakes, websites, mobile applications, backup and restore, archive, enterprise applications, IoT devices, and big data analytics. [AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/) is an open-source software development framework to define cloud infrastructure in code and provision it through AWS CloudFormation. It offers a high-level object-oriented abstraction to define AWS resources imperatively using the power of modern programming languages. [AWS Lambda](https://aws.amazon.com/lambda/) is an event-driven, serverless computing platform provided by Amazon as a part of the Amazon Web Services. It is a computing service that runs code in response to events and automatically manages the computing resources required by that code. [AWS Elastic Beanstalk](https://aws.amazon.com/elasticbeanstalk/) is an easy-to-use service for deploying and scaling web applications and services developed with Java,.NET, PHP, Node.js, Python, Ruby, Go, and Docker on familiar servers such as Apache, Nginx, Passenger, and IIS. [AWS SimSpace Weave](https://aws.amazon.com/simspaceweaver/) is a new compute service to run real-time spatial simulations in the cloud and at scale. With SimSpace Weaver, simulation developers are no longer limited by the compute and memory of their hardware. [AWS Wickr](https://aws.amazon.com/wickr/) is an enterprise communications service with end-to-end encryption, that allows businesses and public sector organizations to communicate more securely, enabling customers to meet auditing and regulatory requirements like e-discovery, legal hold, and [FOIA requests](https://www.foia.gov/). [AWS IoT Greengrass](https://aws.amazon.com/greengrass/) is an Internet of Things (IoT) open source edge runtime and cloud service that helps you build, deploy, and manage device software. It is used for IoT applications on millions of devices in homes, factories, vehicles, and businesses. [AWS CodeArtifact](https://aws.amazon.com/codeartifact/) is a fully managed artifact repository service that makes it easy for organizations of any size to securely store, publish, and share software packages used in their software development process. CodeArtifact can be configured to automatically fetch software packages and dependencies from public artifact repositories so developers have access to the latest versions. [AWS CodeCommit](https://aws.amazon.com/codecommit/) is a fully-managed source control service that hosts secure Git-based repositories. It makes it easy for teams to collaborate on code in a secure and highly scalable ecosystem. CodeCommit eliminates the need to operate your own source control system or worry about scaling its infrastructure. [AWS CodePipeline](https://aws.amazon.com/codepipeline/) is a fully managed [continuous delivery](https://aws.amazon.com/devops/continuous-delivery/) service that helps you automate your release pipelines for fast and reliable application and infrastructure updates. CodePipeline automates the build, test, and deploy phases of your release process every time there is a code change, based on the release model you define. This enables you to rapidly and reliably deliver features and updates. You can easily integrate AWS CodePipeline with third-party services such as GitHub or with your own custom plugin. [AWS CodeStar](https://aws.amazon.com/codestar/) is a unified user interface, enabling you to easily manage your software development activities in one place. With AWS CodeStar, you can set up your entire [continuous delivery](https://aws.amazon.com/devops/continuous-delivery/) toolchain in minutes, allowing you to start releasing code faster. [AWS X-Ray](https://aws.amazon.com/xray/) is a tool that traces user requests as they travel through your entire application. It aggregates the data generated by the individual services and resources that make up your application, providing you an end-to-end view of how your application is performing. It helps developers analyze and debug production, distributed applications, such as those built using a microservices architecture. [AWS CodeDeploy](https://aws.amazon.com/codedeploy/) is a fully managed deployment service that automates software deployments to a variety of compute services such as Amazon EC2, AWS Fargate, AWS Lambda, and your on-premises servers. AWS CodeDeploy makes it easier for you to rapidly release new features, helps you avoid downtime during application deployment, and handles the complexity of updating your applications. [AWS CodeBuild](https://aws.amazon.com/codebuild/) is a fully managed continuous integration service that compiles source code, runs tests, and produces software packages that are ready to deploy. With CodeBuild, you don't need to provision, manage, and scale your own build servers. [Red Hat OpenShift Service on AWS (ROSA)](https://www.openshift.com/products/amazon-openshift) is a fully-managed and jointly supported Red Hat OpenShift offering that combines the power of Red Hat OpenShift, the industry's most comprehensive enterprise Kubernetes platform, and the AWS public cloud. [Amazon API Gateway](https://aws.amazon.com/api-gateway/) is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale. [AWS Storage Gateway](https://aws.amazon.com/storagegateway/) is a hybrid cloud storage service that gives you on-premises access to virtually unlimited cloud storage. [AWS Transit Gateway](https://aws.amazon.com/transit-gateway/) is a tool that connects VPCs and on-premises networks through a central hub. This simplifies your network and puts an end to complex peering relationships. It acts as a cloud router - each new connection is only made once. [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) is a managed service that makes it easy to deploy, operate, and scale OpenSearch clusters in the AWS Cloud. [AWS Verified Access](https://aws.amazon.com/verified-access/) is a service that validates every application request before granting access. It removes the need for a VPN, which simplifies the remote connectivity experience for end users and reduces the management complexity for IT administrators. [Amazon RDS for PostgreSQL](https://aws.amazon.com/rds/postgresql/) is a service that gives you access to the capabilities of the familiar PostgreSQL database engine. This means that the code, applications, and tools you already use today with your existing databases can be used with Amazon RDS. Amazon RDS for PostgreSQL currently supports PostgreSQL 9.6, 10, 11, 12, 13, 14, and 15. With [Trusted Language Extensions (TLE) for PostgreSQL](https://aws.amazon.com/rds/postgresql/features/), you can build high performance extensions and safely run them on Amazon RDS using popular trusted languages without needing AWS to certify code. [Gateway Load Balancer (GWLB)](https://aws.amazon.com/elasticloadbalancing/gateway-load-balancer/) is a tool that makes it easy to deploy, scale, and manage your third-party virtual appliances. It gives you one gateway for distributing traffic across multiple virtual appliances, while scaling them up, or down, based on demand. [AWS Chalice](https://aws.amazon.com/blogs/developer/deploying-aws-chalice-application-using-aws-cloud-development-kit/) is a Python Serverless Microframework for AWS and allows you to quickly create and deploy applications that use Amazon API Gateway and AWS Lambda. [AWS ParallelCluster](https://aws.amazon.com/hpc/parallelcluster/) is an AWS supported Open Source cluster management tool to deploy and manage HPC clusters in the AWS cloud. [AWS Copilot CLI](https://aws.amazon.com/containers/copilot/) is a tool for developers to build, release and operate production ready containerized applications on Amazon ECS and AWS Fargate. [AWS Fargate](https://aws.amazon.com/fargate/) is a serverless compute engine for containers that works with both Amazon Elastic Container Service (ECS) and Amazon Elastic Kubernetes Service (EKS). [Amazon Chime](https://aws.amazon.com/chime/) is a communications service that lets you meet, chat, and place business calls inside and outside your organization, all using a single application. [Amazon Virtual Private Cloud (Amazon VPC)](https://console.aws.amazon.com/vpc) is a service that lets you launch AWS resources in a logically isolated virtual network that you define. You have complete control over your virtual networking environment, including selection of your own IP address range, creation of subnets, and configuration of route tables and network gateways. [AWS Lightsail](https://aws.amazon.com/lightsail/) is an easy-to-use virtual private server (VPS) that offers you everything needed to build an application or website, plus a cost-effective, monthly plan. [Amazon Relational Database Service (Amazon RDS)](https://console.aws.amazon.com/rds/home) is a tool that makes it easy to set up, operate, and scale a relational database in the cloud. It provides cost-efficient and resizable capacity while automating time-consuming administration tasks such as hardware provisioning, database setup, patching and backups. [Amazon Aurora](https://console.aws.amazon.com/rds/home) is a MySQL and PostgreSQL-compatible relational database built for the cloud, that combines the performance and availability of traditional enterprise databases with the simplicity and cost-effectiveness of open source databases. [Amazon Athena](https://aws.amazon.com/athena/) is an interactive query service that makes it easy to analyze data in Amazon S3 using standard SQL. Athena is serverless, so there is no infrastructure to manage, and you pay only for the queries that you run. [Amazon CloudSearch](https://aws.amazon.com/cloudsearch/) is a managed service in the AWS Cloud that makes it simple and cost-effective to set up, manage, and scale a search solution for your website or application. [Amazon Kinesis](https://aws.amazon.com/kinesis/) is a tool that makes it easy to collect, process, and analyze real-time, streaming data so you can get timely insights and react quickly to new information. Amazon Kinesis offers key capabilities to cost-effectively process streaming data at any scale, along with the flexibility to choose the tools that best suit the requirements of your application. With Amazon Kinesis, you can ingest real-time data such as video, audio, application logs, website clickstreams, and IoT telemetry data for machine learning, analytics, and other applications. [Amazon EMR](https://aws.amazon.com/emr/) is the industry-leading cloud big data platform for processing vast amounts of data using open source tools such as [Apache Spark](https://aws.amazon.com/emr/features/spark/), [Apache Hive](https://aws.amazon.com/emr/features/hive/), [Apache HBase](https://aws.amazon.com/emr/features/hbase/), [Apache Flink](https://aws.amazon.com/blogs/big-data/use-apache-flink-on-amazon-emr/),[Apache Hudi](https://aws.amazon.com/emr/features/hudi/), and [Presto](https://aws.amazon.com/emr/features/presto/). [Amazon CodeWhisperer](https://aws.amazon.com/codewhisperer/) is a machine learning (ML)-powered service that helps improve developer productivity by generating code recommendations based on their comments in natural language and code in the integrated development environment (IDE). [Amazon Macie](https://aws.amazon.com/macie/) is a fully managed data security and data privacy service that uses machine learning and pattern matching to discover and protect your sensitive data in AWS. [Amazon GuardDuty](https://aws.amazon.com/guardduty/) is a continuous security monitoring service that analyzes and processes the following data sources: AWS CloudTrail management event logs, AWS CloudTrail data events for S3, DNS logs, EKS audit logs, and VPC flow logs. It uses threat intelligence feeds, such as lists of malicious IP addresses and domains, and machine learning to identify unexpected and potentially unauthorized and malicious activity within your AWS environment. [Amazon Inspector](https://aws.amazon.com/inspector/) is a vulnerability management service that continuously scans your AWS workloads for vulnerabilities. Amazon EC2 instances and container images residing in Amazon Elastic Container Registry (Amazon ECR) for software vulnerabilities and unintended network exposure. [AWS Shield](https://aws.amazon.com/shield/) is a managed Distributed Denial of Service (DDoS) protection service that safeguards applications running on AWS. It provides always-on detection and automatic inline mitigations that minimize application downtime and latency, so there is no need to engage AWS Support to benefit from DDoS protection. [AWS CloudTrail](https://aws.amazon.com/cloudtrail/) is a AWS service that helps you enable governance, compliance, and operational and risk auditing of your AWS account. Actions taken by a user, role, or an AWS service are recorded as events in CloudTrail. Events include actions taken in the AWS Management Console, AWS Command Line Interface, and AWS SDKs and APIs. [AWS Security Hub](https://aws.amazon.com/security-hub/) is a service that collects security data from across AWS accounts, services, and supported third-party partner products and helps you analyze your security trends and identify the highest priority security issues. [Amazon SNS message data protection](https://docs.aws.amazon.com/sns/latest/dg/sns-message-data-protection-custom-data-identifiers.html) is a set of capabilities that leverage pattern matching, machine learning models, and content policies to help security and engineering teams facilitate real-time data protection in their applications that use Amazon SNS to exchange high volumes of data. [AWS RedShift](https://aws.amazon.com/redshift/) is a data warehouse tool that makes it as easy to gain new insights from all your data. With Redshift, you can easily query and combine exabytes of structured and semi-structured data across your data warehouse, operational database, and data lake using standard SQL. It lets you easily save the results of your queries back to your S3 data lake using open formats, like Apache Parquet, so that you can do additional analytics from other analytics services like Amazon EMR, Amazon Athena, and Amazon SageMaker. [AWS Data Pipeline](https://aws.amazon.com/datapipeline/) is a web service that helps you reliably process and move data between different AWS compute and storage services, as well as on-premises data sources, at specified intervals. AWS Data Pipeline, let's you regularly access your data where it’s stored, transform and process it at scale, and efficiently transfer the results to AWS services such as Amazon S3, Amazon RDS, Amazon DynamoDB, and Amazon EMR. [AWS Glue](https://aws.amazon.com/glue/) is a serverless data integration service that makes it easy to discover, prepare, and combine data for analytics, machine learning, and application development. [AWS Lake Formation](https://aws.amazon.com/lake-formation/) is a service that makes it easy to set up a secure data lake in days. A data lake is a centralized, curated, and secured repository that stores all your data, both in its original form and prepared for analysis. [Amazon Managed Blockchain](https://aws.amazon.com/managed-blockchain/) is a fully managed service that makes it easy to join public networks or create and manage scalable private networks using the popular open-source frameworks [Hyperledger Fabric](https://aws.amazon.com/blockchain/what-is-hyperledger-fabric/) and Ethereum. [AWS Wavelength](https://aws.amazon.com/wavelength/) is an AWS Infrastructure offering optimized for mobile edge computing applications. Wavelength Zones are AWS infrastructure deployments that embed AWS compute and storage services within communications service providers’ (CSP) datacenters at the edge of the 5G network, so application traffic from 5G devices can reach application servers running in Wavelength Zones without leaving the telecommunications network. [AWS Outposts](https://aws.amazon.com/outposts/) is a fully managed service that offers the same AWS infrastructure, AWS services, APIs, and tools to virtually any datacenter, co-location space, or on-premises facility for a truly consistent hybrid experience. AWS Outposts is ideal for workloads that require low latency access to on-premises systems, local data processing, data residency, and migration of applications with local system interdependencies. [AWS Batch](https://aws.amazon.com/batch/) is atool that enables developers, scientists, and engineers to easily and efficiently run hundreds of thousands of batch computing jobs on AWS. AWS Batch dynamically provisions the optimal quantity and type of compute resources (e.g., CPU or memory optimized instances) based on the volume and specific resource requirements of the batch jobs submitted. AWS Batch plans, schedules, and executes your batch computing workloads across the full range of AWS compute services and features, such as [AWS Fargate](https://aws.amazon.com/fargate/), [Amazon EC2](https://aws.amazon.com/ec2/) and [Spot Instances](https://aws.amazon.com/ec2/spot/). [Amazon Forecast](https://aws.amazon.com/forecast/) is a fully managed service that uses machine learning to deliver highly accurate forecasts. [AWS Snow Family](https://aws.amazon.com/snow/) is a highly-secure, portable devices to collect and process data at the edge, and migrate data into and out of AWS. [Amazon Neptune](https://aws.amazon.com/neptune/) is a fast, reliable, fully managed graph database service that makes it easy to build and run applications that work with highly connected datasets. The core of Amazon Neptune is a purpose-built, high-performance graph database engine optimized for storing billions of relationships and querying the graph with milliseconds latency. [Amazon Timestream](https://aws.amazon.com/timestream/) is a fast, scalable, and serverless time series database service for IoT and operational applications that makes it easy to store and analyze trillions of events per day up to 1,000 times faster and at as little as 1/10th the cost of relational databases. [AWS IoT](https://aws.amazon.com/iot/) is a service that is built on a secure and proven cloud infrastructure, and scales to billions of devices and trillions of messages. It easily integrates with other AWS services, so you can build complete solutions. [AWS IoT Core](https://aws.amazon.com/iot-core/) lets you connect IoT devices to the AWS cloud without the need to provision or manage servers. AWS IoT Core can support billions of devices and trillions of messages, and can process and route those messages to AWS endpoints and to other devices reliably and securely. [Amazon CodeCatalyst](https://codecatalyst.aws/explore) is a service for workflows based on pull request events in linked GitHub repositories. When a workflow is triggered by a GitHub-based pull request, users will also be able to see the name of the PR that triggered it in the CodeCatalyst workflows UI, and click a link that takes them directly to the pull request in GitHub. [Amazon Lex](https://docs.aws.amazon.com/lexv2/latest/dg/analytics.html) is a service for building conversational interfaces into any application, using voice and text. With Amazon Lex, you can quickly and easily build sophisticated natural language conversational bots (“chatbots”), virtual agents, and interactive voice response (IVR) systems. We are excited to announce the general availability of Analytics on Amazon Lex. [Amazon Omics](https://docs.aws.amazon.com/omics/latest/dev/starting-and-managing-runs.html) is a fully managed service that helps healthcare and life science organizations build at-scale to store, query, and analyze genomic, transcriptomic, and other omics data. With workflow run queuing, you are now able to queue up to thousands of workflow runs, and the service will process the runs at a rate defined by your service quota limits. [AWS Entity Resolution](https://aws.amazon.com/entity-resolution/) is a configurable, machine learning (ML) powered service that helps organizations match and link related records stored across multiple applications, channels, and data stores. [AWS HealthScribe](https://aws.amazon.com/healthscribe/) is a new HIPAA-eligible service designed to help healthcare software vendors build clinical applications that automatically generate preliminary clinical notes by analyzing patient-clinician conversations. It can integrate conversational and generative AI in your application to accelerate clinical documentation workflow and enhance the consultation experience: no machine learning expertise required. [Amazon OpenSearch Service](https://aws.amazon.com/opensearch-service/) is a simple, scalable, and high-performing [vector engine for Amazon OpenSearch Serverless](https://aws.amazon.com/opensearch-service/serverless-vector-engine/). Developers can use this vector engine to build machine learning (ML) augmented search experiences and generative artificial intelligence (AI) applications without having to manage the vector database infrastructure. [Amazon GameLift](https://aws.amazon.com/gamelift/getting-started/) is a fully managed service that allows developers to quickly manage and scale dedicated game servers for multiplayer games. With this release, Amazon GameLift Server SDK now supports Unity 2022.3, Unreal 4.26, Unreal 5.1, Go language, and custom C++ and C# engines. [Amazon SQS (Simple Queue Service)](https://aws.amazon.com/sqs/) is a secure, durable, and available hosted queue that lets you integrate and decouple distributed software systems and components. Amazon SQS offers common constructs such as [dead-letter queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) and [cost allocation tags](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html). It provides a generic web services API that you can access using any programming language that the AWS SDK supports. [AWS Service Catalog Engine for Terraform Cloud (TFC-RE)](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-Terraform.html) is an integration between AWS Service Catalog and Terraform Cloud that allows users to provision Service Catalog products using TFC. This integration gives administrators governance and visibility into their Terraform workloads, and allows Service Catalog administrators to delegate cloud resource provisioning responsibilities to users within their organizations. # AWS DevOps Tools Integration [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) [Open Container Initiative](https://opencontainers.org/about/overview/) is an open governance structure for the express purpose of creating open industry standards around container formats and runtimes. [Buildah](https://buildah.io/) is a command line tool to build Open Container Initiative (OCI) images. It can be used with Docker, Podman, Kubernetes. [Podman](https://podman.io/) is a daemonless, open source, Linux native tool designed to make it easy to find, run, build, share and deploy applications using Open Containers Initiative (OCI) Containers and Container Images. Podman provides a command line interface (CLI) familiar to anyone who has used the Docker Container Engine. [Containerd](https://containerd.io)is a daemon that manages the complete container lifecycle of its host system, from image transfer and storage to container execution and supervision to low-level storage to network attachments and beyond. It is available for Linux and Windows. [OKD](https://okd.io/) is a community distribution of Kubernetes optimized for continuous application development and multi-tenant deployment. OKD adds developer and operations-centric tools on top of Kubernetes to enable rapid application development, easy deployment and scaling, and long-term lifecycle maintenance for small and large teams. [Red Hat OpenShift](https://www.openshift.com/) is an open source container application platform based on the Kubernetes container orchestrator for enterprise app development and deployment in the hybrid cloud Red Hat OpenShift, the open hybrid cloud platform built on Kubernetes. [OpenShift CLI (oc)](https://docs.openshift.com/container-platform/4.4/cli_reference/openshift_cli/getting-started-cli.html) is a command line interface tool that extends the capabilities of kubectl with [many convenience functions](https://docs.openshift.com/container-platform/4.4/cli_reference/openshift_cli/usage-oc-kubectl.html) that make interacting with both Kubernetes and OpenShift clusters easier. [OpenShift Serverless CLI (kn)](https://docs.openshift.com/container-platform/4.4/serverless/serverless-getting-started.html) is a command line interface tool to deploy serverless applications, then you’ll want access and control via the kn command. [OpenShift Pipelines CLI (tkn)](https://docs.openshift.com/container-platform/4.4/pipelines/understanding-openshift-pipelines.html) is a command line interface tool for using Tekton to provide cloud-native CI/CD functionality within the cluster. The tkn command is used to manage the functionality from the CLI. [Red Hat CodeReady Containers](https://developers.redhat.com/products/codeready-containers) is an option to host a local, all-in-one OpenShift 4 cluster on your workstation. CodeReady Containers replaces [minishift](https://www.okd.io/minishift/), used to run OpenShift 3 clusters on your workstation, as a quick and easy method of creating test and development clusters. [Helm CLI](https://docs.openshift.com/container-platform/4.4/cli_reference/helm_cli/getting-started-with-helm-on-openshift-container-platform.html) is a command line interface tool for deploying and managing Kubernetes applications to your clusters. [OpenShift Hive](https://github.com/openshift/hive) is an operator which runs as a service on top of Kubernetes/OpenShift. The Hive service can be used to provision and perform initial configuration of OpenShift 4 clusters. [OpenShift Service Mesh](https://www.openshift.com/blog/introducing-openshift-service-mesh-2.0) is a tool that provides a layer on top of OpenShift for securely connecting services in a consistent manner. This provides centralized control, security and observability across your services without having to modify your applications. [Red Hat OpenShift Service on AWS (ROSA)](https://www.openshift.com/products/amazon-openshift) is a fully-managed and jointly supported Red Hat OpenShift offering that combines the power of Red Hat OpenShift, the industry's most comprehensive enterprise Kubernetes platform, and the AWS public cloud. [Red Hat® Quay](https://www.openshift.com/products/quay) is a secure, private container registry that builds, analyzes and distributes container images. It provides a high level of automation and customization. [Kata Operator](https://github.com/openshift/kata-operator) is an operator to perform lifecycle management (install/upgrade/uninstall) of [Kata Runtime](https://katacontainers.io/) on Openshift as well as Kubernetes cluster. [Ansible](https://www.ansible.com/)is a simple IT automation engine that automates cloud provisioning, configuration management, application deployment, intra-service orchestration, and many other IT needs. It uses a very simple language (YAML, in the form of Ansible Playbooks) that allows you to describe your automation jobs in a way that approaches plain English. Anisble works on Linux (Red Hat EnterPrise Linux(RHEL) and Ubuntu) and Microsoft Windows. [Ansible cmdb](https://github.com/fboender/ansible-cmdb) is a tool that takes the output of Ansible’s fact gathering and converts it into a static HTML overview page containing system configuration information. [Ansible Inventory Grapher](https://github.com/willthames/ansible-inventory-grapher) visually displays inventory inheritance hierarchies and at what level a variable is defined in inventory. [Ansible Playbook Grapher](https://github.com/haidaraM/ansible-playbook-grapher) is a command line tool to create a graph representing your Ansible playbook tasks and roles. [Ansible Shell](https://github.com/dominis/ansible-shell) is an interactive shell for Ansible with built-in tab completion for all the modules. [Ansible Silo](https://github.com/groupon/ansible-silo) is a self-contained Ansible environment by [Docker](https://www.docker.com/). [Ansigenome](https://github.com/nickjj/ansigenome) is a command line tool designed to help you manage your Ansible roles. [ARA](https://github.com/openstack/ara) is a records Ansible playbook runs and makes the recorded data available and intuitive for users and systems by integrating with Ansible as a callback plugin. [Matano](https://matano.dev/) is an Open source cloud-native security lake platform (SIEM alternative) for threat hunting, detection & response, and cybersecurity analytics at petabyte scale on AWS. [GitHub](https://github.com/) provides hosting for software development version control using Git. It offers all of the distributed version control and source code management functionality of Git as well as adding its own features. It provides access control and several collaboration features such as bug tracking, feature requests, task management, and wikis for every project. [GitHub Codespaces](https://docs.github.com/en/free-pro-team@latest/github/developing-online-with-codespaces) is an integrated development environment(IDE) on GitHub. That allows developers to develop entirely in the cloud using Visual Studio and Visual Studio Code. [GitHub Actions](https://docs.github.com/en/actions) will automate, customize, and execute your software development workflows right in your repository with GitHub Actions. You can discover, create, and share actions to perform any job you'd like, including CI/CD, and combine actions in a completely customized workflow.[GitHub Actions for Azure](https://docs.microsoft.com/en-us/azure/developer/github/github-actions) you can create workflows that you can set up in your repository to build, test, package, release and deploy to Azure.Learn more about all other integrations with Azure. [GitLab](https://about.gitlab.com/) is a web-based DevOps lifecycle tool that provides a Git-repository manager providing wiki, issue-tracking and CI/CD pipeline features, using an open-source license, developed by GitLab Inc. [Jenkins](https://jenkins.io/) is a free and open source automation server. Jenkins helps to automate the non-human part of the software development process, with continuous integration and facilitating technical aspects of continuous delivery. [Bitbucket](https://bitbucket.org/) is a web-based version control repository hosting service owned by Atlassian, for source code and development projects that use either Mercurial or Git revision control systems. Bitbucket offers both commercial plans and free accounts. It offers free accounts with an unlimited number of private repositories. Bitbucket integrates with other Atlassian software like Jira, HipChat, Confluence and Bamboo. [Bamboo](https://www.atlassian.com/software/bamboo) is a continuous integration (CI) server that can be used to automate the release management for a software application, creating a continuous delivery pipeline. [Codecov](https://codecov.io/) is the leading, dedicated code coverage solution. It provides highly integrated tools to group, merge, archive and compare coverage reports. Whether your team is comparing changes in a pull request or reviewing a single commit, Codecov will improve the code review workflow and quality. [Drone](https://drone.io/) is a Continuous Delivery system built on container technology. Drone uses a simple YAML configuration file, a superset of docker-compose, to define and execute Pipelines inside Docker containers. [Travis CI](https://travis-ci.org/) is a hosted continuous integration service used to build and test software projects hosted at GitHub. [Circle CI](https://circleci.com/) is a continuous integration and continuous delivery platform that helps software teams work smarter, faster. [Zuul-CI](https://zuul-ci.org/index.html) is a program that drives continuous integration, delivery, and deployment systems with a focus on project gating and interrelated projects. Using the same [Ansible playbooks](https://docs.ansible.com/ansible/latest/user_guide/playbooks.html) to deploy your system and run your tests. [Artifactory](https://jfrog.com/artifactory/) is a Universal Artifact Repository Manager developed by JFrog. It supports all major packages, enterprise ready security, clustered, HA, Docker registry, multi-site replication and scalable. [Azure DevOps](https://azure.microsoft.com/en-us/services/devops/?nav=min) is a set of services for teams to share code, track work, and ship software; CLIs Build, deploy, diagnose, and manage multi-platform, scalable apps and services; Azure Pipelines Continuously build, test, and deploy to any platform and cloud; Azure Lab Services Set up labs for classrooms, trials, development and testing, and other scenarios. [Team City](https://www.jetbrains.com/teamcity/) is a build management and continuous integration server from JetBrains. [Shippable](https://www.shippable.com/) simplifies DevOps and makes it systematic with an Assembly Line platform that is heterogeneous, flexible, and provides complete visibility across your DevOps workflows. [Spinnaker](https://www.spinnaker.io/) is an open source, multi-cloud continuous delivery platform for releasing software changes with high velocity and confidence. [Selenium](https://www.seleniumhq.org/) is a free (open source) automated testing suite for web applications across different browsers and platforms. [Cucumber](https://cucumber.io/) is a tool based on Behavior Driven Development (BDD) framework which is used to write acceptance tests for the web application. It allows automation of functional validation in easily readable and understandable format (like plain English) to Business Analysts, Developers, and Testers. [JUnit](https://junit.org/junit5/) is a unit testing framework for the Java programming language. [Mocha](https://mochajs.org/) is a JavaScript test framework for Node.js programs, featuring browser support, asynchronous testing, test coverage reports, and use of any assertion library. [Karma](https://karma-runner.github.io/latest/index.html) is a simple tool that allows you to execute JavaScript code in multiple real browsers. [Jasmine](https://jasmine.github.io/) is an open source testing framework for JavaScript. It aims to run on any JavaScript-enabled platform, to not intrude on the application nor the IDE, and to have easy-to-read syntax. [Maven](https://maven.apache.org/) is a build automation tool used primarily for Java projects. Maven can also be used to build and manage projects written in C#, Ruby, Scala, and other languages. The Maven project is hosted by the Apache Software Foundation. [Gradle](https://gradle.org/) is an open-source build-automation system that builds upon the concepts of Apache Ant and Apache Maven and introduces a Groovy-based domain-specific language instead of the XML form used by Apache Maven for declaring the project configuration. [Chef](https://www.chef.io/) is an effortless Infrastructure Suite offers visibility into security and compliance status across all infrastructure and makes it easy to detect and correct issues long before they reach production. [Puppet](https://puppet.com/) is an open source tool that makes continuous integration and delivery of your software on traditional or containerized infrastructure easy by pulling together all your existing tools and giving you flexibility to deploy your way. [KubeInit](https://github.com/kubeinit/kubeinit) provides Ansible playbooks and roles for the deployment and configuration of multiple Kubernetes distributions. [Salt](https://www.saltstack.com/) is Python-based, open-source software for event-driven IT automation, remote task execution, and configuration management. Supporting the "Infrastructure as Code" approach to data center system and network deployment and management, configuration automation, SecOps orchestration, vulnerability remediation, and hybrid cloud control. [Terraform](https://www.terraform.io/) is an open-source infrastructure as code software tool created by HashiCorp.It enables users to define and provision a datacenter infrastructure using a high-level configuration language known as Hashicorp Configuration Language (HCL), or optionally JSON. [Consul](https://www.consul.io) is a service networking solution to connect and secure services across any runtime platform and public or private cloud. [Packer](https://www.packer.io/) is lightweight, runs on every major operating system, and is highly performant, creating machine images for multiple platforms in parallel. Packer does not replace configuration management like Chef or Puppet. In fact, when building images, Packer is able to use tools like Chef or Puppet to install software onto the image. [Nomad](https://www.nomadproject.io/) is a highly available, distributed, data-center aware cluster and application scheduler designed to support the modern datacenter with support for long-running services, batch jobs, and much more. [Vagrant](https://www.vagrantup.com/) is a tool for building and managing virtual machine environments in a single workflow. With an easy-to-use workflow and focus on automation, Vagrant lowers development environment setup time and increases production parity. [Vault](https://www.hashicorp.com/products/vault/) is a tool for securely accessing secrets. A secret is anything that you want to tightly control access to, such as API keys, passwords, certificates, and more. Vault provides a unified interface to any secret, while providing tight access control and recording a detailed audit log. [CFEngine](https://cfengine.com/) is an open-source configuration management system, written by Mark Burgess.Its primary function is to provide automated configuration and maintenance of large-scale computer systems, including the unified management of servers, desktops, consumer and industrial devices, embedded networked devices, mobile smartphones, and tablet computers. [Octpus Deploy](https://octopus.com/) is the deployment automation server for your entire team, designed to make it easy to orchestrate releases and deploy applications, whether on-premises or in the cloud. [Kubernetes](https://kubernetes.io/) is an open-source container-orchestration system for automating application deployment, scaling, and management. It was originally designed by Google, and is now maintained by the Cloud Native Computing Foundation. [Docker](https://www.docker.com/) is a set of platform as a service products that use OS-level virtualization to deliver software in packages called containers. Containers are isolated from one another and bundle their own software, libraries and configuration files; they can communicate with each other through well-defined channels. All containers are run by a single operating-system kernel and are thus more lightweight than virtual machines. [PowerShell/PowerShell Core](https://docs.microsoft.com/en-us/powershell/) is a cross-platform (Windows, Linux, and macOS) automation and configuration tool/framework that works well with your existing tools and is optimized for dealing with structured data (e.g. JSON, CSV, XML, etc.), REST APIs, and object models. It includes a command-line shell, an associated scripting language and a framework for processing cmdlets. [Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/) creates virtual machines on Windows 10. Hyper-V can be enabled in many ways including using the Windows 10 control panel, PowerShell or using the Deployment Imaging Servicing and Management tool (DISM). [Cloud Hypervisor](https://github.com/cloud-hypervisor/cloud-hypervisor) is an open source Virtual Machine Monitor (VMM) that runs on top of [KVM](https://www.kernel.org/doc/Documentation/virtual/kvm/api.txt). The project focuses on exclusively running modern, cloud workloads, on top of a limited set of hardware architectures and platforms. Cloud workloads refers to those that are usually run by customers inside a cloud provider. Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is based on the [rust-vmm](https://github.com/rust-vmm) crates. [VMware vSphere Hypervisor](https://www.vmware.com/products/vsphere-hypervisor.html) is a bare-metal hypervisor that virtualizes servers; allowing you to consolidate your applications while saving time and money managing your IT infrastructure. [VMware vSphere](https://www.vmware.com/products/vsphere.html) is the industry-leading compute virtualization platform, and your first step to application modernization. It has been rearchitected with native Kubernetes to allow customers to modernize the 70 million+ workloads now running on vSphere. [VMware Tanzu](https://tanzu.vmware.com/tanzu) is a centralized management platform for consistently operating and securing your Kubernetes infrastructure and modern applications across multiple teams and private/public clouds. [Rancher](https://rancher.com/) is a complete software stack for teams adopting containers. It addresses the operational and security challenges of managing multiple Kubernetes clusters, while providing DevOps teams with integrated tools for running containerized workloads. [K3s](https://github.com/rancher/k3s) is a highly available, certified Kubernetes distribution designed for production workloads in unattended, resource-constrained, remote locations or inside IoT appliances. [Rook](https://rook.io/) is an open source cloud-native storage orchestrator for Kubernetes that turns distributed storage systems into self-managing, self-scaling, self-healing storage services. It automates the tasks of a storage administrator: deployment, bootstrapping, configuration, provisioning, scaling, upgrading, migration, disaster recovery, monitoring, and resource management. [Google Kubernetes Engine (GKE)](https://cloud.google.com/kubernetes-engine/) is a managed, production-ready environment for deploying containerized applications. [Anthos](https://cloud.google.com/anthos/docs/concepts/overview) is a modern application management platform that provides a consistent development and operations experience for cloud and on-premises environments. [Apache Mesos](http://mesos.apache.org/) is a cluster manager that provides efficient resource isolation and sharing across distributed applications, or frameworks. It can run Hadoop, Jenkins, Spark, Aurora, and other frameworks on a dynamically shared pool of nodes. [Apache Spark](https://spark.apache.org/) is a unified analytics engine for big data processing, with built-in modules for streaming, SQL, machine learning and graph processing. [Apache Hadoop](http://hadoop.apache.org/) is a framework that allows for the distributed processing of large data sets across clusters of computers using simple programming models. It is designed to scale up from single servers to thousands of machines, each offering local computation and storage. Rather than rely on hardware to deliver high-availability, the library itself is designed to detect and handle failures at the application layer, so delivering a highly-available service on top of a cluster of computers, each of which may be prone to failures. [Microsoft Azure](https://azure.microsoft.com/en-us/) is a cloud computing service created by Microsoft for building, testing, deploying, and managing applications and services through Microsoft-managed data centers. [Azure Functions](https://azure.microsoft.com/en-us/services/functions/) is a solution for easily running small pieces of code, or "functions," in the cloud. You can write just the code you need for the problem at hand, without worrying about a whole application or the infrastructure to run it. [Rkt](https://coreos.com/rkt/) is a pod-native container engine for Linux. It is composable, secure, and built on standards. [Helm](https://helm.sh/) is the Kubernetes Package Manager. [Kubespray](https://kubespray.io/) is a tool that combines Kubernetes and Ansible to easily install Kubernetes clusters that can be deployed on [AWS](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/aws.md), GCE, [Azure](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/azure.md), [OpenStack](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/openstack.md), [vSphere](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/vsphere.md), [Packet](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/packet.md) (bare metal), Oracle Cloud Infrastructure (Experimental), or Baremetal [OKD](https://okd.io/) is a community distribution of Kubernetes optimized for continuous application development and multi-tenant deployment. OKD adds developer and operations-centric tools on top of Kubernetes to enable rapid application development, easy deployment and scaling, and long-term lifecycle maintenance for small and large teams. [Odo](https://odo.dev/) is a fast, iterative, and straightforward CLI tool for developers who write, build, and deploy applications on Kubernetes and OpenShift. [Knative](https://knative.dev/) is a Kubernetes-based platform to build, deploy, and manage modern serverless workloads. Knative takes care of the operational overhead details of networking, autoscaling (even to zero), and revision tracking. [Etcd](https://etcd.io/) is a distributed key-value store that provides a reliable way to store data that needs to be accessed by a distributed system or cluster of machines. Etcd is used as the backend for service discovery and stores cluster state and configuration for Kubernetes. [OpenStack](https://www.openstack.org/) is a free and open-source software platform for cloud computing, mostly deployed as infrastructure-as-a-service that controls large pools of compute, storage, and networking resources throughout a datacenter, managed through a dashboard or via the OpenStack API. OpenStack works with popular enterprise and open source technologies making it ideal for heterogeneous infrastructure. [Cloud Foundry](https://www.cloudfoundry.org/) is an open source, multi cloud application platform as a service that makes it faster and easier to build, test, deploy and scale applications, providing a choice of clouds, developer frameworks, and application services. It is an open source project and is available through a variety of private cloud distributions and public cloud instances. [Splunk](https://www.splunk.com/) software is used for searching, monitoring, and analyzing machine-generated big data, via a Web-style interface. [Prometheus](https://prometheus.io/) is a free software application used for event monitoring and alerting. It records real-time metrics in a time series database (allowing for high dimensionality) built using a HTTP pull model, with flexible queries and real-time alerting. [Loki](https://grafana.com/oss/loki/) is a horizontally-scalable, highly-available, multi-tenant log aggregation system inspired by Prometheus. It is designed to be very cost effective and easy to operate. It does not index the contents of the logs, but rather a set of labels for each log stream. [Thanos](https://thanos.io/) is a set of components that can be composed into a highly available metric system with unlimited storage capacity, which can be added seamlessly on top of existing Prometheus deployments. [Container Storage Interface (CSI)](https://www.architecting.it/blog/container-storage-interface/) is an API that lets container orchestration platforms like Kubernetes seamlessly communicate with stored data via a plug-in. [OpenEBS](https://openebs.io/) is a Kubernetes-based tool to create stateful applications using Container Attached Storage. [ElasticSearch](https://www.elastic.co/) is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents. Elasticsearch is developed in Java. [Logstash](https://www.elastic.co/products/logstash) is a tool for managing events and logs. When used generically, the term encompasses a larger system of log collection, processing, storage and searching activities. [Kibana](https://www.elastic.co/products/kibana) is an open source data visualization plugin for Elasticsearch. It provides visualization capabilities on top of the content indexed on an Elasticsearch cluster. Users can create bar, line and scatter plots, or pie charts and maps on top of large volumes of data. [New Relic](https://newrelic.com/) is a SaaS-based monitoring tool that fully supports the way DevOps teams work in the modern enterprise by streamlining your workflows with today's collaboration software and orchestration tools like Puppet, Chef, and Ansible. [Nagios](https://www.nagios.org/) is a free and open source computer-software application that monitors systems, networks and infrastructure. Nagios offers monitoring and alerting services for servers, switches, applications and services. It alerts users when things go wrong and alerts them a second time when the problem has been resolved. [SonarQube](https://www.sonarqube.org/) is an open-source platform developed by SonarSource for continuous inspection of code quality to perform automatic reviews with static analysis of code to detect bugs, code smells, and security vulnerabilities on 20+ programming languages. [Genie](https://netflix.github.io/genie) is a federated job orchestration engine developed by Netflix. Genie provides REST APIs to run a variety of big data jobs like Hadoop, Pig, Hive, Spark, Presto, Sqoop and more. It also provides APIs for managing the metadata of many distributed processing clusters and the commands and applications which run on them. [Inviso](https://github.com/Netflix/inviso) is a lightweight tool that provides the ability to search for Hadoop jobs, visualize the performance, and view cluster utilization. [Fenzo](https://github.com/Netflix/Fenzo) is a scheduler Java library for Apache Mesos frameworks that supports plugins for scheduling optimizations and facilitates cluster autoscaling. [Dynomite](https://github.com/Netflix/dynomite) is a thin, distributed dynamo layer for different storage engines and protocols, which includes [Redis](http://redis.io/) and [Memcached](http://www.memcached.org/). Dynomite supports multi-datacenter replication and is designed for High Availability(HA). [Dyno](https://github.com/Netflix/dynomite) is a tool that is used to scale a Java client application utilizing [Dynomite](https://github.com/Netflix/dynomite). [Raigad](https://github.com/Netflix/Raigad) is a process/tool that runs alongside Elasticsearch to automate backup/recovery, Deployments and Centralized Configuration management. [Priam](https://github.com/Netflix/Priam) is a process/tool that runs alongside Apache Cassandra to automate backup/recovery, Deployments and Centralized Configuration management. [Chaos Monkey](https://github.com/Netflix/chaosmonkey) is a resiliency tool used to randomly terminates virtual machine instances and containers that run inside of your production environment. Chaos Monkey should work with any backend that [Spinnaker](http://www.spinnaker.io/) supports (AWS, Google Compute Engine, Microsoft Azure, Kubernetes, and Cloud Foundry). [Falcor](https://netflix.github.io/falcor/) is a JavaScript library for efficient data fetching. Falcor lets you represent all your remote data sources as a single domain model via a virtual JSON graph, whether in memory on the client or over the network on the server. [Restify](https://github.com/restify/node-restify) is a framework, utilizing [connect](https://github.com/senchalabs/connect) style middleware for building REST APIs. [Traefik](https://traefik.io/traefik/) is an open source Edge Router that makes publishing your services a fun and easy experience. It receives requests on behalf of your system and finds out which components are responsible for handling them. What sets Traefik apart, besides its many features, is that it automatically discovers the right configuration for your services. [Jira](https://www.atlassian.com/software/jira) is a proprietary issue tracking product developed by Atlassian that allows bug tracking and agile project management. [Pivotal Tracker](https://www.pivotaltracker.com/) is the agile project management tool of choice for developers around the world for real-time collaboration around a shared, prioritized backlog. [Pulumi](https://www.pulumi.com/) is a cloud engineering platform that enables you to use an unified software engineering process to deliver infrastructure and applications together and faster. Pulumi provides developer-first infrastructure as code that allows you to build, deploy, and manage cloud infrastructure with popular programming languages including Python, JavaScript, TypeScript, Go, and .NET/C#. # Networking [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) ## Networking Learning Resources [AWS Certified Security - Specialty Certification](https://aws.amazon.com/certification/certified-security-specialty/) [Microsoft Certified: Azure Security Engineer Associate](https://docs.microsoft.com/en-us/learn/certifications/azure-security-engineer) [Google Cloud Certified Professional Cloud Security Engineer](https://cloud.google.com/certification/cloud-security-engineer) [Cisco Security Certifications](https://www.cisco.com/c/en/us/training-events/training-certifications/certifications/security.html) [The Red Hat Certified Specialist in Security: Linux](https://www.redhat.com/en/services/training/ex415-red-hat-certified-specialist-security-linux-exam) [Linux Professional Institute LPIC-3 Enterprise Security Certification](https://www.lpi.org/our-certifications/lpic-3-303-overview) [Cybersecurity Training and Courses from IBM Skills](https://www.ibm.com/skills/topics/cybersecurity/) [Cybersecurity Courses and Certifications by Offensive Security](https://www.offensive-security.com/courses-and-certifications/) [Citrix Certified Associate – Networking(CCA-N)](http://training.citrix.com/cms/index.php/certification/networking/) [Citrix Certified Professional – Virtualization(CCP-V)](https://www.globalknowledge.com/us-en/training/certification-prep/brands/citrix/section/virtualization/citrix-certified-professional-virtualization-ccp-v/) [CCNP Routing and Switching](https://learningnetwork.cisco.com/s/ccnp-enterprise) [Certified Information Security Manager(CISM)](https://www.isaca.org/credentialing/cism) [Wireshark Certified Network Analyst (WCNA)](https://www.wiresharktraining.com/certification.html) [Juniper Networks Certification Program Enterprise (JNCP)](https://www.juniper.net/us/en/training/certification/) [Networking courses and specializations from Coursera](https://www.coursera.org/browse/information-technology/networking) [Network & Security Courses from Udemy](https://www.udemy.com/courses/it-and-software/network-and-security/) [Network & Security Courses from edX](https://www.edx.org/learn/cybersecurity) ## Networking Tools & Concepts [cURL](https://curl.se/) is a computer software project providing a library and command-line tool for transferring data using various network protocols(HTTP, HTTPS, FTP, FTPS, SCP, SFTP, TFTP, DICT, TELNET, LDAP LDAPS, MQTT, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP or SMTPS). cURL is also used in cars, television sets, routers, printers, audio equipment, mobile phones, tablets, settop boxes, media players and is the Internet transfer engine for thousands of software applications in over ten billion installations. [cURL Fuzzer](https://github.com/curl/curl-fuzzer) is a quality assurance testing for the curl project. [DoH](https://github.com/curl/doh) is a stand-alone application for DoH (DNS-over-HTTPS) name resolves and lookups. [Authelia](https://www.authelia.com/) is an open-source highly-available authentication server providing single sign-on capability and two-factor authentication to applications running behind [NGINX](https://nginx.org/en/). [nginx(engine x)](https://nginx.org/en/) is an HTTP and reverse proxy server, a mail proxy server, and a generic TCP/UDP proxy server, originally written by Igor Sysoev. [Proxmox Virtual Environment(VE)](https://www.proxmox.com/en/) is a complete open-source platform for enterprise virtualization. It inlcudes a built-in web interface that you can easily manage VMs and containers, software-defined storage and networking, high-availability clustering, and multiple out-of-the-box tools on a single solution. [Wireshark](https://www.wireshark.org/) is a very popular network protocol analyzer that is commonly used for network troubleshooting, analysis, and communications protocol development. Learn more about the other useful [Wireshark Tools](https://wiki.wireshark.org/Tools) available. [HTTPie](https://github.com/httpie/httpie) is a command-line HTTP client. Its goal is to make CLI interaction with web services as human-friendly as possible. HTTPie is designed for testing, debugging, and generally interacting with APIs & HTTP servers. [HTTPStat](https://github.com/reorx/httpstat) is a tool that visualizes curl statistics in a simple layout. [Wuzz](https://github.com/asciimoo/wuzz) is an interactive cli tool for HTTP inspection. It can be used to inspect/modify requests copied from the browser's network inspector with the "copy as cURL" feature. [Websocat](https://github.com/vi/websocat) is a ommand-line client for WebSockets, like netcat (or curl) for ws:// with advanced socat-like functions. - Connection: In networking, a connection refers to pieces of related information that are transferred through a network. This generally infers that a connection is built before the data transfer (by following the procedures laid out in a protocol) and then is deconstructed at the at the end of the data transfer. - Packet: A packet is, generally speaking, the most basic unit that is transferred over a network. When communicating over a network, packets are the envelopes that carry your data (in pieces) from one end point to the other. Packets have a header portion that contains information about the packet including the source and destination, timestamps, network hops. The main portion of a packet contains the actual data being transferred. It is sometimes called the body or the payload. - Network Interface: A network interface can refer to any kind of software interface to networking hardware. For instance, if you have two network cards in your computer, you can control and configure each network interface associated with them individually. A network interface may be associated with a physical device, or it may be a representation of a virtual interface. The "loop-back" device, which is a virtual interface to the local machine, is an example of this. - LAN: LAN stands for "local area network". It refers to a network or a portion of a network that is not publicly accessible to the greater internet. A home or office network is an example of a LAN. - WAN: WAN stands for "wide area network". It means a network that is much more extensive than a LAN. While WAN is the relevant term to use to describe large, dispersed networks in general, it is usually meant to mean the internet, as a whole. If an interface is connected to the WAN, it is generally assumed that it is reachable through the internet. - Protocol: A protocol is a set of rules and standards that basically define a language that devices can use to communicate. There are a great number of protocols in use extensively in networking, and they are often implemented in different layers. Some low level protocols are TCP, UDP, IP, and ICMP. Some familiar examples of application layer protocols, built on these lower protocols, are HTTP (for accessing web content), SSH, TLS/SSL, and FTP. - Port: A port is an address on a single machine that can be tied to a specific piece of software. It is not a physical interface or location, but it allows your server to be able to communicate using more than one application. - Firewall: A firewall is a program that decides whether traffic coming into a server or going out should be allowed. A firewall usually works by creating rules for which type of traffic is acceptable on which ports. Generally, firewalls block ports that are not used by a specific application on a server. - NAT: Network address translation is a way to translate requests that are incoming into a routing server to the relevant devices or servers that it knows about in the LAN. This is usually implemented in physical LANs as a way to route requests through one IP address to the necessary backend servers. - VPN: Virtual private network is a means of connecting separate LANs through the internet, while maintaining privacy. This is used as a means of connecting remote systems as if they were on a local network, often for security reasons. ## Network Layers While networking is often discussed in terms of topology in a horizontal way, between hosts, its implementation is layered in a vertical fashion throughout a computer or network. This means is that there are multiple technologies and protocols that are built on top of each other in order for communication to function more easily. Each successive, higher layer abstracts the raw data a little bit more, and makes it simpler to use for applications and users. It also allows you to leverage lower layers in new ways without having to invest the time and energy to develop the protocols and applications that handle those types of traffic. As data is sent out of one machine, it begins at the top of the stack and filters downwards. At the lowest level, actual transmission to another machine takes place. At this point, the data travels back up through the layers of the other computer. Each layer has the ability to add its own "wrapper" around the data that it receives from the adjacent layer, which will help the layers that come after decide what to do with the data when it is passed off. One method of talking about the different layers of network communication is the OSI model. OSI stands for [Open Systems Interconnect](https://en.wikipedia.org/wiki/OSI_model).This model defines seven separate layers. The layers in this model are: - Application: The application layer is the layer that the users and user-applications most often interact with. Network communication is discussed in terms of availability of resources, partners to communicate with, and data synchronization. - Presentation: The presentation layer is responsible for mapping resources and creating context. It is used to translate lower level networking data into data that applications expect to see. - Session: The session layer is a connection handler. It creates, maintains, and destroys connections between nodes in a persistent way. - Transport: The transport layer is responsible for handing the layers above it a reliable connection. In this context, reliable refers to the ability to verify that a piece of data was received intact at the other end of the connection. This layer can resend information that has been dropped or corrupted and can acknowledge the receipt of data to remote computers. - Network: The network layer is used to route data between different nodes on the network. It uses addresses to be able to tell which computer to send information to. This layer can also break apart larger messages into smaller chunks to be reassembled on the opposite end. - Data Link: This layer is implemented as a method of establishing and maintaining reliable links between different nodes or devices on a network using existing physical connections. - Physical: The physical layer is responsible for handling the actual physical devices that are used to make a connection. This layer involves the bare software that manages physical connections as well as the hardware itself (like Ethernet). The TCP/IP model, more commonly known as the Internet protocol suite, is another layering model that is simpler and has been widely adopted.It defines the four separate layers, some of which overlap with the OSI model: - Application: In this model, the application layer is responsible for creating and transmitting user data between applications. The applications can be on remote systems, and should appear to operate as if locally to the end user. The communication takes place between peers network. - Transport: The transport layer is responsible for communication between processes. This level of networking utilizes ports to address different services. It can build up unreliable or reliable connections depending on the type of protocol used. - Internet: The internet layer is used to transport data from node to node in a network. This layer is aware of the endpoints of the connections, but does not worry about the actual connection needed to get from one place to another. IP addresses are defined in this layer as a way of reaching remote systems in an addressable manner. - Link: The link layer implements the actual topology of the local network that allows the internet layer to present an addressable interface. It establishes connections between neighboring nodes to send data. ### Interfaces **Interfaces** are networking communication points for your computer. Each interface is associated with a physical or virtual networking device. Typically, your server will have one configurable network interface for each Ethernet or wireless internet card you have. In addition, it will define a virtual network interface called the "loopback" or localhost interface. This is used as an interface to connect applications and processes on a single computer to other applications and processes. You can see this referenced as the "lo" interface in many tools. ## Network Protocols Networking works by piggybacks on a number of different protocols on top of each other. In this way, one piece of data can be transmitted using multiple protocols encapsulated within one another. **Media Access Control(MAC)** is a communications protocol that is used to distinguish specific devices. Each device is supposed to get a unique MAC address during the manufacturing process that differentiates it from every other device on the internet. Addressing hardware by the MAC address allows you to reference a device by a unique value even when the software on top may change the name for that specific device during operation. Media access control is one of the only protocols from the link layer that you are likely to interact with on a regular basis. **The IP protocol** is one of the fundamental protocols that allow the internet to work. IP addresses are unique on each network and they allow machines to address each other across a network. It is implemented on the internet layer in the IP/TCP model. Networks can be linked together, but traffic must be routed when crossing network boundaries. This protocol assumes an unreliable network and multiple paths to the same destination that it can dynamically change between. There are a number of different implementations of the protocol. The most common implementation today is IPv4, although IPv6 is growing in popularity as an alternative due to the scarcity of IPv4 addresses available and improvements in the protocols capabilities. **ICMP: internet control message protocol** is used to send messages between devices to indicate the availability or error conditions. These packets are used in a variety of network diagnostic tools, such as ping and traceroute. Usually ICMP packets are transmitted when a packet of a different kind meets some kind of a problem. Basically, they are used as a feedback mechanism for network communications. **TCP: Transmission control protocol** is implemented in the transport layer of the IP/TCP model and is used to establish reliable connections. TCP is one of the protocols that encapsulates data into packets. It then transfers these to the remote end of the connection using the methods available on the lower layers. On the other end, it can check for errors, request certain pieces to be resent, and reassemble the information into one logical piece to send to the application layer. The protocol builds up a connection prior to data transfer using a system called a three-way handshake. This is a way for the two ends of the communication to acknowledge the request and agree upon a method of ensuring data reliability. After the data has been sent, the connection is torn down using a similar four-way handshake. TCP is the protocol of choice for many of the most popular uses for the internet, including WWW, FTP, SSH, and email. It is safe to say that the internet we know today would not be here without TCP. **UDP: User datagram protocol** is a popular companion protocol to TCP and is also implemented in the transport layer. The fundamental difference between UDP and TCP is that UDP offers unreliable data transfer. It does not verify that data has been received on the other end of the connection. This might sound like a bad thing, and for many purposes, it is. However, it is also extremely important for some functions. It’s not required to wait for confirmation that the data was received and forced to resend data, UDP is much faster than TCP. It does not establish a connection with the remote host, it simply fires off the data to that host and doesn't care if it is accepted or not. Since UDP is a simple transaction, it is useful for simple communications like querying for network resources. It also doesn't maintain a state, which makes it great for transmitting data from one machine to many real-time clients. This makes it ideal for VOIP, games, and other applications that cannot afford delays. **HTTP: Hypertext transfer protocol** is a protocol defined in the application layer that forms the basis for communication on the web. HTTP defines a number of functions that tell the remote system what you are requesting. For instance, GET, POST, and DELETE all interact with the requested data in a different way. **FTP: File transfer protocol** is in the application layer and provides a way of transferring complete files from one host to another. It is inherently insecure, so it is not recommended for any externally facing network unless it is implemented as a public, download-only resource. **DNS: Domain name system** is an application layer protocol used to provide a human-friendly naming mechanism for internet resources. It is what ties a domain name to an IP address and allows you to access sites by name in your browser. **SSH: Secure shell** is an encrypted protocol implemented in the application layer that can be used to communicate with a remote server in a secure way. Many additional technologies are built around this protocol because of its end-to-end encryption and ubiquity. There are many other protocols that we haven't covered that are equally important. However, this should give you a good overview of some of the fundamental technologies that make the internet and networking possible. [REST(REpresentational State Transfer)](https://www.codecademy.com/articles/what-is-rest) is an architectural style for providing standards between computer systems on the web, making it easier for systems to communicate with each other. [JSON Web Token (JWT)](https://jwt.io) is a compact URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is digitally signed using JSON Web Signature (JWS). [OAuth 2.0](https://oauth.net/2/) is an open source authorization framework that enables applications to obtain limited access to user accounts on an HTTP service, such as Amazon, Google, Facebook, Microsoft, Twitter GitHub, and DigitalOcean. It works by delegating user authentication to the service that hosts the user account, and authorizing third-party applications to access the user account. ## Virtualization [KVM (for Kernel-based Virtual Machine)](https://www.linux-kvm.org/page/Main_Page) is a full virtualization solution for Linux on x86 hardware containing virtualization extensions (Intel VT or AMD-V). It consists of a loadable kernel module, kvm.ko, that provides the core virtualization infrastructure and a processor specific module, kvm-intel.ko or kvm-amd.ko. [QEMU](https://www.qemu.org) is a fast processor emulator using a portable dynamic translator. QEMU emulates a full system, including a processor and various peripherals. It can be used to launch a different Operating System without rebooting the PC or to debug system code. [Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/) enables running virtualized computer systems on top of a physical host. These virtualized systems can be used and managed just as if they were physical computer systems, however they exist in virtualized and isolated environment. Special software called a hypervisor manages access between the virtual systems and the physical hardware resources. Virtualization enables quick deployment of computer systems, a way to quickly restore systems to a previously known good state, and the ability to migrate systems between physical hosts. [VirtManager](https://github.com/virt-manager/virt-manager) is a graphical tool for managing virtual machines via libvirt. Most usage is with QEMU/KVM virtual machines, but Xen and libvirt LXC containers are well supported. Common operations for any libvirt driver should work. [oVirt](https://www.ovirt.org) is an open-source distributed virtualization solution, designed to manage your entire enterprise infrastructure. oVirt uses the trusted KVM hypervisor and is built upon several other community projects, including libvirt, Gluster, PatternFly, and Ansible.Founded by Red Hat as a community project on which Red Hat Enterprise Virtualization is based allowing for centralized management of virtual machines, compute, storage and networking resources, from an easy-to-use web-based front-end with platform independent access. [Xen](https://github.com/xen-project/xen) is focused on advancing virtualization in a number of different commercial and open source applications, including server virtualization, Infrastructure as a Services (IaaS), desktop virtualization, security applications, embedded and hardware appliances, and automotive/aviation. [Ganeti](https://github.com/ganeti/ganeti) is a virtual machine cluster management tool built on top of existing virtualization technologies such as Xen or KVM and other open source software. Once installed, the tool assumes management of the virtual instances (Xen DomU). [Packer](https://www.packer.io/) is an open source tool for creating identical machine images for multiple platforms from a single source configuration. Packer is lightweight, runs on every major operating system, and is highly performant, creating machine images for multiple platforms in parallel. Packer does not replace configuration management like Chef or Puppet. In fact, when building images, Packer is able to use tools like Chef or Puppet to install software onto the image. [Vagrant](https://www.vagrantup.com/) is a tool for building and managing virtual machine environments in a single workflow. With an easy-to-use workflow and focus on automation, Vagrant lowers development environment setup time, increases production parity, and makes the "works on my machine" excuse a relic of the past. It provides easy to configure, reproducible, and portable work environments built on top of industry-standard technology and controlled by a single consistent workflow to help maximize the productivity and flexibility of you and your team. [VMware Workstation](https://www.vmware.com/products/workstation-pro.html) is a hosted hypervisor that runs on x64 versions of Windows and Linux operating systems; it enables users to set up virtual machines on a single physical machine, and use them simultaneously along with the actual machine. # Databases [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) ## Database Learning Resources [SQL](https://en.wikipedia.org/wiki/SQL) is a standard language for storing, manipulating and retrieving data in relational databases. [SQL Tutorial by W3Schools](https://www.w3schools.com/sql/) [Learn SQL Skills Online from Coursera](https://www.coursera.org/courses?query=sql) [SQL Courses Online from Udemy](https://www.udemy.com/topic/sql/) [SQL Online Training Courses from LinkedIn Learning](https://www.linkedin.com/learning/topics/sql) [Learn SQL For Free from Codecademy](https://www.codecademy.com/learn/learn-sql) [GitLab's SQL Style Guide](https://about.gitlab.com/handbook/business-ops/data-team/platform/sql-style-guide/) [OracleDB SQL Style Guide Basics](https://oracle.readthedocs.io/en/latest/sql/basics/style-guide.html) [Tableau CRM: BI Software and Tools](https://www.salesforce.com/products/crm-analytics/overview/) [Databases on AWS](https://aws.amazon.com/products/databases/) [Best Practices and Recommendations for SQL Server Clustering in AWS EC2.](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/aws-sql-clustering.html) [Connecting from Google Kubernetes Engine to a Cloud SQL instance.](https://cloud.google.com/sql/docs/mysql/connect-kubernetes-engine) [Educational Microsoft Azure SQL resources](https://docs.microsoft.com/en-us/sql/sql-server/educational-sql-resources?view=sql-server-ver15) [MySQL Certifications](https://www.mysql.com/certification/) [SQL vs. NoSQL Databases: What's the Difference?](https://www.ibm.com/cloud/blog/sql-vs-nosql) [What is NoSQL?](https://aws.amazon.com/nosql/) ## Databases and Tools [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) is a key-value and document database that delivers single-digit millisecond performance at any scale. It is a fully managed, multiregion, multimaster, durable database with built-in security, backup and restore, and in-memory caching for internet-scale applications. [Tableau](https://www.tableau.com/) is a Data Visualization software used in relational databases, cloud databases, and spreadsheets. Tableau was acquired by [Salesforce in August 2019](https://investor.salesforce.com/press-releases/press-release-details/2019/Salesforce-Completes-Acquisition-of-Tableau/default.aspx). [DataGrip](https://www.jetbrains.com/datagrip/) is a professional DataBase IDE developed by Jet Brains that provides context-sensitive code completion, helping you to write SQL code faster. Completion is aware of the tables structure, foreign keys, and even database objects created in code you're editing. [RStudio](https://rstudio.com/) is an integrated development environment for R and Python, with a console, syntax-highlighting editor that supports direct code execution, and tools for plotting, history, debugging and workspace management. [MySQL](https://www.mysql.com/) is a fully managed database service to deploy cloud-native applications using the world's most popular open source database. [PostgreSQL](https://www.postgresql.org/) is a powerful, open source object-relational database system with over 30 years of active development that has earned it a strong reputation for reliability, feature robustness, and performance. [FoundationDB](https://www.foundationdb.org/) is an open source distributed database designed to handle large volumes of structured data across clusters of commodity servers. It organizes data as an ordered key-value store and employs ACID transactions for all operations. It is especially well-suited for read/write workloads but also has excellent performance for write-intensive workloads. FoundationDB was acquired by [Apple in 2015](https://techcrunch.com/2015/03/24/apple-acquires-durable-database-company-foundationdb/). [CouchbaseDB](https://www.couchbase.com/) is an open source distributed [multi-model NoSQL document-oriented database](https://en.wikipedia.org/wiki/Multi-model_database). It creates a key-value store with managed cache for sub-millisecond data operations, with purpose-built indexers for efficient queries and a powerful query engine for executing SQL queries. [IBM DB2](https://www.ibm.com/analytics/db2) is a collection of hybrid data management products offering a complete suite of AI-empowered capabilities designed to help you manage both structured and unstructured data on premises as well as in private and public cloud environments. Db2 is built on an intelligent common SQL engine designed for scalability and flexibility. [MongoDB](https://www.mongodb.com/) is a document database meaning it stores data in JSON-like documents. [OracleDB](https://www.oracle.com/database/) is a powerful fully managed database helps developers manage business-critical data with the highest availability, reliability, and security. [MariaDB](https://mariadb.com/) is an enterprise open source database solution for modern, mission-critical applications. [SQLite](https://sqlite.org/index.html) is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine.SQLite is the most used database engine in the world. SQLite is built into all mobile phones and most computers and comes bundled inside countless other applications that people use every day. [SQLite Database Browser](https://sqlitebrowser.org/) is an open source SQL tool that allows users to create, design and edits SQLite database files. It lets users show a log of all the SQL commands that have been issued by them and by the application itself. [dbWatch](https://www.dbwatch.com/) is a complete database monitoring/management solution for SQL Server, Oracle, PostgreSQL, Sybase, MySQL and Azure. Designed for proactive management and automation of routine maintenance in large scale on-premise, hybrid/cloud database environments. [Cosmos DB Profiler](https://hibernatingrhinos.com/products/cosmosdbprof) is a real-time visual debugger allowing a development team to gain valuable insight and perspective into their usage of Cosmos DB database. It identifies over a dozen suspicious behaviors from your application’s interaction with Cosmos DB. [Adminer](https://www.adminer.org/) is an SQL management client tool for managing databases, tables, relations, indexes, users. Adminer has support for all the popular database management systems such as MySQL, MariaDB, PostgreSQL, SQLite, MS SQL, Oracle, Firebird, SimpleDB, Elasticsearch and MongoDB. [DBeaver](https://dbeaver.io/) is an open source database tool for developers and database administrators. It offers supports for JDBC compliant databases such as MySQL, Oracle, IBM DB2, SQL Server, Firebird, SQLite, Sybase, Teradata, Firebird, Apache Hive, Phoenix, and Presto. [DbVisualizer](https://dbvis.com/) is a SQL management tool that allows users to manage a wide range of databases such as Oracle, Sybase, SQL Server, MySQL, H3, and SQLite. [AppDynamics Database](https://www.appdynamics.com/supported-technologies/database) is a management product for Microsoft SQL Server. With AppDynamics you can monitor and trend key performance metrics such as resource consumption, database objects, schema statistics and more, allowing you to proactively tune and fix issues in a High-Volume Production Environment. [Toad](https://www.quest.com/toad/) is a SQL Server DBMS toolset developed by Quest. It increases productivity by using extensive automation, intuitive workflows, and built-in expertise. This SQL management tool resolve issues, manage change and promote the highest levels of code quality for both relational and non-relational databases. [Lepide SQL Server](https://www.lepide.com/sql-storage-manager/) is an open source storage manager utility to analyse the performance of SQL Servers. It provides a complete overview of all configuration and permission changes being made to your SQL Server environment through an easy-to-use, graphical user interface. [Sequel Pro](https://sequelpro.com/) is a fast MacOS database management tool for working with MySQL. This SQL management tool helpful for interacting with your database by easily to adding new databases, new tables, and new rows. # Telco 5G [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <img src="https://user-images.githubusercontent.com/45159366/105409952-14881380-5be6-11eb-84fc-b07db69698ed.png"> **VMware Cloud First Approach. Source: [VMware](https://www.vmware.com/products/telco-cloud-automation.html), 2020.** <img src="https://user-images.githubusercontent.com/45159366/105409956-1520aa00-5be6-11eb-8215-735c92a5470c.png"> **VMware Telco Cloud Automation Components. Source: [VMware](https://www.vmware.com/products/telco-cloud-automation.html), 2020.** ## Telco Learning Resources [HPE(Hewlett Packard Enterprise) Telco Blueprints overview](https://techhub.hpe.com/eginfolib/servers/docs/Telco/Blueprints/infocenter/index.html#GUID-9906A227-C1FB-4FD5-A3C3-F3B72EC81CAB.html) [Network Functions Virtualization Infrastructure (NFVI) by Cisco](https://www.cisco.com/c/en/us/solutions/service-provider/network-functions-virtualization-nfv-infrastructure/index.html) [Introduction to vCloud NFV Telco Edge from VMware](https://docs.vmware.com/en/VMware-vCloud-NFV-OpenStack-Edition/3.1/vloud-nfv-edge-reference-arch-31/GUID-744C45F1-A8D5-4523-9E5E-EAF6336EE3A0.html) [VMware Telco Cloud Automation(TCA) Architecture Overview](https://docs.vmware.com/en/VMware-Telco-Cloud-Platform-5G-Edition/1.0/telco-cloud-platform-5G-edition-reference-architecture/GUID-C19566B3-F42D-4351-BA55-DE70D55FB0DD.html) [5G Telco Cloud from VMware](https://telco.vmware.com/) [Maturing OpenStack Together To Solve Telco Needs from Red Hat](https://www.redhat.com/cms/managed-files/4.Nokia%20CloudBand%20&%20Red%20Hat%20-%20Maturing%20Openstack%20together%20to%20solve%20Telco%20needs%20Ehud%20Malik,%20Senior%20PLM,%20Nokia%20CloudBand.pdf) [Red Hat telco ecosystem program](https://connect.redhat.com/en/programs/telco-ecosystem) [OpenStack for Telcos by Canonical](https://ubuntu.com/blog/openstack-for-telcos-by-canonical) [Open source NFV platform for 5G from Ubuntu](https://ubuntu.com/telco) [Understanding 5G Technology from Verizon](https://www.verizon.com/5g/) [Verizon and Unity partner to enable 5G & MEC gaming and enterprise applications](https://www.verizon.com/about/news/verizon-unity-partner-5g-mec-gaming-enterprise) [Understanding 5G Technology from Intel](https://www.intel.com/content/www/us/en/wireless-network/what-is-5g.html) [Understanding 5G Technology from Qualcomm](https://www.qualcomm.com/invention/5g/what-is-5g) [Telco Acceleration with Xilinx](https://www.xilinx.com/applications/wired-wireless/telco.html) [VIMs on OSM Public Wiki](https://osm.etsi.org/wikipub/index.php/VIMs) [Amazon EC2 Overview and Networking Introduction for Telecom Companies](https://docs.aws.amazon.com/whitepapers/latest/ec2-networking-for-telecom/ec2-networking-for-telecom.pdf) [Citrix Certified Associate – Networking(CCA-N)](http://training.citrix.com/cms/index.php/certification/networking/) [Citrix Certified Professional – Virtualization(CCP-V)](https://www.globalknowledge.com/us-en/training/certification-prep/brands/citrix/section/virtualization/citrix-certified-professional-virtualization-ccp-v/) [CCNP Routing and Switching](https://learningnetwork.cisco.com/s/ccnp-enterprise) [Certified Information Security Manager(CISM)](https://www.isaca.org/credentialing/cism) [Wireshark Certified Network Analyst (WCNA)](https://www.wiresharktraining.com/certification.html) [Juniper Networks Certification Program Enterprise (JNCP)](https://www.juniper.net/us/en/training/certification/) [Cloud Native Computing Foundation Training and Certification Program](https://www.cncf.io/certification/training/) ## Tools [Open Stack](https://www.openstack.org/) is an open source cloud platform, deployed as infrastructure-as-a-service (IaaS) to orchestrate data center operations on bare metal, private cloud hardware, public cloud resources, or both (hybrid/multi-cloud architecture). OpenStack includes advance use of virtualization & SDN for network traffic optimization to handle the core cloud-computing services of compute, networking, storage, identity, and image services. [StarlingX](https://www.starlingx.io/) is a complete cloud infrastructure software stack for the edge used by the most demanding applications in industrial IOT, telecom, video delivery and other ultra-low latency use cases. [Airship](https://www.airshipit.org/) is a collection of open source tools for automating cloud provisioning and management. Airship provides a declarative framework for defining and managing the life cycle of open infrastructure tools and the underlying hardware. [Network functions virtualization (NFV)](https://www.vmware.com/topics/glossary/content/network-functions-virtualization-nfv) is the replacement of network appliance hardware with virtual machines. The virtual machines use a hypervisor to run networking software and processes such as routing and load balancing. NFV allows for the separation of communication services from dedicated hardware, such as routers and firewalls. This separation means network operations can provide new services dynamically and without installing new hardware. Deploying network components with network functions virtualization only takes hours compared to months like with traditional networking solutions. [Software Defined Networking (SDN)](https://www.vmware.com/topics/glossary/content/software-defined-networking) is an approach to networking that uses software-based controllers or application programming interfaces (APIs) to communicate with underlying hardware infrastructure and direct traffic on a network. This model differs from that of traditional networks, which use dedicated hardware devices (routers and switches) to control network traffic. [Virtualized Infrastructure Manager (VIM)](https://www.cisco.com/c/en/us/td/docs/net_mgmt/network_function_virtualization_Infrastructure/3_2_2/install_guide/Cisco_VIM_Install_Guide_3_2_2/Cisco_VIM_Install_Guide_3_2_2_chapter_00.html) is a service delivery and reduce costs with high performance lifecycle management Manage the full lifecycle of the software and hardware comprising your NFV infrastructure (NFVI), and maintaining a live inventory and allocation plan of both physical and virtual resources. [Management and Orchestration(MANO)](https://www.etsi.org/technologies/open-source-mano) is an ETSI-hosted initiative to develop an Open Source NFV Management and Orchestration (MANO) software stack aligned with ETSI NFV. Two of the key components of the ETSI NFV architectural framework are the NFV Orchestrator and VNF Manager, known as NFV MANO. [Magma](https://www.magmacore.org/) is an open source software platform that gives network operators an open, flexible and extendable mobile core network solution. Their mission is to connect the world to a faster network by enabling service providers to build cost-effective and extensible carrier-grade networks. Magma is 3GPP generation (2G, 3G, 4G or upcoming 5G networks) and access network agnostic (cellular or WiFi). It can flexibly support a radio access network with minimal development and deployment effort. [OpenRAN](https://open-ran.org/) is an intelligent Radio Access Network(RAN) integrated on general purpose platforms with open interface between software defined functions. Open RANecosystem enables enormous flexibility and interoperability with a complete openess to multi-vendor deployments. [Open vSwitch(OVS)](https://www.openvswitch.org/)is an open source production quality, multilayer virtual switch licensed under the open source Apache 2.0 license. It is designed to enable massive network automation through programmatic extension, while still supporting standard management interfaces and protocols (NetFlow, sFlow, IPFIX, RSPAN, CLI, LACP, 802.1ag). [Edge](https://www.ibm.com/cloud/what-is-edge-computing) is a distributed computing framework that brings enterprise applications closer to data sources such as IoT devices or local edge servers. This proximity to data at its source can deliver strong business benefits, including faster insights, improved response times and better bandwidth availability. [Multi-access edge computing (MEC)](https://www.etsi.org/technologies/multi-access-edge-computing) is an Industry Specification Group (ISG) within ETSI to create a standardized, open environment which will allow the efficient and seamless integration of applications from vendors, service providers, and third-parties across multi-vendor Multi-access Edge Computing platforms. [Virtualized network functions(VNFs)](https://www.juniper.net/documentation/en_US/cso4.1/topics/concept/nsd-vnf-overview.html) is a software application used in a Network Functions Virtualization (NFV) implementation that has well defined interfaces, and provides one or more component networking functions in a defined way. For example, a security VNF provides Network Address Translation (NAT) and firewall component functions. [Cloud-Native Network Functions(CNF)](https://www.cncf.io/announcements/2020/11/18/cloud-native-network-functions-conformance-launched-by-cncf/) is a network function designed and implemented to run inside containers. CNFs inherit all the cloud native architectural and operational principles including Kubernetes(K8s) lifecycle management, agility, resilience, and observability. [Physical Network Function(PNF)](https://www.mpirical.com/glossary/pnf-physical-network-function) is a physical network node which has not undergone virtualization. Both PNFs and VNFs (Virtualized Network Functions) can be used to form an overall Network Service. [Network functions virtualization infrastructure(NFVI)](https://docs.vmware.com/en/VMware-vCloud-NFV/2.0/vmware-vcloud-nfv-reference-architecture-20/GUID-FBEA6C6B-54D8-4A37-87B1-D825F9E0DBC7.html) is the foundation of the overall NFV architecture. It provides the physical compute, storage, and networking hardware that hosts the VNFs. Each NFVI block can be thought of as an NFVI node and many nodes can be deployed and controlled geographically. # Open Source Security [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) [Open Source Security Foundation (OpenSSF)](https://openssf.org/) is a cross-industry collaboration that brings together leaders to improve the security of open source software by building a broader community, targeted initiatives, and best practices. The OpenSSF brings together open source security initiatives under one foundation to accelerate work through cross-industry support. Along with the Core Infrastructure Initiative and the Open Source Security Coalition, and will include new working groups that address vulnerability disclosures, security tooling and more. ## Security Standards, Frameworks and Benchmarks [STIGs Benchmarks - Security Technical Implementation Guides](https://public.cyber.mil/stigs/) [CIS Benchmarks - CIS Center for Internet Security](https://www.cisecurity.org/cis-benchmarks/) [NIST - Current FIPS](https://www.nist.gov/itl/current-fips) [ISO Standards Catalogue](https://www.iso.org/standards.html) [Common Criteria for Information Technology Security Evaluation (CC)](https://www.commoncriteriaportal.org/cc/) is an international standard (ISO / IEC 15408) for computer security. It allows an objective evaluation to validate that a particular product satisfies a defined set of security requirements. [ISO 22301](https://www.iso.org/en/contents/data/standard/07/51/75106.html) is the international standard that provides a best-practice framework for implementing an optimised BCMS (business continuity management system). [ISO27001](https://www.iso.org/isoiec-27001-information-security.html) is the international standard that describes the requirements for an ISMS (information security management system). The framework is designed to help organizations manage their security practices in one place, consistently and cost-effectively. [ISO 27701](https://www.iso.org/en/contents/data/standard/07/16/71670.html) specifies the requirements for a PIMS (privacy information management system) based on the requirements of ISO 27001. It is extended by a set of privacy-specific requirements, control objectives and controls. Companies that have implemented ISO 27001 will be able to use ISO 27701 to extend their security efforts to cover privacy management. [EU GDPR (General Data Protection Regulation)](https://gdpr.eu/) is a privacy and data protection law that supersedes existing national data protection laws across the EU, bringing uniformity by introducing just one main data protection law for companies/organizations to comply with. [CCPA (California Consumer Privacy Act)](https://www.oag.ca.gov/privacy/ccpa) is a data privacy law that took effect on January 1, 2020 in the State of California. It applies to businesses that collect California residents’ personal information, and its privacy requirements are similar to those of the EU’s GDPR (General Data Protection Regulation). [Payment Card Industry (PCI) Data Security Standards (DSS)](https://docs.microsoft.com/en-us/microsoft-365/compliance/offering-pci-dss) is a global information security standard designed to prevent fraud through increased control of credit card data. [SOC 2](https://www.aicpa.org/interestareas/frc/assuranceadvisoryservices/aicpasoc2report.html) is an auditing procedure that ensures your service providers securely manage your data to protect the interests of your comapny/organization and the privacy of their clients. [NIST CSF](https://www.nist.gov/national-security-standards) is a voluntary framework primarily intended for critical infrastructure organizations to manage and mitigate cybersecurity risk based on existing best practice. ## Security Tools [Checkov](https://www.checkov.io/) is a static code analysis tool for infrastructure as code (IaC) and also a software composition analysis (SCA) tool for images and open source packages. It scans cloud infrastructure provisioned using [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/OpenAPI.md) or [ARM Templates](https://github.com/bridgecrewio/checkov/blob/master/docs/7.Scan%20Examples/Azure%20ARM%20templates.md) and detects security and compliance misconfigurations using graph-based scanning. [OWASP Nettacker](https://github.com/OWASP/Nettacker) is a project created to automate information gathering, vulnerability scanning and eventually generating a report for networks, including services, bugs, vulnerabilities, misconfigurations, and other information. This software will utilize TCP SYN, ACK, ICMP, and many other protocols in order to detect and bypass Firewall/IDS/IPS devices. [Terrascan](https://runterrascan.io/) is a static code analyzer for Infrastructure as Code to mitigate risk before provisioning cloud native infrastructure. [Deepfence ThreatMapper](https://deepfence.io/) is a runtime tool that hunts for vulnerabilities in your cloud native production platforms(Linux, K8s, AWS Fargate and more.), and ranks these vulnerabilities based on their risk-of-exploit. [Dockle](https://containers.goodwith.tech/) is a Container Image Linter for Security and helping build the Best-Practice Docker Image. [Sliver](https://github.com/BishopFox/sliver) is an open source cross-platform adversary emulation/red team framework, it can be used by organizations of all sizes to perform security testing. Sliver's implants support C2 over Mutual TLS (mTLS), WireGuard, HTTP(S), and DNS and are dynamically compiled with per-binary asymmetric encryption keys. [Attack Surface Analyzer](https://github.com/microsoft/AttackSurfaceAnalyzer) is a [Microsoft](https://github.com/microsoft/) developed open source security tool that analyzes the attack surface of a target system and reports on potential security vulnerabilities introduced during the installation of software or system misconfiguration. [Intel Owl](https://intelowl.readthedocs.io/) is an Open Source Intelligence, or OSINT solution to get threat intelligence data about a specific file, an IP or a domain from a single API at scale. It integrates a number of analyzers available online and a lot of cutting-edge malware analysis tools. [SpiceDB](https://docs.authzed.com/) is an open source database system for managing security-critical application permissions inspired by Google's [Zanzibar](https://authzed.com/blog/what-is-zanzibar/) paper. [Bandit](https://github.com/PyCQA/bandit) is a tool designed to find common security issues in Python code. [Payloads All The Things](https://github.com/swisskyrepo/PayloadsAllTheThings) is a list of useful payloads and bypass for Web Application Security and Pentest/CTF. [TheHive](https://thehive-project.org/) is a scalable 3-in-1 open source and free Security Incident Response Platform designed to make life easier for SOCs, CSIRTs, CERTs and any information security practitioner dealing with security incidents that need to be investigated and acted upon swiftly. It is the perfect companion to [MISP](http://www.misp-project.org/). [Cortex](https://thehive-project.org/) is a Powerful Observable Analysis and Active Response Engine. This solves a common problem frequently encountered by SOCs, CSIRTs and security researchers in the course of threat intelligence, digital forensics and incident response. [Scrummage](https://github.com/matamorphosis/Scrummage) is an OSINT tool that centralises search functionality from a bounty of powerful, publicly-available, third-party, [OSINT](https://osintframework.com/) websites. [Bettercap](https://www.bettercap.org/) is a powerful, easily extensible and portable framework written in Go which aims to offer to security researchers, red teamers and reverse engineers an easy to use, all-in-one solution with all the features they might possibly need for performing reconnaissance and attacking [WiFi](https://www.bettercap.org/modules/wifi/) networks, [Bluetooth Low Energy](https://www.bettercap.org/modules/ble/) devices, wireless [HID](https://www.bettercap.org/modules/hid/) devices and [Ethernet](https://www.bettercap.org/modules/ethernet) networks. [Wifiphisher](https://wifiphisher.org/) is a rogue Access Point framework for conducting red team engagements or Wi-Fi security testing. Using Wifiphisher, penetration testers can easily achieve a man-in-the-middle position against wireless clients by performing targeted Wi-Fi association attacks. [AppArmor](https://www.apparmor.net/) is an effective and easy-to-use Linux application security system. AppArmor proactively protects the operating system and applications from external or internal threats, even zero-day attacks, by enforcing good behavior and preventing both known and unknown application flaws from being exploited. AppArmor supplements the traditional Unix discretionary access control (DAC) model by providing mandatory access control (MAC). It has been included in the mainline Linux kernel since version 2.6.36 and its development has been supported by Canonical since 2009. [AWS FIREWALL FACTORY](https://github.com/globaldatanet/aws-firewall-factory) is a tool to deploy, update, test and stage your WAFs while managing them centrally via FMS. [SELinux](https://github.com/SELinuxProject/selinux) is a security enhancement to Linux which allows users and administrators more control over access control. Access can be constrained on such variables as which users and applications can access which resources. These resources may take the form of files. Standard Linux access controls, such as file modes (-rwxr-xr-x) are modifiable by the user and the applications which the user runs. Conversely, SELinux access controls are determined by a policy loaded on the system which may not be changed by careless users or misbehaving applications. [Control Groups(Cgroups)](https://www.redhat.com/sysadmin/cgroups-part-one) is a Linux kernel feature that allows you to allocate resources such as CPU time, system memory, network bandwidth, or any combination of these resources for user-defined groups of tasks (processes) running on a system. [EarlyOOM](https://github.com/rfjakob/earlyoom) is a daemon for Linux that enables users to more quickly recover and regain control over their system in low-memory situations with heavy swap usage. [Libgcrypt](https://www.gnupg.org/related_software/libgcrypt/) is a general purpose cryptographic library originally based on code from GnuPG. [Kali Linux](https://www.kali.org/) is an open source project that is maintained and funded by Offensive Security, a provider of world-class information security training and penetration testing services. [Pi-hole](https://pi-hole.net/) is a [DNS sinkhole](https://en.wikipedia.org/wiki/DNS_Sinkhole) that protects your devices from unwanted content, without installing any client-side software, intended for use on a private network. It is designed for use on embedded devices with network capability, such as the Raspberry Pi, but it can be used on other machines running Linux and cloud implementations. [Aircrack-ng](https://www.aircrack-ng.org/) is a network software suite consisting of a detector, packet sniffer, WEP and WPA/WPA2-PSK cracker and analysis tool for 802.11 wireless LANs. It works with any wireless network interface controller whose driver supports raw monitoring mode and can sniff 802.11a, 802.11b and 802.11g traffic. [Burp Suite](https://portswigger.net/burp) is a leading range of cybersecurity tools. [KernelCI](https://foundation.kernelci.org/) is a community-based open source distributed test automation system focused on upstream kernel development. The primary goal of KernelCI is to use an open testing philosophy to ensure the quality, stability and long-term maintenance of the Linux kernel. [Continuous Kernel Integration project](https://github.com/cki-project) helps find bugs in kernel patches before they are commited to an upstram kernel tree. We are team of kernel developers, kernel testers, and automation engineers. [eBPF](https://ebpf.io) is a revolutionary technology that can run sandboxed programs in the Linux kernel without changing kernel source code or loading kernel modules. By making the Linux kernel programmable, infrastructure software can leverage existing layers, making them more intelligent and feature-rich without continuing to add additional layers of complexity to the system. [Cilium](https://cilium.io/) uses eBPF to accelerate getting data in and out of L7 proxies such as Envoy, enabling efficient visibility into API protocols like HTTP, gRPC, and Kafka. [Hubble](https://github.com/cilium/hubble) is a Network, Service & Security Observability for Kubernetes using eBPF. [Istio](https://istio.io/) is an open platform to connect, manage, and secure microservices. Istio's control plane provides an abstraction layer over the underlying cluster management platform, such as Kubernetes and Mesos. [Certgen](https://github.com/cilium/certgen) is a convenience tool to generate and store certificates for Hubble Relay mTLS. [Scapy](https://scapy.net/) is a python-based interactive packet manipulation program & library. [syzkaller](https://github.com/google/syzkaller) is an unsupervised, coverage-guided kernel fuzzer. [SchedViz](https://github.com/google/schedviz) is a tool for gathering and visualizing kernel scheduling traces on Linux machines. [oss-fuzz](https://google.github.io/oss-fuzz/) aims to make common open source software more secure and stable by combining modern fuzzing techniques with scalable, distributed execution. [OSSEC](https://www.ossec.net/) is a free, open-source host-based intrusion detection system. It performs log analysis, integrity checking, Windows registry monitoring, rootkit detection, time-based alerting, and active response. [Metasploit Project](https://www.metasploit.com/) is a computer security project that provides information about security vulnerabilities and aids in penetration testing and IDS signature development. [Wfuzz](https://github.com/xmendez/wfuzz) was created to facilitate the task in web applications assessments and it is based on a simple concept: it replaces any reference to the FUZZ keyword by the value of a given payload. [Nmap](https://nmap.org/) is a security scanner used to discover hosts and services on a computer network, thus building a "map" of the network. [Patchwork](https://github.com/getpatchwork/patchwork) is a web-based patch tracking system designed to facilitate the contribution and management of contributions to an open-source project. [pfSense](https://www.pfsense.org/) is a free and open source firewall and router that also features unified threat management, load balancing, multi WAN, and more. [Snowpatch](https://github.com/ruscur/snowpatch) is a continuous integration tool for projects using a patch-based, mailing-list-centric git workflow. This workflow is used by a number of well-known open source projects such as the Linux kernel. [Snort](https://www.snort.org/) is an open-source, free and lightweight network intrusion detection system (NIDS) software for Linux and Windows to detect emerging threats. [Wireshark](https://www.wireshark.org/) is a free and open-source packet analyzer. It is used for network troubleshooting, analysis, software and communications protocol development, and education. [OpenSCAP](https://www.open-scap.org/) is U.S. standard maintained by [National Institute of Standards and Technology (NIST)](https://www.nist.gov/). It provides multiple tools to assist administrators and auditors with assessment, measurement, and enforcement of security baselines. OpenSCAP maintains great flexibility and interoperability by reducing the costs of performing security audits. Whether you want to evaluate DISA STIGs, NIST‘s USGCB, or Red Hat’s Security Response Team’s content, all are supported by OpenSCAP. [Tink](https://github.com/google/tink) is a multi-language, cross-platform, open source library that provides cryptographic APIs that are secure, easy to use correctly, and harder to misuse. [OWASP](https://www.owasp.org/index.php/Main_Page) is an online community, produces freely-available articles, methodologies, documentation, tools, and technologies in the field of web application security. [Open Vulnerability and Assessment Language](https://oval.mitre.org/) is a community effort to standardize how to assess and report upon the machine state of computer systems. OVAL includes a language to encode system details, and community repositories of content. Tools and services that use OVAL provide enterprises with accurate, consistent, and actionable information to improve their security. [ClamAV](https://www.clamav.net/) is an open source antivirus engine for detecting trojans, viruses, malware & other malicious threats. ## Open Source Security Learning Resources [Microsoft Open Source Software Security](https://www.microsoft.com/en-us/securityengineering/opensource) [Cloudflare Open Source Security](https://cloudflare.github.io) [The Seven Properties of Highly Secure Devices](https://www.microsoft.com/en-us/research/publication/seven-properties-highly-secure-devices/) [How Layer 7 of the Internet Works](https://www.cloudflare.com/learning/ddos/what-is-layer-7/) [The 7 Kinds of Security](https://www.veracode.com/sites/default/files/Resources/eBooks/7-kinds-of-security.pdf) [The Libgcrypt Reference Manual](https://www.gnupg.org/documentation/manuals/gcrypt/) [The Open Web Application Security Project(OWASP) Foundation Top 10](https://owasp.org/www-project-top-ten/) [Best Practices for Using Open Source Code from The Linux Foundation](https://www.linuxfoundation.org/blog/2017/11/best-practices-using-open-source-code/) [AWS Certified Security - Specialty Certification](https://aws.amazon.com/certification/certified-security-specialty/) [Microsoft Certified: Azure Security Engineer Associate](https://docs.microsoft.com/en-us/learn/certifications/azure-security-engineer) [Google Cloud Certified Professional Cloud Security Engineer](https://cloud.google.com/certification/cloud-security-engineer) [Cisco Security Certifications](https://www.cisco.com/c/en/us/training-events/training-certifications/certifications/security.html) [The Red Hat Certified Specialist in Security: Linux](https://www.redhat.com/en/services/training/ex415-red-hat-certified-specialist-security-linux-exam) [Linux Professional Institute LPIC-3 Enterprise Security Certification](https://www.lpi.org/our-certifications/lpic-3-303-overview) [Cybersecurity Training and Courses from IBM Skills](https://www.ibm.com/skills/topics/cybersecurity/) [Cybersecurity Courses and Certifications by Offensive Security](https://www.offensive-security.com/courses-and-certifications/) [RSA Certification Program](https://community.rsa.com/community/training/certification) [Check Point Certified Security Expert(CCSE) Certification](https://training-certifications.checkpoint.com/#/courses/Check%20Point%20Certified%20Expert%20(CCSE)%20R80.x) [Check Point Certified Security Administrator(CCSA) Certification](https://training-certifications.checkpoint.com/#/courses/Check%20Point%20Certified%20Admin%20(CCSA)%20R80.x) [Check Point Certified Security Master (CCSM) Certification](https://training-certifications.checkpoint.com/#/courses/Check%20Point%20Certified%20Master%20(CCSM)%20R80.x) [Certified Cloud Security Professional(CCSP) Certification](https://www.isc2.org/Certifications/CCSP) [Certified Information Systems Security Professional (CISSP) Certification](https://www.isc2.org/Certifications/CISSP) [CCNP Routing and Switching](https://learningnetwork.cisco.com/s/ccnp-enterprise) [Certified Information Security Manager(CISM)](https://www.isaca.org/credentialing/cism) [Wireshark Certified Network Analyst (WCNA)](https://www.wiresharktraining.com/certification.html) [Juniper Networks Certification Program Enterprise (JNCP)](https://www.juniper.net/us/en/training/certification/) [Security Training Certifications and Courses from Udemy](https://www.udemy.com/courses/search/?src=ukw&q=secuirty) [Security Training Certifications and Courses from Coursera](https://www.coursera.org/search?query=security&) [Security Certifications Training from Pluarlsight](https://www.pluralsight.com/browse/information-cyber-security/security-certifications) # Kubernetes [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) [Kubernetes (K8s)](https://kubernetes.io/) is an open-source system for automating deployment, scaling, and management of containerized applications. <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/105645195-db9ea780-5e4e-11eb-8357-fb38b2f06d74.png"> **Building Highly-Availability(HA) Clusters with kubeadm. Source: [Kubernetes.io](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/), 2020** </p> [Google Kubernetes Engine (GKE)](https://cloud.google.com/kubernetes-engine/) is a managed, production-ready environment for running containerized applications. [Azure Kubernetes Service (AKS)](https://azure.microsoft.com/en-us/services/kubernetes-service/) is serverless Kubernetes, with a integrated continuous integration and continuous delivery (CI/CD) experience, and enterprise-grade security and governance. Unite your development and operations teams on a single platform to rapidly build, deliver, and scale applications with confidence. [Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) is a tool that runs Kubernetes control plane instances across multiple Availability Zones to ensure high availability. [AWS Controllers for Kubernetes (ACK)](https://aws.amazon.com/blogs/containers/aws-controllers-for-kubernetes-ack/) is a new tool that lets you directly manage AWS services from Kubernetes. ACK makes it simple to build scalable and highly-available Kubernetes applications that utilize AWS services. [Container Engine for Kubernetes (OKE)](https://www.oracle.com/cloud-native/container-engine-kubernetes/) is an Oracle-managed container orchestration service that can reduce the time and cost to build modern cloud native applications. Unlike most other vendors, Oracle Cloud Infrastructure provides Container Engine for Kubernetes as a free service that runs on higher-performance, lower-cost compute. [Anthos](https://cloud.google.com/anthos/docs/concepts/overview) is a modern application management platform that provides a consistent development and operations experience for cloud and on-premises environments. [Red Hat Openshift](https://www.openshift.com/) is a fully managed Kubernetes platform that provides a foundation for on-premises, hybrid, and multicloud deployments. [OKD](https://okd.io/) is a community distribution of Kubernetes optimized for continuous application development and multi-tenant deployment. OKD adds developer and operations-centric tools on top of Kubernetes to enable rapid application development, easy deployment and scaling, and long-term lifecycle maintenance for small and large teams. [Odo](https://odo.dev/) is a fast, iterative, and straightforward CLI tool for developers who write, build, and deploy applications on Kubernetes and OpenShift. [Kata Operator](https://github.com/openshift/kata-operator) is an operator to perform lifecycle management (install/upgrade/uninstall) of [Kata Runtime](https://katacontainers.io/) on Openshift as well as Kubernetes cluster. [Thanos](https://thanos.io/) is a set of components that can be composed into a highly available metric system with unlimited storage capacity, which can be added seamlessly on top of existing Prometheus deployments. [OpenShift Hive](https://github.com/openshift/hive) is an operator which runs as a service on top of Kubernetes/OpenShift. The Hive service can be used to provision and perform initial configuration of OpenShift 4 clusters. [Rook](https://rook.io/) is a tool that turns distributed storage systems into self-managing, self-scaling, self-healing storage services. It automates the tasks of a storage administrator: deployment, bootstrapping, configuration, provisioning, scaling, upgrading, migration, disaster recovery, monitoring, and resource management. [VMware Tanzu](https://tanzu.vmware.com/tanzu) is a centralized management platform for consistently operating and securing your Kubernetes infrastructure and modern applications across multiple teams and private/public clouds. [Kubespray](https://kubespray.io/) is a tool that combines Kubernetes and Ansible to easily install Kubernetes clusters that can be deployed on [AWS](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/aws.md), GCE, [Azure](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/azure.md), [OpenStack](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/openstack.md), [vSphere](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/vsphere.md), [Packet](https://github.com/kubernetes-sigs/kubespray/blob/master/docs/packet.md) (bare metal), Oracle Cloud Infrastructure (Experimental), or Baremetal. [KubeInit](https://github.com/kubeinit/kubeinit) provides Ansible playbooks and roles for the deployment and configuration of multiple Kubernetes distributions. [Rancher](https://rancher.com/) is a complete software stack for teams adopting containers. It addresses the operational and security challenges of managing multiple Kubernetes clusters, while providing DevOps teams with integrated tools for running containerized workloads. [K3s](https://github.com/rancher/k3s) is a highly available, certified Kubernetes distribution designed for production workloads in unattended, resource-constrained, remote locations or inside IoT appliances. [Helm](https://helm.sh/) is a Kubernetes Package Manager tool that makes it easier to install and manage Kubernetes applications. [Knative](https://knative.dev/) is a Kubernetes-based platform to build, deploy, and manage modern serverless workloads. Knative takes care of the operational overhead details of networking, autoscaling (even to zero), and revision tracking. [KubeFlow](https://www.kubeflow.org/) is a tool dedicated to making deployments of machine learning (ML) workflows on Kubernetes simple, portable and scalable. [Etcd](https://etcd.io/) is a distributed key-value store that provides a reliable way to store data that needs to be accessed by a distributed system or cluster of machines. Etcd is used as the backend for service discovery and stores cluster state and configuration for Kubernetes. [OpenEBS](https://openebs.io/) is a Kubernetes-based tool to create stateful applications using Container Attached Storage. [Container Storage Interface (CSI)](https://www.architecting.it/blog/container-storage-interface/) is an API that lets container orchestration platforms like Kubernetes seamlessly communicate with stored data via a plug-in. [MicroK8s](https://microk8s.io/) is a tool that delivers the full Kubernetes experience. In a Fully containerized deployment with compressed over-the-air updates for ultra-reliable operations. It is supported on Linux, Windows, and MacOS. [Charmed Kubernetes](https://ubuntu.com/kubernetes/features) is a well integrated, turn-key, conformant Kubernetes platform, optimized for your multi-cloud environments developed by Canonical. [Grafana Kubernetes App](https://grafana.com/grafana/plugins/grafana-kubernetes-app) is a toll that allows you to monitor your Kubernetes cluster's performance. It includes 4 dashboards, Cluster, Node, Pod/Container and Deployment. It allows for the automatic deployment of the required Prometheus exporters and a default scrape config to use with your in cluster Prometheus deployment. [KubeEdge](https://kubeedge.io/en/) is an open source system for extending native containerized application orchestration capabilities to hosts at Edge.It is built upon kubernetes and provides fundamental infrastructure support for network, app. deployment and metadata synchronization between cloud and edge. [Lens](https://k8slens.dev/) is the most powerful IDE for people who need to deal with Kubernetes clusters on a daily basis. It has support for MacOS, Windows and Linux operating systems. [kind](https://kind.sigs.k8s.io/) is a tool for running local Kubernetes clusters using Docker container “nodes”. It was primarily designed for testing Kubernetes itself, but may be used for local development or CI. [Flux CD](https://fluxcd.io/) is a tool that automatically ensures that the state of your Kubernetes cluster matches the configuration you've supplied in Git. It uses an operator in the cluster to trigger deployments inside Kubernetes, which means that you don't need a separate continuous delivery tool. ## Kubernetes Learning Resources [Getting Kubernetes Certifications](https://training.linuxfoundation.org/certification/catalog/?_sft_technology=kubernetes) [Getting started with Kubernetes on AWS](https://aws.amazon.com/kubernetes/) [Kubernetes on Microsoft Azure](https://azure.microsoft.com/en-us/topic/what-is-kubernetes/) [Intro to Azure Kubernetes Service](https://docs.microsoft.com/en-us/azure/aks/kubernetes-dashboard) [Getting started with Google Cloud](https://cloud.google.com/learn/what-is-kubernetes) [Getting started with Kubernetes on Red Hat](https://www.redhat.com/en/topics/containers/what-is-kubernetes) [Getting started with Kubernetes on IBM](https://www.ibm.com/cloud/learn/kubernetes) [YAML basics in Kubernetes](https://developer.ibm.com/technologies/containers/tutorials/yaml-basics-and-usage-in-kubernetes/) [Elastic Cloud on Kubernetes](https://www.elastic.co/elastic-cloud-kubernetes) [Docker and Kubernetes](https://www.docker.com/products/kubernetes) [Deploy a model to an Azure Kubernetes Service cluster](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-deploy-azure-kubernetes-service?tabs=python) [Simplify Machine Learning Inference on Kubernetes with Amazon SageMaker Operators](https://aws.amazon.com/blogs/machine-learning/simplify-machine-learning-inference-on-kubernetes-with-amazon-sagemaker-operators/) [Running Apache Spark on Kubernetes](http://spark.apache.org/docs/latest/running-on-kubernetes.html) [Kubernetes Across VMware vRealize Automation](https://blogs.vmware.com/management/2019/06/kubernetes-across-vmware-cloud-automation-services.html) [VMware Tanzu Kubernetes Grid](https://tanzu.vmware.com/kubernetes-grid) [All the Ways VMware Tanzu Works with AWS](https://tanzu.vmware.com/content/blog/all-the-ways-vmware-tanzutm-works-with-aws) [VMware Tanzu Education](https://tanzu.vmware.com/education) [Using Ansible in a Cloud-Native Kubernetes Environment](https://www.ansible.com/blog/how-useful-is-ansible-in-a-cloud-native-kubernetes-environment) [Managing Kubernetes (K8s) objects with Ansible](https://docs.ansible.com/ansible/latest/collections/community/kubernetes/k8s_module.html) [Setting up a Kubernetes cluster using Vagrant and Ansible](https://kubernetes.io/blog/2019/03/15/kubernetes-setup-using-ansible-and-vagrant/) [Running MongoDB with Kubernetes](https://www.mongodb.com/kubernetes) [Kubernetes Fluentd](https://docs.fluentd.org/v/0.12/articles/kubernetes-fluentd) [Understanding the new GitLab Kubernetes Agent](https://about.gitlab.com/blog/2020/09/22/introducing-the-gitlab-kubernetes-agent/) [Kubernetes Contributors](https://www.kubernetes.dev/) [KubeAcademy from VMware](https://kube.academy/) [Kubernetes Tutorial for Beginners: Basic Concepts](https://spacelift.io/blog/kubernetes-tutorial) # Machine Learning [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <img src="https://user-images.githubusercontent.com/45159366/108111395-756e0480-7049-11eb-85ca-b87315e9d3ef.jpeg"> ## ML frameworks & applications [TensorFlow](https://www.tensorflow.org) is an end-to-end open source platform for machine learning. It has a comprehensive, flexible ecosystem of tools, libraries and community resources that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML powered applications. [Tensorman](https://github.com/pop-os/tensorman) is a utility for easy management of Tensorflow containers by developed by [System76]( https://system76.com).Tensorman allows Tensorflow to operate in an isolated environment that is contained from the rest of the system. This virtual environment can operate independent of the base system, allowing you to use any version of Tensorflow on any version of a Linux distribution that supports the Docker runtime. [Keras](https://keras.io) is a high-level neural networks API, written in Python and capable of running on top of TensorFlow, CNTK, or Theano.It was developed with a focus on enabling fast experimentation. It is capable of running on top of TensorFlow, Microsoft Cognitive Toolkit, R, Theano, or PlaidML. [PyTorch](https://pytorch.org) is a library for deep learning on irregular input data such as graphs, point clouds, and manifolds. Primarily developed by Facebook's AI Research lab. [Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a fully managed service that provides every developer and data scientist with the ability to build, train, and deploy machine learning (ML) models quickly. SageMaker removes the heavy lifting from each step of the machine learning process to make it easier to develop high quality models. [Azure Databricks](https://azure.microsoft.com/en-us/services/databricks/) is a fast and collaborative Apache Spark-based big data analytics service designed for data science and data engineering. Azure Databricks, sets up your Apache Spark environment in minutes, autoscale, and collaborate on shared projects in an interactive workspace. Azure Databricks supports Python, Scala, R, Java, and SQL, as well as data science frameworks and libraries including TensorFlow, PyTorch, and scikit-learn. [Microsoft Cognitive Toolkit (CNTK)](https://docs.microsoft.com/en-us/cognitive-toolkit/) is an open-source toolkit for commercial-grade distributed deep learning. It describes neural networks as a series of computational steps via a directed graph. CNTK allows the user to easily realize and combine popular model types such as feed-forward DNNs, convolutional neural networks (CNNs) and recurrent neural networks (RNNs/LSTMs). CNTK implements stochastic gradient descent (SGD, error backpropagation) learning with automatic differentiation and parallelization across multiple GPUs and servers. [Apache Airflow](https://airflow.apache.org) is an open-source workflow management platform created by the community to programmatically author, schedule and monitor workflows. Install. Principles. Scalable. Airflow has a modular architecture and uses a message queue to orchestrate an arbitrary number of workers. Airflow is ready to scale to infinity. [Open Neural Network Exchange(ONNX)](https://github.com/onnx) is an open ecosystem that empowers AI developers to choose the right tools as their project evolves. ONNX provides an open source format for AI models, both deep learning and traditional ML. It defines an extensible computation graph model, as well as definitions of built-in operators and standard data types. [Apache MXNet](https://mxnet.apache.org/) is a deep learning framework designed for both efficiency and flexibility. It allows you to mix symbolic and imperative programming to maximize efficiency and productivity. At its core, MXNet contains a dynamic dependency scheduler that automatically parallelizes both symbolic and imperative operations on the fly. A graph optimization layer on top of that makes symbolic execution fast and memory efficient. MXNet is portable and lightweight, scaling effectively to multiple GPUs and multiple machines. Support for Python, R, Julia, Scala, Go, Javascript and more. [AutoGluon](https://autogluon.mxnet.io/index.html) is toolkit for Deep learning that automates machine learning tasks enabling you to easily achieve strong predictive performance in your applications. With just a few lines of code, you can train and deploy high-accuracy deep learning models on tabular, image, and text data. [Anaconda](https://www.anaconda.com/) is a very popular Data Science platform for machine learning and deep learning that enables users to develop models, train them, and deploy them. [PlaidML](https://github.com/plaidml/plaidml) is an advanced and portable tensor compiler for enabling deep learning on laptops, embedded devices, or other devices where the available computing hardware is not well supported or the available software stack contains unpalatable license restrictions. [OpenCV](https://opencv.org) is a highly optimized library with focus on real-time computer vision applications. The C++, Python, and Java interfaces support Linux, MacOS, Windows, iOS, and Android. [Scikit-Learn](https://scikit-learn.org/stable/index.html) is a Python module for machine learning built on top of SciPy, NumPy, and matplotlib, making it easier to apply robust and simple implementations of many popular machine learning algorithms. [Weka](https://www.cs.waikato.ac.nz/ml/weka/) is an open source machine learning software that can be accessed through a graphical user interface, standard terminal applications, or a Java API. It is widely used for teaching, research, and industrial applications, contains a plethora of built-in tools for standard machine learning tasks, and additionally gives transparent access to well-known toolboxes such as scikit-learn, R, and Deeplearning4j. [Caffe](https://github.com/BVLC/caffe) is a deep learning framework made with expression, speed, and modularity in mind. It is developed by Berkeley AI Research (BAIR)/The Berkeley Vision and Learning Center (BVLC) and community contributors. [Theano](https://github.com/Theano/Theano) is a Python library that allows you to define, optimize, and evaluate mathematical expressions involving multi-dimensional arrays efficiently including tight integration with NumPy. [nGraph](https://github.com/NervanaSystems/ngraph) is an open source C++ library, compiler and runtime for Deep Learning. The nGraph Compiler aims to accelerate developing AI workloads using any deep learning framework and deploying to a variety of hardware targets.It provides the freedom, performance, and ease-of-use to AI developers. [NVIDIA cuDNN](https://developer.nvidia.com/cudnn) is a GPU-accelerated library of primitives for [deep neural networks](https://developer.nvidia.com/deep-learning). cuDNN provides highly tuned implementations for standard routines such as forward and backward convolution, pooling, normalization, and activation layers. cuDNN accelerates widely used deep learning frameworks, including [Caffe2](https://caffe2.ai/), [Chainer](https://chainer.org/), [Keras](https://keras.io/), [MATLAB](https://www.mathworks.com/solutions/deep-learning.html), [MxNet](https://mxnet.incubator.apache.org/), [PyTorch](https://pytorch.org/), and [TensorFlow](https://www.tensorflow.org/). [Jupyter Notebook](https://jupyter.org/) is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. Jupyter is used widely in industries that do data cleaning and transformation, numerical simulation, statistical modeling, data visualization, data science, and machine learning. [Apache Spark](https://spark.apache.org/) is a unified analytics engine for large-scale data processing. It provides high-level APIs in Scala, Java, Python, and R, and an optimized engine that supports general computation graphs for data analysis. It also supports a rich set of higher-level tools including Spark SQL for SQL and DataFrames, MLlib for machine learning, GraphX for graph processing, and Structured Streaming for stream processing. [Apache Spark Connector for SQL Server and Azure SQL](https://github.com/microsoft/sql-spark-connector) is a high-performance connector that enables you to use transactional data in big data analytics and persists results for ad-hoc queries or reporting. The connector allows you to use any SQL database, on-premises or in the cloud, as an input data source or output data sink for Spark jobs. [Apache PredictionIO](https://predictionio.apache.org/) is an open source machine learning framework for developers, data scientists, and end users. It supports event collection, deployment of algorithms, evaluation, querying predictive results via REST APIs. It is based on scalable open source services like Hadoop, HBase (and other DBs), Elasticsearch, Spark and implements what is called a Lambda Architecture. [Cluster Manager for Apache Kafka(CMAK)](https://github.com/yahoo/CMAK) is a tool for managing [Apache Kafka](https://kafka.apache.org/) clusters. [BigDL](https://bigdl-project.github.io/) is a distributed deep learning library for Apache Spark. With BigDL, users can write their deep learning applications as standard Spark programs, which can directly run on top of existing Spark or Hadoop clusters. [Koalas](https://pypi.org/project/koalas/) is project makes data scientists more productive when interacting with big data, by implementing the pandas DataFrame API on top of Apache Spark. [Apache Spark™ MLflow](https://mlflow.org/) is an open source platform to manage the ML lifecycle, including experimentation, reproducibility, deployment, and a central model registry. MLflow currently offers four components: **[MLflow Tracking](https://mlflow.org/docs/latest/tracking.html)**: Record and query experiments: code, data, config, and results. **[MLflow Projects](https://mlflow.org/docs/latest/projects.html)**: Package data science code in a format to reproduce runs on any platform. **[MLflow Models](https://mlflow.org/docs/latest/models.html)**: Deploy machine learning models in diverse serving environments. **[Model Registry](https://mlflow.org/docs/latest/model-registry.html)**: Store, annotate, discover, and manage models in a central repository. [Eclipse Deeplearning4J (DL4J)](https://deeplearning4j.konduit.ai/) is a set of projects intended to support all the needs of a JVM-based(Scala, Kotlin, Clojure, and Groovy) deep learning application. This means starting with the raw data, loading and preprocessing it from wherever and whatever format it is in to building and tuning a wide variety of simple and complex deep learning networks. [Numba](https://github.com/numba/numba) is an open source, NumPy-aware optimizing compiler for Python sponsored by Anaconda, Inc. It uses the LLVM compiler project to generate machine code from Python syntax. Numba can compile a large subset of numerically-focused Python, including many NumPy functions. Additionally, Numba has support for automatic parallelization of loops, generation of GPU-accelerated code, and creation of ufuncs and C callbacks. [Chainer](https://chainer.org/) is a Python-based deep learning framework aiming at flexibility. It provides automatic differentiation APIs based on the define-by-run approach (dynamic computational graphs) as well as object-oriented high-level APIs to build and train neural networks. It also supports CUDA/cuDNN using [CuPy](https://github.com/cupy/cupy) for high performance training and inference. [cuML](https://github.com/rapidsai/cuml) is a suite of libraries that implement machine learning algorithms and mathematical primitives functions that share compatible APIs with other RAPIDS projects. cuML enables data scientists, researchers, and software engineers to run traditional tabular ML tasks on GPUs without going into the details of CUDA programming. In most cases, cuML's Python API matches the API from scikit-learn. ## ML Learning Resources [Machine Learning by Stanford University from Coursera](https://www.coursera.org/learn/machine-learning) [Machine Learning Courses Online from Coursera](https://www.coursera.org/courses?query=machine%20learning&) [Machine Learning Courses Online from Udemy](https://www.udemy.com/topic/machine-learning/) [Learn Machine Learning with Online Courses and Classes from edX](https://www.edx.org/learn/machine-learning) # Node.js Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93719688-0becd700-fb39-11ea-9b87-3d52f1828aee.png"> <br /> </p> **[Start building with Node.js on AWS](https://aws.amazon.com/sdk-for-node-js/)** ## Node.js Learning Resources [Node.js](https://nodejs.org/) is a JavaScript runtime built on Chrome's V8 JavaScript engine that lets developers write command line tools and server-side scripts outside of a browser. [Node.js Build Working Group](https://github.com/nodejs/build) maintains and controls infrastructure used for continuous integration (CI), releases, benchmarks, web hosting (of nodejs.org and other Node.js web properties) and more. [The OpenJS Foundation](https://openjsf.org/) is made up of 32 open source JavaScript projects including Appium, Dojo, Electron, jQuery, Node.js, and webpack. The foundation's mission is to support the healthy growth of JavaScript and web technologies by providing a neutral organization to host and sustain projects, as well as collaboratively fund activities that benefit the ecosystem as a whole. [Set up NodeJS on WSL 2](https://docs.microsoft.com/en-us/windows/nodejs/setup-on-wsl2) [Getting started with Node.js in Google Cloud](https://cloud.google.com/nodejs/getting-started) [Getting Started with Node.js in AWS](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/getting-started-nodejs.html) [Node.js App Hosting & Deployment in Microsoft Azure](https://azure.microsoft.com/en-us/develop/nodejs/) [The Node.js best practices list ](https://github.com/goldbergyoni/nodebestpractices) [Introduction to Node.js by W3Schools](https://www.w3schools.com/nodejs/nodejs_intro.asp) [The Node.js Community Committee](https://github.com/nodejs/community-committee) [Node.js Mentorship Program Initiative](https://github.com/nodejs/mentorship) [Node.js tutorial in Visual Studio Code](https://code.visualstudio.com/docs/nodejs/nodejs-tutorial) [Server-side Development with NodeJS, Express and MongoDB on Coursera](https://www.coursera.org/learn/server-side-nodejs) ## Node.js Tools [NPM](https://www.npmjs.com/) is the company behind Node package manager, the npm Registry, and npm CLI. [node-gyp](https://github.com/nodejs/node-gyp) is a cross-platform command-line tool written in Node.js for compiling native addon modules for Node.js. It contains a vendored copy of the gyp-next project that was previously used by the Chromium team, extended to support the development of Node.js native addons. [nvm ](https://github.com/nvm-sh/nvm) is a version manager for node.js, designed to be installed per-user, and invoked per-shell. nvm works on any POSIX-compliant shell (sh, dash, ksh, zsh, bash), in particular on these platforms: unix, macOS, and windows WSL. [node-docker](https://hub.docker.com/_/node/) is the official Node.js docker image, made with love by the node community. [Mocha](https://github.com/mochajs/mocha) is a simple, flexible, fun JavaScript test framework for Node.js & The Browser. [AVA](https://github.com/avajs/ava) is a test runner for Node.js with a concise API, detailed error output, embrace of new language features and process isolation that lets you develop with confidence. [egg](https://eggjs.org/) is a born to build better enterprise frameworks and apps with Node.js & Koa. [mysqljs](https://github.com/mysqljs/mysql) is a pure node.js JavaScript Client implementing the MySQL protocol. [axios](https://github.com/axios/axios) is a promise based HTTP client for the browser and node.js. [Fastify](https://www.fastify.io/) is a fast and low overhead web framework, for Node.js. [Express](https://expressjs.com/) is a fast, unopinionated, minimalist web framework for node. [Meteor](https://www.meteor.com/) is an ultra-simple environment for building modern web applications with JavavScript. [NW.js](https://nwjs.io/) is an app runtime based on Chromium and node.js. You can write native apps in HTML and JavaScript with NW.js. It also lets you call Node.js modules directly from the DOM and enables a new way of writing native applications with all Web technologies. [PM2](https://pm2.io/) is a production process manager for Node.js applications with a built-in load balancer. It allows you to keep applications alive forever, to reload them without downtime and to facilitate common system admin tasks. [NestJS](https://nestjs.com/) is a framework for building efficient, scalable Node.js web applications. It uses modern JavaScript, is built with TypeScript and combines elements of OOP (Object Oriented Progamming), FP (Functional Programming), and FRP (Functional Reactive Programming). [jenkins-nodejs](https://plugins.jenkins.io/nodejs/) is a Jenkins plugin for Node.js that provides the NodeJS auto-installer, allowing to create as many NodeJS installations "profiles" as you want. [Strapi](https://strapi.io/) is an open source Node.js Headless CMS to easily build customisable APIs. [Standard](https://standardjs.com/) is a JavaScript Style Guide, with linter & automatic code fixer. [React Starter Kit](https://www.reactstarterkit.com/) is an isomorphic web app boilerplate for web development built on top of [Node.js](https://nodejs.org/), [Express](http://expressjs.com/), [GraphQL](http://graphql.org/) and [React](https://facebook.github.io/react/), containing modern web development tools such as [Webpack](https://webpack.github.io/), [Babel](https://babeljs.io/) and [Browsersync](https://www.browsersync.io/). Helping you to stay productive following the best practices. [Hexo](https://hexo.io/) is a A fast, simple & powerful blog framework, powered by Node.js. # C/C++ Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/115297894-961e0d80-a111-11eb-81c3-e2bd2ac9a7cd.png"> <br /> </p> **[AWS SDK for C++](https://aws.amazon.com/sdk-for-cpp/)** ## C/C++ Learning Resources [C++](https://www.cplusplus.com/doc/tutorial/) is a cross-platform language that can be used to build high-performance applications developed by Bjarne Stroustrup, as an extension to the C language. [C](https://www.iso.org/standard/74528.html) is a general-purpose, high-level language that was originally developed by Dennis M. Ritchie to develop the UNIX operating system at Bell Labs. It supports structured programming, lexical variable scope, and recursion, with a static type system. C also provides constructs that map efficiently to typical machine instructions, which makes it one was of the most widely used programming languages today. [Embedded C](https://en.wikipedia.org/wiki/Embedded_C) is a set of language extensions for the C programming language by the [C Standards Committee](https://isocpp.org/std/the-committee) to address issues that exist between C extensions for different [embedded systems](https://en.wikipedia.org/wiki/Embedded_system). The extensions hep enhance microprocessor features such as fixed-point arithmetic, multiple distinct memory banks, and basic I/O operations. This makes Embedded C the most popular embedded software language in the world. [C & C++ Developer Tools from JetBrains](https://www.jetbrains.com/cpp/) [Open source C++ libraries on cppreference.com](https://en.cppreference.com/w/cpp/links/libs) [C++ Graphics libraries](https://cpp.libhunt.com/libs/graphics) [C++ Libraries in MATLAB](https://www.mathworks.com/help/matlab/call-cpp-library-functions.html) [C++ Tools and Libraries Articles](https://www.cplusplus.com/articles/tools/) [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) [Introduction C++ Education course on Google Developers](https://developers.google.com/edu/c++/) [C++ style guide for Fuchsia](https://fuchsia.dev/fuchsia-src/development/languages/c-cpp/cpp-style) [C and C++ Coding Style Guide by OpenTitan](https://docs.opentitan.org/doc/rm/c_cpp_coding_style/) [Chromium C++ Style Guide](https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md) [C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md) [C++ Style Guide for ROS](http://wiki.ros.org/CppStyleGuide) [Learn C++](https://www.learncpp.com/) [Learn C : An Interactive C Tutorial](https://www.learn-c.org/) [C++ Institute](https://cppinstitute.org/free-c-and-c-courses) [C++ Online Training Courses on LinkedIn Learning](https://www.linkedin.com/learning/topics/c-plus-plus) [C++ Tutorials on W3Schools](https://www.w3schools.com/cpp/default.asp) [Learn C Programming Online Courses on edX](https://www.edx.org/learn/c-programming) [Learn C++ with Online Courses on edX](https://www.edx.org/learn/c-plus-plus) [Learn C++ on Codecademy](https://www.codecademy.com/learn/learn-c-plus-plus) [Coding for Everyone: C and C++ course on Coursera](https://www.coursera.org/specializations/coding-for-everyone) [C++ For C Programmers on Coursera](https://www.coursera.org/learn/c-plus-plus-a) [Top C Courses on Coursera](https://www.coursera.org/courses?query=c%20programming) [C++ Online Courses on Udemy](https://www.udemy.com/topic/c-plus-plus/) [Top C Courses on Udemy](https://www.udemy.com/topic/c-programming/) [C++ For Programmers Course on Udacity](https://www.udacity.com/course/c-for-programmers--ud210) [C++ Fundamentals Course on Pluralsight](https://www.pluralsight.com/courses/learn-program-cplusplus) [Introduction to C++ on MIT Free Online Course Materials](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-096-introduction-to-c-january-iap-2011/) [Introduction to C++ for Programmers | Harvard ](https://online-learning.harvard.edu/course/introduction-c-programmers) [Online C Courses | Harvard University](https://online-learning.harvard.edu/subject/c) ## C/C++ Tools [Visual Studio](https://visualstudio.microsoft.com/) is an integrated development environment (IDE) from Microsoft; which is a feature-rich application that can be used for many aspects of software development. Visual Studio makes it easy to edit, debug, build, and publish your app. By using Microsoft software development platforms such as Windows API, Windows Forms, Windows Presentation Foundation, and Windows Store. [Visual Studio Code](https://code.visualstudio.com/) is a code editor redefined and optimized for building and debugging modern web and cloud applications. [Vcpkg](https://github.com/microsoft/vcpkg) is a C++ Library Manager for Windows, Linux, and MacOS. [ReSharper C++](https://www.jetbrains.com/resharper-cpp/features/) is a Visual Studio Extension for C++ developers developed by JetBrains. [AppCode](https://www.jetbrains.com/objc/) is constantly monitoring the quality of your code. It warns you of errors and smells and suggests quick-fixes to resolve them automatically. AppCode provides lots of code inspections for Objective-C, Swift, C/C++, and a number of code inspections for other supported languages. All code inspections are run on the fly. [CLion](https://www.jetbrains.com/clion/features/) is a cross-platform IDE for C and C++ developers developed by JetBrains. [Code::Blocks](https://www.codeblocks.org/) is a free C/C++ and Fortran IDE built to meet the most demanding needs of its users. It is designed to be very extensible and fully configurable. Built around a plugin framework, Code::Blocks can be extended with plugins. [CppSharp](https://github.com/mono/CppSharp) is a tool and set of libraries which facilitates the usage of native C/C++ code with the .NET ecosystem. It consumes C/C++ header and library files and generates the necessary glue code to surface the native API as a managed API. Such an API can be used to consume an existing native library in your managed code or add managed scripting support to a native codebase. [Conan](https://conan.io/) is an Open Source Package Manager for C++ development and dependency management into the 21st century and on par with the other development ecosystems. [High Performance Computing (HPC) SDK](https://developer.nvidia.com/hpc) is a comprehensive toolbox for GPU accelerating HPC modeling and simulation applications. It includes the C, C++, and Fortran compilers, libraries, and analysis tools necessary for developing HPC applications on the NVIDIA platform. [Thrust](https://github.com/NVIDIA/thrust) is a C++ parallel programming library which resembles the C++ Standard Library. Thrust's high-level interface greatly enhances programmer productivity while enabling performance portability between GPUs and multicore CPUs. Interoperability with established technologies such as CUDA, TBB, and OpenMP integrates with existing software. [Boost](https://www.boost.org/) is an educational opportunity focused on cutting-edge C++. Boost has been a participant in the annual Google Summer of Code since 2007, in which students develop their skills by working on Boost Library development. [Automake](https://www.gnu.org/software/automake/) is a tool for automatically generating Makefile.in files compliant with the GNU Coding Standards. Automake requires the use of GNU Autoconf. [Cmake](https://cmake.org/) is an open-source, cross-platform family of tools designed to build, test and package software. CMake is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of your choice. [GDB](http://www.gnu.org/software/gdb/) is a debugger, that allows you to see what is going on `inside' another program while it executes or what another program was doing at the moment it crashed. [GCC](https://gcc.gnu.org/) is a compiler Collection that includes front ends for C, C++, Objective-C, Fortran, Ada, Go, and D, as well as libraries for these languages. [GSL](https://www.gnu.org/software/gsl/) is a numerical library for C and C++ programmers. It is free software under the GNU General Public License. The library provides a wide range of mathematical routines such as random number generators, special functions and least-squares fitting. There are over 1000 functions in total with an extensive test suite. [OpenGL Extension Wrangler Library (GLEW)](https://www.opengl.org/sdk/libs/GLEW/) is a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. [Libtool](https://www.gnu.org/software/libtool/) is a generic library support script that hides the complexity of using shared libraries behind a consistent, portable interface. To use Libtool, add the new generic library building commands to your Makefile, Makefile.in, or Makefile.am. [Maven](https://maven.apache.org/) is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information. [TAU (Tuning And Analysis Utilities)](http://www.cs.uoregon.edu/research/tau/home.php) is capable of gathering performance information through instrumentation of functions, methods, basic blocks, and statements as well as event-based sampling. All C++ language features are supported including templates and namespaces. [Clang](https://clang.llvm.org/) is a production quality C, Objective-C, C++ and Objective-C++ compiler when targeting X86-32, X86-64, and ARM (other targets may have caveats, but are usually easy to fix). Clang is used in production to build performance-critical software like Google Chrome or Firefox. [OpenCV](https://opencv.org/) is a highly optimized library with focus on real-time applications. Cross-Platform C++, Python and Java interfaces support Linux, MacOS, Windows, iOS, and Android. [Libcu++](https://nvidia.github.io/libcudacxx) is the NVIDIA C++ Standard Library for your entire system. It provides a heterogeneous implementation of the C++ Standard Library that can be used in and between CPU and GPU code. [ANTLR (ANother Tool for Language Recognition)](https://www.antlr.org/) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build parse trees and also generates a listener interface that makes it easy to respond to the recognition of phrases of interest. [Oat++](https://oatpp.io/) is a light and powerful C++ web framework for highly scalable and resource-efficient web application. It's zero-dependency and easy-portable. [JavaCPP](https://github.com/bytedeco/javacpp) is a program that provides efficient access to native C++ inside Java, not unlike the way some C/C++ compilers interact with assembly language. [Cython](https://cython.org/) is a language that makes writing C extensions for Python as easy as Python itself. Cython is based on Pyrex, but supports more cutting edge functionality and optimizations such as calling C functions and declaring C types on variables and class attributes. [Spdlog](https://github.com/gabime/spdlog) is a very fast, header-only/compiled, C++ logging library. [Infer](https://fbinfer.com/) is a static analysis tool for Java, C++, Objective-C, and C. Infer is written in [OCaml](https://ocaml.org/). # Java Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93925952-c0b6fd80-fccb-11ea-9f90-21c4148e3c86.png"> <br /> </p> **[Start building with Java on AWS](https://aws.amazon.com/sdk-for-java/)** **[Start building with Java on AWS IoT](https://github.com/aws/aws-iot-device-sdk-java/blob/master/README.md)** ## Java Learning Resources [Java](https://www.oracle.com/java/) is a popular programming language and development platform(JDK). It reduces costs, shortens development timeframes, drives innovation, and improves application services. With millions of developers running more than 51 billion Java Virtual Machines worldwide. [The Eclipse Foundation](https://www.eclipse.org/downloads/) is home to a worldwide community of developers, the Eclipse IDE, Jakarta EE and over 375 open source projects, including runtimes, tools and frameworks for Java and other languages. [Getting Started with Java](https://docs.oracle.com/javase/tutorial/) [Oracle Java certifications from Oracle University](https://education.oracle.com/java-certification-benefits) [Google Developers Training](https://developers.google.com/training/) [Google Developers Certification](https://developers.google.com/certification/) [Java Tutorial by W3Schools](https://www.w3schools.com/java/) [Building Your First Android App in Java](codelabs.developers.google.com/codelabs/build-your-first-android-app/) [Getting Started with Java in Visual Studio Code](https://code.visualstudio.com/docs/java/java-tutorial) [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html) [AOSP Java Code Style for Contributors](https://source.android.com/setup/contribute/code-style) [Chromium Java style guide](https://chromium.googlesource.com/chromium/src/+/master/styleguide/java/java.md) [Get Started with OR-Tools for Java](https://developers.google.com/optimization/introduction/java) [Getting started with Java Tool Installer task for Azure Pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/tool/java-tool-installer) [Gradle User Manual](https://docs.gradle.org/current/userguide/userguide.html) ## Tools [Java SE](https://www.oracle.com/java/technologies/javase/tools-jsp.html) contains several tools to assist in program development and debugging, and in the monitoring and troubleshooting of production applications. [JDK Development Tools](https://docs.oracle.com/javase/7/docs/technotes/tools/) includes the Java Web Start Tools (javaws) Java Troubleshooting, Profiling, Monitoring and Management Tools (jcmd, jconsole, jmc, jvisualvm); and Java Web Services Tools (schemagen, wsgen, wsimport, xjc). [Android Studio](https://developer.android.com/studio/) is the official integrated development environment for Google's Android operating system, built on JetBrains' IntelliJ IDEA software and designed specifically for Android development. Availble on Windows, macOS, Linux, Chrome OS. [IntelliJ IDEA](https://www.jetbrains.com/idea/) is an IDE for Java, but it also understands and provides intelligent coding assistance for a large variety of other languages such as Kotlin, SQL, JPQL, HTML, JavaScript, etc., even if the language expression is injected into a String literal in your Java code. [NetBeans](https://netbeans.org/features/java/index.html) is an IDE provides Java developers with all the tools needed to create professional desktop, mobile and enterprise applications. Creating, Editing, and Refactoring. The IDE provides wizards and templates to let you create Java EE, Java SE, and Java ME applications. [Java Design Patterns ](https://github.com/iluwatar/java-design-patterns) is a collection of the best formalized practices a programmer can use to solve common problems when designing an application or system. [Elasticsearch](https://www.elastic.co/products/elasticsearch) is a distributed RESTful search engine built for the cloud written in Java. [RxJava](https://github.com/ReactiveX/RxJava) is a Java VM implementation of [Reactive Extensions](http://reactivex.io/): a library for composing asynchronous and event-based programs by using observable sequences. It extends the [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures. [Guava](https://github.com/google/guava) is a set of core Java libraries from Google that includes new collection types (such as multimap and multiset), immutable collections, a graph library, and utilities for concurrency, I/O, hashing, caching, primitives, strings, and more! It is widely used on most Java projects within Google, and widely used by many other companies as well. [okhttp](https://square.github.io/okhttp/) is a HTTP client for Java and Kotlin developed by Square. [Retrofit](https://square.github.io/retrofit/) is a type-safe HTTP client for Android and Java develped by Square. [LeakCanary](https://square.github.io/leakcanary/) is a memory leak detection library for Android develped by Square. [Apache Spark](https://spark.apache.org/) is a unified analytics engine for large-scale data processing. It provides high-level APIs in Scala, Java, Python, and R, and an optimized engine that supports general computation graphs for data analysis. It also supports a rich set of higher-level tools including Spark SQL for SQL and DataFrames, MLlib for machine learning, GraphX for graph processing, and Structured Streaming for stream processing. [Apache Flink](https://flink.apache.org/) is an open source stream processing framework with powerful stream- and batch-processing capabilities with elegant and fluent APIs in Java and Scala. [Fastjson](https://github.com/alibaba/fastjson/wiki) is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. [libGDX](https://libgdx.com/) is a cross-platform Java game development framework based on OpenGL (ES) that works on Windows, Linux, Mac OS X, Android, your WebGL enabled browser and iOS. [Jenkins](https://www.jenkins.io/) is the leading open-source automation server. Built with Java, it provides over 1700 [plugins](https://plugins.jenkins.io/) to support automating virtually anything, so that humans can actually spend their time doing things machines cannot. [DBeaver](https://dbeaver.io/) is a free multi-platform database tool for developers, SQL programmers, database administrators and analysts. Supports any database which has JDBC driver (which basically means - ANY database). EE version also supports non-JDBC datasources (MongoDB, Cassandra, Redis, DynamoDB, etc). [Redisson](https://redisson.pro/) is a Redis Java client with features of In-Memory Data Grid. Over 50 Redis based Java objects and services: Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Publish / Subscribe, Bloom filter, Spring Cache, Tomcat, Scheduler, JCache API, Hibernate, MyBatis, RPC, and local cache. [GraalVM](https://www.graalvm.org/) is a universal virtual machine for running applications written in JavaScript, Python, Ruby, R, JVM-based languages like Java, Scala, Clojure, Kotlin, and LLVM-based languages such as C and C++. [Gradle](https://gradle.org/) is a build automation tool for multi-language software development. From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster. Write in Java, C++, Python or your language of choice. [Apache Groovy](http://www.groovy-lang.org/) is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities, for the Java platform aimed at improving developer productivity thanks to a concise, familiar and easy to learn syntax. It integrates smoothly with any Java program, and immediately delivers to your application powerful features, including scripting capabilities, Domain-Specific Language authoring, runtime and compile-time meta-programming and functional programming. [JaCoCo](https://www.jacoco.org/jacoco/) is a free code coverage library for Java, which has been created by the EclEmma team based on the lessons learned from using and integration existing libraries for many years. [Apache JMeter](http://jmeter.apache.org/) is used to test performance both on static and dynamic resources, Web dynamic applications. It also used to simulate a heavy load on a server, group of servers, network or object to test its strength or to analyze overall performance under different load types. [Junit](https://junit.org/) is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks. [Mockito](https://site.mockito.org/) is the most popular Mocking framework for unit tests written in Java. [SpotBugs](https://spotbugs.github.io/) is a program which uses static analysis to look for bugs in Java code. [SpringBoot](https://spring.io/projects/spring-boot) is a great tool that helps you to create Spring-powered, production-grade applications and services with absolute minimum fuss. It takes an opinionated view of the Spring platform so that new and existing users can quickly get to the bits they need. [YourKit](https://www.yourkit.com/) is a technology leader, creator of the most innovative and intelligent tools for profiling Java & .NET applications. # Go Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93719679-068f8c80-fb39-11ea-8baa-9e779ee58a0a.png"> <br /> </p> **[Start building with Go on AWS](https://aws.amazon.com/sdk-for-go/)** ## Go Learning Resources [Go](https://golang.org/) is an open source programming language that makes it easy to build simple, reliable, and efficient software. [Golang Contribution Guide](https://golang.org/doc/contribute.html) [Google Developers Training](https://developers.google.com/training/) [Google Developers Certification](https://developers.google.com/certification/) [Uber's Go Style Guide](https://github.com/uber-go/guide/blob/master/style.md) [GitLab's Go standards and style guidelines](https://docs.gitlab.com/ee/development/go_guide/) [Effective Go](https://golang.org/doc/effective_go.html) [Go: The Complete Developer's Guide (Golang) on Udemy](https://www.udemy.com/course/go-the-complete-developers-guide/) [Getting Started with Go on Coursera](https://www.coursera.org/learn/golang-getting-started) [Programming with Google Go on Coursera](https://www.coursera.org/specializations/google-golang) [Learning Go Fundamentals on Pluralsight](https://www.pluralsight.com/courses/go-fundamentals) [Learning Go on Codecademy](https://www.codecademy.com/learn/learn-go) ## Go Tools [golang tools](https://pkg.go.dev/golang.org/x/tools) holds the source for various packages and tools that support the Go programming language. [Go in Visual Studio Code](https://code.visualstudio.com/docs/languages/go) is an extension that gives you language features like IntelliSense, code navigation, symbol search, bracket matching, snippets, and many more that will help you in Golang development. [Traefik](https://github.com/traefik/traefik) is a modern HTTP reverse proxy and load balancer that makes deploying microservices easy. Traefik integrates with your existing infrastructure components (Docker, Swarm mode, Kubernetes, Marathon, Consul, Etcd, Rancher, Amazon ECS, etc.) and configures itself automatically and dynamically. Pointing Traefik at your orchestrator should be the only configuration step you need. [Gitea](https://github.com/go-gitea/gitea) is Git with a cup of tea, painless self-hosted git service. Using Go, this can be done with an independent binary distribution across all platforms which Go supports, including Linux, macOS, and Windows on x86, amd64, ARM and PowerPC architectures. [OpenFaaS](https://github.com/openfaas/faas) is Serverless Functions Made Simple. It makes it easy for developers to deploy event-driven functions and microservices to Kubernetes without repetitive, boiler-plate coding. Package your code or an existing binary in a Docker image to get a highly scalable endpoint with auto-scaling and metrics. [micro](https://github.com/zyedidia/micro) is a terminal-based text editor that aims to be easy to use and intuitive, while also taking advantage of the capabilities of modern terminals. As its name indicates, micro aims to be somewhat of a successor to the nano editor by being easy to install and use. It strives to be enjoyable as a full-time editor for people who prefer to work in a terminal, or those who regularly edit files over SSH. [Gravitational Teleport](https://github.com/gravitational/teleport) is a modern security gateway for remotely accessing into Clusters of Linux servers via SSH or SSH-over-HTTPS in a browser or Kubernetes clusters. [NATS](https://nats.io/) is a simple, secure and performant communications system for digital systems, services and devices. NATS is part of the Cloud Native Computing Foundation (CNCF). NATS has over 30 client language implementations, and its server can run on-premise, in the cloud, at the edge, and even on a Raspberry Pi. NATS can secure and simplify design and operation of modern distributed systems. [Act](https://github.com/nektos/act) is a GO program that allows you to run our GitHub Actions locally. [Fiber](https://gofiber.io/) is an [Express](https://github.com/expressjs/express) inspired web framework built on top of [Fasthttp](https://github.com/valyala/fasthttp), the fastest HTTP engine for Go. Designed to ease things up for fast development with zero memory allocation and performance in mind. [Glide](https://github.com/Masterminds/glide) is a vendor Package Management for Golang. [BadgerDB](https://github.com/dgraph-io/badger) is an embeddable, persistent and fast key-value (KV) database written in pure Go. It is the underlying database for [Dgraph](https://dgraph.io/), a fast, distributed graph database. It's meant to be a performant alternative to non-Go-based key-value stores like RocksDB. [Go kit](https://github.com/go-kit/kit) is a programming toolkit for building microservices (or elegant monoliths) in Go. We solve common problems in distributed systems and application architecture so you can focus on delivering business value. [Codis](https://github.com/CodisLabs/codis) is a proxy based high performance Redis cluster solution written in Go. [zap](https://github.com/uber-go/zap) is a blazing fast, structured, leveled logging in Go. [HttpRouter](https://github.com/julienschmidt/httprouter) is a lightweight high performance HTTP request router (also called multiplexer or just mux for short) for Go. [Gorilla WebSocket](https://github.com/gorilla/websocket) is a Go implementation of the WebSocket protocol. [Delve](https://github.com/go-delve/delve) is a debugger for the Go programming language. [GORM](https://github.com/go-gorm/gorm) is a fantastic ORM library for Golang, aims to be developer friendly. [Go Patterns](https://github.com/tmrts/go-patterns) is a curated collection of idiomatic design & application patterns for Go language. # Python Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93133273-ce490380-f68b-11ea-81d0-7f6a3debe6c0.png"> <br /> </p> **[Start building with Python on AWS](https://aws.amazon.com/sdk-for-python/)** **[Start building with Python on AWS IoT](https://github.com/aws/aws-iot-device-sdk-python/blob/master/README.rst)** ## Python Learning Resources [Python](https://www.python.org) is an interpreted, high-level programming language. Python is used heavily in the fields of Data Science and Machine Learning. [Python Developer’s Guide](https://devguide.python.org) is a comprehensive resource for contributing to Python – for both new and experienced contributors. It is maintained by the same community that maintains Python. [Azure Functions Python developer guide](https://docs.microsoft.com/en-us/azure/azure-functions/functions-reference-python) is an introduction to developing Azure Functions using Python. The content below assumes that you've already read the [Azure Functions developers guide](https://docs.microsoft.com/en-us/azure/azure-functions/functions-reference). [CheckiO](https://checkio.org/) is a programming learning platform and a gamified website that teaches Python through solving code challenges and competing for the most elegant and creative solutions. [Python Institute](https://pythoninstitute.org) [PCEP – Certified Entry-Level Python Programmer certification](https://pythoninstitute.org/pcep-certification-entry-level/) [PCAP – Certified Associate in Python Programming certification](https://pythoninstitute.org/pcap-certification-associate/) [PCPP – Certified Professional in Python Programming 1 certification](https://pythoninstitute.org/pcpp-certification-professional/) [PCPP – Certified Professional in Python Programming 2](https://pythoninstitute.org/pcpp-certification-professional/) [MTA: Introduction to Programming Using Python Certification](https://docs.microsoft.com/en-us/learn/certifications/mta-introduction-to-programming-using-python) [Getting Started with Python in Visual Studio Code](https://code.visualstudio.com/docs/python/python-tutorial) [Google's Python Style Guide](https://google.github.io/styleguide/pyguide.html) [Google's Python Education Class](https://developers.google.com/edu/python/) [Real Python](https://realpython.com) [The Python Open Source Computer Science Degree by Forrest Knight](https://github.com/ForrestKnight/open-source-cs-python) [Intro to Python for Data Science](https://www.datacamp.com/courses/intro-to-python-for-data-science) [Intro to Python by W3schools](https://www.w3schools.com/python/python_intro.asp) [Codecademy's Python 3 course](https://www.codecademy.com/learn/learn-python-3) [Learn Python with Online Courses and Classes from edX](https://www.edx.org/learn/python) [Python Courses Online from Coursera](https://www.coursera.org/courses?query=python) ## Python Frameworks and Tools [Python Package Index (PyPI)](https://pypi.org/) is a repository of software for the Python programming language. PyPI helps you find and install software developed and shared by the Python community. [PyCharm](https://www.jetbrains.com/pycharm/) is the best IDE I've ever used. With PyCharm, you can access the command line, connect to a database, create a virtual environment, and manage your version control system all in one place, saving time by avoiding constantly switching between windows. [Python Tools for Visual Studio(PTVS)](https://microsoft.github.io/PTVS/) is a free, open source plugin that turns Visual Studio into a Python IDE. It supports editing, browsing, IntelliSense, mixed Python/C++ debugging, remote Linux/MacOS debugging, profiling, IPython, and web development with Django and other frameworks. [Pylance](https://github.com/microsoft/pylance-release) is an extension that works alongside Python in Visual Studio Code to provide performant language support. Under the hood, Pylance is powered by Pyright, Microsoft's static type checking tool. [Pyright](https://github.com/Microsoft/pyright) is a fast type checker meant for large Python source bases. It can run in a “watch” mode and performs fast incremental updates when files are modified. [Django](https://www.djangoproject.com/) is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. [Flask](https://flask.palletsprojects.com/) is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries. [Web2py](http://web2py.com/) is an open-source web application framework written in Python allowing allows web developers to program dynamic web content. One web2py instance can run multiple web sites using different databases. [AWS Chalice](https://github.com/aws/chalice) is a framework for writing serverless apps in python. It allows you to quickly create and deploy applications that use AWS Lambda. [Tornado](https://www.tornadoweb.org/) is a Python web framework and asynchronous networking library. Tornado uses a non-blocking network I/O, which can scale to tens of thousands of open connections. [HTTPie](https://github.com/httpie/httpie) is a command line HTTP client that makes CLI interaction with web services as easy as possible. HTTPie is designed for testing, debugging, and generally interacting with APIs & HTTP servers. [Scrapy](https://scrapy.org/) is a fast high-level web crawling and web scraping framework, used to crawl websites and extract structured data from their pages. It can be used for a wide range of purposes, from data mining to monitoring and automated testing. [Sentry](https://sentry.io/) is a service that helps you monitor and fix crashes in realtime. The server is in Python, but it contains a full API for sending events from any language, in any application. [Pipenv](https://github.com/pypa/pipenv) is a tool that aims to bring the best of all packaging worlds (bundler, composer, npm, cargo, yarn, etc.) to the Python world. [Python Fire](https://github.com/google/python-fire) is a library for automatically generating command line interfaces (CLIs) from absolutely any Python object. [Bottle](https://github.com/bottlepy/bottle) is a fast, simple and lightweight [WSGI](https://www.wsgi.org/) micro web-framework for Python. It is distributed as a single file module and has no dependencies other than the [Python Standard Library](https://docs.python.org/library/). [CherryPy](https://cherrypy.org) is a minimalist Python object-oriented HTTP web framework. [Sanic](https://github.com/huge-success/sanic) is a Python 3.6+ web server and web framework that's written to go fast. [Pyramid](https://trypyramid.com) is a small and fast open source Python web framework. It makes real-world web application development and deployment more fun and more productive. [TurboGears](https://turbogears.org) is a hybrid web framework able to act both as a Full Stack framework or as a Microframework. [Falcon](https://falconframework.org/) is a reliable, high-performance Python web framework for building large-scale app backends and microservices with support for MongoDB, Pluggable Applications and autogenerated Admin. [Neural Network Intelligence(NNI)](https://github.com/microsoft/nni) is an open source AutoML toolkit for automate machine learning lifecycle, including [Feature Engineering](https://github.com/microsoft/nni/blob/master/docs/en_US/FeatureEngineering/Overview.md), [Neural Architecture Search](https://github.com/microsoft/nni/blob/master/docs/en_US/NAS/Overview.md), [Model Compression](https://github.com/microsoft/nni/blob/master/docs/en_US/Compressor/Overview.md) and [Hyperparameter Tuning](https://github.com/microsoft/nni/blob/master/docs/en_US/Tuner/BuiltinTuner.md). [Dash](https://plotly.com/dash) is a popular Python framework for building ML & data science web apps for Python, R, Julia, and Jupyter. [Luigi](https://github.com/spotify/luigi) is a Python module that helps you build complex pipelines of batch jobs. It handles dependency resolution, workflow management, visualization etc. It also comes with Hadoop support built-in. [Locust](https://github.com/locustio/locust) is an easy to use, scriptable and scalable performance testing tool. [spaCy](https://github.com/explosion/spaCy) is a library for advanced Natural Language Processing in Python and Cython. [NumPy](https://www.numpy.org/) is the fundamental package needed for scientific computing with Python. [Pillow](https://python-pillow.org/) is a friendly PIL(Python Imaging Library) fork. [IPython](https://ipython.org/) is a command shell for interactive computing in multiple programming languages, originally developed for the Python programming language, that offers enhanced introspection, rich media, additional shell syntax, tab completion, and rich history. [GraphLab Create](https://turi.com/) is a Python library, backed by a C++ engine, for quickly building large-scale, high-performance machine learning models. [Pandas](https://pandas.pydata.org/) is a fast, powerful, and easy to use open source data structrures, data analysis and manipulation tool, built on top of the Python programming language. [PuLP](https://coin-or.github.io/pulp/) is an Linear Programming modeler written in python. PuLP can generate LP files and call on use highly optimized solvers, GLPK, COIN CLP/CBC, CPLEX, and GUROBI, to solve these linear problems. [Matplotlib](https://matplotlib.org/) is a 2D plotting library for creating static, animated, and interactive visualizations in Python. Matplotlib produces publication-quality figures in a variety of hardcopy formats and interactive environments across platforms. [Scikit-Learn](https://scikit-learn.org/stable/index.html) is a simple and efficient tool for data mining and data analysis. It is built on NumPy,SciPy, and mathplotlib. # TypeScript Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93133287-d1dc8a80-f68b-11ea-94d3-bba83dd5b0bb.png"> <br /> </p> **[Start building with TypeScript on AWS](https://aws.amazon.com/sdk-for-browser/)** **[Start building with TypeScript on AWS Mobile](https://aws-amplify.github.io/amplify-js/media/quick_start)** **[Start building with TypeScript on AWS IoT](https://github.com/aws/aws-iot-device-sdk-js/blob/master/README.md)** ## TypeScript Learning Resources [TypeScript](https://www.typescriptlang.org) is a language for application-scale JavaScript. TypeScript adds optional types to JavaScript that support tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. [TypeScript support for Webpack](https://webpack.js.org/guides/typescript/) [TypeScript Support for Nuxt.js](https://typescript.nuxtjs.org) [TypeScript Support for Vue.js](https://vuejs.org/v2/guide/typescript.html) [TypeScript Support for React Native](https://reactnative.dev/docs/typescript) [TypeScript Support for Angular](https://angular.io/guide/typescript-configuration) [Ionic/TypeScript Starter Project](http://justin-credible.github.io/Ionic-TypeScript-Starter/) [GitHub Actions for JavaScript and TypeScript](https://docs.github.com/en/actions/language-and-framework-guides/github-actions-for-javascript-and-typescript) ## Tools [WebStorm](https://www.jetbrains.com/webstorm/) is a professional IDE for JavaScript(including support for both HTML and CSS) developed by JetBrains. WebStorm comes with intelligent code completion, on-the-fly error detection, powerful navigation and refactoring for JavaScript, TypeScript, stylesheet languages, and all the most popular frameworks([Angular](https://angular.io/), [React](https://reactjs.org/), [Vue.js](https://vuejs.org/), [Ionic](https://ionicframework.com/), [Apache Cordova](https://cordova.apache.org/), [React Native](https://reactnative.dev/), [Node.js](https://nodejs.org/), [Meteor](https://www.meteor.com/#!), and [Electron](https://www.electronjs.org/)). [ReSharper](https://www.jetbrains.com/resharper/) is a Visual Studio Extension for .NET Developers. It comes with code quality analysis, which is available in C#, VB.NET, XAML, ASP.NET, ASP.NET MVC, JavaScript, TypeScript, CSS, HTML, and XML. You'll know right away if your code needs to be improved. ReSharper is one of many powerful tools developed by [JetBrains](https://www.jetbrains.com). [ts-migrate](https://github.com/airbnb/ts-migrate) is a tool for helping migrate code to TypeScript. It takes a JavaScript, or a partial TypeScript, project in and gives a compiling TypeScript project out. ts-migrate is intended to accelerate the TypeScript migration process. The resulting code will pass the build, but a followup is required to improve type safety. [Deno](https://deno.land) is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. [gulp-typescript](https://github.com/ivogabe/gulp-typescript) is an TypeScript compiler for gulp with incremental compilation support. [React](https://reactjs.org/) is a declarative, efficient, and flexible JavaScript library for building user interfaces. [React Native](https://reactnative.dev) is a framework for building native apps for iOS and Android with React. [Vue.js](http://vuejs.org/) is a progressive, incrementally-adoptable JavaScript framework for building UI on the web. [Angular](https://www.angular.io/) is a development platform for building mobile and desktop web applications using Typescript/JavaScript and other languages. [Ionic Framework](https://ionicframework.com/) is a powerful cross-platform UI toolkit for building native-quality iOS, Android, and Progressive Web Apps with HTML, CSS, and JavaScript. [Stencil](https://stenciljs.com/) is a simple compiler for generating Web Components and static site generated progressive web apps (PWA). Stencil was built by the Ionic team for its next generation of performant mobile and desktop Web Components. [Storybook](https://storybook.js.org/) is a development environment for UI components. It allows you to browse a component library, view the different states of each component, and interactively develop and test components.It works with React, Vue, Angular, Ember, and other web frameworks. [Prettier](https://prettier.io/) is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary. [Nest](https://nestjs.com/) is a framework for building efficient, scalable [Node.js](http://nodejs.org/) server-side applications. It is built with TypeScript and combines elements of Object Oriented Programming(OOP), Functional Programming, and Functional Reactive Programming(FRP). [Definitely Typed](https://github.com/DefinitelyTyped/DefinitelyTyped) is a repository for high quality TypeScript type definitions. [TypeORM](https://github.com/typeorm/typeorm) is an ORM that can run in NodeJS, Browser, Cordova, PhoneGap, Ionic, React Native, NativeScript, Expo, and Electron platforms and can be used with TypeScript and JavaScript (ES5, ES6, ES7, ES8). [NativeScript](https://www.nativescript.org/) empowers you to access native APIs from JavaScript directly. The framework currently provides iOS and Android runtimes for rich mobile development and can be utilized in a number of diverse use cases. [AssemblyScript](https://assemblyscript.org/) compiles a strict variant of TypeScript to [WebAssembly](http://webassembly.org/) using [Binaryen](https://github.com/WebAssembly/binaryen). [React Hook Form](https://react-hook-form.com/) is a performant, flexible and extensible forms with easy to use validation(Web + React Native). [Apollo Client](https://apollographql.com/client) is a fully-featured caching GraphQL client with integrations for React, Angular, and more. It allows you to easily build UI components that fetch data via GraphQL. [TensorFlow.js](https://js.tensorflow.org/) is an open-source WebGL hardware-accelerated JavaScript library for training and deploying machine learning models. [Rome](https://romefrontend.dev/) is a linter, compiler, bundler, and [more](https://romefrontend.dev/#development-status) for JavaScript, TypeScript, JSON, HTML, Markdown, and CSS. [Eclipse Theia](https://github.com/eclipse-theia/theia) is an extensible platform to develop full-fledged multi-language Cloud & Desktop IDE-like products with state-of-the-art web technologies. [InversifyJS](https://github.com/inversify/InversifyJS) is a powerful and lightweight inversion of control(IoC) container for JavaScript & Node.js apps powered by TypeScript. An IoC container uses a class constructor to identify and inject its dependencies. [Gatsby](https://www.gatsbyjs.com/) is a free and open source framework based on React that helps developers build blazing fast websites and apps. [Meteor](https://www.meteor.com/) is an ultra-simple environment for building modern web applications with JavavScript. [TypeScript ESLint](https://typescript-eslint.io/) is a monorepo for all the tooling which enables ESLint to support TypeScript. [TS node](https://github.com/TypeStrong/ts-node) is a TypeScript execution and REPL for node.js. # .NET Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93719689-0d1e0400-fb39-11ea-82e5-331a8ff8060d.png"> </p> **[Start building with .NET on AWS](https://aws.amazon.com/sdk-for-net/)** **[Start building with .NET on AWS Unity Mobile](http://docs.aws.amazon.com/mobile/sdkforunity/developerguide/what-is-unity-plugin.html)** **[Start building with .NET on AWS Xamarin Mobile](https://docs.aws.amazon.com/mobile/sdkforxamarin/developerguide/Welcome.html)** **[Start building with .NET on AWS Tolkit for Azure DevOps](https://aws.amazon.com/vsts/)** ## .NET Learning Resources [.NET](https://dotnet.microsoft.com/learn/dotnet/what-is-dotnet) is a developer platform with tools and libraries for building any type of app, including web, mobile, desktop, games, IoT, cloud, and microservices. [.NET documentation](https://docs.microsoft.com/en-us/dotnet/fundamentals/) [Getting started with .NET](https://docs.microsoft.com/en-us/dotnet/standard/get-started) [.NET Application Architecture Guide](https://dotnet.microsoft.com/learn/dotnet/architecture-guides) [Intro .NET Guide by JetBrains ](https://blog.jetbrains.com/dotnet/2020/07/09/introducing-the-net-guide-tutorials-and-tips-tricks-for-net-rider-and-resharper/) [C# documentation](https://docs.microsoft.com/en-us/dotnet/csharp/) write any application using the C# programming language on the .NET platform. ## Tools [.NET Core](https://docs.microsoft.com/en-us/dotnet/core/introduction) is a cross-platform .NET implementation for websites, servers, and console apps on Windows, Linux, and macOS.The .NET Framework supports websites, services, desktop apps, and more on Windows. Xamarin/Mono is a .NET implementation for running apps on all the major mobile operating systems. [.NET runtime](https://github.com/dotnet/runtime) is a collection of libraries and shared host (dotnet) installers for all supported platforms, as well as the sources to .NET runtime and libraries. [ASP.NET Core](https://asp.net/) is a cross-platform .NET framework for building modern cloud-based web applications on Windows, Mac, or Linux. [Mono](https://www.mono-project.com/) is a software platform designed to allow developers to easily create cross platform applications. It is an open source implementation of Microsoft's .NET Framework based on the ECMA standards for C# and the Common Language Runtime. [Visual Studio](https://visualstudio.microsoft.com/) is an integrated development environment (IDE) from Microsoft; which is a feature-rich application that can be used for many aspects of software development. Visual Studio makes it easy to edit, debug, build, and publish your app. By using Microsoft software development platforms such as Windows API, Windows Forms, Windows Presentation Foundation, and Windows Store. [Rider](https://www.jetbrains.com/rider/) is a fast and powerful, cross-platform .NET IDE devloped by JetBrains to develop .NET, ASP.NET, .NET Core, Xamarin; or Unity applications for Windows, Mac, Linux. [Resharper](https://www.jetbrains.com/resharper/) is a [Visual Studio](https://visualstudio.microsoft.com/) Extension for .NET Developers that has On-the-fly code quality analysis for C#, VB.NET, XAML, ASP.NET, ASP.NET MVC, JavaScript, TypeScript, CSS, HTML, and XML. Letting you know right away if your code needs to be improved. [dotTrace](https://www.jetbrains.com/profiler/) is an .NET performance Profiler developed by Jet Brains. It helps users locate performance bottlenecks in a variety of .NET applications: desktop applications, .NET Core, ASP.NET, ASP.NET Core applications hosted on IIS or IIS Express web servers, Silverlight, WCF services, Windows services, Universal Windows Platform applications, and unit tests. [dotMemory](https://www.jetbrains.com/dotmemory/) is an .NET memory Profiler developed by Jet Brains. It allows the user to analyze memory usage in a variety of .NET and .NET Core applications: desktop applications, Windows services, ASP.NET web applications, IIS, IIS Express, arbitrary .NET processes, and more. [dotCover](https://www.jetbrains.com/dotcover/) is an .NET unit test runner and code coverage tool developed by Jet Brains. It helps the user figure out on-the-fly which unit tests are affected by your latest code changes, and automatically re-runs the affected tests for you. The continuous testing mode can be switched on for any unit test session. [Avalonia](https://avaloniaui.net/) is a cross-platform XAML-based UI framework providing a flexible styling system and supporting a wide range of Operating Systems such as Windows via .NET Framework and .NET Core, Linux via Xorg, macOS. [Polly](https://github.com/App-vNext/Polly) is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. [IdentityServer](https://identityserver.io/) is a free, open source [OpenID Connect](https://openid.net/connect/) and [OAuth 2.0](https://tools.ietf.org/html/rfc6749) framework for ASP.NET Core. IdentityServer4 incorporates all the protocol implementations and extensibility points needed to integrate token-based authentication, single-sign-on and API access control in your applications. [ILSpy](https://github.com/icsharpcode/ILSpy) is the open-source .NET assembly browser and decompiler. [Hangfire](https://www.hangfire.io/) is an easy way to perform background job processing in your .NET and .NET Core applications with no Windows Service or Task Scheduler required. [React Native Windows](https://microsoft.github.io/react-native-windows/) is a ramework for building native Windows apps with React. [React Native](https://reactnative.dev/) is a framework developed by Facebook that enables you to build world-class application experiences on native platforms using a consistent developer experience based on JavaScript and React. [ReactiveUI](https://reactiveui.net/) is a composable, cross-platform model-view-viewmodel framework for all .NET platforms that is inspired by functional reactive programming, which is a paradigm that allows you to abstract mutable state away from your user interfaces and express the idea around a feature in one readable place and improve the testability of your application. [Refit](https://reactiveui.github.io/refit/) is the automatic type-safe REST library for .NET Core, Xamarin and .NET.It's heavily inspired by Square's Retrofit library, Refit turns your REST API into a live interface. [MAUI](https://github.com/dotnet/maui) is the .NET Multi-platform App UI, a framework for building native device applications spanning mobile, tablet, and desktop. [Quasar](https://github.com/quasar/Quasar) is a fast and light-weight remote administration tool coded in C#. The usage ranges from user support through day-to-day administrative work to employee monitoring. Providing high stability and an easy-to-use user interface, Quasar is the perfect remote administration solution for you. # Ruby Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93719684-07282300-fb39-11ea-98fd-90394a2df6f2.png"> <br /> </p> **[Start building with Ruby on AWS](https://aws.amazon.com/sdk-for-ruby/)** ## Ruby Learning Resources [Ruby](https://www.ruby-lang.org/en/) is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write. [Ruby Documentation](https://www.ruby-lang.org/en/documentation/) [Ruby Community](https://www.ruby-lang.org/en/community/) [Ruby Gems](https://guides.rubygems.org/rubygems-basics/) [Ruby courses by Coursera](https://www.coursera.org/courses?query=ruby) [Learn Ruby course by Codecademy](https://www.codecademy.com/learn/learn-ruby) [Ruby Glossary](https://www.codecademy.com/articles/glossary-ruby) [Ruby in Twenty Minutes Quickstart](https://www.ruby-lang.org/en/documentation/quickstart/) [Getting started with a Ruby on Rails application on CircleCI.](https://circleci.com/docs/2.0/language-ruby/) [The Ruby Style Guide](https://rubystyle.guide) [Airbnb's Ruby Style Guide](https://github.com/airbnb/ruby) ## Tools [RubyMine](https://www.jetbrains.com/ruby/) is a professional IDE developed by Jet Brains that provides support for Ruby, Ruby on Rails and web development. [Rails](https://rubyonrails.org/) is a web-application framework that includes everything needed to create database-backed web applications according to the [Model-View-Controller (MVC)](https://en.wikipedia.org/wiki/Model-view-controller) pattern. Understanding the MVC pattern is key to understanding Rails. MVC divides your application into three layers: Model, View, and Controller, each with a specific responsibility. [rbenv](https://github.com/rbenv/rbenv) allows to pick a Ruby version for your application and guarantee that your development environment matches production. Put rbenv to work with Bundler for painless Ruby upgrades and bulletproof deployments. [Prettier for Ruby](https://prettier.io/) is a plugin for the Ruby programming language and its ecosystem. prettier is an opinionated code formatter that supports multiple languages and integrates with most editors. The idea is to eliminate discussions of style in code review and allow developers to get back to thinking about code design instead. [Active Admin](https://activeadmin.info/) is a Ruby on Rails framework for creating elegant backends for website administration. [Capistrano](https://github.com/capistrano/capistrano) is a framework for building automated deployment scripts. Although Capistrano itself is written in Ruby, it can easily be used to deploy projects of any language or framework, be it Rails, Java, or PHP. [Spree](https://spreecommerce.org/) is an open source E-commerce platform for Rails 6 with a modern UX, optional PWA frontend, REST API, GraphQL, several official extensions and 3rd party integrations. [Sidekiq](https://sidekiq.org/) is a simple, efficient background processing for Ruby. It uses hreads to handle many jobs at the same time in the same process. It does not require Rails but will integrate tightly with Rails to make background processing dead simple. [Kaminari](https://github.com/amatsuda/kaminari/wiki) is a Scope and Engine based, clean, powerful, and customizable paginator for modern web app frameworks and ORMs. [React-Rails](https://github.com/reactjs/react-rails) is a flexible tool to use [React](http://facebook.github.io/react/) with Rails. By integrating React.js with Rails views and controllers, the asset pipeline, or webpacker. [Pry](https://github.com/pry/pry) is a runtime developer console and IRB alternative with powerful introspection capabilities. [Brakeman](https://brakemanscanner.org/) is a static analysis tool which checks Ruby on Rails applications for security vulnerabilities. [dotenv](https://github.com/bkeepers/dotenv) is a Ruby gem to load environment variables from `.env`. [Scientist](https://github.com/github/scientist) is a Ruby library for carefully refactoring critical paths. [fastlane](https://fastlane.tools/) is a tool written in Ruby for iOS and Android developers to automate tedious tasks like generating screenshots, dealing with provisioning profiles, and releasing your application. [Fluentd](https://www.fluentd.org/) collects events from various data sources and writes them to files, RDBMS, NoSQL, IaaS, SaaS, Hadoop and so on all written in Ruby. # PHP Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93925949-bf85d080-fccb-11ea-9158-d8d967a03e60.png"> <br /> </p> **[Start building with PHP on AWS](https://aws.amazon.com/sdk-for-php/)** ## PHP Learning Resources [PHP](https://www.php.net/) is a popular general-purpose scripting language that is especially suited to web development. Fast, flexible and pragmatic, PHP powers everything from your blog to the most popular websites in the world. [PHP 8](https://www.php.net/releases/8.0/en.php) [What's New in PHP 8 - Auth0](https://auth0.com/blog/whats-new-php-8/) [PHP Manual](https://www.php.net/manual/en/index.php) [MIT's PHP Code Style Guide](https://mitsloan.mit.edu/shared/content/PHP_Code_Style_Guide.php) [PHP Style Guide](https://gist.github.com/ryansechrest/8138375) [PHP tutorial by W3Schools](https://www.w3schools.com/php/) [PHP MySQL & CodeIgniter Course on Udemy](https://www.udemy.com/course/php-mysql-codeigniter-complete-guide/) ## Tools [PhpStorm](https://www.jetbrains.com/phpstorm/) is a professional PHP IDE developed by Jet Brains for working with Symfony, Laravel, Drupal, WordPress, Laminas, Magento, Joomla!, CakePHP, Yii, and other frameworks. [Laravel](https://laravel.com/) is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable and creative experience to be truly fulfilling. [PHP Tools for Visual Studio/VS Code](https://www.devsense.com/en) is a an extension that turn Visual Studio into a powerful PHP development environment. [Symfony](https://symfony.com/) is a PHP framework for web and console applications and a set of reusable PHP components. Symfony is used by thousands of web applications (including BlaBlaCar.com and Spotify.com) and most of the [popular PHP projects](https://symfony.com/projects) (including Drupal and Magento). [CakePHP](https://cakephp.org) is a rapid development framework for PHP which uses commonly known design patterns like Associative Data Mapping, Front Controller, and MVC. CakePHP's main goal is to provide a structured framework that enables PHP users at all levels to rapidly develop robust web applications, without any loss to flexibility. [Composer](https://getcomposer.org/) is a tools helps you declare, manage, and install dependencies of PHP projects. [Guzzle](https://github.com/guzzle/guzzle) is a PHP HTTP client that makes it easy to send HTTP requests and trivial to integrate with web services. [DesignPatternsPHP](https://designpatternsphp.readthedocs.io/) is a collection of known design patterns and some sample code how to implement them in PHP 7.4. Every pattern has a small list of examples. [CodeIgniter](https://codeigniter.com/) is an Application Development Framework for people who build web sites using PHP. Its goal is to enable you to develop projects much faster than you could if you were writing code from scratch, by providing a rich set of libraries for commonly needed tasks, as well as a simple interface and logical structure to access these libraries. CodeIgniter lets you creatively focus on your project by minimizing the amount of code needed for a given task. [HHVM](https://hhvm.com/) is an open-source virtual machine designed for executing programs written in [Hack](https://hacklang.org/). HHVM uses a just-in-time (JIT) compilation approach to achieve superior performance while maintaining amazing development flexibility. HHVM should be used together with a webserver like the built in, easy to deploy [Proxygen](https://docs.hhvm.com/hhvm/basic-usage/proxygen), or a [FastCGI-based](https://docs.hhvm.com/hhvm/advanced-usage/fastCGI) webserver on top of nginx or Apache. [PHPUnit](https://phpunit.de/) is a programmer-oriented testing framework for PHP. It is an instance of the xUnit architecture for unit testing frameworks. [Phalcon](https://phalcon.io/) is an open source web framework delivered as a C extension for the PHP language providing high performance and lower resource consumption. [Swoole](https://www.swoole.co.uk/) is an event-driven asynchronous & coroutine-based concurrency networking communication engine with high performance written in C and C++ for PHP. [Matomo](https://matomo.org/) is a full-featured PHP MySQL software program that you download and install on your own webserver. At the end of the five-minute installation process, you will be given a JavaScript code. Simply copy and paste this tag on websites you wish to track and access your analytics reports in real-time. [Grav](https://getgrav.org/) is a Fast, Simple, and Flexible, file-based Web-platform. There is Zero installation required. Just extract the ZIP archive, and you are already up and running. It follows similar principles to other flat-file CMS platforms, but has a different design philosophy than most. Grav comes with a powerful Package Management System to allow for simple installation and upgrading of plugins and themes, as well as simple updating of Grav itself. [Whoops](https://filp.github.io/whoops/) is an error handler framework for PHP. Out-of-the-box, it provides a pretty error interface that helps you debug your web projects, but at heart it's a simple yet powerful stacked error handling system. [Slim](https://www.slimframework.com/) is a PHP micro framework that helps you quickly write simple yet powerful web applications and APIs. # Bash/PowerShell Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/95128610-89564100-070e-11eb-83de-9697fb490886.png"> <br /> </p> **[AWS Tools for PowerShell](https://aws.amazon.com/powershell/)** ## Bash/PowerShell Learning Resources [Introduction to Bash Shell Scripting by Coursera](https://www.coursera.org/projects/introduction-to-bash-shell-scripting) [Bash: Shell Script Basics by Pluralsight](https://www.pluralsight.com/courses/bash-shell-scripting) [Bash/Shell by Codecademy](https://www.codecademy.com/catalog/language/bash) [Windows Remote Management in Ansible using PowerShell](https://docs.ansible.com/ansible/latest/user_guide/windows_winrm.html) [Getting Started with PowerShell](https://docs.microsoft.com/en-us/powershell/) [PowerShell in Azure Cloud Shell](https://aka.ms/cloudshell/powershell-docs) [Azure Functions using PowerShell](https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-function-vs-code?pivots=programming-language-powershell) [Azure Automation runbooks](https://docs.microsoft.com/en-us/azure/automation/automation-runbook-types) [Using Visual Studio Code for PowerShell Development](https://docs.microsoft.com/en-us/powershell/scripting/dev-cross-plat/vscode/using-vscode?view=powershell-7) [Integrated Terminal in Visual Studio Code](https://code.visualstudio.com/docs/editor/integrated-terminal) [AWS Tools for Windows PowerShell](https://aws.amazon.com/powershell/) [PowerShell Best Practices and Style Guide](https://poshcode.gitbooks.io/powershell-practice-and-style) [AWS Command Line Interface and aws-shell Sample for AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/sample-aws-cli.html) [Configuring Cloud Shell on Google Cloud](https://cloud.google.com/shell/docs/configuring-cloud-shell) [Google's Shell Style Guide](https://google.github.io/styleguide/shellguide.html) ## Bash/ PowerShell Tools [Bash](https://www.gnu.org/software/bash/) is the GNU Project's shell(Bourne Again SHell), which is an sh-compatible shell that integrates together useful features from the Korn shell (ksh) and the C shell (csh). [PowerShell Core](https://microsoft.com/PowerShell) is a cross-platform (Windows, Linux, and macOS) automation and configuration tool/framework that works well with your existing tools and is optimized for dealing with structured data (JSON, CSV, XML, etc.), REST APIs, and object models. It also includes a command-line shell, an associated scripting language and a framework for processing cmdlets. [Azure PowerShell](https://docs.microsoft.com/en-us/powershell/azure/overview) is a set of cmdlets for managing Microsoft Azure resources directly from the PowerShell command line. [Windows Subsystem for Linux (WSL)](https://docs.microsoft.com/en-us/learn/modules/get-started-with-windows-subsystem-for-linux/) is a compatibility layer developed by Microsoft for running Linux binary executables in a Executable/Linkable Format natively on Windows 10 and Windows Server. [AWS Shell](https://aws.amazon.com/cli/) is a command-line shell program that provides convenience and productivity features to help both new and advanced users of the AWS Command Line Interface. [Google Cloud Shell](https://cloud.google.com/shell/) is a free admin machine with browser-based command-line access for managing your infrastructure and applications on Google Cloud Platform. [VS Code Bash Debug](https://marketplace.visualstudio.com/items?itemName=rogalmic.bash-debug) is a bash debugger GUI frontend based on awesome bashdb scripts (bashdb now included in package). [VS Code Bash IDE](https://marketplace.visualstudio.com/items?itemName=mads-hartmann.bash-ide-vscode) is a Visual Studio Code extension utilizing the [bash language server](https://github.com/bash-lsp/bash-language-server/blob/master/bash-lsp), that is based on [Tree Sitter](https://github.com/tree-sitter/tree-sitter) and its [grammar for Bash](https://github.com/tree-sitter/tree-sitter-bash) and supports [explainshell](https://explainshell.com/) integration. # Rust Development [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) <p align="center"> <img src="https://user-images.githubusercontent.com/45159366/93025405-8dc98700-f5b2-11ea-93f9-12b4a0ef3001.png"> <br /> </p> **[Rusoto: AWS SDK for Rust](https://github.com/rusoto/rusoto)** ## Rust Learning Resources [Rust](https://www.rust-lang.org) is a multi-paradigm programming language focused on performance and safety. Rust has a comparable amount of runtime to C and C++, and has set up its standard library to be amenable towards OS development. Specifically, the standard library is split into two parts: core and std. Core is the lowest-level aspects only, and doesn't include things like allocation, threading, and other higher-level features. [The Rust Language Reference](https://doc.rust-lang.org/nightly/reference/) [The Rust Programming Language Book](https://doc.rust-lang.org/book/) [Learning Rust](https://www.rust-lang.org/learn) [Why AWS loves Rust](https://aws.amazon.com/blogs/opensource/why-aws-loves-rust-and-how-wed-like-to-help/) [Rust Programming courses on Udemy](https://www.udemy.com/courses/search/?src=ukw&q=Rust) [Safety in Systems Programming with Rust at Standford by Ryan Eberhardt](https://reberhardt.com/blog/2020/10/05/designing-a-new-class-at-stanford-safety-in-systems-programming.html) [WebAssembly meets Kubernetes with Krustlet using Rust](https://cloudblogs.microsoft.com/opensource/2020/04/07/announcing-krustlet-kubernetes-rust-kubelet-webassembly-wasm/) [Microsoft's Project Verona](https://github.com/microsoft/verona/blob/master/docs/explore.md) ## Rust Tools [Cargo](https://github.com/rust-lang/cargo) is a package manager that downloads your Rust project’s dependencies and compiles your project. [Crater](https://crater.rust-lang.org/) is a tool to run experiments across parts of the Rust ecosystem. Its primary purpose is to detect regressions in the Rust compiler, and it does this by building a large number of crates, running their test suites and comparing the results between two versions of the Rust compiler. It can operate locally (with Docker as the only dependency) or distributed on the cloud. It can operate locally (with Docker as the only dependency) or distributed on the cloud. [VSCode-Rust](https://github.com/rust-lang/vscode-rust) is plugin that adds language support for Rust to Visual Studio Code. Rust support is powered by a separate language server - either by the official Rust Language Server (RLS) or rust-analyzer, depending on the user's preference. If you don't have it installed, the extension will install it for you (with permission). This extension is built and maintained by the Rust IDEs and editors team with the focus on providing a stable, high quality extension that makes the best use of the respective language server. [Apache Arrow](https://github.com/apache/arrow) is a development platform for in-memory analytics. It contains a set of technologies that enable big data systems to process and move data fast. Arrow's libraries are available for C, C++, C#, Go, Java, JavaScript, MATLAB, Python, R, Ruby, and Rust. [Wasmer](https://wasmer.io/) enables super lightweight containers based on [WebAssembly](https://webassembly.org/) that can run anywhere such as the Desktop to the Cloud and IoT devices, and also embedded in [any programming language](https://github.com/wasmerio/wasmer#language-integrations). [Firecracker](https://firecracker-microvm.github.io) is an open source virtualization technology that is purpose-built for creating and managing secure, multi-tenant container and function-based services that provide serverless operational models. Firecracker runs workloads in lightweight virtual machines, called microVMs, which combine the security and isolation properties provided by hardware virtualization technology with the speed and flexibility of containers. Firecracker has also been integrated in container runtimes, for example [Kata Containers](https://github.com/kata-containers/documentation/wiki/Initial-release-of-Kata-Containers-with-Firecracker-support) and [Weaveworks Ignite](https://github.com/weaveworks/ignite). [Tokio](https://github.com/tokio-rs/tokio) is an event-driven, non-blocking I/O platform for writing asynchronous applications with the Rust programming language. [TiKV](https://github.com/tikv/tikv) is an open-source distributed transactional key-value database that also provides classical key-vlue APIs, but also transactional APIs with ACID compliance. [Sonic](https://crates.io/crates/sonic-server) is a fast, lightweight and schema-less search backend similar to Elasticsearch in some use-cases. [Hyper](https://github.com/hyperium/hyper) is a fast and correct HTTP library for Rust. [Rocket](https://github.com/SergioBenitez/Rocket) is an async web framework for Rust with a focus on usability, security, extensibility, and speed. [Clippy](https://rust-lang.github.io/rust-clippy/) is a collection of lints to catch common mistakes and improve your Rust code. [Servo](https://github.com/servo/servo) is a prototype web browser engine written in the Rust language. [Vector](https://vector.dev/) is a high-performance, end-to-end (agent & aggregator) observability data platform that puts the user in control of their observability data. [RustPython](https://github.com/RustPython/RustPython) is a Python Interpreter written in Rust. [Miri](https://github.com/rust-lang/miri) is an interpreter for Rust's mid-level intermediate representation. It can run binaries and test suites of cargo projects and detect certain classes of undefined behavior. Miri will alsowill also tell you about memory leaks: when there is memory still allocated at the end of the execution, and that memory is not reachable from a global static, Miri will raise an error. [Chalk](https://rust-lang.github.io/chalk/book/) is an implementation and definition of the Rust trait system using a PROLOG-like logic solver. [stdarch](https://doc.rust-lang.org/stable/core/arch/) is Rust's standard library vendor-specific APIs and run-time feature detection. [Simpleinfra](https://github.com/rust-lang/simpleinfra) is rep that contains the tools and automation written by the Rust infrastructure team to manage our services. Using some of the tools in this repo require privileges only infra team members have. [Rustlings](https://github.com/rust-lang/rustlings) is a small set of exercises to get you used to reading and writing Rust code. [Krustlet](https://krustlet.dev/) acts as a Kubernetes Kubelet(written in Rust) by listening on the event stream for new pods that the scheduler assigns to it based on specific Kubernetes [tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/). The project is currently experimental. ## Operating System [Redox](https://www.redox-os.org) is a Unix-like Operating System written in Rust, aiming to bring the innovations of Rust to a modern microkernel and full set of applications. Acitvely being developed by [Jeremy Soeller](https://gitlab.redox-os.org/jackpot51). [Bottlerocket OS](https://github.com/bottlerocket-os/bottlerocket) is an open-source Linux-based operating system meant for hosting containers. Bottlerocket focuses on security and maintainability, providing a reliable, consistent, and safe platform for container-based workloads. [Tock](https://www.tockos.org) is an embedded operating system designed for running multiple concurrent, mutually distrustful applications on Cortex-M and RISC-V based embedded platforms. Tock's design centers around protection, both from potentially malicious applications and from device drivers. Tock uses two mechanisms to protect different components of the operating system. First, the kernel and device drivers are written in Rust, a systems programming language that provides compile-time memory safety, type safety and strict aliasing. Tock uses Rust to protect the kernel (the scheduler and hardware abstraction layer) from platform specific device drivers as well as isolate device drivers from each other. Second, Tock uses memory protection units to isolate applications from each other and the kernel. [Rust on Chrome OS](https://chromium.googlesource.com/chromiumos/docs/+/master/rust_on_cros.md) is a document that provides information on creating Rust projects for installation within Chrome OS and Chrome OS SDK. [Writing an OS in Rust ](https://os.phil-opp.com) is a blog series creates a small operating system in the Rust programming language by [Philipp Oppermann](https://github.com/phil-opp). ## Contribute - [x] If would you like to contribute to this guide simply make a [Pull Request](https://github.com/mikeroyal/AWS-Guide/pulls). ## License [Back to the Top](https://github.com/mikeroyal/AWS-Guide/blob/main/README.md#table-of-contents) Distributed under the [Creative Commons Attribution 4.0 International (CC BY 4.0) Public License](https://creativecommons.org/licenses/by/4.0/).

mapio/labprog

Dieci anni di esercizi di programmazione

2018-03-14T10:00:37Z

# LabProg@UniMI [](http://www.gnu.org/licenses/gpl-3.0) [](http://creativecommons.org/licenses/by-sa/4.0/) Questo *repository* raccoglie il materiale didattico prodotto da [Massimo Santini](https://santini.di.unimi.it) in dieci anni e più di servizio come docente degli insegnamenti di *programmazione* e *laboratorio di programmazione* presso vari corsi di laurea del [Dipartimento di Informatica](http://www.di.unimi.it) dell'[Università degli Studi di Milano](https://www.unimi.it/). Si rivolge principalmente agli studenti e contiene più di **duecentocinquanta esercizi** (corredati di *testcase* e *software di supporto*) e alcune **guide** sull'uso di GNU/Linux, C e Java. I docenti interessati possono fare richiesta per accedere alle *soluzioni degli esercizi*, nonché alle *versioni sorgenti delle guide* e ad un supporto nella configurazione ed uso della [scythe suite](https://github.com/scythe-suite), una collezione di strumenti per la *somministrazione e valutazione automatica degli esercizi*. Il *repository* è corredato da un apposito [sito di docuentazione](https://labprog.mapio.it/) che contiene, oltre alle sopracitate guide, informazioni sugli esercizi e istruzioni d'uso del software corredato. Chiunque abbia **quesiti**, o individui degli **errori** nei testi degli esercizi o delle guide, o nei risultati dei *testcase*, è pregato di sottoporre una [nuova](https://github.com/mapio/labprog/issues) **issue**. Il contenuto di questo *repository* viene generato a partire da una versione *privata* e pertanto (anche in caso di aggiornamenti), contiene un solo *commit* (che viene periodicamente riscritto); per questa ragione è *sconsigliato fare fork*. ### Nota di copyright I testi ed i sorgenti contenuti in questo *repository* sono protetti dalle leggi sul copyright e dalle disposizioni dei trattati internazionali; in particolare ai testi si applica la [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/) ed ai sorgenti la [GNU General Public License 3](https://www.gnu.org/licenses/gpl-3.0.html). L'informazione qui contenuta è ritenuta essere accurata alla data della pubblicazione. Essa è fornita per scopi esclusivamente didattici e non per essere utilizzata in progetti di impianti, prodotti, ecc. Tale informazione è soggetta a cambiamenti senza preavviso. L'autore non si assume alcuna responsabilità per il contenuto di queste pagine (ivi incluse, ma non limitatamente a, la correttezza, completezza, applicabilità ed aggiornamento dell'informazione). In ogni caso non può essere dichiarata conformità all'informazione in oggetto. In ogni caso questa nota di copyright non deve mai essere rimossa e deve essere riportata anche in utilizzi parziali. © Massimo Santini 2018

ankitech/design-pattern

design pattern guide and cheat sheet

2019-10-05T12:10:49Z

# Design Patterns + Creational 1. [Builder pattern](#1builder-pattern) 2. [Factory pattern](#2factory-pattern) 3. [Abstract Factory pattern](#3abstract-factory-pattern) 4. [Prototype pattern](#4prototype-pattern) 5. [Singleton pattern](#5singleton-pattern) + Structural 6. [Adapter pattern](#6adapter-pattern) 7. [Bridge pattern](#7bridge-pattern) 8. [Composite pattern](#8composite-pattern) 9. [Decorator pattern](#9decorator-pattern) 10. [Facade pattern](#10facade-pattern) 11. [Flyweight pattern](#11flyweight-pattern) 12. [Proxy pattern](#12proxy-pattern) + Behavioral 13. [Chain of responsibility pattern](#13chain-of-responsibility-pattern) 14. [Command pattern](#14command-pattern) 15. [Interpreter pattern](#15interpreter-pattern) 16. [Iterator pattern](#16iterator-pattern) 17. [Mediator pattern](#17mediator-pattern) 18. [Memento pattern](#18memento-pattern) 19. [Observer pattern](#19observer-pattern) 20. [State pattern](#20state-pattern) 21. [Strategy pattern](#21strategy-pattern) 22. [Template pattern](#22template-pattern) 23. [Visitor pattern](#23visitor-pattern) ## 1.Builder Pattern **Builder pattern** aims to “Separate the construction of a complex object from its representation so that the same construction process can create different representations.” It is used to construct a complex object step by step and the final step will return the object. The process of constructing an object should be generic so that it can be used to create different representations of the same object.   UML diagram for the classes in code example: [src.main.java.builder](https://github.com/ankitech/design-pattern/tree/master/src/main/java/builder) **For example** : if we want to generate a builder for house **(House Builder)** we House a House builder which can act as a facade for multiple concrete builder classes which can be part of the house builder interface.  ## 2.Factory Pattern Factory design pattern is used when we have a super class with multiple sub-classes and based on input, we need to return one of the sub-class. This pattern take out the responsibility of instantiation of a class from client program to the factory class.Factory pattern introduces loose coupling between classes which is the most important principle one should consider and apply while designing the application architecture. Loose coupling can be introduced in application architecture by programming against abstract entities rather than concrete implementations.   UML diagram for the classes in code example: [src.main.java.factory](https://github.com/ankitech/design-pattern/tree/master/src/main/java/factory) ## 3.Abstract Factory Pattern **Abstract Factory design** pattern is one of the _Creational_ pattern. Abstract Factory pattern is almost similar to Factory Pattern is considered as another layer of abstraction over factory pattern. Abstract Factory patterns work around a **_super-factory_** which creates other factories. Abstract factory pattern implementation provides us a framework that allows us to create objects that follow a general pattern. So at runtime, abstract factory is coupled with any desired concrete factory which can create objects of desired type.   UML diagram for the classes in code example: [src.main.java.abstractFactory](https://github.com/ankitech/design-pattern/tree/master/src/main/java/abstractFactory) ## 4.Prototype Pattern **Prototype** allows us to hide the complexity of making new instances from the client. The concept is to copy an existing object rather than creating a new instance from scratch, something that may include costly operations. The existing object acts as a _prototype_ and contains the state of the object. The newly copied object may change same properties only if required. This approach saves costly resources and time, especially when the object creation is a heavy process. The prototype pattern is a _creational_ design pattern. Prototype patterns is required, when object creation is time consuming, and costly operation, so we create object with existing object itself. One of the best available way to create object from existing objects are `clone()` method. Clone is the simplest approach to implement prototype pattern. However, it is your call to decide how to copy existing object based on your business model.   UML diagram for the classes in code example: [src.main.java.prototype](https://github.com/ankitech/design-pattern/tree/master/src/main/java/prototype) ## 5.Singleton Pattern The **singleton pattern** is one of the simplest design patterns. Sometimes we need to have only one instance of our class for example a single DB connection shared by multiple objects as creating a separate DB connection for every object may be costly. Similarly, there can be a single configuration manager or error manager in an application that handles all problems instead of creating multiple managers._The singleton pattern is a design pattern that restricts the instantiation of a class to one object._  UML diagram for the classes in code example: [src.main.java.singleton](https://github.com/ankitech/design-pattern/tree/master/src/main/java/singleton) ## 6.Adapter Pattern The **adapter pattern** convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. The client sees only the target interface and not the adapter. The adapter implements the target interface. Adapter delegates all requests to Adaptee. For example consider a USB to Ethernet adapter. We need this when we have an Ethernet interface on one end and USB on the other. Since they are incompatible with each other. we use an adapter that converts one to other.   UML diagram for the classes in code example: [src.main.java.adapter](https://github.com/ankitech/design-pattern/tree/master/src/main/java/adapter) ## 7.Bridge Pattern The Bridge design pattern allows you to separate the abstraction from the implementation.It is a structural design pattern. There are 2 parts in Bridge design pattern : - Abstraction - Implementation This is a design mechanism that encapsulates an implementation class inside of an interface class. - The bridge pattern allows the Abstraction and the Implementation to be developed independently and the client code can access only the Abstraction part without being concerned about the Implementation part. - The abstraction is an interface or abstract class and the implementor is also an interface or abstract class. - The abstraction contains a reference to the implementor. Children of the abstraction are referred to as refined bstractions, and children of the implementor are concrete implementors. Since we can change the reference to the implementor in the abstraction, we are able to change the abstraction’s implementor at run-time. Changes to the implementor do not affect client code. - It increases the loose coupling between class abstraction and it’s implementation.   UML diagram for the classes in code example: [src.main.java.bridge](https://github.com/ankitech/design-pattern/tree/master/src/main/java/bridge) ## 8.Composite Pattern _Composite pattern_ is a partitioning design pattern and describes a group of objects that is treated the same way as a single instance of the same type of object. The intent of a composite is to “compose” objects into tree structures to represent part-whole hierarchies. It allows you to have a tree structure and ask each node in the tree structure to perform a task. As described by Gof, **_“Compose objects into tree structure to represent part-whole hierarchies. Composite lets client treat individual objects and compositions of objects uniformly”_**. When dealing with Tree-structured data, programmers often have to discriminate between a leaf-node and a branch. This makes code more complex, and therefore, error prone. The solution is an interface that allows treating complex nd primitive objects uniformly. In object-oriented programming, a composite is an object designed as a composition of one-or-more similar objects, all exhibiting similar functionality. This is known as a “has-a” relationship between objects. The key concept is that you can manipulate a single instance of the object just as you would manipulate a group of them. The operations you can perform on all the composite objects often have a least common denominator relationship.  UML diagram for the classes in code example: [src.main.java.composite](https://github.com/ankitech/design-pattern/tree/master/src/main/java/composite) ## 9.Decorator Pattern _Decorator pattern_ allows a user to add new functionality to an existing object without altering its structure. This type of design pattern comes under structural pattern as this pattern acts as a wrapper to existing class. This pattern creates a decorator class which wraps the original class and provides additional functionality keeping class methods signature intact. We are demonstrating the use of decorator pattern via following example in which we will decorate a shape with some color without alter shape class.  UML diagram for the classes in code example: [src.main.java.decorator](https://github.com/ankitech/design-pattern/tree/master/src/main/java/decorator) ## 10.Facade Pattern ## 11.Flyweight Pattern ## 12.Proxy Pattern ## 13.Chain Of Responsibility Pattern ## 14.Command Pattern ## 15.Interpreter Pattern ## 16.Iterator Pattern ## 17.Mediator Pattern ## 18.Memento Pattern ## 19.Observer Pattern ## 20.State Pattern ## 21.Strategy Pattern ## 22.Template Pattern ## 23.Visitor Pattern

jaydenxiao2016/HighLightGuideView

A library for app's new feature guiding,it supports the shape of round, oval and rectangular!

2016-08-16T07:16:29Z

# HighLightGuideView **项目介绍：** A library for app's new feature guiding,it supports the shape of round, oval and rectangular! (一个用于 app 新功能高亮引导的库,支持圆形、椭圆形、矩形高亮形状)  **支持配置属性：** （1）外部点击是否关闭setTouchOutsideDismiss （2）控件高亮形状类型，有圆形、椭圆形、矩形setHighLightStyle （3）高亮画笔类型，有平滑和一般，默认平滑setMaskblurstyle （4）蒙层颜色setMaskColor （5）高亮控件padding,setHighLisghtPadding **使用方法：** dependencies { compile 'com.jaydenxiao:guider:1.0.0' } **1. 全屏提示，没高亮控件情况引导** HighLightGuideView.builder(this) .addNoHighLightGuidView(R.drawable.listlead) .setMaskColor(getResources().getColor(R.color.mask_color)) .show(); **2. 有高亮控件情况引导（单个高亮控件）** HighLightGuideView.builder(this) .addHighLightGuidView(view, R.drawable.dmtext) .setHighLightStyle(HighLightGuideView.VIEWSTYLE_OVAL) .show(); **3. 有高亮控件情况引导（多个高亮控件）** HighLightGuideView.builder(this) .addHighLightGuidView(view1, R.drawable.dstext) .addHighLightGuidView(view2, R.drawable.dmtext) .setHighLightStyle(HighLightGuideView.VIEWSTYLE_OVAL) .show();

liuyangming/ByteTCC

ByteTCC is a distributed transaction manager based on the TCC(Try/Confirm/Cancel) mechanism. It’s compatible with the JTA specification. User guide: https://github.com/liuyangming/ByteTCC/wiki

2016-02-12T11:51:14Z

 **ByteTCC** is an implementation of Distributed Transaction Manager, based on Try-Confirm-Cancel (TCC) mechanism. **ByteTCC** is comptible with JTA and could be seamlessly integrated with Spring and other Java containers. ## 1. Quick Start #### 1.1 Add maven depenency ###### 1.1.1. Spring Cloud ```xml <dependency> <groupId>org.bytesoft</groupId> <artifactId>bytetcc-supports-springcloud</artifactId> <version>0.5.12</version> </dependency> ``` ###### 1.1.2. dubbo ```xml <dependency> <groupId>org.bytesoft</groupId> <artifactId>bytetcc-supports-dubbo</artifactId> <version>0.5.12</version> </dependency> ``` #### 1.2 Compose a business service ```java @Service("accountService") @Compensable( interfaceClass = IAccountService.class , confirmableKey = "accountServiceConfirm" , cancellableKey = "accountServiceCancel" ) public class AccountServiceImpl implements IAccountService { @Resource(name = "jdbcTemplate") private JdbcTemplate jdbcTemplate; @Transactional public void increaseAmount(String accountId, double amount) throws ServiceException { this.jdbcTemplate.update("update tb_account set frozen = frozen + ? where acct_id = ?", amount, acctId); } } ``` #### 1.3 Compose a confirm service ```java @Service("accountServiceConfirm") public class AccountServiceConfirm implements IAccountService { @Resource(name = "jdbcTemplate") private JdbcTemplate jdbcTemplate; @Transactional public void increaseAmount(String accountId, double amount) throws ServiceException { this.jdbcTemplate.update("update tb_account set amount = amount + ?, frozen = frozen - ? where acct_id = ?", amount, amount, acctId); } } ``` #### 1.4 Compose a cancel service ```java @Service("accountServiceCancel") public class AccountServiceCancel implements IAccountService { @Resource(name = "jdbcTemplate") private JdbcTemplate jdbcTemplate; @Transactional public void increaseAmount(String accountId, double amount) throws ServiceException { this.jdbcTemplate.update("update tb_account set frozen = frozen - ? where acct_id = ?", amount, acctId); } } ``` ## 2. Documentation & Samples * [Document](https://github.com/liuyangming/ByteTCC/wiki) * [Sample](https://github.com/liuyangming/ByteTCC-sample) ## 3. Features * support declarative transaction management * support normal transaction, TCC transaction, compensating service transaction * support distributed transaction scenarios. e.g. multi-datasource, cross-applications and cross-servers transaction * support long live transaction * support Dubbo framework * support Spring Cloud * provide solutions for service idempotence in framework layer ## 4. Contact Me If you have any questions or comments regarding this project, please feel free to contact me at: 1. send mail to _[bytefox#126.com](bytefox@126.com)_ ~OR~ 2. add Tecent QQ group 537445956/606453172/383515467 We will review all the suggestions and implement good ones in future release.

lkrnac/book-eiws-code-samples

Examples for book Pivotal Certified Spring Enterprise Integration Specialist Exam A Study Guide

2015-03-16T18:53:45Z

[ ](https://codeship.com/projects/68847) Examples for book **Pivotal Certified Spring Enterprise Integration Specialist Exam A Study Guide** http://www.apress.com/9781484207949 # More information http://lkrnac.net/blog/2015/10/enterprise-spring-examples-and-integration-tests # Build cd 0000-examples-parent mvn clean install cd ../0000-examples mvn clean install # Possible first time build error Error message: [ERROR] Failed to execute goal org.hornetq:hornetq-maven-plugin:1.2.0:start (start) on project 0501-jms11-jndi: Execution start of goal org.hornetq:hornetq-maven-plugin:1.2.0:start failed: A required class was missing while executing org.hornetq:hornetq-maven-plugin:1.2.0:start: org/slf4j/LoggerFactory Just continue build where it ended: mvn clean install -rf :0501-jms11-jndi

khmarbaise/maui

Maven Unit and Integration Test Guide (MaUI Test Guide)

2011-04-01T15:04:09Z

Maven Unit / Integration Test Guide (MaUI Test Guide) ===================================================== Describe the best practice for doing unit and integrations tests in Maven. The Idea of this module based on [https://issues.apache.org/jira/browse/MNG-1563](https://issues.apache.org/jira/browse/MNG-1563). License ------- [Apache License, Version 2.0, January 2004](http://www.apache.org/licenses/) Homepage -------- The Maven Unit Integration Test Guide [http://khmarbaise.github.com/maui](http://khmarbaise.github.com/maui) Name ---- - MaUI Test Guide Roadmap ------- - Unit Testing with Maven - maven-surefire-plugin - Integration Testing with Maven - maven-failsafe-plugin - Integration Testing in Maven Plugin Development - maven-invoker-plugin - Code Coverage for Unit Testing - Cobertura, Emma http://mojo.codehaus.org/emma-maven-plugin/index.html http://mojo.codehaus.org/cobertura-maven-plugin/index.html - Code Coverage for Integration Testing - Coberatura?, Emma4it ? - How to do this? - http://www.sonatype.com/people/2009/06/integration-tests-with-maven-part-2-test-coverage-reports/ - http://blog.jayway.com/2008/12/13/getting-coverage-for-integration-tests/ - https://github.com/activelylazy/coverage-example - http://www.petrikainulainen.net/programming/maven/creating-code-coverage-reports-for-unit-and-integration-tests-with-the-jacoco-maven-plugin/ - mvn release:.... -Darguments="-Dxxxx" caused by calling instance during release process. - JBehave - http://jbehave.org/reference/stable/maven-goals.html Status ------ - First description about unit test and integration test done. TODOs ----- - Integration test into separate module - examples how to use cargo? - Maven Plugin Development - Unit Test examples - Integration test examples - for example with Maven Invoker Plugin - Maven Unit Testing - Example for multiple usage: - copy xyz-test.jar into target/test folder (dependency:unpack) run the tests there.. - Reporting Unit Tests results - Reporting code coverage results - Reporting Integration test results - Reporting Integration test coverage results. Naming Convention for the examples ---------------------------------- - Prefixes of the projects: mp - Maven Plugin ut - Unit Test it - Integration Test ut- - Unit Test it- - Integration Tests mp-it-... - Maven Plugin - Integration Test

Albertoimpl/k8s-for-the-busy

Kubernetes for the busy developer - A practical guide

2019-10-10T17:57:26Z

cyberbuddy-io/open-source-contribution-for-beginners

This repository targets beginners to guide them about open source and help them make their first contribution.

2021-11-01T05:55:56Z

# Open source:octocat: contribution for beginners         This repository targets beginners:beginner: to guide them about open source, help them make their first contribution and help them know their code. The following text explains how to push your local changes to the remote repository and how to create a Pull Request. If you already know that, just go through the [Contributing Guidelines](https://github.com/cyberbuddy-io/open-source-contribution-for-beginners/blob/master/CONTRIBUTING.md) and you are ready to contribute! ## This Project is <a href="https://vercel.com/?utm_source=opencyberbuddy&utm_campaign=oss"><img src="https://www.datocms-assets.com/31049/1618983297-powered-by-vercel.svg"></a> # Prerequisites: 1. A github account 2. Git CLI 3. An IDE: i. VSCode ii. Sublime for HTML, CSS and JS iii. Or any other IDE of your choice # How to contribute: 1. Fork the repository To fork the repository click on the fork button on the top right corner of the repository section. It will create a copy of that repository in your account.  2. Open Git CLI and follow these steps: 3. Clone the repository i. Copy the URL of the repository.  ii. To copy the contents of the repository in your local `git clone <paste the copied url from github>`  Then you can open the cloned repository in any IDE and make changes. 4. Switch to the branch you want to contribute to. `git checkout <your-branch-name>` 5. Read the repository's contributing guide before starting any editing. 6. Make changes in the contributing branch. 7. Stage the changes `git add <your-full-file-name> (with path)` (to stage all files, use `git add .`) 8. Commit the changes `git commit -m "Your message"` 9. Push the changes `git push -u origin <your-branch-name>` 10. Create an issue in the repository describing the changes you want to make. To know how to do that, see the [Contributing Guidelines](https://github.com/cyberbuddy-io/open-source-contribution-for-beginners/blob/master/CONTRIBUTING.md). 11. Pull request(requesting the project creator to add/merge your changes to the main repository) i. Ensure that you make PR to the right branch. ii. Add relevent title and description to your pull request that explains the changes you made appropriately. iii. Click on create pull request button.   iv. Make sure to mention the issue you want to fix in the description of your pull request. (Format :`Refer to issue #<issue-number>`) 12. Now you just have to wait for the project creator/owner to review your request and merge your changes to the original code. **Congratulations on making your very first open-source contribution!:fist_right::fist_left:** This repository is a collaborative project and is handeled by [@lovishprabhakar](https://github.com/lovishprabhakar)

PacktPublishing/Selenium-WebDriver-3-Practical-Guide-Second-Edition

Selenium WebDriver 3 Practical Guide Second Edition by Packt publishing

2018-07-20T09:07:17Z

# Selenium WebDriver 3 Practical Guide Second Edition <a href="https://www.packtpub.com/web-development/selenium-webdriver-3-practical-guide-second-edition?utm_source=github&utm_campaign=9781788999762"><img src="https://d255esdrn735hr.cloudfront.net/sites/default/files/imagecache/ppv4_main_book_cover/B09986.png" alt="Selenium WebDriver 3 Practical Guide Second Edition" height="256px" align="right"></a> This is the code repository for [Selenium WebDriver 3 Practical Guide ](https://github.com/PacktPublishing/Selenium-WebDriver-3-Practical-Guide-Second-Edition.git), published by Packt. **End-to-end automation testing for web and mobile browsers with Selenium WebDriver** ## What is this book about? Selenium WebDriver 3 is the latest version used by many professionals for automated testing. The book will guide you through various Selenium WebDriver APIs and provide solutions to the common challenges faced while using Selenium WebDriver. You will learn to use remote WebDriver to run tests on remote machines for cross-browser testing and also set up Selenium Grid. This book covers the following exciting features: <First 5 What you'll learn points> * Understand what Selenium 3 is and how is has been improved than its predecessor * Use different mobile and desktop browser platforms with Selenium 3 * Perform advanced actions, such as drag-and-drop and action builders on web page * Learn to use Java 8 API and Selenium 3 together * Explore remote WebDriver and discover how to use it If you feel this book is for you, get your [copy](https://www.amazon.com/Selenium-WebDriver-Practical-Guide-automation/dp/1788999762/ref=sr_1_3?s=books&ie=UTF8&qid=1533181933&sr=1-3&keywords=selenium) today! <a href="https://www.packtpub.com/?utm_source=github&utm_medium=banner&utm_campaign=GitHubBanner"><img src="https://raw.githubusercontent.com/PacktPublishing/GitHub/master/GitHub.png" alt="https://www.packtpub.com/" border="5" /></a> ## Instructions and Navigations All of the code is organized into folders. For example, Chapter01. The code will look like the following: ``` <java.version>1.8</java.version> <selenium.version>3.13.0</selenium.version> <testng.version>6.13.1</testng.version> <maven.compiler.version>3.7.0</maven.compiler.version> </properties> ``` **Following is what you need for this book:** Selenium WebDriver 3 Practical Guide is for software quality assurance/testing professionals, software project managers, or software developers interested in using Selenium for testing their applications. Prior programming experience in Java is necessary. ### Software and Hardware List | Chapter | Software required | OS required | | -------- | ------------------------------------| -----------------------------------| | 1-11 | Eclipse, Mozilla Firefox, Google chrome, or Safari | Linux, MacOS, Windows | We also provide a PDF file that has color images of the screenshots/diagrams used in this book. [Click here to download it](https://www.packtpub.com/sites/default/files/downloads/Puppet5CookbookFourthEdition_ColorImages.pdf). ### Related products <Paste books from the Other books you may enjoy section> * Mastering Selenium WebDriver 3.0 - Second Edition [[Packt]](https://www.packtpub.com/web-development/mastering-selenium-webdriver-30-second-edition?utm_source=github&utm_campaign=9781788999762) [[Amazon]](https://www.amazon.com/Mastering-Selenium-WebDriver-3-0-performance/dp/1788299671/ref=sr_1_fkmr0_1?ie=UTF8&qid=1533182143&sr=8-1-fkmr0&keywords=Mastering+Selenium+WebDriver+3.0+-+Second+Edition) * Selenium Framework Design in Data-Driven Testing [[Packt]](https://www.packtpub.com/web-development/selenium-framework-design-data-driven-testing?utm_source=github&utm_campaign=9781788999762) [[Amazon]](https://www.amazon.com/Selenium-Framework-Design-Data-Driven-Testing/dp/1788473574/ref=sr_1_1_sspa?s=books&ie=UTF8&qid=1533182518&sr=1-1-spons&keywords=Selenium+Framework+Design+in+Data-Driven+Testing&psc=1) ## Get to Know the Author **Unmesh Gundecha** Unmesh Gundecha has over 16 years, experience in Agile software development, test automation, and DevOps methodologies. He is an Agile, open source, and DevOps evangelist with extensive experience in a diverse set of tools and technologies. He has extensive hands-on experience in building sustainable and repeatable test automation solutions for web and mobile platforms, APIs, and CLI apps with continuous integration and delivery pipelines, using best-of-breed open source and commercial tools to do so. He is the author of Selenium Testing Tools Cookbook and Learning Selenium Testing Tools with Python, both by Packt Publishing. ## Other books by the authors * [Selenium Testing Tools Cookbook - Second Edition](https://www.packtpub.com/web-development/selenium-testing-tools-cookbook-second-edition) * [Selenium Framework Design in Data-Driven Testing](https://www.packtpub.com/web-development/learning-selenium-testing-tools-python) ### Suggestions and Feedback [Click here](https://docs.google.com/forms/d/e/1FAIpQLSdy7dATC6QmEL81FIUuymZ0Wy9vH1jHkvpY57OiMeKGqib_Ow/viewform) if you have any feedback or suggestions. ### Download a free PDF <i>If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.<br>Simply click on the link to claim your free PDF.</i> <p align="center"> <a href="https://packt.link/free-ebook/9781788999762">https://packt.link/free-ebook/9781788999762 </a> </p>

sonatype/codestyle

The Sonatype Code Style Guide

2013-06-07T23:18:41Z

<!-- Copyright (c) 2007-present Sonatype, Inc. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 which accompanies this distribution and is available at https://www.eclipse.org/legal/epl-2.0/. --> # Sonatype Codestyle Contains codestyle configuration for: * IDEA * Eclipse * VSCode And some reference examples (which won't compile so don't even try) to help refine the style properly in supported environments. The reference examples should reflect the desired format. The IDE configurations may not support or respect this, which is okay while we're developing the format and auto-formatters. Also contains a set of [checkstyle](https://github.com/checkstyle/checkstyle) and [pmd](https://pmd.github.io/) rules that can be used to enforce code formatting/quality standards as part of the build. Usage/release documentation [here](#checkstyle-and-pmd-rules). # Goals, Intent and Working Agreement ## Goals We want to present a unified approach to code styling across our entire suite of development efforts, automating away the need to respond to deviations during integration of code from a large group of developers, both within and outside of the Sonatype Organization. ## Intent All of the development environments used by developers contributing to Sonatype code should be applying the same agreed upon formatting rules consistently, so that we don't spend needless time aligning these rules along with the more substantial (and important!) logical changes we make on a daily basis. ## Working Agreement - Any change to existing rules should be discussed and agreed upon by the larger group before implementation. Minimally this should result in a mail to the development group with some minimal time for feedback. - Any noted deviation between development environments should result in the scheduling of work to correctly align with agreed upon standard. ## Installation ### IntelliJ IDEA See [the Intellij documentation](https://www.jetbrains.com/help/idea/copying-code-style-settings.html). ### Eclipse See [the eclipse documentation](http://help.eclipse.org/kepler/index.jsp?topic=%2Forg.eclipse.jdt.doc.user%2Freference%2Fpreferences%2Fjava%2Fcodestyle%2Fref-preferences-formatter.htm) for how to import the files into your IDE. In addition, html indentation settings are not exported, but can be set to 2 spaces from Preferences -> Web -> HTML Files -> Editor -> "Indent using spaces". [Screenshot of the eclipse config here.](https://s3.amazonaws.com/uploads.hipchat.com/18157/88592/RSkQhq8UYnxf81Z/upload.png) ### Visual Studio Import sonatype-visualstudio-settings.xml using Tools -> Import and Export Settings... ### Visual Studio ReSharper Import sonatype-visualstudio-resharper-settings.xml using ReSharper -> Options... -> Manage... -> Import and Export -> Import from file... ### VSCode See [the VSCode documentation](https://code.visualstudio.com/docs/getstarted/settings). VSCode uses Eclipse formatter settings. To import them clone this repository locally and use path to it in the settings. - Install Java Extension Pack - Configure Java formatter to use Eclipse settings. You need to specify the name of the profile as well (Sonatype). - Disable indentation guessing and set it to be forced to 2. - Change import order and star thresholds - Disable [online services](https://code.visualstudio.com/docs/supporting/FAQ#_how-to-disable-telemetry-reporting) such as telemetry and natural language search. Those features may send portions of what you have typed to Microsoft servers, which we would like to avoid. Some extensions may also include online services, please review all the settings in the Settings UI visible with the `@tag:usesOnlineServices` filter. All settings required as a JSON snippet (make sure to fix the local path): ``` { "java.format.settings.url": "/path/to/local/codestyle/sonatype-eclipse.xml", "java.format.settings.profile": "Sonatype", "editor.detectIndentation": false, "editor.tabSize": 2, "java.sources.organizeImports.starThreshold": 100, "java.sources.organizeImports.staticStarThreshold": 10, "java.completion.importOrder": [ "java", "javax", "javafx", "com.sonatype", "org.sonatype", "", "#" ], "files.exclude": { "**/.classpath": true, "**/.project": true, "**/.settings": true, "**/.factorypath": true }, "workbench.enableExperiments": false, "telemetry.enableTelemetry": false, "workbench.settings.enableNaturalLanguageSearch": false } ``` ## Basics ### General 120 column right margin 2 space indent for **ALL** formats ### Always Newline at end of file #### IntelliJ IDEA Preferences -&gt; Editor -&gt; General \[ On Save: Ensure every saved file ends with a line break \] ### NO TABS ### Imports Order: * java * javax * javafx * com.sonatype * org.sonatype * _other_ * _static_ Wildcard thresholds: * 100 non-static * 10 static ## Notes Has similarities with "[The Elements of Java Style][java style pdf]" (book), Google and Eclipse styles with some minor changes for clarity and readability: * Class/intf/enum declarations are multiline * if/try/while blocks have new-lines after '}' Some minor differences between IDEA and Eclipse configurations are unavoidable. The configurations here try to get as close as possible, though if each time a file is reformatted there could be additional noise and thus such operation should generally be avoided. To avoid this pain recommend that reformat entire sources to normalize once, then format discrete blocks where appropriate. There is some _crude_ support to use Eclipse formatter from IDEA. Unfortunately the Eclipse formatter is not quite as smart as the IDEA formatter in some/many places. The support also seems to have some strange additional configuration for import handling, etc which is not ideal. It should be possible to craft separate configurations which are _mostly_ compatible and thus avoid _most_ noise if reformatting is done in a sane manner. **DO NOT** reformat entire codebases, but reformat as sources are touched to normalize. Or normalize and _sanitize_ one by one, as the code formatters (IDEA or Eclipse) tend to create some formats which can and **SHOULD** be manually cleaned up, else the code will end up **LESS** readable. ## Javascript Follows "[Google Javascript Style Guide][javascript style page]" with 2 space indents to conform with Java code. Note that IDEA styles import at a global level such that sonatype-idea.xml will import both Java and Javascript style conventions. [java style pdf]: http://its.lnpu.edu.ua/edocs1/new_doc/en/Vermeulen%20A.The%20elements%20of%20Java%20style.2001.pdf [javascript style page]: https://google.github.io/styleguide/javascriptguide.xml ## Scala Follow [docs.scala-lang.org/style](https://docs.scala-lang.org/style/). See some [differences](java-scala-diff.md) from Java. # Checkstyle and PMD rules ## Version Support Note that versions prior to 16 will work with Java 8 projects. Versions starting with 17 are intended for use on Java 11 and later projects. ## Releasing After merging changes to the Checkstyle or PMD rulesets, a main snapshot build will run [here]( https://jenkins.ci.sonatype.dev/job/bnr/job/tools/job/codestyle/job/main-snapshot/ ). Ensure that passes, then run the release job [here]( https://jenkins.ci.sonatype.dev/job/bnr/job/tools/job/codestyle/job/release/ ). After building a new release, update any builds to use new rule versions as appropriate ## Usage ### Maven Sample Checkstyle ``` <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-checkstyle-plugin</artifactId> <version>3.1.2</version> <configuration> <consoleOutput>true</consoleOutput> <configLocation>sonatype/checkstyle-configuration.xml</configLocation> <includeTestSourceDirectory>true</includeTestSourceDirectory> </configuration> <executions> <execution> <goals> <goal>check</goal> </goals> </execution> </executions> <dependencies> <dependency> <groupId>com.puppycrawl.tools</groupId> <artifactId>checkstyle</artifactId> <version>8.42</version> </dependency> <dependency> <groupId>com.sonatype</groupId> <artifactId>checkstyle-checks</artifactId> <version>15</version> </dependency> </dependencies> </plugin> ``` PMD ``` <plugin> <artifactId>maven-pmd-plugin</artifactId> <version>3.10.0</version> <configuration> <linkXRef>false</linkXRef> <printFailingErrors>true</printFailingErrors> <includeTests>true</includeTests> <rulesets> <ruleset>pmd-ruleset/ruleset.xml</ruleset> </rulesets> </configuration> <executions> <execution> <goals> <goal>check</goal> </goals> </execution> </executions> <dependencies> <dependency> <groupId>com.sonatype</groupId> <artifactId>pmd-ruleset</artifactId> <version>3</version> </dependency> </dependencies> </plugin> ```

RandyAbernethy/ThriftBook

Source for the examples in the Programmer's Guide to Apache Thrift

2014-04-04T21:33:26Z

The Programmer's Guide to Apache Thrift ======================================= Source for the examples in: The Programmer's Guide to Apache Thrift http://www.manning.com/abernethy/ The book is organized into three parts: Part I - Apache Thrift Overview ------------------------------- A high level introduction to Apache Thrift and its architecture. Examples from this part are hello worldish. This part also covers basic Apache Thrift setup and debugging. Part II - Programming Apache Thrift ----------------------------------- This part digs into each layer of the Apache Thrift framework, examining transports, protocols, types, services, servers and the Apache Thrift interface definition language in detail. Examples from these chapters use C++, Java and Python as the demonstration languages. C++ examples provide makefiles and Java examples provide Build.xml files for building with make/ant respectively. Build scripts and code have been tested with various Apache Thrift versions. In general you should use the latest version of Apache Thrift. The Ant builds depend on SLF4J. The python examples are directly executable. You can checkout older version of this repo for examples compatible with older versions of Apache Thrift. Part III - Apache Thrift Language Libraries ------------------------------------------- This part of the book provides jump starts for the most popular platforms and languages used with Apache Thrift. The Web, and backend systems are examined through the lens of C++, Java, C#, JavaScript, Python, PHP, Perl and Ruby. Web chapters are complete or in-progress for Haxe, Go and Rust (code is/will-be found here). Part III also includes the final chapter, "Apache Thrift in the Enterprise", which demonstrates Apache Thrift in use with messaging systems and takes a pragmatic look at the key advantages of Apache Thrift and some of the common best practices for developing with the framework. Tools - Miscellaneous Thrift Stuff ---------------------------------- This folder is for various Thrift related stuff. Presently only a GEdit language file for Apache Thrift IDL. Development Environment ----------------------- The Dockerfile in the root of this repo defines a development environment for the book which will make it easy to build and test all of the examples in the book. This file is configured to support C++, Java and Python as built but it is easy to add additional language support to the container or similarly configured system by following the instruction in the book. Apache Thrift is undergoing an important change on the way to v1.0. - Switch out of the build platform (compiler and all libs) from autotools to cmake As things migrate I will update this Dockerfile. You can "$ docker run -it randyabernethy/thrift-book" to run the prebuilt image on Docker Hub (https://hub.docker.com/r/randyabernethy/thrift-book/). [](https://microbadger.com/images/randyabernethy/thrift-book "Thrift Book Layers")

PacktPublishing/Domain-Driven-Design-with-Java-A-Practitioner-s-Guide

Domain-Driven Design with Java - A Practitioner’s Guide, published by Packt

2020-09-06T14:18:03Z

# Domain-Driven Design with Java - A Practitioner’s Guide <a href="https://www.packtpub.com/programming/domain-driven-design-with-java-a-practitioner-s-guide?utm_source=github&utm_medium=repository&utm_campaign=9781800560734"><img src="https://static.packt-cdn.com/products/9781800560734/cover/smaller" alt="Domain-Driven Design with Java - A Practitioner’s Guide" height="256px" align="right"></a> This is the code repository for [Domain-Driven Design with Java - A Practitioner’s Guide](https://www.packtpub.com/programming/domain-driven-design-with-java-a-practitioner-s-guide?utm_source=github&utm_medium=repository&utm_campaign=9781800560734), published by Packt. **Create simple, elegant, and valuable software solutions for complex business problems** ## What is this book about? Domain-Driven Design (DDD) makes available a set of techniques and patterns that enable domain experts, architects, and developers to work together to decompose complex business problems into a set of well-factored, collaborating, and loosely coupled subsystems. This book covers the following exciting features: * Discover how to develop a shared understanding of the problem domain * Establish a clear demarcation between core and peripheral systems * Identify how to evolve and decompose complex systems into well-factored components * Apply elaboration techniques like domain storytelling and event storming * Implement EDA, CQRS, event sourcing, and much more * Design an ecosystem of cohesive, loosely coupled, and distributed microservices * Test-drive the implementation of an event-driven system in Java * Grasp how non-functional requirements influence bounded context decompositions If you feel this book is for you, get your [copy](https://www.amazon.com/dp/1800560737) today! <a href="https://www.packtpub.com/?utm_source=github&utm_medium=banner&utm_campaign=GitHubBanner"><img src="https://raw.githubusercontent.com/PacktPublishing/GitHub/master/GitHub.png" alt="https://www.packtpub.com/" border="5" /></a> ## Instructions and Navigations All of the code is organized into folders. For example, Chapter02. The code will look like the following: ``` interface PasswordService { String generateStrongPassword(); boolean isStrong(String password); boolean isWeak(String password); } ``` **Following is what you need for this book:** This book is for intermediate Java programmers looking to upgrade their software engineering skills and adopt a collaborative and structured approach to designing complex software systems. Specifically, the book will assist senior developers and hands-on architects to gain a deeper understanding of domain-driven design and implement it in their organization. Familiarity with DDD techniques is not a prerequisite; however, working knowledge of Java is expected. ## Errata * Page 28: Figure 1.21 is incorrect and the correct image is as follows: <img src="https://github.com/PacktPublishing/Domain-Driven-Design-with-Java-A-Practitioner-s-Guide/blob/master/value-object-example.png"> ## Pre-Requisites * JDK 14 * Maven 3.3+ ## Usage Convert the AsciiDoc to HTML5 by invoking the `process-resources` goal (configured as the default goal): $ mvn Open the file _target/generated-docs/main.html_ in your browser to see the generated HTML file containing the generated diagram images. ## Graphviz configuration Asciidoctor Diagram bundles both the ditaa and PlantUML libraries and will use them to generate diagrams. In order to generate diagrams using Graphviz, you must install it separately. There are two options to reference the installed Graphviz's _dot_ tool in order to generate diagrams: system's PATH or plug-in attributes configuration. ### Configuration via system's PATH Visit [Graphviz' site](http://www.graphviz.org/) for details on how to install the _dot_ command tool, and to make the _dot_ command available on your system's PATH. With the following software and hardware list you can run all code files present in the book (Chapter 1-12). ### Software and Hardware List | Chapter | Software required | OS required | | -------- | ------------------------------------ | ----------------------------------- | | 1-12 | Spring Framework | Windows/Linux/macOS | | 1-12 | Axon Framework | Windows/Linux/macOS | | 1-12 | JavaFX | Windows/Linux/macOS | We also provide a PDF file that has color images of the screenshots/diagrams used in this book. [Click here to download it](https://packt.link/TwzEB). ### Related products * AWS Penetration Testing [[Packt]](https://www.packtpub.com/product/aws-penetration-testing/9781839216923?utm_source=github&utm_medium=repository&utm_campaign=9781839216923) [[Amazon]](https://www.amazon.com/dp/1839216921) * Learn Kali Linux 2019 [[Packt]](https://www.packtpub.com/free-ebook/learn-kali-linux-2019/9781789611809?utm_source=github&utm_medium=repository&utm_campaign=9781789611809) [[Amazon]](https://www.amazon.com/dp/1789611806) ## Get to Know the Authors **Premanand (Prem) Chandrasekaran** is a technology leader and change agent with a solid track record of leading large technology teams and helping businesses deliver mission critical problems while exhibiting high internal and external quality. In the past two decades, he has had the pleasure of helping a variety of clients and domains ranging from financial services, online retailers, education, healthcare startups among others. His specialties include technical innovation, architecture, continuous delivery, agile/iterative transformation and employee development. When not fiddling with his trusty laptop, he spends time with his son ripping beyblades, playing video games and analyzing the nuances of cricket. **Karthik Krishnan** is a technology leader with over 25 years of experience in designing and building large-scale enterprise solutions across financial and retail domains. He has played numerous technical roles in leading product development for major financial institutions. He is currently serving the role of Technical Principal at Thoughtworks. He is passionate about platform thinking, solution architecture, application security and strives to be known as a coding architect. His most recent assignment entailed leading a large technology team helping their clients in their legacy modernization journey with Cloud. When not working, he spends time practicing playing tunes on his musical keyboard. ### Download a free PDF <i>If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.<br>Simply click on the link to claim your free PDF.</i> <p align="center"> <a href="https://packt.link/free-ebook/9781800560734">https://packt.link/free-ebook/9781800560734 </a> </p>

sucese/react-native

A user guide and principle analysis for React Native。Note：The project has been moved to https://github.com/guoxiaoxing/vinci

2017-02-07T03:32:24Z

# React Native <img src="https://github.com/guoxiaoxing/awesome-react-native/raw/master/art/react_native_banner.png" width="1000"/> **关于作者** >郭孝星，非著名程序员，主要从事Android平台基础架构与中间件方面的工作，欢迎交流技术方面的问题，可以去我的[Github](https://github.com/guoxiaoxing)提交Issue或者发邮件至guoxiaoxingse@163.com与我联系。 文章持续更新中... ## ReactNative基础篇 >本篇系列文章主要介绍ReactNative的基本组件以及一些基本用法。 - [011ReactNative基础篇：环境配置与编译](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative基础篇/01ReactNative基础篇：环境配置与编译.md) - 02ReactNative基础篇：基本概念 - 03ReactNative基础篇：基本组件-View - 04ReactNative基础篇：基本组件-Text、TextInput与Button - 05ReactNative基础篇：基本组件-ScrollView、ListView - 06ReactNative基础篇：基本组件-MapView - 07ReactNative基础篇：基本组件-WebView - 08ReactNative基础篇：基本组件-Modal - 09ReactNative基础篇：基本组件-Navigator - 10ReactNative基础篇：基本组件-Picker - 11ReactNative基础篇：基本组件-Slider - 12ReactNative基础篇：基本组件-Switch - 13ReactNative基础篇：基本组件-Touchable系列 - 14ReactNative基础篇：基本组件-DrawerLayoutAndroid - 15ReactNative基础篇：基本组件-ProgressBarAndroid - 16ReactNative基础篇：基本组件-ToolbarAndroid - 17ReactNative基础篇：基本组件-ViewPagerAndroid - 18ReactNative基础篇：网络请求 - 19ReactNative基础篇：网页浏览器、音视频媒体播放 ## ReactNative源码篇 >本篇系列文章主要分析ReactNative源码，分析ReactNative的启动流程、渲染原理、通信机制与线程模型等方面内容。 - [1ReactNative源码篇：源码初识](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative源码篇/1ReactNative源码篇：源码初识.md) - [2ReactNative源码篇：代码调用](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative源码篇/2ReactNative源码篇：代码调用.md) - [3ReactNative源码篇：启动流程](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative源码篇/3ReactNative源码篇：启动流程.md) - [4ReactNative源码篇：渲染原理](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative源码篇/4ReactNative源码篇：渲染原理.md) - [5ReactNative源码篇：线程模型](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative源码篇/5ReactNative源码篇：线程模型.md) - [6ReactNative源码篇：通信机制](https://github.com/guoxiaoxing/react-native/blob/master/doc/ReactNative源码篇/6ReactNative源码篇：通信机制.md) ## ReactNative基础篇 >本篇系列文章主要从性能优化、崩溃监测等方面进一步阐述ReactNative在生产环境下的最佳实践以及改进优化。 - 01ReactNative实践篇：架构实践 - 02ReactNative实践篇：性能优化 - 03ReactNative实践篇：崩溃监测 ## 附录 ### React Native优秀资料 推荐一些关于React Native的比较高质量资料。 - [Awesome React Native](https://github.com/jondot/awesome-react-native)：Awesome React Native components, news, tools, and learning material! - [react-native-guide](https://github.com/reactnativecn/react-native-guide)：React Native指南汇集了各类react-native学习资源、开源App和组件 - [fangwei716/30-days-of-react-native](https://github.com/fangwei716/30-days-of-react-native) - [fbsamples/f8app](https://github.com/fbsamples/f8app) - [构建 F8 App / React Native 开发指南](https://f8-app.liaohuqiu.net/) ### React Native技术分享 前段时间在公司分享会上做了关于React Native实现原理的分享，以下是分享会的PPT。 <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片01.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片02.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片03.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片04.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片05.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片06.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片07.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片08.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片09.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片10.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片11.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片12.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片13.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片14.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片15.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片16.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片17.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片18.png"/> <img src="https://github.com/guoxiaoxing/react-native/raw/master/art/source/ppt/幻灯片19.png"/>

wimdeblauwe/spring-boot-building-api-backend

Code of the 'Practical Guide to Building an API Back End with Spring Boot' book

2018-09-18T19:07:17Z

ravi2519/JavaCertification

This is a full resource guide for my attempt to get Java 11 Certified

2020-09-15T05:28:49Z

  # Java 11 Certification Hi there! So this is a complete resource guide for my attempt to get Java 11 Certified. On the 18th, January 2021, I passed my "Oracle Certified Professional: Java SE 11 Developer" certification. # Old Rules So I started my journey to get certified in Java 11 to receive Oracle Certified Professional Java SE 11 Developer credentials. Before 1st, October 2020, it was fairly a two-step process: - [Take a 815 exam](https://education.oracle.com/java-se-11-programmer-i/pexam_1Z0-815) Post 1st, October 2020, it is displaying a 404. - [And a 816 exam](https://education.oracle.com/java-se-11-programmer-i/pexam_1Z0-816) Post 1st, October 2020, it is displaying a 404. Both costs approximately 11,300 INR each and covers a different set of the syllabus. You have to purchase the exam voucher from Oracle for each one of these. The voucher will be valid for the next 6 months. And during this period, you can schedule the exam anytime. I did that too, but as soon as I was prepared for 815, THE Oracle changed the game. They were retiring both 815 and 816 in favor of 819. ## Oracle did it again!! And as if 2020 was less weird, Oracle discontinued Java certification test 815 and 816. And in place of it, Java Test 819 was introduced. [The new 819 exam](https://education.oracle.com/java-se-11-developer/pexam_1Z0-819) ## Few features of this new exam - It is a 90 min exam as compared to 180 min ( for 815 and 816 each ). - The total number of questions is reduced to 50, and you need to mark 34 questions correctly to pass. - It costs approximately **18,538 INR** plus taxes. - Covers almost all the topics from exam 815 and 816, with few exceptions. Check out the [819](https://education.oracle.com/java-se-11-developer/pexam_1Z0-819) links for a detailed syllabus. - You will receive "Oracle Certified Professional: Java SE 11 Developer" as Oracle recognition. # Important Topics Below are the list of some of important topics and resources that is used to prepare them. ## Stream, Lambdas and Funtional Interfaces - [Streams, Lambdas, Functional Interfaces](https://www.linkedin.com/learning/functional-programming-with-streams-in-java-9) - [Stream API Java 8](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html) - [Stream Operations](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#StreamOps) - [Stream Tutorial](https://www.baeldung.com/java-8-streams) - [Processing Data with Java SE 8 Streams](https://www.oracle.com/technical-resources/articles/java/ma14-java-se-8-streams.html) - [Method detail of Object class](https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html) This is important because many times we are asked to identify a Function Interface and an inteface with no abstract method and a Object class method is not a function interface. ## Secure Coding in Java SE Application  - [Oracle Secure Coding Guide](https://www.oracle.com/java/technologies/javase/seccodeguide.html#9) # Mock Tests - [Enthuware 819 Mock Test](https://enthuware.com/java-certification-mock-exams/oracle-certified-professional/ocp-java-11-exam-1z0-819) - [Enthuware 816 Mock Test](https://sites.fastspring.com/enthuware/product/1z0816) - [Java Certification (1Z0-815) Topic-wise Tests [2020]](https://www.udemy.com/course/java-11_1z0-815/) - [Java Certification (1Z0-815) Exam Simulation [2020]](https://www.udemy.com/course/java-se-11_1z0-815/) - [Java SE Programmer II (1Z0-816) - Practice Test](https://www.udemy.com/course/java-se-programmer-ii-1z0-816-practice-test/) - [815 free test trial](https://certify.cybervista.net/products/oracle/java-se-11-programmer-i-ocp-free-trial/) # Helpful resources from Oracle - [815 and 816 Study Guide and Sample Questions](https://www.oracle.com/a/ocom/img/dc/ww-java11-programmer-study-guide.pdf?intcmp=WWOUCERTBLOGECBYK051720) - [List of Java Features Added from Java 8 to Java 14](https://ondro.inginea.eu/index.php/new-features-between-java-8-and-java-14/) - [Java Quizzes](https://blogs.oracle.com/javamagazine/quiz-2) - [More than 6 hours of free training by Oracle Universtity](https://learn.oracle.com/ols/module/overview/40805/79727) # Github Resources from my fellow wanderers - [Contains examples and 8008 dumps](https://github.com/springapidev/java-certification) - [Java Certification 815](https://github.com/mariazevedo88/java-certification-oca) - [808, 809 and older PDF files](https://github.com/MohamedDhiaJemai/Books-to-Prepare-Oracle-Java-Certification-Exams) - [OCA and OCP/808 and 809](https://github.com/egenerat/java-8-certification) - [All about modules - some handy modules command-lines](https://github.com/boyarsky/sybex-1Z0-815-chapter-11) # OCP 819 Stories - [Enthuware](https://enthuware.com/oca-ocp-java-certification-resources/255-java-certification-819-experience) - [Jeanne Boysky](https://www.selikoff.net/2020/09/26/jeannes-experience-taking-the-1z0-819-in-the-time-of-covid-19/) - [Scot Selikoff](https://www.selikoff.net/2020/10/06/taking-the-1z0-819-exam-study-everything-and-watch-the-clock-part-2-of-2/) # Coderanch - [OCJCP Page](https://coderanch.com/f/24/java-programmer-OCPJP) - [OCJCP Wall Of Fame](https://coderanch.com/wiki/659976/OCPJP-Wall-Fame) - [OCP 11 FAQ](https://coderanch.com/wiki/707568/certification/OCP-FAQ) # Most recommended! - Selikof/Boyarsky book ( Oracle Certified Professional: Java SE 11 Developer : Complete Study Guide) - [Enthuware 819 Mock Test](https://enthuware.com/java-certification-mock-exams/oracle-certified-professional/ocp-java-11-exam-1z0-819) # Java Code in this Respository - [Basic](https://github.com/ravi2519/JavaCertification/tree/master/basics) : Inheritance, Arrays, Final, Initialization, Overloading, Overriding, Primitives, etc. - [Advanced](https://github.com/ravi2519/JavaCertification/tree/master/advanced) : Annotations, Collections, Concurrency, Enums, Exceptions, Functional Interfaces, Generics, Inner Classes, NIO2, etc - [Streams](https://github.com/ravi2519/JavaCertification/tree/master/streams)

effective-software-testing/code

The code examples of the Effective Software Testing: A Developer's Guide" book"

2021-10-17T09:47:49Z

# Effective software testing  This repository contains the code examples of the _Software Testing: A Developer's Guide_ book, by [Maurício Aniche](https://www.mauricioaniche.com). Each folder contains the code examples of their respective chapter: * Chapter 1: Effective and systematic software testing * Chapter 2: Specification-based testing * Chapter 3: Structural testing and code coverage * Chapter 4: Design by Contracts * Chapter 5: Property-based testing * Chapter 6: Test doubles and mocks * Chapter 7: Designing for testability * Chapter 8: Test-Driven Development * Chapter 9: Larger tests * Chapter 10: Test code quality Each folder is an independent maven project. You should be able to import the project directly in your favorite IDE (e.g., InteliiJ, Eclipse). You can also run all the tests via `mvn test`. To run code coverage in chapter 3, go to the ch3 folder and type `mvn clean test jacoco:report`. Then, open the `target/site/jacoco/index.html` file to see the report. If you want to run the mutation coverage, type `mvn clean compile test-compile pitest:mutationCoverage`. The report will be generated in the `target/pit-reports/**/index.html`, where `**` is a string that represents the date time that you ran the report. For Linux or Mac users, I provide bash scripts `coverage.sh` and `mutation.sh` that run the commands above for you. To run the web tests of chapter 9, you first should run the [Spring PetClinic](https://github.com/spring-projects/spring-petclinic) application. For convenience, we provide a compiled jar here. To run the web app, just go to the ch9 folder and type `java -jar *.jar`. ## Contributing to PRs Maybe you found a test I missed or a better way to implement the code. You are most welcome to submit your PRs! If you do so, I ask you to create another file, with the same name as the original plus some suffix, and add a comment explaining what you did there. I do not want to touch the original files as they match with the code snippets in the book; we do not want readers to get lost. ## License and reuse You are free to reuse and modify the code provided in this repository, for personal or business purposes, as long as the book is always explicitly mentioned as reference. For example, if you are providing training or workshops, you are required to have a dedicated slide with the picture of the book in each of the slide decks that make use of examples from here.

silverbullettt/zipper

Precision-guided context sensitivity for pointer analysis

2018-10-11T12:32:42Z

This is the implementation of the techniques called ZIPPER and ZIPPER-e. ZIPPER is proposed in our OOPSLA'18 paper "[Precision-Guided Context Sensitivity for Pointer Analysis](https://silverbullettt.bitbucket.io/papers/oopsla2018.pdf)", which is the first research work that shows how and where most imprecision is introduced in a context-insensitive pointer analysis. By applying context sensitivity only to the precision-critical methods identified by ZIPPER (context insensitivity to other methods), ZIPPER enables a conventional context-sensitive pointer analysis (e.g., 2-object-sensitivity) to run much faster while retaining essentially all of its precision. The artifact of our paper can be downloaded from [here](http://www.brics.dk/zipper/OOPSLA18-Artifact-Zipper.tar.gz). Based on ZIPPER, we proposed ZIPPER-e (short for ZIPPER-express) in our TOPLAS'20 paper "[A Principled Approach to Selective Context Sensitivity for Pointer Analysis](https://silverbullettt.bitbucket.io/papers/toplas2020.pdf)", which exhibits extremely good efficiency with high precision. **Note: Now we have integrated both ZIPPER and ZIPPER-e in [Tai-e](https://github.com/pascal-lab/Tai-e), an easy-to-learn/use static analysis framework for Java. We recommend you using ZIPPER/ZIPPER-e in [Tai-e](https://github.com/pascal-lab/Tai-e).** To demonstrate the usefulness of ZIPPER and ZIPPER-e to pointer analysis, we have integrated them with [DOOP](https://bitbucket.org/yanniss/doop) ([PLDI'14 artifact version](http://cgi.di.uoa.gr/~smaragd/pldi14ae/pldi14-ae.tgz)), a state-of-the-art context-sensitive points-to analysis framework for Java. For your convenience, this repository also contains the DOOP framework with ZIPPER and ZIPPER-e integrated. This tutorial introduces how to build and use ZIPPER and ZIPPER-e together with DOOP. ## Requirements - A 64-bit Ubuntu system - A Java 8 distribution - A Python 2.x interpreter Please set your `JAVA_HOME` environment variable to point to your Java installation directory. ## Building ZIPPER and ZIPPER-e We have provided a pre-compiled jar of ZIPPER and ZIPPER-e, i.e., `zipper.jar` (this jar also includes ZIPPER-e) in the directory `zipper/build/`. To build them by yourself, you just need to switch to the `zipper/` directory and run script: `$ ./compile.sh` The generated `zipper.jar` will be placed in `zipper/build/` and overwrite the previous one. ## DOOP Framework Now we introduce how to use DOOP together with ZIPPER and ZIPPER-e. ### Installing Datalog Engine To run DOOP framework, you need to install a LogicBlox engine for interpreting the Datalog rules used in DOOP. If you already have such engine installed (e.g., LogicBlox v3.9.0), you can skip this section. Otherwise, you can use PA-Datalog engine, a port available for academic use. The download link and installation instructions of PA-Datalog can be found on [this page](http://snf-705535.vm.okeanos.grnet.gr/agreement.html) (We recommend `.deb` package installation). ### Running DOOP Please first change your current directory to `doop/` folder. The command of running DOOP is: `$ ./run -jre1.6 <analysis> <program-jar-to-analyze>` For example, to analyze `foo.jar` with 2-object-sensitive analysis, just type: `$ ./run -jre1.6 2-object-sensitive+heap foo.jar` You can check all the supported `<analysis>` and other options with `./run -h`. ### Running DOOP with ZIPPER The usage of running ZIPPER-guided pointer analysis is exactly same as the DOOP's usage, except that you need to change the driver script from `run` to `run-zipper.py`. For example, the command to run ZIPPER-guided 2-object-sensitive analysis for `foo.jar` is: `$ ./run-zipper.py -jre1.6 2-object-sensitive+heap foo.jar` Such command first runs a context-insensitive pointer analysis as pre-analysis, then executes ZIPPER to compute and output precision-critical methods, and finally runs the main analysis (`2-object-sensitive+heap` in this case), which applies context sensitivity to only the precision-critical methods output by ZIPPER. ### Running DOOP with ZIPPER-e To guide pointer analysis by ZIPPER-e, you just need to add option `-e` when running `run-zipper.py`. For example, the command to run ZIPPER-e-guided 2-object-sensitive analysis for `foo.jar` is: `$ ./run-zipper.py -e -jre1.6 2-object-sensitive+heap foo.jar`

husseinterek/spring-boot-jpa-hibernate

This is a very simple guide for integrating Hibernate with Spring Boot application.

2018-04-13T10:05:25Z

PacktPublishing/Spring-MVC-Beginners-Guide-Second-Edition

Code repository for Spring MVC Beginner's Guide Second Edition, published by Packt

2016-07-27T11:58:00Z

# Spring-MVC-Beginners-Guide-Second-Edition By Packt This is the code repository for [Spring MVC Beginner's Guide Second Edition](https://www.packtpub.com/application-development/spring-mvc-beginners-guide-second-edition), published by [Packt Publishing](https://www.packtpub.com/). It contains all the required files to run the code. The book is for Java developers who want to exploit Spring MVC and its features to build web applications ###Software Requirements *Java Platform (JDK) 8u91/8u92 *Apache-Maven-3.3.9 *Tomcat 8.0 *STS 3.7.3.RELEA SE *Postman Chrome App ###Related Books *[Instant Spring Tool Suite](https://www.packtpub.com/application-development/instant-spring-tool-suite?utm_source=github&utm_medium=repository&utm_campaign=9781782164142) *[Spring Web Services 2 Cookbook](https://www.packtpub.com/web-development/spring-web-services-2-cookbook?utm_source=github&utm_medium=repository&utm_campaign=9781849515825) *[Spring Security 3.1](https://www.packtpub.com/application-development/spring-security-31?utm_source=github&utm_medium=repository&utm_campaign=9781849518260)

npryce/goos-code-examples

Code examples from later chapters of Growing Object-Oriented Software, Guided by Tests

2010-01-03T18:33:36Z

windfone/DynamicIcon

DynamicIcon/glide/guide

2022-06-06T03:49:55Z

# DynamicIcon APP动态替换Icon(避免杀进程 应用未安装等弊端)/glide预加载/guide引导弹窗

cchesser/java-perf-workshop

Guided walkthrough to understand the performance aspects of a Java web service

2015-06-18T02:27:25Z

## Java Performance Workshop A tutorial workshop that will dive in understanding "what's going on in your JVM". This workshop is utilizing a basic web service that is included, which isn't exactly optimal in how it performs. The goal is to use this service as an interactive example and identify its poor performing elements. To learn more about this web service that is included, see [the site](https://jvmperf.net/).

jeffreyscarpenter/reservation-service

Sample microservice implementation based on reservation data model from Cassandra: The Definitive Guide, 2nd/3rd Ed

2017-05-29T01:49:04Z

# reservation-service This repository provides a sample microservice implementation based on the reservation data model from the O'Reilly book [Cassandra: The Definitive Guide, 3rd Edition](https://www.amazon.com/Cassandra-Definitive-Guide-Distributed-Scale/dp/1098115163)  See especially Chapter 7: "Designing Applications with Cassandra", which describes the design of the service, and Chapter 8: "Application Development with Drivers", which covers the implementation. ## Overview The goal of this project is to provide a minimally functional implementation of a microservice that uses Apache Cassandra for its data storage via the DataStax Java Driver. The Reservation Service is implemented as a RESTful service using Spring Boot and exposes it's API via Swagger.  This service leverages the [reservation schema][schema] developed in the book, based on the data model shown here:  If you'd like to understand more about the motivation behind this design, you can access the data modeling chapter from the book for free at the [O'Reilly website][chapter]. ## Requirements This service runs on Java 11 or [12](https://jdk.java.net/12/) and uses the [DataStax Java Driver][driver]. ## <a name="runservice">Running the Reservation Service</a> The Reservation Service requires a Cassandra cluster consisting of least one node. Here are some different options for running the Reservation Service: - Option 1: Run Cassandra and the Reservation Service in Docker with `docker-compose` command. - Build the application by running `./mvnw compile` - `docker-compose up` if you want to follow the logs **OR** - `docker-compose up -d` to start all containers in detached mode. - Option 2: Running using Spring boot against a local Cassandra instance - Confirm the default JDK is version 11 or later - Download binaries for your platform from http://cassandra.apache.org/download/ - Unzip the archive, for example `tar xvf apache-cassandra-3.11.6-bin.tar.gz some-directory` - Start Cassandra by running `bin/cassandra` - Start spring-boot app by running `./mvnw spring-boot:run` ## Swagger API Once the application is running, you can access the Swagger API at `localhost:8080`. ## Running Tests The test suite for the Reservation Service uses the [Test Containers][testcontainers] project to start a Cassandra node in Docker. You'll want to shut down any infrastructure you created above under [Running the Reservation Service](#runservice). Run the test suite with the Maven `test` target: `./mvnw test` ## Exercises This repository is configured with branches that represent the start point and solution for various exercises used in an online course taught periodically with [O'Reilly Live Training][live-training]. These exercises remove some of the application code and require you to add it back in to get the service back to a functional state. There are exercises to help you learn the various ways of executing statements, such as `SimpleStatement`, `PreparedStatement`, `QueryBuilder` and the Object Mapper. Other exercises teach you how to use batches, lightweight transactions and materialized views. To work on an exercise, select the branch that represents the start point of the exercise, for example: `git checkout simple-statement`. Then search through the code and complete the `TODO` items and run the service again until the service is working. You can view the solution code for a given exercise in the `_solution` branch, for example `git checkout simple-statement-solution`. This repository was updated beginning in July 2019 to use the DataStax Java Driver Version 4.x series. Branches beginning with `old_` represent exercises from a prior version of the course and use the 2.x Driver. ## Disclaimers This service has a couple of shortcomings that would be inappropriate for a production-ready service implementation: - There is minimal data validation - There is minimal handling of fault cases - The schema makes use of Strings as identifiers instead of UUIDs With respect to that last point about UUIDs: for this service I take the same approach that I did for the book. When working with small scale examples, it is simpler to deal with IDs that are human readable strings. If I were intending to build a real system out of this or even implement more of the "ecosystem" of services implied by the book's data model, I would move toward using UUIDs for identifiers. For more of my thinking on this topic, please read the [Identity blog post][identity] from my [Data Model Meets World][dmmw] series. ## Credits I found [this tutorial][tutorial] helpful in getting this implementation up and running quickly. Special thanks to [Cedrick Lunven][clun] for his help in modernizing this app. Comments, improvements and feedback are welcome. Copyright 2017-2020 Jeff Carpenter Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. [tutorial]: http://www.springboottutorial.com/creating-rest-service-with-spring-boot [schema]: /src/main/resources/reservation.cql [dmmw]: https://medium.com/@jscarp/data-model-meets-world-c67a46681b39 [identity]: https://medium.com/@jscarp/data-model-meets-world-part-ii-identity-crisis-d517d3d4c39a [chapter]: https://www.oreilly.com/ideas/cassandra-data-modeling [driver]: https://docs.datastax.com/en/developer/java-driver/4.1/ [docker-hub]: https://hub.docker.com/_/cassandra [live-training]: https://www.oreilly.com/live-training/ [clun]: https://github.com/clun [testcontainers]: https://www.testcontainers.org/

Kingsford-Group/kourami

Kourami: Graph-guided assembly for HLA alleles

2017-04-12T15:21:06Z

<pre> -hhy+. o o o o o o o o o o .` -syss:---.` o o o o o o o o o o o o o :+:` .:/o+++++///ommy+` o _ __ _ `yhs/..:osssooooo++++dmNNNdo` o | |/ /___ _ _ _ __ __ _ _ __ ___ (_) /syy///++++ooooooooodNMdNdmh: o | ' // _ \| | | | '__/ _` | '_ ` _ \| | -do/` .://++++++++oodmmmmmmd- | . \ (_) | |_| | | | (_| | | | | | | | .+: `.://///+///ommmmdy- |_|\_\___/ \__,_|_| \__,_|_| |_| |_|_| . -syo----..`` +y+. </pre> # Overview Kourami is a graph-guided assembler for HLA haplotypes covering typing exons (exons 2 and 3 for Class I and exon 3 for Class II) using high-coverage whole genome sequencing data. Kourami constructs highly accurate haplotype sequences at 1-bp resolution by first encoding currently available HLA allelic sequences from IPD-IMGT/HLA Database ( http://www.ebi.ac.uk/ipd/imgt/hla/ ) as partial-ordered graphs. Each database allele is naturally encoded as a path through the graph and any detectable genetic variations (SNPs or indels) not captured by the known sequences are added to the graph by graph-modification based on read alignment to capture differences novel alleles have compared to known sequences. Unlike previously available WGS-based HLA typing methods (database-matching techniques), Kourami direclty assembles both haplotypes for each HLA gene (HLA-A, -B, -C, -DQA1, -DQB1, -DRB1). From version 0.9.4 or later, Kourami supports additional HLA loci. It also provides the typing result (6-digit 'G' resolution) by outputing the best matching alleles among the known sequences whenever 'G' grouping information is available. # Release The latest release, including both jar and source code can be downloaded from [here](https://github.com/Kingsford-Group/kourami/releases/latest). # Support Kourami is, and will continue to be, [freely and actively supported on a best-effort basis](https://oceangenomics.com/about/#open). If you need industrial-grade technical support, please consider the options at [oceangenomics.com/support](http://oceangenomics.com/support). # Installation To install Kourami, you must have following installed on your system: - JDK 1.8+ - Apache Maven (3.3+) or Apache Ant (1.9+) is required (we **recommend Maven** for easy dependency downloads) - OR you must have dependencies downloaded and added to your CLASSPATH. Then you can compile using javac. - To use Ant, you must have dependencies downloaded and place jars under 'exjars' directory. 'exjars' directory must be created. -A copy of the preformatted IMGT-HLA database (Kourami panel) can be obtained using a script. The panel sequence file needs to be bwa indexed before using and this is NOW done by the script when it downloads the database. The script will download and install the database under ```db``` directory under the Kourami installation directory. The download and index script can be run from the kourami installation directory: ``` scripts/download_panel.sh ``` [MAVEN USERS] To compile and generate a jar file run the following command from the kourami directory where pom.xml is located. ``` mvn install ``` [ANT USERS] To compile and generate a jar file run the following command from the kourami directory where build.xml is located. ``` ant compile jar ``` This will create a "target" directory and place a packaged jar file in it. # Usage ``` java -jar <PATH_TO>/Kourami.jar [options] <bam-1> ... <bam-n> ``` NOTE: kourami jar takes a **bam aligned to Kourami reference panel built from IMGT/HLA db** (included in the preformatted IMGT-HLA database). Detailed notes on how to generate input bam consisting of HLA loci reads aligned to known alleles is explained in [How to prepare input bam and HLA panel for Kourami](https://github.com/Kingsford-Group/kourami/blob/master/preprocessing.md). Option Tag | Description ----------------------- | ----------------------------- -h,--help | print this message -d,--msaDirectory \<path> | build HLAGraph from gen and nuc MSAs provided by IMGT/HLA DB from given directory (required). Can be downloaded by running ```scripts/download_panel.sh```. -o,--outfilePrefix \<outfile> | use given outfile prefix for all output files (required) -a,--additionalLoci | type additional loci (optional) # Output \<outfileprefix>.result contains the typing result and the columns are: 1: Allele 2: #BasesMatched 3: Identity (#BasesMatched/MaxLen(query, db_allele)) 4: Length of the assembled allele 5: Length of the matched allele from IMGT/HLA DB 6: Combined bottleneck weights of both paths at a position. This is not necessarily same as the sum of column 7 and 8. 7: Weight of the bottleneck edge in path 1 8: Weight of the bottleneck edge in path 2 Note: Given a path, a bottleneck edge is an edge with the minimal weight. For an allele, there are always two entries (lines) reported in the result file. Path 1 is reported first, and path 2 is reported in the following line. The columns 6 7 8 are going to be redundant (same) for both lines. \<outfileprefix> contiains program log Assembled allele sequences are outputed in files ending with .typed.fa (multi-FASTA format) # Dependencies Dependecies can be easily downloaded by using Maven install command. In each release, the pre-compiled jar is distributed with all necessary jars for dependencies, and they are: - JGraphT 0.9.1 ( http://jgrapht.org/ ) - Apache Commons CLI 1.4 ( https://commons.apache.org/proper/commons-cli/ ) - fastutil 7.0.13 : Fast & compact type-specific collections for Java ( http://fastutil.di.unimi.it/ ) # How to cite Kourami Please cite our [paper](https://genomebiology.biomedcentral.com/articles/10.1186/s13059-018-1388-2) available on Genome Biology: Lee, H., & Kingsford, C. Kourami: graph-guided assembly for novel human leukocyte antigen allele discovery. *Genome Biology* 19(16), 2018

alblue/com.packtpub.e4

Code samples for the Eclipse Plugin Development by Example: Beginners Guide" book 978-1782160328"

2013-06-05T22:32:41Z

Eclipse Plugin Development by Example: Beginner's Guide ======================================================= This repository contains source code for the Packt Publishing book "Eclipse Plugin Development by Example: Beginners Guide". Tags and branches are available for both versions. https://www.amazon.co.uk/s/ref=dp_byline_sr_book_1?ie=UTF8&text=Dr+Alex+Blewitt&search-alias=books-uk&field-author=Dr+Alex+Blewitt&sort=relevancerank Second Edition -------------- * ISBN-10: 1783980699 * ISBN-13: 978-1-78398-069-7 *Chapters* Chapter 1: [Creating your first Plug-in](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter1) Chapter 2: [Creating Views with SWT](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter2) Chapter 3: [Creating JFace Viewers](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter3) Chapter 4: [Interacting with the User](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter4) Chapter 5: [Working with Preferences](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter5) Chapter 6: [Working with Resources](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter6) Chapter 7: [Creating Eclipse 4 Applications](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter7) Chapter 8: [Migrating to Eclipse 4](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter8) Chapter 9: [Styling Eclipse 4 Applications](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter9) Chapter 10: [Creating Features, Update Sites, Applications and Products](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter10) Chapter 11: [Automated Testing of Plug-ins](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter11) Chapter 12: [Automated Builds with Tycho](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter12) Chapter 13: [Contributing to Eclipse](https://github.com/alblue/com.packtpub.e4/tree/edition2/chapter13) First edition ------------- * ISBN-10: 1782160329 * ISBN-13: 978-1-78216-032-8 Contents -------- Chapter 1: [Creating your first Plug-in](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter1) Chapter 2: [Creating Views with SWT](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter2) Chapter 3: [Creating JFace Viewers](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter3) Chapter 4: [Interacting with the User](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter4) Chapter 5: [Storing Preferences and Settings](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter5) Chapter 6: [Working with Resources](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter6) Chapter 7: [Understanding the Eclipse 4 Model](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter7) Chapter 8: [Creating Features, Update Sites, Applications and Products](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter8) Chapter 9: [Automated Testing of Plug-ins](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter9) Chapter 10: [Automated Builds with Tycho](https://github.com/alblue/com.packtpub.e4/tree/edition1/chapter10) Contact ------- Follow me on Twitter @alblue, or mail alex.blewitt@gmail.com. My blog is at https://alblue.bandlem.com/ LICENSE ------- Code examples are licensed under the Eclipse Public License, version 1.0 as contained in the LICENSE.html file

checkstyle/checkstyle

Checkstyle is a development tool to help programmers write Java code that adheres to a coding standard. By default it supports the Google Java Style Guide and Sun Code Conventions, but is highly configurable. It can be invoked with an ANT task and a command line program.

2013-08-31T02:05:05Z

#  Checkstyle is a tool for checking Java source code for adherence to a Code Standard or set of validation rules (best practices). [![][travis img]][travis] [![][appveyor img]][appveyor] [![][circleci img]][circleci] [![][cirrusci img]][cirrusci] [![][coverage img]][coverage] [![][snyk img]][snyk] [![][semaphoreci img]][semaphoreci] [![][azure img]][azure] [![][error prone img]][error prone] [![][pitest img]][pitest] [![][checker framework img]][checker framework] [![][dependabot img]][dependabot] [![][mavenbadge img]][mavenbadge] [![][sonar img]][sonar] [![][release notes/version img]][release notes/version] [![][closed issues img]][closed issues] [![][link check img]][link check] [![][milestone img]][milestone] Contributors chat: [![][matrix_con img]][matrix_con] The latest release version can be found at [GitHub releases](https://github.com/checkstyle/checkstyle/releases/) or at [Maven repo](https://repo1.maven.org/maven2/com/puppycrawl/tools/checkstyle/). Each-commit builds of maven artifacts can be found at [Maven Snapshot repository](https://oss.sonatype.org/content/repositories/snapshots/com/puppycrawl/tools/checkstyle/). Documentation is available in HTML format, see https://checkstyle.org/checks.html. ## Build instructions and Contribution [Build instructions](https://checkstyle.org/contributing.html#Build) [Setup IDE for development](https://checkstyle.org/beginning_development.html) [Explanation on how to create your own module](https://checkstyle.org/extending.html) [Verification of code quality](https://checkstyle.org/contributing.html#Quality_matters) [Sending Pull Request](https://checkstyle.org/contributing.html#Submitting_your_contribution) [Report Issue](https://checkstyle.org/contributing.html#Report_an_issue) ## Continuous integration and Quality reports See our CIs statuses. Quality reports: https://checkstyle.org/project-reports.html JavaScript, CSS and Java source file analysis on Codacy: [![][codacy img]][codacy] ## Feedback/Support Please send any feedback to https://groups.google.com/forum/?hl=en#!forum/checkstyle Questions and Answers from community: [![][stackoverflow img]][stackoverflow] Bugs and Feature requests (not the questions): https://github.com/checkstyle/checkstyle/issues ## Support/Sponsor checkstyle If you want to speed up fixing of issue and want to encourage somebody in internet to resolve any issue: [![][flattr img]][flattr] [![][liberapay img]][liberapay] [![][backers.opencollective img]][backers.opencollective] [![][sponsors.opencollective img]][sponsors.opencollective] ## Licensing [![][license img]][license] This software is licensed under the terms in the file named "LICENSE" in this directory. The software uses the ANTLR package (https://www.antlr.org/). Its license terms are in the file named "RIGHTS.antlr" in this directory. This product includes software developed by The Apache Software Foundation (https://www.apache.org/). The software uses the Logging and Beanutils packages from the Apache Commons project (https://commons.apache.org/). The license terms of these packages are in the file named "LICENSE.apache20" in this directory. The software uses the Google Guava Libraries (https://github.com/google/guava/). The license terms of these packages are in the file named "LICENSE.apache20" in this directory. The software uses the Picocli Library (https://github.com/remkop/picocli/). Its license terms are in the file named "LICENSE.apache20" in this directory. [travis]:https://travis-ci.com/github/checkstyle/checkstyle/builds [travis img]:https://api.travis-ci.com/checkstyle/checkstyle.svg [appveyor]:https://ci.appveyor.com/project/checkstyle/checkstyle/history [appveyor img]:https://ci.appveyor.com/api/projects/status/rw6bw3dl9kph6ucc?svg=true [sonar]:https://sonarcloud.io/dashboard?id=org.checkstyle%3Acheckstyle [sonar img]:https://sonarcloud.io/api/project_badges/measure?project=org.checkstyle%3Acheckstyle&metric=sqale_index [codacy]:https://www.codacy.com/app/checkstyle/checkstyle [codacy img]:https://api.codacy.com/project/badge/3adf12d434314ba8b38277ea46d3c44b [coverage]:https://codecov.io/github/checkstyle/checkstyle?branch=master [coverage img]:https://codecov.io/github/checkstyle/checkstyle/coverage.svg?branch=master [license]:LICENSE [license img]:https://img.shields.io/badge/license-GNU%20LGPL%20v2.1-blue.svg [mavenbadge]:https://search.maven.org/search?q=g:%22com.puppycrawl.tools%22%20AND%20a:%22checkstyle%22 [mavenbadge img]:https://img.shields.io/maven-central/v/com.puppycrawl.tools/checkstyle.svg?label=Maven%20Central [matrix_con]:https://app.element.io/#/room/#checkstyle_checkstyle:gitter.im [matrix_con img]:https://matrix.to/img/matrix-badge.svg [stackoverflow]:https://stackoverflow.com/questions/tagged/checkstyle [stackoverflow img]:https://img.shields.io/badge/stackoverflow-CHECKSTYLE-blue.svg [teamcity]:https://teamcity.jetbrains.com/viewType.html?buildTypeId=Checkstyle_IdeaInspectionsMaster [teamcity img]:https://teamcity.jetbrains.com/app/rest/builds/buildType:(id:Checkstyle_IdeaInspectionsMaster)/statusIcon [circleci]: https://circleci.com/gh/checkstyle/checkstyle/tree/master [circleci img]: https://circleci.com/gh/checkstyle/checkstyle/tree/master.svg?style=svg [cirrusci]: https://cirrus-ci.com/github/checkstyle/checkstyle [cirrusci img]: https://api.cirrus-ci.com/github/checkstyle/checkstyle.svg?branch=master [snyk]: https://snyk.io/test/github/checkstyle/checkstyle?targetFile=pom.xml [snyk img]: https://snyk.io/test/github/checkstyle/checkstyle/badge.svg [semaphoreci]: https://checkstyle.semaphoreci.com/projects/checkstyle [semaphoreci img]: https://checkstyle.semaphoreci.com/badges/checkstyle/branches/master.svg?style=shields [flattr]:https://flattr.com/submit/auto?fid=g39d10&amp;url=https%3A%2F%2Fcheckstyle.org [flattr img]:https://button.flattr.com/flattr-badge-large.png [azure]:https://dev.azure.com/romanivanovjr/romanivanovjr/_build/latest?definitionId=1&branchName=master [azure img]:https://dev.azure.com/romanivanovjr/romanivanovjr/_apis/build/status/checkstyle.checkstyle?branchName=master [liberapay]:https://liberapay.com/checkstyle/ [liberapay img]:https://liberapay.com/assets/widgets/donate.svg [backers.opencollective]:https://opencollective.com/checkstyle/ [backers.opencollective img]:https://opencollective.com/checkstyle/backers/badge.svg [sponsors.opencollective]:https://opencollective.com/checkstyle/ [sponsors.opencollective img]:https://opencollective.com/checkstyle/sponsors/badge.svg [dependabot]:https://dependabot.com [dependabot img]:https://api.dependabot.com/badges/status?host=github&repo=checkstyle/checkstyle [closed issues]:https://github.com/checkstyle/checkstyle/actions/workflows/no-old-refs.yml [closed issues img]:https://github.com/checkstyle/checkstyle/actions/workflows/no-old-refs.yml/badge.svg [release notes/version]:https://github.com/checkstyle/checkstyle/actions/workflows/releasenotes-gen.yml [release notes/version img]:https://github.com/checkstyle/checkstyle/actions/workflows/releasenotes-gen.yml/badge.svg [link check]:https://github.com/checkstyle/checkstyle/actions/workflows/run-link-check.yml [link check img]:https://github.com/checkstyle/checkstyle/actions/workflows/run-link-check.yml/badge.svg [error prone]:https://github.com/checkstyle/checkstyle/actions/workflows/error-prone.yml [error prone img]:https://github.com/checkstyle/checkstyle/actions/workflows/error-prone.yml/badge.svg [pitest]:https://github.com/checkstyle/checkstyle/actions/workflows/pitest.yml [pitest img]:https://github.com/checkstyle/checkstyle/actions/workflows/pitest.yml/badge.svg [checker framework]:https://github.com/checkstyle/checkstyle/actions/workflows/checker-framework.yml [checker framework img]:https://github.com/checkstyle/checkstyle/actions/workflows/checker-framework.yml/badge.svg [milestone]:https://github.com/checkstyle/checkstyle/actions/workflows/set-milestone-on-referenced-issue.yml [milestone img]:https://github.com/checkstyle/checkstyle/actions/workflows/set-milestone-on-referenced-issue.yml/badge.svg

RenegadeLucien/project-tenacity

Project Tenacity, the final evolution of the Level 3 to X" guides"

2018-02-10T09:44:06Z

# About Project Tenacity Project Tenacity is a dynamic account pathing system for RuneScape 3. Its goal is to provide RS3 players with a powerful, easy-to-use tool to determine the optimal method to progress their account. This tool serves as a replacement and upgrade to my former attempts at making this type of guide, namely my "Level 3 to Quest Cape" and "Level 3 to All Capes" Reddit guides from several years ago. # How to run Project Tenacity requires Java 8 (or higher) to run. If you do not have this, you can download the latest version [here.](https://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html) Once you have Java 8, download Project Tenacity by clicking on the "releases" button above. Select the most recent version and download the .jar file. Finally, run the .jar. # How to use To create a new player profile, select "New Profile" and input a player name to use. If you use a valid RSN and have a public RuneMetrics profile, this will also pull your stats and completed quests from RuneMetrics. Currently, only mainscape profile creation is supported, not Ironman or HCIM. (Sorry. I tried. But adding Ironman and HCIM support would probably take another 3 years to complete.) To load a previously created profile, input the name of the profile you wish to load, and select "Load Profile." It is important to note that every time a profile is created or loaded, the tool will calculate the optimal path for the profile, which will take up to a minute depending on player progress. Once your profile is created or loaded, you will be on the main pathing screen. This screen consists of two tables: an achievement table that contains every achievement in RuneScape that your character has not yet completed, and a player table that includes details about your player, such as your player's skill levels, bank, gear, and the achievements they have completed. The achievement table will provide an estimate of the amount of time that it will take you to complete each achievement in the game. This estimate is determined through three parts: the time taken to fulfill all the requirements for the achievement, the time taken to actually complete the achievement itself, and the time saved by the rewards the achievement gives (this time is deducted from the previous two.) As such, if an achievement provides a lot of reward for little cost, it will be ranked higher on the table than a task that provides no rewards for the same cost. When you click on an achievement in the table, it will provide more details about the achievement in question, such as the total time to complete the achievement (without rewards factored in), the requirements that must be fulfilled before the achievement can be completed, the recommended actions that should be taken to complete the achievement (such as how to train skills for skill requirements), and what skills lamps should be used on (if the achievement provides any lamps.) To mark an achievement as completed, select the achievement and click the "Complete Achievement/Recalc" button. Note that this will automatically perform a recalculation, under the assumption that you completed the recommended actions in order to complete the achievement. If you have selected an achievement but wish to perform a recalc without marking it as completed, you can deselect it by right-clicking anywhere on the table. If you have marked an achievement as completed and wish to unmark it (make it not completed again), you can do this by going to the qualities tab of the player table, removing the row that corresponds to that achievement, and performing a recalc. To complete multiple achievements at once, select them all with Shift+Click or Ctrl+Click, then press the Recalc button. Note that unlike completing single achievements, this will only check the achievements off as completed, and will NOT act as though you had completed all the recommended actions in order to complete the achievements. The player table consists of five subsections: skills, bank, weapons, armour, and qualities. The skills section displays your character's experience in each skill, the bank section displays the items that are in your character's bank, the weapons section displays the current weapons your character can use, the armour section displays the current armour your character can use, and the qualities section is for anything that doesn't fit into the other four sections (mainly used for completed achievements.) Note that the bank, weapons, and armour sections are user-managed, since there is no RuneMetrics API that can get them from your RuneScape profile. Entries in tables other than skills can be added or removed with the text fields and buttons at the bottom-right corner of the screen. Quantities can be edited for any section with a quantity (including skills) by double-clicking on the quantity field and inputting the desired quantity. A few things to note on the player table: -If you input a weapon or a piece of armour into the weapons/armour section that is superior in every way to an existing piece of armour, it will automatically remove the inferior weapon or piece of armour. For this reason, it is NOT recommended to input weaponry or armour into the table that you do not currently have the requirements for, as this will produce undefined behavior. -The bank section is meant only for tradeable items, and will reject untradeable items. Additionaly, since Project Tenacity treats the bank as items that can be sold at any time without loss of progress (since they can simply be bought back if needed), it is not recommended to input items into the bank that you do not want to sell, such as your best weapons or armour. -Changes to the player table will not take effect until you perform a recalc with the "Complete Achievement/Recalc" button. The final point of note is the "Save Player Data" button. In order to save your data, you must click this button. This will automatically generate a player data file, which can be loaded with the "Load Profile" button the next time you start up Project Tenacity. Note that saving ONLY occurs with this button--there is no "auto-saving" feature in Project Tenacity. Backing up your save files is highly recommended. # How to report an error **There is absolutely nothing wrong with Project Tenacity. How DARE you-- (SMACK)** Ahem. If you find something that you think (or know) is wrong, click the "issues" tab above and create a new issue. Include as much detail as possible about the issue, including but not limited to what the issue actually is, what steps you took to cause the issue, if the issue is reproducible, if there is a way you can work around the issue, a screenshot of the issue occurring, and your player data file (if applicable.) After an issue is created, I will tag it with the appropriate severity label: T99 - crash or other technical error (that makes it impossible to use Project Tenacity at all) T90 - information that is definitely incorrect (such as a missed requirement on an achievement) T80 - a visual error or mistake (such as a typo) T70 - information that is possibly incorrect (perhaps Project Tenacity tells you a fight is winnable with your current gear, but you can't manage to do it) T60 - feature request (everything is working, but something could be improved) Creating an issue in this manner is the only 100% surefire way to ensure that I will see your report. Other contact methods such as Reddit, Discord, and in-game RS can be used, but are less certain. And if you flag your feature request as T99, I will NOT be happy. That should be everything. Thanks for using Project Tenacity!

xuyisheng/RatingbarGuide

Ratingbar Guide,include system origin ratingbar and custom ratingbar.

2015-06-18T14:51:08Z

# RatingbarGuide Ratingbar Guide,include system origin ratingbar and custom ratingbar. You can see the detail here : http://blog.csdn.net/eclipsexys/article/details/46552781 代码演示了： - 原生Ratingbar的使用，包括大小样式、自定义图案 - 全自定义Ratingbar，包括动画效果、设置间距、背景 

tzheng/SystemDesign

This is an interview preparation guide for software engineers. Includes behavior interview, system design and coding(Chinese).

2017-08-17T22:09:14Z

# 程序员面试总结 ## 系统设计 系统设计，总的来说就类似于面试官让你盖房子，你搭个框架给他看证明你有能力，面试官可以就跟你讨论讨论框架，也可以跟你讨论什么材料适合，也可以跟你讨论具体某一层楼的室内装修，所以准备系统设计特别耗费时间，需要比较全面的知识。很多新手往往觉得无从下手，但是我认为对于新手还是有一些基本套路可循，所以做了一份设计总结。 系统设计中，最重要的就是 Trade-off，中文应该叫权衡，系统设计之所以难就是难在这里，因为你在设计过程中做的每一个决定都需要给出理由，比如为什么用SQL为什么用NoSQL，这时候就需要考察你对不同数据库的理解，而且在不断深入的过程中，面试官会随时让你挑一个地方让你做具体设计，如果碰巧挑到你不是很熟悉的地方或者没有考虑过的问题，那么面试就危险了。所谓我在这里介绍概念和题目讲解的时候，尽量多覆盖一些知识点，尤其是讲解题目，我会尽量列出多种方法，然后说说不同方法适用于什么情况，如何做出权衡。**个人水平有限，如果有错误的地方请大家指出改正。** 我认为几个需要强调的地方： * 系统设计没有标准答案 * 系统设计重点在于权衡 * 不要只说名词不解释 * 面试过程中需要随机应变 * 面试官有的时候可能不要你回答业界通用的做法 在跟一些面试官交流过程中，大部分面试官都提到了系统设计的考点： * do you gather requirement * do you define the right limits of the system(what the system can/cannot do), do you realize trade-offs * do you think big enough to have the right level of abstraction and keep it simple * do you have basic knowledge, such as avoid single point of failure, CAP theorem, scaling, fault tolerant, consistent hasing... * can you think clearly, do you have a good working method, do you loop back on requirement to test if your design work well, do you call out how the system can and can't envolve * do you have domain expertise 一般系统设计都会涉及到以下几个方面： 首先是需求收集，这里要不断和面试官沟通，了解这个系统需要支持哪些功能，用户量有多少，然后你可以估算系统的QPS。然后需要考虑系统有哪些特性，根据前面计算的QPS判断系统是读多还是写多，是需要可用性(availability) 还是需要一致性(Consistency)。具体可以参照以下文章： * [估算](SystemDesignBasics/estimations.md) * [CAP定理](SystemDesignBasics/cap.md) 搜集完需求之后，接下来就是具体业务逻辑设计，业务逻辑很难归纳，因为每个系统都有自己的业务逻辑，不过针对一些特定的问题有些常见的解决方案，比如你需要设计一个全局UUID有几种解决办法，或者地理位置服务（LBS）通常怎么设计，或者是如何处理海量数据，这些内容可以在系统设计概念中找到。 * [地理位置服务](SystemDesignBasics/lbs.md) * [分布式全局id](SystemDesignBasics/globaluuid.md) * [海量数据处理](SystemDesignBasics/massive-data-processing.md) * [消息队列](SystemDesignBasics/message-queue.md) 再接着就是讨论数据存储，数据存储无外乎就是缓存和永久存储，缓存有许多种类，比如write through, cache aside 等等。永久存储一般是讨论SQL 和 NoSQL的区别，极个别特殊情况可能会直接用文件系统(File System)来存储，这些内容会在以下部分谈到： * [缓存](SystemDesignBasics/cache.md) * [SQL和NoSQL](SystemDesignBasics/sqlvsnosql.md) 除此之外，每一层的设计都会涉及到扩容的问题，还有如何增加备份冗余，以防单点故障(Single point of failure)的问题。为了处理海量访问请求，通常解决办法就是增加机器数量，然后保证负载均衡(load balance)，业务逻辑层，数据存储层都自己的办法，比如master-slave。这些内容会在很多地方被反复提及，具体可以参照： * [一致性哈希 - Consistent Hashing](SystemDesignBasics/consistent-hashing.md) * [分区 - Sharding, Partitioning](SystemDesignBasics/sharding.md) 在讨论完了基本概念之后，我们可以总结一套写常见系统设计题的解答。 * [热门排行榜 - Top K问题](SystemDesignQuestions/topk.md) * [输入提示 - Typeahead](SystemDesignQuestions/typeahead.md) * [视频平台(Youtube, Netflix)](SystemDesignQuestions/videoPlatform.md) * [网络爬虫](SystemDesignQuestions/WebCrawl.md) * [在线聊天服务](../SystemDesignQuestions/chat.md) * [信息流/时间线（Facebook，Twitter...)](SystemDesignQuestions/newsfeed.md) * [地理位置服务（Yelp)](SystemDesignQuestions/PlaceSuggestionPOI.md) * [打车服务(Uber, Lyft)](SystemDesignQuestions/rideshare.md) * [搜索服务(Google, Facebook Status Search)](SystemDesignQuestions/search.md) * [点击统计服务](SystemDesignQuestions/clickCount.md) * [分布式文件系统](SystemDesignQuestions/distributedFileSystem.md) * [分布式工作调度系统](SystemDesignQuestions/eventScheduler.md)

PacktPublishing/Apache-Kafka-Quick-Start-Guide

Apache Kafka Quick Start Guide, Published by Packt

2018-09-06T09:58:35Z

# Apache Kafka Quick Start Guide <a href="https://www.packtpub.com/big-data-and-business-intelligence/apache-kafka-quick-start-guide?utm_source=github&utm_medium=repository&utm_campaign=9781788997829 "><img src="https://d1ldz4te4covpm.cloudfront.net/sites/default/files/imagecache/ppv4_main_book_cover/9781788997829_cover.png" alt="Apache Kafka Quick Start Guide " height="256px" align="right"></a> This is the code repository for [Apache Kafka Quick Start Guide](https://www.packtpub.com/big-data-and-business-intelligence/apache-kafka-quick-start-guide?utm_source=github&utm_medium=repository&utm_campaign=9781788997829), published by Packt. **Leverage Apache Kafka 2.0 to simplify real-time data processing for distributed applications** ## What is this book about? Apache Kafka is a great open source platform for handling your real-time data pipeline to ensure high-speed filtering and pattern matching on the fly. In this book, you will learn how to use Apache Kafka for efficient processing of distributed applications and will get familiar with solving everyday problems in fast data and processing pipelines. This book covers the following exciting features: * How to validate data with Kafka * Add information to existing data flows * Generate new information through message composition * Perform data validation and versioning with the Schema Registry * How to perform message Serialization and Deserialization * How to perform message Serialization and Deserialization * Process data streams with Kafka Streams * Understand the duality between tables and streams with KSQL If you feel this book is for you, get your [copy](https://www.amazon.com/dp/1788997824) today! <a href="https://www.packtpub.com/?utm_source=github&utm_medium=banner&utm_campaign=GitHubBanner"><img src="https://raw.githubusercontent.com/PacktPublishing/GitHub/master/GitHub.png" alt="https://www.packtpub.com/" border="5" /></a> ## Instructions and Navigations All of the code is organized into folders. For example, Chapter02. The code will look like the following: ``` { "event": "CUSTOMER_CONSULTS_ETHPRICE", "customer": { "id": "14862768", "name": "Snowden, Edward", "ipAddress": "95.31.18.111" }, "currency": { "name": "ethereum", "price": "RUB" }, "timestamp": "2018-09-28T09:09:09Z" } ``` **Following is what you need for this book:** This book is for developers who want to quickly master the practical concepts behind Apache Kafka. The audience need not have come across Apache Kafka previously; however, a familiarity of Java or any JVM language will be helpful in understanding the code in this book. With the following software and hardware list you can run all code files present in the book (Chapter 1-8). ### Software and Hardware List | Chapter | Software required | OS required | | -------- | ------------------------------------ | ----------------------------------- | | 3, 4, 5, 6, 7, 8 | Apache Kafka 2.0.0 Gradle 4.0 or above Confluent Platform 5.0.0 | macOS or Linux distribution released after 2014 (Ubuntu/Redhat/Debian) | ### Related products * Building Data Streaming Applications with Apache Kafka [[Packt]](https://www.packtpub.com/big-data-and-business-intelligence/building-data-streaming-applications-apache-kafka?utm_source=github&utm_medium=repository&utm_campaign=9781787283985 ) [[Amazon]](https://www.amazon.com/dp/1787283984) * Apache Kafka 1.0 Cookbook [[Packt]](https://www.packtpub.com/big-data-and-business-intelligence/apache-kafka-10-cookbook?utm_source=github&utm_medium=repository&utm_campaign=9781787286849 ) [[Amazon]](https://www.amazon.com/dp/1787286843) ## Get to Know the Author **Raúl Estrada** has been a programmer since 1996 and a Java developer since 2001. He loves all topics related to computer science. With more than 15 years of experience in high-availability and enterprise software, he has been designing and implementing architectures since 2003. His specialization is in systems integration, and he mainly participates in projects related to the financial sector. He has been an enterprise architect for BEA Systems and Oracle Inc., but he also enjoys web, mobile, and game programming. Raúl is a supporter of free software and enjoys experimenting with new technologies, frameworks, languages, and methods. Raúl is the author of other Packt Publishing titles, such as Fast Data Processing Systems with SMACK and Apache Kafka Cookbook. ## Other books by the author [Fast Data Processing Systems with SMACK Stack](https://www.packtpub.com/big-data-and-business-intelligence/fast-data-processing-systems-smack-stack?utm_source=github&utm_medium=repository&utm_campaign=9781786467201 ) [Fast Data Processing Systems with SMACK stack [Video]](https://www.packtpub.com/big-data-and-business-intelligence/fast-data-processing-systems-smack-stack-video?utm_source=github&utm_medium=repository&utm_campaign=9781788298452 ) []() []() []() ### Suggestions and Feedback [Click here](https://docs.google.com/forms/d/e/1FAIpQLSdy7dATC6QmEL81FIUuymZ0Wy9vH1jHkvpY57OiMeKGqib_Ow/viewform) if you have any feedback or suggestions. ### Download a free PDF <i>If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.<br>Simply click on the link to claim your free PDF.</i> <p align="center"> <a href="https://packt.link/free-ebook/9781788997829">https://packt.link/free-ebook/9781788997829 </a> </p>

bowyer-app/fab-toolbar

[Deprecated] Provides the Floating Action Button Toolbar as specified in the Material Design Guide in a simple library.

2015-07-15T05:58:14Z

Floating Action Button Toolbar ============================== [](https://android-arsenal.com/details/1/2241) Provides the Floating Action Button Toolbar [as specified in the Material Design Guide](http://www.google.com/design/spec/components/buttons-floating-action-button.html#buttons-floating-action-button-transitions) in a simple library.  Usage ==== ### build.gradle ``` repositories { jcenter() } dependencies { compile 'com.bowyer.app:fab-toolbar:1.1.0@aar' } ``` ### Layout XML ``` <android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity"> <com.github.ksoichiro.android.observablescrollview.ObservableListView android:id="@+id/list_view" android:layout_width="match_parent" android:layout_height="match_parent"/> <android.support.design.widget.FloatingActionButton android:id="@+id/fab" android:layout_margin="16dp" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="bottom|end" android:src="@drawable/ic_fab_icon"/> <com.bowyer.app.fabtoolbar.FabToolbar android:id="@+id/fabtoolbar" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_gravity="bottom" app:tb_color="@color/primary" app:tb_container_gravity="center" app:tb_anim_duration="400" app:tb_fab_type="normal"> <!--add your original layout--> </com.bowyer.app.fabtoolbar.FabToolbar> </android.support.design.widget.CoordinatorLayout> ``` Make sure to user CoordinatorLayout as your container for the Floating Action Button if you want to preserve same margin values for both Lollipop and pre Lollipop devices. ### Set up ```java @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ButterKnife.bind(this); initListView(); //set floating button to FabToolbar mFabToolbar.setFab(mFab); } ``` ### Show Hide ```java //expand FabToolbar mFabToolbar.expandFab(); //if mFabToolbar is expand,mFabToolbar contract. else fab slide out. mFabToolbar.slideOutFab(); //fab slide in mFabToolbar.slideInFab(); ``` # Credits This library use following libraries. * [CircularReveal](https://github.com/ozodrukh/CircularReveal) Feature ==== - [x] Android 5.0 lower animation support License -------- ``` Copyright (c) 2015 Bowyer Released under the MIT license http://opensource.org/licenses/mit-license.php ```

ddd-by-examples/all-things-cqrs

Comprehensive guide to a couple of possible ways of synchronizing two states with Spring tools. Synchronization is shown by separating command and queries in a simple CQRS application.

2018-08-17T08:11:04Z

# All Things CQRS A bunch of ways of doing [CQRS](https://martinfowler.com/bliki/CQRS.html) with various [Spring](https://spring.io) tools. ## Getting Started These instructions will get you and overview of how to synchronize two different datasources. We will do so by separating command and queries in a simple CQRS app. Each module represents a different way of introducing this pattern. Also, each module is a standalone [Spring Boot](https://spring.io/projects/spring-boot) application. ### Prerequisites What things you need to run the software: * Java 8+ * [docker-compose](https://docs.docker.com/compose/) ## Overview Sample applications are based on a simple domain that serves credit cards. There are two usecases: * Money can be withdrawn from a card (*Withdraw* **command**) * List of withdrawals from a card can be read (**query**) The important is that: ``` After a successful Withdraw command, a withdrawal should be seen in a result from list of withdrawals query. ``` Hence there is a need for some **synchronization** that makes state for commands and queries consistent. Let's agree on a color code for commands, queries and synchronization. It will make our drawings consistent.  ### Commands and queries handled in one class (no CQRS) Code can be found under [in-one-class](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/in-one-class) module. Running the app: ``` mvn spring-boot:run ``` A sample *Withdraw* command: ``` curl localhost:8080/withdrawals -X POST --header 'Content-Type: application/json' -d '{"card":"3a3e99f0-5ad9-47fa-961d-d75fab32ef0e", "amount": 10.00}' --verbose ``` Verifed by a query: ``` curl http://localhost:8080/withdrawals?cardId=3a3e99f0-5ad9-47fa-961d-d75fab32ef0e --verbose ``` Expected result: ``` [{"amount":10.00}] ``` Architecture overview:  Automatic E2E test for REST API can be found [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/in-one-class/src/test/java/io/dddbyexamples/cqrs/CommandQuerySynchronizationTest.java): ```java @Test public void shouldSynchronizeQuerySideAfterSendingACommand() { // given UUID cardUUid = thereIsCreditCardWithLimit(new BigDecimal(100)); //HTTP POST // when clientWantsToWithdraw(TEN, cardUUid); //HTTP GET // then thereIsOneWithdrawalOf(TEN, cardUUid); } ``` ### CQRS with application service as explicit synchronization Code can be found under [explicit-with-dto](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/explicit-with-dto) module. Same version, but with JPA entities as results of a query can be found [here](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/explicit-with-entity). Running the app: ``` mvn spring-boot:run ``` A sample *Withdraw* command: ``` curl localhost:8080/withdrawals -X POST --header 'Content-Type: application/json' -d '{"card":"3a3e99f0-5ad9-47fa-961d-d75fab32ef0e", "amount": 10.00}' --verbose ``` Verifed by a query: ``` curl http://localhost:8080/withdrawals?cardId=3a3e99f0-5ad9-47fa-961d-d75fab32ef0e --verbose ``` Expected result: ``` [{"amount":10.00}] ``` Architecture overview:  Automatic E2E test for REST API can be found [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/explicit-with-dto/src/test/java/io/dddbyexamples/cqrs/CommandQuerySynchronizationTest.java): ```java @Test public void shouldSynchronizeQuerySideAfterSendingACommand() { // given UUID cardUUid = thereIsCreditCardWithLimit(new BigDecimal(100)); //HTTP POST // when clientWantsToWithdraw(TEN, cardUUid); //HTTP GET // then thereIsOneWithdrawalOf(TEN, cardUUid); } ``` ### CQRS with spring application events as implicit synchronization Code can be found under [with-application-events](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-application-events) module. There is also a version with immutable domain module which just returns events. It Can be found [here](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-application-events-immutable). Running the app: ``` mvn spring-boot:run ``` A sample *Withdraw* command: ``` curl localhost:8080/withdrawals -X POST --header 'Content-Type: application/json' -d '{"card":"3a3e99f0-5ad9-47fa-961d-d75fab32ef0e", "amount": 10.00}' --verbose ``` Verifed by a query: ``` curl http://localhost:8080/withdrawals?cardId=3a3e99f0-5ad9-47fa-961d-d75fab32ef0e --verbose ``` Expected result: ``` [{"amount":10.00}] ``` Architecture overview:  Automatic E2E test for REST API can be found [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/with-application-events/src/test/java/io/dddbyexamples/cqrs/CommandQuerySynchronizationTest.java): ```java @Test public void shouldSynchronizeQuerySideAfterSendingACommand() { // given UUID cardUUid = thereIsCreditCardWithLimit(new BigDecimal(100)); //HTTP POST // when clientWantsToWithdraw(TEN, cardUUid); //HTTP GET // then thereIsOneWithdrawalOf(TEN, cardUUid); } ``` ### CQRS with trigger as implicit synchronization Code can be found under [trigger](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-trigger) module. Running the app: ``` mvn spring-boot:run ``` A sample *Withdraw* command: ``` curl localhost:8080/withdrawals -X POST --header 'Content-Type: application/json' -d '{"card":"3a3e99f0-5ad9-47fa-961d-d75fab32ef0e", "amount": 10.00}' --verbose ``` Verifed by a query: ``` curl http://localhost:8080/withdrawals?cardId=3a3e99f0-5ad9-47fa-961d-d75fab32ef0e --verbose ``` Expected result: ``` [{"amount":10.00}] ``` Architecture overview:  Automatic E2E test for REST API can be found [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/with-trigger/src/test/java/io/dddbyexamples/cqrs/CommandQuerySynchronizationTest.java): ```java @Test public void shouldSynchronizeQuerySideAfterSendingACommand() { // given UUID cardUUid = thereIsCreditCardWithLimit(new BigDecimal(100)); //HTTP POST // when clientWantsToWithdraw(TEN, cardUUid); //HTTP GET // then thereIsOneWithdrawalOf(TEN, cardUUid); } ``` ### CQRS with transaction log tailing as synchronization Synchronization done by listening to database's [transaction log](https://en.wikipedia.org/wiki/Transaction_log), which is a log of transactions accepted by a database management system. Code can be found under [with-log-tailing](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-log-tailing) module. Additional components: * MySQL to keep withdrawals and credit cards. * [Apache Kafka](https://kafka.apache.org) for pub/sub for messages read from database transaction log (in this case it is MySQL). * [Kafka Connect](https://www.confluent.io/product/connectors/) with [Debezium](https://debezium.io) to read MySQL’s transaction log and stream messages to Kafka’s topic. * [Spring Cloud Stream](https://cloud.spring.io/spring-cloud-stream/) to read messages from Kafka’s topic. Running the app, remember to be in **root** of the project: * In *docker-compose.yaml*, under service *kafka* - **CHANGE** IP to match your host machine. Keep port pointing to 9092: ``` ADVERTISED_LISTENERS=PLAINTEXT://YOUR_HOST_IP:9092 ``` * Run the whole infrastructure: ``` docker-compose up ``` * Tell Kafka Connect to tail transaction log of MySQL DB and send messages to Kafka: ``` curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" http://localhost:8083/connectors/ -d @source.json --verbose ``` A sample *Withdraw* command: ``` curl localhost:8080/withdrawals -X POST --header 'Content-Type: application/json' -d '{"card":"3a3e99f0-5ad9-47fa-961d-d75fab32ef0e", "amount": 10.00}' --verbose ``` Verifed by a query: ``` curl http://localhost:8080/withdrawals?cardId=3a3e99f0-5ad9-47fa-961d-d75fab32ef0e --verbose ``` Expected result can be seen below. Remember that it takes time to read transaction log and create a withdrawal. Hence a withdrawal might be not immedietly seen: ``` [{"amount":10.00}] ``` Architecture overview:  Since it is problematic (or immposible) to test transaction log tailing, there is no E2E test that verifies commands and queries. But we can test if a message arrival in Kafka's topic results in a proper withdrawal created. The code is [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/with-log-tailing/src/test/java/io/dddbyexamples/cqrs/sink/ReadModelUpdaterTest.java): ```java @Test public void shouldSynchronizeQuerySideAfterLogTailing() { // given String cardUUid = thereIsCreditCardWithLimit(new BigDecimal(100)); // when creditCardUpdateReadFromDbTransactionLog(TEN, cardUUid); // then thereIsOneWithdrawalOf(TEN, cardUUid); } ``` ### CQRS with Domain Events as synchronization Synchronization done by sending a domain event after succesfully handling a command. Code can be found under [events](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-events) module. It has 2 further modules, architecture is fully distributed. There is a [source](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-events/with-events-source) (deals with commands) and [sink](https://github.com/ddd-by-examples/all-things-cqrs/tree/master/with-events/with-events-sink) (deals with queries). Additional components: * H2 DB to keep credit cards. * [MongoDB](https://www.mongodb.com/what-is-mongodb) to keep withdrawals. * Spring Data Reactive MongoDb to reactively talk to Mongo * [Project Reactor](http://projectreactor.io) to serve non-blocking web-service * [Apache Kafka](https://kafka.apache.org) for pub/sub for domain events * [Spring Cloud Stream](https://cloud.spring.io/spring-cloud-stream/) to read/write messages from/to Kafka’s topic. Running the app, remember to be in **root** of the project: * Run the whole infrastructure: ``` docker-compose up ``` A sample *Withdraw* command: ``` curl localhost:8080/withdrawals -X POST --header 'Content-Type: application/json' -d '{"card":"3a3e99f0-5ad9-47fa-961d-d75fab32ef0e", "amount": 10.00}' --verbose ``` Verifed by a query (notifce a different port: **8888**!): ``` curl http://localhost:8888/withdrawals?cardId=3a3e99f0-5ad9-47fa-961d-d75fab32ef0e --verbose ``` Expected result can be seen below. Remember that it takes time to publish and read domain events from Kafka. Hence a withdrawal might be not immedietly seen: ``` [{"amount":10.00}] ``` Architecture overview:  Since it is not recommended to test 2 microservices in one test, there is no E2E test that verifies commands and queries. But we can test if a message arrival in Kafka's topic results in a proper withdrawal created. The code is [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/with-events/with-events-sink/src/test/java/io/dddbyexamples/cqrs/sink/ReadModelUpdaterTest.java): ```java @Test public void shouldSeeWithdrawalAfterGettingAnEvent() { //when anEventAboutWithdrawalCame(TEN, cardID); //then thereIsOneWithdrawalOf(TEN, cardID); } ``` Also it is possible to test if a successful withdrawal is followed eventually by a proper domain event publication. The code is [here](https://github.com/ddd-by-examples/all-things-cqrs/blob/master/with-events/with-events-source/src/test/java/io/dddbyexamples/cqrs/EventsPublishingTest.java). ```java @Test public void shouldEventuallySendAnEventAboutCardWithdrawal() throws IOException { // given UUID cardUUid = thereIsCreditCardWithLimit(new BigDecimal(100)); // when clientWantsToWithdraw(TEN, cardUUid); // then await().atMost(FIVE_SECONDS).until(() -> eventAboutWithdrawalWasSent(TEN, cardUUid)); } ``` ### CQRS with Axon Framework Take a look [here](https://github.com/pivotalsoftware/ESarch)

IGx89/titanium-c2dm

See the Wiki for a link to a quick setup guide

2010-11-22T17:07:22Z

cmu-pasta/mu2

Mutation-guided mutation-based fuzz testing

2021-08-12T18:08:09Z

# Mutation-Guided Fuzzing Mu2 is a fuzz testing platform for mutation-guided fuzzing, built on top of the [JQF](https://github.com/rohanpadhye/JQF/) platform for fuzzing Java programs. Documentation for running and understanding the implementation of mutation-guided fuzzing provided here. <!-- For project writeup, see [this document](https://saphirasnow.github.io/17-355/Bella_Laybourn_17355_Project.pdf). --> For more questions, feel free to email [Bella Laybourn](mailto:ilaybour@andrew.cmu.edu), [Vasu Vikram](mailto:vasumv@cmu.edu), or [Rohan Padhye](https://rohan.padhye.org). ## Build + Test + Install To install Mu2, run the following: ``` git clone https://github.com/cmu-pasta/mu2 && cd mu2 mvn install ``` ### Development Mu2 is a multimodule project containing the following modules: 1. `core`: all the core instrumentation and guidance logic 2. `examples`: example fuzz drivers for applying mutation-guided fuzzing 3. `integration-tests`: integration tests for mutation-guided fuzzing on sorting targets in `examples` When making changes to mu2 or JQF, you only need to install that particular project's SNAPSHOT for the changes to take effect. To test changes to `mu2`, run the integration tests as follows from the `mu2` repository: ``` mvn verify ``` Coverage reports should be available in `integration-tests/target/site/jacoco-integration-test-coverage-report/index.html`. ## Differential Mutation Testing Fuzzing To use the differential fuzzing goal `mu2:diff`, instrument your tests with `@Diff` and `@Comparison` annotations instead of `@Test` and use the `DiffGoal` and `MutateDiffGoal` as described below. ### Annotations In the differential testing framework, each test is a pair of functions, one annotated with `@Diff` and the other with `@Comparison`. The function annotated with `@Diff` should **not** be `static` and should return an object (neither void nor a primitive, though boxed primitives work). The result of this diff function will be compared with other results using the comparison function (annotated with `@Comparison`). The comparison function should be `static`, take two arguments of the same type as the return type of any associated diff functions, and return a `Boolean` (`Boolean.TRUE` if the two inputs are equivalent, `Boolean.FALSE` otherwise). Multiple functions with these annotations can be included in a single test class, so, to uniquely match the diff function with a comparison function, pass the name of the comparison function as an argument to `@Diff` as `cmp` (see below for example). If no argument is passed to `cmp`, `Objects.equals()` will be used as a default. Each diff function is associated with up to one comparison function, but arbitrarily many diff functions may use a comparison function. Example of a differential test for a function `populateList(List<Integer>)` when the comparison only cares about the size of the populated list: ```java @Diff(cmp = "compare") public List<Integer> testPopulate(List<Integer> input) { return populateList(input); } @Comparison public static Boolean compare(List<Integer> list1, List<Integer> list2) { return list1.size() == list2.size(); } ``` ### Diff Goal For running differential fuzzing. Currently defaults to mutation-guided fuzzing. Example: ```sh mvn mu2:diff -Dclass=package.class -Dmethod=method -Dincludes=prefix ``` ### Mutate Goal For repro on mutation guidance with diff-based tests. Example: ```sh mvn mu2:mutate -Dclass=package.class -Dmethod=method -Dincludes=prefix -Dinput=path/to/corpus ``` ### Repro Goal For repro on other guidances with diff-based tests. Example: ```sh mvn mu2:repro -Dclass=package.class -Dmethod=method -Dincludes=prefix -Dinput=path/to/corpus ``` ### Selecting Instrumentable Classes You can use the `-Dincludes` flags to select which code will be mutated. ```sh mvn mu2:diff -Dclass=package.class -Dmethod=method -Dincludes=prefix1,prefix2 ``` Additionally, setting the `-DtargetIncludes` flag to a comma-separated list that includes every mutated class as well as all classes that depend on a mutable class anywhere in their dependency trees improves efficiency by loading classes not in the list with a separate intermediate ClassLoader. Example using a test of Scala's chess library: ```sh mvn mu2:diff -Dclass=edu.berkeley.cs.jqf.examples.chess.FENTest -Dmethod=testWithGenerator -Dincludes=chess.format.Forsyth,chess.Situation -DtargetIncludes=edu.berkeley.cs.jqf.examples.chess,chess ``` ## Implementation ### MutationInstance A `MutationInstance` is an instance of a mutation: e.g. the class in which the mutation resides, the kind of mutation performed (the `Mutator` - see below), and the location in which the mutation takes places (given as the n'th opportunity for the `Mutator` to be applied to the given class). Each instance also has an ID, which can be used as its index in the `MutationInstance.mutationInstances` array. ### ClassLoaders #### MutationClassLoader A `ClassLoader` which loads a mutated version of a class specified by a `MutationInstance`. For all classes except that specified by the `MutationInstance`, it loads it normally. For the class specified, it mutates the class as specified by the `Mutator` and the mutator index. This class can be used on its own, or can be used through a `MutationClassLoaders` object, which takes the class-loading information as a parameter then provides a map from `MutationInstances` to `MutationClassLoader`s. #### CartographyClassLoader Initial class loading should take place using this ClassLoader. It creates a list of MutationInstances representing all of the mutation opportunities (the "cartograph"). It does this by instrumenting the input class using the `Cartographer`: a `SafeClassWriter` which both logs which mutants are possible, and transforms the input class into one which measures which mutants are run for later optimization. #### MutationClassLoaders A class that contains references to both the `CartographyClassLoader` and a mapping of each `MutationInstance` to its `MutationClassLoader`. A `MutationClassLoaders` object is the external entry point, and such an object is passed to a `MutationGuidance` during construction. ### Mutators #### Mutator Format Each mutator replaces one instruction with another, or with a series of instructions. They sometimes take the form `prefix_oldInstruction_TO_newInstruction(Opcodes.oldInstruction, returnType, [list, of, instruction, calls, ...])` and other times, as appropriate to the type of mutator, are just descriptors. To make that more clear, three actual examples, broken down: `I_ADD_TO_SUB(Opcodes.IADD, null, new InstructionCall(Opcodes.ISUB))` refers to swapping <b>I</b>nteger <b>ADD</b>ition for <b>SUB</b>traction, which requires no relevant return type. `VOID_REMOVE_STATIC(Opcodes.INVOKESTATIC, "V", new InstructionCall(Opcodes.NOP))` refers to removing calls to void functions made with `invokestatic`, which requires that the return type of the called function be <b>V</b>oid. `S_IRETURN_TO_0(Opcodes.IRETURN, "S", new InstructionCall(Opcodes.POP), new InstructionCall(Opcodes.ICONST_0), new InstructionCall(Opcodes.IRETURN))` refers to making a function with return type <b>S</b>hort return the short `0` instead of what it would normally have returned. This requires that the return type of the returning function be <b>S</b>hort. Note how in the second two examples, the opcode alone was not enough to identify the relevant return type, which is why that information was included separately. ##### Pops: An Aside When calling functions, the arguments are loaded onto the stack. This means that, when removing a function call, those arguments must be popped off the stack before continuing. Typically, we would pop off the same number of arguments as the function has, but when the opcode is `invokestatic` there's one fewer because there's an implicit `this` argument added in other cases that `invokestatic` doesn't need. #### InstructionCall Just a wrapper for bytecode instructions so their arguments can be included. ### MutationSnoop A class whose static methods are invoked from mu2-instrumented classes. Used to track infinite loops in mutated code and to perform speculative mutation analysis in the original (cartography) test run. ### MutationGuidance For the most part, an extension of `Zest`. For each fuzz input, runs first the class loaded by the `CartographyClassLoader`, then each of the `MutationInstance`s it has generated that hasn't been killed by a previous fuzz input and have been marked as run by the class loaded by the `CartographyClassLoader`. Saves for reason `+mutants` along with Zest's `+coverage`, etc. ### Timeout To prevent hanging forever on an infinite loop, both MutationInstances and CartographyClassLoaders outfit their classes with a timeout functionality that essentially kills the program after some maximum number of control jumps. This assumes that if the number of control jumps exceeds that then the program has encountered an infinite loop and will not ascertain any new information by continuing to run. ## Scripts ### Setup ``` pip install -r requirements.txt ``` ### Plot Mutants This is a script for visualizing the various mutant numbers across trials of a given fuzzing session run with `-Dengine=mutation`. It takes in an input `plot_data` CSV file and outputs an image plotting found mutants, killed mutants, and optionally seen/infected mutants. Usage: ``` python scripts/plot_mutant_data.py <plot_data_file> <output_image_file> ``` ### Experiments and Venn Diagram Usage: ``` ./getMutants.sh <testClass> <testMethod> <includesClass> <experiments> <trials> <baseDirectory> ./getMutants.sh edu.berkeley.cs.jqf.examples.commons.PatriciaTrieTest testPrefixMap org.apache.commons.collections4.trie 3 1000 ../../jqf/examples ``` Venn diagram script alone: ``` python scripts/venn.py --filters_dir <filters_dir> --num_experiments <num_experiments> --output_img <output_img_name> ``` ## Acknowledgments This project is supported in part by the National Science Foundation under Grant Number [CCF-2120955](https://www.nsf.gov/awardsearch/showAward?AWD_ID=2120955). Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation. This project is also partly supported by [CyLab](https://www.cylab.cmu.edu/).