Spring I/O 2022

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/olgamaciaszek/declarative-clients-in-spring What is a declarative HTTP client vs an imperative one? Why are they useful and why should I care? We’ll talk about options that are available in the Spring Portfolio and what is coming on the horizon. In this session we will look at the history of declarative clients in Spring via Spring Cloud OpenFeign. We will also dive into upcoming options that are coming to Spring and the advantages that these new technologies bring to developer experience.

Spring I/O 2022 - Barcelona, 26-27 May GitHub repo: https://github.com/kubernetes-native-java/controllers-101 You know what’s fun? Automating the ever livin’ heck out of infrastructure! Slaying that YAML! Nobody wants to painstakingly build something then spend weeks trying to write the YAML to describe it to the infrastructure. Thankfully, Kubernetes provides composability through abstractions like operators, controllers, and custom resource definitions. These days, it’s trivial to extend Kubernetes with a Spring Boot application, turn it into a GraalVM native image that runs in a Docker container, and then deploy that. Join us, and we’ll learn how to extend and automate Kubernetes with Spring Boot and Spring Native-powered custom operators and eliminate that ever-so pesky YAML.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://prezi.com/p/70_enojlurd1/jobrunr-springio-barcelona/ Let’s face it - we are not all working for a company like Facebook, Netflix or LinkedIn where we need to process terabytes of data each day. Often we just need to solve some complex business processes with a moderate amount of data. Or we need to generate some documents based on input given by another microservice without blocking the http request. Using JobRunr, you can transform any Java 8 lambda and turn it into a distributed background job: the lambda is analysed together with the arguments and saved as a job to a SQL or noSQL database. Next, different BackgroundJobServer beans (in different JVM instances) inside your application fetch these jobs and process them. By scaling up the instances of your application (e.g. in Kubernetes), your jobs will get processed faster. As of JobRunr 5.0, it also supports Spring Native - scaling up can now happen in milliseconds and processing will go faster than ever!

Spring I/O 2022 - Barcelona, 26-27 May This case-study talk will kick off with a quick intro into health-care data, presenting an opportunity to broaden your horizon. Followed by the story of an actual project, its journey from a simple Spring Boot app into a Kubernetes (k8s) microservice architecture, and how to streamline such a design with a modern k8s abstraction called Distributed Application Runtime (Dapr). Sharing my experiences made during that process can make you benefit in two ways. It gives you an actual practical idea about the reasons for and implementation of the presented architecture, especially if you are new to microservices and k8s. And it enables you to step up your game with Dapr, if you are a pro already.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://docs.google.com/presentation/d/1UVYYUn3CePYd3aS7iuP8fSc4aL4fVxpgqwMO0JRHGu8/edit?usp=sharing Conferences love to show you the latest and greatest framework versions and language features. But those new technologies can feel a world away back at work. And it can be hard to justify the time spent to upgrade something that’s not broken, such as JUnit 4. What if you could migrate in mere minutes? With OpenRewrite you can! A collection of fine grained recipes combine to achieve large scale migrations of frameworks and tools related to the JVM. And since it uses an abstract syntax tree, refactorings are guaranteed safe. Upgrade Spring. Adopt JUnit 5; switch to AssertJ. Replace Log4j with Logback. Fix Checkstyle violations. A world of quick and easy migrations awaits!

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/maeddes/distributed-systems-patterns-spring-cloud-service-mesh-and-ebpf Software Development based on a distributed (microservice) architecture provides both several advantages and new challenges. In order to take advantage of the distribution it requires implementation of service discovery, routing, load-balancing, resilience mechanisms and more. In the ecosystem of Spring there is Spring Cloud, which provides a big range of dedicated solutions to address exactly those challenges. If the microservice architecture is running on top of Kubernetes there are alternative options to address these problems. So-called service mesh implementations do not have to be part of the actual application code, but can happen on a the network level of the container. A fairly new approach is emerging with the eBPF technology, which claims to enable service meshes with minimal overhead. The different approaches of course result in different responsibilities for the developers and application owners. With this talk I want to compare the approaches to figure out if one, the other or a combination can be helpful for certain scenarios. The talk is split into a theoretical and a live-demo part.

Spring I/O 2022 - Barcelona, 26-27 May Chaos Engineering identifies weaknesses in supposedly reliable and stable systems. By discussing how to build transparency around the actual resilience of deployed apps among teams and how to balance appropriate reliability and engineering velocity, we will learn to build a culture of resilience. In the past few years, a lot has happened in the field of chaos engineering. A large community has developed from the original radical new approach of intentionally causing errors and failures. The principles have been refined and the popularity of chaos engineering is growing. I don’t want to reintroduce the topic, but rather show why the topic is more important than ever, how we are currently dealing with it, and why chaos engineering is just the beginning. Our journey into the world of distributed and dynamic systems has just begun. Collaboration and knowledge transfer are our tools for success. With these powerful tools, a Culture of Resilience will automatically emerge. - How to create transparency about the actual resilience of the deployed applications in the teams? - How to balance appropriate reliability with development velocity? - How can you empower people to build a Culture of Resilience? I’ve already had the opportunity to talk to many different teams about the topic of resilience and system stability - questions and uncertainties are more than normal at this point in the journey. That said, it’s important to make these issues more visible. Let’s discuss together how we can move to a future where we turn energy and creativity into code.

Spring I/O 2022 - Barcelona, 26-27 May GitHub repo: https://github.com/snicoll/demo-aot-native Ahead Of Time and Native is a major topic for the upcoming Spring major releases. With this talk, you’ll get a complete tour of the AOT efforts and a glimpse at future developments. After a successful experimental phase with the Spring Native project, the Spring team is bringing Ahead Of Time (AOT) support to Spring. The goal here is to enable GraalVM native use cases and improve JVM efficiency. During this talk, Stéphane and Brian will discuss the state of the AOT theme in Spring Framework 6.0-M4 and Spring Boot 3.0-M3: - The design of the AOT engine - How this new infrastructure can be used by libraries - What to expect as an application developer

Spring I/O 2022 - Barcelona, 26-27 May Spring Framework provides first-class support for Kotlin thanks to the features provided by the programming language. The Spring Framework makes use of Kotlin extension functions to add new specific conveniences to existing APIs. In this session, you will learn about the extensions and DSLs that are provided in Spring for Kotlin developers. Also you will learn about Kotlin's language features that make it possible to extend the existing Java APIs.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/dragon74/spring-boot-based-collaboration Developing software based on micro services architecture is extremely easy when you use spring boot and spring cloud. Just throw in a few lines of code and you can have a micro service up and running. But when you have many micro services it’s not easy to run and maintain all of them locally, so you have use a central deployment. But if all developers do it, how can they work simultaneously on the same central spring cloud environment and still not interrupt each other? In this talk, I will you show you how to resolve this chaos and boost your productivity along the way.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/rieckpil/how-fixing-a-broken-window-cut-down-our-build-time-by-50-percent The broken windows (not the operating system - 😁) theory not only applies to criminological cases but also codebases. It only takes one lazy developer to break the first window. Chances are high that others will follow a similar path and take workarounds or re-apply a not so optimal pattern thinking, "It passed the code review, I must not be that bad". For our Spring Boot integration test setup, we had such a broken window that was causing ever-growing build times. While most books about clean architecture emphasize composition over inheritance, we drifted off from this rule and coupled our tests to an AbstractIntegrationTest class that we then annotated with @DirtiesContext... This resulted in ever-growing build times as each new integration test was launching its own Spring TestContext, adding valuable seconds to the overall build time. Our feedback cycles, as well as the overall satisfaction of the team, started to suffer from this. This talk describes our journey of getting rid of @DirtiesContext on top of an abstract test class (aka. the "broken window") that made reusing the Spring TestContext impossible and resulted in ever-growing build times. Furthermore, we'll discuss recipes, best practices, and antipatterns for resuing the Spring TestContext and testing Spring Boot applications in general. After fixing this "broken window", our overall build time went down by 50% from 25 to 12 minutes.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/bsbodden/bootiful-multi-model-applications-with-redis-stack GitHub Repo: https://github.com/bsbodden/bootiful-redis-stack Redis Stack provides a seamless and straightforward way to use different data models and functionality from Redis, including a document store, a graph database, a time series data database, probabilistic data structures, and a full-text search engine. In this session, I will walk you thru the building of a Spring Boot application that uses a hybrid model with Redis OM Spring. Redis OM Spring provides a robust repository and custom object-mapping abstractions built on the powerful Spring Data Redis (SDR) framework to tap into all the modules of Redis Stack.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/mraible/reactive-microservices-with-spring-boot-and-jhipster-spring-io-2022 Microservice architectures are all the rage in JavaLand. They allow teams to develop services independently and deploy autonomously. Why microservices? If you are developing a large/complex application AND you need to deliver it rapidly, frequently, and reliably over a long period of time THEN the Microservice Architecture is often a good choice. Reactive architectures are becoming increasingly popular for organizations that need to do more, with less hardware. Reactive programming allows you to build systems that are resilient to high load. In this session, I’ll show you how to use JHipster to create a reactive microservices architecture with Spring Boot, Spring Cloud, Keycloak, and run it all in Docker. You will leave with the know-how to create your own resilient apps!

Jun 13, 2022 Spring I/O 2022 - Barcelona, 26-27 May Testcontainers libraries integrate with Spring Boot to offer seamless, unit-test like experience for integration tests with real services running in containers: Kafka, databases, Elasticsearch, cloud technologies and everything else runnable in Docker. This flexibility can help in development environments automatically providing access to all required services without complex setups. In this session we’ll show how you can supercharge your existing testing infrastructure based on Testcontainers for local development, programmatically require service dependencies without sacrificing speed of your development loop!

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/graciano/batch-processing GitHub repo: https://github.com/rodrigolgraciano/batch-demo Spring Batch is a lightweight framework that comes with many out-of-the-box solutions such as transaction management, retry, chunk processing, and several templates to help you read, transform and write data from/to with text/XML files, messages, DB, and more. In the enterprise world, we need to deal with a large amount of data that comes from multiple sources, and there’s a considerable amount of effort to read, process, and distribute it. As the number of records increases, plain Java may not be the best solution. With many out-of-the-box solutions such as transaction management, retry, chunk processing, and several templates, Spring Batch is a lightweight framework to help you in these tasks. This talk will dig into Spring Batch, discuss its architecture and templates, and live code examples to demonstrate its power.

Spring I/O 2022 - Barcelona, 26-27 May Frontend development is getting more and more complex when using JavaScript frameworks like Angular or React. On top of that, the landscape is also rapidly changing. Developers claim that this is needed to build the highly interactive web experiences we all come to know and like. However, that is not true. This talk will show how you can use the productive combination of Java 17, Spring Boot, Thymeleaf, and the htmx JavaScript library to build such experiences without writing JavaScript. Adding a few attributes to your HTML will allow you to implement patterns like Click To Edit, Endless Scrolling, Lazy Loading, etc… You might think that you need to start your new project with a JavaScript framework because you “might need that interactivity” later. This talk will show that you can use htmx to enhance your web application easily where it makes sense. For the rest of your application, use the simplicity and productivity of server-side rendering. htmx is already making great strides in the PHP/Laravel and Python/Django world, it is time for the Java/Spring Boot world to embrace this as well.

Spring I/O 2022 - Barcelona, 26-27 May There are multiple things to consider when creating reactive systems. Orchestration with reactive APIs is not easy and often error prone. Introducing a message broker to handle and manage asynchronous communication is common practice in reactive systems and leads to event driven architectures. In such architectures it becomes harder to manage and monitor the state of your systems. Having transparency about the state is essential especially considering more complex principals for example the Saga Pattern. This talk introduces ways of how to manage state in a reactive system. It outlines the concept of modern workflow engines, ways to integrate them in your spring environment, with message brokers or use them in a standalone fashion.

Spring I/O 2022 - Barcelona, 26-27 May Single page applications (SPA) have become the standard for web application development. Angular, React and Vue.js are the best-known. But does this client architecture fit every application? Or are there alternatives that may fit better and are less complex to develop? In the first part of the talk, the differences between SPAs and classic, server-side approaches are explained and the advantages and disadvantages are discussed. The second part reports on a current customer project in which the front end of a large ERP system had to be replaced by a modern web front end. The chosen framework is Vaadin Flow, a server-side web framework that makes development of web applications entirely in Java possible. First, the new architecture of Vaadin Flow, which is no longer based on GWT but on web components, is explained. Then it will be shown how configurable, form-based and data-centric web applications can be implemented very efficiently by using jOOQ as a database access layer.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/thomasvitale/spring-cloud-gateway-resilience-security-and-observability-5c5c49df-3698-4d25-ad38-f4a6e0d2359e GitHub repo: https://github.com/ThomasVitale/spring-io-2022-spring-cloud-gateway Do you want to use a microservices architecture? Are you looking for a solution to manage access to single services from clients? How can you ensure resilience and security for your entire system? Spring Cloud Gateway is a project based on Reactor, Spring WebFlux, and Spring Boot which provides an effective way to route traffic to your APIs and address cross-cutting concerns. In this session, I’ll show you how to configure an API gateway to route traffic to your microservices architecture and implement solutions to improve the resilience of your system with patterns like circuit breakers, retries, fallbacks, and rate limiters using Spring Cloud Circuit Breaker and Resilience4J. Since the gateway is the entry point of your system, it’s also an excellent candidate to implement security concerns like user authentication. I’ll show you how to do that with Spring Security, OAuth2, and OpenID Connect, relying on Spring Redis Reactive to manage sessions. Finally, I’ll show you how to improve the observability of your system using Spring Boot Actuator and Spring Cloud Sleuth and relying on the Grafana stack.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://xeraa.net/talks/bootiful-opentelemetry/ OpenTelemetry, or OTel for short, is taking over the observability world. And with Spring Boot’s widespread success, they work together very well to uncover all kinds of performance problems or errors. Let’s look at that hands-on. This talk dives into the background of OTel including the technologies its building on (or replacing). It also takes a look at what auto-instrumentation can and cannot achieve. As well as the latest developments beyond tracing with metrics and the first steps towards logging.

Spring I/O 2022 - Barcelona, 26-27 May The Spring team is preparing a new generation of the core framework for 2023 and beyond: Spring Framework 6 comes with a Java 17 and Jakarta EE 9 baseline and introduces major new themes, ranging from AOT/Native to Observability. This talk focuses on key design decisions and roadmap considerations.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://bit.ly/3m3zGWp When it comes to distributed, event-driven messaging systems, we usually see them supporting either one of two types of semantics: streaming, or queueing, and rarely do we find a platform that supports both. In this presentation, we’ll first get an introduction and some clarifications of event-driven versus message-driven systems, event streams, and stream processing. We’ll then take a look at Apache Pulsar which offers a very unique capability in modern, cloud-native applications and architecture, in which its platform supports both Publish-Subscribe and Message Queues, and extends into streams processing as well as performs message mediation & transformation. We will see how it works closely with and relies on Apache Bookkeeper for its durable, scalable, and performant storage of log streams, and leverages on Apache Zookeeper to manage the otherwise very complex ecosystem. We will then compare Apache Pulsar with the popular Apache Kafka platform to understand some of their key differences as to how Pulsar can overcome some of Kafka's limitations. With Pulsar's flexible architecture and cloud-native readiness, we will take a look to see how it can be integrated and work collaboratively with the popular Spring framework.

Spring I/O 2022 - Barcelona, 26-27 May In enterprise contexts, developers are often taught that we need to decouple our application layers and create reusable access methods for our data – but is that really true? Join me to find out how to write less code and create fast & easily maintainable software with Spring Data Projections. Software that has multiple domains needs code which maps between them. The reasoning behind this is, that domains have to be decoupled from each other. This is especially important in layered architecture, a style that is widely used in todays’ software projects. Having layers in the application – usually a persistence layer, an application layer and a presentation layer – enforces separation of concerns and decouples the data models from each other. But: does it really? In this session I will share some thoughts on the up- and downsides of layered architecture, boilerplate code, a common JPA antipattern, why “decoupled classes” do not mean “decoupled data” and how we could make our lives easier, if we let the database do what it does best: Transforming data.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://www.slideshare.net/bunkertor/the-dream-stream-team-for-pulsar-and-spring For building Java applications, Spring is the universal answer as it supplies all the connectors and integrations one could want. The same is true for Apache Pulsar as it provides connectors, integration and flexibility to any use case. Apache Pulsar has a robust native Java library to use with Spring as well as other protocol options. ApachePulsar provides a cloud native, geo-replicated unified messaging platform that allows for many messaging paradigms. This lends it self well to upgrading existing applications as Pulsar supports using libraries for WebSockets, MQTT, Kafka, JMS, AMQP and RocketMQ. In this talk I will build some example applications utilizing several different protocols for building a variety of applications from IoT to Microservices to Log Analytics.

Spring I/O 2022 - Barcelona, 26-27 May Modularity is key to successful application architecture as it allows to evolve different parts of the system at exactly the pace needed, at exactly the right time for proper reasons. Different architectural styles make varying trade-offs in defining constraints on how to implement modularity resulting in system characteristics and consequences for the organization behind the system. The talk starts by discussing approaches and tools to identify modules. It then moves on to give an overview about different strategies on how to implement modules at varying levels of granularity, discusses the trade-offs that each of those approaches imply and points to libraries within the Spring eco-system that support developers implementing the particular styles.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/olgamaciaszek/whats-new-in-spring-cloud Enhanced support for Kotlin, support for Cloud Events, gRPC and RSocket, major enhancements in AWS Lambda support, streaming solutions, and more – a lot of work has gone into Spring Cloud Function in the last year. And what about Spring Cloud Sleuth and the whole observability story? Is there a Spring Cloud Sleuth integration for OkHttp? What declarative HTTP client can you use with WebClient for elegant HTTP calls? How can you easily route between multiple RSocket service instances? What about Spring Cloud Gateway? How can you effortlessly integrate your HTTP-based service with newer services that communicate with RSocket using Spring Cloud Gateway? Does Gateway support GRPC or HTTP2? And, of course, can any of this tech be run as native images? Questions abound, so, in this ”state of the union” session, Olga and Oleg will answer some of them by going over the noteworthy features of various spring-cloud projects, showing how they can be used to solve real problems faced by users.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/marcusdacoregio/securing-spas-with-spring GitHub repo: https://github.com/marcusdacoregio/springio-2022-securing-spas-with-spring Single Page Applications have become a hot topic in developer communities. When dealing with Authentication and Authorization in such applications, there are some things that have a more delicate approach, like hiding secrets, exposing a REST API to the public internet, amongst others. Those concepts might be difficult to absorb and deal with at first. There are a lot of different choices to make, should we use JWT, OAuth, SAML, Session-based authentication, etc.? At the end of the day, we just want to start our projects and make them secure, easy to maintain, and resilient to authentication and authorization changes. Fortunately, Spring Security makes it easy for us, by providing out-of-the-box support for authentication, authorization, and prevention against common attacks. Join Marcus Da Coregio, a Spring Security team member, in this beginner-friendly talk to learn more about: - Secure by Default - SPA Authentication - CORS issues - User Store customization - CSRF tokens - Insecure Direct Object Reference

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://bit.ly/debeziumspring Apache Kafka is a highly popular option for asynchronous event propagation between microservices. Things get challenging though when adding a service’s database to the picture: How can you avoid inconsistencies between Kafka and the database? Enter change data capture (CDC) and Debezium. By capturing changes from the log files of the database, Debezium gives you both reliable and consistent inter-service messaging via Kafka and instant read-your-own-write semantics for services themselves. In this session you’ll see how to leverage CDC for reliable microservices integration, e.g. using the outbox pattern, as well as many other CDC applications, such as maintaining audit logs, automatically keeping your full-text search index in sync, and driving streaming queries. We’ll also discuss practical matters, e.g. HA set-ups, best practices for running Debezium in production on and off Kubernetes, and the many use cases enabled by Kafka Connect’s single message transformations.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://wkorando.github.io/presentations/to-java-n-and-beyond/ Java 17 has come and gone, but development on Java continues on! What has changed since Java 11? And what changes are being added in Java 18 and Beyond? Come find out! In this presentation we will look at some of the key changes that have been added to Java post-8. The large changes; the Module System and Records, quality of life improvements; var, text blocks, pattern matching, and the many performance and runtime improvements. We will finish the presentation with a brief look ahead to some of the changes that will be coming to Java in the near future and why Java’s future is bright.

Spring I/O 2022 - Barcelona, 26-27 May A wide variety of customers use Flowable in ways we never could imagine, confronting us with new requirements every day. Can we deploy your application to Tomcat, Jetty, JBoss, standalone JAR, Kubernetes, Docker, AWS, Azure, Google Cloud? How do we connect it to our Database? How can we change the task execution pool? Can we use OAuth2, LDAP? How about our own inhouse custom security? Can we change …? We will show you how we have managed to leverage the power of the Spring Ecosystem to provide answers to all these questions and speed up our development efforts, while still maintaining a vibrant open-source community. Spring Boot has enabled countless developers around the world to more easily create new applications. Its opinionated approach allows developers to focus on the business value to their customers instead of fiddling with infrastructure details and how to configure the application. At Flowable we decided to build our enterprise Workflow management platform on top of the Spring (Boot) Ecosystem. This allows us to fully focus on bringing our business value to our customers and stand on the shoulders of Spring for many of the requirements expected from an enterprise application. In this talk, we will present how we are leveraging different parts of the Spring ecosystem to build a robust Workflow management platform for our customers, and even enable them to build their own solutions for their own customers. We will show how we rely on Spring Core, Spring Kafka, Spring AMQP and Spring Integration to provide dynamic event processing configurations. How we use Spring Security to allow different types of authentication (LDAP, OAuth2, Basic Auth) and even support custom authentications by allowing customers to only use Spring APIs. Finally, we will show how we use Spring Boot to make it easy for our customers to start creating their applications, without the need to wire things together.

Spring I/O 2022 - Barcelona, 26-27 May You’re a Spring developer with an interest for application architecture, curious how to express architectural ideas in your code base and how the Spring Boot ecosystem can support you implementing that? This talk is for you! The architecture and design of an application significantly influences its maintainability, testability, and quality in general. Spring has always been a versatile tool to support architects implementing practices and patterns that have emerged to align technical building blocks in their code bases with domain concepts and boundaries. It allows developers to ultimately build applications that distinctly reflect architectural ideas and thus are more amendable and maintainable eventually. Key aspects of that are code organization for encapsulation, the Spring bean relationship arrangement and how to use domain events to decouple logically individual parts of the application even within a singular artifact. The talk discusses those patterns and approaches to introduce libraries like jMolecules and Moduliths to in turn show how they uniquely position Spring developers to build better structured, more maintainable applications.

Spring I/O 2022 - Barcelona, 26-27 May At Cloudsoft, we started to build a project on our familiar tech stack, but to overcome some known issues with the stack we decided to migrate it to Spring. The new tech stack is made of mostly AWS services and the project is designed to improve certain aspects of the experience for our customers using AWS services. I can’t tell you as much detail as I’d like about it as it’s currently in Alpha status and due for public release later this year. The final product is going to be available to clients via subscription, and takes a novel approach to solving a known AWS challenge. Thus, I cannot elaborate on the nature of the service provided, but I can share with you the following details: - the architecture - the migration details and reasons behind it - the challenges - the conclusions and solutions The core of the migration was introducing Spring. The most difficult part was using Spring to interface DynamoDB, not because of Spring, but because of the AWS DynamoDB Java SDK and the very cumbersome way to write filter expressions for querying and scanning. The presentation shows the table design, a moderately complex repository method to extract some data and as a bonus, how to reuse Spring code from the main project in a Lambda Step function.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://www.slideshare.net/jkuipers/hearts-of-darksess-a-spring-devops-apocalypse In this talk Joris will share several real-life failure cases concerning running Spring applications in production. Examples include services being killed because of health check issues, Micrometer metrics getting lost, circuit breakers never closing after opening, OOM errors caused by unbounded queues and other nightmarish scenario’s. Not only will you come to understand how these problems could sneak through staging to make their way to production, you will also be given practical tips on how to avoid these things from happening to your own applications. Otto von Bismarck famously said “Fools say that they learn by experience. I prefer to profit by others’ experience”. Don’t be a fool, and profit by attending this talk!

Spring I/O 2022 - Barcelona, 26-27 May GitHub repo: https://github.com/dcaron/bike-rental-extended We build it, you wreck it! CQRS and Event Sourcing is powerful, but also hard. We’ll demonstrate the dark side of event sourcing in production. Before all hope seems lost, we’ll look at how we can leverage Spring Boot, Axon, and Tanzu Application Platform to circumvent these pitfalls. During this session, we will show some of Spring Boot’s features that help ensure a smoothly running, observable workload. We’ll deploy our application in a real production environment and declaratively connect our applications to the services we need. We’ll scale out using Knative and lastly, we’ll see how Spring Boot Autoconfiguration makes configuration of complex solutions easy and boring…. Beware! This session isn’t just theoretical. We love production. Really, we do. But it will be harmed during this session, and you will help us do it.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://www.slideshare.net/sbrannen/testing-with-junit-5-and-spring-spring-io-2022 This session will give you an overview of the latest and greatest in the world of testing using JUnit Jupiter (a.k.a. JUnit 5) and the Spring Framework. The focus will be major new features in JUnit Jupiter 5.8 and 5.9 as well as recent and upcoming enhancements to Spring’s integration testing support.

Spring I/O 2022 - Barcelona, 26-27 May What is the best data architecture in the age of microservices and “you-build-it-you-run-it” cross-functional, autonomous teams? How should different microservices share data between themselves to minimise coupling? How should microservices share data with offline data consumers such as BI, CRM, or ML training pipelines to minimise dependencies with the microservice teams? How can we reconcile data quality, trustworthiness and single-source-of-truth with autonomous teams releasing multiple times per day? Is this doable without a centralized data governance team? Are centralized data governance teams as proposed by data lake architectures compatible with autonomous teams and continuous delivery? Data meshes have been proposed as a new data architecture paradigm to answer the questions above, but there are very few public reports on actual implementations and their challenges. We will share the data mesh journey that we started 2 years ago in eDreams, one of the largest online travel agencies in the world. We will focus on three topics: motivation, technical solution and transformational approach. First, we explain why we think data meshes are a better fit for microservice architectures run by cross-functional, autonomous development teams. Second, we show the architecture of our current implementation, including how the mesh is connected to the online platform, the technologies we used, and the outcomes and rationales for each of the multiple trade-offs we made. They include decentralized team autonomy, data ownership, quality and accountability, PCI and strict (European) privacy regulations, self-service data access and reporting, infrastructure cost and budgeting. Third, we share the organizational challenges we faced when replacing the multiple data systems that were working well at the local level. Finally, we will conclude with our current list of open issues and future work.

Spring I/O 2022 - Barcelona, 26-27 May As Java developers, we know the benefits of type-safety when building apps. The problem? Usually, that type-safety ends when we leave the server. What if it didn’t have to? In this presentation, you’ll learn how to build a modern, reactive, web app in TypeScript with view-to-database type safety using the open-source Hilla framework. The app uses a Spring Boot backend and connects type-safely to a Lit-frontend.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/thombergs/lets-build-components-not-layers Code is written once and read often. So we should focus on making it easily readable. We all know that. The same is true for the architecture of an application. It’s usually created once and then read and re-read, understood and misunderstood, interpreted and misinterpreted a lot of times by a lot of people during its lifetime. We try to get a grip on this problem by using architectural patterns like layers. While layers are a well-understood structure, they only help in understanding the big picture of the application’s architecture. They usually don’t do a good job of organizing the code into pieces that are easy to understand and reason about. Usually, a better approach to structure the code is to build components. Like lego bricks, we can compose multiple (vertical and horizontal) components to a bigger component, until we have built a complete application. We can zoom in and out of the codebase along the seams of the components to understand what we need to understand at the level of abstraction that we are currently concerned with. In this talk, we’ll explore a lightweight way of structuring the codebase of a Spring Boot application that will feel like building lego. This component-based structure is easy to understand and reason about. It’s also easy to maintain over time thanks to a single rule that can be enforced by tooling. Java, Spring Boot, and ArchUnit bring all the tools we need for a nice component-based codebase, we just need to use them. ================================================ Video Chapters 00:00:00 Introduction 00:04:50 About the speaker 00:05:50 Why organise code? 00:08:47 What's wrong with layers? 00:12:09 What's wrong with vertical slices? 00:14:36 Clean / Hexagonal architecture 00:21:38 Component-based architecture 00:30:58 Field Study - Building a check engine component 00:43:44 Why build components? 00:47:03 Thank you

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/larsduelfer/beyond-rest-an-overview-about-modern-api-technologies GitHub repo: https://github.com/NovatecConsulting/YATT REST is the most popular web API technology used these days. It is well supported by programming languages, frameworks and all kind of monitoring tools as well as understood by many developers. It is therefore often the first choice when having to implement a web API for any kind of backend. But there are limitations and use cases where REST API’s do not fit that well. Luckily, there are a few interesting alternatives available these days. GraphQL is one such alternative so are gRPC and RSocket. In this talk I will introduce these technologies, explain their pros and cons compared to REST, talk about their maturity and how they are supported by Spring and Spring Boot. I will show code examples and a live demo.

Spring I/O 2022 - Barcelona, 26-27 May After project Spring Security OAuth has been deprecated, there was a lot of confusion in the community. You could use Spring Security to write the resource server but not the authorization server. But the dark age is now over. In this session, we discuss implementing an authorization server using the new Spring Security Authorization Server project. https://spring.io/blog/2021/08/19/spring-authorization-server-goes-to-production OAuth 2 and OpenID Connect are tremendously important today since they represent the most used standards for implementing authentication in apps. Spring apps are no exception to this approach. We’ll start with a refresher on OAuth 2 and OpenID Connect and remember shortly how an authorization server was configured using the Spring Security OAuth project (now deprecated). Then, we’ll work on an example where we implement an authorization server using the new approach -the Spring Security Authorization Server project. You’ll learn how to use the new project to write your custom authorization server but also what advantages does this project brings above the old-fashioned way.

Spring I/O 2022 - Barcelona, 26-27 May Mr. Who? Besides one of my childhood heroes, Mr. Miyagi is a fictional karate master from Okinawa, Japan, in the movie serie ‘The Karate Kid’. He was the karate mentor of several people and made them worthy champions. I wanted that too! So began my own karate journey with my own sensei (mentor). Later, I became a lawyer and got a so-called ‘patroon’ (another mentor). Both mentor relationships have borne fruit. When I took my first steps in my career switch to the IT world, I discovered that mentorship is not a matter of course. What a pity! Fortunately, I managed to find one again. I experienced it as a difference as night and day. I would like to talk about the mentorship’s “what”, “who” and “how”. I would also like to explain the importance of mentorship in our field and what it could offer us as a developers community. In doing so, I would like to share my own experiences and ideas. To add weight to it, I make a link with research. I have looked at whether I can find my own experiences and ideas back in society, science or both. I think that we as a developers community, but also as an employer and client, should not want anything else and I would like to explain why.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/timvanbaarsen/spring-kafka-beyond-the-basics-lessons-learned-on-our-kafka-journey-at-ing-bank GitHub repo: https://github.com/j-tim/spring-io-barcelona-2022-spring-kafka-beyond-the-basics You know the fundamentals of Apache Kafka. You are a Spring Boot developer and working with Apache Kafka. You have chosen Spring Kafka to integrate with Apache Kafka. You implemented your first producer, consumer and maybe some Kafka streams, it’s working… Hurray! You are ready to deploy to production what can possibly go wrong? In this talk, Tim will take you on a journey beyond the basics of Spring Kafka and will share his knowledge, pitfalls, and lessons learned based on real-life Kafka projects that are running in production for many years at ING Bank in the Netherlands. - Can you survive consuming a poison pill from a Kafka topic without writing gigabytes of log lines? - Do you understand how to deal with exceptions in different cases? - Do you validate incoming data consumed from a topic? - Should you do integration testing for Kafka? And what the other options do I have? - Can you incorporate Apache Kafka as part of your distributed tracing? - Are you able to monitor the performance of your Kafka applications to understand whether or not you are lagging behind? In case you answer one or more above questions with ‘NO’ join this talk! ======================================= Video Chapters 00:00:00 Introduction 00:03:47 Kafka in a nutshell 00:07:44 Spring for Apache Kafka 00:13:35 Scenario: Poison Pill (Deserialization exception) 00:25:43 Scenario: Lack of proper exception handling 00:32:18 Testing 00:37:30 Monitoring 00:42:12 Lessons learned

Spring I/O 2022 - Barcelona, 26-27 May Spring is all about helping developers get to production quickly and safely. These days, “production” is all but guaranteed to mean Kubernetes, and Spring has you covered. Join me, Spring Developer Advocate Josh Long (@starbuxman), and we’ll look at how Spring Boot makes writing blisteringly fast, cloud-native, and scalable services more effortless than ever.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/maciejwalkowiak/troubleshooting-spring-boot-applications-with-sentry GitHub repo: https://github.com/maciejwalkowiak/troubleshooting-spring-boot-appplications-with-sentry Do you hate browsing jungle of logs to find errors and especially context why they happened? Me too. There are better ways! With Sentry and its Spring Boot integration, you get all the context you need to address bugs and performance issues in no time. It’s open source & free. No strings attached. No matter how clean our code is, how good our tests are, how well our infrastructure scales - one day, eventually something will go wrong in production. Bugs and outages cases customer to lose trust and cost real money. Our job is to identify and fix the issue as quickly as possible. In this session, we will have a look at Sentry - an open source troubleshooting and application monitoring solution - and its seamless integration with Spring Boot. We will learn the benefits of treating errors as contextual events and how exception reporting and performance monitoring in a single tool simplify addressing production issues.

Spring I/O 2022 - Barcelona, 26-27 May Config Maps, Secrets, Spring Cloud Configuration Server, Kubernetes Services, Spring Cloud Discovery Client…there are many ways to tackle configuration and service discovery on Kubernetes, but which approach is correct? In this session we will take a look at all the various options for externalizing configuration and using service discovery when running Spring Boot apps on Kubernetes. We will address the pros and cons of each and discuss which approach is appropriate for your individual application to help you best meet your business requirements. With the use of live demos and code, you will walk away with a better understanding of how to build cloud native Spring Boot applications that take advantage of everything Kubernetes has to offer.

Spring I/O 2022 - Barcelona, 26-27 May GraphQL presents an alternative to REST for web APIs that is rapidly becoming a popular choice for web and mobile clients due to its ease of use and control. Spring for GraphQL is a new project developed in collaboration between Spring and GraphQL Java contributors that is set to go GA in May, a week before Spring I/O. The goal for this talk is to provide a comprehensive overview of the programming model and features available in this new project. If you have not yet tried it, the talk should be a good introduction. If you are already a user, you can get insight into decisions made on the way to the 1.0 release.

Spring I/O 2022 - Barcelona, 26-27 May Standardizing solutions within a company is hard. As a result, companies usually end-up creating internal libraries and frameworks to reduce boilerplate. This approach can lead to a new set of problems: rigid designs, lack of documentation, inability to find answers outside the company (no StackOverflow!!), etc. In this session, we’ll talk about the reasons for developing our own internal framework at Travix, on top of Spring Boot (company-wide logging format, unified serialization, metrics, error-handling, etc.). We’ll share the problems that came along with the initial design and why we rewrote it from scratch, to provide a non-intrusive and transparent solution for developers. We’ll show how we can achieve production-readiness using several Spring mechanisms without compromising services final code. BeanPostprocessor, AutoConfiguration, Filters and Interceptors are just some of the concepts that we’ll cover, explaining how they behave and what we can achieve by using them. Not only that, but we’ll also demonstrate how we can allow different applications to customize default behaviours, given their specific requirements. The final result is a Maven dependency that we can add to our projects, transforming them out-of-the-box into production-ready services. Does any of the above sound familiar? Do you want to find out more about the Spring concepts mentioned? We hope to see you at this session.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://www.slideshare.net/salaboy/spring-io-2022-knative-and-spring-bringing-back-the-func Kubernetes is now a standard to deploy and manage containerized applications. How do functions fit into the cloud-native space in 2022? What does it take to write a function in Java or any other language and get it up and running in a Kubernetes cluster? We’ll show with practical examples and a live demo how developers can focus on the business logic while the platform takes care of supporting event-driven and serverless workloads in a polyglot environment. - CloudEvents provide a language and transport-agnostic way to describe events. - Knative Eventing routes CloudEvents between producers and consumers so that developers don’t have to worry about which message broker is used under the hood (e.g. RabbitMQ, Kafka, cloud-provider specific). - Frameworks like Spring Cloud Functions let developers focus on implementing the business logic instead of dealing with infrastructural concerns and integrations with event brokers. - GraalVM and libraries like Spring Native make it possible to build serverless applications in Java and take advantage of the scale-to-zero feature offered by Knative Serving. - Cloud-Native Buildpacks solve the problem of building production-ready containers end to end, offering support for multiple languages and frameworks, and focusing on performance and security. To demonstrate how all these tools can work together, we will show how Knative func combines them and provide developers with a Dockerfile-free and Kubernetes YAML-free experience.

Spring I/O 2022 - Barcelona, 26-27 May Slides: https://speakerdeck.com/mploed/getting-modules-right-with-domain-driven-design Domain-driven Design helps teams achieve a better alignment between the business and the technical architecture in order to design applications that have highly expressive and maintainable domain models. This talk aims at giving you an overview of Domain-driven Design and how the ideas behind it help you to create better modular applications. We will talk about aspects from strategic Domain-driven Design such as Bounded Contexts and Subdomains, in addition to that the talk will explain the most important patterns from the tactical part of Domain-driven Design (Aggregate, Entity, Value Object). Finally you will learn about methods that help you in getting a better understanding about the domain you are working in.

Spring I/O 2022 - Barcelona, 26-27 May JDK Flight Recorder, like its namesake, the flight recorder in an airplane, can be an excellent tool for collecting information on a Java application as it is running and when problems occur. In this presentation we will get an intro on how to use JDK flight recorder to collect information about our Java applications, interpret the results, and how to use the information to improve our applications!

Spring I/O 2022 - Barcelona, 26-27 May Join us in our 10th edition: 18-19 May 2023