Rapid Development Tools for Java EE 8 was a talk given at JavaOne 2017 about new features in Java EE 8 and tools to help with rapid development of Java EE 8 applications. It covered the Reactive Client API and JSON-B support in JAX-RS 2.1, asynchronous events and other new features in CDI 2.0 and Bean Validation 2.0, and how tools like Jeddict can generate Java EE 8 applications from models.
Rapid Development Tools for Java EE 8 [TUT2998]Gaurav Gupta
This document provides a summary of the presentation "Rapid Development Tools for Java EE 8" given by Mert Çalışkan and Gaurav Gupta at JavaOne 2017. The presentation provides an overview of the new features in Java EE 8, including JAX-RS 2.1, CDI 2.0, Bean Validation 2.0, JSON-B, JPA 2.2, and the Java Security API 1.0. It then demonstrates tools for developing Java EE 8 applications more productively, such as the Jeddict modeler, Dynamic Code Evolution Virtual Machine, Payara tools in NetBeans, and Maven plugins. The presentation concludes with a question and answer section.
Moje slajdy z prezentacji na GraphQL Wroclaw #3 https://www.meetup.com/GraphQL-Wroclaw/events/261828347/
Większość prezentacji dotyczących GraphQL opowiada o JavaSkryptowych narzędziach, natomiast mało kto mówi o tym jak korzystać z GraphQL w Javie. Prezentacja będzie o tym, jak sprawić aby nasz backendowy, Javowy serwer korzystał z GraphQL. Będzie o możliwych podejściach w implementacji, dobrych praktykach i 4-letnim doświadczeniu z GraphQL na produkcji.
Struts 2 is an open source MVC framework based on Java EE standards. It uses a request-response pipeline where interceptors pre-process and post-process requests. The core components are interceptors, actions, and results. Interceptors provide functionality like validation while actions contain application logic and results define the response. Values are stored and accessed from a value stack using OGNL.
The document contains questions and answers related to Java Swing components. It discusses how to divide a JFrame into two parts using a JSplitPane. It also explains features of Swing like being truly cross-platform, fully customizable, using JavaBeans components, and having no framework lock-in. Examples are provided for various Swing components like JProgressBar, JTree, JTabbedPane, JScrollPane and how to create menus in Java.
The document discusses plans for Contexts and Dependency Injection (CDI) 2.0. Main topics for CDI 2.0 include improving the event system by adding support for asynchronous events and event ordering. It also aims to define bootstrapping for CDI in Java SE applications and improve aspects of CDI like AOP. The specification work incorporates community feedback and aims to support new Java 8 features.
This document discusses architecture components for building modern Android applications. It covers common app architecture problems and principles like separation of concerns. It introduces key Architecture Components like Activities, Fragments, Services, ContentProviders, ViewModels and LiveData. It also discusses architectural patterns like MVC, MVP, MVVM and recommendations like clean architecture. The document emphasizes principles like modularity, separation of concerns, and testability. It provides an overview of alternatives like Room, Paging Library, and recommendations for legacy apps.
The world of open source libraries and tools is vast for Android developers. Writing apps using solely Android SDK is impractical. Libraries can help you in many ways. They can speed up your development, save you creating boilerplate code and dealing with platform fragmentation, simplify your code and make it more readable and maintainable. In the talk I’m showing how several truly useful libraries can help a developer.
Presented at MobCon Europe 2017.
Rapid Development Tools for Java EE 8 [TUT2998]Gaurav Gupta
This document provides a summary of the presentation "Rapid Development Tools for Java EE 8" given by Mert Çalışkan and Gaurav Gupta at JavaOne 2017. The presentation provides an overview of the new features in Java EE 8, including JAX-RS 2.1, CDI 2.0, Bean Validation 2.0, JSON-B, JPA 2.2, and the Java Security API 1.0. It then demonstrates tools for developing Java EE 8 applications more productively, such as the Jeddict modeler, Dynamic Code Evolution Virtual Machine, Payara tools in NetBeans, and Maven plugins. The presentation concludes with a question and answer section.
Moje slajdy z prezentacji na GraphQL Wroclaw #3 https://www.meetup.com/GraphQL-Wroclaw/events/261828347/
Większość prezentacji dotyczących GraphQL opowiada o JavaSkryptowych narzędziach, natomiast mało kto mówi o tym jak korzystać z GraphQL w Javie. Prezentacja będzie o tym, jak sprawić aby nasz backendowy, Javowy serwer korzystał z GraphQL. Będzie o możliwych podejściach w implementacji, dobrych praktykach i 4-letnim doświadczeniu z GraphQL na produkcji.
Struts 2 is an open source MVC framework based on Java EE standards. It uses a request-response pipeline where interceptors pre-process and post-process requests. The core components are interceptors, actions, and results. Interceptors provide functionality like validation while actions contain application logic and results define the response. Values are stored and accessed from a value stack using OGNL.
The document contains questions and answers related to Java Swing components. It discusses how to divide a JFrame into two parts using a JSplitPane. It also explains features of Swing like being truly cross-platform, fully customizable, using JavaBeans components, and having no framework lock-in. Examples are provided for various Swing components like JProgressBar, JTree, JTabbedPane, JScrollPane and how to create menus in Java.
The document discusses plans for Contexts and Dependency Injection (CDI) 2.0. Main topics for CDI 2.0 include improving the event system by adding support for asynchronous events and event ordering. It also aims to define bootstrapping for CDI in Java SE applications and improve aspects of CDI like AOP. The specification work incorporates community feedback and aims to support new Java 8 features.
This document discusses architecture components for building modern Android applications. It covers common app architecture problems and principles like separation of concerns. It introduces key Architecture Components like Activities, Fragments, Services, ContentProviders, ViewModels and LiveData. It also discusses architectural patterns like MVC, MVP, MVVM and recommendations like clean architecture. The document emphasizes principles like modularity, separation of concerns, and testability. It provides an overview of alternatives like Room, Paging Library, and recommendations for legacy apps.
The world of open source libraries and tools is vast for Android developers. Writing apps using solely Android SDK is impractical. Libraries can help you in many ways. They can speed up your development, save you creating boilerplate code and dealing with platform fragmentation, simplify your code and make it more readable and maintainable. In the talk I’m showing how several truly useful libraries can help a developer.
Presented at MobCon Europe 2017.
Jasig Cas High Availability - Yale UniversityJasig CAS
This document discusses high availability configurations for CAS using F5 load balancers and replicated databases across CAS nodes. It provides options for replicating session data and tickets using JBoss Cache or a replicated database. It also addresses testing and infrastructure considerations.
Binding business data to vaadin componentsPeter Lehto
There are two main differences between setPropertyDataSource() and setContainerDataSource() for Vaadin components:
1. Data source type - setPropertyDataSource() binds the component to a single property, while setContainerDataSource() binds it to a full Container which can contain multiple items and properties.
2. Data binding - setPropertyDataSource() binds the component value to a specific property of the current item. setContainerDataSource() does not directly bind the component, it just sets the container as the available options but does not automatically select any value. The component does not know which property in the container to use as the value.
So in summary:
- setPropertyDataSource() binds a single component to a specific property
This document discusses different approaches to refactoring repeated code in Java, including using methods, callable tasks, Java 8 functions, and interceptors. It notes the pros and cons of each approach in terms of syntax, completeness of handling all required logic, and other factors. The proposed solution is to combine functions and interceptors, using functions for the core logic and interceptors to wrap the function call and handle cross-cutting concerns like logging and resource management in a centralized way. The discussion considers other approaches like dependency injection and invites questions.
This document provides an overview of Spring's transaction management capabilities. It discusses how Spring provides a uniform transaction management API that can work with various transaction technologies like JDBC, Hibernate, JPA etc. It also describes how transactions can be handled programmatically using the TransactionTemplate or directly through the transaction manager. Finally, it covers Spring's declarative transaction support using XML or annotations.
This document provides an overview of the DataStax Java Driver and how to use it to connect to and query Cassandra. It introduces key concepts like CQL, the data model, asynchronous operations, prepared statements, load balancing, and retry policies. The document also includes code examples for connecting to Cassandra, performing basic read and write operations using CQL strings and prepared statements, and more advanced techniques like asynchronous reads, query builders, custom load balancing policies, and object mapping.
The document discusses the Struts 2 framework architecture. It explains that the ActionContext stores the ValueStack which contains request data. The ValueStack holds application domain data for an action invocation and serves as the default root object for resolving OGNL expressions. Various tags like Iterator, If, Url are used to work with and retrieve data from the ValueStack. Results like DispatcherResult handles view resolution by forwarding to JSPs. The validation framework uses validators, validation metadata and domain data to validate action properties.
The document provides an overview of rule engines and the Drools rule engine. It discusses rule formats including Drools Rule Language (DRL), domain-specific languages (DSL), and decision tables. It also covers the ReteOO algorithm, using rules with Java objects, and developing rules using the Drools Eclipse IDE and Guvnor rule management system.
Clustering your Application with HazelcastHazelcast
Hazelcast is an open-source in-memory data grid that provides distributed map, queue, and other data structures. It allows building highly scalable applications by partitioning data and load across clusters of nodes. Hazelcast provides thread-safe concurrent data structures, native Java and C# clients, and can integrate with databases for persistence. It is used by many companies for applications requiring high availability and scalability like financial systems, telecom, and ecommerce.
The document discusses best practices for using the Java Persistence API (JPA). It covers:
- The entity manager and persistence context manage entities within a scope like a transaction.
- Entities transition between managed, detached, and removed states that impact database synchronization.
- Queries retrieve and manage entities from the persistence context and database.
- Transactions and locking strategies like optimistic and pessimistic concurrency control how changes are made.
- Extended and transaction scoped persistence contexts determine entity lifetime and caching.
- The second level cache can improve performance by caching entities across contexts.
This document provides an overview of event sourcing and CQRS approaches to system architecture. It discusses command handling, view handling, and writing event sourced DDD systems. It provides code examples of modeling commands, events, and aggregates in an event sourced system. It discusses benefits of event sourcing like having an audit log, horizontal scaling, and using events to power other services.
For More information, refer to Java EE 7 performance tuning and optimization book:
The book is published by Packt Publishing:
http://www.packtpub.com/java-ee-7-performance-tuning-and-optimization/book
The document provides an overview of the built-in JSP objects including Request, Response, Out, Session, Application, PageContext, Config, Page, and Exception. It describes the implementation class of each object and lists some common methods. A brief description is given for each object explaining its purpose and how it is used to interface between the client and server.
Struts 2 uses the Model-View-Controller (MVC) pattern for building web applications. The key components are:
1. Controller: The FilterDispatcher acts as the controller and maps requests to actions.
2. Model: Actions serve as the model, encapsulating business logic and acting as a data transfer locus between the request and view.
3. View: Results represent the view and render the output.
Actions return a result string to select the appropriate result for rendering. Data is stored in the ValueStack, a central data repository accessible via OGNL expressions. Interceptors handle cross-cutting concerns like validation before and after actions execute.
This document provides an overview of modern Android development techniques including application architecture patterns like MVC, MVP and MVVM. It discusses topics like dependency injection with Dagger 2, reactive programming with RxJava, HTTP libraries like Retrofit and OkHttp, annotations, testing, using Kotlin and the future of Android development targeting the next billion users across more devices.
The document provides an overview and agenda for a presentation on Struts 2, covering key topics such as configuration, actions, interceptors, results, tag libraries, and validation. Struts 2 is an open source MVC web framework that aims to improve developer productivity through features like convention over configuration, plug-in architecture, and reusable tag libraries. The presentation discusses Struts 2 concepts like the request pipeline, value stack, OGNL expressions, and type conversions that allow dynamic data handling.
The document provides an overview of Java Persistence API (JPA) terminology and concepts. It defines key JPA terms like entity, persistence unit, entity manager, and persistence context. It describes entity characteristics and the different types of entity managers, persistence contexts, and transaction managers supported by JPA. The document also covers JPQL, query parameters, named queries, inheritance, collections, caching and more advanced JPA features.
This document provides an overview of React and Redux concepts including:
- React basics like components, props, state, and lifecycle methods
- Flux architecture and how data flows through actions, dispatcher, and stores
- Redux as an alternative to Flux that uses a single store updated by reducers in response to actions
- Additional React topics like JSX, propTypes, and using React with ES6 classes are also covered.
OGNL is an expression language used in Struts 2 to retrieve values from the value stack, which holds objects used by actions. OGNL expressions can be used in JSP views and XML configuration files to extract values. Struts 2 provides tags for control flow, data retrieval, and creating UI elements to build model-view-controller web applications. Validation can be done declaratively using XML files or programmatically in Java code.
The document provides an overview of Struts 2 including:
1. The architecture of Struts 2 which uses patterns like front controller and composite.
2. A basic "Hello World" example demonstrating creating an action class and mapping it in struts.xml.
3. The Action interface and ActionSupport class which provides common functionality like validation. ActionSupport implements interfaces like Validateable.
4. Aware interfaces like SessionAware which allow injecting objects like the session into actions.
Boost Development With Java EE7 On EAP7 (Demitris Andreadis)Red Hat Developers
JBoss EAP7 brings support for the most recent industry standards and technologies, including Java EE7, the latest edition of the premier enterprise development standard. This session will provide an overview of the major additions to Java EE7, and how your team can use these capabilities on the advanced EAP7 runtime to produce better applications with less code.
This 50 minutes talk covers the novelties of Java EE 7 (easier to understand if you already know Java EE 6). It comes from the talk I gave with Arun Gupta at JavaOne 2013
Jasig Cas High Availability - Yale UniversityJasig CAS
This document discusses high availability configurations for CAS using F5 load balancers and replicated databases across CAS nodes. It provides options for replicating session data and tickets using JBoss Cache or a replicated database. It also addresses testing and infrastructure considerations.
Binding business data to vaadin componentsPeter Lehto
There are two main differences between setPropertyDataSource() and setContainerDataSource() for Vaadin components:
1. Data source type - setPropertyDataSource() binds the component to a single property, while setContainerDataSource() binds it to a full Container which can contain multiple items and properties.
2. Data binding - setPropertyDataSource() binds the component value to a specific property of the current item. setContainerDataSource() does not directly bind the component, it just sets the container as the available options but does not automatically select any value. The component does not know which property in the container to use as the value.
So in summary:
- setPropertyDataSource() binds a single component to a specific property
This document discusses different approaches to refactoring repeated code in Java, including using methods, callable tasks, Java 8 functions, and interceptors. It notes the pros and cons of each approach in terms of syntax, completeness of handling all required logic, and other factors. The proposed solution is to combine functions and interceptors, using functions for the core logic and interceptors to wrap the function call and handle cross-cutting concerns like logging and resource management in a centralized way. The discussion considers other approaches like dependency injection and invites questions.
This document provides an overview of Spring's transaction management capabilities. It discusses how Spring provides a uniform transaction management API that can work with various transaction technologies like JDBC, Hibernate, JPA etc. It also describes how transactions can be handled programmatically using the TransactionTemplate or directly through the transaction manager. Finally, it covers Spring's declarative transaction support using XML or annotations.
This document provides an overview of the DataStax Java Driver and how to use it to connect to and query Cassandra. It introduces key concepts like CQL, the data model, asynchronous operations, prepared statements, load balancing, and retry policies. The document also includes code examples for connecting to Cassandra, performing basic read and write operations using CQL strings and prepared statements, and more advanced techniques like asynchronous reads, query builders, custom load balancing policies, and object mapping.
The document discusses the Struts 2 framework architecture. It explains that the ActionContext stores the ValueStack which contains request data. The ValueStack holds application domain data for an action invocation and serves as the default root object for resolving OGNL expressions. Various tags like Iterator, If, Url are used to work with and retrieve data from the ValueStack. Results like DispatcherResult handles view resolution by forwarding to JSPs. The validation framework uses validators, validation metadata and domain data to validate action properties.
The document provides an overview of rule engines and the Drools rule engine. It discusses rule formats including Drools Rule Language (DRL), domain-specific languages (DSL), and decision tables. It also covers the ReteOO algorithm, using rules with Java objects, and developing rules using the Drools Eclipse IDE and Guvnor rule management system.
Clustering your Application with HazelcastHazelcast
Hazelcast is an open-source in-memory data grid that provides distributed map, queue, and other data structures. It allows building highly scalable applications by partitioning data and load across clusters of nodes. Hazelcast provides thread-safe concurrent data structures, native Java and C# clients, and can integrate with databases for persistence. It is used by many companies for applications requiring high availability and scalability like financial systems, telecom, and ecommerce.
The document discusses best practices for using the Java Persistence API (JPA). It covers:
- The entity manager and persistence context manage entities within a scope like a transaction.
- Entities transition between managed, detached, and removed states that impact database synchronization.
- Queries retrieve and manage entities from the persistence context and database.
- Transactions and locking strategies like optimistic and pessimistic concurrency control how changes are made.
- Extended and transaction scoped persistence contexts determine entity lifetime and caching.
- The second level cache can improve performance by caching entities across contexts.
This document provides an overview of event sourcing and CQRS approaches to system architecture. It discusses command handling, view handling, and writing event sourced DDD systems. It provides code examples of modeling commands, events, and aggregates in an event sourced system. It discusses benefits of event sourcing like having an audit log, horizontal scaling, and using events to power other services.
For More information, refer to Java EE 7 performance tuning and optimization book:
The book is published by Packt Publishing:
http://www.packtpub.com/java-ee-7-performance-tuning-and-optimization/book
The document provides an overview of the built-in JSP objects including Request, Response, Out, Session, Application, PageContext, Config, Page, and Exception. It describes the implementation class of each object and lists some common methods. A brief description is given for each object explaining its purpose and how it is used to interface between the client and server.
Struts 2 uses the Model-View-Controller (MVC) pattern for building web applications. The key components are:
1. Controller: The FilterDispatcher acts as the controller and maps requests to actions.
2. Model: Actions serve as the model, encapsulating business logic and acting as a data transfer locus between the request and view.
3. View: Results represent the view and render the output.
Actions return a result string to select the appropriate result for rendering. Data is stored in the ValueStack, a central data repository accessible via OGNL expressions. Interceptors handle cross-cutting concerns like validation before and after actions execute.
This document provides an overview of modern Android development techniques including application architecture patterns like MVC, MVP and MVVM. It discusses topics like dependency injection with Dagger 2, reactive programming with RxJava, HTTP libraries like Retrofit and OkHttp, annotations, testing, using Kotlin and the future of Android development targeting the next billion users across more devices.
The document provides an overview and agenda for a presentation on Struts 2, covering key topics such as configuration, actions, interceptors, results, tag libraries, and validation. Struts 2 is an open source MVC web framework that aims to improve developer productivity through features like convention over configuration, plug-in architecture, and reusable tag libraries. The presentation discusses Struts 2 concepts like the request pipeline, value stack, OGNL expressions, and type conversions that allow dynamic data handling.
The document provides an overview of Java Persistence API (JPA) terminology and concepts. It defines key JPA terms like entity, persistence unit, entity manager, and persistence context. It describes entity characteristics and the different types of entity managers, persistence contexts, and transaction managers supported by JPA. The document also covers JPQL, query parameters, named queries, inheritance, collections, caching and more advanced JPA features.
This document provides an overview of React and Redux concepts including:
- React basics like components, props, state, and lifecycle methods
- Flux architecture and how data flows through actions, dispatcher, and stores
- Redux as an alternative to Flux that uses a single store updated by reducers in response to actions
- Additional React topics like JSX, propTypes, and using React with ES6 classes are also covered.
OGNL is an expression language used in Struts 2 to retrieve values from the value stack, which holds objects used by actions. OGNL expressions can be used in JSP views and XML configuration files to extract values. Struts 2 provides tags for control flow, data retrieval, and creating UI elements to build model-view-controller web applications. Validation can be done declaratively using XML files or programmatically in Java code.
The document provides an overview of Struts 2 including:
1. The architecture of Struts 2 which uses patterns like front controller and composite.
2. A basic "Hello World" example demonstrating creating an action class and mapping it in struts.xml.
3. The Action interface and ActionSupport class which provides common functionality like validation. ActionSupport implements interfaces like Validateable.
4. Aware interfaces like SessionAware which allow injecting objects like the session into actions.
Boost Development With Java EE7 On EAP7 (Demitris Andreadis)Red Hat Developers
JBoss EAP7 brings support for the most recent industry standards and technologies, including Java EE7, the latest edition of the premier enterprise development standard. This session will provide an overview of the major additions to Java EE7, and how your team can use these capabilities on the advanced EAP7 runtime to produce better applications with less code.
This 50 minutes talk covers the novelties of Java EE 7 (easier to understand if you already know Java EE 6). It comes from the talk I gave with Arun Gupta at JavaOne 2013
Fifty New Features of Java EE 7 in Fifty MinutesArun Gupta
This document provides a summary of 50 new features in Java EE 7 across various Java EE specifications like CDI, JPA, EJB, JMS and more. It lists each new feature with a short description. The features include default enabling of CDI, method validation in Bean Validation, interceptors for constructors, prioritizing interceptor bindings, managed executors and scheduled executors for concurrency, schema generation in JPA, transaction management annotations in EJB and JTA, and a simplified JMSContext API.
Fifty Features of Java EE 7 in 50 Minutesglassfish
This document outlines 50 new features of Java EE 7 presented in 50 minutes. It begins with an overview listing the Java EE 7 specifications that have new features, such as JAX-RS 2.0, JSON-P 1.0, CDI 1.1, Bean Validation 1.1, Interceptors 1.2, Concurrency Utilities 1.0, JPA 2.1, JTA 1.2, and others. It then proceeds to briefly describe 16 new features across these specifications, including default CDI enabling, method validation in Bean Validation, interceptor bindings with priority in Interceptors, managed executors and scheduled executors in Concurrency Utilities, and schema generation and stored procedures in JPA.
The document discusses using annotations in Java, providing examples of annotations for servlets, EJBs, web services, CDI, and using frameworks like JUnit, Spring, Javassist, and ASM. It presents code samples to define servlets, session beans, RESTful and SOAP web services, and component injection using annotations instead of XML configurations. The document also demonstrates how to programmatically read annotation values and metadata using reflection, Javassist, and ASM.
The document discusses annotation processing and code generation. It describes using annotation processing to automatically generate retry logic for HTTP requests by creating a $$RetryStale interface with the same methods as the original interface but adding cache headers. The processing is done at compile time using the ProcessingEnvironment API to access elements, generate code with JavaPoet, and write the generated files. It recommends libraries like AutoService, Truth, and Compile testing to make annotation processors easier to write.
This document provides an overview and comparison of various Java web frameworks including JPA 2, MyBatis, Hibernate, Struts 2, Stripes, Spring MVC, Tapestry, Wicket, JSF 2, and GWT. Code examples are shown for implementing basic CRUD functionality using each framework. The frameworks are evaluated based on factors such as ease of use, query APIs, performance, portability, and community support.
Spring Data Requery is alternatives of Spring Data JPA
Requery is lightweight ORM for DBMS (MySQL, PostgreSQL, H2, SQLite, Oracle, SQL Server)
Spring Data Requery provide Query By Native Query, Query By Example and Query By Property like Spring Data JPA
Spring Data Requery is better performance than JPA
This document provides an overview of Java SCORE on ICON. It discusses why Java and the JVM were chosen, how bytecode is instrumented to work with ICON, the structure and APIs of Java SCORE compared to Python SCORE, and storage models including object graphs and key-value stores. It also covers error handling, supporting return types and collections, and object serialization in databases.
Slice: OpenJPA for Distributed PersistencePinaki Poddar
The document discusses Slice, an OpenJPA module that allows JPA applications to use distributed, horizontally partitioned databases in a transparent manner. It describes how Slice works under the hood to enable features like parallel query execution across database partitions, replication of master data, and distribution policies to determine which partition a given object is stored in. The document provides examples of configuring Slice and developing distribution policies.
Java Annotation is quite a handy tool and has the ample potential to make developer's life a lot easier(and exciting!). Learning and using custom Java Annotation Processor takes the power of Annotation even a class higher. This slide goes over a few fundamental things of an Annotation Processor to get someone started to write his/her own Annotation Processor in Java.
Key topics are,
- Java Annotation
- Usage of Annotation
- Custom Java Annotation
- Java Annotation Processor
- Usefulness of Annotation Processor
- Dive into the core of Annotation Processor
- Solve a validation problem with Custom Annotation Processor
- Get to know some exciting Annotation Processing tools that already exist
JUG Berlin Brandenburg: What's new in Java EE 7?gedoplan
Java EE 7 includes many new features and specifications such as JSF 2.2 with new functionality like faces flows, resource library contracts, and HTML 5 friendly markup. JPA 2.1 adds features like converters, enhanced JPQL and criteria queries, CDI injection in entity listeners, and entity graphs. CDI 1.1 enhances bean discovery and enables interceptors, decorators, and alternatives globally with priorities. Other additions are JSON support and client APIs in JAX-RS, and concurrency utilities, batch processing, and WebSockets. GlassFish 4 and WildFly 8 are reference platforms that implement the new Java EE 7 specifications.
Carol McDonald discusses the key themes and technologies in Java EE 6, which was released on December 10, 2009. The major themes of Java EE 6 are right-sizing with modular profiles, extensibility through pluggability, and ease of development through features like dependency injection and managed beans. New and updated specifications in Java EE 6 include CDI 1.0, EJB 3.1, JPA 2.0, JSF 2.0, JAX-RS 1.1, and Servlet 3.0.
NET Systems Programming Learned the Hard Way.pptxpetabridge
This document discusses .NET systems programming and garbage collection. It covers garbage collection generations, modes, and considerations for minimizing allocations. It also discusses eliminating delegates to reduce allocations, using value types appropriately, avoiding empty collections, and optimizing for thread locality to reduce context switching overhead. Data structures and synchronization techniques are discussed, emphasizing the importance of choosing lock-free data structures when possible to improve performance.
The document discusses Java Enterprise Edition 7 and the Java APIs that comprise it, including Java Persistence API, Enterprise JavaBeans, Context and Dependency Injection, and more. It then covers using these technologies with Vaadin, including managing user interfaces with CDI and structuring Vaadin apps using the Model-View-Presenter pattern. The MVP pattern aims to separate complex UI logic from rendering for cleaner code and easier testing.
Spring 3 emphasizes annotation configuration over XML. Key changes include support for JSR 250, 299/330, and 303 annotations as well as a simplified MVC framework with @Controller and @RequestMapping annotations. Validation is integrated using JSR 303 annotations and executed automatically by the framework. Configuration is also simplified through @Configuration classes and the @Bean annotation.
Struts has outgrown its reputation as a simple web framework and has become more of a brand. Because of this, two next generation frameworks are being developed within the project: Shale and Action 2.0. Action 2.0 is based on WebWork, and though its backing beans are similar to JSF, its architecture is much simpler, and easier to use.
Migrating to Struts Action 2.0 is more about unlearning Struts than it is about learning the "WebWork Way". Once you understand how simple WebWork is, you'll find that Struts Action 2.0 is a powerful framework that supports action-based navigation, page-based navigation, AOP/Interceptors, components and rich Ajax support.
Come to this session to see code comparisons and learn about migration strategies to use the kick-ass web framework of 2006.
This document provides an overview of React Native, including its pros and cons compared to native mobile development. It discusses key React Native concepts like components, props, state, styling with flexbox, and networking. It also covers the basics of functional programming concepts used in React like pure functions, immutability, and higher order functions. Finally, it suggests some next steps like using React Native with Redux for cross-platform apps or building desktop apps with Electron.
Similar to Rapid development tools for java ee 8 [tut2998] (20)
Easy Java Integration Testing with TestcontainersPayara
Having problems creating a maintainable set of integration tests for your enterprise Java application? This talk will help you understand how to use Test containers to implement easy integration tests for your next project!
Simplifying Integration Tests for Enterprise Java
Integration testing is always a difficult area. You need to make sure that all system dependencies are prepared, data is correctly initialised for each run and test runs do not interfere with each other. Even with tools like the Arquillian Framework, writing integration tests can be a complicated task and the act of maintaining large sets of tests can become a nightmare if there's not enough knowledge of all dependencies involved.
With the Testcontainers project, convoluted and complicated integration tests can be a thing of the past. A test container allows you to create reliable integration tests covering a wide range of scenarios like using databases, microservices interactions and even GUI and user experience testing. One of the important factors for the success of this framework is the usage of Docker containers to create a reliable reproducible environment for each test, which separates the dependencies and the application code in a way that it is easy to maintain for developers.
In this webinar, Payara Services CEO and Founder Steve Millidge will explain aboutPayara Cloud: how it works, why you might need it, how it can save you time and money.
Steve will explain what a truly “Serverless” solution consists of: how the user does not need to worry about application servers, instances, domains, hosts, Docker containers or any of the traditional concepts. He will explain how serverless can be brought about and its benefits, as well as demonstrating it on a runtime 100% designed forJakarta EEandMicroProfile: Payara Cloud.
Jakarta Concurrency provides APIs for concurrency and asynchronous programming in Java EE and Jakarta EE applications. It allows adding asynchronous breaks and running tasks in parallel or periodically. New features in Jakarta EE 10 include deployable managed executor services and scheduled executor services. Future plans include better integration with CDI contexts and aligning asynchronous servlets and JAX-RS with Concurrency. Developers are encouraged to get involved in the open source Eclipse project.
GlassFish Migration Webinar 2022 Current version.pptxPayara
If you’re running GlassFish in your production or development environment and are worried about the lack of support, infrequent application server releases, lack of bug fixes and patches – Then you might be considering migration.
Payara Server is an open source application server originally derived from GlassFish – supporting reliable and secure deployments of Jakarta EE (Java EE) applications in any environment: on premise, in the cloud or hybrid. To do our part to help advance the Jakarta EE project, Payara Services is a project lead for GlassFish, the Jakarta EE compatible implementation, but we recommend Payara Server Enterprise for your production environments for our included support services, stability, and security.
Migrating from GlassFish to Payara Server can be a simple and straightforward process. In this webinar, Payara CEO Steve Millidge will explain all the things you need to consider in order to make a migration as smooth as possible.
If you have any questions about the above, this will be a great opportunity to get answers directly from the source.
10 Strategies for Developing Reliable Jakarta EE & MicroProfile Applications ...Payara
Ever thought of implementing a modern cloud architecture with Jakarta EE and MicroProfile applications but don’t know which practices to follow? This talk will highlight 10 strategies that will help you implement robust scalable cloud-ready applications!
Securing Microservices with MicroProfile and Auth0v2Payara
In this day and age, securing enterprise platforms is a challenge that developers and consultants tackle in an uninformed manner, producing subpar solutions in most cases. To combat this pattern, third-party security services such as Auth0 have been devised to externalize the security of services, and they focus on stable implementations of common enterprise use cases (identity management, OAuth compatibility, and so on), and platforms such as Eclipse MicroProfile allow for their easy integration with enterprise Java microservices. Moreover, in combination with Kubernetes, MicroProfile is a very powerful tool to simplify securing microservices, monitoring them and creating reproducible deployments. This presentation showcases the strength of combining MicroProfile and an OAuth service by doing a live demonstration of securing enterprise Java microservices in Kubernetes.
Reactive features of MicroProfile you need to learnPayara
Why reactive? How is MicroProfile related to reactive programming? There are many reactive Java libraries but they all work in a different way and provide different API. MicroProfile brings common reactive APIs that can be reused in many libraries to provide a unified experience for many Java developers. Including reactive operators, messaging, REST and more. The core MicroProfile reactive operators API is designed with care by experts behind popular reactive libraries. MicroProfile also provides reactive APIs for asynchronous messaging, REST and thread-control, as well as interceptors to improve the fault-tolerance of your applications. On top of that, MicroProfile aspires to bring unified reactive APIs to Jakarta EE and even to Java SE to make them more accessible to every Java developer. Learning MicroProfile API once will make it easier to get you started with many reactive frameworks with less additional learning.
Effective cloud-ready apps with MicroProfilePayara
Presented during Payara Japan Tour 2019 (https://blog.payara.fish/payara-on-tour-in-japan).
In this session, you'll learn how to develop applications that evolve according to your needs, can easily run in the cloud and integrate with common cloud technologies. We'll start with a simple application, focusing on business logic. MicroProfile framework, powered by a lightweight opensource Payara Micro runtime, will get us started quickly and allow gradual improvements later.
MicroProfile contains a lot of components that make developers productive. It allows separating business logic from common concerns like configuration, failure-recovery, REST service calls, context propagation across service calls and securing services. Adding all of these to existing code is easy. It's also easy to introduce new microservices as needed and adopt cloud technologies as your application grows. I'll show you how, in a step-by-step demo. And if time allows, I'll also show how to run and scale your application effectively with Kubernetes in the cloud.
A step-by-step guide from traditional Java EE to reactive microservice designPayara
Have you wondered how you can improve the design of your applications to improve its performance? You probably heard that reactive design can lead to better response times and more flexible apps. But youre asking: Do I need to rewrite my apps from scratch? Do I need to learn a new framework for all that? The answer is no, especially if your application is built on top of Java EE and Java 8.
Together, we will explore how we can migrate parts of an existing Java EE application step-by-step, in order to increase its response time, throughput, and make it more flexible and robust. We will go through examples how to apply reactive design to a traditional codebase, using standard API from Java SE, Java EE and MicroProfile, split a monolith into several microservices and deploy them to cloud.
This document discusses transactions in microservices architectures and introduces MicroProfile Long Running Actions (LRA) as a solution. It provides an overview of LRA components and flow, and key concepts like compensation and timeouts. Code examples demonstrate using LRA annotations to define long-running transactions across multiple services.
When developing a microservices architecture using containers, orchestration is key to provide an elastic scalable infrastructure. Kubernetes (w/ Docker) and Payara Micro 5 make this possible! This talk will showcase how to implement all of this for a real production scenario!
What's new in Jakarta EE and Eclipse GlassFish (May 2019)Payara
Jakarta EE is now the standard for server-side Java under the Eclipse Foundation. It inherits from Java EE 8. The first Jakarta EE specification will be very similar to Java EE 8. Future versions like Jakarta EE 9 will include renamed specifications from Java EE with minor improvements. Developers should understand the transition from Java EE to Jakarta EE and get involved to help shape its future.
This document previews updates to Payara Platform 5.192, including preliminary JDK 11 support, native Docker support, MicroProfile 2.2 compatibility, and improvements to EJB remote access over HTTP. Potential future additions are also outlined, such as full JDK 11 support, new monitoring tools, Jakarta EE 8 certification, and better public cloud integration.
With the rise of micro-services, REST communication is more popular than ever. But the communication between the different parts must also be performed in a secure way.
First, we need to know if the user or system is allowed to call the JAX-RS endpoint. For this authentication part, self-contained tokens are the best option to not overload any of our services in the system. JWT which contains the authentication but also can contain the authorization info is ideal for this use-case.
And secondly, we need guarantees that the message isn't altered, that we can have message integrity. For that part, we can use signatures as specified in the HTTP signature draft specification.
The goal of MicroProfile is to optimise Java EE for a micro-service architecture. It is based on some of the Java EE specifications and standardise a few technologies from the micro-services space.
However, some of the MicroProfile implementations are completely different 'servers', like the KumuluzEE server. So how can you migrate easily from your favorite Java EE server to a MicroProfile implementation?
This session shows you an overview of what MicroProfile.IO is and how it relates to Java EE. It then demonstrates with a few examples how you can adjust your Java EE application to incorporate some of the MicroProfile.IO specifications and how you can transform your Java EE application to a MicroProfile.IO one using Thorntail, Payara Micro, and KumuluzEE.
Monitor Microservices with MicroProfile MetricsPayara
Microservices architecture has many benefits. But it comes at a cost. Running microservices and monitoring what’s going on is tedious. That’s why MicroProfile adopts monitoring as a first-class concept. In this session, learn how MicroProfile runtimes collect metrics and how to seamlessly collect them with tools like Prometheus and Grafana. Learn how MicroProfile makes it easy to connect information about interrelated service calls, how to gather the information and analyze system bottlenecks, how to deploy and scale MicroProfile applications with Kubernetes and how to react to their health status to detect and automatically recover from failures.
Java2 days -_be_reactive_and_micro_with_a_microprofile_stackPayara
This document discusses reactive microservices using MicroProfile specifications. It introduces MicroProfile as an open-source specification for Java microservices. The goals of MicroProfile are to provide better user experiences, save resources/costs, handle massive loads, and recover from failures. The document then explains the basics of reactive programming and how the reactive pipeline of subscribe, process, and publish fits within MicroProfile 2.0's support for reactive REST/SSE, async CDI events, and monitoring via metrics. It acknowledges some missing pieces and outlines plans to add further reactive capabilities to MicroProfile from Java EE 8, RxJava, and other technologies.
Java2 days 5_agile_steps_to_cloud-ready_appsPayara
This document discusses 5 steps to building elastic and cloud-ready applications:
1. Use JCache for temporary caching to optimize reads and allow for scalable storage with distributed caches.
2. Choose a scalable runtime like Payara Micro that can run applications as executable JARs across multiple instances dynamically.
3. Design RESTful services APIs for client/server communication using JAX-RS.
4. Leverage messaging with CDI events within applications and potentially other technologies like JCA connectors for communication across services.
5. Abstract configuration with MicroProfile Configuration for pluggable, scoped configuration from various sources.
Ondrej mihalyi be reactive and micro with a micro profile stackPayara
The document discusses how to build reactive microservices using a MicroProfile stack. It recommends taking a reactive and micro approach to build systems that can handle high loads and failures, provide better user experiences, and scale massively. It introduces MicroProfile as an open source specification for building reactive Java microservices and lists some of its reactive support capabilities. It also discusses adding additional reactive technologies like RxJava and React.js and demonstrates a reactive application built on these stacks with Payara Server and Micro, which support MicroProfile, Java EE, and other technologies for building reactive systems.
Getting the Most Out of ScyllaDB Monitoring: ShareChat's TipsScyllaDB
ScyllaDB monitoring provides a lot of useful information. But sometimes it’s not easy to find the root of the problem if something is wrong or even estimate the remaining capacity by the load on the cluster. This talk shares our team's practical tips on: 1) How to find the root of the problem by metrics if ScyllaDB is slow 2) How to interpret the load and plan capacity for the future 3) Compaction strategies and how to choose the right one 4) Important metrics which aren’t available in the default monitoring setup.
Conversational agents, or chatbots, are increasingly used to access all sorts of services using natural language. While open-domain chatbots - like ChatGPT - can converse on any topic, task-oriented chatbots - the focus of this paper - are designed for specific tasks, like booking a flight, obtaining customer support, or setting an appointment. Like any other software, task-oriented chatbots need to be properly tested, usually by defining and executing test scenarios (i.e., sequences of user-chatbot interactions). However, there is currently a lack of methods to quantify the completeness and strength of such test scenarios, which can lead to low-quality tests, and hence to buggy chatbots.
To fill this gap, we propose adapting mutation testing (MuT) for task-oriented chatbots. To this end, we introduce a set of mutation operators that emulate faults in chatbot designs, an architecture that enables MuT on chatbots built using heterogeneous technologies, and a practical realisation as an Eclipse plugin. Moreover, we evaluate the applicability, effectiveness and efficiency of our approach on open-source chatbots, with promising results.
The Department of Veteran Affairs (VA) invited Taylor Paschal, Knowledge & Information Management Consultant at Enterprise Knowledge, to speak at a Knowledge Management Lunch and Learn hosted on June 12, 2024. All Office of Administration staff were invited to attend and received professional development credit for participating in the voluntary event.
The objectives of the Lunch and Learn presentation were to:
- Review what KM ‘is’ and ‘isn’t’
- Understand the value of KM and the benefits of engaging
- Define and reflect on your “what’s in it for me?”
- Share actionable ways you can participate in Knowledge - - Capture & Transfer
In our second session, we shall learn all about the main features and fundamentals of UiPath Studio that enable us to use the building blocks for any automation project.
📕 Detailed agenda:
Variables and Datatypes
Workflow Layouts
Arguments
Control Flows and Loops
Conditional Statements
💻 Extra training through UiPath Academy:
Variables, Constants, and Arguments in Studio
Control Flow in Studio
GlobalLogic Java Community Webinar #18 “How to Improve Web Application Perfor...GlobalLogic Ukraine
Під час доповіді відповімо на питання, навіщо потрібно підвищувати продуктивність аплікації і які є найефективніші способи для цього. А також поговоримо про те, що таке кеш, які його види бувають та, основне — як знайти performance bottleneck?
Відео та деталі заходу: https://bit.ly/45tILxj
What is an RPA CoE? Session 2 – CoE RolesDianaGray10
In this session, we will review the players involved in the CoE and how each role impacts opportunities.
Topics covered:
• What roles are essential?
• What place in the automation journey does each role play?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
Essentials of Automations: Exploring Attributes & Automation ParametersSafe Software
Building automations in FME Flow can save time, money, and help businesses scale by eliminating data silos and providing data to stakeholders in real-time. One essential component to orchestrating complex automations is the use of attributes & automation parameters (both formerly known as “keys”). In fact, it’s unlikely you’ll ever build an Automation without using these components, but what exactly are they?
Attributes & automation parameters enable the automation author to pass data values from one automation component to the next. During this webinar, our FME Flow Specialists will cover leveraging the three types of these output attributes & parameters in FME Flow: Event, Custom, and Automation. As a bonus, they’ll also be making use of the Split-Merge Block functionality.
You’ll leave this webinar with a better understanding of how to maximize the potential of automations by making use of attributes & automation parameters, with the ultimate goal of setting your enterprise integration workflows up on autopilot.
This talk will cover ScyllaDB Architecture from the cluster-level view and zoom in on data distribution and internal node architecture. In the process, we will learn the secret sauce used to get ScyllaDB's high availability and superior performance. We will also touch on the upcoming changes to ScyllaDB architecture, moving to strongly consistent metadata and tablets.
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
Discover the Unseen: Tailored Recommendation of Unwatched ContentScyllaDB
The session shares how JioCinema approaches ""watch discounting."" This capability ensures that if a user watched a certain amount of a show/movie, the platform no longer recommends that particular content to the user. Flawless operation of this feature promotes the discover of new content, improving the overall user experience.
JioCinema is an Indian over-the-top media streaming service owned by Viacom18.
Session 1 - Intro to Robotic Process Automation.pdfUiPathCommunity
👉 Check out our full 'Africa Series - Automation Student Developers (EN)' page to register for the full program:
https://bit.ly/Automation_Student_Kickstart
In this session, we shall introduce you to the world of automation, the UiPath Platform, and guide you on how to install and setup UiPath Studio on your Windows PC.
📕 Detailed agenda:
What is RPA? Benefits of RPA?
RPA Applications
The UiPath End-to-End Automation Platform
UiPath Studio CE Installation and Setup
💻 Extra training through UiPath Academy:
Introduction to Automation
UiPath Business Automation Platform
Explore automation development with UiPath Studio
👉 Register here for our upcoming Session 2 on June 20: Introduction to UiPath Studio Fundamentals: https://community.uipath.com/events/details/uipath-lagos-presents-session-2-introduction-to-uipath-studio-fundamentals/
"What does it really mean for your system to be available, or how to define w...Fwdays
We will talk about system monitoring from a few different angles. We will start by covering the basics, then discuss SLOs, how to define them, and why understanding the business well is crucial for success in this exercise.
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
2. Mert Çalışkan
Payara Developer
Java EE / Spring Consultant
Author of PrimeFaces Cookbook
Author of Beginning Spring book
Part-time Lecturer
@mertcal
Gaurav Gupta
Payara Developer
NetBeans Dream Team
Jeddict Creator ( jeddict.github.io )
@jGauravGupta , @ImJeddict
12. ● Server Sent Events (SSE) is a mechanism that allows server to
asynchronously push data from the server to client once the client-server
connection is established by the client.
● It’s mostly like Long-Pooling but it’s not :) and it’s not WebSockets either.
● Implementations already provided it with JAX-RS 2.0 but there was no standard
API. With JAX-RS 2.1, API is created under javax.ws.rs.sse
JAX-RS 2.1
@mertcal
13. @Path("/temperature")
public class TemperatureResource {
private final OutboundSseEvent.Builder sseEventBuilder;
public TemperatureResource( @Context Sse sse) {
this.sseEventBuilder = sse.newEventBuilder();
}
@GET
@Path("/{city}")
@Produces(MediaType.SERVER_SENT_EVENTS)
public void getCurrentTemperatureStream( @Context SseEventSink eventSink) {
while (true) {
eventSink.send( sseEventBuilder.data(temperature)
.mediaType(MediaType. APPLICATION_JSON_TYPE).build());
Thread. sleep(1000);
}
}
}
"text/event-stream"
1
2
3
4
JAX-RS 2.1
@mertcal
14. CDI 2.0 (JSR 365)
- SE Support - It’s possible to use CDI outside of Java EE
- Ordering of CDI events - @Priority helps ordering observers
void receive(@Observes @Priority(APPLICATION + 200) String greet) {
this.greet += greet + "2";
}
void receive2(@Observes @Priority(APPLICATION) String greet) {
this.greet = greet + "1";
}
For send(“Welcome”) output will be:
Welcome1Welcome2
@Inject
private Event<String> event;
public void send(String message) {
event.fire(message);
}
@mertcal
15. CompletableStage<MyEvent> eventSent = event.fireAsync( new MyEvent(),
NotificationOptions.ofExecutor(executor));
- Exception in async observer doesn’t break the observer invocation chain.
callMe(@Observes payload) callMe(@ObservesAsync payload)
event.fire(payload) Sync call Not Notified
event.fireAsync(payload) Not Notified Async call
- Long awaited Asynchronous Events Support
- Fire Sync → Observer Sync / Fire Async → Observer Async
CDI 2.0
@mertcal
16. ● Java 8 Date and Time API Support
@Past(message = "must be a past date")
private java.time.Year yearOfBirth;
● Type Annotations
private List<@NotNull @Email String> emails;
private String @NotNull @Email[] emails;
private Map<@Valid Employee, @Valid Address> addressMap = new HashMap<>();
@mertcal
Bean Validation 2 (JSR 380)
17. ● java.util.Optional Support
private Optional<@Past LocalDate> marriageAnniversary;
private Optional<@Size(max = 20) String> name;
● Repeating Annotations
@Max(value = 2000, groups = Default.class)
@Max(value = 5000, groups = GoldCustomer.class)
private long withdrawalAmount;
@mertcal
Bean Validation 2
19. JSON-B (JSR 367)
● Standard solution like JAXB
● Default mapping between classes and JSON
● Customizable
a. Compile time
■ Property naming @JsonbProperty
■ Property ignoring @JsonbTransient
■ Null handling @JsonbNillable
■ Property ordering @JsonbPropertyOrder
■ Date and Number Format @JsonbDateFormat/@JsonbNumberFormat
■ Adapter @JsonbTypeAdapter
b. Runtime configration
■ Configuration builder JsonbConfig
@jGauravGupta
22. JPA 2.2 (JSR 338)
● @Repeatable annotations
● Support Java 8 Date and Time API
● Ability to return stream of query result
● CDI Injection in AttributeConverters
@jGauravGupta
23. JPA 2.1
Container annotation required
@Entity
@NamedQueries({
@NamedQuery(name = "Employee.findAll",
query = "SELECT e FROM Employee e"),
@NamedQuery(name = "Employee.findByName",
query = "SELECT e FROM Employee e WHERE e.name = :name")
})
class Employee {
@Convert(converter=LocalDateConverter.class)
private LocalDate dateOfBirth;
} AttributeConverter
implementation @jGauravGupta
24. JPA 2.2
Container annotation not required
@Entity
@NamedQueries({
@NamedQuery(name = "Employee.findAll",
query = "SELECT e FROM Employee e"),
@NamedQuery(name = "Employee.findByName",
query = "SELECT e FROM Employee e WHERE e.name = :name")
})
class Employee {
@Convert(converter=LocalDateConverter.class)
private LocalDate dateOfBirth;
}
AttributeConverter not required @jGauravGupta
25. JPA 2.2
@Entity
@NamedQuery(name = "Employee.findAll",
query = "SELECT e FROM Employee e")
@NamedQuery(name = "Employee.findByName",
query = "SELECT e FROM Employee e WHERE e.name = :name")
class Employee {
private LocalDate dateOfBirth;
}
@jGauravGupta
26. JPA 2.2
● Stream query results
Stream<Employee> employees =
em.createQuery(“SELECT e FROM Employee”, Employee.class)
.getResultStream();
@jGauravGupta
27. Security API 1.0 (JSR 375)
● Simplify the existing solution
● Enhance the portability
● New APIs
○ HTTPAuthenticationMechanism
○ IdentityStore
○ SecurityContext
@jGauravGupta
40. ● JRE Patch
● Update the code instantly
● DCEVM Dynamic Code Evolution VM http://dcevm.github.io/
STEP-1 : Java installation with the DCEVM engine
STEP-2 : Connect with the Payara Server
STEP-3 : Turn off redeployment of the application on save
STEP-4 : Turn on compile and apply code changes on save
Dynamic Code Evolution
@jGauravGupta
41. ● Bean Archives
● Beans and their properties
○ such as qualifiers, stereotypes and name
● Invocation Trees
● Observers and producers declared by beans
● Interceptors and decorators
● Extensions
● Fired events
Payara CDI Dev Mode : to inspect
@jGauravGupta
42. ● Graph of bean dependency
Payara CDI Dev Mode : to inspect
@jGauravGupta
43. ● Graph of bean archives
Payara CDI Dev Mode : to inspect
@jGauravGupta
44. ● Trace the admin console actions
● Create automation scripts easily
● Helps to investigate
Payara AsAdmin Recorder
@jGauravGupta
45. ● payara-micro-maven-plugin incorporates payara-micro with produced
artifact.
● Offers 3 mojos
○ bundle
○ start
○ stop
● Plugin is available on Maven Central
<groupId>fish.payara.maven.plugins</groupId>
<artifactId>payara-micro-maven-plugin</artifactId>
<version>1.0.0</version>
Maven Plugin
@mertcal